@shgroup/dsh-serenity-hooks 1.86.0 → 1.87.1

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.86.0",
+  "version": "1.87.1",
   "main": "lib/index.js",
   "description": "宁静号 ACC harness（Native Cordis 插件）：给 DSH 装一个「AI 工作区」——14 个工具（container_fs/cognitive_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫）+ 认知轨迹日志与原地重建 + 网页登录入口/IM 桥/认知轨迹唤醒注册表。轨迹声明 = 轨迹目录下的 trajectory.json（约束面 + 旧标识 uid + CRO 机器绑定 cro.host；旧名 trajectory-constraint.json / skiff.json 仍在读取族里）；轨迹提示词 = 轨迹目录下的 PROMPT.md（一条轨迹「是谁、按什么章程工作」，所有轨迹通用，追加在容器层与质量层之后，不替换它们）。适配 DSH 0.1.7-rc.1 / 0.2.0-rc.1 / 0.2.1-rc.1（三档，deepseek-ai/deepseek-harness）。",
   "engines": {

package/lib/im/channels.d.ts

@@ -128,8 +128,29 @@ export declare function __resetImChannelsForTest(): void;
 /** 已注册通道 id（工具 `channel` 参数枚举） */
 export declare function imChannelIds(): string[];
 /**
- * 可见性判据：本 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 根（由调用方解析）
  */
 export declare function hasEnabledImChannel(root: string): boolean;

package/lib/index.js

@@ -7,7 +7,7 @@ import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as cons
 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-H7TVDayZ.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-GtYJdR06.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 { 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";
@@ -11638,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);
 }
 /**
 * 错误码 → 可行动提示（模型视角：说清怎么改）。
@@ -11847,6 +11871,125 @@ async function runImBridge(root, req) {
 	return fail("ACTION_UNKNOWN", `unknown action "${action}"`);
 }
 //#endregion
+//#region src/seams/tool-visibility.ts
+/** ACC 自己注册的工具名集合（退化档只发这些 —— 它们一定在册） */
+const REGISTERED_TOOLS_SET = new Set(REGISTERED_TOOLS);
+/** 收集器：把各来源的 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 就失败 ⇒ 六个机制**全都不生效**。
+*    ⇒ 策略 = **直接发 → 全量被拒才退到「只发 ACC 自己注册的那些」一档**，退档时
+*    把被放弃的名字如实记账（进 `dropped`，由调用方决定要不要告警）。
+*    ⚠️ **不做 `tools.get` 预探活** —— 那个视图查不出 agent-plane 贡献的工具
+*    （`bash` / `schedule_*`），会把**在册的名字误判成未注册**（见下方发射段的实测记录）。
+*    ⚠️ 这比旧行为**更保守**：旧行为是"某条 restrict 失败 ⇒ 那一格静默不生效"，
+*    新行为是"全量失败 ⇒ 至少 ACC 那一格照常生效" —— **等价或更好**，且总有日志。
+*
+* @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 accOnly = names.filter((n) => REGISTERED_TOOLS_SET.has(n));
+		if (accOnly.length === 0 || accOnly.length === names.length) return {
+			status: "failed",
+			dropped,
+			error: firstError.message
+		};
+		const abandoned = names.filter((n) => !REGISTERED_TOOLS_SET.has(n));
+		try {
+			const dispose = tools.restrict({ deny: accOnly });
+			applied.set(sessionId, {
+				signature,
+				deny: accOnly,
+				dispose
+			});
+			return {
+				status: "applied",
+				dropped: abandoned
+			};
+		} catch (secondError) {
+			return {
+				status: "failed",
+				dropped,
+				error: secondError.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 语义的机械层）
@@ -11983,6 +12126,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();
@@ -12008,168 +12264,18 @@ 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 判据失真、且模型可能顺手排一个"不在任何账本里"的唤醒。
+* ⚠️ 本清单**合并发射时不做探活**。⚠️ 现状缺口（v1.87.1 如实登记）：宿主**没装**
+*    `dsh-tool-schedule` 时，这 4 个名字会把整次 restrict 拒掉，而退档只保留 ACC 自己的名字
+*    ⇒ 这一格的屏蔽**不生效**（旧实现同样不生效，**未回归**；但"顺带修好了"这句是假的，已删）。
 */
 const HOST_SCHEDULE_TOOL_NAMES = [
 	"schedule_create",
@@ -12177,42 +12283,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 隐藏**的专属工具清单。
 *
@@ -12222,156 +12292,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）。
 *
@@ -12395,74 +12315,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);
@@ -13764,7 +13616,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);
@@ -13832,15 +13684,8 @@ function registerContext(ctx, opts = {}) {
 		}
 		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);
