@shgroup/dsh-serenity-hooks 1.89.0 → 1.91.0

package/lib/index.js

@@ -4,17 +4,17 @@ import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as
 import { A as namingTitleFor, B as summarize, C as createSession, E as getActiveSessionInfo, F as resolveSessionByTitle, G as readTrajectoryFile, H as useSession, I as sessionEvents, J as localHuman, K as isoLocal, L as sessionsRoot, M as parseTrajectoryCode, O as listActiveTrajectories, P as readTrajectoryUid, R as setActiveSessionInfo, S as clearActiveSessionInfo, T as findSession, U as TRAJECTORY_FILENAME, V as trajectoryDescOf, W as TRAJECTORY_LEGACY_FILENAMES, Y as localIdStamp, b as UID_FILENAME, c as replacesDefaultIdentity, i as listTrajectoryConstraints, j as parseSessionContextFromEvents, k as listSessions, l as trajectoryCodeForSession, n as findDirNameByCode, o as readTrajectoryConstraintAt, q as localFileStamp, r as isTrajectoryConstrained, s as readTrajectoryConstraintByCode, t as TRAJECTORY_CONSTRAINT_FILENAME, u as trajectoryConstraintForSession, v as COGNITIVE_TRAJECTORY_ACTIONS, w as extractSessionMdPathFromText, x as archiveSession, z as showSession } from "./profile-zxakCNXy.js";
 import { n as checkLocalstoreGitCompliance, o as readStore, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./service-DDmHSglV.js";
 import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-BAMwXu6i.js";
-import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-Bb4GSSFJ.js";
+import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-D5cEPEUY.js";
 import { i as sessionsRootDir, n as findSessionLog, r as hasSessionLogById } from "./cleanup-CPl1SSaK.js";
-import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-DAorSseV.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 { i as runImBridge, n as isImWiredTrajectory, o as readSimpleSettings, r as registerImChannel, s as registerSettingsSection, t as imChannelIds } from "./channels-CuCsUfcY.js";
+import { a as readFeishuCredential, c as readWeixinSettings, d as weixinInboundDir, f as weixinSessionIdForTrajectory, i as matchWeixinRoute, n as extractWeixinText, r as hasVoiceItem, s as readWeixinCredential, t as extractWeixinMedia, u as sanitizeFileName$1 } from "./route-DxIKWeN9.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-CsZ-f64q.js";
 import { a as registerImAccountImpl, i as normalizeAccountChannel, n as getImAccountImpl, r as imAccountChannels } from "./accounts-BHQbakUh.js";
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { appendFileSync, chmodSync, closeSync, cpSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import { homedir, hostname, platform } from "node:os";
@@ -1373,36 +1373,30 @@ CCC 级微信个人号接入（iLink 协议）：dsh 一进程多 CCC，每 CCC
     历史（v1.30.9~v1.30.x）：CCC 侧 MSM weixin-send（走 loopback HTTP 入口 3082）——
     v1.31.0 已退役（脚本删除 + 注册表注销）；3082 入口保留给**非 agent 调用者**。
 
-  ▸ weixin.autoReplyWithLastMessage（v1.30.10，关闭桥的自动输出）：
-    缺省 true = 现状：桥在 agent 一轮结束后把**最终 assistant 文本**自动回发用户（source="reply"）。
-    显式 false = 关闭：桥**不再转发最终文本**，输出权交给 agent——每轮在用户消息**末尾**追加
-    **机制标记** [serenity:weixin-manual-output] + 一行已填好参数的 im-bridge 调用
-    （账号/用户 id），agent 自己决定发什么、发几条（全部记 source="proactive"）。
-    **ACC 只给机制与数据，纪律措辞归 CCC**（v1.30.16）：怎么写/必须怎么做/后果是什么写在
-    CCC 角色提示词文件里（如 .opencode/skiff/<role>.md），可热改（v1.30.15 起角色提示词热重载）。
-    机械闸门（v1.30.16）：本轮 turn 结束仍未成功调用 im-bridge（send / send-file；兼容旧
-    msm("weixin-send") 形态）→ agent 被打回（≤2 次，提示 = 标记 + 事实）；达上限放弃并响亮告警。
-    失败调用不算已送达。
-    语义边界（用户拍板）：只关最终文本；系统类消息（新对话通知 / 语音无法解析提示）保留；
-    typing 指示与 incoming hook 不受影响。
-
-  ▸ weixin.fallbackOnNoSend（v1.30.17，手动模式的**兜底**；缺省 false）：
-    仅在 autoReplyWithLastMessage=false 时生效。true → 一轮结束时若 agent **一次都没成功**
-    调用输出工具（闸门打回用尽），桥把该轮最终文本转发给用户（记录 source="reply-fallback"，
-    日志留响亮告警）——保证"不丢消息"。agent 自己发过 → 不兜底（输出权仍在 agent）。
-    为什么需要（实证）：v1.30.16 闸门会打回 ≤2 次，但实测某模型在**寒暄类消息**上连续 4 轮、
-    跨 3 版 CCC 提示词仍不调工具 → 打回用尽后用户什么都收不到；提示词与闸门均已排除。
-    代价（显式）：角色失去"故意静默"能力（它总会产出一段最终文本）→ 需严格静默的角色保持缺省。
-    三态：① autoReplyWithLastMessage=true（缺省）桥总是回发；② =false + fallbackOnNoSend=true
-    = agent 优先、桥兜底（推荐）；③ 两者皆 false（缺省）= 严格静默（v1.30.10 语义）。
-    ⚠️ 兜底只在**闸门装配成功**时生效（未装配则无法判定是否发送过 → 不冒重复发送风险）。
+  ▸ 🔴🔴 **出站只有一条路：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",
-        "autoReplyWithLastMessage": true,
-        "fallbackOnNoSend": false,
         "accounts": [{ "accountId": "wechat-1", "name": "家庭助手", "enabled": true }],
         "routes": [{ "user": "*", "role": "my-role" }]
       } }
@@ -1414,9 +1408,9 @@ CCC 级微信个人号接入（iLink 协议）：dsh 一进程多 CCC，每 CCC
   触发（双向）：
     incoming  = 用户 → bot：路由命中后、媒体落盘后触发（文本含语音转写；媒体带落盘 relPath）
     outgoing  = bot → 用户：发送成功后触发（reply = 用户实际收到的纯文本，已剥离 think）
-      · source="reply"（缺省）= 回复用户消息；source="proactive"（v1.30.9）= bot 主动发起
-        （CCC 经 im-bridge 工具（v1.31.0；旧 weixin-send MSM 已退役）→ sendProactiveText）；
-        source="reply-fallback"（v1.30.17）= 手动模式下 agent 本轮未发送 → 桥兜底转发最终文本
+      · source="proactive" = agent 经 im-bridge 主动发起（**2026-10-24 起这是唯一值**）
+      · 历史值 reply / reply-fallback（桥自动回发 / 桥兜底转发）已随两个开关一起退役；
+        存量日志里仍能看到它们，那是历史事实，不是当前行为
       · file（仅 send-file 补记）：{ "name": "报告.pdf", "size": 12345, "caption": "可选" }
 
   脚本约定（事件 JSON 单行经 stdin 传入；bun 优先 node 兜底）：
@@ -1431,7 +1425,7 @@ CCC 级微信个人号接入（iLink 协议）：dsh 一进程多 CCC，每 CCC
       "message": { "text": "你好", "media": [{ "kind": "image", "relPath": "_tmp/weixin-inbound/<hash>/img_x.jpg" }] } }
     { "event": "outgoing", "ts": ..., "cccRoot": ..., "accountId": ...,
       "userId": ..., "sessionId": ..., "role": ...,
-      "reply": "已记录（纯文本）", "source": "reply" | "proactive" | "reply-fallback" }
+      "reply": "已记录（纯文本）", "source": "proactive" }
 
   示例脚本（追加到按日文件——持久化归 CCC 自选：文件/DB/远端均可）：
     const fs = require('node:fs'); const p = '/path/ccc/AGENT_SESSIONS/_weixin-log.jsonl';
@@ -1541,6 +1535,51 @@ function hasCliEntry(absPath) {
 	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'` 分支体内**（没有名字、无法从别处取用），
@@ -1748,7 +1787,7 @@ function runMsm(root, args) {
 			throw new Error(`MSM not registered: "${name}"`);
 		}
 		case "ccc-config": return docsPointer("config", "CCC 配置参考");
-		case "check": return checkRegistryQuality(root);
+		case "check": return compactRegistryQuality(checkRegistryQuality(root));
 		default: throw new Error(`Unknown action: ${args.action}`);
 	}
 }
@@ -1938,20 +1977,68 @@ function buildMsmIndex(root) {
 		bySkill.set(k, (bySkill.get(k) ?? 0) + 1);
 	}
 	const groups = [...bySkill.entries()].sort((a, b) => b[1] - a[1]).map(([skill, count]) => `  ${skill}: ${count} MSM`).join("\n");
