@shgroup/dsh-serenity-hooks 1.63.2 → 1.64.0

package/lib/index.js

@@ -3,7 +3,7 @@ import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebSe
 import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readExclusiveTools, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-B0ZGL9lx.js";
 import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-B4P3Uw6D.js";
 import { a as readGitTrack, c as unsetEntry, i as localstorePath, l as writeEntry, n as checkLocalstoreGitCompliance, o as readStore, r as getEntry, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./localstore-ops-DMs_ovHo.js";
-import { a as FACE_PORTS, c as MECHANISM_PORTS, d as registerSkiffSession$1, f as skiffRoleFor$1, h as ACC_VERSION, i as ACP_PORT, l as SKIFF_DEBUG_PORT, m as unregisterSkiffSession$1, n as readSimpleSettings, o as GATEWAY_PORT, p as skiffSessionInfo$1, r as registerSettingsSection, s as MAIN_WEB_PORT, u as WEIXIN_SEND_PORT } from "./settings-section-DGUQZo5j.js";
+import { a as FACE_PORTS, c as MECHANISM_PORTS, d as registerSkiffSession$1, f as skiffRoleFor$1, h as ACC_VERSION, i as ACP_PORT, l as SKIFF_DEBUG_PORT, m as unregisterSkiffSession$1, n as readSimpleSettings, o as GATEWAY_PORT, p as skiffSessionInfo$1, r as registerSettingsSection, s as MAIN_WEB_PORT, u as WEIXIN_SEND_PORT } from "./settings-section-DN7g8K7Q.js";
 import { a as readSkiffRoles, c as roleMsmWhitelist, d as systemPromptSource, f as trajectorySubset, i as isSkiffSessionId, l as roleToolWhitelist, n as buildSkiffBasePrompt, o as resolveRoleSystemPrompt, r as createRolePromptReader, s as resolveSkiffKind } from "./skiff-role-B615L9MV.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
 import { a as readWeixinCredential, c as weixinInboundDir, i as matchWeixinRoute, l as weixinSessionIdFor, n as extractWeixinText, o as readWeixinSettings, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-Aheyq3fN.js";
@@ -9661,7 +9661,7 @@ function emptyRegistry() {
 	};
 }
 /** 条目形状校验（容忍手改：字段缺失/类型不符 → 丢弃该条，不阻断整表） */
-function asEntry$2(value) {
+function asEntry$1(value) {
 	const e = value;
 	if (!e || typeof e.id !== "string" || typeof e.target !== "string") return null;
 	if (typeof e.at !== "string" || typeof e.message !== "string") return null;
@@ -9695,7 +9695,7 @@ function loadWakeRegistry(root) {
 		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
 		const entries = [];
 		for (const item of raw) {
-			const e = asEntry$2(item);
+			const e = asEntry$1(item);
 			if (e) entries.push(e);
 		}
 		return {
@@ -10668,7 +10668,7 @@ const TURN_TTL_MS = 18e5;
 */
 const runningBySession = /* @__PURE__ */ new Map();
 /** 取载体 id（事件 payload 的 `agent` 面；取不到 ⇒ null） */
-function sessionIdOf$3(agent) {
+function sessionIdOf$2(agent) {
 	const id = agent?.session?.id;
 	return typeof id === "string" && id !== "" ? id : null;
 }
@@ -10754,23 +10754,23 @@ function registerCroTurnTracking(ctx) {
 		}
 	};
 	on("agent/created", (payload) => {
-		const id = sessionIdOf$3(payload?.agent);
+		const id = sessionIdOf$2(payload?.agent);
 		if (id) markTurnRunning(id, Date.now());
 	});
 	on("agent/status", (payload) => {
 		const p = payload;
-		const id = sessionIdOf$3(p?.agent);
+		const id = sessionIdOf$2(p?.agent);
 		if (!id) return;
 		const turn = typeof p.turn === "number" ? p.turn : null;
 		if (p.status === "running") markTurnRunning(id, Date.now(), turn);
 		else if (p.status === "idle") clearTurnRunning(id);
 	});
 	on("agent/turn-stopping", (payload) => {
-		const id = sessionIdOf$3(payload?.agent);
+		const id = sessionIdOf$2(payload?.agent);
 		if (id) clearTurnRunning(id);
 	});
 	on("agent/disposed", (payload) => {
-		const id = sessionIdOf$3(payload?.agent);
+		const id = sessionIdOf$2(payload?.agent);
 		if (id) clearTurnRunning(id);
 	});
 	on("session/disposed", (payload) => {
@@ -10839,14 +10839,14 @@ const CRO_LOG_VERSION = 1;
 function croWakeLogPath(root, dirName) {
 	return join(sessionsRoot(root), dirName, CRO_LOG_FILENAME);
 }
-function emptyLog$1() {
+function emptyLog() {
 	return {
 		version: CRO_LOG_VERSION,
 		entries: []
 	};
 }
 /** 条目形状校验（容忍手改：字段缺失/类型不符 → 丢弃该条，不阻断整档） */
-function asEntry$1(value) {
+function asEntry(value) {
 	const e = value;
 	if (!e || typeof e !== "object") return null;
 	if (typeof e.at !== "string" || e.at === "") return null;
@@ -10881,7 +10881,7 @@ function summarizeCroPrompt(prompt) {
 function loadCroWakeLog(root, dirName) {
 	const path = croWakeLogPath(root, dirName);
 	if (!existsSync(path)) return {
-		log: emptyLog$1(),
+		log: emptyLog(),
 		error: null
 	};
 	try {
@@ -10889,7 +10889,7 @@ function loadCroWakeLog(root, dirName) {
 		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
 		const entries = [];
 		for (const item of raw) {
-			const e = asEntry$1(item);
+			const e = asEntry(item);
 			if (e) entries.push(e);
 		}
 		return {
@@ -10901,7 +10901,7 @@ function loadCroWakeLog(root, dirName) {
 		};
 	} catch (err) {
 		return {
-			log: emptyLog$1(),
+			log: emptyLog(),
 			error: `CRO 流水解析失败（${String(err?.message ?? err)}）`
 		};
 	}
@@ -12941,447 +12941,6 @@ function createContainerAdminTool(ctx) {
 	});
 }
 //#endregion
-//#region src/unattended-ops.ts
-/**
-* unattended-ops.ts — 无人值守代理回复（unattended proxy）机制层（S142 **D77**，owner 2026-09-23 提案）
-*
-* ## 这东西用来干什么（白话）
-*
-* 用户发个任务就走开。现在模型干完一段就停下来等回话，用户不在 ⇒ **会话挂在那儿不动**。
-* 本机制 = 用户走开后，系统**代替用户说一句"继续"**：让它自己跑完；干完了用一个**验证码**报告；
-* 卡住了先自己想办法；真不能定的**写下来等用户回来**。
-*
-* ## 归属（D23：ACC 管机制与数据，CCC 管措辞与纪律）
-*
-* | 面 | 归谁 | 内容 |
-* |---|---|---|
-* | **机制** | 🔴 **ACC（本模块）** | 触发判定 / 验证码 / 四选一结构 / 轮上限 / 流水 |
-* | **不可代批的*具体内容*** | **CCC 纪律** | ACC 只给**通用下限**（{@link UNATTENDED_BLOCKED_FLOOR}），CCC 可加严 |
-*
-* 🔵 下限之所以落在 ACC（而不是"完全交给 CCC"）：**没有这张清单，"自行解决"＝把所有把关点自动放行**。
-* 最终内容仍待 owner 一句（设计 §13-5）——本版先给**保守下限**，CCC 只能在其上加严、不得放宽。
-*
-* ## 🔴 核心原则：单一续驱者（single-driver）
-*
-* > **一个会话同一时刻只应有一个"续驱者"：用户 ／ CRO ／ 自排绳 ／ 无人值守代理。**
-*
-* 口径（owner 2026-09-23 19:1x 裁决）= **窄口径：只排除「有 CRO 程序的轨迹」**。
-* 原「宽口径」（任何自排唤醒都排除）**作废** —— 它会让本机制**永远够不着靠续接绳活着的会话**，
-* 等于**放弃"代替旧机制"**（绳因此退化为**长周期保险丝**：6–12h 一条）。
-*
-* ## 🔴 铁律（与 `cro.ts` / `cro-log.ts` 同族，勿破）
-*
-* **本模块的每个导出函数都不抛错**：写盘 / 解析 / 裁剪失败一律返回结构化失败。
-* ⇒ 代理机制的任何问题**不影响 turn 收尾**、不影响既有链路（唤醒投递 / 输出守卫 / rebuild）。
-*
-* ## 🔴 为什么不构成第二真相源（勿删此论证）
-*
-* | 载体 | 谁写 | 主语 | 回答 |
-* |---|---|---|---|
-* | `<轨迹目录>/unattended-log.json`（**本模块**） | **ACC** | ACC | 「**我注入了什么、判了什么、放过没有**」 |
-* | `<轨迹目录>/SESSION.md` | **LLM（CCC）** | CCC | 「**这轮发生了什么、为什么这么定**」 |
-*
-* **内容不重叠**：本模块只记**机械事实**（轮次 / 验证码 / 判定理由码 / 是否放过），**不写散文**；
-* LLM 侧的散文与理由归 SESSION.md。完整审计 = 两者合看（本模块 = 注入面｜SESSION.md = 判断面）。
-*
-* ## 🔴 验证码形态（禁用 4 位字母码）
-*
-* 注入文本**自带**"请回复 ABCD" ⇒ 模型**复述指令**即**假完成**（高概率，不是小概率）
-* ⇒ 用**每轮新生成**的 nonce ＋ **包装 ＋ 独占一行**（`[[UNATTENDED-DONE:<hex>]]`），
-* 明写「**旧码作废**」，校验**只认当前轮**（防上下文里的旧码复活）。
-* 先例 = `cheap-worker` background 的 `SERENITY_CHEAP_WORKER_DONE_<16hex>`（同族实现）。
-*/
-/** 完成码包装前缀（**独占一行**才有意义；见文件头"禁用 4 位字母码"） */
-const UNATTENDED_DONE_PREFIX = "[[UNATTENDED-DONE:";
-/** 注入消息的**首行标记**（幂等可辨：模型与事后审计都能一眼看出这是代理消息，不是用户消息） */
-const UNATTENDED_PROXY_MARK = "[[UNATTENDED-PROXY v1]]";
-/** 🔴 合成消息**固定身份句**（owner 已裁：「形如用户消息，但首句自报身份与权限边界」） */
-const UNATTENDED_IDENTITY_LINE = "无人值守代理 · 非本人";
-/** 生成一枚新 nonce（**每轮一枚**；旧码作废由调用方在文本里声明） */
-function newNonce() {
-	return randomBytes(8).toString("hex");
-}
-/** 完成码全文（注入文本展示用；校验走 {@link hasDoneToken}） */
-function doneToken(nonce) {
-	return `${UNATTENDED_DONE_PREFIX}${nonce}]]`;
-}
-/**
-* 出现过的完成码 nonce 列表（按出现顺序、去重；**小写归一**）。
-* 容忍 8–64 位 hex（模型可能手抄多/少几个字符 ⇒ 那就不匹配，属预期：只认本轮那枚）。
-*/
-function parseDoneNonces(text) {
-	if (typeof text !== "string" || text === "") return [];
-	const re = /\[\[UNATTENDED-DONE:([0-9a-fA-F]{8,64})\]\]/g;
-	const out = [];
-	let m;
-	while ((m = re.exec(text)) !== null) {
-		const n = (m[1] ?? "").toLowerCase();
-		if (n !== "" && !out.includes(n)) out.push(n);
-	}
-	return out;
-}
-/** 触及即停（写待办/交接，**不循环**）——**CCC 的纪律更严则从严** */
-const UNATTENDED_BLOCKED_FLOOR = [
-	"发布 / 发版",
-	"对外发送（邮件 / 微信 / 对外面输出）",
-	"删除与不可逆操作（rm / 归档 / force push）",
-	"凭据与权限变更",
-	"花钱（外部 API 大额调用 / GPU 长任务）",
-	"代用户拍板（替人做决定）"
-];
-/** 四选一正文（{@link buildProxyMessage} 与 {@link buildFalseNotifyRebuke} 共用，避免两份措辞漂移） */
-function proxyBody(input) {
-	return [
-		`A) 已完成、且用户回来会满意 ⇒ 交码 ＋ 附完成凭据（做了什么 / 怎么验的 / 产物路径）`,
-		`B) 已成功向用户发出通知、要停下等他主动回来 ⇒ 交码 ＋ 写明走了哪个通道（**必须真有发送记录**）`,
-		`C) 需要确认但可自决 ⇒ 按「**最保守且可逆**」的选项继续做完（⚠️ **不要交码**，直接做）`,
-		`D) 触及不可代批边界 ⇒ **立即停**，把问题写进待办 / 交接，然后交码`,
-		``,
-		`不可代批的**通用下限**（你所在 CCC 的纪律更严则从严）：${(input.blocked ?? UNATTENDED_BLOCKED_FLOOR).join(" / ")}`,
-		``,
-		`交码 = **独占一行、逐字复制下面这一行**（旧码一律作废，只认本轮这个）：`,
-		``,
-		`    ${doneToken(input.nonce)}`,
-		``,
-		`禁止：把本条当真实用户的授权；禁止把本指令文本复述成回答；禁止什么都没做只回一个码；`,
-		`禁止借机发起**新的长任务**（代理只推进"已在办"的事）。`
-	].join("\n");
-}
-/** 组装一次代理注入消息（**形如用户消息，但首句自报身份与权限边界**） */
-function buildProxyMessage(input) {
-	return [
-		`${UNATTENDED_PROXY_MARK} round=${input.round}/${input.maxRounds} nonce=${input.nonce}`,
-		`${UNATTENDED_IDENTITY_LINE} —— 这条消息是**系统代用户发的**，不是用户本人；我没有任何权限替你拍板。`,
-		``,
-		`用户不在场。你只能以下列**四条之一**收束本轮：`,
-		``,
-		proxyBody(input)
-	].join("\n");
-}
-/**
-* 组装一次**假完成打回**消息（设计 §7 的机械核验分支：声称已通知用户，但本轮无发送记录）。
-*
-* ⚠️ 同样带**新 nonce**：它是一次"再来一轮"，不是"放过"。
-*/
-function buildFalseNotifyRebuke(input) {
-	return [
-		`${UNATTENDED_PROXY_MARK} round=${input.round}/${input.maxRounds} nonce=${input.nonce}`,
-		`${UNATTENDED_IDENTITY_LINE} —— 这条消息是**系统代用户发的**，不是用户本人。`,
-		``,
-		`🔴 你交的码是对的，但**你声称已通知用户，而我这边查不到任何发送记录** ⇒ **不算合法收束**。`,
-		`要么**真的发**（走可用通道；发成之后再交码），要么改走 A / C / D。其余口径同下。`,
-		``,
-		proxyBody(input)
-	].join("\n");
-}
-/**
-* 「收尾文本**声称**已联系用户」的**启发式**判据（设计 §7 的触发器，**不是**判据本身）。
-*
-* 🔴 机械判据 = **ACC 侧的发送记录**（{@link hasOutboundSendSince}）；本函数只回答"**要不要去查记录**"。
-* 误判方向（明标）：**误报**（模型换了个说法没被匹配到）⇒ 退回"只认码"，不产生假放过；
-* **误报**（正常措辞被当成声称）⇒ 多打回一轮（有轮上限兜底）。⇒ 偏严，符合设计 §11
-* 把"谎称已发消息"列为失败模式的取向。
-*/
-const NOTIFY_CLAIM_PATTERNS = [
-	/已(经)?(成功)?(向|给|和)?\s*(用户|您|你|他|她|本人|主人)?[^\n。]{0,16}(发送|发出|告知|通知|联系|留言|汇报)/,
-	/\b(?:notified|informed|messaged|contacted)\s+(?:the\s+)?user\b/i,
-	/\b(?:sent|sending)\s+(?:a\s+)?(?:message|notification|notice)\s+to\s+(?:the\s+)?user\b/i,
-	/\bI\s+(?:have\s+)?(?:notified|informed|messaged|contacted)\b/i
-];
-/** 收尾文本是否**声称**已联系用户（见 {@link NOTIFY_CLAIM_PATTERNS} 的误判方向说明） */
-function claimsUserNotification(text) {
-	if (typeof text !== "string" || text === "") return false;
-	return NOTIFY_CLAIM_PATTERNS.some((re) => re.test(text));
-}
-/**
-* **不许开**的会话（设计 §3 的"建议写死"，本版**确实写死**）：
-* `skiff-`（F4 问答 / **微信桥会话也是这个前缀** —— 桥那侧的"用户"是**家人**，
-* 代理替家人说话 = **冒充**）｜ `acp-`（对外程序化面 —— ⚠️ **2026-10-15 起已成死判据**：
-* 该前缀从无生产者且面 E 已退役；理由与"为何保留"见 `output-guard-seam.ts` 文件头）｜
-* `cheap-worker-`（自主 worker，已有自己的完成码循环）。
-*
-* ⚠️ **`rebuild-` 不在排除面**（与 `output-guard-seam.ts` 的取向**刻意不同**）：重建会话是
-* **同一轨迹的载体**（内部维护面），不是对外面；把它排除会让"重建后就没人推了"。
-*/
-function isProxyExcludedSessionId(sessionId) {
-	if (typeof sessionId !== "string" || sessionId === "") return true;
-	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("cheap-worker-");
-}
-/**
-* 一次判定的**唯一入口**（纯函数）。
-*
-* 顺序即语义（R↓，勿随意调换）：
-*  1. **闸/空间/会话资格**（关着、不在 CCC、非主会话、排除面）⇒ skip；
-*  2. **单一续驱者**：用户刚发起 ⇒ skip（人就在场）；该轨迹有 CRO ⇒ skip（程序在驱动）；
-*  3. **合法收束优先于轮上限** —— 最后一轮交的码必须算数（否则等于永远收不了尾）；
-*  4. 交码 ＋ 声称已通知 ＋ **无发送记录** ⇒ 假完成，走下一轮（reason=`false-notify`）；
-*  5. 墙钟 / 轮上限 ⇒ cap（**停下不动**，退回改造前的行为，不产生新风险）；
-*  6. 其余 ⇒ inject 下一轮。
-*/
-function decideUnattendedAction(f) {
-	if (!f.enabled) return {
-		action: "skip",
-		reason: "mode-off",
-		round: 0
-	};
-	if (!f.root) return {
-		action: "skip",
-		reason: "not-in-ccc",
-		round: 0
-	};
-	if (!f.isMainSession) return {
-		action: "skip",
-		reason: "not-main-session",
-		round: 0
-	};
-	if (f.sessionIdExcluded) return {
-		action: "skip",
-		reason: "excluded-session",
-		round: 0
-	};
-	if (f.userInitiated) return {
-		action: "skip",
-		reason: "user-initiated",
-		round: 0
-	};
-	if (f.hasCroProgram) return {
-		action: "skip",
-		reason: "cro-programmed",
-		round: 0
-	};
-	const run = f.run;
-	if (run !== null && f.doneNonce !== null && f.doneNonce.toLowerCase() === run.nonce.toLowerCase() && run) {
-		if (f.claimsNotify && !f.outboundSeen) {
-			if (run.round >= 15) return {
-				action: "cap",
-				reason: "round-cap",
-				round: run.round
-			};
-			return {
-				action: "inject",
-				reason: "false-notify",
-				round: run.round + 1
-			};
-		}
-		return {
-			action: "accept",
-			reason: "done-code",
-			round: run.round
-		};
-	}
-	if (run && f.nowMs - run.startedAt > 72e5) return {
-		action: "cap",
-		reason: "wall-clock",
-		round: run.round
-	};
-	if (run && run.round >= 15) return {
-		action: "cap",
-		reason: "round-cap",
-		round: run.round
-	};
-	const round = (run?.round ?? 0) + 1;
-	return {
-		action: "inject",
-		reason: run === null ? "first-stop" : f.doneNonce !== null ? "stale-code" : "no-legal-closure",
-		round
-	};
-}
-/** 键 = 载体（dsh 会话 id）——与 `cro-turns.ts` 同款选择（事件本身就以 agent/session 为主语） */
-const runs = /* @__PURE__ */ new Map();
-/** 取该会话的代理段（无 ⇒ null） */
-function getProxyRun(sessionId) {
-	return runs.get(sessionId) ?? null;
-}
-/** 开始 / 推进一段代理（`startedAt` 由调用方给出 ⇒ 跨轮保留首次值） */
-function setProxyRun(sessionId, run) {
-	if (!sessionId) return;
-	runs.set(sessionId, run);
-}
-/** 结束该会话的代理段（放过 / 上限 / 用户回来 / 载体销毁） */
-function clearProxyRun(sessionId) {
-	if (!sessionId) return;
-	runs.delete(sessionId);
-}
-/**
-* 「该载体最近一次由**真实用户**发起的轮次号」（会话 id → turn）。
-*
-* ⚠️ 只留**一条**（不是集合）：`claimed` 的 `turn` 单调递增，留最新一条即可回答
-* "本轮是不是用户发起的"，且**表的大小 = 会话数**（本容器栽过 5 次"只增不清"，此处结构性避免）。
-*/
-const userTurns = /* @__PURE__ */ new Map();
-/** 记下"这个载体的这一轮是真实用户发起的" */
-function noteUserTurn(sessionId, turn) {
-	if (!sessionId || typeof turn !== "number") return;
-	userTurns.set(sessionId, turn);
-}
-/** 该载体的这一轮是否由真实用户发起（判据 = `noteUserTurn` 写入的最新一条） */
-function isUserTurn(sessionId, turn) {
-	if (!sessionId || typeof turn !== "number") return false;
-	return userTurns.get(sessionId) === turn;
-}
-/** 清掉该载体的用户轮次记录（载体销毁时） */
-function clearUserTurn(sessionId) {
-	if (!sessionId) return;
-	userTurns.delete(sessionId);
-}
-/** 清空全部进程内运行态（disposer；**不碰磁盘**） */
-function clearUnattendedState() {
-	runs.clear();
-	userTurns.clear();
-	outboundSends.clear();
-}
-/** 发送记录保留窗（超出即丢：它只服务"这一轮到底发没发"这个瞬时问题） */
-const UNATTENDED_OUTBOUND_TTL_MS = 216e5;
-const outboundSends = /* @__PURE__ */ new Map();
-/**
-* 记一次**成功的**出站发送（`im-bridge` 工具面在通道返回成功后调用）。
-*
-* ⚠️ **覆盖边界（诚实标注）**：只覆盖 **ACC 自己这条通道**（`im-bridge` 的 send / send-file）。
-* CCC 自有的发送通道（如 `mail-tool` MSM）**ACC 看不见** ⇒ 那类"已通知"落到
-* {@link hasOutboundSendSince} = false ⇒ 会被判成假完成。⇒ 本版口径：**代理模式下"联系用户"
-* 只认 ACC 通道**；这与设计 §7 的原话（im-bridge 记日志）一致，边界写在此处以免误读。
-*/
-function noteOutboundSend(root, atMs = Date.now()) {
-	if (!root) return;
-	const list = outboundSends.get(root) ?? [];
-	list.push(atMs);
-	const cutoff = atMs - UNATTENDED_OUTBOUND_TTL_MS;
-	const kept = list.filter((t) => t >= cutoff).slice(-20);
-	outboundSends.set(root, kept);
-}
-/** 自 `sinceMs` 起该 CCC 是否有过成功出站发送（**只读，不清表**——清理归写入侧的裁剪） */
-function hasOutboundSendSince(root, sinceMs, nowMs = Date.now()) {
-	if (!root) return false;
-	const list = outboundSends.get(root);
-	if (!list || list.length === 0) return false;
-	const floor = Math.max(sinceMs, nowMs - UNATTENDED_OUTBOUND_TTL_MS);
-	return list.some((t) => t >= floor && t <= nowMs);
-}
-/** 固定文件名（与 `cro-wake-log.json` 并排、主语分明：那份记"我叫了什么"，这份记"我代说了什么"） */
-const UNATTENDED_LOG_FILENAME = "unattended-log.json";
-/** 保留窗 = 2 日（与 CRO 流水同值；**常量** ⇒ 无需人工清理动作） */
-const UNATTENDED_LOG_RETENTION_MS = 1728e5;
-const UNATTENDED_LOG_VERSION = 1;
-/** 日志绝对路径 */
-function unattendedLogPath(root, dirName) {
-	return join(sessionsRoot(root), dirName, UNATTENDED_LOG_FILENAME);
-}
-function emptyLog() {
-	return {
-		version: UNATTENDED_LOG_VERSION,
-		entries: []
-	};
-}
-/** 条目形状校验（容忍手改：字段缺失/类型不符 ⇒ 丢弃该条，不阻断整档） */
-function asEntry(value) {
-	const e = value;
-	if (!e || typeof e !== "object") return null;
-	if (typeof e.at !== "string" || e.at === "") return null;
-	if (e.event !== "inject" && e.event !== "accept" && e.event !== "cap" && e.event !== "yield") return null;
-	if (typeof e.reason !== "string") return null;
-	return {
-		at: e.at,
-		event: e.event,
-		round: typeof e.round === "number" ? e.round : 0,
-		nonce: typeof e.nonce === "string" ? e.nonce : null,
-		reason: e.reason,
-		sessionId: typeof e.sessionId === "string" ? e.sessionId : ""
-	};
-}
-/** 读取流水（**永不抛**；读坏 ⇒ 当作空档 + 返回 error 文本） */
-function loadUnattendedLog(root, dirName) {
-	const path = unattendedLogPath(root, dirName);
-	if (!existsSync(path)) return {
-		log: emptyLog(),
-		error: null
-	};
-	try {
-		const parsed = JSON.parse(readFileSync(path, "utf-8"));
-		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
-		const entries = [];
-		for (const item of raw) {
-			const e = asEntry(item);
-			if (e) entries.push(e);
-		}
-		return {
-			log: {
-				version: UNATTENDED_LOG_VERSION,
-				entries
-			},
-			error: null
-		};
-	} catch (err) {
-		return {
-			log: emptyLog(),
-			error: `无人值守流水解析失败（${String(err?.message ?? err)}）`
-		};
-	}
-}
-/**
-* 按窗裁剪（**纯函数** ⇒ 可穷举测试）。
-* 🔴 `at` 不可解析者**一律丢弃**并在返回值里报数（`dropped`）——**不静默吞掉**（同 `cro-log.ts` 纪律）。
-*/
-function pruneUnattendedLogEntries(entries, nowMs, windowMs = UNATTENDED_LOG_RETENTION_MS) {
-	const floor = nowMs - windowMs;
-	const kept = [];
-	let pruned = 0;
-	let dropped = 0;
-	for (const e of entries) {
-		const t = Date.parse(e.at);
-		if (Number.isNaN(t)) {
-			dropped += 1;
-			continue;
-		}
-		if (t >= floor) kept.push(e);
-		else pruned += 1;
-	}
-	return {
-		kept,
-		pruned,
-		dropped
-	};
-}
-/**
-* 追加一条流水并按窗裁剪（**本模块的落盘入口；永不抛**）。
-*
-* 顺序 = 读 → 追加 → 裁剪 → **原子写**（tmp + rename）。任一步失败 ⇒ `{ok:false, error}`，**不抛**
-* ——调用方只记一行 console 日志 ⇒ **代理机制的问题绝不影响 turn 收尾**。
-*/
-function appendUnattendedLog(root, dirName, entry, nowMs = Date.now()) {
-	if (!root || !dirName) return {
-		ok: false,
-		error: "缺少 CCC 根或轨迹目录名",
-		kept: 0
-	};
-	const path = unattendedLogPath(root, dirName);
-	try {
-		const loaded = loadUnattendedLog(root, dirName);
-		const full = {
-			at: isoLocal(nowMs),
-			...entry
-		};
-		const { kept } = pruneUnattendedLogEntries([...loaded.log.entries, full], nowMs);
-		mkdirSync(dirname(path), { recursive: true });
-		const tmp = `${path}.tmp`;
-		writeFileSync(tmp, `${JSON.stringify({
-			version: UNATTENDED_LOG_VERSION,
-			entries: kept
-		}, null, 2)}\n`, "utf-8");
-		renameSync(tmp, path);
-		return {
-			ok: true,
-			error: null,
-			kept: kept.length
-		};
-	} catch (err) {
-		return {
-			ok: false,
-			error: `无人值守流水写入失败（${String(err?.message ?? err)}）`,
-			kept: 0
-		};
-	}
-}
-//#endregion
 //#region src/im-bridge.ts
 /**
 * im-bridge.ts — IM 发送能力层（v1.31.0，S142 用户洞察）
@@ -13532,19 +13091,17 @@ async function runImBridge(root, req) {
 		const resolved = channel.resolveUser(root, rawUser);
 		if (!resolved) return fail("ALIAS_UNKNOWN", `unknown user "${rawUser}"`);
 		try {
-			const sent = await channel.send({
-				root,
-				userId: resolved.id,
-				text,
-				accountId: req.account
-			});
-			noteOutboundSend(root);
 			return {
 				ok: true,
 				channel: channelId,
 				action,
 				detail: {
-					...sent,
+					...await channel.send({
+						root,
+						userId: resolved.id,
+						text,
+						accountId: req.account
+					}),
 					user: resolved.alias ?? resolved.id
 				}
 			};
@@ -13563,21 +13120,19 @@ async function runImBridge(root, req) {
 		const file = readCccFile(root, fileArg);
 		if (!file.ok) return fail(file.code, file.error);
 		try {
-			const sent = await channel.sendFile({
-				root,
-				userId: resolved.id,
-				data: file.data,
-				fileName: file.fileName,
-				caption: req.caption,
-				accountId: req.account
-			});
-			noteOutboundSend(root);
 			return {
 				ok: true,
 				channel: channelId,
 				action,
 				detail: {
-					...sent,
+					...await channel.sendFile({
+						root,
+						userId: resolved.id,
+						data: file.data,
+						fileName: file.fileName,
+						caption: req.caption,
+						accountId: req.account
+					}),
 					user: resolved.alias ?? resolved.id
 				}
 			};
@@ -14011,7 +13566,7 @@ function forgetExclusiveToolsVisibility(sessionId) {
 *
 * 🔴 **为什么需要它（缺陷根因）**：工具是 `apply()` 里 `ctx.tools.register(...)` 注册到**宿主级**的
 * ⇒ 它们出现在**每一个**会话的工具清单里，**与会话 cwd 无关**。其余各缝（身份注入 ／ guards ／
-* keeper ／ output-guard ／ unattended ／ bootstrap）都已有 `if (!root) return` 这道门，
+* keeper ／ output-guard ／ bootstrap）都已有 `if (!root) return` 这道门，
 * **唯独"工具可见性"这一层没有** ⇒ 在非 CCC 目录开会话时，模型仍看得见这 14 个工具，
 * 于是会去调 —— 调了才抛 `No CCC found`。**那是运行时报错，不是事先不可见**。
 *
@@ -20338,8 +19893,10 @@ function isExternalFaceSession(sessionId) {
 	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
 }
 /** 读会话最后一个 assistant/message 文本（skiff-core 同款）
-*  **2026-09-23（S142 D77）起导出**：`unattended-seam.ts` 复用同一读法（本容器纪律：
-*  「同一读法只留一份」——两份 `lastAssistantText` 会在宿主改事件形状时**只修一处**）。
+*  **v1.63.3 起唯一的导出理由消失**：原导出是给 `unattended-seam.ts` 复用的（D77），
+*  该文件已随无人值守功能整条退役 ⇒ 现只有本模块自己用（`isLeak` 的调用点）。
+*  ⚠️ 保持 `export` 无害（它有测试覆盖，且将来"同一读法只留一份"的纪律仍成立），
+*  但**不要**再写成"为了 X 复用才导出"——那个 X 不存在了。
 *  **v1.27.7：剥离 think 块再检测**（用户："不检查think内容（因为不输出）"）——
 *  ` think…` 是模型思考过程，不进入用户可见输出；敏感词检测只针对**最终呈现文本**，
 *  否则 think 内提及内部机制词（思考过程必然推演机制）会误打回。复用 stripThink
@@ -20398,235 +19955,6 @@ function registerOutputGuardHook(ctx) {
 	});
 }
 //#endregion
-//#region src/unattended-seam.ts
-/**
-* unattended-seam.ts — 无人值守代理回复的**拦截缝**（S142 **D77**，owner 2026-09-23 令「我需要的是一个机制」）
-*
-* ## 停在哪、怎么接（设计 §4 的裁决：**A 的通道 ＋ B 的措辞**）
-*
-* 复用的是**已验证过的**通道——`agent/turn-stopping`（serial）里 `agent.steer()`：
-* 宿主语义 = "**listener 反对就打回**，机器重读 inbox：有新 steer ⇒ 再跑一步，没有 ⇒ 关轮"
-* （`host/contract.ts` 的 `HOST_EVENTS` 原文）。因此：
-* · **轮不结束**（语义正是"有人打回"）⇒ **零新机械**；
-* · 文本**写成代理用户的话**（B 的措辞）+ **首句自报身份**（owner 已裁）。
-*
-* 模板 = `output-guard-seam.ts`（同一缝位、同一 `createUserMessage + PLUGIN_SOURCE` 形态）。
-*
-* ## 🔴「这轮是不是真实用户发起的」怎么判（本机制**唯一**的新机械；2026-09-23 取证）
-*
-* 交接块把它列为"动手前必须先查清的一件事"，取证结论（读宿主类型面，非猜测）：
-*
-* | 事实 | 出处 |
-* |---|---|
-* | 每条进入 inbox 的消息都发 `agent/inbox/inserted { agent, message }`；**在轮内离开 inbox 时**发 `agent/inbox/claimed { agent, message, turn }` | `@deepseek-ai/dsh-agent` README（Inbox 段）＋ `runtime-types.d.ts` |
-* | `claimed.turn` = **拥有该消息的那一轮**；`turn-stopping.turn` = **即将关闭的那一轮** ⇒ 两者同编号可直接比对 | `runtime-types.d.ts` 同一文件两处 `turn` 声明 |
-* | 消息来源可辨：`MessageSourceMap` 里**真实用户** = `kind: 'user'`（`user` ／ `user-rpc` 两种形态**同 kind**）；**ACC 自己注入**的一律 `kind: 'plugin:dsh-serenity-hooks'`（v1.47.0 改；旧值 = `'plugin'`） | `@deepseek-ai/dsh-llm` `src/message.ts` 的 `MessageSourceMap`（合并和类型）＋ 本仓 `message-source.ts`（**唯一**声明处与常量处） |
-*
-* ⇒ **判据 = 「这一轮 claim 到的消息里，有没有 `source.kind === 'user'`」**。
-* 没有现成信号时本可退化为"记账法"（我们知道自己投过什么），**但不必**：宿主已给出一手信号。
-*
-* ## 🔴 为什么"用户发起的轮"要跳过（这是设计 §3-③ 的本意，别当成漏洞）
-*
-* 用户**刚说完话**⇒ 人就在跟前，代理插话既是冒充也是浪费。**"用户说完走开"那种情形**
-* 由**绳（长周期保险丝）／其它非用户发起的唤醒**覆盖：那条轮**不是**用户发起的 ⇒ 代理接手，
-* 一路推进到**合法收束**。⇒ 两个机制合起来才等于"用户走开后会话还能自己跑完"。
-*
-* ## 🔴 铁律（与 `unattended-ops.ts` 同族）
-*
-* **本模块的任何失败都不得影响 turn 收尾**：所有 handler 包 try/catch，异常只记一行 console。
-*/
-/** 取载体 id（payload 的 `agent` 面；取不到 ⇒ 空串） */
-function sessionIdOf$2(agent) {
-	const id = agent?.session?.id;
-	return typeof id === "string" ? id : "";
-}
-/** 取会话对象（payload 的 `agent.session`） */
-function sessionOf(agent) {
-	return agent?.session;
-}
-/** 取会话 cwd（`header.cwd`；取不到回落进程 cwd——与 `output-guard-seam.ts` 同款读法） */
-function cwdOf(agent) {
-	return sessionOf(agent)?.header?.cwd ?? process.cwd();
-}
-/** 是否 **CCC 内主会话**（`delegationDepth` 缺省 0；子代理 / 无头运行不算） */
-function isMainSession(agent) {
-	return (sessionOf(agent)?.header?.delegationDepth ?? 0) === 0;
-}
-/**
-* 该会话所属轨迹**是否带 CRO 程序**（窄口径的唯一排除项）。
-* 判据 = 轨迹目录下存在 `continuous-re-occurrence.ts`（与 `cro.ts` 同源：**文件在 = 启用**）。
-* 无绑定（未挂在任何轨迹上）⇒ false（没有程序在驱动它）。
-*/
-function hasCroProgram(session, root) {
-	const dirName = readLastBound(session)?.dirName;
-	if (!dirName) return false;
-	return existsSync(join(sessionsRoot(root), dirName, CRO_FILENAME));
-}
-/** 落一条流水（**永不抛**；无绑定 ⇒ 无落点，只回 false 由调用方记 console） */
-function logEvent(session, root, entry, nowMs) {
-	const dirName = readLastBound(session)?.dirName;
-	if (!dirName) return false;
-	const res = appendUnattendedLog(root, dirName, entry, nowMs);
-	if (!res.ok) console.log(`[serenity-hooks] unattended: 流水未落盘 — ${res.error ?? "未知原因"}`);
-	return res.ok;
-}
-/**
-* 一轮收尾（`agent/turn-stopping`）的完整处置。
-*
-* 顺序：**取事实 → 纯函数判定 → 执行**（判定全在 `unattended-ops.ts`，本函数只做 I/O 与 steer）。
-* @returns 便于用例观察的判定结果文本（生产不使用返回值）
-*/
-function handleTurnStopping(agent, turn) {
-	if (readSimpleSettings().unattendedEnabled !== true) return "skip:mode-off";
-	const sessionId = sessionIdOf$2(agent);
-	if (sessionId === "") return "skip:no-session-id";
-	const root = cccRootForCwd(cwdOf(agent));
-	if (root === null) return "skip:not-in-ccc";
-	const session = sessionOf(agent);
-	const nowMs = Date.now();
-	const run = getProxyRun(sessionId);
-	const text = lastAssistantText(agent);
-	const nonces = parseDoneNonces(text);
-	const sessionIdExcluded = isProxyExcludedSessionId(sessionId);
-	const userInitiated = turn === null ? true : isUserTurn(sessionId, turn);
-	const cro = !sessionIdExcluded && !userInitiated && isMainSession(agent) ? hasCroProgram(session, root) : false;
-	const verdict = decideUnattendedAction({
-		enabled: true,
-		root,
-		isMainSession: isMainSession(agent),
-		sessionIdExcluded,
-		userInitiated,
-		hasCroProgram: cro,
-		run,
-		nowMs,
-		doneNonce: nonces.length > 0 ? nonces[nonces.length - 1] ?? null : null,
-		claimsNotify: claimsUserNotification(text),
-		outboundSeen: run !== null && hasOutboundSendSince(root, run.startedAt, nowMs)
-	});
-	if (verdict.action === "skip") return `skip:${verdict.reason}`;
-	if (verdict.action === "accept" || verdict.action === "cap") {
-		clearProxyRun(sessionId);
-		logEvent(session, root, {
-			event: verdict.action,
-			round: verdict.round,
-			nonce: run?.nonce ?? null,
-			reason: verdict.reason,
-			sessionId
-		}, nowMs);
-		console.log(`[serenity-hooks] unattended: ${verdict.action} (${verdict.reason}, round=${verdict.round}, session=${sessionId})`);
-		return `${verdict.action}:${verdict.reason}`;
-	}
-	const nonce = newNonce();
-	const startedAt = run?.startedAt ?? nowMs;
-	setProxyRun(sessionId, {
-		round: verdict.round,
-		nonce,
-		startedAt
-	});
-	const message = verdict.reason === "false-notify" ? buildFalseNotifyRebuke({
-		round: verdict.round,
-		maxRounds: 15,
-		nonce
-	}) : buildProxyMessage({
-		round: verdict.round,
-		maxRounds: 15,
-		nonce
-	});
-	try {
-		agent.steer(createUserMessage({
-			content: [{
-				type: "text",
-				text: message
-			}],
-			source: PLUGIN_SOURCE
-		}));
-	} catch (error) {
-		clearProxyRun(sessionId);
-		logEvent(session, root, {
-			event: "cap",
-			round: verdict.round,
-			nonce,
-			reason: "steer-failed",
-			sessionId
-		}, nowMs);
-		console.warn(`[serenity-hooks] unattended: steer 失败（本轮放弃） — ${String(error?.message ?? error)}`);
-		return "cap:steer-failed";
-	}
-	logEvent(session, root, {
-		event: "inject",
-		round: verdict.round,
-		nonce,
-		reason: verdict.reason,
-		sessionId
-	}, nowMs);
-	console.log(`[serenity-hooks] unattended: inject round=${verdict.round}/15 (${verdict.reason}, session=${sessionId})`);
-	return `inject:${verdict.reason}`;
-}
-/**
-* 装配无人值守代理缝（`index.ts` apply 调用）。
-*
-* 订阅三个事件（**都已在 `host/contract.ts` 白名单里**，新增的 `agent/inbox/claimed` 同批登记）：
-* · `agent/inbox/claimed` —— 记「真实用户发起的轮次」；用户回来时**让位**（清代理段 + 记流水）;
-* · `agent/turn-stopping` —— 判定 + 注入（本机制主体）；
-* · `agent/disposed` / `session/disposed` —— 载体销毁清表（**本容器栽过 5 次"只增不清"**）。
-*/
-function registerUnattendedSeam(ctx) {
-	const on = (event, handler) => {
-		try {
-			ctx.on(event, handler);
-		} catch (err) {
-			console.log(`[serenity-hooks] ✗ 无人值守代理未装配（${event} 不可用）: ${String(err?.message ?? err)}`);
-		}
-	};
-	on("agent/inbox/claimed", (payload) => {
-		try {
-			const p = payload;
-			const sessionId = sessionIdOf$2(p?.agent);
-			if (sessionId === "") return;
-			if (p.message?.source?.kind !== "user") return;
-			noteUserTurn(sessionId, (typeof p.turn === "number" ? p.turn : null) ?? -1);
-			const run = getProxyRun(sessionId);
-			if (!run) return;
-			clearProxyRun(sessionId);
-			const root = cccRootForCwd(cwdOf(p.agent));
-			if (root) logEvent(sessionOf(p.agent), root, {
-				event: "yield",
-				round: run.round,
-				nonce: run.nonce,
-				reason: "user-returned",
-				sessionId
-			}, Date.now());
-			console.log(`[serenity-hooks] unattended: yield — 用户回来了 (session=${sessionId}, round=${run.round})`);
-		} catch (err) {
-			console.log(`[serenity-hooks] unattended: claimed 观察失败 — ${String(err?.message ?? err)}`);
-		}
-	});
-	on("agent/turn-stopping", (payload) => {
-		try {
-			const p = payload;
-			if (!p?.agent) return;
-			handleTurnStopping(p.agent, typeof p.turn === "number" ? p.turn : null);
-		} catch (err) {
-			console.log(`[serenity-hooks] unattended: turn-stopping 处置失败（已忽略） — ${String(err?.message ?? err)}`);
-		}
-	});
-	on("agent/disposed", (payload) => {
-		const sessionId = sessionIdOf$2(payload?.agent);
-		if (sessionId === "") return;
-		clearProxyRun(sessionId);
-		clearUserTurn(sessionId);
-	});
-	on("session/disposed", (payload) => {
-		const id = payload?.id;
-		if (typeof id !== "string" || id === "") return;
-		clearProxyRun(id);
-		clearUserTurn(id);
-	});
-	registerDisposer(ctx, "unattended proxy", () => {
-		clearUnattendedState();
-	});
-}
-//#endregion
 //#region src/human-channel.ts
 /**
 * human-channel.ts — 人机信道的**机制层**（机器级；2026-09-26 owner 定案 ⇒ 方案 §2.6）
@@ -24901,7 +24229,6 @@ function renderClock(label, s) {
 	const parts = [
 		`armed=${s.armed}`,
 		`CRO 闸=${readSimpleSettings().croEnabled !== false}`,
-		`无人值守闸=${readSimpleSettings().unattendedEnabled === true}`,
 		`tick 次数=${s.ticks}`,
 		`上次 tick=${ts(s.lastTickAt)}`
 	];
@@ -26022,7 +25349,6 @@ const Config = z.object({
 	skiffEnabled: z.boolean().volatile(),
 	skiffDebugPort: z.number().min(1024).max(65535).volatile(),
 	croEnabled: z.boolean().volatile(),
-	unattendedEnabled: z.boolean().volatile(),
 	diagramEnabled: z.boolean().volatile(),
 	acpFaceEnabled: z.boolean().volatile(),
 	acpFacePort: z.number().min(1024).max(65535).volatile()
@@ -26080,7 +25406,6 @@ function apply(ctx, config) {
 	registerGateway(ctx);
 	registerRebuildTurnHook(ctx);
 	registerOutputGuardHook(ctx);
-	registerUnattendedSeam(ctx);
 	if (config.env) registerEnv(ctx);
 	if (config.opencodeSkills) registerOpencodeSkills(ctx);
 	registerBootstrap(ctx);