@shgroup/dsh-serenity-hooks 1.104.0 → 1.107.0

package/lib/contract-BiNzzd77.js

@@ -0,0 +1,2197 @@
+import { l as hostInjected, r as cccRootForCwd, u as hostService } from "./ccc-roots-DPMwBywc.js";
+import { c as matchBlacklist, d as readCccName$1, l as pathInside, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readSafeModeHiddenTools, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-BmpE3cQz.js";
+import { F as isoLocal, g as listActiveTrajectories } from "./bind-file-B0TuOP89.js";
+import { c as profileWriteWhitelist, s as profileToolWhitelist, u as ACC_VERSION } from "./rules-BLkYTPUy.js";
+import { l as trajectoryCodeForSession, u as trajectoryConstraintForSession } from "./profile-BjBn_-be.js";
+import { n as isImWiredTrajectory } from "./channels-Dty_NIl_.js";
+import { REGISTERED_TOOLS } from "./invariant.js";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { execFile, execFileSync, spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { promisify } from "node:util";
+import { platform as platform$1 } from "node:process";
+//#region src/im/endpoint.ts
+/**
+* im/endpoint.ts — 主动发送入口地址的**零依赖叶模块**（v1.30.9，S142）
+*
+* 为什么单独一个模块（R↓）：地址的读者是 `msm-ops.buildMsmEnv`（把地址注入 MSM 子进程 env），
+* 写者才是 `weixin-send-api`（监听器启停）。若 msm-ops 直接 import weixin-send-api，
+* 静态依赖链会拖进整条微信桥栈（weixin-bridge → trajectory-session → `@deepseek-ai/dsh-llm`）——
+* 后果实测：`acc-extras` / `ops` / `trajectory-constraint-admin` 三个测试套件因解析不到宿主包而**整文件加载失败**
+* （它们只用到 MSM 注册表逻辑）。叶模块把「读」与「写」解耦：读者零依赖，写者自己承担重量。
+*
+* 同款先例：`host/effect.ts`（拆卸登记）、`trajectory/carrier.ts`（等待结算）。
+*/
+let endpoint = null;
+/** 设置当前入口地址（weixin-send-api 启停时调用；null = 未启动） */
+function setWeixinSendEndpoint(value) {
+	endpoint = value;
+}
+/** 当前入口地址（形如 http://127.0.0.1:3082；未启动 → null） */
+function weixinSendEndpoint() {
+	return endpoint;
+}
+//#endregion
+//#region src/tools/config-docs.ts
+/**
+* 渲染**目录**（第一层）。
+*
+* 🔴 只调 `summary`，**绝不调 `render`** —— 目录若触发正文，就退化成"整份长文"。
+* 这条不是性能优化，是**判据**：它保证 `docs` 的输出大小与章数成正比，与正文长度无关。
+*/
+function renderDocsIndex(chapters) {
+	const lines = [
+		"═══ CCC 配置说明 · 目录 ═══",
+		"",
+		"说明类内容已超过单次返回的合适篇幅 ⇒ 先读目录，再按章取详情。",
+		"",
+		"用法：container_admin config docs <章节>",
+		""
+	];
+	for (const ch of chapters) lines.push(`  ${ch.id.padEnd(14)}${ch.summary}`);
+	lines.push("");
+	lines.push("旧入口（msm catalog / msm ccc-config / config guide）**降为指针**，只指路、不再返回正文。");
+	return lines.join("\n");
+}
+/**
+* 解析一个章节参数（第二层）。
+*
+* 不存在 ⇒ 返回 `null`，由调用方给出**带候选清单**的拒绝 ——
+* "不知道这个章节" 与 "这一章是空的" 必须可区分（否则用户以为功能没有）。
+*/
+function findDocsChapter(chapters, id) {
+	const want = id.trim().toLowerCase();
+	if (want === "") return null;
+	return chapters.find((c) => c.id.toLowerCase() === want) ?? null;
+}
+/**
+* **指针文案**（v1.75.0，owner 裁 Q3「指针」）——被降级的旧入口共用这一份。
+*
+* ## 为什么要有"指针"这个形态（而不是直接删掉旧入口）
+*
+* 旧入口的名字（`msm catalog` / `msm ccc-config` / `config guide`）**已经写在 CCC 侧的
+* 文档与提示词里**，硬删会让它们全部变成"未知动作"，而且**没有任何机械信号**告诉我们
+* 哪份文档已经说谎了（本仓 D151 同族）。
+*
+* ⇒ 保留名字、只换返回内容：调用方能**自己顺着指针找到正文**，而正文仍然只有一份。
+*
+* 🔴 **必须只有一处实现**：`container-admin.ts`（config 域）与 `msm/service.ts`（msm 域）
+* 都要用它。两处各写一份文案 ⇒ 措辞漂移（本仓反复踩过的形态）。
+*
+* @param chapter 正文所在的章 id
+* @param what 这个入口原来叫什么（进标题，让调用方一眼确认自己找对了）
+*/
+function docsPointer(chapter, what) {
+	return [
+		`═══ ${what} — 正文已统一 ═══`,
+		"",
+		`正文在：container_admin config docs ${chapter}`,
+		"",
+		"为什么改（v1.75.0，owner 裁「指针」）：这个内容此前有**两个**正文入口，",
+		"而它们返回同一份常量 ⇒ 两个真相源。现在「一个内容一个正文入口」，本入口只指路。",
+		"",
+		"索引（不知道还有哪些章）：container_admin config docs"
+	].join("\n");
+}
+//#endregion
+//#region src/tools/msm/service.ts
+/**
+* tools/msm/service.ts — msm 纯操作层（acc_msm → msm 执行 + container_admin 管理面，v1.30；零 DSH 依赖）
+*
+* MSM（Mech & Semi-Mech）框架：exec 执行 / register|deregister|check 管理。
+* 复用 CCC 的 mech-registry.json（v1 或数组格式）。cwd 钉在 CCC 根。
+*/
+const execFileAsync = promisify(execFile);
+const MSM_TIMEOUT_MS = 6e5;
+const BUN_EXE_CANDIDATES = [
+	() => join(process.env["USERPROFILE"] ?? process.env["HOME"] ?? "", ".bun", "bin", "bun.exe"),
+	() => join(process.env["APPDATA"] ?? "", "npm", "node_modules", "bun", "bin", "bun.exe"),
+	() => join(process.env["LOCALAPPDATA"] ?? "", "npm", "node_modules", "bun", "bin", "bun.exe")
+];
+let bunExeCache;
+function bunExecutablePath() {
+	if (bunExeCache !== void 0) return bunExeCache;
+	if (platform$1 !== "win32") {
+		bunExeCache = "bun";
+		return bunExeCache;
+	}
+	for (const cand of BUN_EXE_CANDIDATES) try {
+		if (existsSync(cand())) {
+			bunExeCache = cand();
+			return bunExeCache;
+		}
+	} catch {}
+	bunExeCache = null;
+	return null;
+}
+/** CCC 名：从 .serenity 解析（review P2-2 统一收口到 kernel/ccc.ts readCccName——跳 # 注释/空行首非空行；此处保留导出名兼容内部调用） */
+function readCccName(root) {
+	return readCccName$1(root);
+}
+/**
+* path-arg 逃逸校验：根内 + symlink 防御（对齐 osp validatePathArgsFromTokens）。
+* symlink 指向根外 → 拒绝（realpath 解析后与根前缀比对）。
+*/
+function assertPathInsideRoot(root, value, flagName) {
+	const abs = resolve(root, value);
+	if (classifyPath(abs, root) === "outside") throw new Error(`Path escape blocked: --${flagName}=${value} escapes the CCC root`);
+	if (existsSync(abs)) try {
+		const real = realpathSync(abs);
+		if (classifyPath(real, root) === "outside") throw new Error(`Path escape blocked: --${flagName}=${value} resolves via symlink outside the root (${real})`);
+	} catch (e) {
+		if (e instanceof Error && e.message.includes("symlink")) throw e;
+	}
+}
+/**
+* 业务子进程 env：注入 SERENITY_ROOT / SERENITY_CCC / SERENITY_VERSION（对齐 osp）
+* + SERENITY_WEIXIN_API（v1.30.9：微信主动发送入口地址——MSM 脚本零硬编码端口；
+*   未启动则不注入，脚本回退默认值）。
+*/
+function buildMsmEnv(root) {
+	const env = {
+		...process.env,
+		SERENITY_ROOT: root,
+		SERENITY_CCC: readCccName(root) ?? "",
+		SERENITY_VERSION: ACC_VERSION
+	};
+	const weixinApi = weixinSendEndpoint();
+	if (weixinApi) env.SERENITY_WEIXIN_API = weixinApi;
+	return env;
+}
+/**
+* Windows 兼容（审计观察点 A）：`.cmd` 不能直接被 CreateProcess 解析——
+* `execFile('npx')` / `spawnSync('npx')` 在 Windows 必 ENOENT（需 shell 或显式 .cmd）。
+* bun 无扩展名（bun.exe 可被 libuv 按 PATHEXT 解析），保持 'bun'。
+*/
+const NPX_BIN = process.platform === "win32" ? "npx.cmd" : "npx";
+/**
+* ACC 能力目录（需求④ S142 用户拍板："acc 配置各自做 guide 越来越多，整合成目录式使用指南"）。
+* 目录在前、详情各归各——**单一真相源**：本目录只索引"去哪个工具/子命令看详情"，不复制详情
+* （避免 container_admin/weixin-doctor 等 guide 全文重复 → 多真相源 → 失同步）。
+* 后续新增功能只需在此加一行（低熵可演进）。
+*
+* 🔴 **2026-10-19 v1.75.0 起导出**：它是 `container_admin config docs catalog` 那一章的正文。
+* `msm catalog` 动作**降为指针**（只指路，不再返回本常量）—— 否则同一份正文会有两个入口，
+* 而"两个入口返回同一份内容"正是本目录自己反对的形态。
+*/
+const ACC_CATALOG = `═══ ACC Usage Catalog ═══
+Directory of ACC capabilities — each area lists where to go for details (guides live with their feature; this catalog only points).
+
+  ① 轨迹本体          → cognitive_trajectory（list/show/create/use + rebuild 超限重建 + send-now 即时投递 + send-later 未来一次性唤醒
+                          + cro-guide CRO 编写指南）
+                         原 logbook 已并入（v1.33 用户裁决：废除 logbook 词）；close/archive 删（归档走 container_fs mv），
+                         health/qa/summary 分别并入 use / list，hook-develop-guide 并进 container_admin msm guide
+  ② 认知质量框架      → praxis（eap/neat/cce/ontology 四合一——可实践理论注入，section 渐进披露，无参即目录）
+                          ontology（v1.52 D121：本体工程**引擎**——init/check/explain/verify/review/compliance；
+                          与 praxis ontology 的分工 = 那个是**方法文本**、这个是**能跑的那个**）
+  ③ 工具与执行        → container_fs（容器文件系统 15 子命令）/ container_git（git）/ dashboard（health 含注册表检查/time/wait）
+                         acc_msm 已并入 msm（执行+发现）与 container_admin（管理）——msm("<name>", ["<args>"])；inspect=true 查用法
+                         （v1.106.0 已删 exclusiveTools 机制：原专属工具 acc-diag **已并入 dashboard diag**）
+  ④ 轨迹约束与对外面  → container_admin config（轨迹约束四动作 guide/validate/apply/list——**原 role 域已并入 config**，旧名作过渡别名仍可用；说明类配置走**两层菜单** config docs 目录 ／ config docs <章节> 详情）
+                         外部程序化接入用官方 dsh --profile acp
+                         ＋ 现成 ACP 客户端；本插件不提供 ACP 面
+  ⑤ 自主与接入        → cognitive_trajectory send-now（跨轨迹的**即时**递送，**不排队**：live 目标在跑就当场注入当前轮、空闲则立即起轮；非 live 冷载入——等效于直接 wake；**有同步回执**）
+                         cognitive_trajectory send-later（跨轨迹的"未来时刻 + 一条 message"；fire-and-forget，无回执无回收）
+                         weixin 微信桥（配置/扫码/路由/消息 hook——CCC 侧 weixin-doctor MSM：msm("weixin-doctor", ["guide"])）
+  ⑥ CCC 配置总览      → container_admin config docs config（按章详情——8 段全表）
+                          或 container_admin msm ccc-config（同一份正文的旧入口，保留）
+  ⑦ 注册表与安全      → mech-registry.json 由 container_admin msm register/deregister 管理（写保护——不可直接编辑）
+                         dashboard health 输出 registry 完整性检查；损坏恢复指引见 health registry.issues
+                         CCC 级开关：safeMode.blacklist（写路径黑名单）
+                         / safeMode.hiddenTools（**安全模式开启期间**额外隐藏的工具，v1.51.4）
+                         CCC 级 skill 供给：cognitiveTrajectory.skills（v1.44.0——**本 CCC 每条轨迹都带**，含 轨迹约束会话；与轨迹自己的 frontmatter 声明取并集）
+
+每区：一句话定位 + 详细入口（工具名 / guide 子命令）。详情永远以对应工具的 guide/ccc-config 为单一真相源。
+`;
+const MSM_GUIDE = `MSM Development Manual (Mech & Semi-Mech framework)
+
+## What it is
+MSM = the executable-unit layer. Mech is pure TS with zero LLM reasoning; Semi-Mech is a TS framework + LLM decision points.
+MSM is ACC's deterministic executable-unit layer — all shell/exec operations go through MSM and cannot be bypassed.
+
+## Registering a new MSM (container_admin msm register)
+1. Write the script under <skill>/scripts/ (runnable via tsx; must include a main() CLI guard with an import.meta.url check)
+2. container_admin msm register --domain msm --action register <name> --skill <s> --path <script path relative to root> --category <mech|semi-mech> --description <desc>
+3. Auto-writes mech-registry.json (preserving the original format) + git commit (commits only the registry file)
+4. Validation: path must be inside root, script must exist, name must be globally unique
+
+## flag schema (v1)
+flags is a new-style object array for parameter validation and path-escape guarding:
+  [{"name":"output","type":"string","description":"output path"},
+   {"name":"target","type":"path","description":"operation target (type:path enables in-root validation + symlink defense)"},
+   {"name":"force","type":"boolean","description":"force mode","default":false}]
+- {name, type} format — new style, type:"path" enables the path-escape guard
+- {flag, description} format — old style, CLI flag description string
+- On registration, flags are passed via container_admin msm register --flags '<json>'
+
+## Script conventions
+- Top-of-file documentation: purpose / usage / exit codes
+- Exit codes: 0 success / 1 user / 2 system / 3 operator (per ACC protocol classification)
+- main() CLI guard (DC-M2): the script must start with
+    if (import.meta.url === \`file://\${process.argv[1]}\`) { main() }
+  or an equivalent isMain / require.main === check — so vitest imports never trigger top-level code
+- A paired .test.ts or .spec.ts (DC-M1, vitest)
+- Business subprocess environment: SERENITY_ROOT / SERENITY_CCC / SERENITY_VERSION injected
+
+## Interaction & confirmation conventions (no blocking confirmation)
+- MSMs run in **user-less subprocesses** (spawn/execFile, 600s timeout) — **never** use
+  readline / prompt / process.stdin etc. to block waiting for user input (it would hang until killed by the timeout)
+- When a second confirmation is needed: **directly return the confirmation request** (list the operation to perform and its impact + how to retry with the confirmation flag),
+  returning a non-zero exit code (or an explicit hint)
+- After the agent confirms, **re-invoke the MSM with the confirmation flag** (e.g. --confirm / --yes / --force) to retry
+- Standard mode (two-phase):
+  1. First call: destructive/confirmation-requiring operation detected and no confirmation flag present → output the confirmation request (list operation/impact/rollback),
+     exit non-zero (e.g. 1 user), **perform no changes**
+  2. After the agent evaluates, re-invoke: with the confirmation flag → execute and output the result
+- Applies to: delete/overwrite/push/batch operations and other irreversible or wide-impact operations
+- Anti-example (forbidden): readline waiting for user input, process.stdin.on('data') blocking waits
+  (MSMs have no stdin interaction channel — they hang until the 600s timeout)
+
+## Quality checks (container_admin msm check, DC-M1~M4)
+DC-M1 has .test.ts/.spec.ts; DC-M2 has a main() guard (function main( / isMain / require.main === / import.meta.url);
+DC-M3 bidirectional: scripts unregistered + registry references missing scripts; DC-M4 path-type flags marked type:"path"
+
+## Self-description (protocol flags, first argument only)
+msm("<name>", ["--list"])           — list all MSMs
+msm("<name>", ["--schema", "<n>"])  — view a specific MSM's parameter schema
+msm("<name>", ["--format=json"])    — JSON output mode (remaining args passed through losslessly)
+`;
+/**
+* CCC 配置参考（对齐 osp ccc-config action）。
+*
+* 🔴 **2026-10-19 起导出**：`container_admin config docs config` 的两层菜单把它作为
+* 「config」章正文返回。**不另写一份**——同一段说明有第二份副本就会漂（本轨反复踩过）。
+*/
+const CCC_CONFIG_REFERENCE = `═══ CCC Configuration Reference ═══
+
+CCC-level features are configured in .opencode/serenity.json.
+Below are all available configuration sections.
+
+── 1. sessionKeeper.threshold / sessionKeeper.sessionMdMaxKB ──
+cognitive-trajectory-assistant（COGNITIVE-TRAJECTORY-ASSISTANT · CHECKPOINT）提醒机制的积分阈值（非 headless 主 agent）。
+按工具调用加权 + 耗时计分；达到阈值注入提醒，要求模型回复 ACK 码。
+
+  Config:
+    { "sessionKeeper": { "threshold": 150, "sessionMdMaxKB": 100 } }
+
+  计分：write/edit = 3，task = 10，read/grep/glob/msm 等 = 1，时间 = 1/分钟
+  默认：150
+
+  ▸ sessionMdMaxKB（v1.31.1 新增；v1.31.2 100→200；🔴 v1.84.0 200→100）：
+    **活跃 SESSION.md 体积上限（KB，缺省 100；0 = 关闭）**。
+    超过 → 注入 [COGNITIVE-TRAJECTORY-ASSISTANT · LOGBOOK COMPACTION] 提醒：暂停当前工作 →
+    加载 eap（praxis eap）→ **按 EAP 重构整个 SESSION.md**（v1.84.0 起；旧版是四条重写原则）。
+    判据 = EAP 三个变量：E↑ 变量/边界/有向关系全显式 ｜ R↓ 带理由与被否项，长证据链外移到
+    references/*.md（SESSION.md 留链接）｜ S↑ 结构每次同样重建，不是时间流水账。
+    两条硬约束随提醒给出：保留固定段落的**顺序与标题**（与系统提示词对齐）+ 保留顶部 frontmatter。
+    超限后每次工具调用都提醒；连续 3 次未重写 → 升级强制语气；
+    文件回到限内 → 自动停止（自愈）。轨迹提醒**不机械阻断工作**（与 rebuild 提醒同族）。
+
+── 2. localstore.gitTrack ──
+localstore.json 的 git 策略：allow 可提交 / deny 禁提交（默认 deny）。
+deny 时写入自动确保 .gitignore 含该文件（物理保证），container_git commit 会检查拒绝。
+
+  Config:
+    { "localstore": { "gitTrack": "allow" } }
+
+── 3. hooks.autoRestoreSession ──
+会话自动恢复（默认 true；受 events 门控——仅根会话 + 已有对话历史才恢复）。
+
+  Config:
+    { "hooks": { "autoRestoreSession": false } }
+
+── 4. safeMode（黑名单 ＋ 开启期间隐藏的工具）──
+safe-mode 由 WebUI 开关控制（写 .serenity-safe-on 标记）；黑名单路径受 guards seam 拦截。
+
+  ▸ blacklist：写路径黑名单（同下 Config）。
+  ▸ hiddenTools（v1.51.4，owner 2026-10-09 令）：**仅在安全模式开启期间**额外从模型工具
+    清单隐藏的工具（ACC 基础表恒隐 bash）。打开 safe-mode 生效、**关掉即全部恢复**；
+    改本键**热生效**（下一个 pre-step 重算，无需重启）。声明在 CCC（D23）——ACC 代码里
+    不出现任何具体工具名。
+    ⚠️ 写一个**本 CCC 未注册**的名字会让**整次 restrict 失败**（DSH 契约逐字："unknown
+    names … fail"）⇒ 此时**退化为只隐藏基础表**并在日志响亮报错（绝不因一个错名丢掉
+    safe-mode 的核心隐藏）。诊断：\`AGENT_SESSIONS/.restrict-diag.json\` 的 \`denyByKey\`。
+    ⚠️ 隐藏 = **从 schema 移除**（agent 根本看不到该工具）⇒ 别把 skill/文档还在教的工具写进来。
+
+  Config:
+    { "safeMode": { "blacklist": [".secrets/"], "hiddenTools": ["workflow", "job_kill"] } }
+
+── 5. 轨迹约束.roles（F4 认知子集角色）──
+轨迹约束角色 = 全知全能 cognitive trajectory 的任意子集（CCC 定义）。每角色独立模型 + 双白名单
+（MSM 白名单 msms[] 与非 MSM 工具白名单 tools[]，白名单外全隐藏；skill 加载恒可用）。
+cognitive trajectory 纪律子集（session/keeper/rebuild 参与项）默认全关 = 完全独立。
+systemPrompt 内联 或 systemPromptFile（.md 引用，推荐）——角色会话的完整人格/边界提示词。
+validate 校验 / apply 生效 / list 查看：container_admin config <guide|validate|apply|list>（原 role 域已并入 config，旧名作过渡别名仍可用）。
+
+  Config:
+    { "轨迹约束": { "roles": {
+        "qa": {
+          "model": "provider/model",
+          "msms": ["web-search", "vlm-describe"],
+          "tools": ["read", "grep", "glob"],
+          "systemPromptFile": ".opencode/skiff/qa.md"
+        } } } }
+
+── 6. cognitive_trajectory（轨迹 + 唤醒注册表，D58）──
+CCC 的一条 cognitive trajectory = 持久身体（SESSION.md）+ 时间轴（AGENT_SESSIONS/ 目录 + 唤醒注册表）。
+一个 CCC 内可多条并行；条目全部由人类/agent 显式登记。
+⚠️ ACC 不再提供**周期自唤醒**（原 autopilot，2026-09-15 整段退场：机制/时钟/container_admin autopilot
+域/面板区块一并删除）。自主巡航改由 CCC 自己驱动（home-serenity 侧 msm autopilot-round 每轮自排下一轮，
+真相源 = S151 SESSION.md §1/§1b/§1c）。**本轮的 cognitiveTrajectory.autopilot 配置段保留**（见下表）——
+它现由 **CCC 侧脚本**读取，ACC 不再消费该段。
+唤醒注册表（cognitive_trajectory send-later）：唤醒 = 未来时刻 + 一条 message，可唤醒自己或别的 cognitive trajectory；
+落点 AGENT_SESSIONS/wake-registry.json，中心调度器到点投递（fire-and-forget；无回执、无回收）。
+运行态诊断（ACC 负责人专用）：acc-diag（① live 运行态 / ①b 唤醒时钟 / ③ 唤醒注册表）。
+
+▸ cognitiveTrajectory.skills（v1.44.0，**CCC 级 skill 供给**；owner 令 2026-09-20「要求实现我的诉求……
+  注入是动态注入就行；create 先不触发吧；**轨迹约束也支持**」）：
+  **本 CCC 的每条轨迹都带这些 skill**——声明的 skill 全文在该轨迹**被绑定期间**注入系统提示词
+  （**动态注入**：每请求重新求值、不缓存 ⇒ 改配置或改 frontmatter **即时生效**，无需重新 use、无需重启）。
+  两条声明来源**并集**（不是二选一）：本键 **cognitiveTrajectory.skills**（容器给的底座，**在前**）
+  ＋ 轨迹自己 SESSION.md 顶部 frontmatter 的 skills:（这条轨迹额外的，**追加**；同名去重）。
+  ✅ **含 轨迹约束角色会话**（旁路的是 ACC 身份与纪律；skill 是"工作资料"，照给）。
+  守卫：名字先过安全校验才用于拼路径（防穿越）｜**合并后**统一 32 KB 上限截断｜找不到响亮写 [缺失]。
+  ⚠️ 与 create **无关**（create 刻意不夺绑定，U6）⇒ 注入的门是"**存在绑定**"（cognitive_trajectory use）。
+  失败语义：未配置 / 字段缺失 / 配置损坏 ⇒ **空数组**（= 无 CCC 级供给；轨迹级声明照旧生效）。
+  归属（D23）：**机制在 ACC**（读取 + 合并 + 注入 + 守卫），**声明在 CCC**（本键）。
+
+  Config:
+    { "cognitiveTrajectory": {
+        "skills": ["acc-session", "cce"],   // v1.44.0：本 CCC 的每条轨迹都带（含 轨迹约束会话）
+        "autopilot": {                   // 原 autopilotTrajectory 段，字段不变（旧键仍回退读）
+          "enabled": true,
+          "intervalHours": 2,
+          "session": "S151",
+          "biasProvider": "autopilot-bias.ts",
+          "topPrompt": "本轨迹核心目标/纪律/质量要求（CCC 自填，防漂移）",
+          "avoidWakeHours": { "start": 8, "end": 18 }
+        } } }
+
+── 7. weixin（微信桥 F4c-3，含消息记录 hook）──
+CCC 级微信个人号接入（iLink 协议）：dsh 一进程多 CCC，每 CCC 独立对接微信桥。
+账号/路由/开关在此文件；**bot_token 凭据在 CCC localstore credential scope**
+（扫码绑定后自动写入，永不进 git 明文面）。
+路由 user → role：exact 优先，* 通配兜底；role 必须 ∈ 该 CCC 轨迹约束.roles。
+面板（WebUI 设置 → 微信桥）可扫码绑定/移除账号/编辑路由；msm("weixin-doctor", ["status"|"diag"|"verify"|"guide"]) 排查 + 大而全指南。凭据主动查看：localstore get WEIXIN_<ACCOUNT>_TOKEN。
+  ▸ 主动发送（v1.31.0：**ACC 工具 im-bridge**）：调
+    im-bridge({channel:"weixin", action:"send", user:"<别名|id>", text:"<文本>"}) 给用户发消息——
+    **工具只能操作本会话 CCC**（无 ccc 参数，防误发他容器）→ weixin-bridge.sendProactiveText →
+    成功后触发 outgoing hook（source="proactive"）。文件用 action:"send-file" + file:"<CCC 内路径>"
+    （逃逸/缺失/超 20MB 拒绝）+ 可选 caption。**可见性**：本 CCC 配置了 IM 通道
+    （weixin.enabled=true）才出现在模型工具清单里；未配置 → 由 guards 逐 agent
+    tools.restrict({deny:['im-bridge']}) 移除（不是"看得到但被拒"）。轨迹约束角色另需在
+    roles.<role>.tools 白名单列出 im-bridge。
+    历史（v1.30.9~v1.30.x）：CCC 侧 MSM weixin-send（走 loopback HTTP 入口 3082）——
+    v1.31.0 已退役（脚本删除 + 注册表注销）；3082 入口保留给**非 agent 调用者**。
+
+  ▸ 🔴🔴 **出站只有一条路：agent 自己调 im-bridge**（2026-10-24 起，owner 令）。
+    桥**永不**替你回发最终文本 —— 你说什么、说几条、什么时候说、要不要不说，全由你决定。
+    ⛔ 不要指望"我把话写进回答里就会自动发出去"：**不会**。必须真的调工具。
+    ⇒ 每轮用户消息末尾都会附一行**已填好参数**的 im-bridge 调用模板（机制标记
+    [serenity:weixin-manual-output]），照它改 text 即可。
+    ⇒ 本轮结束仍未成功调用（send / send-file）→ 你会被打回（≤2 次，提示 = 标记 + 事实）；
+      达上限后**用户将收不到任何消息**（没有任何兜底转发）。
+    ⇒ 成功调用才算送达；失败调用不算（不会被当成本轮已发送）。
+    ⚠️ **前提**：本轨迹必须在 \`.opencode/serenity.json\` 的 \`im.routes\` 里被点名，否则 \`im-bridge\`
+      对你不**可见**——那种情况下闸门不会打回你（改成一条响亮告警，指明"该轨迹无发送权"），
+      因为打回一个你根本满足不了的要求只会空转。
+
+  ▸ **已退役（不要再配，配了也不生效）**：
+    · \`weixin.autoReplyWithLastMessage\`（v1.30.10~2026-10-24）= 桥替 agent 回发最终文本。
+      **被否理由**（owner 原话）：「autoReply 并不合适，主动性的 imBridge 仍然是更好的」——
+      它让 agent 失去"说几条/何时说/要不要不说"的决定权，而那正是主动发送的价值。
+    · \`weixin.fallbackOnNoSend\`（v1.30.17~2026-10-24）= 手动模式下 agent 没发成功时桥兜底转发。
+      它只在上面那个开关 =false 时才有意义 ⇒ 一起退役。
+    ⚠️ 旧配置里残留这两个键**静默忽略**（不会报错，也不会生效）。
+
+  Config:
+    { "weixin": {
+        "enabled": true,
+        "hook": "scripts/weixin-message-hook.ts",
+        "accounts": [{ "accountId": "wechat-1", "name": "家庭助手", "enabled": true }],
+        "routes": [{ "user": "*", "role": "my-role" }]
+      } }
+
+  ▸ weixin.hook（消息记录 hook，v1.27.13）：
+  微信桥每收/发一条消息触发一次 CCC 自写脚本，由 CCC 自行持久化保存（存哪/存成什么
+  /是否入库全归 CCC——ACC 不绑定存储）。未配置 hook → 零变化（不触发）。
+
+  触发（双向）：
+    incoming  = 用户 → bot：路由命中后、媒体落盘后触发（文本含语音转写；媒体带落盘 relPath）
+    outgoing  = bot → 用户：发送成功后触发（reply = 用户实际收到的纯文本，已剥离 think）
+      · source="proactive" = agent 经 im-bridge 主动发起（**2026-10-24 起这是唯一值**）
+      · 历史值 reply / reply-fallback（桥自动回发 / 桥兜底转发）已随两个开关一起退役；
+        存量日志里仍能看到它们，那是历史事实，不是当前行为
+      · file（仅 send-file 补记）：{ "name": "报告.pdf", "size": 12345, "caption": "可选" }
+
+  脚本约定（事件 JSON 单行经 stdin 传入；bun 优先 node 兜底）：
+    #!/usr/bin/env bun  或  node script.js —— 读 process.stdin 整段 JSON.parse
+    const ev = JSON.parse(await new Response(process.stdin).text())
+    ev.event === 'incoming' | 'outgoing'
+
+  事件 schema（**不含任何会话凭据**——context_token/bot_token/token/aes_key 均不出现）：
+    { "event": "incoming", "ts": 1788359941488, "cccRoot": "/path/ccc",
+      "accountId": "wechat-1", "userId": "u1@im.wechat",
+      "sessionId": "skiff-weixin-xxx", "role": "my-role",
+      "message": { "text": "你好", "media": [{ "kind": "image", "relPath": "_tmp/weixin-inbound/<hash>/img_x.jpg" }] } }
+    { "event": "outgoing", "ts": ..., "cccRoot": ..., "accountId": ...,
+      "userId": ..., "sessionId": ..., "role": ...,
+      "reply": "已记录（纯文本）", "source": "proactive" }
+
+  示例脚本（追加到按日文件——持久化归 CCC 自选：文件/DB/远端均可）：
+    const fs = require('node:fs'); const p = '/path/ccc/AGENT_SESSIONS/_weixin-log.jsonl';
+    fs.appendFileSync(p, JSON.stringify(ev) + '\\n');
+
+  执行语义（旁路容忍）：异步 fire-and-forget + 15s 超时 kill + 失败仅日志——
+  微信桥消息处理/回复不受 hook 影响；脚本须在 CCC 根内（路径逃逸拒绝）。
+  媒体 relPath 指向 _tmp/weixin-inbound/（临时目录）——需持久保存媒体文件请自行 copy。
+
+── 8. （已删除）exclusiveTools（专属工具声明，v1.33 → v1.106.0 删除）──
+🔴 **本键已不存在**（owner 2026-11-01 裁「机制整体删」）。
+原语义：ACC 注册但默认对所有 CCC 隐藏的工具，只有在 CCC 配置里点名才可见（fail-closed）。
+**删除理由**：那张表永远只有一个成员 acc-diag，而它已并入**常驻**的 dashboard 的 diag 动作。
+表空之后那个 filter 恒回空数组 ⇒ 机制**静默空转、且任何测试都证伪不了它**
+（一个验不出死活的机制比没有它更坏：它提供"这里还有一层保护"的错觉）。
+
+  ▸ 要运行态诊断 ⇒ 直接用 dashboard 的 diag 动作（**无需任何声明，所有轨迹可见**）。
+  ▸ 旧配置里残留 exclusiveTools ⇒ **静默忽略**（schemastery 非 strict），不影响加载。
+  ▸ ⚠️ 连带后果（owner 已知并确认）：dashboard 是常驻工具 ⇒ diag 段对**所有轨迹**可见，
+    而它的 live 会话清单是**全部 CCC** 的（跨容器）。这是「方案 C」的既定代价，不是缺陷。
+`;
+function parseRegistry(raw) {
+	const data = JSON.parse(raw.replace(/^\uFEFF/, ""));
+	if (Array.isArray(data)) return data;
+	const entries = data.entries;
+	if (!Array.isArray(entries)) throw new Error("invalid registry: missing entries[]");
+	return entries;
+}
+/**
+* 注册表单级化（需求⑤a S142 用户拍板：注册表只有一级——对齐 osp cccName 单聚合档）：
+* 所有 entry 集中写入 `.opencode/skills/<cccName>/references/mech-registry.json`
+* （cccName = .serenity 首行，即顶层入口 skill 目录），skill 只作 entry 字段。
+* 不再扫描/写入各 skill 目录的分散注册表（历史形态 v1.14~v1.27，register --skill
+* 曾写入各自 skill 目录 —— 多真相源，废弃）。
+*/
+function findRegistries(root) {
+	const cccName = readCccName(root);
+	if (!cccName) return [];
+	const aggregate = join(root, ".opencode", "skills", cccName, "references", "mech-registry.json");
+	return existsSync(aggregate) ? [aggregate] : [];
+}
+function loadMsmEntries(root) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const regPath of findRegistries(root)) for (const entry of parseRegistry(readFileSync(regPath, "utf-8"))) if (!byName.has(entry.name)) byName.set(entry.name, entry);
+	return [...byName.values()];
+}
+function findEntry(root, name) {
+	return loadMsmEntries(root).find((e) => e.name === name) ?? null;
+}
+/**
+* 扫描各 skill `scripts/` 下的**未注册候选**（DC-M3 正向基准，对齐 osp）。
+*
+* 🔴 **入口判据**（S151 轮 112 跨轨迹信号 → S142 实测精化，2026-09-17；取证见 S142 §0q）：
+*   · **入口 ⟺ 有 shebang（`^#!`） ∨ 声明了 `function main(`** —— **`process.argv` 单独不算**。
+*     反例（实测）：`home-desk/scripts/lib/desk-dispatch.ts` 含 **5** 处 `process.argv`，
+*     但无 shebang / 无 `main()`，且被 `desk-window.ts`、`desk-vision.ts` **import** ⇒ **它是库**。
+*   · **库 ⟺ 无 shebang ∧ 无 `main()` ∧ 被其它脚本 import** ⇒ **不是 MSM 候选，不上报**。
+*     ⚠️ **"有 `.test.ts`" 不是入口证据** —— 库**同样**有测试
+*     （`home-serenity/scripts/dev-kit/dev-kit.test.ts` 开头自述"**共享库单测**"）。
+*     📌 实现只测**前两条**（shebang / `main()`）：第三条"被 import"是**描述性**的，不作判据 ——
+*     因为**无 CLI 入口的文件本来就不可能被 `msm()` 调用**，上报它只会得到一条无法处置的欠账。
+*     🔗 **与 DC-M2 自洽**：DC-M2 本就要求**已注册**脚本必须有 main() 守卫 ⇒ 把"无入口"的文件
+*     排除出候选，与注册表的契约**同向**（两条判据不会互相打架）。
+*
+* 🔴 **本函数只扫 `scripts/` 一层（非递归），这是当前刻意的语义**（嵌套子域对容器不可见；
+*   见 CCC `docs/t024-msm-skill-inventory.md` §3b）。**若将来改为递归，上面的判据就是护栏**：
+*   嵌套候选实测 **8 个**（`dev-kit/` 5 + `home-desk/scripts/lib/` 3）**全部是库**——
+*   不按判据过滤，一次递归就会制造 8 条假欠账，并可能诱使后续轮次把库注册成**假 MSM**。
+*   ⇒ **改递归前先读本条注释。**
+*/
+function scanSkillScripts(root) {
+	const out = [];
+	const skillsDir = join(root, ".opencode", "skills");
+	if (!existsSync(skillsDir)) return out;
+	for (const skill of readdirSync(skillsDir)) {
+		const scriptsDir = join(skillsDir, skill, "scripts");
+		if (!existsSync(scriptsDir)) continue;
+		for (const f of readdirSync(scriptsDir)) {
+			const abs = join(scriptsDir, f);
+			let isFile = false;
+			try {
+				isFile = statSync(abs).isFile();
+			} catch {
+				continue;
+			}
+			if (!isFile) continue;
+			if (!/\.(ts|js|mjs)$/.test(f)) continue;
+			if (/\.(test|spec)\./.test(f)) continue;
+			if (!hasCliEntry(abs)) continue;
+			out.push(join(".opencode", "skills", skill, "scripts", f));
+		}
+	}
+	return out.sort();
+}
+/** 入口判据的机械实现（判据、反例与递归化护栏见 `scanSkillScripts` 注释） */
+function hasCliEntry(absPath) {
+	let text;
+	try {
+		text = readFileSync(absPath, "utf-8");
+	} catch {
+		return true;
+	}
+	if (/^#!/.test(text)) return true;
+	return /\b(?:async\s+)?function\s+main\s*\(/.test(text);
+}
+/**
+* **把 issue 列表压成「按检查码分组的一行摘要」**（D237：成功/失败类调用的返回精简）。
+*
+* ## 为什么需要它（owner 2026-10-24 令）
+*
+* > 「tool 的返回内容会影响 Agent 注意力……对于返回成功失败类的调用，如果成功要大幅精简；
+* >   对于其它的调用，简练其结构，在确保信息有效的情况下降低大小」
+*
+* 实测症状（本仓真读数）：`container_admin msm check` 返回 **36 条 issue，每条一个三字段对象**，
+* 而其中 **M1 有 20 条、detail 逐字相同**（`no .test.ts / .spec.ts`）、**M3 有 16 条**（同样同 detail）。
+* ⇒ 同一句话重复 20 遍**不携带额外信息**，只吃掉注意力。
+*
+* ## 判据（照 D237 分档）
+*
+* - **有 issue（失败面）⇒ 不省略任何一条**：失败条目是唯一能改变下一步的东西（D186「出声必须指名哪一半」）。
+*   但可以**折叠结构**：同 `(check, detail)` 的条目合并成「一组 + 名字列表」，逐条信息一个字不丢。
+* - **零 issue（成功面）⇒ 只留一行结论 + 计数**：通过的条目对下一步零信息量。
+*
+* @param report 原始报告（逐条 issue）
+* @returns 压缩后的**面向 agent 的**结构（键名短、重复消除；entries 全保留只做分组）
+*/
+function compactRegistryQuality(report) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const it of report.issues) {
+		const key = `${it.check}\u0000${it.detail}`;
+		const hit = byKey.get(key);
+		if (hit) hit.names.push(it.name);
+		else byKey.set(key, {
+			check: it.check,
+			detail: it.detail,
+			names: [it.name]
+		});
+	}
+	const groups = [...byKey.values()].sort((a, b) => a.check === b.check ? b.names.length - a.names.length : a.check < b.check ? -1 : 1).map((g) => ({
+		check: g.check,
+		detail: g.detail,
+		count: g.names.length,
+		names: g.names
+	}));
+	return {
+		checked: report.checked,
+		issueCount: report.issues.length,
+		groups
+	};
+}
+/**
+* **注册表「质量契约」判据（DC-M1~M4）** —— 具名出口（C5 观察面归一，2026-09-15）。
+*
+* 此前这段判据**只存在于 `runMsm` 的 `case 'check'` 分支体内**（没有名字、无法从别处取用），
+* 于是 `dashboard health` 只能另写一份 **不同判据** 的结构检查（`checkRegistryHealth`）。
+* 抽成具名函数后，两条判据**各自有名字、各自可被取用、且仍然完全独立**——合并它们是错的：
+* 本判据的主语是**条目契约**（有没有测试 / main() 守卫 / 双向注册 / path 型 flag），
+* 结构判据的主语是**文件能否安全解析**。同一份注册表在两条判据下可以给出相反结论。
+*
+* 行为与抽取前**逐字一致**（`runMsm` 的 `check` 分支现只做 `return checkRegistryQuality(root)`）。
+*/
+function checkRegistryQuality(root) {
+	const entries = loadMsmEntries(root);
+	const issues = [];
+	const norm = (p) => p.split("\\").join("/").toLowerCase();
+	const registeredPaths = new Set(entries.map((e) => norm(e.path)));
+	for (const scriptPath of scanSkillScripts(root)) if (!registeredPaths.has(norm(scriptPath))) issues.push({
+		name: scriptPath,
+		check: "M3",
+		detail: "script not registered in mech-registry"
+	});
+	for (const e of entries) {
+		const script = join(root, e.path);
+		const scriptExists = existsSync(script);
+		if (!scriptExists) issues.push({
+			name: e.name,
+			check: "M3",
+			detail: `script missing (${e.path})`
+		});
+		const testFileTs = script.replace(/\.ts$/, ".test.ts");
+		const testFileSpec = script.replace(/\.ts$/, ".spec.ts");
+		if (!existsSync(testFileTs) && !existsSync(testFileSpec)) issues.push({
+			name: e.name,
+			check: "M1",
+			detail: "no .test.ts / .spec.ts"
+		});
+		if (scriptExists) {
+			const src = readFileSync(script, "utf-8");
+			if (!(/function main\(/.test(src) || /\bisMain\b/.test(src) || /require\.main\s*===/.test(src) || /import\.meta\.url/.test(src))) issues.push({
+				name: e.name,
+				check: "M2",
+				detail: "no main() guard"
+			});
+		}
+		for (const f of e.flags ?? []) if ("name" in f && /path|file|dir/i.test(f.name) && f.type !== "path") issues.push({
+			name: e.name,
+			check: "M4",
+			detail: `flag --${f.name} should be type:"path"`
+		});
+	}
+	return {
+		checked: entries.length,
+		issues
+	};
+}
+function registryPathFor(root, _skill) {
+	const cccName = readCccName(root) ?? "unknown";
+	return join(root, ".opencode", "skills", cccName, "references", "mech-registry.json");
+}
+function writeRegistry(path, entries, isV1Wrapped = true) {
+	mkdirSync(dirname(path), { recursive: true });
+	const payload = isV1Wrapped ? JSON.stringify({
+		version: 1,
+		description: "MSM registry (managed by acc-msm / dsh-serenity-hooks)",
+		entries
+	}, null, 2) + "\n" : JSON.stringify(entries, null, 2) + "\n";
+	writeFileSync(path, payload, "utf-8");
+}
+function runMsm(root, args) {
+	switch (args.action) {
+		case "list": {
+			const entries = loadMsmEntries(root);
+			const cccName = readCccName(root) ?? "unknown";
+			const header = `(serenity-plugin v${ACC_VERSION}) CCC:${cccName} Root:${root}`;
+			if (entries.length === 0) return `${header}\n(no MSM registered)`;
+			const lines = entries.map((e) => {
+				const base = `${e.name} | ${e.skill ?? "-"} | ${e.category ?? "-"} | ${e.description ?? ""}`;
+				if (e.flags && e.flags.length > 0) return `${base} [flags: ${e.flags.map((f) => `--${f.name} <${f.type ?? "string"}>`).join(", ")}]`;
+				return base;
+			});
+			return `${header}\n` + lines.join("\n");
+		}
+		case "guide": return { guide: MSM_GUIDE };
+		case "catalog": return { catalog: docsPointer("catalog", "ACC 能力目录") };
+		case "exec": {
+			const { entry, businessArgs, fmtJson, hasHelp, protocol } = prepareExec(root, args);
+			const p = protocolResult(protocol);
+			if (p !== void 0) return p;
+			const baseOpts = {
+				cwd: root,
+				encoding: "utf-8",
+				timeout: MSM_TIMEOUT_MS,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				env: buildMsmEnv(root)
+			};
+			const bunBin = bunExecutablePath();
+			let r = bunBin ? spawnSync(bunBin, [entry.path, ...businessArgs], baseOpts) : {
+				error: { code: "ENOENT" },
+				status: null,
+				stdout: "",
+				stderr: "",
+				pid: 0,
+				signal: null
+			};
+			if (r.error && isBunMissing(r.error)) r = spawnSync(NPX_BIN, [
+				"tsx",
+				entry.path,
+				...businessArgs
+			], {
+				...baseOpts,
+				shell: platform$1 === "win32"
+			});
+			return msmExecResult(entry.name, r.status ?? 2, r.stdout ?? "", r.stderr ?? "", fmtJson, hasHelp);
+		}
+		case "register": {
+			const name = args.name ?? "";
+			const { skill, path, category, description } = args;
+			if (!name) throw new Error("register requires name");
+			if (!path || !category || !description) throw new Error("register requires path/category/description");
+			const scriptAbs = resolve(root, path);
+			if (classifyPath(scriptAbs, root) === "outside") throw new Error(`MSM register: path "${path}" escapes CCC root "${root}"`);
+			if (!existsSync(scriptAbs)) throw new Error(`MSM script not found: "${path}"`);
+			if (loadMsmEntries(root).some((e) => e.name === name)) throw new Error(`MSM already registered: "${name}"`);
+			const regPath = registryPathFor(root, skill);
+			const raw = existsSync(regPath) ? readFileSync(regPath, "utf-8").replace(/^\uFEFF/, "") : "";
+			const isV1Wrapped = raw === "" ? true : !Array.isArray(JSON.parse(raw));
+			const entries = existsSync(regPath) ? parseRegistry(readFileSync(regPath, "utf-8")) : [];
+			let flags;
+			if (args.flags) try {
+				const parsed = JSON.parse(args.flags);
+				if (!Array.isArray(parsed)) throw new Error("flags must be a JSON array");
+				flags = parsed;
+			} catch (e) {
+				throw new Error(`register flags parse failed: ${e instanceof Error ? e.message : String(e)}`);
+			}
+			entries.push({
+				name,
+				path,
+				skill,
+				category,
+				description,
+				usage: args.usage ?? `msm ${name} [args...]`,
+				flags: flags ?? []
+			});
+			writeRegistry(regPath, entries, isV1Wrapped);
+			try {
+				const relRegistry = relative(root, regPath);
+				execFileSync("git", [
+					"add",
+					"--",
+					relRegistry
+				], {
+					cwd: root,
+					stdio: "pipe"
+				});
+				execFileSync("git", [
+					"commit",
+					"-m",
+					`chore(msm): register ${name}`
+				], {
+					cwd: root,
+					stdio: "pipe"
+				});
+			} catch {}
+			return {
+				registered: name,
+				registry: relative(root, regPath)
+			};
+		}
+		case "deregister": {
+			const name = args.name ?? "";
+			for (const regPath of findRegistries(root)) {
+				const dRaw = readFileSync(regPath, "utf-8").replace(/^\uFEFF/, "");
+				const isV1Wrapped = !Array.isArray(JSON.parse(dRaw));
+				const entries = parseRegistry(readFileSync(regPath, "utf-8"));
+				const idx = entries.findIndex((e) => e.name === name);
+				if (idx >= 0) {
+					entries.splice(idx, 1);
+					writeRegistry(regPath, entries, isV1Wrapped);
+					try {
+						const relRegistry = relative(root, regPath);
+						execFileSync("git", [
+							"add",
+							"--",
+							relRegistry
+						], {
+							cwd: root,
+							stdio: "pipe"
+						});
+						execFileSync("git", [
+							"commit",
+							"-m",
+							`chore(msm): deregister ${name}`
+						], {
+							cwd: root,
+							stdio: "pipe"
+						});
+					} catch {}
+					return { deregistered: name };
+				}
+			}
+			throw new Error(`MSM not registered: "${name}"`);
+		}
+		case "ccc-config": return docsPointer("config", "CCC 配置参考");
+		case "check": return compactRegistryQuality(checkRegistryQuality(root));
+		default: throw new Error(`Unknown action: ${args.action}`);
+	}
+}
+function prepareExec(root, args) {
+	const name = args.name ?? "";
+	const entry = findEntry(root, name);
+	if (!entry) throw new Error(`MSM not registered: "${name}"`);
+	const business = args.args ?? [];
+	if (business[0] === "--list") return {
+		entry,
+		businessArgs: [],
+		fmtJson: false,
+		hasHelp: false,
+		protocol: { list: loadMsmEntries(root).map((e) => ({
+			name: e.name,
+			category: e.category ?? null
+		})) }
+	};
+	if (business[0] === "--schema") {
+		const target = business[1];
+		const found = target ? loadMsmEntries(root).find((e) => e.name === target) : null;
+		if (!found) throw new Error(`MSM not registered: "${target}"`);
+		return {
+			entry,
+			businessArgs: [],
+			fmtJson: false,
+			hasHelp: false,
+			protocol: { schema: {
+				name: found.name,
+				path: found.path,
+				flags: (found.flags ?? []).map((f) => ({
+					name: f.name,
+					type: f.type ?? null,
+					description: f.description ?? null
+				}))
+			} }
+		};
+	}
+	const fmtJson = business[0] === "--format=json";
+	const businessArgs = fmtJson ? business.slice(1) : business;
+	const hasHelp = businessArgs.includes("--help") || businessArgs.includes("-h");
+	for (const flag of entry.flags ?? []) {
+		if (flag.type !== "path") continue;
+		const eq = businessArgs.find((a) => a.startsWith(`--${flag.name}=`));
+		if (eq) assertPathInsideRoot(root, eq.slice(flag.name.length + 3), flag.name);
+		else {
+			const idx = businessArgs.indexOf(`--${flag.name}`);
+			if (idx >= 0 && businessArgs[idx + 1]) assertPathInsideRoot(root, businessArgs[idx + 1], flag.name);
+		}
+	}
+	const script = resolve(root, entry.path);
+	if (classifyPath(script, root) === "outside") throw new Error(`MSM script escapes CCC root: "${entry.path}"`);
+	if (!existsSync(script)) throw new Error(`MSM script not found: "${entry.path}"`);
+	return {
+		entry: {
+			...entry,
+			path: script
+		},
+		businessArgs,
+		fmtJson,
+		hasHelp
+	};
+}
+/** 协议结果扁平化：{list|schema} 包装 → 顶层值（兼容旧契约）；非协议返回 undefined */
+function protocolResult(protocol) {
+	if (!protocol) return void 0;
+	if ("list" in protocol) return protocol.list;
+	if ("schema" in protocol) return protocol.schema;
+}
+/** 失败 TIP（对齐 osp：业务 exit≠0 且未传 --help 时追加提示） */
+function helpTip() {
+	return "\n[TIP] Pass \"--help\" as the first arg to see this MSM's usage and required flags.";
+}
+function msmExecResult(name, status, stdout, stderr, fmtJson, hasHelp = false) {
+	const tip = status !== 0 && !hasHelp ? helpTip() : "";
+	if (fmtJson) return status === 0 ? {
+		name,
+		exit: 0,
+		ok: true,
+		data: stdout.trim()
+	} : {
+		name,
+		exit: status,
+		ok: false,
+		error: (stderr.trim() || stdout.trim()) + tip
+	};
+	return {
+		name,
+		exit: status,
+		stdout,
+		stderr: stderr + tip
+	};
+}
+/**
+* 异步执行 MSM（msm 工具主路径）：
+* 用 execFile + promisify + timeout（超时自动 kill），**不阻塞 Node 事件循环**。
+* （同步 spawnSync 版会阻塞 web 事件循环 → MSM 脚本自请求 3080 时死锁，见 postmortem。）
+*/
+/** bun 缺失的错误码集（Windows 兼容：无 bun 时 execFile('bun') 抛 EINVAL 而非 ENOENT，见 Windows 审计问题 5） */
+const BUN_MISSING_CODES = /* @__PURE__ */ new Set([
+	"ENOENT",
+	"EINVAL",
+	"EPERM"
+]);
+function isBunMissing(err) {
+	return typeof err.code === "string" && BUN_MISSING_CODES.has(err.code);
+}
+async function runMsmAsync(root, args) {
+	if (args.action !== "exec") return runMsm(root, args);
+	const { entry, businessArgs, fmtJson, hasHelp, protocol } = prepareExec(root, args);
+	const p = protocolResult(protocol);
+	if (p !== void 0) return p;
+	const bunBin = bunExecutablePath();
+	const baseOpts = {
+		cwd: root,
+		encoding: "utf-8",
+		timeout: MSM_TIMEOUT_MS,
+		maxBuffer: 67108864,
+		env: buildMsmEnv(root)
+	};
+	try {
+		if (bunBin) {
+			const r = await execFileAsync(bunBin, [entry.path, ...businessArgs], baseOpts);
+			return msmExecResult(entry.name, 0, r.stdout, r.stderr, fmtJson, hasHelp);
+		}
+		throw { code: "ENOENT" };
+	} catch (e) {
+		const err = e;
+		if (isBunMissing(err)) try {
+			const r = await execFileAsync(NPX_BIN, [
+				"tsx",
+				entry.path,
+				...businessArgs
+			], {
+				...baseOpts,
+				shell: platform$1 === "win32"
+			});
+			return msmExecResult(entry.name, 0, r.stdout, r.stderr, fmtJson, hasHelp);
+		} catch (e2) {
+			const err2 = e2;
+			const status = err2.killed ? 124 : typeof err2.code === "number" ? err2.code : 2;
+			const stdout = err2.stdout ?? "";
+			const stderr = err2.killed ? `MSM timed out after ${MSM_TIMEOUT_MS}ms` : err2.stderr ?? err2.message ?? "";
+			return msmExecResult(entry.name, status, stdout, stderr, fmtJson, hasHelp);
+		}
+		const status = err.killed ? 124 : typeof err.code === "number" ? err.code : 2;
+		const stdout = err.stdout ?? "";
+		const stderr = err.killed ? `MSM timed out after ${MSM_TIMEOUT_MS}ms` : err.stderr ?? err.message ?? "";
+		return msmExecResult(entry.name, status, stdout, stderr, fmtJson, hasHelp);
+	}
+}
+//#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 就失败 ⇒ 六个机制**全都不生效**。
+*    ⇒ 策略 = **直接发 → 被拒时从宿主的错误文案里解析出它点名的未知名字 → 只剔那几个、其余重发一次**。
+*    被剔掉的名字进 `dropped`（调用方决定要不要告警）。
+*    ⚠️ **不做 `tools.get` 预探活** —— 那个视图查不出 agent-plane 贡献的工具
+*    （`bash` / `schedule_*`），会把**在册的名字误判成未注册**（见下方发射段的实测记录）。
+*    🔴 **也不按"谁注册的"降级** —— `REGISTERED_TOOLS` 只含 ACC 自己的 14 个，
+*    用它当"在册面"会**整类丢掉宿主工具**（2026-10-24 真机缺陷，见发射段）。
+*    ⇒ 唯一合法的在册判据是**宿主自己的回答**：要么发一次成功，要么它说出哪些名字不认识。
+*
+* @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 = [];
+	const names = decision.deny;
+	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 (firstError) {
+		const message = errorText(firstError);
+		const unknown = parseUnknownToolNames(message);
+		if (unknown.length === 0) return {
+			status: "failed",
+			dropped,
+			error: message
+		};
+		const unknownSet = new Set(unknown);
+		const remaining = names.filter((n) => !unknownSet.has(n));
+		dropped.push(...names.filter((n) => unknownSet.has(n)));
+		if (remaining.length === 0) return {
+			status: "failed",
+			dropped,
+			error: message
+		};
+		try {
+			const dispose = tools.restrict({ deny: remaining });
+			applied.set(sessionId, {
+				signature: decisionSignature({
+					...decision,
+					deny: remaining
+				}),
+				deny: remaining,
+				dispose
+			});
+			return {
+				status: "applied",
+				dropped
+			};
+		} catch (secondError) {
+			return {
+				status: "failed",
+				dropped,
+				error: errorText(secondError)
+			};
+		}
+	}
+}
+/** 取异常的可读文案（非 Error 也能取到 message；都没有则 String()） */
+function errorText(e) {
+	if (e instanceof Error) return e.message;
+	if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string") return e.message;
+	return String(e);
+}
+/**
+* 从宿主的 `tools.restrict()` 错误文案里解析出**被点名的未知工具名**。
+*
+* 宿主逐字形态（`dsh-tools/lib/types/index.js` 的 `restrict()`）：
+* ```
+* tools.restrict() names unknown global tool(s) "a", "b"; known global tools: x, y, z
+* ```
+* 单数时是 `tool`，复数时是 `tool(s)`——两种都匹配。
+*
+* 🔴 **只取分号之前那一段**：分号后是 `known global tools:` 清单，**不能**误当成未知名字。
+* 🔴 解析不出来就返回 `[]`（调用方据此走"如实失败、不记账"），**绝不猜**。
+*/
+function parseUnknownToolNames(message) {
+	const head = message.split(";")[0] ?? "";
+	if (!/names unknown global tool/.test(head)) return [];
+	const out = [];
+	for (const m of head.matchAll(/"([^"]+)"/g)) {
+		const name = m[1];
+		if (name !== void 0 && name !== "") out.push(name);
+	}
+	return [...new Set(out)];
+}
+/** 会话销毁清理（防 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 语义的机械层）
+*
+* 纯决策逻辑（decideGuard）与 DSH 注册（registerGuards）分离：
+* 前者零 DSH 依赖可单测，后者把决策接到 tools/pre-execute 瀑布 + ctx.tools.guard 终局。
+*
+* 对应 opencode-serenity-plugin 的 tool.execute.before 路径守卫 + bash 开关 + 黑名单。
+*/
+/** 写类工具名（黑名单/治理文件只拦这些；读工具只做路径越界检查——对齐 osp） */
+const WRITE_TOOLS = /* @__PURE__ */ new Set([
+	"write",
+	"edit",
+	"str_replace_editor",
+	"container_fs",
+	"bash",
+	"touch"
+]);
+/** container_fs 的写类子命令（mkdir/rm/mv/cp/touch）；其余 9 子命令（root/resolve/exists/
+*  list/tree/relative/reveal/info/find）为只读——只读子命令不查黑名单（同 read 语义）
+*  🔴 `append` 已于 v1.101.0 退役（owner 2026-10-26），故不在此集合。 */
+const CC_FS_WRITE_ACTIONS = /* @__PURE__ */ new Set([
+	"mkdir",
+	"rm",
+	"mv",
+	"cp",
+	"touch"
+]);
+/**
+* 凭据文件硬名单（数据面守卫，v1.26.3，S142 用户：localstore.json 需要在 read 工具的黑名单里）：
+* **任何工具**（含 read/grep/glob/container_fs 只读子命令）命中这些相对 CCC 根的路径 → deny。
+*
+* 与 safeMode.blacklist（写黑名单，v1.18.5 决策只拦写）语义独立：
+* - 黑名单 = 用户可配置的写保护（REPOSITORIES/ 等只读参考源不误伤读）
+* - 凭据硬名单 = **结构性数据面边界**（不依赖 safe-mode 开关，凭据文件任何时候不可读）——
+*   对齐 CCE Bounded Space + wardn "structural guarantee, not policy"：localstore.json
+*   含 API keys/tokens/SSH 密码，即使 prompt 纪律失败也无值可吐（机械保证）。
+*/
+const SENSITIVE_CREDENTIAL_FILES = /* @__PURE__ */ new Set(["localstore.json"]);
+/**
+* MSM 注册表写保护（需求⑤b S142 用户拍板："msm注册的文件需要写保护起来，避免CCC意外写坏搞崩自己"）：
+* mech-registry.json 是 CCC 执行层地基（坏 → loadMsmEntries 抛 → container_admin/output-guard 全崩，
+* register 也崩 → 自锁）。**写 deny、读 allow**（与 localstore 读 deny 语义区分 R6——注册表是
+* 结构核心不是秘密，需被 output-guard/trajectory-constraint-admin 读取建 MSM 词表）。
+*
+* 单级化（需求⑤a）后**唯一合法注册表 = cccName 聚合档**
+* `.opencode/skills/<cccName>/references/mech-registry.json`（cccName = .serenity 首行）。
+* 历史 root 级 `mech-registry.json` 与各 skill 分散注册表已废弃：**不再保护**
+* （review P1：保护一个永不被读的文件 = 死锁——MSM 既不可见又不可删/迁移）。
+* 写工具命中聚合档 → deny（唯一合法写通道 = container_admin msm register/deregister
+* 内部 writeRegistry，走工具实现不经 pre-execute → 天然豁免）；读工具放行。
+*/
+function isProtectedRegistryRel(root, rel) {
+	const lower = (s) => process.platform === "win32" ? s.toLowerCase() : s;
+	const relCi = lower(rel);
+	try {
+		const marker = resolve(root, ".serenity");
+		if (existsSync(marker)) {
+			const line = readCccName$1(root);
+			if (line) {
+				if (relCi === lower(`.opencode/skills/${line}/references/mech-registry.json`)) return true;
+				if (relCi === lower(`.opencode/skills/${line}/references`)) return true;
+			}
+		}
+	} catch {}
+	return false;
+}
+/** 判定工具是否为写类：普通工具按名；container_fs 复合工具按子命令 action */
+function isWriteTool(toolName, action) {
+	if (!WRITE_TOOLS.has(toolName)) return false;
+	if (toolName === "container_fs") return action !== void 0 && CC_FS_WRITE_ACTIONS.has(action);
+	return true;
+}
+/**
+* 安全模式 + 黑名单 + P3 路径守卫的纯决策。
+* 对齐 opencode-serenity-plugin 标准：安全模式 = **bash 禁用** + 写入黑名单；
+* write/edit 等工具仅受路径逃逸与黑名单约束（不整体禁用）。
+* 优先级：safe-mode bash > 路径越界 > 黑名单命中。
+*/
+function decideGuard(input) {
+	const { root, toolName, safeModeOn, blacklist, pathArg, action } = input;
+	if (input.trajectoryConstraint !== void 0 && input.trajectoryConstraint !== null) {
+		const profile = input.trajectoryConstraint;
+		if (toolName === "skill") return { kind: "allow" };
+		if ((profile.msms ?? []).includes(toolName)) return {
+			deny: `"${toolName}" is a registered MSM, not a direct tool in this trajectory — call it through the msm tool: msm("${toolName}", ["<args>"]) (pass "--help" or inspect=true for usage)`,
+			kind: "deny"
+		};
+		const whitelist = profileToolWhitelist(profile);
+		if (whitelist !== null && !whitelist.has(toolName)) return {
+			deny: "tool not allowed in this 轨迹约束 trajectory",
+			kind: "deny"
+		};
+		const writeScopes = profileWriteWhitelist(profile);
+		if (writeScopes !== null && pathArg !== void 0 && isWriteTool(toolName, action)) {
+			const abs = resolve(root, pathArg);
+			if (!writeScopes.some((scope) => pathInside(resolve(root, scope), abs))) return {
+				deny: `${toolName}: write outside this trajectory's declared write scope (allowed: ${writeScopes.length > 0 ? writeScopes.join(" / ") : "(none — \"writes\" is an empty array)"}); target: ${pathArg} — add the prefix to this trajectory's trajectory.json "writes" if the write is intended`,
+				kind: "deny"
+			};
+		}
+	}
+	if (safeModeOn && toolName === "bash") return {
+		deny: `bash: no such tool`,
+		kind: "deny"
+	};
+	if (pathArg !== void 0) {
+		const abs = resolve(root, pathArg);
+		if (!pathInside(resolve(root), abs)) return {
+			deny: `path escape blocked: "${pathArg}" escapes the CCC root`,
+			kind: "deny"
+		};
+		const rel = relative(root, abs).split("\\").join("/");
+		if (SENSITIVE_CREDENTIAL_FILES.has(rel)) return {
+			deny: `access blocked: "${pathArg}" is a sensitive credential file (${rel})`,
+			kind: "deny"
+		};
+		if (isWriteTool(toolName, action)) {
+			if (rel === ".serenity-safe-on" || rel === ".serenity" || rel.startsWith(".serenity-safe-on/") || rel.startsWith(".serenity/")) return {
+				deny: `CCC governance file "${rel}" is reserved for the user — agent must not write`,
+				kind: "deny"
+			};
+			if (isProtectedRegistryRel(root, rel)) return {
+				deny: rel.endsWith("/mech-registry.json") ? `mech-registry.json is ACC-managed (${rel}) — use container_admin msm register/deregister instead of writing it directly` : `"${rel}" is an ancestor of the ACC-managed mech-registry.json — removing/moving it would destroy the registry; the registry is managed by container_admin msm register/deregister`,
+				kind: "deny"
+			};
+			const hit = matchBlacklist(rel, blacklist);
+			if (hit) return {
+				deny: hit.message ?? `blacklist blocked: "${pathArg}" matches rule "${hit.pattern}"`,
+				kind: "deny"
+			};
+		}
+	}
+	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",
+			"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", () => isImWiredTrajectory(root, trajectoryCodeForSession(root, sessionId)) ? { deny: [] } : { deny: [IM_BRIDGE_TOOL_NAME] }));
+	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)) };
+	}));
+	out.push(sourceOf("alwaysDeny", () => ({ deny: [...ALWAYS_DENY_TOOLS] })));
+	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();
+}
+/**
+* 安全模式开启时从模型工具列表隐藏的工具 —— **基础表**（只隐藏 bash；write/edit 保留）。
+* 它**恒隐**、与 CCC 配置无关；CCC 声明的 `safeMode.hiddenTools` 是**附加**项（见下）。
+*/
+const SAFE_MODE_DENY_TOOLS = ["bash"];
+/**
+* **常驻拒绝表** —— 与安全模式**无关**，任何 CCC、任何时刻都隐藏（v1.106.0，owner 2026-11-01 令）。
+*
+* 为什么与 `SAFE_MODE_DENY_TOOLS` 分开成两张表（而不是往那张里加一项）：
+* 那张表的**名字即语义**——"安全模式期间的附加拒绝"。把常驻项塞进去会让"名字与行为不符"，
+* 而这类错位**没有机械信号**（D151：退役/错位的开关零信号）。⇒ 两张表、两条来源，各说各的。
+*
+* ## 首个条目：`ask_user_question`
+*
+* owner 原话（2026-11-01）：**「宁静号追求更高程度的自动化和轨迹协作，这种阻塞性的东西会降低效率」**
+* ⇒ 它会让一轮停下来等人回答，与"轨迹自驱 + 轨迹间协作"直接冲突。
+*
+* ⚠️ **边界（诚实标注，D255）**：
+*  - 本表是**藏**（`tools.restrict({deny})` 让模型看不见），**不是禁** —— 它不阻止经别的路径调用。
+*    要真禁得住需在 tool-call 层拦截，那是另一件事，不在本次范围。
+*  - 它**不依赖** `.serenity-safe-on`：安全模式关着也照样藏。
+*  - 宿主若不认识某个名字，`applyVisibilityDecision` 会从它的错误里解析并只剔掉那几个
+*    （⇒ 本表写错一个名字**不会**连累其它来源，也不会静默冻结）。
+*/
+const ALWAYS_DENY_TOOLS = ["ask_user_question"];
+const safeModeRestrictions = /* @__PURE__ */ new Map();
+const restrictDiag = {
+	lastKey: null,
+	lastAttemptAt: null,
+	lastSuccess: null,
+	lastError: null,
+	activeKeys: [],
+	denyByKey: {}
+};
+function getRestrictDiagnostics() {
+	return {
+		...restrictDiag,
+		activeKeys: [...safeModeRestrictions.keys()],
+		denyByKey: Object.fromEntries([...safeModeRestrictions].map(([k, v]) => [k, v.deny]))
+	};
+}
+/** 条件可见的 IM 工具名（与 tools/im/channels.ts 的注册名一致） */
+const IM_BRIDGE_TOOL_NAME = "im-bridge";
+/**
+* 会话销毁清理（lifecycle 调用）。
+*
+* ⚠️ 方案 C 后撤销动作**只在** `forgetToolVisibility` 里做一次（那一次合并 restrict）。
+* 本函数保留为语义占位：重复撤销同一条 restrict 会抛错，故这里刻意不做动作。
+*/
+function forgetImBridgeVisibility(_sessionId) {}
+/** 会话销毁清理（lifecycle 调用）——方案 C 后由统一清理撤销，这里保留语义占位。 */
+function forgetHostScheduleToolHiding(_sessionId) {}
+/**
+* 宿主 `dsh-tool-schedule` 注册的 4 个模型可见工具名（**逐字**）。
+*
+* 🔴 **为什么要在 CCC 内屏蔽**（owner 原话：「这和 CRO 冲突，要求在宁静号激活情况下屏蔽掉」）：
+* 宁静号的唤醒/巡航走 `cognitive_trajectory send-later` → `AGENT_SESSIONS/wake-registry.json`
+* → 中心调度器 5min tick（D58）。宿主这套定时器是**另一个**真相源 ⇒ 两处记账、
+* CRO 判据失真、且模型可能顺手排一个"不在任何账本里"的唤醒。
+* ⚠️ 本清单**合并发射时不做探活**。⚠️ 现状缺口（v1.87.1 如实登记）：宿主**没装**
+*    `dsh-tool-schedule` 时，这 4 个名字会把整次 restrict 拒掉，而退档只保留 ACC 自己的名字
+*    ⇒ 这一格的屏蔽**不生效**（旧实现同样不生效，**未回归**；但"顺带修好了"这句是假的，已删）。
+*/
+const HOST_SCHEDULE_TOOL_NAMES = [
+	"schedule_create",
+	"schedule_list",
+	"schedule_update",
+	"schedule_delete"
+];
+/** 会话销毁清理（lifecycle 调用）。
+* ⚠️ 方案 C 后撤销只在 `forgetToolVisibility` 做一次；本函数保留语义占位。
+* 留着它的价值：lifecycle 的调用点表达"这条会话有轨迹约束可见性状态要清"，
+* 删掉调用点会让那件事**从代码里消失**（将来有人重加机制时找不到插点）。 */
+function forgetTrajectoryConstraintToolVisibility(_sessionId) {}
+/** 会话销毁清理（lifecycle 调用）——同上，语义占位。 */
+function forgetExclusiveToolsVisibility(_sessionId) {}
+/**
+* 非 CCC 会话的工具隐藏状态（sessionId → restrict disposer）。
+*
+* 🔴 **为什么需要它（缺陷根因）**：工具是 `apply()` 里 `ctx.tools.register(...)` 注册到**宿主级**的
+* ⇒ 它们出现在**每一个**会话的工具清单里，**与会话 cwd 无关**。其余各缝（身份注入 ／ guards ／
+* keeper ／ output-guard ／ bootstrap）都已有 `if (!root) return` 这道门，
+* **唯独"工具可见性"这一层没有** ⇒ 在非 CCC 目录开会话时，模型仍看得见这 14 个工具，
+* 于是会去调 —— 调了才抛 `No CCC found`。**那是运行时报错，不是事先不可见**。
+*
+* 判据（owner 原话：「宁静号所有功能在非宁静号目录不生效」）：
+* - **在 CCC 内** → 解除隐藏（本机制**一次 restrict 都不发**，既有行为零改变）
+* - **不在 CCC 内** → `restrict({ deny: [...REGISTERED_TOOLS] })` ⇒ 从模型工具清单移除
+*
+* ⚠️ **与 `syncExclusiveToolsVisibility` 的分工**：那个管"CCC 内哪个工具可见"（按 CCC 配置判）；
+* 本函数管"**这个会话配不配看到任何 ACC 工具**"（按"在不在 CCC 内"判）。二者独立、可叠加。
+*
+* ⚠️ **必须逐个名字显式列出**：宿主的 `restrict` 对**未注册的工具名**会让**整次调用失败**
+* （`dsh-tools` 契约逐字："Empty filters, unknown names … fail"）⇒ 不能写通配。
+* 但 `REGISTERED_TOOLS` 是"插件**具备**的工具面"，其中 **`diagram` 是按开关注册的**
+* （缺省关 ⇒ 缺省**并不在册**）⇒ 直接拿全表去 deny **可能整次失败**，那样就会
+* **静默退回"工具照样可见"**＝缺陷没修好。故此处走**两档尝试**（见 `hideAllFor`）。
+*/
+const nonCccRestrictions = /* @__PURE__ */ new Map();
+/** 会话销毁清理（lifecycle 调用；防 per-会话 Map 无界增长） */
+function forgetNonCccToolVisibility(sessionId) {
+	const existing = nonCccRestrictions.get(sessionId);
+	if (!existing) return;
+	try {
+		existing();
+	} catch {}
+	nonCccRestrictions.delete(sessionId);
+}
+/**
+* 从 exec 参数中提取常见路径字段（write/edit 工具）；宽松读取。
+* container_fs 复合工具：path（单路径）/ paths（数组）/ src / dst——取第一个命中（越界检查
+* 逐路径由 decideGuard 单 pathArg 覆盖；多路径字段取首个，避免漏检主体路径）。
+*/
+function extractPathArg(exec) {
+	const args = exec.arguments;
+	if (args === null || typeof args !== "object") return void 0;
+	const a = args;
+	for (const key of [
+		"path",
+		"file_path",
+		"target",
+		"src",
+		"dst"
+	]) {
+		const v = a[key];
+		if (typeof v === "string") return v;
+	}
+	const paths = a["paths"];
+	if (Array.isArray(paths) && paths.length > 0 && typeof paths[0] === "string") return paths[0];
+}
+/** 从 exec 参数提取 container_fs 子命令 action；无则 undefined */
+function extractAction(exec) {
+	const args = exec.arguments;
+	if (args === null || typeof args !== "object") return void 0;
+	const a = args;
+	return typeof a.action === "string" ? a.action : void 0;
+}
+/**
+* 注册守卫：tools/pre-execute 瀑布 + ctx.tools.guard 终局。
+* 两者都从 CCC 根实时读取配置（无状态、无缓存）。
+*/
+function registerGuards(ctx, opts = {}) {
+	const configPaths = opts.configPaths;
+	const evaluate = (exec) => {
+		const cwd = resolveAgentCwd(exec);
+		const root = cccRootForCwd(cwd);
+		if (!root) return { kind: "allow" };
+		const safeModeOn = isSafeModeOn(root);
+		const blacklist = readBlacklist(root, configPaths);
+		const pathArg = extractPathArg(exec);
+		const action = extractAction(exec);
+		const sessionId = exec?.agent?.session?.id;
+		const trajectoryConstraint = trajectoryConstraintForSession(root, sessionId);
+		return decideGuard({
+			root,
+			toolName: exec.name,
+			safeModeOn,
+			blacklist,
+			pathArg,
+			action,
+			trajectoryConstraint
+		});
+	};
+	ctx.on("tools/pre-execute", async (exec, next) => {
+		const d = evaluate(exec);
+		if (d.deny) return {
+			kind: "deny",
+			reason: d.deny
+		};
+		return next();
+	});
+	ctx.tools.guard((exec) => {
+		return evaluate(exec).deny;
+	});
+}
+//#endregion
+//#region src/skills/opencode-scan.ts
+/**
+* opencode-scan.ts — opencode skill 标准扫描（纯逻辑，零 DSH 依赖）
+*
+* 兼容 opencode 的 skill 标准：`.opencode/skills/<name>/SKILL.md`
+* （frontmatter: name/description/whenToUse；结构含 references/、scripts/）。
+*/
+/** 解析 --- 分隔的 YAML frontmatter（只需 name/description/whenToUse） */
+function parseFrontmatter(raw) {
+	const text = raw.replace(/^\uFEFF/, "");
+	const m = /^---\s*\n([\s\S]*?)\n---\s*\n?/.exec(text);
+	if (!m) return {
+		meta: {
+			name: "",
+			description: ""
+		},
+		content: text
+	};
+	const fm = m[1];
+	const body = text.slice(m[0].length);
+	const grab = (key) => {
+		const line = fm.split("\n").find((l) => l.startsWith(`${key}:`));
+		if (!line) return void 0;
+		return line.slice(key.length + 1).trim().replace(/^['"]|['"]$/g, "");
+	};
+	const meta = {
+		name: grab("name") ?? "",
+		description: grab("description") ?? ""
+	};
+	const whenToUse = grab("whenToUse");
+	if (whenToUse) meta.whenToUse = whenToUse;
+	return {
+		meta,
+		content: body
+	};
+}
+/** 扫描 CCC 的 .opencode/skills（一级目录 + SKILL.md 存在性） */
+function listOpencodeSkillDirs(root) {
+	const dir = join(root, ".opencode", "skills");
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join(dir, e.name)).filter((d) => existsSync(join(d, "SKILL.md")));
+}
+/** 加载一个 opencode skill（frontmatter 解析 + 正文）；读失败（EPERM/占用等）返回 null，单目录容错 */
+function loadOpencodeSkill(skillDir) {
+	let raw;
+	try {
+		raw = readFileSync(join(skillDir, "SKILL.md"), "utf-8");
+	} catch {
+		return null;
+	}
+	const { meta, content } = parseFrontmatter(raw);
+	return {
+		name: meta.name,
+		dir: skillDir,
+		meta,
+		content,
+		path: join(skillDir, "SKILL.md")
+	};
+}
+//#endregion
+//#region src/surface/status.ts
+/**
+* surface/status.ts — 状态与安全模式操作（纯逻辑，零 DSH 依赖，可独立单测）
+*
+* WebUI 停靠栏的数据源：ACC 版本 / CCC 根 / safe-mode 状态 / 黑名单 / keeper 阈值。
+* setSafeMode 直接读写 .serenity-safe-on 标记（守卫实时读取，写即生效）。
+*/
+/** 宿主包名 —— 从运行入口反推包根时的**身份核对**用（见 {@link dshVersionFromEntry}） */
+const HOST_PACKAGE_NAME = "@deepseek-ai/dsh";
+/** 上溯层数上限：入口脚本在包内的深度是 `lib/`（1 层）或 `lib/x/y/`（≤3 层）⇒ 6 层足够，且**保证有界** */
+const MAX_ENTRY_ASCENT = 6;
+/**
+* 🔴 **布局无关档**：从**正在跑的那个入口脚本**反推宿主包根，读它的 `version`。
+*
+* 为什么必须补这一档（R↓：一处**静默失效**的实际缺陷；2026-09-28 docker bench 实测）：
+* 下面那条静态候选链（{@link readDshVersion} 的 ②）是**猜安装位置**——`npm_config_prefix` /
+* `APPDATA\npm` / `~/.npm-global`。一旦宿主装在**别处**（典型 = 容器镜像里的
+* `/usr/local/lib/node_modules/@deepseek-ai/dsh`），**三个候选全不中** ⇒ 返回 `null`
+* ⇒ `checkHostVersion(null)` 只给一条 **`required: false`** 的 issue ⇒ 报告 `ok` 仍为 `true`
+* ⇒ **版本门完全静默**（bench 逐字：`host contract degraded (1 optional): host version unknown`）。
+* ⚠️ 这类坏法**比"偶尔报警"更危险**：一条**永远为假**的判据看起来像"没报警 = 没问题"。
+*
+* 而"我们正跑在哪个宿主里"**本来就有直接证据**：`process.argv[1]`（= 启动本进程的那个脚本）。
+* 三条判据要点（每条都对应一个实测过的坑）：
+*  ① **先 `realpath`** —— 全局安装的 `dsh` 是**符号链接**（`/usr/local/bin/dsh` → `…/@deepseek-ai/dsh/lib/bin.js`），
+*     而 Node 的 `argv[1]` **保留调用路径、不解析符号链接** ⇒ 不 realpath 就永远上溯不到包根。
+*  ② **核对包名**（`name === '@deepseek-ai/dsh'`）—— 否则在 vitest / npx 等入口下会误取**别人的**
+*     `package.json`（这是本档**唯一**的假阳性来源）。
+*  ③ **上溯有界**（{@link MAX_ENTRY_ASCENT}）—— 不设界的话，一个不在任何 dsh 包内的入口会一路爬到文件系统根。
+*
+* @param entry `process.argv[1]`（单测直接注入，无需替身）
+*/
+function dshVersionFromEntry(entry) {
+	if (typeof entry !== "string" || entry === "") return null;
+	let dir;
+	try {
+		const real = realpathSync(entry);
+		dir = statSync(real).isDirectory() ? real : dirname(real);
+	} catch {
+		return null;
+	}
+	for (let i = 0; i < MAX_ENTRY_ASCENT; i++) {
+		try {
+			const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+			if (pkg.name === HOST_PACKAGE_NAME && typeof pkg.version === "string") return pkg.version;
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* 读取已安装 DSH CLI 版本；读不到返回 null。
+*
+* **两档，顺序有理由**：
+*  ① 🔴 **布局无关档**（{@link dshVersionFromEntry}）= **正在跑的就是它** —— 直接证据优先于"猜安装位置"。
+*  ② **静态候选链**（跨平台历史档，保留）：`npm_config_prefix` ／ `APPDATA\npm` ／ `~/.npm-global`
+*     （Windows npm 全局装在 `%APPDATA%\npm`，见审计问题 13）。
+*     ⚠️ 保留它是因为**本进程不一定是 dsh CLI**（单测、嵌入式、将来别的宿主进程）——
+*     那时"本机装了哪个版本"仍需一个答案，只是证据等级更低。
+*/
+function readDshVersion() {
+	const fromEntry = dshVersionFromEntry(process.argv[1]);
+	if (fromEntry !== null) return fromEntry;
+	const candidates = [];
+	if (process.env.npm_config_prefix) candidates.push(join(process.env.npm_config_prefix, "lib", "node_modules", "@deepseek-ai", "dsh"));
+	if (process.env.APPDATA) candidates.push(join(process.env.APPDATA, "npm", "node_modules", "@deepseek-ai", "dsh"));
+	candidates.push(join(homedir(), ".npm-global", "lib", "node_modules", "@deepseek-ai", "dsh"));
+	for (const p of candidates) try {
+		const pkg = JSON.parse(readFileSync(join(p, "package.json"), "utf-8"));
+		if (typeof pkg.version === "string") return pkg.version;
+	} catch {}
+	return null;
+}
+function getStatus(cwd, configPaths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	const root = cccRootForCwd(cwd);
+	const restrict = getRestrictDiagnostics();
+	const common = {
+		accVersion: ACC_VERSION,
+		dshVersion: readDshVersion(),
+		nodeVersion: process.version
+	};
+	if (!root) return {
+		root: null,
+		...common,
+		safeModeOn: false,
+		blacklist: [],
+		threshold: null,
+		trajectories: [],
+		skills: [],
+		restrict
+	};
+	const cfg = loadSerenityConfig(root, configPaths);
+	return {
+		root,
+		...common,
+		safeModeOn: isSafeModeOn(root),
+		blacklist: readBlacklist(root, configPaths),
+		threshold: cfg.sessionKeeper?.threshold ?? null,
+		trajectories: listActiveTrajectories(root),
+		skills: listSkillSummaries(root),
+		restrict
+	};
+}
+/**
+* 技能清单（面板用；owner 2026-10-18 要求 skills 单独占一个 panel）。
+*
+* 只取**两个可文件系统验证的事实**：名字（目录名）＋ 是否已建模（`skill.ttl` 存在）。
+* 为什么"是否建模"值得进面板：它是 skill 形态的**唯一二值区别**（有 `skill.ttl` = 增强型，
+* 无 = 普通 skill），而后者**完全正常** —— 所以面板把它呈现为**信息**，不是缺陷标记。
+*
+* ⚠️ 单目录读失败**不抛**（`loadOpencodeSkill` 返回 null 时照旧收入名字）：
+* 面板是只读状态面，一个坏目录不该让整块面板消失。
+*/
+function listSkillSummaries(root) {
+	const out = [];
+	for (const dir of listOpencodeSkillDirs(root)) {
+		const name = basename(dir);
+		out.push({
+			name,
+			modeled: existsSync(join(dir, "skill.ttl"))
+		});
+	}
+	return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** 切换安全模式（写/删标记文件）；返回实际生效状态 */
+function setSafeMode(root, on) {
+	const marker = resolve(root, SAFE_MODE_MARKER);
+	if (on) {
+		if (!existsSync(marker)) writeFileSync(marker, isoLocal() + "\n", "utf-8");
+	} else rmSync(marker, { force: true });
+	return { on: isSafeModeOn(root) };
+}
+//#endregion
+//#region src/host/contract.ts
+/** dsp 依赖的宿主服务与成员（对照 `_tmp/host-0.1.5-rc.1/`（`dsh-develop host-fetch` 产物）逐一核对） */
+const HOST_SERVICES = [
+	{
+		id: "tools",
+		name: "tools",
+		access: "injected",
+		members: [{
+			name: "register",
+			kind: "function"
+		}, {
+			name: "guard",
+			kind: "function"
+		}],
+		impact: "10 个 ACC 工具无法注册 / 机械守卫失效",
+		required: true
+	},
+	{
+		id: "sessions",
+		name: "sessions",
+		access: "injected",
+		members: [
+			{
+				name: "list",
+				kind: "function"
+			},
+			{
+				name: "get",
+				kind: "function"
+			},
+			{
+				name: "create",
+				kind: "function"
+			}
+		],
+		impact: "会话定位/rebuild/CCC 解析失效",
+		required: true
+	},
+	{
+		id: "agents",
+		name: "agents",
+		access: "injected",
+		members: [{
+			name: "create",
+			kind: "function"
+		}, {
+			name: "get",
+			kind: "function"
+		}],
+		impact: "轨迹约束无法创建或复用 agent",
+		required: true
+	},
+	{
+		id: "webServer",
+		name: "webServer",
+		access: "injected",
+		members: [{
+			name: "register",
+			kind: "function"
+		}, {
+			name: "port",
+			kind: "value"
+		}],
+		impact: "状态接口/网关端口发现失效",
+		required: true
+	},
+	{
+		id: "settings",
+		name: "settings",
+		access: "injected",
+		members: [{
+			name: "describe",
+			kind: "function"
+		}, {
+			name: "update",
+			kind: "function"
+		}],
+		impact: "设置面板不装配 → 所有开关静默 no-op；opencode 路由自动配置与多模态补丁失效",
+		required: true
+	},
+	{
+		id: "web",
+		name: "web",
+		access: "injected",
+		members: [{
+			name: "registerFetchProvider",
+			kind: "function"
+		}],
+		impact: "web_fetch provider 无法注册 → fake-ip 网络下 web_fetch 不可用",
+		required: false
+	},
+	{
+		id: "systemPrompt",
+		name: "systemPrompt",
+		access: "injected",
+		members: [],
+		impact: "Induction（入口 skill 段）注入失效",
+		required: true
+	},
+	{
+		id: "sessionProjections",
+		name: "sessionProjections",
+		access: "injected",
+		members: [{
+			name: "snapshot",
+			kind: "function"
+		}],
+		impact: "上下文压力读数失效 → rebuild 提醒不再触发",
+		required: false
+	},
+	{
+		id: "skills",
+		name: "skills",
+		access: "injected",
+		members: [],
+		impact: "opencode skill 兼容层（.opencode/skills 注册）失效",
+		required: false
+	},
+	{
+		id: "shellEnv",
+		name: "shellEnv",
+		access: "injected",
+		members: [],
+		impact: "DSH_SERENITY_* 环境事实注入失效",
+		required: false
+	},
+	{
+		id: "agentLoop",
+		name: "agentLoop",
+		access: "injected",
+		members: [],
+		impact: "子 agent 无法装配 preset（轨迹载体创建会退到全局工具层）",
+		required: false
+	},
+	{
+		id: "subagents",
+		name: "subagents",
+		access: "lazy",
+		members: [{
+			name: "startActivation",
+			kind: "function",
+			anyOf: "spawn-starter"
+		}, {
+			name: "start",
+			kind: "function",
+			anyOf: "spawn-starter"
+		}],
+		impact: "子 agent 委派不可用（cheap-worker 已下线 ⇒ 现无消费者，仅备将来）",
+		required: false
+	},
+	{
+		id: "sessionTitle",
+		name: "sessionTitle",
+		access: "lazy",
+		members: [{
+			name: "rename",
+			kind: "function"
+		}],
+		impact: "会话命名 / rebuild 后重命名跳过（仅告警）",
+		required: false
+	},
+	{
+		id: "tokenMeter",
+		name: "tokenMeter",
+		access: "lazy",
+		members: [{
+			name: "estimateMessage",
+			kind: "function"
+		}],
+		impact: "rebuild shadow-price 定价失效（计量不准）",
+		required: false
+	},
+	{
+		id: "workspaceRegistry",
+		name: "workspaceRegistry",
+		access: "lazy",
+		members: [{
+			name: "list",
+			kind: "function"
+		}, {
+			name: "archivedSessionIds",
+			kind: "value"
+		}],
+		impact: "CCC 自动发现回落失效 ＋ **归档状态不可知**（已归档会话会被误判成活载体）",
+		required: false
+	},
+	{
+		id: "sessionPersistence",
+		name: "sessionPersistence",
+		access: "lazy",
+		members: [{
+			name: "list",
+			kind: "function"
+		}],
+		impact: "CCC 自动发现回落失效（诊断面受限）",
+		required: false
+	},
+	{
+		id: "sessionController",
+		name: "sessionController",
+		access: "lazy",
+		members: [{
+			name: "resolveAgent",
+			kind: "function"
+		}],
+		impact: "cognitive trajectory 冷会话唤醒不可用（只能唤醒已加载的 live 会话）——唤醒注册表投递降级",
+		required: false
+	},
+	{
+		id: "connection",
+		name: "connection",
+		access: "lazy",
+		members: [{
+			name: "authenticatedUrl",
+			kind: "function"
+		}, {
+			name: "authorizeIndex",
+			kind: "function"
+		}],
+		impact: "双端口网关无法换取 dsh cookie → 外部反代 401",
+		required: false
+	},
+	{
+		id: "storageDomain",
+		name: "storageDomain",
+		access: "lazy",
+		members: [{
+			name: "open",
+			kind: "function"
+		}],
+		impact: "轨迹绑定无处可存 → §0L 整体不可用（须退回\"写会话日志\"备选方案）",
+		required: false
+	}
+];
+/**
+* dsp **被验证过的宿主版本档**（单一真相源）—— 每档 = 一个半开区间 `[floor, ceiling)`。
+*
+* 🔴 为什么是"档"而不是一条 caret 范围（R↓：2026-09-28 0.2.0-rc.1 适配轮实测得出）：
+*  - **宿主门的判据是真 semver**（`@deepseek-ai/dsh-app-boot:evaluatePluginCompatibility`
+*    = `semver.satisfies(runtime, range, { includePrerelease: true })`）⇒ **它支持 `||` 联合范围**；
+*  - 而 **dsp 这边是手写比较器**（{@link compareSemver}），**不实现 semver 的 range 语义**：
+*    旧写法"用正则从 `REQUIRED_HOST_RANGE` 剥前缀取 floor"在**联合范围上会取到垃圾**
+*    （`^0.1.7-rc.1 || ^0.2.0-rc.1` 的预发布捕获组 `(.*)` 会**吞掉 `||` 之后整段**）
+*    ⇒ 判定**变瞎**（既非"通过"也非"低于下限"，而是不可解释的值）。
+*  ⇒ 故**档表是唯一被验证的真相**：`REQUIRED_HOST_RANGE`（给宿主门看的串）与
+*    `checkHostVersion`（给自己的手写比较器）**都从它派生**，两者不可能互相漂移。
+*
+* 🔴 两档的由来（**实测，非推断**；判据表见插件仓 `docs/dsh-0.2.0-rc.1-adaptation-plan.md` §7.4）：
+*  - `^0.1.7-rc.1` 在 `0.2.0-rc.1` 上被宿主**整包拒绝 ＋ 回滚**
+*    （逐字 `installation rejected: … incompatible with dsh 0.2.0-rc.1` ＋ `restored package.json, …`）；
+*  - 单档 `^0.2.0-rc.1` 会**同样硬拒本机正在跑的 `0.1.7-rc.2`**
+*    ⇒ 发布后 deploy 必须先升宿主，**而升级会打断本容器**；
+*  - ⇒ 双档是**唯一不把本机宿主堵死的写法**（两档在真 semver 下均 PASS）。
+* 档上界取 `<0.2.0` / `<0.3.0`（即 `^0.2.0-rc.1` 的 caret 上界）：第二档同时覆盖
+* `0.2.0` 正式版与后续 `0.2.0-rc.N`。
+*
+* 🆕 **第三档 `^0.2.1-rc.1`（v1.59.3 适配，2026-10-17）** —— 为什么非加不可：
+*  - npm 的 `^0.2.0-rc.1` 对**预发布**只放行**同一 `major.minor.patch`** 的 prerelease
+*    ⇒ **`0.2.1-rc.1` 不满足它**（patch 位不同）⇒ 宿主门会**整包拒绝安装**（D98 同族）。
+*  - 而第二档的 `ceiling: '0.3.0'` 本来就"包含" 0.2.1 —— 那是**我们自己的手写比较器**的语义；
+*    两个判据（真 semver 门 vs 手写区间）在这里**给出相反答案**，故必须把第三档显式写出来，
+*    让**派生串**（{@link REQUIRED_HOST_RANGE}）里真的出现 `^0.2.1-rc.1`。
+*  ⚠️ **加档不是收窄**：前两档原样保留（0.1.7 / 0.2.0 两代仍被声明支持）。
+*/
+const VERIFIED_HOST_BANDS = [
+	{
+		floor: "0.1.7-rc.1",
+		ceiling: "0.2.0"
+	},
+	{
+		floor: "0.2.0-rc.1",
+		ceiling: "0.3.0"
+	},
+	{
+		floor: "0.2.1-rc.1",
+		ceiling: "0.3.0"
+	}
+];
+/**
+* 与 `package.json` 的 `peerDependencies` **逐字同串**的宿主版本范围（由 {@link VERIFIED_HOST_BANDS} 派生）。
+*
+* 🔴 这个字符串**就是**宿主门（`evaluatePluginCompatibility`）拿去跑 `semver.satisfies` 的那个串
+* ⇒ 它与档表**必须一致**（"声明 union、判定单档"是一种自相矛盾）。
+* 一致性由 `tests/host-contract.test.ts` 的**跨文件对账用例**钉住（读 package.json 逐字比对）。
+*/
+const REQUIRED_HOST_RANGE = VERIFIED_HOST_BANDS.map((b) => `^${b.floor}`).join(" || ");
+/** 最小 semver 比较（无依赖）：返回 -1 / 0 / 1；解析失败返回 null */
+function compareSemver(a, b) {
+	const parse = (v) => {
+		const m = /^(\d+)\.(\d+)\.(\d+)(?:-(.*))?$/.exec(v.trim());
+		if (!m) return null;
+		return [
+			Number(m[1]),
+			Number(m[2]),
+			Number(m[3]),
+			m[4] ?? ""
+		];
+	};
+	const pa = parse(a);
+	const pb = parse(b);
+	if (!pa || !pb) return null;
+	for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+	const ra = pa[3];
+	const rb = pb[3];
+	if (ra === rb) return 0;
+	if (ra === "") return 1;
+	if (rb === "") return -1;
+	return ra < rb ? -1 : 1;
+}
+/**
+* 宿主版本是否落在 dsp **被验证过的档**（{@link VERIFIED_HOST_BANDS}）之内。
+* 无版本信息 → 视为未知（ok=false，detail 说明），不猜测。
+*
+* 🔴 **逐档判**（v1.50.x，0.2.0-rc.1 适配轮）：判据 = "∃ 档：`version >= floor ∧ version < ceiling`"。
+* 曾经的做法是"从 `REQUIRED_HOST_RANGE` 剥前缀取一个 floor ＋ 一个显式 ceiling"——
+* **单档假设一旦不成立（改联合范围），那个正则就会取到垃圾**（详见 {@link VERIFIED_HOST_BANDS}
+* 的注释）⇒ 故本函数**只读档表**，不再从范围串反推。
+* ⚠️ 手写比较器**不实现 semver 的 range 语义**（本条只做"区间内/外"），这也是必须逐档判的原因。
+*/
+function checkHostVersion(version) {
+	if (version === null) return {
+		ok: false,
+		detail: `host version unknown (required ${REQUIRED_HOST_RANGE})`
+	};
+	let matched = false;
+	let belowEveryFloor = true;
+	let unparseable = false;
+	for (const band of VERIFIED_HOST_BANDS) {
+		const floor = compareSemver(version, band.floor);
+		const ceiling = compareSemver(version, band.ceiling);
+		if (floor === null || ceiling === null) {
+			unparseable = true;
+			break;
+		}
+		if (floor >= 0) {
+			belowEveryFloor = false;
+			if (ceiling < 0) {
+				matched = true;
+				break;
+			}
+		}
+	}
+	if (unparseable) return {
+		ok: false,
+		detail: `host version "${version}" not parseable (required ${REQUIRED_HOST_RANGE})`
+	};
+	if (matched) return {
+		ok: true,
+		detail: `host ${version} within ${REQUIRED_HOST_RANGE}`
+	};
+	if (belowEveryFloor) return {
+		ok: false,
+		detail: `host ${version} is below the verified floor (required ${REQUIRED_HOST_RANGE})`
+	};
+	return {
+		ok: false,
+		detail: `host ${version} is outside the verified range (required ${REQUIRED_HOST_RANGE})`
+	};
+}
+/** 结构化读取宿主服务（lazy → ctx.get；injected → 直接属性，属性缺失再试 ctx.get） */
+function readService(ctx, name, access) {
+	return access === "lazy" ? hostService(ctx, name) : hostInjected(ctx, name);
+}
+/**
+* 探针：核对运行中的宿主是否仍满足 dsp 依赖的服务与成员。
+*
+* @param ctx 宿主插件上下文（真实 cordis Context；测试可传结构化替身）
+* @param hostVersion 运行中宿主版本（`readDshVersion()` 结果；null = 未知）
+* @returns 报告（`ok:false` 时 `issues` 逐条给出缺失项与后果）
+*/
+function probeHostContract(ctx, hostVersion = null) {
+	const issues = [];
+	let checked = 0;
+	for (const svc of HOST_SERVICES) {
+		checked += 1;
+		let value;
+		try {
+			value = readService(ctx, svc.name, svc.access);
+		} catch {
+			value = void 0;
+		}
+		if (value === void 0 || value === null) {
+			issues.push({
+				id: svc.id,
+				kind: "service",
+				detail: `service "${svc.name}" not available (${svc.access})`,
+				impact: svc.impact,
+				required: svc.required
+			});
+			continue;
+		}
+		for (const member of svc.members) {
+			checked += 1;
+			const actual = value[member.name];
+			if (!(member.kind === "function" ? typeof actual === "function" : actual !== void 0)) {
+				if (member.anyOf !== void 0) {
+					const siblings = svc.members.filter((m) => m.anyOf === member.anyOf);
+					if (siblings.some((m) => {
+						const v = value[m.name];
+						return m.kind === "function" ? typeof v === "function" : v !== void 0;
+					})) continue;
+					issues.push({
+						id: `${svc.id}.${member.anyOf}`,
+						kind: "member",
+						detail: `service "${svc.name}" is missing every ${member.kind} of "${member.anyOf}" (${siblings.map((m) => m.name).join(" | ")})`,
+						impact: svc.impact,
+						required: svc.required
+					});
+					continue;
+				}
+				issues.push({
+					id: `${svc.id}.${member.name}`,
+					kind: "member",
+					detail: `service "${svc.name}" is missing ${member.kind} "${member.name}"`,
+					impact: svc.impact,
+					required: svc.required
+				});
+			}
+		}
+	}
+	const version = checkHostVersion(hostVersion);
+	if (!version.ok) issues.push({
+		id: "host.version",
+		kind: "version",
+		detail: version.detail,
+		impact: "契约未经该宿主版本验证（漂移风险）",
+		required: false
+	});
+	return {
+		ok: issues.every((i) => !i.required),
+		checked,
+		hostVersion,
+		versionOk: version.ok,
+		issues
+	};
+}
+/**
+* 取宿主契约报告——**每次调用现探**（`ctx` 决定"问谁"，**不缓存"答案"**）。
+*
+* 为什么**不缓存**（R↓：一个被实测推翻的设计，留档以免重犯）：
+* v1.34.1 曾把 `apply()` 时的探针结果存为模块级快照，理由是"两者对**同一个已装载的宿主**
+* 问同一个问题，第二次计算的答案**不可能不同**，成本却是一次全服务遍历"。
+* **该前提被实测证伪**（本机 2026-09-15，v1.34.1 部署后）：
+*  - `apply()` 跑在装载早期，表中 `access:'lazy'` 的服务**尚未实例化**（`ctx.get` 返回 undefined）
+*    ⇒ 启动探针把它们记为 `not available (lazy)`；
+*  - 到 `dashboard health` 被调用时它们早已可用 ⇒ **现探给的是相反结论**。
+*  - 实测差异：快照 = `checked 36 / issues 3`（含 `workspaceRegistry not available` ＋ 后果
+*    "工作区白名单下拉为空"），而**同一时刻** `GET /serenity/cccs` 正常返回 **4 个工作区**
+*    （含 3 个无 live 会话的冷 CCC）⇒ 快照渲染出的是**假阴性**。
+* ⇒ 「两次探针」**不是重复计算，问的是两个时刻**；缓存答案 = 把装载瞬间的观测冒充运行态事实。
+*
+* 保留统一入口的收益（这才是 C5 的正确部分）：取数口唯一——`container-status` / `kit-ops`
+* 只问这一个函数；将来若要"筛掉装载期噪声"，只需改这一处。
+*
+* @param ctx 宿主上下文；**未给** ⇒ 返回 `null`（不猜、不暗跑探针）
+* @param hostVersion 运行中宿主版本（`readDshVersion()`；null = 未知）
+*/
+function hostContractReport(ctx, hostVersion = null) {
+	if (ctx === void 0) return null;
+	return probeHostContract(ctx, hostVersion);
+}
+/** 单行摘要（启动告警用） */
+function summarizeHostContract(report) {
+	if (report.ok && report.issues.length === 0) return `host contract ok (${report.checked} checks, host ${report.hostVersion ?? "unknown"})`;
+	const required = report.issues.filter((i) => i.required);
+	const optional = report.issues.filter((i) => !i.required);
+	return `${required.length > 0 ? `host contract BROKEN (${required.length} required)` : `host contract degraded (${optional.length} optional)`}: ${report.issues.map((i) => i.detail).join("; ")}`;
+}
+//#endregion
+export { docsPointer as C, setWeixinSendEndpoint as E, runMsmAsync as S, renderDocsIndex as T, CCC_CONFIG_REFERENCE as _, setSafeMode as a, loadMsmEntries as b, forgetExclusiveToolsVisibility as c, forgetNonCccToolVisibility as d, forgetTrajectoryConstraintToolVisibility as f, ACC_CATALOG as g, forgetToolVisibility as h, readDshVersion as i, forgetHostScheduleToolHiding as l, syncToolVisibility as m, summarizeHostContract as n, listOpencodeSkillDirs as o, registerGuards as p, getStatus as r, loadOpencodeSkill as s, hostContractReport as t, forgetImBridgeVisibility as u, checkRegistryQuality as v, findDocsChapter as w, runMsm as x, findEntry as y };