-	return `${entries.length} MSMs registered (by skill):\n${groups}\n\nExecute: msm("<name>", ["<args>"]) — e.g. msm("ssh-connect", ["status"])\nInspect: msm("<name>", [], inspect=true) — view usage/flags\nPartial name returns matching candidates.\nFull listing: use container_admin (register/deregister/check).`;
+	return `${entries.length} MSMs registered (by skill):\n${groups}\n\nExecute: msm("<name>", ["<args>"]) — e.g. msm("ssh-connect", ["status"])\nInspect: msm("<name>", [], inspect=true) — view usage/flags\nPartial name returns matching candidates.\nRegistry maintenance: container_admin (domain=msm, action=register|deregister|check).`;
 }
 /** 模糊候选：name/description 子串匹配（未精确命中时返回 top-K，供 LLM 下轮选对） */
 function suggestMsm(root, query, limit = 5) {
 	const q = query.toLowerCase();
-	const hits = loadMsmEntries(root).filter((e) => e.name.toLowerCase().includes(q) || (e.description ?? "").toLowerCase().includes(q)).slice(0, limit);
-	if (hits.length === 0) return `No MSM matches "${query}". Registered: ${buildMsmIndex(root)}`;
+	const entries = loadMsmEntries(root);
+	const hits = entries.filter((e) => e.name.toLowerCase().includes(q) || (e.description ?? "").toLowerCase().includes(q)).slice(0, limit);
+	if (hits.length === 0) {
+		const skills = new Set(entries.map((e) => e.skill ?? "uncategorized"));
+		return `No MSM matches "${query}" (${entries.length} registered across ${skills.size} skills).\nTry a shorter fragment, e.g. msm("${query.slice(0, 3)}"), or msm() for counts by skill.`;
+	}
 	const lines = hits.map((e) => {
-		const base = `${e.name} | ${e.skill ?? "-"} | ${e.category ?? "-"} | ${e.description ?? ""}`;
+		const base = `${e.name} | ${e.skill ?? "-"} | ${e.category ?? "-"} | ${shortDesc(e.description)}`;
 		const flags = (e.flags ?? []).map((f) => `--${f.name} <${f.type ?? "string"}>`).join(", ");
 		return flags ? `${base} [flags: ${flags}]` : base;
 	});
 	return `No exact MSM "${query}" — did you mean one of these?\n` + lines.join("\n");
 }
