@shgroup/dsh-serenity-hooks 1.21.0 → 1.23.0

package/lib/index.js

@@ -7,7 +7,7 @@ import { homedir, platform } from "node:os";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { randomBytes, randomUUID, scryptSync, timingSafeEqual } from "node:crypto";
+import { createHmac, randomBytes, randomUUID, scryptSync, timingSafeEqual } from "node:crypto";
 import { createServer, request } from "node:http";
 //#region src/ccc.ts
 /**
@@ -213,10 +213,10 @@ function runCcFs(root, args) {
 	switch (a) {
 		case "root": return root;
 		case "resolve":
-			if (!args.path) throw new Error("resolve 需要 path");
+			if (!args.path) throw new Error("resolve requires path");
 			return resolveInside(root, args.path);
 		case "exists": {
-			if (!args.path) throw new Error("exists 需要 path");
+			if (!args.path) throw new Error("exists requires path");
 			const absPath = args.path.startsWith("/") ? resolve(args.path) : resolveInside(root, args.path);
 			return existsSync(absPath) ? "true" : "false";
 		}
@@ -271,13 +271,13 @@ function runCcFs(root, args) {
 			};
 		}
 		case "relative": {
-			if (!args.path) throw new Error("relative 需要 path");
+			if (!args.path) throw new Error("relative requires path");
 			const absPath = args.path.startsWith("/") ? resolve(args.path) : resolveInside(root, args.path);
 			if (!absPath.startsWith(root)) throw new Error(`relative: path "${args.path}" resolves to "${absPath}" which is outside serenity root "${root}"`);
 			return safeRel(root, absPath);
 		}
 		case "mkdir": {
-			if (!args.path) throw new Error("mkdir 需要 path");
+			if (!args.path) throw new Error("mkdir requires path");
 			const absPath = validateWritePath(root, args.path);
 			if (existsSync(absPath)) {
 				if (statSync(absPath).isDirectory()) return `directory already exists: ${args.path}`;
@@ -289,7 +289,7 @@ function runCcFs(root, args) {
 		case "rm": {
 			const targets = [...args.paths ?? []];
 			if (args.path) targets.push(args.path);
-			if (targets.length === 0) throw new Error("rm 需要至少一个 path 参数（path 或 paths）");
+			if (targets.length === 0) throw new Error("rm requires at least one path argument (path or paths)");
 			const dryRun = args.dryRun ?? false;
 			const recursive = args.recursive ?? false;
 			const results = [];
@@ -334,7 +334,7 @@ function runCcFs(root, args) {
 			return results.join("\n");
 		}
 		case "mv": {
-			if (!args.src || !args.dst) throw new Error("mv 需要 src + dst");
+			if (!args.src || !args.dst) throw new Error("mv requires src + dst");
 			const srcAbs = validateWritePath(root, args.src);
 			const dstAbs = validateWritePath(root, args.dst);
 			if (!existsSync(srcAbs)) throw new Error(`mv: source not found: ${args.src}`);
@@ -345,7 +345,7 @@ function runCcFs(root, args) {
 			return `moved: ${args.src} → ${args.dst}`;
 		}
 		case "cp": {
-			if (!args.src || !args.dst) throw new Error("cp 需要 src + dst");
+			if (!args.src || !args.dst) throw new Error("cp requires src + dst");
 			const srcAbs = validateWritePath(root, args.src);
 			const dstAbs = validateWritePath(root, args.dst);
 			if (!existsSync(srcAbs)) throw new Error(`cp: source not found: ${args.src}`);
@@ -357,7 +357,7 @@ function runCcFs(root, args) {
 			return `copied: ${args.src} → ${args.dst}`;
 		}
 		case "touch": {
-			if (!args.path) throw new Error("touch 需要 path");
+			if (!args.path) throw new Error("touch requires path");
 			const absPath = validateWritePath(root, args.path);
 			if (existsSync(absPath)) {
 				const now = /* @__PURE__ */ new Date();
@@ -370,7 +370,7 @@ function runCcFs(root, args) {
 			return `created empty file: ${args.path}`;
 		}
 		case "append": {
-			if (!args.path || args.content === void 0) throw new Error("append 需要 path + content");
+			if (!args.path || args.content === void 0) throw new Error("append requires path + content");
 			const absPath = validateWritePath(root, args.path);
 			const parentDir = dirname(absPath);
 			if (!existsSync(parentDir)) mkdirSync(parentDir, { recursive: true });
@@ -379,7 +379,7 @@ function runCcFs(root, args) {
 			return `appended ${Buffer.byteLength(content, "utf8")} bytes to ${args.path}`;
 		}
 		case "reveal": {
-			if (!args.path) throw new Error("reveal 需要 path");
+			if (!args.path) throw new Error("reveal requires path");
 			const absPath = resolveInside(root, args.path);
 			if (!existsSync(absPath)) throw new Error(`no such path: ${absPath}`);
 			const os = platform();
@@ -405,7 +405,7 @@ function runCcFs(root, args) {
 			}
 		}
 		case "info": {
-			if (!args.path) throw new Error("info 需要 path");
+			if (!args.path) throw new Error("info requires path");
 			const absPath = args.path.startsWith("/") ? resolve(args.path) : resolveInside(root, args.path);
 			if (!existsSync(absPath)) throw new Error(`info: path "${absPath}" does not exist`);
 			const stat = statSync(absPath);
@@ -422,7 +422,7 @@ function runCcFs(root, args) {
 			].join("\n");
 		}
 		case "find": {
-			if (!args.pattern) throw new Error("find 需要 pattern");
+			if (!args.pattern) throw new Error("find requires pattern");
 			const relPath = args.path || ".";
 			const absPath = relPath.startsWith("/") ? resolve(relPath) : resolveInside(root, relPath);
 			if (!existsSync(absPath)) throw new Error(`find: path "${absPath}" does not exist`);
@@ -471,7 +471,7 @@ function runCcFs(root, args) {
 				count: matches.length
 			};
 		}
-		default: throw new Error(`未知 action: ${a}`);
+		default: throw new Error(`Unknown action: ${a}`);
 	}
 }
 //#endregion
