@shgroup/dsh-serenity-hooks 1.90.0 → 1.92.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.",
@@ -8870,10 +8957,14 @@ function appendCroWakeLog(root, dirName, input, nowMs = Date.now()) {
 *
 * ## 判据（三条同时成立，缺一不可）
 *
-* 1. 日志里**最后一条 `turn/end`** 的 `reason.kind === 'interrupted'`；
+* 1. 日志里**最后一条 `turn/end`** 的 `reason.kind` ∈ {@link UNFINISHED_KINDS}
+*    （= `interrupted` 崩溃补收尾 ／ `aborted` 正常终止，两者都是"这一轮没收完"）；
 * 2. 该 `turn/end` **之后没有新的 `turn/start`**（否则已被后续轮次接续）；
 * 3. ⛔ **不要求**末条是 `session/end-seed`（2026-10-23 放宽，原因见 {@link detectInterruptedEnd}）。
 *
+* 🔴 **2026-10-24 补入 `aborted`**：修前只认 `interrupted` ⇒「被正常终止」整类漏扫
+* （发布重启／换宿主最常见的形态）。判据问的是「这一轮收完了吗」，**不是"进程死得惨不惨"**。
+*
 * ⚠️ **为什么不能只看"存在过 interrupted"**：一个长会话历史上可能中断几十次
 * （本容器实测单会话 33 次）。只看"曾经中断"会把早已恢复的会话全部当成待续 ⇒ 灾难。
 *
@@ -8966,34 +9057,54 @@ function readTailEvents(logPath, want) {
 	return events.slice(-want);
 }
 /**
-* 判定一组尾部事件是否「以 interrupted 结尾」。
+* 判定一组尾部事件是否「以未完成的轮次结尾」。
 * 不命中 → null。
 *
-* ## 🔴 2026-10-23 判据放宽（owner 实测：「不是挂在工具调用上的，也要能被 interrupted 筛选到并唤醒」）
+* ## 🔴🔴 2026-10-24 判据放宽（owner 报障：「有的会话在重启时不是崩溃的就扫不到，还是没修好」）
+*
+* ### 漏的是什么（宿主源码实读，非推测）
+*
+* 宿主只有**两条**会写出「轮次没收完」的 `turn/end`，而它们的 `kind` **不是同一个词**：
+*
+* | 形态 | 写谁 | `reason.kind` | 修前是否命中 |
+* |---|---|---|---|
+* | 进程**崩溃**／被强杀，下一轮 resume 时补收尾 | `interruptedTurnClosers()` → `openTurnClosers(events,{kind:'interrupted'})` | **`interrupted`** | ✅ |
+* | 进程**正常退出**（`restart-web` 的 SIGTERM、`agent/disposed`、用户中断） | 驱动 catch 里 `abortedCancelCause(signal)` | **`aborted`** ＋ 内层 `reason:{kind:'user'\|'parent'\|'disposed'\|'hook'}` | ❌ **漏** |
+*
+* ⇒ 修前只认 `interrupted` ⇒ **「被正常终止」这一大类全部漏掉**，而它恰恰是
+* **发布重启／换宿主** 最常见的形态（比崩溃常见得多）。
 *
-* ### 原判据（v1.87.4 起）为什么漏
-* 原来只认 **末条事件 = `session/end-seed`**。实测（本机 3337 条会话全扫）：
-*   · 末轮 `turn/end[interrupted]` 的会话 **26** 条；
-*   · 其中满足原判据的只有 **24** 条 ⇒ **漏 2 条**，形态逐字为：
-*     `… turn/end[interrupted] -> session/end-seed -> agent/inbox/spliced -> agent/inbox/spliced`
-*   ⇒ 重启后宿主把这**两条**追加在 end-seed 之后（它们是"恢复时把待办消息重新塞进收件箱"），
-*     于是"末条必须 end-seed"这条**在恢复动作发生之后就恒不成立**。
-*   ⚠️ 讽刺的是：**正是那些被恢复过、又再次被打断的会话**最容易长成这样
-*     ⇒ 原判据恰好对"反复中断"的会话失明，而它们才是最需要守护的。
+* 🔴 **这两条是同一个状态的两种成因，不是"一个对一个不对"**：
+* 判据问的是「**这一轮有没有收完**」，不是「进程死得惨不惨」。
+* 拿死法当判据 ⇒ 换一种死法就漏一批（这正是 owner 反复看到的"还是没修好"）。
 *
-* ### 新判据（三条，缺一不可）
-* 1. 日志里**最后一条 `turn/end`** 的 `reason.kind === 'interrupted'`；
-* 2. 该 `turn/end` **之后没有新的 `turn/start`**（否则说明它已被后续轮次接续）；
-* 3. ⛔ **不再要求末条是 `end-seed`**。
+* ### 为什么不能只加 `aborted` 就完事
+* `aborted.reason.kind` 里还可能有 `hook`（宿主主动 hook 取消）——它同属"没跑完"。
+* ⇒ 本判据**只看外层 `kind`**，理由：外层已经回答了"这一轮收完了吗"，
+*   内层回答的是"谁让它停的"，**那是另一个问题**，混进来会让判据随"谁取消的"漂移。
 *
-* ### 为什么不改成"末条必须是某个白名单"
-* 那就是原缺陷换个白名单再犯一次（`agent/inbox/spliced` 之外还会有别的）。
-* **判据要问的是"最后一轮的结束原因是什么、之后有没有新轮开始"**，
-* 而不是"日志最后一个 token 长什么样"——后者是**载体形态**，前者是**状态**。
+* ### ⛔ 刻意**不**纳入的形态（保守边界，写明理由）
+* - `error`：本轮**收完了**（宿主记了错误收尾），它不是"停在这里等人续"；
+* - 完全没有 `turn/end` 的开轮（例如日志末尾是 `turn/start` 后再无事件）：
+*   那**也可能是"进程正活着、这一轮正在跑"**，与真中断在读数上不可分
+*   ⇒ 纳入会误唤醒在跑的会话。⚠️ 这是**已知边界**，不是遗漏。
 *
 * ### 为什么不会误报"曾经中断但已恢复"
 * 恢复一定伴随 `turn/start`（新一轮）或新的 `turn/end`（`completed` 等）⇒ 判据 1／2 各自挡住。
-* 实测该放宽**不新增误报**：原 24 条全含于新判据（`curOnly = 0`），新增 2 条全是真漏。
+*/
+/**
+* 「这一轮没跑完」的 `turn/end.reason.kind` 取值域。
+*
+* 🔴🔴 **2026-10-24（owner 报障）**：原判据只认 `'interrupted'` 一个词 ⇒
+* **「被正常终止」整类漏扫**。两个值对应的形态见 {@link detectInterruptedEnd} 的头注。
+*
+* ⚠️ **这是判据的唯一取值点** —— 别在别处再写一份字面量（两份会漂）。
+*/
+const UNFINISHED_KINDS = /* @__PURE__ */ new Set(["interrupted", "aborted"]);
+/**
+* 命中判定。
+*
+* @returns 命中时给出被中断的轮次与"可能有副作用"的工具名；不命中 null
 */
 function detectInterruptedEnd(events) {
 	if (events.length === 0) return null;
@@ -9004,9 +9115,10 @@ function detectInterruptedEnd(events) {
 	}
 	if (idx < 0) return null;
 	const turnEnd = events[idx];
-	if (turnEnd?.data?.reason?.kind !== "interrupted") return null;
+	const kind = turnEnd?.data?.reason?.kind;
+	if (typeof kind !== "string" || !UNFINISHED_KINDS.has(kind)) return null;
 	for (let i = idx + 1; i < events.length; i++) if (events[i]?.type === "turn/start") return null;
-	const turn = typeof turnEnd.data?.turn === "number" ? turnEnd.data.turn : null;
+	const turn = typeof turnEnd?.data?.turn === "number" ? turnEnd.data.turn : null;
 	return {
 		turn,
 		pendingTools: findPendingTools(events, turn)
@@ -10848,12 +10960,12 @@ function collectRunningSessionIds(nowMs) {
 function renderInterruptedScan(input) {
 	const { projectDir, lookbackHours, scan } = input;
 	const lines = [];
-	lines.push(`═══ 以 interrupted 结尾的 dsh 会话（回看 ${lookbackHours}h）═══`);
+	lines.push(`═══ 末轮未跑完的 dsh 会话（回看 ${lookbackHours}h）═══`);
 	lines.push(`  扫描域: ${projectDir}`);
 	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped} · 耗时 ${scan.elapsedMs}ms${scan.errors.length > 0 ? ` · 读取失败 ${scan.errors.length}` : ""}`);
 	if (scan.sessions.length === 0) {
 		lines.push("");
-		lines.push("✓ 没有会话以 interrupted 结尾 —— 无需处理。");
+		lines.push("✓ 没有末轮未跑完的会话 —— 无需处理。");
 		return lines.join("\n");
 	}
 	lines.push("");
@@ -10864,7 +10976,9 @@ function renderInterruptedScan(input) {
 		if (s.pendingTools.length > 0) lines.push(`      ⚠️ 有调用无结果的工具（副作用未知）: ${s.pendingTools.join(", ")}`);
 	}
 	lines.push("");
-	lines.push("判据: 日志末条 = session/end-seed，且其前最近的 turn/end 的 reason.kind = interrupted。");
+	lines.push("判据: 日志末条 `turn/end` 的 `reason.kind` ∈ {interrupted, aborted}，且其后没有新的 turn/start。");
+	lines.push("      interrupted = 进程崩溃后被 resume 补收尾 ／ aborted = 被正常终止（重启、销毁、用户中断）。");
+	lines.push("      两者都表示「这一轮没跑完」，都会被收进来。");
 	lines.push("🔴 本动作**只读** —— 是否续跑、续哪条、几点续，由调用方（你的认知轨迹）决定。");
 	lines.push("⚠️ 未完成的工具调用「副作用未知」≠「没执行」：它们可能已写文件 / 已发消息。");
 	lines.push("   续跑前应先核对副作用，而不是把那一轮整段重放。");
@@ -10890,7 +11004,7 @@ function renderContinueResult(input) {
 	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped} · 耗时 ${scan.elapsedMs}ms`);
 	if (scan.sessions.length === 0) {
 		lines.push("");
-		lines.push("✓ 没有会话以 interrupted 结尾 —— 无需续跑。");
+		lines.push("✓ 没有末轮未跑完的会话 —— 无需续跑。");
 		return lines.join("\n");
 	}
 	lines.push("");
@@ -11039,7 +11153,7 @@ function createCognitiveTrajectoryTool(ctx) {
 			"list (inventory + stats) / show (read one SESSION.md) / create (make a NEW trajectory) / use (bind THIS conversation) / rebuild (clear-and-rebuild THIS conversation in place) / archive (move a trajectory out of the active list; one-way, never overwrites).",
 			"(B) DELIVERY — sends ONE message to ANOTHER trajectory; your own binding is unchanged: send-now (right now) / send-later (one future instant).",
 			"(C) REFERENCE — cro-guide: how to give a trajectory its own program that decides when it should be woken.",
-			"(D) INSPECTION — interrupted: list dsh sessions whose LAST turn ended with reason \"interrupted\" (the process died before that turn completed). PURE READ: no periodic scheduling, no auto-continue, no log mutation — deciding IF/WHEN/WHICH to resume belongs to the calling trajectory (this is the \"entry point only\" contract). The criterion is EXACTLY \"ends with interrupted\", NOT \"was ever interrupted\": one long session may have been interrupted dozens of times historically, and treating those as pending would resurrect sessions that already recovered. Each hit reports the turn number and the tool names that had a call but no result (best-effort — those side effects are UNKNOWN, so re-running them blindly is dangerous).",
+			"(D) INSPECTION — interrupted: list dsh sessions whose LAST turn did not finish — reason.kind is \"interrupted\" (process died; the host synthesised the closer on resume) OR \"aborted\" (terminated normally: restart, dispose, user cancel). Both mean \"this turn did not complete\"; picking only one misses an entire class. PURE READ: no periodic scheduling, no auto-continue, no log mutation — deciding IF/WHEN/WHICH to resume belongs to the calling trajectory (this is the \"entry point only\" contract). The criterion is EXACTLY \"the last turn did not finish\", NOT \"was ever interrupted\": one long session may have been interrupted dozens of times historically, and treating those as pending would resurrect sessions that already recovered. Each hit reports the turn number and the tool names that had a call but no result (best-effort — those side effects are UNKNOWN, so re-running them blindly is dangerous).",
 			"HOW TO CHOOSE (a rule, not a guess):",
 			"not yet bound + starting new work ⇒ create (with no prior binding it activates immediately, so the new trajectory has a carrier at once).",
 			"already bound + recording a SEPARATE future line ⇒ create (it does NOT steal your binding; activate the new one later by send-now).",
@@ -11335,16 +11449,16 @@ function createCognitiveTrajectoryTool(ctx) {
 				return listResident(root);
 				case "interrupted": {
 					/**
-					* 以 `interrupted` 结尾的 dsh 会话（owner 2026-10-22 令：**只出入口**）。
+					* 以未完成轮次结尾的 dsh 会话（owner 2026-10-22 令：**只出入口**）。
 					*
 					* 🔴 **边界（owner 原话：「我们 ACC 不关心周期」）**：本动作**只回答**"此刻哪些会话
-					* 的最后一轮以 interrupted 结束"，**不判周期、不自动续跑、不改日志**。
+					* 的最后一轮没跑完"，**不判周期、不自动续跑、不改日志**。
 					* 何时扫、续谁、怎么续 = 调用方（CCC 的认知轨迹）的事。
 					*
 					* 🔴 **为什么不是"曾经中断过"**：长会话历史上可中断几十次（实测单会话 33 次）；
-					* 按"曾经"判会把早已恢复的会话全部当成待续 ⇒ 灾难。判据在
-					* `trajectory/interrupted.ts` 的 `detectInterruptedEnd`：**末条 = end-seed
-					* 且其前最近的 turn/end 是 interrupted**。
+					* 按"曾经"判会把早已恢复的会话全部当成待续 ⇒ 灾难。
+					* 🔴 **判据只在一处**：`trajectory/interrupted.ts` 的 `detectInterruptedEnd`
+					* （⛔ 别在此处复述取值域 —— 2026-10-24 就是这份复述漏掉了 `aborted`）。
 					*
 					* 🔴 **正在跑的会话要排除**：live 会话不该被判成"待续"（它正在跑，不是中断）。
 					*/
@@ -12255,460 +12369,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);
@@ -15144,11 +14804,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);
@@ -15185,7 +14845,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, {
@@ -15206,7 +14866,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);
@@ -15232,7 +14892,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})` });
@@ -15244,7 +14904,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) {
@@ -15267,7 +14927,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);
@@ -15317,7 +14977,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,
@@ -15332,7 +14992,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, {
@@ -19899,7 +19559,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 } : {}
 	};
 }
@@ -20105,8 +19765,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;
@@ -20135,10 +19793,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;
@@ -20155,7 +19809,7 @@ function sessionIdOf$1(value) {
 * 🔴 **原名为 `isSuccessfulWeixinSend`，2026-10-20 改名**（Q4 出站飞书）：
 * 它曾硬比 `channel !== 'weixin' ⇒ false`。接第二个渠道后，那条判据的含义变成
 * **"只有微信算发出去了"** —— 而实际后果是：飞书会话里 agent 真的发成功了，
-* 闸门仍判"未发送" ⇒ 打回 ≤2 次，若 CCC 开了 `fallbackOnNoSend` 还会再兜底转发一遍
+* 闸门仍判"未发送" ⇒ 打回 ≤2 次，且当时的 `fallbackOnNoSend` 还会再兜底转发一遍
 * ⇒ **重复投递**。⇒ 判据从"是不是微信"改成"是不是**这个会话所在的那条渠道**"，
 * 函数名随之更正（**名字要能对着行为读**，D151/D179 同族）。
 *
@@ -20237,10 +19891,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);
@@ -20261,7 +19937,6 @@ function registerWeixinOutputGuard(ctx) {
 		console.warn("[serenity-hooks] ✗ weixin 输出闸门未装配：agent/turn-stopping 不可用");
 		return;
 	}
-	guardActive = true;
 }
 //#endregion
 //#region src/im/inbound-event.ts
@@ -20544,31 +20219,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({
@@ -20583,53 +20257,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 });
 		}
@@ -20643,7 +20271,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` 里。
@@ -20651,22 +20279,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）。
+*
+* 它实现的是「手动模式下 agent 一次都没发成功 ⇒ 桥兜底转发最终文本」。
+* **随 `fallbackOnNoSend` 一起退役** —— 那个开关只在 `autoReplyWithLastMessage=false` 时才有意义，
+* 而后者已整条删除（出站只剩 `im-bridge` 一条路）。
 *
-* 四个条件同时成立才兜底：
-* ① CCC 显式开启 `fallbackOnNoSend`（缺省 false = 严格静默）
-* ② 机械闸门**已装配**（未装配时无法判定"是否发送过" → 宁可静默也不冒重复发送风险）
-* ③ 本轮**没有**成功发送（agent 自己发过 → 输出权归 agent，桥不插话）
-* ④ 有最终文本可转发（空文本无意义）
+* ⛔ **不要把它改写成"自动兜底"再放回来**：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
 /** 去重集合上限（飞书重推窗口有限；限量防内存无界增长） */
@@ -22935,8 +22566,6 @@ const weixinChannel = {
 		});
 		return {
 			enabled: settings.enabled === true,
-			autoReplyWithLastMessage: settings.autoReplyWithLastMessage !== false,
-			fallbackOnNoSend: settings.fallbackOnNoSend === true,
 			routes,
 			accounts
 		};
@@ -23177,8 +22806,6 @@ const feishuChannel = {
 		}));
 		return {
 			enabled: settings.enabled === true,
-			autoReplyWithLastMessage: settings.autoReplyWithLastMessage !== false,
-			fallbackOnNoSend: settings.fallbackOnNoSend === true,
 			routes,
 			accounts
 		};