@@ -13857,31 +13702,14 @@ 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);
 		}
@@ -14478,11 +14306,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./route-GtYJdR06.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-GtYJdR06.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);
@@ -14519,7 +14347,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-GtYJdR06.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, {
@@ -14540,7 +14368,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./route-GtYJdR06.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);
@@ -14566,7 +14394,7 @@ function registerStatusApi(ctx, opts = {}) {
 							trajectory: code
 						});
 					}
-					const { saveWeixinRoutes } = await import("./route-GtYJdR06.js").then((n) => n.c);
+					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})` });
@@ -14578,7 +14406,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./route-GtYJdR06.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) {
@@ -14601,7 +14429,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "appId 与 appSecret 都必须填（只填一个等于没绑）" });
 						return;
 					}
-					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-GtYJdR06.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);
@@ -14651,7 +14479,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./ilink-BMk2w2KY.js").then((n) => n.a);
-				const { readWeixinSettings } = await import("./route-GtYJdR06.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,
@@ -14666,7 +14494,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-GtYJdR06.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, {
@@ -21152,20 +20980,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 {}

package/lib/{route-GtYJdR06.js → route-3OzOAjec.js}

@@ -423,4 +423,4 @@ function setWeixinEnabled(root, enabled) {
 	return next;
 }
 //#endregion
-export { readFeishuCredential as a, route_exports as c, weixinSessionIdForTrajectory as d, matchWeixinRoute as i, sanitizeFileName as l, extractWeixinText as n, readWeixinCredential as o, hasVoiceItem as r, readWeixinSettings as s, extractWeixinMedia as t, weixinInboundDir as u };
+export { readFeishuCredential as a, readWeixinSettings as c, weixinInboundDir as d, weixinSessionIdForTrajectory as f, matchWeixinRoute as i, route_exports as l, extractWeixinText as n, readImSettings as o, hasVoiceItem as r, readWeixinCredential as s, extractWeixinMedia as t, sanitizeFileName as u };

package/lib/seams/guards.d.ts

@@ -10,6 +10,7 @@ import type { Context } from 'cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import { type BlacklistRule } from '../kernel/ccc.js';
 import { type TrajectoryConstraint } from '../trajectory/policy/profile.js';
+import { type VisibilitySource } from './tool-visibility.js';
 export interface GuardInput {
     root: string;
     toolName: string;
@@ -39,6 +40,39 @@ interface GuardDecisionResult {
  * 优先级：safe-mode bash > 路径越界 > 黑名单命中。
  */
 export declare function decideGuard(input: GuardInput): GuardDecisionResult;
+/**
+ * 🔴 **工具可见性的唯一发射入口**（方案 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 工具
+ */
+export declare function syncToolVisibility(agent: Agent, root: string | null): void;
+/**
+ * 六源 → 各自的 deny 集合（**纯函数：只读配置、不碰宿主**）。
+ *
+ * 每条来源**自己负责自己的失败**：抛错就 catch 在这里，转成 `ok:false + error`。
+ * ⛔ 绝不让一个来源的异常冒泡 —— 那会让另外五源一起失效（正是合并最容易犯的错）。
+ */
+export declare function computeVisibilitySources(sessionId: string, root: string | null): VisibilitySource[];
 /** restrict 诊断状态（status API 暴露；排查 restrict 未生效问题） */
 interface RestrictDiagnostics {
     lastKey: string | null;
@@ -51,53 +85,28 @@ interface RestrictDiagnostics {
 }
 export declare function getRestrictDiagnostics(): RestrictDiagnostics;
 /**
- * 同步安全模式工具隐藏：标记存在 → `agent.ctx.tools.restrict deny` 隐藏
- * **基础表（bash）∪ CCC 声明的 `safeMode.hiddenTools`**；标记消失 → 全部解除。
- * pre-step 每步调用 ⇒ 开／关／**改声明**三种变化都实时生效（v1.51.4 起含"改声明"）。
+ * im-bridge 隐藏诊断（排查"工具为什么不在清单里"）。
  *
- * 与 `readSafeModeHiddenTools` 的分工（R↓）：本函数负责**形状与失败退化**，reader 只管取值。
- * 🔴 退化规则：DSH 契约规定 **未注册的工具名会让整次 restrict 失败**（"unknown names … fail"）
- * ⇒ 绝不能让 CCC 写错一个名字就丢掉 safe-mode 的核心隐藏（bash）。失败时退化为**只隐藏基础表**，
- * 并在日志响亮报错；退化态**按期望签名记账**，不会每步重试刷屏。
+ * 🔴 方案 C 之后**唯一真相源**是 `seams/tool-visibility.ts` 的全局表。
+ * 本函数只**读**它并回答"该会话当前是否隐藏了 im-bridge" ——
+ * 不再自己维护第二份状态（那会让诊断与实现各说一套，D164 同族）。
  */
-export declare function syncSafeModeRestriction(agent: Agent, root: string): void;
-/** im-bridge 隐藏诊断（排查"工具为什么不在清单里"） */
 export declare function getImBridgeVisibilityDiagnostics(): {
     hiddenKeys: string[];
 };
 /**
- * 同步 im-bridge 可见性（v1.31.0，S142 用户拍板 Q3「未配置则不可见」）。
- *
- * 判据 = 本会话 CCC 是否启用了**任一** IM 通道（`hasEnabledImChannel`，当前只有 weixin）：
- * - 未启用 → `agent.ctx.tools.restrict({ deny: ['im-bridge'] })`：**从 schema 移除**
- *   （模型看不到，而不是看得到但调用被拒——用户原话"不配置则不可见"）
- * - 启用 → 解除隐藏（CCC 配置热更新即时生效）
+ * 会话销毁清理（lifecycle 调用）。
  *
- * 与 `syncSafeModeRestriction` 同点调用（pre-step 每步 + 会话就绪），失败不阻断
- * （守卫仍兜底；restrict 不可用时最坏是"看得到但通道未配置 → 返回 CHANNEL_NOT_CONFIGURED"）。
+ * ⚠️ 方案 C 后撤销动作**只在** `forgetToolVisibility` 里做一次（那一次合并 restrict）。
+ * 本函数保留为语义占位：重复撤销同一条 restrict 会抛错，故这里刻意不做动作。
  */
-export declare function syncImBridgeVisibility(agent: Agent, root: string): void;
-/** 会话销毁清理（lifecycle 调用；防 per-会话 Map 无界增长——review F-08 同族） */
-export declare function forgetImBridgeVisibility(sessionId: string): void;
+export declare function forgetImBridgeVisibility(_sessionId: string): void;
 /** 诊断面：本会话已屏蔽的宿主定时器工具（排查"工具为什么不见了"） */
 export declare function getHostScheduleHiddenDiagnostics(): {
     hidden: string[];
 };
-/**
- * 在 **CCC 内**屏蔽宿主自带的定时器工具（v1.59.5）。
- *
- * 判据 = **会话是否落在某个 CCC 内**（`root !== null`）——与 `syncCccToolVisibility` 互补：
- * 那个管"不在 CCC ⇒ 隐藏**我们自己的**全部工具"，本函数管"**在** CCC ⇒ 隐藏**宿主的**定时器工具"。
- *
- * 幂等；失败不阻断 step（最坏 = 那一个工具仍可见，但那只是"宿主的正常能力没被藏起来"，
- * 不会让会话坏掉）。逐个名字独立发 restrict ⇒ 任何一个名字不在册都不会连累其余三个。
- *
- * @param agent 目标会话
- * @param root  该会话的 CCC 根；`null` ⇒ 非 CCC ⇒ **不动**（宿主的定时器在别处是正常能力）
- */
-export declare function syncHostScheduleToolHiding(agent: Agent, root: string | null): void;
-/** 会话销毁清理（lifecycle 调用；按 `${sessionId}::` 前缀回收） */
-export declare function forgetHostScheduleToolHiding(sessionId: string): void;
+/** 会话销毁清理（lifecycle 调用）——方案 C 后由统一清理撤销，这里保留语义占位。 */
+export declare function forgetHostScheduleToolHiding(_sessionId: string): void;
 /** 专属工具隐藏诊断（排查"工具为什么不在清单里"） */
 export declare function getExclusiveToolsDiagnostics(): {
     hidden: string[];
@@ -107,62 +116,17 @@ export declare function getTrajectoryConstraintVisibilityDiagnostics(): {
     keys: string[];
     denyByKey: Record<string, string[]>;
 };
-/**
- * 同步 **轨迹约束会话的工具面**：把白名单之外的工具**从 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 根
- */
-export declare function syncTrajectoryConstraintToolVisibility(agent: Agent, root: string): void;
-/** 会话销毁清理（lifecycle 调用） */
-export declare function forgetTrajectoryConstraintToolVisibility(sessionId: string): void;
-/**
- * 同步专属工具可见性（v1.33）。
- *
- * 判据 = CCC 配置 `exclusiveTools`（`readExclusiveTools`）：
- * - **未声明** → `agent.ctx.tools.restrict({ deny: [tool] })`：从 schema 移除（模型看不到）
- * - **声明** → 解除隐藏（CCC 配置热更新即时生效）
- *
- * 判据失败按"未声明"处理（fail-closed：专属工具默认隐藏），原因见 `readExclusiveTools` 注释。
- * 与 `syncImBridgeVisibility` 同点调用（pre-step 每步 + 会话就绪），失败不阻断一步——
- * 最坏情况是"看得到但被拒"，而不是让 step 出错。
- */
-export declare function syncExclusiveToolsVisibility(agent: Agent, root: string): void;
-/** 会话销毁清理（lifecycle 调用；本函数按 `${sessionId}::` 前缀回收全部专属工具项） */
-export declare function forgetExclusiveToolsVisibility(sessionId: string): void;
+/** 会话销毁清理（lifecycle 调用）。
+ * ⚠️ 方案 C 后撤销只在 `forgetToolVisibility` 做一次；本函数保留语义占位。
+ * 留着它的价值：lifecycle 的调用点表达"这条会话有轨迹约束可见性状态要清"，
+ * 删掉调用点会让那件事**从代码里消失**（将来有人重加机制时找不到插点）。 */
+export declare function forgetTrajectoryConstraintToolVisibility(_sessionId: string): void;
+/** 会话销毁清理（lifecycle 调用）——同上，语义占位。 */
+export declare function forgetExclusiveToolsVisibility(_sessionId: string): void;
 /** 非 CCC 隐藏诊断（排查"工具为什么不见了"） */
 export declare function getNonCccHiddenDiagnostics(): {
     hidden: string[];
 };
-/**
- * 同步「本会话在不在 CCC 内」的工具可见性（v1.56.6）。
- *
- * @param agent 目标会话的 agent
- * @param root 该会话的 CCC 根；`null` ⇒ **不在任何 CCC 内** ⇒ 隐藏全部 ACC 工具
- *
- * 幂等：同一会话重复调用不会重复 restrict（已是目标态即直接返回）。
- * 失败不抛（最坏情况：工具可见，但**调用时**仍被各工具自己的根解析拒绝——既有兜底不变）。
- */
-export declare function syncCccToolVisibility(agent: Agent, root: string | null): void;
 /** 会话销毁清理（lifecycle 调用；防 per-会话 Map 无界增长） */
 export declare function forgetNonCccToolVisibility(sessionId: string): void;
 interface GuardRegistration {

package/lib/seams/tool-visibility.d.ts

@@ -0,0 +1,77 @@
+/** 一次 restrict 的 deny 集合来源（每个来源**独立成败**，互不连累） */
+export interface VisibilitySource {
+    /** 稳定标识（诊断与去重用；例：`safeMode` / `im-bridge` / `hostSchedule`） */
+    readonly id: string;
+    /** 本来源要隐藏的工具名（已去重前的数组；由收集器统一去重） */
+    readonly deny: readonly string[];
+    /**
+     * 本来源的判据是否成立。
+     * - `false` ⇒ 本来源**不贡献** deny（等价于它"没意见"），**不是**错误。
+     * - 读取配置抛错等情况由来源自己决定返回 `false` 还是抛（收集器会捕获并降级）。
+     */
+    readonly ok: boolean;
+    /** `ok=false` 且确实出了错（不是"判据不成立"）时的一句话，用于诊断 */
+    readonly error?: string;
+}
+/** 一次可见性判决（纯数据，可 JSON 化，便于诊断与测试断言） */
+export interface VisibilityDecision {
+    /** 合并后的 deny（已去重、已排序 —— 排序让签名稳定、可比较） */
+    readonly deny: string[];
+    /** 参与判决的来源（含失败的），用于诊断"谁把工具藏了" */
+    readonly sources: readonly VisibilitySource[];
+    /** 是否有任一来源报错（决定要不要打日志；**不影响** deny 的计算） */
+    readonly hasError: boolean;
+}
+/**
+ * 🔴 本模块的**准入契约**：可见性判决只允许用 `deny`。
+ *
+ * 宿主 `restrict` 同时支持 `allow` 与 `deny`，而**两者不可混用合并**：
+ * `allow: A₁` 与 `allow: A₂` 的交集是 `A₁ ∩ A₂`，**不是并集**。
+ * ⇒ 若将来某个来源想"只保留某几个工具"，它**不能**塞进本模块，
+ * 必须自己单独发一条 restrict（那条会与本次的 deny 正常求交）。
+ * 该常量是这条契约的**机器可读声明**（测试据此钉住）。
+ */
+export declare const TOOL_VISIBILITY_DENY_ONLY = true;
+/** 收集器：把各来源的 deny 合并成一个判决（**纯函数、无副作用**） */
+export declare function collectVisibilityDecision(sources: readonly VisibilitySource[]): VisibilityDecision;
+/** 判决签名（幂等判据：签名相同 ⇒ 目标态已达到 ⇒ **一次 restrict 都不发**） */
+export declare function decisionSignature(decision: VisibilityDecision): string;
+/** 诊断：当前每个会话的可见性状态（排查"某工具为何不可见"） */
+export declare function getToolVisibilityDiagnostics(): {
+    keys: string[];
+    denyByKey: Record<string, string[]>;
+};
+/**
+ * 发射一次判决（**唯一的写点**）。
+ *
+ * 三条纪律：
+ * ① **幂等**：签名与当前已发射的一致 ⇒ 直接返回 `'unchanged'`，**不碰宿主**
+ *    （这正是消除"工具清单闪动"的那一步）。
+ * ② **先撤后发**：宿主的 disposer 才是"撤销上一次"，先撤再发才不会叠加旧集合。
+ *    （旧集合是新集合的子集时叠不叠都看不出来，但**不是子集时**会残留 —— 必须撤。）
+ * ③ 🔴 **未注册的名字不许炸掉整次发射**：宿主契约"unknown names … fail"。
+ *    合并后集合里只要有一个不在册的名字，整次 restrict 就失败 ⇒ 六个机制**全都不生效**。
+ *    ⇒ 策略 = **直接发 → 全量被拒才退到「只发 ACC 自己注册的那些」一档**，退档时
+ *    把被放弃的名字如实记账（进 `dropped`，由调用方决定要不要告警）。
+ *    ⚠️ **不做 `tools.get` 预探活** —— 那个视图查不出 agent-plane 贡献的工具
+ *    （`bash` / `schedule_*`），会把**在册的名字误判成未注册**（见下方发射段的实测记录）。
+ *    ⚠️ 这比旧行为**更保守**：旧行为是"某条 restrict 失败 ⇒ 那一格静默不生效"，
+ *    新行为是"全量失败 ⇒ 至少 ACC 那一格照常生效" —— **等价或更好**，且总有日志。
+ *
+ * @returns `'unchanged'` ／ `'applied'` ／ `'failed'`（`failed` 时 `deny` 保持原样）
+ */
+export declare function applyVisibilityDecision(agent: {
+    ctx: {
+        tools: {
+            restrict(f: {
+                deny: string[];
+            }): () => void;
+        };
+    };
+}, sessionId: string, decision: VisibilityDecision): {
+    status: 'unchanged' | 'applied' | 'failed';
+    dropped: string[];
+    error?: string;
+};
+/** 会话销毁清理（防 per-会话 Map 无界增长；lifecycle 调用） */
+export declare function forgetToolVisibility(sessionId: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.86.0",
+  "version": "1.87.1",
   "description": "宁静号 ACC harness（Native Cordis 插件）——给 DeepSeek Harness 装一个「AI 工作区」：14 个工具（container_fs/cognitive_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫/对外输出守卫）+ 认知轨迹日志与原地重建 + 网页登录入口/IM 桥/认知轨迹唤醒注册表。轨迹声明 = 轨迹目录下的 trajectory.json（约束面 + 旧标识 uid + CRO 机器绑定 cro.host；旧名 trajectory-constraint.json / skiff.json 仍在读取族里）；轨迹提示词 = 轨迹目录下的 PROMPT.md（一条轨迹「是谁、按什么章程工作」，所有轨迹通用，追加在容器层与质量层之后，不替换它们）。适配 DSH 0.1.7-rc.1 / 0.2.0-rc.1 / 0.2.1-rc.1（三档）。",
   "license": "MIT",
   "repository": {