+/**
+* 候选行的**描述截断**（D237：其它调用的"简练结构"那一档）。
+*
+* 判据 = **「帮不帮得了下决定」**：选哪个 MSM 靠前半句的分句就够，后面那些
+* 「子命令清单 / 设计取舍 / 历史沿革」属于**选中之后**才需要的细节（`inspect=true` 给全）。
+* 实测：一条候选描述可达 200+ 字，5 条候选就能吃掉大半屏。
+*
+* ⚠️ 截断点选**分号/句号/破折号**这类天然断句符，不做"每 N 字硬切"——硬切会把词切两半
+*    （中文尤其明显），反而降低可读性。
+*
+* 🔴 **实现更正（自查抓到）**：初版先 `slice(0, max)` 再在里面找断句符 ⇒ 当第一个断句符
+*    出现在很靠前的位置时（如「短说明；后面全是细节」），它落在 `max/3` 之外就被放弃了，
+*    于是退化成硬切 —— **正好违反"在天然断句符处收尾"这条本意**。
+*    ⇒ 正确做法：**先找 max 之后最近的那个断句符**，让它成为截断点（宁可略超 max，
+*      也要停在句读上）；只有在整串都没有断句符时才硬切。
+*/
+function shortDesc(desc, max = 64) {
+	const s = (desc ?? "").trim();
+	if (s === "") return "";
+	if (s.length <= max) return s;
+	const BREAKS = [
+		"；",
+		";",
+		"。",
+		"——",
+		"·",
+		"，",
+		","
+	];
+	const windowEnd = Math.min(s.length, max * 2);
+	let best = -1;
+	for (const brk of BREAKS) {
+		const at = s.indexOf(brk, max);
+		if (at !== -1 && at < windowEnd && (best === -1 || at < best)) best = at;
+	}
+	if (best !== -1) return s.slice(0, best).trimEnd() + "…";
+	let back = -1;
+	for (const brk of BREAKS) {
+		const at = s.lastIndexOf(brk, max);
+		if (at > back) back = at;
+	}
+	if (back >= Math.floor(max / 4)) return s.slice(0, back).trimEnd() + "…";
+	return s.slice(0, max).trimEnd() + "…";
+}
 const msmTool = defineTool({
 	name: "msm",
 	description: "Execute a registered CCC MSM (Mech & Semi-Mech). msm(name, args) runs it directly; name not found returns matching candidates; inspect=true shows usage/flags without running; no args returns a summary index. The full CCC MSM list is discoverable via partial-name matching or the index.",
@@ -10341,13 +10428,39 @@ async function runWakeTick(ctx) {
 * - ⚠️ **本函数任何失败都不得连累既有链路**（设计 §5 铁律）：整体 try/catch 吞掉并留一行日志。
 */
 async function runInterruptedSafetyNet(ctx, root, log) {
+	const s0 = wakeSchedulerState();
+	const tickNow = s0.ticks + 1;
+	const phase = tickNow <= 1 ? "启动首拍" : tickNow <= 3 ? "刚启动窗口" : "常规 tick";
+	const tickTag = `tick=${s0.ticks}(当前第${tickNow}拍·${phase})`;
 	try {
 		const agents = hostAgents(ctx);
 		const sc = hostService(ctx, "sessionController");
-		const liveIds = /* @__PURE__ */ new Set();
-		if (typeof agents?.get === "function") for (const id of collectLiveSessionIdsForSafetyNet(ctx)) liveIds.add(id);
+		/**
+		* 🔴 **A105：live 排除的粒度 =「此刻有没有在跑」，不是「宿主认不认识它」。**
+		*
+		* 修前：`collectLiveSessionIdsForSafetyNet` 取的是 `hostSessions(ctx).list()`
+		* ⇒ 那是**载入状态**（会话对象在本进程里），**不是**轮次状态 ⇒
+		* 一条「已载入、但上一轮被重启打断」的会话会被**误排除**，
+		* 而那恰恰是**最该被接走**的一类（2026-10-23 实测：这正是那次 13 分钟盲窗的形状）。
+		*
+		* ⇒ 现在与权威 `interrupted` 动作**用同一个取数口**（`listRunningSessionIds`），
+		*   两处对"在跑"的认知**不可能再不一致**（A105 的全部目的就是这一条）。
+		*/
+		const liveIds = new Set(listRunningSessionIds(Date.now()));
 		const scan = scanInterruptedSessions(`${sessionsRootDir()}/${projectDirNameForCwd(root)}`, { liveIds });
-		if (scan.sessions.length === 0) return;
+		/**
+		* 🔴 **A106：无命中也要出声**（`ok`/`fail`/`not-ready`/`no-wake` 之后缺的第五格）。
+		*
+		* 修前这里 `return`，**一行都不写** ⇒ 宿主日志里没有任何「中断兜底」字样 ⇒
+		* **「我扫了、没东西」与「我没被跑」在读数上完全一样**（D216 同族第四次）。
+		* ⇒ 判据同 A102：**可以不出声地判"没事"，但"判过"本身要留痕**。
+		* ⚠️ 密度很低（每 tick 一行，5min 一次），且**必须带拍号与扫描读数**，
+		*   否则又是一堆分不清是哪一拍的日志行（guard 明确要求）。
+		*/
+		if (scan.sessions.length === 0) {
+			log.push(`· ${root}: 中断兜底 ${tickTag} → 扫 ${scan.scanned} 个 · 命中 0 · 排除在跑 ${liveIds.size} 个 · 跳过 ${scan.skipped} ⇒ 无需注入`);
+			return;
+		}
 		const resumeOne = createResumeOne({
 			agents,
 			sessionController: sc,
@@ -10359,6 +10472,7 @@ async function runInterruptedSafetyNet(ctx, root, log) {
 				source: PLUGIN_SOURCE
 			})
 		});
+		log.push(`· ${root}: 中断兜底 ${tickTag} → 扫 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 排除在跑 ${liveIds.size} 个`);
 		for (const hit of scan.sessions) try {
 			const out = await resumeOne(hit);
 			log.push(`· ${root}: 中断兜底 ${hit.sessionId}（turn ${hit.turn ?? "?"}）→ ` + (out.ok ? `已注入（${out.how ?? "?"}）` : `未注入：${out.error ?? "未知"}`));
@@ -10366,18 +10480,20 @@ async function runInterruptedSafetyNet(ctx, root, log) {
 			log.push(`· ${root}: 中断兜底 ${hit.sessionId} 注入抛错（已忽略）：${String(err?.message ?? err)}`);
 		}
 	} catch (err) {
-		log.push(`· ${root}: 中断兜底整体失败（已忽略，不影响既有链路）：${String(err?.message ?? err)}`);
+		log.push(`· ${root}: 中断兜底 ${tickTag} 整体失败（已忽略，不影响既有链路）：${String(err?.message ?? err)}`);
 	}
 }
-/** 取容器内**全部** live 会话 id（best-effort，取不到就少排除几个）。 */
-function collectLiveSessionIdsForSafetyNet(ctx) {
-	const out = [];
-	try {
-		const list = hostSessions(ctx)?.list?.() ?? [];
-		for (const s of list) if (typeof s?.id === "string" && s.id) out.push(s.id);
-	} catch {}
-	return out;
-}
+/**
+* ⚠️ **2026-10-23 A105 已删除 `collectLiveSessionIdsForSafetyNet`。**
+*
+* 它取的是 `hostSessions(ctx).list()` =「宿主认不认识」，而 A105 的结论是
+* 判据必须是「**此刻有没有在跑**」。现在两处（本兜底与权威 `interrupted` 动作）
+* 都走 `listRunningSessionIds()` —— **同一张表、同一个口径**，不可能再打架。
+*
+* 🔴 后人若要"把 live 表也加回来做双保险"：**不要** ——
+*    `live ∧ ¬running` 恰是「已载入、但上一轮被打断」那一类，**它最该被接走**；
+*    加回来就是把最该救的那一格重新排除掉。
+*/
 /**
 * 装配调度器（index.ts apply 调用）：5min tick + 生命周期 disposer +
 * 会话出现/settings 变化时热启动（与 autopilot 同款触发面，互不干扰）。
@@ -10728,85 +10844,6 @@ function listResident(root) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/trajectory/live.ts
-/**
-* trajectory/live.ts — 进程内 live 会话取数 + 精简诊断
-*
-* ── 为什么单独成模块（R↓，2026-09-15 S142「ACC 侧 autopilot 退场」S1 搬迁）──
-* 这两个函数原先住在 `autopilot-trajectory.ts`，但它们的**主语不是 autopilot**：
-* `listLiveSessions` 服务 `acc-diag` ① 段的"**哪个会话属于哪个 CCC**"（会话维度，
-* 不是 CCC 维度），而"**独立进程看不到运行时**"正是 `acc-diag` 存在的理由。
-* autopilot 退场后它们必须活下去 ⇒ 独立成模块，不再挂着已死机制的名字。
-*
-* ── 迁移边界（不搬什么，以及为什么）──────────────────────────────────────
-* 原 `diagLive` 还含两段，**均不搬**（其主语是 autopilot，随机制退场）：
-*   · `autopilotCccs`（逐 CCC 目标命中 / agent 定位诊断）—— 依赖 `readAutopilotSettings` /
-*     `getAutopilotStatus` / `resolveTargetAgent`
-*   · `panelResolved`（无参面板请求落到哪个 CCC）—— 面板区块随机制退场
-* 留下的 = **进程 cwd/CCC + live 会话清单**（`acc-diag` ① 段仍需要）。
-*
-* 判据纪律：本模块**不得**反向依赖 autopilot 判据层（那会让退场半途而废）。
-*
-* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
-* **本模块的 `ctx` 参数类型从 `Context` 改为 `unknown`** —— 消除本文件唯一的 `W2` 接触
-* （直接 import 宿主 `cordis` 的类型）。
-*
-* **为什么这是"真解耦"而不是"把类型藏起来"（判据）：** `ctx` 在本模块**从不被解引用** ——
-* 它只被**原样透传**给 `hostSessions(ctx)`，而后者（`host/access.ts`，**L0**）的参数
-* 本就声明为 `ctx: unknown` ⇒ `Context` 这个 import **在语义上是多余的**，
-* 它没有参与任何类型检查，只贡献了一处 L1→宿主 的接触点。
-* 🔵 **证据**：grep 本文件 `ctx` 全部 5 处命中 —— 3 处在参数/调用位、2 处在注释，
-* **零处**属性访问（`ctx.xxx`）。
-*/
-/**
-* 从 dsh 会话 log 读取标题（latest-wins `session/title` 事件）——
-* **标题不在 `sessions.list()` 条目上**（wire/对象均无 title 字段；F3 命名经
-* `sessionTitle.rename` 写进 session log），必须从 events 提取（rebuild 同款读取模式）。
-*/
-function readSessionTitle(session) {
-	try {
-		const events = sessionEvents(session);
-		for (let i = events.length - 1; i >= 0; i--) {
-			const e = events[i];
-			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
-		}
-	} catch {}
-	return null;
-}
-/**
-* 逐条 live 会话（`cccRoot` = 该会话 cwd 的 CCC 归属，无 → null）。
-*
-* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
-* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
-*
-* @param ctx 插件上下文（**只透传**给 L0 取数口，本模块不解引用 ⇒ 类型为 `unknown`）
-* @returns 逐条 live 会话
-*/
-function listLiveSessions(ctx) {
-	const out = [];
-	try {
-		const sessions = hostSessions(ctx);
-		for (const s of sessions?.list?.() ?? []) {
-			const cwd = s?.header?.cwd ?? null;
-			out.push({
-				id: s?.id ?? "",
-				cwd,
-				cccRoot: cwd ? cccRootForCwd(cwd) : null,
-				title: readSessionTitle(s)
-			});
-		}
-	} catch {}
-	return out;
-}
-function diagLive(ctx) {
-	const processCwd = process.cwd();
-	return {
-		processCwd,
-		processCcc: cccRootForCwd(processCwd),
-		liveSessions: listLiveSessions(ctx)
-	};
-}
-//#endregion
 //#region src/tools/cognitive-trajectory.ts
 /**
 * trajectory.ts — `cognitive_trajectory` 真实 DSH 工具定义（defineTool）
@@ -10848,17 +10885,44 @@ function diagLive(ctx) {
 * 活跃会话跟踪：内存 Map（按 dsh 会话 id 隔离）+ 从 events 恢复（S134）。
 */
 /**
-* 当前宿主里**正在跑**的 dsh 会话 id（用于把 live 会话排除出"待续"名单）。
+* 当前**正在跑轮次**的 dsh 会话 id（用于把 live 会话排除出"待续"名单）。
 *
 * 🔴 **为什么必须排除**：一个正在跑的会话，其日志末条**不是** `session/end-seed`
 * （它还在写），所以按判据本来也不会命中；但排除是**双保险** ——
 * 万一某轮刚被中断、宿主还没来得及继续，把 live 会话当"待续"会导致**重复投递**。
-* 拿不到 live 列表时退化为空集（不阻断扫描，只少一层保护）。
+*
+* ── 🔴🔴 2026-10-23 A105：**从「live 表」改为「在跑表」，且从 `ctx` 取数** ──────────
+*
+* **修前有两个缺陷，叠在一起让这段排除在生产上形同虚设：**
+*
+* ① **`ctx` 传的是 `undefined`** ⇒ `listLiveSessions(undefined)` ⇒ `hostSessions(undefined)`
+*    ⇒ 取不到宿主 ⇒ **live 表恒空** ⇒ `scanInterruptedSessions` 的 `liveIds` 是空集。
+*    ⚠️ 原注释写「ctx 在 execute 里拿不到（本工具只拿到 exec）」，**那句是错的**：
+*    本工具的工厂 `createCognitiveTrajectoryTool(ctx)` **闭包捕获了真 ctx**，
+*    且同文件的 `continue-all-interrupted` 分支早就靠它取 `hostAgents(ctx)` / `hostService(ctx,…)`
+*    —— 见那一支的注释「**必须用工厂参数 `ctx`，不能用 `exec`**」。**同一份源码里，
+*    一处说"拿不到"、另一处说"必须用它"**，这正是两个读数打架的典型形态。
+*
+* ② **粒度错了：`live ≠ 在跑`。** `listLiveSessions` 答的是「宿主认不认识这个会话」
+*    （会话对象已载入本进程），**不是**「它此刻有没有轮次在跑」。
+*    ⇒ 一条**已载入但空闲**的会话会被误排除 ⇒ **它恰恰是"上一轮被重启打断、最该被接走"的那一类**。
+*    2026-10-23 实测：同一时刻 `acc-diag` 把一条会话列为 live，而本动作把它当命中扫出 ⇒
+*    两个口径两个答案；随后真机证明那条会话当时**确实该被接走**。
+*
+* ⇒ **现在答的是「此刻有没有在跑」**，取数口 = `listRunningSessionIds(nowMs)`（`cro/turns.ts`）：
+*   由 `agent/status=running` 置位、`idle` 清位，`TURN_TTL_MS` 兜底。
+*
+* 🔴 **不要再改回「宿主认不认识它」** —— 这是本函数最容易被"改得更省事"而改回去的地方。
+*    「宿主认识」是**载入状态**，「在跑」是**轮次状态**，两者互不蕴含：
+*    载入而空闲（该接走）、在跑但刚被中断（该接走）、在跑且健康（才该排除）。
+*    只有第三格该排除 ⇒ 判据必须是轮次状态。
+*
+* 拿不到 running 表时退化为空集（不阻断扫描，只少一层保护）—— 与修前同口径。
 */
-function collectLiveSessionIds() {
+function collectRunningSessionIds(nowMs) {
 	const out = /* @__PURE__ */ new Set();
 	try {
-		for (const s of listLiveSessions(void 0)) if (typeof s.id === "string" && s.id) out.add(s.id);
+		for (const id of listRunningSessionIds(nowMs)) if (typeof id === "string" && id) out.add(id);
 	} catch {}
 	return out;
 }
@@ -11380,7 +11444,7 @@ function createCognitiveTrajectoryTool(ctx) {
 						lookbackHours,
 						scan: scanInterruptedSessions(projectDir, {
 							lookbackMs: lookbackHours * 36e5,
-							liveIds: collectLiveSessionIds()
+							liveIds: collectRunningSessionIds(Date.now())
 						})
 					});
 				}
@@ -11404,7 +11468,7 @@ function createCognitiveTrajectoryTool(ctx) {
 					const projectDir = join(sessionsRootPath, projectDirNameForCwd(cwdRead));
 					const scan = scanInterruptedSessions(projectDir, {
 						lookbackMs: lookbackHours * 36e5,
-						liveIds: collectLiveSessionIds()
+						liveIds: collectRunningSessionIds(Date.now())
 					});
 					if (dryRun) return renderContinueResult({
 						projectDir,
@@ -12278,460 +12342,6 @@ function createContainerAdminTool(ctx) {
 	});
 }
 //#endregion
-//#region src/im/log-scan.ts
-/**
-* im/log-scan.ts — 读聊天记录落盘，汇总出「与谁有过往来」（`contacts` 的数据源）
-*
-* ## 这个文件解决什么
-*
-* owner 2026-10-22：「配路由需要的是**账户到轨迹**，轨迹 CCC 知道，**账户 CCC 不知道**，
-* 需要有个能力让 CCC 查询用户配好的账户」。这里的"账户"= **通道用户**（对方是谁），
-* 不是 IM 账号（我们自己登录的身份，`status` 早就能查）。
-*
-* 那个 id（微信 `xxx@im.wechat` / 飞书 `ou_…`）不在任何配置文件里 ——
-* 它**只在聊天记录里出现过**。⇒ 本文件把记录读成联系人表。
-*
-* ## 🔴 两条硬边界
-*
-* 1. **只读**：本文件不写任何东西。真相源仍是那些 jsonl（append-only 事件流），
-*    本文件只是它的一次投影 —— ⛔ 不产生第二真相源。
-* 2. **不猜渠道**：事件的 `channel` 字段为准；缺它（存量事件）⇒ 按
-*    `accountId → im.accounts[].channel` 回填，仍取不到才落 `weixin`
-*    （那是该字段存在之前唯一的渠道）。⛔ **绝不按 userId 的形状猜**
-*    （`ou_` 前缀 / `@im.wechat` 后缀都是命名习惯，不是判据 —— D167 认族不认名）。
-*/
-/** 日志根目录族（**新旧两代并存**：`_im-logs/<channel>/` 与存量 `_weixin-logs/`） */
-const IM_LOG_DIR_NEW = "_im-logs";
-const IM_LOG_DIR_LEGACY = "_weixin-logs";
-/** 某 CCC 下**存在**的日志目录（相对根），新代在前 */
-function imLogRoots(root) {
-	const out = [];
-	const newBase = join(root, "AGENT_SESSIONS", IM_LOG_DIR_NEW);
-	const legacy = join(root, "AGENT_SESSIONS", IM_LOG_DIR_LEGACY);
-	if (existsSync(newBase)) out.push(join("AGENT_SESSIONS", IM_LOG_DIR_NEW));
-	if (existsSync(legacy)) out.push(join("AGENT_SESSIONS", IM_LOG_DIR_LEGACY));
-	return out;
-}
-/** 收集某个日志根下所有 `*.jsonl`（含 `_im-logs/<channel>/` 一层；按文件名排序） */
-function jsonlFilesIn(root, rel) {
-	const abs = join(root, rel);
-	const out = [];
-	let entries = [];
-	try {
-		entries = readdirSync(abs, { withFileTypes: true }).map((d) => d.name);
-	} catch {
-		return out;
-	}
-	for (const name of entries.sort()) {
-		if (name.startsWith(".")) continue;
-		if (name.endsWith(".jsonl")) {
-			out.push(join(rel, name));
-			continue;
-		}
-		if (rel === join("AGENT_SESSIONS", "_im-logs")) {
-			const sub = join(rel, name);
-			try {
-				for (const child of readdirSync(join(root, sub)).sort()) if (child.endsWith(".jsonl")) out.push(join(sub, child));
-			} catch {}
-		}
-	}
-	return out;
-}
-/** 从文件名 / 所在目录猜渠道（**只作为回填的最后一级**，不是判据） */
-function channelFromPath(rel) {
-	const parts = rel.split("/");
-	const idx = parts.indexOf(IM_LOG_DIR_NEW);
-	const candidate = idx >= 0 && parts.length > idx + 2 ? parts[idx + 1] : void 0;
-	return candidate !== void 0 && candidate !== "" ? candidate : null;
-}
-/**
-* 扫描本 CCC 的全部聊天记录，按 `(channel, userId)` 汇总。
-*
-* @param root CCC 根
-* @param accountChannel 存量事件缺 `channel` 时的回填表（`accountId → channel`）
-* @returns 汇总结果 ＋ **扫描域** ＋ 读取错误（三者都不可省）
-*/
-function scanImContacts(root, accountChannel = {}) {
-	const byKey = /* @__PURE__ */ new Map();
-	const sources = [];
-	const errors = [];
-	for (const rel of imLogRoots(root)) for (const fileRel of jsonlFilesIn(root, rel)) {
-		sources.push(fileRel);
-		let text = "";
-		try {
-			text = readFileSync(join(root, fileRel), "utf8");
-		} catch (err) {
-			errors.push(`${fileRel}: ${err instanceof Error ? err.message : String(err)}`);
-			continue;
-		}
-		const pathChannel = channelFromPath(fileRel);
-		for (const line of text.split("\n")) {
-			const trimmed = line.trim();
-			if (trimmed === "") continue;
-			let ev;
-			try {
-				ev = JSON.parse(trimmed);
-			} catch {
-				errors.push(`${fileRel}: 有 1 行不是合法 JSON（已跳过）`);
-				continue;
-			}
-			const userId = typeof ev.userId === "string" ? ev.userId.trim() : "";
-			if (userId === "") continue;
-			const accountId = typeof ev.accountId === "string" ? ev.accountId.trim() : "";
-			const channel = (typeof ev.channel === "string" && ev.channel.trim() !== "" ? ev.channel.trim() : null) ?? pathChannel ?? (accountId !== "" ? accountChannel[accountId] ?? null : null) ?? "weixin";
-			const key = `${channel}\u0000${userId}`;
-			let entry = byKey.get(key);
-			if (!entry) {
-				entry = {
-					channel,
-					userId,
-					accountIds: [],
-					roleAtEvent: null,
-					firstSeen: null,
-					lastSeen: null,
-					messages: 0
-				};
-				byKey.set(key, entry);
-			}
-			if (accountId !== "" && !entry.accountIds.includes(accountId)) entry.accountIds.push(accountId);
-			if (typeof ev.role === "string" && ev.role.trim() !== "") entry.roleAtEvent = ev.role.trim();
-			const ts = typeof ev.ts === "number" && Number.isFinite(ev.ts) ? ev.ts : null;
-			if (ts !== null) {
-				if (entry.firstSeen === null || ts < entry.firstSeen) entry.firstSeen = ts;
-				if (entry.lastSeen === null || ts > entry.lastSeen) entry.lastSeen = ts;
-			}
-			entry.messages += 1;
-		}
-	}
-	return {
-		contacts: [...byKey.values()].sort((a, b) => (b.lastSeen ?? 0) - (a.lastSeen ?? 0)),
-		sources,
-		errors
-	};
-}
-//#endregion
-//#region src/im/channels.ts
-/**
-* im/channels.ts — IM 发送能力层（v1.31.0，S142 用户洞察）
-*
-* 用户原话：「既然微信桥是我们 ACC 提供的，那么 weixin-send 应该是我们 ACC 提供的能力，
-* 当用户配置了微信桥则可用，不配置则不可见」＋「设定一个复杂的多层工具，叫 im-bridge，
-* 里面有微信，然后保留后续可能兼容别的 im 的空间」。
-*
-* 分层（E↑）：
-*   `tools/im/channels.ts`（工具面：参数 → 结果渲染）
-*     → **本模块**（通道注册表 + 可见性判据 + 动作分发 + 错误码翻译）
-*       → 通道实现（`im/weixin-channel.ts`：协议/凭据/账号/记录）
-*
-* 边界（R↓）：
-* - **本模块零宿主依赖**（不 import cordis/agent）——可见性判定与分发都是纯逻辑，可独立单测。
-* - **通道只提供机制**：本模块不认识"微信"；新增 IM 只需注册一个通道实现（R3 家族式扩展）。
-* - **只能操作本会话 CCC**（R4）：`root` 由调用方（工具面）从 agent cwd 解析后传入，
-*   本模块不接受"目标 CCC"参数——跨 CCC 发送不在能力面。
-* - **记录归通道**（R5）：通道实现负责让每次发送都落既有 hook。
-*/
-/** 文本长度上限（微信侧单条实践上限；超限拒绝而非静默截断——与 HTTP 入口同值） */
-const IM_SEND_MAX_TEXT = 4e3;
-/** 文件大小上限（20MB，与媒体接收上限一致） */
-const IM_FILE_MAX_BYTES = 20971520;
-const channels = /* @__PURE__ */ new Map();
-/** 注册通道（index.ts apply 调用；重复 id 覆盖——测试与热重载友好） */
-function registerImChannel(channel) {
-	channels.set(channel.id, channel);
-}
-/** 已注册通道 id（工具 `channel` 参数枚举） */
-function imChannelIds() {
-	return [...channels.keys()];
-}
-/**
-* 可见性判据：本 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) {
-	let settings;
-	try {
-		settings = readImSettings(root);
-	} catch {
-		return false;
-	}
-	return (settings.accounts ?? []).some((a) => a.enabled !== false);
-}
-/**
-* 可见性判据（**轨迹级**，2026-10-23 owner 令）：
-* 这个 dsh 会话所属的认知轨迹，是否**被 IM 路由表点名**（= 它才是那个"接线人"）。
-*
-* ## 它解决的问题（owner 原话的**去标识改写**，原文含私有角色名，按 D145 不入仓库）
-*
-* > 「很多轨迹发消息给我，但是我没空回，它们就会等待我，其实并不是，我希望他们继续工作；
-* >  所以只有 IM 桥绑定了任意账户的认知轨迹才拥有 `im-bridge` 这个 tool，
-* >  这样可以确保只有一个接线角色和我联系，其它轨迹和它联系即可，它会自行回复它们的」
-*
-* ⇒ 旧判据是 **CCC 级**（{@link hasEnabledImChannel}：本 CCC 有任一启用账号 ⇒ 全体可见）。
-* 它的后果不是"少一个工具"，而是**一条错误的工作流**：每条轨迹都以为自己该直接对 owner 说话，
-* 于是发完就**停下来等人回**——而 owner 根本没空逐条回。**工具在，就把等待也带上了。**
-*
-* ## 判据（两条，缺一不可）
-*
-* 1. 本 CCC 有可用账号（{@link hasEnabledImChannel}）—— 没有账号时路由表也没有意义；
-* 2. 本会话**绑定的轨迹编码**出现在 `routes[].trajectory` 里。
-*
-* ⚠️ **为什么不看 `routes[].user`**：那是"对端是谁"（owner 的通道 id），
-*    判"这条轨迹能不能说话"只跟**轨迹**有关，与哪个对端无关。
-*
-* ⚠️ **`*` 通配也算点名**：`{ user:"*", trajectory:"<某轨迹>" }` 这条路由的含义就是
-*    "**没人认领的消息都归那条轨迹**" ⇒ 它确实是一条被授权的接线轨迹，必须算可见。
-*    这与 `matchWeixinRoute` 的通配兜底语义**同源**，不另立规则。
-*
-* ## 拿不到轨迹编码时怎么办（fail-closed，与 `exclusive` 同向）
-*
-* 会话 → 轨迹编码要读绑定。**取不到就判不可见**：
-* - 与 `exclusive`（未声明 ⇒ 隐藏）同向；
-* - 反向（取不到就放行）会让"绑定坏了"表现成"工具还在"，
-*   而那正是本判据要防的形态（D179：配置说它有、行为说它没有，且零报错）。
-* ⚠️ 代价明示：绑定读取若短暂失败，该轮会少一个工具；下一轮绑定恢复即回。
-*    这比"误给一条轨迹发消息的权限"便宜 —— 后者会让它**停下来等 owner**。
-*
-* @param root CCC 根
-* @param trajectoryCode 本会话所属认知轨迹的编码（**由调用方解析**，见 `trajectory/policy/profile.ts`）
-* @returns true = 该轨迹接线，`im-bridge` 可见
-*/
-function isImWiredTrajectory(root, trajectoryCode) {
-	if (typeof trajectoryCode !== "string" || trajectoryCode.trim() === "") return false;
-	if (!hasEnabledImChannel(root)) return false;
-	let settings;
-	try {
-		settings = readImSettings(root);
-	} catch {
-		return false;
-	}
-	const wanted = trajectoryCode.trim();
-	for (const route of settings.routes ?? []) {
-		const target = typeof route.trajectory === "string" ? route.trajectory.trim() : "";
-		if (target !== "" && target === wanted) return true;
-	}
-	return false;
-}
-/**
-* 错误码 → 可行动提示（模型视角：说清怎么改）。
-*
-* 🔴 `CHANNEL_NOT_CONFIGURED` 的提示**不能写死某一个渠道的字段名**（2026-10-20 Q4 真机验收踩到）：
-* 首版逐字写「enable it in … (weixin.enabled)」，而接第二个渠道后，**飞书能不能用不取决于
-* 这个开关**（它取决于有没有一条启用中的飞书账号）⇒ 按那句提示去改 `weixin.enabled`
-* **不会生效**，而错误码又指向"没配置" ⇒ 用户据此改完还是同一句报错。
-* ⇒ 提示按**渠道是否带自己的启用判据**分岔：带 `channelHint` 的就用它自己的说法。
-*/
-function remediationFor(code, channelHint) {
-	switch (code) {
-		case "CHANNEL_UNKNOWN": return "Use a registered channel id (see the tool description)";
-		case "CHANNEL_NOT_CONFIGURED": return channelHint ?? "This CCC has not configured that channel — check .opencode/serenity.json (the channel's own enabled flag / accounts) or the settings panel";
-		case "ACTION_UNKNOWN": return "Use send / send-file / users / status";
-		case "ACTION_UNSUPPORTED": return "This channel does not support that action";
-		case "ALIAS_UNKNOWN": return "Use a configured alias (see action=users) or a raw channel user id";
-		case "TEXT_REQUIRED": return "Provide text";
-		case "TEXT_TOO_LONG": return `Shorten the text to <= ${IM_SEND_MAX_TEXT} characters`;
-		case "USER_REQUIRED": return "Provide user";
-		case "FILE_REQUIRED": return "Provide file (a path inside this CCC)";
-		case "FILE_ESCAPE": return "Use a path inside this CCC";
-		case "FILE_NOT_FOUND": return "Check the path exists inside this CCC";
-		case "FILE_TOO_LARGE": return `Use a file <= ${Math.round(IM_FILE_MAX_BYTES / 1048576)} MB`;
-		default: return;
-	}
-}
-function fail(code, error, remediation) {
-	return {
-		ok: false,
-		code,
-		error,
-		...remediation ?? remediationFor(code) ? { remediation: remediation ?? remediationFor(code) } : {}
-	};
-}
-/** CCC 内文件读取（路径逃逸/缺失/超限一律拒绝，返回稳定码） */
-function readCccFile(root, relOrAbs) {
-	const abs = isAbsolute(relOrAbs) ? resolve(relOrAbs) : resolve(root, relOrAbs);
-	const rel = relative(resolve(root), abs);
-	if (rel.startsWith("..") || isAbsolute(rel)) return {
-		ok: false,
-		code: "FILE_ESCAPE",
-		error: `file escapes the CCC root: ${relOrAbs}`
-	};
-	if (!existsSync(abs)) return {
-		ok: false,
-		code: "FILE_NOT_FOUND",
-		error: `file not found: ${relOrAbs}`
-	};
-	let size = 0;
-	try {
-		size = statSync(abs).size;
-	} catch (err) {
-		return {
-			ok: false,
-			code: "FILE_NOT_FOUND",
-			error: `cannot stat file: ${relOrAbs} (${err instanceof Error ? err.message : String(err)})`
-		};
-	}
-	if (size > 20971520) return {
-		ok: false,
-		code: "FILE_TOO_LARGE",
-		error: `file is ${size} bytes (> ${IM_FILE_MAX_BYTES})`
-	};
-	try {
-		return {
-			ok: true,
-			data: readFileSync(abs),
-			fileName: abs.split("/").pop() ?? "file"
-		};
-	} catch (err) {
-		return {
-			ok: false,
-			code: "FILE_NOT_FOUND",
-			error: `cannot read file: ${relOrAbs} (${err instanceof Error ? err.message : String(err)})`
-		};
-	}
-}
-/**
-* 执行一次 IM 动作（工具面唯一入口）。
-*
-* 顺序：通道解析 → 动作校验 → 用户解析（别名 → id）→ 输入校验 → 调用通道实现。
-* 任何一步失败都返回**稳定错误码 + 可行动提示**（不抛错——工具面统一渲染）。
-*
-* @param root 本会话 CCC 根（调用方从 agent cwd 解析；本函数不接受目标 CCC）
-* @param req 工具参数
-*/
-async function runImBridge(root, req) {
-	const channelId = (req.channel ?? "").trim();
-	const action = (req.action ?? "").trim();
-	if (channelId === "") return fail("CHANNEL_REQUIRED", "channel is required", "Provide channel (e.g. \"weixin\")");
-	const channel = channels.get(channelId);
-	if (!channel) return fail("CHANNEL_UNKNOWN", `unknown channel "${channelId}" (registered: ${imChannelIds().join(", ") || "(none)"})`);
-	if (!channel.isEnabled(root)) return fail("CHANNEL_NOT_CONFIGURED", `channel "${channelId}" is not configured for this CCC (${root})`, channel.notEnabledReason?.(root));
-	if (action === "users") return {
-		ok: true,
-		channel: channelId,
-		action,
-		detail: { users: channel.listUsers(root) }
-	};
-	if (action === "contacts") {
-		if (!channel.listContacts) return fail("ACTION_UNSUPPORTED", `channel "${channelId}" has no record source for contacts`);
-		const settings = readWeixinSettings(root);
-		const accountChannel = {};
-		for (const account of settings.accounts ?? []) if (typeof account.accountId === "string" && account.accountId !== "") accountChannel[account.accountId] = typeof account.channel === "string" && account.channel !== "" ? account.channel : "weixin";
-		const scanned = scanImContacts(root, accountChannel);
-		const mine = scanned.contacts.filter((c) => c.channel === channelId);
-		/** 当前路由表（`user → trajectory`）；同一 user 多条时后者覆盖 */
-		const routeMap = /* @__PURE__ */ new Map();
-		for (const route of settings.routes ?? []) if (typeof route.user === "string" && route.user !== "") routeMap.set(route.user, typeof route.trajectory === "string" ? route.trajectory : "");
-		const contacts = mine.map((c) => ({
-			channel: c.channel,
-			userId: c.userId,
-			accountIds: c.accountIds,
-			route: routeMap.get(c.userId) ?? null,
-			firstSeen: c.firstSeen === null ? null : new Date(c.firstSeen).toISOString(),
-			lastSeen: c.lastSeen === null ? null : new Date(c.lastSeen).toISOString(),
-			messages: c.messages
-		}));
-		const seenUsers = new Set(mine.map((c) => c.userId));
-		return {
-			ok: true,
-			channel: channelId,
-			action,
-			detail: {
-				contacts,
-				unrouted: mine.filter((c) => !routeMap.has(c.userId)).map((c) => c.userId),
-				orphanRoutes: [...routeMap.keys()].filter((user) => !seenUsers.has(user)),
-				sources: scanned.sources,
-				...scanned.errors.length > 0 ? { errors: scanned.errors } : {}
-			}
-		};
-	}
-	if (action === "status") return {
-		ok: true,
-		channel: channelId,
-		action,
-		detail: channel.status(root)
-	};
-	if (action === "send") {
-		const rawUser = (req.user ?? "").trim();
-		if (rawUser === "") return fail("USER_REQUIRED", "user is required");
-		const text = req.text ?? "";
-		if (text === "") return fail("TEXT_REQUIRED", "text is required");
-		if (text.length > 4e3) return fail("TEXT_TOO_LONG", `text is ${text.length} characters (> ${IM_SEND_MAX_TEXT})`);
-		const resolved = channel.resolveUser(root, rawUser);
-		if (!resolved) return fail("ALIAS_UNKNOWN", `unknown user "${rawUser}"`);
-		try {
-			return {
-				ok: true,
-				channel: channelId,
-				action,
-				detail: {
-					...await channel.send({
-						root,
-						userId: resolved.id,
-						text,
-						accountId: req.account
-					}),
-					user: resolved.alias ?? resolved.id
-				}
-			};
-		} catch (err) {
-			return fail("SEND_FAILED", err instanceof Error ? err.message : String(err));
-		}
-	}
-	if (action === "send-file") {
-		if (!channel.sendFile) return fail("ACTION_UNSUPPORTED", `channel "${channelId}" does not support send-file`);
-		const rawUser = (req.user ?? "").trim();
-		if (rawUser === "") return fail("USER_REQUIRED", "user is required");
-		const fileArg = (req.file ?? "").trim();
-		if (fileArg === "") return fail("FILE_REQUIRED", "file is required");
-		const resolved = channel.resolveUser(root, rawUser);
-		if (!resolved) return fail("ALIAS_UNKNOWN", `unknown user "${rawUser}"`);
-		const file = readCccFile(root, fileArg);
-		if (!file.ok) return fail(file.code, file.error);
-		try {
-			return {
-				ok: true,
-				channel: channelId,
-				action,
-				detail: {
-					...await channel.sendFile({
-						root,
-						userId: resolved.id,
-						data: file.data,
-						fileName: file.fileName,
-						caption: req.caption,
-						accountId: req.account
-					}),
-					user: resolved.alias ?? resolved.id
-				}
-			};
-		} catch (err) {
-			return fail("SEND_FAILED", err instanceof Error ? err.message : String(err));
-		}
-	}
-	return fail("ACTION_UNKNOWN", `unknown action "${action}"`);
-}
-//#endregion
 //#region src/seams/tool-visibility.ts
 /** ACC 自己注册的工具名集合（退化档只发这些 —— 它们一定在册） */
 const REGISTERED_TOOLS_SET = new Set(REGISTERED_TOOLS);
@@ -15167,11 +14777,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./route-3OzOAjec.js").then((n) => n.l);
+					const { readWeixinSettings } = await import("./route-DxIKWeN9.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-3OzOAjec.js").then((n) => n.l);
+					const { imCredentialBound } = await import("./route-DxIKWeN9.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);
@@ -15208,7 +14818,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { fetchQRCode } = await import("./ilink-CsZ-f64q.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-3OzOAjec.js").then((n) => n.l);
+					const { readWeixinSettings } = await import("./route-DxIKWeN9.js").then((n) => n.l);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15229,7 +14839,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./route-3OzOAjec.js").then((n) => n.l);
+					const { removeWeixinAccount } = await import("./route-DxIKWeN9.js").then((n) => n.l);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -15255,7 +14865,7 @@ function registerStatusApi(ctx, opts = {}) {
 							trajectory: code
 						});
 					}
-					const { saveWeixinRoutes } = await import("./route-3OzOAjec.js").then((n) => n.l);
+					const { saveWeixinRoutes } = await import("./route-DxIKWeN9.js").then((n) => n.l);
 					const { findDirNameByCode } = await import("./profile-zxakCNXy.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})` });
@@ -15267,7 +14877,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./route-3OzOAjec.js").then((n) => n.l);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./route-DxIKWeN9.js").then((n) => n.l);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -15290,7 +14900,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "appId 与 appSecret 都必须填（只填一个等于没绑）" });
 						return;
 					}
