@shgroup/dsh-serenity-hooks 1.68.0 → 1.69.1

package/lib/index.js

@@ -2,11 +2,10 @@ import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-RMzGU-CJ.js";
 import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readSafeModeHiddenTools, i as findGitRoot, l as pathInside, m as readExclusiveTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readCognitiveTrajectorySkills, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-C33QWoWZ.js";
 import { A as summarize, C as readTrajectoryUid, D as setActiveSessionInfo, E as sessionsRoot, F as localIdStamp, M as isoLocal, N as localFileStamp, O as setTrajectoryUid, P as localHuman, S as readActiveSessionMd, T as sessionEvents$1, _ as getActiveSessionInfo, a as pruneMissingBindings, b as namingTitleFor, c as setBindingStore, d as UID_FILENAME, f as archiveSession, g as findSession, h as extractSessionMdPathFromText, i as listBoundSessionIds, j as useSession, k as showSession, l as COGNITIVE_TRAJECTORY_ACTIONS, m as createSession, n as PLUGIN_SOURCE, o as readLastBound, p as clearActiveSessionInfo, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, u as DEFAULT_SESSION_SCOPE, v as listActiveTrajectories, w as resolveSessionByTitle, x as parseSessionContextFromEvents, y as listSessions } from "./message-source-Catc7q1z.js";