@@ -493,66 +493,66 @@ function renderText$10(value) {
 }
 const ccFsTool = defineTool({
 	name: "cc_fs",
-	description: "CCC 内文件系统操作（cc-fs 语义，DSH 原生版）。15 子命令：root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find。全部路径限定在 CCC 根内，路径逃逸自动阻断。reveal 在 OS 文件管理器中打开路径（Linux xdg-open / macOS Finder / Windows Explorer）。与 read/write/edit 互补（结构性操作）。",
+	description: "CCC filesystem operations (cc-fs semantics, DSH-native). 15 subcommands: root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find. All paths confined to the CCC root; path escape is blocked automatically. reveal opens a path in the OS file manager (Linux xdg-open / macOS Finder / Windows Explorer). Complements read/write/edit (structural operations).",
 	parameters: {
 		action: {
 			type: "string",
 			enum: [...CC_FS_ACTIONS],
 			required: true,
-			description: "子命令"
+			description: "Subcommand"
 		},
 		path: {
 			type: "string",
-			description: "主路径参数（resolve/exists/list/tree/relative/touch/append/info/rm 单路径）"
+			description: "Primary path argument (single-path ops: resolve/exists/list/tree/relative/touch/append/info/rm)"
 		},
 		paths: {
 			type: "array",
 			items: { type: "string" },
-			description: "批量路径（mkdir/rm）"
+			description: "Batch paths (mkdir/rm)"
 		},
 		src: {
 			type: "string",
-			description: "mv/cp 源路径"
+			description: "mv/cp source path"
 		},
 		dst: {
 			type: "string",
-			description: "mv/cp 目标路径"
+			description: "mv/cp destination path"
 		},
 		content: {
 			type: "string",
-			description: "append 内容"
+			description: "append content"
 		},
 		pattern: {
 			type: "string",
-			description: "find 匹配（glob *? 或大小写不敏感子串）"
+			description: "find match (glob *? or case-insensitive substring)"
 		},
 		depth: {
 			type: "integer",
-			description: "tree 最大深度（1-10，默认 3）"
+			description: "tree max depth (1-10, default 3)"
 		},
 		dryRun: {
 			type: "boolean",
-			description: "rm/archive 预览模式"
+			description: "rm/archive preview mode"
 		},
 		recursive: {
 			type: "boolean",
-			description: "rm 删目录 / cp 复制目录需 recursive"
+			description: "rm directory / cp directory requires recursive"
 		},
 		filesOnly: {
 			type: "boolean",
-			description: "tree 只显示文件（与 dirsOnly 互斥）"
+			description: "tree shows files only (mutually exclusive with dirsOnly)"
 		},
 		dirsOnly: {
 			type: "boolean",
-			description: "tree 只显示目录（与 filesOnly 互斥）"
+			description: "tree shows directories only (mutually exclusive with filesOnly)"
 		},
 		absolute: {
 			type: "boolean",
-			description: "find 返回绝对路径"
+			description: "find returns absolute paths"
 		},
 		maxDepth: {
 			type: "integer",
-			description: "find 最大递归深度（缺省不限）"
+			description: "find max recursion depth (default unlimited)"
 		}
 	},
 	output: {
@@ -625,24 +625,24 @@ function isWriteTool(toolName, action) {
 function decideGuard(input) {
 	const { root, toolName, safeModeOn, blacklist, pathArg, action } = input;
 	if (safeModeOn && toolName === "bash") return {
-		deny: `bash: 没有这个工具`,
+		deny: `bash: no such tool`,
 		kind: "deny"
 	};
 	if (pathArg !== void 0) {
 		const abs = resolve(root, pathArg);
 		if (!pathInside(resolve(root), abs)) return {
-			deny: `path escape blocked: "${pathArg}" 越出 CCC 根`,
+			deny: `path escape blocked: "${pathArg}" escapes the CCC root`,
 			kind: "deny"
 		};
 		if (isWriteTool(toolName, action)) {
 			const rel = relative(root, abs).split("\\").join("/");
 			if (rel === ".serenity-safe-on" || rel === ".serenity" || rel.startsWith(".serenity-safe-on/") || rel.startsWith(".serenity/")) return {
-				deny: `CCC 治理文件 "${rel}" 保留给用户，agent 不可写`,
+				deny: `CCC governance file "${rel}" is reserved for the user — agent must not write`,
 				kind: "deny"
 			};
 			const hit = matchBlacklist(rel, blacklist);
 			if (hit) return {
-				deny: hit.message ?? `blacklist blocked: "${pathArg}" 命中规则 "${hit.pattern}"`,
+				deny: hit.message ?? `blacklist blocked: "${pathArg}" matches rule "${hit.pattern}"`,
 				kind: "deny"
 			};
 		}
@@ -916,11 +916,11 @@ async function runKit(root, args) {
 		}
 		case "wait": {
 			const seconds = args.seconds ?? 1;
-			if (!Number.isInteger(seconds) || seconds <= 0) throw new Error("wait 需要正整数秒数（缺省 1）");
+			if (!Number.isInteger(seconds) || seconds <= 0) throw new Error("wait requires a positive integer number of seconds (default 1)");
 			await new Promise((r) => setTimeout(r, seconds * 1e3));
 			return `waited ${seconds}s`;
 		}
-		default: throw new Error(`未知 action: ${args.action}`);
+		default: throw new Error(`Unknown action: ${args.action}`);
 	}
 }
 //#endregion
@@ -939,17 +939,17 @@ function renderText$9(value) {
 }
 const kitTool = defineTool({
 	name: "acc_kit",
-	description: "ACC 通用能力工具包：health（CCC 三原则检查 P1/P2/配置，healthy/degraded 报告）/ time（now_iso/now_local/epoch_ms）/ wait（等待 N 秒，缺省 1）。进入 CCC 工作前的例行自检。",
+	description: "ACC general-purpose utility kit: health (CCC three-principle check P1/P2/config, healthy/degraded report) / time (now_iso/now_local/epoch_ms) / wait (wait N seconds, default 1). Routine self-check before entering a CCC.",
 	parameters: {
 		action: {
 			type: "string",
 			enum: [...KIT_ACTIONS],
 			required: true,
-			description: "子命令"
+			description: "Subcommand"
 		},
 		seconds: {
 			type: "integer",
-			description: "wait 的秒数（正整数，缺省 1）"
+			description: "Seconds to wait (positive integer, default 1)"
 		}
 	},
 	output: {
@@ -1018,7 +1018,7 @@ function ensureLocalstoreGitignored(root) {
 	if (isLocalstoreGitignored(root)) return { status: "ignored" };
 	const gi = join(root, ".gitignore");
 	const existing = existsSync(gi) ? readFileSync(gi, "utf-8") : "";
-	const line = `${LOCALSTORE_FILENAME}  # ACC localstore（localstore.gitTrack 缺省 deny，禁提交）`;
+	const line = `${LOCALSTORE_FILENAME}  # ACC localstore (localstore.gitTrack defaults to deny — do not commit)`;
 	writeFileSync(gi, (existing.endsWith("\n") || existing === "" ? existing : existing + "\n") + line + "\n", "utf-8");
 	return { status: "appended" };
 }
@@ -1032,11 +1032,11 @@ function checkLocalstoreGitCompliance(root) {
 	if (isLocalstoreGitignored(root)) return { ok: true };
 	return {
 		ok: false,
-		reason: `localstore.json 禁止提交（localstore.gitTrack=deny 缺省）但 .gitignore 未包含——请将 ${LOCALSTORE_FILENAME} 加入 .gitignore（或改配置 localstore.gitTrack=allow 显式放行）`
+		reason: `localstore.json must not be committed (localstore.gitTrack=deny default) but .gitignore does not cover it — add ${LOCALSTORE_FILENAME} to .gitignore (or set localstore.gitTrack=allow to explicitly permit)`
 	};
 }
 /** 读取全文件（顶层分节）；文件不存在/坏 JSON 返回空 */
-function readAll$1(root) {
+function readAll(root) {
 	const p = localstorePath(root);
 	if (!existsSync(p)) return {};
 	try {
@@ -1048,28 +1048,28 @@ function readAll$1(root) {
 	}
 }
 /** 写回全文件（2 空格缩进 + 尾换行，方便 MSM 直接读取） */
-function writeAll$1(root, data) {
+function writeAll(root, data) {
 	writeFileSync(localstorePath(root), JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 /** 读取命名空间全部条目：credential → 扁平；config → 分节（剔除 credentials 保留节） */
 function readStore(root, scope) {
-	const all = readAll$1(root);
+	const all = readAll(root);
 	if (scope === "credential") return all["credentials"] ?? {};
 	const { [CREDENTIALS_SECTION]: _cred, ...rest } = all;
 	return rest;
 }
 /** 校验凭据 key 合法（大写蛇形）；不合法抛错 */
 function assertCredentialKey(key) {
-	if (!CREDENTIAL_KEY_RE.test(key)) throw new Error(`credential key "${key}" 必须匹配大写蛇形 ^[A-Z][A-Z0-9_]*$（如 HOME_GITLAB_TOKEN）`);
+	if (!CREDENTIAL_KEY_RE.test(key)) throw new Error(`credential key "${key}" must match UPPER_SNAKE ^[A-Z][A-Z0-9_]*$ (e.g. HOME_GITLAB_TOKEN)`);
 }
 /** 校验 config 路径（节.key）；不合法抛错 */
 function assertConfigPath(path) {
 	const idx = path.indexOf(".");
-	if (idx <= 0 || idx === path.length - 1) throw new Error(`config path "${path}" 必须为 section.key（如 loop.defaultModel）`);
+	if (idx <= 0 || idx === path.length - 1) throw new Error(`config path "${path}" must be section.key (e.g. loop.defaultModel)`);
 	const section = path.slice(0, idx);
 	const key = path.slice(idx + 1);
-	if (!CONFIG_SECTION_RE.test(section)) throw new Error(`config 节 "${section}" 必须匹配 ^[a-z][a-z0-9-]*$`);
-	if (!CONFIG_KEY_RE.test(key)) throw new Error(`config key "${key}" 必须匹配小驼峰 ^[a-z][a-zA-Z0-9_]*$（如 defaultModel）`);
+	if (!CONFIG_SECTION_RE.test(section)) throw new Error(`config section "${section}" must match ^[a-z][a-z0-9-]*$`);
+	if (!CONFIG_KEY_RE.test(key)) throw new Error(`config key "${key}" must match lowerCamel ^[a-z][a-zA-Z0-9_]*$ (e.g. defaultModel)`);
 	return {
 		section,
 		key
@@ -1077,7 +1077,7 @@ function assertConfigPath(path) {
 }
 /** 写入单个条目（自动建文件；deny 默认时同步确保 .gitignore 物理保证） */
 function writeEntry(root, scope, name, value) {
-	const all = readAll$1(root);
+	const all = readAll(root);
 	if (scope === "credential") {
 		assertCredentialKey(name);
 		all[CREDENTIALS_SECTION] ??= {};
@@ -1087,12 +1087,12 @@ function writeEntry(root, scope, name, value) {
 		all[section] ??= {};
 		all[section][key] = value;
 	}
-	writeAll$1(root, all);
+	writeAll(root, all);
 	ensureLocalstoreGitignored(root);
 }
 /** 删除单个条目（不存在返回 false）；空节自动移除 */
 function unsetEntry(root, scope, name) {
-	const all = readAll$1(root);
+	const all = readAll(root);
 	if (scope === "credential") {
 		assertCredentialKey(name);
 		const sec = all[CREDENTIALS_SECTION];
@@ -1106,12 +1106,12 @@ function unsetEntry(root, scope, name) {
 		delete sec[key];
 		if (Object.keys(sec).length === 0) delete all[section];
 	}
-	writeAll$1(root, all);
+	writeAll(root, all);
 	return true;
 }
 /** 读取单个条目值；不存在返回 null */
 function getEntry(root, scope, name) {
-	const all = readAll$1(root);
+	const all = readAll(root);
 	if (scope === "credential") {
 		assertCredentialKey(name);
 		return all["credentials"]?.[name] ?? null;
@@ -1132,18 +1132,18 @@ function listKeys(root, scope) {
 function docText(root) {
 	const path = localstorePath(root);
 	return [
-		"# localstore — ACC 本地凭据/配置存储（标准，S134 重设计）",
+		"# localstore — ACC local credential/config storage (standard, S134 redesign)",
 		"",
-		"一个工具管理两个命名空间：credential（凭据）+ config（偏好）。",
-		`存储于 CCC 根根目录 ${path}（JSON 格式，MSM 可直接 read + JSON.parse）。`,
+		"One tool manages two namespaces: credential (credentials) + config (preferences).",
+		`Stored at the CCC root in ${path} (JSON format; MSMs can read + JSON.parse directly).`,
 		"",
-		"## git 提交策略",
-		"- 配置：.opencode/serenity.json `localstore.gitTrack`：`\"allow\"`（可提交）| `\"deny\"`（禁提交；.dsh 回退）",
-		"- **缺省 deny（没配就是不提交）**；deny 时写入会自动确保 .gitignore 含 localstore.json",
-		"  （物理保证，不依赖 dsh 运行）；cc_git commit 会检查拒绝",
-		"- 想提交：配置 `\"localstore\": { \"gitTrack\": \"allow\" }`，并从 .gitignore 移除 localstore.json",
+		"## Git commit policy",
+		"- Config: .opencode/serenity.json `localstore.gitTrack`: `\"allow\"` (may commit) | `\"deny\"` (must not commit; .dsh fallback)",
+		"- **Default deny (unset = not committed)**; when deny, writes automatically ensure .gitignore contains localstore.json",
+		"  (physical guarantee, independent of dsh runtime); cc_git commit checks and refuses",
+		"- To commit: set `\"localstore\": { \"gitTrack\": \"allow\" }` and remove localstore.json from .gitignore",
 		"",
-		"## 格式（JSON 顶层分节）",
+		"## Format (JSON top-level sections)",
 		"```json",
 		"{",
 		"  \"credentials\": {",
@@ -1154,24 +1154,24 @@ function docText(root) {
 		"  }",
 		"}",
 		"```",
-		"- credentials 为保留节（凭据，key 大写蛇形）；其余节 = config（path = section.key）",
+		"- credentials is a reserved section (credentials, UPPER_SNAKE keys); other sections = config (path = section.key)",
 		"",
-		"## key 规范",
-		"- credential key: ^[A-Z][A-Z0-9_]*$（如 HOME_GITLAB_TOKEN）",
-		"- config path: section.key（节 ^[a-z][a-z0-9-]*$，key 小驼峰 ^[a-z][a-zA-Z0-9_]*$，如 loop.defaultModel）",
+		"## Key conventions",
+		"- credential key: ^[A-Z][A-Z0-9_]*$ (e.g. HOME_GITLAB_TOKEN)",
+		"- config path: section.key (section ^[a-z][a-z0-9-]*$, key lowerCamel ^[a-z][a-zA-Z0-9_]*$, e.g. loop.defaultModel)",
 		"",
-		"## 读取方法（agent 可直接用 fs 工具）",
-		`- 用 read 工具读 ${path} → JSON.parse 解析`,
-		"- 或用 localstore get <name> [--scope credential|config]",
+		"## Reading (agents may use fs tools directly)",
+		`- Read ${path} with the read tool → JSON.parse`,
+		"- Or use localstore get <name> [--scope credential|config]",
 		"",
-		"## 写入方法",
-		"- 推荐：localstore set <name> <value> [--scope ...]（自动建文件/保留其他条目/联动 .gitignore）",
-		"- 或直接用 write/edit 工具修改文件，保持 JSON 合法",
+		"## Writing",
+		"- Recommended: localstore set <name> <value> [--scope ...] (auto-creates file / preserves other entries / syncs .gitignore)",
+		"- Or modify the file directly with write/edit, keeping the JSON valid",
 		"",
-		"## 安全边界",
-		"- list/show 对 credential 只返回 key 名，不返回值",
-		"- 凭据值应在 agent 内部使用，不要写入对话/日志",
-		"- 默认 deny：文件不会提交 git（.gitignore 物理保证 + cc_git 检查兜底）",
+		"## Security boundary",
+		"- list/show return only key names for credentials, never values",
+		"- Credential values should be used internally by the agent; never write them into conversation or logs",
+		"- Default deny: the file is not committed to git (.gitignore physical guarantee + cc_git check fallback)",
 		""
 	].join("\n");
 }
@@ -1184,9 +1184,9 @@ function runLocalStore(root, args) {
 			keys: listKeys(root, scope)
 		};
 		case "get": {
-			if (!args.name) throw new Error("get 需要 name");
+			if (!args.name) throw new Error("get requires name");
 			const value = getEntry(root, scope, args.name);
-			if (value === null) throw new Error(`not found: ${args.name}（scope=${scope}）`);
+			if (value === null) throw new Error(`not found: ${args.name} (scope=${scope})`);
 			return {
 				scope,
 				name: args.name,
@@ -1195,8 +1195,8 @@ function runLocalStore(root, args) {
 			};
 		}
 		case "set": {
-			if (!args.name) throw new Error("set 需要 name");
-			if (args.value === void 0) throw new Error("set 需要 value");
+			if (!args.name) throw new Error("set requires name");
+			if (args.value === void 0) throw new Error("set requires value");
 			writeEntry(root, scope, args.name, args.value);
 			const git = checkLocalstoreGitCompliance(root);
 			return {
@@ -1210,7 +1210,7 @@ function runLocalStore(root, args) {
 			};
 		}
 		case "unset": {
-			if (!args.name) throw new Error("unset 需要 name");
+			if (!args.name) throw new Error("unset requires name");
 			const removed = unsetEntry(root, scope, args.name);
 			return {
 				scope,
@@ -1219,7 +1219,7 @@ function runLocalStore(root, args) {
 			};
 		}
 		case "show": {
-			if (!args.name) throw new Error("show 需要 name");
+			if (!args.name) throw new Error("show requires name");
 			const exists = getEntry(root, scope, args.name) !== null;
 			return {
 				scope,
@@ -1229,7 +1229,7 @@ function runLocalStore(root, args) {
 			};
 		}
 		case "doc": return { doc: docText(root) };
-		default: throw new Error(`未知子命令: ${args.action}（可用 list/get/set/unset/show/doc）`);
+		default: throw new Error(`Unknown subcommand: ${args.action} (available: list/get/set/unset/show/doc)`);
 	}
 }
 //#endregion
@@ -1276,7 +1276,7 @@ function git(root, args) {
 	} catch (err) {
 		return {
 			stdout: (err.stdout?.toString() ?? "").trimEnd(),
-			stderr: err.killed ? `git 操作超时（${GIT_TIMEOUT_MS / 1e3}s）` : (err.stderr?.toString() ?? "").trimEnd()
+			stderr: err.killed ? `git operation timed out (${GIT_TIMEOUT_MS / 1e3}s)` : (err.stderr?.toString() ?? "").trimEnd()
 		};
 	}
 }
@@ -1306,7 +1306,7 @@ function runGit(root, args) {
 				"status",
 				"--porcelain"
 			]);
-			if (r.stderr) throw new Error(`status 失败：${r.stderr.trim()}`);
+			if (r.stderr) throw new Error(`status failed: ${r.stderr.trim()}`);
 			const files = (r.stdout ? r.stdout.split("\n") : []).map((line) => {
 				return {
 					status: line.slice(0, 2).trim() || "??",
@@ -1353,7 +1353,7 @@ function runGit(root, args) {
 				"origin",
 				branch
 			]);
-			if (stderr.includes("non-fast-forward") || stderr.includes("rejected") || stderr.includes("[rejected]")) return `[REJECTED] Push to origin/${branch} was rejected (non-fast-forward).\n\n远程有新的提交，本地落后。操作建议：\n  1. 先用 bash: git fetch origin ${branch}\n  2. 查看远程变更: git log HEAD..origin/${branch}\n  3. 合并或变基: git merge origin/${branch} 或 git rebase origin/${branch}\n  4. 有冲突则手动解决后: git add ... && git commit\n  5. 再次推送: cc_git push`;
+			if (stderr.includes("non-fast-forward") || stderr.includes("rejected") || stderr.includes("[rejected]")) return `[REJECTED] Push to origin/${branch} was rejected (non-fast-forward).\n\nRemote has new commits and your local branch is behind. Suggested actions:\n  1. Use bash: git fetch origin ${branch}\n  2. Inspect remote changes: git log HEAD..origin/${branch}\n  3. Merge or rebase: git merge origin/${branch} or git rebase origin/${branch}\n  4. Resolve conflicts manually if any: git add ... && git commit\n  5. Push again: cc_git push`;
 			if (!stderr || stderr.includes("->") || stderr === "") return stdout || `Pushed to origin/${branch}`;
 			throw new Error(`cc_git push failed:\n${stderr}`);
 		}
@@ -1382,7 +1382,7 @@ function runGit(root, args) {
 				const msg = mergeResult.stdout || "Pulled successfully.";
 				return msg.endsWith("\n") ? msg.trimEnd() : msg;
 			}
-			if (mergeResult.stderr.includes("non-fast-forward") || mergeResult.stderr.includes("Not possible to fast-forward") || mergeResult.stderr.includes("rejected") || mergeResult.stderr.includes("could not be applied")) return `[REJECTED] Pull from origin/${branch} was rejected (non-fast-forward).\n\n远程有新的提交，本地的历史与远程产生了分歧（非快进）。操作建议：\n  1. 查看差异: cc_git log HEAD..origin/${branch}\n  2. 用 bash 手动合并: git merge origin/${branch}\n  3. 或用 rebase: git rebase origin/${branch}\n  4. 有冲突则手动解决后: git add <file> && git commit\n  5. 推送: cc_git push`;
+			if (mergeResult.stderr.includes("non-fast-forward") || mergeResult.stderr.includes("Not possible to fast-forward") || mergeResult.stderr.includes("rejected") || mergeResult.stderr.includes("could not be applied")) return `[REJECTED] Pull from origin/${branch} was rejected (non-fast-forward).\n\nRemote has new commits and your local history diverged from remote (non-fast-forward). Suggested actions:\n  1. Inspect differences: cc_git log HEAD..origin/${branch}\n  2. Merge manually with bash: git merge origin/${branch}\n  3. Or rebase: git rebase origin/${branch}\n  4. Resolve conflicts manually if any: git add <file> && git commit\n  5. Push: cc_git push`;
 			throw new Error(`cc_git pull failed:\n${mergeResult.stderr}`);
 		}
 		case "log": {
@@ -1395,7 +1395,7 @@ function runGit(root, args) {
 				"-n",
 				String(n)
 			]);
-			if (r.stderr) throw new Error(`git log 失败：${r.stderr.trim()}`);
+			if (r.stderr) throw new Error(`git log failed: ${r.stderr.trim()}`);
 			if (!r.stdout) return "(no commits)";
 			return r.stdout;
 		}
@@ -1409,7 +1409,7 @@ function runGit(root, args) {
 			if (!stdout) return "(no diff)";
 			return stdout;
 		}
-		default: throw new Error(`未知 action: ${args.action}`);
+		default: throw new Error(`Unknown action: ${args.action}`);
 	}
 }
 //#endregion
@@ -1428,33 +1428,33 @@ function renderText$8(value) {
 }
 const gitTool = defineTool({
 	name: "cc_git",
-	description: "CCC 内 git 操作（cc-git 语义，对齐 osp）。status/commit/push/log/pull/diff；push/pull 非快进时输出 [REJECTED] + 操作建议（绝不自动 force）。merge/rebase/冲突解决走 bash。",
+	description: "CCC git operations (cc-git semantics, aligned with osp). status/commit/push/log/pull/diff; non-fast-forward push/pull outputs [REJECTED] + suggested actions (never auto-force). merge/rebase/conflict resolution go through bash.",
 	parameters: {
 		action: {
 			type: "string",
 			enum: [...GIT_ACTIONS],
 			required: true,
-			description: "子命令：status/commit/push/log/pull/diff"
+			description: "Subcommand: status/commit/push/log/pull/diff"
 		},
 		message: {
 			type: "string",
-			description: "commit 消息（commit 必填）"
+			description: "Commit message (required for commit)"
 		},
 		count: {
 			type: "integer",
-			description: "log 条数（默认 10，max 100；运行时 clamp 1-100）"
+			description: "Log count (default 10, max 100; runtime clamp 1-100)"
 		},
 		staged: {
 			type: "boolean",
-			description: "diff: 显示暂存区变更（--cached）"
+			description: "diff: show staged changes (--cached)"
 		},
 		ref: {
 			type: "string",
-			description: "diff: 对比 ref（如 HEAD~1 / main / origin/main）"
+			description: "diff: compare ref (e.g. HEAD~1 / main / origin/main)"
 		},
 		path: {
 			type: "string",
-			description: "diff: 限定路径（如 src/、package.json）"
+			description: "diff: restrict to path (e.g. src/, package.json)"
 		}
 	},
 	output: {
@@ -1491,10 +1491,10 @@ function readCccName(root) {
 */
 function assertPathInsideRoot(root, value, flagName) {
 	const abs = resolve(root, value);
-	if (classifyPath(abs, root) === "outside") throw new Error(`Path escape blocked: --${flagName}=${value} 越出 CCC 根`);
+	if (classifyPath(abs, root) === "outside") throw new Error(`Path escape blocked: --${flagName}=${value} escapes the CCC root`);
 	if (existsSync(abs)) try {
 		const real = realpathSync(abs);
-		if (classifyPath(real, root) === "outside") throw new Error(`Path escape blocked: --${flagName}=${value} 经 symlink 指向根外 (${real})`);
+		if (classifyPath(real, root) === "outside") throw new Error(`Path escape blocked: --${flagName}=${value} resolves via symlink outside the root (${real})`);
 	} catch (e) {
 		if (e instanceof Error && e.message.includes("symlink")) throw e;
 	}
@@ -1523,58 +1523,58 @@ const MSM_ACTIONS = [
 	"guide",
 	"ccc-config"
 ];
-const MSM_GUIDE = `MSM 开发手册（Mech & Semi-Mech 框架）
+const MSM_GUIDE = `MSM Development Manual (Mech & Semi-Mech framework)
 
-## 是什么
-MSM = 可执行单元层。Mech 纯 TS 零 LLM 推理；Semi-Mech TS 框架 + LLM 决策点。
-MSM 是 ACC 的确定性可执行单元层——所有 shell/exec 操作走 MSM，不可绕过。
+## What it is
+MSM = the executable-unit layer. Mech is pure TS with zero LLM reasoning; Semi-Mech is a TS framework + LLM decision points.
+MSM is ACC's deterministic executable-unit layer — all shell/exec operations go through MSM and cannot be bypassed.
 
-## 注册新 MSM（acc_msm register）
-1. 在 <skill>/scripts/ 写脚本（tsx 可跑；必须带 main() CLI 守卫 import.meta.url 检查）
-2. acc_msm register <name> --skill <s> --path <脚本相对根路径> --category <mech|semi-mech> --description <desc>
-3. 自动写入 mech-registry.json（保留原格式）+ git commit（只提交注册表文件）
-4. 校验：path 必须根内、脚本必须存在、name 全局唯一
+## Registering a new MSM (acc_msm register)
+1. Write the script under <skill>/scripts/ (runnable via tsx; must include a main() CLI guard with an import.meta.url check)
+2. acc_msm register <name> --skill <s> --path <script path relative to root> --category <mech|semi-mech> --description <desc>
+3. Auto-writes mech-registry.json (preserving the original format) + git commit (commits only the registry file)
+4. Validation: path must be inside root, script must exist, name must be globally unique
 
-## flag schema（v1）
-flags 是 new-style 对象数组，用于参数校验与 path 逃逸守卫：
-  [{"name":"output","type":"string","description":"输出路径"},
-   {"name":"target","type":"path","description":"操作目标（type:path 启用根内校验 + symlink 防御）"},
-   {"name":"force","type":"boolean","description":"强制模式","default":false}]
-- {name, type} 格式 — new style，type:"path" 启用 path-escape 守卫
-- {flag, description} 格式 — old style，CLI flag 描述字符串
-- 注册时 flags 经 acc_msm register --flags '<json>' 传入（工具当前解析 name 风格）
+## flag schema (v1)
+flags is a new-style object array for parameter validation and path-escape guarding:
+  [{"name":"output","type":"string","description":"output path"},
+   {"name":"target","type":"path","description":"operation target (type:path enables in-root validation + symlink defense)"},
+   {"name":"force","type":"boolean","description":"force mode","default":false}]
+- {name, type} format — new style, type:"path" enables the path-escape guard
+- {flag, description} format — old style, CLI flag description string
+- On registration, flags are passed via acc_msm register --flags '<json>' (the tool currently parses the name style)
 
-## 脚本约定
-- 顶部文档：用途/用法/退出码
-- 退出码：0 成功 / 1 user / 2 system / 3 operator（对齐 ACC 协议分类）
-- main() CLI 守卫（DC-M2）：脚本顶部必须有
+## Script conventions
+- Top-of-file documentation: purpose / usage / exit codes
+- Exit codes: 0 success / 1 user / 2 system / 3 operator (per ACC protocol classification)
+- main() CLI guard (DC-M2): the script must start with
     if (import.meta.url === \`file://\${process.argv[1]}\`) { main() }
-  或等价 isMain / require.main === 判断——vitest import 时不触发顶层代码
-- 配对 .test.ts 或 .spec.ts（DC-M1，vitest）
-- 业务子进程环境：注入 SERENITY_ROOT / SERENITY_CCC / SERENITY_VERSION
+  or an equivalent isMain / require.main === check — so vitest imports never trigger top-level code
+- A paired .test.ts or .spec.ts (DC-M1, vitest)
+- Business subprocess environment: SERENITY_ROOT / SERENITY_CCC / SERENITY_VERSION injected
 
-## 交互与确认规范（禁止阻塞性确认）
-- MSM 运行在**无用户交互的子进程**（spawn/execFile，600s 超时）——**禁止**用
-  readline / prompt / process.stdin 等阻塞等待用户输入（会卡死至超时被 kill）
-- 需要二次确认时：**直接返回确认信息**（输出将执行的操作与影响 + 如何带确认参数重试），
-  以非 0 退出码返回（或明确提示）
-- agent 确认后**重新调用 MSM 并带上确认参数**（如 --confirm / --yes / --force）重试
-- 标准模式（两段式）：
-  1. 首次调用：检测到破坏性/需确认操作且未带确认 flag → 输出确认请求（列出操作/影响/回滚），
-     exit 非 0（如 1 user），**不执行任何变更**
-  2. agent 评估后重新调用：带确认 flag → 执行并输出结果
-- 适用场景：删除/覆盖/推送/批量操作 等不可逆或影响面大的操作
-- 反例（禁止）：readline 等待用户输入、process.stdin.on('data') 阻塞等待
-  （MSM 无 stdin 交互通道——卡死至 600s 超时）
+## Interaction & confirmation conventions (no blocking confirmation)
+- MSMs run in **user-less subprocesses** (spawn/execFile, 600s timeout) — **never** use
+  readline / prompt / process.stdin etc. to block waiting for user input (it would hang until killed by the timeout)
+- When a second confirmation is needed: **directly return the confirmation request** (list the operation to perform and its impact + how to retry with the confirmation flag),
+  returning a non-zero exit code (or an explicit hint)
+- After the agent confirms, **re-invoke the MSM with the confirmation flag** (e.g. --confirm / --yes / --force) to retry
+- Standard mode (two-phase):
+  1. First call: destructive/confirmation-requiring operation detected and no confirmation flag present → output the confirmation request (list operation/impact/rollback),
+     exit non-zero (e.g. 1 user), **perform no changes**
+  2. After the agent evaluates, re-invoke: with the confirmation flag → execute and output the result
+- Applies to: delete/overwrite/push/batch operations and other irreversible or wide-impact operations
+- Anti-example (forbidden): readline waiting for user input, process.stdin.on('data') blocking waits
+  (MSMs have no stdin interaction channel — they hang until the 600s timeout)
 
-## 品质检查（acc_msm check，DC-M1~M4）
-DC-M1 有 .test.ts/.spec.ts；DC-M2 有 main() 守卫（function main( / isMain / require.main === / import.meta.url）；
-DC-M3 双向：脚本未注册 + 注册表引用脚本缺失；DC-M4 路径型 flag 标记 type:"path"
+## Quality checks (acc_msm check, DC-M1~M4)
+DC-M1 has .test.ts/.spec.ts; DC-M2 has a main() guard (function main( / isMain / require.main === / import.meta.url);
+DC-M3 bidirectional: scripts unregistered + registry references missing scripts; DC-M4 path-type flags marked type:"path"
 
-## 自描述（协议 flag，仅限参数首位）
-acc_msm exec <name> --list        — 列出全部 MSM
-acc_msm exec <name> --schema <n>   — 查看某 MSM 的参数 schema
-acc_msm exec <name> --format=json  — JSON 输出模式（其余参数无损透传）
+## Self-description (protocol flags, first argument only)
+acc_msm exec <name> --list        — list all MSMs
+acc_msm exec <name> --schema <n>   — view a specific MSM's parameter schema
+acc_msm exec <name> --format=json  — JSON output mode (remaining args passed through losslessly)
 `;
 /** CCC 配置参考（对齐 osp ccc-config action） */
 const CCC_CONFIG_REFERENCE = `═══ CCC Configuration Reference ═══
@@ -1720,8 +1720,8 @@ function runMsm(root, args) {
 		case "register": {
 			const name = args.name ?? "";
 			const { skill, path, category, description } = args;
-			if (!name) throw new Error("register 需要 name");
-			if (!path || !category || !description) throw new Error("register 需要 path/category/description");
+			if (!name) throw new Error("register requires name");
+			if (!path || !category || !description) throw new Error("register requires path/category/description");
 			const scriptAbs = resolve(root, path);
 			if (classifyPath(scriptAbs, root) === "outside") throw new Error(`MSM register: path "${path}" escapes CCC root "${root}"`);
 			if (!existsSync(scriptAbs)) throw new Error(`MSM script not found: "${path}"`);
@@ -1735,7 +1735,7 @@ function runMsm(root, args) {
 				if (!Array.isArray(parsed)) throw new Error("flags must be a JSON array");
 				flags = parsed;
 			} catch (e) {
-				throw new Error(`register flags 解析失败：${e instanceof Error ? e.message : String(e)}`);
+				throw new Error(`register flags parse failed: ${e instanceof Error ? e.message : String(e)}`);
 			}
 			entries.push({
 				name,
@@ -1848,7 +1848,7 @@ function runMsm(root, args) {
 				issues
 			};
 		}
-		default: throw new Error(`未知 action: ${args.action}`);
+		default: throw new Error(`Unknown action: ${args.action}`);
 	}
 }
 function prepareExec(root, args) {
@@ -2013,46 +2013,46 @@ function renderText$7(value) {
 }
 const msmTool = defineTool({
 	name: "acc_msm",
-	description: "MSM（Mech & Semi-Mech）框架：list 列出注册 MSM（header+flags 展示）；exec 执行（600s 超时，path 逃逸+symlink 阻断，注入 SERENITY_ROOT/CCC/VERSION env，失败追加 --help TIP；参数首位 --list/--schema/--format=json 为协议）；register/deregister 管理注册表（path 根内+脚本存在+全局唯一校验，自动 git 精提交）；check 品质检查 DC-M1~M4；guide 开发手册；ccc-config CCC 配置参考（loop.defaultModel/sessionKeeper.threshold/localstore.gitTrack/hooks.autoRestoreSession）。复用 CCC 的 mech-registry.json。",
+	description: "MSM (Mech & Semi-Mech) framework: list lists registered MSMs (header+flags display); exec executes (600s timeout, path-escape + symlink blocking, injects SERENITY_ROOT/CCC/VERSION env, appends --help TIP on failure; first arg --list/--schema/--format=json is protocol); register/deregister manage the registry (path inside root + script exists + globally unique validation, auto git precision commit); check quality checks DC-M1~M4; guide development manual; ccc-config CCC config reference (loop.defaultModel/sessionKeeper.threshold/localstore.gitTrack/hooks.autoRestoreSession). Reuses the CCC mech-registry.json.",
 	parameters: {
 		action: {
 			type: "string",
 			enum: [...MSM_ACTIONS],
 			required: true,
-			description: "子命令：list/exec/register/deregister/check/guide/ccc-config"
+			description: "Subcommand: list/exec/register/deregister/check/guide/ccc-config"
 		},
 		name: {
 			type: "string",
-			description: "MSM 名（exec/register/deregister）"
+			description: "MSM name (exec/register/deregister)"
 		},
 		args: {
 			type: "array",
 			items: { type: "string" },
-			description: "exec 的业务参数（参数首位 --list/--schema <n>/--format=json 为协议 flag，其余无损透传）"
+			description: "exec business args (first arg --list/--schema <n>/--format=json is protocol flag, rest passed through losslessly)"
 		},
 		skill: {
 			type: "string",
-			description: "register 的所属 skill"
+			description: "register owning skill"
 		},
 		path: {
 			type: "string",
-			description: "register 的脚本相对路径（必须根内且存在）"
+			description: "register script relative path (must be inside root and exist)"
 		},
 		category: {
 			type: "string",
-			description: "register 的类别（mech/semi-mech）"
+			description: "register category (mech/semi-mech)"
 		},
 		description: {
 			type: "string",
-			description: "register 的描述"
+			description: "register description"
 		},
 		flags: {
 			type: "string",
-			description: "register 的 flags JSON 字符串（new-style 对象数组，type:\"path\" 启用逃逸校验）"
+			description: "register flags JSON string (new-style object array; type:\"path\" enables escape validation)"
 		},
 		usage: {
 			type: "string",
-			description: "register 的自定义 usage（缺省自动生成）"
+			description: "register custom usage (auto-generated by default)"
 		}
 	},
 	output: {
@@ -2072,31 +2072,31 @@ const msmTool = defineTool({
 *
 * 内嵌框架内容（自包含，不依赖已安装技能）；可选 section 参数聚焦某原则。
 */
-const EAP_CONTENT = `# EAP 认知质量框架（显式抽象原则）
+const EAP_CONTENT = `# EAP Cognitive Quality Framework (Explicit Abstraction Principle)
 
-> "思维的功能价值与其外部可重建性成正比。"
+> "The functional value of a thought is proportional to its external reconstructability."
 
-## 三变量
-| 变量 | 含义 | 提升手段 |
-|------|------|---------|
-| E↑ 显式度 | 变量/实体/关系被明确定义的程度 | 定义变量、指明关系方向与基数、划定边界 |
-| R↓ 重建成本 | 未来重建原始推理的成本 | 记录决策理由、上下文、约束、备选方案 |
-| S↑ 稳定性 | 同一输入反复产生一致结果的程度 | 结构固化、协议化、避免依赖隐含上下文 |
+## Three Variables
+| Variable | Meaning | How to improve |
+|----------|---------|----------------|
+| E↑ Explicitness | Degree to which variables/entities/relations are clearly defined | Define variables, state relationship direction & cardinality, draw boundaries |
+| R↓ Reconstructability | Cost of rebuilding the original reasoning later | Record decision rationale, context, constraints, alternatives |
+| S↑ Stability | Degree to which the same input repeatedly produces consistent output | Fix structures, protocolize, avoid relying on implicit context |
 
-## 输出前自检清单
-- [ ] 变量/实体明确定义（E↑）
-- [ ] 关系指明方向/基数（E↑）
-- [ ] 边界划定——什么在范围内/什么不在（E↑）
-- [ ] 不使用歧义词汇："处理""优化""问题"→ 具体化（E↑）
-- [ ] 关键决策记录理由与备选（R↓）
-- [ ] 不跳级讨论——先对齐上层再进入下层（R↓）
-- [ ] 结构可重复执行/生成（S↑）
+## Pre-Output Self-Check Checklist
+- [ ] Variables/entities clearly defined (E↑)
+- [ ] Relationships state direction/cardinality (E↑)
+- [ ] Boundaries drawn — what is in scope / what is not (E↑)
+- [ ] No ambiguous words: "handle" "optimize" "problem" → be specific (E↑)
+- [ ] Key decisions record rationale and alternatives (R↓)
+- [ ] No level-skipping — align the upper layer before descending (R↓)
+- [ ] Structures can be regenerated repeatably (S↑)
 
-## 与 ACC 的关系
-ACC（插件/模板）结构编码为代码（E↑）；从 ACC 生成 CCC 确定（R↓）；多 CCC 一致（S↑）。
-CCC（home-serenity 等）认知内容编码为 skill/SESSION/设计文档。产出物用本清单自检。
+## Relationship with ACC
+ACC (plugin/template) encodes structure as code (E↑); generating a CCC from ACC is deterministic (R↓); consistent across multiple CCCs (S↑).
+CCC (home-serenity etc.) encodes cognitive content as skills/SESSIONs/design docs. Use this checklist to self-check outputs.
 
-## 参考
+## Reference
 https://github.com/tellmewhattodo/theory-eap`;
 function renderText$6(value) {
 	return [{
@@ -2106,7 +2106,7 @@ function renderText$6(value) {
 }
 const eapTool = defineTool({
 	name: "eap",
-	description: "EAP 认知质量框架（渐进式披露）：定义 E↑ 显式度 / R↓ 重建成本 / S↑ 稳定性 + 输出前自检清单。无 section 返回完整框架；指定 section 聚焦对应内容。",
+	description: "EAP cognitive quality framework (progressive disclosure): defines E↑ explicitness / R↓ reconstructability / S↑ stability + pre-output self-check checklist. No section returns the full framework; specify a section to focus.",
 	parameters: { section: {
 		type: "string",
 		enum: [
@@ -2114,16 +2114,16 @@ const eapTool = defineTool({
 			"checklist",
 			"acc"
 		],
-		description: "聚焦片段：variables（三变量）/ checklist（自检清单）/ acc（与 ACC 关系）"
+		description: "Focus section: variables (three variables) / checklist (self-check list) / acc (relationship with ACC)"
 	} },
 	output: {
 		schema: { type: "string" },
 		render: (_args, value) => renderText$6(value)
 	},
 	async execute(args) {
-		if (args.section === "variables") return EAP_CONTENT.split("## 输出前自检清单")[0];
-		if (args.section === "checklist") return EAP_CONTENT.match(/## 输出前自检清单[\s\S]*?(?=## )/)?.[0] ?? EAP_CONTENT;
-		if (args.section === "acc") return EAP_CONTENT.match(/## 与 ACC 的关系[\s\S]*/)?.[0] ?? EAP_CONTENT;
+		if (args.section === "variables") return EAP_CONTENT.split("## Pre-Output Self-Check Checklist")[0];
+		if (args.section === "checklist") return EAP_CONTENT.match(/## Pre-Output Self-Check Checklist[\s\S]*?(?=## )/)?.[0] ?? EAP_CONTENT;
+		if (args.section === "acc") return EAP_CONTENT.match(/## Relationship with ACC[\s\S]*/)?.[0] ?? EAP_CONTENT;
 		return EAP_CONTENT;
 	}
 });
@@ -2132,33 +2132,33 @@ const eapTool = defineTool({
 /**
 * neat.ts — Neat 设计协作协议工具（渐进式披露，ACC 标准工具化）
 */
-const NEAT_CONTENT = `# Neat 设计协作协议
+const NEAT_CONTENT = `# Neat Design Collaboration Protocol
 
-> 复杂设计不是一次想出来的，是小步对齐走出来的。
+> Complex design is not thought up at once — it is walked out in small aligned steps.
 
-## 四条铁律
-| 铁律 | 含义 | 反例 |
-|------|------|------|
-| 小步对齐 | 一次只推进一个决策，确认后再走下一步 | 一次抛 10 个方案 |
-| 显式决策 | 每个选择记录理由与备选 | "我觉得这样好"（无理由） |
-| 文档驱动 | 结论沉淀到具名文件（<subject>-<scope>-<type>.md） | 结论只存在于对话里 |
-| 不跳级 | 严格按层级推进 | 需求未对齐就写实现 |
+## Four Iron Rules
+| Rule | Meaning | Anti-example |
+|------|---------|--------------|
+| Small-step alignment | Advance one decision at a time; confirm before the next step | Presenting 10 options at once |
+| Explicit decisions | Every choice records rationale and alternatives | "I feel this is good" (no rationale) |
+| Document-driven | Conclusions land in named files (<subject>-<scope>-<type>.md) | Conclusions exist only in conversation |
+| No level-skipping | Advance strictly through the layers | Writing implementation before requirements are aligned |
 
-## 五层推进顺序（不跳级）
-需求层 → 范围层 → 方案层 → 接口层 → 实现层
-| 层 | 产物 | 问题 |
-|----|------|------|
-| 需求层 | 需求描述 | "要解决什么问题？" |
-| 范围层 | 范围清单（in/out） | "做哪些、明确不做哪些？" |
-| 方案层 | 方案对比 + 选定 | "怎么做？选哪个？为什么？" |
-| 接口层 | 接口/协议定义 | "边界怎么交互？" |
-| 实现层 | 代码/文档 | "逐层落地" |
+## Five-Layer Progression (no skipping)
+Requirements → Scope → Solution → Interface → Implementation
+| Layer | Artifact | Question |
+|-------|----------|----------|
+| Requirements | Requirements description | "What problem are we solving?" |
+| Scope | Scope list (in/out) | "What is in, explicitly what is out?" |
+| Solution | Solution comparison + selection | "How? Which one? Why?" |
+| Interface | Interface/protocol definition | "How do the boundaries interact?" |
+| Implementation | Code/docs | "Land it layer by layer" |
 
-## 协作节奏
-1. 提出当前层一个决策点（带上下文 + 建议 + 理由）
-2. 等待确认或修正（小步）
-3. 确认后记录决策（写入会话 SESSION.md 或设计文档）
-4. 推进到下一决策点`;
+## Collaboration Rhythm
+1. Raise one decision point of the current layer (with context + suggestion + rationale)
+2. Wait for confirmation or correction (small step)
+3. After confirmation, record the decision (into session SESSION.md or a design doc)
+4. Move to the next decision point`;
 function renderText$5(value) {
 	return [{
 		type: "text",
@@ -2167,19 +2167,19 @@ function renderText$5(value) {
 }
 const neatTool = defineTool({
 	name: "neat",
-	description: "Neat 设计协作协议（渐进式披露）：小步对齐 / 显式决策 / 文档驱动 / 不跳级（需求→范围→方案→接口→实现）。无 section 返回完整协议。",
+	description: "Neat design collaboration protocol (progressive disclosure): small-step alignment / explicit decisions / document-driven / no level-skipping (requirements→scope→solution→interface→implementation). No section returns the full protocol.",
 	parameters: { section: {
 		type: "string",
 		enum: ["rules", "layers"],
-		description: "聚焦片段：rules（四条铁律）/ layers（五层推进）"
+		description: "Focus section: rules (four iron rules) / layers (five-layer progression)"
 	} },
 	output: {
 		schema: { type: "string" },
 		render: (_args, value) => renderText$5(value)
 	},
 	async execute(args) {
-		if (args.section === "rules") return NEAT_CONTENT.match(/## 四条铁律[\s\S]*?(?=## )/)?.[0] ?? NEAT_CONTENT;
-		if (args.section === "layers") return NEAT_CONTENT.match(/## 五层推进顺序[\s\S]*?(?=## )/)?.[0] ?? NEAT_CONTENT;
+		if (args.section === "rules") return NEAT_CONTENT.match(/## Four Iron Rules[\s\S]*?(?=## )/)?.[0] ?? NEAT_CONTENT;
+		if (args.section === "layers") return NEAT_CONTENT.match(/## Five-Layer Progression[\s\S]*?(?=## )/)?.[0] ?? NEAT_CONTENT;
 		return NEAT_CONTENT;
 	}
 });
@@ -2192,52 +2192,52 @@ const neatTool = defineTool({
 * 不可逆不确定性约束下，维持认知实体身份、可达性与演化能力的工程学科。
 * 来源：home-serenity `.opencode/skills/cce/SKILL.md` + CCE 理论。
 */
-const CCE_CONTENT = `# CCE — 认知连续性工程（Cognitive Continuity Engineering）
+const CCE_CONTENT = `# CCE — Cognitive Continuity Engineering
 
-> **认知连续性工程是在有限资源与不可逆不确定性的约束下，维持一个认知实体的身份、可达性与演化能力的工程学科。**
-> CCE 不优化认知。它维护认知得以继续的条件。—— 存续工程（Persistence Engineering），非绩效工程
+> **Cognitive Continuity Engineering is the engineering discipline of maintaining a cognitive entity's identity, accessibility, and capacity to evolve under the constraints of bounded resources and irreversible uncertainty.**
+> CCE does not optimize cognition. It preserves the conditions under which cognition can continue. — Persistence Engineering, not performance engineering
 
-## 核心命题
-- **连续性属于容器，而非任何个体参与者**——智能体来来去去，但 CCC 的认知轨迹持续存在
-- **组织必须至少与积累同步**——否则操作化认知熵（H_op）无界增长，可达性丧失
-- **重建优于保存**——产物的价值由其使未来智能体重建原始推理的能力决定
+## Core Propositions
+- **Continuity belongs to the container, not to any individual participant** — agents come and go, but the CCC's cognitive trajectory persists
+- **Organization must at minimum keep pace with accumulation** — otherwise operational cognitive entropy (H_op) grows unboundedly and accessibility is lost
+- **Reconstruction over preservation** — an artifact's value is determined by its ability to let future agents rebuild the original reasoning
 
-## 认知容器（Cognitive Container）
-一个有界的认知空间，认知可在其中积累、重组和演化。5 个定义属性：
-| 属性 | 功能 |
-|------|------|
-| 身份（Identity） | 区分此认知系统与其他系统 |
-| 边界（Boundaries） | 定义什么在认知空间内/外 |
-| 持久记忆（Persistent Memory） | 跨时间保留积累的认知 |
-| 操作约束（Operational Constraints） | 定义容器内允许哪些操作 |
-| 演化历史（Evolutionary History） | 记录认知变化轨迹，使重建可能 |
+## Cognitive Container
+A bounded cognitive space in which cognition can accumulate, reorganize, and evolve. 5 defining properties:
+| Property | Function |
+|----------|----------|
+| Identity | Distinguishes this cognitive system from others |
+| Boundaries | Define what is inside/outside the cognitive space |
+| Persistent Memory | Retains accumulated cognition across time |
+| Operational Constraints | Define which operations are allowed inside the container |
+| Evolutionary History | Records the trajectory of cognitive change, making reconstruction possible |
 
-## 操作化认知熵（H_op）
-不度量总体熵（不可操作），只度量智能体在容器内完成任务的**多余认知成本**：
+## Operational Cognitive Entropy (H_op)
+Does not measure total entropy (not operational); it measures only the **excess cognitive cost** for agents to complete tasks inside the container:
 > H_op(C, t) = cost(task | C, t) − cost(task | ideal)
-维持条件：**H_op(C, t) ≤ H_critical** —— 智能体仍可在合理成本内完成任务
+Continuity condition: **H_op(C, t) ≤ H_critical** — agents can still complete tasks at reasonable cost
 
-## 连续性维护条件
-> **ΔH_org ≥ ΔH_in** —— 组织必须至少与积累同步
+## Continuity Maintenance Condition
+> **ΔH_org ≥ ΔH_in** — organization must at minimum keep pace with accumulation
 
-## 六阶段生命周期
-Experience → Accumulation → Organization → Abstraction → Reconstruction → Evolution →（循环）
-| 阶段 | 工程关切 |
-|------|---------|
-| Experience | 输入是否携带足够结构 |
-| Accumulation | 信息是否无损存储 |
-| Organization | 熵管理 — ΔH_org 抵消 ΔH_in |
-| Abstraction | 抽象是否显式编码 |
-| Reconstruction | 推理结构能否从产物恢复 |
-| Evolution | 演化保持连贯还是引入漂移 |
+## Six-Phase Lifecycle
+Experience → Accumulation → Organization → Abstraction → Reconstruction → Evolution →（loop）
+| Phase | Engineering Concern |
+|-------|---------------------|
+| Experience | Does input carry enough structure |
+| Accumulation | Is information stored losslessly |
+| Organization | Entropy management — ΔH_org offsets ΔH_in |
+| Abstraction | Is abstraction explicitly encoded |
+| Reconstruction | Can reasoning structure be recovered from artifacts |
+| Evolution | Does evolution stay coherent or introduce drift |
 
-## 与 EAP 的关系
-EAP 回答"一段知识应如何被结构化"（显式度 E↑ / 重建成本 R↓ / 稳定性 S↑）；
-CCE 回答"有结构的知识应如何跨时间持续演化而不丧失连贯性"。两者互补：EAP 是静态质量，CCE 是动态存续。
+## Relationship with EAP
+EAP answers "how a piece of knowledge should be structured" (explicitness E↑ / reconstructability R↓ / stability S↑);
+CCE answers "how structured knowledge should keep evolving across time without losing coherence". They complement each other: EAP is static quality, CCE is dynamic persistence.
 
-## 与 Serenity 的关系
-Serenity 的会话系统、会话追踪、熵管理机制（SQC 品质循环）都是 CCE 的工程实现；
-CCC 系统提示词中嵌入的行为约束即来自 CCE。`;
+## Relationship with Serenity
+Serenity's session system, session tracking, and entropy management mechanisms (SQC quality loop) are all engineering implementations of CCE;
+the behavioral constraints embedded in CCC system prompts come from CCE.`;
 function renderText$4(value) {
 	return [{
 		type: "text",
@@ -2246,7 +2246,7 @@ function renderText$4(value) {
 }
 const cceTool = defineTool({
 	name: "cce",
-	description: "CCE 认知连续性工程（渐进式披露）：在有限资源与不可逆不确定性约束下，维持认知实体身份/可达性/演化能力的工程学科。无 section 返回完整框架；指定 section 聚焦对应内容。",
+	description: "CCE cognitive continuity engineering (progressive disclosure): the engineering discipline of maintaining a cognitive entity's identity/accessibility/evolution under bounded resources and irreversible uncertainty. No section returns the full framework; specify a section to focus.",
 	parameters: { section: {
 		type: "string",
 		enum: [
@@ -2255,7 +2255,7 @@ const cceTool = defineTool({
 			"lifecycle",
 			"eap"
 		],
-		description: "聚焦片段：container（认知容器 5 属性）/ entropy（操作化认知熵 H_op）/ lifecycle（六阶段）/ eap（与 EAP 关系）"
+		description: "Focus section: container (5 cognitive-container properties) / entropy (operational entropy H_op) / lifecycle (six phases) / eap (relationship with EAP)"
 	} },
 	output: {
 		schema: { type: "string" },
@@ -2265,15 +2265,15 @@ const cceTool = defineTool({
 		const section = args.section;
 		const blocks = {
 			container: {
-				start: "## 认知容器（Cognitive Container）",
-				end: "## 操作化认知熵"
+				start: "## Cognitive Container",
+				end: "## Operational Cognitive Entropy"
 			},
 			entropy: {
-				start: "## 操作化认知熵（H_op）",
-				end: "## 连续性维护条件"
+				start: "## Operational Cognitive Entropy (H_op)",
+				end: "## Continuity Maintenance Condition"
 			},
-			lifecycle: { start: "## 六阶段生命周期" },
-			eap: { start: "## 与 EAP 的关系" }
+			lifecycle: { start: "## Six-Phase Lifecycle" },
+			eap: { start: "## Relationship with EAP" }
 		};
 		if (section) {
 			const b = blocks[section];
@@ -2343,11 +2343,11 @@ function writeProgress(root, label, p) {
 	}, null, 2) + "\n", "utf-8");
 	const lines = [
 		`# loop: ${label}`,
-		`- 模型: ${p.model}`,
-		`- 轮次: ${p.round}`,
-		`- 完成: ${p.done}`,
+		`- Model: ${p.model}`,
+		`- Round: ${p.round}`,
+		`- Done: ${p.done}`,
 		"",
-		`## 最近响应`,
+		`## Latest response`,
 		"",
 		p.lastResponse,
 		""
@@ -2389,66 +2389,66 @@ function splitModel(model) {
 /** 轮次 prompt（对齐老 loop 结构：回顾进度 → 自由工作 → 汇报；S134 EAP 化：固定详尽） */
 function buildRoundPrompt(opts) {
 	const { root, session, label, round, stopToken, progress, task } = opts;
-	const resumeNote = progress && progress.round > 0 ? `上一轮（round ${progress.round}）已完成：${progress.lastResponse.slice(0, 300)}\n永远从上次停止处继续，绝不重做已完成工作。` : "这是第一轮。";
-	return `# ${label} — 牛马循环 round ${round}
+	const resumeNote = progress && progress.round > 0 ? `Previous round (round ${progress.round}) completed: ${progress.lastResponse.slice(0, 300)}\nAlways continue from where you left off; never redo completed work.` : "This is the first round.";
+	return `# ${label} — workhorse loop round ${round}
 
-CCC 根：${root}
-${session ? `工作会话：${session}（AGENT_SESSIONS/${session}/SESSION.md 记录进度）` : ""}
-${task ? `任务：${task}` : `任务：以 label「${label}」对应的工作为准（若存在工作会话，先读 SESSION.md 明确目标）`}
+CCC root: ${root}
+${session ? `Work session: ${session} (progress recorded in AGENT_SESSIONS/${session}/SESSION.md)` : ""}
+${task ? `Task: ${task}` : `Task: follow the work corresponding to label "${label}" (if a work session exists, read SESSION.md first to clarify the goal)`}
 ${resumeNote}
 
-## 工作规范（每轮固定，必须遵守）
-1. 本轮内自由工作：读文件、改代码、执行命令，尽一切手段推进任务。
-2. 若本任务属于**阅读整理或文字编写类工作**（读文件提炼、总结、撰写文档、生成文本等），
-   请先加载 eap（acc-eap skill）并按 EAP 标准组织输出：
-   - E↑ 显式：实体/变量明确定义，关系指明方向与基数，边界划定，不用歧义词
-   - R↓ 可重建：关键结论记录来源与推理，可被后续 agent 重建
-   - S↑ 稳定：输出结构可重复生成，不依赖隐含上下文
-3. 汇报必须具体可核验，不写空话。
+## Work rules (fixed every round, must follow)
+1. Work freely within this round: read files, modify code, execute commands — use every means to advance the task.
+2. If this task is **reading/curating or text-writing work** (extracting from files, summarizing, writing docs, generating text, etc.),
+   first load eap (acc-eap skill) and organize output per the EAP standard:
+   - E↑ Explicit: entities/variables clearly defined, relationships with direction and cardinality, boundaries drawn, no ambiguous words
+   - R↓ Reconstructable: key conclusions record sources and reasoning, rebuildable by later agents
+   - S↑ Stable: output structure regenerates repeatably, no reliance on implicit context
+3. Reports must be concrete and verifiable — no filler.
 
-## 每轮汇报（固定格式，逐条回答）
-1. 本轮做了什么（具体）
-2. 下一步计划
-3. 是否已完成（若完成，只输出 ${stopToken}）
+## Per-round report (fixed format, answer each item)
+1. What was done this round (concrete)
+2. Next-step plan
+3. Whether the task is complete (if complete, output only ${stopToken})
 
-若已完成任务，只输出 ${stopToken}。`;
+If the task is complete, output only ${stopToken}.`;
 }
 /**
 * loop 规模化使用指引（guide 子命令输出；S134）：
 * 使用 loop 前必须先加载 eap 设计方案；并行策略；提示词规范（详尽固定 EAP）；
 * 阅读/文字编写类 loop 内部也加载 eap。
 */
-const LOOP_GUIDE = `# loop — 规模化使用指引（guide）
+const LOOP_GUIDE = `# loop — Scale-Up Usage Guide (guide)
 
-## ⚠️ 使用前：必须先加载 eap 设计方案
-调用 loop 前，请先加载 eap（acc-eap skill），基于 EAP 框架设计「规模化 loop 方案」。
+## ⚠️ Before using: load eap and design the plan
+Before calling loop, load eap (acc-eap skill) and design the "scale-up loop plan" based on the EAP framework.
 
-### 1. 任务拆解（E↑ 显式）
-- 大任务拆成明确子任务：每个子任务定义 目标 / 输入 / 边界（做什么、不做什么）/ 验收标准
-- 依赖显式化：有依赖的串行，无依赖的可并行
+### 1. Task decomposition (E↑ Explicit)
+- Split large tasks into explicit subtasks: each subtask defines goal / input / boundaries (what to do, what not to do) / acceptance criteria
+- Make dependencies explicit: dependent tasks run serially, independent ones can run in parallel
 
-### 2. 提示词设计（loop 的 task 参数）
-- task 必须详尽、固定、符合 EAP：目标明确、边界划定、验收标准可判定
-- 反例「处理这个文件」——歧义；正例「读取 <路径>，提取「关键决策」表格全部行，
-  输出 JSON 数组（字段 id/结论/证据），不改动原文件」
-- 阅读整理 / 文字编写类工作（读文件提炼、总结、撰写文档、生成文本等）：
-  loop 内部 agent 也会被要求加载 eap，按 EAP 标准组织输出
+### 2. Prompt design (loop's task parameter)
+- task must be detailed, fixed, and EAP-compliant: clear goal, drawn boundaries, decidable acceptance criteria
+- Anti-example "handle this file" — ambiguous; good example "read <path>, extract all rows of the「关键决策」table,
+  output a JSON array (fields id/conclusion/evidence), do not modify the original file"
+- Reading/curating or text-writing work (extracting from files, summarizing, writing docs, generating text, etc.):
+  the loop-internal agent is also required to load eap and organize output per the EAP standard
 
-### 3. 并行策略（规模化）
-- 无依赖的子任务可并行：每个子任务一个独立 loop（独立 label + task）
-- 并行执行方式：
-  a. 后台 subagent：每个 subagent 内调 loop（各自 label），subagent 并行运行
-  b. workflow：parallel 阶段驱动多个 loop 子 agent
-- 并发安全已保证：sessionId 唯一（loop-<label>-<uuid>）、进度文件按 label 隔离
-  （AGENT_SESSIONS/loop-<label>.json）——同 label 续跑、不同 label 互不干扰
-- 汇总：并行 loop 各自产出进度后，主 agent 汇总合并（或再派一个汇总 loop）
+### 3. Parallel strategy (scale-up)
+- Independent subtasks can run in parallel: each subtask gets its own loop (own label + task)
+- Parallel execution:
+  a. Background subagents: each subagent calls loop (own label), subagents run in parallel
+  b. workflow: parallel phase drives multiple loop sub-agents
+- Concurrency safety guaranteed: unique sessionId (loop-<label>-<uuid>), progress files isolated per label
+  (AGENT_SESSIONS/loop-<label>.json) — same label resumes, different labels never interfere
+- Aggregation: after each parallel loop produces progress, the main agent merges (or spawns one aggregation loop)
 
-## 完成判定
-- 唯一完成条件 = loop 内部 agent 精确回显本轮随机验证码（stop token）；对话轮次上限 100（对齐 osp 保险阀，超限强制结束可续跑）
-- agent 非正常停止时自动重启（≤100 次防死循环）
+## Completion criteria
+- The only completion condition = the loop-internal agent echoes this round's random verification code (stop token); dialogue round cap 100 (osp fail-safe, forced stop beyond the cap, resumable)
+- Automatic restart on abnormal agent stop (≤100 restarts, anti-infinite-loop)
 
-## 等待界面
-- WebUI 会话头部 Serenity 详情卡显示运行中 loop 的进度（label / 轮次 / 最近响应），并行任务各自一行，约 3s 刷新
+## Waiting UI
+- The WebUI session-header Serenity detail card shows running loops' progress (label / round / last response), one line per parallel task, ~3s refresh
 `;
 /** 列出 AGENT_SESSIONS/loop-*.json 的全部进度（按 updated 倒序；坏文件跳过） */
 function listActiveLoops(root) {
@@ -2537,29 +2537,29 @@ function lastAssistantText(agent) {
 function createLoopTool(ctx) {
 	return defineTool({
 		name: "loop",
-		description: "牛马循环（老 loop 等效）：用指定模型创建专用 agent 反复执行任务直到完成。\n用法：loop guide（输出规模化使用指引——使用前先加载 eap 设计规模化方案）；loop 接受 task（要完成的目标）或依赖 session 上下文；模型缺省读 .opencode/serenity.json 的 loop.defaultModel（当前 minimax-cn-coding-plan/MiniMax-M3，廉价牛马）。\n行为：内部硬性 while 循环驱动 agent 逐轮推进任务，每轮等待无超时（agent 工作多久等多久）。唯一完成条件 = agent 精确回显本轮随机完成码（stop token），防止低智能模型提前结束。轮次不需要调用者指定——对话轮次上限 100（对齐 osp 保险阀，超限强制结束可续跑），agent 非正常停止时自动重启（重启 ≤100 次，防死循环保险阀）。\n进度：写入 AGENT_SESSIONS/loop-<label>.md/.json；同 label 再次调用从上次轮次续跑（不重做）。\n约束：loop agent 受完整 Serenity 约束（ACC 身份/入口技能系统提示词/守卫/session-keeper）。\n示例：loop 执行「扫描 SQC 并修复 DC 问题」，label: sqc-scan；loop guide",
+		description: "The workhorse loop (equivalent to the legacy loop): create a dedicated agent with the specified model and run it repeatedly until the task is done.\nUsage: loop guide (print the scale-up usage guide — load eap to design a scale-up plan before using); loop accepts task (the goal to complete) or relies on session context; default model reads loop.defaultModel from .opencode/serenity.json (currently minimax-cn-coding-plan/MiniMax-M3, the cheap workhorse).\nBehavior: an internal hard while-loop drives the agent round by round, each round waits with no timeout (the agent works as long as it needs). The only completion condition = the agent echoes this round's random completion code (stop token), preventing low-intelligence models from finishing early. Rounds need no caller input — dialogue round cap 100 (osp fail-safe; forced stop beyond the cap, resumable), automatic restart on abnormal stop (≤100 restarts, anti-infinite-loop fail-safe).\nProgress: written to AGENT_SESSIONS/loop-<label>.md/.json; calling again with the same label resumes from the last round (no redo).\nConstraints: loop agents carry full Serenity constraints (ACC identity / entry-skill system prompt / guards / trajectory-steward).\nExample: loop 执行「扫描 SQC 并修复 DC 问题」 (run SQC scan and fix DC issues), label: sqc-scan; loop guide",
 		parameters: {
 			task: {
 				type: "string",
 				required: true,
-				description: "要完成的任务目标（必填：告诉 loop agent 做什么）"
+				description: "The task goal to complete (required: tell the loop agent what to do)"
 			},
 			label: {
 				type: "string",
 				required: true,
-				description: "任务标签（1-50 字符；进度文件命名 loop-<label>.md/.json）"
+				description: "Task label (1-50 chars; progress file named loop-<label>.md/.json)"
 			},
 			session: {
 				type: "string",
-				description: "工作会话 S###（上下文提示，进度记录参考）"
+				description: "Work session S### (context hint, progress reference)"
 			},
 			model: {
 				type: "string",
-				description: "provider/model（如 minimax-cn-coding-plan/MiniMax-M3）；缺省读 loop.defaultModel"
+				description: "provider/model (e.g. minimax-cn-coding-plan/MiniMax-M3); default reads loop.defaultModel"
 			},
 			guide: {
 				type: "boolean",
-				description: "输出规模化使用指引（不创建 agent；使用 loop 前先看——含 eap 设计方案要求/并行策略/提示词规范）"
+				description: "Print the scale-up usage guide (creates no agent; read before using loop — includes eap scale-up design requirements / parallelism strategy / prompt conventions)"
 			}
 		},
 		output: {
@@ -2572,16 +2572,16 @@ function createLoopTool(ctx) {
 			if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 			const cfg = loadSerenityConfig(root, DEFAULT_SERENITY_CONFIG_PATHS);
 			const model = args.model ?? cfg.loop?.defaultModel;
-			if (!model) throw new Error("loop 需要 model：传参或配置 .opencode/serenity.json loop.defaultModel");
+			if (!model) throw new Error("loop requires a model: pass --model or configure .opencode/serenity.json loop.defaultModel");
 			const label = args.label;
-			if (!ctx.agentLoop) throw new Error("loop: ctx.agentLoop 不可用");
+			if (!ctx.agentLoop) throw new Error("loop: ctx.agentLoop unavailable");
 			const { provider, model: modelName } = splitModel(model);
 			const stopToken = newStopToken();
 			let progress = readProgress(root, label);
 			const startRound = progress ? progress.round + 1 : 1;
 			const parentCtx = exec.agent?.ctx;
 			const inherited = loopPresetInheritance(parentCtx);
-			if (!ctx.agents) throw new Error("loop: ctx.agents 不可用");
+			if (!ctx.agents) throw new Error("loop: ctx.agents unavailable");
 			const parentSession = (exec.agent?.session)?.id;
 			let handle;
 			let loopAgent;
@@ -2692,10 +2692,10 @@ function createLoopTool(ctx) {
 				progressFile: json,
 				lastResponse: lastResponse.slice(0, 2e3),
 				usage: {
-					how: `loop 内部硬性 while 驱动 agent 逐轮推进，agent 精确回显随机完成码即终止；对话轮次上限 100（对齐 osp 保险阀），agent 非正常停止时自动重启（≤100 次）`,
-					progress: `进度在 AGENT_SESSIONS/loop-${label}.md 与 .json；同 label 再调 loop 会从下一轮续跑（不重做）`,
-					constraints: "loop agent 受完整 Serenity 约束（ACC 身份/入口技能系统提示词/守卫）",
-					next: done ? "任务已完成；可查看进度文件收尾" : `任务未完成（${finishReason}，已达 100 轮或 100 次重启保险阀）；可同 label 续跑`
+					how: `loop drives the agent round by round via an internal hard while-loop; the agent terminates by echoing the random completion code; dialogue round cap 100 (osp fail-safe), automatic restart on abnormal stop (≤100 times)`,
+					progress: `Progress in AGENT_SESSIONS/loop-${label}.md and .json; calling loop again with the same label resumes from the next round (no redo)`,
+					constraints: "loop agents carry full Serenity constraints (ACC identity / entry-skill system prompt / guards / trajectory-steward)",
+					next: done ? "Task completed; check the progress file to wrap up" : `Task incomplete (${finishReason}, hit 100 rounds or 100 restart fail-safe); resume with the same label`
 				}
 			};
 		}
@@ -4792,7 +4792,11 @@ function registerSettingsSection(ctx, config) {
 		setSource: (get) => {
 			simpleSource = get;
 		},
-		onChange: () => {}
+		onChange: () => {
+			try {
+				ctx.emit?.("serenity/settings-changed");
+			} catch {}
+		}
 	});
 }
 //#endregion
@@ -5392,20 +5396,54 @@ function agentCwd$3(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
 /** 当前 dsh 会话 id（use/close 按会话隔离的 scope） */
-function agentScope$3(exec) {
+function agentScope$2(exec) {
 	return exec.agent?.session?.id ?? "default";
 }
 /**
-* use 激活宁静号会话后，把当前 dsh 会话重命名为该 SESSION 目录名。
-* 门控：naming.enabled + sessionTitle 服务存在；失败静默（不阻断 use 主流程）。
-* @returns 实际执行的 rename（或 null = 未执行）
+* 从激活会话派生命名标题（v1.22.9 格式修正）：
+* F3 原始需求是 **`S###-日期`**（如 `S143-2026-08-26`）——从 `sessionId` 派生，
+* 而非完整目录名（`2026-08-24--S142--...` 超长 + 中文，不符合用户拍板格式）。
+* 无 S### 编号（issue 会话等）→ 回退目录名。
+* @returns `S143-2026-08-26` 或原目录名
 */
-function renameDshSessionOnUse(deps, session, rename, active) {
-	if (!deps.namingEnabled) return null;
-	if (!deps.sessionTitleAvailable) return null;
-	rename(session, active.dirName);
+function namingTitleFor(active) {
+	const sid = active.sessionId;
+	if (typeof sid === "string" && /^S\d+$/.test(sid)) {
+		const date = active.dirName.match(/^(\d{4}-\d{2}-\d{2})--/)?.[1] ?? "";
+		if (date) return `${sid}-${date}`;
+		return sid;
+	}
 	return active.dirName;
 }
+/**
+* use 激活宁静号会话后，把当前 dsh 会话重命名为命名标题（`S###-日期`）。
+* 门控：naming.enabled + sessionTitle 服务存在；失败不静默——返回 null 且输出
+* 失败原因（调用方 console.warn），保证可观测性（v1.22.9）。
+* @returns { title, ok } 或 { ok:false, reason }（未执行/失败均返回对象，非 null 歧义）
+*/
+function renameDshSessionOnUse(deps, session, rename, active) {
+	if (!deps.namingEnabled) return {
+		ok: false,
+		reason: "naming.enabled=false"
+	};
+	if (!deps.sessionTitleAvailable) return {
+		ok: false,
+		reason: "sessionTitle service unavailable"
+	};
+	const title = namingTitleFor(active);
+	try {
+		rename(session, title);
+		return {
+			ok: true,
+			title
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `rename threw: ${String(error?.message ?? error)}`
+		};
+	}
+}
 function renderText$2(value) {
 	return [{
 		type: "text",
@@ -5431,68 +5469,71 @@ function discoverCccSubcommands(entries) {
 }
 /** 生成扩展提示（对齐 osp buildExtHint） */
 function buildExtHint(hasSessionTool, hooks, subcommands) {
-	if (!hasSessionTool) return "\n\n[CCC] 如需扩展会话能力，可注册 session-tool MSM (acc_msm register)，详见 session hook-develop-guide";
+	if (!hasSessionTool) return "\n\n[CCC] To extend session capabilities, register a session-tool MSM (acc_msm register); see session hook-develop-guide";
 	const parts = [];
-	if (hooks.length > 0) parts.push(`钩子: ${hooks.join(", ")}`);
-	if (subcommands.length > 0) parts.push(`扩展子命令 (acc_msm exec session-tool): ${subcommands.join(", ")}`);
-	return `\n\n[CCC] session-tool MSM 已注册${parts.length > 0 ? ` (${parts.join("; ")})` : ""}`;
+	if (hooks.length > 0) parts.push(`hooks: ${hooks.join(", ")}`);
+	if (subcommands.length > 0) parts.push(`custom subcommands (acc_msm exec session-tool): ${subcommands.join(", ")}`);
+	return `\n\n[CCC] session-tool MSM registered${parts.length > 0 ? ` (${parts.join("; ")})` : ""}`;
 }
 /** hook-develop-guide 内容（对齐 osp getHookDevelopGuide） */
 function getHookDevelopGuide(hasSessionTool) {
 	return [
-		"═══ Session Extension Protocol (SEP) v1 — 开发指南 ═══",
+		"═══ Session Extension Protocol (SEP) v1 — Developer Guide ═══",
 		"",
-		"CCC 可以通过注册 session-tool MSM 来扩展 ACC session 工具的能力，",
-		"而无需修改 plugin 代码。ACC 的行为不会缩水——CCC 只在 ACC 完成后做后处理。",
+		"A CCC can extend the ACC session tool by registering a session-tool MSM,",
+		"without modifying plugin code. ACC behavior is never reduced — the CCC only",
+		"does post-processing after ACC completes.",
 		"",
-		"── 口子一：后处理钩子 (Hooks) ──",
+		"── Extension point 1: Post-processing hooks ──",
 		"",
-		"ACC 的某些子命令执行完成后，会检查 CCC 的 session-tool MSM 是否",
-		"注册了对应的钩子。如果注册了，ACC 会调用 MSM 做后处理。",
+		"After certain ACC subcommands complete, ACC checks whether the CCC's",
+		"session-tool MSM has registered a matching hook. If so, ACC invokes the MSM",
+		"for post-processing.",
 		"",
-		"可用钩子：",
+		"Available hooks:",
 		"",
 		"  create-transform",
-		"    触发时机：create 写完默认 SESSION.md 后",
-		"    调用方式：acc_msm exec session-tool --hook=create-transform --session-dir=<path>",
-		"    允许行为：读取 SESSION.md，原地修改内容（追加字段、换模板、调 API 等）",
-		"    注意事项：ACC 已确保目录和 SESSION.md 存在，CCC 只做修改",
+		"    Trigger: after create writes the default SESSION.md",
+		"    Invocation: acc_msm exec session-tool --hook=create-transform --session-dir=<path>",
+		"    Allowed: read SESSION.md and modify it in place (append fields, swap templates, call APIs, etc.)",
+		"    Note: ACC has already ensured the directory and SESSION.md exist; the CCC only modifies",
 		"",
-		"── 口子二：新子命令 (Custom Subcommands) ──",
+		"── Extension point 2: Custom subcommands ──",
 		"",
-		"LLM 可以直接调用 acc_msm exec session-tool <subcommand> 来执行 CCC 专属的子命令，",
-		"如 reindex、export、batch-create 等。这些子命令不走 ACC session tool 的 enum。",
+		"The LLM can call acc_msm exec session-tool <subcommand> to run CCC-specific",
+		"subcommands such as reindex, export, batch-create. These bypass the ACC session",
+		"tool's enum.",
 		"",
-		"── 如何注册 session-tool MSM ──",
+		"── How to register a session-tool MSM ──",
 		"",
-		"1. 编写脚本，放在 CCC 的 skills 目录下：",
+		"1. Write the script under the CCC skills directory:",
 		"     .opencode/skills/<ccc-name>/scripts/session-tool.ts",
 		"",
-		"2. 注册到 mech-registry.json：",
+		"2. Register it in mech-registry.json:",
 		"     acc_msm register session-tool \\",
 		"       --skill <ccc-name> --path .opencode/skills/<ccc-name>/scripts/session-tool.ts \\",
 		"       --category semi-mech \\",
-		"       --description \"CCC session 扩展: 钩子 + 自定义子命令\" \\",
+		"       --description \"CCC session extension: hooks + custom subcommands\" \\",
 		"       --flags '[",
 		"         {\"name\":\"hook\",\"type\":\"string\",\"description\":\"create-transform\"},",
 		"         {\"name\":\"subcommand\",\"type\":\"string\",\"description\":\"reindex | export\"},",
-		"         {\"name\":\"session-dir\",\"type\":\"path\",\"description\":\"session 目录路径\"},",
-		"         {\"name\":\"dry-run\",\"type\":\"boolean\",\"description\":\"预览模式\"}",
+		"         {\"name\":\"session-dir\",\"type\":\"path\",\"description\":\"session directory path\"},",
+		"         {\"name\":\"dry-run\",\"type\":\"boolean\",\"description\":\"preview mode\"}",
 		"       ]'",
 		"",
-		"3. 钩子声明约定：",
-		"     flags 中的 --hook description 字段按 | 分割枚举支持的钩子名。",
-		"     ACC 发现 create-transform 在列表中时，就会在 create 后调用。",
+		"3. Hook declaration convention:",
+		"     The --hook description field in flags enumerates supported hook names, split by |.",
+		"     When ACC finds create-transform in the list, it invokes it after create.",
 		"",
-		"4. 子命令声明约定：",
-		"     flags 中的 --subcommand description 字段按 | 分割枚举支持的子命令名。",
-		"     LLM 看到提示后可调用 acc_msm exec session-tool <subcommand>。",
+		"4. Subcommand declaration convention:",
+		"     The --subcommand description field in flags enumerates supported subcommand names, split by |.",
+		"     The LLM can then call acc_msm exec session-tool <subcommand>.",
 		"",
-		hasSessionTool ? "✅ 当前 CCC 已注册 session-tool MSM" : "ℹ️  当前 CCC 尚未注册 session-tool MSM — 使用 acc_msm register 开始",
+		hasSessionTool ? "✅ This CCC has a session-tool MSM registered" : "ℹ️  This CCC has no session-tool MSM yet — start with acc_msm register",
 		"",
-		"── 更多信息 ──",
+		"── More information ──",
 		"",
-		"参考 ACC 源码: src/tools/session.ts (hook 调用逻辑)"
+		"Reference ACC source: src/tools/session.ts (hook invocation logic)"
 	].join("\n");
 }
 /**
@@ -5502,37 +5543,37 @@ function getHookDevelopGuide(hasSessionTool) {
 function createSessionTool(ctx) {
 	return defineTool({
 		name: "session",
-		description: "工作会话全周期管理（AGENT_SESSIONS/，home-session 约定）。list/show/create/use/close/health/qa/archive/summary/hook-develop-guide。create 需 --desc <desc> [--goal] 或 --issue <工单号>（二选一）；close 需 --confirm；use 激活当前 dsh 会话的活跃会话（内存 + events 恢复，按 dsh 会话隔离不泄露）。",
+		description: "Full work-session lifecycle (AGENT_SESSIONS/, home-session convention). list/show/create/use/close/health/qa/archive/summary/hook-develop-guide. create requires --desc <desc> [--goal] or --issue <ticket> (exactly one); close requires --confirm; use activates the session for the current dsh conversation (in-memory + events restore, isolated per dsh session).",
 		parameters: {
 			action: {
 				type: "string",
 				enum: [...SESSION_ACTIONS],
 				required: true,
-				description: "子命令：list（状态摘要）/ show（S### 或目录名或模糊关键词）/ create（--desc 或 --issue）/ use（激活上下文，closed 可重开）/ close（需 --name + --confirm，不可撤销）/ health（stale/stalled/drift/ghost）/ qa（事实核对）/ archive（归档，name 缺省批量）/ summary（仪表盘）/ hook-develop-guide（CCC 扩展指南）"
+				description: "Subcommand: list (status summary) / show (S### or dir name or fuzzy keyword) / create (--desc or --issue) / use (activate context, closed can be reopened) / close (requires --name + --confirm, irreversible) / health (stale/stalled/drift/ghost) / qa (fact check) / archive (archive, name defaults to batch) / summary (dashboard) / hook-develop-guide (CCC extension guide)"
 			},
 			name: {
 				type: "string",
-				description: "show/use/close/archive/qa 的会话标识（S### 或目录名或关键词）"
+				description: "show/use/close/archive/qa session identifier (S### or dir name or keyword)"
 			},
 			desc: {
 				type: "string",
-				description: "create 的短描述（任意语言，≤5 词；与 issue 互斥）"
+				description: "create short description (any language, ≤5 words; mutually exclusive with issue)"
 			},
 			issue: {
 				type: "string",
-				description: "create 的工单号（如 apaas-26116；目录命名 YYYY-MM-DD--<issue>；与 desc 互斥）"
+				description: "create ticket number (e.g. apaas-26116; dir named YYYY-MM-DD--<issue>; mutually exclusive with desc)"
 			},
 			goal: {
 				type: "string",
-				description: "create 的一句话目标（可选）"
+				description: "create one-sentence goal (optional)"
 			},
 			confirm: {
 				type: "boolean",
-				description: "close 必须为 true（防误关）"
+				description: "close must be true (prevents accidental close)"
 			},
 			dryRun: {
 				type: "boolean",
-				description: "create/archive 预览模式（不实际修改）"
+				description: "create/archive preview mode (no actual changes)"
 			}
 		},
 		output: {
@@ -5550,7 +5591,7 @@ function createSessionTool(ctx) {
 			switch (args.action) {
 				case "list": return listSessions(root) + extHint;
 				case "show":
-					if (!args.name) throw new Error("show 需要 name（S### 或目录名）");
+					if (!args.name) throw new Error("show requires name (S### or directory name)");
 					return showSession(root, args.name) + extHint;
 				case "create": {
 					const result = createSession({
@@ -5575,25 +5616,31 @@ function createSessionTool(ctx) {
 					return message + extHint;
 				}
 				case "use": {
-					if (!args.name) throw new Error("use 需要 name（S### 或目录名）");
-					const scope = agentScope$3(exec);
+					if (!args.name) throw new Error("use requires name (S### or directory name)");
+					const scope = agentScope$2(exec);
 					const active = useSession(root, args.name, scope);
 					try {
 						const info = getActiveSessionInfo(scope);
 						if (info) {
 							const rename = (ctx.get?.("sessionTitle"))?.rename;
 							const dshSession = exec.agent?.session;
-							if (dshSession && typeof rename === "function") renameDshSessionOnUse({
-								namingEnabled: readSimpleSettings().namingEnabled,
-								sessionTitleAvailable: true
-							}, dshSession, rename, info);
+							if (dshSession && typeof rename === "function") {
+								const result = renameDshSessionOnUse({
+									namingEnabled: readSimpleSettings().namingEnabled,
+									sessionTitleAvailable: true
+								}, dshSession, rename, info);
+								if (result.ok) console.log(`[serenity-hooks] dsh 会话已重命名: ${String(dshSession.id ?? "?")} → ${result.title}`);
+								else console.warn(`[serenity-hooks] dsh 会话重命名未执行: ${result.reason}`);
+							} else console.warn(`[serenity-hooks] dsh 会话重命名未执行: sessionTitle 服务不可用或缺少 agent session`);
 						}
-					} catch {}
+					} catch (err) {
+						console.warn(`[serenity-hooks] dsh 会话重命名异常: ${String(err?.message ?? err)}`);
+					}
 					return active;
 				}
 				case "close":
-					if (!args.name) throw new Error("close 需要 name（S### 或目录名）");
-					return closeSession(root, args.name, args.confirm ?? false, agentScope$3(exec));
+					if (!args.name) throw new Error("close requires name (S### or directory name)");
+					return closeSession(root, args.name, args.confirm ?? false, agentScope$2(exec));
 				case "archive": return archiveSessions(root, {
 					name: args.name,
 					dryRun: args.dryRun ?? false
@@ -5601,254 +5648,14 @@ function createSessionTool(ctx) {
 				case "health": return healthCheck(root) + extHint;
 				case "summary": return summarize(root) + extHint;
 				case "qa":
-					if (!args.name) throw new Error("qa 需要 name（S### 或目录名）");
+					if (!args.name) throw new Error("qa requires name (S### or directory name)");
 					return qaCheck(root, args.name) + extHint;
-				default: throw new Error(`未知 action: ${args.action}`);
-			}
-		}
-	});
-}
-//#endregion
-//#region src/rebuild.ts
-/** 归档目录名（与 session-ops ARCHIVE_DIR_NAME 一致） */
-const ARCHIVE_DIR = "_archived";
-/**
-* 归档旧会话：SESSION.md 标记 completed + 目录移 _archived/（立即，跳过 grace）。
-* 纯逻辑（可单测）；找不到会话/无 SESSION.md 抛错。
-* @returns 归档后的新路径（或 null = 会话已归档/不存在）
-*/
-function archiveSessionNow(root, key) {
-	const sessionsDir = sessionsRoot(root);
-	const archiveDir = join(sessionsDir, ARCHIVE_DIR);
-	let target = null;
-	try {
-		const entries = readDirSafe(sessionsDir);
-		for (const name of entries) {
-			if (!name.includes("--S") && name !== key) continue;
-			if (name === key || name.endsWith(`--${key}`) || name.includes(`--${key}--`)) {
-				target = join(sessionsDir, name);
-				break;
-			}
-		}
-	} catch {
-		return null;
-	}
-	if (target === null) for (const name of readDirSafe(sessionsDir)) {
-		const m = name.match(/--S(\d{3,})--/);
-		if (m && `S${m[1]}` === key) {
-			target = join(sessionsDir, name);
-			break;
-		}
-	}
-	if (target === null) return null;
-	const mdPath = join(target, "SESSION.md");
-	if (existsSync(mdPath)) {
-		let content = readFileSync(mdPath, "utf-8").replace(/\r\n/g, "\n");
-		content = content.replace(/## 状态\n\n?- \[ \] 进行中/, "## 状态\n- [x] 已完成\n- [x] 已关闭（session_rebuild 归档）");
-		const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-		if (!content.includes("-- 关闭")) content = content.replace(/(## 进度记录\n)/, `$1- ${now} — 关闭（session_rebuild 归档）\n`);
-		writeFileSync(mdPath, content, "utf-8");
-	}
-	if (!existsSync(archiveDir)) mkdirSync(archiveDir, { recursive: true });
-	const dest = join(archiveDir, target.split(/[\\/]/).pop());
-	renameSync(target, dest);
-	return dest;
-}
-function readDirSafe(dir) {
-	try {
-		return readdirSync(dir);
-	} catch {
-		return [];
-	}
-}
-/** 新会话锚点消息（重建指令 + SESSION.md 路径 + 摘要） */
-function buildRebuildAnchor(root, oldDirName, note) {
-	const mdPath = join(root, "AGENT_SESSIONS", oldDirName, "SESSION.md");
-	const lines = [
-		"[SESSION-REBUILD] 上下文已清空重建（Ship of Theseus：会话归档，身份延续）。",
-		`- 旧会话（已归档）：AGENT_SESSIONS/_archived/${oldDirName}`,
-		`- 完整上下文：${mdPath}`,
-		`- 请先读取旧会话的 SESSION.md（目标/决策/进度/未解决问题），从上次进度继续。`
-	];
-	if (note) lines.push(`- 重建背景：${note}`);
-	return lines.join("\n");
-}
-/**
-* 执行 session_rebuild（服务端逻辑）：
-* ① 归档当前宁静号会话（LLM 经 session use 激活的那个）
-* ② 创建新宁静号 SESSION 目录（createSession）+ dsh agent 会话（ctx.agents.create）
-* ③ 返回锚点文本（调用方负责注入到新 agent）
-* @returns rebuild 结果；rebuild.enabled=false 或非 CCC 抛错
-*/
-async function executeRebuild(ctx, opts) {
-	if (!readSimpleSettings().rebuildEnabled) throw new Error("session_rebuild 已禁用（rebuild.enabled=false，可在 dsh 设置面板开启）");
-	const { root, activeDirName, note } = opts;
-	let old = null;
-	if (activeDirName) old = {
-		dirName: activeDirName,
-		archivedTo: archiveSessionNow(root, activeDirName)
-	};
-	const created = createSession({
-		root,
-		desc: "rebuild",
-		goal: "上下文超限清空重建（session_rebuild）",
-		dryRun: false
-	});
-	const parentSession = opts.parentSessionId;
-	const sessionId = `rebuild-${randomUUID()}`;
-	let newSession = {
-		sessionId: String(sessionId),
-		dirName: created.dirName
-	};
-	if (ctx.agents) try {
-		const handle = await ctx.agents.create({
-			sessionId,
-			meta: {
-				cwd: opts.agentCwd,
-				origin: "subagent",
-				...parentSession ? { parentSession } : {}
-			},
-			agentOptions: void 0
-		});
-		newSession = {
-			sessionId: String(sessionId),
-			dirName: created.dirName
-		};
-		const anchor = buildRebuildAnchor(root, created.dirName, note);
-		handle.agent.inject({
-			content: [{
-				type: "text",
-				text: anchor
-			}],
-			source: {
-				kind: "plugin",
-				plugin: "dsh-serenity-hooks"
+				default: throw new Error(`Unknown action: ${args.action}`);
 			}
-		});
-	} catch {}
-	return {
-		oldSession: old,
-		newSession,
-		anchor: buildRebuildAnchor(root, created.dirName, note)
-	};
-}
-//#endregion
-//#region src/tools/rebuild.ts
-/**
-* rebuild.ts — session_rebuild 工具定义（F2，v1.21）
-*
-* LLM 主动触发清空重建（用户决策：keeper 超阈值提示，不自动执行——防误清空）。
-* 执行：归档当前会话 → 创建新会话（宁静号 SESSION 目录 + dsh agent）→ 锚点注入。
-* 服务端逻辑在 ../rebuild.ts（executeRebuild，可单测）。
-*/
-function agentCwd$2(exec) {
-	return exec.agent?.session?.header?.cwd ?? process.cwd();
-}
-function agentScope$2(exec) {
-	return exec.agent?.session?.id ?? "default";
-}
-function renderText$1(value) {
-	return [{
-		type: "text",
-		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
-	}];
-}
-/** 创建 session_rebuild 工具（闭包捕获 ctx → ctx.agents.create 新会话） */
-function createRebuildTool(ctx) {
-	return defineTool({
-		name: "session_rebuild",
-		description: "上下文超限清空重建（Ship of Theseus）：归档当前宁静号会话（SESSION.md 标记 completed + 移 _archived/），创建新会话并注入重建锚点（SESSION.md 路径 + 摘要 + 重建指令）。用途：SESSION-KEEPER 提示上下文接近上限时，在任务自然停顿点主动调用。触发后请先读取旧会话 SESSION.md 从上次进度继续。",
-		parameters: { note: {
-			type: "string",
-			description: "可选：给新会话的一句话背景（重建后 LLM 的起始上下文）"
-		} },
-		output: {
-			schema: { type: "json" },
-			render: (args, value) => renderText$1(value)
-		},
-		async execute(args, exec) {
-			const root = findSerenityRoot(agentCwd$2(exec));
-			if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
-			const active = getActiveSessionInfo(agentScope$2(exec));
-			const parentSessionId = (exec.agent?.session)?.id;
-			const result = await executeRebuild(ctx, {
-				root,
-				activeDirName: active?.dirName ?? null,
-				note: args.note,
-				agentCwd: agentCwd$2(exec),
-				parentSessionId
-			});
-			return {
-				ok: true,
-				oldSession: result.oldSession,
-				newSession: result.newSession,
-				anchor: result.anchor,
-				instruction: "已归档旧会话并创建新会话。新会话将自动获得重建锚点；请在新会话中继续工作（可用 session use 激活它）。"
-			};
 		}
 	});
 }
 //#endregion
-//#region src/tools/localstore.ts
-/**
-* localstore.ts — localstore 真实 DSH 工具定义（defineTool）
-*
-* ACC 标准本地凭据/配置存储（S133 设计，S134 重设计：CCC 根 localstore.json）。
-* 进程内注册，零 DSH 依赖逻辑在 localstore-ops.ts（可单测）。
-* doc 子命令输出存储规范，agent 可直接用 fs 工具（read/write）自己读写。
-*/
-const ACTIONS = [
-	"list",
-	"get",
-	"set",
-	"unset",
-	"show",
-	"doc"
-];
-function agentCwd$1(exec) {
-	return exec.agent?.session?.header?.cwd ?? process.cwd();
-}
-function renderText(value) {
-	return [{
-		type: "text",
-		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
-	}];
-}
-const localstoreTool = defineTool({
-	name: "localstore",
-	description: "ACC 标准本地凭据/配置存储：一个工具管理两个命名空间 credential（凭据）与 config（本地偏好）。存储于 CCC 根根目录 localstore.json（JSON 格式，MSM 可直接读取）。git 策略：.opencode/serenity.json localstore.gitTrack（allow 可提交 / deny 禁提交，缺省 deny；.dsh 回退）——deny 时写入自动确保 .gitignore 含该文件（物理保证），cc_git commit 会检查拒绝。子命令：list（列 key，凭据不返回值）/ get <name>（读值）/ set <name> <value>（写）/ unset <name>（删）/ show <name>（元数据，凭据不打印值）/ doc（输出存储规范——路径/格式/key 规范/git 策略，agent 可按说明直接用 read/write 操作文件）。默认 scope=credential；config 需传 --scope config（路径为 section.key，如 loop.defaultModel）。",
-	parameters: {
-		action: {
-			type: "string",
-			enum: [...ACTIONS],
-			required: true,
-			description: "子命令：list/get/set/unset/show/doc"
-		},
-		name: {
-			type: "string",
-			description: "条目名（credential 用大写蛇形；config 用 section.key）"
-		},
-		value: {
-			type: "string",
-			description: "set 的值"
-		},
-		scope: {
-			type: "string",
-			enum: [...LOCALSTORE_SCOPES],
-			description: "命名空间 credential|config（默认 credential）"
-		}
-	},
-	output: {
-		schema: { type: "json" },
-		render: (args, value) => renderText(value)
-	},
-	async execute(args, exec) {
-		const root = findSerenityRoot(agentCwd$1(exec));
-		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
-		return runLocalStore(root, args);
-	}
-});
-//#endregion
 //#region src/seams/bootstrap.ts
 /** 默认首请求工具集：dsp 平台 Minimal 等价核心（anchored 是 bash+str_replace_editor） */
 const DEFAULT_BOOTSTRAP_TOOLS = [
@@ -6147,83 +5954,337 @@ function registerBootstrap(ctx) {
 	}, { prepend: true });
 }
 //#endregion
-//#region src/seams/keeper.ts
-const SCORES = {
-	write: 3,
-	edit: 3,
-	str_replace_editor: 3,
-	task: 10,
-	read: 1,
-	grep: 1,
-	glob: 1,
-	skill: 1,
-	acc_msm: 1,
-	cc_fs: 1
-};
-function scoreTool(toolName) {
-	return SCORES[toolName] ?? 0;
-}
-var KeeperTracker = class {
-	threshold;
-	now;
-	score = 0;
-	lastTs = 0;
-	counter = 0;
-	constructor(threshold, now = Date.now) {
-		this.threshold = threshold;
-		this.now = now;
-	}
-	/** 记录一次工具调用 + 经过时间；返回是否应触发提醒 */
-	step(toolName) {
-		const now = this.now();
-		if (this.lastTs > 0) this.score += Math.floor((now - this.lastTs) / 6e4);
-		this.lastTs = now;
-		this.score += scoreTool(toolName);
-		return this.score >= this.threshold;
-	}
-	/** 生成确认码并清零积分 */
-	ack() {
-		this.counter += 1;
-		this.score = 0;
-		this.lastTs = 0;
-		return `K${this.counter}`;
-	}
-	get currentScore() {
-		return this.score;
-	}
+//#region src/rebuild.ts
+const PLUGIN_SOURCE$2 = {
+	kind: "plugin",
+	plugin: "dsh-serenity-hooks"
 };
-function reminderText(code, score) {
-	return `[SESSION-KEEPER] Score threshold reached (${score}). Please acknowledge with [SESSION-KEEPER-recorded-${code}] once progress is synced to the working session (acc-session show). No need to interrupt your work — just acknowledge inline and keep going.`;
+/** acknowledge 尾句（first-anchor 的确认要求——rebuild 重建后不重走确认轮，直接继续） */
+const ACK_SUFFIX_RE = /Please simply reply "acknowledge" — no action needed\.\s*$/;
+/**
+* 剥离 first-anchor 消息的 acknowledge 尾句（rebuild 锚点保留协议正文但不要求确认回复）。
+*/
+function stripAckSuffix(text) {
+	return text.replace(ACK_SUFFIX_RE, "").trimEnd();
 }
-/** F2 rebuild 提示（v1.21）：上下文接近上限时引导 LLM 主动触发 session_rebuild */
-function rebuildReminderText(ratio) {
-	return `[SESSION-REBUILD] 上下文占用已达 ${(ratio * 100).toFixed(0)}%（接近上限）。SESSION.md 已实时整理，无需压缩——如需清空重建，可在适当时机调用 session_rebuild（将归档当前会话并开启新会话，身份自动延续）。`;
+/**
+* 构建重建锚点消息（v1.22.4 定稿语义 + v1.22.5 保留 first-anchor 正文）：
+* 「[TRAJECTORY-REBUILD] + first-anchor 协议正文（去 acknowledge 尾句）+ 继续 {SESSION 名} 的工作」。
+* @param root - CCC 根
+* @param sessionName - 当前 use 的宁静号 SESSION 名（如 S142）；无激活则通用指令
+* @param activeMdPath - 持久轨迹 SESSION.md 绝对路径（保持原位）
+* @param anchorMessages - first-anchor 协议消息序列（缺省 DEFAULT_ANCHOR_MESSAGES；可注入测试）
+*/
+function buildRebuildAnchor(root, sessionName, activeMdPath, anchorMessages = DEFAULT_ANCHOR_MESSAGES) {
+	const rel = activeMdPath.startsWith(root) ? activeMdPath.slice(root.length + 1) : activeMdPath;
+	return [
+		"[TRAJECTORY-REBUILD] The conversation has been cleared and rebuilt (Ship of Theseus: the carrier is replaced, the trajectory continues).",
+		"",
+		...anchorMessages.flatMap((text) => [stripAckSuffix(text), ""]),
+		sessionName !== "" ? `Continue the work of ${sessionName}.` : "Continue the current work.",
+		`- Persistent trajectory (SESSION.md, unmoved): ${rel}`,
+		`- Read that SESSION.md first (goal/decisions/progress/unresolved), then continue from the last checkpoint.`
+	].join("\n");
 }
-/** 读取会话 contextPressure 投影（sessionProjections 可选服务；未装配返回 null） */
-function readContextPressure(ctx, session) {
+const pendingRebuilds = /* @__PURE__ */ new Map();
+/** 陈旧队列存活时长（毫秒）：超过则丢弃（turn 异常结束/agent 崩溃时防残留误清空） */
+const PENDING_TTL_MS = 6e5;
+/**
+* 排队一次重建（v1.22.4 定稿语义第一步）：
+* ① 门控校验（rebuild.enabled + 会话定位）
+* ② 构建锚点（激活会话名 + 持久轨迹路径）
+* ③ 写入 pending 队列——**不立即改 surface**（等 turn-stopping 执行）
+* @returns 排队结果；rebuild.enabled=false 或非 CCC 抛错
+*/
+async function queueRebuild(ctx, opts) {
+	if (!readSimpleSettings().rebuildEnabled) throw new Error("session_rebuild is disabled (rebuild.enabled=false — enable it in the dsh settings panel)");
+	const { root, note, dshSessionId } = opts;
+	if (!ctx.sessions?.get?.(dshSessionId)) throw new Error(`Unable to locate dsh session ${dshSessionId} (session may be closed)`);
+	const scope = dshSessionId;
+	let sessionMdPath = null;
+	let sessionName = "";
 	try {
-		const projections = ctx.get?.("sessionProjections");
-		if (!projections) return null;
-		const pressure = (projections.snapshot?.(session))?.values?.contextPressure;
-		if (!pressure || typeof pressure.projectedTokens !== "number") return null;
-		return {
-			projectedTokens: pressure.projectedTokens,
-			contextWindow: pressure.contextWindow
-		};
-	} catch {
-		return null;
-	}
+		const active = getActiveSessionInfo(scope);
+		if (active?.mdPath) {
+			sessionMdPath = active.mdPath;
+			sessionName = active.sessionId ?? "";
+		}
+	} catch {}
+	const mdPath = sessionMdPath ?? join(root, "AGENT_SESSIONS", "SESSION.md");
+	const anchor = buildRebuildAnchor(root, sessionName, mdPath);
+	pendingRebuilds.set(dshSessionId, {
+		anchor,
+		queuedAt: Date.now()
+	});
+	return {
+		queued: true,
+		anchor,
+		sessionMdPath
+	};
 }
-const PLUGIN_SOURCE$1 = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
-/** 每 agent 一个跟踪器（进程内存态，agent token 维度） */
-const trackers = /* @__PURE__ */ new Map();
-function registerKeeper(ctx, opts = {}) {
-	const defaultThreshold = opts.defaultThreshold ?? 150;
-	const trackerFor = (exec) => {
-		const key = exec.agent?.session?.id ?? "global";
+/**
+* 执行真正的 surface replace（v1.22.4 定稿语义第二步，turn-stopping 时调用）：
+* 当前 turn 已完整结束（所有 tool/result 已 append）→ 全部节点替换为锚点消息。
+* 同一会话 id 原地重建——同工作区天然满足，无新/旧会话之分。
+* @returns 是否执行了 replace（false = 无 pending 或 surface 空）
+*/
+function performRebuild(session, pending) {
+	const nodes = [...session.surface.nodes];
+	if (nodes.length === 0) return false;
+	session.append("user/message", {
+		content: [{
+			type: "text",
+			text: pending.anchor
+		}],
+		source: { kind: "user" }
+	}, {
+		surfaceOp: {
+			op: "replace",
+			start: nodes[0],
+			end: nodes[nodes.length - 1]
+		},
+		sourceEventSeqs: nodes
+	});
+	return true;
+}
+/**
+* 注册 turn-stopping 钩子（index.ts apply 调用）：
+* agent 每轮 turn 结束前（serial）检查 pending 队列——有该会话的重建请求 → 执行清空
+* 并 **steer 自动继续**（v1.22.5：next-step 非空 → turn 不 break → 模型自动读取
+* SESSION.md 继续，无需用户手工输入；DSH 官方先例 hooks-claude-code Stop hook）。
+* 陈旧队列（超 TTL）丢弃防误清空；无 pending 零开销。
+*/
+function registerRebuildTurnHook(ctx) {
+	ctx.on("agent/turn-stopping", (payload) => {
+		const agent = payload?.agent;
+		if (!agent) return;
+		const id = agent.id;
+		const pending = pendingRebuilds.get(id);
+		if (pending === void 0) return;
+		if (Date.now() - pending.queuedAt > PENDING_TTL_MS) {
+			pendingRebuilds.delete(id);
+			return;
+		}
+		pendingRebuilds.delete(id);
+		try {
+			if (performRebuild(agent.session, pending)) {
+				agent.steer(createUserMessage({
+					content: [{
+						type: "text",
+						text: "[TRAJECTORY-REBUILD] The conversation has been cleared and rebuilt. Follow the anchor instructions above now: read the persistent trajectory (SESSION.md) and continue the work automatically from the last checkpoint."
+					}],
+					source: PLUGIN_SOURCE$2
+				}));
+				console.log(`[serenity-hooks] session_rebuild executed with auto-continue (turn ${payload.turn ?? "?"} ended): ${id}`);
+			}
+		} catch (error) {
+			console.warn(`[serenity-hooks] session_rebuild failed: ${String(error?.message ?? error)}`);
+		}
+	});
+}
+//#endregion
+//#region src/tools/rebuild.ts
+/**
+* rebuild.ts — session_rebuild 工具定义（轨迹跟踪器，v1.22.4 定稿：复用旧会话 + 完全清空重来）
+*
+* LLM 主动触发清空重建（用户决策：keeper 超阈值提示 [TRAJECTORY]，不自动执行——防误清空）。
+* v1.22.4 定稿语义（用户明确）：**复用当前 dsh 会话（同一 id），turn 结束时 surface
+* 完全清空重建**——锚点消息「继续 {宁静号 SESSION 名} 的工作」；SESSION.md 是持久轨迹
+* 永远原位，身份从 SESSION.md 自动延续。同一会话 id → 同工作区天然满足、无新/旧会话
+* 之分、无需销毁/切换/归档。
+* v1.22.5 增强（S142 用户需求）：① turn-stopping 执行 replace 后 **steer 自动继续**
+* （无需用户手工输入，模型自动读 SESSION.md 接续）；② 锚点消息**保留 first-anchor
+* 协议正文**（ACC 身份/EAP/协作协议，去 acknowledge 尾句——重建后直接干活）。
+* 执行时机：工具只排队（queueRebuild），`agent/turn-stopping` 钩子执行真正 replace
+* （turn 结束前所有 tool/result 已 append → 无孤儿；S141 INVALID_REQUEST 根治）。
+* 服务端逻辑在 ../rebuild.ts（queueRebuild/performRebuild/registerRebuildTurnHook）。
+*/
+function agentCwd$2(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function agentSessionId(exec) {
+	return exec.agent?.session?.id ?? "";
+}
+function renderText$1(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+/** 创建 session_rebuild 工具（闭包捕获 ctx → 排队清空重建，turn 结束时同一会话原地重来并自动继续） */
+function createRebuildTool(ctx) {
+	return defineTool({
+		name: "session_rebuild",
+		description: "Trajectory-tracker overflow rebuild (Ship of Theseus): this session is the rebuildable carrier of a trajectory — the current conversation is discarded and rebuilt in place at the end of this turn with the anchor \"continue the work of {SESSION name}\" (first-anchor protocol body included), then auto-continues. SESSION.md (the trajectory's persistent body) stays in place; identity continues from it. Use when you receive a [TRAJECTORY] reminder (context above threshold), at a natural pause point. After triggering, resume from SESSION.md when this turn ends.",
+		parameters: { note: {
+			type: "string",
+			description: "Optional: one-sentence rebuild background note (for the rebuilt self)"
+		} },
+		output: {
+			schema: { type: "json" },
+			render: (args, value) => renderText$1(value)
+		},
+		async execute(args, exec) {
+			const root = findSerenityRoot(agentCwd$2(exec));
+			if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+			const dshSessionId = agentSessionId(exec);
+			if (!dshSessionId) throw new Error("Unable to determine the current dsh session id");
+			const result = await queueRebuild(ctx, {
+				root,
+				note: args.note,
+				agentCwd: agentCwd$2(exec),
+				dshSessionId
+			});
+			return {
+				ok: true,
+				queued: result.queued,
+				anchor: result.anchor,
+				sessionMdPath: result.sessionMdPath,
+				instruction: "Queued clear-and-rebuild: when this turn ends, the same conversation will be cleared and injected with the \"continue the work\" anchor (first-anchor protocol body included), then auto-continue — no manual input needed; resume from SESSION.md at that point."
+			};
+		}
+	});
+}
+//#endregion
+//#region src/tools/localstore.ts
+/**
+* localstore.ts — localstore 真实 DSH 工具定义（defineTool）
+*
+* ACC 标准本地凭据/配置存储（S133 设计，S134 重设计：CCC 根 localstore.json）。
+* 进程内注册，零 DSH 依赖逻辑在 localstore-ops.ts（可单测）。
+* doc 子命令输出存储规范，agent 可直接用 fs 工具（read/write）自己读写。
+*/
+const ACTIONS = [
+	"list",
+	"get",
+	"set",
+	"unset",
+	"show",
+	"doc"
+];
+function agentCwd$1(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function renderText(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const localstoreTool = defineTool({
+	name: "localstore",
+	description: "ACC standard local credential/config storage: one tool manages two namespaces — credential (credentials) and config (local preferences). Stored in localstore.json at the CCC root (JSON format, directly readable by MSMs). Git policy: .opencode/serenity.json localstore.gitTrack (allow commits / deny commits, default deny; .dsh fallback) — when deny, writes ensure .gitignore contains this file (physical guarantee), cc_git commit checks and refuses. Subcommands: list (list keys, credentials never return values) / get <name> (read value) / set <name> <value> (write) / unset <name> (delete) / show <name> (metadata, credentials never print values) / doc (output the storage spec — path/format/key conventions/git policy; agents may operate the file directly with read/write per the spec). Default scope=credential; config requires --scope config (path is section.key, e.g. loop.defaultModel).",
+	parameters: {
+		action: {
+			type: "string",
+			enum: [...ACTIONS],
+			required: true,
+			description: "Subcommand: list/get/set/unset/show/doc"
+		},
+		name: {
+			type: "string",
+			description: "Entry name (credentials: UPPER_SNAKE; config: section.key)"
+		},
+		value: {
+			type: "string",
+			description: "set value"
+		},
+		scope: {
+			type: "string",
+			enum: [...LOCALSTORE_SCOPES],
+			description: "Namespace credential|config (default credential)"
+		}
+	},
+	output: {
+		schema: { type: "json" },
+		render: (args, value) => renderText(value)
+	},
+	async execute(args, exec) {
+		const root = findSerenityRoot(agentCwd$1(exec));
+		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+		return runLocalStore(root, args);
+	}
+});
+//#endregion
+//#region src/seams/keeper.ts
+const SCORES = {
+	write: 3,
+	edit: 3,
+	str_replace_editor: 3,
+	task: 10,
+	read: 1,
+	grep: 1,
+	glob: 1,
+	skill: 1,
+	acc_msm: 1,
+	cc_fs: 1
+};
+function scoreTool(toolName) {
+	return SCORES[toolName] ?? 0;
+}
+var KeeperTracker = class {
+	threshold;
+	now;
+	score = 0;
+	lastTs = 0;
+	counter = 0;
+	constructor(threshold, now = Date.now) {
+		this.threshold = threshold;
+		this.now = now;
+	}
+	/** 记录一次工具调用 + 经过时间；返回是否应触发提醒 */
+	step(toolName) {
+		const now = this.now();
+		if (this.lastTs > 0) this.score += Math.floor((now - this.lastTs) / 6e4);
+		this.lastTs = now;
+		this.score += scoreTool(toolName);
+		return this.score >= this.threshold;
+	}
+	/** 生成确认码并清零积分 */
+	ack() {
+		this.counter += 1;
+		this.score = 0;
+		this.lastTs = 0;
+		return `K${this.counter}`;
+	}
+	get currentScore() {
+		return this.score;
+	}
+};
+function reminderText(code, score) {
+	return `[TRAJECTORY-STEWARD] Score threshold reached (${score}). Please acknowledge with [TRAJECTORY-STEWARD-recorded-${code}] once progress is synced to the working session (acc-session show). No need to interrupt your work — just acknowledge inline and keep going.`;
+}
+/** F2 rebuild 提示（v1.21；v1.22.1 对齐"轨迹跟踪器"概念；v1.23.0 英化 + 载体关系）：
+* SESSION.md = trajectory 持久身体，自身会话 = 可重建载体（工作副本）。
+* 上下文接近上限时引导 LLM 主动触发 session_rebuild。 */
+function rebuildReminderText(ratio) {
+	return `[TRAJECTORY] Context usage at ${(ratio * 100).toFixed(0)}% (trajectory-tracker threshold). This session is the rebuildable carrier of the trajectory: SESSION.md is the persistent body, this conversation is only a temporary work copy — no compaction needed. Call session_rebuild at a natural pause to rebuild the carrier (this copy is discarded; identity continues from SESSION.md).`;
+}
+/** 读取会话 contextPressure 投影（sessionProjections 可选服务；未装配返回 null） */
+function readContextPressure(ctx, session) {
+	try {
+		const projections = ctx.get?.("sessionProjections");
+		if (!projections) return null;
+		const pressure = (projections.snapshot?.(session))?.values?.contextPressure;
+		if (!pressure || typeof pressure.projectedTokens !== "number") return null;
+		return {
+			projectedTokens: pressure.projectedTokens,
+			contextWindow: pressure.contextWindow
+		};
+	} catch {
+		return null;
+	}
+}
+const PLUGIN_SOURCE$1 = {
+	kind: "plugin",
+	plugin: "dsh-serenity-hooks"
+};
+/** 每 agent 一个跟踪器（进程内存态，agent token 维度） */
+const trackers = /* @__PURE__ */ new Map();
+function registerKeeper(ctx, opts = {}) {
+	const defaultThreshold = opts.defaultThreshold ?? 150;
+	const trackerFor = (exec) => {
+		const key = exec.agent?.session?.id ?? "global";
 		let t = trackers.get(key);
 		if (!t) {
 			const root = findSerenityRoot(exec.agent?.session?.header?.cwd ?? process.cwd());
@@ -6238,32 +6299,30 @@ function registerKeeper(ctx, opts = {}) {
 		const tracker = trackerFor(exec);
 		const shouldRemind = tracker.step(exec.name);
 		const downstream = await next();
-		if (!shouldRemind) return downstream;
-		const content = [{
-			type: "text",
-			text: reminderText(tracker.ack(), tracker.currentScore)
-		}];
-		createUserMessage({
-			content,
-			source: PLUGIN_SOURCE$1
-		});
-		const extra = [];
+		const blocks = [];
+		if (shouldRemind) {
+			const code = tracker.ack();
+			blocks.push({
+				type: "text",
+				text: reminderText(code, tracker.currentScore)
+			});
+		}
 		if (readSimpleSettings().rebuildEnabled) {
 			const session = exec.agent?.session;
 			if (session) {
 				const pressure = readContextPressure(ctx, session);
 				if (pressure && pressure.contextWindow && pressure.contextWindow > 0) {
 					const ratio = pressure.projectedTokens / pressure.contextWindow;
-					if (ratio >= readSimpleSettings().rebuildThreshold) extra.push({
+					if (ratio >= readSimpleSettings().rebuildThreshold) blocks.push({
 						type: "text",
 						text: rebuildReminderText(ratio)
 					});
 				}
 			}
 		}
-		const allBlocks = extra.length > 0 ? [...content, ...extra] : content;
+		if (blocks.length === 0) return downstream;
 		const reminderAll = createUserMessage({
-			content: allBlocks,
+			content: blocks,
 			source: PLUGIN_SOURCE$1
 		});
 		if (downstream.kind === "block") return {
@@ -6348,7 +6407,7 @@ function findEntrySkills(root) {
 }
 function truncateContent(content, maxChars) {
 	if (content.length <= maxChars) return content;
-	return content.slice(0, maxChars) + `\n...（已截断，原长 ${content.length} 字符）`;
+	return content.slice(0, maxChars) + `\n... (truncated, original length ${content.length} chars)`;
 }
 //#endregion
 //#region src/seams/system-prompt.ts
@@ -6357,7 +6416,7 @@ const HIDDEN_LINES = /安全模式|safe-mode|\.serenity-safe-on/g;
 function sanitizeSkillContent(content) {
 	return content.split("\n").filter((line) => !HIDDEN_LINES.test(line)).join("\n");
 }
-/** 1) ACC 块：身份 + CCC 名/Root + 内置工具清单（工具名换本插件真实 9 工具） */
+/** 1) ACC 块：身份 + CCC 名/Root + 内置工具清单（工具名换本插件真实 11 工具） */
 function accBlock(root) {
 	const cccName = basename(root);
 	return [
@@ -6370,18 +6429,19 @@ function accBlock(root) {
 		"the runtime instance of an Abstract Cognitive Container (ACC).",
 		"The ACC (this plugin) provides the following built-in tools:",
 		"",
-		"  cc_fs    — CCC 内文件系统操作（root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find）",
-		"  session  — session lifecycle（list/show/create/health/qa/archive/summary）",
-		"  acc_kit  — ACC utility kit（health: CCC three principles / time: now / wait: wait N seconds）",
-		"  cc_git   — git operations（status/commit/push/log）",
-		"  acc_msm  — MSM framework（list/exec/register/deregister/check/guide）",
-		"  eap      — return the full EAP cognitive quality framework",
-		"  neat     — return the full Neat design collaboration protocol",
-		"  cce      — return the full Cognitive Continuity Engineering framework",
-		"  loop     — 牛马循环：指定模型专用 agent 反复执行",
-		"  localstore — ACC 本地凭据/配置存储（CCC 根 localstore.json，JSON 格式；git 策略 localstore.gitTrack 缺省 deny）；doc 子命令输出规范",
+		"  cc_fs     — CCC filesystem operations (root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find)",
+		"  session   — session lifecycle (list/show/create/health/qa/archive/summary)",
+		"  acc_kit   — ACC utility kit (health: CCC three principles / time: now / wait: wait N seconds)",
+		"  cc_git    — git operations (status/commit/push/log)",
+		"  acc_msm   — MSM framework (list/exec/register/deregister/check/guide)",
+		"  eap       — return the full EAP cognitive quality framework",
+		"  neat      — return the full Neat design collaboration protocol",
+		"  cce       — return the full Cognitive Continuity Engineering framework",
+		"  loop      — run a dedicated model-specific agent in repeated rounds toward a goal",
+		"  session_rebuild — rebuild this conversation in place from SESSION.md when the trajectory-tracker trips",
+		"  localstore — ACC local credential/config storage (CCC-root localstore.json, JSON format; git policy localstore.gitTrack default deny); doc subcommand outputs the spec",
 		"",
-		"  ℹ️ CCC 内文件操作（read/write/edit/glob/grep 等）请使用相对 CCC 根的相对路径（如 AGENT_SESSIONS/2026-08-14--S134--x/SESSION.md）；Root / SESSION.md path 等绝对路径仅作标识，不作工具入参",
+		"  ℹ️ Use relative paths from the CCC root for CCC-internal file operations (read/write/edit/glob/grep etc.), e.g. AGENT_SESSIONS/2026-08-14--S134--x/SESSION.md; Root / absolute SESSION.md paths are identifiers only, not tool arguments",
 		"",
 		"The DSH platform tools remain available too (read/write/edit/glob/grep/web_search/ask_user_question/subagent/workflow/goal and more) — the ACC tools above are the serenity-native layer, not the only tools.",
 		"",
@@ -6454,6 +6514,12 @@ function principlesBlock(root) {
 		"fault to be hidden. Never disguise or excuse what you do not know;",
 		"not-knowing is a state to be repaired, and reporting it is the first repair.",
 		"",
+		"The session-trajectory relation: a session is the rebuildable carrier of a",
+		"trajectory. SESSION.md is the trajectory's persistent body — it never moves;",
+		"the current conversation is a temporary work copy that may be discarded and",
+		"rebuilt (session_rebuild). Identity belongs to the trajectory, not to any",
+		"session.",
+		"",
 		"MSM principles — machinery before improvisation:",
 		"- Determinism first: use a registered Mech before hand-rolling; reserve",
 		"  Semi-Mech for genuine judgment points.",
@@ -6479,10 +6545,15 @@ function eapBlock() {
 	return [
 		"",
 		"=== Serenity EAP ===",
-		"每次输出前自检（显式抽象原则：思维的价值 = 外部可重建性）:",
-		"  • E↑ 显式 — 变量/实体明确定义，关系指明方向/基数，边界划定；不用歧义词（\"处理\"\"优化\"→具体化）",
-		"  • R↓ 可重建 — 关键决策记录理由与备选，不跳级讨论（先对齐上层再进下层）",
-		"  • S↑ 稳定 — 结构可重复生成，避免依赖隐含上下文",
+		"Self-check before every output (Explicit Abstraction Principle: the functional",
+		"value of a thought equals its external reconstructability):",
+		"  • E↑ Explicit — variables/entities clearly defined, relationships with",
+		"    direction/cardinality, boundaries drawn; avoid ambiguous words (\"handle\",",
+		"    \"optimize\" → be specific)",
+		"  • R↓ Reconstructable — key decisions record rationale and alternatives;",
+		"    no level-skipping (align the upper layer before descending)",
+		"  • S↑ Stable — structures regenerate repeatably, no reliance on implicit",
+		"    context",
 		""
 	].join("\n");
 }
@@ -6538,9 +6609,11 @@ function metaphorBlock() {
 		"   ballast (constraints) before setting sail. Verdict: skipping the",
 		"   anchor and working directly = sailing uninspected.",
 		"",
-		"7. The Logbook → Session Tracking. SESSION.md is the only ship log.",
-		"   Unrecorded = unvoyaged. Verdict: finishing multi-step work without",
-		"   a progress record = a missing page.",
+		"7. The Logbook → Session Tracking. SESSION.md is the trajectory's logbook —",
+		"   the persistent body of the voyage; sessions are rebuildable carriers of",
+		"   the trajectory. Discard the carrier, keep the logbook. Unrecorded =",
+		"   unvoyaged. Verdict: finishing multi-step work without a progress record",
+		"   = a missing page.",
 		"",
 		"8. The Ship of Theseus → Continuity. Planks may be replaced; the ship",
 		"   remains the same. The container can be rebuilt; identity persists.",
@@ -6651,8 +6724,8 @@ function sessionBlock(root, scope = DEFAULT_SESSION_SCOPE) {
 	return [
 		"",
 		"=== Serenity Session ===",
-		`Active session: ${active.sessionId} — ${active.dirName}`,
-		`SESSION.md path: ${active.mdPath}`,
+		`Active session: ${active.sessionId} — ${active.dirName} (this session is the rebuildable carrier of the trajectory)`,
+		`SESSION.md path: ${active.mdPath} (the trajectory's persistent body — stays in place through rebuilds)`,
 		"",
 		"Rules:",
 		"  • Record all progress into this SESSION.md",
@@ -6669,6 +6742,15 @@ function sessionBlock(root, scope = DEFAULT_SESSION_SCOPE) {
 		"    status: \"completed\" }",
 		"This preserves the session context across todo updates.",
 		"Do NOT remove or reorder this item — keep it at position 0.",
+		"",
+		"TRAJECTORY-STEWARD: a background tracker scores your tool use (write/edit=3,",
+		"task=10, read/grep/glob/msm=1, +1 per minute) and reminds you with a",
+		"[TRAJECTORY-STEWARD] message when the threshold is reached. On every such",
+		"reminder you MUST reply with the exact ACK code:",
+		"  [TRAJECTORY-STEWARD-recorded-{code}]  — if you recorded progress to SESSION.md",
+		"  [TRAJECTORY-STEWARD-skipped-{code}]  — if nothing to record this round",
+		"Do not ignore the reminder; do not stop ongoing work. Codes are single-use;",
+		"never reuse a prior code.",
 		""
 	].join("\n");
 }
@@ -6713,9 +6795,9 @@ function codeModeAdaptationLine(ctx, scope) {
 	return [
 		"",
 		"=== Serenity Code Mode ===",
-		"当前会话以 Code Mode 呈现工具：模型直接调用 ACC 工具名（cc_fs/acc_msm 等）会被拒绝（UNKNOWN_TOOL）。",
-		"请在一个 run_code 程序内经生成的 SDK 绑定调用：`await tools.cc_fs(...)`、`await tools.acc_msm(...)` 等。",
-		"程序只返回你 print/return 的内容——务必 curate 输出。",
+		"This session renders tools in Code Mode: direct calls to ACC tool names (cc_fs/acc_msm etc.) are rejected (UNKNOWN_TOOL).",
+		"Call them inside a single run_code program via the generated SDK bindings: `await tools.cc_fs(...)`, `await tools.acc_msm(...)`.",
+		"The program only returns what you print/return — curate your output.",
 		""
 	].join("\n");
 }
@@ -6797,14 +6879,14 @@ function accIdentityText(root, configPaths = DEFAULT_SERENITY_CONFIG_PATHS, entr
 	const loop = loadSerenityConfig(root, configPaths).loop?.defaultModel;
 	const phase2 = existsSync(resolve(root, ".dsh", "PHASE2-PROMPT.md"));
 	const lines = [
-		`[ACC] 宁静号认知容器已激活（dsh-serenity-hooks v${ACC_VERSION}）`,
-		`- CCC 根：${root}`,
-		`- 约束：路径隔离（P3，fs 沙箱）+ 会话追踪（AGENT_SESSIONS/）`,
-		`- 知识：加载 acc-serenity 入口技能；设计协作走 acc-eap / acc-neat`
+		`[ACC] Serenity cognitive container active (dsh-serenity-hooks v${ACC_VERSION})`,
+		`- CCC root: ${root}`,
+		`- Constraints: path isolation (P3, fs sandbox) + session tracking (AGENT_SESSIONS/)`,
+		`- Knowledge: load the acc-serenity entry skill; use acc-eap / acc-neat for design collaboration`
 	];
-	if (loop) lines.push(`- loop 默认模型：${loop}`);
+	if (loop) lines.push(`- loop default model: ${loop}`);
 	if (phase2) {
-		lines.push("- ⚠️ **Phase 2 认知对齐访谈待完成**：请按下方 5 个 Topic 逐项访谈并沉淀答案到 AGENT_SESSIONS/ 会话");
+		lines.push("- ⚠️ **Phase 2 cognitive alignment interview pending**: work through the 5 Topics below and record answers in an AGENT_SESSIONS/ session");
 		try {
 			const prompt = readFileSync(resolve(root, ".dsh", "PHASE2-PROMPT.md"), "utf-8");
 			lines.push(truncateContent(prompt, Math.min(entrySkillMaxChars, 8e3)));
@@ -6938,16 +7020,65 @@ function registerCompactRetention(ctx, opts = {}) {
 		} catch {}
 	});
 }
+const B32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+/** base32（无填充，大小写不敏感）→ 字节；非法字符抛错。 */
+function base32Decode(input) {
+	const clean = input.toUpperCase().replace(/[\s=]/g, "");
+	if (clean.length === 0) throw new Error("empty base32");
+	const out = [];
+	let bits = 0;
+	let value = 0;
+	for (const ch of clean) {
+		const idx = B32_ALPHABET.indexOf(ch);
+		if (idx === -1) throw new Error(`invalid base32 char: ${ch}`);
+		value = value << 5 | idx;
+		bits += 5;
+		if (bits >= 8) {
+			out.push(value >>> bits - 8 & 255);
+			bits -= 8;
+		}
+	}
+	return Uint8Array.from(out);
+}
+/** 一个时步的 TOTP code（6 位，前导零保留）。counter = floor(epochSeconds / step) */
+function totpCode(secretBase32, counter) {
+	const key = base32Decode(secretBase32);
+	const msg = Buffer.alloc(8);
+	msg.writeBigUInt64BE(BigInt(counter));
+	const digest = createHmac("sha1", Buffer.from(key)).update(msg).digest();
+	const offset = digest[digest.length - 1] & 15;
+	const bin = (digest[offset] & 127) << 24 | digest[offset + 1] << 16 | digest[offset + 2] << 8 | digest[offset + 3];
+	return String(bin % 10 ** 6).padStart(6, "0");
+}
+/** 当前 epoch 秒 */
+function nowEpochSeconds() {
+	return Math.floor(Date.now() / 1e3);
+}
+/**
+* 校验用户输入的 code（允许 ±TOTP_WINDOW 时步漂移，防重放窗口内同 code 复用由
+* 调用方按账号记录最近成功 counter 实现——本函数只做纯算法校验）。
+* @returns 命中的 counter（用于防重放）；不匹配返回 null。
+*/
+function verifyTotpCode(secretBase32, code, nowSeconds = nowEpochSeconds()) {
+	if (!/^\d{6}$/.test(code)) return null;
+	const current = Math.floor(nowSeconds / 30);
+	for (let offset = -1; offset <= 1; offset++) if (totpCode(secretBase32, current + offset) === code) return current + offset;
+	return null;
+}
 //#endregion
 //#region src/config-ops.ts
 /**
-* config-ops.ts — 高级设定配置读写（结构化，localstore.json `serenityAdvanced` 节）
+* config-ops.ts — plugin 全局配置读写（结构化，`~/.dsh/serenity-hooks.json`）
 *
-* 与 localstore-ops 的扁平 config 节（section.key → string）不同，高级设定需要
-* 结构化对象（嵌套 boolean/number/数组账号列表），故独立实现：直接读写
-* localstore.json 顶层 `serenityAdvanced` 节，保留其余节（credentials/config）不变。
+* 归属原则（S142 用户拍板，v1.22）：**plugin 是全局的，CCC 是具体的**——
+* 账号密码/gateway 监听配置是 plugin 级能力，归 plugin 全局文件；
+* CCC 的 localstore.json 只管 CCC 自己的凭据/配置。v1.21.x 曾把
+* `serenityAdvanced` 存进 CCC localstore（归属错误 + 与 DSH settings 开关割裂），
+* 本版本迁移到 plugin 全局文件（migrateLegacyLocalstore 一次性迁移）。
 *
-* git 策略：沿用 localstore 语义——写入时 ensureLocalstoreGitignored（deny 缺省物理保证）。
+* 文件：$DSH_HOME/serenity-hooks.json（缺省 ~/.dsh/serenity-hooks.json；
+* env SERENITY_HOOKS_CONFIG 可覆盖——测试/部署注入）。
+* 权限：0600（含账号密码 hash，敏感）。
 *
 * 安全：密码仅存 scrypt hash（node:crypto 内置，零依赖）；wire 层永不返回 hash
 * （GET 只回 user/id，设置面板"密码"字段提交空串 = 不修改）。
@@ -6961,7 +7092,11 @@ function defaultAdvancedSettings() {
 			enabled: false,
 			host: "0.0.0.0",
 			port: 3081,
-			accounts: []
+			accounts: [],
+			workspaces: [],
+			cookieSecure: false,
+			allowWorkspaceCreate: true,
+			totpEnabled: false
 		},
 		rebuild: {
 			enabled: true,
@@ -6986,8 +7121,14 @@ function verifyPassword(password, stored) {
 	const derived = scryptSync(password, salt, SCRYPT_KEYLEN);
 	return expected.length === derived.length && timingSafeEqual(expected, derived);
 }
-function readAll(root) {
-	const p = localstorePath(root);
+/** 全局配置文件路径：env SERENITY_HOOKS_CONFIG 覆盖（测试注入）→ $DSH_HOME → ~/.dsh */
+function globalConfigPath() {
+	const override = process.env.SERENITY_HOOKS_CONFIG;
+	if (override && override !== "") return override;
+	const dshHome = process.env.DSH_HOME ?? join(process.env.HOME ?? "", ".dsh");
+	return join(dshHome, "serenity-hooks.json");
+}
+function readFileSafe(p) {
 	if (!existsSync(p)) return {};
 	try {
 		const v = JSON.parse(readFileSync(p, "utf-8").replace(/^\uFEFF/, ""));
@@ -6997,9 +7138,11 @@ function readAll(root) {
 		return {};
 	}
 }
-function writeAll(root, data) {
-	writeFileSync(localstorePath(root), JSON.stringify(data, null, 2) + "\n", "utf-8");
-	ensureLocalstoreGitignored(root);
+function writeFileSafe(p, data) {
+	writeFileSync(p, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	try {
+		chmodSync(p, 384);
+	} catch {}
 }
 /** 深合并默认值（缺省字段补齐；accounts 数组整体替换） */
 function mergeWithDefaults(raw) {
@@ -7014,7 +7157,11 @@ function mergeWithDefaults(raw) {
 			enabled: typeof gateway.enabled === "boolean" ? gateway.enabled : def.gateway.enabled,
 			host: typeof gateway.host === "string" && gateway.host !== "" ? gateway.host : def.gateway.host,
 			port: typeof gateway.port === "number" && Number.isInteger(gateway.port) ? gateway.port : def.gateway.port,
-			accounts: Array.isArray(gateway.accounts) ? gateway.accounts.filter((a) => typeof a === "object" && a !== null && typeof a.id === "string" && typeof a.user === "string" && typeof a.passHash === "string") : def.gateway.accounts
+			accounts: Array.isArray(gateway.accounts) ? gateway.accounts.filter((a) => typeof a === "object" && a !== null && typeof a.id === "string" && typeof a.user === "string" && typeof a.passHash === "string") : def.gateway.accounts,
+			workspaces: Array.isArray(gateway.workspaces) ? gateway.workspaces.filter((w) => typeof w === "string" && w !== "") : def.gateway.workspaces,
+			cookieSecure: typeof gateway.cookieSecure === "boolean" ? gateway.cookieSecure : def.gateway.cookieSecure,
+			allowWorkspaceCreate: typeof gateway.allowWorkspaceCreate === "boolean" ? gateway.allowWorkspaceCreate : def.gateway.allowWorkspaceCreate,
+			totpEnabled: typeof gateway.totpEnabled === "boolean" ? gateway.totpEnabled : def.gateway.totpEnabled
 		},
 		rebuild: {
 			enabled: typeof rebuild.enabled === "boolean" ? rebuild.enabled : def.rebuild.enabled,
@@ -7023,22 +7170,20 @@ function mergeWithDefaults(raw) {
 		naming: { enabled: typeof naming.enabled === "boolean" ? naming.enabled : def.naming.enabled }
 	};
 }
-/** 读取高级设定（文件缺失/坏 JSON → 默认值） */
-function readAdvancedSettings(root) {
-	return mergeWithDefaults(readAll(root)[ADVANCED_SECTION]);
+/** 读取全局配置（文件缺失/坏 JSON → 默认值） */
+function readAdvancedSettings() {
+	return mergeWithDefaults(readFileSafe(globalConfigPath()));
 }
-/** 写入高级设定全量（保留其他节） */
-function writeAdvancedSettings(root, settings) {
-	const all = readAll(root);
-	all[ADVANCED_SECTION] = settings;
-	writeAll(root, all);
+/** 写入全局配置（整体替换） */
+function writeAdvancedSettings(settings) {
+	writeFileSafe(globalConfigPath(), settings);
 }
 /**
-* 部分更新（面板 PUT 用）：传入 Partial，深合并到现有值。
+* 部分更新：传入 Partial，深合并到现有值。
 * accounts 传入数组 → 整体替换；accounts 未传 → 保留现有。
 */
-function updateAdvancedSettings(root, patch) {
-	const current = readAdvancedSettings(root);
+function updateAdvancedSettings(patch) {
+	const current = readAdvancedSettings();
 	const gw = patch.gateway;
 	const rb = patch.rebuild;
 	const nm = patch.naming;
@@ -7047,7 +7192,11 @@ function updateAdvancedSettings(root, patch) {
 			enabled: typeof gw.enabled === "boolean" ? gw.enabled : current.gateway.enabled,
 			host: typeof gw.host === "string" && gw.host !== "" ? gw.host : current.gateway.host,
 			port: typeof gw.port === "number" && Number.isInteger(gw.port) ? gw.port : current.gateway.port,
-			accounts: Array.isArray(gw.accounts) ? gw.accounts : current.gateway.accounts
+			accounts: Array.isArray(gw.accounts) ? gw.accounts : current.gateway.accounts,
+			workspaces: Array.isArray(gw.workspaces) ? gw.workspaces.filter((w) => typeof w === "string" && w !== "") : current.gateway.workspaces,
+			cookieSecure: typeof gw.cookieSecure === "boolean" ? gw.cookieSecure : current.gateway.cookieSecure,
+			allowWorkspaceCreate: typeof gw.allowWorkspaceCreate === "boolean" ? gw.allowWorkspaceCreate : current.gateway.allowWorkspaceCreate,
+			totpEnabled: typeof gw.totpEnabled === "boolean" ? gw.totpEnabled : current.gateway.totpEnabled
 		} : current.gateway,
 		rebuild: rb !== void 0 ? {
 			enabled: typeof rb.enabled === "boolean" ? rb.enabled : current.rebuild.enabled,
@@ -7055,10 +7204,25 @@ function updateAdvancedSettings(root, patch) {
 		} : current.rebuild,
 		naming: nm !== void 0 ? { enabled: typeof nm.enabled === "boolean" ? nm.enabled : current.naming.enabled } : current.naming
 	};
-	writeAdvancedSettings(root, next);
+	writeAdvancedSettings(next);
 	return next;
 }
-/** 持久化 → wire（剥离 passHash；只留 hasPassword 布尔） */
+/**
+* 一次性迁移（v1.21.x → v1.22）：旧版把 `serenityAdvanced` 存在 CCC localstore.json；
+* 新版归 plugin 全局文件。全局文件已存在 → 跳过（幂等）；localstore 无旧节 → 跳过。
+* @param root - CCC 根（localstore.json 所在目录）
+* @returns true = 已迁移（旧节保留在 localstore 供回滚，读取方以全局文件为准）
+*/
+function migrateLegacyLocalstore(root) {
+	if (!root) return false;
+	const gpath = globalConfigPath();
+	if (existsSync(gpath)) return false;
+	const legacy = readFileSafe(join(root, "localstore.json"))[ADVANCED_SECTION];
+	if (legacy === void 0 || legacy === null || typeof legacy !== "object") return false;
+	writeFileSafe(gpath, legacy);
+	return true;
+}
+/** 持久化 → wire（剥离 passHash/totpSecret；只留布尔） */
 function toWire(settings) {
 	return {
 		gateway: {
@@ -7068,8 +7232,13 @@ function toWire(settings) {
 			accounts: settings.gateway.accounts.map((a) => ({
 				id: a.id,
 				user: a.user,
-				hasPassword: a.passHash !== ""
-			}))
+				hasPassword: a.passHash !== "",
+				hasTotp: typeof a.totpSecret === "string" && a.totpSecret !== ""
+			})),
+			workspaces: [...settings.gateway.workspaces],
+			cookieSecure: settings.gateway.cookieSecure,
+			allowWorkspaceCreate: settings.gateway.allowWorkspaceCreate,
+			totpEnabled: settings.gateway.totpEnabled
 		},
 		rebuild: settings.rebuild,
 		naming: settings.naming
@@ -7080,30 +7249,44 @@ function toWire(settings) {
 * accounts 元素可选带 `pass`：非空 → 重新 hash；空/缺省 → 保留现有 hash（按 id 匹配）。
 * 新账号（id 不在现有）必须带非空 pass，否则抛错（无法生成 hash）。
 */
-function applyWirePatch(root, wire) {
-	const current = readAdvancedSettings(root);
+function applyWirePatch(wire) {
+	const current = readAdvancedSettings();
 	const patch = {};
 	if (wire.gateway !== void 0) {
 		const gwPatch = { ...current.gateway };
 		if (typeof wire.gateway.enabled === "boolean") gwPatch.enabled = wire.gateway.enabled;
 		if (typeof wire.gateway.host === "string" && wire.gateway.host !== "") gwPatch.host = wire.gateway.host;
 		if (typeof wire.gateway.port === "number" && Number.isInteger(wire.gateway.port)) gwPatch.port = wire.gateway.port;
+		if (Array.isArray(wire.gateway.workspaces)) gwPatch.workspaces = wire.gateway.workspaces.filter((w) => typeof w === "string" && w !== "");
+		if (typeof wire.gateway.cookieSecure === "boolean") gwPatch.cookieSecure = wire.gateway.cookieSecure;
+		if (typeof wire.gateway.allowWorkspaceCreate === "boolean") gwPatch.allowWorkspaceCreate = wire.gateway.allowWorkspaceCreate;
+		if (typeof wire.gateway.totpEnabled === "boolean") gwPatch.totpEnabled = wire.gateway.totpEnabled;
 		if (Array.isArray(wire.gateway.accounts)) {
 			const byId = new Map(current.gateway.accounts.map((a) => [a.id, a]));
 			gwPatch.accounts = wire.gateway.accounts.map((a) => {
 				const existing = byId.get(a.id);
 				const pass = a.pass;
-				if (typeof pass === "string" && pass !== "") return {
+				const totp = a.totpSecret;
+				const totpReset = a.totpReset === true;
+				const totpConfirm = a.totpConfirm;
+				if (typeof totp === "string" && totp !== "") {
+					if (typeof totpConfirm !== "string" || verifyTotpCode(totp, totpConfirm) === null) throw new Error(`Account "${a.user}" TOTP confirmation code invalid — enter the 6-digit code currently shown by the authenticator`);
+				}
+				const nextTotp = totpReset ? void 0 : typeof totp === "string" && totp !== "" ? totp : existing?.totpSecret;
+				const withTotp = {
 					id: a.id,
 					user: a.user,
+					...nextTotp === void 0 ? {} : { totpSecret: nextTotp }
+				};
+				if (typeof pass === "string" && pass !== "") return {
+					...withTotp,
 					passHash: hashPassword(pass)
 				};
 				if (existing) return {
-					id: a.id,
-					user: a.user,
+					...withTotp,
 					passHash: existing.passHash
 				};
-				throw new Error(`账号 "${a.user}"（id=${a.id}）未提供密码且无现有 hash——新账号必须设置密码`);
+				throw new Error(`Account "${a.user}" (id=${a.id}) has no password and no existing hash — new accounts must set a password`);
 			});
 		}
 		patch.gateway = gwPatch;
@@ -7115,7 +7298,7 @@ function applyWirePatch(root, wire) {
 		patch.rebuild = rbPatch;
 	}
 	if (wire.naming !== void 0 && typeof wire.naming.enabled === "boolean") patch.naming = { enabled: wire.naming.enabled };
-	return updateAdvancedSettings(root, patch);
+	return updateAdvancedSettings(patch);
 }
 //#endregion
 //#region src/api.ts
@@ -7155,7 +7338,7 @@ function saveImageToTmp(root, mediaType, data) {
 	writeFileSync(join(dir, filename), bytes);
 	return `${IMAGE_UPLOAD_DIR}/${filename}`;
 }
-function readBody(req, maxBytes) {
+function readBody$1(req, maxBytes) {
 	return new Promise((resolve, reject) => {
 		let data = "";
 		req.on("data", (chunk) => {
@@ -7177,14 +7360,27 @@ function sendJson(res, code, body) {
 	});
 	res.end(payload);
 }
-/** 从请求参数解析 workspace：优先 sessionId → 会话 header.cwd；其次 workspace 参数；最后进程 cwd */
+/**
+* 从请求参数解析 workspace：优先 sessionId → 会话 header.cwd；其次 workspace 参数；
+* 无参 → 遍历 live sessions 找第一个 CCC 会话的 cwd（远程访问时 sessionId 可能缺失，
+* 回退 process.cwd()=$HOME 会错误显示"未激活"——v1.22.2 修复）；最后进程 cwd。
+* 纯逻辑（可单测）：resolveWorkspaceCore(sessionCwd, workspaceParam, listCwds)。
+*/
+function resolveWorkspaceCore(sessionCwd, workspaceParam, listCwds, fallback) {
+	if (sessionCwd) return sessionCwd;
+	if (workspaceParam) return workspaceParam;
+	for (const cwd of listCwds()) if (cwd && findSerenityRoot(cwd)) return cwd;
+	return fallback;
+}
 function resolveWorkspace(ctx, params) {
-	if (params.sessionId) {
-		const session = ctx.sessions?.get?.(params.sessionId);
-		if (session?.header?.cwd) return session.header.cwd;
-	}
-	if (typeof params.workspace === "string" && params.workspace) return params.workspace;
-	return process.cwd();
+	let sessionCwd;
+	if (params.sessionId) sessionCwd = (ctx.sessions?.get?.(params.sessionId))?.header?.cwd;
+	let listCwds = () => [];
+	try {
+		const sessions = ctx.sessions;
+		if (typeof sessions?.list === "function") listCwds = () => sessions.list().map((s) => s.header?.cwd ?? "").filter(Boolean);
+	} catch {}
+	return resolveWorkspaceCore(sessionCwd, params.workspace, listCwds, process.cwd());
 }
 function registerStatusApi(ctx, opts = {}) {
 	const configPaths = opts.configPaths ?? DEFAULT_SERENITY_CONFIG_PATHS;
@@ -7225,7 +7421,7 @@ function registerStatusApi(ctx, opts = {}) {
 					sendJson(res, 403, { error: "图片落盘仅限 WebUI（client 专用）" });
 					return;
 				}
-				const raw = await readBody(req, 20971520);
+				const raw = await readBody$1(req, 20971520);
 				const body = JSON.parse(raw);
 				const workspace = resolveWorkspace(ctx, {
 					sessionId: body.sessionId,
@@ -7268,7 +7464,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson(res, 403, { error: "safe-mode 切换仅限 WebUI（agent 不可自行开关）" });
 						return;
 					}
-					const raw = await readBody(req, 65536);
+					const raw = await readBody$1(req, 65536);
 					const body = JSON.parse(raw);
 					const workspace = resolveWorkspace(ctx, {
 						sessionId: body.sessionId,
@@ -7302,35 +7498,16 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				if (req.method === "GET") {
-					const url = new URL(req.url ?? "/", "http://127.0.0.1");
-					const workspace = resolveWorkspace(ctx, {
-						sessionId: url.searchParams.get("sessionId") ?? void 0,
-						workspace: url.searchParams.get("workspace") ?? void 0
-					});
-					const root = findSerenityRoot(workspace);
-					if (!root) {
-						sendJson(res, 200, {
-							config: null,
-							error: `no CCC found from workspace: ${workspace}`
-						});
-						return;
-					}
-					sendJson(res, 200, { config: toWire(readAdvancedSettings(root)) });
+					sendJson(res, 200, { config: toWire(readAdvancedSettings()) });
 					return;
 				}
 				if (req.method === "PUT") {
-					const raw = await readBody(req, 131072);
-					const body = JSON.parse(raw);
-					const workspace = resolveWorkspace(ctx, {
-						sessionId: body.sessionId,
-						workspace: body.workspace
-					});
-					const root = findSerenityRoot(workspace);
-					if (!root) {
-						sendJson(res, 404, { error: `no CCC found from workspace: ${workspace}` });
-						return;
-					}
-					sendJson(res, 200, { config: toWire(applyWirePatch(root, body.config ?? {})) });
+					const raw = await readBody$1(req, 131072);
+					const saved = applyWirePatch(JSON.parse(raw).config ?? {});
+					try {
+						ctx.emit?.("serenity/config-updated");
+					} catch {}
+					sendJson(res, 200, { config: toWire(saved) });
 					return;
 				}
 				sendJson(res, 405, { error: "method not allowed" });
@@ -7356,9 +7533,9 @@ function registerEnv(ctx) {
 	ctx.shellEnv.register({
 		name: "dsh-serenity-hooks",
 		variables: {
-			DSH_SERENITY_ROOT: { description: "CCC 根目录（宁静号认知容器）" },
-			DSH_SERENITY_CCC: { description: "CCC 名称（根目录 basename）" },
-			DSH_SERENITY_VERSION: { description: "ACC 插件版本" }
+			DSH_SERENITY_ROOT: { description: "CCC root directory (Serenity cognitive container)" },
+			DSH_SERENITY_CCC: { description: "CCC name (root directory basename)" },
+			DSH_SERENITY_VERSION: { description: "ACC plugin version" }
 		},
 		resolve(execution) {
 			return resolveSerenityEnv((execution.agent?.session)?.header?.cwd ?? process.cwd());
@@ -7478,41 +7655,126 @@ function registerOpencodeSkills(ctx) {
 	ctx.skills.registerProvider(() => provider);
 }
 //#endregion
-//#region src/gateway.ts
-/** 极简登录页（内嵌 HTML，无外部资源——适配任何部署） */
-function loginPageHtml(extra) {
-	return `<!doctype html><html lang="zh"><head><meta charset="utf-8"><title>Serenity 登录</title>
-<style>
-body{font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#111;color:#eee}
-.card{background:#1c1c1e;padding:32px 40px;border-radius:12px;width:300px;box-shadow:0 8px 30px rgba(0,0,0,.5)}
-h1{font-size:18px;margin:0 0 20px}input{width:100%;box-sizing:border-box;padding:10px;margin:8px 0;border:1px solid #333;border-radius:6px;background:#222;color:#eee}
-button{width:100%;padding:10px;margin-top:16px;border:0;border-radius:6px;background:#3b82f6;color:#fff;font-size:14px;cursor:pointer}
-.error{color:#f87171;font-size:12px;min-height:16px;margin-top:8px}
-</style></head><body><div class="card"><h1>🔐 Serenity Web UI</h1>
-<form method="post" action="/serenity/login">
-<input type="text" name="user" placeholder="用户名" autocomplete="username" required autofocus>
-<input type="password" name="password" placeholder="密码" autocomplete="current-password" required>
-<button type="submit">登录</button>
-<div class="error">${extra}</div>
-</form></div></body></html>`;
-}
-/** 账号验证（纯逻辑）：user + password 对 localstore accounts 匹配（scrypt） */
+//#region src/gateway-auth.ts
+/**
+* gateway-auth.ts — F1 双端口网关：认证域纯逻辑（v1.22.4 安全加固）
+*
+* 从 gateway.ts 拆分（S142 熵点治理，v1.22.8）：认证纯逻辑独立成模块——
+* 登录验证（scrypt）/ 会话 token（滑动 TTL + 吊销）/ 失败锁定（账号维度指数退避）/
+* CSRF（双提交 + Origin 校验）/ cookie 解析 / 登录页 HTML。
+* gateway.ts 保留 HTTP 装配（startGateway/registerGateway）并从本模块 import。
+*
+* 纯函数设计（可单测）：无 socket/无 HTTP 依赖，全部导出可注入测试。
+*/
 function verifyGatewayLogin(accounts, user, password) {
 	const account = accounts.find((a) => a.user === user);
 	if (!account) return false;
 	return verifyPassword(password, account.passHash);
 }
-/** 内存 token 表（重启即清空——用户决策） */
-const tokens = /* @__PURE__ */ new Set();
-/** 颁发 token（Hex 32 字节） */
-function issueToken() {
+/** 内存会话表（重启即清空——用户决策） */
+const sessions = /* @__PURE__ */ new Map();
+/** 颁发会话 token（Hex 32 字节） */
+function issueToken(user) {
 	const token = randomBytes(32).toString("hex");
-	tokens.add(token);
+	sessions.set(token, {
+		token,
+		lastActiveAt: Date.now(),
+		user
+	});
 	return token;
 }
-/** 校验 token 是否有效 */
+/** 主动吊销会话（登出）；返回是否确实存在 */
+function revokeToken(token) {
+	return sessions.delete(token);
+}
+/**
+* 校验 token 有效性（滑动过期：有效则刷新 lastActiveAt）。
+* @returns 有效会话或 undefined
+*/
 function validateToken(token) {
-	return typeof token === "string" && token !== "" && tokens.has(token);
+	if (typeof token !== "string" || token === "") return void 0;
+	const session = sessions.get(token);
+	if (session === void 0) return void 0;
+	if (Date.now() - session.lastActiveAt > 864e5) {
+		sessions.delete(token);
+		return;
+	}
+	session.lastActiveAt = Date.now();
+	return session;
+}
+/** 首次锁定时长（毫秒） */
+const FAIL_LOCK_BASE_MS = 9e5;
+/** 锁定时长指数退避上限 */
+const FAIL_LOCK_MAX_MS = 144e5;
+/** 账号 → 失败状态（内存；重启清零——攻击者重启服务可绕过，但公网常驻服务下有效） */
+const failStates = /* @__PURE__ */ new Map();
+/** 获取账号失败状态（纯逻辑，供测试注入） */
+function getFailState(user) {
+	let st = failStates.get(user);
+	if (!st) {
+		st = {
+			count: 0,
+			lockedUntil: 0,
+			lockRound: 0
+		};
+		failStates.set(user, st);
+	}
+	return st;
+}
+/** 重置失败状态（登录成功/管理员解封） */
+function resetFailState(user) {
+	failStates.delete(user);
+}
+/** 记录一次失败；达到阈值 → 锁定（指数退避）。返回锁定剩余毫秒（0 = 未锁定） */
+function recordLoginFailure(user) {
+	const st = getFailState(user);
+	if (st.lockedUntil > 0 && Date.now() < st.lockedUntil) return st.lockedUntil - Date.now();
+	st.count += 1;
+	if (st.count >= 5) {
+		const base = FAIL_LOCK_BASE_MS * 2 ** st.lockRound;
+		st.lockedUntil = Date.now() + Math.min(base, FAIL_LOCK_MAX_MS);
+		st.lockRound += 1;
+		st.count = 0;
+		return st.lockedUntil - Date.now();
+	}
+	return 0;
+}
+/** 剩余锁定毫秒（0 = 未锁定） */
+function accountLockRemaining(user) {
+	const st = getFailState(user);
+	return st.lockedUntil > 0 && Date.now() < st.lockedUntil ? st.lockedUntil - Date.now() : 0;
+}
+/** 生成 CSRF cookie 值（随机 32B hex） */
+function newCsrfToken() {
+	return randomBytes(32).toString("hex");
+}
+/** 从请求头取 CSRF token（X-CSRF-Token 或表单字段） */
+function csrfFromRequest(req, body) {
+	const header = req.headers["x-csrf-token"];
+	if (typeof header === "string" && header !== "") return header;
+	const form = body.get("csrf");
+	return form && form !== "" ? form : null;
+}
+/** 常量时间比较（token 校验用） */
+function safeEqual(a, b) {
+	const ab = Buffer.from(a);
+	const bb = Buffer.from(b);
+	return ab.length === bb.length && timingSafeEqual(ab, bb);
+}
+/**
+* Origin 校验（S3）：跨站 POST 被浏览器强制带 Origin（同源 GET/导航除外）。
+* 允许：① 同源（Origin.host === 网关自身 host）② 主端口 loopback（127.0.0.1:mainPort）。
+* 无 Origin（curl/非浏览器直连）→ 仅当携带有效 CSRF 双提交时放行（脚本无 cookie 无法伪造）。
+* @returns 是否通过
+*/
+function originAllowed(originHeader, reqHost, mainPort) {
+	if (originHeader === void 0 || originHeader === "null") return true;
+	try {
+		const originHost = new URL(originHeader).host;
+		return originHost === reqHost || originHost === `127.0.0.1:${mainPort}` || originHost === `localhost:${mainPort}`;
+	} catch {
+		return false;
+	}
 }
 /** 从 Cookie 头解析指定 cookie 值（纯逻辑，可单测） */
 function cookieValue(header, name) {
@@ -7524,43 +7786,391 @@ function cookieValue(header, name) {
 	}
 }
 /**
-* 启动第二监听器。返回 { server, dispose }——dispose 关 server + 清 token。
+* 登录页：内嵌 HTML 无外部资源——适配任何部署。
+* 移动端关键点：
+*  - viewport meta（防止移动浏览器按 980px 视口缩放）
+*  - 触控目标 ≥ 44px（Apple HIG）；输入字号 ≥ 16px（iOS 聚焦不自动放大）
+*  - env(safe-area-inset-*) 适配刘海屏/底部手势条
+*  - color-scheme: dark + 明暗自适应
+* @param extra - 错误提示文案
+* @param csrf - CSRF token（隐藏字段随表单双提交；无 = 旧调用方兼容）
+*/
+function loginPageHtml(extra, csrf) {
+	return `<!doctype html><html lang="zh"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<meta name="color-scheme" content="dark light">
+<meta name="theme-color" content="#111114">
+<meta name="referrer" content="no-referrer">
+<title>Serenity 登录</title>
+<style>
+:root{color-scheme:dark}
+*{box-sizing:border-box}
+html,body{height:100%}
+body{font-family:system-ui,-apple-system,"Segoe UI",Roboto,"PingFang SC","Microsoft YaHei",sans-serif;display:flex;align-items:center;justify-content:center;margin:0;padding:env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);background:#111114;color:#eee}
+.card{background:#1c1c20;padding:32px 28px;border-radius:16px;width:min(340px,calc(100vw - 48px));box-shadow:0 12px 40px rgba(0,0,0,.55);border:1px solid rgba(255,255,255,.06)}
+h1{font-size:20px;margin:0 0 4px;text-align:center;letter-spacing:.02em}
+.sub{font-size:13px;color:#999;text-align:center;margin:0 0 24px}
+label{display:block;font-size:13px;color:#bbb;margin:14px 0 6px}
+input{width:100%;padding:14px 14px;margin:0;border:1px solid #3a3a40;border-radius:10px;background:#141418;color:#eee;font-size:16px;-webkit-appearance:none;appearance:none}
+input:focus{outline:none;border-color:#3b82f6;box-shadow:0 0 0 3px rgba(59,130,246,.25)}
+input::placeholder{color:#666}
+#f-code{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;letter-spacing:.35em;text-align:center;font-weight:600}
+button{width:100%;padding:15px 14px;margin-top:24px;border:0;border-radius:10px;background:#3b82f6;color:#fff;font-size:16px;font-weight:600;cursor:pointer;min-height:50px;-webkit-appearance:none;appearance:none}
+button:active{background:#2563eb}
+.error{color:#f87171;font-size:13px;min-height:18px;margin-top:12px;text-align:center}
+.hint{color:#777;font-size:12px;margin-top:10px;text-align:center}
+.foot{margin-top:20px;text-align:center;font-size:12px;color:#666}
+@media (prefers-color-scheme:light){
+  body{background:#f4f4f6;color:#1a1a1e}
+  .card{background:#fff;border-color:rgba(0,0,0,.08);box-shadow:0 12px 40px rgba(0,0,0,.12)}
+  .sub{color:#666}
+  label{color:#444}
+  input{background:#fafafa;border-color:#d0d0d6;color:#1a1a1e}
+  input::placeholder{color:#aaa}
+  .hint{color:#999}
+  .foot{color:#999}
+}
+</style></head><body><div class="card">
+<h1>🔐 Serenity Web UI</h1>
+<p class="sub">宁静号 · 外部访问</p>
+<form method="post" action="/serenity/login">
+${csrf ? `<input type="hidden" name="csrf" value="${csrf}">` : ""}
+<label for="f-user">用户名</label>
+<input id="f-user" type="text" name="user" placeholder="用户名" autocomplete="username" autocapitalize="none" autocorrect="off" required autofocus enterkeyhint="next">
+<label for="f-pass">密码</label>
+<input id="f-pass" type="password" name="password" placeholder="密码" autocomplete="current-password" required enterkeyhint="next">
+<label for="f-code">验证码（已绑定 Authenticator 时填写）</label>
+<input id="f-code" type="text" name="code" placeholder="6 位验证码" inputmode="numeric" pattern="[0-9]{6}" maxlength="6" autocomplete="one-time-code" enterkeyhint="go">
+<button type="submit">登录</button>
+<div class="error">${extra}</div>
+<p class="hint">未绑定验证器的账号只需用户名 + 密码</p>
+</form>
+<p class="foot">Serenity ACC · dsh-serenity-hooks</p>
+</div></body></html>`;
+}
+//#endregion
+//#region src/gateway-proxy.ts
+/**
+* gateway-proxy.ts — F1 双端口网关：代理辅助纯逻辑（v1.22.1-1.22.3 稳定性修复）
+*
+* 从 gateway.ts 拆分（S142 熵点治理，v1.22.8）：
+*  - crypto.randomUUID polyfill（非安全上下文修复，v1.22.0）
+*  - 反代请求头构造（信任栅栏修复：Host + Origin 同步改写 loopback，v1.22.1）
+*  - workspace 白名单过滤（响应 items 前缀过滤 + create 校验 + 403 RPC 响应，v1.22）
+*  - HTML polyfill 注入（幂等 marker）
+* 纯函数设计（可单测）；gateway.ts 装配层 import 使用。
+*/
+/**
+* 经第二端口 http://LAN-IP:3081 访问 = 非安全上下文 → DSH client 的
+* `crypto.randomUUID()`（ui-conversation/service.ts 等）抛错，provider 目录加载失败。
+* 用 `crypto.getRandomValues` 实现（与 DSH 官方 random-uuid.ts 同算法），
+* 零改 DSH——gateway 反代 HTML 时注入。
+*/
+const RANDOM_UUID_POLYFILL = `<script>
+(function () {
+  if (typeof crypto === 'undefined' || typeof crypto.randomUUID === 'function') return
+  try {
+    crypto.randomUUID = function () {
+      var bytes = crypto.getRandomValues(new Uint8Array(16))
+      bytes[6] = (bytes[6] & 0x0f) | 0x40
+      bytes[8] = (bytes[8] & 0x3f) | 0x80
+      var hex = Array.from(bytes, function (b) { return b.toString(16).padStart(2, '0') }).join('')
+      return hex.slice(0, 8) + '-' + hex.slice(8, 12) + '-' + hex.slice(12, 16) + '-' + hex.slice(16, 20) + '-' + hex.slice(20)
+    }
+  } catch (e) { /* getRandomValues 也不可用则放弃 */ }
+})()
+<\/script>`;
+/** 注入标记（幂等：已注入的 HTML 不重复注入） */
+const POLYFILL_MARKER = "data-sp-randomuuid-polyfill";
+/**
+* workspace.list 响应过滤（v1.22 白名单）：
+* DSH client→server RPC 全部走 HTTP JSON（`POST /api/workspace.list`，WS 仅下行推送）。
+* 白名单（workspaces 路径前缀）非空 → 只保留匹配前缀的 items；
+* 空 = 全部允许（默认，向后兼容）。
+*/
+function filterWorkspaceList(body, allowPrefixes) {
+	if (allowPrefixes.length === 0) return body;
+	try {
+		const parsed = JSON.parse(body);
+		const value = parsed?.result?.value;
+		if (parsed?.result?.ok !== true || !value || !Array.isArray(value.items)) return body;
+		const keep = (path) => typeof path === "string" && allowPrefixes.some((p) => path.startsWith(p));
+		value.items = value.items.filter((item) => keep(item.path));
+		return JSON.stringify(parsed);
+	} catch {
+		return body;
+	}
+}
+/**
+* 校验 workspace.create 请求路径是否在白名单内（v1.22）：
+* 白名单非空且路径不匹配 → 拒绝（由调用方构造 403 RPC 响应）。
+*/
+function workspaceAllowed(allowPrefixes, path) {
+	if (allowPrefixes.length === 0) return true;
+	return typeof path === "string" && allowPrefixes.some((p) => path.startsWith(p));
+}
+/** 构造 workspace.create 拒绝的 JSON RPC 响应体（code=forbidden） */
+function workspaceDenyResponse(rpcId) {
+	return JSON.stringify({
+		type: "server-response",
+		rpcId,
+		result: {
+			ok: false,
+			error: {
+				code: "forbidden",
+				message: "workspace not in external allowlist",
+				details: {}
+			}
+		}
+	});
+}
+/** 在 HTML 的 </head> 前注入 polyfill（幂等：含 marker 则跳过） */
+function injectPolyfillHtml(html) {
+	if (html.includes(POLYFILL_MARKER)) return html;
+	const head = RANDOM_UUID_POLYFILL.replace("<script>", `<script ${POLYFILL_MARKER}="1">`);
+	if (html.includes("</head>")) return html.replace("</head>", `${head}\n</head>`);
+	return `${head}\n${html}`;
+}
+/**
+* 反代请求头构造（v1.22.1 信任栅栏修复，纯逻辑可测）：
+* DSH isTrustedApiRequest 要求 Origin.host === Host.host——Host 改写为 loopback 后
+* Origin 必须同步改写（浏览器 POST 必带 Origin，透传外部地址 → 403）。
+*/
+function buildProxyHeaders(reqHeaders, mainPort, bodyOverride) {
+	const headers = {
+		...reqHeaders,
+		host: `127.0.0.1:${mainPort}`,
+		origin: `http://127.0.0.1:${mainPort}`
+	};
+	if (bodyOverride !== void 0) headers["content-length"] = Buffer.byteLength(bodyOverride);
+	return headers;
+}
+//#endregion
+//#region src/gateway.ts
+/** 读取请求体（≤ maxBytes；超限 reject） */
+function readBody(req, maxBytes) {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		req.on("data", (chunk) => {
+			data += chunk.toString("utf-8");
+			if (data.length > maxBytes) {
+				reject(/* @__PURE__ */ new Error("body too large"));
+				req.destroy();
+			}
+		});
+		req.on("end", () => resolve(data));
+		req.on("error", reject);
+	});
+}
+/**
+* 启动第二监听器。返回 { server, dispose }——dispose 关 server（**不清 token**：
+* token 模块级，进程重启自然清空；热重建清 token → 已登录用户 WS 断 + 重连 cookie 无效）。
 * @param config - 监听/代理配置。
-* @param getAccounts - 运行时读取账号列表（localstore；gateway.enabled 开关在调用方判）。
+* @param getAccounts - 运行时读取账号列表（plugin 全局文件；gateway.enabled 开关在调用方判）。
 */
 function startGateway(config, getAccounts) {
 	const { host, port, cookieName, mainPort, loginDelayMs } = config;
-	/** 校验请求 Cookie 是否含有效 token */
+	const allowWorkspaces = config.allowWorkspaces ?? [];
+	const cookieSecure = config.cookieSecure === true;
+	const allowWorkspaceCreate = config.allowWorkspaceCreate !== false;
+	const totpEnabled = config.totpEnabled === true;
+	/** 校验请求 Cookie 是否含有效 token（v1.22.4：滑动过期 + 返回会话供审计） */
 	const authed = (req) => validateToken(cookieValue(req.headers.cookie, cookieName));
-	/** 反向代理：改写 Host 头 → 主端口（loopback 过信任栅栏） */
-	const proxy = (req, res) => {
+	/**
+	* 反向代理：改写 Host + Origin 头 → 主端口（loopback 过信任栅栏）。
+	* v1.22.1 修复：DSH 信任栅栏（api-request-trust.ts isTrustedApiRequest）要求
+	* **Origin.host === Host.host**——仅改写 Host（127.0.0.1:3080）而 Origin 透传
+	* （http://192.168.x.x:3081）→ 不一致 → 所有 /api RPC 403（host.pickDirectory 首个暴露）。
+	* 增强：
+	*  - HTML 响应 → 注入 crypto.randomUUID polyfill（非安全上下文修复）
+	*  - /api/workspace.list 响应 → 白名单过滤 items
+	* @param bodyOverride - workspace.create 已读 body 时的重放（白名单检查后转发）
+	*/
+	const proxy = (req, res, bodyOverride) => {
+		const url = new URL(req.url ?? "/", `http://${host}:${port}`);
+		const method = req.method === "POST" && url.pathname.startsWith("/api/") ? url.pathname.slice(5) : null;
+		const headers = buildProxyHeaders(req.headers, mainPort, bodyOverride);
 		const target = request({
 			host: "127.0.0.1",
 			port: mainPort,
 			path: req.url ?? "/",
 			method: req.method,
-			headers: {
-				...req.headers,
-				host: `127.0.0.1:${mainPort}`
-			}
+			headers
 		}, (upstream) => {
-			res.writeHead(upstream.statusCode ?? 502, upstream.headers);
+			const status = upstream.statusCode ?? 502;
+			const ct = String(upstream.headers["content-type"] ?? "");
+			if (status === 200 && ct.includes("text/html")) {
+				const chunks = [];
+				upstream.on("data", (c) => chunks.push(c));
+				upstream.on("end", () => {
+					const transformed = injectPolyfillHtml(Buffer.concat(chunks).toString("utf-8"));
+					const out = {
+						...upstream.headers,
+						"content-length": Buffer.byteLength(transformed)
+					};
+					res.writeHead(status, out);
+					res.end(transformed);
+				});
+				upstream.on("error", () => {
+					try {
+						res.destroy();
+					} catch {}
+				});
+				return;
+			}
+			if (method === "workspace.list" && status === 200 && ct.includes("application/json")) {
+				const chunks = [];
+				upstream.on("data", (c) => chunks.push(c));
+				upstream.on("end", () => {
+					const transformed = filterWorkspaceList(Buffer.concat(chunks).toString("utf-8"), allowWorkspaces);
+					const out = {
+						...upstream.headers,
+						"content-length": Buffer.byteLength(transformed)
+					};
+					res.writeHead(status, out);
+					res.end(transformed);
+				});
+				upstream.on("error", () => {
+					try {
+						res.destroy();
+					} catch {}
+				});
+				return;
+			}
+			res.writeHead(status, upstream.headers);
 			upstream.pipe(res);
+			upstream.on("error", () => {
+				try {
+					res.destroy();
+				} catch {}
+			});
 		});
 		target.on("error", () => {
-			res.writeHead(502, { "content-type": "text/plain" });
-			res.end("502 Bad Gateway: dsh web 主端口不可达");
+			try {
+				res.writeHead(502, { "content-type": "text/plain" });
+				res.end("502 Bad Gateway: dsh web 主端口不可达");
+			} catch {}
 		});
-		req.pipe(target);
+		req.on("error", () => {
+			try {
+				target.destroy();
+			} catch {}
+		});
+		res.on("error", () => {
+			try {
+				target.destroy();
+			} catch {}
+		});
+		if (bodyOverride !== void 0) target.end(bodyOverride);
+		else req.pipe(target);
 	};
+	const lastTotpCounter = /* @__PURE__ */ new Map();
 	const server = createServer((req, res) => {
 		const url = new URL(req.url ?? "/", `http://${host}:${port}`);
-		if (authed(req)) {
+		if (req.method === "POST" && url.pathname === "/serenity/logout") {
+			const cookie = cookieValue(req.headers.cookie, cookieName);
+			if (cookie !== void 0) revokeToken(cookie);
+			res.writeHead(302, {
+				location: "/",
+				"set-cookie": `${cookieName}=; HttpOnly; SameSite=Strict; Path=/; Max-Age=0${cookieSecure ? "; Secure" : ""}`
+			});
+			res.end();
+			return;
+		}
+		const session = authed(req);
+		if (session !== void 0) {
+			if (req.method === "POST" && url.pathname === "/api/workspace.create") {
+				if (!allowWorkspaceCreate) {
+					readBody(req, 131072).then((body) => {
+						let rpcId = "unknown";
+						try {
+							const parsed = JSON.parse(body);
+							if (typeof parsed.rpcId === "string") rpcId = parsed.rpcId;
+						} catch {}
+						res.writeHead(403, { "content-type": "application/json" });
+						res.end(JSON.stringify({
+							type: "server-response",
+							rpcId,
+							result: {
+								ok: false,
+								error: {
+									code: "forbidden",
+									message: "workspace creation disabled for external access",
+									details: {}
+								}
+							}
+						}));
+					}).catch(() => {
+						res.writeHead(400, { "content-type": "application/json" });
+						res.end(JSON.stringify({
+							type: "server-response",
+							rpcId: "unknown",
+							result: {
+								ok: false,
+								error: {
+									code: "bad-request",
+									message: "body too large",
+									details: {}
+								}
+							}
+						}));
+					});
+					return;
+				}
+				readBody(req, 131072).then((body) => {
+					let rpcId = "unknown";
+					let path;
+					try {
+						const parsed = JSON.parse(body);
+						if (typeof parsed.rpcId === "string") rpcId = parsed.rpcId;
+						if (typeof parsed.payload?.path === "string") path = parsed.payload.path;
+					} catch {}
+					if (!workspaceAllowed(allowWorkspaces, path)) {
+						res.writeHead(403, { "content-type": "application/json" });
+						res.end(workspaceDenyResponse(rpcId));
+						return;
+					}
+					proxy(req, res, body);
+				}).catch(() => {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({
+						type: "server-response",
+						rpcId: "unknown",
+						result: {
+							ok: false,
+							error: {
+								code: "bad-request",
+								message: "body too large",
+								details: {}
+							}
+						}
+					}));
+				});
+				return;
+			}
+			if (req.method === "PUT" && url.pathname === "/serenity/config") {
+				if (!originAllowed(req.headers.origin, req.headers.host ?? "", mainPort)) {
+					console.warn(`[serenity-hooks] 拒绝跨源配置写（Origin=${String(req.headers.origin)}）：session=${session.user}`);
+					res.writeHead(403, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "cross-origin config write rejected" }));
+					return;
+				}
+			}
 			proxy(req, res);
 			return;
 		}
 		if (req.method === "POST" && url.pathname === "/serenity/login") {
 			let body = "";
+			req.on("error", () => {
+				try {
+					res.destroy();
+				} catch {}
+			});
+			res.on("error", () => {
+				try {
+					req.destroy();
+				} catch {}
+			});
 			req.on("data", (chunk) => {
 				body += chunk.toString("utf-8");
 			});
@@ -7568,86 +8178,215 @@ function startGateway(config, getAccounts) {
 				const params = new URLSearchParams(body);
 				const user = params.get("user") ?? "";
 				const password = params.get("password") ?? "";
-				if (verifyGatewayLogin(getAccounts(), user, password)) {
-					const token = issueToken();
+				const code = params.get("code") ?? "";
+				const remote = req.socket.remoteAddress ?? "unknown";
+				const cookieCsrf = cookieValue(req.headers.cookie, "serenity_csrf");
+				const formCsrf = csrfFromRequest(req, params);
+				if (cookieCsrf === void 0 || formCsrf === null || !safeEqual(cookieCsrf, formCsrf)) {
+					console.warn(`[serenity-hooks] 登录拒绝（CSRF 校验失败）：user=${user} ip=${remote}`);
+					res.writeHead(403, { "content-type": "text/html; charset=utf-8" });
+					res.end(loginPageHtml("会话校验失败，请刷新页面重试"));
+					return;
+				}
+				const lockedRemaining = accountLockRemaining(user);
+				if (lockedRemaining > 0) {
+					console.warn(`[serenity-hooks] 登录拒绝（账号锁定中）：user=${user} ip=${remote} 剩余=${Math.ceil(lockedRemaining / 6e4)}min`);
+					res.writeHead(429, {
+						"content-type": "text/html; charset=utf-8",
+						"retry-after": String(Math.ceil(lockedRemaining / 1e3))
+					});
+					res.end(loginPageHtml(`账号已锁定，请 ${Math.ceil(lockedRemaining / 6e4)} 分钟后再试`));
+					return;
+				}
+				const accounts = getAccounts();
+				const account = accounts.find((a) => a.user === user);
+				const passOk = account !== void 0 && verifyGatewayLogin(accounts, user, password);
+				let totpOk = true;
+				if (totpEnabled && passOk && account !== void 0 && typeof account.totpSecret === "string" && account.totpSecret !== "") {
+					const hit = verifyTotpCode(account.totpSecret, code);
+					totpOk = hit !== null;
+					if (totpOk && hit !== null && lastTotpCounter.get(account.id) === hit) totpOk = false;
+					if (totpOk && hit !== null) lastTotpCounter.set(account.id, hit);
+				}
+				if (passOk && totpOk) {
+					resetFailState(user);
+					const token = issueToken(user);
 					res.writeHead(302, {
 						location: "/",
-						"set-cookie": `${cookieName}=${token}; HttpOnly; SameSite=Strict; Path=/`
+						"set-cookie": `${cookieName}=${token}; HttpOnly; SameSite=Strict; Path=/${cookieSecure ? "; Secure" : ""}`
 					});
 					res.end();
+					console.log(`[serenity-hooks] 登录成功: user=${user} ip=${remote}`);
 					return;
 				}
+				const lockMs = recordLoginFailure(user);
+				console.warn(`[serenity-hooks] 登录失败: user=${user} ip=${remote} reason=${!passOk ? "bad-password" : "bad-totp"}${lockMs > 0 ? ` 锁定=${Math.ceil(lockMs / 6e4)}min` : ""}`);
+				const msg = lockMs > 0 ? `尝试过多，账号已锁定 ${Math.ceil(lockMs / 6e4)} 分钟` : passOk ? "验证码错误" : "用户名或密码错误";
 				res.writeHead(401, { "content-type": "text/html; charset=utf-8" });
-				res.end(loginPageHtml("用户名或密码错误"));
+				res.end(loginPageHtml(msg));
 			});
 			return;
 		}
-		res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
-		res.end(loginPageHtml(""));
+		const csrf = newCsrfToken();
+		res.writeHead(200, {
+			"content-type": "text/html; charset=utf-8",
+			"set-cookie": `serenity_csrf=${csrf}; HttpOnly; SameSite=Strict; Path=/${cookieSecure ? "; Secure" : ""}`
+		});
+		res.end(loginPageHtml("", csrf));
 	});
 	server.on("upgrade", (req, socket, head) => {
 		if (!authed(req)) {
 			socket.destroy();
 			return;
 		}
+		socket.on("error", () => {
+			try {
+				usocket?.destroy();
+			} catch {}
+		});
+		let usocket;
 		const upstream = request({
 			host: "127.0.0.1",
 			port: mainPort,
 			path: req.url ?? "/",
 			method: req.method,
-			headers: {
-				...req.headers,
-				host: `127.0.0.1:${mainPort}`
+			headers: buildProxyHeaders(req.headers, mainPort)
+		});
+		upstream.on("upgrade", (ures, usock, uhead) => {
+			usocket = usock;
+			usock.on("error", () => {
+				try {
+					socket.destroy();
+				} catch {}
+			});
+			const statusLine = `HTTP/1.1 ${ures.statusCode ?? 101} ${ures.statusMessage ?? "Switching Protocols"}\r\n`;
+			const headerLines = Object.entries(ures.headers).map(([k, v]) => `${k}: ${Array.isArray(v) ? v.join(", ") : String(v)}\r\n`).join("");
+			try {
+				socket.write(statusLine + headerLines + "\r\n");
+			} catch {
+				usock.destroy();
+				socket.destroy();
+				return;
 			}
+			usock.pipe(socket);
+			socket.pipe(usock);
+			if (head.length > 0) usock.write(head);
+			if (uhead.length > 0) socket.write(uhead);
 		});
-		upstream.on("upgrade", (_ures, usocket, uhead) => {
-			usocket.pipe(socket);
-			socket.pipe(usocket);
-			if (uhead.length > 0) usocket.write(uhead);
-			if (head.length > 0) socket.write(head);
+		upstream.on("response", (ures) => {
+			const chunks = [];
+			ures.on("data", (c) => chunks.push(c));
+			ures.on("end", () => {
+				const body = Buffer.concat(chunks);
+				const statusLine = `HTTP/1.1 ${ures.statusCode ?? 502} ${ures.statusMessage ?? ""}\r\n`;
+				const headerLines = Object.entries(ures.headers).filter(([k]) => ![
+					"transfer-encoding",
+					"connection",
+					"upgrade"
+				].includes(k.toLowerCase())).map(([k, v]) => `${k}: ${Array.isArray(v) ? v.join(", ") : String(v)}\r\n`).join("");
+				try {
+					socket.write(statusLine + headerLines + `content-length: ${body.length}\r\n\r\n`);
+					socket.write(body);
+					socket.end();
+				} catch {
+					socket.destroy();
+				}
+			});
+			ures.on("error", () => socket.destroy());
 		});
 		upstream.on("error", () => socket.destroy());
 		upstream.end();
 	});
-	server.listen(port, host);
+	const listenWithRetry = (attempt = 0) => {
+		const onError = (err) => {
+			if (err.code === "EADDRINUSE" && attempt < 10) {
+				console.warn(`[serenity-hooks] gateway 端口 ${port} 被占用（${err.code}），1s 后重试（${attempt + 1}/10）…`);
+				setTimeout(() => listenWithRetry(attempt + 1), 1e3);
+				return;
+			}
+			console.warn(`[serenity-hooks] gateway 监听 ${host}:${port} 失败: ${err.message ?? String(err)}`);
+		};
+		server.removeAllListeners("error");
+		server.on("error", onError);
+		server.removeAllListeners("clientError");
+		server.on("clientError", (_err, socket) => {
+			try {
+				socket.destroy();
+			} catch {}
+		});
+		server.listen(port, host);
+	};
+	listenWithRetry();
 	return {
 		server,
 		dispose: () => {
-			tokens.clear();
 			server.close();
 		}
 	};
 }
-/** 注册 gateway（index.ts apply 调用）：webServer 就绪后按配置启动第二监听器。 */
-function registerGateway(ctx, opts) {
+/** 注册 gateway（index.ts apply 调用）。
+* 归属原则（v1.22）：gateway 是 plugin 全局能力——enabled 开关读 DSH settings
+* （readSimpleSettings().gatewayEnabled），host/port/accounts 读 plugin 全局文件
+* （readAdvancedSettings()，~/.dsh/serenity-hooks.json）。**不依赖任何具体 CCC**。
+* 幂等 sync：仅当 配置/端口/开关 变化时重建监听器。
+* 事件驱动：config-updated（/serenity/config PUT 后 emit）+ DSH settings 变化（onChange emit）触发重新 sync。
+*/
+function registerGateway(ctx) {
 	let current = null;
+	let lastSig = null;
 	const sync = () => {
 		try {
+			const webServer = ctx.get?.("webServer");
+			if (!webServer?.port) return;
+			const enabled = readSimpleSettings().gatewayEnabled;
+			const settings = readAdvancedSettings();
+			const sig = `${enabled}|${settings.gateway.host}|${settings.gateway.port}|${settings.gateway.accounts.length}|${settings.gateway.workspaces.join(",")}|${webServer.port}`;
+			if (sig === lastSig) return;
+			lastSig = sig;
 			if (current) {
 				current.dispose();
 				current = null;
 			}
-			const root = opts.getRoot();
-			if (!root) return;
-			const webServer = ctx.get?.("webServer");
-			if (!webServer?.port) return;
-			const settings = readAdvancedSettings(root);
-			if (!settings.gateway.enabled) return;
-			if (settings.gateway.accounts.length === 0) return;
+			if (!enabled) {
+				console.log("[serenity-hooks] gateway 已停止（gatewayEnabled=false，可在 dsh 设置面板开启）");
+				return;
+			}
 			current = startGateway({
 				host: settings.gateway.host,
 				port: settings.gateway.port,
 				cookieName: "serenity_session",
 				mainPort: webServer.port,
-				loginDelayMs: 0
-			}, () => readAdvancedSettings(root).gateway.accounts);
-			console.log(`[serenity-hooks] gateway 已启动: http://${settings.gateway.host}:${settings.gateway.port} → 127.0.0.1:${webServer.port}`);
+				loginDelayMs: 0,
+				allowWorkspaces: settings.gateway.workspaces,
+				cookieSecure: settings.gateway.cookieSecure === true,
+				allowWorkspaceCreate: settings.gateway.allowWorkspaceCreate !== false,
+				totpEnabled: settings.gateway.totpEnabled === true
+			}, () => readAdvancedSettings().gateway.accounts);
+			const accounts = settings.gateway.accounts.length;
+			const wsNote = settings.gateway.workspaces.length === 0 ? "" : `；工作区白名单 ${settings.gateway.workspaces.length} 条`;
+			console.log(`[serenity-hooks] gateway 已启动: http://${settings.gateway.host}:${settings.gateway.port} → 127.0.0.1:${webServer.port}` + (accounts === 0 ? "（⚠️ 未配置账号，登录页将提示）" : `（${accounts} 个账号）`) + wsNote);
 		} catch (err) {
-			console.warn(`[serenity-hooks] gateway 启动失败: ${String(err?.message ?? err)}`);
+			console.warn(`[serenity-hooks] gateway 同步失败: ${String(err?.message ?? err)}`);
 		}
 	};
 	sync();
-	ctx.on("session/event", () => {});
+	ctx.on("agent/session-start", (payload) => {
+		try {
+			const cwd = payload.agent?.session?.header?.cwd;
+			if (cwd) {
+				const root = findSerenityRoot(cwd);
+				if (root && migrateLegacyLocalstore(root)) console.log(`[serenity-hooks] ✓ 已迁移 serenityAdvanced（CCC localstore → plugin 全局文件）`);
+			}
+		} catch {}
+		sync();
+	});
+	ctx.on("serenity/config-updated", () => {
+		lastSig = null;
+		sync();
+	});
+	ctx.on("serenity/settings-changed", () => {
+		sync();
+	});
 }
 //#endregion
 //#region src/index.ts
@@ -7661,7 +8400,8 @@ const inject = [
 	"skills",
 	"agentLoop",
 	"agents",
-	"systemPrompt"
+	"systemPrompt",
+	"sessionProjections"
 ];
 const Config = z.object({
 	serenityConfigPaths: z.array(z.string()).default([...DEFAULT_SERENITY_CONFIG_PATHS]),
@@ -7712,7 +8452,8 @@ function apply(ctx, config) {
 	});
 	if (config.api) registerStatusApi(ctx, { configPaths: config.serenityConfigPaths });
 	registerSettingsSection(ctx, config);
-	registerGateway(ctx, { getRoot: () => findSerenityRoot(process.cwd()) });
+	registerGateway(ctx);
+	registerRebuildTurnHook(ctx);
 	if (config.env) registerEnv(ctx);
 	if (config.opencodeSkills) registerOpencodeSkills(ctx);
 	registerBootstrap(ctx);