-					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-3OzOAjec.js").then((n) => n.l);
+					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-DxIKWeN9.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);
@@ -15340,7 +14950,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./ilink-CsZ-f64q.js").then((n) => n.a);
-				const { readWeixinSettings } = await import("./route-3OzOAjec.js").then((n) => n.l);
+				const { readWeixinSettings } = await import("./route-DxIKWeN9.js").then((n) => n.l);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15355,7 +14965,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-3OzOAjec.js").then((n) => n.l);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-DxIKWeN9.js").then((n) => n.l);
 						const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -19922,7 +19532,7 @@ function buildOutgoingHookEvent(input) {
 		sessionId: input.sessionId,
 		role: input.role,
 		reply: input.reply,
-		...input.source && input.source !== "reply" ? { source: input.source } : {},
+		...input.source ? { source: input.source } : {},
 		...input.file ? { file: input.file } : {}
 	};
 }
@@ -20128,8 +19738,6 @@ const manualSessions = /* @__PURE__ */ new Map();
 const sentTurn = /* @__PURE__ */ new Map();
 /** 连续打回计数（成功发送即清零） */
 const rebukeCounts = /* @__PURE__ */ new Map();
-/** 闸门是否装配成功（v1.30.17：桥据此判断能否信任"未发送"这一判定——未装配时不兜底，防重复发送） */
-let guardActive = false;
 /** 桥：登记手动模式会话（每轮 incoming 都调用，幂等覆盖） */
 function noteManualOutputSession(sessionId, session) {
 	if (typeof sessionId !== "string" || sessionId === "") return;
@@ -20158,10 +19766,6 @@ function hasSentThisTurn(sessionId, turn) {
 	if (recorded === null || turn === null) return true;
 	return recorded === turn;
 }
-/** 闸门是否装配成功（未装配 → 桥不做兜底：宁可静默也不冒重复发送的风险） */
-function isWeixinOutputGuardActive() {
-	return guardActive;
-}
 /** 从 agent / 会话对象取会话 id（形状宽容） */
 function sessionIdOf$1(value) {
 	const v = value;
@@ -20178,7 +19782,7 @@ function sessionIdOf$1(value) {
 * 🔴 **原名为 `isSuccessfulWeixinSend`，2026-10-20 改名**（Q4 出站飞书）：
 * 它曾硬比 `channel !== 'weixin' ⇒ false`。接第二个渠道后，那条判据的含义变成
 * **"只有微信算发出去了"** —— 而实际后果是：飞书会话里 agent 真的发成功了，
-* 闸门仍判"未发送" ⇒ 打回 ≤2 次，若 CCC 开了 `fallbackOnNoSend` 还会再兜底转发一遍
+* 闸门仍判"未发送" ⇒ 打回 ≤2 次，且当时的 `fallbackOnNoSend` 还会再兜底转发一遍
 * ⇒ **重复投递**。⇒ 判据从"是不是微信"改成"是不是**这个会话所在的那条渠道**"，
 * 函数名随之更正（**名字要能对着行为读**，D151/D179 同族）。
 *
@@ -20260,10 +19864,32 @@ function registerWeixinOutputGuard(ctx) {
 			const session = manualSessions.get(sessionId);
 			if (!session) return;
 			if (hasSentThisTurn(sessionId, payload?.turn ?? null)) return;
+			/**
+			* 🔴🔴 **D234 修法（2026-10-24，D238 强制同批）：先确认"它有权发"，再打回。**
+			*
+			* 缺陷（我 2026-10-23 查出的真缺陷）：v1.88.0 起 `im-bridge` **只对 IM 路由表点名的
+			* 轨迹可见**（取不到轨迹编码即 fail-closed 隐藏）。而本闸门**无条件打回**，打回文案
+			* （`buildManualOutputRebuke`）逐字要求调用的正是那个工具 ⇒ 对一条"能收到消息但没被
+			* 路由表点名"的轨迹，**agent 无论如何都满足不了** ⇒ 连打 2 次后只剩告警，
+			* 用户侧零输出。**打回命中一个不可满足的前置条件**（D205 同族：前置不成立必须显式红，
+			* 而不是继续走必然失败的重试）。
+			*
+			* 🔴 为什么砍掉自动回发后这条变成**必配件**：手动模式成了唯一路径 ⇒ 本闸门**恒生效**
+			* （不再有"自动模式"这条安全退路），缺陷从边缘情形升级为主路径。
+			*
+			* 判据（与 `seams/guards.ts` 的可见性判据**同源**，D235 的要求）：
+			* 用同一个 `isImWiredTrajectory` 判——**可见性判据与打回判据必须同源**，
+			* 否则两处各判一套，又会长出"能发但被判成不能发"这类漂移。
+			*/
+			if (!isImWiredTrajectory(session.root, trajectoryCodeForSession(session.root, sessionId))) {
+				console.warn(`[serenity-hooks] ✗ im 输出闸门：session=${sessionId} role=${session.role} **没有 im-bridge 发送权**（该轨迹不在本 CCC 的 IM 路由表 im.routes 里）⇒ **不打回**。本轮 agent 若想说话也无路可走 —— 请把该轨迹编码加进 .opencode/serenity.json 的 im.routes，或让它把话交给已被点名的接线轨迹。`);
+				rebukeCounts.delete(sessionId);
+				return;
+			}
 			const count = (rebukeCounts.get(sessionId) ?? 0) + 1;
 			if (count > 2) {
 				rebukeCounts.delete(sessionId);
-				console.warn(`[serenity-hooks] ✗ weixin 输出闸门：连续 2 次打回后仍未发送（session=${sessionId}, role=${session.role}）——本轮用户将收不到 agent 自己发的消息`);
+				console.warn(`[serenity-hooks] ✗ weixin 输出闸门：连续 2 次打回后仍未发送（session=${sessionId}, role=${session.role}）——**本轮用户将收不到任何消息**（兜底转发已于 2026-10-24 整条退役，出站只剩 im-bridge 一条路）`);
 				return;
 			}
 			rebukeCounts.set(sessionId, count);
@@ -20284,7 +19910,6 @@ function registerWeixinOutputGuard(ctx) {
 		console.warn("[serenity-hooks] ✗ weixin 输出闸门未装配：agent/turn-stopping 不可用");
 		return;
 	}
-	guardActive = true;
 }
 //#endregion
 //#region src/im/inbound-event.ts
@@ -20567,31 +20192,30 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 			if (workspaceMd) {
 				if (!ensureWorkspacePromptSection(ref.agent, sessionId, root)) parts.push(workspaceCognitiveTrajectoryLine(workspaceMd));
 			}
-			const manualOutput = settings.autoReplyWithLastMessage === false;
 			if (text) parts.push(text);
 			parts.push(...mediaNotes, ...degradedNotes);
-			if (manualOutput) {
-				/**
-				* 🔴 **不在这里清空"已发送"标记**（2026-10-21 修"同一条消息被处理两轮"）。
-				*
-				* 旧写法 `clearSentThisTurn(sessionId)` 的语义是"来了新消息就当这个会话没发过"——
-				* 而它**连正在跑那一轮的证据一起抹掉**：真机时刻线
-				* `12:08:25 发送成功 → 12:08:56 新入站(抹) → 12:09:19 那一轮 turn-stopping 判"没发" ⇒ 打回`
-				* ⇒ 用户看到的就是"同一条消息被处理了两轮"。
-				*
-				* 现在**没有任何清空动作**：标记记的是**轮号**，上一轮发的记录在下一轮 `turn-stopping`
-				* 时天然不匹配（`hasSentThisTurn` 按轮比）⇒ 陈旧记录靠"轮号不等"淘汰，
-				* 不靠"谁来抹掉"。清空动作本身就是误伤面。
-				*/
-				noteManualOutputSession(sessionId, {
-					root,
-					accountId,
-					userId: fromUserId,
-					role: trajectory,
-					channel
-				});
-				parts.push(manualOutputMarker(accountId, fromUserId, channel));
-			} else forgetManualOutputSession(sessionId);
+			/**
+			* 🔴🔴 **2026-10-24（owner 令，D238）：出站只有一条路 —— agent 自己调 `im-bridge`。**
+			*
+			* 此前这里是 `if (manualOutput) {…}` 条件分支：`autoReplyWithLastMessage=false` 才走手动，
+			* 否则桥替 agent 转发最终文本。**该开关已整条退役** ⇒ 本段成为**唯一路径**：
+			* 每轮都登记闸门 ＋ 注入机制标记，桥**永不**自动回发。
+			*
+			* 为什么要这样（owner 原话）：「autoReply 并不合适，主动性的 imBridge 仍然是更好的」
+			* —— 自动回发让 agent 失去"说几条 / 何时说 / 要不要不说"的决定权，而这正是主动发送的价值。
+			*
+			* ⚠️ **由此产生的唯一代价（必须同时修）**：agent 不发 ⇒ 用户确实收不到。
+			* 所以 D234 的修法是本改动的**必配件**：guard 打回前必须确认 `im-bridge` 对该轨迹可见，
+			* 否则"没权发"会被无解地打回成"忘了发"。见 `im/guard.ts`。
+			*/
+			noteManualOutputSession(sessionId, {
+				root,
+				accountId,
+				userId: fromUserId,
+				role: trajectory,
+				channel
+			});
+			parts.push(manualOutputMarker(accountId, fromUserId, channel));
 			const question = parts.join("\n");
 			const hookRel = settings.hook;
 			if (hookRel) invokeWeixinHook(root, hookRel, buildIncomingHookEvent({
@@ -20606,53 +20230,7 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 			})).catch((err) => {
 				console.log(`[serenity-hooks] im hook incoming error: ${err instanceof Error ? err.message : String(err)}`);
 			});
-			const answer = (await askTrajectory(ctx, ref.agent, question)).answer ?? "";
-			if (manualOutput) {
-				if (!manualOutputFallbackNeeded({
-					fallbackOnNoSend: settings.fallbackOnNoSend,
-					guardActive: isWeixinOutputGuardActive(),
-					sentThisTurn: hasSentThisTurn(sessionId),
-					answer
-				})) return;
-				const reply = markdownToPlainText(stripThink(answer));
-				await io.sendText({
-					toUserId: fromUserId,
-					text: reply,
-					replyRef: event.replyRef
-				});
-				console.warn(`[serenity-hooks] ⚠ im 输出兜底：agent 本轮未发送（闸门打回用尽）→ 桥转发最终文本（session=${sessionId}, trajectory=${trajectory}）`);
-				if (hookRel) invokeWeixinHook(root, hookRel, buildOutgoingHookEvent({
-					cccRoot: root,
-					channel,
-					accountId,
-					userId: fromUserId,
-					sessionId,
-					role: trajectory,
-					reply,
-					source: "reply-fallback"
-				})).catch((err) => {
-					console.log(`[serenity-hooks] im hook outgoing(reply-fallback) error: ${err instanceof Error ? err.message : String(err)}`);
-				});
-				return;
-			}
-			if (answer === "") return;
-			const reply = markdownToPlainText(stripThink(answer));
-			await io.sendText({
-				toUserId: fromUserId,
-				text: reply,
-				replyRef: event.replyRef
-			});
-			if (hookRel) invokeWeixinHook(root, hookRel, buildOutgoingHookEvent({
-				cccRoot: root,
-				channel,
-				accountId,
-				userId: fromUserId,
-				sessionId,
-				role: trajectory,
-				reply
-			})).catch((err) => {
-				console.log(`[serenity-hooks] im hook outgoing error: ${err instanceof Error ? err.message : String(err)}`);
-			});
+			await askTrajectory(ctx, ref.agent, question);
 		} finally {
 			await io.typingStop?.({ toUserId: fromUserId });
 		}
@@ -20666,7 +20244,7 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 	}
 }
 /**
-* 手动输出模式的**机制标记**（v1.30.10 引入；v1.30.16 按「ACC 管机制、CCC 管措辞」重构）。
+* 出站**机制标记**（v1.30.10 引入；v1.30.16 按「ACC 管机制、CCC 管措辞」重构）。
 *
 * 边界（R↓）：ACC 只提供**机制与数据**——"桥不转发最终文本"这个事实 + 三个已填好的参数值。
 * **纪律措辞归 CCC**：怎么写、必须怎么做、后果是什么，全部写在轨迹的 `PROMPT.md` 里。
@@ -20674,22 +20252,25 @@ async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
 * 🔴 **渠道不是常量**（2026-10-20 Q4）：此前这里硬写 `channel:"weixin"`，
 * 而一条**飞书**会话收到的却是"发往微信"的命令 ⇒ 模型照着做必然失败（目标 id 是 open_id）。
 * ⇒ 渠道由调用方传入；缺省 `'weixin'` 保留既有调用点与测试的读数。
+*
+* 🔴 2026-10-24（D238）：本标记从"手动模式才注入"变成**每轮必注入**（手动模式已成唯一路径）。
+* ⚠️ **标记字符串 `[serenity:weixin-manual-output]` 不改名**：CCC 侧角色提示词按它做判据，
+*    改名会把已写好的纪律文档全打成废纸；它是**协议标记**，不是渠道名（与 A85 同一处置）。
 */
 function manualOutputMarker(accountId, userId, channel = "weixin") {
 	return ["[serenity:weixin-manual-output]", `im-bridge({channel:"${channel}", action:"send", account:"${accountId}", user:"${userId}", text:"<回复>"})`].join("\n");
 }
 /**
-* 手动输出模式的**兜底判定**（纯函数，v1.30.17——把决策矩阵从装配里抽出来，可独立测试）。
+* 🔴 **`manualOutputFallbackNeeded` 已于 2026-10-24 删除**（owner 令，D238）。
 *
-* 四个条件同时成立才兜底：
-* ① CCC 显式开启 `fallbackOnNoSend`（缺省 false = 严格静默）
-* ② 机械闸门**已装配**（未装配时无法判定"是否发送过" → 宁可静默也不冒重复发送风险）
-* ③ 本轮**没有**成功发送（agent 自己发过 → 输出权归 agent，桥不插话）
-* ④ 有最终文本可转发（空文本无意义）
+* 它实现的是「手动模式下 agent 一次都没发成功 ⇒ 桥兜底转发最终文本」。
+* **随 `fallbackOnNoSend` 一起退役** —— 那个开关只在 `autoReplyWithLastMessage=false` 时才有意义，
+* 而后者已整条删除（出站只剩 `im-bridge` 一条路）。
+*
+* ⛔ **不要把它改写成"自动兜底"再放回来**：owner 否决的正是"桥替 agent 说最后一句"这件事本身
+* （「autoReply 并不合适，主动性的 imBridge 仍然是更好的」），而不是它的某个实现细节。
+* 兜底带来的"不丢消息"收益，改由 guard 打回（可见性前置检查 ＋ 响亮告警）承担。
 */
