Merge current account transaction backend into settings work

Why: Main now serializes account recovery and requires maintenance CLI commands to open existing storage, deliver credentials through protected files and use file/environment DSN sources ahead of the deprecated flag.

Evidence: SELF /tmp/project-settings-backend-account-sync-full-20261014-973d52c1.json covers the combined Go suite and vet; /tmp/project-settings-backend-merge-schema-red-20261014-973d52c1.json and /tmp/project-settings-backend-merge-schema-green-20261014-973d52c1.json preserve a schema-guidance regression and its fix.

Impact: Keep the U7 transaction contract and the approved settings ownership APIs together. PostgreSQL CLI errors hide connection details while schema mismatch retains a safe migration instruction.

Refs: P2/P8, Dev #486, Backend #185

cmd/agent-system/account_io_test.go

@@ -44,24 +44,16 @@ func cliStore(t *testing.T) (string, *store.Store) {
 	return dir, s
 }
 func TestOutputFileAppliesToEveryCredentialCommand(t *testing.T) {
-	for _, sub := range []string{"create", "initialize-account", "bootstrap-admin"} {
+	for _, sub := range []string{"create", "reset-password", "issue-login-key", "bootstrap-admin"} {
 		t.Run(sub, func(t *testing.T) {
 			dir, s := cliStore(t)
-			if sub != "bootstrap-admin" {
-				if _, e := s.BootstrapFirstAdminWrite(store.AccountWrite{Owner: "root", Name: "Root", Actor: "test"}); e != nil {
+			if sub != "create" && sub != "bootstrap-admin" {
+				if e := s.CreateAccount("ada", "Ada", "", false); e != nil {
 					t.Fatal(e)
 				}
 			}
 			out := filepath.Join(t.TempDir(), "secret")
-			args := []string{sub, "--data", dir, "--owner", "ada", "--out-file", out}
-			if sub == "initialize-account" {
-				a, e := s.CreatePendingAccount("root", "ada", store.AccountProfile{Name: "Ada"})
-				if e != nil {
-					t.Fatal(e)
-				}
-				args = append(args, "--user-id", a.ID, "--expected-state-version", "1", "--expected-generation", "0")
-			}
-			rc, _ := accountCLI(t, args...)
+			rc, _ := accountCLI(t, sub, "--data", dir, "--owner", "ada", "--out-file", out)
 			if rc != 0 {
 				t.Fatalf("credential command failed: %d", rc)
 			}

cmd/agent-system/identity_dsn_test.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"agent-system-backend/internal/store"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func captureIdentityCLI(t *testing.T, run func() int) (int, string) {
+	t.Helper()
+	file, err := os.CreateTemp(t.TempDir(), "identity-output")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+	stdout, stderr := os.Stdout, os.Stderr
+	os.Stdout, os.Stderr = file, file
+	defer func() { os.Stdout, os.Stderr = stdout, stderr }()
+	code := run()
+	if _, err := file.Seek(0, io.SeekStart); err != nil {
+		t.Fatal(err)
+	}
+	raw, err := io.ReadAll(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return code, string(raw)
+}
+
+func TestIdentityCommandPGSchemaErrorKeepsRecoveryInstructionWithoutDSN(t *testing.T) {
+	const dsn = "postgres://fixture:dsn-private-fixture@127.0.0.1/db"
+	message := identityCommandError(dsn, errors.New("schema v3 与本二进制 v4 不一致；请运行 agent-system migrate，或先启动一次服务"))
+	if !strings.Contains(message, "agent-system migrate") || strings.Contains(message, "dsn-private-fixture") || strings.Contains(message, "postgres://") {
+		t.Fatalf("schema recovery instruction or secret boundary lost: %q", message)
+	}
+}
+
+func TestIdentityCommandsUseEnvironmentDSNWithoutPrintingCredentials(t *testing.T) {
+	const privateFixture = "dsn-private-fixture"
+	t.Setenv("AGENT_SYSTEM_DSN", "postgres://fixture:"+privateFixture+"@%invalid/db")
+	for _, sub := range []string{"user", "apikey"} {
+		data := t.TempDir()
+		local, err := store.OpenSQLite(filepath.Join(data, "agent-system.db"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := local.EnsureUser("alice", "Alice fixture"); err != nil {
+			local.Close()
+			t.Fatal(err)
+		}
+		local.Close()
+		code, out := captureIdentityCLI(t, func() int {
+			if sub == "user" {
+				return runUser([]string{"list", "--data", data})
+			}
+			return runAPIKey([]string{"list", "--owner", "alice", "--data", data})
+		})
+		if code != 1 {
+			t.Fatalf("%s ignored configured PG binding and fell back to SQLite: code=%d", sub, code)
+		}
+		if strings.Contains(out, privateFixture) || strings.Contains(out, "postgres://") {
+			t.Fatal("identity diagnostic disclosed DSN credentials")
+		}
+	}
+}
+
+func TestIdentityCommandDSNSourcePrecedence(t *testing.T) {
+	t.Setenv("AGENT_SYSTEM_DSN", "environment-fixture")
+	if got, err := resolveAccountDSN("deprecated-flag-fixture", ""); err != nil || got != "environment-fixture" {
+		t.Fatalf("configured environment lost to deprecated flag: %q %v", got, err)
+	}
+	path := filepath.Join(t.TempDir(), "dsn")
+	if err := os.WriteFile(path, []byte("protected-file-fixture\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if got, err := resolveAccountDSN("deprecated-flag-fixture", path); err != nil || got != "protected-file-fixture" {
+		t.Fatalf("protected DSN file lost precedence: %q %v", got, err)
+	}
+	t.Setenv("AGENT_SYSTEM_DSN", "")
+	if got, err := resolveAccountDSN("deprecated-flag-fixture", ""); err != nil || got != "deprecated-flag-fixture" {
+		t.Fatalf("deprecated flag compatibility lost: %q %v", got, err)
+	}
+	if got, err := resolveAccountDSN("", ""); err != nil || got != "" {
+		t.Fatalf("unset sources did not choose embedded storage: %q %v", got, err)
+	}
+}

cmd/agent-system/main.go

@@ -195,7 +195,7 @@ func runAPIKey(args []string) int {
 	sub := args[0]
 	fs := flag.NewFlagSet("apikey "+sub, flag.ExitOnError)
 	data := fs.String("data", "./data", "数据目录")
-	dsn := fs.String("dsn", "", "PostgreSQL 档 DSN（空 = 嵌入式档）")
+	dsn := fs.String("dsn", "", "PostgreSQL DSN（已弃用；优先使用 --dsn-file 或 AGENT_SYSTEM_DSN）")
 	dsnFile := fs.String("dsn-file", "", "0600权限的PostgreSQL DSN文件")
 	owner := fs.String("owner", "", "租户名（owner）")
 	name := fs.String("name", "default", "密钥名称")
@@ -225,14 +225,10 @@ func runAPIKey(args []string) int {
 		defer delivery.abort()
 		key, err := app.CreateAPIKey(*dsn, *data, *owner, *name)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "apikey create:", err)
+			fmt.Fprintln(os.Stderr, "apikey create:", identityCommandError(*dsn, err))
 			return 1
 		}
 		// 明文仅此一次输出；库中只存 SHA-256 摘要。
-		if delivery.file == nil {
-			fmt.Println(key) // Existing API-key CLI compatibility; owner grants require a file.
-			return 0
-		}
 		if err := delivery.deliver("api-key", *owner, key, nil); err != nil {
 			fmt.Fprintln(os.Stderr, "apikey create:", err)
 			return 1
@@ -241,7 +237,7 @@ func runAPIKey(args []string) int {
 	case "list":
 		keys, err := app.ListAPIKeys(*dsn, *data, *owner)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "apikey list:", err)
+			fmt.Fprintln(os.Stderr, "apikey list:", identityCommandError(*dsn, err))
 			return 1
 		}
 		out, _ := json.MarshalIndent(keys, "", "  ")
@@ -250,7 +246,7 @@ func runAPIKey(args []string) int {
 	case "revoke":
 		ok, err := app.RevokeAPIKey(*dsn, *data, *owner, *name)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "apikey revoke:", err)
+			fmt.Fprintln(os.Stderr, "apikey revoke:", identityCommandError(*dsn, err))
 			return 1
 		}
 		if !ok {
@@ -265,11 +261,26 @@ func runAPIKey(args []string) int {
 	}
 }
 
-// deliverCredential writes only to a new private file. The secret never goes
-// to stdout or an existing path; a JSON payload may include expiresAt.
+// PostgreSQL driver errors can contain connection strings. Account CLI errors
+// never echo a configured DSN, regardless of which protected input supplied it.
+func identityCommandError(dsn string, err error) string {
+	if dsn != "" {
+		message := err.Error()
+		if strings.HasPrefix(message, "schema 版本不可读") ||
+			(strings.HasPrefix(message, "schema v") && strings.Contains(message, "请运行 agent-system migrate")) {
+			return "账户存储 schema 与本二进制不一致；请运行 agent-system migrate，或先启动一次服务"
+		}
+		return "身份存储操作失败；PostgreSQL 连接详情已隐藏，请核对受保护的连接配置"
+	}
+	return err.Error()
+}
+
+// deliverCredential 凭据单次交付（KTD14）：--out 时写 0600 JSON 文件，stdout 只报
+// 属主/用途/文件路径不含明文；缺省沿用 stdout 一次输出。文件含 expiresAt 便于交接。
 func deliverCredential(outPath, kind, owner, plaintext string, expiresAt any) error {
 	if outPath == "" {
-		return fmt.Errorf("protected credential delivery path required")
+		fmt.Println(plaintext)
+		return nil
 	}
 	payload := map[string]any{"kind": kind, "owner": owner, "secret": plaintext}
 	if expiresAt != nil {
@@ -332,7 +343,7 @@ func (out *credentialOutput) abort() {
 
 func (out *credentialOutput) deliver(kind, owner, plaintext string, expiresAt any) error {
 	if out.file == nil {
-		return fmt.Errorf("protected credential delivery path required")
+		return deliverCredential("", kind, owner, plaintext, expiresAt)
 	}
 	out.mutated = true // Keep the private recovery artifact if delivery fails after DB commit.
 	var body []byte
@@ -364,21 +375,19 @@ func (out *credentialOutput) deliver(kind, owner, plaintext string, expiresAt an
 	return nil
 }
 
-// runUser：本地 owner 账号初始化、续办和只读／撤销操作。
+// runUser：create / reset-password / list / issue-login-key / revoke-login-key / bootstrap-admin。
+// 默认 create 无初始密码并签发激活 Key；--generate-password 兼容旧随机密码路径。
 func runUser(args []string) int {
 	if len(args) == 0 {
-		fmt.Fprintln(os.Stderr, "用法：agent-system user <create|initialize-account|list|revoke-login-key|bootstrap-admin> [flags]")
+		fmt.Fprintln(os.Stderr, "用法：agent-system user <create|reset-password|list|issue-login-key|revoke-login-key|bootstrap-admin> [flags]")
 		return 2
 	}
 	sub := args[0]
 	fs := flag.NewFlagSet("user "+sub, flag.ExitOnError)
 	data := fs.String("data", "./data", "数据目录")
-	dsn := fs.String("dsn", "", "PostgreSQL 档 DSN（空 = 嵌入式档；已弃用，优先 AGENT_SYSTEM_DSN 或 --dsn-file）")
+	dsn := fs.String("dsn", "", "PostgreSQL DSN（已弃用；优先使用 --dsn-file 或 AGENT_SYSTEM_DSN）")
 	dsnFile := fs.String("dsn-file", "", "0600 权限的 DSN 文件")
 	owner := fs.String("owner", "", "用户名（owner）")
-	userID := fs.String("user-id", "", "待初始化账号稳定ID")
-	expectedStateVersion := fs.Int64("expected-state-version", 0, "待初始化账号状态版本")
-	expectedGeneration := fs.Int64("expected-generation", -1, "待初始化账号代数")
 	name := fs.String("name", "", "显示名")
 	password := fs.String("password", "", "密码（已弃用；请用 --password-stdin）")
 	passwordStdin := fs.Bool("password-stdin", false, "从 stdin 读取密码")
@@ -387,21 +396,13 @@ func runUser(args []string) int {
 	admin := fs.Bool("admin", false, "管理员")
 	role := fs.String("role", "user", "角色 user|admin")
 	openExisting := fs.Bool("open-existing", false, "兼容旧参数；账户命令始终只打开既有存储")
-	generatePassword := fs.Bool("generate-password", false, "旧随机初始密码参数（现已拒绝）")
-	fs.String("purpose", "recover", "旧 issue-login-key 参数（现已拒绝）")
-	fs.Int("ttl-minutes", 30, "旧 issue-login-key 参数（现已拒绝）")
-	fs.Bool("revoke-all-credentials", false, "旧 issue-login-key 参数（现已拒绝）")
+	generatePassword := fs.Bool("generate-password", false, "create 时生成随机初始密码")
+	purpose := fs.String("purpose", "recover", "issue-login-key：activate|recover")
+	ttlMin := fs.Int("ttl-minutes", 30, "登录 Key 有效分钟（5–120）")
+	revokeAll := fs.Bool("revoke-all-credentials", false, "签发时撤销全部长期 API Key 与会话")
 	keyID := fs.String("id", "", "revoke-login-key 凭据编号")
-	out := fs.String("out", "", "凭据保护交付文件（0600 JSON）")
+	out := fs.String("out", "", "凭据交付文件（0600 JSON，代替 stdout 明文；非交互推荐）")
 	fs.Parse(args[1:])
-	if sub == "reset-password" || sub == "issue-login-key" {
-		fmt.Fprintln(os.Stderr, "RECOVERY_CONTRACT_REPLACED: use owner initialization or owner-confirmed recovery")
-		return 2 // reject before DSN/password reads, storage opens or output reservation
-	}
-	if sub == "create" && (*password != "" || *passwordStdin || *generatePassword) {
-		fmt.Fprintln(os.Stderr, "RECOVERY_CONTRACT_REPLACED: local creation uses trusted activation only")
-		return 2
-	}
 	resolvedDSN, err := resolveAccountDSN(*dsn, *dsnFile)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "user:", err)
@@ -417,11 +418,7 @@ func runUser(args []string) int {
 	}
 	*dsn = resolvedDSN
 	*password = resolvedPassword
-	credentialAction := sub == "create" || sub == "initialize-account" || sub == "bootstrap-admin"
-	if credentialAction && *outFile == "" && *out == "" {
-		fmt.Fprintln(os.Stderr, "user: --out or --out-file is required for protected credential delivery")
-		return 2
-	}
+	credentialAction := sub == "create" || sub == "reset-password" || sub == "issue-login-key" || sub == "bootstrap-admin"
 	if !credentialAction && (*outFile != "" || *out != "") {
 		fmt.Fprintln(os.Stderr, "user: 此子命令不生成凭据")
 		return 2
@@ -452,7 +449,7 @@ func runUser(args []string) int {
 		}
 		pw, opID, err := app.CreateUserAccount(*dsn, *data, *owner, *name, *password, isAdmin, *openExisting, *generatePassword)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "user create:", err)
+			fmt.Fprintln(os.Stderr, "user create:", identityCommandError(*dsn, err))
 			return 1
 		}
 		if err := delivery.deliver("login-key", *owner, pw, nil); err != nil {
@@ -460,44 +457,70 @@ func runUser(args []string) int {
 			return 1
 		}
 		fmt.Fprintf(os.Stderr, "operation_id=%s\n", opID)
-		return 0
-	case "initialize-account":
-		if *userID == "" || *expectedStateVersion < 1 || *expectedGeneration < 0 {
-			fmt.Fprintln(os.Stderr, "user initialize-account: --user-id、--expected-state-version、--expected-generation 必填")
-			return 2
-		}
-		plain, targetOwner, err := app.InitializeAccount(*dsn, *data, *userID, *expectedStateVersion, *expectedGeneration)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, "user initialize-account:", err)
-			return 1
-		}
-		if err := delivery.deliver("activation", targetOwner, plain, time.Now().Add(30*time.Minute).UTC()); err != nil {
-			fmt.Fprintln(os.Stderr, "user initialize-account:", err)
-			return 1
+		if *out == "" && *outFile == "" {
+			if *password == "" && !*generatePassword {
+				fmt.Fprintln(os.Stderr, "一次性激活 Key 仅此一次输出；兑换后设置密码。")
+			} else if *password == "" {
+				fmt.Fprintln(os.Stderr, "初始密码仅此一次输出；该用户首次登录须修改密码。")
+			}
 		}
 		return 0
 	case "reset-password":
-		fmt.Fprintln(os.Stderr, "RECOVERY_CONTRACT_REPLACED")
-		return 2
+		if *owner == "" {
+			fmt.Fprintln(os.Stderr, "user reset-password: --owner 必填")
+			return 2
+		}
+		pw, err := app.ResetUserPassword(*dsn, *data, *owner, *password, *openExisting)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "user reset-password:", identityCommandError(*dsn, err))
+			return 1
+		}
+		if err := delivery.deliver("password", *owner, pw, nil); err != nil {
+			fmt.Fprintln(os.Stderr, "user reset-password:", err)
+			return 1
+		}
+		if *out == "" && *outFile == "" && *password == "" {
+			fmt.Fprintln(os.Stderr, "新密码仅此一次输出；该用户下次登录须修改密码（其余会话已吊销）。")
+		}
+		return 0
 	case "list":
 		users, err := app.ListUserAccounts(*dsn, *data, *openExisting)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "user list:", err)
+			fmt.Fprintln(os.Stderr, "user list:", identityCommandError(*dsn, err))
 			return 1
 		}
 		out, _ := json.MarshalIndent(users, "", "  ")
 		fmt.Println(string(out))
 		return 0
 	case "issue-login-key":
-		fmt.Fprintln(os.Stderr, "RECOVERY_CONTRACT_REPLACED")
-		return 2
+		if *owner == "" {
+			fmt.Fprintln(os.Stderr, "user issue-login-key: --owner 必填")
+			return 2
+		}
+		if *purpose != store.LoginKeyPurposeActivate && *purpose != store.LoginKeyPurposeRecover {
+			fmt.Fprintf(os.Stderr, "user issue-login-key: 无效 purpose %q\n", *purpose)
+			return 2
+		}
+		plain, err := app.IssueUserLoginKey(*dsn, *data, *owner, *purpose, *openExisting, *revokeAll, time.Duration(*ttlMin)*time.Minute)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "user issue-login-key:", identityCommandError(*dsn, err))
+			return 1
+		}
+		if err := delivery.deliver("login-key", *owner, plain, time.Now().Add(time.Duration(*ttlMin)*time.Minute).UTC()); err != nil {
+			fmt.Fprintln(os.Stderr, "user issue-login-key:", err)
+			return 1
+		}
+		if *out == "" && *outFile == "" {
+			fmt.Fprintln(os.Stderr, "一次性登录 Key 仅此一次输出。")
+		}
+		return 0
 	case "revoke-login-key":
 		if *keyID == "" {
 			fmt.Fprintln(os.Stderr, "user revoke-login-key: --id 必填")
 			return 2
 		}
 		if err := app.RevokeUserLoginKey(*dsn, *data, *keyID, *openExisting); err != nil {
-			fmt.Fprintln(os.Stderr, "user revoke-login-key:", err)
+			fmt.Fprintln(os.Stderr, "user revoke-login-key:", identityCommandError(*dsn, err))
 			return 1
 		}
 		fmt.Println("revoked")
@@ -509,13 +532,16 @@ func runUser(args []string) int {
 		}
 		plain, err := app.BootstrapAdmin(*dsn, *data, *owner, *openExisting)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, "user bootstrap-admin:", err)
+			fmt.Fprintln(os.Stderr, "user bootstrap-admin:", identityCommandError(*dsn, err))
 			return 1
 		}
 		if err := delivery.deliver("bootstrap-admin", *owner, plain, time.Now().Add(30*time.Minute).UTC()); err != nil {
 			fmt.Fprintln(os.Stderr, "user bootstrap-admin:", err)
 			return 1
 		}
+		if *out == "" && *outFile == "" {
+			fmt.Fprintln(os.Stderr, "首位管理员激活 Key 仅此一次输出。")
+		}
 		return 0
 	default:
 		fmt.Fprintln(os.Stderr, "user: 未知子命令", sub)

cmd/agent-system/user_contract_test.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestLegacyUserCredentialCommandsStopBeforeOpeningStorage(t *testing.T) {
-	data := t.TempDir()
-	for _, args := range [][]string{
-		{"reset-password", "--data", data, "--owner", "victim", "--password", "attacker-password"},
-		{"issue-login-key", "--data", data, "--owner", "victim", "--purpose", "recover", "--revoke-all-credentials"},
-	} {
-		if code := runUser(args); code != 2 {
-			t.Fatalf("legacy command did not reject before storage: %v code=%d", args[0], code)
-		}
-	}
-	out := filepath.Join(data, "delivery.json")
-	if code := runUser([]string{"create", "--data", data, "--owner", "victim", "--password", "attacker-password", "--out", out}); code != 2 {
-		t.Fatalf("password-bearing local create accepted: %d", code)
-	}
-	if _, err := os.Stat(filepath.Join(data, "agent-system.db")); !os.IsNotExist(err) {
-		t.Fatalf("rejected commands opened/created a database: %v", err)
-	}
-	if _, err := os.Stat(out); !os.IsNotExist(err) {
-		t.Fatalf("rejected commands wrote a delivery file: %v", err)
-	}
-}
-
-func TestCredentialDeliveryCreatesExclusive0600File(t *testing.T) {
-	dir := t.TempDir()
-	out := filepath.Join(dir, "credential.json")
-	if err := os.WriteFile(out, []byte("old"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := deliverCredential(out, "activation", "alice", "secret", nil); err == nil {
-		t.Fatal("existing permissive file was overwritten")
-	}
-	bytes, err := os.ReadFile(out)
-	if err != nil || string(bytes) != "old" {
-		t.Fatalf("existing file changed: %q %v", bytes, err)
-	}
-	out = filepath.Join(dir, "new.json")
-	if err := deliverCredential(out, "activation", "alice", "secret", nil); err != nil {
-		t.Fatal(err)
-	}
-	info, err := os.Stat(out)
-	if err != nil || info.Mode().Perm() != 0o600 {
-		t.Fatalf("delivery mode: %v %v", info, err)
-	}
-	bytes, err = os.ReadFile(out)
-	if err != nil || !strings.Contains(string(bytes), `"secret": "secret"`) {
-		t.Fatalf("delivery payload: %v", err)
-	}
-}

cmd/storage-migrate/integration_test.go

@@ -45,18 +45,6 @@ func TestMigrateEndToEndAndIdempotent(t *testing.T) {
 	target, cleanup := pgSchemaDSN(t)
 	defer cleanup()
 	fixture := buildFixture(t)
-	src, err := sql.Open("sqlite", fixture)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer src.Close()
-	var sourcePublic, sourceStaff, sourcePrivate, sourceSecret string
-	var sourceKeyVersion int64
-	if err := src.QueryRow(`SELECT public_revision,staff_no_revision,private_revision,cursor_key_version,cursor_secret FROM account_directory_revision WHERE id=1`).Scan(
-		&sourcePublic, &sourceStaff, &sourcePrivate, &sourceKeyVersion, &sourceSecret,
-	); err != nil {
-		t.Fatal(err)
-	}
 
 	if err := cmdMigrate([]string{"--source", fixture, "--target", target, "--migration-id", "mig-e2e"}); err != nil {
 		t.Fatalf("首次迁移：%v", err)
@@ -73,16 +61,6 @@ func TestMigrateEndToEndAndIdempotent(t *testing.T) {
 	}
 	defer st.Close()
 	db := st.DB()
-	var targetPublic, targetStaff, targetPrivate, targetSecret string
-	var targetKeyVersion int64
-	if err := db.QueryRow(`SELECT public_revision,staff_no_revision,private_revision,cursor_key_version,cursor_secret FROM account_directory_revision WHERE id=1`).Scan(
-		&targetPublic, &targetStaff, &targetPrivate, &targetKeyVersion, &targetSecret,
-	); err != nil {
-		t.Fatal(err)
-	}
-	if targetPublic != sourcePublic || targetStaff != sourceStaff || targetPrivate != sourcePrivate || targetKeyVersion != sourceKeyVersion || targetSecret != sourceSecret {
-		t.Fatal("迁移后的目录版本或游标密钥与源库不一致")
-	}
 	var pinned, archived bool
 	if err := db.QueryRow(`SELECT pinned, archived FROM conversations WHERE id='c1'`).Scan(&pinned, &archived); err != nil || !pinned || archived {
 		t.Fatalf("布尔映射：pinned=%v archived=%v err=%v", pinned, archived, err)

cmd/storage-migrate/main.go

@@ -281,7 +281,7 @@ func cmdBackup(args []string) error {
 // copyOrder：按外键依赖排序的业务表全集（projects 最先，引用方在后）。
 // admission_leases 是运行态执行许可（迁移无意义），明确排除。
 var copyOrder = []string{
-	"projects", "users", "account_directory_revision", "profiles", "settings", "plugins",
+	"projects", "users", "profiles", "settings", "plugins",
 	"conversations", "runs", "messages", "events", "artifacts",
 	"hitl_cards", "plans", "todos", "knowledge", "knowledge_vectors",
 	"activity_cards", "project_event_shares", "command_audit", "prompt_modules",
@@ -297,7 +297,6 @@ var copyOrder = []string{
 	"agent_system_identity",
 	"account_events",
 	"redeem_attempts",
-	"recovery_proposals", "recovery_proposal_proofs",
 }
 
 const controlDDL = `
@@ -451,11 +450,6 @@ func guardIdentity(db *sql.DB, migrationID, snapID string, srcVersion int) error
 func businessRows(db *sql.DB) (int64, error) {
 	var total int64
 	for _, t := range copyOrder {
-		// Schema setup seeds this singleton before a migration starts. It is
-		// replaced from the source during copying and is not target business data.
-		if t == "account_directory_revision" {
-			continue
-		}
 		var n int64
 		if err := db.QueryRow(`SELECT COUNT(*) FROM "` + t + `"`).Scan(&n); err != nil {
 			if strings.Contains(err.Error(), "does not exist") {
@@ -713,14 +707,6 @@ func copyRows(db *sql.DB, src *sql.DB, table string, cols []string) error {
 		return err
 	}
 	defer tx.Rollback()
-	// The destination migrator creates a fresh singleton directory revision at
-	// schema startup. Replace it with the source's opaque revision so existing
-	// cursors/visible-change history remain tied to the migrated account data.
-	if table == "account_directory_revision" {
-		if _, err := tx.Exec(`DELETE FROM account_directory_revision`); err != nil {
-			return err
-		}
-	}
 	stmt, err := tx.Prepare(fmt.Sprintf(`INSERT INTO "%s" (%s) VALUES (%s) ON CONFLICT DO NOTHING`, table, colList, placeholders))
 	if err != nil {
 		return err
@@ -798,8 +784,7 @@ func advanceSequences(db *sql.DB, table string) error {
 // checkOwners：业务行引用的 owner 必须存在于 users（单租户默认 ”/'local'
 // 除外）。未知 owner 阻塞迁移（U4/R7：不静默带过未知归属）。
 func checkOwners(db *sql.DB, src *sql.DB) error {
-	ownerTables := []string{"projects", "conversations", "runs", "artifacts", "knowledge", "hitl_cards", "profiles", "activity_cards",
-		"project_event_shares", "command_audit", "sessions", "api_keys", "login_keys", "account_events", "recovery_proposals"}
+	ownerTables := []string{"projects", "conversations", "runs", "artifacts", "knowledge", "hitl_cards", "profiles", "activity_cards", "project_event_shares", "command_audit"}
 	for _, t := range ownerTables {
 		if !sqliteHasTable(src, t) {
 			continue

docs/iam-u3-account-write-fence-inventory.md

@@ -1,120 +0,0 @@
-# IAM U3 A1: account write fence inventory
-
-Status: stage 4–5 implementation inventory; the fixed candidate is the commit containing this file, and stage 6 human review remains pending. The route table records the **4053c4d baseline finding** and the intended final sink; its `Now` column is historical, not a claim about the amended candidate. Scope follows the approved Documents A1–A4 amendment `fb3a8214df963697ebd745ad11eb852ed9444fe3` and approved delegated-actor amendment `5783940e4c434102cbca8c22bd282d87b28fa840`.
-
-The 66 non-GET `/api` registrations were enumerated from `internal/server/server.go`. Paths below omit `/api`. `A` means `s.owner(r)` (auth-off: implicit `store.OwnerDefault`); `B` means body owner, `K` redeemed-key owner, `S` current password-session owner. Target resource owner never substitutes for actor. In the historical `Now` column, `T` means the baseline already had a final Store check; `M` means a Backend DB write lacked one; `E` means an external or process-local effect; `—` means no business mutation or permitted credential cleanup. `D` means a short Store transaction with actor account lock and enabled read **before** resource/scope/conversation locks; `F` means stage immutable bytes, then `D` for the visible DB reference; `X` means last effective-state check before external action plus cancellation; `C` means `D` at each command handler's actual sink; `P` means `D` for Backend projection and `X` at the separate RDM callback. `Vnn` identifies the route for traceability; verification uses representative concurrency cases and complete source-to-sink review, rather than one duplicate test per route.
-
-| # | Route → handler (source line) | Actor | Final sink | Now | Required fence | Verify |
-|---:|---|---|---|---|---|---|
-| 01 | `POST /auth/login` → `login` (`accounts.go:148`) | B | `CreateSessionVerified` | T | retain account/version transaction check | V01 |
-| 02 | `POST /auth/login-key/redeem` → `redeemLoginKey` (`accounts.go:106`) | K | `RedeemLoginKey`; failed-attempt security counter | T | retain account/grant transaction check | V02 |
-| 03 | `POST /auth/recovery-grants/redeem` → `redeemLoginKey` (`accounts.go:106`) | K | same as 02 | T | same as 02 | V03 |
-| 04 | `POST /auth/logout` → `logout` (`accounts.go:202`) | A | `DeleteSession` credential cleanup | — | permit cleanup after disable | V04 |
-| 05 | `POST /auth/password` → `changePassword` (`accounts.go:214`) | S | checked setup/forced/active password Store transaction | T | retain session/account recheck | V05 |
-| 06 | `POST /admin/users` → `createAdminUser` (`accounts.go:321`) | A | `CreatePendingAccount` | T | retain actor enabled/admin transaction check | V06 |
-| 07 | `PATCH /me/profile` → `patchMeProfile` (`accounts.go:394`) | S | `PatchAccountProfile` | T | retain actor/target transaction check | V07 |
-| 08 | `PATCH /admin/users/{userId}/profile` → `patchAdminAccountProfile` (`accounts.go:419`) | A | `PatchAccountProfile` | T | retain actor/target transaction check | V08 |
-| 09 | `PUT /admin/users/{userId}/state` → `setAdminAccountState` (`accounts.go:444`) | A | `SetAccountEnabled` | T | retain shared account lock and in-tx actor check | V09 |
-| 10 | `POST /admin/users/{userId}/recovery-proposals` → `createAdminRecoveryProposal` (`recovery.go:7`) | A | `CreateRecoveryProposal` | T | retain actor/target transaction check | V10 |
-| 11 | `DELETE /admin/users/{userId}/recovery-proposals/{id}` → `revokeAdminRecoveryProposal` (`recovery.go:47`) | A | `RevokeRecoveryProposal` | T | retain actor/target transaction check | V11 |
-| 12 | `POST /auth/recovery-proposals/{id}/confirm` → `confirmRecoveryProposal` (`recovery.go:81`) | S | `ConfirmRecoveryProposal` | T | retain owner/session proof in transaction | V12 |
-| 13 | `POST /auth/recovery-proposals/{id}/rotate-grant` → `rotateRecoveryGrant` (`recovery.go:105`) | S | `RotateRecoveryGrant` | T | retain owner/session proof in transaction | V13 |
-| 14 | `POST /admin/users/{owner}/password` → `resetAdminUserPassword` (`accounts.go:468`) | A | 410 response only | — | no business sink | V14 |
-| 15 | `POST /admin/users/{owner}/login-keys` → `issueAdminLoginKey` (`accounts.go:478`) | A | 410 response only | — | no business sink | V15 |
-| 16 | `DELETE /admin/users/{owner}/login-keys/{id}` → `revokeAdminLoginKey` (`accounts.go:494`) | A | `RevokeLoginKeyCascade` | M | D: lock/recheck admin actor too, then target/grant | V16 |
-| 17 | `POST /projects` → `createProject` (`server.go:713`) | A | `CreateProject` or RDM `Create` + Host projection | M/E | P | V17 |
-| 18 | `PATCH /projects/{id}` → `patchProject` (`server.go:734`) | A | RDM `Rename` or `RenameProject`; `UpdateProjectSettings` | M/E | P; D for every settings write | V18 |
-| 19 | `DELETE /projects/{id}` → `deleteProject` (`server.go:812`) | A | RDM `Archive` or `DeleteProject` | M/E | P | V19 |
-| 20 | `POST /projects/{id}/conversations` → `createConversation` (`server.go:875`) | A | `CreateConversation[InProject]`; RDM `Work` precheck | M | D; keep domain work check | V20 |
-| 21 | `PATCH /conversations/{id}` → `patchConversation` (`server.go:914`) | A | update, permission, note, flags: separate Store writes | M | D at each final write | V21 |
-| 22 | `DELETE /conversations/{id}` → `deleteConversation` (`server.go:950`) | A | `DeleteConversation` | M | D | V22 |
-| 23 | `POST /conversations/{id}/messages` → `postMessage` (`server.go:956`) | A | message, run, message-run link; optional Bus dispatch | M/E | D per write; C for command; actor lock before conversation lock | V23 |
-| 24 | `POST /conversations/{id}/rewind` → `rewindFiles` (`rewind.go:27`) | A | checkpoint files, then `AppendMessage` | M/E | X for rewind, D for message | V24 |
-| 25 | `POST /conversations/{id}/regenerate` → `regenerateMessage` (`borrow.go:159`) | A | message flags/exclusion, regen marker, rewind files, new run | M/E | D per write, X for rewind | V25 |
-| 26 | `POST /messages/{id}/exclude` → `excludeMessage` (`borrow.go:122`) | A | `ExcludeRunGroup(messageID)` | M | D; derive conversation owner in transaction | V26 |
-| 27 | `POST /messages/{id}/variant` → `selectVariant` (`borrow.go:146`) | A | `SelectVariant(messageID)` | M | D; derive conversation owner in transaction | V27 |
-| 28 | `POST /secrets` → `createSecret` (`borrow.go:21`) | A | `AddSecret` | M | D | V28 |
-| 29 | `POST /secrets/{id}/activate` → `activateSecret` (`borrow.go:39`) | A | `ActivateSecret` | M | D | V29 |
-| 30 | `PATCH /secrets/{id}` → `renameSecret` (`borrow.go:43`) | A | `RenameSecret` | M | D | V30 |
-| 31 | `DELETE /secrets/{id}` → `deleteSecret` (`borrow.go:54`) | A | `DeleteSecret` | M | D | V31 |
-| 32 | `POST /context-entries` → `saveContextEntry` (`borrow.go:64`) | A | `SaveContextEntry` | M | D | V32 |
-| 33 | `DELETE /context-entries/{id}` → `deleteContextEntry` (`borrow.go:78`) | A | `DeleteContextEntry` | M | D | V33 |
-| 34 | `POST /prompt-commands` → `saveUserPromptCommand` (`borrow.go:87`) | A | `SaveUserCommand`, then process Bus register | M/E | D; X before Bus mutation | V34 |
-| 35 | `DELETE /prompt-commands/{id}` → `deleteUserPromptCommand` (`borrow.go:102`) | A | `DeleteUserCommand`, then Bus unregister | M/E | D; X before Bus mutation | V35 |
-| 36 | `POST /runs/{id}/cancel` → `cancelRun` (`server.go:1278`) | A | PG `EnqueueCommand` or local cancel handle | M/E | D for enqueue with in-tx run owner; X locally | V36 |
-| 37 | `POST /hitl/{id}/resolve` → `resolveHITL` (`server.go:1314`) | A | local HITL/card/event writes or PG `EnqueueCommand` | M | D at each Store sink, including queue | V37 |
-| 38 | `POST /cards/{id}/actions/{actionId}` → `cardAction` (`server.go:1401`) | A | Cards action or Bus confirm, then receipt message | M/E | D for card/message; C for confirmed handler | V38 |
-| 39 | `POST /cards/{id}/pin` → `cardPin` (`server.go:1453`) | A | card version write | M | D | V39 |
-| 40 | `POST /cards/{id}/dismiss` → `cardDismiss` (`server.go:1462`) | A | card version/event write | M | D | V40 |
-| 41 | `POST /cards/{id}/to_project` → `cardToProject` (`server.go:1386`) | A | project card copy and original dismissal | M | D at both writes | V41 |
-| 42 | `POST /projects/{id}/uploads` → `upload` (`server.go:1469`) | A | Blob + artifact row, card, knowledge/vector index | M/E | F; D at later card/index writes | V42 |
-| 43 | `PUT /artifacts/{id}/content` → `putArtifactContent` (`server.go:1651`) | A | **in-place Blob overwrite before SQL UPDATE** | M/E | F using new immutable blob ref, guarded DB pointer swap | V43 |
-| 44 | `DELETE /artifacts/{id}` → `deleteArtifact` (`server.go:1656`) | A | metadata, index/vector rows, Blob deletion | M/E | D for visible rows; X for post-commit GC | V44 |
-| 45 | `POST /profiles` → `saveProfile` (`server.go:1667`) | A | profile Store row | M | D | V45 |
-| 46 | `DELETE /profiles/{id}` → `deleteProfile` (`server.go:1683`) | A | profile Store row | M | D | V46 |
-| 47 | `POST /prompts` → `savePromptModule` (`server.go:2023`) | A | prompt Store row | M | D | V47 |
-| 48 | `DELETE /prompts/{id}` → `deletePromptModule` (`server.go:2044`) | A | prompt Store row | M | D | V48 |
-| 49 | `PUT /settings/user` → `putSettingsUser` (`server.go:1717`) | A | settings transaction, then separate snapshot row | M | D for settings and snapshot | V49 |
-| 50 | `PUT /settings/project/{id}` → `putSettingsProject` (`server.go:1726`) | A | settings transaction, then separate snapshot row | M | D for settings and snapshot | V50 |
-| 51 | `PUT /settings/system` → `putSettingsSystem` (`server.go:1782`) | A | system settings and snapshot under synthetic owner | M | D with **request actor**, not `OwnerSystemRow` | V51 |
-| 52 | `POST /tools` → `createUserTool` (`server.go:1815`) | A | process Registry register; future HTTP tool execution | E | X for registration and each tool execution | V52 |
-| 53 | `DELETE /tools/{name}` → `deleteUserTool` (`server.go:1834`) | A | process Registry unregister | E | X | V53 |
-| 54 | `POST /plugins/{id}/enabled` → `setPluginEnabled` (`platform_api.go:132`) | A | `SetPluginEnabled` upsert | M | D | V54 |
-| 55 | `POST /plugins/{id}/activation` → `setSurfaceActivation` (`platform_api.go:251`) | A | activation transaction, separate audit row | M | D for both writes | V55 |
-| 56 | `POST /surfaces` → `submitSurface` (`platform_api.go:194`) | A | snapshot transaction, then event/pending row | M | D for snapshot/event writes | V56 |
-| 57 | `POST /surfaces/{id}/actions` → `submitSurfaceAction` (`platform_api.go:271`) | A | action insert, Bus dispatch, action-state update | M/E | D for both action writes; C for dispatch | V57 |
-| 58 | `POST /plugins/reload` → `reloadPlugins` (`server.go:1908`) | A | process registry/sidecar changes and `UpsertPlugin` | M/E | X for process changes; D for DB writes | V58 |
-| 59 | `POST /commands/{id}` → `execCommand` (`server.go:1211`) | A | Bus audit/card/pending or arbitrary command handler/RDM | M/E | C, X for external handler | V59 |
-| 60 | `POST /projects/{id}/knowledge` → `addKnowledge` (`server.go:2055`) | A | `AddKnowledge` batch transaction | M | D; in-tx project/owner check | V60 |
-| 61 | `POST /tasks` → `createBackgroundTask` (`platform_api.go:16`) | A | task insert | M | D | V61 |
-| 62 | `POST /tasks/{id}` → `updateBackgroundTask` (`platform_api.go:52`) | A | task update | M | D | V62 |
-| 63 | `POST /memory` → `putMemory` (`platform_api.go:69`) | A | memory upsert | M | D | V63 |
-| 64 | `POST /audit` → `postAudit` (`platform_api.go:112`) | A | client-origin business audit row | M | D; security-denial audit is a separate exception | V64 |
-| 65 | `POST /admin/backup` → `backup` (`server.go:2224`) | A | directory + SQLite backup file | E | X and explicit admin authorization | V65 |
-| 66 | `POST /admin/recovery-holds/{runId}/release` → `releaseRecoveryHold` (`accounts.go:526`) | A | recovery-hold UPDATE | M | D with actor admin check and run/hold owner lookup | V66 |
-
-The route count is not a full write count. `GET /api/llm/budget` → `llmBudget` (`platform_api.go`) calls `AccountTokens(owner, 0, budget)`; the amended Store returns a read-only total when tokens are zero. **V67** therefore has no business write. Ordinary authenticated GETs can refresh session `last_seen_at` as credential maintenance; session/API-key in-flight revocation remains a separate impact analysis.
-
-## Host and run manager exits
-
-| ID | Entry and actor | Final sink | Now → required fence | Verify |
-|---|---|---|---|---|
-| H01 | `inprocHost.KVPut`, host owner (`hostcaps.go:295`) | `PutPluginKV` | M → D | VH01 |
-| H02 | `inprocHost.Audit`, host owner; actor label is `plugin:<id>` (`hostcaps.go:309`) | `AppendAuditEvent` | M → D using host owner | VH02 |
-| H03 | `KnowledgeWrite/Publish/Delete`, host owner (`hostcaps.go:350-424`) | knowledge rows, vector rows; publish deletes then writes | M/E → D at every DB sink; X before embedding/remote model | VH03 |
-| H04 | `TaskCreate/Update`, host owner (`hostcaps.go:427-443`) | background-task rows | M → D | VH04 |
-| H05 | `EnsureProject/RenameOwnedProject`, host owner (`project_lifecycle.go:125-135`) | Backend projection rows, RDM callback upstream | M/E → actor D before project-name lock; X at callback | VH05 |
-| H06 | `SurfaceSave`, host owner (`hostcaps.go:481`) | `surfacesvc.Submit` snapshot/event | M → D at Store sinks | VH06 |
-| H07 | `Complete`, host owner (`hostcaps.go:319`) | external LLM request | E → X with context cancellation | VH07 |
-| H08 | scoped Host reconstructed from owner/plugin ID (`hostcaps.go:103`) | same H01-H07 methods | M/E → same final sink fences; early `requireEffective` alone is insufficient | VH08 |
-| G01 | `startClaimedRun`/subagent spawn, run owner (`runmgr.go:1443,1924`) | `CreateRun`, `UpdateRun` and admission rows | M → D for business state; keep failure-only cleanup explicit | VG01 |
-| G02 | `Emit`, `AskHITL`, cards, plan/todos (`runmgr.go:676-935`) | events, HITL/card, plan/todo rows | M → D at each final Store write | VG02 |
-| G03 | `WriteArtifact`, run owner (`runmgr.go:968`) | Blob, artifact, event, knowledge/vector rows | M/E → F then D for each later write | VG03 |
-| G04 | `ExecuteTool`, run owner (`runmgr.go:1080-1167`) | Registry HTTP/command/filesystem side effects, output artifacts | E/M → X before external call; C/D for command and output sinks | VG04 |
-| G05 | `stageInputs`, checkpoint recording/rewind and subagent transcript (`inputs.go:17-90`, `rewind.go:37-99`, `subagent_transcript.go:46-84`) | workspace files | E → X before each effect and cancellation; no cross-system atomic claim | VG05 |
-| G06 | `ResolveHITL`, run/card owner (`runmgr.go:1780-1860`) | HITL/card/event and possible run writes | M → D | VG06 |
-| G07 | background notice delivery and subagent completion (`runmgr.go:1982-2041,2444-2455`) | run/message/event plus transcript files | M/E → D for business rows, X for files | VG07 |
-| G08 | `settleRunWithFence`, run owner (`runmgr.go:1700-1722`) | final run + assistant message | T for enabled check in `store/recovery.go:184-220`; retain narrow failure-state exception | VG08 |
-| G09 | `OnUsage`, run owner (`app.go:668-680`) | usage and budget audit rows | M → D or documented accounting-only exception | VG09 |
-
-At the 4053c4d baseline, Host/runmgr effective-account queries were early checks, Bus confirmation and Surface writes had separate sinks, and artifact content could be overwritten in place before a checked SQL update. These are the reasons for the sink-level mapping below; file paths and old line numbers in the historical tables are navigational rather than final-SHA evidence.
-
-## Amended candidate mapping and limits
-
-This section supersedes the historical `Now` column when checking the amended candidate. V01–V15 retain their existing account/credential transaction or response-only behavior; V16 uses actor-checked login-key revocation. V17–V23 route project, conversation, message, run creation and link writes through account-checked Store entries. V24–V35 use guarded file/message and borrow/secret/context/command entries; V25 prepares the message exclusion and regeneration marker in one checked transaction, then consumes the marker only with successful run settlement. V36–V44 guard command queue, HITL, card, surface/event, artifact metadata and index writes. Artifact content updates switch immutable blob references in the checked transaction. V45–V51 guard profile, prompt, settings and snapshot writes, using the **request actor** for system settings. V52–V59 combine last checks for process/HTTP/tool effects with guarded plugin, surface, card, command pending and audit DB writes. V60–V66 use guarded knowledge, task, memory, audit and hold updates. V65 refuses whole-database backup under authenticated mode because administrator status does not grant access to other owners' business content; auth-off backup has a last check. V67 is read-only at zero tokens.
-
-VH01–VH04/VH06/VH08 use the Host owner and final Store account checks for Backend-owned rows. H05 delegated rename now derives a **single-project** projection from the current authenticated lifecycle or command Host; its final Store transaction locks the real operator and creator in stable order, checks both effective states and verifies the persisted project owner. The global `NewScopedHost` cannot derive this delegated capability; its original creator-owned methods remain. VH07 checks immediately before its external model call and passes the caller context. VG01–VG09 use checked run, admission/lease, event, HITL, card, artifact, index, notice, command and settle sinks. File staging, transcript, tool HTTP/search/code execution and overlay writeback check just before effects and propagate cancellation. Failed/cancelled/interrupted run sealing, lease release, notice deletion and failed-start marker deletion are narrowly scoped safety cleanup; positive token usage is accounting for model work already incurred.
-
-The H05/V17–V19 late-write blocker was reproduced in the earlier candidate and repaired under the separately approved Documents `5783940` plan. Tests cover creator/operator effective state, a disable between early check and final write on SQLite/PG, a two-process PG disable, opposite lock order progress, and both HTTP PATCH and no-conversation command Host sources. The RDM database authorization/intent commit is still separate from Backend's account/project transaction; a permission withdrawal or cross-database failure is handled by the existing I1 failure intent and recovery path rather than a zero-window assertion. Completion and stage 6 claims require exact-HEAD receipts and human review.
-
-The account lock closes the **account-enabled versus Backend-owned business write** race on the same database. It does not prove that a session or API key revoked after request authentication cannot complete a write while that account remains enabled; that is a distinct credential-version fence and outside this amendment's promise. RDM commits in its own database and external requests, processes and files cannot share the Backend transaction. The last check can race with those effects, and a multi-file operation can leave earlier files committed when a later check fails. No cross-database or external zero-window claim is made.
-
-**Sink discovery still required:** Backend source alone cannot enumerate every dynamically registered Bus handler, plugin sidecar command, or the RDM callback's independent database writes. V17–V19, V23, V38, V57–V59 and VH05 must record the actual composed handlers and their final sinks in the tested composition; an unknown or unguarded handler blocks the A1 completion claim. The external HTTP tool destination and filesystem actions depend on runtime configuration, so VG04/VG05 must verify the actual enabled tool set and cancellation points.
-
-## Common implementation and verification gate
-
-1. Build one short Store write-transaction primitive: `Begin` → PG actor advisory lock (`account:<owner>`) → `SELECT enabled ... FOR UPDATE` → existing resource/scope/conversation/admission locks → resource authorization and write → commit. The actor lock must precede all other PG locks, including project-name locks; participating account owners use sorted order, then bootstrap lock where required. `SetAccountEnabled` already takes the account lock (`store/account_state.go:20-45`); `lockAccountUsers` supplies sorted PG account locking (`store/account_model.go:115-145`). SQLite uses `_txlock=immediate` (`store/store.go:188-199`). In auth-off mode, only a missing `OwnerDefault` row is implicitly enabled; an existing disabled row rejects (`app/account_guard.go:10-23`). No DB connection or transaction spans request body decoding, embedding, tool execution, RDM callback, or full HTTP lifetime.
-2. Make methods with only resource IDs derive owner inside the guarded transaction. Pass actor separately for system settings (`OwnerSystemRow`), delegated Host calls, commands, queue commands, audit and background jobs. Preserve project/duty authorization as a separate condition; account enabled does not grant resource access. For files, stage invisible immutable bytes and switch the visible DB reference in `D`; failed transaction deletes staged bytes, post-commit old-blob GC may continue. RDM's independent database keeps the explicit cross-database window from the amendment.
-3. Review **every** V/VH/VG route against its final sink on the fixed candidate SHA. Use deterministic pause-and-disable tests for representative project, message/run, artifact, settings, command/surface and Host/runmgr paths on SQLite and isolated PostgreSQL. Test account lock ordering with two PG connections. Verify the existing credential routes' in-transaction ordering. For external effects, verify the last check and cancellation and state the remaining check-to-effect window. Record exact command, tested SHA and output in the Dev task card; local SELF is not independent REPLAY or CI GATE.
-
-Stage 6 stops if any Backend-owned business write lacks a final actor-enabled transaction fence, if artifact content remains visibly mutable after disable via in-place overwrite, or if an external/RDM effect is described as same-DB atomic. Session/API-key in-flight revocation is a separate amendment impact analysis; enabled checks do not prove credential-revocation fencing.

internal/app/account_directory.go

@@ -1,407 +0,0 @@
-package app
-
-import (
-	"context"
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"sort"
-	"strings"
-	"sync"
-	"unicode"
-	"unicode/utf8"
-
-	"agent-system-backend/internal/store"
-	"agent-system-backend/pkg/extension"
-)
-
-type accountDirectorySlot struct {
-	mu         sync.RWMutex
-	pluginID   string
-	resolver   extension.AccountDirectoryScopeResolver
-	secret     [32]byte
-	keyVersion int
-}
-
-func newAccountDirectorySlot(st *store.Store) (*accountDirectorySlot, error) {
-	key, err := st.GetAccountCursorKey()
-	if err != nil {
-		return nil, err
-	}
-	return &accountDirectorySlot{secret: key.Secret, keyVersion: key.Version}, nil
-}
-
-func (s *accountDirectorySlot) register(pluginID string, fn extension.AccountDirectoryScopeResolver) error {
-	if fn == nil || pluginID != "rdm" {
-		return store.ErrAccountForbidden
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.resolver != nil {
-		return errors.New("account directory resolver already registered")
-	}
-	s.pluginID, s.resolver = pluginID, fn
-	return nil
-}
-
-type directoryPolicy struct {
-	allowed    map[string]bool
-	match      []string
-	candidates map[string]bool
-	owners     map[string]bool
-	rows       []store.DirectoryAccountRow
-	all        bool
-	status     string
-	version    string
-}
-
-type directoryCursor struct {
-	KeyVersion int    `json:"k"`
-	Version    string `json:"v"`
-	Owner      string `json:"o"`
-	UserID     string `json:"u"`
-}
-
-type directoryVisibleRow struct {
-	UserID  string
-	Owner   string
-	Enabled bool
-	Name    string
-	StaffNo string
-}
-
-func knownDirectoryField(field string) bool {
-	return field == "owner" || field == "name" || field == "staffNo"
-}
-
-func (h inprocHost) directoryPolicy(ctx context.Context, q extension.AccountDirectoryQuery, loadRows bool) (directoryPolicy, error) {
-	var p directoryPolicy
-	if err := h.requireEffective(); err != nil {
-		return p, err
-	}
-	if h.actor == "" || h.caps.st == nil || h.caps.directory == nil || q.SchemaVersion != extension.AccountDirectorySchemaVersion {
-		return p, store.ErrAccountForbidden
-	}
-	actor, err := h.caps.st.GetUserAuthState(h.actor)
-	if err != nil || !actor.Enabled {
-		return p, store.ErrAccountForbidden
-	}
-	if q.Mode != extension.AccountDirectoryModeExact && q.Mode != extension.AccountDirectoryModeFuzzy {
-		return p, store.ErrInvalidAccountProfile
-	}
-	if !utf8.ValidString(q.Query) || utf8.RuneCountInString(q.Query) > 128 {
-		return p, store.ErrInvalidAccountProfile
-	}
-	for _, r := range q.Query {
-		if unicode.IsControl(r) {
-			return p, store.ErrInvalidAccountProfile
-		}
-	}
-	p.status = q.Status
-	if p.status == "" {
-		p.status = "enabled"
-	}
-	if p.status != "enabled" && p.status != "disabled" && p.status != "all" {
-		return p, store.ErrInvalidAccountProfile
-	}
-	var scope extension.AccountDirectoryScope
-	switch q.Purpose {
-	case extension.AccountDirectoryPurposeSystemUsers:
-		if !actor.IsAdmin || q.ProjectID != "" || q.DocumentID != "" {
-			return p, store.ErrAccountForbidden
-		}
-		scope = extension.AccountDirectoryScope{AllowedFields: []string{"owner", "name", "staffNo"},
-			MatchFields: []string{"owner", "name", "staffNo"}, AllCandidates: true, ScopeVersion: "system.users.v1"}
-	case extension.AccountDirectoryPurposeProjectMembers, extension.AccountDirectoryPurposeDocumentDuties:
-		if h.pluginID != "rdm" || q.ProjectID == "" || (q.Purpose == extension.AccountDirectoryPurposeDocumentDuties && q.DocumentID == "") ||
-			(q.Purpose == extension.AccountDirectoryPurposeProjectMembers && q.DocumentID != "") || p.status != "enabled" {
-			return p, store.ErrAccountForbidden
-		}
-		h.caps.directory.mu.RLock()
-		resolver, pluginID := h.caps.directory.resolver, h.caps.directory.pluginID
-		h.caps.directory.mu.RUnlock()
-		if resolver == nil || pluginID != h.pluginID {
-			return p, store.ErrAccountForbidden
-		}
-		scope, err = resolver(ctx, extension.AccountDirectoryScopeRequest{
-			Actor: h.actor, PluginID: h.pluginID, Purpose: q.Purpose, ProjectID: q.ProjectID, DocumentID: q.DocumentID,
-		})
-		if err != nil {
-			return p, store.ErrAccountForbidden
-		}
-		if q.Purpose == extension.AccountDirectoryPurposeDocumentDuties && scope.AllCandidates {
-			return p, store.ErrAccountForbidden
-		}
-	default:
-		return p, store.ErrAccountForbidden
-	}
-	if scope.ScopeVersion == "" {
-		return p, store.ErrAccountForbidden
-	}
-	p.allowed = map[string]bool{"owner": true}
-	for _, field := range scope.AllowedFields {
-		if !knownDirectoryField(field) {
-			return p, store.ErrAccountForbidden
-		}
-		p.allowed[field] = true
-	}
-	matchAllowed := map[string]bool{}
-	for _, field := range scope.MatchFields {
-		if !knownDirectoryField(field) || !p.allowed[field] {
-			return p, store.ErrAccountForbidden
-		}
-		matchAllowed[field] = true
-	}
-	requested := q.SearchFields
-	if len(requested) == 0 {
-		requested = []string{"owner", "name"}
-	}
-	for _, field := range requested {
-		if !matchAllowed[field] {
-			return p, store.ErrAccountForbidden
-		}
-		p.match = append(p.match, field)
-	}
-	sort.Strings(p.match)
-	p.candidates = make(map[string]bool, len(scope.CandidateIDs))
-	p.owners = make(map[string]bool, len(scope.CandidateOwners))
-	for _, id := range scope.CandidateIDs {
-		if id == "" {
-			return p, store.ErrAccountForbidden
-		}
-		p.candidates[id] = true
-	}
-	for _, owner := range scope.CandidateOwners {
-		if owner == "" {
-			return p, store.ErrAccountForbidden
-		}
-		p.owners[owner] = true
-	}
-	p.all = scope.AllCandidates
-	if q.Purpose == extension.AccountDirectoryPurposeSystemUsers {
-		p.all = true
-	}
-	visible := make([]directoryVisibleRow, 0)
-	if loadRows {
-		rows, err := h.caps.st.ListDirectoryAccountRows()
-		if err != nil {
-			return p, err
-		}
-		for _, row := range rows {
-			if !directoryRowAllowed(row, p) {
-				continue
-			}
-			p.rows = append(p.rows, row)
-			item := directoryVisibleRow{UserID: row.UserID, Owner: row.Owner, Enabled: row.Enabled}
-			if p.allowed["name"] {
-				item.Name = row.Name
-			}
-			if p.allowed["staffNo"] {
-				item.StaffNo = row.StaffNo
-			}
-			visible = append(visible, item)
-		}
-	}
-	ids := make([]string, 0, len(p.candidates))
-	for id := range p.candidates {
-		ids = append(ids, id)
-	}
-	sort.Strings(ids)
-	owners := make([]string, 0, len(p.owners))
-	for owner := range p.owners {
-		owners = append(owners, owner)
-	}
-	sort.Strings(owners)
-	allowed := make([]string, 0, len(p.allowed))
-	for field := range p.allowed {
-		allowed = append(allowed, field)
-	}
-	sort.Strings(allowed)
-	fingerprint := struct {
-		Actor, Plugin, Purpose, Project, Document, Mode, Query, Status, Scope string
-		Match, Allowed, IDs, Owners                                           []string
-		Visible                                                               []directoryVisibleRow
-		All                                                                   bool
-	}{Actor: h.actor, Plugin: h.pluginID, Purpose: q.Purpose, Project: q.ProjectID, Document: q.DocumentID,
-		Mode: q.Mode, Query: strings.TrimSpace(q.Query), Status: p.status,
-		Scope: scope.ScopeVersion, Match: p.match, Allowed: allowed, IDs: ids, Owners: owners, Visible: visible, All: p.all}
-	encoded, err := json.Marshal(fingerprint)
-	if err != nil {
-		return p, err
-	}
-	digest := sha256.Sum256(encoded)
-	p.version = hex.EncodeToString(digest[:])
-	return p, nil
-}
-
-func (s *accountDirectorySlot) encodeCursor(c directoryCursor) (string, error) {
-	c.KeyVersion = s.keyVersion
-	data, err := json.Marshal(c)
-	if err != nil {
-		return "", err
-	}
-	mac := hmac.New(sha256.New, s.secret[:])
-	_, _ = mac.Write([]byte("iam-directory-cursor-v1\x00"))
-	_, _ = mac.Write(data)
-	return base64.RawURLEncoding.EncodeToString(data) + "." + base64.RawURLEncoding.EncodeToString(mac.Sum(nil)), nil
-}
-
-func (s *accountDirectorySlot) decodeCursor(token, version string) (directoryCursor, error) {
-	var c directoryCursor
-	payload, signature, found := strings.Cut(token, ".")
-	if !found {
-		return c, store.ErrConflict
-	}
-	data, err := base64.RawURLEncoding.DecodeString(payload)
-	if err != nil || len(data) > 1024 {
-		return c, store.ErrConflict
-	}
-	provided, err := base64.RawURLEncoding.DecodeString(signature)
-	if err != nil {
-		return c, store.ErrConflict
-	}
-	mac := hmac.New(sha256.New, s.secret[:])
-	_, _ = mac.Write([]byte("iam-directory-cursor-v1\x00"))
-	_, _ = mac.Write(data)
-	if !hmac.Equal(provided, mac.Sum(nil)) || json.Unmarshal(data, &c) != nil || c.KeyVersion != s.keyVersion || c.Version != version || c.Owner == "" || c.UserID == "" {
-		return directoryCursor{}, store.ErrConflict
-	}
-	return c, nil
-}
-
-func directoryEntry(row store.DirectoryAccountRow, p directoryPolicy) extension.AccountDirectoryEntry {
-	entry := extension.AccountDirectoryEntry{UserID: row.UserID, Owner: row.Owner, Valid: row.Enabled}
-	if p.allowed["name"] {
-		entry.Name = row.Name
-	}
-	if p.allowed["staffNo"] {
-		entry.StaffNo = row.StaffNo
-	}
-	return entry
-}
-
-func directoryMatches(row store.DirectoryAccountRow, fields []string, mode, query string) bool {
-	for _, field := range fields {
-		value := row.Owner
-		switch field {
-		case "name":
-			value = row.Name
-		case "staffNo":
-			value = row.StaffNo
-		}
-		if mode == extension.AccountDirectoryModeExact && strings.EqualFold(value, query) {
-			return true
-		}
-		if mode == extension.AccountDirectoryModeFuzzy && strings.Contains(strings.ToLower(value), strings.ToLower(query)) {
-			return true
-		}
-	}
-	return false
-}
-
-func directoryRowAllowed(row store.DirectoryAccountRow, p directoryPolicy) bool {
-	if !p.all && !p.candidates[row.UserID] && !p.owners[row.Owner] {
-		return false
-	}
-	return p.status == "all" || (p.status == "enabled" && row.Enabled) || (p.status == "disabled" && !row.Enabled)
-}
-
-func (h inprocHost) QueryAccountDirectory(ctx context.Context, q extension.AccountDirectoryQuery) (extension.AccountDirectoryPage, error) {
-	query := strings.TrimSpace(q.Query)
-	p, err := h.directoryPolicy(ctx, q, query != "")
-	if err != nil {
-		return extension.AccountDirectoryPage{}, err
-	}
-	maxLimit := 50
-	if q.Purpose == extension.AccountDirectoryPurposeSystemUsers {
-		maxLimit = 100
-	}
-	if q.Limit == 0 {
-		q.Limit = 20
-	}
-	if q.Limit < 1 || q.Limit > maxLimit {
-		return extension.AccountDirectoryPage{}, store.ErrInvalidAccountProfile
-	}
-	page := extension.AccountDirectoryPage{Entries: []extension.AccountDirectoryEntry{}, DirectoryVersion: p.version}
-	if query == "" {
-		if q.Cursor != "" {
-			return extension.AccountDirectoryPage{}, store.ErrConflict
-		}
-		return page, nil
-	}
-	if q.Mode == extension.AccountDirectoryModeFuzzy && utf8.RuneCountInString(query) < 2 {
-		return extension.AccountDirectoryPage{}, store.ErrInvalidAccountProfile
-	}
-	var after directoryCursor
-	if q.Cursor != "" {
-		after, err = h.caps.directory.decodeCursor(q.Cursor, p.version)
-		if err != nil {
-			return extension.AccountDirectoryPage{}, err
-		}
-	}
-	matched := make([]store.DirectoryAccountRow, 0, q.Limit+1)
-	for _, row := range p.rows {
-		if !directoryMatches(row, p.match, q.Mode, query) {
-			continue
-		}
-		if after.Owner != "" && (row.Owner < after.Owner || (row.Owner == after.Owner && row.UserID <= after.UserID)) {
-			continue
-		}
-		matched = append(matched, row)
-		if len(matched) > q.Limit {
-			break
-		}
-	}
-	more := len(matched) > q.Limit
-	if more {
-		matched = matched[:q.Limit]
-	}
-	for _, row := range matched {
-		page.Entries = append(page.Entries, directoryEntry(row, p))
-	}
-	if more {
-		last := matched[len(matched)-1]
-		page.NextCursor, err = h.caps.directory.encodeCursor(directoryCursor{Version: p.version, Owner: last.Owner, UserID: last.UserID})
-		if err != nil {
-			return extension.AccountDirectoryPage{}, err
-		}
-	}
-	return page, nil
-}
-
-func (h inprocHost) LookupAccountDirectory(ctx context.Context, q extension.AccountDirectoryQuery, userID string) (extension.AccountDirectoryLookup, error) {
-	if userID == "" || q.Cursor != "" {
-		return extension.AccountDirectoryLookup{}, store.ErrInvalidAccountProfile
-	}
-	p, err := h.directoryPolicy(ctx, q, true)
-	if err != nil {
-		return extension.AccountDirectoryLookup{}, err
-	}
-	for _, row := range p.rows {
-		if row.UserID == userID {
-			return extension.AccountDirectoryLookup{Entry: directoryEntry(row, p), DirectoryVersion: p.version}, nil
-		}
-	}
-	return extension.AccountDirectoryLookup{}, store.ErrNotFound
-}
-
-func (h inprocHost) LookupAccountDirectoryOwner(ctx context.Context, q extension.AccountDirectoryQuery, owner string) (extension.AccountDirectoryLookup, error) {
-	if owner == "" || q.Cursor != "" {
-		return extension.AccountDirectoryLookup{}, store.ErrInvalidAccountProfile
-	}
-	p, err := h.directoryPolicy(ctx, q, true)
-	if err != nil {
-		return extension.AccountDirectoryLookup{}, err
-	}
-	for _, row := range p.rows {
-		if row.Owner == owner {
-			return extension.AccountDirectoryLookup{Entry: directoryEntry(row, p), DirectoryVersion: p.version}, nil
-		}
-	}
-	return extension.AccountDirectoryLookup{}, store.ErrNotFound
-}
-
-var _ extension.AccountDirectoryProvider = inprocHost{}

internal/app/account_directory_test.go

@@ -1,221 +0,0 @@
-package app
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"agent-system-backend/internal/store"
-	"agent-system-backend/pkg/extension"
-)
-
-func openDirectoryTestStore(t *testing.T) *store.Store {
-	t.Helper()
-	dsn := os.Getenv("AGENT_PG_TEST_DSN")
-	if dsn == "" {
-		st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "directory.db"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		t.Cleanup(func() { st.Close() })
-		return st
-	}
-	admin, err := sql.Open("pgx", dsn)
-	if err != nil {
-		t.Fatal(err)
-	}
-	schema := "t_" + strings.ToLower(store.NewID("dir"))
-	if _, err := admin.Exec(`CREATE EXTENSION IF NOT EXISTS pg_trgm`); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := admin.Exec(`CREATE SCHEMA ` + schema); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() {
-		_, _ = admin.Exec(`DROP SCHEMA IF EXISTS ` + schema + ` CASCADE`)
-		_ = admin.Close()
-	})
-	separator := "?"
-	if strings.Contains(dsn, "?") {
-		separator = "&"
-	}
-	st, err := store.OpenPostgres(dsn+separator+"search_path="+schema+",public", filepath.Join(t.TempDir(), "artifacts"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { st.Close() })
-	return st
-}
-
-func TestAccountDirectoryAppliesDomainScopeBeforeSearchAndCursor(t *testing.T) {
-	st := openDirectoryTestStore(t)
-	t.Logf("directory provider dialect=%s", st.Dialect())
-	if err := st.CreateAccount("admin", "", "hash", true); err != nil {
-		t.Fatal(err)
-	}
-	alice, err := st.CreatePendingAccount("admin", "alice", store.AccountProfile{Name: "同名", StaffNo: "hidden-a"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	bob, err := st.CreatePendingAccount("admin", "bob", store.AccountProfile{Name: "同名", StaffNo: "hidden-b"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	outsider, err := st.CreatePendingAccount("admin", "outsider", store.AccountProfile{Name: "同名", StaffNo: "hidden-x"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	slot, err := newAccountDirectorySlot(st)
-	if err != nil {
-		t.Fatal(err)
-	}
-	h := inprocHost{caps: hostcaps{st: st, directory: slot}, pluginID: "rdm", actor: "admin", owner: "admin"}
-	query := extension.AccountDirectoryQuery{SchemaVersion: extension.AccountDirectorySchemaVersion,
-		Purpose: extension.AccountDirectoryPurposeProjectMembers, ProjectID: "project-1",
-		Mode: extension.AccountDirectoryModeFuzzy, Query: "同名", Limit: 1}
-	if _, err := h.QueryAccountDirectory(context.Background(), query); err == nil {
-		t.Fatal("domain directory ran without trusted resolver")
-	}
-	if err := (pluginRegistry{pluginID: "rdm", caps: h.caps}).RegisterAccountDirectoryScopeResolver(func(context.Context, extension.AccountDirectoryScopeRequest) (extension.AccountDirectoryScope, error) {
-		return extension.AccountDirectoryScope{AllowedFields: []string{"owner", "name"}, MatchFields: []string{"owner", "name"},
-			CandidateIDs: []string{alice.ID, bob.ID}, ScopeVersion: "scope-1"}, nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-	page, err := h.QueryAccountDirectory(context.Background(), query)
-	if err != nil || len(page.Entries) != 1 || page.Entries[0].UserID != alice.ID || page.Entries[0].StaffNo != "" || page.NextCursor == "" {
-		t.Fatalf("first scoped page: %+v %v", page, err)
-	}
-	query.Cursor = page.NextCursor
-	otherSlot, err := newAccountDirectorySlot(st)
-	if err != nil {
-		t.Fatal(err)
-	}
-	otherSlot.pluginID, otherSlot.resolver = slot.pluginID, slot.resolver
-	otherHost := h
-	otherHost.caps.directory = otherSlot
-	second, err := otherHost.QueryAccountDirectory(context.Background(), query)
-	if err != nil || len(second.Entries) != 1 || second.Entries[0].UserID != bob.ID || second.NextCursor != "" {
-		t.Fatalf("second scoped page on another host: %+v %v", second, err)
-	}
-	query.Cursor = ""
-	query.Query = "hidden-x"
-	if found, err := h.QueryAccountDirectory(context.Background(), query); err != nil || len(found.Entries) != 0 {
-		t.Fatalf("hidden staff number matched: %+v %v", found, err)
-	}
-	query.SearchFields = []string{"staffNo"}
-	if _, err := h.QueryAccountDirectory(context.Background(), query); err == nil {
-		t.Fatal("hidden staff number accepted as search field")
-	}
-	query.SearchFields = nil
-	query.Query = "同名"
-	if hit, err := h.LookupAccountDirectoryOwner(context.Background(), query, "alice"); err != nil || hit.Entry.UserID != alice.ID {
-		t.Fatalf("explicit owner lookup failed to resolve stable ID: %+v %v", hit, err)
-	}
-	if _, err := h.LookupAccountDirectoryOwner(context.Background(), query, "outsider"); !errors.Is(err, store.ErrNotFound) {
-		t.Fatalf("owner lookup leaked outsider: %v", err)
-	}
-	if _, err := h.LookupAccountDirectory(context.Background(), query, "not-in-scope"); !errors.Is(err, store.ErrNotFound) {
-		t.Fatalf("exact lookup leaked outsider: %v", err)
-	}
-	page, err = h.QueryAccountDirectory(context.Background(), query)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.PatchAccountProfile("admin", alice.ID, alice.ProfileVersion, map[string]string{"phone": "private-edit"}); err != nil {
-		t.Fatal(err)
-	}
-	query.Cursor = page.NextCursor
-	if _, err := h.QueryAccountDirectory(context.Background(), query); err != nil {
-		t.Fatalf("private edit invalidated candidate cursor: %v", err)
-	}
-	if _, err := st.PatchAccountProfile("admin", alice.ID, alice.ProfileVersion+1, map[string]string{"staffNo": "still-hidden"}); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := h.QueryAccountDirectory(context.Background(), query); err != nil {
-		t.Fatalf("unavailable field invalidated candidate cursor: %v", err)
-	}
-	if _, err := st.PatchAccountProfile("admin", outsider.ID, outsider.ProfileVersion, map[string]string{"name": "out-of-scope-change"}); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := h.QueryAccountDirectory(context.Background(), query); err != nil {
-		t.Fatalf("out-of-scope edit invalidated candidate cursor: %v", err)
-	}
-	if _, err := st.PatchAccountProfile("admin", alice.ID, alice.ProfileVersion+2, map[string]string{"name": "changed"}); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := h.QueryAccountDirectory(context.Background(), query); !errors.Is(err, store.ErrConflict) {
-		t.Fatalf("visible edit did not invalidate cursor: %v", err)
-	}
-}
-
-func TestPGDirectoryCursorContinuesInAnotherProcess(t *testing.T) {
-	baseDSN := os.Getenv("AGENT_PG_TEST_DSN")
-	if baseDSN == "" {
-		t.Skip("isolated PostgreSQL test DSN required")
-	}
-	if os.Getenv("IAM_U3_DIRECTORY_CHILD") == "1" {
-		schema := os.Getenv("IAM_U3_DIRECTORY_SCHEMA")
-		separator := "?"
-		if strings.Contains(baseDSN, "?") {
-			separator = "&"
-		}
-		st, err := store.OpenExistingPostgres(baseDSN+separator+"search_path="+schema+",public", filepath.Join(t.TempDir(), "artifacts"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer st.Close()
-		slot, err := newAccountDirectorySlot(st)
-		if err != nil {
-			t.Fatal(err)
-		}
-		h := inprocHost{caps: hostcaps{st: st, directory: slot}, actor: "admin", owner: "admin"}
-		q := extension.AccountDirectoryQuery{SchemaVersion: extension.AccountDirectorySchemaVersion,
-			Purpose: extension.AccountDirectoryPurposeSystemUsers, Mode: extension.AccountDirectoryModeFuzzy,
-			Query: "same", Limit: 1, Cursor: os.Getenv("IAM_U3_DIRECTORY_CURSOR")}
-		page, err := h.QueryAccountDirectory(context.Background(), q)
-		if err != nil || len(page.Entries) != 1 || page.Entries[0].Owner != "beta" {
-			t.Fatalf("cross-process page: %+v %v", page, err)
-		}
-		return
-	}
-	st := openDirectoryTestStore(t)
-	if err := st.EnsureSystemIdentity("u3-directory-cross-process", "pg"); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("admin", "Admin", "hash", true); err != nil {
-		t.Fatal(err)
-	}
-	for _, owner := range []string{"alpha", "beta"} {
-		if _, err := st.CreatePendingAccount("admin", owner, store.AccountProfile{Name: "same"}); err != nil {
-			t.Fatal(err)
-		}
-	}
-	slot, err := newAccountDirectorySlot(st)
-	if err != nil {
-		t.Fatal(err)
-	}
-	h := inprocHost{caps: hostcaps{st: st, directory: slot}, actor: "admin", owner: "admin"}
-	q := extension.AccountDirectoryQuery{SchemaVersion: extension.AccountDirectorySchemaVersion,
-		Purpose: extension.AccountDirectoryPurposeSystemUsers, Mode: extension.AccountDirectoryModeFuzzy,
-		Query: "same", Limit: 1}
-	page, err := h.QueryAccountDirectory(context.Background(), q)
-	if err != nil || len(page.Entries) != 1 || page.Entries[0].Owner != "alpha" || page.NextCursor == "" {
-		t.Fatalf("initial page: %+v %v", page, err)
-	}
-	var schema string
-	if err := st.DB().QueryRow(`SELECT current_schema()`).Scan(&schema); err != nil {
-		t.Fatal(err)
-	}
-	cmd := exec.Command(os.Args[0], "-test.run=^TestPGDirectoryCursorContinuesInAnotherProcess$")
-	cmd.Env = append(os.Environ(), "IAM_U3_DIRECTORY_CHILD=1", "IAM_U3_DIRECTORY_SCHEMA="+schema,
-		"IAM_U3_DIRECTORY_CURSOR="+page.NextCursor)
-	if out, err := cmd.CombinedOutput(); err != nil {
-		t.Fatalf("cross-process cursor failed: %v: %s", err, strings.ReplaceAll(string(out), baseDSN, "[REDACTED]"))
-	}
-}

internal/app/account_guard.go

@@ -1,24 +0,0 @@
-package app
-
-import (
-	"context"
-	"errors"
-
-	"agent-system-backend/internal/store"
-)
-
-// accountEffectiveAuthorization is shared by runmgr and in-process Host
-// capabilities. The implicit local singleton is the only auth-off missing-row
-// exception; an existing disabled local account remains denied.
-func accountEffectiveAuthorization(st *store.Store, authOn bool) func(context.Context, string) (bool, error) {
-	return func(_ context.Context, owner string) (bool, error) {
-		account, err := st.GetAccountByOwner(owner)
-		if errors.Is(err, store.ErrNotFound) && !authOn && owner == store.OwnerDefault {
-			return true, nil
-		}
-		if err != nil {
-			return false, err
-		}
-		return account.Enabled, nil
-	}
-}

internal/app/account_guard_test.go

@@ -1,117 +0,0 @@
-package app
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"agent-system-backend/internal/settings"
-	"agent-system-backend/internal/store"
-)
-
-func TestInprocHostRechecksEffectiveAccountOnEveryCapability(t *testing.T) {
-	st, err := store.OpenSQLite(t.TempDir() + "/host.db")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	if err := st.CreateAccount("alice", "", "", false); err != nil {
-		t.Fatal(err)
-	}
-	check := accountEffectiveAuthorization(st, true)
-	h := inprocHost{caps: hostcaps{st: st, accountGuard: func(owner string) error {
-		valid, err := check(context.Background(), owner)
-		if err != nil {
-			return err
-		}
-		if !valid {
-			return store.ErrAccountForbidden
-		}
-		return nil
-	}}, owner: "alice", actor: "alice", pluginID: "rdm"}
-	if err := h.KVPut("before", "allowed"); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.DB().Exec(`UPDATE users SET enabled=FALSE WHERE owner=?`, "alice"); err != nil {
-		t.Fatal(err)
-	}
-	if err := h.KVPut("after", "denied"); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled host wrote KV: %v", err)
-	}
-	if _, _, err := h.KVGet("before"); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled host read KV: %v", err)
-	}
-	if _, err := h.TaskCreate("test", "denied", ""); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled host created task: %v", err)
-	}
-	if _, err := h.ProjectNameAvailable("denied", ""); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled host used project capability: %v", err)
-	}
-	if err := h.Audit("action", "target", ""); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled host wrote audit: %v", err)
-	}
-	if _, err := h.Complete(context.Background(), "denied"); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled host reached model completion: %v", err)
-	}
-	if _, err := h.KnowledgeSearch(context.Background(), "", "denied", 1); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled host read knowledge: %v", err)
-	}
-}
-
-func TestHostCompletionChecksAgainAfterModelSettingsRead(t *testing.T) {
-	st, err := store.OpenSQLite(t.TempDir() + "/host-complete.db")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	requests := 0
-	model := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		requests++
-		_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"late"}}]}`))
-	}))
-	defer model.Close()
-	set := settings.NewService(st)
-	set.SetSystemOverride(map[string]any{"models": map[string]any{"chat": map[string]any{"model": "test", "baseUrl": model.URL}}})
-	checks := 0
-	h := inprocHost{caps: hostcaps{st: st, set: set, accountGuard: func(string) error {
-		checks++
-		if checks >= 3 {
-			return store.ErrAccountForbidden
-		}
-		return nil
-	}}, owner: "alice", actor: "alice", pluginID: "rdm"}
-	if _, err := h.Complete(context.Background(), "late"); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("completion after disable: %v", err)
-	}
-	if checks != 3 || requests != 0 {
-		t.Fatalf("late completion reached model: checks=%d requests=%d", checks, requests)
-	}
-}
-
-func TestImplicitLocalAccountExceptionIsAuthOffOnly(t *testing.T) {
-	st, err := store.OpenSQLite(t.TempDir() + "/local.db")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	allowed, err := accountEffectiveAuthorization(st, false)(context.Background(), store.OwnerDefault)
-	if err != nil || !allowed {
-		t.Fatalf("implicit local denied: %v %v", allowed, err)
-	}
-	allowed, err = accountEffectiveAuthorization(st, true)(context.Background(), store.OwnerDefault)
-	if !errors.Is(err, store.ErrNotFound) || allowed {
-		t.Fatalf("auth-on missing account allowed: %v %v", allowed, err)
-	}
-	if err := st.EnsureUser(store.OwnerDefault, ""); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.DB().Exec(`UPDATE users SET enabled=FALSE WHERE owner=?`, store.OwnerDefault); err != nil {
-		t.Fatal(err)
-	}
-	allowed, err = accountEffectiveAuthorization(st, false)(context.Background(), store.OwnerDefault)
-	if err != nil || allowed {
-		t.Fatalf("disabled existing local account allowed: %v %v", allowed, err)
-	}
-}

internal/app/account_lister_test.go

@@ -16,20 +16,11 @@ func TestInprocHostListAccounts(t *testing.T) {
 	}
 	t.Cleanup(func() { st.Close() })
 	for _, o := range []string{"carol", "alice", "bob", "dave"} {
-		if err := st.EnsureUser(o, ""); err != nil {
-			t.Fatal(err)
-		}
 		if _, err := st.CreateAPIKey(o, "e2e"); err != nil {
 			t.Fatal(err)
 		}
 	}
-	if _, err := st.DB().Exec(`UPDATE users SET is_admin=TRUE WHERE owner='alice'`); err != nil {
-		t.Fatal(err)
-	}
-	h := inprocHost{caps: hostcaps{st: st}, owner: "alice", actor: "alice"}
-	if _, _, err := (inprocHost{caps: hostcaps{st: st}}).ListAccounts("", 2); err == nil {
-		t.Fatal("legacy directory allowed a host without a trusted dispatch actor")
-	}
+	h := inprocHost{caps: hostcaps{st: st}}
 
 	// 首页（limit=2）：alice/bob，next=bob。
 	page, next, err := h.ListAccounts("", 2)
@@ -59,12 +50,6 @@ func TestInprocHostListAccounts(t *testing.T) {
 	if _, _, err := h.ListAccounts("", 999); err != nil {
 		t.Fatalf("limit 超限应钳制不报错: %v", err)
 	}
-	if _, err := st.DB().Exec(`UPDATE users SET enabled=FALSE WHERE owner='alice'`); err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := h.ListAccounts("", 2); err == nil {
-		t.Fatal("disabled administrator retained legacy directory access")
-	}
 }
 
 // TestInprocHostSearchAccounts：EXT-19 扩展 SearchAccounts——账号/姓名子串
@@ -80,7 +65,7 @@ func TestInprocHostSearchAccounts(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := st.CreateAccount("alice", "王小明", hash, true); err != nil {
+	if err := st.CreateAccount("alice", "王小明", hash, false); err != nil {
 		t.Fatal(err)
 	}
 	if err := st.CreateAccount("bob", "李大明", hash, false); err != nil {
@@ -89,10 +74,7 @@ func TestInprocHostSearchAccounts(t *testing.T) {
 	if err := st.CreateAccount("carol", "", hash, false); err != nil {
 		t.Fatal(err)
 	}
-	h := inprocHost{caps: hostcaps{st: st}, owner: "alice", actor: "alice"}
-	if _, err := (inprocHost{caps: hostcaps{st: st}, owner: "bob", actor: "bob"}).SearchAccounts("alice", 50); err == nil {
-		t.Fatal("ordinary actor gained legacy system directory search")
-	}
+	h := inprocHost{caps: hostcaps{st: st}}
 
 	// 姓名子串（同名区分场景）：两个"大明/小明"都以"明"命中。
 	got, err := h.SearchAccounts("明", 50)

internal/app/app.go

@@ -292,17 +292,7 @@ func Run(opt Options) error {
 	if err := setSvc.SnapshotAndMigrateSecrets(); err != nil {
 		return fmt.Errorf("migrate secrets: %w", err)
 	}
-	runtime.SecretLookup = func(owner, service string) (string, bool) {
-		if owner == "" {
-			owner = store.OwnerDefault
-		}
-		if v, ok := st.ActiveSecret(owner, service); ok {
-			return v, true
-		}
-		// P2 受管：密钥统一迁入 secrets 表后，系统层受管密钥挂在系统行
-		//（owner=settings.OwnerSystemRow）；租户未单独配置时回退系统密钥。
-		return st.ActiveSecret(settings.OwnerSystemRow, service)
-	}
+	runtime.SecretLookup = setSvc.LookupSecret
 	rag.SecretLookup = func(service, fallback string) string {
 		return runtime.LookupSecret(store.OwnerDefault, service, fallback)
 	}
@@ -312,7 +302,7 @@ func Run(opt Options) error {
 	if err := tools.RegisterLazySearchTools(reg, func() agenttools.SearchProvider {
 		effNow := setSvc.Effective(store.OwnerDefault, "")
 		tavilyNow := effNow.GetString("tools.tavily.apiKeys", "")
-		if active, ok := st.ActiveSecret(store.OwnerDefault, "tools.tavily"); ok {
+		if active, ok := setSvc.LookupSecret(store.OwnerDefault, "tools.tavily"); ok {
 			tavilyNow = active
 		}
 		keys := splitKeyPool(tavilyNow)
@@ -381,7 +371,7 @@ func Run(opt Options) error {
 			},
 		}
 		tavilyNow := effNow.GetString("tools.tavily.apiKeys", "")
-		if active, ok := st.ActiveSecret(store.OwnerDefault, "tools.tavily"); ok {
+		if active, ok := setSvc.LookupSecret(store.OwnerDefault, "tools.tavily"); ok {
 			tavilyNow = active
 		}
 		if keys := splitKeyPool(tavilyNow); len(keys) > 0 {
@@ -450,9 +440,6 @@ func Run(opt Options) error {
 	subRunner := &runtime.SubLLMRunner{Prompts: promptSvc, Trace: traceFn}
 	mockRunner := &runtime.MockRunner{}
 	mgr := runmgr.New(st, b, reg, profSvc, setSvc, convRunner, subRunner, mockRunner, &runtime.MockSubagent{})
-	authOn := resolved.AuthEnabled()
-	effectiveAccount := accountEffectiveAuthorization(st, authOn)
-	mgr.SetAccountEffectiveAuthorization(effectiveAccount, !authOn)
 	instanceID := opt.InstanceID
 	if instanceID == "" {
 		host, err := os.Hostname()
@@ -527,25 +514,14 @@ func Run(opt Options) error {
 	// fs 预留能力沙箱根：<DataDir>/workspaces/<owner>/<conversationID>/。
 	mgr.SetWorkspaceRoot(filepath.Join(opt.DataDir, "workspaces"))
 	// 中断子代理续跑（N2 WP5）：依赖转录目录（workspaceRoot）与派生请求。
-	mgr.ResumeInterruptedChildrenChecked(context.Background(), func(ctx context.Context, owner string) error {
-		valid, err := effectiveAccount(ctx, owner)
-		if err != nil {
-			return err
-		}
-		if !valid {
-			return store.ErrAccountForbidden
-		}
-		return nil
-	})
+	mgr.ResumeInterruptedChildren()
 
 	// 收件箱任务卡：事件走会话事件管道（持久化/seq/重放）；关闭即 T0 基线。
 	cardSvc := cardsvc.New(st, mgr.EmitCardEvent)
-	cardSvc.SetAccountCheckedEmitter(mgr.EmitCardEventAccountChecked)
 	cardSvc.SetProjectSharedEmitter(mgr.EmitProjectSharedCardEvent)
 	surfaceSvc := surfacesvc.New(st, mgr.EmitCardEvent)
-	surfaceSvc.SetAccountCheckedEmitter(mgr.EmitCardEventAccountChecked)
 	go func() { // 启动恢复：重发「快照已落盘、事件未发出」的待恢复投影（KTD）。
-		if n, err := surfaceSvc.RecoverPendingEventsAccountChecked(context.Background(), !authOn); err == nil && n > 0 {
+		if n, err := surfaceSvc.RecoverPendingEvents(context.Background()); err == nil && n > 0 {
 			log.Printf("surface: recovered %d pending events", n)
 		}
 	}()
@@ -568,17 +544,6 @@ func Run(opt Options) error {
 
 	// 命令总线（提案 T3/D27/D30）：四入口同源分发 + 审计 + 危险内联确认卡。
 	bus := cmdbus.New(st, cardSvc, func() time.Time { return time.Now().UTC() })
-	bus.SetEffectiveAccountGuard(func(ctx context.Context, actor string) error {
-		valid, err := effectiveAccount(ctx, actor)
-		if err != nil {
-			return err
-		}
-		if !valid {
-			return store.ErrAccountForbidden
-		}
-		return nil
-	})
-	bus.RequireAccountCheckedWrites(!authOn)
 	// U5：页面动作分发口——surfacesvc.SubmitAction 经命令总线四入口同源分发
 	//（审计信封、参数校验、DangerHigh 内联确认卡全复用；Confirmed 不透传）。
 	surfaceSvc.SetDispatcher(func(ctx context.Context, d surfacesvc.ActionDispatch) (surfacesvc.ActionOutcome, error) {
@@ -622,21 +587,7 @@ func Run(opt Options) error {
 	// hostcaps：hostapi 闭包与进程内插件句柄共用的 owner 作用域能力（EXT-1 批注 1）。
 	authzSlot := &projectAuthz{}
 	projectSlot := &projectLifecycleSlot{}
-	directorySlot, err := newAccountDirectorySlot(st)
-	if err != nil {
-		return err
-	}
-	caps := hostcaps{projects: projectSlot, directory: directorySlot, st: st, pipe: pipe, set: setSvc, authz: authzSlot, surfaces: surfaceSvc, allowImplicitLocal: !authOn,
-		accountGuard: func(owner string) error {
-			valid, err := effectiveAccount(context.Background(), owner)
-			if err != nil {
-				return err
-			}
-			if !valid {
-				return store.ErrAccountForbidden
-			}
-			return nil
-		}}
+	caps := hostcaps{projects: projectSlot, st: st, pipe: pipe, set: setSvc, authz: authzSlot, surfaces: surfaceSvc}
 	// EXT-13：回合内检索（knowledge_search / @knowledge 注入）与 HTTP/Host 检索面
 	// 同一适配器授权；槽为共享指针，扩展在 applyCompiled 期间注册后即生效。
 	mgr.SetSharedKnowledgeAllow(func(owner string, projectID core.ID) bool {
@@ -672,9 +623,6 @@ func Run(opt Options) error {
 		}
 	}
 	hostSrv.Dispatch = func(ctx context.Context, pluginID, owner, commandID string, params map[string]any) error {
-		if err := caps.accountGuard(owner); err != nil {
-			return err
-		}
 		resp := bus.Dispatch(ctx, cmdbus.Request{ID: commandID, Params: params, Entrance: "api", Actor: pluginID, Owner: owner})
 		if resp.Receipt.State == "rejected" || resp.Receipt.State == "unknown" {
 			return fmt.Errorf("%s", resp.Receipt.Reason)
@@ -700,6 +648,10 @@ func Run(opt Options) error {
 	// EXT-8b：资源级适配器注入读面（未注册=server 回落 V1，行为不变）。
 	if authzSlot.hasV2() {
 		srv.SetResourceAuthorizerV2(authzSlot.AuthorizeResource)
+		mgr.SetArtifactResourceAllow(func(actor string, artifact core.Artifact) bool {
+			ok, err := authzSlot.AuthorizeResource(extension.ResourceAuthzQuery{Actor: actor, Action: "model-context", ResourceType: "artifact", ResourceID: artifact.ID, Owner: artifact.Owner, ProjectID: artifact.ProjectID})
+			return err == nil && ok
+		})
 	}
 	// EXT-9：宿主可关闭上传自动索引（发布决定移交下游命令层）。
 	srv.DisableUploadIndexing = opt.DisableUploadIndexing
@@ -735,6 +687,7 @@ func Run(opt Options) error {
 		return int(setSvc.Effective(store.OwnerDefault, "").GetNumber("runtime.rateLimitPerMin", 0))
 	})
 	// 认证策略（auto）：PG 档默认开启（多用户面不能裸奔）；嵌入式档默认关闭（本地单用户）。
+	authOn := resolved.AuthEnabled()
 	srv.Auth = server.NewAuthenticator(st, authOn)
 	if authOn {
 		log.Printf("auth: API key required (create with: agent-system apikey create --owner <name>)")
@@ -779,69 +732,63 @@ func Run(opt Options) error {
 	return nil
 }
 
-func assertLocalAccountOwner(st *store.Store, storageDSN, dataDir string) error {
-	if storageDSN == "" {
-		storageDSN = os.Getenv("AGENT_SYSTEM_DSN")
-	}
-	if storageDSN != "" {
-		var isOwner bool
-		err := st.DB().QueryRow(`SELECT current_user = pg_get_userbyid(c.relowner) FROM pg_class c WHERE c.oid='users'::regclass`).Scan(&isOwner)
-		if err != nil || !isOwner {
-			return store.ErrAccountForbidden
-		}
-		return nil
-	}
-	info, err := os.Stat(filepath.Join(dataDir, "agent-system.db"))
-	if err != nil {
-		return err
-	}
-	stat, ok := info.Sys().(*syscall.Stat_t)
-	if !ok || (os.Geteuid() != 0 && stat.Uid != uint32(os.Geteuid())) {
-		return store.ErrAccountForbidden
-	}
-	return nil
-}
-
-// CreateUserAccount is the local owner-only, audited pending-account path.
-// Password-bearing creation is rejected before storage is opened.
+// CreateUserAccount CLI 建号。
+// password 空且 generatePassword=false：无初始密码，同事务签发 activate Key，返回明文 Key。
+// generatePassword=true 或显式 password：兼容旧路径（随机/给定密码 + must_change）。
 func CreateUserAccount(storageDSN, dataDir, owner, name, password string, isAdmin, openExisting, generatePassword bool) (string, string, error) {
-	if password != "" || generatePassword {
-		return "", "", fmt.Errorf("RECOVERY_CONTRACT_REPLACED: local creation uses trusted activation only")
-	}
-	var out store.AccountOutcome
+	var out, opID string
 	err := withStoreMode(storageDSN, dataDir, openExisting, func(st *store.Store) error {
-		if err := assertLocalAccountOwner(st, storageDSN, dataDir); err != nil {
-			return err
+		if password != "" || generatePassword {
+			pw := password
+			if pw == "" {
+				pw = server.RandomPassword()
+			}
+			hash, err := store.HashPassword(pw)
+			if err != nil {
+				return err
+			}
+			outc, err := st.CreateActivatedAccount(store.AccountWrite{
+				Owner: owner, Name: name, PasswordHash: hash, IsAdmin: isAdmin, MustChange: true,
+				Actor: cliActor(), InstanceID: accountInstanceID(), Action: "account.create",
+			})
+			if err != nil {
+				return err
+			}
+			out = pw
+			opID = outc.OperationID
+			return nil
 		}
-		_, next, err := st.CreateLocalPendingAccountWithAudit(owner, name, isAdmin, accountInstanceID())
-		out = next
-		return err
-	})
-	return out.Plain, out.OperationID, err
-}
-
-// IssueUserLoginKey is retained only as a rejecting compatibility entry.
-func IssueUserLoginKey(storageDSN, dataDir, owner, purpose string, openExisting, revokeAllCreds bool, ttl time.Duration) (string, error) {
-	return "", fmt.Errorf("RECOVERY_CONTRACT_REPLACED: use owner initialization or owner-confirmed recovery")
-}
-
-// InitializeAccount resumes a specific pending account. The operator identity
-// comes from the local OS UID; the target is fixed by stable user ID and CAS.
-func InitializeAccount(storageDSN, dataDir, userID string, expectedStateVersion, expectedGeneration int64) (string, string, error) {
-	var plain, owner string
-	err := withStoreMode(storageDSN, dataDir, true, func(st *store.Store) error {
-		if err := assertLocalAccountOwner(st, storageDSN, dataDir); err != nil {
-			return err
-		}
-		account, err := st.GetAccount(userID)
+		outc, err := st.CreateActivatedAccount(store.AccountWrite{
+			Owner: owner, Name: name, IsAdmin: isAdmin, Purpose: store.LoginKeyPurposeActivate, CreatedBy: "cli",
+			Actor: cliActor(), InstanceID: accountInstanceID(), Action: "account.create",
+		})
 		if err != nil {
 			return err
 		}
-		out, err := st.InitializePendingAccountWithAudit(userID, expectedStateVersion, expectedGeneration, accountInstanceID())
-		plain, owner = out.Plain, account.Owner
+		out = outc.Plain
+		opID = outc.OperationID
+		return nil
+	})
+	return out, opID, err
+}
+
+// IssueUserLoginKey CLI 签发激活/恢复 Key。
+func IssueUserLoginKey(storageDSN, dataDir, owner, purpose string, openExisting, revokeAllCreds bool, ttl time.Duration) (string, error) {
+	var plain string
+	err := withStoreMode(storageDSN, dataDir, openExisting, func(st *store.Store) error {
+		if revokeAllCreds {
+			outc, err := st.RevokeAllAndIssue(store.AccountWrite{
+				Owner: owner, Purpose: purpose, CreatedBy: "cli", TTL: ttl,
+				Actor: cliActor(), InstanceID: accountInstanceID(),
+			})
+			plain = outc.Plain
+			return err
+		}
+		p, _, err := st.IssueLoginKey(owner, purpose, "cli", ttl)
+		plain = p
 		return err
 	})
-	return plain, owner, err
+	return plain, err
 }
 
 // RevokeUserLoginKey CLI 撤销未使用登录 Key。
@@ -856,9 +803,6 @@ func RevokeUserLoginKey(storageDSN, dataDir, id string, openExisting bool) error
 func BootstrapAdmin(storageDSN, dataDir, owner string, openExisting bool) (string, error) {
 	var plain string
 	err := withStoreMode(storageDSN, dataDir, openExisting, func(st *store.Store) error {
-		if err := assertLocalAccountOwner(st, storageDSN, dataDir); err != nil {
-			return err
-		}
 		outc, err := st.BootstrapFirstAdminWrite(store.AccountWrite{
 			Owner: owner, Name: owner, Actor: cliActor(), InstanceID: accountInstanceID(),
 		})
@@ -871,7 +815,19 @@ func BootstrapAdmin(storageDSN, dataDir, owner string, openExisting bool) (strin
 // ResetUserPassword CLI 重置密码：单事务写 must_change=1、bump 认证版本、
 // 作废未用登录 Key、吊销全部会话并审计。
 func ResetUserPassword(storageDSN, dataDir, owner, password string, openExisting bool) (string, error) {
-	return "", fmt.Errorf("RECOVERY_CONTRACT_REPLACED: administrators cannot set another user's password")
+	if password == "" {
+		password = server.RandomPassword()
+	}
+	hash, err := store.HashPassword(password)
+	if err != nil {
+		return "", err
+	}
+	if err := withStoreMode(storageDSN, dataDir, openExisting, func(st *store.Store) error {
+		return st.AdminResetUserPassword(owner, hash, cliActor(), "cli")
+	}); err != nil {
+		return "", err
+	}
+	return password, nil
 }
 
 // ListUserAccounts CLI 用户列表。
@@ -938,16 +894,6 @@ func withStoreMode(storageDSN, dataDir string, _ bool, fn func(*store.Store) err
 func CreateAPIKey(storageDSN, dataDir, owner, name string) (string, error) {
 	var plain string
 	err := withStoreMode(storageDSN, dataDir, true, func(st *store.Store) error {
-		if err := assertLocalAccountOwner(st, storageDSN, dataDir); err != nil {
-			return err
-		}
-		account, err := st.GetAccountByOwner(owner)
-		if err != nil {
-			return err
-		}
-		if !account.Enabled || account.InitializationState == store.InitializationPending {
-			return store.ErrAccountForbidden
-		}
 		p, e := st.CreateAPIKey(owner, name)
 		plain = p
 		return e
@@ -960,7 +906,7 @@ func ListAPIKeys(storageDSN, dataDir, owner string) ([]store.APIKeyInfo, error)
 	var out []store.APIKeyInfo
 	err := withStoreMode(storageDSN, dataDir, true, func(st *store.Store) error {
 		if _, err := st.GetUser(owner); err != nil {
-			return fmt.Errorf("owner %q 不存在（先建立账号）", owner)
+			return fmt.Errorf("owner %q 不存在（先 apikey create 创建）", owner)
 		}
 		var e error
 		out, e = st.ListAPIKeys(owner)

internal/app/compiled.go

@@ -64,7 +64,7 @@ func (r pluginRegistry) AddCommandHandler(spec json.RawMessage, h extension.Hand
 		return fmt.Errorf("extension: command spec: %w", err)
 	}
 	return r.bus.RegisterPluginCommand(s, func(ctx context.Context, req cmdbus.Request) (any, error) {
-		host := requestBoundHost{inprocHost{caps: r.caps, pluginID: r.pluginID, owner: req.Owner, actor: req.Actor}}
+		host := inprocHost{caps: r.caps, pluginID: r.pluginID, owner: req.Owner, actor: req.Actor}
 		return h(ctx, host, extension.Request{
 			ID: req.ID, Params: req.Params, Entrance: req.Entrance,
 			Actor: req.Actor, Owner: req.Owner, ConversationID: req.ConversationID,
@@ -116,17 +116,6 @@ func (r compiledRegistry) RegisterResourceAuthorizer(extension.ResourceAuthorize
 	return errors.New("extension: declarative plugins cannot register resource authorizers")
 }
 
-func (r compiledRegistry) RegisterAccountDirectoryScopeResolver(extension.AccountDirectoryScopeResolver) error {
-	return errors.New("extension: declarative plugins cannot register account directory authorization")
-}
-
-func (r pluginRegistry) RegisterAccountDirectoryScopeResolver(fn extension.AccountDirectoryScopeResolver) error {
-	if r.pluginID != "rdm" || r.caps.directory == nil {
-		return errors.New("extension: account directory resolver requires trusted RDM registration")
-	}
-	return r.caps.directory.register(r.pluginID, fn)
-}
-
 // RegisterResourceAuthorizer 进程内扩展（EXT-1）：填充 EXT-8 适配器槽
 // （hostcaps.authz 共享指针；首个注册者生效，组合根已装配进 Server/runmgr）。
 // 此前 pluginRegistry 未覆盖该方法——进程内插件注册适配器会命中声明式分支的
@@ -161,14 +150,6 @@ type recordRegistry struct {
 	sum *server.CompiledPlugin
 }
 
-func (r recordRegistry) RegisterAccountDirectoryScopeResolver(fn extension.AccountDirectoryScopeResolver) error {
-	registrar, ok := r.Registry.(extension.AccountDirectoryRegistrar)
-	if !ok {
-		return errors.New("extension: account directory registration unavailable")
-	}
-	return registrar.RegisterAccountDirectoryScopeResolver(fn)
-}
-
 func (r recordRegistry) AddCommand(spec json.RawMessage) error {
 	if err := r.Registry.AddCommand(spec); err != nil {
 		return err

internal/app/delegated_project_projection.go

@@ -1,122 +0,0 @@
-package app
-
-import (
-	"agent-system-backend/internal/store"
-	"agent-system-backend/pkg/extension"
-	core "agent-system-core"
-)
-
-// requestBoundHost is created only for a current lifecycle or command request.
-// A reconstructed global ScopedHost is a plain inprocHost and cannot expose
-// the delegated projection method by type assertion.
-type requestBoundHost struct{ inprocHost }
-
-// ProjectProjectionForCreator only derives from a live request Host of the
-// registered RDM provider. The operator is inherited from that Host, never
-// accepted as a caller-supplied field. RDM's project.settings decision remains
-// its own domain authority; this capability fences the Backend projection.
-func (bound requestBoundHost) ProjectProjectionForCreator(creator, projectID string) (extension.ProjectHost, error) {
-	h := bound.inprocHost
-	if h.actor == "" || h.actor != h.owner || h.pluginID != "rdm" ||
-		h.caps.projects == nil || h.caps.st == nil || creator == "" || projectID == "" {
-		return nil, store.ErrAccountForbidden
-	}
-	slot := h.caps.projects
-	slot.mu.Lock()
-	registered := slot.provider != nil && slot.holder == h.pluginID
-	slot.mu.Unlock()
-	if !registered {
-		return nil, store.ErrAccountForbidden
-	}
-	if err := h.requireEffective(); err != nil {
-		return nil, err
-	}
-	if h.caps.accountGuard != nil {
-		if err := h.caps.accountGuard(creator); err != nil {
-			return nil, err
-		}
-	}
-	project, err := h.caps.st.ProjectMetadata(projectID)
-	if err != nil {
-		return nil, err
-	}
-	if string(project.Owner) != creator || string(project.ID) != projectID {
-		return nil, store.ErrNotFound
-	}
-	return delegatedProjectProjection{caps: h.caps, pluginID: h.pluginID,
-		actor: h.actor, creator: creator, projectID: projectID}, nil
-}
-
-// delegatedProjectProjection exposes only ProjectHost, and every method is
-// confined to the bound project. It cannot be cast to the broader Host.
-type delegatedProjectProjection struct {
-	caps      hostcaps
-	pluginID  string
-	actor     string
-	creator   string
-	projectID string
-}
-
-var _ extension.ProjectHost = delegatedProjectProjection{}
-
-func (p delegatedProjectProjection) Owner() string { return p.creator }
-
-func (p delegatedProjectProjection) check() error {
-	if p.caps.accountGuard == nil {
-		return nil
-	}
-	if err := p.caps.accountGuard(p.actor); err != nil {
-		return err
-	}
-	return p.caps.accountGuard(p.creator)
-}
-
-func (p delegatedProjectProjection) target(id string) error {
-	if id == "" || id != p.projectID {
-		return store.ErrNotFound
-	}
-	return nil
-}
-
-func (p delegatedProjectProjection) OwnedProjects() ([]core.Project, error) {
-	return nil, store.ErrAccountForbidden
-}
-
-func (p delegatedProjectProjection) OwnedProject(string) (core.Project, error) {
-	return core.Project{}, store.ErrAccountForbidden
-}
-
-func (p delegatedProjectProjection) EnsureProject(string, string) (core.Project, error) {
-	return core.Project{}, store.ErrAccountForbidden
-}
-
-func (p delegatedProjectProjection) ProjectMetadata(id string) (core.Project, error) {
-	if err := p.target(id); err != nil {
-		return core.Project{}, err
-	}
-	if err := p.check(); err != nil {
-		return core.Project{}, err
-	}
-	view := inprocHost{caps: p.caps, pluginID: p.pluginID, owner: p.creator, actor: p.actor}
-	return view.ProjectMetadata(id)
-}
-
-func (p delegatedProjectProjection) ProjectNameAvailable(name, exceptID string) (bool, error) {
-	if err := p.target(exceptID); err != nil {
-		return false, err
-	}
-	if err := p.check(); err != nil {
-		return false, err
-	}
-	return p.caps.st.ProjectNameAvailable(name, exceptID)
-}
-
-func (p delegatedProjectProjection) RenameOwnedProject(id, name string) (core.Project, error) {
-	if err := p.target(id); err != nil {
-		return core.Project{}, err
-	}
-	if err := p.check(); err != nil {
-		return core.Project{}, err
-	}
-	return p.caps.st.RenameOwnedProjectAccountChecked(p.actor, p.creator, p.projectID, name, p.caps.allowImplicitLocal)
-}

internal/app/delegated_project_projection_entry_test.go

@@ -1,108 +0,0 @@
-package app
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	agentcommand "agent-command"
-	"agent-system-backend/internal/cmdbus"
-	"agent-system-backend/internal/server"
-	"agent-system-backend/internal/settings"
-	"agent-system-backend/internal/store"
-	"agent-system-backend/pkg/extension"
-	core "agent-system-core"
-)
-
-func TestDelegatedProjectionIsBoundAtHTTPAndCommandEntries(t *testing.T) {
-	st, err := store.OpenSQLite(t.TempDir() + "/entries.db")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	for _, owner := range []string{"alice", "bob"} {
-		if err := st.EnsureUser(owner, ""); err != nil {
-			t.Fatal(err)
-		}
-	}
-	httpProject, err := st.CreateProject("alice", "HTTP original")
-	if err != nil {
-		t.Fatal(err)
-	}
-	commandProject, err := st.CreateProject("alice", "Command original")
-	if err != nil {
-		t.Fatal(err)
-	}
-	check := func(owner string) error {
-		state, err := st.GetUserAuthState(owner)
-		if err != nil {
-			return err
-		}
-		if !state.Enabled {
-			return store.ErrAccountForbidden
-		}
-		return nil
-	}
-	projectFromRequest := func(h extension.Host, id, name string) (core.Project, error) {
-		bound, ok := h.(extension.DelegatedProjectProjectionHost)
-		if !ok {
-			return core.Project{}, errors.New("request Host lost operator-bound projection")
-		}
-		projection, err := bound.ProjectProjectionForCreator("alice", id)
-		if err != nil {
-			return core.Project{}, err
-		}
-		return projection.RenameOwnedProject(id, name)
-	}
-	slot := &projectLifecycleSlot{}
-	caps := hostcaps{st: st, set: settings.NewService(st), projects: slot, accountGuard: check}
-	provider := completeLifecycle()
-	provider.Rename = func(_ context.Context, h extension.Host, id, name string) (core.Project, error) {
-		return projectFromRequest(h, id, name)
-	}
-	if err := (pluginRegistry{pluginID: "rdm", caps: caps}).RegisterProjectLifecycle(provider); err != nil {
-		t.Fatal(err)
-	}
-	srv := server.New(st, nil, nil, nil, caps.set, nil)
-	srv.Auth = server.NewAuthenticator(st, true)
-	slot.wire(srv, caps)
-	key, err := st.CreateAPIKey("bob", "delegate-entry")
-	if err != nil {
-		t.Fatal(err)
-	}
-	req := httptest.NewRequest(http.MethodPatch, "/api/projects/"+string(httpProject.ID), strings.NewReader(`{"name":"via HTTP"}`))
-	req.Header.Set("Authorization", "Bearer "+key)
-	rec := httptest.NewRecorder()
-	srv.Handler().ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("HTTP lifecycle rename: status=%d body=%s", rec.Code, rec.Body.String())
-	}
-	bus := cmdbus.New(st, nil, nil)
-	bus.SetEffectiveAccountGuard(func(_ context.Context, owner string) error { return check(owner) })
-	bus.RequireAccountCheckedWrites(false)
-	reg := pluginRegistry{pluginID: "rdm", caps: caps, compiledRegistry: compiledRegistry{bus: bus}}
-	err = reg.AddCommandHandler(json.RawMessage(`{"id":"rdm.fixture.rename","title":"Rename"}`),
-		func(_ context.Context, h extension.Host, req extension.Request) (any, error) {
-			id, _ := req.Params["id"].(string)
-			name, _ := req.Params["name"].(string)
-			return projectFromRequest(h, id, name)
-		})
-	if err != nil {
-		t.Fatal(err)
-	}
-	result := bus.Dispatch(context.Background(), cmdbus.Request{ID: "rdm.fixture.rename", Owner: "bob", Actor: "bob",
-		Params: map[string]any{"id": string(commandProject.ID), "name": "via command"}})
-	if result.Receipt.State != agentcommand.StateCommitted {
-		t.Fatalf("command rename: %+v", result.Receipt)
-	}
-	for _, tc := range []struct{ id, want string }{{string(httpProject.ID), "via HTTP"}, {string(commandProject.ID), "via command"}} {
-		project, err := st.ProjectMetadata(tc.id)
-		if err != nil || project.Name != tc.want {
-			t.Fatalf("entry %s did not reach bound projection: %+v %v", tc.id, project, err)
-		}
-	}
-}

internal/app/delegated_project_projection_pg_test.go

@@ -1,135 +0,0 @@
-package app
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"agent-system-backend/internal/store"
-)
-
-// Two processes share one isolated PostgreSQL schema. The child has already
-// accepted a stale early account read when the parent commits disable; only
-// the final Backend transaction can stop the physical rename.
-func TestPGDelegatedProjectionDisableAcrossProcesses(t *testing.T) {
-	baseDSN := os.Getenv("AGENT_PG_TEST_DSN")
-	if baseDSN == "" {
-		t.Skip("isolated PostgreSQL DSN required")
-	}
-	separator := "?"
-	if strings.Contains(baseDSN, "?") {
-		separator = "&"
-	}
-	if os.Getenv("IAM_U3_DELEGATE_CHILD") == "1" {
-		dsn := baseDSN + separator + "search_path=" + os.Getenv("IAM_U3_DELEGATE_SCHEMA") + ",public"
-		st, err := store.OpenExistingPostgres(dsn, filepath.Join(t.TempDir(), "artifacts"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer st.Close()
-		var bobChecks atomic.Int32
-		check := func(owner string) error {
-			state, err := st.GetUserAuthState(owner)
-			if err != nil {
-				return err
-			}
-			if !state.Enabled {
-				return store.ErrAccountForbidden
-			}
-			if owner == "bob" && bobChecks.Add(1) == 2 {
-				if err := os.WriteFile(os.Getenv("IAM_U3_DELEGATE_READY"), []byte("ready"), 0o600); err != nil {
-					return err
-				}
-				deadline := time.Now().Add(5 * time.Second)
-				for {
-					if _, err := os.Stat(os.Getenv("IAM_U3_DELEGATE_RELEASE")); err == nil {
-						break
-					}
-					if time.Now().After(deadline) {
-						return errors.New("parent did not release paused child")
-					}
-					time.Sleep(10 * time.Millisecond)
-				}
-			}
-			return nil
-		}
-		slot := &projectLifecycleSlot{}
-		caps := hostcaps{st: st, projects: slot, accountGuard: check}
-		if err := (pluginRegistry{pluginID: "rdm", caps: caps}).RegisterProjectLifecycle(completeLifecycle()); err != nil {
-			t.Fatal(err)
-		}
-		host := requestBoundHost{inprocHost{caps: caps, pluginID: "rdm", owner: "bob", actor: "bob"}}
-		projection, err := host.ProjectProjectionForCreator("alice", os.Getenv("IAM_U3_DELEGATE_PROJECT"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := projection.RenameOwnedProject(os.Getenv("IAM_U3_DELEGATE_PROJECT"), "late"); !errors.Is(err, store.ErrAccountForbidden) {
-			t.Fatalf("late physical rename was not fenced: %v", err)
-		}
-		return
-	}
-	st := openDirectoryTestStore(t)
-	if err := st.EnsureSystemIdentity("u3-delegate-two-process", "pg"); err != nil {
-		t.Fatal(err)
-	}
-	for _, account := range []struct {
-		owner string
-		admin bool
-	}{{"admin", true}, {"alice", false}, {"bob", false}} {
-		if err := st.CreateAccount(account.owner, "", "", account.admin); err != nil {
-			t.Fatal(err)
-		}
-	}
-	project, err := st.CreateProject("alice", "before")
-	if err != nil {
-		t.Fatal(err)
-	}
-	var schema string
-	if err := st.DB().QueryRow(`SELECT current_schema()`).Scan(&schema); err != nil {
-		t.Fatal(err)
-	}
-	barrier := t.TempDir()
-	ready, release := filepath.Join(barrier, "ready"), filepath.Join(barrier, "release")
-	cmd := exec.Command(os.Args[0], "-test.run=^TestPGDelegatedProjectionDisableAcrossProcesses$")
-	cmd.Env = append(os.Environ(), "IAM_U3_DELEGATE_CHILD=1", "IAM_U3_DELEGATE_SCHEMA="+schema,
-		"IAM_U3_DELEGATE_PROJECT="+string(project.ID), "IAM_U3_DELEGATE_READY="+ready, "IAM_U3_DELEGATE_RELEASE="+release)
-	var output bytes.Buffer
-	cmd.Stdout, cmd.Stderr = &output, &output
-	if err := cmd.Start(); err != nil {
-		t.Fatal(err)
-	}
-	deadline := time.Now().Add(5 * time.Second)
-	for {
-		if _, err := os.Stat(ready); err == nil {
-			break
-		}
-		if time.Now().After(deadline) {
-			_ = cmd.Process.Kill()
-			t.Fatalf("child did not reach stale early check: %s", strings.ReplaceAll(output.String(), baseDSN, "[REDACTED]"))
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	bob, err := st.GetAccountByOwner("bob")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.SetAccountEnabled("admin", bob.ID, bob.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(release, []byte("release"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := cmd.Wait(); err != nil {
-		t.Fatalf("child failed: %v: %s", err, strings.ReplaceAll(output.String(), baseDSN, "[REDACTED]"))
-	}
-	got, err := st.ProjectMetadata(string(project.ID))
-	if err != nil || got.Name != "before" {
-		t.Fatalf("disabled operator's project rename persisted: %+v %v", got, err)
-	}
-}

internal/app/ext9_publish_test.go

@@ -23,9 +23,6 @@ func newExt9Host(t *testing.T) (interface {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { st.Close() })
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
 	set := settings.NewService(st)
 	pipe := rag.NewPipeline(st, set, nil, nil)
 	h := inprocHost{caps: hostcaps{st: st, pipe: pipe, set: set}, pluginID: "rdm", owner: "alice"}

internal/app/hostcaps.go

@@ -21,15 +21,12 @@ import (
 // 同一实现同时服务 hostapi.Server 的 Search/Complete 闭包与进程内
 // inprocHost（EXT-1 批注 1：复用现有 owner 作用域函数，不新造句柄）。
 type hostcaps struct {
-	projects           *projectLifecycleSlot
-	directory          *accountDirectorySlot
-	accountGuard       func(string) error
-	allowImplicitLocal bool
-	st                 *store.Store
-	pipe               *rag.Pipeline
-	set                *settings.Service
-	authz              *projectAuthz       // EXT-8 适配器槽（共享指针；首个注册者生效）
-	surfaces           *surfacesvc.Service // EXT-17 Surface 能力槽（nil = 未装配，明确拒绝）
+	projects *projectLifecycleSlot
+	st       *store.Store
+	pipe     *rag.Pipeline
+	set      *settings.Service
+	authz    *projectAuthz       // EXT-8 适配器槽（共享指针；首个注册者生效）
+	surfaces *surfacesvc.Service // EXT-17 Surface 能力槽（nil = 未装配，明确拒绝）
 }
 
 // projectAuthz EXT-8 资源授权适配器槽：进程内扩展注册，组合根装配进 Server。
@@ -112,11 +109,6 @@ type sharedRetriever interface {
 }
 
 func (c hostcaps) search(ctx context.Context, owner string, projectID core.ID, text string, topK int) ([]core.RetrievalHit, error) {
-	if c.accountGuard != nil {
-		if err := c.accountGuard(owner); err != nil {
-			return nil, err
-		}
-	}
 	q := core.RetrievalQuery{ProjectID: projectID, Text: text, TopK: topK}
 	if c.projects != nil && projectID != "" {
 		id, err := c.projects.resolve(ctx, c, owner, projectID)
@@ -151,23 +143,10 @@ func (c hostcaps) searchDefault(ctx context.Context, owner, text string) ([]core
 
 // complete 经基座 LLM 路由补全（owner 的模型配置生效；未配置报错）。
 func (c hostcaps) complete(ctx context.Context, owner, prompt string) (string, error) {
-	if c.accountGuard != nil {
-		if err := c.accountGuard(owner); err != nil {
-			return "", err
-		}
-	}
 	route := runtime.ResolveChatModel(core.AgentProfile{}, c.set.Effective(owner, ""))
 	if route.Model == "" || route.Base == "" {
 		return "", fmt.Errorf("llm route not configured")
 	}
-	if err := ctx.Err(); err != nil {
-		return "", err
-	}
-	if c.accountGuard != nil {
-		if err := c.accountGuard(owner); err != nil {
-			return "", err
-		}
-	}
 	return completeChat(ctx, route.Base, route.Key, route.Model, prompt)
 }
 
@@ -197,13 +176,6 @@ type inprocHost struct {
 	actor    string // EXT-18：分发主体（空＝非 dispatch 上下文）
 }
 
-func (h inprocHost) requireEffective() error {
-	if h.caps.accountGuard != nil {
-		return h.caps.accountGuard(h.owner)
-	}
-	return nil
-}
-
 func (h inprocHost) PluginID() string { return h.pluginID }
 func (h inprocHost) Owner() string    { return h.owner }
 
@@ -218,26 +190,14 @@ func (h inprocHost) IsAdmin() bool {
 	if err != nil {
 		return false
 	}
-	return state.Enabled && state.IsAdmin
+	return state.IsAdmin
 }
 
-func (h inprocHost) legacySystemDirectoryAuthorized() bool {
-	if h.requireEffective() != nil {
-		return false
-	}
-	if h.actor == "" {
-		return false
-	}
-	state, err := h.caps.st.GetUserAuthState(h.actor)
-	return err == nil && state.Enabled && state.IsAdmin
-}
-
-// ListAccounts 保留 EXT-19 旧签名，仅供有受信分发主体的系统管理上下文；
-// 项目和文档候选必须走带 locator 的 AccountDirectoryProvider。
+// ListAccounts 实现 EXT-19 AccountLister（最小账号目录）：仅授权管理读面用。
+// 有效态＝账号存在且非停用（当前 users 表无停用位——must_change_password 不影响
+// 有效性；后续加停用位在此映射）。P3（2026-10-13）：携带 Name 供同名区分。
+// 游标＝owner 升序偏移。
 func (h inprocHost) ListAccounts(cursor string, limit int) ([]extension.AccountEntry, string, error) {
-	if !h.legacySystemDirectoryAuthorized() {
-		return nil, "", store.ErrAccountForbidden
-	}
 	if limit <= 0 || limit > 200 {
 		limit = 50
 	}
@@ -247,7 +207,7 @@ func (h inprocHost) ListAccounts(cursor string, limit int) ([]extension.AccountE
 	}
 	entries := make([]extension.AccountEntry, 0, len(users))
 	for _, u := range users {
-		entries = append(entries, extension.AccountEntry{Owner: u.Owner, Name: u.Name, Valid: u.Enabled})
+		entries = append(entries, extension.AccountEntry{Owner: u.Owner, Name: u.Name, Valid: true})
 	}
 	// 排序+游标（owner 升序；cursor 为上一页末 owner，空＝首页）。
 	for i := 0; i < len(entries); i++ {
@@ -278,9 +238,6 @@ func (h inprocHost) ListAccounts(cursor string, limit int) ([]extension.AccountE
 // 姓名子串检索（大小写不敏感；空 query ＝ 首页候选）。结果按 owner 升序，
 // 有效态口径与 ListAccounts 一致。
 func (h inprocHost) SearchAccounts(query string, limit int) ([]extension.AccountEntry, error) {
-	if !h.legacySystemDirectoryAuthorized() {
-		return nil, store.ErrAccountForbidden
-	}
 	if limit <= 0 || limit > 200 {
 		limit = 50
 	}
@@ -296,7 +253,7 @@ func (h inprocHost) SearchAccounts(query string, limit int) ([]extension.Account
 			!strings.Contains(strings.ToLower(u.Name), q) {
 			continue
 		}
-		entries = append(entries, extension.AccountEntry{Owner: u.Owner, Name: u.Name, Valid: u.Enabled})
+		entries = append(entries, extension.AccountEntry{Owner: u.Owner, Name: u.Name, Valid: true})
 	}
 	sort.Slice(entries, func(i, j int) bool { return entries[i].Owner < entries[j].Owner })
 	if len(entries) > limit {
@@ -306,40 +263,25 @@ func (h inprocHost) SearchAccounts(query string, limit int) ([]extension.Account
 }
 
 func (h inprocHost) KVPut(key, value string) error {
-	if err := h.requireEffective(); err != nil {
-		return err
-	}
-	return h.caps.st.PutPluginKVAccountChecked(h.owner, h.pluginID, key, value, h.caps.allowImplicitLocal)
+	return h.caps.st.PutPluginKV(h.pluginID, h.owner, key, value)
 }
 
 func (h inprocHost) KVGet(key string) (string, bool, error) {
-	if err := h.requireEffective(); err != nil {
-		return "", false, err
-	}
 	return h.caps.st.GetPluginKV(h.pluginID, h.owner, key)
 }
 
 func (h inprocHost) Audit(action, target, evidence string) error {
-	if err := h.requireEffective(); err != nil {
-		return err
-	}
-	return h.caps.st.AppendAuditEventAccountChecked(h.owner, store.AuditEvent{
+	return h.caps.st.AppendAuditEvent(store.AuditEvent{
 		Owner: h.owner, Actor: "plugin:" + h.pluginID,
 		Action: action, Target: target, Evidence: evidence,
-	}, h.caps.allowImplicitLocal)
+	})
 }
 
 func (h inprocHost) Complete(ctx context.Context, prompt string) (string, error) {
-	if err := h.requireEffective(); err != nil {
-		return "", err
-	}
 	return h.caps.complete(ctx, h.owner, prompt)
 }
 
 func (h inprocHost) KnowledgeSearch(ctx context.Context, projectID core.ID, text string, topK int) ([]core.RetrievalHit, error) {
-	if err := h.requireEffective(); err != nil {
-		return nil, err
-	}
 	return h.caps.search(ctx, h.owner, projectID, text, topK)
 }
 
@@ -361,9 +303,6 @@ func (h inprocHost) knowledgeSource(source string) error {
 // "plugin:<id>"；embed=false 只写全文行，embed=true 走 IndexChunks 建向量
 // （embedding 失败降级纯全文，不阻断写入）。
 func (h inprocHost) KnowledgeWrite(ctx context.Context, docs []core.KnowledgeDoc, embed bool) error {
-	if err := h.requireEffective(); err != nil {
-		return err
-	}
 	if len(docs) == 0 {
 		return nil
 	}
@@ -378,21 +317,20 @@ func (h inprocHost) KnowledgeWrite(ctx context.Context, docs []core.KnowledgeDoc
 		}
 	}
 	if !embed {
-		return h.caps.st.AddKnowledgeAccountChecked(h.owner, h.caps.allowImplicitLocal, docs...)
+		return h.caps.st.AddKnowledge(docs...)
 	}
-	return h.caps.pipe.IndexChunksAccountChecked(ctx, core.ID(h.owner), docs, h.caps.allowImplicitLocal)
+	return h.caps.pipe.IndexChunks(ctx, core.ID(h.owner), docs)
 }
 
 // KnowledgePublish replaces refs and their vectors within the publication scope.
 // A registered lifecycle scopes replacement to the exact owner/project/plugin;
 // ordinary unregistered Hosts retain the legacy cross-source ref semantics.
 func (h inprocHost) KnowledgePublish(ctx context.Context, docs []core.KnowledgeDoc, embed bool) error {
-	if err := h.requireEffective(); err != nil {
-		return err
-	}
 	if len(docs) == 0 {
 		return nil
 	}
+	type publicationRef struct{ projectID, ref string }
+	refs := map[publicationRef]bool{}
 	for i := range docs {
 		docs[i].Owner = core.ID(h.owner)
 		if docs[i].Source == "" {
@@ -401,33 +339,39 @@ func (h inprocHost) KnowledgePublish(ctx context.Context, docs []core.KnowledgeD
 		if err := h.knowledgeSource(docs[i].Source); err != nil {
 			return err
 		}
+		if docs[i].Ref != "" {
+			refs[publicationRef{docs[i].ProjectID, docs[i].Ref}] = true
+		}
 	}
 	scoped := h.caps.projects != nil && h.caps.projects.active()
-	if embed {
-		return h.caps.pipe.PublishChunksAccountChecked(ctx, core.ID(h.owner), h.pluginID, scoped, docs, h.caps.allowImplicitLocal)
+	for ref := range refs {
+		var err error
+		if scoped {
+			err = h.caps.st.DeletePluginProjectKnowledgeByRef(ctx, h.owner, ref.projectID, ref.ref, h.pluginID)
+		} else {
+			err = h.caps.st.DeleteProjectKnowledgeByRef(ctx, h.owner, ref.projectID, ref.ref)
+		}
+		if err != nil {
+			return err
+		}
 	}
-	return h.caps.st.ReplaceKnowledgeAccountChecked(ctx, h.owner, h.pluginID, scoped, h.caps.allowImplicitLocal, docs...)
+
+	return h.KnowledgeWrite(ctx, docs, embed)
 }
 
 // KnowledgeDelete 撤销本插件来源（EXT-9）：前缀强制 plugin:<自身ID>——manual
 // 或他人来源拒绝（fail-closed）；删行+向量，幂等。
 func (h inprocHost) KnowledgeDelete(ctx context.Context, sourcePrefix string) error {
-	if err := h.requireEffective(); err != nil {
-		return err
-	}
 	if sourcePrefix != "plugin:"+h.pluginID {
 		return fmt.Errorf("ext-9: plugins may only delete their own source prefix, want %q", "plugin:"+h.pluginID)
 	}
-	_, err := h.caps.st.DeleteKnowledgeBySourceAccountChecked(ctx, h.owner, sourcePrefix, h.caps.allowImplicitLocal)
+	_, err := h.caps.st.DeleteKnowledgeBySource(ctx, h.owner, sourcePrefix)
 	return err
 }
 
 // TaskCreate/TaskUpdate 后台任务台账：基座只记进度/状态，执行体由下游自跑（H5）。
 func (h inprocHost) TaskCreate(kind, title, conversationID string) (string, error) {
-	if err := h.requireEffective(); err != nil {
-		return "", err
-	}
-	t, err := h.caps.st.CreateBackgroundTaskAccountChecked(h.owner, kind, title, conversationID, h.caps.allowImplicitLocal)
+	t, err := h.caps.st.CreateBackgroundTask(h.owner, kind, title, conversationID)
 	if err != nil {
 		return "", err
 	}
@@ -435,42 +379,27 @@ func (h inprocHost) TaskCreate(kind, title, conversationID string) (string, erro
 }
 
 func (h inprocHost) TaskUpdate(taskID, status string, progress int, errText string) error {
-	if err := h.requireEffective(); err != nil {
-		return err
-	}
-	return h.caps.st.UpdateBackgroundTaskAccountChecked(h.owner, taskID, status, progress, errText, h.caps.allowImplicitLocal)
+	return h.caps.st.UpdateBackgroundTask(h.owner, taskID, status, progress, errText)
 }
 
 // ArtifactGet/ArtifactContent 工件只读（R1-3 ingest 读原件；写入属完整集）。
 func (h inprocHost) ArtifactGet(artifactID string) (core.Artifact, error) {
-	if err := h.requireEffective(); err != nil {
-		return core.Artifact{}, err
-	}
 	return h.caps.st.GetArtifact(h.owner, artifactID)
 }
 
 func (h inprocHost) ArtifactContent(artifactID string) ([]byte, error) {
-	if err := h.requireEffective(); err != nil {
-		return nil, err
-	}
 	return h.caps.st.ArtifactContent(h.owner, artifactID)
 }
 
 // ParseDocument 内置文档解析（EXT-5）：委托 hostcaps.parse；纯计算不经存储，
 // owner 作用域由调用方经 ArtifactContent 取字节时保证。
 func (h inprocHost) ParseDocument(ctx context.Context, filename, mime string, content []byte) (core.ParsedDocument, error) {
-	if err := h.requireEffective(); err != nil {
-		return core.ParsedDocument{}, err
-	}
 	return h.caps.parse(ctx, filename, mime, content)
 }
 
 // ---- EXT-17 Surface 能力（可选）：nil 槽=能力缺失，明确拒绝不降级 ----
 
 func (h inprocHost) surface() (*surfacesvc.Service, error) {
-	if err := h.requireEffective(); err != nil {
-		return nil, err
-	}
 	if h.caps.surfaces == nil {
 		return nil, surfacesvc.ErrUnavailable
 	}
@@ -482,11 +411,11 @@ func (h inprocHost) SurfaceSave(ctx context.Context, req extension.SurfaceSaveRe
 	if err != nil {
 		return core.SurfaceSnapshot{}, err
 	}
-	return svc.SubmitAccountChecked(ctx, h.owner, h.pluginID, surfacesvc.SubmitRequest{
+	return svc.Submit(ctx, h.owner, h.pluginID, surfacesvc.SubmitRequest{
 		SurfaceID: req.SurfaceID, ConversationID: req.ConversationID, SourceRunID: req.SourceRunID,
 		BaseRevision: req.BaseRevision, ObservedEpoch: req.ObservedEpoch,
 		ContextVersion: req.ContextVersion, SemanticText: req.SemanticText, Spec: req.Spec,
-	}, h.caps.allowImplicitLocal)
+	})
 }
 
 func (h inprocHost) SurfaceGet(ctx context.Context, surfaceID core.ID) (core.SurfaceSnapshot, error) {

internal/app/inproc_host_test.go

@@ -78,9 +78,6 @@ func TestInprocHostOwnerScope(t *testing.T) {
 	bus, st := newInprocTestApp(t, nil) // embedder nil：embed=true 仍只落全文（IndexChunks 降级路径）
 
 	for _, owner := range []string{"alice", "bob"} {
-		if err := st.EnsureUser(owner, ""); err != nil {
-			t.Fatal(err)
-		}
 		resp := bus.Dispatch(context.Background(), cmdbus.Request{
 			ID: "tst.record", Params: map[string]any{"ref": owner + "-ref"}, Owner: owner, Actor: "ui", Entrance: "chat",
 		})
@@ -160,9 +157,6 @@ func TestInprocHostKnowledgeWriteEmbedHash(t *testing.T) {
 		},
 	})
 	bus, st := newInprocTestApp(t, func() string { return "hash" })
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
 
 	resp := bus.Dispatch(context.Background(), cmdbus.Request{
 		ID: "tst.embed", Params: map[string]any{"text": "Hash 向量内容"}, Owner: "alice", Entrance: "api",

internal/app/knowledge_authorization_test.go

@@ -16,11 +16,6 @@ func TestHostKnowledgeV2AndProjectReplacement(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer st.Close()
-	for _, owner := range []string{"alice", "bob"} {
-		if err := st.EnsureUser(owner, ""); err != nil {
-			t.Fatal(err)
-		}
-	}
 	pipe := rag.NewPipeline(st, settings.NewService(st), nil, nil)
 	auth := &projectAuthz{}
 	alice := inprocHost{owner: "alice", pluginID: "rdm", caps: hostcaps{st: st, pipe: pipe, authz: auth}}
@@ -81,9 +76,6 @@ func TestRegisteredProjectHostRejectsForeignKnowledgeSource(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer st.Close()
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
 	slot := &projectLifecycleSlot{}
 	caps := hostcaps{st: st, projects: slot}
 	if err := (pluginRegistry{pluginID: "rdm", caps: caps}).RegisterProjectLifecycle(completeLifecycle()); err != nil {
@@ -118,9 +110,6 @@ func TestProjectPublishPreservesForeignPluginAndScope(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer st.Close()
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
 	slot := &projectLifecycleSlot{}
 	caps := hostcaps{st: st, projects: slot}
 	if err := (pluginRegistry{pluginID: "rdm", caps: caps}).RegisterProjectLifecycle(completeLifecycle()); err != nil {
@@ -161,9 +150,6 @@ func TestUnregisteredPublishRetainsLegacyRefScope(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer st.Close()
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
 	if err := st.AddKnowledge(core.KnowledgeDoc{ID: "legacy", Owner: "alice", ProjectID: "old-project", Source: "manual", Ref: "same", Chunk: "legacyneedle"}); err != nil {
 		t.Fatal(err)
 	}

internal/app/local_account_test.go

@@ -1,98 +0,0 @@
-package app
-
-import (
-	"errors"
-	"path/filepath"
-	"testing"
-
-	"agent-system-backend/internal/store"
-)
-
-func TestLocalOwnerAccountCreationAndReissuePreserveIdentity(t *testing.T) {
-	dir := t.TempDir()
-	seed, err := store.OpenSQLite(filepath.Join(dir, "agent-system.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := seed.EnsureSystemIdentity("test-local-owner", "sqlite"); err != nil {
-		t.Fatal(err)
-	}
-	seed.Close()
-	bootstrap, err := BootstrapAdmin("", dir, "root", false)
-	if err != nil || bootstrap == "" {
-		t.Fatalf("bootstrap: %v", err)
-	}
-	first, _, err := CreateUserAccount("", dir, "alice", "", "", false, true, false)
-	if err != nil || first == "" {
-		t.Fatalf("local pending create: %v", err)
-	}
-	st, err := store.OpenExistingSQLite(filepath.Join(dir, "agent-system.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	account, err := st.GetAccountByOwner("alice")
-	if err != nil {
-		t.Fatal(err)
-	}
-	st.Close()
-	second, owner, err := InitializeAccount("", dir, account.ID, account.StateVersion, account.InitializationGeneration)
-	if err != nil || owner != "alice" || second == first {
-		t.Fatalf("owner reissue: owner=%s err=%v", owner, err)
-	}
-	st, err = store.OpenExistingSQLite(filepath.Join(dir, "agent-system.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	current, err := st.GetAccount(account.ID)
-	if err != nil || current.Owner != account.Owner || current.ID != account.ID || current.InitializationGeneration != account.InitializationGeneration+1 {
-		t.Fatalf("reissue changed account identity: %+v %v", current, err)
-	}
-	if _, _, err := st.RedeemLoginKey(first); err == nil {
-		t.Fatal("old activation grant survived reissue")
-	}
-	if _, _, err := st.RedeemLoginKey(second); err != nil {
-		t.Fatalf("new activation grant failed: %v", err)
-	}
-}
-
-func TestAPIKeyCLIRequiresExistingInitializedAccount(t *testing.T) {
-	dir := t.TempDir()
-	st, err := store.OpenSQLite(filepath.Join(dir, "agent-system.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := st.EnsureSystemIdentity("test-api-key-admission", "sqlite"); err != nil {
-		t.Fatal(err)
-	}
-	st.Close()
-	if _, err := CreateAPIKey("", dir, "alice", "integration"); !errors.Is(err, store.ErrNotFound) {
-		t.Fatalf("missing account was implicitly created: %v", err)
-	}
-	grant, err := BootstrapAdmin("", dir, "alice", true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := CreateAPIKey("", dir, "alice", "integration"); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("pending account received a full API key: %v", err)
-	}
-	st, err = store.OpenExistingSQLite(filepath.Join(dir, "agent-system.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	token, _, err := st.RedeemLoginKey(grant)
-	if err != nil {
-		t.Fatal(err)
-	}
-	hash, err := store.HashPassword("trusted-owner-password")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.CompleteSetPasswordChecked(token, hash); err != nil {
-		t.Fatal(err)
-	}
-	if key, err := CreateAPIKey("", dir, "alice", "integration"); err != nil || key == "" {
-		t.Fatalf("initialized account could not receive its API key: %v", err)
-	}
-}

internal/app/project_lifecycle.go

@@ -15,6 +15,7 @@ type projectLifecycleSlot struct {
 	mu       sync.Mutex
 	holder   string
 	provider *extension.ProjectLifecycle
+	settings extension.ProjectSettingsAuthorizer
 }
 
 func (r compiledRegistry) RegisterProjectLifecycle(extension.ProjectLifecycle) error {
@@ -51,8 +52,9 @@ func (slot *projectLifecycleSlot) wire(srv *server.Server, caps hostcaps) {
 	}
 	holder := slot.holder
 	srv.SetProjectLifecycle(*slot.provider, func(owner string) extension.Host {
-		return requestBoundHost{inprocHost{caps: caps, owner: owner, actor: owner, pluginID: holder}}
+		return inprocHost{caps: caps, owner: owner, actor: owner, pluginID: holder}
 	})
+	srv.SetProjectSettingsAuthorizer(slot.settings)
 }
 
 func (slot *projectLifecycleSlot) active() bool {
@@ -84,9 +86,6 @@ func (slot *projectLifecycleSlot) resolve(ctx context.Context, caps hostcaps, ow
 var _ extension.ProjectHost = inprocHost{}
 
 func (h inprocHost) OwnedProjects() ([]core.Project, error) {
-	if err := h.requireEffective(); err != nil {
-		return nil, err
-	}
 	ps, err := h.caps.st.ListProjects(h.owner)
 	for i := range ps {
 		ps[i].Owner = h.owner
@@ -94,15 +93,9 @@ func (h inprocHost) OwnedProjects() ([]core.Project, error) {
 	return ps, err
 }
 func (h inprocHost) OwnedProject(id string) (core.Project, error) {
-	if err := h.requireEffective(); err != nil {
-		return core.Project{}, err
-	}
 	return h.caps.st.GetProject(h.owner, id)
 }
 func (h inprocHost) ProjectMetadata(id string) (core.Project, error) {
-	if err := h.requireEffective(); err != nil {
-		return core.Project{}, err
-	}
 	p, err := h.caps.st.ProjectMetadata(id)
 	if err != nil {
 		return core.Project{}, err
@@ -123,29 +116,11 @@ func (h inprocHost) ProjectMetadata(id string) (core.Project, error) {
 	return p, nil
 }
 func (h inprocHost) EnsureProject(id, name string) (core.Project, error) {
-	if err := h.requireEffective(); err != nil {
-		return core.Project{}, err
-	}
-	if h.actor != "" && h.actor != h.owner {
-		return core.Project{}, store.ErrAccountForbidden
-	}
-	// A creator-scoped Host is the approved I1 projection capability. RDM
-	// authorizes a delegated operator before invoking it; cross-database
-	// commit fencing remains outside U3's guarantee.
-	return h.caps.st.EnsureProjectAccountChecked(h.owner, h.owner, id, name, h.caps.allowImplicitLocal)
+	return h.caps.st.EnsureProject(h.owner, id, name)
 }
 func (h inprocHost) RenameOwnedProject(id, name string) (core.Project, error) {
-	if err := h.requireEffective(); err != nil {
-		return core.Project{}, err
-	}
-	if h.actor != "" && h.actor != h.owner {
-		return core.Project{}, store.ErrAccountForbidden
-	}
-	return h.caps.st.RenameOwnedProjectAccountChecked(h.owner, h.owner, id, name, h.caps.allowImplicitLocal)
+	return h.caps.st.RenameOwnedProject(h.owner, id, name)
 }
 func (h inprocHost) ProjectNameAvailable(name, exceptID string) (bool, error) {
-	if err := h.requireEffective(); err != nil {
-		return false, err
-	}
 	return h.caps.st.ProjectNameAvailable(name, exceptID)
 }

internal/app/project_lifecycle_test.go

@@ -11,12 +11,7 @@ import (
 	"encoding/json"
 	"errors"
 	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
 	"testing"
-	"time"
 )
 
 func completeLifecycle() extension.ProjectLifecycle {
@@ -60,11 +55,6 @@ func TestProjectHostMetadataDoesNotGrantMutation(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer st.Close()
-	for _, owner := range []string{"alice", "bob"} {
-		if err := st.EnsureUser(owner, ""); err != nil {
-			t.Fatal(err)
-		}
-	}
 	alice := inprocHost{owner: "alice", caps: hostcaps{st: st}}
 	p, err := alice.EnsureProject("stable", "Shared")
 	if err != nil {
@@ -141,9 +131,6 @@ func TestProjectHostMetadataMasksSharedSecretsWithoutMutation(t *testing.T) {
 	srv := server.New(st, nil, nil, nil, svc, nil)
 	srv.Auth = server.NewAuthenticator(st, true)
 	slot.wire(srv, caps)
-	if err := st.EnsureUser("bob", ""); err != nil {
-		t.Fatal(err)
-	}
 	key, err := st.CreateAPIKey("bob", "test")
 	if err != nil {
 		t.Fatal(err)
@@ -174,180 +161,3 @@ func TestProjectHostMetadataMasksSharedSecretsWithoutMutation(t *testing.T) {
 		t.Fatal("metadata read mutated persisted owner settings")
 	}
 }
-
-func TestRequestBoundDelegatedProjectionFencesRealOperator(t *testing.T) {
-	st, err := store.OpenSQLite(t.TempDir() + "/delegated-project.db")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	for _, account := range []struct {
-		owner string
-		admin bool
-	}{{"admin", true}, {"alice", false}, {"bob", false}} {
-		if err := st.CreateAccount(account.owner, "", "", account.admin); err != nil {
-			t.Fatal(err)
-		}
-	}
-	project, err := st.CreateProject("alice", "original")
-	if err != nil {
-		t.Fatal(err)
-	}
-	guard := accountEffectiveAuthorization(st, true)
-	check := func(owner string) error {
-		valid, err := guard(context.Background(), owner)
-		if err != nil {
-			return err
-		}
-		if !valid {
-			return store.ErrAccountForbidden
-		}
-		return nil
-	}
-	slot := &projectLifecycleSlot{}
-	caps := hostcaps{st: st, projects: slot, accountGuard: check}
-	if err := (pluginRegistry{pluginID: "rdm", caps: caps}).RegisterProjectLifecycle(completeLifecycle()); err != nil {
-		t.Fatal(err)
-	}
-	request := requestBoundHost{inprocHost{caps: caps, pluginID: "rdm", owner: "bob", actor: "bob"}}
-	delegator, ok := any(request).(interface {
-		ProjectProjectionForCreator(creator, projectID string) (extension.ProjectHost, error)
-	})
-	if !ok {
-		t.Fatal("request-bound delegated projection capability missing")
-	}
-	projection, err := delegator.ProjectProjectionForCreator("alice", string(project.ID))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if projection.Owner() != "alice" {
-		t.Fatalf("trusted projection owner=%s", projection.Owner())
-	}
-	if _, ok := projection.(extension.Host); ok {
-		t.Fatal("single-project projection exposed broad creator Host capabilities")
-	}
-	if _, err := projection.RenameOwnedProject(string(project.ID), "delegated"); err != nil {
-		t.Fatalf("active delegated rename: %v", err)
-	}
-	if _, err := projection.RenameOwnedProject("another-project", "hijack"); !errors.Is(err, store.ErrNotFound) {
-		t.Fatalf("projection escaped bound project: %v", err)
-	}
-	if _, err := projection.EnsureProject("another-project", "hijack"); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("projection created another project: %v", err)
-	}
-	bob, err := st.GetAccountByOwner("bob")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.SetAccountEnabled("admin", bob.ID, bob.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := projection.RenameOwnedProject(string(project.ID), "late"); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled real operator renamed creator project: %v", err)
-	}
-	got, err := st.ProjectMetadata(string(project.ID))
-	if err != nil || got.Name != "delegated" {
-		t.Fatalf("late rename changed project: %+v %v", got, err)
-	}
-}
-
-func TestDelegatedProjectionRejectsDisableBetweenEarlyCheckAndWrite(t *testing.T) {
-	var st, other *store.Store
-	var err error
-	if baseDSN := os.Getenv("AGENT_PG_TEST_DSN"); baseDSN != "" {
-		st = openDirectoryTestStore(t)
-		if err := st.EnsureSystemIdentity("u3-delegated-projection", "pg"); err != nil {
-			t.Fatal(err)
-		}
-		var schema string
-		if err := st.DB().QueryRow(`SELECT current_schema()`).Scan(&schema); err != nil {
-			t.Fatal(err)
-		}
-		separator := "?"
-		if strings.Contains(baseDSN, "?") {
-			separator = "&"
-		}
-		other, err = store.OpenExistingPostgres(baseDSN+separator+"search_path="+schema+",public", filepath.Join(t.TempDir(), "other-artifacts"))
-	} else {
-		db := filepath.Join(t.TempDir(), "shared.db")
-		st, err = store.OpenSQLite(db)
-		if err == nil {
-			other, err = store.OpenExistingSQLite(db)
-		}
-		if st != nil {
-			defer st.Close()
-		}
-	}
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer other.Close()
-	for _, account := range []struct {
-		owner string
-		admin bool
-	}{{"admin", true}, {"alice", false}, {"bob", false}} {
-		if err := st.CreateAccount(account.owner, "", "", account.admin); err != nil {
-			t.Fatal(err)
-		}
-	}
-	project, err := st.CreateProject("alice", "before")
-	if err != nil {
-		t.Fatal(err)
-	}
-	entered, release := make(chan struct{}), make(chan struct{})
-	var bobChecks atomic.Int32
-	check := func(owner string) error {
-		state, err := st.GetUserAuthState(owner)
-		if err != nil {
-			return err
-		}
-		if !state.Enabled {
-			return store.ErrAccountForbidden
-		}
-		if owner == "bob" && bobChecks.Add(1) == 2 {
-			close(entered)
-			<-release
-		}
-		return nil
-	}
-	slot := &projectLifecycleSlot{}
-	caps := hostcaps{st: st, projects: slot, accountGuard: check}
-	if err := (pluginRegistry{pluginID: "rdm", caps: caps}).RegisterProjectLifecycle(completeLifecycle()); err != nil {
-		t.Fatal(err)
-	}
-	host := requestBoundHost{inprocHost{caps: caps, pluginID: "rdm", owner: "bob", actor: "bob"}}
-	projection, err := host.ProjectProjectionForCreator("alice", string(project.ID))
-	if err != nil {
-		t.Fatal(err)
-	}
-	written := make(chan error, 1)
-	go func() {
-		_, err := projection.RenameOwnedProject(string(project.ID), "late")
-		written <- err
-	}()
-	select {
-	case <-entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("rename did not reach paused early account check")
-	}
-	bob, err := st.GetAccountByOwner("bob")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := other.SetAccountEnabled("admin", bob.ID, bob.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	close(release)
-	select {
-	case err := <-written:
-		if !errors.Is(err, store.ErrAccountForbidden) {
-			t.Fatalf("late delegated rename committed: %v", err)
-		}
-	case <-time.After(3 * time.Second):
-		t.Fatal("late rename did not return")
-	}
-	got, err := st.ProjectMetadata(string(project.ID))
-	if err != nil || got.Name != "before" {
-		t.Fatalf("project changed after disable: %+v %v", got, err)
-	}
-}

internal/app/project_settings.go

@@ -0,0 +1,35 @@
+package app
+
+import (
+	"agent-system-backend/pkg/extension"
+	"errors"
+)
+
+func (r compiledRegistry) RegisterProjectSettingsAuthorizer(extension.ProjectSettingsAuthorizer) error {
+	return errors.New("extension: declarative plugins cannot register project settings authorization")
+}
+
+func (r pluginRegistry) RegisterProjectSettingsAuthorizer(fn extension.ProjectSettingsAuthorizer) error {
+	if r.caps.projects == nil || r.pluginID == "" || fn == nil {
+		return errors.New("extension: project settings authorization unavailable")
+	}
+	slot := r.caps.projects
+	slot.mu.Lock()
+	defer slot.mu.Unlock()
+	if slot.settings != nil {
+		return errors.New("extension: project settings authorization already registered")
+	}
+	if slot.provider == nil || slot.holder != r.pluginID {
+		return errors.New("extension: project settings authorizer requires the registered project provider")
+	}
+	slot.settings = fn
+	return nil
+}
+
+func (r recordRegistry) RegisterProjectSettingsAuthorizer(fn extension.ProjectSettingsAuthorizer) error {
+	optional, ok := r.Registry.(extension.ProjectSettingsRegistry)
+	if !ok {
+		return errors.New("extension: project settings authorization unavailable")
+	}
+	return optional.RegisterProjectSettingsAuthorizer(fn)
+}

internal/app/project_settings_test.go

@@ -0,0 +1,38 @@
+package app
+
+import (
+	"agent-system-backend/pkg/extension"
+	"context"
+	"testing"
+)
+
+func TestProjectSettingsOptionalRegistrationEnforcesProviderOwnership(t *testing.T) {
+	fn := func(context.Context, string, string, bool) error { return nil }
+	slot := &projectLifecycleSlot{}
+	reg := pluginRegistry{pluginID: "rdm", caps: hostcaps{projects: slot}}
+	if err := reg.RegisterProjectSettingsAuthorizer(fn); err == nil {
+		t.Fatal("settings authorizer accepted without project provider")
+	}
+	if err := reg.RegisterProjectLifecycle(completeLifecycle()); err != nil {
+		t.Fatal(err)
+	}
+	if err := (pluginRegistry{pluginID: "another", caps: hostcaps{projects: slot}}).RegisterProjectSettingsAuthorizer(fn); err == nil {
+		t.Fatal("another provider took settings authority")
+	}
+	optional, ok := any(recordRegistry{Registry: reg}).(interface {
+		RegisterProjectSettingsAuthorizer(func(context.Context, string, string, bool) error) error
+	})
+	if !ok {
+		t.Fatal("optional callback is not compatible with old-pin anonymous assertion")
+	}
+	if err := optional.RegisterProjectSettingsAuthorizer(fn); err != nil {
+		t.Fatal(err)
+	}
+	if err := reg.RegisterProjectSettingsAuthorizer(fn); err == nil {
+		t.Fatal("duplicate settings authorizer accepted")
+	}
+	if err := (compiledRegistry{}).RegisterProjectSettingsAuthorizer(fn); err == nil {
+		t.Fatal("declarative plugin took configuration authority")
+	}
+	var _ extension.ProjectSettingsRegistry = recordRegistry{}
+}

internal/app/scoped_host_test.go

@@ -24,9 +24,6 @@ func TestScopedHostFactory(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { st.Close() })
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
 	set := settings.NewService(st)
 	pipe := rag.NewPipeline(st, set, nil, nil)
 	caps := hostcaps{st: st, pipe: pipe, set: set}
@@ -42,9 +39,6 @@ func TestScopedHostFactory(t *testing.T) {
 	if h.Owner() != "alice" || h.PluginID() != "rdm" {
 		t.Fatalf("Owner/PluginID = %s/%s, want alice/rdm", h.Owner(), h.PluginID())
 	}
-	if _, ok := h.(extension.DelegatedProjectProjectionHost); ok {
-		t.Fatal("globally reconstructed Host exposed request-bound projection authority")
-	}
 	// KV 往返落 owner 作用域。
 	if err := h.KVPut("k1", "v1"); err != nil {
 		t.Fatal(err)

internal/cardsvc/account_checked.go

@@ -1,219 +0,0 @@
-package cardsvc
-
-import (
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-	"errors"
-)
-
-func (s *Service) requireAccountCheckedEmitter() error {
-	if s.emit != nil && s.accountCheckedEmit == nil {
-		return ErrGuardedEmitterRequired
-	}
-	return nil
-}
-
-func (s *Service) ResolveByRefAccountChecked(actor, ref, actionID, answer string, allowImplicitDefault bool) error {
-	if err := s.requireAccountCheckedEmitter(); err != nil {
-		return err
-	}
-	id, err := s.st.CardIDByRef(actor, ref)
-	if errors.Is(err, store.ErrNotFound) {
-		return nil
-	}
-	if err != nil {
-		return err
-	}
-	card, version, err := s.st.GetCardVersion(actor, id)
-	if err != nil {
-		return err
-	}
-	if card.Status.Terminal() {
-		return nil
-	}
-	card.Status = core.CardResolved
-	if err := s.UpdateVersionedAccountChecked(actor, card, version, allowImplicitDefault); errors.Is(err, store.ErrConflict) {
-		return nil
-	} else if err != nil {
-		return err
-	}
-	return s.emitCardAccountChecked(actor, card, core.EvCardResolved,
-		core.CardResolvedPayload{CardID: card.ID, ActionID: actionID, Answer: answer})
-}
-
-// AppendAccountChecked preserves stream-card throttling while fencing its
-// durable body update against account disable.
-func (s *Service) AppendAccountChecked(actor, id, text string, allowImplicitDefault bool) error {
-	if err := s.requireAccountCheckedEmitter(); err != nil {
-		return err
-	}
-	card, version, err := s.st.GetCardVersion(actor, id)
-	if err != nil {
-		return err
-	}
-	if text != "" {
-		if n := len(card.Body); n > 0 && card.Body[n-1].Type == core.UIMarkdown {
-			card.Body[n-1].Markdown += text
-		} else {
-			card.Body = append(card.Body, core.UINode{Type: core.UIMarkdown, Markdown: text})
-		}
-	}
-	card.UpdatedAt = s.now().UTC()
-	if err := s.st.SaveCardVersionedAccountChecked(actor, &card, "", version, allowImplicitDefault); err != nil {
-		return err
-	}
-	if card.ConversationID == "" && card.ProjectID == "" {
-		return nil
-	}
-	s.emitMu.Lock()
-	last, seen := s.lastEmit[id]
-	emit := !seen || s.now().Sub(last) >= cardAppendWindow
-	if emit {
-		s.lastEmit[id] = s.now()
-	}
-	s.emitMu.Unlock()
-	if !emit {
-		return nil
-	}
-	return s.emitCardAccountChecked(actor, card, core.EvCardUpdated, core.CardPayload{Card: card})
-}
-
-func (s *Service) emitCardAccountChecked(actor string, card core.ActivityCard, typ core.StreamEventType, payload any) error {
-	if s.accountCheckedEmit == nil || (card.ConversationID == "" && card.ProjectID == "") {
-		return nil
-	}
-	if card.ConversationID != "" {
-		if err := s.accountCheckedEmit(actor, card.ConversationID, card.SourceRunID, typ, payload); err != nil {
-			return err
-		}
-		if !s.MirrorConvCards {
-			return nil
-		}
-	}
-	if card.ProjectID != "" {
-		return s.accountCheckedEmit(actor, string(core.ProjectChannelKey(card.ProjectID)), card.SourceRunID, typ, payload)
-	}
-	return nil
-}
-
-// CreateAccountChecked creates a card under the actor's final Store fence.
-func (s *Service) CreateAccountChecked(actor string, card core.ActivityCard, ref string, allowImplicitDefault bool) (core.ActivityCard, error) {
-	if err := s.requireAccountCheckedEmitter(); err != nil {
-		return card, err
-	}
-	if card.ID == "" {
-		card.ID = store.NewID("card")
-	}
-	now := s.now().UTC()
-	card.CreatedAt, card.UpdatedAt = now, now
-	if card.Status == "" {
-		card.Status = core.CardActive
-	}
-	if err := s.st.SaveCardAccountChecked(actor, &card, ref, allowImplicitDefault); err != nil {
-		return card, err
-	}
-	return card, s.emitCardAccountChecked(actor, card, core.EvCardCreated, core.CardPayload{Card: card})
-}
-
-func (s *Service) updateVersionedAccountChecked(actor string, card core.ActivityCard, expectedVersion int, allowImplicitDefault bool) (core.ActivityCard, error) {
-	if err := s.requireAccountCheckedEmitter(); err != nil {
-		return card, err
-	}
-	card.UpdatedAt = s.now().UTC()
-	if err := s.st.SaveCardVersionedAccountChecked(actor, &card, "", expectedVersion, allowImplicitDefault); err != nil {
-		return card, err
-	}
-	return card, s.emitCardAccountChecked(actor, card, core.EvCardUpdated, core.CardPayload{Card: card})
-}
-
-func (s *Service) UpdateVersionedAccountChecked(actor string, card core.ActivityCard, expectedVersion int, allowImplicitDefault bool) error {
-	_, err := s.updateVersionedAccountChecked(actor, card, expectedVersion, allowImplicitDefault)
-	return err
-}
-
-func (s *Service) SetPinnedAccountChecked(actor, id string, pinned, allowImplicitDefault bool) (core.ActivityCard, error) {
-	card, version, err := s.st.GetCardVersion(actor, id)
-	if err != nil {
-		return card, err
-	}
-	card.Pinned = pinned
-	card, err = s.updateVersionedAccountChecked(actor, card, version, allowImplicitDefault)
-	if err != nil {
-		return card, err
-	}
-	return card, nil
-}
-
-func (s *Service) SetStatusAccountChecked(actor, id string, status core.CardStatus, tone, note string, allowImplicitDefault bool) (core.ActivityCard, error) {
-	card, version, err := s.st.GetCardVersion(actor, id)
-	if err != nil {
-		return card, err
-	}
-	card.Status = status
-	if tone != "" {
-		card.Tone = tone
-	}
-	card, err = s.updateVersionedAccountChecked(actor, card, version, allowImplicitDefault)
-	if err != nil {
-		return card, err
-	}
-	return card, s.emitCardAccountChecked(actor, card, core.EvCardStatus,
-		core.CardStatusPayload{CardID: card.ID, Status: status, Tone: card.Tone, Note: note})
-}
-
-func (s *Service) DismissAccountChecked(actor, id string, allowImplicitDefault bool) (core.ActivityCard, error) {
-	return s.SetStatusAccountChecked(actor, id, core.CardDismissed, "", "dismissed by user", allowImplicitDefault)
-}
-
-func (s *Service) ActionAccountChecked(actor, id, actionID, freeText string, allowImplicitDefault bool) (core.ActivityCard, string, error) {
-	card, version, err := s.st.GetCardVersion(actor, id)
-	if err != nil {
-		return card, "", err
-	}
-	if card.Status != core.CardActionRequired {
-		return card, "", ErrNotAwaiting
-	}
-	label, found := actionID, false
-	for _, action := range card.Actions {
-		if action.ID == actionID {
-			label, found = action.Label, true
-			break
-		}
-	}
-	if !found {
-		if actionID == "" && freeText != "" {
-			label = freeText
-		} else {
-			return card, "", ErrNoAction
-		}
-	}
-	card.Status = core.CardResolved
-	card, err = s.updateVersionedAccountChecked(actor, card, version, allowImplicitDefault)
-	if err != nil {
-		return card, "", err
-	}
-	err = s.emitCardAccountChecked(actor, card, core.EvCardResolved,
-		core.CardResolvedPayload{CardID: card.ID, ActionID: actionID, Answer: freeText})
-	return card, label, err
-}
-
-// ToProjectAccountChecked performs the copy and dismissal in one transaction.
-// Events are published after commit through the actor-aware event sink.
-func (s *Service) ToProjectAccountChecked(actor, id string, allowImplicitDefault bool) (core.ActivityCard, error) {
-	if err := s.requireAccountCheckedEmitter(); err != nil {
-		return core.ActivityCard{}, err
-	}
-	archived, origin, created, err := s.st.ArchiveCardToProjectAccountChecked(actor, id, s.now().UTC(), allowImplicitDefault)
-	if err != nil || !created {
-		return archived, err
-	}
-	if err := s.emitCardAccountChecked(actor, archived, core.EvCardCreated, core.CardPayload{Card: archived}); err != nil {
-		return archived, err
-	}
-	if err := s.emitCardAccountChecked(actor, origin, core.EvCardUpdated, core.CardPayload{Card: origin}); err != nil {
-		return archived, err
-	}
-	err = s.emitCardAccountChecked(actor, origin, core.EvCardStatus,
-		core.CardStatusPayload{CardID: origin.ID, Status: core.CardDismissed, Tone: origin.Tone, Note: "已留档到项目"})
-	return archived, err
-}

internal/cardsvc/account_checked_test.go

@@ -1,109 +0,0 @@
-package cardsvc
-
-import (
-	"errors"
-	"testing"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-func TestAccountCheckedCardActionsUseActorEventSinkAndRespectDisable(t *testing.T) {
-	st, err := store.OpenSQLite(t.TempDir() + "/cards.db")
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { st.Close() })
-	if err := st.CreateAccount("admin", "", "", true); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("alice", "", "", false); err != nil {
-		t.Fatal(err)
-	}
-	project, err := st.CreateProject("alice", "cards")
-	if err != nil {
-		t.Fatal(err)
-	}
-	conv, err := st.CreateConversation("alice", project.ID, "cards", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	legacyCalls := 0
-	svc := New(st, func(string, string, core.StreamEventType, any) error {
-		legacyCalls++
-		return nil
-	})
-	type emitted struct {
-		actor, channel string
-		typ            core.StreamEventType
-	}
-	var guarded []emitted
-	svc.SetAccountCheckedEmitter(func(actor, channel, runID string, typ core.StreamEventType, payload any) error {
-		guarded = append(guarded, emitted{actor, channel, typ})
-		return nil
-	})
-	base := core.ActivityCard{ProjectID: project.ID, ConversationID: conv.ID, Title: "Action",
-		Status: core.CardActionRequired, Actions: []core.UIAction{{ID: "yes", Label: "Approve"}}}
-	action, err := svc.CreateAccountChecked("alice", base, "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, label, err := svc.ActionAccountChecked("alice", action.ID, "yes", "", false); err != nil || label != "Approve" {
-		t.Fatalf("guarded action: label=%q err=%v", label, err)
-	}
-	pending, err := svc.CreateAccountChecked("alice", base, "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	pin, err := svc.CreateAccountChecked("alice", core.ActivityCard{ProjectID: project.ID, ConversationID: conv.ID, Title: "Pin"}, "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := svc.SetPinnedAccountChecked("alice", pin.ID, true, false); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := svc.DismissAccountChecked("alice", pin.ID, false); err != nil {
-		t.Fatal(err)
-	}
-	archive, err := svc.CreateAccountChecked("alice", core.ActivityCard{ProjectID: project.ID, ConversationID: conv.ID, Title: "Archive"}, "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	archived, err := svc.ToProjectAccountChecked("alice", archive.ID, false)
-	if err != nil || archived.ConversationID != "" {
-		t.Fatalf("guarded archive: %+v %v", archived, err)
-	}
-	if legacyCalls != 0 {
-		t.Fatalf("guarded card operations used unguarded emitter %d times", legacyCalls)
-	}
-	if len(guarded) == 0 {
-		t.Fatal("guarded operations published no events")
-	}
-	for _, event := range guarded {
-		if event.actor != "alice" {
-			t.Fatalf("event actor lost: %+v", event)
-		}
-	}
-	before := len(guarded)
-	account, err := st.GetAccountByOwner("alice")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	for _, mutate := range []func() error{
-		func() error { _, err := svc.CreateAccountChecked("alice", base, "", false); return err },
-		func() error { _, _, err := svc.ActionAccountChecked("alice", pending.ID, "yes", "", false); return err },
-		func() error { _, err := svc.SetPinnedAccountChecked("alice", pin.ID, false, false); return err },
-		func() error { _, err := svc.DismissAccountChecked("alice", pin.ID, false); return err },
-		func() error { _, err := svc.ToProjectAccountChecked("alice", archive.ID, false); return err },
-	} {
-		if err := mutate(); !errors.Is(err, store.ErrAccountForbidden) {
-			t.Fatalf("disabled actor mutated card: %v", err)
-		}
-	}
-	if len(guarded) != before {
-		t.Fatalf("disabled actor published %d events", len(guarded)-before)
-	}
-}

internal/cardsvc/cardsvc.go

@@ -17,26 +17,19 @@ import (
 // 获得持久化、seq 排序、断线重放与终态对账（Stream 契约）。
 type Emitter func(conversationID, runID string, typ core.StreamEventType, payload any) error
 
-// AccountCheckedEmitter persists an actor-attributed event through its own
-// final account-checked Store transaction. The card write and event emission
-// are separate commits; the application wires this to its guarded event sink.
-type AccountCheckedEmitter func(actor, conversationID, runID string, typ core.StreamEventType, payload any) error
-
 var (
-	ErrNotFound               = store.ErrNotFound // 语义对齐存储层：跨租户/不存在一律 NotFound
-	ErrNoAction               = errors.New("card: action not found")
-	ErrNotAwaiting            = errors.New("card: not awaiting action")
-	ErrGuardedEmitterRequired = errors.New("card: account-checked emitter required")
+	ErrNotFound    = store.ErrNotFound // 语义对齐存储层：跨租户/不存在一律 NotFound
+	ErrNoAction    = errors.New("card: action not found")
+	ErrNotAwaiting = errors.New("card: not awaiting action")
 )
 
 // cardAppendWindow 是流式追加（Append）的 card.updated 发布节流窗口（D45）。
 const cardAppendWindow = 250 * time.Millisecond
 
 type Service struct {
-	st                 *store.Store
-	emit               Emitter
-	accountCheckedEmit AccountCheckedEmitter
-	projectSharedEmit  ProjectSharedEmitter
+	st                *store.Store
+	emit              Emitter
+	projectSharedEmit ProjectSharedEmitter
 	// MirrorConvCards EXT-12：会话卡是否镜像进项目公共流（缺省 true=现状全量
 	// 镜像；false 时会话卡只进本人会话流，项目级卡不受影响）。
 	MirrorConvCards bool
@@ -49,10 +42,6 @@ func New(st *store.Store, emit Emitter) *Service {
 	return &Service{st: st, emit: emit, now: time.Now, lastEmit: map[string]time.Time{}, MirrorConvCards: true}
 }
 
-func (s *Service) SetAccountCheckedEmitter(emit AccountCheckedEmitter) {
-	s.accountCheckedEmit = emit
-}
-
 // ProjectSharedEmitter is an internal trusted publication adapter. It is never
 // bound to model arguments or exposed as a mandatory extension capability.
 type ProjectSharedEmitter func(owner, producer, channel, runID string, typ core.StreamEventType, payload any) error

internal/cmdbus/account_guard_test.go

@@ -1,169 +0,0 @@
-package cmdbus
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-
-	agentcommand "agent-command"
-)
-
-func TestEffectiveAccountGuardRejectsBeforeDispatchEffects(t *testing.T) {
-	for _, tc := range []struct {
-		name string
-		req  Request
-		err  error
-		want string
-	}{
-		{"disabled handler", Request{ID: "demo.ping", Owner: "alice", Actor: "alice"}, errors.New("disabled"), "alice"},
-		{"failed lookup", Request{ID: "demo.ping", Owner: "alice", Actor: "alice"}, errors.New("database unavailable"), "alice"},
-		{"plugin actor uses account owner", Request{ID: "demo.ping", Owner: "alice", Actor: "plugin:rdm"}, errors.New("disabled"), "alice"},
-		{"actor fallback", Request{ID: "demo.ping", Actor: "alice"}, errors.New("disabled"), "alice"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			audit, cards := &memAudit{}, &memCards{}
-			b := newTestBus(audit, cards)
-			called := 0
-			b.SetEffectiveAccountGuard(func(_ context.Context, actor string) error {
-				called++
-				if actor != tc.want {
-					t.Fatalf("guard actor = %q, want %q", actor, tc.want)
-				}
-				return tc.err
-			})
-			resp := b.Dispatch(context.Background(), tc.req)
-			if resp.Receipt.State != agentcommand.StateRejected || !strings.Contains(resp.Receipt.Reason, "effective account") {
-				t.Fatalf("guard rejection: %+v", resp.Receipt)
-			}
-			if called != 1 || len(audit.logs) != 0 || len(cards.created) != 0 {
-				t.Fatalf("guard calls=%d audits=%d cards=%d", called, len(audit.logs), len(cards.created))
-			}
-		})
-	}
-}
-
-func TestEffectiveAccountGuardRejectsBeforePendingConfirmAndRechecks(t *testing.T) {
-	audit, cards := &memAudit{}, &memCards{}
-	b := newTestBus(audit, cards)
-	allowed := false
-	b.SetEffectiveAccountGuard(func(_ context.Context, actor string) error {
-		if actor != "alice" {
-			t.Fatalf("guard actor = %q", actor)
-		}
-		if !allowed {
-			return errors.New("disabled")
-		}
-		return nil
-	})
-	req := Request{ID: "demo.risky", Owner: "alice", Actor: "alice", ConversationID: "cnv_1", Params: map[string]any{"target": "prod"}}
-	if r := b.Dispatch(context.Background(), req); r.Receipt.State != agentcommand.StateRejected {
-		t.Fatalf("disabled dispatch: %+v", r.Receipt)
-	}
-	if len(cards.created) != 0 || len(b.pending) != 0 || len(audit.logs) != 0 {
-		t.Fatal("disabled dispatch created confirmation effects")
-	}
-	allowed = true
-	r := b.Dispatch(context.Background(), req)
-	if r.Receipt.State != agentcommand.StateAccepted || len(cards.created) != 1 || len(b.pending) != 1 {
-		t.Fatalf("enabled dispatch: %+v", r.Receipt)
-	}
-	allowed = false
-	before := len(audit.logs)
-	if r := b.Confirm("alice", "card_x1", "confirm"); r.Receipt.State != agentcommand.StateRejected {
-		t.Fatalf("disabled confirm: %+v", r.Receipt)
-	}
-	if len(b.pending) != 1 || len(audit.logs) != before {
-		t.Fatal("disabled confirm consumed pending request or wrote audit")
-	}
-	allowed = true
-	if r := b.Confirm("alice", "card_x1", "confirm"); r.Receipt.State != agentcommand.StateCommitted {
-		t.Fatalf("re-enabled confirm: %+v", r.Receipt)
-	}
-}
-
-func TestEffectiveAccountGuardStopsConfirmedHandlerAfterStateChanges(t *testing.T) {
-	b := New(&memAudit{}, &memCards{}, nil)
-	executed := 0
-	if err := b.RegisterPluginCommand(agentcommand.CommandSpec{ID: "demo.effect", Title: "Effect"}, func(context.Context, Request) (any, error) {
-		executed++
-		return "done", nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-	checks := 0
-	b.SetEffectiveAccountGuard(func(_ context.Context, actor string) error {
-		checks++
-		if actor != "alice" {
-			t.Fatalf("guard actor = %q", actor)
-		}
-		if checks == 4 {
-			return errors.New("disabled after confirmation started")
-		}
-		return nil
-	})
-	// Confirm passes its own check, then Dispatch must check once more before
-	// invoking the handler. A direct confirmed request takes the same path.
-	if err := b.RegisterBuiltin(agentcommand.CommandSpec{ID: "demo.high", Title: "High", Danger: agentcommand.DangerHigh}, "", func(context.Context, Request) (any, error) {
-		executed++
-		return "done", nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-	r := b.Dispatch(context.Background(), Request{ID: "demo.high", Owner: "alice", ConversationID: "cnv_1"})
-	if r.Receipt.State != agentcommand.StateAccepted {
-		t.Fatalf("initial dispatch: %+v", r.Receipt)
-	}
-	// Dispatch checks again before creating the confirmation card. Confirm's
-	// check passes; its nested Dispatch catches the fourth-state change.
-	if r := b.Confirm("alice", "card_x1", "confirm"); r.Receipt.State != agentcommand.StateRejected {
-		t.Fatalf("confirm after disable: %+v", r.Receipt)
-	}
-	if executed != 0 || len(b.pending) != 0 {
-		t.Fatalf("executed=%d pending=%d", executed, len(b.pending))
-	}
-	// Direct confirmed execution also passes through the same guard.
-	checks = 3
-	if r := b.Dispatch(context.Background(), Request{ID: "demo.effect", Owner: "alice", Confirmed: true}); r.Receipt.State != agentcommand.StateRejected || executed != 0 {
-		t.Fatalf("direct confirmed dispatch: %+v executed=%d", r.Receipt, executed)
-	}
-}
-
-type trackingPendingStore struct {
-	owner, payload string
-	takes          int
-}
-
-func (p *trackingPendingStore) SavePendingConfirm(_ string, owner, payload string) error {
-	p.owner, p.payload = owner, payload
-	return nil
-}
-func (p *trackingPendingStore) TakePendingConfirm(string) (string, string, bool, error) {
-	p.takes++
-	return p.owner, p.payload, p.payload != "", nil
-}
-
-func TestEffectiveAccountGuardDoesNotConsumeStoredPendingOnDeniedConfirm(t *testing.T) {
-	b := newTestBus(&memAudit{}, &memCards{})
-	pendingStorage := &trackingPendingStore{}
-	b.SetPendingStore(pendingStorage)
-	allowed := true
-	b.SetEffectiveAccountGuard(func(_ context.Context, actor string) error {
-		if actor != "alice" {
-			t.Fatalf("guard actor = %q", actor)
-		}
-		if !allowed {
-			return errors.New("database unavailable")
-		}
-		return nil
-	})
-	r := b.Dispatch(context.Background(), Request{ID: "demo.risky", Owner: "alice", ConversationID: "cnv_1", Params: map[string]any{"target": "prod"}})
-	if r.Receipt.State != agentcommand.StateAccepted || pendingStorage.payload == "" {
-		t.Fatalf("pending setup: %+v", r.Receipt)
-	}
-	b.pending = map[string]pending{} // force the restored path
-	allowed = false
-	if r := b.Confirm("alice", "card_x1", "confirm"); r.Receipt.State != agentcommand.StateRejected || pendingStorage.takes != 0 {
-		t.Fatalf("denied confirm: %+v takes=%d", r.Receipt, pendingStorage.takes)
-	}
-}

internal/cmdbus/account_write_fence_test.go

@@ -1,18 +0,0 @@
-package cmdbus
-
-import (
-	"context"
-	"testing"
-
-	agentcommand "agent-command"
-)
-
-func TestStrictAccountWritesRejectLegacyBusPorts(t *testing.T) {
-	audit, cards := &memAudit{}, &memCards{}
-	b := newTestBus(audit, cards)
-	b.RequireAccountCheckedWrites(false)
-	resp := b.Dispatch(context.Background(), Request{ID: "demo.risky", Owner: "alice", Actor: "alice", ConversationID: "cnv_1", Params: map[string]any{"target": "prod"}})
-	if resp.Receipt.State != agentcommand.StateUnknown || len(cards.created) != 0 || len(audit.logs) != 0 || len(b.pending) != 0 {
-		t.Fatalf("legacy port wrote under strict mode: %+v, cards=%d audit=%d pending=%d", resp.Receipt, len(cards.created), len(audit.logs), len(b.pending))
-	}
-}

internal/cmdbus/cmdbus.go

@@ -49,13 +49,6 @@ type CommandTool struct {
 // 不投影给该 owner 的模型。组合根按需装配（如 generative-ui 按 activation 台账）。
 type ToolGate func(owner, commandID string) bool
 
-// EffectiveAccountGuard checks the current account state before a command can
-// create a confirmation or invoke a handler. The composition root supplies the
-// check; nil keeps standalone and auth-off fixtures unchanged. The actor is
-// derived only from trusted Request identity fields, never Params. This is an
-// early check, not an atomic fence across handler databases or external calls.
-type EffectiveAccountGuard func(ctx context.Context, actor string) error
-
 // SetToolGate 装配 owner 级注入闸（组合根；启动期一次）。
 func (b *Bus) SetToolGate(g ToolGate) { b.toolGate = g }
 
@@ -115,20 +108,17 @@ type pending struct {
 }
 
 type Bus struct {
-	reg                 *agentcommand.Registry
-	audit               AuditStore
-	cards               CardPort
-	now                 func() time.Time
-	handlers            map[string]Handler
-	slash               map[string]string // "/x" → command id
-	pendMu              sync.Mutex
-	pending             map[string]pending
-	pendingStore        PendingStore
-	intents             *IntentStore          // G2-2：意图声明表（自然语言路由）
-	toolGate            ToolGate              // U3：owner 级工具注入闸（nil = 不过滤）
-	accountGuard        EffectiveAccountGuard // A1: optional command execution precheck
-	strictAccountWrites bool
-	allowImplicitLocal  bool
+	reg          *agentcommand.Registry
+	audit        AuditStore
+	cards        CardPort
+	now          func() time.Time
+	handlers     map[string]Handler
+	slash        map[string]string // "/x" → command id
+	pendMu       sync.Mutex
+	pending      map[string]pending
+	pendingStore PendingStore
+	intents      *IntentStore // G2-2：意图声明表（自然语言路由）
+	toolGate     ToolGate     // U3：owner 级工具注入闸（nil = 不过滤）
 }
 
 // PendingStore 把危险命令的确认挂起态落盘。进程内 map 仍是热路径；重启后从存储取回。
@@ -154,70 +144,6 @@ func (b *Bus) Registry() *agentcommand.Registry { return b.reg }
 // SetPendingStore 注入确认挂起态的持久化实现（nil = 仅进程内）。
 func (b *Bus) SetPendingStore(st PendingStore) { b.pendingStore = st }
 
-// SetEffectiveAccountGuard installs the composition-root check at startup.
-// Handler Store writes still need their own final transaction fence.
-func (b *Bus) SetEffectiveAccountGuard(g EffectiveAccountGuard) { b.accountGuard = g }
-
-// RequireAccountCheckedWrites makes every Bus-owned durable sink use a final
-// account transaction. The composition root enables this after wiring Store
-// and Cards; standalone in-memory fixtures retain their legacy ports.
-func (b *Bus) RequireAccountCheckedWrites(allowImplicitLocal bool) {
-	b.strictAccountWrites = true
-	b.allowImplicitLocal = allowImplicitLocal
-}
-
-func (b *Bus) createConfirmCard(actor string, card core.ActivityCard, ref string) (core.ActivityCard, error) {
-	if !b.strictAccountWrites {
-		return b.cards.Create(actor, card, ref)
-	}
-	checked, ok := b.cards.(interface {
-		CreateAccountChecked(string, core.ActivityCard, string, bool) (core.ActivityCard, error)
-	})
-	if !ok {
-		return core.ActivityCard{}, fmt.Errorf("cmdbus: account-checked card port required")
-	}
-	return checked.CreateAccountChecked(actor, card, ref, b.allowImplicitLocal)
-}
-
-func (b *Bus) setConfirmCardStatus(actor, id string, status core.CardStatus, tone, note string) (core.ActivityCard, error) {
-	if !b.strictAccountWrites {
-		return b.cards.SetStatus(actor, id, status, tone, note)
-	}
-	checked, ok := b.cards.(interface {
-		SetStatusAccountChecked(string, string, core.CardStatus, string, string, bool) (core.ActivityCard, error)
-	})
-	if !ok {
-		return core.ActivityCard{}, fmt.Errorf("cmdbus: account-checked card port required")
-	}
-	return checked.SetStatusAccountChecked(actor, id, status, tone, note, b.allowImplicitLocal)
-}
-
-func (b *Bus) savePending(cardID, owner, payload string) error {
-	if !b.strictAccountWrites {
-		return b.pendingStore.SavePendingConfirm(cardID, owner, payload)
-	}
-	checked, ok := b.pendingStore.(interface {
-		SavePendingConfirmAccountChecked(string, string, string, bool) error
-	})
-	if !ok {
-		return fmt.Errorf("cmdbus: account-checked pending store required")
-	}
-	return checked.SavePendingConfirmAccountChecked(cardID, owner, payload, b.allowImplicitLocal)
-}
-
-func (b *Bus) takePending(cardID, owner string) (string, string, bool, error) {
-	if !b.strictAccountWrites {
-		return b.pendingStore.TakePendingConfirm(cardID)
-	}
-	checked, ok := b.pendingStore.(interface {
-		TakePendingConfirmAccountChecked(string, string, bool) (string, string, bool, error)
-	})
-	if !ok {
-		return "", "", false, fmt.Errorf("cmdbus: account-checked pending store required")
-	}
-	return checked.TakePendingConfirmAccountChecked(cardID, owner, b.allowImplicitLocal)
-}
-
 // RegisterBuiltin 登记内置命令并绑定宿主处理器与 `/` 别名。
 func (b *Bus) RegisterBuiltin(spec agentcommand.CommandSpec, slash string, h Handler) error {
 	spec.Binding = agentcommand.Binding{Kind: agentcommand.BindBuiltin}
@@ -316,16 +242,10 @@ func (b *Bus) HasCommand(id string) bool {
 // List 四入口共享的命令清单（`/` 菜单、按钮、卡片 action 提示用）。
 func (b *Bus) List() []agentcommand.Registered { return b.reg.List() }
 
-// Dispatch 统一分发：账号预检→校验→危险收口→执行→审计。账号预检拒绝只返回回执，
-// 避免停用账号或检查故障时继续写入审计；其余路径维持四入口审计对称。
+// Dispatch 统一分发：校验→危险收口→执行→审计。任何路径都产出回执与审计（入口对称）。
 func (b *Bus) Dispatch(ctx context.Context, req Request) Response {
 	start := b.now()
 	req.Entrance = agentcommand.CanonicalEntrance(req.Entrance)
-	if err := b.checkEffectiveAccount(ctx, accountActor(req)); err != nil {
-		// A rejected account cannot create a card, pending row, audit row, or
-		// invoke a handler. A failed read is also a denial.
-		return b.accountRejected(req.ID, start)
-	}
 	receipt := func(state agentcommand.ResultState, op, reason string) Response {
 		return Response{Receipt: b.auditReceipt(req, state, op, reason, start)}
 	}
@@ -341,24 +261,17 @@ func (b *Bus) Dispatch(ctx context.Context, req Request) Response {
 		if b.cards == nil || req.ConversationID == "" {
 			return receipt(agentcommand.StateRejected, "", "high-danger command requires conversation context for inline confirm")
 		}
-		if err := b.checkEffectiveAccount(ctx, accountActor(req)); err != nil {
-			return b.accountRejected(req.ID, start)
-		}
-		card, err := b.createConfirmCard(accountActor(req), confirmCard(spec, req), "cmd:"+spec.ID)
+		card, err := b.cards.Create(req.Owner, confirmCard(spec, req), "cmd:"+spec.ID)
 		if err != nil {
 			return receipt(agentcommand.StateUnknown, "", "confirm card: "+err.Error())
 		}
-		if b.pendingStore != nil {
-			raw, _ := json.Marshal(req)
-			if err := b.savePending(card.ID, accountActor(req), string(raw)); err != nil {
-				return receipt(agentcommand.StateUnknown, "", "confirm pending: "+err.Error())
-			}
-		} else if b.strictAccountWrites {
-			return receipt(agentcommand.StateUnknown, "", "confirm pending: account-checked store required")
-		}
 		b.pendMu.Lock()
 		b.pending[card.ID] = pending{req: req, cardID: card.ID}
 		b.pendMu.Unlock()
+		if b.pendingStore != nil {
+			raw, _ := json.Marshal(req)
+			_ = b.pendingStore.SavePendingConfirm(card.ID, req.Owner, string(raw))
+		}
 		r := b.auditReceipt(req, agentcommand.StateAccepted, card.ID, "awaiting explicit confirm", start)
 		return Response{Receipt: r, Card: &card}
 	}
@@ -366,9 +279,6 @@ func (b *Bus) Dispatch(ctx context.Context, req Request) Response {
 	if !ok {
 		return receipt(agentcommand.StateRejected, "", "no host handler bound for "+req.ID)
 	}
-	if err := b.checkEffectiveAccount(ctx, accountActor(req)); err != nil {
-		return b.accountRejected(req.ID, start)
-	}
 	payload, err := h(ctx, req)
 	if err != nil {
 		return receipt(agentcommand.StateRejected, "", "rejected: "+err.Error())
@@ -379,98 +289,49 @@ func (b *Bus) Dispatch(ctx context.Context, req Request) Response {
 
 // Confirm 确认卡回道：actionID=confirm 执行挂起请求（entrance 归一 card），其余视为取消。
 func (b *Bus) Confirm(owner, cardID, actionID string) Response {
-	return b.ConfirmContext(context.Background(), owner, cardID, actionID)
-}
-
-// ConfirmContext carries the request cancellation through the confirmed
-// handler and repeats the account check before consuming durable state.
-func (b *Bus) ConfirmContext(ctx context.Context, owner, cardID, actionID string) Response {
-	// The caller supplies the authenticated card owner. Check before even
-	// consuming a persisted pending request; Dispatch checks the stored
-	// request again immediately before executing its handler.
-	if err := b.checkEffectiveAccount(ctx, owner); err != nil {
-		return b.accountRejected("unknown", b.now())
-	}
 	b.pendMu.Lock()
 	p, ok := b.pending[cardID]
-	b.pendMu.Unlock()
-	if ok && p.req.Owner != "" && p.req.Owner != owner {
-		return Response{Receipt: agentcommand.ExecReceipt{CommandID: p.req.ID, State: agentcommand.StateRejected, Reason: "confirm owner mismatch", Time: b.now().UTC()}}
+	if ok && actionID == "confirm" {
+		delete(b.pending, cardID)
 	}
-	if b.pendingStore != nil {
-		storedOwner, payload, found, err := b.takePending(cardID, owner)
-		if err != nil {
-			return b.accountRejected("unknown", b.now())
-		}
-		if found {
+	b.pendMu.Unlock()
+	if ok && actionID == "confirm" && b.pendingStore != nil {
+		_, _, _, _ = b.pendingStore.TakePendingConfirm(cardID)
+	}
+	if !ok && b.pendingStore != nil {
+		_, payload, found, err := b.pendingStore.TakePendingConfirm(cardID)
+		if err == nil && found {
 			var req Request
-			if storedOwner != owner || json.Unmarshal([]byte(payload), &req) != nil {
-				return Response{Receipt: agentcommand.ExecReceipt{CommandID: "unknown", State: agentcommand.StateRejected, Reason: "invalid pending confirm", Time: b.now().UTC()}}
+			if json.Unmarshal([]byte(payload), &req) == nil {
+				p = pending{req: req, cardID: cardID}
+				ok = true
 			}
-			p = pending{req: req, cardID: cardID}
-			ok = true
-		} else if b.strictAccountWrites {
-			ok = false
 		}
-	} else if b.strictAccountWrites {
-		ok = false
 	}
 	if !ok {
 		return Response{Receipt: agentcommand.ExecReceipt{CommandID: "unknown", State: agentcommand.StateRejected, Reason: "no pending confirm (expired or already resolved)", Time: b.now().UTC()}}
 	}
 	req := p.req
-	if req.Owner != "" && req.Owner != owner {
-		return Response{Receipt: agentcommand.ExecReceipt{CommandID: req.ID, State: agentcommand.StateRejected, Reason: "confirm owner mismatch", Time: b.now().UTC()}}
-	}
-	b.pendMu.Lock()
-	delete(b.pending, cardID)
-	b.pendMu.Unlock()
 	req.Confirmed = true
 	req.Entrance = "card"
 	if actionID != "confirm" {
 		if b.cards != nil {
-			_, _ = b.setConfirmCardStatus(owner, cardID, core.CardResolved, "muted", "cancelled")
+			_, _ = b.cards.SetStatus(owner, cardID, core.CardResolved, "muted", "cancelled")
 		}
 		start := b.now()
 		return Response{Receipt: b.auditReceipt(req, agentcommand.StateRejected, "", "cancelled at confirm card", start)}
 	}
-	resp := b.Dispatch(ctx, req)
+	resp := b.Dispatch(context.Background(), req)
 	if b.cards != nil {
 		if resp.Receipt.State == agentcommand.StateCommitted {
-			_, _ = b.setConfirmCardStatus(owner, cardID, core.CardResolved, "ok", "confirmed")
+			_, _ = b.cards.SetStatus(owner, cardID, core.CardResolved, "ok", "confirmed")
 		} else {
-			_, _ = b.setConfirmCardStatus(owner, cardID, core.CardFailed, "danger", resp.Receipt.Reason)
+			_, _ = b.cards.SetStatus(owner, cardID, core.CardFailed, "danger", resp.Receipt.Reason)
 		}
 	}
 	return resp
 }
 
-func accountActor(req Request) string {
-	// Plugin and delegated commands use Actor for an audit label such as a
-	// plugin ID; Owner is the effective account whose state controls effects.
-	if req.Owner != "" {
-		return req.Owner
-	}
-	return req.Actor
-}
-
-func (b *Bus) checkEffectiveAccount(ctx context.Context, actor string) error {
-	if err := ctx.Err(); err != nil {
-		return err
-	}
-	if b.accountGuard == nil {
-		return nil
-	}
-	return b.accountGuard(ctx, actor)
-}
-
-func (b *Bus) accountRejected(commandID string, start time.Time) Response {
-	return Response{Receipt: agentcommand.ExecReceipt{
-		CommandID: commandID, State: agentcommand.StateRejected,
-		Reason: "effective account unavailable", Time: start.UTC(),
-	}}
-}
-
 func (b *Bus) auditReceipt(req Request, state agentcommand.ResultState, op, reason string, start time.Time) agentcommand.ExecReceipt {
 	env := agentcommand.AuditEnvelope{
 		Time: start.UTC(), Actor: req.Actor, CommandID: req.ID, Entrance: agentcommand.CanonicalEntrance(req.Entrance),
@@ -480,20 +341,7 @@ func (b *Bus) auditReceipt(req Request, state agentcommand.ResultState, op, reas
 	if _, src, err := b.reg.Resolve(req.ID); err == nil {
 		env.Source = src
 	}
-	var err error
-	if b.strictAccountWrites {
-		checked, ok := b.audit.(interface {
-			AppendAuditAccountChecked(string, agentcommand.AuditEnvelope, bool) error
-		})
-		if !ok {
-			err = fmt.Errorf("cmdbus: account-checked audit store required")
-		} else {
-			err = checked.AppendAuditAccountChecked(accountActor(req), env, b.allowImplicitLocal)
-		}
-	} else {
-		err = b.audit.AppendAudit(req.Owner, env)
-	}
-	if err != nil {
+	if err := b.audit.AppendAudit(req.Owner, env); err != nil {
 		// 审计不可用：结果标记未知，不臆断成功（四态语义）。
 		return agentcommand.ExecReceipt{CommandID: req.ID, State: agentcommand.StateUnknown, Reason: "audit unavailable: " + err.Error(), Time: b.now().UTC()}
 	}

internal/plugins/account_reload_test.go

@@ -1,137 +0,0 @@
-package plugins
-
-import (
-	"encoding/json"
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"agent-system-backend/internal/store"
-)
-
-func TestLoadDirAccountCheckedRejectsDisabledActorWithoutEffects(t *testing.T) {
-	host, reg, dir := newHost(t)
-	if err := host.st.CreateAccount("admin", "", "hash", true); err != nil {
-		t.Fatal(err)
-	}
-	if err := host.st.CreateAccount("alice", "", "hash", false); err != nil {
-		t.Fatal(err)
-	}
-	writeExamplePlugin(t, dir, "example")
-	if err := host.LoadDir()["example"]; err != nil {
-		t.Fatal(err)
-	}
-	if _, _, ok := reg.Get("http_echo"); !ok {
-		t.Fatal("fixture plugin was not registered")
-	}
-	if err := os.RemoveAll(filepath.Join(dir, "example")); err != nil {
-		t.Fatal(err)
-	}
-	root := filepath.Join(dir, "side")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	mark := filepath.Join(t.TempDir(), "sidecar-ran")
-	manifest := `{"id":"side","name":"Side","version":"1.0.0","apiVersion":"1.0","backend":{"mode":"sidecar","command":"/bin/touch","args":["` + mark + `"],"schemaVersion":1},"provides":{}}`
-	if err := os.WriteFile(filepath.Join(root, "plugin.json"), []byte(manifest), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	account, err := host.st.GetAccountByOwner("alice")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := host.st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := host.LoadDirAccountChecked("alice", false); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled reload: %v", err)
-	}
-	if _, _, ok := reg.Get("http_echo"); !ok || len(host.List()) != 1 {
-		t.Fatal("disabled reload changed the existing process registry")
-	}
-	if _, err := os.Stat(mark); !os.IsNotExist(err) {
-		t.Fatalf("disabled reload started sidecar: %v", err)
-	}
-	plugins, err := host.st.ListPlugins()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(plugins) != 1 || plugins[0].ID != "example" {
-		t.Fatalf("disabled reload changed plugin rows: %+v", plugins)
-	}
-	if version, err := host.st.PluginSchemaVersion("side"); err != nil || version != 0 {
-		t.Fatalf("disabled reload changed schema version: %d, %v", version, err)
-	}
-}
-
-func TestLoadDirAccountCheckedWritesForEnabledActor(t *testing.T) {
-	host, _, dir := newHost(t)
-	if err := host.st.CreateAccount("alice", "", "hash", false); err != nil {
-		t.Fatal(err)
-	}
-	root := filepath.Join(dir, "plain")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	manifest := `{"id":"plain","name":"Plain","version":"1.0.0","apiVersion":"1.0","backend":{"schemaVersion":2},"provides":{}}`
-	if err := os.WriteFile(filepath.Join(root, "plugin.json"), []byte(manifest), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	results, err := host.LoadDirAccountChecked("alice", false)
-	if err != nil || results["plain"] != nil {
-		t.Fatalf("enabled reload: %v, %+v", err, results)
-	}
-	plugins, err := host.st.ListPlugins()
-	if err != nil || len(plugins) != 1 || plugins[0].ID != "plain" {
-		t.Fatalf("plugin row: %+v, %v", plugins, err)
-	}
-	if version, err := host.st.PluginSchemaVersion("plain"); err != nil || version != 2 {
-		t.Fatalf("schema version: %d, %v", version, err)
-	}
-}
-
-func TestLoadDirAccountCheckedRechecksBetweenPlugins(t *testing.T) {
-	host, _, dir := newHost(t)
-	if err := host.st.CreateAccount("admin", "", "hash", true); err != nil {
-		t.Fatal(err)
-	}
-	if err := host.st.CreateAccount("alice", "", "hash", false); err != nil {
-		t.Fatal(err)
-	}
-	account, err := host.st.GetAccountByOwner("alice")
-	if err != nil {
-		t.Fatal(err)
-	}
-	mark := filepath.Join(t.TempDir(), "b-ran")
-	for id, manifest := range map[string]string{
-		"a": `{"id":"a","name":"A","version":"1.0.0","apiVersion":"1.0","provides":{}}`,
-		"b": `{"id":"b","name":"B","version":"1.0.0","apiVersion":"1.0","backend":{"mode":"sidecar","command":"/bin/touch","args":["` + mark + `"]},"provides":{}}`,
-	} {
-		root := filepath.Join(dir, id)
-		if err := os.MkdirAll(root, 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(filepath.Join(root, "plugin.json"), []byte(manifest), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	callbackCount := 0
-	host.OnCommands = func([]json.RawMessage) error {
-		callbackCount++
-		_, err := host.st.SetAccountEnabled("admin", account.ID, account.StateVersion, false)
-		return err
-	}
-	results, err := host.LoadDirAccountChecked("alice", false)
-	if !errors.Is(err, store.ErrAccountForbidden) || results["a"] != nil || callbackCount != 1 {
-		t.Fatalf("reload after callback disable: %v, %+v, callbacks=%d", err, results, callbackCount)
-	}
-	plugins, err := host.st.ListPlugins()
-	if err != nil || len(plugins) != 1 || plugins[0].ID != "a" {
-		t.Fatalf("later plugin wrote after disable: %+v, %v", plugins, err)
-	}
-	if _, err := os.Stat(mark); !os.IsNotExist(err) {
-		t.Fatalf("later sidecar started after disable: %v", err)
-	}
-}

internal/plugins/host.go

@@ -67,55 +67,14 @@ func New(st *store.Store, reg *tools.Registry, s *settings.Service, dir string)
 	return &Host{st: st, registry: reg, settings: s, dir: dir, loaded: map[string]*Loaded{}, sidecars: map[string]*exec.Cmd{}}
 }
 
-type loadAccountGuard struct {
-	st                   *store.Store
-	actor                string
-	allowImplicitDefault bool
-	failed               error
-}
-
-func (g *loadAccountGuard) check() error {
-	if g == nil {
-		return nil // startup and existing fixture loader retain legacy behavior
-	}
-	if g.failed != nil {
-		return g.failed
-	}
-	g.failed = g.st.CheckEffectiveAccountForExternalEffect(g.actor, g.allowImplicitDefault)
-	return g.failed
-}
-
-func (g *loadAccountGuard) record(err error) error {
-	if g != nil && err != nil {
-		g.failed = err
-	}
-	return err
-}
-
 // LoadDir 全量装载目录（启动与热加载共用）；返回每个插件的结果（失败不中断其他）。
 func (h *Host) LoadDir() map[string]error {
-	results, _ := h.loadDir(nil)
-	return results
-}
-
-// LoadDirAccountChecked reloads on behalf of an already authorized actor.
-// Each Backend-owned DB write is fenced in its final transaction; process,
-// sidecar and filesystem effects get a fresh state check immediately before
-// execution. The caller must separately enforce plugin-management authority.
-func (h *Host) LoadDirAccountChecked(actor string, allowImplicitDefault bool) (map[string]error, error) {
-	return h.loadDir(&loadAccountGuard{st: h.st, actor: actor, allowImplicitDefault: allowImplicitDefault})
-}
-
-func (h *Host) loadDir(guard *loadAccountGuard) (map[string]error, error) {
-	if err := guard.check(); err != nil {
-		return nil, err
-	}
 	entries, err := os.ReadDir(h.dir)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return map[string]error{}, nil
+			return map[string]error{}
 		}
-		return map[string]error{"<dir>": err}, nil
+		return map[string]error{"<dir>": err}
 	}
 	results := map[string]error{}
 	seen := map[string]bool{}
@@ -125,19 +84,12 @@ func (h *Host) loadDir(guard *loadAccountGuard) (map[string]error, error) {
 		}
 		id := e.Name()
 		seen[id] = true
-		results[id] = h.loadOne(filepath.Join(h.dir, id), guard)
-		if guard != nil && guard.failed != nil {
-			return results, guard.failed
-		}
+		results[id] = h.loadOne(filepath.Join(h.dir, id))
 	}
 	// 移除已消失的插件（卸载语义）。
 	h.mu.Lock()
 	for id := range h.loaded {
 		if !seen[id] {
-			if err := guard.check(); err != nil {
-				h.mu.Unlock()
-				return results, err
-			}
 			delete(h.loaded, id)
 			if cmd := h.sidecars[id]; cmd != nil && cmd.Process != nil {
 				_ = cmd.Process.Kill()
@@ -152,34 +104,25 @@ func (h *Host) loadDir(guard *loadAccountGuard) (map[string]error, error) {
 	onIntents, onCommands, onWorkflows := h.OnIntents, h.OnCommands, h.OnWorkflows
 	h.mu.Unlock()
 	if onCommands != nil {
-		if err := guard.check(); err != nil {
-			return results, err
-		}
 		if err := onCommands(cmdOverlay); err != nil {
 			results["<commands>"] = err
 		}
 	}
 	if onIntents != nil {
-		if err := guard.check(); err != nil {
-			return results, err
-		}
 		if err := onIntents(overlay); err != nil {
 			results["<intents>"] = err
 		}
 	}
 	if onWorkflows != nil {
-		if err := guard.check(); err != nil {
-			return results, err
-		}
 		if err := onWorkflows(defs, scripts); err != nil {
 			results["<workflows>"] = err
 		}
 	}
-	return results, nil
+	return results
 }
 
 // loadOne 装载单个插件；任何失败返回错误且不改变既有注册（fail-closed）。
-func (h *Host) loadOne(dir string, guard *loadAccountGuard) error {
+func (h *Host) loadOne(dir string) error {
 	manifestPath := filepath.Join(dir, "plugin.json")
 	raw, err := os.ReadFile(manifestPath)
 	if err != nil {
@@ -202,9 +145,6 @@ func (h *Host) loadOne(dir string, guard *loadAccountGuard) error {
 	ld := &Loaded{Manifest: m, Dir: dir, Cards: map[string][]core.UINode{}, Prompts: map[string]string{}, Defaults: map[string]any{}, Scripts: map[string]string{}}
 
 	// 同 ID 重载：先注销旧注册（含旧版本工具），再装载新资产。
-	if err := guard.check(); err != nil {
-		return err
-	}
 	h.registry.UnregisterBySource(core.SourcePlugin, m.ID)
 
 	// tools/*.json：声明式 HTTP 工具（或含 parameters 的描述型工具）。
@@ -219,9 +159,6 @@ func (h *Host) loadOne(dir string, guard *loadAccountGuard) error {
 		if err != nil {
 			return fmt.Errorf("plugins: %s: tool %s: %w", m.ID, name, err)
 		}
-		if err := guard.check(); err != nil {
-			return err
-		}
 		if err := h.registry.Register(desc, exec); err != nil {
 			return fmt.Errorf("plugins: %s: register tool %s: %w", m.ID, name, err)
 		}
@@ -324,13 +261,10 @@ func (h *Host) loadOne(dir string, guard *loadAccountGuard) error {
 		}
 	}
 
-	if err := h.loadDeclared(dir, m, ld, guard); err != nil {
+	if err := h.loadDeclared(dir, m, ld); err != nil {
 		return err
 	}
-	if err := h.startSidecar(m, dir, guard); err != nil {
-		return err
-	}
-	if err := guard.check(); err != nil {
+	if err := h.startSidecar(m, dir); err != nil {
 		return err
 	}
 	h.mu.Lock()
@@ -340,31 +274,18 @@ func (h *Host) loadOne(dir string, guard *loadAccountGuard) error {
 	defs, scripts := h.collectWorkflowsLocked()
 	onIntents, onCommands, onWorkflows := h.OnIntents, h.OnCommands, h.OnWorkflows
 	h.mu.Unlock()
-	if guard == nil {
-		_ = h.st.UpsertPlugin(m.ID, dir, m)
-	} else if err := h.st.UpsertPluginAccountChecked(guard.actor, m.ID, dir, m, guard.allowImplicitDefault); err != nil {
-		return guard.record(err)
-	}
+	_ = h.st.UpsertPlugin(m.ID, dir, m)
 	if onCommands != nil {
-		if err := guard.check(); err != nil {
-			return err
-		}
 		if err := onCommands(cmdOverlay); err != nil {
 			return fmt.Errorf("plugins: %s: commands rejected by command bus (kept previous): %w", m.ID, err)
 		}
 	}
 	if onIntents != nil {
-		if err := guard.check(); err != nil {
-			return err
-		}
 		if err := onIntents(overlay); err != nil {
 			return fmt.Errorf("plugins: %s: intents rejected by host gate (kept previous): %w", m.ID, err)
 		}
 	}
 	if onWorkflows != nil {
-		if err := guard.check(); err != nil {
-			return err
-		}
 		if err := onWorkflows(defs, scripts); err != nil {
 			return fmt.Errorf("plugins: %s: workflows rejected: %w", m.ID, err)
 		}

internal/plugins/host_v2.go

@@ -21,7 +21,7 @@ func (h *Host) SetHostAPI(baseURL, token string) {
 	h.hostAPI, h.hostToken = baseURL, token
 }
 
-func (h *Host) startSidecar(m core.PluginManifest, dir string, guard *loadAccountGuard) error {
+func (h *Host) startSidecar(m core.PluginManifest, dir string) error {
 	if m.Backend.Mode != "sidecar" || m.Backend.Command == "" {
 		return nil
 	}
@@ -38,19 +38,10 @@ func (h *Host) startSidecar(m core.PluginManifest, dir string, guard *loadAccoun
 		"AGENT_HOST_TOKEN="+h.hostToken,
 		"AGENT_PLUGIN_ID="+m.ID,
 	)
-	if err := guard.check(); err != nil {
-		return err
-	}
 	if err := cmd.Start(); err != nil {
 		return fmt.Errorf("plugins: %s: sidecar: %w", m.ID, err)
 	}
 	h.mu.Lock()
-	if err := guard.check(); err != nil {
-		h.mu.Unlock()
-		_ = cmd.Process.Kill()
-		_ = cmd.Wait()
-		return err
-	}
 	if h.sidecars == nil {
 		h.sidecars = map[string]*exec.Cmd{}
 	}
@@ -63,7 +54,7 @@ func (h *Host) startSidecar(m core.PluginManifest, dir string, guard *loadAccoun
 	return nil
 }
 
-func (h *Host) loadDeclared(dir string, m core.PluginManifest, ld *Loaded, guard *loadAccountGuard) error {
+func (h *Host) loadDeclared(dir string, m core.PluginManifest, ld *Loaded) error {
 	for _, name := range m.Provides.Skills {
 		body, err := os.ReadFile(filepath.Join(dir, "skills", name+".md"))
 		if err != nil {
@@ -79,15 +70,9 @@ func (h *Host) loadDeclared(dir string, m core.PluginManifest, ld *Loaded, guard
 		ld.Skills[name] = string(body)
 		if h.skillsRoot != "" {
 			dest := filepath.Join(h.skillsRoot, "plugin-"+m.ID, name)
-			if err := guard.check(); err != nil {
-				return err
-			}
 			if err := os.MkdirAll(dest, 0o755); err != nil {
 				return err
 			}
-			if err := guard.check(); err != nil {
-				return err
-			}
 			if err := os.WriteFile(filepath.Join(dest, "SKILL.md"), body, 0o644); err != nil {
 				return err
 			}
@@ -146,9 +131,6 @@ func (h *Host) loadDeclared(dir string, m core.PluginManifest, ld *Loaded, guard
 		ld.Pages = append(ld.Pages, item)
 	}
 	if m.Backend.SchemaVersion > 0 && h.st != nil {
-		if guard != nil {
-			return guard.record(h.st.SetPluginSchemaVersionAccountChecked(guard.actor, m.ID, m.Backend.SchemaVersion, guard.allowImplicitDefault))
-		}
 		cur, err := h.st.PluginSchemaVersion(m.ID)
 		if err != nil {
 			return err

internal/profiles/profiles.go

@@ -2,6 +2,7 @@
 package profiles
 
 import (
+	"errors"
 	"reflect"
 
 	"agent-system-backend/internal/store"
@@ -50,11 +51,20 @@ func (s *Service) EnsureDefault() error {
 	return s.st.SaveProfile(DefaultProfile())
 }
 
-func (s *Service) List(owner string) ([]core.AgentProfile, error) { return s.st.ListProfiles(owner) }
+func (s *Service) List(owner string) ([]core.AgentProfile, error) {
+	profiles, err := s.st.ListProfiles(owner)
+	for i := range profiles {
+		profiles[i].Model = core.ModelRoute{}
+	}
+	return profiles, err
+}
 
 func (s *Service) Get(owner, id string) (core.AgentProfile, error) {
 	p, err := s.st.GetProfile(owner, id)
 	if err == nil {
+		// Preserve old rows for migration, but never advertise obsolete personal
+		// model overrides as available configuration or pass them to a real run.
+		p.Model = core.ModelRoute{}
 		return p, nil
 	}
 	// 空或未知画像回落默认（T0 行为基线）。
@@ -65,6 +75,9 @@ func (s *Service) Save(owner string, p core.AgentProfile) error {
 	if p.ID == DefaultProfileID {
 		return errReadOnly("profiles: builtin profile is read-only; duplicate and modify")
 	}
+	if p.Model != (core.ModelRoute{}) {
+		return errors.New("模型路由由系统管理员配置；个人画像不能覆盖模型")
+	}
 	if p.Tools.Allow == nil {
 		p.Tools.Allow = []string{"*"}
 	}
@@ -74,23 +87,6 @@ func (s *Service) Save(owner string, p core.AgentProfile) error {
 
 func (s *Service) Delete(owner, id string) error { return s.st.DeleteProfile(owner, id) }
 
-// SaveAccountChecked is the user-facing write path. Builtin profiles remain
-// read-only and the Store binds the write to the actor's effective account.
-func (s *Service) SaveAccountChecked(actor string, p core.AgentProfile, allowImplicitDefault bool) error {
-	if p.ID == DefaultProfileID || p.Builtin {
-		return errReadOnly("profiles: builtin profile is read-only; duplicate and modify")
-	}
-	if p.Tools.Allow == nil {
-		p.Tools.Allow = []string{"*"}
-	}
-	p.Owner = actor
-	return s.st.SaveProfileAccountChecked(actor, p, allowImplicitDefault)
-}
-
-func (s *Service) DeleteAccountChecked(actor, id string, allowImplicitDefault bool) error {
-	return s.st.DeleteProfileAccountChecked(actor, id, allowImplicitDefault)
-}
-
 type errReadOnly string
 
 func (e errReadOnly) Error() string { return string(e) }

internal/profiles/profiles_fence_test.go

@@ -1,54 +0,0 @@
-package profiles
-
-import (
-	"errors"
-	"path/filepath"
-	"testing"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-func TestProfileServiceAccountCheckedWrites(t *testing.T) {
-	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "test.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	if err := st.CreateAccount("admin", "", "", true); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("alice", "", "", false); err != nil {
-		t.Fatal(err)
-	}
-	svc := New(st)
-	if err := svc.EnsureDefault(); err != nil {
-		t.Fatal(err)
-	}
-	if err := svc.SaveAccountChecked("alice", core.AgentProfile{ID: "profile-a", Name: "A"}, false); err != nil {
-		t.Fatal(err)
-	}
-	got, err := st.GetProfile("alice", "profile-a")
-	if err != nil || got.Owner != "alice" || got.Builtin || len(got.Tools.Allow) != 1 || got.Tools.Allow[0] != "*" {
-		t.Fatalf("service did not normalize actor profile: %+v %v", got, err)
-	}
-	if err := svc.SaveAccountChecked("alice", core.AgentProfile{ID: DefaultProfileID}, false); err == nil {
-		t.Fatal("service edited builtin default")
-	}
-	if err := svc.SaveAccountChecked("alice", core.AgentProfile{ID: "forged", Builtin: true}, false); err == nil {
-		t.Fatal("service accepted forged builtin profile")
-	}
-	account, err := st.GetAccountByOwner("alice")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	if err := svc.DeleteAccountChecked("alice", "profile-a", false); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled actor deleted profile: %v", err)
-	}
-	if err := svc.SaveAccountChecked("alice", core.AgentProfile{ID: "profile-a", Name: "late"}, false); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled actor saved profile: %v", err)
-	}
-}

internal/profiles/profiles_test.go

@@ -0,0 +1,53 @@
+package profiles
+
+import (
+	"agent-system-backend/internal/store"
+	core "agent-system-core"
+	"path/filepath"
+	"testing"
+)
+
+func TestSaveRejectsPersonalModelRoute(t *testing.T) {
+	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "profiles.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	s := New(st)
+	for _, route := range []core.ModelRoute{{Chat: "personal"}, {Lightweight: "personal"}, {Embedding: "personal"}, {Rerank: "personal"}} {
+		if err := s.Save("alice", core.AgentProfile{ID: "personal", Model: route}); err == nil {
+			t.Fatal("system managed route accepted in personal profile")
+		}
+	}
+	if err := s.Save("alice", core.AgentProfile{ID: "legal", Name: "Personal assistant"}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestLegacyProfileRoutesRemainStoredButAreNotProjected(t *testing.T) {
+	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "legacy.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	legacy := core.AgentProfile{ID: "old", Owner: "alice", Name: "Legacy", Model: core.ModelRoute{Chat: "old-model"}}
+	if err := st.SaveProfile(legacy); err != nil {
+		t.Fatal(err)
+	}
+	s := New(st)
+	p, err := s.Get("alice", "old")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if p.Model != (core.ModelRoute{}) {
+		t.Fatal("obsolete model-route projection claims personal override remains available")
+	}
+	list, err := s.List("alice")
+	if err != nil || len(list) != 1 || list[0].Model != (core.ModelRoute{}) {
+		t.Fatal("obsolete route exposed in profile list")
+	}
+	raw, err := st.GetProfile("alice", "old")
+	if err != nil || raw.Model.Chat != "old-model" {
+		t.Fatal("legacy recovery route was deleted")
+	}
+}

internal/prompts/library/base-deliverables.md

@@ -1,7 +1,7 @@
 ---
 id: base.deliverables
 layer: base
-version: 9
+version: 7
 title: 交付物工作流
 description: 生成文档、表格、演示稿的工作流、样式决策与技能入口（常驻基座）
 ---
@@ -36,10 +36,8 @@ description: 生成文档、表格、演示稿的工作流、样式决策与技
 - 技能目录是环境变量 `AGENT_SKILLS_DIR`（环境段会写出绝对路径）。`PYTHONPATH` 已包含其中的 `house-style`，脚本里直接 `import housestyle`。
 - **house-style**：设计系统、三套主题、模板与仿制、lint。先读 `$AGENT_SKILLS_DIR/house-style/SKILL.md`。
 - **docx-author / xlsx-author / pptx-author**：各类交付物的版面范式和最小示例。
-- **frontend-design / canvas-design / copywriting / copy-editing**（第三方 vendor，溯源见各自 UPSTREAM.md）：视觉方向与排版审美、海报/信息图等 png·pdf 视觉产物（PIL 渲染，字体已随包）、营销/商务文案的撰写改写与编辑润色。交付物主题与配色仍以 house-style 为权威；需要超出主题规范的视觉判断或文案功力时 `load_skill` 对应技能。
 - 小队角色用 `load_skill`；其他路径用 `run_shell` 查看技能文件，例如 `cat "$AGENT_SKILLS_DIR/house-style/SKILL.md"`。不要假设工作区里有 `skills/` 目录。
 - 缺库时：`pip install --user python-docx openpyxl python-pptx`。PDF 仿制可选 `pdfplumber`；没装就说明只能近似，并请用户确认主色和字体。
-- 缺库又装不上时，如实告知用户当前环境无法生成带排版的 Office 交付物并说明缺什么；禁止改用 zipfile/字符串手工拼 OOXML 充数——那样生成的包缺母版与主题，结构自检会拒绝登记。
 
 要求与边界：
 

internal/prompts/library/tool-run-python.md

@@ -1,8 +1,8 @@
 ---
 id: tool.run_python
 layer: tool
-version: 2
+version: 1
 title: run_python 工具描述
 description: Python 执行原语的模型侧说明文案
 ---
-执行完整 Python 脚本（python3，工作目录=会话工作区）。适用：数据处理、生成 Excel/PPT/图片（housestyle kit）、批量操作。Word 交付物优先写 .md 源后用 run_shell 跑 `python3 -m housestyle.build`。任何 Office 交付物（docx/xlsx/pptx）都禁止用 zipfile 或字符串手工拼 OOXML——手拼的包缺母版与主题，register_artifact 的结构自检会直接拒绝；一律走 housestyle kit 构件。缺库先 `pip install --user python-pptx python-docx openpyxl`，装不上就如实告知用户当前环境无法生成本类交付物，不要退回手拼。报错先读退出码与 traceback 定位行号再改，同一错误不要原样重跑。生成带排版的文件（xlsx/pptx）先读 `$AGENT_SKILLS_DIR/house-style/SKILL.md` 的构件表，不确定签名先 `inspect.signature`。
+执行完整 Python 脚本（python3，工作目录=会话工作区）。适用：数据处理、生成 Excel/PPT/图片（housestyle kit）、批量操作。Word 交付物优先写 .md 源后用 run_shell 跑 `python3 -m housestyle.build`，不要在脚本里手工拼 docx。报错先读退出码与 traceback 定位行号再改，同一错误不要原样重跑。生成带排式的文件（xlsx/pptx）先读 `$AGENT_SKILLS_DIR/house-style/SKILL.md` 的构件表，不确定签名先 `inspect.signature`。

internal/prompts/service.go

@@ -228,27 +228,6 @@ func (s *Service) Save(owner string, m core.PromptModule) error {
 // Delete 撤销用户覆盖（回到内置）。
 func (s *Service) Delete(owner, id string) error { return s.st.DeletePromptModule(owner, id) }
 
-// SaveAccountChecked applies the same user override rules as Save and uses
-// the Store's final actor-state transaction for the database write.
-func (s *Service) SaveAccountChecked(actor string, m core.PromptModule, allowImplicitDefault bool) error {
-	if err := validateSubagentOverride(m); err != nil {
-		return err
-	}
-	m.Source = string(core.SourceUser)
-	m.Owner = actor
-	for _, b := range s.builtin {
-		if b.ID == m.ID {
-			m.BasedOnVersion = b.Version
-			break
-		}
-	}
-	return s.st.SavePromptModuleAccountChecked(actor, m, allowImplicitDefault)
-}
-
-func (s *Service) DeleteAccountChecked(actor, id string, allowImplicitDefault bool) error {
-	return s.st.DeletePromptModuleAccountChecked(actor, id, allowImplicitDefault)
-}
-
 // MatchCommand 命令触发匹配：文本以某技能命令开头时返回该模块与剩余文本。
 func (s *Service) MatchCommand(owner, text string) (core.PromptModule, string, bool, error) {
 	mods, err := s.Effective(owner)

internal/prompts/service_fence_test.go

@@ -1,52 +0,0 @@
-package prompts
-
-import (
-	"errors"
-	"path/filepath"
-	"testing"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-func TestPromptServiceAccountCheckedWrites(t *testing.T) {
-	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "test.db"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer st.Close()
-	if err := st.CreateAccount("admin", "", "", true); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("alice", "", "", false); err != nil {
-		t.Fatal(err)
-	}
-	svc, err := NewService(st, []core.PromptModule{{ID: "task.example", Layer: core.LayerTask, Version: 2}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	module := core.PromptModule{ID: "task.example", Layer: core.LayerTask, Body: "Alice"}
-	if err := svc.SaveAccountChecked("alice", module, false); err != nil {
-		t.Fatal(err)
-	}
-	got, err := st.GetPromptModule("alice", module.ID)
-	if err != nil || got.Owner != "alice" || got.Source != string(core.SourceUser) || got.BasedOnVersion != 2 {
-		t.Fatalf("service did not normalize actor module: %+v %v", got, err)
-	}
-	if err := svc.SaveAccountChecked("missing", module, false); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("missing actor saved prompt: %v", err)
-	}
-	account, err := st.GetAccountByOwner("alice")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	if err := svc.DeleteAccountChecked("alice", module.ID, false); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled actor deleted prompt: %v", err)
-	}
-	if err := svc.SaveAccountChecked("alice", module, false); !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("disabled actor saved prompt: %v", err)
-	}
-}

internal/rag/account_index_test.go

@@ -1,83 +0,0 @@
-package rag
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-type checkedKnowledgeIndexer interface {
-	IndexDocumentAccountChecked(ctx context.Context, owner, projectID core.ID, source, title, ref, plainText string, allowImplicitDefault bool) error
-	IndexChunksAccountChecked(ctx context.Context, owner core.ID, docs []core.KnowledgeDoc, allowImplicitDefault bool) error
-	PublishChunksAccountChecked(ctx context.Context, owner core.ID, pluginID string, scoped bool, docs []core.KnowledgeDoc, allowImplicitDefault bool) error
-}
-
-func checkedIndexer(t *testing.T, p *Pipeline) checkedKnowledgeIndexer {
-	t.Helper()
-	i, ok := any(p).(checkedKnowledgeIndexer)
-	if !ok {
-		t.Fatal("Pipeline is missing account-checked indexing APIs")
-	}
-	return i
-}
-
-type disableDuringEmbed struct{ st *store.Store }
-
-func (e disableDuringEmbed) Embed(_ context.Context, texts []string) ([][]float32, error) {
-	if _, err := e.st.DB().Exec(`UPDATE users SET enabled=FALSE WHERE owner='alice'`); err != nil {
-		return nil, err
-	}
-	vecs := make([][]float32, len(texts))
-	for i := range vecs {
-		vecs[i] = []float32{1, 0}
-	}
-	return vecs, nil
-}
-
-func TestCheckedIndexStopsVectorWriteAfterEmbeddingDisablesAccount(t *testing.T) {
-	p, st := newTestPipeline(t, nil, nil)
-	i := checkedIndexer(t, p)
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
-	p.SetEmbedder(disableDuringEmbed{st: st})
-	err := i.IndexChunksAccountChecked(context.Background(), "alice", []core.KnowledgeDoc{
-		{ID: "knw-during-embed", Owner: "alice", Ref: "embedded", Source: "manual", Chunk: "A searchable document"},
-	}, false)
-	if !errors.Is(err, store.ErrAccountForbidden) {
-		t.Fatalf("vector write after disable: got %v, want ErrAccountForbidden", err)
-	}
-	var lexical, vectors int
-	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM knowledge WHERE owner='alice' AND ref='embedded'`).Scan(&lexical); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM knowledge_vectors WHERE owner='alice' AND ref='embedded'`).Scan(&vectors); err != nil {
-		t.Fatal(err)
-	}
-	if lexical != 1 || vectors != 0 {
-		t.Fatalf("expected pre-disable lexical commit and no late vector: lexical=%d vectors=%d", lexical, vectors)
-	}
-}
-
-func TestCheckedIndexDocumentAndPublishUseGuardedKnowledge(t *testing.T) {
-	p, st := newTestPipeline(t, nil, nil)
-	i := checkedIndexer(t, p)
-	if err := st.EnsureUser("alice", ""); err != nil {
-		t.Fatal(err)
-	}
-	if err := i.IndexDocumentAccountChecked(context.Background(), "alice", "p1", "upload", "minutes", "upload-ref", "A document with enough searchable text", false); err != nil {
-		t.Fatal(err)
-	}
-	if err := i.PublishChunksAccountChecked(context.Background(), "alice", "alpha", true, []core.KnowledgeDoc{
-		{ID: "knw-published", Owner: "alice", ProjectID: "p1", Ref: "published", Source: "plugin:alpha", Chunk: "A published document"},
-	}, false); err != nil {
-		t.Fatal(err)
-	}
-	var n int
-	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM knowledge WHERE owner='alice'`).Scan(&n); err != nil || n != 2 {
-		t.Fatalf("guarded index and publish rows=%d, %v", n, err)
-	}
-}

internal/rag/hybrid.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
-	"errors"
 	"log"
 
 	"agent-system-backend/internal/settings"
@@ -86,25 +85,6 @@ func (p *Pipeline) IndexDocument(owner, projectID core.ID, source, title, ref, p
 	return p.IndexChunks(context.Background(), owner, docs)
 }
 
-// IndexDocumentAccountChecked is the upload/artifact indexing entry when the
-// caller has an authenticated actor. Chunking takes no DB connection; every
-// later lexical/vector write has its own final account transaction check.
-func (p *Pipeline) IndexDocumentAccountChecked(ctx context.Context, owner, projectID core.ID, source, title, ref, plainText string, allowImplicitDefault bool) error {
-	if plainText == "" {
-		return nil
-	}
-	doc := core.ParsedDocument{Blocks: []core.DocBlock{{Type: core.BlockPara, Text: plainText}}}
-	chunks := p.chunker.Chunk(doc)
-	if len(chunks) == 0 {
-		return nil
-	}
-	docs := make([]core.KnowledgeDoc, len(chunks))
-	for i, c := range chunks {
-		docs[i] = core.KnowledgeDoc{Owner: owner, ProjectID: projectID, Source: source, Title: title, Ref: ref, Chunk: c.Text}
-	}
-	return p.IndexChunksAccountChecked(ctx, owner, docs, allowImplicitDefault)
-}
-
 // IndexChunks 写入已构造好的知识分块并建向量（EXT-1 KnowledgeWrite embed=true 的路径）。
 // AddKnowledge 原地回填 docs[i].ID；embedding 失败降级为纯全文（记日志，不阻断写入）。
 func (p *Pipeline) IndexChunks(ctx context.Context, owner core.ID, docs []core.KnowledgeDoc) error {
@@ -138,74 +118,6 @@ func (p *Pipeline) IndexChunks(ctx context.Context, owner core.ID, docs []core.K
 	return nil
 }
 
-// IndexChunksAccountChecked preserves batch atomicity for lexical rows and
-// fences each vector write after the external embedding call. Embedding cannot
-// share the DB transaction; a disable during that call leaves already
-// committed lexical rows but blocks subsequent vector publication.
-func (p *Pipeline) IndexChunksAccountChecked(ctx context.Context, owner core.ID, docs []core.KnowledgeDoc, allowImplicitDefault bool) error {
-	if len(docs) == 0 {
-		return nil
-	}
-	if err := p.st.AddKnowledgeAccountChecked(string(owner), allowImplicitDefault, docs...); err != nil {
-		return err
-	}
-	return p.indexVectorsAccountChecked(ctx, owner, docs, allowImplicitDefault)
-}
-
-// PublishChunksAccountChecked replaces all affected refs in one guarded Store
-// transaction, then builds vectors through individually guarded writes.
-func (p *Pipeline) PublishChunksAccountChecked(ctx context.Context, owner core.ID, pluginID string, scoped bool, docs []core.KnowledgeDoc, allowImplicitDefault bool) error {
-	if len(docs) == 0 {
-		return nil
-	}
-	if err := p.st.ReplaceKnowledgeAccountChecked(ctx, string(owner), pluginID, scoped, allowImplicitDefault, docs...); err != nil {
-		return err
-	}
-	return p.indexVectorsAccountChecked(ctx, owner, docs, allowImplicitDefault)
-}
-
-func (p *Pipeline) indexVectorsAccountChecked(ctx context.Context, owner core.ID, docs []core.KnowledgeDoc, allowImplicitDefault bool) error {
-	if p.embedder == nil {
-		return nil
-	}
-	if err := ctx.Err(); err != nil {
-		return err
-	}
-	account, err := p.st.GetAccountByOwner(string(owner))
-	if errors.Is(err, store.ErrNotFound) && allowImplicitDefault && owner == store.OwnerDefault {
-		err = nil
-		account.Enabled = true
-	}
-	if err != nil {
-		return err
-	}
-	if !account.Enabled {
-		return store.ErrAccountForbidden
-	}
-	texts := make([]string, len(docs))
-	for i, d := range docs {
-		texts[i] = d.Chunk
-	}
-	vecs, err := p.embedder.Embed(ctx, texts)
-	if err != nil {
-		log.Printf("[rag] embedding 降级为纯全文（ref=%s）: %v", firstRef(docs), err)
-		return nil
-	}
-	model := embedderModel(p.embedder)
-	for i, v := range vecs {
-		if i >= len(docs) {
-			break
-		}
-		if len(v) == 0 {
-			continue
-		}
-		if err := p.st.UpsertKnowledgeVectorExtAccountChecked(ctx, string(owner), string(docs[i].ID), docs[i].Ref, model, contentHash(docs[i].Chunk), v, allowImplicitDefault); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // embedderModel 模型身份（可选接口：EmbeddingProvider 契约未含，实现侧
 // 声明；未声明=空=legacy 无身份行，向后兼容）。
 func embedderModel(e core.EmbeddingProvider) string {

internal/runmgr/account_guard_test.go

@@ -1,145 +0,0 @@
-package runmgr
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"testing"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-// A missing domain provider must not make a registered account guard optional.
-func TestAccountGuardBlocksRunToolAndQueuedHITL(t *testing.T) {
-	c, st := newExecEnv(t)
-	if err := st.CreateAccount("alice", "Alice", "", false); err != nil {
-		t.Fatal(err)
-	}
-	c.mgr.SetAccountEffectiveAuthorization(func(_ context.Context, owner string) (bool, error) {
-		a, err := st.GetAccountByOwner(owner)
-		return err == nil && a.Enabled, err
-	})
-	c.run.ID = store.NewID("run")
-	c.run.Status = core.RunWaitingHITL
-	if err := st.CreateRun(&c.run); err != nil {
-		t.Fatal(err)
-	}
-	h := &runHandle{hitlCh: make(chan hitlAnswer, 1)}
-	c.mgr.active = map[string]*runHandle{c.run.ID: h}
-	card := core.HITLCard{ID: "disabled-card", RunID: c.run.ID, ConversationID: c.run.ConversationID}
-	if err := st.SaveHITLCard("alice", &card); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.DB().Exec(`UPDATE users SET enabled=FALSE WHERE owner='alice'`); err != nil {
-		t.Fatal(err)
-	}
-	conv, err := st.GetConversation("alice", c.run.ConversationID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := c.mgr.StartConversationRun(conv, core.Message{}, nil, nil); !errors.Is(err, store.ErrNotFound) {
-		t.Fatalf("disabled account started run without domain provider: %v", err)
-	}
-	res := c.ExecuteTool(core.ToolCallRequest{CallID: "disabled-tool", Name: "write_artifact", Arguments: json.RawMessage(`{"name":"denied.txt","content":"x"}`)})
-	if res.Status != "error" {
-		t.Fatalf("disabled account executed tool: %+v", res)
-	}
-	arts, err := st.ListArtifacts("alice", c.run.ProjectID)
-	if err != nil || len(arts) != 0 {
-		t.Fatalf("disabled account wrote artifact: %+v %v", arts, err)
-	}
-
-	if _, _, err := c.mgr.ResolveHITL("alice", card.ID, core.HITLResponse{ChoiceID: "yes"}); !errors.Is(err, store.ErrNotFound) {
-		t.Fatalf("disabled account resolved HITL: %v", err)
-	}
-	persisted, err := st.GetHITLCard("alice", card.ID)
-	if err != nil || persisted.Resolved || len(h.hitlCh) != 0 {
-		t.Fatalf("disabled HITL changed state: %+v channel=%d err=%v", persisted, len(h.hitlCh), err)
-	}
-	payload, _ := json.Marshal(HITLCommandPayload{Owner: "alice", CardID: card.ID, Kind: "yes"})
-	c.mgr.applyHITLCommand(ownedCommand{CommandID: "queued-disabled", Payload: string(payload)})
-	if len(h.hitlCh) != 0 {
-		t.Fatal("queued approval delivered to disabled run")
-	}
-}
-
-func TestAccountGuardStoreReadFailureBlocksOutput(t *testing.T) {
-	c, st := newExecEnv(t)
-	runCtx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	c.ctx = runCtx
-	c.mgr.active = map[string]*runHandle{"active": {owner: "alice", cancel: cancel}}
-	readErr := errors.New("account store unavailable")
-	c.mgr.SetAccountEffectiveAuthorization(func(context.Context, string) (bool, error) { return false, readErr })
-	if err := c.Emit(core.EvToolOutput, core.ToolOutputPayload{Text: "secret"}); !errors.Is(err, readErr) {
-		t.Fatalf("store failure emitted output: %v", err)
-	}
-	if runCtx.Err() == nil {
-		t.Fatal("account-state read failure left active local run executing")
-	}
-	if err := c.SetAssistantParts([]core.Part{{Type: core.PartText, Text: "secret"}}); !errors.Is(err, readErr) {
-		t.Fatalf("store failure retained assistant output: %v", err)
-	}
-	evs, err := st.EventsAfter(c.run.ConversationID, 0, 100)
-	if err != nil || len(evs) != 0 {
-		t.Fatalf("store failure persisted output events: %+v %v", evs, err)
-	}
-}
-
-func TestAccountGuardBlocksRestoredNoticeOutput(t *testing.T) {
-	c, st := newExecEnv(t)
-	if err := st.CreateAccount("alice", "Alice", "", false); err != nil {
-		t.Fatal(err)
-	}
-	c.mgr.SetAccountEffectiveAuthorization(func(_ context.Context, owner string) (bool, error) {
-		a, err := st.GetAccountByOwner(owner)
-		return err == nil && a.Enabled, err
-	})
-	if _, err := st.DB().Exec(`UPDATE users SET enabled=FALSE WHERE owner='alice'`); err != nil {
-		t.Fatal(err)
-	}
-	if err := c.mgr.startNoticeRun(c.run.ConversationID, []bgNotice{{owner: "alice", name: "restored", payload: core.AgentResultPayload{Summary: "must not deliver"}}}); !errors.Is(err, store.ErrNotFound) {
-		t.Fatalf("restored notice delivered to disabled account: %v", err)
-	}
-	msgs, err := st.ListMessages(c.run.ConversationID)
-	if err != nil || len(msgs) != 0 {
-		t.Fatalf("restored notice persisted output: %+v %v", msgs, err)
-	}
-}
-
-func TestAccountGuardDiscardsComposedOutputAfterDisable(t *testing.T) {
-	c, st := newExecEnv(t)
-	if err := st.CreateAccount("alice", "Alice", "", false); err != nil {
-		t.Fatal(err)
-	}
-	c.mgr.SetAccountEffectiveAuthorization(func(_ context.Context, owner string) (bool, error) {
-		a, err := st.GetAccountByOwner(owner)
-		return err == nil && a.Enabled, err
-	})
-	c.run.ID = store.NewID("run")
-	c.run.Status = core.RunRunning
-	if err := st.CreateRun(&c.run); err != nil {
-		t.Fatal(err)
-	}
-	c.h = &runHandle{assistant: []core.Part{{Type: core.PartText, Text: "must not persist"}}}
-	if _, err := st.DB().Exec(`UPDATE users SET enabled=FALSE WHERE owner='alice'`); err != nil {
-		t.Fatal(err)
-	}
-	c.mgr.finishRun(c, core.RunCompleted, core.Usage{}, nil)
-	got, err := st.GetRunByID(c.run.ID)
-	if err != nil || got.Status == core.RunCompleted {
-		t.Fatalf("disabled run completed: %+v %v", got, err)
-	}
-	msgs, err := st.ListMessages(c.run.ConversationID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, msg := range msgs {
-		for _, part := range msg.Parts {
-			if part.Text == "must not persist" {
-				t.Fatal("previously composed assistant output persisted after disable")
-			}
-		}
-	}
-}

internal/runmgr/admission.go

@@ -70,23 +70,16 @@ func (g *admissionGate) QueueFull() bool {
 }
 
 // acquire 阻塞获取执行许可（ctx 取消则放弃排队）。预算关闭时零开销直通。
-func (g *admissionGate) acquire(ctx context.Context, st *store.Store, runID, owner string, accountGuard ...bool) error {
+func (g *admissionGate) acquire(ctx context.Context, st *store.Store, runID, owner string) error {
 	if g == nil {
 		return nil
 	}
 	budget := g.budget()
 	if budget.Off() {
-		return ctx.Err()
+		return nil
 	}
 	for {
-		var err error
-		if len(accountGuard) > 0 && accountGuard[0] {
-			allowImplicit := len(accountGuard) > 1 && accountGuard[1]
-			err = st.TryAcquireExecutionSlotAccountChecked(owner, runID, budget, allowImplicit)
-		} else {
-			err = st.TryAcquireExecutionSlot(runID, owner, budget)
-		}
-		if err == nil {
+		if err := st.TryAcquireExecutionSlot(runID, owner, budget); err == nil {
 			return nil
 		} else if !errors.Is(err, store.ErrBudgetExceeded) {
 			return err // 存储故障：不放行（fail-closed，宁可拒绝执行）

internal/runmgr/commands.go

@@ -170,7 +170,7 @@ func (m *Manager) applyHITLCommand(c ownedCommand) {
 	_, _, err := m.ResolveHITL(p.Owner, p.CardID, resp)
 	if err != nil {
 		// 过期/未知 gate：明确销项（resolved + 注记），发出可见结论。
-		_ = m.resolveHITLCardForEffectiveAccount(p.Owner, p.CardID, core.HITLResolvedPayload{
+		_ = m.st.ResolveHITLCard(p.Owner, p.CardID, core.HITLResolvedPayload{
 			CardID: core.ID(p.CardID), Kind: "expired", Answer: "跨实例审批迟到：gate 已过期或执行已移交",
 		})
 		log.Printf("[runmgr] hitl %s (card %s) rejected: %v", c.CommandID, p.CardID, err)

internal/runmgr/events.go

@@ -20,12 +20,10 @@ import (
 // 会话内事件天然单线程（一个会话至多一个在途 run，子代理在父执行栈内同步运行），
 // 少数跨 goroutine 路径（HITL resolve）与冲盘互斥由 flushing 锁保证不交叉。
 type eventBuffer struct {
-	store               *store.Store
-	bus                 *bus.Bus
-	accountGuardEnabled bool
-	allowImplicitLocal  bool
-	interval            time.Duration // 定时冲盘窗口
-	maxBuf              int           // 单会话缓冲条数上限（触发立即冲盘）
+	store    *store.Store
+	bus      *bus.Bus
+	interval time.Duration // 定时冲盘窗口
+	maxBuf   int           // 单会话缓冲条数上限（触发立即冲盘）
 	// onPersisted 落盘+本地发布后的回调（PG 档 NOTIFY 跨实例扇出；nil = 无）。
 	onPersisted func(conversationID string, evs []core.StreamEvent)
 
@@ -118,41 +116,6 @@ func (eb *eventBuffer) emit(conversationID, runID string, typ core.StreamEventTy
 	return 0, nil
 }
 
-// emitAccountChecked flushes any earlier deltas and the new structural event
-// in one final account-checked Store transaction. A disabled owner loses its
-// buffered deltas instead of persisting them after disable.
-func (eb *eventBuffer) emitAccountChecked(actor, conversationID, runID string, typ core.StreamEventType, payload any, allowImplicitDefault bool) error {
-	e := core.StreamEvent{ConversationID: conversationID, RunID: runID,
-		TS: time.Now().UTC().Format(time.RFC3339Nano), V: core.ProtocolVersion, Type: typ}
-	if projectID, ok := core.ProjectFromChannel(core.ID(conversationID)); ok {
-		e.ProjectID = projectID
-	}
-	if payload != nil {
-		raw, err := json.Marshal(payload)
-		if err != nil {
-			return err
-		}
-		e.Payload = raw
-	}
-	eb.flushing.Lock()
-	defer eb.flushing.Unlock()
-	eb.mu.Lock()
-	batch := append([]core.StreamEvent(nil), eb.buf[conversationID]...)
-	delete(eb.buf, conversationID)
-	eb.mu.Unlock()
-	batch = append(batch, e)
-	if _, err := eb.store.AppendEventsAccountChecked(actor, conversationID, batch, allowImplicitDefault); err != nil {
-		return err
-	}
-	for _, event := range batch {
-		eb.bus.Publish(event)
-	}
-	if eb.onPersisted != nil {
-		eb.onPersisted(conversationID, batch)
-	}
-	return nil
-}
-
 // emitProjectShared persists an explicit internal publication and its proof
 // before fan-out. A client-visible payload cannot opt itself into this path.
 func (eb *eventBuffer) emitProjectShared(owner, producer, channel, runID string, typ core.StreamEventType, payload any) error {
@@ -169,12 +132,7 @@ func (eb *eventBuffer) emitProjectShared(owner, producer, channel, runID string,
 	eb.flushing.Lock()
 	defer eb.flushing.Unlock()
 	events := []core.StreamEvent{event}
-	if eb.accountGuardEnabled {
-		_, err = eb.store.AppendProjectSharedEventsAccountChecked(owner, producer, channel, events, eb.allowImplicitLocal)
-	} else {
-		_, err = eb.store.AppendProjectSharedEvents(owner, producer, channel, events)
-	}
-	if err != nil {
+	if _, err := eb.store.AppendProjectSharedEvents(owner, producer, channel, events); err != nil {
 		return err
 	}
 	for _, event := range events {
@@ -190,13 +148,7 @@ func (eb *eventBuffer) emitProjectShared(owner, producer, channel, runID string,
 func (eb *eventBuffer) append(conversationID string, evs []core.StreamEvent) error {
 	eb.flushing.Lock()
 	defer eb.flushing.Unlock()
-	var err error
-	if eb.accountGuardEnabled {
-		_, err = eb.store.AppendEventsForEffectiveChannel(conversationID, evs, eb.allowImplicitLocal)
-	} else {
-		_, err = eb.store.AppendEvents(conversationID, evs)
-	}
-	if err != nil {
+	if _, err := eb.store.AppendEvents(conversationID, evs); err != nil {
 		return err
 	}
 	for i := range evs {

internal/runmgr/exec_tool_artifact_test.go

@@ -77,11 +77,9 @@ func TestRunPythonRegisterArtifactBackfill(t *testing.T) {
 	if err := tools.RegisterInterpreterTools(c.mgr.registry); err != nil {
 		t.Fatal(err)
 	}
-	// 夹具必须是结构合法的最小 docx：登记口会做 OPC 结构自检，
-	// 伪 zip（PK 魔数+垃圾字节）现在会被拒绝而非登记。
 	py := c.ExecuteTool(core.ToolCallRequest{
 		CallID: "py1", Name: "run_python",
-		Arguments: json.RawMessage(`{"script":"import zipfile\nwith zipfile.ZipFile('note.docx','w') as z:\n    z.writestr('[Content_Types].xml','<?xml version=\"1.0\"?><Types/>')\n    z.writestr('word/document.xml','<?xml version=\"1.0\"?><doc/>')\n"}`),
+		Arguments: json.RawMessage(`{"script":"open('note.docx','wb').write(b'PK\\x03\\x04hello')\n"}`),
 	})
 	if py.Status != "ok" || !strings.Contains(py.Output, "exit=0") {
 		t.Fatalf("run_python: %s %s", py.Status, py.Output)

internal/runmgr/file_effect_account_check_test.go

@@ -1,173 +0,0 @@
-package runmgr
-
-import (
-	"context"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-type checkedFileEffects interface {
-	stageInputsChecked(ctx context.Context, conv core.Conversation, eff core.EffectiveSettings, files []WorkspaceFile, check func(context.Context) error) ([]string, error)
-	persistInputTextsChecked(ctx context.Context, owner, conversation string, attachments []core.ParsedDocument, check func(context.Context) error) error
-	writeSubagentRequestChecked(ctx context.Context, run core.Run, agentID, name, task, hint string, detach bool, check func(context.Context) error) error
-	writeSubagentTranscriptChecked(ctx context.Context, run core.Run, parts []core.Part, status string, check func(context.Context) error) error
-}
-
-func checkedFiles(t *testing.T, m *Manager) checkedFileEffects {
-	t.Helper()
-	c, ok := any(m).(checkedFileEffects)
-	if !ok {
-		t.Fatal("Manager is missing checked workspace/transcript file effects")
-	}
-	return c
-}
-
-func rejectAt(n int, sentinel error) (func(context.Context) error, *int) {
-	calls := 0
-	return func(ctx context.Context) error {
-		calls++
-		if calls == n {
-			return sentinel
-		}
-		return nil
-	}, &calls
-}
-
-func TestCheckedStageInputsStopsBeforeEachFileEffect(t *testing.T) {
-	root := t.TempDir()
-	m := &Manager{workspaceRoot: root}
-	c := checkedFiles(t, m)
-	conv := core.Conversation{ID: "conv", Owner: "alice"}
-	denied := errors.New("account disabled")
-	check, calls := rejectAt(3, denied)
-	paths, err := c.stageInputsChecked(context.Background(), conv, core.EffectiveSettings{}, []WorkspaceFile{
-		{Name: "first.txt", Content: []byte("first")},
-		{Name: "second.txt", Content: []byte("second")},
-	}, check)
-	if !errors.Is(err, denied) || *calls != 3 || len(paths) != 1 || paths[0] != "inputs/first.txt" {
-		t.Fatalf("late file guard: paths=%v calls=%d err=%v", paths, *calls, err)
-	}
-	dir := filepath.Join(root, "alice", "conv", "inputs")
-	if body, err := os.ReadFile(filepath.Join(dir, "first.txt")); err != nil || string(body) != "first" {
-		t.Fatalf("first file should predate rejection: %q, %v", body, err)
-	}
-	if _, err := os.Stat(filepath.Join(dir, "second.txt")); !os.IsNotExist(err) {
-		t.Fatalf("late second file was written: %v", err)
-	}
-	cancelled, cancel := context.WithCancel(context.Background())
-	cancel()
-	if _, err := c.stageInputsChecked(cancelled, core.Conversation{ID: "other", Owner: "alice"}, core.EffectiveSettings{}, nil, nil); !errors.Is(err, context.Canceled) {
-		t.Fatalf("cancelled stage: %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(root, "alice", "other")); !os.IsNotExist(err) {
-		t.Fatalf("cancelled stage created directory: %v", err)
-	}
-}
-
-func TestCheckedPersistTextRejectsBeforeWrite(t *testing.T) {
-	root := t.TempDir()
-	m := &Manager{workspaceRoot: root}
-	c := checkedFiles(t, m)
-	dir := filepath.Join(root, "alice", "conv", "inputs")
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	docs := []core.ParsedDocument{{
-		Meta:   core.DocMeta{Filename: "minutes.docx"},
-		Blocks: []core.DocBlock{{Type: core.BlockPara, Text: strings.Repeat("substantial meeting content ", 20)}},
-	}}
-	denied := errors.New("account disabled")
-	check, calls := rejectAt(1, denied)
-	if err := c.persistInputTextsChecked(context.Background(), "alice", "conv", docs, check); !errors.Is(err, denied) || *calls != 1 {
-		t.Fatalf("persist guard: calls=%d err=%v", *calls, err)
-	}
-	if _, err := os.Stat(filepath.Join(dir, "minutes.md")); !os.IsNotExist(err) {
-		t.Fatalf("persist wrote after rejection: %v", err)
-	}
-	if err := c.persistInputTextsChecked(context.Background(), "alice", "conv", docs, nil); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(dir, "minutes.md")); err != nil {
-		t.Fatalf("permitted persist missing: %v", err)
-	}
-}
-
-func TestCheckedSubagentTranscriptStopsBeforeAppendAndDoneMarker(t *testing.T) {
-	root := t.TempDir()
-	m := &Manager{workspaceRoot: root}
-	c := checkedFiles(t, m)
-	run := core.Run{ID: "child", Owner: "alice", ConversationID: "conv"}
-	denied := errors.New("account disabled")
-	check, calls := rejectAt(2, denied)
-	if err := c.writeSubagentRequestChecked(context.Background(), run, "agent", "name", "task", "", true, check); !errors.Is(err, denied) || *calls != 2 {
-		t.Fatalf("request guard: calls=%d err=%v", *calls, err)
-	}
-	dir := filepath.Join(root, "alice", "conv", "subagents", "child")
-	if _, err := os.Stat(filepath.Join(dir, "request.json")); !os.IsNotExist(err) {
-		t.Fatalf("request written after rejection: %v", err)
-	}
-	if err := c.writeSubagentRequestChecked(context.Background(), run, "agent", "name", "task", "", true, nil); err != nil {
-		t.Fatal(err)
-	}
-	check, calls = rejectAt(4, denied) // mkdir, open, first append, second append
-	parts := []core.Part{{Type: core.PartText, Text: "first"}, {Type: core.PartText, Text: "second"}}
-	if err := c.writeSubagentTranscriptChecked(context.Background(), run, parts, "completed", check); !errors.Is(err, denied) || *calls != 4 {
-		t.Fatalf("append guard: calls=%d err=%v", *calls, err)
-	}
-	body, err := os.ReadFile(filepath.Join(dir, "transcript.jsonl"))
-	if err != nil || !strings.Contains(string(body), "first") || strings.Contains(string(body), "second") {
-		t.Fatalf("transcript after rejection: %q, %v", body, err)
-	}
-	if _, err := os.Stat(filepath.Join(dir, "done.json")); !os.IsNotExist(err) {
-		t.Fatalf("done marker written after rejection: %v", err)
-	}
-}
-
-func TestCheckedResumePassesOwnerAndStopsBeforeRedispatch(t *testing.T) {
-	c, st := newSpawnEnv(t, &gateRunner{})
-	c.mgr.runner = noopRunner{}
-	c.mgr.SetWorkspaceRoot(t.TempDir())
-	parent := c.run
-	if err := st.CreateRun(&parent); err != nil {
-		t.Fatal(err)
-	}
-	child := core.Run{
-		ID: store.NewID("run"), ParentRunID: parent.ID, ConversationID: parent.ConversationID,
-		ProjectID: parent.ProjectID, Owner: parent.Owner, Kind: core.RunSubagent,
-		ProfileID: parent.ProfileID, Status: core.RunRunning, CreatedAt: time.Now().UTC(),
-	}
-	if err := st.CreateRun(&child); err != nil {
-		t.Fatal(err)
-	}
-	c.mgr.writeSubagentRequest(child, "agent.sub.explore", "name", "task", "", true)
-	if _, err := st.SealInterrupted(child.ID); err != nil {
-		t.Fatal(err)
-	}
-	before, err := st.SubagentRunIDs(parent.ConversationID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	denied := errors.New("account disabled")
-	var checkedOwner string
-	c.mgr.ResumeInterruptedChildrenChecked(context.Background(), func(_ context.Context, owner string) error {
-		checkedOwner = owner
-		return denied
-	})
-	if checkedOwner != child.Owner {
-		t.Fatalf("resume checked owner %q, want %q", checkedOwner, child.Owner)
-	}
-	after, err := st.SubagentRunIDs(parent.ConversationID)
-	if err != nil || len(after) != len(before) {
-		t.Fatalf("denied resume spawned child: before=%d after=%d err=%v", len(before), len(after), err)
-	}
-	if _, err := os.Stat(filepath.Join(c.mgr.subagentDir(child.Owner, child.ConversationID, child.ID), "resumed.json")); !os.IsNotExist(err) {
-		t.Fatalf("denied resume wrote marker: %v", err)
-	}
-}

internal/runmgr/genui_auto.go

@@ -28,7 +28,7 @@ func (m *Manager) maybeGenUIAuto(owner, convID, reason string) {
 		ConversationID: convID, Role: core.RoleSystem,
 		Parts: []core.Part{{Type: core.PartText, Text: text}},
 	}
-	_ = m.appendMessageForEffectiveAccount(owner, &msg)
+	_ = m.st.AppendMessage(&msg)
 }
 
 func planStageChanged(prev, next core.PlanSnapshot) bool {

internal/runmgr/inputs.go

@@ -1,7 +1,8 @@
 package runmgr
 
 import (
-	"context"
+	"crypto/sha256"
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -20,21 +21,16 @@ type WorkspaceFile struct {
 // StageWorkspaceInputs 把原件和可选默认模板写到 <root>/<owner>/<conversation>/inputs/。
 // root 为空时不写（工作区未配置）。返回工作区相对路径。同一批里重名的文件加序号。
 func StageWorkspaceInputs(root, owner, conversation string, files []WorkspaceFile, templateName string, template []byte) ([]string, error) {
-	return StageWorkspaceInputsChecked(context.Background(), root, owner, conversation, files, templateName, template, nil)
-}
-
-// StageWorkspaceInputsChecked rechecks the actor immediately before each
-// directory/file mutation. The caller supplies its effective-account check;
-// check and filesystem syscall cannot be atomic with an account DB commit.
-func StageWorkspaceInputsChecked(ctx context.Context, root, owner, conversation string, files []WorkspaceFile, templateName string, template []byte, check func(context.Context) error) ([]string, error) {
 	if strings.TrimSpace(root) == "" {
 		return nil, nil
 	}
 	dir := filepath.Join(root, owner, conversation, "inputs")
-	if err := checkFileEffect(ctx, check); err != nil {
+	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return nil, err
 	}
-	if err := os.MkdirAll(dir, 0o755); err != nil {
+	// Only remove a copy whose protected provenance still matches its content.
+	// Unknown legacy files and user-modified originals are never deleted by name.
+	if err := clearGeneratedTemplate(dir); err != nil {
 		return nil, err
 	}
 	var rels []string
@@ -44,10 +40,10 @@ func StageWorkspaceInputsChecked(ctx context.Context, root, owner, conversation
 		if !ok || len(file.Content) == 0 {
 			continue
 		}
-		name = uniqueInputName(name, used)
-		if err := checkFileEffect(ctx, check); err != nil {
-			return rels, err
+		if generatedTemplateName(name) {
+			name = "uploaded-" + name
 		}
+		name = uniqueInputName(name, used)
 		if err := os.WriteFile(filepath.Join(dir, name), file.Content, 0o644); err != nil {
 			return rels, err
 		}
@@ -61,25 +57,62 @@ func StageWorkspaceInputsChecked(ctx context.Context, root, owner, conversation
 			ext = filepath.Ext(base)
 		}
 		name := "_default-template" + ext
-		if err := checkFileEffect(ctx, check); err != nil {
+		existing := map[string]bool{}
+		entries, err := os.ReadDir(dir)
+		if err != nil {
 			return rels, err
 		}
+		for _, entry := range entries {
+			existing[entry.Name()] = true
+		}
+		name = uniqueInputName(name, existing)
 		if err := os.WriteFile(filepath.Join(dir, name), template, 0o644); err != nil {
 			return rels, err
 		}
+		manifest, _ := json.Marshal(templateProvenance{Name: name, Hash: fmt.Sprintf("%x", sha256.Sum256(template))})
+		if err := os.WriteFile(filepath.Join(dir, templateProvenanceFile), manifest, 0600); err != nil {
+			return rels, err
+		}
 		rels = append(rels, "inputs/"+name)
 	}
 	return rels, nil
 }
 
-func checkFileEffect(ctx context.Context, check func(context.Context) error) error {
-	if err := ctx.Err(); err != nil {
+const templateProvenanceFile = ".default-template-origin.json"
+
+type templateProvenance struct {
+	Name string `json:"name"`
+	Hash string `json:"hash"`
+}
+
+func generatedTemplateName(name string) bool {
+	return name == "_default-template" || strings.HasPrefix(name, "_default-template.") || strings.HasPrefix(name, "_default-template-")
+}
+
+func clearGeneratedTemplate(dir string) error {
+	path := filepath.Join(dir, templateProvenanceFile)
+	raw, err := os.ReadFile(path)
+	if os.IsNotExist(err) {
+		return nil
+	}
+	if err != nil {
 		return err
 	}
-	if check != nil {
-		return check(ctx)
+	var provenance templateProvenance
+	if json.Unmarshal(raw, &provenance) == nil {
+		if name, valid := safeInputName(provenance.Name); valid && name == provenance.Name && generatedTemplateName(name) {
+			body, err := os.ReadFile(filepath.Join(dir, name))
+			if err != nil && !os.IsNotExist(err) {
+				return err
+			}
+			if err == nil && fmt.Sprintf("%x", sha256.Sum256(body)) == provenance.Hash {
+				if err := os.Remove(filepath.Join(dir, name)); err != nil {
+					return err
+				}
+			}
+		}
 	}
-	return nil
+	return os.Remove(path)
 }
 
 // PersistInputTexts 把附件解析出的纯文本写成 inputs/<原名>.md，与原件并列。
@@ -87,14 +120,8 @@ func checkFileEffect(ctx context.Context, check func(context.Context) error) err
 // 「根据纪要制定方案」不再只能依赖上一轮产物（实测后续轮 0 次读原件）。
 // 原本就是文本类（md/txt/csv）的跳过；解析文本过短（<200 字）视为解析失败跳过。
 func PersistInputTexts(root, owner, conversation string, attachments []core.ParsedDocument) {
-	_ = PersistInputTextsChecked(context.Background(), root, owner, conversation, attachments, nil)
-}
-
-// PersistInputTextsChecked propagates a failed final check or file write so a
-// guarded caller stops before later extracted files are published.
-func PersistInputTextsChecked(ctx context.Context, root, owner, conversation string, attachments []core.ParsedDocument, check func(context.Context) error) error {
 	if strings.TrimSpace(root) == "" {
-		return nil
+		return
 	}
 	dir := filepath.Join(root, owner, conversation, "inputs")
 	for _, doc := range attachments {
@@ -115,14 +142,10 @@ func PersistInputTextsChecked(ctx context.Context, root, owner, conversation str
 		if _, err := os.Stat(out); err == nil {
 			continue // 已有同名解析文本（同一附件重发）不覆盖
 		}
-		if err := checkFileEffect(ctx, check); err != nil {
-			return err
-		}
-		if err := os.WriteFile(out, []byte(text), 0o644); err != nil {
-			return err
+		if err := os.WriteFile(out, []byte(text), 0o644); err == nil {
+			_ = out
 		}
 	}
-	return nil
 }
 
 // ListWorkspaceInputs 列出会话工作区 inputs/ 目录的相对路径（原样返回给环境段）。
@@ -134,10 +157,17 @@ func ListWorkspaceInputs(root, owner, conversation string, staged []string) []st
 		return staged
 	}
 	var out []string
+	current := map[string]bool{}
+	for _, path := range staged {
+		current[path] = true
+	}
 	for _, e := range ents {
 		if e.IsDir() || strings.HasPrefix(e.Name(), ".") {
 			continue
 		}
+		if generatedTemplateName(e.Name()) && !current["inputs/"+e.Name()] {
+			continue
+		}
 		out = append(out, "inputs/"+e.Name())
 	}
 	if len(out) == 0 {
@@ -147,24 +177,23 @@ func ListWorkspaceInputs(root, owner, conversation string, staged []string) []st
 }
 
 func (m *Manager) stageInputs(conv core.Conversation, eff core.EffectiveSettings, files []WorkspaceFile) ([]string, error) {
-	return m.stageInputsChecked(context.Background(), conv, eff, files, nil)
-}
-
-func (m *Manager) stageInputsChecked(ctx context.Context, conv core.Conversation, eff core.EffectiveSettings, files []WorkspaceFile, check func(context.Context) error) ([]string, error) {
 	var templateName string
 	var template []byte
 	if id := strings.TrimSpace(eff.GetString("deliverables.templateArtifactId", "")); id != "" && m.st != nil {
-		if art, err := m.st.GetArtifact(conv.Owner, id); err == nil {
-			if body, err := m.st.ArtifactContent(conv.Owner, id); err == nil && len(body) > 0 {
+		if art, err := m.st.GetArtifactByID(id); err == nil && art.ProjectID == conv.ProjectID && m.templateAllowed(conv.Owner, art) {
+			if body, err := m.st.ArtifactContentByID(id); err == nil && len(body) > 0 && m.templateAllowed(conv.Owner, art) {
 				templateName, template = art.Name, body
 			}
 		}
 	}
-	return StageWorkspaceInputsChecked(ctx, m.workspaceRoot, conv.Owner, conv.ID, files, templateName, template, check)
+	return StageWorkspaceInputs(m.workspaceRoot, conv.Owner, conv.ID, files, templateName, template)
 }
 
-func (m *Manager) persistInputTextsChecked(ctx context.Context, owner, conversation string, attachments []core.ParsedDocument, check func(context.Context) error) error {
-	return PersistInputTextsChecked(ctx, m.workspaceRoot, owner, conversation, attachments, check)
+func (m *Manager) templateAllowed(owner string, artifact core.Artifact) bool {
+	if m.artifactResourceAllow != nil {
+		return m.artifactResourceAllow(owner, artifact)
+	}
+	return artifact.Owner == owner
 }
 
 func safeInputName(name string) (string, bool) {

internal/runmgr/memory.go

@@ -12,11 +12,9 @@ import (
 // storeMemory 把 agent-native 的记忆端口接到 memory_entries 表（N3 WP5）。
 // owner/项目态由适配器持有（端口本身不传租户态）。
 type storeMemory struct {
-	st                   *store.Store
-	owner                string
-	projectID            string
-	checked              bool
-	allowImplicitDefault bool
+	st        *store.Store
+	owner     string
+	projectID string
 }
 
 // NewStoreMemory 构建端口实现（owner 为空时用默认租户）。
@@ -27,10 +25,6 @@ func NewStoreMemory(st *store.Store, owner, projectID string) memory.Store {
 	return &storeMemory{st: st, owner: owner, projectID: projectID}
 }
 
-func newAccountCheckedStoreMemory(st *store.Store, owner, projectID string, allowImplicitDefault bool) memory.Store {
-	return &storeMemory{st: st, owner: owner, projectID: projectID, checked: true, allowImplicitDefault: allowImplicitDefault}
-}
-
 // Recall 按 scope 过滤（空 = 不限，保持迁移前 Memories() 的全量语义），
 // 过期与空内容条目的剔除与文案渲染在 memory.Block（同一形态）。
 func (m *storeMemory) Recall(ctx context.Context, q memory.RecallQuery) ([]memory.Entry, error) {
@@ -65,9 +59,6 @@ func (c *runCtx) StoreMemory() memory.Store {
 	if c.mgr == nil || c.mgr.st == nil {
 		return nil
 	}
-	if c.mgr.accountEffectiveAuthorization != nil {
-		return newAccountCheckedStoreMemory(c.mgr.st, c.run.Owner, c.run.ProjectID, c.mgr.accountAllowImplicitLocal)
-	}
 	return NewStoreMemory(c.mgr.st, c.run.Owner, c.run.ProjectID)
 }
 
@@ -82,16 +73,10 @@ func (m *storeMemory) Append(ctx context.Context, e memory.Entry) error {
 	if created.IsZero() {
 		created = now
 	}
-	entry := core.MemoryEntry{
+	_, err := m.st.PutMemory(m.owner, core.MemoryEntry{
 		ID: e.ID, Scope: e.Scope, ProjectID: core.ID(projectID), Type: e.Type,
 		Content: e.Content, Source: e.Source, Confidence: e.Confidence,
 		CreatedAt: created, ExpiresAt: e.ExpiresAt,
-	}
-	var err error
-	if m.checked {
-		_, err = m.st.PutMemoryAccountChecked(m.owner, entry, m.allowImplicitDefault)
-	} else {
-		_, err = m.st.PutMemory(m.owner, entry)
-	}
+	})
 	return err
 }

internal/runmgr/rewind.go

@@ -1,7 +1,6 @@
 package runmgr
 
 import (
-	"context"
 	"fmt"
 	"log"
 	"path/filepath"
@@ -81,11 +80,6 @@ func (m *Manager) RewindFiles(owner, convID, messageID string) (checkpoint.Resul
 	if err != nil {
 		return checkpoint.Result{}, err
 	}
-	if m.accountEffectiveAuthorization != nil {
-		if err := m.authorizeAccountEffective(context.Background(), owner); err != nil {
-			return checkpoint.Result{}, err
-		}
-	}
 	res, err := cpLog.Rewind(messageID, ordered)
 	if err != nil {
 		return checkpoint.Result{}, err
@@ -99,12 +93,7 @@ func (m *Manager) RewindFiles(owner, convID, messageID string) (checkpoint.Resul
 		ConversationID: convID, Role: core.RoleSystem,
 		Parts: []core.Part{{Type: core.PartText, Text: note}},
 	}
-	if m.accountEffectiveAuthorization != nil {
-		err = m.st.AppendMessageWithRequestAccountChecked(owner, m.accountAllowImplicitLocal, &msg, "")
-	} else {
-		err = m.st.AppendMessage(&msg)
-	}
-	if err != nil {
+	if err := m.st.AppendMessage(&msg); err != nil {
 		return res, err
 	}
 	return res, nil

internal/runmgr/shared_template_test.go

@@ -0,0 +1,97 @@
+package runmgr
+
+import (
+	"agent-system-backend/internal/store"
+	core "agent-system-core"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestProjectTemplateCannotReadAnotherProjectsArtifact(t *testing.T) {
+	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "templates.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	p, _ := st.CreateProject("alice", "Current")
+	other, _ := st.CreateProject("alice", "Other")
+	artifact := core.Artifact{Owner: "alice", ProjectID: other.ID, Name: "private-template.docx"}
+	if err := st.CreateArtifact(&artifact, []byte("other project private template")); err != nil {
+		t.Fatal(err)
+	}
+	m := &Manager{st: st, workspaceRoot: t.TempDir()}
+	paths, err := m.stageInputs(core.Conversation{ID: "conversation", Owner: "alice", ProjectID: p.ID}, core.EffectiveSettings{"deliverables": map[string]any{"templateArtifactId": artifact.ID}}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(paths) != 0 {
+		t.Fatal("template settings read another project's artifact")
+	}
+}
+
+func TestSharedTemplateUsesLiveResourceAuthorityAndClearsRevokedCopy(t *testing.T) {
+	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "templates.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	p, _ := st.CreateProject("alice", "Shared")
+	artifact := core.Artifact{Owner: "alice", ProjectID: p.ID, Name: "template.docx"}
+	if err := st.CreateArtifact(&artifact, []byte("shared template")); err != nil {
+		t.Fatal(err)
+	}
+	m := &Manager{st: st, workspaceRoot: t.TempDir()}
+	allowed := true
+	m.SetArtifactResourceAllow(func(actor string, a core.Artifact) bool { return allowed && actor == "bob" && a.ID == artifact.ID })
+	conv := core.Conversation{ID: "bob-private", Owner: "bob", ProjectID: p.ID}
+	eff := core.EffectiveSettings{"deliverables": map[string]any{"templateArtifactId": artifact.ID}}
+	paths, err := m.stageInputs(conv, eff, []WorkspaceFile{{Name: "original.txt", Content: []byte("private original")}})
+	if err != nil || len(paths) != 2 {
+		t.Fatalf("authorized template: %v %v", paths, err)
+	}
+	allowed = false
+	paths, err = m.stageInputs(conv, eff, nil)
+	if err != nil || len(paths) != 0 {
+		t.Fatalf("revoked template: %v %v", paths, err)
+	}
+	if _, err := os.Stat(filepath.Join(m.workspaceRoot, "bob", conv.ID, "inputs", "_default-template.docx")); !os.IsNotExist(err) {
+		t.Fatal("revoked cached template still available")
+	}
+	if body, err := os.ReadFile(filepath.Join(m.workspaceRoot, "bob", conv.ID, "inputs", "original.txt")); err != nil || string(body) != "private original" {
+		t.Fatal("revocation removed private uploaded original")
+	}
+	// Matching ownership also goes through the registered resource policy.
+	conv.Owner = "alice"
+	if paths, err := m.stageInputs(conv, eff, nil); err != nil || len(paths) != 0 {
+		t.Fatal("owner bypassed live template resource policy")
+	}
+}
+
+func TestTemplateStagingPreservesUntrackedLegacyOriginal(t *testing.T) {
+	root := t.TempDir()
+	dir := filepath.Join(root, "alice", "conversation", "inputs")
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	legacy := filepath.Join(dir, "_default-template.docx")
+	if err := os.WriteFile(legacy, []byte("private original with legacy reserved name"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	paths, err := StageWorkspaceInputs(root, "alice", "conversation", nil, "new-template.docx", []byte("authorized generated template"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if body, err := os.ReadFile(legacy); err != nil || string(body) != "private original with legacy reserved name" {
+		t.Fatal("unknown legacy file deleted or overwritten")
+	}
+	if len(paths) != 1 || paths[0] == "inputs/_default-template.docx" {
+		t.Fatal("new generated file reused unknown original path")
+	}
+	if _, err := StageWorkspaceInputs(root, "alice", "conversation", nil, "", nil); err != nil {
+		t.Fatal(err)
+	}
+	if body, err := os.ReadFile(legacy); err != nil || string(body) != "private original with legacy reserved name" {
+		t.Fatal("revocation removed unknown original")
+	}
+}

internal/runmgr/subagent_transcript.go

@@ -1,7 +1,6 @@
 package runmgr
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -40,94 +39,51 @@ type subagentRequest struct {
 // writeSubagentRequest 在派生时落 request.json 与空转录（失败只记日志，
 // 不阻断派生——转录是辅助面）。
 func (m *Manager) writeSubagentRequest(run core.Run, agentID, name, task, hint string, detach bool) {
-	if err := m.writeSubagentRequestChecked(context.Background(), run, agentID, name, task, hint, detach, nil); err != nil {
-		log.Printf("[runmgr] subagent request %s: %v", run.ID, err)
-	}
-}
-
-// writeSubagentRequestChecked keeps transcript file effects behind an optional
-// live account check. Failures stop later file writes; this auxiliary record
-// cannot be committed atomically with the account database.
-func (m *Manager) writeSubagentRequestChecked(ctx context.Context, run core.Run, agentID, name, task, hint string, detach bool, check func(context.Context) error) error {
 	dir := m.subagentDir(run.Owner, run.ConversationID, run.ID)
 	if dir == "" {
-		return nil
-	}
-	if err := checkFileEffect(ctx, check); err != nil {
-		return err
+		return
 	}
 	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return err
+		log.Printf("[runmgr] subagent dir %s: %v", run.ID, err)
+		return
 	}
 	body, _ := json.MarshalIndent(subagentRequest{
 		AgentID: agentID, Name: name, Task: task, Hint: hint, Detach: detach,
 		CreatedAt: time.Now().UTC().Format(time.RFC3339),
 	}, "", "  ")
-	if err := checkFileEffect(ctx, check); err != nil {
-		return err
-	}
 	if err := os.WriteFile(filepath.Join(dir, "request.json"), body, 0o644); err != nil {
-		return err
+		log.Printf("[runmgr] subagent request %s: %v", run.ID, err)
 	}
 	// 转录文件先建（append 语义清晰可见）。
-	if err := checkFileEffect(ctx, check); err != nil {
-		return err
+	if _, err := os.OpenFile(filepath.Join(dir, "transcript.jsonl"), os.O_CREATE|os.O_WRONLY, 0o644); err != nil {
+		log.Printf("[runmgr] subagent transcript %s: %v", run.ID, err)
 	}
-	f, err := os.OpenFile(filepath.Join(dir, "transcript.jsonl"), os.O_CREATE|os.O_WRONLY, 0o644)
-	if err != nil {
-		return err
-	}
-	return f.Close()
 }
 
 // writeSubagentTranscript 把本次收集到的 parts 追加进转录并落 done 标记。
 // status 是终态（completed/failed/cancelled/interrupted）。
 func (m *Manager) writeSubagentTranscript(run core.Run, parts []core.Part, status string) {
-	if err := m.writeSubagentTranscriptChecked(context.Background(), run, parts, status, nil); err != nil {
-		log.Printf("[runmgr] subagent transcript %s: %v", run.ID, err)
-	}
-}
-
-func (m *Manager) writeSubagentTranscriptChecked(ctx context.Context, run core.Run, parts []core.Part, status string, check func(context.Context) error) error {
 	dir := m.subagentDir(run.Owner, run.ConversationID, run.ID)
 	if dir == "" {
-		return nil
-	}
-	if err := checkFileEffect(ctx, check); err != nil {
-		return err
+		return
 	}
 	if err := os.MkdirAll(dir, 0o755); err != nil {
-		return err
-	}
-	if err := checkFileEffect(ctx, check); err != nil {
-		return err
+		return
 	}
 	f, err := os.OpenFile(filepath.Join(dir, "transcript.jsonl"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
 	if err != nil {
-		return err
+		log.Printf("[runmgr] transcript open %s: %v", run.ID, err)
+		return
 	}
 	enc := json.NewEncoder(f)
 	for i, p := range parts {
-		if err := checkFileEffect(ctx, check); err != nil {
-			_ = f.Close()
-			return err
-		}
-		if err := enc.Encode(map[string]any{"index": i, "type": string(p.Type), "text": p.Text, "at": time.Now().UTC().Format(time.RFC3339)}); err != nil {
-			_ = f.Close()
-			return err
-		}
-	}
-	if err := f.Close(); err != nil {
-		return err
+		_ = enc.Encode(map[string]any{"index": i, "type": string(p.Type), "text": p.Text, "at": time.Now().UTC().Format(time.RFC3339)})
 	}
+	_ = f.Close()
 	done, _ := json.Marshal(map[string]string{"status": status, "endedAt": time.Now().UTC().Format(time.RFC3339)})
-	if err := checkFileEffect(ctx, check); err != nil {
-		return err
-	}
 	if err := os.WriteFile(filepath.Join(dir, "done.json"), done, 0o644); err != nil {
-		return err
+		log.Printf("[runmgr] done marker %s: %v", run.ID, err)
 	}
-	return nil
 }
 
 // doneStatus 读 done.json 的 status（无文件或不可读按 "interrupted" 处理——
@@ -166,24 +122,12 @@ func readSubagentRequest(dir string) (*subagentRequest, error) {
 // 未完成未续跑的，用原请求重新派生（后台），并把前次转录路径写进 hint
 // 供模型读取后继续（N2 WP5 的「可恢复」）。幂等：done/resumed 标记跳过。
 func (m *Manager) ResumeInterruptedChildren() {
-	m.ResumeInterruptedChildrenChecked(context.Background(), nil)
-}
-
-// ResumeInterruptedChildrenChecked rechecks each run owner before redispatch
-// and before writing the resumed marker. A disable between redispatch and the
-// marker can still leave a spawned run without this file; DB/file atomicity is
-// unavailable, so callers must keep the run admission guard as well.
-func (m *Manager) ResumeInterruptedChildrenChecked(ctx context.Context, check func(context.Context, string) error) {
 	runs, err := m.st.ListInterruptedSubagentRuns()
 	if err != nil {
 		log.Printf("[runmgr] resume scan: %v", err)
 		return
 	}
 	for _, run := range runs {
-		if err := ctx.Err(); err != nil {
-			log.Printf("[runmgr] resume cancelled: %v", err)
-			return
-		}
 		// 恢复隔离（协作存储 U3）：未知外部副作用的 run 不自动续跑——hold
 		// 未解除即跳过；判定出错同样跳过（fail-closed：宁可人工核对，不盲重派）。
 		if held, herr := m.st.HasOpenRecoveryHold(string(run.ID), string(run.ConversationID)); herr != nil || held {
@@ -218,10 +162,6 @@ func (m *Manager) ResumeInterruptedChildrenChecked(ctx context.Context, check fu
 		}
 		hint := req.Hint + "\n（本任务是前次中断后的自动续跑；前次转录在 " +
 			filepath.Join(dir, "transcript.jsonl") + "，可读取后继续。）"
-		if err := checkOwnerFileEffect(ctx, run.Owner, check); err != nil {
-			log.Printf("[runmgr] resume skip %s: account check: %v", run.ID, err)
-			continue
-		}
 		newID, err := m.spawnBackground(parent, req.AgentID, req.Name, req.Task, hint)
 		if err != nil {
 			log.Printf("[runmgr] resume spawn %s: %v", run.ID, err)
@@ -231,10 +171,6 @@ func (m *Manager) ResumeInterruptedChildrenChecked(ctx context.Context, check fu
 			"newRun":    newID,
 			"resumedAt": time.Now().UTC().Format(time.RFC3339),
 		})
-		if err := checkOwnerFileEffect(ctx, run.Owner, check); err != nil {
-			log.Printf("[runmgr] resumed marker skip %s: account check: %v", run.ID, err)
-			continue
-		}
 		if err := os.WriteFile(filepath.Join(dir, "resumed.json"), marker, 0o644); err != nil {
 			log.Printf("[runmgr] resumed marker %s: %v", run.ID, err)
 		}
@@ -242,13 +178,6 @@ func (m *Manager) ResumeInterruptedChildrenChecked(ctx context.Context, check fu
 	}
 }
 
-func checkOwnerFileEffect(ctx context.Context, owner string, check func(context.Context, string) error) error {
-	if check == nil {
-		return checkFileEffect(ctx, nil)
-	}
-	return checkFileEffect(ctx, func(ctx context.Context) error { return check(ctx, owner) })
-}
-
 func fileExists(path string) bool {
 	_, err := os.Stat(path)
 	return err == nil

internal/runtime/managed_model_test.go

@@ -0,0 +1,33 @@
+package runtime
+
+import (
+	"path/filepath"
+	"testing"
+
+	"agent-system-backend/internal/settings"
+	"agent-system-backend/internal/store"
+	core "agent-system-core"
+)
+
+func TestManagedModelsIgnorePersistedProfileRoutes(t *testing.T) {
+	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "models.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	svc := settings.NewService(st)
+	if err := svc.MergeSystem(map[string]any{"models": map[string]any{
+		"chat":        map[string]any{"model": "system-chat", "baseUrl": "https://system.example", "apiKey": "system-key"},
+		"lightweight": map[string]any{"model": "system-lite", "baseUrl": "https://lite.example", "apiKey": "lite-key"},
+	}}); err != nil {
+		t.Fatal(err)
+	}
+	prof := core.AgentProfile{Owner: "alice", Model: core.ModelRoute{Chat: "old-personal-chat", Lightweight: "old-personal-lite"}}
+	eff := svc.Effective("alice", "project")
+	if got := ResolveChatModel(prof, eff); got.Model != "system-chat" || got.Key != "system-key" {
+		t.Fatalf("personal chat route still effective: %+v", got)
+	}
+	if got := ResolveLightweightModel(prof, eff); got.Model != "system-lite" || got.Key != "lite-key" {
+		t.Fatalf("personal lightweight route still effective: %+v", got)
+	}
+}

internal/runtime/model.go

@@ -6,7 +6,8 @@ import (
 	core "agent-system-core"
 )
 
-// SecretLookup 由组合根注入。返回该服务当前生效的明文；没有独立密钥时 ok 为 false，调用方用设置里的旧字段。
+// SecretLookup is wired by the composition root. Protected services resolve only
+// system authority; ok=true with an empty value means explicit revocation.
 var SecretLookup func(owner, service string) (string, bool)
 
 // LookupSecret 给组合根以外的调用方使用。owner 为空时用 local。
@@ -21,15 +22,15 @@ func overlayKey(owner, service, fallback string) string {
 	if owner == "" {
 		owner = "local"
 	}
-	if v, ok := SecretLookup(owner, service); ok && strings.TrimSpace(v) != "" {
+	if v, ok := SecretLookup(owner, service); ok {
 		return v
 	}
 	return fallback
 }
 
-// 模型路由解析（4.7 / 4.9 覆盖链）：设置层 defaults → system → user → project，
-// 画像 ModelRoute 为会话内最高层覆盖（kind 为空回落设置层主模型）。
-// 端点与密钥按 kind 独立配置，轻量档空则回落主档。
+// Real Service.Effective snapshots carry the trusted managed-model policy and
+// ignore legacy profile routes. Unmanaged standalone runtime snapshots retain
+// their own profile semantics. Lightweight model/endpoint falls back to chat.
 
 // ContextInjection 是一条条件注入，由 runmgr 从存储读出，组装时再转换成 ctxasm 的形状。
 type ContextInjection struct {
@@ -50,10 +51,10 @@ type ResolvedModel struct {
 	Key   string
 }
 
-// ResolveChatModel 解析主对话模型（画像 route > 设置层）。
+// ResolveChatModel resolves system-managed chat settings in actual runs.
 func ResolveChatModel(prof core.AgentProfile, eff core.EffectiveSettings) ResolvedModel {
 	m := eff.GetString("models.chat.model", "")
-	if prof.Model.Chat != "" {
+	if !eff.GetBool("_policy.managedModels", false) && prof.Model.Chat != "" {
 		m = prof.Model.Chat
 	}
 	return ResolvedModel{Kind: "chat", Model: m,
@@ -80,12 +81,12 @@ func ChatFallbacks(eff core.EffectiveSettings) []string {
 	return out
 }
 
-// ResolveLightweightModel 解析轻量模型：画像 route > 设置层轻量档 > 回落主档。
+// ResolveLightweightModel resolves the managed lightweight route, then chat.
 func ResolveLightweightModel(prof core.AgentProfile, eff core.EffectiveSettings) ResolvedModel {
 	m := eff.GetString("models.lightweight.model", "")
 	base := eff.GetString("models.lightweight.baseUrl", "")
 	key := overlayKey(prof.Owner, "models.lightweight", eff.GetString("models.lightweight.apiKey", ""))
-	if prof.Model.Lightweight != "" {
+	if !eff.GetBool("_policy.managedModels", false) && prof.Model.Lightweight != "" {
 		m = prof.Model.Lightweight
 	}
 	if m == "" || base == "" {

internal/server/account_contract_test.go

@@ -1,154 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/url"
-	"testing"
-
-	"agent-system-backend/internal/store"
-)
-
-func TestAdminAccountSearchFiltersAndVersionedCursor(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	admin := bootAdmin(t, h, st)
-	alice, err := st.CreatePendingAccount("admin", "alice-search", store.AccountProfile{Name: "同名", Phone: "private-needle"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	bob, err := st.CreatePendingAccount("admin", "bob-search", store.AccountProfile{Name: "同名", Phone: "other"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	search := func(query url.Values) (int, struct {
-		Accounts []struct {
-			UserID string `json:"userId"`
-			Owner  string `json:"owner"`
-		} `json:"accounts"`
-		NextCursor string `json:"nextCursor"`
-	}) {
-		response := do(h, "GET", "/api/admin/users/search?"+query.Encode(), "", admin)
-		var page struct {
-			Accounts []struct {
-				UserID string `json:"userId"`
-				Owner  string `json:"owner"`
-			} `json:"accounts"`
-			NextCursor string `json:"nextCursor"`
-		}
-		_ = json.Unmarshal(response.Body.Bytes(), &page)
-		return response.Code, page
-	}
-	params := url.Values{"query": {"同名"}, "mode": {"fuzzy"}, "fields": {"name"}, "limit": {"1"}}
-	code, first := search(params)
-	if code != http.StatusOK || len(first.Accounts) != 1 || first.Accounts[0].UserID != alice.ID || first.NextCursor == "" {
-		t.Fatalf("first search page: %d %+v", code, first)
-	}
-	params.Set("cursor", first.NextCursor)
-	other := New(st, srv.mgr, srv.reg, srv.prof, srv.set, srv.plugins)
-	other.Auth = srv.Auth
-	h = other.Handler()
-	code, second := search(params)
-	if code != http.StatusOK || len(second.Accounts) != 1 || second.Accounts[0].UserID != bob.ID || second.NextCursor != "" {
-		t.Fatalf("second search page on another server: %d %+v", code, second)
-	}
-	params.Del("cursor")
-	params.Set("query", "private-needle")
-	params.Set("fields", "phone")
-	params.Set("mode", "exact")
-	code, contact := search(params)
-	if code != http.StatusOK || len(contact.Accounts) != 1 || contact.Accounts[0].UserID != alice.ID {
-		t.Fatalf("authorized contact search: %d %+v", code, contact)
-	}
-	params.Set("query", "同名")
-	params.Set("fields", "name")
-	params.Set("mode", "fuzzy")
-	params.Set("cursor", first.NextCursor)
-	if _, err := st.PatchAccountProfile("admin", alice.ID, alice.ProfileVersion, map[string]string{"phone": "changed-private"}); err != nil {
-		t.Fatal(err)
-	}
-	code, _ = search(params)
-	if code != http.StatusConflict {
-		t.Fatalf("private profile edit did not expire system cursor: %d", code)
-	}
-}
-
-func TestSelfProfileRequiresPasswordAuthenticatedFullSession(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	hash, err := store.HashPassword("self-profile-password")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("legacy-self", "", hash, false); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.ClearMustChangePassword("legacy-self"); err != nil {
-		t.Fatal(err)
-	}
-	legacyCookie, err := st.CreateSession("legacy-self")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rec := do(h, "GET", "/api/me", "", legacyCookie); rec.Code != http.StatusOK {
-		t.Fatalf("historical full session lost ordinary identity: %d", rec.Code)
-	}
-	if rec := do(h, "GET", "/api/me/profile", "", legacyCookie); rec.Code != http.StatusForbidden {
-		t.Fatalf("unknown session lineage read profile: %d %s", rec.Code, rec.Body.String())
-	}
-	if rec := do(h, "PATCH", "/api/me/profile", `{"expectedProfileVersion":1,"patch":{"name":"injected"}}`, legacyCookie); rec.Code != http.StatusForbidden {
-		t.Fatalf("unknown session lineage edited profile: %d %s", rec.Code, rec.Body.String())
-	}
-	login := do(h, "POST", "/api/auth/login", `{"owner":"legacy-self","password":"self-profile-password"}`, "")
-	if login.Code != http.StatusOK {
-		t.Fatalf("password login: %d %s", login.Code, login.Body.String())
-	}
-	if rec := do(h, "GET", "/api/me/profile", "", cookieOf(login)); rec.Code != http.StatusOK {
-		t.Fatalf("verified password session could not read profile: %d %s", rec.Code, rec.Body.String())
-	}
-}
-
-func TestAccountHTTPPendingCreateProfileAndDisable(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	adminCookie := bootAdmin(t, h, st)
-	for _, body := range []string{
-		`{"owner":"blocked-password","password":"old-pass-9"}`,
-		`{"owner":"blocked-admin","isAdmin":true}`,
-	} {
-		if rec := do(h, "POST", "/api/admin/users", body, adminCookie); rec.Code != http.StatusBadRequest {
-			t.Fatalf("unsafe create accepted: %d %s", rec.Code, rec.Body.String())
-		}
-	}
-	if _, err := st.GetUser("blocked-password"); err != store.ErrNotFound {
-		t.Fatalf("unsafe create had side effect: %v", err)
-	}
-	rec := do(h, "POST", "/api/admin/users", `{"owner":"alice","profile":{"name":"同名"}}`, adminCookie)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("pending create: %d %s", rec.Code, rec.Body.String())
-	}
-	var created struct {
-		UserID         string `json:"userId"`
-		Owner          string `json:"owner"`
-		ProfileVersion int64  `json:"profileVersion"`
-	}
-	if err := json.Unmarshal(rec.Body.Bytes(), &created); err != nil || created.UserID == "" || created.Owner != "alice" || created.ProfileVersion != 1 {
-		t.Fatalf("create projection: %+v %v", created, err)
-	}
-	rec = do(h, "PATCH", "/api/admin/users/"+created.UserID+"/profile", `{"expectedProfileVersion":1,"patch":{"phone":"123"}}`, adminCookie)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("profile patch: %d %s", rec.Code, rec.Body.String())
-	}
-	rec = do(h, "PATCH", "/api/admin/users/"+created.UserID+"/profile", `{"expectedProfileVersion":2,"patch":{"isAdmin":"true"}}`, adminCookie)
-	if rec.Code != http.StatusBadRequest {
-		t.Fatalf("privilege field accepted: %d %s", rec.Code, rec.Body.String())
-	}
-	rec = do(h, "PUT", "/api/admin/users/"+created.UserID+"/state", `{"expectedStateVersion":1,"enabled":false}`, adminCookie)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("disable: %d %s", rec.Code, rec.Body.String())
-	}
-	account, err := st.GetAccount(created.UserID)
-	if err != nil || account.Enabled || account.Profile.Phone != "123" {
-		t.Fatalf("state/profile after disable: %+v %v", account, err)
-	}
-}

internal/server/account_effect_guard.go

@@ -1,8 +0,0 @@
-package server
-
-// checkActorBeforeExternalEffect is the last effective-state check before a
-// process-local or filesystem effect. Such effects cannot share the account
-// database transaction, so callers must also use cancellation where available.
-func (s *Server) checkActorBeforeExternalEffect(actor string) error {
-	return s.st.CheckEffectiveAccountForExternalEffect(actor, s.Auth == nil || !s.Auth.Enabled)
-}

internal/server/account_search.go

@@ -1,204 +0,0 @@
-package server
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/json"
-	"net/http"
-	"sort"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-
-	"agent-system-backend/internal/store"
-)
-
-type adminSearchCursor struct {
-	KeyVersion int    `json:"k"`
-	Version    string `json:"v"`
-	Owner      string `json:"o"`
-	UserID     string `json:"u"`
-}
-
-func (s *Server) signAdminCursor(cursor adminSearchCursor) string {
-	cursor.KeyVersion = s.accountSearchKey.Version
-	data, _ := json.Marshal(cursor)
-	mac := hmac.New(sha256.New, s.accountSearchKey.Secret[:])
-	_, _ = mac.Write([]byte("iam-admin-search-cursor-v1\x00"))
-	_, _ = mac.Write(data)
-	return base64.RawURLEncoding.EncodeToString(data) + "." + base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
-}
-
-func (s *Server) parseAdminCursor(encoded, version string) (adminSearchCursor, bool) {
-	var cursor adminSearchCursor
-	payload, signature, found := strings.Cut(encoded, ".")
-	if !found {
-		return cursor, false
-	}
-	data, err := base64.RawURLEncoding.DecodeString(payload)
-	if err != nil || len(data) > 1024 {
-		return cursor, false
-	}
-	provided, err := base64.RawURLEncoding.DecodeString(signature)
-	if err != nil {
-		return cursor, false
-	}
-	mac := hmac.New(sha256.New, s.accountSearchKey.Secret[:])
-	_, _ = mac.Write([]byte("iam-admin-search-cursor-v1\x00"))
-	_, _ = mac.Write(data)
-	if !hmac.Equal(provided, mac.Sum(nil)) || json.Unmarshal(data, &cursor) != nil || cursor.KeyVersion != s.accountSearchKey.Version || cursor.Version != version || cursor.Owner == "" || cursor.UserID == "" {
-		return adminSearchCursor{}, false
-	}
-	return cursor, true
-}
-
-func searchAccountField(account store.Account, field string) string {
-	switch field {
-	case "userId":
-		return account.ID
-	case "owner":
-		return account.Owner
-	case "name":
-		return account.Profile.Name
-	case "phone":
-		return account.Profile.Phone
-	case "email":
-		return account.Profile.Email
-	case "staffNo":
-		return account.Profile.StaffNo
-	case "department":
-		return account.Profile.Department
-	case "notes":
-		return account.Profile.Notes
-	}
-	return ""
-}
-
-func (s *Server) searchAdminUsers(w http.ResponseWriter, r *http.Request) {
-	if s.accountSearchKeyErr != nil || s.accountSearchKey.Version < 1 {
-		http.Error(w, "account directory signing unavailable", http.StatusServiceUnavailable)
-		return
-	}
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
-		return
-	}
-	params := r.URL.Query()
-	query := strings.TrimSpace(params.Get("query"))
-	if !utf8.ValidString(query) || utf8.RuneCountInString(query) > 128 {
-		http.Error(w, "invalid account search query", http.StatusBadRequest)
-		return
-	}
-	for _, ch := range query {
-		if unicode.IsControl(ch) {
-			http.Error(w, "invalid account search query", http.StatusBadRequest)
-			return
-		}
-	}
-	mode := params.Get("mode")
-	if mode == "" {
-		mode = "fuzzy"
-	}
-	if mode != "exact" && mode != "fuzzy" {
-		http.Error(w, "unknown account search mode", http.StatusBadRequest)
-		return
-	}
-	status := params.Get("status")
-	if status == "" {
-		status = "all"
-	}
-	if status != "all" && status != "enabled" && status != "disabled" {
-		http.Error(w, "unknown account status filter", http.StatusBadRequest)
-		return
-	}
-	limit := 20
-	if raw := params.Get("limit"); raw != "" {
-		parsed, err := strconv.Atoi(raw)
-		if err != nil || parsed < 1 || parsed > 100 {
-			http.Error(w, "invalid account search limit", http.StatusBadRequest)
-			return
-		}
-		limit = parsed
-	}
-	fields := []string{"owner", "name", "userId"}
-	if raw := params.Get("fields"); raw != "" {
-		fields = strings.Split(raw, ",")
-	}
-	allowed := map[string]bool{"owner": true, "name": true, "userId": true, "phone": true, "email": true,
-		"staffNo": true, "department": true, "notes": true}
-	seen := map[string]bool{}
-	for _, field := range fields {
-		if !allowed[field] || seen[field] {
-			http.Error(w, "unknown or duplicate account search field", http.StatusBadRequest)
-			return
-		}
-		seen[field] = true
-	}
-	sort.Strings(fields)
-	accounts, revision, err := s.st.ListAdminAccountsForActor(actor)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	visibleRevision := sha256.Sum256([]byte(revision.Private))
-	directoryVersion := hex.EncodeToString(visibleRevision[:])
-	fingerprint, _ := json.Marshal(struct {
-		Actor, Query, Mode, Status, Revision string
-		Fields                               []string
-	}{actor, query, mode, status, directoryVersion, fields})
-	digest := sha256.Sum256(fingerprint)
-	version := hex.EncodeToString(digest[:])
-	var after adminSearchCursor
-	if token := params.Get("cursor"); token != "" {
-		var valid bool
-		after, valid = s.parseAdminCursor(token, version)
-		if !valid {
-			http.Error(w, "account search cursor expired or invalid", http.StatusConflict)
-			return
-		}
-	}
-	page := make([]store.Account, 0, limit+1)
-	for _, account := range accounts {
-		if status == "enabled" && !account.Enabled || status == "disabled" && account.Enabled {
-			continue
-		}
-		if after.Owner != "" && (account.Owner < after.Owner || account.Owner == after.Owner && account.ID <= after.UserID) {
-			continue
-		}
-		if query != "" {
-			matched := false
-			for _, field := range fields {
-				value := searchAccountField(account, field)
-				if mode == "exact" && strings.EqualFold(value, query) || mode == "fuzzy" && strings.Contains(strings.ToLower(value), strings.ToLower(query)) {
-					matched = true
-					break
-				}
-			}
-			if !matched {
-				continue
-			}
-		}
-		page = append(page, account)
-		if len(page) > limit {
-			break
-		}
-	}
-	more := len(page) > limit
-	if more {
-		page = page[:limit]
-	}
-	items := make([]map[string]any, 0, len(page))
-	for _, account := range page {
-		items = append(items, accountProfileJSON(account))
-	}
-	next := ""
-	if more {
-		last := page[len(page)-1]
-		next = s.signAdminCursor(adminSearchCursor{Version: version, Owner: last.Owner, UserID: last.ID})
-	}
-	w.Header().Set("Cache-Control", "no-store")
-	writeJSON(w, http.StatusOK, map[string]any{"accounts": items, "nextCursor": next, "directoryVersion": directoryVersion})
-}

internal/server/account_sse_test.go

@@ -1,78 +0,0 @@
-package server
-
-import (
-	"bufio"
-	"encoding/json"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-
-	core "agent-system-core"
-)
-
-func TestAccountDisableStopsNextSSEBusinessFrame(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	if err := st.CreateAccount("admin", "", "admin-hash", true); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("sse-user", "", "user-hash", false); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.ClearMustChangePassword("sse-user"); err != nil {
-		t.Fatal(err)
-	}
-	user, err := st.GetAccountByOwner("sse-user")
-	if err != nil {
-		t.Fatal(err)
-	}
-	project, err := st.CreateProject("sse-user", "stream")
-	if err != nil {
-		t.Fatal(err)
-	}
-	conv, err := st.CreateConversation("sse-user", project.ID, "stream", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	selected := make(chan core.StreamEvent, 1)
-	srv.Subscribe = func(string) (<-chan core.StreamEvent, func()) { return selected, func() {} }
-	token, err := st.CreateSession("sse-user")
-	if err != nil {
-		t.Fatal(err)
-	}
-	httpServer := httptest.NewServer(srv.Handler())
-	defer httpServer.Close()
-	request, err := http.NewRequest(http.MethodGet, httpServer.URL+"/api/events?conversationId="+conv.ID, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	request.AddCookie(&http.Cookie{Name: SessionCookie, Value: token})
-	client := &http.Client{Timeout: 3 * time.Second}
-	response, err := client.Do(request)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer response.Body.Close()
-	reader := bufio.NewReader(response.Body)
-	first, err := reader.ReadString('\n')
-	if err != nil || !strings.HasPrefix(first, "retry:") {
-		t.Fatalf("SSE did not open: %q %v", first, err)
-	}
-	if _, err := st.SetAccountEnabled("admin", user.ID, user.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	selected <- core.StreamEvent{ConversationID: conv.ID, Seq: 1, Type: core.EvToolOutput,
-		Payload: json.RawMessage(`{"text":"must-not-stream"}`)}
-	tail, err := io.ReadAll(reader)
-	if err != nil {
-		t.Fatalf("revoked stream did not close: %v", err)
-	}
-	if strings.Contains(string(tail), "must-not-stream") {
-		t.Fatal("disabled account received the next SSE business frame")
-	}
-	if _, _, ok := st.SessionInfo(token); ok {
-		t.Fatal("disabled account session still authenticates")
-	}
-}

internal/server/account_write_fence_test.go

@@ -1,208 +0,0 @@
-package server
-
-import (
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-type pausedRequestBody struct {
-	reader  io.Reader
-	entered chan struct{}
-	release chan struct{}
-	once    sync.Once
-}
-
-func (b *pausedRequestBody) Read(p []byte) (int, error) {
-	b.once.Do(func() { close(b.entered) })
-	<-b.release
-	return b.reader.Read(p)
-}
-
-func (*pausedRequestBody) Close() error { return nil }
-
-func TestProjectCreateCannotCommitAfterAccountDisable(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	_ = bootAdmin(t, h, st)
-	hash, err := store.HashPassword("actor-password")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("actor", "Actor", hash, false); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.ClearMustChangePassword("actor"); err != nil {
-		t.Fatal(err)
-	}
-	key, err := st.CreateAPIKey("actor", "request")
-	if err != nil {
-		t.Fatal(err)
-	}
-	account, err := st.GetAccountByOwner("actor")
-	if err != nil {
-		t.Fatal(err)
-	}
-	body := &pausedRequestBody{reader: strings.NewReader(`{"name":"late-project"}`), entered: make(chan struct{}), release: make(chan struct{})}
-	req := httptest.NewRequest(http.MethodPost, "/api/projects", body)
-	req.Header.Set("Authorization", "Bearer "+key)
-	rec := httptest.NewRecorder()
-	done := make(chan struct{})
-	go func() {
-		h.ServeHTTP(rec, req)
-		close(done)
-	}()
-	select {
-	case <-body.entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("project request never reached its body")
-	}
-	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	close(body.release)
-	select {
-	case <-done:
-	case <-time.After(3 * time.Second):
-		t.Fatal("request did not finish after disable")
-	}
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("disabled request committed: status=%d body=%s", rec.Code, rec.Body.String())
-	}
-	var n int
-	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM projects WHERE owner='actor'`).Scan(&n); err != nil || n != 0 {
-		t.Fatalf("late project row count=%d err=%v", n, err)
-	}
-}
-
-func TestUserMessageCannotCommitAfterAccountDisable(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	_ = bootAdmin(t, h, st)
-	key, err := createLegacyAPIKeyFixture(t, st, "actor", "request")
-	if err != nil {
-		t.Fatal(err)
-	}
-	account, err := st.GetAccountByOwner("actor")
-	if err != nil {
-		t.Fatal(err)
-	}
-	project, err := st.CreateProject("actor", "fixture")
-	if err != nil {
-		t.Fatal(err)
-	}
-	conversation, err := st.CreateConversation("actor", string(project.ID), "fixture", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	body := &pausedRequestBody{reader: strings.NewReader(`{"text":"late message"}`), entered: make(chan struct{}), release: make(chan struct{})}
-	req := httptest.NewRequest(http.MethodPost, "/api/conversations/"+string(conversation.ID)+"/messages", body)
-	req.Header.Set("Authorization", "Bearer "+key)
-	rec := httptest.NewRecorder()
-	done := make(chan struct{})
-	go func() {
-		h.ServeHTTP(rec, req)
-		close(done)
-	}()
-	select {
-	case <-body.entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("message request never reached its body")
-	}
-	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	close(body.release)
-	select {
-	case <-done:
-	case <-time.After(3 * time.Second):
-		t.Fatal("message request did not finish after disable")
-	}
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("disabled message request committed: status=%d body=%s", rec.Code, rec.Body.String())
-	}
-	var n int
-	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM messages WHERE conversation_id=?`, conversation.ID).Scan(&n); err != nil || n != 0 {
-		t.Fatalf("late message count=%d err=%v", n, err)
-	}
-}
-
-func TestAdminCannotDownloadOtherOwnersThroughDatabaseBackup(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	admin := bootAdmin(t, h, st)
-	rec := do(h, http.MethodPost, "/api/admin/backup", "{}", admin)
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("system admin received all-owner database backup: %d %s", rec.Code, rec.Body.String())
-	}
-}
-
-func TestRegenerationCannotChangeMessageAfterAccountDisable(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	_ = bootAdmin(t, h, st)
-	key, err := createLegacyAPIKeyFixture(t, st, "actor", "regenerate")
-	if err != nil {
-		t.Fatal(err)
-	}
-	account, err := st.GetAccountByOwner("actor")
-	if err != nil {
-		t.Fatal(err)
-	}
-	project, err := st.CreateProject("actor", "fixture")
-	if err != nil {
-		t.Fatal(err)
-	}
-	conv, err := st.CreateConversation("actor", string(project.ID), "fixture", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	user := core.Message{ConversationID: conv.ID, Role: core.RoleUser, Parts: []core.Part{{Type: core.PartText, Text: "question"}}}
-	target := core.Message{ConversationID: conv.ID, Role: core.RoleAssistant, Parts: []core.Part{{Type: core.PartText, Text: "answer"}}}
-	if err := st.AppendMessage(&user); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.AppendMessage(&target); err != nil {
-		t.Fatal(err)
-	}
-	body := &pausedRequestBody{reader: strings.NewReader(`{"messageId":"` + target.ID + `"}`), entered: make(chan struct{}), release: make(chan struct{})}
-	req := httptest.NewRequest(http.MethodPost, "/api/conversations/"+string(conv.ID)+"/regenerate", body)
-	req.Header.Set("Authorization", "Bearer "+key)
-	rec := httptest.NewRecorder()
-	done := make(chan struct{})
-	go func() {
-		h.ServeHTTP(rec, req)
-		close(done)
-	}()
-	select {
-	case <-body.entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("regeneration request never reached its body")
-	}
-	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	close(body.release)
-	select {
-	case <-done:
-	case <-time.After(3 * time.Second):
-		t.Fatal("regeneration did not finish after disable")
-	}
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("disabled regeneration status=%d body=%s", rec.Code, rec.Body.String())
-	}
-	got, err := st.MessageByID(target.ID)
-	if err != nil || got.Excluded || got.VariantGroup != "" {
-		t.Fatalf("rejected regeneration changed target: %+v %v", got, err)
-	}
-	if _, _, ok := st.PeekRegenPending(string(conv.ID)); ok {
-		t.Fatal("rejected regeneration left marker")
-	}
-}

internal/server/accounts.go

@@ -24,19 +24,6 @@ func decodeJSON(r *http.Request, v any) error {
 	return json.NewDecoder(r.Body).Decode(v)
 }
 
-func decodeStrictJSON(r *http.Request, v any) error {
-	decoder := json.NewDecoder(io.LimitReader(r.Body, 1<<20))
-	decoder.DisallowUnknownFields()
-	if err := decoder.Decode(v); err != nil {
-		return err
-	}
-	var extra any
-	if err := decoder.Decode(&extra); !errors.Is(err, io.EOF) {
-		return errors.New("exactly one JSON object required")
-	}
-	return nil
-}
-
 // 登录失败退避（进程内；管理员发放制下用户量小，进程内即可，实例重启清零）。
 var loginGuard = struct {
 	sync.Mutex
@@ -104,7 +91,6 @@ func authStateJSON(st store.UserAuthState) map[string]any {
 // redeemLoginKey：一次性登录 Key → set_password_only 会话（专用 body，不经 Bearer）。
 // 请求只有 Key：身份由服务端绑定记录确定；按来源 IP 退避防爆破。
 func (s *Server) redeemLoginKey(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Cache-Control", "no-store")
 	if s.Auth == nil || !s.Auth.Enabled {
 		http.Error(w, "auth disabled (embedded single-tenant mode)", http.StatusPreconditionFailed)
 		return
@@ -138,7 +124,6 @@ func (s *Server) redeemLoginKey(w http.ResponseWriter, r *http.Request) {
 	st, _ := s.st.GetUserAuthState(owner)
 	out := authStateJSON(st)
 	out["sessionScope"] = store.SessionScopeSetPasswordOnly
-	out["passwordChangeMode"] = store.PasswordChangeModeGrantSetup
 	out["reloginRequired"] = false
 	writeJSON(w, http.StatusOK, out)
 }
@@ -194,7 +179,6 @@ func (s *Server) login(w http.ResponseWriter, r *http.Request) {
 	setSessionCookie(w, r, token, maxAge)
 	out := authStateJSON(st)
 	out["sessionScope"] = scope
-	out["passwordChangeMode"] = store.PasswordChangeModeCurrentRequired
 	writeJSON(w, http.StatusOK, out)
 }
 
@@ -222,11 +206,6 @@ func (s *Server) changePassword(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "session expired", http.StatusUnauthorized)
 		return
 	}
-	mode, err := s.st.SessionPasswordChangeMode(tok)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
 	var req struct {
 		Current string `json:"current"`
 		Next    string `json:"next"`
@@ -244,27 +223,15 @@ func (s *Server) changePassword(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	if scope == store.SessionScopeSetPasswordOnly {
-		var completeErr error
-		switch mode {
-		case store.PasswordChangeModeGrantSetup:
-			_, completeErr = s.st.CompleteSetPasswordChecked(tok, hash)
-		case store.PasswordChangeModeCurrentRequired:
-			_, completeErr = s.st.CompleteForcedPasswordChecked(tok, req.Current, hash)
-		default:
-			http.Error(w, "unsupported password change mode", http.StatusForbidden)
-			return
-		}
-		if completeErr != nil {
-			if errors.Is(completeErr, store.ErrBadCredentials) {
-				http.Error(w, "current password incorrect", http.StatusUnauthorized)
-				return
-			}
-			if errors.Is(completeErr, store.ErrNotFound) {
+	st0, _ := s.st.GetUserAuthState(owner)
+	forceSet := scope == store.SessionScopeSetPasswordOnly || st0.MustChangePassword || !st0.HasPassword
+	if forceSet {
+		if _, err := s.st.CompleteSetPasswordChecked(tok, hash); err != nil {
+			if errors.Is(err, store.ErrNotFound) {
 				http.Error(w, "session expired", http.StatusUnauthorized)
 				return
 			}
-			writeStoreErr(w, completeErr)
+			writeStoreErr(w, err)
 			return
 		}
 		setSessionCookie(w, r, "", -1)
@@ -303,7 +270,7 @@ func validPassword(pw string) error {
 func (s *Server) requireAdmin(w http.ResponseWriter, r *http.Request) (string, bool) {
 	owner := s.owner(r)
 	st, err := s.st.GetUserAuthState(owner)
-	if err != nil || !st.Enabled || !st.IsAdmin || s.Auth == nil || !s.Auth.Enabled {
+	if err != nil || !st.IsAdmin {
 		http.Error(w, "admin required", http.StatusForbidden)
 		return "", false
 	}
@@ -324,10 +291,12 @@ func (s *Server) createAdminUser(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	var req struct {
-		Owner   string               `json:"owner"`
-		Profile store.AccountProfile `json:"profile"`
+		Owner    string `json:"owner"`
+		Name     string `json:"name"`
+		Password string `json:"password"`
+		IsAdmin  bool   `json:"isAdmin"`
 	}
-	if err := decodeStrictJSON(r, &req); err != nil {
+	if err := decodeJSON(r, &req); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
@@ -336,139 +305,59 @@ func (s *Server) createAdminUser(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "owner required (no spaces or slashes)", http.StatusBadRequest)
 		return
 	}
-	account, err := s.st.CreatePendingAccount(actor, req.Owner, req.Profile)
+	if err := validPassword(req.Password); err != nil {
+		http.Error(w, "initial password must be 8+ characters", http.StatusBadRequest)
+		return
+	}
+	hash, err := store.HashPassword(req.Password)
 	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if _, err := s.st.CreateActivatedAccount(store.AccountWrite{Owner: req.Owner, Name: strings.TrimSpace(req.Name), PasswordHash: hash, IsAdmin: req.IsAdmin, Actor: actor, Action: "account.create"}); err != nil {
 		writeStoreErr(w, err)
 		return
 	}
-	writeJSON(w, http.StatusOK, accountProfileJSON(account))
-}
-
-func accountProfileJSON(account store.Account) map[string]any {
-	return map[string]any{
-		"userId": account.ID, "owner": account.Owner, "profile": account.Profile,
-		"profileVersion": account.ProfileVersion, "enabled": account.Enabled,
-		"stateVersion": account.StateVersion, "isAdmin": account.IsAdmin,
-		"passwordSet": account.HasPassword, "initializationState": account.InitializationState,
-		"initializationGeneration": account.InitializationGeneration,
-	}
-}
-
-func (s *Server) requireFullPasswordSession(w http.ResponseWriter, r *http.Request) (string, bool) {
-	if s.Auth == nil || !s.Auth.Enabled || AuthVia(r) != AuthViaSession || SessionScope(r) != store.SessionScopeFull {
-		http.Error(w, "full password session required", http.StatusForbidden)
-		return "", false
-	}
-	token := sessionToken(r)
-	owner, scope, valid := s.st.SessionInfo(token)
-	if !valid || scope != store.SessionScopeFull || owner != s.owner(r) {
-		http.Error(w, "full password session required", http.StatusForbidden)
-		return "", false
-	}
-	st, err := s.st.GetUserAuthState(owner)
-	if err != nil || !st.Enabled || st.MustChangePassword || !st.HasPassword {
-		http.Error(w, "full password session required", http.StatusForbidden)
-		return "", false
-	}
-	method, err := s.st.SessionAuthMethod(token)
-	if err != nil || method != store.AuthMethodPassword {
-		http.Error(w, "password-authenticated session required", http.StatusForbidden)
-		return "", false
-	}
-	return owner, true
-}
-
-func (s *Server) meProfile(w http.ResponseWriter, r *http.Request) {
-	owner, ok := s.requireFullPasswordSession(w, r)
-	if !ok {
-		return
-	}
-	account, err := s.st.GetAccountByOwner(owner)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	writeJSON(w, http.StatusOK, accountProfileJSON(account))
-}
-
-func (s *Server) patchMeProfile(w http.ResponseWriter, r *http.Request) {
-	owner, ok := s.requireFullPasswordSession(w, r)
-	if !ok {
-		return
-	}
-	account, err := s.st.GetAccountByOwner(owner)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	s.patchAccountProfile(w, r, owner, account.ID)
-}
-
-func (s *Server) adminAccount(w http.ResponseWriter, r *http.Request) {
-	if _, ok := s.requireAdmin(w, r); !ok {
-		return
-	}
-	account, err := s.st.GetAccount(r.PathValue("userId"))
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	writeJSON(w, http.StatusOK, accountProfileJSON(account))
-}
-
-func (s *Server) patchAdminAccountProfile(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
-		return
-	}
-	s.patchAccountProfile(w, r, actor, r.PathValue("userId"))
-}
-
-func (s *Server) patchAccountProfile(w http.ResponseWriter, r *http.Request, actor, userID string) {
-	var req struct {
-		ExpectedProfileVersion int64             `json:"expectedProfileVersion"`
-		Patch                  map[string]string `json:"patch"`
-	}
-	if err := decodeStrictJSON(r, &req); err != nil || req.Patch == nil {
-		http.Error(w, "invalid profile patch", http.StatusBadRequest)
-		return
-	}
-	account, err := s.st.PatchAccountProfile(actor, userID, req.ExpectedProfileVersion, req.Patch)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	writeJSON(w, http.StatusOK, accountProfileJSON(account))
-}
-
-func (s *Server) setAdminAccountState(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
-		return
-	}
-	var req struct {
-		ExpectedStateVersion int64 `json:"expectedStateVersion"`
-		Enabled              *bool `json:"enabled"`
-	}
-	if err := decodeStrictJSON(r, &req); err != nil || req.Enabled == nil {
-		http.Error(w, "invalid state change", http.StatusBadRequest)
-		return
-	}
-	account, err := s.st.SetAccountEnabled(actor, r.PathValue("userId"), req.ExpectedStateVersion, *req.Enabled)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	writeJSON(w, http.StatusOK, accountProfileJSON(account))
+	st, _ := s.st.GetUserAuthState(req.Owner)
+	writeJSON(w, http.StatusOK, map[string]any{
+		"owner": st.Owner, "name": st.Name, "isAdmin": st.IsAdmin,
+		"mustChangePassword": st.MustChangePassword,
+	})
 }
 
 // resetAdminUserPassword：管理员直接重置密码（兼容保留的既有入口；常规恢复
 // 走签发一次性登录 Key）。单事务：must_change=1、bump auth_version、作废未用
 // 登录 Key、吊销全部会话、审计。
 func (s *Server) resetAdminUserPassword(w http.ResponseWriter, r *http.Request) {
-	if _, ok := s.requireAdmin(w, r); ok {
-		http.Error(w, "RECOVERY_CONTRACT_REPLACED: propose recovery instead", http.StatusGone)
+	actor, ok := s.requireAdmin(w, r)
+	if !ok {
+		return
 	}
+	owner := r.PathValue("owner")
+	var req struct {
+		Password string `json:"password"`
+	}
+	if err := decodeJSON(r, &req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if err := validPassword(req.Password); err != nil {
+		http.Error(w, "new password must be 8+ characters", http.StatusBadRequest)
+		return
+	}
+	hash, err := store.HashPassword(req.Password)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if err := s.st.AdminResetUserPassword(owner, hash, actor, "admin-http"); err != nil {
+		writeStoreErr(w, err)
+		return
+	}
+	st, _ := s.st.GetUserAuthState(owner)
+	writeJSON(w, http.StatusOK, map[string]any{
+		"owner": st.Owner, "mustChangePassword": st.MustChangePassword,
+	})
 }
 
 // ---- 管理员：一次性登录 Key（恢复流程主入口）----
@@ -476,9 +365,38 @@ func (s *Server) resetAdminUserPassword(w http.ResponseWriter, r *http.Request)
 // issueAdminLoginKey：为指定既有用户签发恢复 Key（明文仅本次响应返回）。
 // 同事务撤销旧恢复 Key 及其受限会话；不改密码、不吊销正常会话、不动业务数据。
 func (s *Server) issueAdminLoginKey(w http.ResponseWriter, r *http.Request) {
-	if _, ok := s.requireAdmin(w, r); ok {
-		http.Error(w, "RECOVERY_CONTRACT_REPLACED: propose recovery instead", http.StatusGone)
+	actor, ok := s.requireAdmin(w, r)
+	if !ok {
+		return
 	}
+	owner := strings.TrimSpace(r.PathValue("owner"))
+	var req struct {
+		Purpose    string `json:"purpose"`
+		TTLMinutes int    `json:"ttlMinutes"`
+	}
+	if err := decodeJSON(r, &req); err != nil && !errors.Is(err, io.EOF) {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	purpose := req.Purpose
+	if purpose == "" {
+		purpose = store.LoginKeyPurposeRecover
+	}
+	if purpose != store.LoginKeyPurposeRecover && purpose != store.LoginKeyPurposeActivate {
+		http.Error(w, "purpose must be recover or activate", http.StatusBadRequest)
+		return
+	}
+	ttl := time.Duration(req.TTLMinutes) * time.Minute
+	plain, meta, err := s.st.IssueLoginKey(owner, purpose, actor, ttl)
+	if err != nil {
+		writeStoreErr(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"id": meta.ID, "owner": meta.Owner, "purpose": meta.Purpose,
+		"status": meta.Status, "expiresAt": meta.ExpiresAt, "createdBy": meta.CreatedBy,
+		"key": plain, // 明文仅此一次；关闭弹层后不可再取
+	})
 }
 
 // listAdminLoginKeys：指定用户的 Key 状态与有效期（不返回明文）。
@@ -496,7 +414,7 @@ func (s *Server) revokeAdminLoginKey(w http.ResponseWriter, r *http.Request) {
 	if !ok {
 		return
 	}
-	if err := s.st.RevokeLoginKeyCascadeAdmin(actor, r.PathValue("owner"), r.PathValue("id")); err != nil {
+	if _, err := s.st.RevokeLoginKeyCascade(r.PathValue("id"), actor); err != nil {
 		writeStoreErr(w, err)
 		return
 	}
@@ -524,8 +442,7 @@ func (s *Server) listRecoveryHolds(w http.ResponseWriter, r *http.Request) {
 // releaseRecoveryHold 人工解除单条 hold（幂等）；解除后该 run 才可能被再次
 // 续跑/接管。副作用未核对就解除的风险由操作者承担——与 task-close 同级谨慎。
 func (s *Server) releaseRecoveryHold(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
+	if _, ok := s.requireAdmin(w, r); !ok {
 		return
 	}
 	runID := r.PathValue("runId")
@@ -533,5 +450,5 @@ func (s *Server) releaseRecoveryHold(w http.ResponseWriter, r *http.Request) {
 		writeStoreErr(w, err)
 		return
 	}
-	writeOKOr(w, s.st.ReleaseRecoveryHoldAccountChecked(actor, runID, s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.ReleaseRecoveryHold(runID))
 }

internal/server/adminzone_test.go

@@ -46,7 +46,7 @@ func TestListAdminZoneSections(t *testing.T) {
 		}},
 	}
 	h := srv.Handler()
-	key, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	key, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/api_key_fixture_test.go

@@ -1,17 +0,0 @@
-package server
-
-import (
-	"testing"
-
-	"agent-system-backend/internal/store"
-)
-
-// createLegacyAPIKeyFixture creates the historical integration identity
-// explicitly before exercising the formal, non-creating key issuance path.
-func createLegacyAPIKeyFixture(t *testing.T, st *store.Store, owner, name string) (string, error) {
-	t.Helper()
-	if err := st.EnsureUser(owner, ""); err != nil {
-		t.Fatal(err)
-	}
-	return st.CreateAPIKey(owner, name)
-}

internal/server/audit_scope_test.go

@@ -17,11 +17,11 @@ func TestCommandAuditOwnerScoping(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
 
-	aliceKey, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	aliceKey, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	bobKey, err := createLegacyAPIKeyFixture(t, st, "bob", "e2e")
+	bobKey, err := st.CreateAPIKey("bob", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/auth.go

@@ -46,7 +46,7 @@ func (a *Authenticator) Middleware(next http.Handler) http.Handler {
 		}
 		p := r.URL.Path
 		// 豁免：静态前端、登录、一次性 Key 兑换（body 专用，不走 Bearer）。
-		if !strings.HasPrefix(p, "/api/") || p == "/api/auth/login" || p == "/api/auth/login-key/redeem" || p == "/api/auth/recovery-grants/redeem" {
+		if !strings.HasPrefix(p, "/api/") || p == "/api/auth/login" || p == "/api/auth/login-key/redeem" {
 			next.ServeHTTP(w, r)
 			return
 		}
@@ -54,10 +54,6 @@ func (a *Authenticator) Middleware(next http.Handler) http.Handler {
 		if key == "" {
 			key = r.URL.Query().Get("key")
 		}
-		if key != "" && sessionToken(r) != "" {
-			http.Error(w, "conflicting credentials", http.StatusUnauthorized)
-			return
-		}
 		// 一次性登录 Key 不得经 Bearer / ?key= 使用。
 		if strings.HasPrefix(key, "alk_") {
 			http.Error(w, "unauthorized: one-time login keys must use /api/auth/login-key/redeem", http.StatusUnauthorized)
@@ -70,6 +66,8 @@ func (a *Authenticator) Middleware(next http.Handler) http.Handler {
 		if key != "" {
 			if o, keyOK := a.st.AuthOwner(key); keyOK {
 				owner, via, scope, ok = o, AuthViaKey, store.SessionScopeFull, true
+			} else if o, sc, sessOK := cookieSession(r, a.st); sessOK {
+				owner, via, scope, ok = o, AuthViaSession, sc, true
 			} else {
 				http.Error(w, "unauthorized: invalid or revoked API key", http.StatusUnauthorized)
 				return
@@ -101,9 +99,8 @@ func (a *Authenticator) enforcePasswordGate(w http.ResponseWriter, r *http.Reque
 		return nil
 	}
 	st, err := a.st.GetUserAuthState(owner)
-	if err != nil || !st.Enabled {
-		http.Error(w, "unauthorized: account unavailable", http.StatusUnauthorized)
-		return errGate
+	if err != nil {
+		return nil
 	}
 	// 长期 API Key：仅当 must_change（已有密码待改）时拒绝业务，防止绕过改密门；
 	// 无密码的纯集成账户仍可走 Key（与历史 apikey 语义兼容）。

internal/server/auth_e2e_test.go

@@ -36,11 +36,7 @@ func newAuthTestServer(t *testing.T) (*Server, *store.Store) {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { st.Close() })
-	return newAuthTestServerOnStore(t, st, dir), st
-}
 
-func newAuthTestServerOnStore(t *testing.T, st *store.Store, dir string) *Server {
-	t.Helper()
 	b := bus.New()
 	reg := tools.NewRegistry()
 	reg.RegisterBuiltin()
@@ -52,7 +48,7 @@ func newAuthTestServerOnStore(t *testing.T, st *store.Store, dir string) *Server
 	srv := New(st, mgr, reg, profSvc, setSvc, ph)
 	srv.Auth = NewAuthenticator(st, true)
 	srv.Subscribe = func(cid string) (<-chan core.StreamEvent, func()) { return b.Subscribe(cid) }
-	return srv
+	return srv, st
 }
 
 func TestAuthMiddleware(t *testing.T) {
@@ -68,7 +64,7 @@ func TestAuthMiddleware(t *testing.T) {
 	}
 
 	// 创建密钥。
-	key, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	key, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -107,8 +103,8 @@ func TestAuthMiddleware(t *testing.T) {
 func TestTenantIsolationHTTP(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	keyA, _ := createLegacyAPIKeyFixture(t, st, "alice", "a")
-	keyB, _ := createLegacyAPIKeyFixture(t, st, "bob", "b")
+	keyA, _ := st.CreateAPIKey("alice", "a")
+	keyB, _ := st.CreateAPIKey("bob", "b")
 
 	do := func(key, method, path string, body any) int {
 		var buf bytes.Buffer
@@ -332,8 +328,8 @@ func TestAdminAccountFlow(t *testing.T) {
 	if rec := session("POST", "/api/admin/users", `{"owner":"alice","name":"爱丽丝","password":"alice-init-01"}`); rec.Code != http.StatusForbidden {
 		t.Fatalf("must_change admin must be gated before create: %d %s", rec.Code, rec.Body.String())
 	}
-	// 历史初始密码必须提供 current；成功后销毁会话，须重新密码登录。
-	if rec := session("POST", "/api/auth/password", `{"current":"boot-pass-00","next":"admin-final-9"}`); rec.Code != http.StatusOK ||
+	// 首登改密：不要求 current；成功后销毁会话，须重新密码登录。
+	if rec := session("POST", "/api/auth/password", `{"next":"admin-final-9"}`); rec.Code != http.StatusOK ||
 		!strings.Contains(rec.Body.String(), `"reloginRequired":true`) {
 		t.Fatalf("admin force set-password: %d %s", rec.Code, rec.Body.String())
 	}
@@ -349,21 +345,14 @@ func TestAdminAccountFlow(t *testing.T) {
 	}
 	tok = strings.Split(strings.Split(rec.Header().Get("Set-Cookie"), SessionCookie+"=")[1], ";")[0]
 
-	// 管理员只建无凭据的普通账号；历史强制改密夹具由 Store 直接设置。
-	if rec := session("POST", "/api/admin/users", `{"owner":"alice","profile":{"name":"爱丽丝"}}`); rec.Code != http.StatusOK {
+	// 管理员建号（普通用户，初始密码）。
+	if rec := session("POST", "/api/admin/users", `{"owner":"alice","name":"爱丽丝","password":"alice-init-01"}`); rec.Code != http.StatusOK {
 		t.Fatalf("admin create user: %d %s", rec.Code, rec.Body.String())
 	}
 	// 重名冲突 409。
-	if rec := session("POST", "/api/admin/users", `{"owner":"alice"}`); rec.Code != http.StatusConflict {
+	if rec := session("POST", "/api/admin/users", `{"owner":"alice","password":"alice-init-01"}`); rec.Code != http.StatusConflict {
 		t.Fatalf("duplicate owner must 409: %d", rec.Code)
 	}
-	legacyHash, err := store.HashPassword("alice-init-01")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := st.SetUserPassword("alice", legacyHash); err != nil {
-		t.Fatal(err)
-	}
 
 	// alice 首登：mustChangePassword=true；业务 API 被设密门拒绝。
 	req = httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"owner":"alice","password":"alice-init-01"}`))
@@ -391,11 +380,11 @@ func TestAdminAccountFlow(t *testing.T) {
 	if rec := alice("POST", "/api/admin/users", `{"owner":"bob","password":"bob-init-001"}`); rec.Code != http.StatusForbidden {
 		t.Fatalf("must_change non-admin create must 403: %d", rec.Code)
 	}
-	// must_change 改密要求 current；短密码拒绝；成功后 reloginRequired。
+	// must_change 改密忽略 current；短密码拒绝；成功后 reloginRequired。
 	if rec := alice("POST", "/api/auth/password", `{"next":"short"}`); rec.Code != http.StatusBadRequest {
 		t.Fatalf("short password must 400: %d", rec.Code)
 	}
-	if rec := alice("POST", "/api/auth/password", `{"current":"alice-init-01","next":"alice-final-9"}`); rec.Code != http.StatusOK ||
+	if rec := alice("POST", "/api/auth/password", `{"current":"ignored","next":"alice-final-9"}`); rec.Code != http.StatusOK ||
 		!strings.Contains(rec.Body.String(), `"reloginRequired":true`) {
 		t.Fatalf("alice force set-password: %d %s", rec.Code, rec.Body.String())
 	}
@@ -423,23 +412,23 @@ func TestAdminAccountFlow(t *testing.T) {
 		t.Fatalf("non-admin create must 403: %d", rec.Code)
 	}
 
-	// 旧管理员重置入口关闭，不能动 alice 的密码与当前会话。
-	if rec := session("POST", "/api/admin/users/alice/password", `{"password":"reset-init-02"}`); rec.Code != http.StatusGone {
-		t.Fatalf("admin reset must be closed: %d %s", rec.Code, rec.Body.String())
+	// 管理员重置 alice 密码 → 其旧会话吊销 + 首登再改密。
+	if rec := session("POST", "/api/admin/users/alice/password", `{"password":"reset-init-02"}`); rec.Code != http.StatusOK {
+		t.Fatalf("admin reset: %d %s", rec.Code, rec.Body.String())
 	}
-	if rec := alice("GET", "/api/me", ""); rec.Code != http.StatusOK {
-		t.Fatalf("closed reset must preserve alice session: %d", rec.Code)
+	if rec := alice("GET", "/api/me", ""); rec.Code != http.StatusUnauthorized {
+		t.Fatalf("alice old session must be revoked after reset: %d", rec.Code)
 	}
-	req = httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"owner":"alice","password":"alice-final-9"}`))
+	req = httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"owner":"alice","password":"reset-init-02"}`))
 	req.Header.Set("Content-Type", "application/json")
 	rec = httptest.NewRecorder()
 	h.ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK || strings.Contains(rec.Body.String(), `"mustChangePassword":true`) {
-		t.Fatalf("closed reset must preserve normal login: %d %s", rec.Code, rec.Body.String())
+	if !strings.Contains(rec.Body.String(), `"mustChangePassword":true`) {
+		t.Fatalf("reset must force change on next login: %s", rec.Body.String())
 	}
 
 	// API key 通道兼容：密钥登录照旧（并具备其 owner 身份）。
-	key, err := createLegacyAPIKeyFixture(t, st, "admin", "cli")
+	key, err := st.CreateAPIKey("admin", "cli")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -458,7 +447,7 @@ func TestAdminAccountFlow(t *testing.T) {
 		rec = httptest.NewRecorder()
 		h.ServeHTTP(rec, req)
 	}
-	req = httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"owner":"alice","password":"alice-final-9"}`))
+	req = httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"owner":"alice","password":"reset-init-02"}`))
 	req.Header.Set("Content-Type", "application/json")
 	rec = httptest.NewRecorder()
 	h.ServeHTTP(rec, req)
@@ -475,8 +464,8 @@ func TestAdminAccountFlow(t *testing.T) {
 	}
 }
 
-// TestStaleKeySessionFallback：混合 Bearer 与 cookie 的认证上下文不确定，必须拒绝。
-// /api/me 的 authVia 仍区分单独有效的 key / session。
+// TestStaleKeySessionFallback：浏览器残留失效 Bearer key 时，有效会话不被一票否决；
+// /api/me 的 authVia 区分凭证通道（key / session），供前端区分改密门放行范围。
 func TestStaleKeySessionFallback(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
@@ -497,14 +486,14 @@ func TestStaleKeySessionFallback(t *testing.T) {
 	}
 	tok := strings.Split(strings.Split(rec.Header().Get("Set-Cookie"), SessionCookie+"=")[1], ";")[0]
 
-	// 会话 + 失效 key：拒绝混合凭证，不把有效 cookie 当证明兜底。
+	// 会话 + 失效 key：回落会话（200，authVia=session），不再被 key 一票否决。
 	req = httptest.NewRequest("GET", "/api/me", nil)
 	req.AddCookie(&http.Cookie{Name: SessionCookie, Value: tok})
 	req.Header.Set("Authorization", "Bearer ask_stale_key")
 	rec = httptest.NewRecorder()
 	h.ServeHTTP(rec, req)
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("stale key + valid session must be rejected: %d %s", rec.Code, rec.Body.String())
+	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"authVia":"session"`) {
+		t.Fatalf("stale key + valid session must fall back to session: %d %s", rec.Code, rec.Body.String())
 	}
 
 	// 失效 key 且无会话：仍 401（key 专属文案）。
@@ -517,7 +506,7 @@ func TestStaleKeySessionFallback(t *testing.T) {
 	}
 
 	// 有效 key：authVia=key。
-	key, err := createLegacyAPIKeyFixture(t, st, "carol", "cli")
+	key, err := st.CreateAPIKey("carol", "cli")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -555,11 +544,11 @@ func TestSystemSettingsAdminGate(t *testing.T) {
 	if err := st.CreateAccount("dave", "普通乙", hash, false); err != nil {
 		t.Fatal(err)
 	}
-	keyBoss, err := createLegacyAPIKeyFixture(t, st, "boss", "cli")
+	keyBoss, err := st.CreateAPIKey("boss", "cli")
 	if err != nil {
 		t.Fatal(err)
 	}
-	keyDave, err := createLegacyAPIKeyFixture(t, st, "dave", "cli")
+	keyDave, err := st.CreateAPIKey("dave", "cli")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -600,7 +589,7 @@ func TestSystemSettingsAdminGate(t *testing.T) {
 	}
 
 	// 管理员：写入生效，系统读面掩码返回，dave 的有效设置拿到系统值。
-	if rec := do(keyBoss, "PUT", "/api/settings/system", `{"models":{"chat":{"model":"m-boss","apiKey":"sk-boss-secret"}}}`); rec.Code != http.StatusOK {
+	if rec := do(keyBoss, "PUT", "/api/settings/system", `{"values":{"models":{"chat":{"model":"m-boss","apiKey":"sk-boss-secret"}}},"expectedRevision":0}`); rec.Code != http.StatusOK {
 		t.Fatalf("boss put system: %d %s", rec.Code, rec.Body.String())
 	}
 	rec := do(keyBoss, "GET", "/api/settings/system", "")

internal/server/borrow.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	agentcommand "agent-command"
+	"agent-system-backend/internal/settings"
 	"agent-system-backend/internal/store"
 	core "agent-system-core"
 )
@@ -15,7 +16,13 @@ var userCommandSlug = regexp.MustCompile(`^[a-z][a-z0-9-]*$`)
 
 func (s *Server) listSecrets(w http.ResponseWriter, r *http.Request) {
 	list, err := s.st.ListSecrets(s.owner(r))
-	writeJSONOr(w, list, err)
+	filtered := make([]store.Secret, 0, len(list))
+	for _, secret := range list {
+		if !settings.ProtectedSecretService(secret.Service) {
+			filtered = append(filtered, secret)
+		}
+	}
+	writeJSONOr(w, filtered, err)
 }
 
 func (s *Server) createSecret(w http.ResponseWriter, r *http.Request) {
@@ -28,23 +35,29 @@ func (s *Server) createSecret(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	if strings.TrimSpace(req.Service) == "" || strings.TrimSpace(req.Value) == "" {
-		http.Error(w, "store: secret service and value are required", http.StatusBadRequest)
+	if settings.ProtectedSecretService(strings.TrimSpace(req.Service)) {
+		http.Error(w, "模型和搜索服务密钥只能在系统设置中配置", http.StatusBadRequest)
 		return
 	}
-	sec, err := s.st.AddSecretAccountChecked(s.owner(r), req.Service, req.Label, req.Value, s.Auth == nil || !s.Auth.Enabled)
+	sec, err := s.st.AddSecret(s.owner(r), req.Service, req.Label, req.Value)
 	if err != nil {
-		writeStoreErr(w, err)
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	writeJSON(w, http.StatusOK, sec)
 }
 
 func (s *Server) activateSecret(w http.ResponseWriter, r *http.Request) {
-	writeOKOr(w, s.st.ActivateSecretAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	if !s.mutablePersonalSecret(w, r) {
+		return
+	}
+	writeOKOr(w, s.st.ActivateSecret(s.owner(r), r.PathValue("id")))
 }
 
 func (s *Server) renameSecret(w http.ResponseWriter, r *http.Request) {
+	if !s.mutablePersonalSecret(w, r) {
+		return
+	}
 	var req struct {
 		Label string `json:"label"`
 	}
@@ -52,11 +65,29 @@ func (s *Server) renameSecret(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	writeOKOr(w, s.st.RenameSecretAccountChecked(s.owner(r), r.PathValue("id"), req.Label, s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.RenameSecret(s.owner(r), r.PathValue("id"), req.Label))
 }
 
 func (s *Server) deleteSecret(w http.ResponseWriter, r *http.Request) {
-	writeOKOr(w, s.st.DeleteSecretAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	if !s.mutablePersonalSecret(w, r) {
+		return
+	}
+	writeOKOr(w, s.st.DeleteSecret(s.owner(r), r.PathValue("id")))
+}
+
+func (s *Server) mutablePersonalSecret(w http.ResponseWriter, r *http.Request) bool {
+	list, err := s.st.ListSecrets(s.owner(r))
+	if err != nil {
+		writeStoreErr(w, err)
+		return false
+	}
+	for _, secret := range list {
+		if secret.ID == r.PathValue("id") && settings.ProtectedSecretService(secret.Service) {
+			http.Error(w, "旧模型和搜索服务密钥已退出生效链；请在系统设置中配置", http.StatusBadRequest)
+			return false
+		}
+	}
+	return true
 }
 
 func (s *Server) listContextEntries(w http.ResponseWriter, r *http.Request) {
@@ -71,20 +102,16 @@ func (s *Server) saveContextEntry(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	if strings.TrimSpace(e.Content) == "" {
-		http.Error(w, "store: entry content required", http.StatusBadRequest)
-		return
-	}
-	saved, err := s.st.SaveContextEntryAccountChecked(s.owner(r), e, s.Auth == nil || !s.Auth.Enabled)
+	saved, err := s.st.SaveContextEntry(s.owner(r), e)
 	if err != nil {
-		writeStoreErr(w, err)
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	writeJSON(w, http.StatusOK, saved)
 }
 
 func (s *Server) deleteContextEntry(w http.ResponseWriter, r *http.Request) {
-	writeOKOr(w, s.st.DeleteContextEntryAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.DeleteContextEntry(s.owner(r), r.PathValue("id")))
 }
 
 func (s *Server) listUserPromptCommands(w http.ResponseWriter, r *http.Request) {
@@ -98,46 +125,31 @@ func (s *Server) saveUserPromptCommand(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	if strings.TrimSpace(c.Template) == "" {
-		http.Error(w, "store: command template required", http.StatusBadRequest)
-		return
-	}
-	owner := s.owner(r)
-	allowImplicitDefault := s.Auth == nil || !s.Auth.Enabled
-	saved, err := s.st.SaveUserCommandAccountChecked(owner, c, allowImplicitDefault)
+	saved, err := s.st.SaveUserCommand(s.owner(r), c)
 	if err != nil {
-		writeStoreErr(w, err)
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	if s.Bus != nil {
-		// The Bus is outside the database transaction. Recheck immediately before
-		// mutation; a disable between this check and RegisterUser remains possible.
-		if err := s.st.CheckEffectiveAccountForExternalEffect(owner, allowImplicitDefault); err != nil {
-			writeStoreErr(w, err)
-			return
-		}
-		s.registerUserPrompt(saved)
-	}
+	s.registerUserPrompt(saved)
 	writeJSON(w, http.StatusOK, saved)
 }
 
 func (s *Server) deleteUserPromptCommand(w http.ResponseWriter, r *http.Request) {
 	owner := s.owner(r)
 	id := r.PathValue("id")
-	allowImplicitDefault := s.Auth == nil || !s.Auth.Enabled
-	deleted, err := s.st.DeleteUserCommandAccountChecked(owner, id, allowImplicitDefault)
-	if err != nil {
+	list, _ := s.st.ListUserCommands(owner)
+	var name string
+	for _, c := range list {
+		if c.ID == id {
+			name = c.Name
+		}
+	}
+	if err := s.st.DeleteUserCommand(owner, id); err != nil {
 		writeStoreErr(w, err)
 		return
 	}
-	if s.Bus != nil && deleted.Name != "" {
-		// The account check is the last database action before the Bus mutation;
-		// the two systems cannot share an atomic commit.
-		if err := s.st.CheckEffectiveAccountForExternalEffect(owner, allowImplicitDefault); err != nil {
-			writeStoreErr(w, err)
-			return
-		}
-		s.Bus.UnregisterUser(userCommandID(deleted.Name), deleted.Name)
+	if s.Bus != nil && name != "" {
+		s.Bus.UnregisterUser(userCommandID(name), name)
 	}
 	writeJSON(w, http.StatusOK, map[string]any{"deleted": id})
 }
@@ -163,7 +175,7 @@ func (s *Server) excludeMessage(w http.ResponseWriter, r *http.Request) {
 		writeStoreErr(w, err)
 		return
 	}
-	writeOKOr(w, s.st.ExcludeRunGroupAccountChecked(s.owner(r), msg.ID, excluded, s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.ExcludeRunGroup(msg.ID, excluded))
 }
 
 func (s *Server) selectVariant(w http.ResponseWriter, r *http.Request) {
@@ -176,7 +188,7 @@ func (s *Server) selectVariant(w http.ResponseWriter, r *http.Request) {
 		writeStoreErr(w, err)
 		return
 	}
-	writeOKOr(w, s.st.SelectVariantAccountChecked(s.owner(r), msg.ID, s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.SelectVariant(msg.ID))
 }
 
 func (s *Server) regenerateMessage(w http.ResponseWriter, r *http.Request) {
@@ -210,7 +222,11 @@ func (s *Server) regenerateMessage(w http.ResponseWriter, r *http.Request) {
 	}
 	var user core.Message
 	found := false
+	maxIndex := target.VariantIndex
 	for _, m := range hist {
+		if m.VariantGroup != "" && m.VariantGroup == target.VariantGroup && m.VariantIndex > maxIndex {
+			maxIndex = m.VariantIndex
+		}
 		if m.ID == target.ID {
 			found = true
 		}
@@ -222,8 +238,19 @@ func (s *Server) regenerateMessage(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "no user turn to regenerate", http.StatusBadRequest)
 		return
 	}
-	group, index, err := s.st.PrepareRegenerationAccountChecked(owner, convID, target.ID, s.Auth == nil || !s.Auth.Enabled)
-	if err != nil {
+	group := target.VariantGroup
+	if group == "" {
+		group = "var_" + target.ID
+	}
+	if err := s.st.SetMessageFlags(target.ID, true, group, target.VariantIndex); err != nil {
+		writeStoreErr(w, err)
+		return
+	}
+	if err := s.st.ExcludeRunGroup(target.ID, true); err != nil {
+		writeStoreErr(w, err)
+		return
+	}
+	if err := s.st.SetRegenPending(convID, group, maxIndex+1); err != nil {
 		writeStoreErr(w, err)
 		return
 	}
@@ -232,7 +259,7 @@ func (s *Server) regenerateMessage(w http.ResponseWriter, r *http.Request) {
 	}
 	run, err := s.mgr.StartConversationRun(conv, user, nil, nil)
 	if err != nil {
-		_ = s.st.ClearRegenPendingAfterFailedStart(owner, convID, group, index, s.Auth == nil || !s.Auth.Enabled)
+		_, _, _ = s.st.TakeRegenPending(convID)
 		writeStoreErr(w, err)
 		return
 	}
@@ -289,11 +316,6 @@ func (s *Server) appendUserPromptCommands(owner string, out []map[string]any) []
 		return out
 	}
 	for _, c := range list {
-		if s.Bus != nil {
-			if err := s.st.CheckEffectiveAccountForExternalEffect(owner, s.Auth == nil || !s.Auth.Enabled); err != nil {
-				return out
-			}
-		}
 		s.registerUserPrompt(c)
 		out = append(out, map[string]any{
 			"id": userCommandID(c.Name), "name": c.Name, "title": c.Title,

internal/server/borrow_account_write_test.go

@@ -1,158 +0,0 @@
-package server
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-
-	"agent-system-backend/internal/store"
-)
-
-func TestBorrowWritesCannotCommitAfterAccountDisable(t *testing.T) {
-	for _, tc := range []struct {
-		name, path, body, table string
-	}{
-		{"secret", "/api/secrets", `{"service":"late","value":"hidden"}`, "secret_keys"},
-		{"context", "/api/context-entries", `{"content":"late"}`, "context_entries"},
-		{"command", "/api/prompt-commands", `{"name":"late","template":"late"}`, "user_commands"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			srv, st := newAuthTestServer(t)
-			h := srv.Handler()
-			_ = bootAdmin(t, h, st)
-			key, err := createLegacyAPIKeyFixture(t, st, "actor", "borrow")
-			if err != nil {
-				t.Fatal(err)
-			}
-			account, err := st.GetAccountByOwner("actor")
-			if err != nil {
-				t.Fatal(err)
-			}
-			body := &pausedRequestBody{reader: strings.NewReader(tc.body), entered: make(chan struct{}), release: make(chan struct{})}
-			req := httptest.NewRequest(http.MethodPost, tc.path, body)
-			req.Header.Set("Authorization", "Bearer "+key)
-			rec := httptest.NewRecorder()
-			done := make(chan struct{})
-			go func() {
-				h.ServeHTTP(rec, req)
-				close(done)
-			}()
-			select {
-			case <-body.entered:
-			case <-time.After(3 * time.Second):
-				t.Fatal("request did not reach its body")
-			}
-			if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-				t.Fatal(err)
-			}
-			close(body.release)
-			select {
-			case <-done:
-			case <-time.After(3 * time.Second):
-				t.Fatal("request did not finish")
-			}
-			if rec.Code != http.StatusForbidden {
-				t.Fatalf("late write status=%d body=%s", rec.Code, rec.Body.String())
-			}
-			var count int
-			if err := st.DB().QueryRow("SELECT COUNT(*) FROM " + tc.table + " WHERE owner='actor'").Scan(&count); err != nil || count != 0 {
-				t.Fatalf("late rows=%d err=%v", count, err)
-			}
-		})
-	}
-}
-
-func TestBorrowImplicitLocalCannotWriteWhenExplicitlyDisabled(t *testing.T) {
-	srv, st := newTestServer(t)
-	if err := st.CreateAccount("admin", "", "", true); err != nil {
-		t.Fatal(err)
-	}
-	secret, err := st.AddSecret(store.OwnerDefault, "service", "original", "hidden")
-	if err != nil {
-		t.Fatal(err)
-	}
-	entry, err := st.SaveContextEntry(store.OwnerDefault, store.ContextEntry{Content: "original"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	command, err := st.SaveUserCommand(store.OwnerDefault, store.UserCommand{Name: "original", Template: "original"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := st.EnsureUser(store.OwnerDefault, ""); err != nil {
-		t.Fatal(err)
-	}
-	account, err := st.GetAccountByOwner(store.OwnerDefault)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := st.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	for _, tc := range []struct{ method, path, body string }{
-		{http.MethodPost, "/api/secrets", `{"service":"late","value":"hidden"}`},
-		{http.MethodPost, "/api/secrets/" + secret.ID + "/activate", ""},
-		{http.MethodPatch, "/api/secrets/" + secret.ID, `{"label":"late"}`},
-		{http.MethodDelete, "/api/secrets/" + secret.ID, ""},
-		{http.MethodPost, "/api/context-entries", `{"content":"late"}`},
-		{http.MethodDelete, "/api/context-entries/" + entry.ID, ""},
-		{http.MethodPost, "/api/prompt-commands", `{"name":"late","template":"late"}`},
-		{http.MethodDelete, "/api/prompt-commands/" + command.ID, ""},
-	} {
-		rec := httptest.NewRecorder()
-		srv.Handler().ServeHTTP(rec, httptest.NewRequest(tc.method, tc.path, strings.NewReader(tc.body)))
-		if rec.Code != http.StatusForbidden {
-			t.Fatalf("disabled local account wrote %s: %d %s", tc.path, rec.Code, rec.Body.String())
-		}
-	}
-	if value, ok := st.ActiveSecret(store.OwnerDefault, "service"); !ok || value != "hidden" {
-		t.Fatalf("rejected secret mutations changed active value: %q %v", value, ok)
-	}
-	entries, err := st.ListContextEntries(store.OwnerDefault, "", "")
-	if err != nil || len(entries) != 1 || entries[0].Content != "original" {
-		t.Fatalf("rejected context mutations changed rows: %+v %v", entries, err)
-	}
-	commands, err := st.ListUserCommands(store.OwnerDefault)
-	if err != nil || len(commands) != 1 || commands[0].Template != "original" {
-		t.Fatalf("rejected command mutations changed rows: %+v %v", commands, err)
-	}
-	srv.appendUserPromptCommands(store.OwnerDefault, nil)
-	for _, registered := range srv.Bus.List() {
-		if registered.Spec.ID == "user.original" {
-			t.Fatal("disabled account registered a command during listing")
-		}
-	}
-}
-
-func TestBorrowPromptCommandBusFollowsCommittedWrite(t *testing.T) {
-	srv, st := newTestServer(t)
-	h := srv.Handler()
-	rec := httptest.NewRecorder()
-	h.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/api/prompt-commands", strings.NewReader(`{"name":"local","template":"hello"}`)))
-	if rec.Code != http.StatusOK {
-		t.Fatalf("save command: %d %s", rec.Code, rec.Body.String())
-	}
-	commands, err := st.ListUserCommands(store.OwnerDefault)
-	if err != nil || len(commands) != 1 {
-		t.Fatalf("saved command missing: %+v %v", commands, err)
-	}
-	registered := false
-	for _, command := range srv.Bus.List() {
-		registered = registered || command.Spec.ID == "user.local"
-	}
-	if !registered {
-		t.Fatal("committed command was not registered in the Bus")
-	}
-	rec = httptest.NewRecorder()
-	h.ServeHTTP(rec, httptest.NewRequest(http.MethodDelete, "/api/prompt-commands/"+commands[0].ID, nil))
-	if rec.Code != http.StatusOK {
-		t.Fatalf("delete command: %d %s", rec.Code, rec.Body.String())
-	}
-	for _, command := range srv.Bus.List() {
-		if command.Spec.ID == "user.local" {
-			t.Fatal("deleted command remained registered in the Bus")
-		}
-	}
-}

internal/server/compiled_list_test.go

@@ -75,7 +75,7 @@ func TestListPluginsMergesCompiled(t *testing.T) {
 		{ID: "generative-ui", Commands: []string{"generative-ui.present"}},
 	}
 	h := srv.Handler()
-	key, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	key, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/e2e_test.go

@@ -6,7 +6,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 
 	agentcommand "agent-command"
@@ -60,16 +59,6 @@ func newTestServer(t *testing.T) (*Server, *store.Store) {
 	profSvc := profiles.New(st)
 	profSvc.EnsureDefault()
 	mgr := runmgr.New(st, b, reg, profSvc, setSvc, &runtime.LLMRunner{}, &runtime.SubLLMRunner{}, &runtime.MockRunner{}, &runtime.MockSubagent{})
-	mgr.SetAccountEffectiveAuthorization(func(_ context.Context, owner string) (bool, error) {
-		account, err := st.GetAccountByOwner(owner)
-		if errors.Is(err, store.ErrNotFound) && owner == store.OwnerDefault {
-			return true, nil
-		}
-		if err != nil {
-			return false, err
-		}
-		return account.Enabled, nil
-	}, true)
 	pluginDir := filepath.Join(dir, "plugins")
 	os.MkdirAll(pluginDir, 0o755)
 	ph := plugins.New(st, reg, setSvc, pluginDir)
@@ -77,7 +66,6 @@ func newTestServer(t *testing.T) (*Server, *store.Store) {
 	// 生产同款装配（app.go）：卡片事件经 runmgr 事件缓冲持久化/发布——项目流
 	//（project:<id> 伪键，D50）依赖它；此前为 no-op emitter，事件不入库。
 	cardSvc := cardsvc.New(st, mgr.EmitCardEvent)
-	cardSvc.SetAccountCheckedEmitter(mgr.EmitCardEventAccountChecked)
 	srv.Cards = cardSvc
 	mgr.SetCards(cardSvc) // run 内产卡（摄取/编排/submit_card）经 runmgr，与 app.go 装配一致
 	srv.Bus = cmdbus.New(st, srv.Cards, nil)
@@ -144,6 +132,17 @@ func stubTargets(prompt string) []string {
 
 func doJSON(t *testing.T, h http.Handler, method, path string, body any) (int, map[string]any) {
 	t.Helper()
+	// Existing fixture callers provide desired values; public writes carry the
+	// freshly read revision. Tests of stale/legacy requests use raw HTTP directly.
+	if method == "PUT" && path == "/api/settings/system" {
+		if values, ok := body.(map[string]any); ok && values["values"] == nil {
+			code, current := doJSON(t, h, "GET", path, nil)
+			if code != 200 {
+				t.Fatalf("read system revision: %d", code)
+			}
+			body = map[string]any{"values": values, "expectedRevision": current["systemRevision"]}
+		}
+	}
 	var buf bytes.Buffer
 	if body != nil {
 		json.NewEncoder(&buf).Encode(body)
@@ -1026,7 +1025,7 @@ func TestSquadOrchestration(t *testing.T) {
 
 // TestModelRoutingOverrideChain：P2 受管语义下的模型配置链路——models.* 是系统
 // 受管项，user/project 层整笔拒绝（含嵌套与点路径），仅系统层可写；画像层模型名
-// 仍是最终覆盖。经由真实 run 的失败信息携带解析出的模型名取证。
+// 存量画像层也不能覆盖。经由真实 run 的失败信息携带解析出的模型名取证。
 func TestModelRoutingOverrideChain(t *testing.T) {
 	srv, st := newTestServer(t)
 	h := srv.Handler()
@@ -1073,19 +1072,22 @@ func TestModelRoutingOverrideChain(t *testing.T) {
 		t.Fatalf("non-managed user write rejected")
 	}
 
-	// 画像层：model-C 为最终覆盖。关 mock（系统层）→ 发消息 → run 失败信息携带解析结果。
+	// 新画像路由被拒，存量画像路由保留原数据但退出生效链。
 	if code, _ := doJSON(t, h, "PUT", "/api/settings/system", map[string]any{"runtime": map[string]any{"mock": false}}); code != 200 {
 		t.Fatal("disable mock via system layer failed")
 	}
-	prof := mustCode(t, h, "POST", "/api/profiles", map[string]any{
+	code, _ = doJSON(t, h, "POST", "/api/profiles", map[string]any{
 		"id": "prof_route_c", "name": "路由C", "systemPrompt": "x",
 		"model":   map[string]any{"chat": "model-C"},
 		"tools":   map[string]any{"allow": []string{"*"}},
 		"context": map[string]any{"maxHistoryMessages": 10},
 		"hitl":    map[string]any{"askOnAmbiguity": true}, "budget": map[string]any{},
 	})
-	if prof["id"] != "prof_route_c" {
-		t.Fatalf("profile save: %v", prof)
+	if code != http.StatusBadRequest {
+		t.Fatalf("personal profile model accepted: %d", code)
+	}
+	if err := st.SaveProfile(core.AgentProfile{ID: "prof_route_c", Owner: store.OwnerDefault, Name: "Legacy route", Model: core.ModelRoute{Chat: "model-C"}, Tools: core.ToolPolicy{Allow: []string{"*"}}}); err != nil {
+		t.Fatal(err)
 	}
 	mustCode(t, h, "PATCH", "/api/conversations/"+convID, map[string]any{"profileId": "prof_route_c"})
 	runID := postMessage(t, h, convID, "触发一次真实模型调用（预期失败并携带解析出的模型名）")
@@ -1094,8 +1096,8 @@ func TestModelRoutingOverrideChain(t *testing.T) {
 		t.Fatalf("expected failed run (no baseUrl), got %v", terminal["status"])
 	}
 	errMsg := terminal["error"].(map[string]any)["message"].(string)
-	if !strings.Contains(errMsg, `model-C`) {
-		t.Fatalf("run error should carry profile-routed model name: %q", errMsg)
+	if !strings.Contains(errMsg, `model-SYS`) || strings.Contains(errMsg, `model-C`) {
+		t.Fatalf("run error should carry system-routed model name: %q", errMsg)
 	}
 }
 
@@ -1259,7 +1261,8 @@ func TestSettingsDottedKeyAndSecretMask(t *testing.T) {
 		}
 	}
 
-	set(map[string]any{"runtime.entry": "squad"})
+	setSys(map[string]any{"runtime.entry": "squad"})
+	set(map[string]any{"ui.theme": "light"})
 	if got := svc.Effective(store.OwnerDefault, "").GetString("runtime.entry", ""); got != "squad" {
 		t.Fatalf("dotted write did not take effect: %q", got)
 	}

internal/server/ext9_upload_switch_test.go

@@ -15,7 +15,7 @@ import (
 func TestUploadPreIndexSwitch(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	alice, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	alice, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/login_key_test.go

@@ -13,14 +13,10 @@ import (
 func TestRedeemLoginKeyRestrictedSession(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	if err := st.CreateAccount("admin", "", "admin-hash", true); err != nil {
+	if err := st.CreateAccount("carol", "", "", false); err != nil {
 		t.Fatal(err)
 	}
-	account, err := st.CreatePendingAccount("admin", "carol", store.AccountProfile{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	plain, err := st.InitializePendingAccount(account.ID, account.StateVersion, account.InitializationGeneration)
+	plain, _, err := st.IssueLoginKey("carol", store.LoginKeyPurposeActivate, "test", 0)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/login_recovery_test.go

@@ -5,6 +5,7 @@ package server
 
 import (
 	"bytes"
+	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -34,7 +35,7 @@ func bootAdmin(t *testing.T, h http.Handler, st *store.Store) string {
 	if tok == "" {
 		t.Fatal("missing session cookie")
 	}
-	req = httptest.NewRequest("POST", "/api/auth/password", strings.NewReader(`{"current":"boot-pass-00","next":"admin-final-9"}`))
+	req = httptest.NewRequest("POST", "/api/auth/password", strings.NewReader(`{"next":"admin-final-9"}`))
 	req.AddCookie(&http.Cookie{Name: SessionCookie, Value: tok})
 	req.Header.Set("Content-Type", "application/json")
 	rec = httptest.NewRecorder()
@@ -88,48 +89,145 @@ func do(h http.Handler, method, path, body, cookie string) *httptest.ResponseRec
 func TestAdminLoginKeyRecoveryFlow(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	admin := bootAdmin(t, h, st)
-	hash, err := store.HashPassword("victim-old-password")
-	if err != nil {
+	adminTok := bootAdmin(t, h, st)
+	if err := st.CreateAccount("mallory", "", "", false); err != nil {
 		t.Fatal(err)
 	}
-	if err := st.CreateAccount("victim", "", hash, false); err != nil {
+	if err := st.CreateAccount("pleb", "", "", false); err != nil {
 		t.Fatal(err)
 	}
-	legacy, _, err := st.IssueLoginKey("victim", store.LoginKeyPurposeRecover, "legacy-admin", 0)
-	if err != nil {
+
+	// 匿名/无会话不能签发。
+	if rec := do(h, "POST", "/api/admin/users/mallory/login-keys", `{}`, "not-a-session"); rec.Code != http.StatusUnauthorized {
+		t.Fatalf("anonymous issue: %d", rec.Code)
+	}
+
+	// 管理员签发：返回明文一次 + 元数据。
+	rec := do(h, "POST", "/api/admin/users/mallory/login-keys", `{}`, adminTok)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("issue: %d %s", rec.Code, rec.Body.String())
+	}
+	var issued struct {
+		ID  string `json:"id"`
+		Key string `json:"key"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &issued); err != nil {
 		t.Fatal(err)
 	}
-	if rec := do(h, "POST", "/api/admin/users/victim/login-keys", `{}`, admin); rec.Code != http.StatusGone {
-		t.Fatalf("administrator secret issuance must be closed: %d %s", rec.Code, rec.Body.String())
+	if !strings.HasPrefix(issued.Key, "alk_") || issued.ID == "" {
+		t.Fatalf("issue payload: %+v", issued)
 	}
-	if rec := do(h, "POST", "/api/auth/login-key/redeem", `{"key":"`+legacy+`"}`, ""); rec.Code == http.StatusOK {
-		t.Fatal("legacy administrator key redeemed after cutover")
+
+	// 列表：状态可见、无明文。
+	rec = do(h, "GET", "/api/admin/users/mallory/login-keys", "", adminTok)
+	if rec.Code != http.StatusOK || strings.Contains(rec.Body.String(), "alk_") {
+		t.Fatalf("list must not leak plaintext: %d %s", rec.Code, rec.Body.String())
 	}
-	if rec := do(h, "GET", "/api/admin/users/victim/login-keys", "", admin); rec.Code != http.StatusOK || strings.Contains(rec.Body.String(), legacy) {
-		t.Fatalf("metadata lookup leaked secret: %d %s", rec.Code, rec.Body.String())
+	if !strings.Contains(rec.Body.String(), `"status":"unused"`) {
+		t.Fatalf("list should show unused status: %s", rec.Body.String())
+	}
+
+	// 用户兑换：只提交 Key，身份由服务端绑定决定。
+	req := httptest.NewRequest("POST", "/api/auth/login-key/redeem", strings.NewReader(`{"key":"`+issued.Key+`"}`))
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"owner":"mallory"`) ||
+		!strings.Contains(rec.Body.String(), `"sessionScope":"set_password_only"`) {
+		t.Fatalf("redeem: %d %s", rec.Code, rec.Body.String())
+	}
+	userTok := cookieOf(rec)
+
+	// 重复兑换失败。
+	req = httptest.NewRequest("POST", "/api/auth/login-key/redeem", strings.NewReader(`{"key":"`+issued.Key+`"}`))
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusConflict {
+		t.Fatalf("replay redeem: %d", rec.Code)
+	}
+
+	// 受限会话：业务与管理员入口均拒绝。
+	if rec := do(h, "GET", "/api/projects", "", userTok); rec.Code != http.StatusForbidden {
+		t.Fatalf("business api: %d", rec.Code)
+	}
+	if rec := do(h, "POST", "/api/admin/users/pleb/login-keys", `{}`, userTok); rec.Code != http.StatusForbidden {
+		t.Fatalf("restricted session must not issue keys: %d", rec.Code)
+	}
+
+	// 设密（无 current）→ reloginRequired → 新密码登录。
+	rec = do(h, "POST", "/api/auth/password", `{"next":"mallory-final-9"}`, userTok)
+	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"reloginRequired":true`) {
+		t.Fatalf("set password: %d %s", rec.Code, rec.Body.String())
+	}
+	req = httptest.NewRequest("POST", "/api/auth/login", strings.NewReader(`{"owner":"mallory","password":"mallory-final-9"}`))
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK || strings.Contains(rec.Body.String(), `"mustChangePassword":true`) {
+		t.Fatalf("login with new password: %d %s", rec.Code, rec.Body.String())
 	}
 }
 
+// 补发与撤销：旧 Key 作废、旧受限会话失效。
 func TestAdminLoginKeyReissueAndRevoke(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	admin := bootAdmin(t, h, st)
-	if err := st.CreateAccount("victim", "", "", false); err != nil {
+	adminTok := bootAdmin(t, h, st)
+	if err := st.CreateAccount("nia", "", "", false); err != nil {
 		t.Fatal(err)
 	}
-	legacy, meta, err := st.IssueLoginKey("victim", store.LoginKeyPurposeRecover, "legacy-admin", 0)
-	if err != nil {
-		t.Fatal(err)
+	issue := func() (string, string) {
+		rec := do(h, "POST", "/api/admin/users/nia/login-keys", `{}`, adminTok)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("issue: %d %s", rec.Code, rec.Body.String())
+		}
+		var out struct {
+			ID  string `json:"id"`
+			Key string `json:"key"`
+		}
+		json.Unmarshal(rec.Body.Bytes(), &out)
+		return out.ID, out.Key
 	}
-	if rec := do(h, "DELETE", "/api/admin/users/other/login-keys/"+meta.ID, "", admin); rec.Code != http.StatusNotFound {
-		t.Fatalf("path owner mismatch revoked key: %d %s", rec.Code, rec.Body.String())
+	oldID, oldKey := issue()
+	_ = oldID
+
+	// 兑换旧 Key 得受限会话；补发后该会话失效、旧 Key 不可再用。
+	req := httptest.NewRequest("POST", "/api/auth/login-key/redeem", strings.NewReader(`{"key":"`+oldKey+`"}`))
+	req.Header.Set("Content-Type", "application/json")
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	oldSess := cookieOf(rec)
+	if oldSess == "" {
+		t.Fatal("redeem old key failed")
 	}
-	if rec := do(h, "DELETE", "/api/admin/users/victim/login-keys/"+meta.ID, "", admin); rec.Code != http.StatusOK {
-		t.Fatalf("legacy metadata revoke: %d %s", rec.Code, rec.Body.String())
+	issue()
+	if rec := do(h, "GET", "/api/me", "", oldSess); rec.Code != http.StatusUnauthorized {
+		t.Fatalf("restricted session must die after reissue: %d", rec.Code)
 	}
-	if rec := do(h, "POST", "/api/auth/login-key/redeem", `{"key":"`+legacy+`"}`, ""); rec.Code == http.StatusOK {
-		t.Fatal("revoked legacy key redeemed")
+	req = httptest.NewRequest("POST", "/api/auth/login-key/redeem", strings.NewReader(`{"key":"`+oldKey+`"}`))
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code == http.StatusOK {
+		t.Fatal("consumed old key must not redeem again")
+	}
+
+	// 撤销端点：未用 Key 撤销后不可兑换。
+	newID, newKey := issue()
+	if rec := do(h, "DELETE", "/api/admin/users/nia/login-keys/"+newID, "", adminTok); rec.Code != http.StatusOK {
+		t.Fatalf("revoke: %d %s", rec.Code, rec.Body.String())
+	}
+	req = httptest.NewRequest("POST", "/api/auth/login-key/redeem", strings.NewReader(`{"key":"`+newKey+`"}`))
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code == http.StatusOK {
+		t.Fatal("revoked key must not redeem")
+	}
+	// 不存在的编号 404。
+	if rec := do(h, "DELETE", "/api/admin/users/nia/login-keys/lk_nope", "", adminTok); rec.Code != http.StatusNotFound {
+		t.Fatalf("unknown key revoke: %d", rec.Code)
 	}
 }
 
@@ -155,7 +253,7 @@ func TestLoginMustChangeCreatesRestrictedSession(t *testing.T) {
 	if rec := do(h, "GET", "/api/projects", "", tok); rec.Code != http.StatusForbidden {
 		t.Fatalf("business api before set: %d", rec.Code)
 	}
-	rec = do(h, "POST", "/api/auth/password", `{"current":"temp-pass-00","next":"oscar-final-9"}`, tok)
+	rec = do(h, "POST", "/api/auth/password", `{"next":"oscar-final-9"}`, tok)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("set password: %d %s", rec.Code, rec.Body.String())
 	}
@@ -173,14 +271,10 @@ func TestActiveChangePasswordRequiresCurrent(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
 	_ = srv
-	if err := st.CreateAccount("admin", "", "admin-hash", true); err != nil {
+	if err := st.CreateAccount("petra", "", "", false); err != nil {
 		t.Fatal(err)
 	}
-	account, err := st.CreatePendingAccount("admin", "petra", store.AccountProfile{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	plain, err := st.InitializePendingAccount(account.ID, account.StateVersion, account.InitializationGeneration)
+	plain, _, err := st.IssueLoginKey("petra", store.LoginKeyPurposeActivate, "test", 0)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/platform_api.go

@@ -23,9 +23,9 @@ func (s *Server) createBackgroundTask(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "kind required", http.StatusBadRequest)
 		return
 	}
-	task, err := s.st.CreateBackgroundTaskAccountChecked(s.owner(r), body.Kind, body.Title, body.ConversationID, s.Auth == nil || !s.Auth.Enabled)
+	task, err := s.st.CreateBackgroundTask(s.owner(r), body.Kind, body.Title, body.ConversationID)
 	if err != nil {
-		writeStoreErr(w, err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	writeJSON(w, http.StatusCreated, task)
@@ -59,8 +59,8 @@ func (s *Server) updateBackgroundTask(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "status required", http.StatusBadRequest)
 		return
 	}
-	if err := s.st.UpdateBackgroundTaskAccountChecked(s.owner(r), r.PathValue("id"), body.Status, body.Progress, body.Error, s.Auth == nil || !s.Auth.Enabled); err != nil {
-		writeStoreErr(w, err)
+	if err := s.st.UpdateBackgroundTask(s.owner(r), r.PathValue("id"), body.Status, body.Progress, body.Error); err != nil {
+		http.Error(w, err.Error(), http.StatusNotFound)
 		return
 	}
 	s.getBackgroundTask(w, r)
@@ -81,9 +81,9 @@ func (s *Server) putMemory(w http.ResponseWriter, r *http.Request) {
 	if e.Source == "" {
 		e.Source = "manual"
 	}
-	saved, err := s.st.PutMemoryAccountChecked(s.owner(r), e, s.Auth == nil || !s.Auth.Enabled)
+	saved, err := s.st.PutMemory(s.owner(r), e)
 	if err != nil {
-		writeStoreErr(w, err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	writeJSON(w, http.StatusCreated, saved)
@@ -119,11 +119,11 @@ func (s *Server) postAudit(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "action required", http.StatusBadRequest)
 		return
 	}
-	if err := s.st.AppendAuditEventAccountChecked(s.owner(r), store.AuditEvent{
+	if err := s.st.AppendAuditEvent(store.AuditEvent{
 		Owner: s.owner(r), Actor: s.owner(r), Action: body.Action, Target: body.Target,
 		Evidence: body.Evidence, TraceID: r.Header.Get("X-Trace-Id"),
-	}, s.Auth == nil || !s.Auth.Enabled); err != nil {
-		writeStoreErr(w, err)
+	}); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	w.WriteHeader(http.StatusNoContent)
@@ -137,8 +137,8 @@ func (s *Server) setPluginEnabled(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "bad json", http.StatusBadRequest)
 		return
 	}
-	if err := s.st.SetPluginEnabledAccountChecked(s.owner(r), r.PathValue("id"), body.Enabled, s.Auth == nil || !s.Auth.Enabled); err != nil {
-		writeStoreErr(w, err)
+	if err := s.st.SetPluginEnabled(s.owner(r), r.PathValue("id"), body.Enabled); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	w.WriteHeader(http.StatusNoContent)
@@ -210,11 +210,11 @@ func (s *Server) submitSurface(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "pluginId and spec required", http.StatusBadRequest)
 		return
 	}
-	snap, err := s.Surfaces.SubmitAccountChecked(r.Context(), s.owner(r), body.PluginID, surfacesvc.SubmitRequest{
+	snap, err := s.Surfaces.Submit(r.Context(), s.owner(r), body.PluginID, surfacesvc.SubmitRequest{
 		SurfaceID: core.ID(body.SurfaceID), ConversationID: core.ID(body.ConversationID),
 		BaseRevision: body.BaseRevision, ObservedEpoch: body.ObservedEpoch,
 		ContextVersion: body.ContextVersion, SemanticText: body.SemanticText, Spec: body.Spec,
-	}, s.Auth == nil || !s.Auth.Enabled)
+	})
 	if err != nil {
 		s.writeSurfaceError(w, err)
 		return
@@ -260,7 +260,7 @@ func (s *Server) setSurfaceActivation(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "enabled required", http.StatusBadRequest)
 		return
 	}
-	row, err := s.Surfaces.SetActivationAccountChecked(r.Context(), s.owner(r), r.PathValue("id"), body.Enabled, s.Auth == nil || !s.Auth.Enabled)
+	row, err := s.Surfaces.SetActivation(r.Context(), s.owner(r), r.PathValue("id"), body.Enabled)
 	if err != nil {
 		s.writeSurfaceError(w, err)
 		return
@@ -299,10 +299,10 @@ func (s *Server) submitSurfaceAction(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "actionId and requestId required", http.StatusBadRequest)
 		return
 	}
-	res, err := s.Surfaces.SubmitActionAccountChecked(r.Context(), s.owner(r), surfacesvc.SubmitActionRequest{
+	res, err := s.Surfaces.SubmitAction(r.Context(), s.owner(r), surfacesvc.SubmitActionRequest{
 		SurfaceID: core.ID(r.PathValue("id")), ActionID: body.ActionID,
 		Revision: body.Revision, RequestID: body.RequestID, Data: body.Data,
-	}, s.Auth == nil || !s.Auth.Enabled)
+	})
 	if err != nil {
 		s.writeSurfaceError(w, err)
 		return

internal/server/project_events_test.go

@@ -20,9 +20,7 @@ func projectStreamReplay(t *testing.T, s *Server, key, project string) *httptest
 	t.Helper()
 	r := httptest.NewRequest("GET", "/api/events?scope=project&projectId="+project+"&since=0", nil)
 	r.Header.Set("Authorization", "Bearer "+key)
-	// Replay can pass more than a thousand private events before the first
-	// visible frame; account checks on CI and under -race need headroom.
-	ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
+	ctx, cancel := context.WithTimeout(r.Context(), 200*time.Millisecond)
 	defer cancel()
 	w := httptest.NewRecorder()
 	s.Handler().ServeHTTP(w, r.WithContext(ctx))
@@ -31,11 +29,10 @@ func projectStreamReplay(t *testing.T, s *Server, key, project string) *httptest
 func projectEventFixture(t *testing.T) (*Server, string, string, string, *atomic.Bool) {
 	t.Helper()
 	s, st := newAuthTestServer(t)
-	alice, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
-	bob, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	alice, _ := st.CreateAPIKey("alice", "test")
+	bob, _ := st.CreateAPIKey("bob", "test")
 	p, _ := st.CreateProject("alice", "Project")
 	s.Cards = cardsvc.New(st, s.mgr.EmitCardEvent)
-	s.Cards.SetAccountCheckedEmitter(s.mgr.EmitCardEventAccountChecked)
 	s.Cards.SetProjectSharedEmitter(s.mgr.EmitProjectSharedCardEvent)
 	member := &atomic.Bool{}
 	member.Store(true)
@@ -80,8 +77,7 @@ func TestProjectEventsSharedProofAndPrivatePagination(t *testing.T) {
 	}
 	w := projectStreamReplay(t, s, bob, p)
 	if w.Code != 200 || bytes.Contains(w.Body.Bytes(), []byte("PRIVATE HISTORY")) || !bytes.Contains(w.Body.Bytes(), []byte("EXPLICIT SHARED")) {
-		t.Fatalf("private pagination/spoof proof failed: code=%d private=%t shared=%t bytes=%d", w.Code,
-			bytes.Contains(w.Body.Bytes(), []byte("PRIVATE HISTORY")), bytes.Contains(w.Body.Bytes(), []byte("EXPLICIT SHARED")), w.Body.Len())
+		t.Fatal("private pagination/spoof proof failed")
 	}
 }
 func TestProjectEventsLivePrivacyAndRevocation(t *testing.T) {

internal/server/project_lifecycle.go

@@ -45,11 +45,11 @@ func (s *Server) createPrivateConversation(ctx context.Context, owner, projectID
 		if err := s.projectWork(ctx, owner, projectID); err != nil {
 			return core.Conversation{}, err
 		}
-		return s.st.CreateConversationAccountChecked(owner, projectID, title, profile, s.Auth == nil || !s.Auth.Enabled, false)
+		return s.st.CreateConversationInProject(owner, projectID, title, profile)
 	}
-	c, err := s.st.CreateConversationAccountChecked(owner, projectID, title, profile, s.Auth == nil || !s.Auth.Enabled, true)
+	c, err := s.st.CreateConversation(owner, projectID, title, profile)
 	if errors.Is(err, store.ErrNotFound) && s.authorizeSharedResource(owner, "read", "project", core.ID(projectID), "", core.ID(projectID)) {
-		return s.st.CreateConversationAccountChecked(owner, projectID, title, profile, s.Auth == nil || !s.Auth.Enabled, false)
+		return s.st.CreateConversationInProject(owner, projectID, title, profile)
 	}
 	return c, err
 }

internal/server/project_lifecycle_test.go

@@ -32,7 +32,7 @@ func lifecycleRequest(t *testing.T, s *Server, key, method, path, body string) *
 }
 func TestProjectLifecycleDelegatesAndPreservesArchiveHistory(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
+	key, _ := st.CreateAPIKey("alice", "test")
 	p, _ := st.CreateProject("alice", "Original")
 	c, _ := st.CreateConversation("alice", p.ID, "Private", "")
 	calls := []string{}
@@ -74,9 +74,9 @@ func TestProjectLifecycleDelegatesAndPreservesArchiveHistory(t *testing.T) {
 func fmtWrap(err error) error { return errors.Join(errors.New("wrapped"), err) }
 func TestProjectLifecycleMemberPrivateWork(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	alice, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
-	bob, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
-	mallory, _ := createLegacyAPIKeyFixture(t, st, "mallory", "test")
+	alice, _ := st.CreateAPIKey("alice", "test")
+	bob, _ := st.CreateAPIKey("bob", "test")
+	mallory, _ := st.CreateAPIKey("mallory", "test")
 	p, _ := st.CreateProject("alice", "Shared")
 	ac, _ := st.CreateConversation("alice", p.ID, "Alice private", "")
 	ready := true
@@ -126,7 +126,7 @@ func TestProjectLifecycleMemberPrivateWork(t *testing.T) {
 }
 func TestProjectLifecycleReadOnlyAuthorizerDoesNotGrantWrite(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	key, _ := st.CreateAPIKey("bob", "test")
 	p, _ := st.CreateProject("alice", "Shared")
 	s.SetProjectAuthorizer(func(string, core.ID) (bool, error) { return true, nil })
 	s.SetProjectLifecycle(extension.ProjectLifecycle{}, nil)
@@ -140,7 +140,7 @@ func TestProjectLifecycleReadOnlyAuthorizerDoesNotGrantWrite(t *testing.T) {
 
 func TestProjectLifecycleRevocationGuardsExecutionResumption(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
+	key, _ := st.CreateAPIKey("alice", "test")
 	p, _ := st.CreateProject("alice", "Project")
 	conv, _ := st.CreateConversation("alice", p.ID, "Private", "")
 	s.SetProjectLifecycle(extension.ProjectLifecycle{Work: func(context.Context, string, core.ID) (bool, error) { return false, nil }}, nil)
@@ -158,7 +158,7 @@ func TestProjectLifecycleRevocationGuardsExecutionResumption(t *testing.T) {
 
 func TestProjectLifecycleRevocationGuardsSurfaceAction(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
+	key, _ := st.CreateAPIKey("alice", "test")
 	p, _ := st.CreateProject("alice", "Project")
 	conv, _ := st.CreateConversation("alice", p.ID, "Private", "")
 	svc := surfacesvc.New(st, nil)
@@ -179,7 +179,7 @@ func TestProjectLifecycleRevocationGuardsSurfaceAction(t *testing.T) {
 
 func TestProjectLifecycleSettingsRetainServiceMetadata(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
+	key, _ := st.CreateAPIKey("alice", "test")
 	p, _ := st.CreateProject("alice", "Project")
 	s.SetProjectLifecycle(extension.ProjectLifecycle{List: func(context.Context, extension.Host) ([]core.Project, error) {
 		current, err := st.GetProject("alice", p.ID)
@@ -203,8 +203,8 @@ func TestProjectLifecycleSettingsRetainServiceMetadata(t *testing.T) {
 
 func TestProjectLifecyclePublicMetadataMasksSecrets(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	alice, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
-	bob, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	alice, _ := st.CreateAPIKey("alice", "test")
+	bob, _ := st.CreateAPIKey("bob", "test")
 	p, _ := st.CreateProject("alice", "Shared")
 	raw := map[string]any{"models.chat.apiKey": "fixture-key", "custom": map[string]any{"token": "fixture-token"}, "custom.api_key": "fixture-flat-token", "plugin.private.credential": "fixture-schema-token", "display": map[string]any{"caption": "Shared"}, "rdm.projectId": "canonical", "rdm.state": "ready"}
 	if err := st.UpdateProjectSettings("alice", p.ID, raw); err != nil {
@@ -243,7 +243,7 @@ func TestGenericProjectPatchRejectsManagedSettingsAtomically(t *testing.T) {
 	for _, registered := range []bool{false, true} {
 		t.Run(fmt.Sprint(registered), func(t *testing.T) {
 			s, st := newAuthTestServer(t)
-			key, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
+			key, _ := st.CreateAPIKey("alice", "test")
 			p, _ := st.CreateProject("alice", "Original")
 			s.set.SetExtraSchema([]core.SettingDesc{{Key: "plugins.private.managed", Scope: core.SettingScopeSystem}})
 			if registered {
@@ -286,7 +286,7 @@ func TestGenericProjectPatchAcceptsNestedMaskedWriteback(t *testing.T) {
 	for _, registered := range []bool{false, true} {
 		t.Run(fmt.Sprint(registered), func(t *testing.T) {
 			s, st := newAuthTestServer(t)
-			key, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
+			key, _ := st.CreateAPIKey("alice", "test")
 			p, _ := st.CreateProject("alice", "Project")
 			if err := st.UpdateProjectSettings("alice", p.ID, map[string]any{"models": map[string]any{"chat": map[string]any{"apiKey": "fixture-persisted-key"}}, "display": map[string]any{"caption": "Original"}}); err != nil {
 				t.Fatal(err)
@@ -347,9 +347,9 @@ func lifecycleUpload(t *testing.T, s *Server, key, projectID, name, content stri
 
 func TestProjectLifecycleMemberUploadStaysPrivate(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	alice, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
-	bob, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
-	mallory, _ := createLegacyAPIKeyFixture(t, st, "mallory", "test")
+	alice, _ := st.CreateAPIKey("alice", "test")
+	bob, _ := st.CreateAPIKey("bob", "test")
+	mallory, _ := st.CreateAPIKey("mallory", "test")
 	p, _ := st.CreateProject("alice", "Shared")
 	ready := true
 	s.SetProjectLifecycle(extension.ProjectLifecycle{Work: func(_ context.Context, actor string, id core.ID) (bool, error) {
@@ -399,8 +399,8 @@ func TestProjectLifecycleMemberUploadStaysPrivate(t *testing.T) {
 
 func TestProjectLifecycleUploadSuppressesPrivateProjectCards(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	alice, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
-	bob, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	alice, _ := st.CreateAPIKey("alice", "test")
+	bob, _ := st.CreateAPIKey("bob", "test")
 	p, _ := st.CreateProject("alice", "Shared")
 	s.SetProjectLifecycle(extension.ProjectLifecycle{Work: func(_ context.Context, actor string, id core.ID) (bool, error) {
 		return id == p.ID && (actor == "alice" || actor == "bob"), nil
@@ -409,7 +409,6 @@ func TestProjectLifecycleUploadSuppressesPrivateProjectCards(t *testing.T) {
 		return q.ResourceType == "project" && q.ProjectID == p.ID && (q.Actor == "alice" || q.Actor == "bob"), nil
 	})
 	s.Cards = cardsvc.New(st, s.mgr.EmitCardEvent)
-	s.Cards.SetAccountCheckedEmitter(s.mgr.EmitCardEventAccountChecked)
 	s.Cards.SetProjectSharedEmitter(s.mgr.EmitProjectSharedCardEvent)
 	s.DisableUploadIndexing = true
 	if _, err := s.Cards.PublishProjectCard("alice", "plugin:rdm:structure", core.ActivityCard{ProjectID: p.ID, Title: "Shared structure", Kind: core.CardKindProgress}, ""); err != nil {
@@ -469,10 +468,9 @@ func TestProjectLifecycleUploadSuppressesPrivateProjectCards(t *testing.T) {
 
 func TestUnregisteredUploadKeepsLegacyCardsAndValidation(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "alice", "test")
+	key, _ := st.CreateAPIKey("alice", "test")
 	p, _ := st.CreateProject("alice", "Private")
 	s.Cards = cardsvc.New(st, s.mgr.EmitCardEvent)
-	s.Cards.SetAccountCheckedEmitter(s.mgr.EmitCardEventAccountChecked)
 	s.DisableUploadIndexing = true
 	if w := lifecycleUpload(t, s, key, p.ID, "legacy-upload.txt", "Original"); w.Code != 200 {
 		t.Fatalf("unregistered owner upload=%d", w.Code)
@@ -488,7 +486,7 @@ func TestUnregisteredUploadKeepsLegacyCardsAndValidation(t *testing.T) {
 
 func TestProjectLifecycleUploadRechecksBeforePersistence(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	key, _ := st.CreateAPIKey("bob", "test")
 	p, _ := st.CreateProject("alice", "Shared")
 	ready := true
 	s.SetProjectLifecycle(extension.ProjectLifecycle{Work: func(context.Context, string, core.ID) (bool, error) {

internal/server/project_resource_filter_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestKnowledgeV2UsesDocumentIdentity(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	key, _ := st.CreateAPIKey("bob", "test")
 	docs := []core.KnowledgeDoc{{ID: "published-slice", Owner: "alice", ProjectID: "domain-p", Chunk: "sharedneedle published"}, {ID: "private-draft", Owner: "alice", ProjectID: "domain-p", Chunk: "sharedneedle draft"}, {ID: "self-denied", Owner: "bob", ProjectID: "domain-p", Chunk: "sharedneedle own restricted"}, {ID: "self-allowed", Owner: "bob", ProjectID: "domain-p", Chunk: "sharedneedle own"}}
 	if err := st.AddKnowledge(docs...); err != nil {
 		t.Fatal(err)
@@ -39,7 +39,7 @@ func TestKnowledgeV2UsesDocumentIdentity(t *testing.T) {
 }
 func TestArtifactListV2FiltersEachResource(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	key, _ := st.CreateAPIKey("bob", "test")
 	p, _ := st.CreateProject("alice", "Project")
 	private := core.Artifact{Owner: "alice", ProjectID: p.ID, Name: "Private", MIME: "text/plain"}
 	public := core.Artifact{Owner: "alice", ProjectID: p.ID, Name: "Shared", MIME: "text/plain"}
@@ -62,7 +62,7 @@ func TestArtifactListV2FiltersEachResource(t *testing.T) {
 
 func TestKnowledgeV2ResolvesTrustedProjectScope(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	key, _ := st.CreateAPIKey("bob", "test")
 	if err := st.AddKnowledge(core.KnowledgeDoc{ID: "slice-current", Owner: "alice", ProjectID: "domain-current", Chunk: "scopeneedle current"}, core.KnowledgeDoc{ID: "slice-other", Owner: "alice", ProjectID: "domain-other", Chunk: "scopeneedle other"}); err != nil {
 		t.Fatal(err)
 	}
@@ -83,7 +83,7 @@ func TestKnowledgeV2ResolvesTrustedProjectScope(t *testing.T) {
 
 func TestKnowledgeV2UsesStoredPublicationSource(t *testing.T) {
 	s, st := newAuthTestServer(t)
-	key, _ := createLegacyAPIKeyFixture(t, st, "bob", "test")
+	key, _ := st.CreateAPIKey("bob", "test")
 	// A known published identity replaced by a private row must lose sharing.
 	if err := st.AddKnowledge(core.KnowledgeDoc{ID: "known-published-id", Owner: "alice", ProjectID: "domain", Source: "manual", Chunk: "sourceneedle private"}, core.KnowledgeDoc{ID: "real-published-id", Owner: "alice", ProjectID: "domain", Source: "plugin:rdm:published", Chunk: "sourceneedle public"}); err != nil {
 		t.Fatal(err)

internal/server/project_settings.go

@@ -0,0 +1,213 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+
+	"agent-system-backend/internal/settings"
+	"agent-system-backend/internal/store"
+	"agent-system-backend/pkg/extension"
+	core "agent-system-core"
+)
+
+func (s *Server) SetProjectSettingsAuthorizer(fn extension.ProjectSettingsAuthorizer) {
+	s.projectSettingsAuthz = fn
+}
+
+func (s *Server) settingsProject(ctx context.Context, actor, id string, write bool) (core.Project, error) {
+	p, err := s.st.ProjectMetadata(id)
+	if err != nil {
+		return core.Project{}, err
+	}
+	if s.projectSettingsAuthz != nil {
+		if err := s.projectSettingsAuthz(ctx, actor, p.ID, write); err != nil {
+			return core.Project{}, err
+		}
+		return p, nil
+	}
+	// A domain lifecycle can revoke even the project creator. Missing settings
+	// capability fails closed; read/work authorization cannot grant configuration.
+	if s.projectLifecycle != nil {
+		return core.Project{}, store.ErrNotFound
+	}
+	if p.Owner != actor {
+		return core.Project{}, store.ErrNotFound
+	}
+	return p, nil
+}
+
+func decodeSettingsObject(r *http.Request) (map[string]any, error) {
+	var values map[string]any
+	decoder := json.NewDecoder(io.LimitReader(r.Body, 1<<20))
+	if err := decoder.Decode(&values); err != nil {
+		return nil, err
+	}
+	if values == nil {
+		return nil, errors.New("需要设置对象")
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return nil, errors.New("设置请求必须只包含一个对象")
+	}
+	return values, nil
+}
+
+func decodeStrictSettingsRequest(r *http.Request, target any) error {
+	decoder := json.NewDecoder(io.LimitReader(r.Body, 1<<20))
+	decoder.DisallowUnknownFields()
+	if err := decoder.Decode(target); err != nil {
+		return err
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return errors.New("请求只能包含一个对象")
+	}
+	return nil
+}
+
+func (s *Server) previewSettingsMigration(w http.ResponseWriter, r *http.Request) {
+	actor := s.owner(r)
+	project, err := s.settingsProject(r.Context(), actor, r.PathValue("id"), true)
+	if err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	var req struct {
+		Choices          []settings.MigrationChoice `json:"choices"`
+		ExpectedRevision *int64                     `json:"expectedRevision"`
+	}
+	if err := decodeStrictSettingsRequest(r, &req); err != nil || req.ExpectedRevision == nil || *req.ExpectedRevision < 0 {
+		http.Error(w, "需要 choices 和 expectedRevision", 400)
+		return
+	}
+	for _, choice := range req.Choices {
+		if _, err := s.st.GetUser(choice.SourceOwner); err != nil && !(s.Auth == nil && choice.SourceOwner == actor) {
+			writeStoreErr(w, store.ErrNotFound)
+			return
+		}
+		if _, err := s.settingsProject(r.Context(), choice.SourceOwner, project.ID, false); err != nil {
+			writeProjectErr(w, err)
+			return
+		}
+	}
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	result, err := s.set.PreviewProjectMigration(actor, project.ID, req.Choices, *req.ExpectedRevision)
+	if err != nil {
+		s.writeMigrationError(w, err)
+		return
+	}
+	writeJSON(w, 200, result)
+}
+
+func (s *Server) applySettingsMigration(w http.ResponseWriter, r *http.Request) {
+	actor := s.owner(r)
+	project, err := s.settingsProject(r.Context(), actor, r.PathValue("id"), true)
+	if err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	var req struct {
+		Observation      string `json:"observation"`
+		ExpectedRevision *int64 `json:"expectedRevision"`
+	}
+	if err := decodeStrictSettingsRequest(r, &req); err != nil || req.ExpectedRevision == nil || *req.ExpectedRevision < 0 {
+		http.Error(w, "需要 observation 和 expectedRevision", 400)
+		return
+	}
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	selected, choices, err := s.set.MigrationSelection(actor, project.ID, req.Observation, *req.ExpectedRevision)
+	if err != nil {
+		s.writeMigrationError(w, err)
+		return
+	}
+	for _, choice := range choices {
+		if _, err := s.st.GetUser(choice.SourceOwner); err != nil && !(s.Auth == nil && choice.SourceOwner == actor) {
+			writeStoreErr(w, store.ErrNotFound)
+			return
+		}
+		if _, err := s.settingsProject(r.Context(), choice.SourceOwner, project.ID, false); err != nil {
+			writeProjectErr(w, err)
+			return
+		}
+	}
+	if err := s.validateProjectTemplate(actor, project, selected); err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	if _, err := s.settingsProject(r.Context(), actor, project.ID, true); err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	result, err := s.set.ApplyProjectMigration(actor, project.ID, req.Observation, *req.ExpectedRevision, selected)
+	if err != nil {
+		s.writeMigrationError(w, err)
+		return
+	}
+	writeJSON(w, 200, result)
+}
+
+func (s *Server) writeMigrationError(w http.ResponseWriter, err error) {
+	if errors.Is(err, settings.ErrSettingsConflict) {
+		http.Error(w, err.Error(), 409)
+		return
+	}
+	var invalid *settings.ErrInvalidSetting
+	if errors.As(err, &invalid) {
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	writeProjectErr(w, err)
+}
+
+func (s *Server) putSettingsPersonalProject(w http.ResponseWriter, r *http.Request) {
+	owner := s.owner(r)
+	p, err := s.settingsProject(r.Context(), owner, r.PathValue("id"), false)
+	if err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	values, err := decodeSettingsObject(r)
+	if err != nil {
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	if err := s.set.ValidateWrite(values, settings.PersonalProjectScope); err != nil {
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	s.writeSettingsMerge(w, func() error { return s.set.MergePersonalProject(owner, p.ID, values) })
+}
+
+func (s *Server) validateProjectTemplate(actor string, p core.Project, values map[string]any) error {
+	projected := s.set.ProjectValues(values, settings.ProjectSettingScope)
+	id := core.EffectiveSettings(projected).GetString("deliverables.templateArtifactId", "")
+	if id == "" {
+		return nil
+	}
+	a, err := s.st.GetArtifactByID(id)
+	if err != nil || a.ProjectID != p.ID {
+		return store.ErrNotFound
+	}
+	if s.ProjectAuthzV2 != nil {
+		if !s.authorizeSharedResource(actor, "model-context", "artifact", a.ID, a.Owner, a.ProjectID) {
+			return store.ErrNotFound
+		}
+	} else if a.Owner != actor {
+		return store.ErrNotFound
+	}
+	return nil
+}
+
+func (s *Server) getSettingsMigration(w http.ResponseWriter, r *http.Request) {
+	if _, ok := s.requireSystemAdmin(w, r); !ok {
+		return
+	}
+	if r.URL.Query().Get("dryRun") != "true" {
+		http.Error(w, "迁移清单仅支持 dryRun=true；不执行自动迁移", 400)
+		return
+	}
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	view, err := s.set.MigrationInventory()
+	writeJSONOr(w, view, err)
+}

internal/server/recovery.go

@@ -1,128 +0,0 @@
-package server
-
-import (
-	"net/http"
-)
-
-func (s *Server) createAdminRecoveryProposal(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
-		return
-	}
-	var req struct {
-		ExpectedStateVersion int64  `json:"expectedStateVersion"`
-		IdempotencyKey       string `json:"idempotencyKey"`
-	}
-	if err := decodeStrictJSON(r, &req); err != nil {
-		http.Error(w, "invalid recovery proposal", http.StatusBadRequest)
-		return
-	}
-	proposal, err := s.st.CreateRecoveryProposal(actor, r.PathValue("userId"), req.ExpectedStateVersion, req.IdempotencyKey)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	w.Header().Set("Cache-Control", "no-store")
-	writeJSON(w, http.StatusOK, proposal)
-}
-
-func (s *Server) getAdminRecoveryProposal(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
-		return
-	}
-	proposal, err := s.st.GetRecoveryProposalForAdmin(actor, r.PathValue("userId"), r.PathValue("id"))
-	writeJSONOr(w, proposal, err)
-}
-
-func (s *Server) listAdminRecoveryProposals(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
-		return
-	}
-	proposals, err := s.st.ListRecoveryProposalsForAdmin(actor, r.PathValue("userId"))
-	writeJSONOr(w, map[string]any{"proposals": proposals}, err)
-}
-
-func (s *Server) revokeAdminRecoveryProposal(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireAdmin(w, r)
-	if !ok {
-		return
-	}
-	var req struct {
-		ExpectedVersion int64 `json:"expectedVersion"`
-	}
-	if err := decodeStrictJSON(r, &req); err != nil {
-		http.Error(w, "invalid recovery revocation", http.StatusBadRequest)
-		return
-	}
-	proposal, err := s.st.RevokeRecoveryProposal(actor, r.PathValue("userId"), r.PathValue("id"), req.ExpectedVersion)
-	writeJSONOr(w, proposal, err)
-}
-
-func (s *Server) listMyRecoveryProposals(w http.ResponseWriter, r *http.Request) {
-	owner, ok := s.requireFullPasswordSession(w, r)
-	if !ok {
-		return
-	}
-	proposals, err := s.st.ListOwnerRecoveryProposals(owner)
-	writeJSONOr(w, map[string]any{"proposals": proposals}, err)
-}
-
-func (s *Server) getMyRecoveryProposal(w http.ResponseWriter, r *http.Request) {
-	owner, ok := s.requireFullPasswordSession(w, r)
-	if !ok {
-		return
-	}
-	proposal, err := s.st.GetOwnerRecoveryProposal(owner, r.PathValue("id"))
-	writeJSONOr(w, proposal, err)
-}
-
-func (s *Server) confirmRecoveryProposal(w http.ResponseWriter, r *http.Request) {
-	if _, ok := s.requireFullPasswordSession(w, r); !ok {
-		return
-	}
-	var req struct {
-		ExpectedVersion int64 `json:"expectedVersion"`
-	}
-	if err := decodeStrictJSON(r, &req); err != nil {
-		http.Error(w, "invalid recovery confirmation", http.StatusBadRequest)
-		return
-	}
-	plain, proposal, err := s.st.ConfirmRecoveryProposal(sessionToken(r), r.PathValue("id"), req.ExpectedVersion)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	w.Header().Set("Cache-Control", "no-store")
-	out := map[string]any{"proposal": proposal}
-	if plain != "" {
-		out["grant"] = plain
-	}
-	writeJSON(w, http.StatusOK, out)
-}
-
-func (s *Server) rotateRecoveryGrant(w http.ResponseWriter, r *http.Request) {
-	if _, ok := s.requireFullPasswordSession(w, r); !ok {
-		return
-	}
-	var req struct {
-		ExpectedVersion    int64 `json:"expectedVersion"`
-		ExpectedGeneration int64 `json:"expectedGeneration"`
-	}
-	if err := decodeStrictJSON(r, &req); err != nil {
-		http.Error(w, "invalid recovery grant rotation", http.StatusBadRequest)
-		return
-	}
-	plain, proposal, err := s.st.RotateRecoveryGrant(sessionToken(r), r.PathValue("id"), req.ExpectedVersion, req.ExpectedGeneration)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	w.Header().Set("Cache-Control", "no-store")
-	out := map[string]any{"proposal": proposal}
-	if plain != "" {
-		out["grant"] = plain
-	}
-	writeJSON(w, http.StatusOK, out)
-}

internal/server/recovery_contract_test.go

@@ -1,168 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"net/http"
-	"strconv"
-	"strings"
-	"testing"
-
-	"agent-system-backend/internal/store"
-)
-
-func TestOwnerConfirmedRecoveryHTTPKeepsGrantFromAdministrator(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	admin := bootAdmin(t, h, st)
-	pending, err := st.CreatePendingAccount("admin", "recovery-user", store.AccountProfile{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	activation, err := st.InitializePendingAccount(pending.ID, pending.StateVersion, pending.InitializationGeneration)
-	if err != nil {
-		t.Fatal(err)
-	}
-	setup := do(h, "POST", "/api/auth/login-key/redeem", `{"key":"`+activation+`"}`, "")
-	if setup.Code != http.StatusOK || !strings.Contains(setup.Body.String(), `"passwordChangeMode":"grant_setup"`) {
-		t.Fatalf("activation redeem: %d %s", setup.Code, setup.Body.String())
-	}
-	if rec := do(h, "POST", "/api/auth/password", `{"next":"alice-initial-password"}`, cookieOf(setup)); rec.Code != http.StatusOK {
-		t.Fatalf("initial set: %d %s", rec.Code, rec.Body.String())
-	}
-	ownerLogin := do(h, "POST", "/api/auth/login", `{"owner":"recovery-user","password":"alice-initial-password"}`, "")
-	if ownerLogin.Code != http.StatusOK {
-		t.Fatalf("trusted owner login: %d %s", ownerLogin.Code, ownerLogin.Body.String())
-	}
-	ownerCookie := cookieOf(ownerLogin)
-	account, err := st.GetAccount(pending.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	proposalResponse := do(h, "POST", "/api/admin/users/"+pending.ID+"/recovery-proposals",
-		`{"expectedStateVersion":`+jsonNumber(account.StateVersion)+`,"idempotencyKey":"http-request-1"}`, admin)
-	if proposalResponse.Code != http.StatusOK || strings.Contains(proposalResponse.Body.String(), "grant") {
-		t.Fatalf("administrator proposal leaked grant: %d %s", proposalResponse.Code, proposalResponse.Body.String())
-	}
-	var proposal store.RecoveryProposal
-	if err := json.Unmarshal(proposalResponse.Body.Bytes(), &proposal); err != nil || proposal.ID == "" {
-		t.Fatalf("proposal metadata: %+v %v", proposal, err)
-	}
-	if got := do(h, "GET", "/api/admin/users/"+pending.ID+"/recovery-proposals/"+proposal.ID, "", admin); got.Code != http.StatusOK || strings.Contains(got.Body.String(), "grant") {
-		t.Fatalf("administrator status leaked grant: %d %s", got.Code, got.Body.String())
-	}
-	confirmed := do(h, "POST", "/api/auth/recovery-proposals/"+proposal.ID+"/confirm", `{"expectedVersion":1}`, ownerCookie)
-	if confirmed.Code != http.StatusOK || confirmed.Header().Get("Cache-Control") != "no-store" {
-		t.Fatalf("owner confirm: %d %s", confirmed.Code, confirmed.Body.String())
-	}
-	var confirmation struct {
-		Proposal store.RecoveryProposal `json:"proposal"`
-		Grant    string                 `json:"grant"`
-	}
-	if err := json.Unmarshal(confirmed.Body.Bytes(), &confirmation); err != nil || confirmation.Grant == "" {
-		t.Fatalf("confirmation secret response: %v", err)
-	}
-	if duplicate := do(h, "POST", "/api/auth/recovery-proposals/"+proposal.ID+"/confirm", `{"expectedVersion":1}`, ownerCookie); duplicate.Code != http.StatusOK || strings.Contains(duplicate.Body.String(), `"grant"`) {
-		t.Fatalf("duplicate confirmation replayed grant: %d %s", duplicate.Code, duplicate.Body.String())
-	}
-	if got := do(h, "GET", "/api/me/recovery-proposals/"+proposal.ID, "", ownerCookie); got.Code != http.StatusOK || strings.Contains(got.Body.String(), confirmation.Grant) {
-		t.Fatalf("owner status replayed grant: %d %s", got.Code, got.Body.String())
-	}
-	rotated := do(h, "POST", "/api/auth/recovery-proposals/"+proposal.ID+"/rotate-grant",
-		`{"expectedVersion":`+jsonNumber(confirmation.Proposal.Version)+`,"expectedGeneration":`+jsonNumber(confirmation.Proposal.Generation)+`}`, ownerCookie)
-	if rotated.Code != http.StatusOK {
-		t.Fatalf("owner rotate: %d %s", rotated.Code, rotated.Body.String())
-	}
-	var rotation struct {
-		Grant string `json:"grant"`
-	}
-	if err := json.Unmarshal(rotated.Body.Bytes(), &rotation); err != nil || rotation.Grant == "" || rotation.Grant == confirmation.Grant {
-		t.Fatalf("rotation grant: %v", err)
-	}
-	if duplicate := do(h, "POST", "/api/auth/recovery-proposals/"+proposal.ID+"/rotate-grant",
-		`{"expectedVersion":`+jsonNumber(confirmation.Proposal.Version)+`,"expectedGeneration":`+jsonNumber(confirmation.Proposal.Generation)+`}`, ownerCookie); duplicate.Code != http.StatusOK || strings.Contains(duplicate.Body.String(), `"grant"`) {
-		t.Fatalf("duplicate rotation replayed grant: %d %s", duplicate.Code, duplicate.Body.String())
-	}
-	if old := do(h, "POST", "/api/auth/recovery-grants/redeem", `{"key":"`+confirmation.Grant+`"}`, ""); old.Code == http.StatusOK {
-		t.Fatal("old recovery grant remained usable")
-	}
-	redeemed := do(h, "POST", "/api/auth/recovery-grants/redeem", `{"key":"`+rotation.Grant+`"}`, "")
-	if redeemed.Code != http.StatusOK {
-		t.Fatalf("recovery redeem: %d %s", redeemed.Code, redeemed.Body.String())
-	}
-	if done := do(h, "POST", "/api/auth/password", `{"next":"alice-recovered-password"}`, cookieOf(redeemed)); done.Code != http.StatusOK {
-		t.Fatalf("recovery finish: %d %s", done.Code, done.Body.String())
-	}
-	if login := do(h, "POST", "/api/auth/login", `{"owner":"recovery-user","password":"alice-recovered-password"}`, ""); login.Code != http.StatusOK {
-		t.Fatalf("relogin: %d %s", login.Code, login.Body.String())
-	}
-}
-
-func jsonNumber(v int64) string { return strconv.FormatInt(v, 10) }
-
-func TestLegacyAdministratorRecoveryEntrancesAreClosed(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	admin := bootAdmin(t, h, st)
-	hash, err := store.HashPassword("old-victim-pass")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("victim", "", hash, false); err != nil {
-		t.Fatal(err)
-	}
-	if err := st.ClearMustChangePassword("victim"); err != nil {
-		t.Fatal(err)
-	}
-	for _, route := range []struct{ path, body string }{
-		{"/api/admin/users/victim/password", `{"password":"attacker-pass"}`},
-		{"/api/admin/users/victim/login-keys", `{"purpose":"recover"}`},
-		{"/api/admin/users/victim/login-keys", `{"purpose":"activate"}`},
-	} {
-		rec := do(h, "POST", route.path, route.body, admin)
-		if rec.Code != http.StatusGone || !strings.Contains(rec.Body.String(), "RECOVERY_CONTRACT_REPLACED") {
-			t.Fatalf("legacy route remained active: %s %d %s", route.path, rec.Code, rec.Body.String())
-		}
-	}
-	if _, ok := st.VerifyLogin("victim", "old-victim-pass"); !ok {
-		t.Fatal("closed routes changed existing password")
-	}
-	if keys, err := st.ListLoginKeys("victim"); err != nil || len(keys) != 0 {
-		t.Fatalf("closed routes issued a grant: %+v %v", keys, err)
-	}
-}
-
-func TestLegacyGrantAndRestrictedSessionCannotSkipCurrentPassword(t *testing.T) {
-	srv, st := newAuthTestServer(t)
-	h := srv.Handler()
-	hash, err := store.HashPassword("old-victim-pass")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := st.CreateAccount("victim", "", hash, false); err != nil {
-		t.Fatal(err)
-	}
-	grant, _, err := st.IssueLoginKey("victim", store.LoginKeyPurposeRecover, "legacy-admin", 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rec := do(h, "POST", "/api/auth/login-key/redeem", `{"key":"`+grant+`"}`, ""); rec.Code == http.StatusOK {
-		t.Fatal("legacy administrator grant created a restricted session")
-	}
-	if err := st.SetUserPassword("victim", hash); err != nil {
-		t.Fatal(err)
-	}
-	login := do(h, "POST", "/api/auth/login", `{"owner":"victim","password":"old-victim-pass"}`, "")
-	if login.Code != http.StatusOK || !strings.Contains(login.Body.String(), `"passwordChangeMode":"current_required"`) {
-		t.Fatalf("legacy forced login mode: %d %s", login.Code, login.Body.String())
-	}
-	cookie := cookieOf(login)
-	if rec := do(h, "POST", "/api/auth/password", `{"next":"victim-new-pass"}`, cookie); rec.Code == http.StatusOK {
-		t.Fatal("forced password session skipped current password")
-	}
-	if rec := do(h, "POST", "/api/auth/password", `{"current":"old-victim-pass","next":"victim-new-pass"}`, cookie); rec.Code != http.StatusOK {
-		t.Fatalf("legacy forced change with current failed: %d %s", rec.Code, rec.Body.String())
-	}
-	if _, ok := st.VerifyLogin("victim", "victim-new-pass"); !ok {
-		t.Fatal("current-required password change did not complete")
-	}
-}

internal/server/recovery_multi_instance_test.go

@@ -1,124 +0,0 @@
-package server
-
-import (
-	"database/sql"
-	"encoding/json"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"agent-system-backend/internal/store"
-)
-
-func twinRecoveryStores(t *testing.T) (*store.Store, *store.Store) {
-	t.Helper()
-	dsn := os.Getenv("AGENT_PG_TEST_DSN")
-	if dsn == "" {
-		path := filepath.Join(t.TempDir(), "shared.db")
-		first, err := store.OpenSQLite(path)
-		if err != nil {
-			t.Fatal(err)
-		}
-		second, err := store.OpenSQLite(path)
-		if err != nil {
-			first.Close()
-			t.Fatal(err)
-		}
-		t.Cleanup(func() { second.Close(); first.Close() })
-		return first, second
-	}
-	admin, err := sql.Open("pgx", dsn)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := admin.Exec(`CREATE EXTENSION IF NOT EXISTS pg_trgm`); err != nil {
-		t.Fatal(err)
-	}
-	schema := "t_" + strings.ToLower(store.NewID("recovery"))
-	if _, err := admin.Exec(`CREATE SCHEMA ` + schema); err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _, _ = admin.Exec(`DROP SCHEMA IF EXISTS ` + schema + ` CASCADE`); admin.Close() })
-	isolate := store.AppendPGRuntimeParam(dsn, "search_path", schema+",public")
-	first, err := store.OpenPostgres(isolate, filepath.Join(t.TempDir(), "a-artifacts"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	second, err := store.OpenPostgres(isolate, filepath.Join(t.TempDir(), "b-artifacts"))
-	if err != nil {
-		first.Close()
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { second.Close(); first.Close() })
-	return first, second
-}
-
-func TestRecoveryAcrossTwoHTTPInstancesAndIndependentPools(t *testing.T) {
-	first, second := twinRecoveryStores(t)
-	t.Logf("recovery HTTP dialect=%s two independent stores", first.Dialect())
-	hA := newAuthTestServerOnStore(t, first, t.TempDir()).Handler()
-	hB := newAuthTestServerOnStore(t, second, t.TempDir()).Handler()
-	adminCookie := bootAdmin(t, hA, first)
-	account, err := first.CreatePendingAccount("admin", "two-instance-owner", store.AccountProfile{})
-	if err != nil {
-		t.Fatal(err)
-	}
-	activation, err := first.InitializePendingAccount(account.ID, account.StateVersion, account.InitializationGeneration)
-	if err != nil {
-		t.Fatal(err)
-	}
-	setup := do(hB, "POST", "/api/auth/login-key/redeem", `{"key":"`+activation+`"}`, "")
-	if setup.Code != http.StatusOK {
-		t.Fatalf("second instance activation redeem: %d %s", setup.Code, setup.Body.String())
-	}
-	if done := do(hA, "POST", "/api/auth/password", `{"next":"two-instance-initial"}`, cookieOf(setup)); done.Code != http.StatusOK {
-		t.Fatalf("first instance initial set: %d %s", done.Code, done.Body.String())
-	}
-	login := do(hA, "POST", "/api/auth/login", `{"owner":"two-instance-owner","password":"two-instance-initial"}`, "")
-	if login.Code != http.StatusOK {
-		t.Fatalf("first instance login: %d %s", login.Code, login.Body.String())
-	}
-	ownerCookie := cookieOf(login)
-	current, err := second.GetAccount(account.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	proposalResponse := do(hA, "POST", "/api/admin/users/"+account.ID+"/recovery-proposals",
-		`{"expectedStateVersion":`+jsonNumber(current.StateVersion)+`,"idempotencyKey":"two-instance-proposal"}`, adminCookie)
-	if proposalResponse.Code != http.StatusOK {
-		t.Fatalf("proposal: %d %s", proposalResponse.Code, proposalResponse.Body.String())
-	}
-	var proposal store.RecoveryProposal
-	if err := json.Unmarshal(proposalResponse.Body.Bytes(), &proposal); err != nil {
-		t.Fatal(err)
-	}
-	confirmation := do(hB, "POST", "/api/auth/recovery-proposals/"+proposal.ID+"/confirm", `{"expectedVersion":1}`, ownerCookie)
-	if confirmation.Code != http.StatusOK {
-		t.Fatalf("second instance confirm: %d %s", confirmation.Code, confirmation.Body.String())
-	}
-	var confirmed struct {
-		Grant string `json:"grant"`
-	}
-	if err := json.Unmarshal(confirmation.Body.Bytes(), &confirmed); err != nil || confirmed.Grant == "" {
-		t.Fatalf("grant response: %v", err)
-	}
-	redeemed := do(hA, "POST", "/api/auth/recovery-grants/redeem", `{"key":"`+confirmed.Grant+`"}`, "")
-	if redeemed.Code != http.StatusOK {
-		t.Fatalf("first instance grant redeem: %d %s", redeemed.Code, redeemed.Body.String())
-	}
-	if completed := do(hB, "POST", "/api/auth/password", `{"next":"two-instance-recovered"}`, cookieOf(redeemed)); completed.Code != http.StatusOK {
-		t.Fatalf("second instance recovery completion: %d %s", completed.Code, completed.Body.String())
-	}
-	if old := do(hB, "GET", "/api/me", "", ownerCookie); old.Code != http.StatusUnauthorized {
-		t.Fatalf("old proof session survived: %d", old.Code)
-	}
-	if fresh := do(hA, "POST", "/api/auth/login", `{"owner":"two-instance-owner","password":"two-instance-recovered"}`, ""); fresh.Code != http.StatusOK {
-		t.Fatalf("recovered password login: %d %s", fresh.Code, fresh.Body.String())
-	}
-	after, err := first.GetAccount(account.ID)
-	if err != nil || after.CredentialOrigin != store.CredentialOriginOwnerRecovery || after.ID != account.ID {
-		t.Fatalf("persistent identity or provenance changed: %+v %v", after, err)
-	}
-}

internal/server/resource_authz_consumption_test.go

@@ -19,11 +19,11 @@ import (
 func newV2CaptureServer(t *testing.T) (*Server, *store.Store, string, string, string) {
 	t.Helper()
 	srv, st := newAuthTestServer(t)
-	alice, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	alice, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	bob, err := createLegacyAPIKeyFixture(t, st, "bob", "e2e")
+	bob, err := st.CreateAPIKey("bob", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/resource_authz_test.go

@@ -19,15 +19,15 @@ func TestProjectResourceAuthorizerSharesReads(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
 
-	alice, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	alice, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	bob, err := createLegacyAPIKeyFixture(t, st, "bob", "e2e")
+	bob, err := st.CreateAPIKey("bob", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	carol, err := createLegacyAPIKeyFixture(t, st, "carol", "e2e")
+	carol, err := st.CreateAPIKey("carol", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/rewind.go

@@ -38,7 +38,7 @@ func (s *Server) rewindFiles(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "messageId required", http.StatusBadRequest)
 		return
 	}
-	if err := s.mgr.ClaimConversation(id, owner); err != nil {
+	if err := s.mgr.ClaimConversation(id); err != nil {
 		if errors.Is(err, runmgr.ErrConversationBusy) {
 			http.Error(w, "conversation busy", http.StatusConflict)
 			return

internal/server/run_process_events_test.go

@@ -1,131 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"net/http"
-	"strconv"
-	"testing"
-	"time"
-
-	"agent-system-backend/internal/store"
-	core "agent-system-core"
-)
-
-func TestRunProcessEventsAreOrderedAndBoundToConversation(t *testing.T) {
-	srv, st := newTestServer(t)
-	h := srv.Handler()
-	_, convID := setupConversation(t, h)
-	_, otherConvID := setupConversation(t, h)
-	runID := postMessage(t, h, convID, "整理材料")
-	waitRunTerminal(t, h, runID, 5*time.Second)
-	events := []core.StreamEvent{
-		{RunID: runID, Type: core.EvThinkingDelta, Payload: json.RawMessage(`{"index":0,"text":"先核对日期"}`)},
-		{RunID: runID, Type: core.EvToolOutput, Payload: json.RawMessage(`{"callId":"call-1","stream":"stdout","text":"完整工具输出"}`)},
-	}
-	if _, err := st.AppendEvents(convID, events); err != nil {
-		t.Fatal(err)
-	}
-	// The runner may persist its terminal event after its status becomes terminal.
-	// Anchor paging to the events this test appended, not an earlier snapshot.
-	path := "/api/conversations/" + convID + "/runs/" + runID + "/events?after=" + strconv.FormatInt(events[0].Seq-1, 10) + "&limit=1"
-	code, first := doJSON(t, h, http.MethodGet, path, nil)
-	if code != http.StatusOK {
-		t.Fatalf("first page: %d %v", code, first)
-	}
-	page := first["events"].([]any)
-	if len(page) != 1 || page[0].(map[string]any)["type"] != string(core.EvThinkingDelta) {
-		t.Fatalf("first page: %v", page)
-	}
-	seq := int64(page[0].(map[string]any)["seq"].(float64))
-	code, second := doJSON(t, h, http.MethodGet, "/api/conversations/"+convID+"/runs/"+runID+"/events?after="+strconv.FormatInt(seq, 10)+"&limit=1", nil)
-	if code != http.StatusOK {
-		t.Fatalf("second page: %d %v", code, second)
-	}
-	page = second["events"].([]any)
-	if len(page) != 1 || page[0].(map[string]any)["type"] != string(core.EvToolOutput) {
-		t.Fatalf("second page: %v", page)
-	}
-	if payload := page[0].(map[string]any)["payload"].(map[string]any); payload["text"] != "完整工具输出" {
-		t.Fatalf("payload: %v", payload)
-	}
-	parent, err := st.GetRunByID(runID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	child := core.Run{ID: "run_child_process", ParentRunID: parent.ID, ConversationID: parent.ConversationID,
-		ProjectID: parent.ProjectID, Owner: parent.Owner, Kind: core.RunSubagent, Status: core.RunCompleted}
-	if err := st.CreateRun(&child); err != nil {
-		t.Fatal(err)
-	}
-	childEvents := []core.StreamEvent{
-		{RunID: child.ID, Type: core.EvAgentProgress, Payload: json.RawMessage(`{"agentRun":"run_child_process","note":"正在核对附录"}`)},
-		{RunID: child.ID, Type: core.EvToolOutput, Payload: json.RawMessage(`{"callId":"hidden","text":"child raw output"}`)},
-		{RunID: child.ID, Type: core.EvAgentResult, Payload: json.RawMessage(`{"agentRun":"run_child_process","status":"completed","summary":"附录已核对"}`)},
-	}
-	if _, err := st.AppendEvents(convID, childEvents); err != nil {
-		t.Fatal(err)
-	}
-	code, childPage := doJSON(t, h, http.MethodGet, "/api/conversations/"+convID+"/runs/"+runID+"/events?after="+strconv.FormatInt(events[1].Seq, 10), nil)
-	if code != http.StatusOK {
-		t.Fatalf("child page: %d %v", code, childPage)
-	}
-	childRows := childPage["events"].([]any)
-	if len(childRows) != 2 || childRows[0].(map[string]any)["type"] != string(core.EvAgentProgress) || childRows[1].(map[string]any)["type"] != string(core.EvAgentResult) {
-		t.Fatalf("child progress/result not retained or raw child output leaked: %v", childRows)
-	}
-	code, _ = doJSON(t, h, http.MethodGet, "/api/conversations/"+otherConvID+"/runs/"+runID+"/events", nil)
-	if code != http.StatusNotFound {
-		t.Fatalf("mismatched conversation exposed run: %d", code)
-	}
-}
-
-func TestRunProcessEventsRejectsDisabledImplicitLocal(t *testing.T) {
-	first, second := twinRecoveryStores(t)
-	t.Logf("process-event replay dialect=%s independent stores", first.Dialect())
-	if err := first.CreateAccount("admin", "", "", true); err != nil {
-		t.Fatal(err)
-	}
-	if err := first.EnsureUser(store.OwnerDefault, ""); err != nil {
-		t.Fatal(err)
-	}
-	project, err := first.CreateProject(store.OwnerDefault, "Project")
-	if err != nil {
-		t.Fatal(err)
-	}
-	conversation, err := first.CreateConversation(store.OwnerDefault, project.ID, "Process", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	run := core.Run{ID: "run_local_process", ConversationID: conversation.ID, ProjectID: project.ID,
-		Owner: store.OwnerDefault, Kind: core.RunConversation, Status: core.RunCompleted}
-	if err := first.CreateRun(&run); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := first.AppendEvents(conversation.ID, []core.StreamEvent{{RunID: run.ID, Type: core.EvThinkingDelta,
-		Payload: json.RawMessage(`{"index":0,"text":"private process"}`)}}); err != nil {
-		t.Fatal(err)
-	}
-	srv := newAuthTestServerOnStore(t, second, t.TempDir())
-	h := srv.Handler()
-	path := "/api/conversations/" + conversation.ID + "/runs/" + run.ID + "/events"
-	code, _ := doJSON(t, h, http.MethodGet, path, nil)
-	if code != http.StatusUnauthorized {
-		t.Fatalf("auth-on replay without credential: %d", code)
-	}
-	srv.Auth.Enabled = false
-	code, _ = doJSON(t, h, http.MethodGet, path, nil)
-	if code != http.StatusOK {
-		t.Fatalf("enabled local account could not read process events: %d", code)
-	}
-	account, err := first.GetAccountByOwner(store.OwnerDefault)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := first.SetAccountEnabled("admin", account.ID, account.StateVersion, false); err != nil {
-		t.Fatal(err)
-	}
-	code, _ = doJSON(t, h, http.MethodGet, path, nil)
-	if code != http.StatusForbidden {
-		t.Fatalf("disabled local account read process events: %d", code)
-	}
-}

internal/server/server.go

@@ -42,28 +42,27 @@ import (
 )
 
 type Server struct {
-	accountSearchKey    store.AccountCursorKey
-	accountSearchKeyErr error
-	projectLifecycle    *extension.ProjectLifecycle
-	projectHost         func(string) extension.Host
-	st                  *store.Store
-	Auth                *Authenticator       // API key 认证（nil/未启用 = 默认租户；组合根注入）
-	Retriever           core.Retriever       // 混合检索（nil = store 全文；组合根注入）
-	Indexer             core.DocumentIndexer // 检索索引入口（nil = 整文档单块；组合根注入）
-	Limiter             ratelimit.Limiter    // 租户限流（nil = 不限；组合根注入）
-	LimitLookup         func() int           // 当前限流值（次/分；<=0 不限；组合根缓存注入）
-	mgr                 *runmgr.Manager
-	Cards               *cardsvc.Service    // 收件箱任务卡（nil = 不启用；组合根注入）
-	Surfaces            *surfacesvc.Service // Generative UI Surface（nil = 不启用；EXT-17）
-	Bus                 *cmdbus.Bus         // 命令总线（nil = 不启用；组合根注入；四入口同源 D27）
-	Gate                NLIntentGate        // 意图闸门（chat 入口同源判定；nil = 不接）
-	Workflows           *workflow.Registry  // 已装载工作流（nil = 不接）
-	Prompts             *prompts.Service    // 提示词库（nil = 不启用 API 与技能命令；执行器另有回退）
-	reg                 *tools.Registry
-	prof                *profiles.Service
-	set                 *settings.Service
-	plugins             *plugins.Host
-	static              fs.FS
+	projectLifecycle     *extension.ProjectLifecycle
+	projectSettingsAuthz extension.ProjectSettingsAuthorizer
+	projectHost          func(string) extension.Host
+	st                   *store.Store
+	Auth                 *Authenticator       // API key 认证（nil/未启用 = 默认租户；组合根注入）
+	Retriever            core.Retriever       // 混合检索（nil = store 全文；组合根注入）
+	Indexer              core.DocumentIndexer // 检索索引入口（nil = 整文档单块；组合根注入）
+	Limiter              ratelimit.Limiter    // 租户限流（nil = 不限；组合根注入）
+	LimitLookup          func() int           // 当前限流值（次/分；<=0 不限；组合根缓存注入）
+	mgr                  *runmgr.Manager
+	Cards                *cardsvc.Service    // 收件箱任务卡（nil = 不启用；组合根注入）
+	Surfaces             *surfacesvc.Service // Generative UI Surface（nil = 不启用；EXT-17）
+	Bus                  *cmdbus.Bus         // 命令总线（nil = 不启用；组合根注入；四入口同源 D27）
+	Gate                 NLIntentGate        // 意图闸门（chat 入口同源判定；nil = 不接）
+	Workflows            *workflow.Registry  // 已装载工作流（nil = 不接）
+	Prompts              *prompts.Service    // 提示词库（nil = 不启用 API 与技能命令；执行器另有回退）
+	reg                  *tools.Registry
+	prof                 *profiles.Service
+	set                  *settings.Service
+	plugins              *plugins.Host
+	static               fs.FS
 	// Subscribe 注入 bus 订阅（事件在线转发；重放走 store 游标）。
 	Subscribe func(conversationID string) (<-chan core.StreamEvent, func())
 	// DisableUploadIndexing EXT-9：true 时上传端点不再自动写检索索引（原件与
@@ -162,9 +161,7 @@ func New(st *store.Store, mgr *runmgr.Manager, reg *tools.Registry, p *profiles.
 	if err != nil {
 		panic(err) // embed 布局错误属构建期问题
 	}
-	key, keyErr := st.GetAccountCursorKey()
-	return &Server{st: st, mgr: mgr, reg: reg, prof: p, set: s, plugins: ph, static: sub,
-		accountSearchKey: key, accountSearchKeyErr: keyErr}
+	return &Server{st: st, mgr: mgr, reg: reg, prof: p, set: s, plugins: ph, static: sub}
 }
 
 // NLIntentGate 意图闸门端口（intentgate.Gate 实现；避免包依赖方向反转）。
@@ -223,7 +220,7 @@ func (s *Server) WireBuiltinCommands() {
 		ParamsSchema: json.RawMessage(`{"type":"object","required":["on"],"properties":{"on":{"type":"boolean"}}}`)},
 		"/mock", func(ctx context.Context, req cmdbus.Request) (any, error) {
 			on, _ := req.Params["on"].(bool)
-			if err := s.set.MergeUserAccountChecked(req.Owner, map[string]any{"runtime": map[string]any{"mock": on}}, s.Auth == nil || !s.Auth.Enabled); err != nil {
+			if err := s.set.MergeUser(req.Owner, map[string]any{"runtime": map[string]any{"mock": on}}); err != nil {
 				return nil, err
 			}
 			return map[string]any{"runtime.mock": on}, nil
@@ -232,7 +229,7 @@ func (s *Server) WireBuiltinCommands() {
 		ParamsSchema: json.RawMessage(`{"type":"object","required":["model"],"properties":{"model":{"type":"string"}}}`)},
 		"/model", func(ctx context.Context, req cmdbus.Request) (any, error) {
 			m, _ := req.Params["model"].(string)
-			if err := s.set.MergeUserAccountChecked(req.Owner, map[string]any{"models": map[string]any{"chat": map[string]any{"model": m}}}, s.Auth == nil || !s.Auth.Enabled); err != nil {
+			if err := s.set.MergeUser(req.Owner, map[string]any{"models": map[string]any{"chat": map[string]any{"model": m}}}); err != nil {
 				return nil, err
 			}
 			return map[string]any{"model": m}, nil
@@ -241,7 +238,7 @@ func (s *Server) WireBuiltinCommands() {
 		ParamsSchema: json.RawMessage(`{"type":"object","required":["profileId"],"properties":{"profileId":{"type":"string"}}}`)},
 		"/profile", func(ctx context.Context, req cmdbus.Request) (any, error) {
 			pid, _ := req.Params["profileId"].(string)
-			if err := s.st.UpdateConversationAccountChecked(req.Owner, req.ConversationID, "", pid, s.Auth == nil || !s.Auth.Enabled); err != nil {
+			if err := s.st.UpdateConversation(req.Owner, req.ConversationID, "", pid); err != nil {
 				return nil, err
 			}
 			return map[string]any{"profile": pid}, nil
@@ -286,25 +283,10 @@ func (s *Server) Handler() http.Handler {
 	// ---- 认证与会话（管理员发放制，R2）----
 	mux.HandleFunc("POST /api/auth/login", s.login)
 	mux.HandleFunc("POST /api/auth/login-key/redeem", s.redeemLoginKey)
-	mux.HandleFunc("POST /api/auth/recovery-grants/redeem", s.redeemLoginKey)
 	mux.HandleFunc("POST /api/auth/logout", s.logout)
 	mux.HandleFunc("POST /api/auth/password", s.changePassword)
 	mux.HandleFunc("GET /api/admin/users", s.listAdminUsers)
-	mux.HandleFunc("GET /api/admin/users/search", s.searchAdminUsers)
 	mux.HandleFunc("POST /api/admin/users", s.createAdminUser)
-	mux.HandleFunc("GET /api/me/profile", s.meProfile)
-	mux.HandleFunc("PATCH /api/me/profile", s.patchMeProfile)
-	mux.HandleFunc("GET /api/admin/users/{userId}", s.adminAccount)
-	mux.HandleFunc("PATCH /api/admin/users/{userId}/profile", s.patchAdminAccountProfile)
-	mux.HandleFunc("PUT /api/admin/users/{userId}/state", s.setAdminAccountState)
-	mux.HandleFunc("POST /api/admin/users/{userId}/recovery-proposals", s.createAdminRecoveryProposal)
-	mux.HandleFunc("GET /api/admin/users/{userId}/recovery-proposals", s.listAdminRecoveryProposals)
-	mux.HandleFunc("GET /api/admin/users/{userId}/recovery-proposals/{id}", s.getAdminRecoveryProposal)
-	mux.HandleFunc("DELETE /api/admin/users/{userId}/recovery-proposals/{id}", s.revokeAdminRecoveryProposal)
-	mux.HandleFunc("GET /api/me/recovery-proposals", s.listMyRecoveryProposals)
-	mux.HandleFunc("GET /api/me/recovery-proposals/{id}", s.getMyRecoveryProposal)
-	mux.HandleFunc("POST /api/auth/recovery-proposals/{id}/confirm", s.confirmRecoveryProposal)
-	mux.HandleFunc("POST /api/auth/recovery-proposals/{id}/rotate-grant", s.rotateRecoveryGrant)
 	mux.HandleFunc("POST /api/admin/users/{owner}/password", s.resetAdminUserPassword)
 	mux.HandleFunc("POST /api/admin/users/{owner}/login-keys", s.issueAdminLoginKey)
 	mux.HandleFunc("GET /api/admin/users/{owner}/login-keys", s.listAdminLoginKeys)
@@ -319,7 +301,6 @@ func (s *Server) Handler() http.Handler {
 	mux.HandleFunc("POST /api/projects/{id}/conversations", s.createConversation)
 	mux.HandleFunc("GET /api/conversations", s.listTasks)
 	mux.HandleFunc("GET /api/conversations/{id}", s.conversationDetail)
-	mux.HandleFunc("GET /api/conversations/{id}/runs/{runId}/events", s.runProcessEvents)
 	mux.HandleFunc("GET /api/conversations/{id}/export", s.exportConversation)
 	mux.HandleFunc("PATCH /api/conversations/{id}", s.patchConversation)
 	mux.HandleFunc("DELETE /api/conversations/{id}", s.deleteConversation)
@@ -375,6 +356,11 @@ func (s *Server) Handler() http.Handler {
 	mux.HandleFunc("GET /api/settings", s.getSettings)
 	mux.HandleFunc("PUT /api/settings/user", s.putSettingsUser)
 	mux.HandleFunc("PUT /api/settings/project/{id}", s.putSettingsProject)
+	mux.HandleFunc("PUT /api/settings/project/{id}/personal", s.putSettingsPersonalProject)
+	mux.HandleFunc("GET /api/settings/migration", s.getSettingsMigration)
+	mux.HandleFunc("POST /api/settings/project/{id}/migration/preview", s.previewSettingsMigration)
+	mux.HandleFunc("POST /api/settings/project/{id}/migration/apply", s.applySettingsMigration)
+	mux.HandleFunc("POST /api/settings/migration/system", s.putSettingsSystem)
 	mux.HandleFunc("GET /api/settings/system", s.getSettingsSystem)
 	mux.HandleFunc("PUT /api/settings/system", s.putSettingsSystem)
 	mux.HandleFunc("GET /api/tools", s.listTools)
@@ -533,11 +519,6 @@ func (s *Server) events(w http.ResponseWriter, r *http.Request) {
 
 	lastVisible := since
 	send := func(e core.StreamEvent) bool {
-		// Recheck before every frame, including stored replay. A revocation during
-		// an active stream must not disclose the next queued business event.
-		if !stillAuthed() {
-			return false
-		}
 		if e.Seq <= lastVisible {
 			return true
 		}
@@ -597,10 +578,6 @@ func (s *Server) events(w http.ResponseWriter, r *http.Request) {
 				return
 			}
 		case <-heartbeat.C:
-			if !stillAuthed() {
-				stop()
-				return
-			}
 			fmt.Fprint(w, ": ping\n\n")
 			flusher.Flush()
 		case e, ok := <-live:
@@ -728,7 +705,7 @@ func (s *Server) createProject(w http.ResponseWriter, r *http.Request) {
 		writeProjectJSON(w, s.publicProjectMetadata(p), err)
 		return
 	}
-	p, err := s.st.CreateProjectAccountChecked(s.owner(r), strings.TrimSpace(req.Name), s.Auth == nil || !s.Auth.Enabled)
+	p, err := s.st.CreateProject(s.owner(r), strings.TrimSpace(req.Name))
 	writeJSONOr(w, p, err)
 }
 
@@ -769,7 +746,7 @@ func (s *Server) patchProject(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 		if req.Settings != nil {
-			if err := s.st.UpdateProjectSettingsAccountChecked(s.owner(r), id, req.Settings, s.Auth == nil || !s.Auth.Enabled); err != nil {
+			if err := s.st.UpdateProjectSettings(s.owner(r), id, req.Settings); err != nil {
 				writeStoreErr(w, err)
 				return
 			}
@@ -795,13 +772,13 @@ func (s *Server) patchProject(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if req.Name != nil {
-		if err := s.st.RenameProjectAccountChecked(s.owner(r), id, *req.Name, s.Auth == nil || !s.Auth.Enabled); err != nil {
+		if err := s.st.RenameProject(s.owner(r), id, *req.Name); err != nil {
 			writeStoreErr(w, err)
 			return
 		}
 	}
 	if req.Settings != nil {
-		if err := s.st.UpdateProjectSettingsAccountChecked(s.owner(r), id, req.Settings, s.Auth == nil || !s.Auth.Enabled); err != nil {
+		if err := s.st.UpdateProjectSettings(s.owner(r), id, req.Settings); err != nil {
 			writeStoreErr(w, err)
 			return
 		}
@@ -823,7 +800,7 @@ func (s *Server) deleteProject(w http.ResponseWriter, r *http.Request) {
 		writeJSON(w, http.StatusOK, map[string]any{"ok": true})
 		return
 	}
-	writeOKOr(w, s.st.DeleteProjectAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.DeleteProject(s.owner(r), r.PathValue("id")))
 }
 
 func (s *Server) listConversations(w http.ResponseWriter, r *http.Request) {
@@ -860,11 +837,6 @@ func (s *Server) me(w http.ResponseWriter, r *http.Request) {
 	if sc := SessionScope(r); sc != "" {
 		out["sessionScope"] = sc
 	}
-	if AuthVia(r) == AuthViaSession {
-		if mode, err := s.st.SessionPasswordChangeMode(sessionToken(r)); err == nil {
-			out["passwordChangeMode"] = mode
-		}
-	}
 	if st, err := s.st.GetUserAuthState(owner); err == nil {
 		out["isAdmin"] = st.IsAdmin
 		out["mustChangePassword"] = st.MustChangePassword
@@ -912,58 +884,6 @@ func (s *Server) conversationDetail(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-// runProcessEvents lets an owner reopen the exact persisted process after the
-// transient SSE bubble has been replaced by the settled assistant message.
-func (s *Server) runProcessEvents(w http.ResponseWriter, r *http.Request) {
-	id, runID := r.PathValue("id"), r.PathValue("runId")
-	owner := s.owner(r)
-	if err := s.checkActorBeforeExternalEffect(owner); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	if _, err := s.st.GetConversation(owner, id); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	run, err := s.st.GetRun(owner, runID)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	if string(run.ConversationID) != id {
-		http.NotFound(w, r)
-		return
-	}
-	after, err := strconv.ParseInt(r.URL.Query().Get("after"), 10, 64)
-	if r.URL.Query().Get("after") == "" {
-		after, err = 0, nil
-	}
-	if err != nil || after < 0 {
-		http.Error(w, "invalid after", http.StatusBadRequest)
-		return
-	}
-	limit := 500
-	if raw := r.URL.Query().Get("limit"); raw != "" {
-		limit, err = strconv.Atoi(raw)
-		if err != nil || limit < 1 || limit > 500 {
-			http.Error(w, "invalid limit", http.StatusBadRequest)
-			return
-		}
-	}
-	events, err := s.st.RunEventsAfter(id, runID, after, limit)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	// The authenticated account can be disabled while stored events are read.
-	// Recheck immediately before returning private process output.
-	if err := s.checkActorBeforeExternalEffect(owner); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	writeJSON(w, http.StatusOK, map[string]any{"events": events})
-}
-
 func (s *Server) patchConversation(w http.ResponseWriter, r *http.Request) {
 	id := r.PathValue("id")
 	var req struct {
@@ -980,28 +900,28 @@ func (s *Server) patchConversation(w http.ResponseWriter, r *http.Request) {
 	onlyMode := req.PermissionMode != nil && req.Title == "" && req.ProfileID == "" && req.Pinned == nil && req.Archived == nil && req.AllowCrossRead == nil && req.CrossPrivate == nil && req.SessionNote == nil
 	onlyNote := req.SessionNote != nil && req.Title == "" && req.ProfileID == "" && req.Pinned == nil && req.Archived == nil && req.AllowCrossRead == nil && req.CrossPrivate == nil && req.PermissionMode == nil
 	if !onlyMode && !onlyNote {
-		if err := s.st.UpdateConversationAccountChecked(s.owner(r), id, req.Title, req.ProfileID, s.Auth == nil || !s.Auth.Enabled); err != nil {
+		if err := s.st.UpdateConversation(s.owner(r), id, req.Title, req.ProfileID); err != nil {
 			writeStoreErr(w, err)
 			return
 		}
 	}
 	if req.PermissionMode != nil {
-		if err := s.st.SetPermissionModeAccountChecked(s.owner(r), id, *req.PermissionMode, s.Auth == nil || !s.Auth.Enabled); err != nil {
+		if err := s.st.SetPermissionMode(s.owner(r), id, *req.PermissionMode); err != nil {
 			writeStoreErr(w, err)
 			return
 		}
 	}
 	if req.SessionNote != nil {
-		if err := s.st.SetSessionNoteAccountChecked(s.owner(r), id, *req.SessionNote, s.Auth == nil || !s.Auth.Enabled); err != nil {
+		if err := s.st.SetSessionNote(s.owner(r), id, *req.SessionNote); err != nil {
 			writeStoreErr(w, err)
 			return
 		}
 	}
-	writeOKOr(w, s.st.SetConversationFlagsAccountChecked(s.owner(r), id, req.Pinned, req.Archived, req.AllowCrossRead, req.CrossPrivate, s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.SetConversationFlags(s.owner(r), id, req.Pinned, req.Archived, req.AllowCrossRead, req.CrossPrivate))
 }
 
 func (s *Server) deleteConversation(w http.ResponseWriter, r *http.Request) {
-	writeOKOr(w, s.st.DeleteConversationAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.DeleteConversation(s.owner(r), r.PathValue("id")))
 }
 
 // ---- 消息发送（含命令路由与附件） ----
@@ -1121,14 +1041,14 @@ func (s *Server) postMessage(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, "execution queue full（runtime.execQueueMax）", http.StatusTooManyRequests)
 			return
 		}
-		if err := s.mgr.ClaimConversation(convID, owner); err != nil {
+		if err := s.mgr.ClaimConversation(convID); err != nil {
 			writeStoreErr(w, err)
 			return
 		}
 		claimed = true
 	}
 	msg := core.Message{ConversationID: convID, Role: core.RoleUser, Parts: parts}
-	if err := s.st.AppendMessageWithRequestAccountChecked(owner, s.Auth == nil || !s.Auth.Enabled, &msg, req.RequestID); err != nil {
+	if err := s.st.AppendMessageWithRequest(&msg, req.RequestID); err != nil {
 		var dup *store.DuplicateRequestError
 		if errors.As(err, &dup) {
 			if claimed {
@@ -1176,11 +1096,7 @@ func (s *Server) postMessage(w http.ResponseWriter, r *http.Request) {
 		writeProjectErr(w, startErr)
 		return
 	}
-	if err := s.st.SetMessageRunIDAccountChecked(owner, msg.ID, string(run.ID), s.Auth == nil || !s.Auth.Enabled); err != nil {
-		_ = s.mgr.CancelRun(string(run.ID))
-		writeStoreErr(w, err)
-		return
-	}
+	_ = s.st.SetMessageRunID(msg.ID, run.ID)
 	msg.RunID = run.ID
 	writeJSON(w, http.StatusOK, map[string]any{"message": msg, "run": run})
 }
@@ -1341,8 +1257,12 @@ func (s *Server) cancelRun(w http.ResponseWriter, r *http.Request) {
 	// conversation_id 必须回填真实值：消费侧按执行权 JOIN 匹配，空串永远
 	// 无法送达（同批实测）。
 	if s.st.Dialect() == "postgres" && !s.mgr.RunActiveLocally(runID) {
-		if cerr := s.st.EnqueueCommandAccountChecked(s.owner(r), store.NewID("cmd"), "cancel", runID, 0,
-			runmgr.CancelCommandPayload{Owner: s.owner(r), RunID: runID}, s.Auth == nil || !s.Auth.Enabled); cerr != nil {
+		convID := ""
+		if run, gerr := s.st.GetRun(s.owner(r), runID); gerr == nil {
+			convID = string(run.ConversationID)
+		}
+		if cerr := s.st.EnqueueCommand(store.NewID("cmd"), "cancel", runID, convID, 0,
+			runmgr.CancelCommandPayload{Owner: s.owner(r), RunID: runID}); cerr != nil {
 			writeStoreErr(w, cerr)
 			return
 		}
@@ -1396,8 +1316,8 @@ func (s *Server) resolveHITL(w http.ResponseWriter, r *http.Request) {
 			if kind == "" {
 				kind = "free"
 			}
-			if cerr := s.st.EnqueueCommandAccountChecked(s.owner(r), store.NewID("cmd"), "hitl", string(card.RunID), 0,
-				runmgr.HITLCommandPayload{Owner: s.owner(r), CardID: string(resp.CardID), Kind: kind, Answer: json.RawMessage(resp.FreeText)}, s.Auth == nil || !s.Auth.Enabled); cerr == nil {
+			if cerr := s.st.EnqueueCommand(store.NewID("cmd"), "hitl", string(card.RunID), string(card.ConversationID), 0,
+				runmgr.HITLCommandPayload{Owner: s.owner(r), CardID: string(resp.CardID), Kind: kind, Answer: json.RawMessage(resp.FreeText)}); cerr == nil {
 				writeJSON(w, http.StatusAccepted, map[string]any{"accepted": true, "via": "command"})
 				return
 			}
@@ -1437,7 +1357,7 @@ func (s *Server) listProjectCards(w http.ResponseWriter, r *http.Request) {
 // cardToProject 会话卡留档到项目收件箱（D48）：复制为项目级卡（幂等），原卡
 // dismissed 留痕；回执给前端 upsert 两张卡的终态。
 func (s *Server) cardToProject(w http.ResponseWriter, r *http.Request) {
-	created, err := s.Cards.ToProjectAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled)
+	created, err := s.Cards.ToProject(s.owner(r), r.PathValue("id"))
 	if err != nil {
 		writeStoreErr(w, err)
 		return
@@ -1482,12 +1402,12 @@ func (s *Server) cardAction(w http.ResponseWriter, r *http.Request) {
 	// 命令确认卡（ref=cmd:<id>）走总线回道：confirm=执行挂起命令，其余=取消。
 	if ref, err := s.st.CardRef(owner, r.PathValue("id")); err == nil && strings.HasPrefix(ref, "cmd:") {
 		if card, err := s.Cards.Get(owner, r.PathValue("id")); err == nil && card.Status == core.CardActionRequired {
-			resp := s.Bus.ConfirmContext(r.Context(), owner, card.ID, r.PathValue("actionId"))
+			resp := s.Bus.Confirm(owner, card.ID, r.PathValue("actionId"))
 			writeJSON(w, http.StatusOK, map[string]any{"card": card, "receipt": resp.Receipt, "payload": resp.Payload})
 			return
 		}
 	}
-	card, label, err := s.Cards.ActionAccountChecked(owner, r.PathValue("id"), r.PathValue("actionId"), body.FreeText, s.Auth == nil || !s.Auth.Enabled)
+	card, label, err := s.Cards.Action(owner, r.PathValue("id"), r.PathValue("actionId"), body.FreeText)
 	if err != nil {
 		writeStoreErr(w, err)
 		return
@@ -1498,10 +1418,7 @@ func (s *Server) cardAction(w http.ResponseWriter, r *http.Request) {
 	if card.ConversationID != "" {
 		receipt = &core.Message{ID: store.NewID("msg"), ConversationID: card.ConversationID, Role: core.RoleAssistant, CreatedAt: time.Now().UTC()}
 		receipt.Parts = []core.Part{{Type: core.PartText, Text: fmt.Sprintf("✓ 已按「%s」处理「%s」——结论已记录并留痕（card:%s）", label, card.Title, card.ID)}}
-		if err := s.st.AppendMessageWithRequestAccountChecked(owner, s.Auth == nil || !s.Auth.Enabled, receipt, ""); err != nil {
-			writeStoreErr(w, err)
-			return
-		}
+		_ = s.st.AppendMessage(receipt)
 	}
 	writeJSON(w, http.StatusOK, map[string]any{"card": card, "receipt": receipt})
 }
@@ -1511,12 +1428,12 @@ func (s *Server) cardPin(w http.ResponseWriter, r *http.Request) {
 		Pinned bool `json:"pinned"`
 	}
 	_ = json.NewDecoder(r.Body).Decode(&body)
-	card, err := s.Cards.SetPinnedAccountChecked(s.owner(r), r.PathValue("id"), body.Pinned, s.Auth == nil || !s.Auth.Enabled)
+	card, err := s.Cards.SetPinned(s.owner(r), r.PathValue("id"), body.Pinned)
 	writeJSONOr(w, map[string]any{"card": card}, err)
 }
 
 func (s *Server) cardDismiss(w http.ResponseWriter, r *http.Request) {
-	card, err := s.Cards.DismissAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled)
+	card, err := s.Cards.Dismiss(s.owner(r), r.PathValue("id"))
 	writeJSONOr(w, map[string]any{"card": card}, err)
 }
 
@@ -1562,7 +1479,7 @@ func (s *Server) upload(w http.ResponseWriter, r *http.Request) {
 	}
 	mime := header.Header.Get("Content-Type")
 	art := core.Artifact{ProjectID: projectID, Owner: owner, Name: header.Filename, Kind: kindOf(header.Filename), MIME: mime}
-	if err := s.st.CreateArtifactAccountChecked(owner, &art, content, s.Auth == nil || !s.Auth.Enabled); err != nil {
+	if err := s.st.CreateArtifact(&art, content); err != nil {
 		writeStoreErr(w, err)
 		return
 	}
@@ -1577,13 +1494,7 @@ func (s *Server) upload(w http.ResponseWriter, r *http.Request) {
 	// original filename/parser metadata out of shared project cards and events.
 	showIngestCard := s.Cards != nil && s.projectLifecycle == nil
 	if showIngestCard {
-		var cardErr error
-		ingestCard, cardErr = s.Cards.CreateAccountChecked(owner, ingestCard, "", s.Auth == nil || !s.Auth.Enabled)
-		if errors.Is(cardErr, store.ErrAccountForbidden) {
-			writeStoreErr(w, cardErr)
-			return
-		}
-		showIngestCard = cardErr == nil
+		ingestCard, _ = s.Cards.Create(owner, ingestCard, "")
 	}
 	doc := ingest.Parse(art.Name, mime, content)
 	if showIngestCard {
@@ -1602,42 +1513,19 @@ func (s *Server) upload(w http.ResponseWriter, r *http.Request) {
 			body = append(body, core.UINode{Type: core.UIMarkdown, Markdown: "_解析不完整不静默：原始文件已永久保留，可取回或重试。_"})
 		}
 		ingestCard.Body = body
-		if _, version, err := s.st.GetCardVersion(owner, ingestCard.ID); err == nil {
-			if err := s.Cards.UpdateVersionedAccountChecked(owner, ingestCard, version, s.Auth == nil || !s.Auth.Enabled); errors.Is(err, store.ErrAccountForbidden) {
-				writeStoreErr(w, err)
-				return
-			}
-		}
+		_ = s.Cards.Update(owner, ingestCard)
 	}
 	// 文本可解析的进检索索引（管线分块+全文+可选向量）。
 	// EXT-9：宿主关闭自动索引时跳过（发布决定移交下游命令层；原件与摄取卡不变）。
 	if !s.DisableUploadIndexing {
 		if plain := doc.PlainText(); plain != "" && len(plain) < 200000 {
-			var indexErr error
 			if s.Indexer != nil {
-				if checked, ok := s.Indexer.(interface {
-					IndexDocumentAccountChecked(context.Context, core.ID, core.ID, string, string, string, string, bool) error
-				}); ok {
-					indexErr = checked.IndexDocumentAccountChecked(r.Context(), core.ID(owner), core.ID(projectID), "upload", art.Name, art.ID, plain, s.Auth == nil || !s.Auth.Enabled)
-				} else if s.Auth != nil && s.Auth.Enabled {
-					indexErr = store.ErrAccountForbidden // Unknown indexer has no final account fence.
-				} else {
-					indexErr = s.Indexer.IndexDocument(owner, projectID, "upload", art.Name, art.ID, plain)
-				}
+				_ = s.Indexer.IndexDocument(owner, projectID, "upload", art.Name, art.ID, plain)
 			} else {
-				indexErr = s.st.AddKnowledgeAccountChecked(owner, s.Auth == nil || !s.Auth.Enabled,
-					core.KnowledgeDoc{Owner: core.ID(owner), ProjectID: core.ID(projectID), Source: "upload", Title: art.Name, Ref: art.ID, Chunk: plain})
-			}
-			if errors.Is(indexErr, store.ErrAccountForbidden) {
-				writeStoreErr(w, indexErr)
-				return
+				_ = s.st.AddKnowledge(core.KnowledgeDoc{Owner: owner, ProjectID: projectID, Source: "upload", Title: art.Name, Ref: art.ID, Chunk: plain})
 			}
 		}
 	}
-	if err := s.checkActorBeforeExternalEffect(owner); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
 	writeJSON(w, http.StatusOK, core.UploadInfo{ArtifactID: art.ID, Filename: art.Name, MIME: mime, Size: art.Size, Parsed: &doc})
 }
 
@@ -1735,11 +1623,11 @@ func (s *Server) artifactContent(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) putArtifactContent(w http.ResponseWriter, r *http.Request) {
 	body, _ := io.ReadAll(io.LimitReader(r.Body, 20<<20))
-	writeOKOr(w, s.st.UpdateArtifactContentAccountChecked(s.owner(r), r.PathValue("id"), body, s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.UpdateArtifactContent(s.owner(r), r.PathValue("id"), body))
 }
 
 func (s *Server) deleteArtifact(w http.ResponseWriter, r *http.Request) {
-	writeOKOr(w, s.st.DeleteArtifactAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.st.DeleteArtifact(s.owner(r), r.PathValue("id")))
 }
 
 // ---- 画像 ----
@@ -1758,19 +1646,15 @@ func (s *Server) saveProfile(w http.ResponseWriter, r *http.Request) {
 	if p.ID == "" {
 		p.ID = "prof_" + strconv.FormatInt(time.Now().UnixNano()%100000, 10)
 	}
-	if err := s.prof.SaveAccountChecked(s.owner(r), p, s.Auth == nil || !s.Auth.Enabled); err != nil {
-		if errors.Is(err, store.ErrAccountForbidden) {
-			writeStoreErr(w, err)
-		} else {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-		}
+	if err := s.prof.Save(s.owner(r), p); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	writeJSON(w, http.StatusOK, p)
 }
 
 func (s *Server) deleteProfile(w http.ResponseWriter, r *http.Request) {
-	writeOKOr(w, s.prof.DeleteAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	writeOKOr(w, s.prof.Delete(s.owner(r), r.PathValue("id")))
 }
 
 // ---- 设置 ----
@@ -1778,51 +1662,108 @@ func (s *Server) deleteProfile(w http.ResponseWriter, r *http.Request) {
 func (s *Server) getSettings(w http.ResponseWriter, r *http.Request) {
 	owner := s.owner(r)
 	projectID := r.URL.Query().Get("project")
-	schema := append(settings.Schema(), s.plugins.SettingsSchema()...)
-	writeJSON(w, http.StatusOK, map[string]any{
-		"schema":   schema,
-		"defaults": settings.Masked(settings.SystemDefaults(), schema),
-		"user":     settings.Masked(mustUser(s.set, owner), schema),
-		"project":  settings.Masked(mustScope(s.set, owner, projectID), schema),
-	})
-}
-
-func mustUser(s *settings.Service, owner string) map[string]any {
-	m, _ := s.UserScope(owner)
-	if m == nil {
-		return map[string]any{}
-	}
-	return m
-}
-
-func mustScope(s *settings.Service, owner, projectID string) map[string]any {
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
 	if projectID == "" {
-		return map[string]any{}
+		schema := s.set.SchemaFor(settings.UserSettingScope)
+		user, err := s.set.UserScope(owner)
+		if err != nil {
+			writeStoreErr(w, err)
+			return
+		}
+		writeJSON(w, 200, map[string]any{"schema": schema, "defaults": settings.Masked(s.set.DefaultsFor(settings.UserSettingScope), schema), "user": settings.Masked(user, schema), "project": map[string]any{}})
+		return
 	}
-	m, _ := s.ProjectScope(owner, projectID)
-	return m
+	p, err := s.settingsProject(r.Context(), owner, projectID, false)
+	if err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	shared, revision, err := s.set.SharedProjectScope(p.ID)
+	if err != nil {
+		writeStoreErr(w, err)
+		return
+	}
+	schema := s.set.SchemaFor(settings.ProjectSettingScope)
+	personalSchema := s.set.SchemaFor(settings.PersonalProjectScope)
+	personalProject, err := s.set.ProjectScope(owner, p.ID)
+	if err != nil {
+		writeStoreErr(w, err)
+		return
+	}
+	personalUser, err := s.set.UserScope(owner)
+	if err != nil {
+		writeStoreErr(w, err)
+		return
+	}
+	_, configureErr := s.settingsProject(r.Context(), owner, p.ID, true)
+	writeJSON(w, 200, map[string]any{
+		"schema": schema, "defaults": settings.Masked(s.set.DefaultsFor(settings.ProjectSettingScope), schema), "project": settings.Masked(shared, schema),
+		"user": map[string]any{}, "projectRevision": revision, "projectCanConfigure": configureErr == nil,
+		"personalSchema": personalSchema, "personalDefaults": settings.Masked(s.set.DefaultsFor(settings.PersonalProjectScope), personalSchema),
+		"personalProject": settings.Masked(personalProject, personalSchema), "personalUser": settings.Masked(personalUser, personalSchema),
+	})
 }
 
 func (s *Server) putSettingsUser(w http.ResponseWriter, r *http.Request) {
-	var values map[string]any
-	if err := json.NewDecoder(r.Body).Decode(&values); err != nil {
+	values, err := decodeSettingsObject(r)
+	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	s.writeSettingsMerge(w, func() error {
-		return s.set.MergeUserAccountChecked(s.owner(r), values, s.Auth == nil || !s.Auth.Enabled)
-	})
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	if err := s.set.ValidateWrite(values, settings.UserSettingScope); err != nil {
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	s.writeSettingsMerge(w, func() error { return s.set.MergeUser(s.owner(r), values) })
 }
 
 func (s *Server) putSettingsProject(w http.ResponseWriter, r *http.Request) {
-	var values map[string]any
-	if err := json.NewDecoder(r.Body).Decode(&values); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
+	var req struct {
+		Values           map[string]any `json:"values"`
+		ExpectedRevision *int64         `json:"expectedRevision"`
+		Unset            []string       `json:"unset,omitempty"`
+	}
+	decoder := json.NewDecoder(io.LimitReader(r.Body, 1<<20))
+	decoder.DisallowUnknownFields()
+	if err := decoder.Decode(&req); err != nil || req.Values == nil || req.ExpectedRevision == nil || *req.ExpectedRevision < 0 {
+		http.Error(w, "需要 values 和 expectedRevision", 400)
 		return
 	}
-	s.writeSettingsMerge(w, func() error {
-		return s.set.MergeProjectAccountChecked(s.owner(r), r.PathValue("id"), values, s.Auth == nil || !s.Auth.Enabled)
-	})
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		http.Error(w, "请求只能包含一个对象", 400)
+		return
+	}
+	owner := s.owner(r)
+	p, err := s.settingsProject(r.Context(), owner, r.PathValue("id"), true)
+	if err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	if err := s.set.ValidateWrite(req.Values, settings.ProjectSettingScope); err != nil {
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	if err := s.validateProjectTemplate(owner, p, req.Values); err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	// Recheck authority after resource validation and immediately before persistence.
+	if _, err := s.settingsProject(r.Context(), owner, p.ID, true); err != nil {
+		writeProjectErr(w, err)
+		return
+	}
+	revision, err := s.set.MergeSharedProject(p.ID, req.Values, *req.ExpectedRevision, req.Unset)
+	if errors.Is(err, settings.ErrSettingsConflict) {
+		http.Error(w, err.Error(), 409)
+		return
+	}
+	if err != nil {
+		s.writeSettingsMerge(w, func() error { return err })
+		return
+	}
+	writeJSON(w, 200, map[string]any{"ok": true, "projectRevision": revision})
 }
 
 // writeSettingsMerge 统一处理设置写入结果：触碰系统受管项返回 400 并列出路径，
@@ -1838,6 +1779,11 @@ func (s *Server) writeSettingsMerge(w http.ResponseWriter, merge func() error) {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
+	var invalid *settings.ErrInvalidSetting
+	if errors.As(err, &invalid) {
+		http.Error(w, err.Error(), 400)
+		return
+	}
 	writeStoreErr(w, err)
 }
 
@@ -1847,7 +1793,7 @@ func (s *Server) writeSettingsMerge(w http.ResponseWriter, merge func() error) {
 // （Auth 未启用）本机即管理员——该档全部 API 本就无认证，锁系统层只会破坏
 // 嵌入式部署的配置播种，不增加安全边界。
 func (s *Server) requireSystemAdmin(w http.ResponseWriter, r *http.Request) (string, bool) {
-	if s.Auth == nil || !s.Auth.Enabled {
+	if s.Auth == nil {
 		return s.owner(r), true
 	}
 	return s.requireAdmin(w, r)
@@ -1857,30 +1803,49 @@ func (s *Server) getSettingsSystem(w http.ResponseWriter, r *http.Request) {
 	if _, ok := s.requireSystemAdmin(w, r); !ok {
 		return
 	}
-	schema := append(settings.Schema(), s.plugins.SettingsSchema()...)
-	sys, err := s.set.SystemScope()
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	schema := s.set.SchemaFor(core.SettingScopeSystem)
+	sys, revision, err := s.set.SystemSnapshot()
 	if err != nil {
 		writeStoreErr(w, err)
 		return
 	}
 	writeJSON(w, http.StatusOK, map[string]any{
-		"schema":   schema,
-		"defaults": settings.Masked(settings.SystemDefaults(), schema),
-		"system":   settings.Masked(sys, schema),
+		"schema":         schema,
+		"defaults":       settings.Masked(s.set.DefaultsFor(core.SettingScopeSystem), schema),
+		"system":         settings.Masked(s.set.ProjectValues(sys, core.SettingScopeSystem), schema),
+		"systemRevision": revision,
 	})
 }
 
 func (s *Server) putSettingsSystem(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireSystemAdmin(w, r)
-	if !ok {
+	if _, ok := s.requireSystemAdmin(w, r); !ok {
 		return
 	}
-	var values map[string]any
-	if err := json.NewDecoder(r.Body).Decode(&values); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
+	var req struct {
+		Values           map[string]any `json:"values"`
+		ExpectedRevision *int64         `json:"expectedRevision"`
+		Unset            []string       `json:"unset,omitempty"`
+	}
+	if err := decodeStrictSettingsRequest(r, &req); err != nil || req.Values == nil || req.ExpectedRevision == nil || *req.ExpectedRevision < 0 {
+		http.Error(w, "需要 values 和 expectedRevision；旧系统写入格式请先读取 systemRevision 再按新格式保存", 400)
 		return
 	}
-	writeOKOr(w, s.set.MergeSystemAccountChecked(actor, values, s.Auth == nil || !s.Auth.Enabled))
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	if err := s.set.ValidateWrite(req.Values, core.SettingScopeSystem); err != nil {
+		http.Error(w, err.Error(), 400)
+		return
+	}
+	revision, err := s.set.MergeSystemAtRevision(req.Values, *req.ExpectedRevision, req.Unset)
+	if errors.Is(err, settings.ErrSettingsConflict) {
+		http.Error(w, err.Error(), 409)
+		return
+	}
+	if err != nil {
+		s.writeSettingsMerge(w, func() error { return err })
+		return
+	}
+	writeJSON(w, 200, map[string]any{"ok": true, "systemRevision": revision})
 }
 
 // ---- 工具（用户声明式 HTTP 工具注册）----
@@ -1915,11 +1880,25 @@ func (s *Server) createUserTool(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "v1 用户工具需为声明式 HTTP 工具（提供 http 段）", http.StatusBadRequest)
 		return
 	}
-	lookup := func(key string) string { return s.set.Effective(s.owner(r), "").GetString(key, "") }
-	if err := s.checkActorBeforeExternalEffect(s.owner(r)); err != nil {
-		writeStoreErr(w, err)
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	if !s.set.PersonalCredentialReferenceAllowed(desc.HTTP.AuthRef) {
+		http.Error(w, "个人 HTTP 工具只能引用个人凭据，不能导出系统模型、搜索或环境密钥", 400)
 		return
 	}
+	owner := s.owner(r)
+	lookup := func(key string) string {
+		if !s.set.PersonalCredentialReferenceAllowed(key) {
+			return ""
+		}
+		if value, ok := s.st.ActiveSecret(owner, key); ok {
+			return value
+		}
+		personal, err := s.set.UserScope(owner)
+		if err != nil {
+			return ""
+		}
+		return core.EffectiveSettings(personal).GetString(key, "")
+	}
 	if err := s.reg.Register(desc, tools.HTTPExecutor(*desc.HTTP, lookup)); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
@@ -1933,10 +1912,6 @@ func (s *Server) deleteUserTool(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "仅可删除 user 来源工具", http.StatusForbidden)
 		return
 	}
-	if err := s.checkActorBeforeExternalEffect(s.owner(r)); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
 	s.reg.UnregisterBySource(core.SourceUser, name)
 	writeJSON(w, http.StatusOK, map[string]any{"deleted": name})
 }
@@ -2006,24 +1981,32 @@ func (s *Server) listPlugins(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) reloadPlugins(w http.ResponseWriter, r *http.Request) {
-	actor, ok := s.requireSystemAdmin(w, r)
-	if !ok {
-		return
-	}
-	if err := s.checkActorBeforeExternalEffect(actor); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
-	results, err := s.plugins.LoadDirAccountChecked(actor, s.Auth == nil || !s.Auth.Enabled)
-	if err != nil {
-		writeStoreErr(w, err)
-		return
-	}
+	results := s.plugins.LoadDir()
 	writeJSON(w, http.StatusOK, map[string]any{"reloaded": len(results), "errors": results})
 }
 
 func (s *Server) pluginSettingsSchema(w http.ResponseWriter, r *http.Request) {
-	writeJSON(w, http.StatusOK, s.plugins.SettingsSchema())
+	scope := core.SettingScope(r.URL.Query().Get("scope"))
+	if scope == "" {
+		scope = settings.UserSettingScope
+	}
+	if scope == core.SettingScopeSystem {
+		if _, ok := s.requireSystemAdmin(w, r); !ok {
+			return
+		}
+	}
+	if scope != core.SettingScopeSystem && scope != settings.UserSettingScope && scope != settings.ProjectSettingScope && scope != settings.PersonalProjectScope {
+		http.Error(w, "设置范围无效", 400)
+		return
+	}
+	s.set.SetExtraSchema(s.plugins.SettingsSchema())
+	out := []core.SettingDesc{}
+	for _, d := range s.set.SchemaFor(scope) {
+		if strings.HasPrefix(d.Group, "plugin:") {
+			out = append(out, d)
+		}
+	}
+	writeJSON(w, http.StatusOK, out)
 }
 
 // listAdminZoneSections 管理区声明分区清单（WP3-I3）：展平全部编译插件的
@@ -2146,12 +2129,8 @@ func (s *Server) savePromptModule(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "id/layer/body required", http.StatusBadRequest)
 		return
 	}
-	if err := s.Prompts.SaveAccountChecked(s.owner(r), m, s.Auth == nil || !s.Auth.Enabled); err != nil {
-		if errors.Is(err, store.ErrAccountForbidden) {
-			writeStoreErr(w, err)
-		} else {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-		}
+	if err := s.Prompts.Save(s.owner(r), m); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	writeJSON(w, http.StatusOK, m)
@@ -2162,7 +2141,7 @@ func (s *Server) deletePromptModule(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "prompt library not enabled", http.StatusServiceUnavailable)
 		return
 	}
-	writeJSONOr(w, map[string]any{"deleted": r.PathValue("id")}, s.Prompts.DeleteAccountChecked(s.owner(r), r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled))
+	writeJSONOr(w, map[string]any{"deleted": r.PathValue("id")}, s.Prompts.Delete(s.owner(r), r.PathValue("id")))
 }
 func (s *Server) listParsers(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, ingest.ParsersDescription())
@@ -2186,7 +2165,7 @@ func (s *Server) addKnowledge(w http.ResponseWriter, r *http.Request) {
 			docs[i].Source = "manual"
 		}
 	}
-	writeOKOr(w, s.st.AddKnowledgeForOwnedProjectAccountChecked(owner, r.PathValue("id"), s.Auth == nil || !s.Auth.Enabled, docs...))
+	writeOKOr(w, s.st.AddKnowledge(docs...))
 }
 
 func (s *Server) searchKnowledge(w http.ResponseWriter, r *http.Request) {
@@ -2301,18 +2280,6 @@ func writeOKOr(w http.ResponseWriter, err error) {
 }
 
 func writeStoreErr(w http.ResponseWriter, err error) {
-	if errors.Is(err, store.ErrOwnerProofUnavailable) {
-		http.Error(w, "OWNER_PROOF_UNAVAILABLE", http.StatusConflict)
-		return
-	}
-	if errors.Is(err, store.ErrAccountForbidden) {
-		http.Error(w, err.Error(), http.StatusForbidden)
-		return
-	}
-	if errors.Is(err, store.ErrInvalidAccountProfile) {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
 	if errors.Is(err, store.ErrNotFound) {
 		http.Error(w, err.Error(), http.StatusNotFound)
 		return
@@ -2338,26 +2305,12 @@ func writeStoreErr(w http.ResponseWriter, err error) {
 
 // backup 触发一致性在线备份（嵌入式档：VACUUM INTO；PG 档见运维指南 pg_dump）。
 func (s *Server) backup(w http.ResponseWriter, r *http.Request) {
-	if s.Auth != nil && s.Auth.Enabled {
-		// A database backup includes other owners' business content. IAM U3
-		// does not grant a system administrator that content authority.
-		http.Error(w, "backup requires local owner maintenance", http.StatusForbidden)
-		return
-	}
-	if err := s.checkActorBeforeExternalEffect(s.owner(r)); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
 	dir := filepath.Join(s.st.DataDir(), "backups")
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	dest := filepath.Join(dir, "agent-system-"+time.Now().UTC().Format("20060102T150405Z")+".db")
-	if err := s.checkActorBeforeExternalEffect(s.owner(r)); err != nil {
-		writeStoreErr(w, err)
-		return
-	}
 	if err := s.st.Backup(dest); err != nil {
 		http.Error(w, err.Error(), http.StatusNotImplemented)
 		return

internal/server/settings_completion_test.go

@@ -0,0 +1,387 @@
+package server
+
+import (
+	"agent-system-backend/internal/settings"
+	"agent-system-backend/pkg/extension"
+	core "agent-system-core"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func TestSharedProjectSettingsRealRequestsAndRevocation(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	alice, _ := st.CreateAPIKey("alice", "test")
+	bob, _ := st.CreateAPIKey("bob", "test")
+	mallory, _ := st.CreateAPIKey("mallory", "test")
+	p, _ := st.CreateProject("alice", "Shared business")
+	other, _ := st.CreateProject("alice", "Other")
+	revoked := false
+	s.SetProjectSettingsAuthorizer(func(_ context.Context, actor, id string, write bool) error {
+		if id != p.ID || revoked || actor == "mallory" {
+			return lifecycleStatusError(404)
+		}
+		if write && actor != "alice" {
+			return lifecycleStatusError(403)
+		}
+		return nil
+	})
+	write := func(key, body string) int {
+		return lifecycleRequest(t, s, key, "PUT", "/api/settings/project/"+p.ID, body).Code
+	}
+	if code := write(alice, `{"values":{"deliverables.style":"formal"},"expectedRevision":0}`); code != 200 {
+		t.Fatalf("save=%d", code)
+	}
+	w := lifecycleRequest(t, s, bob, "GET", "/api/settings?project="+p.ID, "")
+	var view map[string]any
+	_ = json.Unmarshal(w.Body.Bytes(), &view)
+	if w.Code != 200 || view["projectRevision"] != float64(1) || view["projectCanConfigure"] != false || !strings.Contains(w.Body.String(), "formal") {
+		t.Fatalf("member shared read=%d %s", w.Code, w.Body.String())
+	}
+	if code := write(bob, `{"values":{"deliverables.style":"minimal"},"expectedRevision":1}`); code != 403 {
+		t.Fatalf("work/member treated as configuration authority=%d", code)
+	}
+	if code := write(alice, `{"values":{"deliverables.style":"minimal"},"expectedRevision":0}`); code != 409 {
+		t.Fatalf("stale save=%d", code)
+	}
+	for _, id := range []string{other.ID, "missing"} {
+		if w := lifecycleRequest(t, s, bob, "GET", "/api/settings?project="+id, ""); w.Code != 404 {
+			t.Fatalf("cross project read=%d", w.Code)
+		}
+	}
+	if w := lifecycleRequest(t, s, mallory, "GET", "/api/settings?project="+p.ID, ""); w.Code != 404 {
+		t.Fatalf("outsider read=%d", w.Code)
+	}
+	if w := lifecycleRequest(t, s, alice, "PUT", "/api/settings/project/"+p.ID+"/personal", `{"crossSession.read":true,"ui.theme":"light","context.userInstructions":"Alice only"}`); w.Code != 200 {
+		t.Fatalf("personal save=%d %s", w.Code, w.Body.String())
+	}
+	w = lifecycleRequest(t, s, bob, "GET", "/api/settings?project="+p.ID, "")
+	if strings.Contains(w.Body.String(), "Alice only") || s.set.Effective("bob", p.ID).GetBool("crossSession.read", false) {
+		t.Fatal("personal state shared with another member")
+	}
+	revoked = true
+	if w := lifecycleRequest(t, s, alice, "GET", "/api/settings?project="+p.ID, ""); w.Code != 404 {
+		t.Fatalf("creator bypassed revocation=%d", w.Code)
+	}
+	if code := write(alice, `{"values":{"deliverables.style":"minimal"},"expectedRevision":1}`); code != 404 {
+		t.Fatalf("revoked write=%d", code)
+	}
+	if got := s.set.Effective("alice", p.ID).GetString("deliverables.style", ""); got != "formal" {
+		t.Fatalf("denied save changed data: %s", got)
+	}
+}
+
+func TestSharedProjectSettingsConcurrentRevision(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	p, _ := st.CreateProject("alice", "Concurrent")
+	var wg sync.WaitGroup
+	codes := make(chan int, 2)
+	for _, style := range []string{"formal", "minimal"} {
+		wg.Add(1)
+		go func(style string) {
+			defer wg.Done()
+			body := fmt.Sprintf(`{"values":{"deliverables.style":%q},"expectedRevision":0}`, style)
+			codes <- lifecycleRequest(t, s, key, "PUT", "/api/settings/project/"+p.ID, body).Code
+		}(style)
+	}
+	wg.Wait()
+	close(codes)
+	counts := map[int]int{}
+	for code := range codes {
+		counts[code]++
+	}
+	if counts[200] != 1 || counts[409] != 1 {
+		t.Fatalf("concurrent save outcomes=%v", counts)
+	}
+}
+
+func TestProjectWorkCapabilityCannotConfigureSettings(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	p, _ := st.CreateProject("alice", "Capability")
+	s.SetProjectLifecycle(extension.ProjectLifecycle{Work: func(context.Context, string, core.ID) (bool, error) { return true, nil }}, nil)
+	if w := lifecycleRequest(t, s, key, "PUT", "/api/settings/project/"+p.ID, `{"values":{"deliverables.style":"formal"},"expectedRevision":0}`); w.Code != 404 {
+		t.Fatalf("missing configure capability allowed write: %d", w.Code)
+	}
+}
+
+func TestMigrationInventoryProtectedAndNonDestructive(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	if w := lifecycleRequest(t, s, key, "GET", "/api/settings/migration?dryRun=true", ""); w.Code != 403 {
+		t.Fatalf("nonadmin inventory=%d", w.Code)
+	}
+	s.Auth = nil
+	_ = st.MergeSettingsScope("alice", "project:p", map[string]any{"deliverables.style": "formal", "models.chat.apiKey": "sensitive-source-fixture"})
+	_ = st.MergeSettingsScope("bob", "project:p", map[string]any{"deliverables.style": "minimal"})
+	_, _ = st.AddSecret("alice", "models.chat", "Old", "sensitive-secret-fixture")
+	w := lifecycleRequest(t, s, "", "GET", "/api/settings/migration?dryRun=true", "")
+	if w.Code != 200 || !strings.Contains(w.Body.String(), `"conflict"`) || strings.Contains(w.Body.String(), "sensitive-") {
+		t.Fatalf("inventory invalid=%d %s", w.Code, w.Body.String())
+	}
+	raw, _ := st.GetSettingsScope("alice", "project:p")
+	encoded, _ := json.Marshal(raw)
+	if !strings.Contains(string(encoded), "sensitive-source-fixture") {
+		t.Fatal("dry run removed recovery value")
+	}
+	if s.set.Effective("bob", "p").GetString("deliverables.style", "") != "modern" {
+		t.Fatal("conflicting legacy values automatically promoted")
+	}
+}
+
+func TestPersonalSecretsRejectSystemManagedServices(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, err := st.CreateAPIKey("alice", "test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, service := range []string{"models.chat", "models.lightweight", "models.embedding", "models.rerank", "tools.tavily"} {
+		body, _ := json.Marshal(map[string]string{"service": service, "value": "fixture-key"})
+		w := lifecycleRequest(t, s, key, "POST", "/api/secrets", string(body))
+		if w.Code != http.StatusBadRequest {
+			t.Fatalf("personal %s accepted: %d %s", service, w.Code, w.Body.String())
+		}
+	}
+	old, err := st.AddSecret("alice", "models.chat", "old", "old-fixture-key")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, action := range []struct{ method, path, body string }{{"POST", "/api/secrets/" + old.ID + "/activate", ""}, {"PATCH", "/api/secrets/" + old.ID, `{"label":"new"}`}, {"DELETE", "/api/secrets/" + old.ID, ""}} {
+		if w := lifecycleRequest(t, s, key, action.method, action.path, action.body); w.Code != 400 {
+			t.Fatalf("old protected key mutable: %s %d", action.method, w.Code)
+		}
+	}
+	if w := lifecycleRequest(t, s, key, "GET", "/api/secrets", ""); w.Code != 200 || strings.Contains(w.Body.String(), old.ID) {
+		t.Fatal("retired protected key displayed as personal configuration")
+	}
+	if w := lifecycleRequest(t, s, key, "POST", "/api/secrets", `{"service":"custom.personal","value":"fixture"}`); w.Code != 200 {
+		t.Fatal("unrelated personal credentials blocked")
+	}
+}
+
+func TestSettingsReadProjectsOnlyRequestedScopes(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	p, _ := st.CreateProject("alice", "Settings project")
+	w := lifecycleRequest(t, s, key, "GET", "/api/settings?project="+p.ID, "")
+	if w.Code != http.StatusOK {
+		t.Fatalf("read: %d %s", w.Code, w.Body.String())
+	}
+	if strings.Contains(w.Body.String(), "models.chat") || strings.Contains(w.Body.String(), "主模型") {
+		t.Fatal("system schema exposed in project settings")
+	}
+}
+
+func TestSettingsRejectUnknownAndMalformedPaths(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	for _, body := range []string{`{"unknown":{"key":true}}`, `{"unknown":"••••••"}`, `{"ui":{"theme":{"nested":"light"}}}`, `{"ui":{}}`, `{"ui..theme":"light"}`, `{"ui":{"theme":"invalid"}}`, `{"ui.theme":"invalid","ui":{"theme":"light"}}`, `null`} {
+		w := lifecycleRequest(t, s, key, "PUT", "/api/settings/user", body)
+		if w.Code != http.StatusBadRequest {
+			t.Fatalf("malformed accepted %s: %d", body, w.Code)
+		}
+	}
+}
+
+func TestProjectSettingsExplicitMigrationSourceAndRetry(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	p, _ := st.CreateProject("alice", "Migration")
+	if err := st.MergeSettingsScope("alice", "project:"+p.ID, map[string]any{"deliverables.style": "formal", "ui.theme": "light", "context.userInstructions": "private-original"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := st.MergeSettingsScope("bob", "project:"+p.ID, map[string]any{"deliverables.style": "minimal"}); err != nil {
+		t.Fatal(err)
+	}
+	preview := func() string {
+		w := lifecycleRequest(t, s, key, "POST", "/api/settings/project/"+p.ID+"/migration/preview", `{"choices":[{"path":"deliverables.style","sourceOwner":"alice"}],"expectedRevision":0}`)
+		if w.Code != 200 {
+			t.Fatalf("preview=%d %s", w.Code, w.Body.String())
+		}
+		if strings.Contains(w.Body.String(), "private-original") || strings.Contains(w.Body.String(), "formal") {
+			t.Fatal("preview disclosed source values")
+		}
+		var response struct {
+			Observation string `json:"observation"`
+		}
+		_ = json.Unmarshal(w.Body.Bytes(), &response)
+		return response.Observation
+	}
+	apply := func(observation string) *httptest.ResponseRecorder {
+		body, _ := json.Marshal(map[string]any{"observation": observation, "expectedRevision": 0})
+		return lifecycleRequest(t, s, key, "POST", "/api/settings/project/"+p.ID+"/migration/apply", string(body))
+	}
+	old := preview()
+	_ = st.MergeSettingsScope("alice", "project:"+p.ID, map[string]any{"deliverables.style": "modern"})
+	if w := apply(old); w.Code != 409 {
+		t.Fatalf("changed source accepted=%d", w.Code)
+	}
+	if got := s.set.Effective("alice", p.ID).GetString("deliverables.style", ""); got != "modern" {
+		t.Fatalf("stale apply changed target=%s", got)
+	}
+	_ = st.MergeSettingsScope("alice", "project:"+p.ID, map[string]any{"deliverables.style": "formal"})
+	observation := preview()
+	if w := apply(observation); w.Code != 200 {
+		t.Fatalf("apply=%d %s", w.Code, w.Body.String())
+	}
+	if w := apply(observation); w.Code != 200 {
+		t.Fatalf("retry=%d %s", w.Code, w.Body.String())
+	}
+	if got := s.set.Effective("bob", p.ID).GetString("deliverables.style", ""); got != "formal" {
+		t.Fatalf("explicit selected source not applied=%s", got)
+	}
+	raw, _ := st.GetSettingsScope("alice", "project:"+p.ID)
+	encoded, _ := json.Marshal(raw)
+	if !strings.Contains(string(encoded), "private-original") || !strings.Contains(string(encoded), "formal") {
+		t.Fatal("migration changed original/private source")
+	}
+}
+
+func TestExplicitSystemMigrationCASAndCredentialRevocation(t *testing.T) {
+	s, st := newTestServer(t)
+	_, err := st.AddSecret(settings.OwnerSystemRow, "models.chat", "old", "old-system-fixture")
+	if err != nil {
+		t.Fatal(err)
+	}
+	code, view := doJSON(t, s.Handler(), "GET", "/api/settings/system", nil)
+	if code != 200 {
+		t.Fatal(code)
+	}
+	revision := int64(view["systemRevision"].(float64))
+	save := func(path, value string, expected int64) *httptest.ResponseRecorder {
+		body, _ := json.Marshal(map[string]any{"values": map[string]any{"models.chat.apiKey": value}, "expectedRevision": expected})
+		return lifecycleRequest(t, s, "", "POST", path, string(body))
+	}
+	if w := save("/api/settings/migration/system", "new-system-fixture", revision); w.Code != 200 {
+		t.Fatalf("explicit provided system values=%d %s", w.Code, w.Body.String())
+	}
+	if got, _ := s.set.LookupSecret("alice", "models.chat"); got != "new-system-fixture" {
+		t.Fatal("old active table credential shadowed explicit new value")
+	}
+	if w := save("/api/settings/migration/system", "wrong-stale-fixture", revision); w.Code != 409 {
+		t.Fatalf("stale system migration=%d", w.Code)
+	}
+	if w := save("/api/settings/migration/system", "", revision+1); w.Code != 200 {
+		t.Fatalf("revoke=%d %s", w.Code, w.Body.String())
+	}
+	if got, _ := s.set.LookupSecret("alice", "models.chat"); got != "" {
+		t.Fatal("revocation fell back to old credential")
+	}
+	if w := lifecycleRequest(t, s, "", "PUT", "/api/settings/system", `{"models.chat.model":"legacy-format"}`); w.Code != 400 {
+		t.Fatal("legacy unversioned write silently accepted")
+	}
+}
+
+func TestMigrationRejectsUntrustedSourcesTokensAndRevokedActor(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	bob, _ := st.CreateAPIKey("bob", "test")
+	p, _ := st.CreateProject("alice", "Trusted")
+	other, _ := st.CreateProject("alice", "Other")
+	_ = st.MergeSettingsScope("alice", "project:"+p.ID, map[string]any{"deliverables.style": "formal"})
+	_ = st.MergeSettingsScope("bob", "project:"+p.ID, map[string]any{"deliverables.style": "minimal"})
+	preview := func(source string) *httptest.ResponseRecorder {
+		body, _ := json.Marshal(map[string]any{"choices": []map[string]string{{"path": "deliverables.style", "sourceOwner": source}}, "expectedRevision": 0})
+		return lifecycleRequest(t, s, key, "POST", "/api/settings/project/"+p.ID+"/migration/preview", string(body))
+	}
+	if w := preview("bob"); w.Code != 404 {
+		t.Fatalf("forged scope granted source authority=%d", w.Code)
+	}
+	w := preview("alice")
+	if w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	var response struct {
+		Observation string `json:"observation"`
+	}
+	_ = json.Unmarshal(w.Body.Bytes(), &response)
+	body, _ := json.Marshal(map[string]any{"observation": response.Observation, "expectedRevision": 0})
+	if w := lifecycleRequest(t, s, key, "POST", "/api/settings/project/"+other.ID+"/migration/apply", string(body)); w.Code != 404 {
+		t.Fatal("token reused for another project")
+	}
+	if w := lifecycleRequest(t, s, bob, "POST", "/api/settings/project/"+p.ID+"/migration/apply", string(body)); w.Code != 404 {
+		t.Fatal("token reused by another actor")
+	}
+	s.SetProjectSettingsAuthorizer(func(context.Context, string, string, bool) error { return lifecycleStatusError(403) })
+	if w := lifecycleRequest(t, s, key, "POST", "/api/settings/project/"+p.ID+"/migration/apply", string(body)); w.Code != 403 {
+		t.Fatal("revoked actor migration applied")
+	}
+}
+
+func TestPersonalHTTPToolsCannotExportSystemCredential(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	for _, ref := range []string{"models.chat.apiKey", "tools.tavily.apiKeys", "env:MODEL_API_KEY"} {
+		body, _ := json.Marshal(map[string]any{"name": "private.export", "http": map[string]any{"method": "GET", "url": "https://user-controlled.invalid", "authRef": ref}})
+		if w := lifecycleRequest(t, s, key, "POST", "/api/tools", string(body)); w.Code != 400 {
+			t.Fatalf("personal tool can refer to protected credential namespace %s: %d", ref, w.Code)
+		}
+	}
+}
+
+func TestPublicProjectAndSystemUnsetEnvelope(t *testing.T) {
+	s, st := newTestServer(t)
+	p, _ := st.CreateProject("local", "Defaults")
+	w := lifecycleRequest(t, s, "", "PUT", "/api/settings/project/"+p.ID, `{"values":{"deliverables.style":"formal"},"expectedRevision":0}`)
+	if w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	w = lifecycleRequest(t, s, "", "PUT", "/api/settings/project/"+p.ID, `{"values":{},"unset":["deliverables.style"],"expectedRevision":1}`)
+	if w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	if s.set.Effective("local", p.ID).GetString("deliverables.style", "") != "modern" {
+		t.Fatal("project unset did not restore inherited default")
+	}
+	if w := lifecycleRequest(t, s, "", "PUT", "/api/settings/project/"+p.ID, `{"values":{"deliverables.style":"formal"},"unset":["deliverables.style"],"expectedRevision":2}`); w.Code != 400 {
+		t.Fatal("overlap request accepted")
+	}
+	revision, _ := s.set.SystemRevision()
+	body, _ := json.Marshal(map[string]any{"values": map[string]any{}, "unset": []string{"runtime.mock"}, "expectedRevision": revision})
+	if w := lifecycleRequest(t, s, "", "PUT", "/api/settings/system", string(body)); w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	if s.set.Effective("local", "").GetBool("runtime.mock", true) {
+		t.Fatal("system unset did not restore default")
+	}
+}
+
+func TestPublicPersonalMergePatchDeletesOnlyKnownNonsecretLeaves(t *testing.T) {
+	s, st := newAuthTestServer(t)
+	key, _ := st.CreateAPIKey("alice", "test")
+	p, _ := st.CreateProject("alice", "Personal reset")
+	if w := lifecycleRequest(t, s, key, "PUT", "/api/settings/user", `{"ui.theme":"light","ui.cardflow":false,"retrieval.topK":12}`); w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	if w := lifecycleRequest(t, s, key, "PUT", "/api/settings/user", `{"ui.theme":null,"ui.cardflow":null,"retrieval.topK":null}`); w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	w := lifecycleRequest(t, s, key, "GET", "/api/settings", "")
+	var view struct {
+		User map[string]any `json:"user"`
+	}
+	_ = json.Unmarshal(w.Body.Bytes(), &view)
+	if w.Code != 200 || view.User["ui"] != nil || view.User["retrieval"] != nil {
+		t.Fatal("deleted preferences still read back as overrides")
+	}
+	if w := lifecycleRequest(t, s, key, "PUT", "/api/settings/project/"+p.ID+"/personal", `{"crossSession.read":true}`); w.Code != 200 {
+		t.Fatal(w.Code)
+	}
+	if w := lifecycleRequest(t, s, key, "PUT", "/api/settings/project/"+p.ID+"/personal", `{"crossSession.read":null}`); w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	if s.set.Effective("alice", p.ID).GetBool("crossSession.read", true) {
+		t.Fatal("personal project reset stayed active")
+	}
+	for _, body := range []string{`{"ui":null}`, `{"unknown":null}`, `{"models.chat.apiKey":null}`, `{"deliverables.style":null}`, `{"_policy.managedModels":null}`} {
+		if w := lifecycleRequest(t, s, key, "PUT", "/api/settings/user", body); w.Code != 400 {
+			t.Fatal("invalid personal reset accepted")
+		}
+	}
+}

internal/server/shared_projects_test.go

@@ -16,11 +16,11 @@ import (
 func TestSharedProjectListAndConversation(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	alice, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	alice, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	bob, err := createLegacyAPIKeyFixture(t, st, "bob", "e2e")
+	bob, err := st.CreateAPIKey("bob", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/shared_retrieval_test.go

@@ -19,11 +19,11 @@ import (
 func TestSharedKnowledgeRetrieval(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	alice, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	alice, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	bob, err := createLegacyAPIKeyFixture(t, st, "bob", "e2e")
+	bob, err := st.CreateAPIKey("bob", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -94,11 +94,11 @@ func TestProjectSSEScopeGate(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	_ = st
 	h := srv.Handler()
-	alice, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	alice, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	bob, err := createLegacyAPIKeyFixture(t, st, "bob", "e2e")
+	bob, err := st.CreateAPIKey("bob", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -147,11 +147,11 @@ func TestProjectSSEScopeGate(t *testing.T) {
 func TestSharedCitationRefDownloadable(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	alice, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	alice, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
-	bob, err := createLegacyAPIKeyFixture(t, st, "bob", "e2e")
+	bob, err := st.CreateAPIKey("bob", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/server/surface_api_test.go

@@ -18,7 +18,7 @@ import (
 func TestSurfaceDirectAPIGuards(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	key, err := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	key, err := st.CreateAPIKey("alice", "e2e")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -94,7 +94,7 @@ func TestSurfaceDirectAPIGuards(t *testing.T) {
 func TestSurfaceActionEndpoint(t *testing.T) {
 	srv, st := newAuthTestServer(t)
 	h := srv.Handler()
-	key, _ := createLegacyAPIKeyFixture(t, st, "alice", "e2e")
+	key, _ := st.CreateAPIKey("alice", "e2e")
 	svc := surfacesvc.New(st, nil)
 	svc.SetDispatcher(func(ctx context.Context, d surfacesvc.ActionDispatch) (surfacesvc.ActionOutcome, error) {
 		return surfacesvc.ActionOutcome{State: "committed", Receipt: map[string]any{"ok": true}}, nil

internal/settings/migration.go

@@ -0,0 +1,111 @@
+package settings
+
+import (
+	core "agent-system-core"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+// MigrationEntry deliberately includes no values, masks, or value digests. Raw
+// recovery data stays in the existing protected DB rows/snapshots.
+type MigrationEntry struct {
+	Owner          string `json:"owner"`
+	Scope          string `json:"scope"`
+	Path           string `json:"path"`
+	Status         string `json:"status"`
+	Reason         string `json:"reason"`
+	LastSnapshotAt string `json:"lastSnapshotAt,omitempty"`
+}
+
+type MigrationInventory struct {
+	DryRun  bool             `json:"dryRun"`
+	Entries []MigrationEntry `json:"entries"`
+}
+
+// MigrationInventory is read-only. Settings rows have no trustworthy per-key
+// modification timestamps, so snapshot time is only a recovery reference. It
+// never guesses the newest owner or promotes a personal credential/configuration.
+func (s *Service) MigrationInventory() (MigrationInventory, error) {
+	out := MigrationInventory{DryRun: true, Entries: []MigrationEntry{}}
+	refs, err := s.st.ListSettingsScopes()
+	if err != nil {
+		return out, err
+	}
+	type candidate struct {
+		index int
+		value any
+	}
+	groups := map[string][]candidate{}
+	for _, ref := range refs {
+		if ref.Owner == OwnerSystemRow || (ref.Scope != ScopeUser && !strings.HasPrefix(ref.Scope, ScopeProjectPrefix)) {
+			continue
+		}
+		values, err := s.st.GetSettingsScope(ref.Owner, ref.Scope)
+		if err != nil {
+			return out, err
+		}
+		values = normalizeKeys(values)
+		stamp := ""
+		if at, ok := s.st.LatestSnapshotAt(ref.Owner, ref.Scope); ok {
+			stamp = at.UTC().Format("2006-01-02T15:04:05.999999999Z07:00")
+		}
+		for _, d := range s.Descriptors() {
+			value, present := valueAtPath(values, d.Key)
+			if !present {
+				continue
+			}
+			entry := MigrationEntry{Owner: ref.Owner, Scope: ref.Scope, Path: d.Key, LastSnapshotAt: stamp}
+			if d.Scope == core.SettingScopeSystem {
+				entry.Status = "quarantined"
+				entry.Reason = "系统受管旧覆盖已退出生效链，原值保留；禁止自动提升为系统配置"
+			} else if d.Scope == ProjectSettingScope && strings.HasPrefix(ref.Scope, ScopeProjectPrefix) {
+				entry.Status = "requires-decision"
+				entry.Reason = "旧项目业务副本保留；按键选择权威来源后才能迁移，快照时间不等于修改时间"
+				group := ref.Scope + ":" + d.Key
+				groups[group] = append(groups[group], candidate{len(out.Entries), value})
+			} else {
+				continue
+			}
+			out.Entries = append(out.Entries, entry)
+		}
+		known := map[string]bool{}
+		for _, d := range s.Descriptors() {
+			known[d.Key] = true
+		}
+		for _, path := range core.TouchesManagedSettings(values, s.ManagedSettingPaths()) {
+			if !known[path] {
+				out.Entries = append(out.Entries, MigrationEntry{Owner: ref.Owner, Scope: ref.Scope, Path: path, Status: "quarantined", Reason: "系统受管命名空间的旧未知项已退出生效链，原值保留", LastSnapshotAt: stamp})
+			}
+		}
+	}
+	for _, group := range groups {
+		if len(group) < 2 {
+			continue
+		}
+		for _, item := range group[1:] {
+			if !reflect.DeepEqual(group[0].value, item.value) {
+				for _, candidate := range group {
+					out.Entries[candidate.index].Status = "conflict"
+					out.Entries[candidate.index].Reason = "同项目同键的多 owner 副本值不同；必须由项目负责人逐键裁定，禁止自动合并"
+				}
+				break
+			}
+		}
+	}
+	secrets, err := s.st.SecretInventory()
+	if err != nil {
+		return out, err
+	}
+	for _, entry := range secrets {
+		if entry.Owner != "" && ProtectedSecretService(entry.Service) {
+			out.Entries = append(out.Entries, MigrationEntry{Owner: entry.Owner, Scope: "secret_keys", Path: entry.Service, Status: "quarantined", Reason: fmt.Sprintf("%d 条个人密钥已退出生效链，原记录保留；系统凭据须单独配置", entry.Count)})
+		}
+	}
+	sort.Slice(out.Entries, func(i, j int) bool {
+		a, b := out.Entries[i], out.Entries[j]
+		return a.Scope+"\x00"+a.Path+"\x00"+a.Owner < b.Scope+"\x00"+b.Path+"\x00"+b.Owner
+	})
+	return out, nil
+}

internal/settings/migration_apply.go

@@ -0,0 +1,226 @@
+package settings
+
+import (
+	"encoding/json"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+
+	"agent-system-backend/internal/store"
+	core "agent-system-core"
+)
+
+const observationPrefix = "migration-observation:"
+
+type MigrationChoice struct {
+	Path        string `json:"path"`
+	SourceOwner string `json:"sourceOwner"`
+}
+type MigrationPreview struct {
+	Observation     string   `json:"observation"`
+	ProjectRevision int64    `json:"projectRevision"`
+	Conflicts       []string `json:"conflicts"`
+}
+type MigrationApplyResult struct {
+	ProjectRevision int64 `json:"projectRevision"`
+	Replayed        bool  `json:"replayed"`
+}
+
+func (s *Service) migrationChoices(choices []MigrationChoice) error {
+	if len(choices) == 0 || len(choices) > 100 {
+		return &ErrInvalidSetting{Path: "choices", Reason: "请选择 1 到 100 个明确来源"}
+	}
+	descriptors := map[string]core.SettingDesc{}
+	for _, d := range s.SchemaFor(ProjectSettingScope) {
+		descriptors[d.Key] = d
+	}
+	seen := map[string]bool{}
+	for _, choice := range choices {
+		d, ok := descriptors[choice.Path]
+		leaf := choice.Path[strings.LastIndex(choice.Path, ".")+1:]
+		if !ok || choice.SourceOwner == "" || seen[choice.Path] {
+			return &ErrInvalidSetting{Path: choice.Path, Reason: "未知、重复或缺少来源的项目业务项"}
+		}
+		if d.Secret || d.Type == core.SettingSecret || isSecretKey(leaf) {
+			return &ErrInvalidSetting{Path: choice.Path, Reason: "不迁移个人密钥；请明确配置新的共享凭据"}
+		}
+		seen[choice.Path] = true
+	}
+	return nil
+}
+
+// migrationSources projects business values only; an observation never copies
+// another actor's personal preferences or credentials into its recovery record.
+func (s *Service) migrationSources(rows map[store.SettingsScopeRef]map[string]any, projectID string) map[string]any {
+	sources := map[string]any{}
+	for ref, row := range rows {
+		if ref.Owner != "" && ref.Scope == ScopeProjectPrefix+projectID {
+			values := s.ProjectValues(row, ProjectSettingScope)
+			for _, d := range s.SchemaFor(ProjectSettingScope) {
+				if d.Secret || d.Type == core.SettingSecret || isSecretKey(d.Key[strings.LastIndex(d.Key, ".")+1:]) {
+					deletePath(values, d.Key)
+				}
+			}
+			sources[ref.Owner] = values
+		}
+	}
+	return sources
+}
+
+func (s *Service) chosenMigrationValues(sources map[string]any, choices []MigrationChoice) (map[string]any, error) {
+	values := map[string]any{}
+	for _, choice := range choices {
+		row, _ := sources[choice.SourceOwner].(map[string]any)
+		value, ok := valueAtPath(row, choice.Path)
+		if !ok {
+			return nil, &ErrInvalidSetting{Path: choice.Path, Reason: "观察的来源中缺少有效值"}
+		}
+		values = core.MergeSettings(values, expandDotted(choice.Path, value))
+	}
+	return values, s.ValidateWrite(values, ProjectSettingScope)
+}
+
+func migrationConflicts(sources map[string]any, choices []MigrationChoice) []string {
+	out := []string{}
+	for _, choice := range choices {
+		var first any
+		seen := false
+		for _, row := range sources {
+			values, _ := row.(map[string]any)
+			value, ok := valueAtPath(values, choice.Path)
+			if !ok {
+				continue
+			}
+			if !seen {
+				first = value
+				seen = true
+			} else if !reflect.DeepEqual(first, value) {
+				out = append(out, choice.Path)
+				break
+			}
+		}
+	}
+	sort.Strings(out)
+	return out
+}
+
+func (s *Service) PreviewProjectMigration(actor, projectID string, choices []MigrationChoice, expectedRevision int64) (MigrationPreview, error) {
+	result := MigrationPreview{Conflicts: []string{}}
+	if actor == "" || projectID == "" {
+		return result, &ErrInvalidSetting{Path: "project", Reason: "需要受信项目和身份"}
+	}
+	if err := s.migrationChoices(choices); err != nil {
+		return result, err
+	}
+	target := store.SettingsScopeRef{Owner: OwnerSystemRow, Scope: ScopeSharedProjectPrefix + projectID}
+	observation := store.SettingsScopeRef{Owner: OwnerSystemRow, Scope: observationPrefix + store.NewID("obs")}
+	err := s.st.UpdateSettingsScopes([]store.SettingsScopeRef{target, observation}, ScopeProjectPrefix+projectID, func(rows map[store.SettingsScopeRef]map[string]any) (map[store.SettingsScopeRef]map[string]any, error) {
+		revision := sharedRevision(rows[target])
+		if revision != expectedRevision {
+			return nil, ErrSettingsConflict
+		}
+		sources := s.migrationSources(rows, projectID)
+		if _, err := s.chosenMigrationValues(sources, choices); err != nil {
+			return nil, err
+		}
+		result.Observation = strings.TrimPrefix(observation.Scope, observationPrefix)
+		result.ProjectRevision = revision
+		result.Conflicts = migrationConflicts(sources, choices)
+		return map[store.SettingsScopeRef]map[string]any{observation: {"actor": actor, "projectId": projectID, "expectedRevision": revision, "choices": choices, "sources": sources, "createdAt": time.Now().UTC().Format(time.RFC3339Nano)}}, nil
+	})
+	return result, err
+}
+
+func (s *Service) MigrationSelection(actor, projectID, token string, expectedRevision int64) (map[string]any, []MigrationChoice, error) {
+	if !validObservationToken(token) {
+		return nil, nil, store.ErrNotFound
+	}
+	row, err := s.st.GetSettingsScope(OwnerSystemRow, observationPrefix+token)
+	if err != nil {
+		return nil, nil, err
+	}
+	if row["actor"] != actor || row["projectId"] != projectID {
+		return nil, nil, store.ErrNotFound
+	}
+	number, _ := row["expectedRevision"].(float64)
+	if int64(number) != expectedRevision {
+		return nil, nil, ErrSettingsConflict
+	}
+	var choices []MigrationChoice
+	encoded, _ := json.Marshal(row["choices"])
+	if err := json.Unmarshal(encoded, &choices); err != nil {
+		return nil, nil, err
+	}
+	if err := s.migrationChoices(choices); err != nil {
+		return nil, nil, err
+	}
+	sources, _ := row["sources"].(map[string]any)
+	values, err := s.chosenMigrationValues(sources, choices)
+	return values, choices, err
+}
+
+func validObservationToken(token string) bool {
+	return strings.HasPrefix(token, "obs_") && len(token) <= 100 && !strings.ContainsAny(token, "/\\\x00")
+}
+
+func (s *Service) ApplyProjectMigration(actor, projectID, token string, expectedRevision int64, prevalidated map[string]any) (MigrationApplyResult, error) {
+	result := MigrationApplyResult{}
+	if actor == "" || projectID == "" || !validObservationToken(token) {
+		return result, store.ErrNotFound
+	}
+	target := store.SettingsScopeRef{Owner: OwnerSystemRow, Scope: ScopeSharedProjectPrefix + projectID}
+	observation := store.SettingsScopeRef{Owner: OwnerSystemRow, Scope: observationPrefix + token}
+	err := s.st.UpdateSettingsScopes([]store.SettingsScopeRef{target, observation}, ScopeProjectPrefix+projectID, func(rows map[store.SettingsScopeRef]map[string]any) (map[store.SettingsScopeRef]map[string]any, error) {
+		observed := rows[observation]
+		if observed["actor"] != actor || observed["projectId"] != projectID {
+			return nil, store.ErrNotFound
+		}
+		observedRevision := int64(0)
+		if number, ok := observed["expectedRevision"].(float64); ok {
+			observedRevision = int64(number)
+		}
+		if observedRevision != expectedRevision {
+			return nil, ErrSettingsConflict
+		}
+		if number, applied := observed["appliedRevision"].(float64); applied {
+			result.ProjectRevision = int64(number)
+			result.Replayed = true
+			return nil, nil
+		}
+		if sharedRevision(rows[target]) != expectedRevision {
+			return nil, ErrSettingsConflict
+		}
+		previous, _ := observed["sources"].(map[string]any)
+		current := s.migrationSources(rows, projectID)
+		if !reflect.DeepEqual(previous, current) {
+			return nil, ErrSettingsConflict
+		}
+		var choices []MigrationChoice
+		encoded, _ := json.Marshal(observed["choices"])
+		if err := json.Unmarshal(encoded, &choices); err != nil {
+			return nil, err
+		}
+		if err := s.migrationChoices(choices); err != nil {
+			return nil, err
+		}
+		selected, err := s.chosenMigrationValues(current, choices)
+		if err != nil {
+			return nil, err
+		}
+		if prevalidated == nil || !reflect.DeepEqual(selected, prevalidated) {
+			return nil, ErrSettingsConflict
+		}
+		row := rows[target]
+		existing, _ := row["values"].(map[string]any)
+		next := core.MergeSettings(s.ProjectValues(existing, ProjectSettingScope), selected)
+		revision := sharedRevision(row)
+		if !reflect.DeepEqual(existing, next) {
+			revision++
+		}
+		result.ProjectRevision = revision
+		completed := core.MergeSettings(observed, map[string]any{"appliedRevision": revision, "appliedAt": time.Now().UTC().Format(time.RFC3339Nano)})
+		return map[store.SettingsScopeRef]map[string]any{target: {"revision": revision, "values": next, "updatedAt": time.Now().UTC().Format(time.RFC3339Nano)}, observation: completed}, nil
+	})
+	return result, err
+}

internal/settings/migration_apply_test.go

@@ -0,0 +1,93 @@
+package settings
+
+import (
+	"path/filepath"
+	"testing"
+
+	"agent-system-backend/internal/store"
+)
+
+func TestMigrationApplyRollbackAndIdempotentRetry(t *testing.T) {
+	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "migration.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	s := NewService(st)
+	if err := st.MergeSettingsScope("alice", ScopeProjectPrefix+"p1", map[string]any{"deliverables.style": "formal", "ui.theme": "light"}); err != nil {
+		t.Fatal(err)
+	}
+	preview, err := s.PreviewProjectMigration("alice", "p1", []MigrationChoice{{Path: "deliverables.style", SourceOwner: "alice"}}, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected, _, err := s.MigrationSelection("alice", "p1", preview.Observation, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Observation is sorted before target, so failure of this later write must
+	// roll back the previously attempted observation completion as well.
+	if _, err := st.DB().Exec(`CREATE TRIGGER reject_migration BEFORE INSERT ON settings WHEN NEW.scope='shared-project:p1' BEGIN SELECT RAISE(ABORT,'fixture migration target failure'); END`); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.ApplyProjectMigration("alice", "p1", preview.Observation, 0, selected); err == nil {
+		t.Fatal("injected target failure succeeded")
+	}
+	row, _ := st.GetSettingsScope(OwnerSystemRow, observationPrefix+preview.Observation)
+	if _, exists := row["appliedRevision"]; exists {
+		t.Fatal("failed migration left completed observation")
+	}
+	_, revision, err := s.SharedProjectScope("p1")
+	if err != nil || revision != 0 {
+		t.Fatal("failed migration changed target")
+	}
+	if _, err := st.DB().Exec(`DROP TRIGGER reject_migration`); err != nil {
+		t.Fatal(err)
+	}
+	result, err := s.ApplyProjectMigration("alice", "p1", preview.Observation, 0, selected)
+	if err != nil || result.ProjectRevision != 1 || result.Replayed {
+		t.Fatalf("retry=%+v %v", result, err)
+	}
+	result, err = s.ApplyProjectMigration("alice", "p1", preview.Observation, 0, selected)
+	if err != nil || result.ProjectRevision != 1 || !result.Replayed {
+		t.Fatalf("idempotent replay=%+v %v", result, err)
+	}
+	original, _ := st.GetSettingsScope("alice", ScopeProjectPrefix+"p1")
+	if original["ui.theme"] != "light" || original["deliverables.style"] != "formal" {
+		t.Fatal("migration rewrote source/personal rows")
+	}
+}
+
+func TestMigrationRejectsChangedSourceSetTargetAndPrivateCredentials(t *testing.T) {
+	st, err := store.OpenSQLite(filepath.Join(t.TempDir(), "migration.db"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.Close() })
+	s := NewService(st)
+	_ = st.MergeSettingsScope("alice", ScopeProjectPrefix+"p1", map[string]any{"deliverables.style": "formal"})
+	choices := []MigrationChoice{{Path: "deliverables.style", SourceOwner: "alice"}}
+	preview, err := s.PreviewProjectMigration("alice", "p1", choices, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected, _, _ := s.MigrationSelection("alice", "p1", preview.Observation, 0)
+	_ = st.MergeSettingsScope("new-owner", ScopeProjectPrefix+"p1", map[string]any{"deliverables.style": "minimal"})
+	if _, err := s.ApplyProjectMigration("alice", "p1", preview.Observation, 0, selected); err != ErrSettingsConflict {
+		t.Fatalf("changed conflict/source set=%v", err)
+	}
+	preview, err = s.PreviewProjectMigration("alice", "p1", choices, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected, _, _ = s.MigrationSelection("alice", "p1", preview.Observation, 0)
+	if _, err := s.MergeSharedProject("p1", map[string]any{"deliverables.style": "modern"}, 0); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.ApplyProjectMigration("alice", "p1", preview.Observation, 0, selected); err != ErrSettingsConflict {
+		t.Fatalf("changed target=%v", err)
+	}
+	if _, err := s.PreviewProjectMigration("alice", "p1", []MigrationChoice{{Path: "models.chat.apiKey", SourceOwner: "other"}}, 1); err == nil {
+		t.Fatal("private credential source accepted")
+	}
+}