@shgroup/dsh-serenity-hooks 1.85.0 → 1.87.0

package/lib/index.js

@@ -1,14 +1,14 @@
 import { i as __toESM, n as __exportAll } from "./rolldown-runtime-B4iAMlE-.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-VCJ3aYJA.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-BI_4UVcj.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, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-CyYJL4F2.js";
-import { A as sessionEvents, B as isoLocal, C as listSessions, E as parseTrajectoryCode, F as trajectoryDescOf, H as localHuman, I as useSession, L as TRAJECTORY_FILENAME, M as setActiveSessionInfo, N as showSession, O as readTrajectoryUid, P as summarize, R as TRAJECTORY_LEGACY_FILENAMES, S as listActiveTrajectories, T as parseSessionContextFromEvents, U as localIdStamp, V as localFileStamp, _ as createSession, a as readTrajectoryConstraintAt, b as getActiveSessionInfo, c as trajectoryConstraintForSession, f as COGNITIVE_TRAJECTORY_ACTIONS, g as clearActiveSessionInfo, h as archiveSession, j as sessionsRoot, k as resolveSessionByTitle, m as UID_FILENAME, n as isTrajectoryConstrained, o as readTrajectoryConstraintByCode, r as listTrajectoryConstraints, s as replacesDefaultIdentity, t as TRAJECTORY_CONSTRAINT_FILENAME, v as extractSessionMdPathFromText, w as namingTitleFor, y as findSession, z as readTrajectoryFile } from "./profile-DnLSb7yv.js";
+import { A as resolveSessionByTitle, B as readTrajectoryFile, C as listActiveTrajectories, D as parseTrajectoryCode, E as parseSessionContextFromEvents, F as summarize, H as localFileStamp, I as trajectoryDescOf, L as useSession, M as sessionsRoot, N as setActiveSessionInfo, P as showSession, R as TRAJECTORY_FILENAME, T as namingTitleFor, U as localHuman, V as isoLocal, W as localIdStamp, _ as clearActiveSessionInfo, b as findSession, c as replacesDefaultIdentity, g as archiveSession, h as UID_FILENAME, i as listTrajectoryConstraints, j as sessionEvents, k as readTrajectoryUid, l as trajectoryConstraintForSession, n as findDirNameByCode, o as readTrajectoryConstraintAt, p as COGNITIVE_TRAJECTORY_ACTIONS, r as isTrajectoryConstrained, s as readTrajectoryConstraintByCode, t as TRAJECTORY_CONSTRAINT_FILENAME, v as createSession, w as listSessions, x as getActiveSessionInfo, y as extractSessionMdPathFromText, z as TRAJECTORY_LEGACY_FILENAMES } from "./profile-vHheCJiU.js";
 import { n as checkLocalstoreGitCompliance, o as readStore, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./service-DDmHSglV.js";
-import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-D7dVNDIh.js";
-import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-I6SM2GT6.js";
+import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-DRkQwfgh.js";
+import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-DZXSLLEx.js";
 import { n as hasSessionLogById, r as sessionsRootDir } from "./cleanup-C-92qnDs.js";
-import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-4ag1jtR0.js";
+import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-H7TVDayZ.js";
+import { a as readFeishuCredential, c as readWeixinSettings, d as weixinInboundDir, f as weixinSessionIdForTrajectory, i as matchWeixinRoute, n as extractWeixinText, o as readImSettings, r as hasVoiceItem, s as readWeixinCredential, t as extractWeixinMedia, u as sanitizeFileName$1 } from "./route-3OzOAjec.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
-import { a as readFeishuCredential, d as weixinSessionIdForTrajectory, i as matchWeixinRoute, l as sanitizeFileName$1, n as extractWeixinText, o as readWeixinCredential, r as hasVoiceItem, s as readWeixinSettings, t as extractWeixinMedia, u as weixinInboundDir } from "./route-Dr0SFD8A.js";
 import { c as sendTextMessage, i as getUpdates, l as sendTyping, n as downloadMedia, o as markdownToPlainText, r as getConfig, s as sendFileMessage, t as TypingStatus, u as sniffImageExt } from "./ilink-BMk2w2KY.js";
 import { a as registerImAccountImpl, i as normalizeAccountChannel, n as getImAccountImpl, r as imAccountChannels } from "./accounts-BHQbakUh.js";
 import { createRequire } from "node:module";
@@ -11048,6 +11048,152 @@ const TRAJECTORY_SELF_GUIDE = [
   ⚠️ 以上四项都是**读取当前真实状态**，不是"保存成功"的回执。保存成功 ≠ 生效（本仓反复踩过）。`
 ].join("\n");
 //#endregion
+//#region src/tools/im-docs.ts
+/**
+* tools/im-docs.ts — 「IM 桥怎么用、怎么配路由」的**手册正文**（2026-10-22）
+*
+* ## 为什么需要这一章（owner 原话）
+*
+* 「我在测试飞书，发现 ACC 没提供 IM 桥使用说明和账户查询方法，**导致 CCC 没办法自己配路由**，
+*  这个要完善下」＋「配路由需要的是**账户到轨迹**，轨迹 CCC 知道，**账户 CCC 不知道**，
+*  需要有个能力让 CCC 查询用户配好的账户」。
+*
+* ⇒ 两件事被同时指出来：**没有说明面**（只能猜配置形状）＋ **没有查询面**（拿不到对方 id）。
+* 后者已由 `im-bridge action=contacts` 兑现；本章补前者。
+*
+* ## 🔴 写这一章时守的两条纪律
+*
+* 1. **只描述已经建成的东西**（D179）：本章出现的每个字段、每个动作，都必须在实现里存在。
+*    写"打算做"的功能进手册 = 教用户按图施工然后把自己锁死。
+* 2. **指针从读者真正打开的那个工具发出**（D178）：读这一章的人是 **CCC 的 agent**，
+*    它手边常用的入口是 `im-bridge`（工具描述已指向本章）。⛔ 不能只藏在 container_admin 里。
+*/
+const IM_BRIDGE_GUIDE = `# IM 桥（im-bridge）—— 怎么用、怎么配、怎么查
+
+## 一、它是什么
+
+一个 CCC 通过 IM 渠道（微信 / 飞书）跟家人收发消息的能力。
+**只作用于本容器**——没有"目标容器"参数（跨 CCC 发送不在能力面）。
+
+工具在**未配置任何 IM 渠道时根本不可见**（不是"看得到但被拒"）。
+⇒ 你看到这个工具，说明本 CCC 已配了至少一个渠道。
+
+## 二、五个动作
+
+| 动作 | 用途 | 关键参数 |
+|---|---|---|
+| \`send\` | 发一条文本 | \`user\`（对方）＋ \`text\` |
+| \`send-file\` | 发本容器内的一个文件 | \`user\` ＋ \`file\`（**CCC 根相对路径**）＋ 可选 \`caption\` |
+| \`users\` | 已配的**别名**表 | — |
+| \`status\` | 渠道健康 ＋ **账号** ＋ **当前路由**（含每条路由的目标是否存在） | — |
+| \`contacts\` | **跟本容器有过往来的人**（含对方 id）＋ 未配路由的 ／ 配了却没往来的 | — |
+
+⚠️ 渠道不一定支持全部动作（例如飞书目前不支持 \`send-file\`，会如实返回 \`ACTION_UNSUPPORTED\`）。
+**如实返回"不支持"比假装支持好**——后者会得到一条"发出去但对方收不到"的静默故障。
+
+## 三、🔴 配路由：先 \`contacts\`，再写，再 \`status\` 自检
+
+路由的形状（\`.opencode/serenity.json\` 的 \`im.routes\`）：
+
+\`\`\`json
+{
+  "im": {
+    "enabled": true,
+    "accounts": [
+      { "accountId": "wechat-1", "channel": "weixin", "enabled": true },
+      { "accountId": "feishu-1", "channel": "feishu", "enabled": true }
+    ],
+    "routes": [
+      { "user": "o9cq…@im.wechat", "trajectory": "zhaocai-xingzai" },
+      { "user": "ou_xxxxxxxx",     "trajectory": "llm-intel" }
+    ]
+  }
+}
+\`\`\`
+
+- \`user\` = **对方在该渠道内的 id**（不是我们的账号，也不是别名）
+  · 微信：形如 \`xxx@im.wechat\`
+  · 飞书：形如 \`ou_…\`（open_id）
+- \`trajectory\` = **认知轨迹编码**（目录名里那一段，如 \`S142\` / \`llm-intel\`）
+- \`*\` 可作为 \`user\` 的**通配兜底**（exact 优先）
+
+### 那个 \`user\` id 从哪里来 —— 这是本节存在的原因
+
+**你不知道对方 id，而它也不在任何配置文件里。** 它只出现在聊天记录中。
+⇒ 用 \`im-bridge({channel:"weixin", action:"contacts"})\`，它会给出：
+
+\`\`\`json
+{
+  "contacts": [
+    { "channel": "weixin", "userId": "o9cq…@im.wechat", "accountIds": ["wechat-1"],
+      "route": null, "firstSeen": "2026-09-04T…", "lastSeen": "2026-10-22T…", "messages": 1284 }
+  ],
+  "unrouted":     ["o9cq…@im.wechat"],
+  "orphanRoutes": ["ou_typo_never_seen"],
+  "sources":      ["AGENT_SESSIONS/_im-logs/weixin/2026-10-22.jsonl", "…"]
+}
+\`\`\`
+
+三行输出**各有用途，缺一行这个动作就只剩"列名字"**：
+
+| 字段 | 含义 | 你要做什么 |
+|---|---|---|
+| \`contacts[].userId\` | 对方 id | **复制它**填进 \`routes[].user\` |
+| \`unrouted\` | ⚠️ 有往来、但**没配路由** | 这些人的消息现在**无处可去** ⇒ 这就是该配的 |
+| \`orphanRoutes\` | ❓ 配了路由、但记录里**从没出现过** | 大概率 **id 写错**（或从未有人发过） |
+| \`sources\` | 实际读过的文件 | **否定性结论的可信度上限** = 这个列表；它空着就别下"没人"的结论 |
+
+### 写完怎么自检
+
+\`im-bridge({channel:"weixin", action:"status"})\` 的 \`routes[]\` 每条都带 **\`targetExists\`**：
+
+- \`true\` ⇒ 该轨迹目录真实存在，路由**有机会**生效
+- \`false\` ⇒ **轨迹编码写错了**（或那条轨迹已被归档/删除）
+
+🔴 这一格是"配了不生效"的**唯一机械信号**：写错一个编码**不会有任何报错**，
+消息进来找不到目标就静默不投递，你只会看到"没回音"。
+
+## 四、多账号 / 多渠道
+
+一个 CCC 绑多个账号是常态（owner 2026-10-22：「一个 CCC 绑定多个账户很常见」）。
+
+- **账号**在 \`im.accounts[]\`，每条自带 \`channel\`（缺省 \`weixin\`）
+- **路由是通道无关的**（\`user → trajectory\`）；同一轨迹可以被多个渠道的对端指向
+- \`contacts\` 的每条带 \`accountIds\`（该对端被哪些账号收过）——**多账号靠它区分**
+- 发消息时可用 \`account\` 参数指定用哪个账号（缺省：第一个启用且已绑定的）
+
+## 五、聊天记录落在哪
+
+\`\`\`
+AGENT_SESSIONS/_im-logs/<channel>/<YYYY-MM-DD>.jsonl
+\`\`\`
+
+- 按**渠道**分目录（\`weixin\` / \`feishu\`），按**本地自然天**分文件，逐行 JSON 追加
+- 老路径 \`AGENT_SESSIONS/_weixin-logs/\` 是**同一族的前代**（2026-10-22 之前的微信记录）；
+  读侧**两个都认**，⛔ 但**只往新路径写**
+- 每条事件带 \`channel\` 字段 ⇒ 飞书事件不会再混进微信目录（此前会，目录名会说谎）
+- 媒体的持久副本在 \`_im-logs/<channel>/media/<日期>/\`
+
+⚠️ **记录归 CCC**（\`im.hook\` 指向本容器的脚本），ACC 不认识存储格式 —— 这层分离是有意的。
+
+## 六、出错时
+
+工具返回**稳定错误码 + 可行动提示**，常见的：
+
+| 码 | 意思 | 怎么改 |
+|---|---|---|
+| \`CHANNEL_NOT_CONFIGURED\` | 本 CCC 没启用该渠道 | 看提示里的**那一半**（总开关 vs 缺账号，两者改法不同） |
+| \`ALIAS_UNKNOWN\` | \`user\` 既不是已配别名、也不是合法的裸 id | 先 \`action=users\` 看别名，或用 \`contacts\` 拿裸 id |
+| \`ACTION_UNSUPPORTED\` | 该渠道没实现这个动作 | 换动作；⛔ 不要重试 |
+| \`FILE_ESCAPE\` | \`file\` 跑出了 CCC 根 | 用容器内相对路径 |
+
+## 七、边界（明确不做）
+
+- ⛔ 跨 CCC 发送（只作用于本容器）
+- ⛔ 修改配置（\`contacts\` 只读；加路由要人/CCC 自己写 \`serenity.json\`）
+- ⛔ 判断"对方读没读"——记录只证明**已发出**
+`;
+//#endregion
 //#region src/tools/container-admin.ts
 /**
 * container-admin.ts — container_admin（v1.30：机务舱——容器管理面统一入口）
@@ -11198,6 +11344,11 @@ const DOCS_CHAPTERS = [
 		id: "trajectory-constraint",
 		summary: "轨迹约束（只讲限制面）：trajectory.json 的双白名单 ／ 模型 ／ 纪律参与项 ／ IM 路由",
 		render: () => TRAJECTORY_CONSTRAINT_GUIDE
+	},
+	{
+		id: "im-bridge",
+		summary: "IM 桥怎么用、怎么配路由、怎么查对方 id —— send/send-file/users/status/contacts 五个动作 ＋ 路由三步法（contacts → 写 → status 自检）",
+		render: () => IM_BRIDGE_GUIDE
 	}
 ];
 /**
@@ -11208,7 +11359,7 @@ const DOCS_CHAPTERS = [
 function createContainerAdminTool(ctx) {
 	return defineTool({
 		name: "container_admin",
-		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): config — CCC configuration: docs (usage-manual index) / docs <chapter> (one chapter in full) / view (current values) + 轨迹约束 (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference). TRAJECTORY SELF-DOCS: a cognitive trajectory describing ITSELF — charter (PROMPT.md) / resident declaration / self-restriction (whitelists) ⇒ config docs trajectory-self; the restriction side only ⇒ config docs trajectory-constraint. Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
+		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): config — CCC configuration: docs (usage-manual index) / docs <chapter> (one chapter in full) / view (current values) + 轨迹约束 (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference). TRAJECTORY SELF-DOCS: a cognitive trajectory describing ITSELF — charter (PROMPT.md) / resident declaration / self-restriction (whitelists) ⇒ config docs trajectory-self; the restriction side only ⇒ config docs trajectory-constraint. IM BRIDGE: how to send / configure routes / look up the other party's channel user id — send / send-file / users / status / contacts + the three-step route recipe ⇒ config docs im-bridge. Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
 		parameters: {
 			domain: {
 				type: "string",
@@ -11321,6 +11472,138 @@ function createContainerAdminTool(ctx) {
 	});
 }
 //#endregion
+//#region src/im/log-scan.ts
+/**
+* im/log-scan.ts — 读聊天记录落盘，汇总出「与谁有过往来」（`contacts` 的数据源）
+*
+* ## 这个文件解决什么
+*
+* owner 2026-10-22：「配路由需要的是**账户到轨迹**，轨迹 CCC 知道，**账户 CCC 不知道**，
+* 需要有个能力让 CCC 查询用户配好的账户」。这里的"账户"= **通道用户**（对方是谁），
+* 不是 IM 账号（我们自己登录的身份，`status` 早就能查）。
+*
+* 那个 id（微信 `xxx@im.wechat` / 飞书 `ou_…`）不在任何配置文件里 ——
+* 它**只在聊天记录里出现过**。⇒ 本文件把记录读成联系人表。
+*
+* ## 🔴 两条硬边界
+*
+* 1. **只读**：本文件不写任何东西。真相源仍是那些 jsonl（append-only 事件流），
+*    本文件只是它的一次投影 —— ⛔ 不产生第二真相源。
+* 2. **不猜渠道**：事件的 `channel` 字段为准；缺它（存量事件）⇒ 按
+*    `accountId → im.accounts[].channel` 回填，仍取不到才落 `weixin`
+*    （那是该字段存在之前唯一的渠道）。⛔ **绝不按 userId 的形状猜**
+*    （`ou_` 前缀 / `@im.wechat` 后缀都是命名习惯，不是判据 —— D167 认族不认名）。
+*/
+/** 日志根目录族（**新旧两代并存**：`_im-logs/<channel>/` 与存量 `_weixin-logs/`） */
+const IM_LOG_DIR_NEW = "_im-logs";
+const IM_LOG_DIR_LEGACY = "_weixin-logs";
+/** 某 CCC 下**存在**的日志目录（相对根），新代在前 */
+function imLogRoots(root) {
+	const out = [];
+	const newBase = join(root, "AGENT_SESSIONS", IM_LOG_DIR_NEW);
+	const legacy = join(root, "AGENT_SESSIONS", IM_LOG_DIR_LEGACY);
+	if (existsSync(newBase)) out.push(join("AGENT_SESSIONS", IM_LOG_DIR_NEW));
+	if (existsSync(legacy)) out.push(join("AGENT_SESSIONS", IM_LOG_DIR_LEGACY));
+	return out;
+}
+/** 收集某个日志根下所有 `*.jsonl`（含 `_im-logs/<channel>/` 一层；按文件名排序） */
+function jsonlFilesIn(root, rel) {
+	const abs = join(root, rel);
+	const out = [];
+	let entries = [];
+	try {
+		entries = readdirSync(abs, { withFileTypes: true }).map((d) => d.name);
+	} catch {
+		return out;
+	}
+	for (const name of entries.sort()) {
+		if (name.startsWith(".")) continue;
+		if (name.endsWith(".jsonl")) {
+			out.push(join(rel, name));
+			continue;
+		}
+		if (rel === join("AGENT_SESSIONS", "_im-logs")) {
+			const sub = join(rel, name);
+			try {
+				for (const child of readdirSync(join(root, sub)).sort()) if (child.endsWith(".jsonl")) out.push(join(sub, child));
+			} catch {}
+		}
+	}
+	return out;
+}
+/** 从文件名 / 所在目录猜渠道（**只作为回填的最后一级**，不是判据） */
+function channelFromPath(rel) {
+	const parts = rel.split("/");
+	const idx = parts.indexOf(IM_LOG_DIR_NEW);
+	const candidate = idx >= 0 && parts.length > idx + 2 ? parts[idx + 1] : void 0;
+	return candidate !== void 0 && candidate !== "" ? candidate : null;
+}
+/**
+* 扫描本 CCC 的全部聊天记录，按 `(channel, userId)` 汇总。
+*
+* @param root CCC 根
+* @param accountChannel 存量事件缺 `channel` 时的回填表（`accountId → channel`）
+* @returns 汇总结果 ＋ **扫描域** ＋ 读取错误（三者都不可省）
+*/
+function scanImContacts(root, accountChannel = {}) {
+	const byKey = /* @__PURE__ */ new Map();
+	const sources = [];
+	const errors = [];
+	for (const rel of imLogRoots(root)) for (const fileRel of jsonlFilesIn(root, rel)) {
+		sources.push(fileRel);
+		let text = "";
+		try {
+			text = readFileSync(join(root, fileRel), "utf8");
+		} catch (err) {
+			errors.push(`${fileRel}: ${err instanceof Error ? err.message : String(err)}`);
+			continue;
+		}
+		const pathChannel = channelFromPath(fileRel);
+		for (const line of text.split("\n")) {
+			const trimmed = line.trim();
+			if (trimmed === "") continue;
+			let ev;
+			try {
+				ev = JSON.parse(trimmed);
+			} catch {
+				errors.push(`${fileRel}: 有 1 行不是合法 JSON（已跳过）`);
+				continue;
+			}
+			const userId = typeof ev.userId === "string" ? ev.userId.trim() : "";
+			if (userId === "") continue;
+			const accountId = typeof ev.accountId === "string" ? ev.accountId.trim() : "";
+			const channel = (typeof ev.channel === "string" && ev.channel.trim() !== "" ? ev.channel.trim() : null) ?? pathChannel ?? (accountId !== "" ? accountChannel[accountId] ?? null : null) ?? "weixin";
+			const key = `${channel}\u0000${userId}`;
+			let entry = byKey.get(key);
+			if (!entry) {
+				entry = {
+					channel,
+					userId,
+					accountIds: [],
+					roleAtEvent: null,
+					firstSeen: null,
+					lastSeen: null,
+					messages: 0
+				};
+				byKey.set(key, entry);
+			}
+			if (accountId !== "" && !entry.accountIds.includes(accountId)) entry.accountIds.push(accountId);
+			if (typeof ev.role === "string" && ev.role.trim() !== "") entry.roleAtEvent = ev.role.trim();
+			const ts = typeof ev.ts === "number" && Number.isFinite(ev.ts) ? ev.ts : null;
+			if (ts !== null) {
+				if (entry.firstSeen === null || ts < entry.firstSeen) entry.firstSeen = ts;
+				if (entry.lastSeen === null || ts > entry.lastSeen) entry.lastSeen = ts;
+			}
+			entry.messages += 1;
+		}
+	}
+	return {
+		contacts: [...byKey.values()].sort((a, b) => (b.lastSeen ?? 0) - (a.lastSeen ?? 0)),
+		sources,
+		errors
+	};
+}
+//#endregion
 //#region src/im/channels.ts
 /**
 * im/channels.ts — IM 发送能力层（v1.31.0，S142 用户洞察）
@@ -11355,15 +11638,39 @@ function imChannelIds() {
 	return [...channels.keys()];
 }
 /**
-* 可见性判据：本 CCC 是否启用了**任一** IM 通道。
+* 可见性判据：本 CCC 是否**有任何可用的 IM 账号**。
 * 未启用 → 工具面对该 agent **不可见**（`tools.restrict` 移除，而非调用时报错）。
+*
+* ## 🔴 2026-10-22 判据修正（owner 令：「把开关升级为有任意账号即可，而不是盯着微信」）
+*
+* **旧判据** = 遍历已注册通道、任一 `channel.isEnabled(root)` 为真即可见。
+* **旧判据的缺陷**（实测于一个只配飞书的 CCC）：`feishuChannel.isEnabled()` 首行是
+* `if (settings.enabled !== true) return false` —— 总开关一关，**后面的账号判断根本不执行**
+* ⇒ 账号明明配了、`enabled:true`，却因为一个**渠道无关的总开关**被永久判成"未启用"
+* ⇒ `im-bridge` 在模型清单里彻底消失，而配置面看上去是对的（`accounts[]` 里躺着一条 feishu）。
+* 这正是 D179 的形态：**配置说它有，行为说它没有**，且零报错。
+*
+* **新判据** = **账号即事实**：`readImSettings(root).accounts` 里存在
+* 「`enabled !== false` 的账号」即视为可见。理由三条：
+* ① **可见性问的是"这个 CCC 有没有 IM 能力"**，而能力的载体是**账号**，不是总开关；
+* ② 总开关的语义是"**要不要让桥跑起来**"，把它当成可见性上限，会让"配好了但暂时不想让它跑"
+*    这种合法状态变成"工具凭空消失"；
+* ③ 判**按账号判**后，微信与飞书不再各有一套"总开关 + 账号"的双重判据 ⇒ 消除同族漂移。
+*
+* ⚠️ **不放宽的部分**：没有账号 ⇒ 仍然不可见（`accounts` 为空即 false）。
+* ⚠️ 单个通道自己的 `isEnabled` 仍是**发送/启停**判据（那是通道自己的事），
+*    只是**不再兼任**工具可见性判据 —— 两件事被这次修正分开了。
+*
 * @param root 本会话 CCC 根（由调用方解析）
 */
 function hasEnabledImChannel(root) {
-	for (const channel of channels.values()) try {
-		if (channel.isEnabled(root)) return true;
-	} catch {}
-	return false;
+	let settings;
+	try {
+		settings = readImSettings(root);
+	} catch {
+		return false;
+	}
+	return (settings.accounts ?? []).some((a) => a.enabled !== false);
 }
 /**
 * 错误码 → 可行动提示（模型视角：说清怎么改）。
@@ -11464,6 +11771,39 @@ async function runImBridge(root, req) {
 		action,
 		detail: { users: channel.listUsers(root) }
 	};
+	if (action === "contacts") {
+		if (!channel.listContacts) return fail("ACTION_UNSUPPORTED", `channel "${channelId}" has no record source for contacts`);
+		const settings = readWeixinSettings(root);
+		const accountChannel = {};
+		for (const account of settings.accounts ?? []) if (typeof account.accountId === "string" && account.accountId !== "") accountChannel[account.accountId] = typeof account.channel === "string" && account.channel !== "" ? account.channel : "weixin";
+		const scanned = scanImContacts(root, accountChannel);
+		const mine = scanned.contacts.filter((c) => c.channel === channelId);
+		/** 当前路由表（`user → trajectory`）；同一 user 多条时后者覆盖 */
+		const routeMap = /* @__PURE__ */ new Map();
+		for (const route of settings.routes ?? []) if (typeof route.user === "string" && route.user !== "") routeMap.set(route.user, typeof route.trajectory === "string" ? route.trajectory : "");
+		const contacts = mine.map((c) => ({
+			channel: c.channel,
+			userId: c.userId,
+			accountIds: c.accountIds,
+			route: routeMap.get(c.userId) ?? null,
+			firstSeen: c.firstSeen === null ? null : new Date(c.firstSeen).toISOString(),
+			lastSeen: c.lastSeen === null ? null : new Date(c.lastSeen).toISOString(),
+			messages: c.messages
+		}));
+		const seenUsers = new Set(mine.map((c) => c.userId));
+		return {
+			ok: true,
+			channel: channelId,
+			action,
+			detail: {
+				contacts,
+				unrouted: mine.filter((c) => !routeMap.has(c.userId)).map((c) => c.userId),
+				orphanRoutes: [...routeMap.keys()].filter((user) => !seenUsers.has(user)),
+				sources: scanned.sources,
+				...scanned.errors.length > 0 ? { errors: scanned.errors } : {}
+			}
+		};
+	}
 	if (action === "status") return {
 		ok: true,
 		channel: channelId,
@@ -11531,6 +11871,114 @@ async function runImBridge(root, req) {
 	return fail("ACTION_UNKNOWN", `unknown action "${action}"`);
 }
 //#endregion
+//#region src/seams/tool-visibility.ts
+/** 收集器：把各来源的 deny 合并成一个判决（**纯函数、无副作用**） */
+function collectVisibilityDecision(sources) {
+	const deny = /* @__PURE__ */ new Set();
+	let hasError = false;
+	for (const s of sources) {
+		if (s.error !== void 0) hasError = true;
+		if (!s.ok) continue;
+		for (const name of s.deny) if (typeof name === "string" && name !== "") deny.add(name);
+	}
+	return {
+		deny: [...deny].sort(),
+		sources,
+		hasError
+	};
+}
+/** 判决签名（幂等判据：签名相同 ⇒ 目标态已达到 ⇒ **一次 restrict 都不发**） */
+function decisionSignature(decision) {
+	return decision.deny.join(",");
+}
+/** `${sessionId}` → 已发射状态（**全模块唯一的一份**） */
+const applied = /* @__PURE__ */ new Map();
+/**
+* 发射一次判决（**唯一的写点**）。
+*
+* 三条纪律：
+* ① **幂等**：签名与当前已发射的一致 ⇒ 直接返回 `'unchanged'`，**不碰宿主**
+*    （这正是消除"工具清单闪动"的那一步）。
+* ② **先撤后发**：宿主的 disposer 才是"撤销上一次"，先撤再发才不会叠加旧集合。
+*    （旧集合是新集合的子集时叠不叠都看不出来，但**不是子集时**会残留 —— 必须撤。）
+* ③ 🔴 **未注册的名字不许炸掉整次发射**：宿主契约"unknown names … fail"。
+*    合并后集合里只要有一个不在册的名字，整次 restrict 就失败 ⇒ 六个机制**全都不生效**。
+*    ⇒ 发射前**先逐个探活**（`tools.get(name)`），把不在册的名字剔掉并**如实记账**
+*    （剔除的名字进 `dropped`，由调用方决定要不要告警）。
+*    ⚠️ 这比旧行为**更保守**：旧行为是"某条 restrict 失败 ⇒ 那一格静默不生效"，
+*    新行为是"剔掉那个名字、其余照常生效" —— **等价或更好**，且总有日志。
+*
+* @returns `'unchanged'` ／ `'applied'` ／ `'failed'`（`failed` 时 `deny` 保持原样）
+*/
+function applyVisibilityDecision(agent, sessionId, decision) {
+	const signature = decisionSignature(decision);
+	const existing = applied.get(sessionId);
+	if (existing !== void 0 && existing.signature === signature) return {
+		status: "unchanged",
+		dropped: []
+	};
+	if (existing !== void 0) {
+		try {
+			existing.dispose();
+		} catch {}
+		applied.delete(sessionId);
+	}
+	const tools = agent.ctx.tools;
+	const dropped = [];
+	let names = decision.deny;
+	if (typeof tools.get === "function") {
+		names = [];
+		for (const n of decision.deny) {
+			let present = false;
+			try {
+				present = tools.get(n) !== void 0;
+			} catch {
+				present = false;
+			}
+			if (present) names.push(n);
+			else dropped.push(n);
+		}
+	}
+	if (names.length === 0) {
+		applied.set(sessionId, {
+			signature,
+			deny: [],
+			dispose: () => {}
+		});
+		return {
+			status: "applied",
+			dropped
+		};
+	}
+	try {
+		const dispose = tools.restrict({ deny: [...names] });
+		applied.set(sessionId, {
+			signature,
+			deny: names,
+			dispose
+		});
+		return {
+			status: "applied",
+			dropped
+		};
+	} catch (e) {
+		return {
+			status: "failed",
+			dropped,
+			error: e.message
+		};
+	}
+}
+/** 会话销毁清理（防 per-会话 Map 无界增长；lifecycle 调用） */
+function forgetToolVisibility(sessionId) {
+	const existing = applied.get(sessionId);
+	if (existing === void 0) return;
+	try {
+		existing.dispose();
+	} catch {}
+	applied.delete(sessionId);
+}
+//#endregion
 //#region src/seams/guards.ts
 /**
 * guards.ts — 拦截缝：安全模式 + 路径守卫（P3 语义的机械层）
@@ -11667,6 +12115,119 @@ function decideGuard(input) {
 	}
 	return { kind: "allow" };
 }
+/**
+* 🔴 **工具可见性的唯一发射入口**（方案 C 的落地）。
+*
+* ## 它取代了什么
+*
+* 改之前有六条独立 sync，每条在自己的 per-会话 Map 里放一个 `restrict` disposer，
+* 且都由 `pre-step`（每步）与 `seed`（冷载入）各自调用 ⇒ 一次交互里可能发出多次
+* `tools.restrict` ⇒ 宿主每次发 `tools/change` ⇒ 模型侧看到工具清单**先进后出**
+* （实测症状：`新增 7 个` 紧跟 `移除 7 个`）。
+*
+* ## 为什么合并是对的（不是简化）
+*
+* 宿主 `ToolRuntime.restrict` 契约逐字：**Restrictions intersect**。
+* ⇒ N 次 `deny: Dᵢ` 的净效果 = `⋃Dᵢ`。先求并集只发一次，**结果相同**、只触发一次 `tools/change`。
+* 前提 = **只用 `deny`**（`allow` 的"交集"不满足并集律）；本仓 18 处 restrict 全部只发 `deny`。
+*
+* ## 正确性怎么保住（这是本设计被质疑的那一点）
+*
+* 六源**各自独立**算自己的 deny 并**各自 catch**：某一个来源读配置抛错 ⇒ 它返回
+* `ok:false`（不贡献 deny），**其余五源照常生效**。⇒ 合并**不会**把一格的失败放大成六格。
+* 全量计算见 {@link computeVisibilitySources}（纯函数）。
+*
+* @param agent 目标会话
+* @param root  CCC 根；`null` ⇒ 不在 CCC 内 ⇒ 隐藏**全部** ACC 工具
+*/
+function syncToolVisibility(agent, root) {
+	const sessionId = agent.session.id ?? "global";
+	const sources = computeVisibilitySources(sessionId, root);
+	const decision = collectVisibilityDecision(sources);
+	if (root !== null && decision.hasError) {
+		const bad = sources.filter((s) => s.error !== void 0);
+		for (const s of bad) console.error(`[serenity-hooks] 工具可见性来源「${s.id}」判据失败（其余来源照常生效）: ${s.error ?? ""}`);
+	}
+	const r = applyVisibilityDecision(agent, sessionId, decision);
+	if (r.status === "failed") console.error(`[serenity-hooks] 工具可见性发射失败 (session=${sessionId}): ${r.error ?? ""}`);
+	else if (r.dropped.length > 0) console.log(`[serenity-hooks] 工具可见性：跳过 ${r.dropped.length} 个未注册名（${r.dropped.join(", ")}）`);
+}
+/**
+* 六源 → 各自的 deny 集合（**纯函数：只读配置、不碰宿主**）。
+*
+* 每条来源**自己负责自己的失败**：抛错就 catch 在这里，转成 `ok:false + error`。
+* ⛔ 绝不让一个来源的异常冒泡 —— 那会让另外五源一起失效（正是合并最容易犯的错）。
+*/
+function computeVisibilitySources(sessionId, root) {
+	const out = [];
+	out.push(sourceOf("nonCcc", () => {
+		if (root !== null) return { deny: [] };
+		return { deny: [...REGISTERED_TOOLS] };
+	}));
+	if (root === null) {
+		for (const id of [
+			"safeMode",
+			"imBridge",
+			"exclusive",
+			"hostSchedule",
+			"trajectoryConstraint"
+		]) out.push({
+			id,
+			deny: [],
+			ok: false
+		});
+		return out;
+	}
+	out.push(sourceOf("safeMode", () => {
+		if (!isSafeModeOn(root)) return { deny: [] };
+		let declared = [];
+		try {
+			declared = readSafeModeHiddenTools(root);
+		} catch (e) {
+			return {
+				deny: [...SAFE_MODE_DENY_TOOLS],
+				error: e.message
+			};
+		}
+		return { deny: [.../* @__PURE__ */ new Set([...SAFE_MODE_DENY_TOOLS, ...declared])] };
+	}));
+	out.push(sourceOf("imBridge", () => hasEnabledImChannel(root) ? { deny: [] } : { deny: [IM_BRIDGE_TOOL_NAME] }));
+	out.push(sourceOf("exclusive", () => {
+		const declared = readExclusiveTools(root);
+		return { deny: EXCLUSIVE_TOOL_NAMES.filter((t) => !declared.includes(t)) };
+	}));
+	out.push(sourceOf("hostSchedule", () => ({ deny: [...HOST_SCHEDULE_TOOL_NAMES] })));
+	out.push(sourceOf("trajectoryConstraint", () => {
+		const profile = trajectoryConstraintForSession(root, sessionId);
+		if (profile === null) return { deny: [] };
+		const allowed = profileToolWhitelist(profile);
+		if (allowed === null) return { deny: [] };
+		return { deny: REGISTERED_TOOLS.filter((n) => !allowed.has(n)) };
+	}));
+	return out;
+}
+/**
+* 把一个"可能抛错的 denies 计算"包成来源（**统一在这里 catch**）。
+* 失败 ⇒ `ok:false`：本来源不贡献 deny，**其余来源不受影响**。
+*/
+function sourceOf(id, fn) {
+	try {
+		const r = fn();
+		return {
+			id,
+			deny: r.deny,
+			ok: true,
+			...r.error !== void 0 ? { error: r.error } : {}
+		};
+	} catch (e) {
+		return {
+			id,
+			deny: [],
+			ok: false,
+			error: e.message
+		};
+	}
+}
 /** 从 exec 提取 agent 会话 cwd（CCC 根检测基准）；无则回退进程 cwd */
 function resolveAgentCwd(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
@@ -11692,168 +12253,17 @@ function getRestrictDiagnostics() {
 		denyByKey: Object.fromEntries([...safeModeRestrictions].map(([k, v]) => [k, v.deny]))
 	};
 }
-/** 诊断落盘：AGENT_SESSIONS/.restrict-diag.json（文件通道，避免 HTTP 自锁） */
-function writeRestrictDiag(root) {
-	try {
-		const dir = resolve(root, "AGENT_SESSIONS");
-		mkdirSync(dir, { recursive: true });
-		writeFileSync(resolve(dir, ".restrict-diag.json"), JSON.stringify({
-			...getRestrictDiagnostics(),
-			cccRoot: root
-		}, null, 2) + "\n", "utf-8");
-	} catch {}
-}
-/**
-* 同步安全模式工具隐藏：标记存在 → `agent.ctx.tools.restrict deny` 隐藏
-* **基础表（bash）∪ CCC 声明的 `safeMode.hiddenTools`**；标记消失 → 全部解除。
-* pre-step 每步调用 ⇒ 开／关／**改声明**三种变化都实时生效（v1.51.4 起含"改声明"）。
-*
-* 与 `readSafeModeHiddenTools` 的分工（R↓）：本函数负责**形状与失败退化**，reader 只管取值。
-* 🔴 退化规则：DSH 契约规定 **未注册的工具名会让整次 restrict 失败**（"unknown names … fail"）
-* ⇒ 绝不能让 CCC 写错一个名字就丢掉 safe-mode 的核心隐藏（bash）。失败时退化为**只隐藏基础表**，
-* 并在日志响亮报错；退化态**按期望签名记账**，不会每步重试刷屏。
-*/
-function syncSafeModeRestriction(agent, root) {
-	const key = agent.session.id ?? "global";
-	const on = isSafeModeOn(root);
-	const existing = safeModeRestrictions.get(key);
-	if (!on) {
-		if (existing !== void 0) {
-			try {
-				existing.dispose();
-			} catch (e) {
-				console.error(`[serenity-hooks] restrict 解除失败 (key=${key}):`, e.message);
-			}
-			safeModeRestrictions.delete(key);
-		}
-		writeRestrictDiag(root);
-		return;
-	}
-	let declared = [];
-	try {
-		declared = readSafeModeHiddenTools(root);
-	} catch (e) {
-		console.error(`[serenity-hooks] safeMode.hiddenTools 判据读取失败 (key=${key}):`, e.message);
-	}
-	const deny = [.../* @__PURE__ */ new Set([...SAFE_MODE_DENY_TOOLS, ...declared])];
-	const signature = deny.join(",");
-	if (existing !== void 0 && existing.signature === signature) {
-		writeRestrictDiag(root);
-		return;
-	}
-	if (existing !== void 0) {
-		try {
-			existing.dispose();
-		} catch (e) {
-			console.error(`[serenity-hooks] restrict 重算前解除失败 (key=${key}):`, e.message);
-		}
-		safeModeRestrictions.delete(key);
-	}
-	let applied = deny;
-	let dispose;
-	try {
-		dispose = agent.ctx.tools.restrict({ deny: [...deny] });
-	} catch (e) {
-		restrictDiag.lastKey = key;
-		restrictDiag.lastAttemptAt = isoLocal();
-		restrictDiag.lastSuccess = false;
-		restrictDiag.lastError = e.message;
-		console.error(`[serenity-hooks] restrict 失败，已退化为基础表（多为 safeMode.hiddenTools 里有本 CCC **未注册**的工具名）(key=${key}):`, e.message);
-		applied = [...SAFE_MODE_DENY_TOOLS];
-		try {
-			dispose = agent.ctx.tools.restrict({ deny: applied });
-		} catch (e2) {
-			restrictDiag.lastError = `${e.message} ／ 退化亦失败: ${e2.message}`;
-			console.error(`[serenity-hooks] restrict 退化失败（守卫仍兜底拦截）(key=${key}):`, e2.message);
-			safeModeRestrictions.set(key, {
-				signature,
-				deny: [],
-				dispose: () => {}
-			});
-			writeRestrictDiag(root);
-			return;
-		}
-	}
-	restrictDiag.lastKey = key;
-	restrictDiag.lastAttemptAt = isoLocal();
-	restrictDiag.lastSuccess = true;
-	restrictDiag.lastError = null;
-	safeModeRestrictions.set(key, {
-		signature,
-		deny: applied,
-		dispose
-	});
-	writeRestrictDiag(root);
-}
 /** 条件可见的 IM 工具名（与 tools/im/channels.ts 的注册名一致） */
 const IM_BRIDGE_TOOL_NAME = "im-bridge";
-/** agent key → restrict disposer（im-bridge 隐藏状态；key 同安全模式 = 会话 id） */
-const imBridgeRestrictions = /* @__PURE__ */ new Map();
-/**
-* 同步 im-bridge 可见性（v1.31.0，S142 用户拍板 Q3「未配置则不可见」）。
-*
-* 判据 = 本会话 CCC 是否启用了**任一** IM 通道（`hasEnabledImChannel`，当前只有 weixin）：
-* - 未启用 → `agent.ctx.tools.restrict({ deny: ['im-bridge'] })`：**从 schema 移除**
-*   （模型看不到，而不是看得到但调用被拒——用户原话"不配置则不可见"）
-* - 启用 → 解除隐藏（CCC 配置热更新即时生效）
-*
-* 与 `syncSafeModeRestriction` 同点调用（pre-step 每步 + 会话就绪），失败不阻断
-* （守卫仍兜底；restrict 不可用时最坏是"看得到但通道未配置 → 返回 CHANNEL_NOT_CONFIGURED"）。
-*/
-function syncImBridgeVisibility(agent, root) {
-	const key = agent.session.id ?? "global";
-	let enabled = false;
-	try {
-		enabled = hasEnabledImChannel(root);
-	} catch (e) {
-		console.error(`[serenity-hooks] im-bridge 可见性判据失败 (key=${key}):`, e.message);
-		return;
-	}
-	const existing = imBridgeRestrictions.get(key);
-	if (!enabled && !existing) try {
-		const dispose = agent.ctx.tools.restrict({ deny: [IM_BRIDGE_TOOL_NAME] });
-		imBridgeRestrictions.set(key, dispose);
-	} catch (e) {
-		console.error(`[serenity-hooks] im-bridge 隐藏失败 (key=${key}):`, e.message);
-	}
-	else if (enabled && existing) {
-		try {
-			existing();
-		} catch (e) {
-			console.error(`[serenity-hooks] im-bridge 解除隐藏失败 (key=${key}):`, e.message);
-		}
-		imBridgeRestrictions.delete(key);
-	}
-}
-/** 会话销毁清理（lifecycle 调用；防 per-会话 Map 无界增长——review F-08 同族） */
-function forgetImBridgeVisibility(sessionId) {
-	const existing = imBridgeRestrictions.get(sessionId);
-	if (!existing) return;
-	try {
-		existing();
-	} catch {}
-	imBridgeRestrictions.delete(sessionId);
-}
 /**
-* 宿主 `dsh-tool-schedule` 注册的 4 个模型可见工具名（**逐字**，来自该包 `lib/index.js` 的
-* `defineTool({ name: … })`：`schedule_create` / `schedule_list` / `schedule_update` / `schedule_delete`）。
+* 宿主 `dsh-tool-schedule` 注册的 4 个模型可见工具名（**逐字**）。
 *
-* 🔴 **为什么要在 CCC 内屏蔽（owner 原话：「这和 CRO 冲突，要求在宁静号激活情况下屏蔽掉」）**：
-* 宿主从 `0.2.1-rc.2` 起自带一套**模型可见的定时器工具**（`ctx.schedule` 服务 + 这 4 个工具）。
-* 而宁静号的唤醒/巡航走的是**另一套**机制：`cognitive_trajectory send-later` → 落 CCC 的
-* `AGENT_SESSIONS/wake-registry.json` → 由**中心调度器 5min tick 统一投递**（D58）。
-* 两套并存会产生**三个具体问题**（不是"重复功能"这种审美问题）：
-*  ① **两处真相源**：宿主的 schedule 状态在宿主域、我们的在 CCC 文件里，**谁在跑说不清**；
-*  ② **CRO 判据失真**：CRO 程序读的是 `wake-registry.json`，宿主定时器触发的唤起**它看不见**
-*     ⇒ 巡检/记账全部遗漏（本轨已有同族教训：「CRO 只在 `wake===true` 时算」那条被推翻）；
-*  ③ **安静失败**：模型可能顺手用 `schedule_create` 排一个唤醒，**它不在任何人的账本里**。
-* ⇒ 故**在 CCC 内隐藏**（从模型清单移除），非 CCC 会话**不受影响**（那是宿主的正常能力）。
-*
-* ⚠️ **一处必须防的坑**（与 `hideAllFor` 同族）：宿主 `restrict` 对**未注册的名字**会让**整次调用失败**
-* （`dsh-tools` 契约逐字："Empty filters, unknown names … fail"）。
-* 这 4 个名字是否在册取决于**宿主是否装了该 tool 包**（不同宿主版本/裁剪可能没有）
-* ⇒ 所以**逐个名字单独发 restrict**，某个失败就跳过那个，**绝不整批发**
-* （整批发一旦撞到缺名的宿主 ⇒ 一个都不隐藏 + 只有一行 log ⇒ 缺陷静默）。
+* 🔴 **为什么要在 CCC 内屏蔽**（owner 原话：「这和 CRO 冲突，要求在宁静号激活情况下屏蔽掉」）：
+* 宁静号的唤醒/巡航走 `cognitive_trajectory send-later` → `AGENT_SESSIONS/wake-registry.json`
+* → 中心调度器 5min tick（D58）。宿主这套定时器是**另一个**真相源 ⇒ 两处记账、
+* CRO 判据失真、且模型可能顺手排一个"不在任何账本里"的唤醒。
+* ⚠️ 本清单**合并发射时不需要探活**（`applyVisibilityDecision` 统一个剔掉未注册名），
+*    所以宿主没装该包时不会炸掉整次发射 —— 这是方案 C 顺带修掉的一个旧坑。
 */
 const HOST_SCHEDULE_TOOL_NAMES = [
 	"schedule_create",
@@ -11861,42 +12271,6 @@ const HOST_SCHEDULE_TOOL_NAMES = [
 	"schedule_update",
 	"schedule_delete"
 ];
-/** `${sessionId}::${toolName}` → restrict disposer（逐工具，便于某个名字不成立时单独跳过） */
-const hostScheduleRestrictions = /* @__PURE__ */ new Map();
-/**
-* 在 **CCC 内**屏蔽宿主自带的定时器工具（v1.59.5）。
-*
-* 判据 = **会话是否落在某个 CCC 内**（`root !== null`）——与 `syncCccToolVisibility` 互补：
-* 那个管"不在 CCC ⇒ 隐藏**我们自己的**全部工具"，本函数管"**在** CCC ⇒ 隐藏**宿主的**定时器工具"。
-*
-* 幂等；失败不阻断 step（最坏 = 那一个工具仍可见，但那只是"宿主的正常能力没被藏起来"，
-* 不会让会话坏掉）。逐个名字独立发 restrict ⇒ 任何一个名字不在册都不会连累其余三个。
-*
-* @param agent 目标会话
-* @param root  该会话的 CCC 根；`null` ⇒ 非 CCC ⇒ **不动**（宿主的定时器在别处是正常能力）
-*/
-function syncHostScheduleToolHiding(agent, root) {
-	if (root === null) return;
-	const sessionId = agent.session.id ?? "global";
-	for (const tool of HOST_SCHEDULE_TOOL_NAMES) {
-		const key = `${sessionId}::${tool}`;
-		if (hostScheduleRestrictions.has(key)) continue;
-		try {
-			hostScheduleRestrictions.set(key, agent.ctx.tools.restrict({ deny: [tool] }));
-		} catch {}
-	}
-}
-/** 会话销毁清理（lifecycle 调用；按 `${sessionId}::` 前缀回收） */
-function forgetHostScheduleToolHiding(sessionId) {
-	const prefix = `${sessionId}::`;
-	for (const [key, dispose] of [...hostScheduleRestrictions]) {
-		if (!key.startsWith(prefix)) continue;
-		try {
-			dispose();
-		} catch {}
-		hostScheduleRestrictions.delete(key);
-	}
-}
 /**
 * ACC 注册但**默认对所有 CCC 隐藏**的专属工具清单。
 *
@@ -11906,156 +12280,6 @@ function forgetHostScheduleToolHiding(sessionId) {
 * 本族是"被点名才可见"（能力归属 ACC 负责人）。
 */
 const EXCLUSIVE_TOOL_NAMES = ["acc-diag"];
-/** `${sessionId}::${toolName}` → restrict disposer */
-const exclusiveRestrictions = /* @__PURE__ */ new Map();
-/**
-* `sessionId` → { signature, dispose }（角色工具面 restrict 状态）
-*
-* `signature` = 本轮实际发出的 deny 清单（排序后 join）。用它做**幂等判据**：
-* 每次 pre-step 都重算白名单，只有**算出来的结果变了**才重新发 restrict
-* —— 配置不变就不重复发（restrict 会重建 schema，没必要每步都做）。
-*/
-const trajectoryConstraintRestrictions = /* @__PURE__ */ new Map();
-/**
-* 同步 **轨迹约束会话的工具面**：把白名单之外的工具**从 schema 移除**（不是"看得到但被拒"）。
-*
-* ## 为什么必须有这条（owner 2026-10-19：「工具清单也要热加载」）
-*
-* 在它之前，轨迹约束白名单**只由运行时守卫拦截**（`decideGuard` 的 轨迹约束 分支）：
-* 工具全部出现在模型 schema 里，调用时才被打回。⇒ 两个真实后果：
-*  ① **模型看得见它不该有的工具** —— 它会去试，试了才撞墙（一轮白烧，且错误文案泛化，
-*     看不出"是不在清单里"还是"临时性拒绝"）；
-*  ② **配置变动在 schema 上永远不生效** —— 改 `trajectory-constraint.json` 的 `tools` 只影响"调用是否放行"。
-*
-* ## 判据与降级
-*
-* - deny 集合 = **`REGISTERED_TOOLS` − 白名单**（只对**我们自己注册的**工具算，
-*   不去动宿主的工具 —— 宿主的工具由各自的条件同步管）。
-* - ⚠️ **未注册的名字会让整次 restrict 失败**（宿主契约逐字 "unknown names … fail"），
-*   而 `diagram` 是按开关注册的 ⇒ 与 `hideAllFor` 同款**两档尝试**（先全覆盖，失败退常驻段）。
-* - 读不到约束面（不是 轨迹约束 / 配置删了）⇒ **撤销既有隐藏**（回到"无约束"）：
-*   ⛔ 不能只是 `return` —— 那会把上一步的隐藏**永久留在**一个已不再是 轨迹约束的会话上
-*   （这正是 owner 说的"删掉 `trajectory-constraint.json` 就该立刻恢复"）。
-* - 幂等：算出来的 deny 签名不变就跳过（不每步重建 schema）。
-*
-* @param agent 目标会话
-* @param root  CCC 根
-*/
-function syncTrajectoryConstraintToolVisibility(agent, root) {
-	const sessionId = agent.session.id ?? "global";
-	const profile = trajectoryConstraintForSession(root, sessionId);
-	const existing = trajectoryConstraintRestrictions.get(sessionId);
-	if (profile === null) {
-		if (existing !== void 0) {
-			try {
-				existing.dispose();
-			} catch {}
-			trajectoryConstraintRestrictions.delete(sessionId);
-		}
-		return;
-	}
-	const allowed = profileToolWhitelist(profile);
-	if (allowed === null) {
-		if (existing !== void 0) {
-			try {
-				existing.dispose();
-			} catch {}
-			trajectoryConstraintRestrictions.delete(sessionId);
-		}
-		return;
-	}
-	const resident = REGISTERED_TOOLS.slice(0, REGISTERED_TOOLS.length - 3);
-	const tiers = [REGISTERED_TOOLS, resident];
-	for (const names of tiers) {
-		const deny = names.filter((n) => !allowed.has(n));
-		const signature = [...deny].sort().join(",");
-		if (existing !== void 0 && existing.signature === signature) return;
-		if (deny.length === 0) {
-			if (existing !== void 0) {
-				try {
-					existing.dispose();
-				} catch {}
-				trajectoryConstraintRestrictions.delete(sessionId);
-			}
-			return;
-		}
-		try {
-			if (existing !== void 0) {
-				try {
-					existing.dispose();
-				} catch {}
-				trajectoryConstraintRestrictions.delete(sessionId);
-			}
-			const dispose = agent.ctx.tools.restrict({ deny: [...deny] });
-			trajectoryConstraintRestrictions.set(sessionId, {
-				signature,
-				deny,
-				dispose
-			});
-			return;
-		} catch {
-			continue;
-		}
-	}
-}
-/** 会话销毁清理（lifecycle 调用） */
-function forgetTrajectoryConstraintToolVisibility(sessionId) {
-	const existing = trajectoryConstraintRestrictions.get(sessionId);
-	if (!existing) return;
-	try {
-		existing.dispose();
-	} catch {}
-	trajectoryConstraintRestrictions.delete(sessionId);
-}
-/**
-* 同步专属工具可见性（v1.33）。
-*
-* 判据 = CCC 配置 `exclusiveTools`（`readExclusiveTools`）：
-* - **未声明** → `agent.ctx.tools.restrict({ deny: [tool] })`：从 schema 移除（模型看不到）
-* - **声明** → 解除隐藏（CCC 配置热更新即时生效）
-*
-* 判据失败按"未声明"处理（fail-closed：专属工具默认隐藏），原因见 `readExclusiveTools` 注释。
-* 与 `syncImBridgeVisibility` 同点调用（pre-step 每步 + 会话就绪），失败不阻断一步——
-* 最坏情况是"看得到但被拒"，而不是让 step 出错。
-*/
-function syncExclusiveToolsVisibility(agent, root) {
-	const sessionId = agent.session.id ?? "global";
-	let declared = [];
-	try {
-		declared = readExclusiveTools(root);
-	} catch (e) {
-		console.error(`[serenity-hooks] 专属工具可见性判据失败 (session=${sessionId}):`, e.message);
-	}
-	for (const tool of EXCLUSIVE_TOOL_NAMES) {
-		const key = `${sessionId}::${tool}`;
-		const existing = exclusiveRestrictions.get(key);
-		const visible = declared.includes(tool);
-		if (!visible && !existing) try {
-			exclusiveRestrictions.set(key, agent.ctx.tools.restrict({ deny: [tool] }));
-		} catch (e) {
-			console.error(`[serenity-hooks] 专属工具隐藏失败 (${key}):`, e.message);
-		}
-		else if (visible && existing) {
-			try {
-				existing();
-			} catch (e) {
-				console.error(`[serenity-hooks] 专属工具解除隐藏失败 (${key}):`, e.message);
-			}
-			exclusiveRestrictions.delete(key);
-		}
-	}
-}
-/** 会话销毁清理（lifecycle 调用；本函数按 `${sessionId}::` 前缀回收全部专属工具项） */
-function forgetExclusiveToolsVisibility(sessionId) {
-	const prefix = `${sessionId}::`;
-	for (const [key, dispose] of [...exclusiveRestrictions]) {
-		if (!key.startsWith(prefix)) continue;
-		try {
-			dispose();
-		} catch {}
-		exclusiveRestrictions.delete(key);
-	}
-}
 /**
 * 非 CCC 会话的工具隐藏状态（sessionId → restrict disposer）。
 *
@@ -12079,74 +12303,6 @@ function forgetExclusiveToolsVisibility(sessionId) {
 * **静默退回"工具照样可见"**＝缺陷没修好。故此处走**两档尝试**（见 `hideAllFor`）。
 */
 const nonCccRestrictions = /* @__PURE__ */ new Map();
-/**
-* 在非 CCC 会话上隐藏全部 ACC 工具（两档尝试）。
-*
-* 🔴 **为什么要两档（D119：不许照源码"意图"断言宿主行为）**：取消注册的工具名会让整次
-* `restrict` 失败，而 `diagram` 缺省不在册。若只发一次全表 deny，"deny 里有个不在册的名字"
-* 就会让**整次调用**失败 ⇒ 一个都不隐藏（且只有一行 console.error）。
-*
-* 档位（**先全覆盖、失败再退到"恒在册"那一段**）：
-*   ① 全表 `REGISTERED_TOOLS`（14：含条件工具）—— 首选，覆盖最全
-*   ② 常驻段（前 `length - CONDITIONAL_TOOL_COUNT` 个）—— 退路：只保证**恒注册**的那些被隐藏
-*
-* 返回**实际生效的注销器**；两档都失败 → `{ failed: [...] }`（原因一并带回，由调用方决定怎么响）。
-*
-* ⚠️ **档位失败不在这里逐条告警**：档 ① 在 `diagram` 缺省关时**按设计**就会失败（它不在册），
-* 那是**常态**、不是故障 ⇒ 逐条 error 会在每个非 CCC 会话上刷**假警报**（看着像坏了，其实档 ② 已成功）。
-* 真正的失败只由调用方在"两档全失败"时**响亮报一次**。
-*/
-function hideAllFor(agent) {
-	const resident = REGISTERED_TOOLS.slice(0, REGISTERED_TOOLS.length - 3);
-	const tiers = [{
-		label: "全表（含条件工具）",
-		names: REGISTERED_TOOLS
-	}, {
-		label: "常驻段（跳过条件工具）",
-		names: resident
-	}];
-	const failed = [];
-	for (const tier of tiers) try {
-		return {
-			dispose: agent.ctx.tools.restrict({ deny: [...tier.names] }),
-			names: tier.names
-		};
-	} catch (e) {
-		failed.push(`${tier.label}: ${e.message}`);
-	}
-	return { failed };
-}
-/**
-* 同步「本会话在不在 CCC 内」的工具可见性（v1.56.6）。
-*
-* @param agent 目标会话的 agent
-* @param root 该会话的 CCC 根；`null` ⇒ **不在任何 CCC 内** ⇒ 隐藏全部 ACC 工具
-*
-* 幂等：同一会话重复调用不会重复 restrict（已是目标态即直接返回）。
-* 失败不抛（最坏情况：工具可见，但**调用时**仍被各工具自己的根解析拒绝——既有兜底不变）。
-*/
-function syncCccToolVisibility(agent, root) {
-	const sessionId = agent.session.id ?? "global";
-	const existing = nonCccRestrictions.get(sessionId);
-	const shouldHide = root === null;
-	if (shouldHide && !existing) {
-		const hidden = hideAllFor(agent);
-		if ("failed" in hidden) {
-			console.error(`[serenity-hooks] 非 CCC 工具隐藏**两档全失败**(session=${sessionId}) —— 工具仍可见（但有各工具自身的 !root 兜底）：${hidden.failed.join(" ／ ")}`);
-			return;
-		}
-		nonCccRestrictions.set(sessionId, hidden.dispose);
-		return;
-	}
-	if (!shouldHide && existing) {
-		try {
-			existing();
-		} catch (e) {
-			console.error(`[serenity-hooks] 非 CCC 工具恢复失败 (session=${sessionId}):`, e.message);
-		}
-		nonCccRestrictions.delete(sessionId);
-	}
-}
 /** 会话销毁清理（lifecycle 调用；防 per-会话 Map 无界增长） */
 function forgetNonCccToolVisibility(sessionId) {
 	const existing = nonCccRestrictions.get(sessionId);
@@ -13352,11 +13508,65 @@ function accMessage(root, configPaths, entrySkillMaxChars) {
 		source: PLUGIN_SOURCE
 	});
 }
-/** 每 agent 是否已注入过（进程内存态） */
+/**
+* 每 agent 是否已注入过 —— **只作为本进程内的快路径**，⛔ 不是判据。
+*
+* 🔴🔴 2026-10-22（owner 报「send-now 创建的会话消息注入两次」的取证结论）：
+* 此前**它就是判据**，于是 `pre-step` 那道门拿它回答"**这条会话**注入过没有"——
+* 而它实际回答的是"**本进程**注入过没有"。进程一换（`restart-web` / 看门狗拉起 /
+* 崩溃重启）它就清空 ⇒ 老会话被冷载入时 `pre-step` 判"没注入过" ⇒ **再注入一遍**。
+*
+* 实测铁证（同一会话两条 `[ACC] … active` 横幅，相隔 18.6 小时）：
+* 只有**跨过重启**的会话有两条，没跨的只有一条 ⇒ 重复的量 = 跨了几个进程。
+*
+* ⇒ 判据改为 {@link hasAccBanner}（读**会话历史**）。本 Set 降级为"同进程免重复扫"的优化：
+*   命中它就直接返回（省一次扫），⛔ 它为空**不代表**没注入过。
+*/
 const injected = /* @__PURE__ */ new Set();
 function agentKey(agent) {
 	return agent.session.id ?? "global";
 }
+/**
+* ACC 身份横幅在**会话历史**里的识别特征（结构判据，不依赖措辞顺序）。
+*
+* 🔴 为什么认 `source.kind` ＋ 正文前缀两件：
+*   - 只认正文 ⇒ 将来文案一改就静默失效（D151 同族：判据不能长在措辞上）；
+*   - 只认 `source.kind` ⇒ 本插件注入的**所有**消息都算（`skill-catalog` 块、假首轮横幅…）
+*     ⇒ 会把"别的注入出现过"误当成"身份横幅出现过"，导致**永不再注入**。
+* ⇒ 两者与：由本插件发出 **且** 正文以 ACC 横幅首词开头。
+*/
+const ACC_BANNER_PREFIX = "[ACC] Serenity cognitive container active";
+/**
+* 这条会话的历史里**是否已经有** ACC 身份横幅（= 判据的唯一权威）。
+*
+* 🔴 这是本条修复的核心：**"注入过没有"是会话的属性，不是进程的属性。**
+* 会话历史随会话走（落盘、重启后仍在），进程内状态随进程死。
+*
+* ⚠️ 读不到 events（受限宿主 / 投影未就绪）⇒ 返回 `false`（退回"注入一次"）。
+*   这是**偏保守**的选择：多注入一条横幅（可见、可清理）远好于
+*   **永远不再注入**（陈旧会话里 ACC 身份彻底缺失，且零信号）。
+*
+* @param session 目标会话（`sessionEvents` 能读的形状）
+*/
+function hasAccBanner(session) {
+	return sessionEvents(session).some((event) => {
+		const e = event;
+		if (e.type !== "user/message") return false;
+		if (e.data?.source?.kind !== PLUGIN_SOURCE.kind) return false;
+		return textOfUserMessage(e.data)?.trimStart().startsWith(ACC_BANNER_PREFIX) === true;
+	});
+}
+/** 从 `user/message` 的 content 块数组里拼出纯文本（无 text 块 ⇒ undefined） */
+function textOfUserMessage(data) {
+	const content = data?.content;
+	if (!Array.isArray(content)) return void 0;
+	const parts = [];
+	for (const block of content) {
+		const b = block;
+		if (b?.type === "text" && typeof b.text === "string") parts.push(b.text);
+	}
+	return parts.length === 0 ? void 0 : parts.join("");
+}
 function agentScope(agent) {
 	return agent.session.id ?? "default";
 }
@@ -13394,7 +13604,7 @@ function registerContext(ctx, opts = {}) {
 		const cwd = agent.session?.header?.cwd ?? process.cwd();
 		const root = cccRootForCwd(cwd);
 		try {
-			syncCccToolVisibility(agent, root);
+			syncToolVisibility(agent, root);
 		} catch {}
 		if (!root) return;
 		const key = agentKey(agent);
@@ -13456,18 +13666,14 @@ function registerContext(ctx, opts = {}) {
 				}
 			}
 		} catch {}
-		if (injected.has(key)) return;
+		if (injected.has(key) || hasAccBanner(agent.session)) {
+			injected.add(key);
+			return;
+		}
 		injected.add(key);
 		agent.inject(accMessage(root, configPaths, entrySkillMaxChars));
-		syncSafeModeRestriction(agent, root);
-		try {
-			syncImBridgeVisibility(agent, root);
-		} catch {}
-		try {
-			syncExclusiveToolsVisibility(agent, root);
-		} catch {}
 		try {
-			syncHostScheduleToolHiding(agent, root);
+			syncToolVisibility(agent, root);
 		} catch {}
 		try {
 			syncTrajectoryModelForSession(agent, root);
@@ -13484,35 +13690,22 @@ function registerContext(ctx, opts = {}) {
 		const root = cccRootForCwd(cwd);
 		const key = agentKey(agent);
 		const downstream = await next();
-		if (root) {
-			try {
-				syncTrajectoryConstraintToolVisibility(agent, root);
-			} catch {}
-			try {
-				syncTrajectoryModelForSession(agent, root);
-			} catch {}
-		}
-		if (root && hasTrajectoryOwnCharter(root, key)) return downstream;
 		try {
-			syncCccToolVisibility(agent, root);
+			syncToolVisibility(agent, root);
 		} catch {}
+		if (root) try {
+			syncTrajectoryModelForSession(agent, root);
+		} catch {}
+		if (root && hasTrajectoryOwnCharter(root, key)) return downstream;
 		if (root) {
-			try {
-				syncSafeModeRestriction(agent, root);
-			} catch {}
-			try {
-				syncImBridgeVisibility(agent, root);
-			} catch {}
-			try {
-				syncExclusiveToolsVisibility(agent, root);
-			} catch {}
-			try {
-				syncHostScheduleToolHiding(agent, root);
-			} catch {}
 			registerEntrySkillSection(agent, root);
 			registerCognitiveTrajectorySkillSection(agent, root);
 		}
-		if (!root || injected.has(key) || downstream.kind !== "enter") return downstream;
+		if (!root || downstream.kind !== "enter") return downstream;
+		if (injected.has(key) || hasAccBanner(agent.session)) {
+			injected.add(key);
+			return downstream;
+		}
 		injected.add(key);
 		return {
 			kind: "enter",
@@ -14101,11 +14294,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+					const { readWeixinSettings } = await import("./route-3OzOAjec.js").then((n) => n.l);
 					const { weixinBridgeStatus } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { imCredentialBound } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+					const { imCredentialBound } = await import("./route-3OzOAjec.js").then((n) => n.l);
 					const { normalizeAccountChannel } = await import("./accounts-BHQbakUh.js").then((n) => n.t);
 					const accounts = (settings.accounts ?? []).map((a) => {
 						const channel = normalizeAccountChannel(a.channel);
@@ -14142,7 +14335,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { fetchQRCode } = await import("./ilink-BMk2w2KY.js").then((n) => n.a);
 					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("./route-Dr0SFD8A.js").then((n) => n.c);
+					const { readWeixinSettings } = await import("./route-3OzOAjec.js").then((n) => n.l);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -14163,7 +14356,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+					const { removeWeixinAccount } = await import("./route-3OzOAjec.js").then((n) => n.l);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -14189,8 +14382,8 @@ function registerStatusApi(ctx, opts = {}) {
 							trajectory: code
 						});
 					}
-					const { saveWeixinRoutes } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
-					const { findDirNameByCode } = await import("./profile-DnLSb7yv.js").then((n) => n.i);
+					const { saveWeixinRoutes } = await import("./route-3OzOAjec.js").then((n) => n.l);
+					const { findDirNameByCode } = await import("./profile-vHheCJiU.js").then((n) => n.a);
 					for (const r of routes) if (findDirNameByCode(root, r.trajectory) === null) {
 						sendJson$2(res, 400, { error: `unknown trajectory: ${r.trajectory} (no such trajectory code in ${root})` });
 						return;
@@ -14201,7 +14394,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./route-3OzOAjec.js").then((n) => n.l);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -14224,7 +14417,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "appId 与 appSecret 都必须填（只填一个等于没绑）" });
 						return;
 					}
-					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-3OzOAjec.js").then((n) => n.l);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					const before = readWeixinSettings(root);
 					const accountId = (body.accountId ?? "").trim() !== "" ? body.accountId.trim() : nextFeishuAccountId(before);
@@ -14274,7 +14467,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./ilink-BMk2w2KY.js").then((n) => n.a);
-				const { readWeixinSettings } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+				const { readWeixinSettings } = await import("./route-3OzOAjec.js").then((n) => n.l);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -14289,7 +14482,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-3OzOAjec.js").then((n) => n.l);
 						const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -18825,12 +19018,15 @@ function appendHumanChannelAudit(event) {
 const WEIXIN_HOOK_TIMEOUT_MS = 15e3;
 /** hook stderr/stdout 日志截断（防脚本刷屏） */
 const HOOK_LOG_MAX = 500;
+/** 存量调用点未传 `channel` 时的缺省值（本字段存在之前唯一的渠道） */
+const DEFAULT_HOOK_CHANNEL = "weixin";
 /** 构造 incoming 事件对象（纯函数，可测） */
 function buildIncomingHookEvent(input) {
 	return {
 		event: "incoming",
 		ts: Date.now(),
 		cccRoot: input.cccRoot,
+		channel: input.channel ?? DEFAULT_HOOK_CHANNEL,
 		accountId: input.accountId,
 		userId: input.userId,
 		sessionId: input.sessionId,
@@ -18847,6 +19043,7 @@ function buildOutgoingHookEvent(input) {
 		event: "outgoing",
 		ts: Date.now(),
 		cccRoot: input.cccRoot,
+		channel: input.channel ?? DEFAULT_HOOK_CHANNEL,
 		accountId: input.accountId,
 		userId: input.userId,
 		sessionId: input.sessionId,
@@ -19229,7 +19426,7 @@ const MEDIA_MAX_BYTES = 20971520;
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-VCJ3aYJA.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-BI_4UVcj.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -19297,7 +19494,7 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const { findDirNameByCode } = await import("./profile-DnLSb7yv.js").then((n) => n.i);
+	const { findDirNameByCode } = await import("./profile-vHheCJiU.js").then((n) => n.a);
 	if (findDirNameByCode(root, target.role) === null) {
 		const detail = `目标 CCC "${target.ccc}" 内没有编码为 "${target.role}" 的认知轨迹`;
 		console.error(`[serenity-hooks] ✗ human-channel: ${detail}（account=${input.account} user=${input.user}）—— 该消息**未投递**，请改订阅表里的目标编码`);
@@ -19526,6 +19723,7 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 			const hookRel = settings.hook;
 			if (hookRel) invokeWeixinHook(root, hookRel, buildIncomingHookEvent({
 				cccRoot: root,
+				channel,
 				accountId,
 				userId: fromUserId,
 				sessionId,
@@ -19552,6 +19750,7 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 				console.warn(`[serenity-hooks] ⚠ im 输出兜底：agent 本轮未发送（闸门打回用尽）→ 桥转发最终文本（session=${sessionId}, trajectory=${trajectory}）`);
 				if (hookRel) invokeWeixinHook(root, hookRel, buildOutgoingHookEvent({
 					cccRoot: root,
+					channel,
 					accountId,
 					userId: fromUserId,
 					sessionId,
@@ -19572,6 +19771,7 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 			});
 			if (hookRel) invokeWeixinHook(root, hookRel, buildOutgoingHookEvent({
 				cccRoot: root,
+				channel,
 				accountId,
 				userId: fromUserId,
 				sessionId,
@@ -20247,7 +20447,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-VCJ3aYJA.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-BI_4UVcj.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -20344,6 +20544,7 @@ async function sendProactiveText(input) {
 	}
 	if (settings.hook) invokeWeixinHook(root, settings.hook, buildOutgoingHookEvent({
 		cccRoot: root,
+		channel: "weixin",
 		accountId,
 		userId: toUserId,
 		sessionId,
@@ -20538,7 +20739,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-VCJ3aYJA.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-BI_4UVcj.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -20767,20 +20968,11 @@ function cleanupSessionState(sessionId) {
 		forgetManualOutputSession(sessionId);
 	} catch {}
 	try {
-		forgetImBridgeVisibility(sessionId);
-	} catch {}
-	try {
-		forgetExclusiveToolsVisibility(sessionId);
+		forgetToolVisibility(sessionId);
 	} catch {}
 	try {
 		forgetNonCccToolVisibility(sessionId);
 	} catch {}
-	try {
-		forgetHostScheduleToolHiding(sessionId);
-	} catch {}
-	try {
-		forgetTrajectoryConstraintToolVisibility(sessionId);
-	} catch {}
 	try {
 		forgetLogbookCompactionState(sessionId);
 	} catch {}
@@ -21753,6 +21945,24 @@ function credentialValue$1(root, key) {
 function channelError$1(code, error, remediation) {
 	return /* @__PURE__ */ new Error(`${code}: ${error}${remediation ? ` — ${remediation}` : ""}`);
 }
+/**
+* 路由目标轨迹**是否存在**（`status` 的自检列）。
+*
+* 🔴 复用既有判据 `findDirNameByCode`（它扫活跃区并按编码解析）—— ⛔ 不在这里另写一套目录扫描，
+*    两份判据会漂（一处认归档、另一处不认，就会出现"这里说有、投递时说没有"）。
+*
+* ⚠️ 解析失败（`findDirNameByCode` 在**重码**时会抛）⇒ 返回 `false` 但**不吞掉原因**：
+*    重码本身也是"这个路由不可信"的一种形态，`status` 里会表现为 `targetExists:false`，
+*    配合 `cognitive_trajectory list` 可定位。不额外造一个错误码（键名已经够直白）。
+*/
+function trajectoryDirExists(root, code) {
+	if (typeof code !== "string" || code.trim() === "") return false;
+	try {
+		return findDirNameByCode(root, code.trim()) !== null;
+	} catch {
+		return false;
+	}
+}
 const weixinChannel = {
 	id: "weixin",
 	isEnabled(root) {
@@ -21831,6 +22041,7 @@ const weixinChannel = {
 			const trajectory = matchWeixinRoute(settings.routes ?? [], input.userId) ?? "";
 			invokeWeixinHook(input.root, settings.hook, buildOutgoingHookEvent({
 				cccRoot: input.root,
+				channel: "weixin",
 				accountId: account.accountId,
 				userId: input.userId,
 				sessionId: weixinSessionIdForTrajectory(trajectory !== "" ? trajectory : sanitizeFileName$1(input.userId) || "unknown"),
@@ -21862,10 +22073,14 @@ const weixinChannel = {
 			lastPollAt: account.lastPollAt,
 			...account.lastError ? { lastError: account.lastError } : {}
 		})));
-		const routes = (settings.routes ?? []).map((route) => ({
-			user: route.user,
-			role: route.trajectory
-		}));
+		const routes = (settings.routes ?? []).map((route) => {
+			const code = route.trajectory;
+			return {
+				user: route.user,
+				role: code,
+				targetExists: trajectoryDirExists(root, code)
+			};
+		});
 		return {
 			enabled: settings.enabled === true,
 			autoReplyWithLastMessage: settings.autoReplyWithLastMessage !== false,
@@ -21906,12 +22121,17 @@ const weixinChannel = {
 * ⇒ 校验**值的形状**（飞书 open_id 以 `ou_` 开头）：错配在**解析处**就失败，
 *    错误码是 `ALIAS_UNKNOWN` + 可行动提示。
 *
-* ## 🔴 为什么不 fire 记录 hook
+* ## 🔴 记录 hook：曾经不 fire，2026-10-22 起 fire（A83 已裁）
 *
-* `settings.hook` 的契约与消费方都是**微信的**：CCC 的 `scripts/weixin-message-hook.ts`
-* 把事件追加进 `AGENT_SESSIONS/_weixin-logs/<日期>.jsonl`。飞书事件若流进去，
-* 那个目录就**同时装两种渠道的数据而名字只说一种**（D151／D179 同族：名字开始撒谎）。
-* ⇒ 本期**不落记录**，并把它登记为待裁（A83）。工具描述里按渠道写清这件事。
+* **当时的理由**：`settings.hook` 的契约与消费方都是**微信的**，CCC 的
+* `scripts/weixin-message-hook.ts` 把事件追加进 `AGENT_SESSIONS/_weixin-logs/<日期>.jsonl`。
+* 飞书事件若流进去，那个目录就**同时装两种渠道的数据而名字只说一种**（D151／D179 同族）。
+*
+* **为什么现在可以 fire**：同批给 hook 事件加了 **`channel` 字段**（owner 2026-10-22：
+* 「一个 CCC 绑定多个账户很常见，聊天记录落盘要完善」）⇒ CCC 侧 hook 按渠道分流到
+* `_im-logs/<channel>/`，**目录名不再需要撒谎**。
+* ⇒ 所以这不是"决定记录"，而是"**让记录不再有害**之后才记录"。
+* ⚠️ 顺序有意义：**先有渠道字段，再有记录**。反过来做就会先造出一批分不清渠道的数据。
 */
 /**
 * 飞书 open_id 的形状前缀（官方形态：`ou_` ＋ 一串）。
@@ -22066,6 +22286,18 @@ const feishuChannel = {
 		const settings = readWeixinSettings(input.root);
 		const trajectory = matchWeixinRoute(settings.routes ?? [], input.userId) ?? "";
 		const sessionId = weixinSessionIdForTrajectory(trajectory !== "" ? trajectory : sanitizeFileName$1(input.userId) || "unknown");
+		if (settings.hook) invokeWeixinHook(input.root, settings.hook, buildOutgoingHookEvent({
+			cccRoot: input.root,
+			channel: "feishu",
+			accountId: account.accountId,
+			userId: input.userId,
+			sessionId,
+			role: trajectory,
+			reply: markdownToPlainText(input.text),
+			source: "proactive"
+		})).catch((err) => {
+			console.log(`[serenity-hooks] im hook outgoing(feishu) error: ${err instanceof Error ? err.message : String(err)}`);
+		});
 		return {
 			accountId: account.accountId,
 			userId: input.userId,
@@ -22119,7 +22351,8 @@ const ACTIONS = [
 	"send",
 	"send-file",
 	"users",
-	"status"
+	"status",
+	"contacts"
 ];
 function renderText(value) {
 	return [{
@@ -22134,7 +22367,7 @@ function renderText(value) {
 function createImBridgeTool() {
 	return defineTool({
 		name: "im-bridge",
-		description: `Send messages to family members through an IM channel configured for THIS container. This tool only acts on the current container (no target container parameter). It is hidden entirely when this container has no IM channel configured. Channels: ${imChannelIds().join(", ") || "(none registered)"}. Actions: send (text) / send-file (a file inside this container) / users (list configured recipients) / status (channel health). Not every channel supports every action (e.g. send-file may return ACTION_UNSUPPORTED). user accepts a configured alias (e.g. user-a, user-b) or a raw channel user id. Failures return a stable code plus a remediation hint.`,
+		description: `Send messages to family members through an IM channel configured for THIS container. This tool only acts on the current container (no target container parameter). It is hidden entirely when this container has no IM channel configured. Channels: ${imChannelIds().join(", ") || "(none registered)"}. Actions: send (text) / send-file (a file inside this container) / users (configured aliases) / status (channel health, accounts + current routes) / contacts (people this container has exchanged messages with — use this to find the \`user\` id when adding a route, since that id exists only in the chat logs). Not every channel supports every action (e.g. send-file may return ACTION_UNSUPPORTED). user accepts a configured alias or a raw channel user id. Docs: container_admin config docs im-bridge (how to add a route, where the other party's id comes from). Failures return a stable code plus a remediation hint.`,
 		parameters: {
 			channel: {
 				type: "string",
@@ -22145,7 +22378,7 @@ function createImBridgeTool() {
 				type: "string",
 				enum: [...ACTIONS],
 				required: true,
-				description: "send / send-file / users / status"
+				description: "send / send-file / users / status / contacts"
 			},
 			user: {
 				type: "string",