-function manualOutputFallbackNeeded(input) {
-	return input.fallbackOnNoSend === true && input.guardActive && !input.sentThisTurn && input.answer !== "";
-}
 //#endregion
 //#region src/im/feishu-account.ts
 /** 去重集合上限（飞书重推窗口有限；限量防内存无界增长） */
@@ -22958,8 +22539,6 @@ const weixinChannel = {
 		});
 		return {
 			enabled: settings.enabled === true,
-			autoReplyWithLastMessage: settings.autoReplyWithLastMessage !== false,
-			fallbackOnNoSend: settings.fallbackOnNoSend === true,
 			routes,
 			accounts
 		};
@@ -23200,8 +22779,6 @@ const feishuChannel = {
 		}));
 		return {
 			enabled: settings.enabled === true,
-			autoReplyWithLastMessage: settings.autoReplyWithLastMessage !== false,
-			fallbackOnNoSend: settings.fallbackOnNoSend === true,
 			routes,
 			accounts
 		};
@@ -23292,6 +22869,85 @@ function createImBridgeTool() {
 	});
 }
 //#endregion
+//#region src/trajectory/live.ts
+/**
+* trajectory/live.ts — 进程内 live 会话取数 + 精简诊断
+*
+* ── 为什么单独成模块（R↓，2026-09-15 S142「ACC 侧 autopilot 退场」S1 搬迁）──
+* 这两个函数原先住在 `autopilot-trajectory.ts`，但它们的**主语不是 autopilot**：
+* `listLiveSessions` 服务 `acc-diag` ① 段的"**哪个会话属于哪个 CCC**"（会话维度，
+* 不是 CCC 维度），而"**独立进程看不到运行时**"正是 `acc-diag` 存在的理由。
+* autopilot 退场后它们必须活下去 ⇒ 独立成模块，不再挂着已死机制的名字。
+*
+* ── 迁移边界（不搬什么，以及为什么）──────────────────────────────────────
+* 原 `diagLive` 还含两段，**均不搬**（其主语是 autopilot，随机制退场）：
+*   · `autopilotCccs`（逐 CCC 目标命中 / agent 定位诊断）—— 依赖 `readAutopilotSettings` /
+*     `getAutopilotStatus` / `resolveTargetAgent`
+*   · `panelResolved`（无参面板请求落到哪个 CCC）—— 面板区块随机制退场
+* 留下的 = **进程 cwd/CCC + live 会话清单**（`acc-diag` ① 段仍需要）。
+*
+* 判据纪律：本模块**不得**反向依赖 autopilot 判据层（那会让退场半途而废）。
+*
+* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
+* **本模块的 `ctx` 参数类型从 `Context` 改为 `unknown`** —— 消除本文件唯一的 `W2` 接触
+* （直接 import 宿主 `cordis` 的类型）。
+*
+* **为什么这是"真解耦"而不是"把类型藏起来"（判据）：** `ctx` 在本模块**从不被解引用** ——
+* 它只被**原样透传**给 `hostSessions(ctx)`，而后者（`host/access.ts`，**L0**）的参数
+* 本就声明为 `ctx: unknown` ⇒ `Context` 这个 import **在语义上是多余的**，
+* 它没有参与任何类型检查，只贡献了一处 L1→宿主 的接触点。
+* 🔵 **证据**：grep 本文件 `ctx` 全部 5 处命中 —— 3 处在参数/调用位、2 处在注释，
+* **零处**属性访问（`ctx.xxx`）。
+*/
+/**
+* 从 dsh 会话 log 读取标题（latest-wins `session/title` 事件）——
+* **标题不在 `sessions.list()` 条目上**（wire/对象均无 title 字段；F3 命名经
+* `sessionTitle.rename` 写进 session log），必须从 events 提取（rebuild 同款读取模式）。
+*/
+function readSessionTitle(session) {
+	try {
+		const events = sessionEvents(session);
+		for (let i = events.length - 1; i >= 0; i--) {
+			const e = events[i];
+			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
+		}
+	} catch {}
+	return null;
+}
+/**
+* 逐条 live 会话（`cccRoot` = 该会话 cwd 的 CCC 归属，无 → null）。
+*
+* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
+* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
+*
+* @param ctx 插件上下文（**只透传**给 L0 取数口，本模块不解引用 ⇒ 类型为 `unknown`）
+* @returns 逐条 live 会话
+*/
+function listLiveSessions(ctx) {
+	const out = [];
+	try {
+		const sessions = hostSessions(ctx);
+		for (const s of sessions?.list?.() ?? []) {
+			const cwd = s?.header?.cwd ?? null;
+			out.push({
+				id: s?.id ?? "",
+				cwd,
+				cccRoot: cwd ? cccRootForCwd(cwd) : null,
+				title: readSessionTitle(s)
+			});
+		}
+	} catch {}
+	return out;
+}
+function diagLive(ctx) {
+	const processCwd = process.cwd();
+	return {
+		processCwd,
+		processCcc: cccRootForCwd(processCwd),
+		liveSessions: listLiveSessions(ctx)
+	};
+}
+//#endregion
 //#region src/surface/observation.ts
 /**
 * surface/observation.ts — 容器状态模型的**取数层唯一出口**（C5「观察面归一」，S142 2026-09-15）