@shgroup/dsh-serenity-hooks 1.59.0 → 1.59.2

package/lib/index.js

@@ -2,10 +2,11 @@ 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-GIJ3A_tw.js";
 import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readExclusiveTools, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-B0ZGL9lx.js";
 import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-B4P3Uw6D.js";
-import { _ as runLocalStore, a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as readStore, h as readGitTrack, i as matchWeixinRoute, l as weixinSessionIdFor, m as localstorePath, n as extractWeixinText, o as readWeixinSettings, p as getEntry, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia, v as writeEntry } from "./weixin-route-CSDBGLwl.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-DMs_ovHo.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-DGUQZo5j.js";
 import { a as readSkiffRoles, c as roleMsmWhitelist, d as systemPromptSource, f as trajectorySubset, i as isSkiffSessionId, l as roleToolWhitelist, n as buildSkiffBasePrompt, o as resolveRoleSystemPrompt, r as createRolePromptReader, s as resolveSkiffKind } from "./skiff-role-B615L9MV.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-Aheyq3fN.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";
@@ -15004,6 +15005,8 @@ 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([
@@ -15323,11 +15326,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-Aheyq3fN.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-CSDBGLwl.js").then((n) => n.u);
+					const { readWeixinCredential } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
 					const accounts = (settings.accounts ?? []).map((a) => ({
 						accountId: a.accountId,
 						name: a.name ?? void 0,
@@ -15359,7 +15362,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-CSDBGLwl.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15380,7 +15383,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
+					const { removeWeixinAccount } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -15393,7 +15396,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
 						return;
 					}
-					const { saveWeixinRoutes } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
+					const { saveWeixinRoutes } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
 					const { readSkiffRoles } = await import("./skiff-role-B615L9MV.js").then((n) => n.u);
 					const roles = readSkiffRoles(root);
 					for (const r of routes) if (!roles.has(r.role)) {
@@ -15406,7 +15409,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -15450,7 +15453,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
-				const { readWeixinSettings } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
+				const { readWeixinSettings } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15465,7 +15468,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-CSDBGLwl.js").then((n) => n.u);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
 						const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -15549,6 +15552,7 @@ function registerStatusApi(ctx, opts = {}) {
 			}
 		}
 	});
+	registerAcpAccountsApi(ctx);
 }
 /** 进行中的扫码登录（loginKey → 状态；进程内，5min 有效） */
 const weixinLogins = /* @__PURE__ */ new Map();
@@ -15569,6 +15573,99 @@ 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-GIJ3A_tw.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-B615L9MV.js").then((n) => n.u);
+					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-page.ts
 const VOYAGE_PATH = "/serenity/voyage";
@@ -21853,19 +21950,59 @@ function registerWeixinSendApi(ctx) {
 *
 * 本模块**零 DSH 依赖**（只 `node:crypto` ／ `node:fs` ／ `node:path` 与本仓纯逻辑）⇒ 可独立单测。
 */
-/** localstore 凭据键（credential scope ⇒ UPPER_SNAKE） */
-const ACP_TOKEN_KEY = "IM_ACP_TOKEN";
+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;
 /**
-* 该 CCC 的 ACP token（**读**；不存在返回 null）。
+* 该**账户**的 ACP token（**读**；不存在返回 null）。
+*
+* 🔴 **不自动生成** —— 生成是**写操作**，只在显式要求时做（`ensureAcpToken`）。
+*    读路径永远无副作用：否则每次判定都会改 localstore。
 *
-* 🔴 **不自动生成** —— 生成是**写操作**，只在 owner/面板显式要求时做
-* （`ensureAcpToken`）。读路径永远无副作用：否则每次启动都会改 localstore。
+* @param accountId 账户键（必填 —— 凭据按账户分离，没有"CCC 默认 token"这回事）
 */
-function readAcpToken(root) {
+function readAcpToken(root, accountId) {
 	try {
-		const value = getEntry(root, "credential", ACP_TOKEN_KEY);
+		const value = getEntry(root, "credential", acpTokenKeyFor(accountId));
 		return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
 	} catch {
 		return null;
@@ -21876,12 +22013,23 @@ function readAcpToken(root) {
 *
 * ⚠️ **幂等**：已有 token 时**原样返回**（不轮换）—— 轮换会让在用的客户端立刻断线，
 *    必须是一次显式动作（`resetAcpToken`）。
+*
+* @param accountId 多账户时指明哪个账户；省略 ＝ 单账户简写键
 */
-function ensureAcpToken(root) {
-	const existing = readAcpToken(root);
+function ensureAcpToken(root, accountId) {
+	const existing = readAcpToken(root, accountId);
 	if (existing) return existing;
 	const token = randomBytes(TOKEN_BYTES).toString("hex");
-	writeEntry(root, "credential", ACP_TOKEN_KEY, token);
+	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;
 }
 /**
@@ -21900,6 +22048,49 @@ function safeEqual(a, b) {
 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。
 *
@@ -21922,32 +22113,92 @@ function extractToken(headers, url) {
 	return null;
 }
 /**
-* 校验一枚候选 token，返回它归属的 CCC 根（**未命中返回 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 resolveTokenOwner(candidate, roots) {
+function resolveTokenAccount(candidate, roots, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
 	if (!candidate) return null;
-	for (const root of roots) {
-		const token = readAcpToken(root);
-		if (token && safeEqual(candidate, token)) return root;
-	}
+	for (const root of roots) for (const acct of expandAcpAccounts(root, paths)) if (safeEqual(candidate, acct.token)) return acct;
 	return null;
 }
 /**
-* 枚举**启用了 ACP 通道**的 CCC（供 `resolveTokenOwner` 用）。
+* 枚举**有可用 ACP 账户**的 CCC（供准入名单用）。
 *
-* 判据（与装配层同源，见 `acpChannelEnabled`）：`im.channel === 'acp'` ∧ `im.acp.enabled === true`
-* ∧ token 已生成。⚠️ 三者**缺一即不算**（fail-closed：宁可连不上，不可放行一个半配置的通道）。
+* 判据：`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 (!acpChannelEnabled(root, paths)) continue;
-		if (!readAcpToken(root)) continue;
-		out.push(root);
-	}
+	for (const root of roots) if (expandAcpAccounts(root, paths).length > 0) out.push(root);
 	return out;
 }
 /** 读该 CCC 的 `im` 段（未配置 ⇒ 归一缺省；永不 undefined） */
@@ -21980,11 +22231,6 @@ function acpChannelEnabled(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
 	const im = readImSettings(root, paths);
 	return im.channel === "acp" && im.acp.enabled === true;
 }
-/** 该 CCC 绑定的 skiff 角色名（未配置 ⇒ null） */
-function acpRoleFor(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
-	const role = readImSettings(root, paths).acp.role;
-	return typeof role === "string" && role.trim() !== "" ? role.trim() : null;
-}
 /**
 * 客户端 `session/new` 传来的 `cwd` 是否落在该 token 归属的 CCC 内。
 *
@@ -21999,6 +22245,126 @@ function cwdInsideRoot(cwd, root) {
 	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 同名，便于对账） */
@@ -22016,54 +22382,79 @@ function authorizeUpgrade(req) {
 		ok: false,
 		reason: "未携带 token（用 Authorization: Bearer <t> 或 ?token=<t>）"
 	};
-	const roots = acpRoots;
+	const roots = knownAcpRoots();
 	if (roots.length === 0) return {
 		ok: false,
 		reason: "本机没有任何启用了 ACP 通道的 CCC"
 	};
-	const owner = resolveTokenOwner(candidate, roots);
-	if (!owner) return {
+	const acct = resolveTokenAccount(candidate, roots);
+	if (!acct) return {
 		ok: false,
-		reason: "token 不匹配任何已启用 ACP 通道的 CCC"
+		reason: "token 不匹配任何已声明账户的 ACP 通道"
 	};
-	const role = acpRoleFor(owner);
+	const role = acct.role;
 	if (!role) return {
 		ok: false,
-		reason: `CCC（${owner}）未配置 im.acp.role`
+		reason: `CCC（${acct.root}）账户 ${acct.accountId} 未配 im.acp.accounts[].role`
 	};
 	return {
 		ok: true,
-		root: owner,
-		role
+		root: acct.root,
+		role,
+		accountId: acct.accountId
 	};
 }
 /**
-* 归属候选 CCC 的**同步**缓存。
+* CCC 根候选的来源（**只要根，不判配置**）。
 *
-* 🔴 为什么缓存而非每次现算：`listCccs()` 是 **async**（要读 workspace registry ＋
-*    `sessionPersistence`），而 `'upgrade'` 回调是**同步**的 ⇒ 不能在那里 await。
-* ⇒ 启动时算一次 ＋ 配置变更时刷新；这是**准入名单**，宁可用稍旧的名单（新 CCC 多等一次
-*    配置事件即可生效），也不让 upgrade 挂起。
+* 🔴 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 ＝ 一个都没发现，日志会说为什么）
 */
-let acpRoots = [];
-/** 刷新准入名单（**只收启用了 ACP 通道且已生成 token 的 CCC**）。返回新名单长度。 */
 async function refreshAcpRoots(ctx) {
 	try {
-		const all = (await listCccs(ctx)).map((e) => e.root);
-		for (const root of all) try {
-			if (acpChannelEnabled(root) && !readAcpToken(root)) {
-				const token = ensureAcpToken(root);
-				console.log(`[serenity-hooks] ✓ 面 E：已为 CCC 生成 ACP token（${root}，指纹 ${tokenFingerprint(token)}）`);
-			}
+		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 生成 token 失败（${root}）: ${String(err?.message ?? err)}`);
+			console.warn(`[serenity-hooks] 面 E：为 CCC（${root}）生成 token 失败: ${String(err?.message ?? err)}`);
 		}
-		acpRoots = listAcpRoots(all);
+		if (created > 0) console.log(`[serenity-hooks] ✓ 面 E：已为 ${created} 个 ACP 账户生成 token`);
+		return knownRoots.length;
 	} catch (err) {
-		acpRoots = [];
-		console.warn(`[serenity-hooks] 面 E：CCC 准入名单刷新失败（已清空，连接将被拒）: ${String(err?.message ?? 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;
 	}
-	return acpRoots.length;
 }
 /**
 * 把**本连接归属的 CCC 角色**套到该连接创建的 agent 上（v1.59.0）。
@@ -22162,13 +22553,58 @@ 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) {
+function wsToAcpStream(ws, onWarn, cccRoot, accountId) {
+	const pin = createAcpSessionPin(cccRoot, accountId);
 	return {
 		readable: new ReadableStream({ start(controller) {
 			let buf = "";
@@ -22179,11 +22615,15 @@ function wsToAcpStream(ws, onWarn) {
 					const line = buf.slice(0, i);
 					buf = buf.slice(i + 1);
 					if (!line.trim()) continue;
+					let msg;
 					try {
-						controller.enqueue(JSON.parse(line));
+						msg = JSON.parse(line);
 					} catch {
 						onWarn(line.slice(0, 120));
+						continue;
 					}
+					recordAcpPending(pin, msg);
+					controller.enqueue(normalizeInboundCwd(msg, cccRoot));
 				}
 			});
 			ws.on("close", () => {
@@ -22198,10 +22638,133 @@ function wsToAcpStream(ws, onWarn) {
 			});
 		} }),
 		writable: new WritableStream({ write(msg) {
-			ws.send(`${JSON.stringify(msg)}\n`);
+			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,
@@ -22282,9 +22845,10 @@ ACP 面：认证失败（${verdict.reason}）。请在该 CCC 的 localstore 生
 				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) => {
@@ -22451,7 +23015,7 @@ function registerAcpFace(ctx) {
 	} catch {}
 	const refresh = () => {
 		refreshAcpRoots(ctx).then((n) => {
-			console.log(`[serenity-hooks] 面 E：CCC 准入名单已刷新（${n} 个 CCC 启用 ACP 通道）`);
+			console.log(`[serenity-hooks] 面 E：CCC 候选根已枚举（${n} 个）`);
 		});
 	};
 	try {