-import { a as readGitTrack, c as unsetEntry, i as localstorePath, l as writeEntry, n as checkLocalstoreGitCompliance, o as readStore, r as getEntry, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./localstore-ops-ylQoPz1Q.js";
-import { a as FACE_PORTS, c as MECHANISM_PORTS, d as registerSkiffSession$1, f as skiffRoleFor$1, h as ACC_VERSION, i as ACP_PORT, l as SKIFF_DEBUG_PORT, m as unregisterSkiffSession$1, n as readSimpleSettings, o as GATEWAY_PORT, p as skiffSessionInfo$1, r as registerSettingsSection, s as MAIN_WEB_PORT, u as WEIXIN_SEND_PORT } from "./settings-section-B1YzjFz6.js";
+import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-D_DvgPqy.js";
+import { a as GATEWAY_PORT, c as SKIFF_DEBUG_PORT, d as skiffRoleFor$1, f as skiffSessionInfo$1, i as FACE_PORTS, l as WEIXIN_SEND_PORT, m as ACC_VERSION, n as readSimpleSettings, o as MAIN_WEB_PORT, p as unregisterSkiffSession$1, r as registerSettingsSection, s as MECHANISM_PORTS, u as registerSkiffSession$1 } from "./settings-section-DcZPcWPv.js";
 import { a as isSkiffSessionId, c as resolveSkiffKind, f as systemPromptSource, i as createRolePromptReader, l as roleMsmWhitelist, n as buildSkiffBasePrompt, o as readSkiffRoles, r as cognitiveTrajectorySubset, s as resolveRoleSystemPrompt, u as roleToolWhitelist } from "./skiff-role-Boc4SKct.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
-import { a as readWeixinCredential, c as weixinInboundDir, i as matchWeixinRoute, l as weixinSessionIdFor, n as extractWeixinText, o as readWeixinSettings, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-BoSC-uPp.js";
 import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-BrRcPiQs.js";
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
@@ -1085,8 +1084,8 @@ Directory of ACC capabilities — each area lists where to go for details (guide
                          cheap-worker（杂工 agent 编排——guide 子命令：cheap-worker guide）
                          专属工具（**默认对所有 CCC 隐藏**，只有在自己 exclusiveTools 里点名的 CCC 可见）→ acc-diag（运行态诊断）
   ④ 角色与对外面      → container_admin role（Skiff 认知子集角色：guide/validate/apply/list——skiff_admin 已并入）
-                         3099 Skiff 调试问答页（人工调试面）。🔴 2026-10-15：自造 ACP 面已退役
-                         ⇒ 外部程序化接入改走官方 dsh --profile acp ＋ 现成 ACP 客户端
+                         3099 Skiff 调试问答页（人工调试面）。外部程序化接入用官方 dsh --profile acp
+                         ＋ 现成 ACP 客户端；本插件不提供 ACP 面
   ⑤ 自主与接入        → cognitive_trajectory send-now（跨轨迹的**即时**递送，**不排队**：live 目标在跑就当场注入当前轮、空闲则立即起轮；非 live 冷载入——等效于直接 wake；**有同步回执**）
                          cognitive_trajectory send-later（跨轨迹的"未来时刻 + 一条 message"；fire-and-forget，无回执无回收）
                          weixin 微信桥（配置/扫码/路由/消息 hook——CCC 侧 weixin-doctor MSM：msm("weixin-doctor", ["guide"])）
@@ -14990,8 +14989,6 @@ const FILE_UPLOAD_PATH = "/serenity/file-upload";
 const CONFIG_PATH = "/serenity/config";
 const CCCS_PATH = "/serenity/cccs";
 const WEIXIN_PATH = "/serenity/weixin";
-/** 🔴 v1.59.1：ACP 账户台账（面板数据面；形状照 `/serenity/weixin`） */
-const ACP_PATH = "/serenity/acp";
 /** 图片落盘目录（CCC 根相对；S142 图片自动识别基础设施——粘贴图片落盘供 agent 经 CCC vlm MSM 自主处理） */
 const IMAGE_UPLOAD_DIR = "_tmp/images_from_user";
 const IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
@@ -15117,17 +15114,42 @@ function requireWebUi(req, res, message) {
 	return false;
 }
 /**
-* 从请求参数解析 workspace：优先 sessionId → 会话 header.cwd；其次 workspace 参数；
-* 无参 → 遍历 live sessions 找第一个 CCC 会话的 cwd（远程访问时 sessionId 可能缺失，
-* 回退 process.cwd()=$HOME 会错误显示"未激活"——v1.22.2 修复）；最后进程 cwd。
-* 纯逻辑（可单测）：resolveWorkspaceCore(sessionCwd, workspaceParam, listCwds)。
+* 从请求参数解析 workspace：sessionId → 会话 header.cwd；其次 workspace 参数；
+* 再次**唯一**的 CCC 会话 cwd；最后进程 cwd。
+*
+* 🔴🔴 **2026-10-18 修缺陷（owner 报「在别的 CCC 点开显示的还是 home-serenity 的信息」）**：
+* 旧实现第 ③ 步是「**遍历 live sessions 找第一个 CCC 会话的 cwd**」—— 那是**跨工作区猜测**：
+* 只要 sessionId 缺失或那条会话查不到（ACP/skiff 会话、尚未 materialize 的会话、远程访问），
+* 它就会**静默返回另一个 CCC 的路径**，于是面板把**别人的轨迹/技能/安全模式**当成你的显示出来。
+* 这比"显示未激活"危险得多 —— 用户会据此做判断（以为自己的 safe-mode 开着、以为那是自己的轨迹）。
+*
+* 修法与既有先例一致（`rebuild.ts` 对"跨轨迹猜测"的裁决：**响亮失败优于静默接错**）：
+* **多个候选 ⇒ 不猜**。只有当 live sessions 里的 CCC 根**唯一**时才采用它
+* （那正是 v1.22.2 要救的场景：单 CCC 部署 + 远程访问缺 sessionId）；
+* 一旦出现**两个及以上**不同 CCC 根，就退回进程 cwd（→ 面板显示"未激活"），绝不挑一个顶替。
+*
+* @param sessionCwd sessionId 查到的会话 cwd（最权威）
+* @param workspaceParam 显式 workspace 参数
+* @param listCwds 枚举 live sessions 的 cwd（用于"唯一 CCC"兜底）
+* @param fallback 最后兜底（进程 cwd）
 */
 function resolveWorkspaceCore(sessionCwd, workspaceParam, listCwds, fallback) {
 	if (sessionCwd) return sessionCwd;
 	if (workspaceParam) return workspaceParam;
-	for (const cwd of listCwds()) if (cwd && cccRootForCwd(cwd)) return cwd;
+	const roots = /* @__PURE__ */ new Set();
+	for (const cwd of listCwds()) {
+		if (!cwd) continue;
+		const r = cccRootForCwd(cwd);
+		if (r) roots.add(r);
+	}
+	if (roots.size === 1) return [...roots][0];
 	return fallback;
 }
+/**
+* 解析本次请求所属的 workspace。
+* 🔴 2026-10-18：导出给 `registerVoyageApi` 复用（航行页词表按当前 CCC 注入）——
+* **单一真相源**，⛔ 不让调用方另写一份"找 CCC"的逻辑。
+*/
 function resolveWorkspace(ctx, params) {
 	let sessionCwd;
 	if (params.sessionId) sessionCwd = (hostSessions(ctx)?.get?.(params.sessionId))?.header?.cwd;
@@ -15311,11 +15333,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 					const { weixinBridgeStatus } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { readWeixinCredential } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+					const { readWeixinCredential } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 					const accounts = (settings.accounts ?? []).map((a) => ({
 						accountId: a.accountId,
 						name: a.name ?? void 0,
@@ -15347,7 +15369,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { fetchQRCode } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
 					const { randomUUID } = await import("node:crypto");
 					for (const [key, v] of weixinLogins) if (Date.now() - v.startedAt > WEIXIN_LOGIN_TTL_MS) weixinLogins.delete(key);
-					const { readWeixinSettings } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15368,7 +15390,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+					const { removeWeixinAccount } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -15381,7 +15403,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
 						return;
 					}
-					const { saveWeixinRoutes } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+					const { saveWeixinRoutes } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 					const { readSkiffRoles } = await import("./skiff-role-Boc4SKct.js").then((n) => n.d);
 					const roles = readSkiffRoles(root);
 					for (const r of routes) if (!roles.has(r.role)) {
@@ -15394,7 +15416,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -15438,7 +15460,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
-				const { readWeixinSettings } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+				const { readWeixinSettings } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15453,7 +15475,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
 						const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -15537,7 +15559,6 @@ function registerStatusApi(ctx, opts = {}) {
 			}
 		}
 	});
-	registerAcpAccountsApi(ctx);
 }
 /** 进行中的扫码登录（loginKey → 状态；进程内，5min 有效） */
 const weixinLogins = /* @__PURE__ */ new Map();
@@ -15558,98 +15579,125 @@ function requireCcc(root) {
 		root: serenityRoot
 	};
 }
-/** ACP 账户台账端点（面板专用；形状照 `/serenity/weixin`） */
-function registerAcpAccountsApi(ctx) {
-	ctx.webServer.register({
-		kind: "exact",
-		path: ACP_PATH,
-		handler: async (req, res) => {
-			try {
-				if (!requireWebUi(req, res, "ACP 账户配置仅限 WebUI（client 专用）")) return;
-				const url = new URL(req.url ?? "/", "http://127.0.0.1");
-				if (req.method === "GET") {
-					const chk = requireCcc(url.searchParams.get("ccc") ?? void 0);
-					if (!chk.ok) {
-						sendJson$3(res, 400, { error: chk.error });
-						return;
-					}
-					const { acpChannelStatus, listAcpRoots } = await Promise.resolve().then(() => acp_auth_exports);
-					const { listCccs } = await import("./ccc-roots-RMzGU-CJ.js").then((n) => n.a);
-					const st = acpChannelStatus(chk.root);
-					const all = (await listCccs(ctx)).map((e) => e.root);
-					sendJson$3(res, 200, {
-						channel: st.channel,
-						enabled: st.enabled,
-						accounts: st.accounts,
-						roots: listAcpRoots(all)
-					});
-					return;
-				}
-				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
-					return;
-				}
-				const raw = await readBody$3(req, 65536);
-				const body = JSON.parse(raw);
-				const chk = requireCcc(body.ccc);
-				if (!chk.ok) {
-					sendJson$3(res, 400, { error: chk.error });
-					return;
-				}
-				const root = chk.root;
-				const acp = await Promise.resolve().then(() => acp_auth_exports);
-				if (body.action === "upsert") {
-					const account = acp.normalizeAcpAccount(body.account);
-					if (!account) {
-						sendJson$3(res, 400, { error: "invalid account (accountId 与 role 均必填)" });
-						return;
-					}
-					const { readSkiffRoles } = await import("./skiff-role-Boc4SKct.js").then((n) => n.d);
-					const roles = readSkiffRoles(root);
-					if (!roles.has(account.role)) {
-						sendJson$3(res, 400, { error: `role "${account.role}" 不在该 CCC 的 skiff.roles 里（现有：${[...roles.keys()].join(", ") || "无"}）` });
-						return;
-					}
-					acp.upsertAcpAccount(root, account);
-					const created = acp.ensureAcpChannelTokens(root).includes(account.accountId);
-					sendJson$3(res, 200, {
-						saved: true,
-						accounts: acp.acpChannelStatus(root).accounts,
-						token: created ? acp.readAcpToken(root, account.accountId) : void 0
-					});
-					return;
-				}
-				if (body.action === "remove") {
-					const accountId = typeof body.accountId === "string" ? body.accountId.trim() : "";
-					if (accountId === "") {
-						sendJson$3(res, 400, { error: "missing accountId" });
-						return;
-					}
-					acp.removeAcpAccount(root, accountId);
-					sendJson$3(res, 200, {
-						removed: accountId,
-						accounts: acp.acpChannelStatus(root).accounts
-					});
-					return;
-				}
-				if (body.action === "rotate") {
-					const accountId = typeof body.accountId === "string" ? body.accountId.trim() : "";
-					if (accountId === "") {
-						sendJson$3(res, 400, { error: "missing accountId" });
-						return;
-					}
-					sendJson$3(res, 200, {
-						rotated: accountId,
-						token: acp.resetAcpToken(root, accountId)
-					});
-					return;
-				}
-				sendJson$3(res, 400, { error: `unknown action: ${String(body.action)}` });
-			} catch (err) {
-				sendJson$3(res, 400, { error: err?.message ?? String(err) });
-			}
+//#endregion
+//#region src/voyage-vocab.ts
+/**
+* voyage-vocab.ts — 航行页词表改为**按当前 CCC 运行时注入**（纯逻辑，零 DSH 依赖）
+*
+* ## 为什么需要它（owner 2026-10-18 报的缺陷）
+* 资产 `assets/serenity-voyage.html` 的词表是**构建期扫描容器写死的常量**：
+*   `var VOCAB = {"skills":[...],"msms":[...],"zh":[...],"onto":[...],"counts":{...}}`
+* v2 改版把"写死名单"改成"构建期扫描"是为防名单漂移——方向对，但代价是：
+* **一份静态资产只能属于一个 CCC**。于是任何别的 CCC 打开动画，看到的都是
+* **构建它的那个 CCC** 的技能/工具/本体名字与计数。owner 原话：
+* 「为什么我在别的 CCC 点开显示的还是我们 home-serenity 的信息」「动画也有这个毛病」。
+*
+* ## 修法（owner 裁决：运行时按当前 CCC 注入）
+* 资产**保持静态**（一份文件服务所有 CCC，永不漂）；由它的**服务端路由**在返回前
+* 把 `var VOCAB = {...};` 那一行替换成从该请求所属 CCC 实况读出的词表。
+*
+* 三条判据（R↓）：
+*  ① **只替换那一行**（锚 = 行首 `var VOCAB = ` 到行尾 `;`）—— 资产里其余 3000+ 行
+*    three.js / 渲染代码**一个字节都不动**。
+*  ② **读不出来就走原样**：锚认不出、或原 VOCAB 解析失败 ⇒ **返回入参本身**，不报错。
+*    航行页是**装饰**，不该因为某个 CCC 缺目录、或资产结构变了就打不开（旁路容忍铁律）。
+*  ③ **`zh` 不来自容器**：中文隐喻词是作品的语汇装饰，属资产自身 ⇒ 注入时**保留原值**。
+*    实现上不"重建"整个对象，而是**在原对象上覆盖**四个实况键 —— 未列出的键自动保留。
+*/
+/** 资产里那一行的锚 —— `var VOCAB = {...};`（`.*?` 非贪婪 + 行尾分号） */
+const VOCAB_LINE_RE = /^var VOCAB = (\{.*\});[ \t]*$/m;
+/**
+* 扫描一个 CCC 的实况词表。**每一项独立容错**：任一来源缺失/读坏 ⇒ 该项为空，其余照常。
+*
+* | 字段 | 来源 | 为什么是它 |
+* |---|---|---|
+* | `skills` | `.opencode/skills/` 下含 `SKILL.md` 的目录名 | 与状态面板同一条判据 |
+* | `msms` | `mech-registry.json` 的注册名 | **MSM 的唯一真相源** |
+* | `onto` | `.opencode/skills/` 下含 `skill.ttl` 的目录名 | 增强型（建模过）的 skill |
+* | `counts` | 上述长度 ＋ 轨迹数 | 计数与词表同源，否则 HUD 与星场对不上 |
+*
+* @param root CCC 根
+*/
+function scanVoyageLiveVocab(root) {
+	const skills = scanSkillDirs(root, "SKILL.md");
+	const onto = scanSkillDirs(root, "skill.ttl");
+	const msms = scanMsmNames(root);
+	return {
+		skills,
+		msms,
+		onto,
+		counts: {
+			skill: skills.length,
+			msm: msms.length,
+			onto: onto.length,
+			session: scanTrajectoryCount(root)
 		}
-	});
+	};
+}
+/** 技能名：`.opencode/skills/<name>/<marker>` 存在的目录名（marker = `SKILL.md` 或 `skill.ttl`） */
+function scanSkillDirs(root, marker) {
+	const dir = join(root, ".opencode", "skills");
+	try {
+		if (!existsSync(dir)) return [];
+		return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync(join(dir, e.name, marker))).map((e) => e.name).sort();
+	} catch {
+		return [];
+	}
+}
+/**
+* MSM 名：读 `mech-registry.json` 的 `msms[].name`。
+*
+* 🔴 **为什么不扫 `scripts/`**：注册表是 MSM 的**唯一真相源**；扫目录会把共享库
+* （`dev-kit/`、`lib/*`）也算成 MSM —— 本仓对"入口判据"已翻车多次。
+* ⚠️ 注册表若换了位置 ⇒ **静默降级为空**（装饰页不该因此打不开）。
+*/
+function scanMsmNames(root) {
+	const candidates = [join(root, ".opencode", "skills", "home-serenity", "references", "mech-registry.json"), join(root, ".opencode", "references", "mech-registry.json")];
+	for (const p of candidates) try {
+		if (!existsSync(p)) continue;
+		const names = (JSON.parse(readFileSync(p, "utf-8")).msms ?? []).map((m) => typeof m?.name === "string" ? m.name : "").filter((n) => n !== "");
+		if (names.length > 0) return [...new Set(names)].sort();
+	} catch {}
+	return [];
+}
+/** 轨迹数：`AGENT_SESSIONS/` 下非 `_` / `.` 前缀的目录（与轨迹层"活跃"判据一致） */
+function scanTrajectoryCount(root) {
+	const dir = join(root, "AGENT_SESSIONS");
+	try {
+		if (!existsSync(dir)) return 0;
+		return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => !e.name.startsWith("_") && !e.name.startsWith(".")).length;
+	} catch {
+		return 0;
+	}
+}
+/**
+* 把实况词表注入资产 HTML。
+*
+* 做法 = **在原 VOCAB 对象上覆盖**四个实况键（不重建整个对象）⇒ `zh` 等装饰键自动保留。
+* 任一环节不成立就**原样返回**（见文件头判据②），因此：
+* @returns 注入后的 HTML；未注入时**与入参逐字节相同**
+*/
+function injectVoyageVocab(html, live) {
+	if (live === null) return html;
+	const m = VOCAB_LINE_RE.exec(html);
+	if (!m) return html;
+	let base;
+	try {
+		base = JSON.parse(m[1]);
+	} catch {
+		return html;
+	}
+	const merged = {
+		...base,
+		skills: live.skills,
+		msms: live.msms,
+		onto: live.onto,
+		counts: {
+			...typeof base.counts === "object" && base.counts !== null ? base.counts : {},
+			...live.counts
+		}
+	};
+	return html.replace(VOCAB_LINE_RE, () => `var VOCAB = ${JSON.stringify(merged)};`);
 }
 //#endregion
 //#region src/voyage-page.ts
@@ -15688,6 +15736,9 @@ function sendJson$2(res, status, body) {
 /**
 * 注册 `/serenity/voyage`（GET）。
 * @param opts.assetPath 覆盖资产路径（测试用；生产不传）
+* @param opts.resolveRoot 解析本次请求所属 CCC 根（生产由 api.ts 的 resolveWorkspace 提供）。
+*   🔴 **2026-10-18 新增**：词表按请求所属 CCC **运行时注入**（owner 报「在别的 CCC 点开
+*   显示的还是 home-serenity 的信息」）。不传 ⇒ 不注入（保持资产原样 = 旧行为）。
 */
 function registerVoyageApi(ctx, opts = {}) {
 	ctx.webServer.register({
@@ -15705,9 +15756,18 @@ function registerVoyageApi(ctx, opts = {}) {
 				sendJson$2(res, 500, { error: `voyage asset unavailable: ${err?.message ?? String(err)}` });
 				return;
 			}
+			let root = null;
+			try {
+				root = opts.resolveRoot?.(req) ?? null;
+			} catch {
+				root = null;
+			}
+			if (root !== null) try {
+				html = injectVoyageVocab(html, scanVoyageLiveVocab(root));
+			} catch {}
 			res.statusCode = 200;
 			res.setHeader("content-type", "text/html; charset=utf-8");
-			res.setHeader("cache-control", "private, max-age=86400");
+			res.setHeader("cache-control", root !== null ? "no-cache" : "private, max-age=86400");
 			res.setHeader("content-length", String(Buffer.byteLength(html)));
 			res.end(html);
 		}
@@ -21648,1120 +21708,6 @@ function registerWeixinSendApi(ctx) {
 	sync();
 }
 //#endregion
-//#region src/acp-auth.ts
-/**
-* acp-auth.ts — ACP 面的**认证 ＋ 身份**层（v1.59.0，owner 2026-10-17 令）
-*
-* ## 它解决什么
-*
-* owner 令（逐字）：「将微信桥升级为 IM 桥，每个 CCC 可以选择微信实现或 ACP 实现，
-* 微信实现保留不变向前兼容，**ACP 实现就可以暴露端口并绑定 skiff，并且要随即生成认证用的 token**」。
-*
-* 面 E（`acp-face.ts`）原本**无认证、无 CCC 归属、无角色** —— 本模块补上这三件：
-*   ① **token**：每 CCC 一枚，落**该 CCC 的 localstore**（credential scope）。
-*   ② **CCC 归属**：连接建立时由 token 反查 ⇒ **服务端权威**（不拿客户端自述的 `cwd` 当身份）。
-*   ③ **角色**：该 CCC 的 `im.acp.role` ⇒ 供装配层把 ACP 会话套上 skiff 角色。
-*
-* ## 🔴 架构决策：一面多 token，不是每 CCC 一个端口
-*
-* | | 甲：每 CCC 一个端口 | **乙：一面多 token** ← 选它 |
-* |---|---|---|
-* | 端口 | 随 CCC 数增长 | **固定 3200** |
-* | 身份来源 | 端口号 | **token（一一对应 CCC）** |
-*
-* **判据**：`token → CCC` 是一一对应，而 `cwd` 是**客户端可填的**。
-* ⇒ 用 token 定 CCC 比用 cwd 定 CCC 强：前者**服务端权威**，后者**客户端自述**。
-* ⇒ 连接一建立就知道"这是哪个 CCC"，**该连接的所有会话都归它**，角色绑定无需猜。
-* ⚠️ `cwd` 仍要校验（见 `cwdInsideRoot`）：防一枚 token 越权到别的 CCC。
-*
-* ## 🔴 为什么认证放在 WS upgrade 层，而不在 ACP 协议里
-*
-* `dsh-acp` 的 `authenticate()` **恒成功**且 `authMethods: []`（读其 `lib/index.js` 逐字），
-* 且它**不导出**可替换的认证缝 ⇒ 改协议层要重写它的接线（P0′ 已实测此路不通）。
-* 而**我们自己持有 HTTP server**（自持面）⇒ 在 `upgrade` **升级之前**校验，
-* 失败即 `401 ＋ destroy` ⇒ **连接根本进不来**。
-*
-* ## 边界
-*
-* 本模块**零 DSH 依赖**（只 `node:crypto` ／ `node:fs` ／ `node:path` 与本仓纯逻辑）⇒ 可独立单测。
-*/
-var acp_auth_exports = /* @__PURE__ */ __exportAll({
-	acpChannelEnabled: () => acpChannelEnabled,
-	acpChannelStatus: () => acpChannelStatus,
-	acpSessionKeyFor: () => acpSessionKeyFor,
-	acpTokenKeyFor: () => acpTokenKeyFor,
-	cwdInsideRoot: () => cwdInsideRoot,
-	ensureAcpChannelTokens: () => ensureAcpChannelTokens,
-	ensureAcpToken: () => ensureAcpToken,
-	expandAcpAccounts: () => expandAcpAccounts,
-	extractToken: () => extractToken,
-	listAcpRoots: () => listAcpRoots,
-	normalizeAcpAccount: () => normalizeAcpAccount,
-	readAcpMainSession: () => readAcpMainSession,
-	readAcpToken: () => readAcpToken,
-	readImSettings: () => readImSettings,
-	removeAcpAccount: () => removeAcpAccount,
-	resetAcpToken: () => resetAcpToken,
-	resolveTokenAccount: () => resolveTokenAccount,
-	safeEqual: () => safeEqual,
-	saveAcpAccounts: () => saveAcpAccounts,
-	tokenFingerprint: () => tokenFingerprint,
-	upsertAcpAccount: () => upsertAcpAccount,
-	writeAcpMainSession: () => writeAcpMainSession
-});
-/** 多账户凭据键前缀（`IM_ACP_TOKEN_<ACCOUNT_ID>`；与微信桥 `WEIXIN_<ID>_<FIELD>` 同构） */
-const ACP_TOKEN_PREFIX = "IM_ACP_TOKEN_";
-/**
-* `accountId` → UPPER_SNAKE 片段（`agmente-phone` → `AGMENTE_PHONE`）。
-*
-* 🔴 **与 `weixin-route.ts` 的 `accountKeyPart` 逐字同规则** —— 刻意复制而非共享：
-*    两者属不同子域（微信 vs ACP），共享会让"改微信键规则"意外改掉 ACP 的既有凭据键，
-*    而凭据键**改一次就等于全体客户端掉线**。⇒ 用"同规则的两份"换"互不牵连"。
-*/
-function accountKeyPart(accountId) {
-	return accountId.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
-}
-/** 该账户的凭据键（`IM_ACP_TOKEN_<ACCOUNT_ID>`）；`accountId` 必填 */
-function acpTokenKeyFor(accountId) {
-	return `${ACP_TOKEN_PREFIX}${accountKeyPart(accountId)}`;
-}
-/** token 字节数（32 B = 256 bit；hex 后 64 字符） */
-const TOKEN_BYTES = 32;
-/**
-* 该**账户**的 ACP token（**读**；不存在返回 null）。
-*
-* 🔴 **不自动生成** —— 生成是**写操作**，只在显式要求时做（`ensureAcpToken`）。
-*    读路径永远无副作用：否则每次判定都会改 localstore。
-*
-* @param accountId 账户键（必填 —— 凭据按账户分离，没有"CCC 默认 token"这回事）
-*/
-function readAcpToken(root, accountId) {
-	try {
-		const value = getEntry(root, "credential", acpTokenKeyFor(accountId));
-		return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
-	} catch {
-		return null;
-	}
-}
-/**
-* 生成（或返回既有）ACP token 并落该 CCC 的 localstore。
-*
-* ⚠️ **幂等**：已有 token 时**原样返回**（不轮换）—— 轮换会让在用的客户端立刻断线，
-*    必须是一次显式动作（`resetAcpToken`）。
-*
-* @param accountId 多账户时指明哪个账户；省略 ＝ 单账户简写键
-*/
-function ensureAcpToken(root, accountId) {
-	const existing = readAcpToken(root, accountId);
-	if (existing) return existing;
-	const token = randomBytes(TOKEN_BYTES).toString("hex");
-	writeEntry(root, "credential", acpTokenKeyFor(accountId), token);
-	return token;
-}
-/**
-* 轮换 token（显式动作；返回新值）。旧 token 立即失效。
-* @param accountId 账户键
-*/
-function resetAcpToken(root, accountId) {
-	const token = randomBytes(TOKEN_BYTES).toString("hex");
-	writeEntry(root, "credential", acpTokenKeyFor(accountId), token);
-	return token;
-}
-/**
-* 常时比较（防时序侧信道）。
-*
-* 🔴 两个长度不等时 `timingSafeEqual` **会抛** ⇒ 先比长度并立刻返回 false。
-*    ⚠️ 那一步本身**泄漏长度**（可接受：token 长度固定且公开）。
-*/
-function safeEqual(a, b) {
-	const bufA = Buffer.from(a, "utf8");
-	const bufB = Buffer.from(b, "utf8");
-	if (bufA.length !== bufB.length) return false;
-	return timingSafeEqual(bufA, bufB);
-}
-/** token 指纹（诊断面用；不可逆） */
-function tokenFingerprint(token) {
-	return createHash("sha256").update(token).digest("hex").slice(0, 12);
-}
-/** 主会话键前缀（`IM_ACP_SESSION_<ACCOUNT_ID>`；与 `IM_ACP_TOKEN_<ACCOUNT_ID>` 同族同规则） */
-const ACP_SESSION_PREFIX = "IM_ACP_SESSION_";
-/**
-* 该账户的**主会话**键（`IM_ACP_SESSION_<ACCOUNT_ID>`）。
-*
-* 🔴 为什么放在 **credential** 节而不是 config 节：它跟 token 一样是**每账户一值的键控数据**
-*    （键由 `accountId` 派生、随账户生命周期存亡）。放 config 节要另造一层 `section.key`
-*    结构，而这一层的唯一读者就是本模块 ⇒ 多一层结构 = 多一处会漂的形状。
-*
-* ⚠️ 它**不是凭据**（会话 id 不是秘密）—— 共享 credential 节只是为了复用它既有的
-*    「按 accountId 派生键 ＋ 删账户时一并清理」这套语义，不引入第二套键规则。
-*/
-function acpSessionKeyFor(accountId) {
-	return `${ACP_SESSION_PREFIX}${accountKeyPart(accountId)}`;
-}
-/**
-* 读该账户的主会话 id（不存在 ⇒ `null`）。
-*
-* 🔴 **读路径无副作用**（与 `readAcpToken` 同纪律）：不存在的含义是「这个账户还没有主会话」，
-*    而那时的正确行为是**让 App 去建**（`session/list` 回空数组），不是替它编一个。
-*/
-function readAcpMainSession(root, accountId) {
-	try {
-		const value = getEntry(root, "credential", acpSessionKeyFor(accountId));
-		return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
-	} catch {
-		return null;
-	}
-}
-/**
-* 记下该账户的主会话 id（**写操作**；由 `session/new` 的出站响应触发）。
-*
-* 🔴 **后写覆盖先写**（last-wins）：owner 要的是"一条长期对话"，而"再建一条"是用户
-*    在 App 里显式点「新对话」的结果 ⇒ 那时他要的就是**新的那条**。
-*    ⛔ **被否的两种做法**：① 已有主会话就拒建（用户会看到"点了没反应"）；
-*    ② 把 `session/new` 改写成 `session/resume`（响应形状不同，要让客户端认一条
-*    **不存在于协议里**的响应 —— 那是拿协议兼容性换一个我们本来就有的语义）。
-*/
-function writeAcpMainSession(root, accountId, sessionId) {
-	const id = String(sessionId ?? "").trim();
-	if (id === "") return;
-	writeEntry(root, "credential", acpSessionKeyFor(accountId), id);
-}
-/**
-* 从一次 HTTP upgrade 请求里取出候选 token。
-*
-* 两种携带方式都认（客户端差异；Agmente 等用具名头，脚本常用查询串）：
-*   ① `Authorization: Bearer <t>`
-*   ② `?token=<t>`（查询串）
-*
-* @returns 取到的 token；两者都无 → null
-*/
-function extractToken(headers, url) {
-	const auth = headers["authorization"];
-	if (typeof auth === "string") {
-		const m = /^Bearer\s+(.+)$/i.exec(auth.trim());
-		if (m?.[1]) return m[1].trim();
-	}
-	if (typeof url === "string" && url !== "") try {
-		const q = new URL(url, "http://placeholder.invalid").searchParams.get("token");
-		if (q && q.trim() !== "") return q.trim();
-	} catch {}
-	return null;
-}
-/**
-* 把该 CCC 的配置**展开成账户列表**（读时现算，**无快照**）。
-*
-* 🔴 **`im.acp.accounts` 是必填项** —— 没有它就没有账户，**一个都认证不了**。
-*    刻意**不提供**"单账户简写"退回路径（v1.59.1）：那会多出一条永不生效的分支，
-*    而它的唯一作用是把"配置写错了"伪装成"用了简写"。
-*
-* 判据（三条都由调用方以 fail-closed 消费）：
-*  - `enabled !== false`（缺省 true）
-*  - `role` 非空（空 ⇒ 该账户**不出现**在列表里 ⇒ 必然登录失败）
-*  - token 存在（不存在 ⇒ 同样不出现）
-*
-* ⚠️ 本函数**纯读，绝不生成 token** —— 生成是写操作，归 `ensureAcpChannelTokens`。
-*    这样 upgrade 路径可以随时现算而不冒"每次连接都写 localstore"的风险。
-*/
-function expandAcpAccounts(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const im = readImSettings(root, paths);
-	if (im.channel !== "acp" || im.acp.enabled !== true) return [];
-	const declared = Array.isArray(im.acp.accounts) ? im.acp.accounts : [];
-	const out = [];
-	for (const a of declared) {
-		if (typeof a !== "object" || a === null) continue;
-		if (a.enabled === false) continue;
-		const accountId = typeof a.accountId === "string" ? a.accountId.trim() : "";
-		if (accountId === "") continue;
-		const role = typeof a.role === "string" ? a.role.trim() : "";
-		if (role === "") continue;
-		const token = readAcpToken(root, accountId);
-		if (!token) continue;
-		out.push({
-			root,
-			accountId,
-			tokenKey: acpTokenKeyFor(accountId),
-			token,
-			role
-		});
-	}
-	return out;
-}
-/**
-* **让配置里声明的账户都拥有 token**（写操作；幂等；由装配层与配置变更时调用）。
-*
-* 🔴 owner 令「**随即生成**认证用的 token」的落地点。与 v1.59.0 的差别：
-*    那时只在**启动**时跑一次 ⇒ 加一台设备要重启；现在**任何一次判定前都可以跑**，
-*    且撤账户后不会被"复活"（只对**当前声明里**的账户生成）。
-*
-* @returns 本次**新生成**的账户键列表（已存在的原样返回，不轮换）
-*/
-function ensureAcpChannelTokens(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const im = readImSettings(root, paths);
-	if (im.channel !== "acp" || im.acp.enabled !== true) return [];
-	const declared = Array.isArray(im.acp.accounts) ? im.acp.accounts : [];
-	const created = [];
-	for (const a of declared) {
-		if (typeof a !== "object" || a === null) continue;
-		if (a.enabled === false) continue;
-		const accountId = typeof a.accountId === "string" ? a.accountId.trim() : "";
-		if (accountId === "") continue;
-		try {
-			if (!readAcpToken(root, accountId)) {
-				ensureAcpToken(root, accountId);
-				created.push(accountId);
-			}
-		} catch {}
-	}
-	return created;
-}
-/**
-* 校验一枚候选 token，返回它归属的**账户**（未命中返回 null）。
-*
-* @param candidate 客户端出示的 token
-* @param roots 候选 CCC 根集合（由调用方枚举——本模块不认识"CCC 在哪"）
-*/
-function resolveTokenAccount(candidate, roots, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	if (!candidate) return null;
-	for (const root of roots) for (const acct of expandAcpAccounts(root, paths)) if (safeEqual(candidate, acct.token)) return acct;
-	return null;
-}
-/**
-* 枚举**有可用 ACP 账户**的 CCC（供准入名单用）。
-*
-* 判据：`im.channel === 'acp'` ∧ `im.acp.enabled === true` ∧ **至少一个账户有 token 且配了角色**。
-* ⚠️ 缺一即不算（fail-closed：宁可连不上，不可放行一个半配置的通道）。
-*/
-function listAcpRoots(roots, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const out = [];
-	for (const root of roots) if (expandAcpAccounts(root, paths).length > 0) out.push(root);
-	return out;
-}
-/** 读该 CCC 的 `im` 段（未配置 ⇒ 归一缺省；永不 undefined） */
-function readImSettings(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	try {
-		const im = loadSerenityConfig(root, paths).im;
-		if (!im || typeof im !== "object") return {
-			channel: "weixin",
-			acp: {}
-		};
-		return {
-			channel: im.channel === "acp" ? "acp" : "weixin",
-			acp: im.acp && typeof im.acp === "object" ? im.acp : {}
-		};
-	} catch {
-		return {
-			channel: "weixin",
-			acp: {}
-		};
-	}
-}
-/**
-* 该 CCC 是否启用 ACP 入站通道。
-*
-* 🔴 **两个条件都真才算**：`im.channel === 'acp'` **且** `im.acp.enabled === true`。
-*    为什么双键：`channel` 表达"选了哪条路"，`enabled` 表达"现在开不开" ⇒
-*    让 owner 能**选好 ACP 但暂时关着**（不用删配置），与既有各面的 `enabled` 范式一致。
-*/
-function acpChannelEnabled(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const im = readImSettings(root, paths);
-	return im.channel === "acp" && im.acp.enabled === true;
-}
-/**
-* 客户端 `session/new` 传来的 `cwd` 是否落在该 token 归属的 CCC 内。
-*
-* 🔴 **为什么必须校验**：token 定的是"哪个 CCC"，而 `cwd` 由**客户端**指定。
-*    不校验 ⇒ 一枚 CCC A 的 token 可以把会话开到 CCC B（越权读到另一个 CCC 的上下文）。
-*    这与 CCC 自身的路径围墙（P3）是同一条纪律，只是发生在**接入**这一层。
-*
-* 判据用 `relative()` 而非 `startsWith`（后者会把 `/a/bc` 误判为在 `/a/b` 内）。
-*/
-function cwdInsideRoot(cwd, root) {
-	if (!isAbsolute(cwd)) return false;
-	const rel = relative(resolve(root), resolve(cwd));
-	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
-}
-/** 该 CCC 的 ACP 通道对外**可见形态**（诊断面用；**绝不含 token 明文**） */
-function acpChannelStatus(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const im = readImSettings(root, paths);
-	const declared = Array.isArray(im.acp.accounts) ? im.acp.accounts : [];
-	const usable = new Set(expandAcpAccounts(root, paths).map((a) => a.accountId));
-	const accounts = [];
-	for (const a of declared) {
-		if (typeof a !== "object" || a === null) continue;
-		const accountId = typeof a.accountId === "string" ? a.accountId.trim() : "";
-		if (accountId === "") continue;
-		const role = typeof a.role === "string" && a.role.trim() !== "" ? a.role.trim() : null;
-		const token = readAcpToken(root, accountId);
-		const enabled = a.enabled !== false;
-		let blockedBy = null;
-		if (!enabled) blockedBy = "该账户 enabled=false";
-		else if (!role) blockedBy = "未配 role";
-		else if (!token) blockedBy = "尚无 token（保存配置后自动生成）";
-		accounts.push({
-			accountId,
-			name: typeof a.name === "string" && a.name.trim() !== "" ? a.name.trim() : null,
-			role,
-			enabled,
-			hasToken: token !== null,
-			tokenFingerprint: token ? tokenFingerprint(token) : null,
-			mainSession: readAcpMainSession(root, accountId),
-			usable: usable.has(accountId),
-			blockedBy
-		});
-	}
-	return {
-		channel: im.channel,
-		enabled: acpChannelEnabled(root, paths),
-		accounts
-	};
-}
-/**
-* 读取 serenity.json 原文（不存在 → 空对象）。
-*
-* ⚠️ 与 `weixin-route.ts` 的同名函数**刻意各写一份**：两者写的是**不同段**
-* （`weixin` vs `im.acp.accounts`），共用一个会在"某天只想改其中一段"时
-* 意外把另一段也重写一遍。同规则两份 > 一个会互相牵连的共用件。
-*/
-function readRawConfig(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	for (const candidate of paths) {
-		const p = resolve(root, candidate);
-		if (existsSync(p)) try {
-			const v = JSON.parse(readFileSync(p, "utf-8").replace(/^\uFEFF/, ""));
-			if (v && typeof v === "object" && !Array.isArray(v)) return v;
-		} catch {
-			return {};
-		}
-	}
-	return {};
-}
-/**
-* 写回 `im.acp.accounts`（保留文件里其余所有字段）。
-*
-* 🔴 **只碰这一个键**：`im.channel` / `im.acp.enabled` 归面板总开关与人工配置，
-*    本函数不越权改它们（否则"加一台设备"会顺手把通道开关也改了）。
-*/
-function saveAcpAccounts(root, accounts, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const target = resolve(root, paths[0] ?? ".opencode/serenity.json");
-	const raw = readRawConfig(root, paths);
-	const im = raw.im && typeof raw.im === "object" ? raw.im : {};
-	const acp = im.acp && typeof im.acp === "object" ? im.acp : {};
-	acp.accounts = accounts;
-	im.acp = acp;
-	raw.im = im;
-	const dir = resolve(target, "..");
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	writeFileSync(target, JSON.stringify(raw, null, 2) + "\n", "utf-8");
-	return accounts;
-}
-/**
-* 规范化一条账户声明（面板传入的任意形状 → 合法声明；非法 ⇒ null）。
-*
-* 🔴 返回类型里 `role` 是**必填**（不是 `ImAcpAccount` 的可选形态）——
-*    本函数的契约就是"要么给一个角色齐备的账户，要么给 null"。
-*    这样调用方**不必再判一次** `role` 有没有（那正是会漂的第二处判据）。
-*/
-function normalizeAcpAccount(input) {
-	if (typeof input !== "object" || input === null) return null;
-	const a = input;
-	const accountId = typeof a.accountId === "string" ? a.accountId.trim() : "";
-	if (accountId === "") return null;
-	const role = typeof a.role === "string" ? a.role.trim() : "";
-	if (role === "") return null;
-	const out = {
-		accountId,
-		role
-	};
-	if (typeof a.name === "string" && a.name.trim() !== "") out.name = a.name.trim();
-	if (a.enabled === false) out.enabled = false;
-	return out;
-}
-/** 增／改一条账户（按 accountId 定位；写入后返回全表） */
-function upsertAcpAccount(root, account, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const list = [...readImSettings(root, paths).acp.accounts ?? []];
-	const idx = list.findIndex((a) => a.accountId === account.accountId);
-	if (idx >= 0) list[idx] = {
-		...list[idx],
-		...account
-	};
-	else list.push(account);
-	return saveAcpAccounts(root, list, paths);
-}
-/**
-* 删一条账户（**同时清掉它的 token ＋ 主会话**，避免留死键）。
-*
-* 🔴 主会话键**必须一起清**：否则日后用同一个 `accountId` 重建账户时，它会**静默继承**
-*    那条旧会话 —— 而那条会话的 cwd／角色都是上一代账户的。这个失效**没有任何信号**
-*    （列表上它看着就是一条正常会话）。
-*/
-function removeAcpAccount(root, accountId, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const next = saveAcpAccounts(root, (readImSettings(root, paths).acp.accounts ?? []).filter((a) => a.accountId !== accountId), paths);
-	for (const key of [acpTokenKeyFor(accountId), acpSessionKeyFor(accountId)]) try {
-		unsetEntry(root, "credential", key);
-	} catch {}
-	return next;
-}
-//#endregion
-//#region src/acp-face.ts
-/** 面名（面宿主幂等键；与 FACE_PORTS 的 id 同名，便于对账） */
-const FACE_ACP = "acp";
-/**
-* 校验一次 upgrade 请求（**只读**：不改任何状态）。
-*
-* 判据链（任一环失败即拒，fail-closed）：候选 token 缺失 ⇒ 不匹配任何 CCC ⇒
-* 该 CCC 未启用 ACP 通道 ⇒ 该 CCC 未配角色。最后一环尤其重要：**没有角色的 ACP 会话
-* 等于一个无身份、无约束的裸 agent** ⇒ 宁可连不上。
-*/
-function authorizeUpgrade(req) {
-	const candidate = extractToken(req.headers, req.url);
-	if (!candidate) return {
-		ok: false,
-		reason: "未携带 token（用 Authorization: Bearer <t> 或 ?token=<t>）"
-	};
-	const roots = knownAcpRoots();
-	if (roots.length === 0) return {
-		ok: false,
-		reason: "本机没有任何启用了 ACP 通道的 CCC"
-	};
-	const acct = resolveTokenAccount(candidate, roots);
-	if (!acct) return {
-		ok: false,
-		reason: "token 不匹配任何已声明账户的 ACP 通道"
-	};
-	const role = acct.role;
-	if (!role) return {
-		ok: false,
-		reason: `CCC（${acct.root}）账户 ${acct.accountId} 未配 im.acp.accounts[].role`
-	};
-	return {
-		ok: true,
-		root: acct.root,
-		role,
-		accountId: acct.accountId
-	};
-}
-/**
-* CCC 根候选的来源（**只要根，不判配置**）。
-*
-* 🔴 v1.59.1 分层变更：**这份名单是"本机有哪些 CCC"，不是"谁能连 ACP"**。
-*    "谁能连"由 `expandAcpAccounts` 现算（读各 CCC 的 serenity.json ＋ localstore）。
-*    ⇒ 缓存失效的代价从"配错权限"降为"多看/少看一个候选根"，**不再是安全问题**。
-*/
-let knownRoots = [];
-/**
-* 准入名单的现算入口（v1.59.1）。
-*
-* 顺序：**先用已知根**（免 async）→ 逐个 `expandAcpAccounts` 现读配置。
-* 未知根时退回上次枚举的结果（可能稍旧，但只影响"会不会去问它"，不影响是否放行）。
-*
-* ⚠️ 这里是**同步**的（upgrade 回调用）⇒ 不 await、不扫盘。
-*/
-function knownAcpRoots() {
-	return listAcpRoots(knownRoots);
-}
-/**
-* 刷新"本机有哪些 CCC"（async，枚举宿主三来源）。
-*
-* 🔴 **失败必须响亮**：v1.59.0 这里是 `void refresh(...)` 且没有 catch ——
-*    枚举失败会让名单清空 ⇒ **所有连接一律 401**，而现场只有一行 stdout 看不到的日志。
-*    这正是本轨记过的「调用没报错 ≠ 已验证」。
-*
-* @returns 本次枚举到的根数（0 ＝ 一个都没发现，日志会说为什么）
-*/
-async function refreshAcpRoots(ctx) {
-	try {
-		knownRoots = (await listCccs(ctx)).map((e) => e.root);
-		let created = 0;
-		for (const root of knownRoots) try {
-			created += ensureAcpChannelTokens(root).length;
-		} catch (err) {
-			console.warn(`[serenity-hooks] 面 E：为 CCC（${root}）生成 token 失败: ${String(err?.message ?? err)}`);
-		}
-		if (created > 0) console.log(`[serenity-hooks] ✓ 面 E：已为 ${created} 个 ACP 账户生成 token`);
-		return knownRoots.length;
-	} catch (err) {
-		knownRoots = [];
-		const msg = `面 E：CCC 枚举失败（准入名单将为空，所有连接会被拒）: ${String(err?.message ?? err)}`;
-		console.warn(`[serenity-hooks] ${msg}`);
-		state.lastErrors.push({
-			at: Date.now(),
-			applied: false,
-			error: msg
-		});
-		if (state.lastErrors.length > MAX_ERR_KEEP) state.lastErrors.shift();
-		return 0;
-	}
-}
-/**
-* 把**本连接归属的 CCC 角色**套到该连接创建的 agent 上（v1.59.0）。
-*
-* ## 🔴 为什么是"认领"而不是"直接挂"
-*
-* 理想形态是：在本连接的 scoped fiber 里监听 `session/created`，**只**收到本连接建的会话。
-* 但那条路依赖一个**我没有实测过的**引擎行为 —— cordis 的 `EventsService.dispatch()` 只在
-* **派发方设了 `Context.filter`** 时才按 ctx 过滤（读 `@deepseek-ai/cordis/src/events.ts`
-* 的 `.filter(hook => hook.global || !filter || filter.call(thisArg, hook.ctx))`）。
-* ⇒ 若宿主派发 `session/created` 时**没设**过滤器，本监听器会**收到全进程**的会话
-* （网页端、别的轨迹、别的连接），**套错角色**。
-*
-* 🔴 **D119 纪律**：不许照源码的"意图"断言引擎行为 ⇒ 本实现**不赌**那条语义，
-* 改用**认领制**（两条过滤都可以自证，不依赖 filter）：
-*   ① **cwd 必须落在本连接归属的 CCC 内**（token 已定 CCC ⇒ 越界会话直接跳过）；
-*   ② **同一会话只被认领一次**（`claimed` 集合；先到先得 ⇒ 不会被另一条连接的监听器抢走）。
-*
-* ⚠️ **残余风险（如实标注）**：若**同一 CCC** 同时有网页端会话与 ACP 会话在创建，
-*   本函数可能把网页端那个会话也认领了（两者 cwd 都在该 CCC 内）。⇒ 判据是"cwd ＋ 先到先得"，
-*   **不是"确属本连接"**。⚠️ **这一格必须由探针实测**（见 REBUILD-TODO 的待办）；
-*   未实测前**不得**声称"只套本连接的会话"。
-*
-* 失败语义：全程不抛（本面是可选面）——角色挂不上只记日志，不阻断 ACP 接线。
-*/
-function bindRoleToConnScopedAgent(scoped, root, roleName) {
-	try {
-		const role = readSkiffRoles(root).get(roleName);
-		if (!role) {
-			console.warn(`[serenity-hooks] 面 E：CCC（${root}）未定义 skiff 角色 "${roleName}" ⇒ 本连接不注入角色`);
-			return;
-		}
-		const rolePrompt = createRolePromptReader(root, role);
-		const claimed = /* @__PURE__ */ new Set();
-		const onCreated = (session) => {
-			try {
-				const id = session?.header?.id;
-				const cwd = session?.header?.cwd;
-				if (!id || !cwd) return;
-				if (claimed.has(id)) return;
-				if (!cwdInsideRoot(cwd, root)) return;
-				const target = resolveAgentById(scoped, id);
-				if (!target) return;
-				target.ctx.systemPrompt.section({
-					name: "serenity-skiff",
-					order: -60,
-					text: () => [buildSkiffBasePrompt(roleName, role), rolePrompt()].filter(Boolean).join("\n")
-				});
-				claimed.add(id);
-				console.log(`[serenity-hooks] ✓ 面 E：会话 ${id} 已绑定角色 "${roleName}"（CCC=${root}）`);
-			} catch (err) {
-				console.warn(`[serenity-hooks] 面 E：角色注入失败（不影响会话）: ${String(err?.message ?? err)}`);
-			}
-		};
-		for (const eventName of ["session/created", "agent/created"]) try {
-			scoped.on(eventName, onCreated);
-		} catch {}
-	} catch (err) {
-		console.warn(`[serenity-hooks] 面 E：角色绑定装配失败: ${String(err?.message ?? err)}`);
-	}
-}
-/** 按会话 id 取 live agent（只读；取不到返回 undefined） */
-function resolveAgentById(scoped, sessionId) {
-	try {
-		const agent = hostInjected(scoped, "agents")?.get?.(sessionId);
-		if (!agent?.ctx?.systemPrompt || typeof agent.ctx.systemPrompt.section !== "function") return void 0;
-		return agent;
-	} catch {
-		return;
-	}
-}
-/** 本面绑定的地址（取自集中端口表 —— **单一真相源**，不在本文件硬写） */
-const ACP_HOST = FACE_PORTS.acp.host ?? "127.0.0.1";
-/**
-* `dsh-acp` 需要的服务（**替它声明**，见文件头坑 ①）。
-*
-* 逐字出处 = `dsh-acp/lib/index.js` 的 `const inject = ["agents","llm","sessionPersistence","sessions"]`。
-* ⚠️ **少一个就在它内部抛错**（实测那条是 `sessionPersistence`）⇒ 这里是**照抄它的声明**，
-*    不是"我们觉得它需要什么"。⇒ 它升版改了 `inject`，这里要跟着改（列为**跨版本注意点**）。
-*/
-const ACP_REQUIRED_SERVICES = [
-	"agents",
-	"llm",
-	"sessionPersistence",
-	"sessions"
-];
-function acpFaceActive() {
-	return faceActive(FACE_ACP);
-}
-/**
-* 面是否在监听（意图读取）。
-* ⚠️ 与 `startFace` 的关系同其余各面：**启动本身不读它**（`startFace` 是机械入口），
-* 由装配层用它决定"起还是停"。
-*/
-function acpFaceEnabled() {
-	return readSimpleSettings().acpFaceEnabled;
-}
-/**
-* 把客户端给的 `cwd` 归一化成宿主要求的**绝对路径**（v1.59.1）。
-*
-* ## 为什么需要
-* 宿主 `dsh-acp` 在每次 `session/new` 都有这一行（`lib/index.js` 逐字）：
-* ```js
-* if (!isAbsolute(params.cwd)) throw invalidParams(`cwd must be an absolute path: ${params.cwd}`)
-* ```
-* 而**连接归属哪个 CCC 已由 token 决定**（服务端权威）⇒ 让用户再手打一遍绝对路径
-* 是**同一个信息说两遍**，且那第二遍正是最容易打错的一遍。
-*
-* ## 规则（唯一一条）
-* **非绝对路径 ⇒ 一律解释为「本连接归属 CCC 的根」**。
-*
-* | 客户端填 | 送宿主 |
-* |---|---|
-* | `serenity` / `a` / `.` / 空 | `/…/home-serenity`（该 token 的 CCC 根） |
-* | `/…/home-serenity`（已绝对且在根内） | 原样 |
-* | `/…/home-serenity/sub` | 原样（仍在根内） |
-* | `/etc`（绝对但在根外） | **原样透传，交给 `cwdInsideRoot` 拒** |
-*
-* 🔴 **最后一行为什么不在这里直接拒**：越权判据必须**只有一处**（`cwdInsideRoot`，
-* 它也管着角色认领），在这里再判一次就是**两份会漂的实现**。归一化只负责"把非绝对变成绝对"。
-*
-* @param raw 客户端原样给的 `cwd`（可能是 `undefined`）
-* @param cccRoot 本连接归属的 CCC 根
-*/
-function normalizeClientCwd(raw, cccRoot) {
-	const value = typeof raw === "string" ? raw.trim() : "";
-	if (value === "" || !isAbsolute(value)) return cccRoot;
-	return value;
-}
-/**
-* 把一条裸 WS socket 适配成 ACP `Stream`。
-*
-* 🔴 与官方 `ndJsonStream` **同语义**：我们自己做「消息 ↔ 文本帧」的分帧（按行）。
-*    实测注意（P0′）：`dsh-acp` 写出的每条消息**自带换行**，客户端同样 ⇒ 按行切分即正确。
-*    ⚠️ **空行要丢**；**非 JSON 帧要容忍**（桥/客户端可能插入控制帧）。
-*
-* 🔴 v1.59.1：**入站消息在这里做一次 `cwd` 归一化**（见 {@link normalizeClientCwd}）。
-*    为什么是这里：`session/new` 与 `session/resume` 都带 `cwd`，而这是**唯一**能同时
-*    拦到两者、且属于我们自己的缝（再往下就进 `dsh-acp` 了，那里改了就是改宿主）。
-*
-* 🔴 v1.59.2：这条缝同时承担 **owner「每账户固定一条长期对话」** 的双向改写 ——
-*    入站 `recordAcpPending`（记 id→method）＋ 出站 `rewriteAcpResponse`（收窄 list ／ 记 new）。
-*    ⚠️ 两件事都必须在**同一个** `ws` 上做：`pending` 是**每条连接一份**的，
-*    拆到两处会让它失去"这条连接上请求与响应配对"这个唯一用途。
-*
-* @param cccRoot 本连接归属的 CCC 根（token 反查所得）
-* @param accountId 本连接归属的账户键（主会话键由它派生）
-*/
-function wsToAcpStream(ws, onWarn, cccRoot, accountId) {
-	const pin = createAcpSessionPin(cccRoot, accountId);
-	return {
-		readable: new ReadableStream({ start(controller) {
-			let buf = "";
-			ws.on("message", (data) => {
-				buf += typeof data === "string" ? data : String(data);
-				let i;
-				while ((i = buf.indexOf("\n")) >= 0) {
-					const line = buf.slice(0, i);
-					buf = buf.slice(i + 1);
-					if (!line.trim()) continue;
-					let msg;
-					try {
-						msg = JSON.parse(line);
-					} catch {
-						onWarn(line.slice(0, 120));
-						continue;
-					}
-					recordAcpPending(pin, msg);
-					controller.enqueue(normalizeInboundCwd(msg, cccRoot));
-				}
-			});
-			ws.on("close", () => {
-				try {
-					controller.close();
-				} catch {}
-			});
-			ws.on("error", () => {
-				try {
-					controller.close();
-				} catch {}
-			});
-		} }),
-		writable: new WritableStream({ write(msg) {
-			ws.send(`${JSON.stringify(rewriteAcpResponse(pin, msg))}\n`);
-		} })
-	};
-}
-/**
-* 需要把 `cwd` 钉到本连接 CCC 根的方法（**必须逐个列出**）。
-*
-* 🔴 **v1.59.1 的第一版判据错了**：只判「params 里有没有 `cwd`」⇒ 漏掉 `session/list`。
-*    宿主 `listSessions` 的过滤是
-*    `if (params.cwd !== void 0 && !sameDirectory(header.cwd, params.cwd)) return`
-*    —— **不给 cwd 就返回全机器所有会话**。实测后果：手机 App 列表里冒出
-*    23 条别的 CCC 的会话，全部显示为 `UNKNOWN` ／ `New Chat`
-*    （owner：「**我需要是指定CCC的，不然没办法用**」）。
-* ⇒ 🆕 **判据：凡"应当被 CCC 收窄"的读接口，都必须把 `cwd` 钉成 CCC 根，不能依赖客户端传** ——
-*    token 已经定了 CCC，让客户端再声明一次既冗余、又可以被静默漏掉。
-*/
-const CWD_PINNED_METHODS = /* @__PURE__ */ new Set([
-	"session/new",
-	"session/resume",
-	"session/list"
-]);
-/**
-* 把一条入站消息的 `cwd` 归一化（**含"没给就补上"**）。
-*
-* | 情形 | 结果 |
-* |---|---|
-* | 方法不在 {@link CWD_PINNED_METHODS} | 原样（不碰别的消息） |
-* | 给了非绝对路径（`serenity` ／ `a` ／ 空串） | → 本连接 CCC 根 |
-* | 给了绝对路径 | 原样（越界由 `cwdInsideRoot` 拒） |
-* | **压根没给**（`session/list` 常见） | **→ 本连接 CCC 根**（否则列出全机器） |
-*/
-function normalizeInboundCwd(msg, cccRoot) {
-	if (typeof msg !== "object" || msg === null) return msg;
-	const m = msg;
-	if (typeof m.method !== "string" || !CWD_PINNED_METHODS.has(m.method)) return msg;
-	const params = typeof m.params === "object" && m.params !== null ? m.params : {};
-	return {
-		...msg,
-		params: {
-			...params,
-			cwd: normalizeClientCwd(params.cwd, cccRoot)
-		}
-	};
-}
-/** 请求 id 的 Map 键（区分 `1` 与 `"1"` —— JSON-RPC 允许两者，混用也不该串号） */
-function requestIdKey(id) {
-	return `${typeof id}:${String(id)}`;
-}
-/** 记账上限（防"客户端发一堆请求又从不收响应"把内存撑大） */
-const MAX_PENDING = 256;
-/** 建一条连接的钉住状态 */
-function createAcpSessionPin(root, accountId) {
-	return {
-		root,
-		accountId,
-		pending: /* @__PURE__ */ new Map()
-	};
-}
-/**
-* 入站记账：把"这条请求的方法"记住，供出站按 `id` 反查。
-*
-* 判据：**既要有 `id`，又要有 `method`** —— 只满足一个的是响应（`id` 无 `method`）
-* 或通知（`method` 无 `id`）⇒ 与我们无关，不记。
-*/
-function recordAcpPending(pin, msg) {
-	if (typeof msg !== "object" || msg === null) return;
-	const m = msg;
-	if (m.id === void 0 || m.id === null) return;
-	if (typeof m.method !== "string") return;
-	const key = requestIdKey(m.id);
-	pin.pending.set(key, m.method);
-	while (pin.pending.size > MAX_PENDING) {
-		const oldest = pin.pending.keys().next();
-		if (oldest.done) break;
-		pin.pending.delete(oldest.value);
-	}
-}
-/**
-* 出站改写（本功能的落点）。返回**要发给客户端的那条消息**。
-*
-* | 原响应 | 改写后 |
-* |---|---|
-* | `session/list` | `{sessions:[该账户那一条]}`；**没有主会话 ⇒ `{sessions:[]}`** |
-* | `session/new` | 原样，**同时**把 `result.sessionId` 记为该账户的主会话 |
-* | 其余（含所有 error 响应、所有通知） | 原样 |
-*
-* 🔴 **没有主会话时回空数组，绝不回退成全量列表** —— 退回去正是 owner 说
-*    「23 个对我没什么用」的那个东西。空数组会让 App 引导用户新建，而新建即建立主会话。
-*
-* 🔴 `nextCursor` **一律丢掉**：收窄到一条之后，分页游标失去意义；
-*    留着它会让客户端继续翻页（而后续页仍会被收窄成同一条 ⇒ 前端可能出现重复项）。
-*/
-function rewriteAcpResponse(pin, msg) {
-	if (typeof msg !== "object" || msg === null) return msg;
-	const m = msg;
-	if (m.method !== void 0) return msg;
-	const method = m.id === void 0 || m.id === null ? void 0 : pin.pending.get(requestIdKey(m.id));
-	if (method === void 0) return msg;
-	if (m.error !== void 0) return msg;
-	if (method === "session/new") {
-		const sessionId = m.result?.sessionId;
-		if (typeof sessionId === "string" && sessionId.trim() !== "") try {
-			writeAcpMainSession(pin.root, pin.accountId, sessionId);
-		} catch (err) {
-			console.warn(`[serenity-hooks] ⚠ 面 E：记录主会话失败（CCC=${pin.root} 账户=${pin.accountId}）: ${String(err?.message ?? err)}`);
-		}
-		return msg;
-	}
-	if (method === "session/list") {
-		const pinned = readAcpMainSession(pin.root, pin.accountId);
-		if (!pinned) return {
-			...m,
-			result: { sessions: [] }
-		};
-		const list = m.result?.sessions;
-		const hit = Array.isArray(list) ? list.find((s) => s?.sessionId === pinned) : void 0;
-		const sessions = hit !== void 0 ? [hit] : [{
-			sessionId: pinned,
-			cwd: pin.root
-		}];
-		return {
-			...m,
-			result: { sessions }
-		};
-	}
-	return msg;
-}
-function newState() {
-	return {
-		handle: null,
-		wss: null,
-		connections: 0,
-		applied: 0,
-		rejected: 0,
-		lastErrors: [],
-		disposers: []
-	};
-}
-/** 当前面状态（供 `status()` / 诊断读；无监听时 `handle` 为 null） */
-let state = newState();
-/** 保留最近若干条连接错误（诊断窗口；不无限增长） */
-const MAX_ERR_KEEP = 8;
-/**
-* 启动面 E（幂等；重复调用只起一次）。
-*
-* 🔴 **失败语义**：本面**默认关**且是**可选面** ⇒ 起不来**不得**影响插件其余部分
-* （调用方负责 catch；本函数把失败原样抛出，由装配层记日志）。
-*/
-async function startAcpFace(ctx) {
-	const port = readSimpleSettings().acpFacePort;
-	let dshAcp;
-	let wsMod;
-	try {
-		dshAcp = await import("@deepseek-ai/dsh-acp");
-		wsMod = await import("ws");
-	} catch (err) {
-		const msg = String(err?.message ?? err);
-		throw new Error(`面 E 依赖不可用（${msg}）—— 需要宿主提供 @deepseek-ai/dsh-acp，且本插件能 resolve 到 ws`);
-	}
-	if (typeof dshAcp.apply !== "function") throw new Error("面 E：@deepseek-ai/dsh-acp 未导出 apply（版本不匹配？）");
-	const wss = new wsMod.WebSocketServer({ noServer: true });
-	const local = newState();
-	local.wss = wss;
-	const handle = await startFace({
-		name: FACE_ACP,
-		port,
-		host: ACP_HOST,
-		enabled: () => readSimpleSettings().acpFaceEnabled,
-		handler: (_req, res) => {
-			res.writeHead(426, {
-				"content-type": "text/plain; charset=utf-8",
-				"upgrade": "websocket",
-				"cache-control": "no-store"
-			});
-			res.end("This is an ACP (Agent Client Protocol) endpoint over WebSocket. Use an ACP client.\n");
-		}
-	});
-	local.handle = handle;
-	handle.server.on("upgrade", (req, socket, head) => {
-		local.connections += 1;
-		const verdict = authorizeUpgrade(req);
-		if (!verdict.ok) {
-			local.rejected += 1;
-			local.lastErrors.push({
-				at: Date.now(),
-				applied: false,
-				error: `auth: ${verdict.reason}`
-			});
-			if (local.lastErrors.length > MAX_ERR_KEEP) local.lastErrors.shift();
-			try {
-				socket.write(`HTTP/1.1 401 Unauthorized\r
-content-type: text/plain; charset=utf-8\r
-connection: close\r
-\r
-ACP 面：认证失败（${verdict.reason}）。请在该 CCC 的 localstore 生成并使用 IM_ACP_TOKEN。\n`);
-			} catch {}
-			try {
-				socket.destroy();
-			} catch {}
-			console.warn(`[serenity-hooks] ✗ 面 E：拒绝一条连接（${verdict.reason}）`);
-			return;
-		}
-		try {
-			wss.handleUpgrade(req, socket, head, (ws) => {
-				try {
-					const connRoot = verdict.root;
-					const connRole = verdict.role;
-					const connAccount = verdict.accountId;
-					const stream = wsToAcpStream(ws, (line) => {
-						console.log(`[serenity-hooks] 面 E：丢弃一条非 JSON 帧（前 120 字）: ${line}`);
-					}, connRoot, connAccount);
-					const fiber = ctx.plugin({
-						inject: ACP_REQUIRED_SERVICES,
-						apply: (scoped) => {
-							const sel = resolveAcpSelection(scoped);
-							bindRoleToConnScopedAgent(scoped, connRoot, connRole);
-							dshAcp.apply(scoped, {
-								stream,
-								provider: sel.provider,
-								model: sel.model
-							});
-						}
-					});
-					local.disposers.push(() => {
-						try {
-							fiber?.dispose?.();
-						} catch {}
-					});
-					local.applied += 1;
-				} catch (err) {
-					const msg = String(err?.message ?? err).slice(0, 200);
-					local.lastErrors.push({
-						at: Date.now(),
-						applied: false,
-						error: msg
-					});
-					if (local.lastErrors.length > MAX_ERR_KEEP) local.lastErrors.shift();
-					console.warn(`[serenity-hooks] ✗ 面 E：dsh-acp 接线失败: ${msg}`);
-					try {
-						ws.close(1011, "acp bridge failed");
-					} catch {}
-				}
-			});
-		} catch (err) {
-			console.warn(`[serenity-hooks] ✗ 面 E：WebSocket 握手失败: ${String(err?.message ?? err)}`);
-			try {
-				socket.destroy();
-			} catch {}
-		}
-	});
-	state = local;
-	console.log(`[serenity-hooks] ✓ 面 E（官方 ACP）：ws://${ACP_HOST}:${port}  ⚠️ 协议无认证，靠外部 Access 兜底`);
-	return handle;
-}
-/**
-* 停面 E（幂等）。
-*
-* ⚠️ **与其余各面同款注意**：`stopFace` **不用** `closeAllConnections()`（那会掐断在飞的请求）；
-*  WS 连接由 `wss.close()` 与 socket 自身生命周期收束。
-*/
-function stopAcpFace() {
-	const wss = state.wss;
-	if (wss) try {
-		wss.close();
-	} catch {}
-	state.disposers = [];
-	state.wss = null;
-	state.handle = null;
-	const stopped = stopFace(FACE_ACP);
-	if (stopped) console.log("[serenity-hooks] face acp: 已停止");
-	return stopped;
-}
-/** ACP 会话用的 provider（取 CCC 现有路由；留空 = 由宿主/请求监听器决定） */
-function readAcpProvider() {
-	return process.env.SERENITY_ACP_PROVIDER || void 0;
-}
-/** ACP 会话用的 model（同上） */
-function readAcpModel() {
-	return process.env.SERENITY_ACP_MODEL || void 0;
-}
-/**
-* 解析 ACP 会话该用的 `{provider, model}`。
-*
-* ## 🔴 为什么必须有这个函数（2026-10-16 容器实测抓出的**真缺陷**）
-*
-* 早先我们是**裸传** `provider: readAcpProvider(), model: readAcpModel()` —— 而它们读的是
-* **环境变量**，默认**未设** ⇒ 传下去就是 `undefined`。后果**不是"用默认模型"**：
-* 上游 `dsh-acp` 的 `agentOptions()`（`lib/index.js:1356-1361`）**只在字段非 undefined 时才带上**：
-* ```js
-* ...config.provider !== void 0 ? { provider: config.provider } : {},
-* ...config.model    !== void 0 ? { model: config.model }    : {}
-* ```
-* ⇒ **我们传 undefined，agent 就真的没有模型** ⇒ 第一条 `session/prompt` 必失败，逐字报：
-* `Internal error: turn failed: prompt variable "{{model}}" has no value for this assembly
-*  (section "deployment:persona-prefix")`。
-*
-* ⚠️ **网页端不中招**（它经 `agent-default-model` 层拿到默认值）⇒ **只有 ACP 这条入口坏** ——
-* 也就是说：**手机上第一条消息必然失败，而本机怎么试都正常**。
-* 🔴 这个缺陷 **typecheck ／ 2812 条单测 ／ deploy 预检 全绿**（它是运行时合成形态，
-* 静态面结构性地看不见）⇒ **只有"容器 ＋ 真模型"那一跑能抓到它**。
-*
-* ## 修法 = **读宿主自己的默认模型服务**（不另造真相源）
-*
-* 宿主暴露服务 `ctx.agentDefaultModel.currentSelection()`，其契约逐字写着
-* *"Default model selection for Agents created **without an explicit model**"*
-* （`dsh-agent-default-model/lib/types/index.d.ts`）—— 这正是"没显式指定时该用什么"的**权威出处**。
-* ⇒ 我们只是**把它转交给 ACP**，不引入第二套缺省。
-*
-* 优先级（**显式 > 宿主默认**）：`SERENITY_ACP_PROVIDER/MODEL` 环境变量（调试用）＞ 宿主默认。
-* ⚠️ **一处如实标注的弱化**：这里**不打日志**（每次连接都解析一次，打日志会刷屏）；
-* 若宿主服务缺失，**退回"两个都 undefined"＝旧行为**（即那条已知会失败的形态）——
-* 而不是静默编一个模型。⇒ 副作用是"没有默认模型时仍会失败"，但那**与宿主自身缺配置时的行为一致**。
-*
-* 🔵 **公开导出**（而非模块私有）：它是一个**纯函数 ＋ 有独立契约**的单元（本仓同类先例 =
-* `host/access.ts` 的一组读取器），且**那个真缺陷正是在它这一层**（裸传 undefined）——
-* 回归钉必须能**直接钉住它**，而不是隔着 WS 握手去间接观察（那样测不出"取到了什么"）。
-*/
-function resolveAcpSelection(ctx) {
-	const envProvider = readAcpProvider();
-	const envModel = readAcpModel();
-	if (envProvider && envModel) return {
-		provider: envProvider,
-		model: envModel
-	};
-	try {
-		const sel = hostInjected(ctx, "agentDefaultModel")?.currentSelection?.();
-		if (sel?.provider && sel?.model) return {
-			provider: sel.provider,
-			model: sel.model
-		};
-	} catch {}
-	return {
-		provider: envProvider,
-		model: envModel
-	};
-}
-/**
-* 装配（`index.ts` 的 `apply` 调用）：按**面板/部署键**启停面 E，配置变化热同步。
-*
-* 🔴 **W3 接线**（2026-10-16）：本轮之前 `startAcpFace` 虽已实现却**没有任何调用点**
-* —— 即"面写好了但从不起"。本函数补上它，形式与两个兄弟面一致
-* （`registerWeixinSendApi` ／ `registerDiagramTool`）：
-*
-* ① **反应式**：面板拨开关**只改配置、不重跑 `apply`**（v1.51.1 实测过的那条铁律）
-*    ⇒ 必须监听事件才会"拨了就有反应"；
-* ② 监听**宿主的真事件** `settings/document-updated`（按 ns 过滤），
-*    ⛔ **不监听** `serenity/settings-changed` —— 那个事件**全仓没有任何 `emit` 点**
-*    （＝死通道；见 `registerDiagramTool` 的注释），照它接线等于接了个永远不响的铃；
-* ③ 再挂 `agent/created`／`session/created` 兜底（宿主事件面若换名，至少还有这条能自愈）；
-* ④ 启动时同步一次（`apply` 时按当前配置定初始态）。
-*
-* ⚠️ **失败语义**：本面**默认关**且**依赖可选**（`dsh-acp` 是 peer）⇒ 起不来**只记日志**，
-*    绝不抛出（抛出会让整个插件加载失败，而它只是一个可选面）。
-*/
-function registerAcpFace(ctx) {
-	const sync = () => {
-		if (!acpFaceEnabled()) {
-			if (acpFaceActive()) stopAcpFace();
-			return;
-		}
-		if (acpFaceActive()) return;
-		startAcpFace(ctx).catch((err) => {
-			console.error(`[serenity-hooks] ✗ 面 E（官方 ACP）启动失败: ${String(err?.message ?? err)}`);
-		});
-	};
-	try {
-		ctx.on("settings/document-updated", (ns) => {
-			if (String(ns) === "serenity-hooks") sync();
-		});
-	} catch {}
-	for (const eventName of ["agent/created", "session/created"]) try {
-		ctx.on(eventName, () => {
-			sync();
-		});
-	} catch {}
-	const refresh = () => {
-		refreshAcpRoots(ctx).then((n) => {
-			console.log(`[serenity-hooks] 面 E：CCC 候选根已枚举（${n} 个）`);
-		});
-	};
-	try {
-		ctx.on("settings/document-updated", (ns) => {
-			if (String(ns) === "serenity-hooks") refresh();
-		});
-	} catch {}
-	refresh();
-	sync();
-}
-//#endregion
 //#region src/seams/lifecycle.ts
 /** 从 Agent / Session / 事件负载中取会话 id（形状宽容：未知结构返回 null） */
 function sessionIdOf(value) {
@@ -25400,10 +24346,6 @@ const Config = z.object({
 	opencodeProvider: z.object({ autoConfigure: z.boolean().default(true) }),
 	visionPatch: z.object({ enabled: z.boolean().default(true) }),
 	diagram: z.object({ enabled: z.boolean().default(false) }),
-	acpFace: z.object({
-		enabled: z.boolean().default(false),
-		port: z.number().min(1024).max(65535).default(ACP_PORT)
-	}),
 	humanChannel: z.object({
 		accounts: z.array(humanChannelAccountSchema).default([]),
 		subscriptions: z.array(humanChannelSubscriptionSchema).default([]),
@@ -25415,9 +24357,7 @@ const Config = z.object({
 	skiffEnabled: z.boolean().volatile(),
 	skiffDebugPort: z.number().min(1024).max(65535).volatile(),
 	croEnabled: z.boolean().volatile(),
-	diagramEnabled: z.boolean().volatile(),
-	acpFaceEnabled: z.boolean().volatile(),
-	acpFacePort: z.number().min(1024).max(65535).volatile()
+	diagramEnabled: z.boolean().volatile()
 });
 function apply(ctx, config) {
 	try {
@@ -25465,7 +24405,14 @@ function apply(ctx, config) {
 	});
 	if (config.api) {
 		registerStatusApi(ctx, { configPaths: config.serenityConfigPaths });
-		registerVoyageApi(ctx);
+		registerVoyageApi(ctx, { resolveRoot: (req) => {
+			const url = new URL(req.url ?? "/", "http://localhost");
+			const ws = resolveWorkspace(ctx, {
+				sessionId: url.searchParams.get("sessionId") ?? void 0,
+				workspace: url.searchParams.get("workspace") ?? void 0
+			});
+			return cccRootForCwd(ws);
+		} });
 	}
 	registerSettingsSection(ctx, config);
 	if (config.tools) registerDiagramTool(ctx);
@@ -25480,7 +24427,6 @@ function apply(ctx, config) {
 	registerWakeScheduler(ctx);
 	registerWeixinBridge(ctx);
 	registerWeixinSendApi(ctx);
-	registerAcpFace(ctx);
 	registerWeixinOutputGuard(ctx);
 	registerLifecycle(ctx);
 	if (config.webFetch?.enabled !== false) registerWebFetchProvider(ctx);