@shgroup/dsh-serenity-hooks 1.45.1 → 1.47.0

package/lib/index.js

@@ -2,13 +2,13 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { a as hostSettings, c as hostWebServer, i as hostSessions, n as hostInjected, o as hostSubagents, r as hostService, s as hostWeb, t as hostAgents } from "./access-fiehjxV6.js";
 import { a as findSerenityRoot, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, g as resolveInside, i as findGitRoot, l as pathInside, m as readTrajectorySkills, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readHandymanConfig, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-DG4Oc7I1.js";
 import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-FxWXuZPw.js";
-import { C as useSession, S as summarize, T as localFileStamp, _ as resolveSessionByTitle, a as resolveSessionTrajectoryLabel, b as setActiveSessionInfo, c as TRAJECTORY_ACTIONS, d as extractSessionMdPathFromText, f as findSession, g as readActiveSessionMd, h as parseSessionContextFromEvents, i as readLastBound, l as clearActiveSessionInfo, m as listSessions, o as setBindingStore, p as getActiveSessionInfo, r as pruneMissingBindings, s as DEFAULT_SESSION_SCOPE, t as appendBound, u as createSession, v as sessionEvents$1, w as isoLocal, x as showSession, y as sessionsRoot } from "./trajectory-bound-BPWKkzJC.js";
+import { C as showSession, D as localFileStamp, E as isoLocal, S as setActiveSessionInfo, T as useSession, _ as parseSessionContextFromEvents, a as pruneMissingBindings, b as sessionEvents$1, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as readActiveSessionMd, w as summarize, x as sessionsRoot, y as resolveSessionByTitle } from "./message-source-Boc-AbHs.js";
 import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-CWMRa36W.js";
 import { a as unregisterSkiffSession$1, i as skiffSessionSnapshot$1, n as skiffRoleFor$1, o as ACC_VERSION, r as skiffSessionInfo$1, t as registerSkiffSession$1 } from "./skiff-registry-BjIX_KD1.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-KqQA6pkr.js";
-import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-CIuyoSOX.js";
+import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-DTJW4smh.js";
 import { r as sessionsRootDir, t as hasSessionLogById } from "./session-cleanup-BtkSmry8.js";
-import { a as registerDisposer, c as addWake, i as registerCroTurnTracking, l as listWakes, n as sendToTrajectory, o as buildCroSnapshot, r as wakeSchedulerState, s as WAKE_CATCH_UP_MS, t as registerWakeScheduler } from "./wake-scheduler-DF-YWcX5.js";
+import { a as registerDisposer, c as WAKE_CATCH_UP_MS, i as registerCroTurnTracking, l as addWake, n as sendToTrajectory, o as CRO_FILENAME, r as wakeSchedulerState, s as buildCroSnapshot, t as registerWakeScheduler, u as listWakes } from "./wake-scheduler-DdaRNofO.js";
 import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-CtFYm53S.js";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
@@ -1915,14 +1915,16 @@ function waitAgentIdle(ctx, agent) {
 /**
 * skills-discovery.ts — CCC 入口 skill 自动发现（纯逻辑，零 DSH 依赖）
 *
-* 发现全部入口技能（原文全量，不截断）：
+* 发现全部入口技能（原文全量，不截断）—— **现行三个来源**（原为四个，**来源 3 已于 2026-09-21 删除**）：
 *   0. **`.serenity` 记号文件内容 = 顶层入口 skill 名**（CCC 记号文件的权威语义，
 *      tiangong-serenity 的 .serenity 内容为 `tg-serenity`）—— 最高优先
 *   1. `.dsh/entry-skill` 指针文件（内容 = skill 名）—— 兼容旧约定
 *   2. `.opencode/skills/*-serenity/SKILL.md` —— 自动扫描该 CCC 的顶层入口
 *      （home-serenity / tg-serenity / pangu-serenity …，命名模式 `*-serenity`）
-*   3. `.dsh/skills/*-serenity/SKILL.md` —— 自动扫描 ACC/harness 入口（acc-serenity 等）
-* 按名去重；顺序 = 记号文件 → 指针 → opencode 入口 → dsh 入口。
+*   ~~3. `.dsh/skills/*-serenity/SKILL.md`（扫 ACC 装进 CCC 的技能副本）~~ —— 🔴 **已删**：
+*      owner 2026-09-21 令「连模板和安装命令一起删」（B 案）。**判据、实测证据与日期逐字记在
+*      `findEntrySkills()` 体内那一段注释里**——本头部只留结论，**不复述判据**（避免两处会漂的真相源）。
+* 按名去重；顺序 = 记号文件 → 指针 → opencode 入口。
 *
 * 任何 CCC 都能自动注入其顶层入口 skill 全文（不硬编码名字）。
 */
@@ -1991,7 +1993,6 @@ function findEntrySkills(root) {
 		}
 	}
 	for (const dir of scanSerenityDirs(resolve(root, ".opencode", "skills"))) add(join(dir, "SKILL.md"), "opencode");
-	for (const dir of scanSerenityDirs(resolve(root, ".dsh", "skills"))) add(join(dir, "SKILL.md"), "dsh");
 	return out;
 }
 function truncateContent(content, maxChars) {
@@ -2153,11 +2154,13 @@ function mergeSkillNames(cccSkills, trajSkills) {
 * @param mdPath 轨迹的 SESSION.md 路径（**来自绑定的 `mdPath`**，不用 label 拼）
 * @param maxChars 总长上限（字符）
 * @param cccSkills CCC 级声明（`readTrajectorySkills`；缺省空 = 只有轨迹级，行为与 v1.43 一致）
+* @param onInjectedNames 观测回调（本次请求实际带上的 skill 名；**纯观测**，供用量统计用——
+*        回调抛错被吞，**不影响注入正文**）
 * @returns 注入正文；两条来源皆无声明 → `''`（空串 = 宿主不产出该 section 块）；
 *          SESSION.md 缺失/读失败 → 响亮提示（若同时有 CCC 级声明，则提示在前、正文随后——
 *          **提示不因"别处有内容"而被吞掉**）
 */
-function buildTrajectorySkillsSection(root, mdPath, maxChars = TRAJECTORY_SKILLS_MAX_CHARS, cccSkills = []) {
+function buildTrajectorySkillsSection(root, mdPath, maxChars = TRAJECTORY_SKILLS_MAX_CHARS, cccSkills = [], onInjectedNames) {
 	const abs = absoluteMdPath(root, mdPath);
 	let trajNames = [];
 	let notice = "";
@@ -2169,6 +2172,9 @@ function buildTrajectorySkillsSection(root, mdPath, maxChars = TRAJECTORY_SKILLS
 	}
 	const names = mergeSkillNames(cccSkills, trajNames);
 	if (names.length === 0) return notice;
+	if (onInjectedNames) try {
+		onInjectedNames(names);
+	} catch {}
 	const blocks = [];
 	for (const name of names) {
 		if (!isSafeSkillName(name)) {
@@ -2189,6 +2195,274 @@ function buildTrajectorySkillsSection(root, mdPath, maxChars = TRAJECTORY_SKILLS
 	const body = blocks.join("\n\n");
 	return truncateContent(notice ? `${notice}\n\n${body}` : body, maxChars);
 }
+//#endregion
+//#region src/usage-stats.ts
+/**
+* usage-stats.ts — ACC 用量统计（**skill 加载次数** ＋ **MSM 执行次数**；落该 CCC 的 `_tmp`）
+*
+* ## 所有者令（本模块的存在理由）
+*
+* 「我需要对 ACC 增加一个统计功能，包括 **skill 加载次数统计，msm 执行次数统计**；
+*  要求这个统计**自动生成在 CCC 的 `_tmp` 内的指定文件**」
+* ＋（对齐时确认）「**skill 加载**两个口径**都记、用字段区分**」「**只记名字、不记参数**」
+* 「**重启后读旧文件续算**」。
+*
+* ## 它解决什么麻烦（白话）
+*
+* 在此之前，「**哪些 skill 真的被加载过、哪些 MSM 真的在跑**」在 ACC 侧**一个数都没有** ——
+* 要判断「这东西还有人用吗」，只能靠翻会话记录**猜**。
+* ⇒ 本模块让每个 CCC 留下一份**纯计数**账本：**用了哪个、多少次、第一次和最近一次是什么时候**。
+* 用途 = 清理/精简的**依据**（没有人用的东西与天天在用的东西，不再靠猜）。
+*
+* ## 🔴 铁律（与 `cro-log.ts` 同族）
+*
+* **本模块每个导出函数都不抛错**：读盘 / 解析 / 写盘失败一律返回结构化失败，
+* 由调用方只记一行日志（或什么都不做）⇒ **统计的问题绝不影响工具执行与既有链路**。
+* 调用点在 `tools/post-execute` 的中途 ⇒ **更不能抛**（否则等于用统计打断会话）。
+*
+* ## 🔴 只记名字（所有者令；也是本模块唯一的"不入盘"约束）
+*
+* **绝不写 `arguments`**：MSM 参数里可能有凭据 / 路径 / 正文。
+* ⇒ 本模块只保留**计数键**（skill 名 / MSM 名），并对其做**长度与数量上限**（见常量），
+* 使文件规模**结构上有界**（不需要轮转，也不会被异常名字撑爆）。
+*
+* ## 🔴 重启后必须续算（所有者令）
+*
+* 宿主会被重启（本容器实测 24h 内 3 次）⇒ 计数**不能只活在内存里**：
+* 每次写盘 = **读旧文件 → 在旧值上自增 → 原子写**（`tmp + rename`，与 `wake-registry.ts` /
+* `cro-log.ts` 同款形态）⇒ **进程重启后计数自然延续**，无需额外的 flush/落盘时机。
+*
+* ## 口径（两个字段，勿合并）
+*
+* | 字段 | 含义 | 喂它的地方 |
+* |---|---|---|
+* | `skill.loads` | 模型**主动**调宿主 `skill` 工具（把某 skill 的 `SKILL.md` 全文载入） | `tools/post-execute`（工具名 = `skill`） |
+* | `skill.injections` | ACC **每请求注入**的 skill 段（`trajectory.skills` / 轨迹 frontmatter 声明） | `seams/system-prompt.ts` 的 trajectory-skills section 求值回调 |
+* | `msm` | `msm` 工具的一次执行，按 **MSM 名**分桶 | `tools/post-execute`（工具名 = `msm`） |
+*
+* 🔴 **两者差好几个数量级**：`loads` 是模型的**动作**（稀疏），`injections` 是**请求的属性**（稠密）。
+* 合并成一个数就**再也读不出**「这个 skill 是被人主动用的，还是只是被配上了」。
+*/
+/** 落点目录（所有者令：CCC 的 `_tmp` 内） */
+const USAGE_STATS_SUBDIR = "_tmp";
+/** 固定文件名（所有者令「指定文件」；对齐时我取的名字，owner 未反对 ⇒ 定为常量） */
+const USAGE_STATS_FILENAME = "acc-usage.json";
+/** 每个桶的键数上限（**结构上界**，见文件头"只记名字"节） */
+const USAGE_MAX_KEYS_PER_BUCKET = 1e3;
+const USAGE_STATS_VERSION = 1;
+/** 统计文件绝对路径（**纯函数**） */
+function usageStatsPath(root) {
+	return join(root, USAGE_STATS_SUBDIR, USAGE_STATS_FILENAME);
+}
+/** 空账本（**纯函数**） */
+function emptyUsageStats() {
+	return {
+		version: USAGE_STATS_VERSION,
+		updatedAt: isoLocal(0),
+		skill: {
+			loads: {},
+			injections: {}
+		},
+		msm: {}
+	};
+}
+/** 单条计数形状校验（容忍手改：字段缺失/类型不符 ⇒ 丢弃该条，不阻断整档） */
+function asCounter(value) {
+	const c = value;
+	if (!c || typeof c !== "object") return null;
+	if (typeof c.count !== "number" || !Number.isFinite(c.count) || c.count < 0) return null;
+	const firstAt = typeof c.firstAt === "string" ? c.firstAt : "";
+	const lastAt = typeof c.lastAt === "string" ? c.lastAt : firstAt;
+	return {
+		count: Math.floor(c.count),
+		firstAt,
+		lastAt
+	};
+}
+/** 桶校验（非对象 ⇒ 空桶；逐键过滤非法条） */
+function asBucket(value) {
+	const out = {};
+	if (!value || typeof value !== "object") return out;
+	for (const [k, v] of Object.entries(value)) {
+		const c = asCounter(v);
+		if (c) out[k] = c;
+	}
+	return out;
+}
+/**
+* 读取账本（**永不抛**；读坏 ⇒ 空账本 + 返回 error 文本，**不静默吞掉**）。
+* 文件不存在 = 正常初态（`error: null` 且空账本）。
+*/
+function loadUsageStats(root) {
+	const path = usageStatsPath(root);
+	if (!existsSync(path)) return {
+		stats: emptyUsageStats(),
+		error: null
+	};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		const skill = parsed.skill ?? {};
+		return {
+			stats: {
+				version: USAGE_STATS_VERSION,
+				updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : isoLocal(0),
+				skill: {
+					loads: asBucket(skill.loads),
+					injections: asBucket(skill.injections)
+				},
+				msm: asBucket(parsed.msm)
+			},
+			error: null
+		};
+	} catch (err) {
+		return {
+			stats: emptyUsageStats(),
+			error: `用量统计解析失败（${String(err?.message ?? err)}）`
+		};
+	}
+}
+/** 键是否可记（非空 + 不超长；**不截断**——截断会造出一个不存在的名字） */
+function isRecordableUsageName(name) {
+	return typeof name === "string" && name !== "" && [...name].length <= 120;
+}
+/**
+* 在桶上自增一格（**纯函数**：不改入参，返回新桶）。
+* 新键超桶上限 ⇒ **不新增**（但仍自增已有键）⇒ 键数**结构上有界**。
+*/
+function bumpBucket(bucket, name, at, maxKeys = USAGE_MAX_KEYS_PER_BUCKET) {
+	const prev = bucket[name];
+	if (!prev && Object.keys(bucket).length >= maxKeys) return bucket;
+	const next = prev ? {
+		count: prev.count + 1,
+		firstAt: prev.firstAt || at,
+		lastAt: at
+	} : {
+		count: 1,
+		firstAt: at,
+		lastAt: at
+	};
+	return {
+		...bucket,
+		[name]: next
+	};
+}
+/** 从工具入参里取名字（首个命中的键胜出；取不到 ⇒ `null`） */
+function nameFromArgs(args, keys) {
+	if (args === null || typeof args !== "object") return null;
+	const a = args;
+	for (const k of keys) if (isRecordableUsageName(a[k])) return a[k];
+	return null;
+}
+/** `msm` 工具的名字键（`msm(name, args)` 的第一个参数） */
+const MSM_NAME_KEYS = ["name"];
+/** `skill` 工具的名字键（宿主 `skill` 工具用 `name`；另两个是防御性容错） */
+const SKILL_NAME_KEYS = [
+	"name",
+	"skill",
+	"skillName"
+];
+const NOTHING = {
+	ok: true,
+	error: null,
+	recorded: null,
+	name: null,
+	wrote: false
+};
+/**
+* 读 → 自增 → 原子写（**本模块唯一写盘通道；永不抛**）。
+*
+* @param root CCC 根
+* @param mutate 在已载入的账本上做一次自增（返回值 = 本次记录的结论；返回 `NOTHING` 则不写盘）
+* @param nowMs 当前毫秒（可注入 ⇒ 便于测 firstAt/lastAt）
+*/
+function writeThrough(root, mutate, nowMs = Date.now()) {
+	const path = usageStatsPath(root);
+	try {
+		const at = isoLocal(nowMs);
+		const loaded = loadUsageStats(root);
+		const outcome = mutate(loaded.stats, at);
+		if (outcome.recorded === null) return outcome;
+		loaded.stats.updatedAt = at;
+		mkdirSync(join(root, USAGE_STATS_SUBDIR), { recursive: true });
+		const tmp = `${path}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(loaded.stats, null, 2)}\n`, "utf-8");
+		renameSync(tmp, path);
+		return {
+			...outcome,
+			ok: true,
+			error: null,
+			wrote: true
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: `用量统计写入失败（${String(err?.message ?? err)}）`,
+			recorded: null,
+			name: null,
+			wrote: false
+		};
+	}
+}
+/**
+* 记录一次工具调用的用量（**`tools/post-execute` 的喂入口**）。
+*
+* 只认两类工具名；其余一律 `NOTHING`（**不产生文件、不产生噪声**）。
+* 🔴 **不看 `arguments` 的其余内容**——只取名字键。
+*/
+function recordToolUsage(root, toolName, args, nowMs = Date.now()) {
+	if (toolName === "msm") {
+		const name = nameFromArgs(args, MSM_NAME_KEYS);
+		if (!name) return NOTHING;
+		return writeThrough(root, (stats, at) => {
+			stats.msm = bumpBucket(stats.msm, name, at);
+			return {
+				ok: true,
+				error: null,
+				recorded: "msm",
+				name,
+				wrote: false
+			};
+		}, nowMs);
+	}
+	if (toolName === "skill") {
+		const name = nameFromArgs(args, SKILL_NAME_KEYS);
+		if (!name) return NOTHING;
+		return writeThrough(root, (stats, at) => {
+			stats.skill.loads = bumpBucket(stats.skill.loads, name, at);
+			return {
+				ok: true,
+				error: null,
+				recorded: "skill.load",
+				name,
+				wrote: false
+			};
+		}, nowMs);
+	}
+	return NOTHING;
+}
+/**
+* 记录一次 **skill 注入**（每个请求的 skill 段装配时调用）。
+*
+* ⚠️ 与 `recordToolUsage` 不同，本函数的调用频度 = **请求频度**（稠密）：
+* 调用方应**只在真的注入了非空内容时**调用（空 section 由宿主丢弃 ⇒ 不产生噪声）。
+* 一次调用只写一次盘（`names` 内的多个 skill 合并在**同一次**读改写里）。
+*/
+function recordSkillInjections(root, names, nowMs = Date.now()) {
+	const usable = names.filter((n) => isRecordableUsageName(n));
+	if (usable.length === 0) return NOTHING;
+	return writeThrough(root, (stats, at) => {
+		let bucket = stats.skill.injections;
+		for (const n of usable) bucket = bumpBucket(bucket, n, at);
+		stats.skill.injections = bucket;
+		return {
+			ok: true,
+			error: null,
+			recorded: "skill.injection",
+			name: usable.join(","),
+			wrote: false
+		};
+	}, nowMs);
+}
 /** 验证窗口：当前时步 ± 1（容忍时钟漂移/生成延迟） */
 const TOTP_WINDOW = 1;
 /** 输出位数（标准 6 位） */
@@ -3159,7 +3433,7 @@ function registerTrajectorySkillSection(agent, root) {
 			text: () => {
 				const current = readLastBound(session);
 				if (!current) return "";
-				return buildTrajectorySkillsSection(root, current.mdPath, TRAJECTORY_SKILLS_MAX_CHARS, readTrajectorySkills(root));
+				return buildTrajectorySkillsSection(root, current.mdPath, TRAJECTORY_SKILLS_MAX_CHARS, readTrajectorySkills(root), (names) => recordSkillInjections(root, names));
 			}
 		});
 		trajectorySkillAgents.add(key);
@@ -3170,10 +3444,6 @@ function registerTrajectorySkillSection(agent, root) {
 }
 //#endregion
 //#region src/skiff-core.ts
-const PLUGIN_SOURCE$5 = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
 const skiffAgents = /* @__PURE__ */ new Map();
 /** 查 sessionId 的 Skiff 角色名（无 → null） */
 function skiffRoleFor(sessionId) {
@@ -3583,7 +3853,7 @@ async function askSkiff(ctx, agent, question, eventsStart, options) {
 			type: "text",
 			text: question
 		}],
-		source: PLUGIN_SOURCE$5
+		source: PLUGIN_SOURCE
 	}));
 	await waitAgentIdle(ctx, agent);
 	const answer = lastAssistantText$2(agent);
@@ -4094,10 +4364,7 @@ async function runHandymanJob(ctx, opts) {
 						type: "text",
 						text: prompt
 					}],
-					source: {
-						kind: "plugin",
-						plugin: "dsh-serenity-hooks"
-					}
+					source: PLUGIN_SOURCE
 				}));
 				await waitAgentIdle(ctx, workerAgent);
 				lastResponse = lastAssistantText$1(workerAgent);
@@ -5211,6 +5478,445 @@ 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>]]`），
+* 明写「**旧码作废**」，校验**只认当前轮**（防上下文里的旧码复活）。
+* 先例 = `handyman` background 的 `SERENITY_HANDYMAN_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-`（对外程序化面）｜ `handyman-`（自主 worker，已有自己的完成码循环）。
+*
+* ⚠️ **`rebuild-` 不在排除面**（与 `output-guard-seam.ts` 的取向**刻意不同**）：重建会话是
+* **同一轨迹的载体**（内部维护面），不是对外面；把它排除会让"重建后就没人推了"。
+*/
+function isProxyExcludedSessionId(sessionId) {
+	if (typeof sessionId !== "string" || sessionId === "") return true;
+	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("handyman-");
+}
+/**
+* 一次判定的**唯一入口**（纯函数）。
+*
+* 顺序即语义（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 用户洞察）
@@ -5361,17 +6067,19 @@ 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: {
-					...await channel.send({
-						root,
-						userId: resolved.id,
-						text,
-						accountId: req.account
-					}),
+					...sent,
 					user: resolved.alias ?? resolved.id
 				}
 			};
@@ -5390,19 +6098,21 @@ 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: {
-					...await channel.sendFile({
-						root,
-						userId: resolved.id,
-						data: file.data,
-						fileName: file.fileName,
-						caption: req.caption,
-						accountId: req.account
-					}),
+					...sent,
 					user: resolved.alias ?? resolved.id
 				}
 			};
@@ -5994,7 +6704,7 @@ function registerBootstrap(ctx) {
 			if (depth === 0) {
 				if (hasUserMessageHistory(session)) return;
 			} else if (sid !== void 0 && anchoredSessions.has(sid)) return;
-			if (message?.source?.kind === "plugin") return;
+			if (message?.source?.kind === "plugin:dsh-serenity-hooks") return;
 			const inbox = agent.inbox;
 			if (!inbox?.prepend) return;
 			for (let i = SETTINGS.anchorMessages.length - 1; i >= 0; i--) inbox.prepend("next-turn", {
@@ -6005,8 +6715,7 @@ function registerBootstrap(ctx) {
 					text: SETTINGS.anchorMessages[i]
 				}],
 				source: {
-					kind: "plugin",
-					plugin: "dsh-serenity-hooks",
+					kind: ACC_MESSAGE_KIND,
 					form: "notice",
 					summary: "bootstrap anchor turn"
 				}
@@ -6332,10 +7041,6 @@ function trajectoryCompactionReminderText(input) {
 	if (escalated) return `${eventToken("compaction")} ${facts} — you have been reminded repeatedly and have NOT compacted SESSION.md. This is now mandatory: STOP the current task step, load eap (praxis eap), rewrite SESSION.md, then resume. ${principles} ${frontmatterGuard} This reminder persists until the file is under the limit.`;
 	return `${eventToken("compaction")} ${facts}. Pause the current work and compact this trajectory's log (SESSION.md) before continuing — that log is the persistent body of this trajectory, and its size is operational entropy (H_op) the container pays on every read. ${principles} ${frontmatterGuard} After rewriting, resume the paused work; this reminder stops once the file is under the limit.`;
 }
-const PLUGIN_SOURCE$4 = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
 /** 每 agent 一个跟踪器（进程内存态，agent token 维度） */
 const trackers = /* @__PURE__ */ new Map();
 /** 连续超阈值轮数达此值 → 升级为 [TRAJECTORY-ESCALATED] 强制语气（此后持续升级催，直到 rebuild） */
@@ -6364,6 +7069,9 @@ function registerKeeper(ctx, opts = {}) {
 		const tracker = trackerFor(exec);
 		const shouldRemind = skiffKeeper ? tracker.step(exec.name) : false;
 		const downstream = await next();
+		try {
+			recordToolUsage(root, exec.name, exec.arguments);
+		} catch {}
 		const blocks = [];
 		if (shouldRemind) {
 			const code = tracker.ack();
@@ -6418,7 +7126,7 @@ function registerKeeper(ctx, opts = {}) {
 		if (blocks.length === 0) return downstream;
 		const reminderAll = createUserMessage({
 			content: blocks,
-			source: PLUGIN_SOURCE$4
+			source: PLUGIN_SOURCE
 		});
 		if (downstream.kind === "block") return {
 			kind: "block",
@@ -6462,10 +7170,6 @@ function accIdentityText(root, configPaths = DEFAULT_SERENITY_CONFIG_PATHS, entr
 	}
 	return lines.join("\n");
 }
-const PLUGIN_SOURCE$3 = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
 /**
 * ACC 注入消息（S134 去重）：**只含简短身份锚点**（[ACC] 已激活 + CCC 根 + 约束 + Phase 2）。
 * ⚠️ 原文案含「+ handyman 模型」，该注入已于 2026-09-16 删除（§0e-G）⇒ 此处同步订正（散文级残留）。
@@ -6480,7 +7184,7 @@ function accMessage(root, configPaths, entrySkillMaxChars) {
 	}];
 	return createUserMessage({
 		content,
-		source: PLUGIN_SOURCE$3
+		source: PLUGIN_SOURCE
 	});
 }
 /** 每 agent 是否已注入过（进程内存态） */
@@ -6594,7 +7298,7 @@ function registerContext(ctx, opts = {}) {
 			syncExclusiveToolsVisibility(agent, root);
 		} catch {}
 	};
-	if (opts.seedOnStart ?? true) ctx.on("agent/session-start", (payload) => {
+	if (opts.seedOnStart ?? true) ctx.on("agent/created", async (payload) => {
 		try {
 			seed(payload.agent);
 		} catch {}
@@ -7075,7 +7779,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const settings = readAdvancedSettings();
-				const { readSimpleSettings } = await import("./settings-section-CIuyoSOX.js").then((n) => n.r);
+				const { readSimpleSettings } = await import("./settings-section-DTJW4smh.js").then((n) => n.r);
 				const simple = readSimpleSettings();
 				const allowed = settings.publicAsk.allowed;
 				const port = simple.acpHttpPort ?? ACP_HTTP_PORT;
@@ -7798,8 +8502,8 @@ const HOST_SERVICES = [
 	}
 ];
 /** dsp 被验证过的宿主版本范围（与 package.json peerDependencies 同源，单一真相源） */
-const REQUIRED_HOST_RANGE = "^0.1.5-rc.2";
-/** 范围 floor：剥掉 caret/比较前缀（`^0.1.5-rc.2` → `0.1.5-rc.2`），供 {@link checkHostVersion} 使用 */
+const REQUIRED_HOST_RANGE = "^0.1.7-rc.1";
+/** 范围 floor：剥掉 caret/比较前缀（`^0.1.7-rc.1` → `0.1.7-rc.1`），供 {@link checkHostVersion} 使用 */
 const REQUIRED_HOST_FLOOR = REQUIRED_HOST_RANGE.replace(/^[\^~>=<\s]+/, "");
 /** 范围 ceiling：`^0.1.x` 的上界 = `<0.2.0`（显式常量，见 {@link checkHostVersion} 注释） */
 const REQUIRED_HOST_CEILING = "0.2.0";
@@ -9023,7 +9727,7 @@ function registerGateway(ctx) {
 		});
 	};
 	sync();
-	ctx.on("agent/session-start", (payload) => {
+	ctx.on("agent/created", async (payload) => {
 		try {
 			const cwd = payload.agent?.session?.header?.cwd;
 			if (cwd) {
@@ -9052,10 +9756,6 @@ var rebuild_exports = /* @__PURE__ */ __exportAll({
 	sanitizeFocusLine: () => sanitizeFocusLine,
 	stripAckSuffix: () => stripAckSuffix
 });
-const PLUGIN_SOURCE$2 = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
 /** acknowledge 尾句（first-anchor 的确认要求——rebuild 重建后不重走确认轮，直接继续） */
 const ACK_SUFFIX_RE = /Please simply reply "acknowledge" — no action needed\.\s*$/;
 /**
@@ -9371,7 +10071,7 @@ function registerRebuildTurnHook(ctx) {
 						type: "text",
 						text: `${eventToken("rebuild")} The conversation has been cleared and rebuilt. Follow the anchor instructions above now: read the persistent trajectory (SESSION.md) and continue the work automatically from the last checkpoint.`
 					}],
-					source: PLUGIN_SOURCE$2
+					source: PLUGIN_SOURCE
 				}));
 				writeRebuildDiag(resolveSerenityRootFor(agent), {
 					sessionId: id,
@@ -11524,7 +12224,7 @@ const MECHANISM_WORDS = [
 	"localstore.json",
 	".opencode/serenity.json",
 	"AGENT_SESSIONS",
-	"agent/session-start",
+	"agent/created",
 	"agent/turn-stopping",
 	"tools/pre-execute",
 	"tools/post-execute",
@@ -11634,17 +12334,15 @@ function buildRebuke(hits) {
 const rebukeStates = /* @__PURE__ */ new Map();
 //#endregion
 //#region src/output-guard-seam.ts
-const PLUGIN_SOURCE$1 = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
 /** 外部面会话判定（v1.26.3 用户拍板：仅外部面检测，本地维护会话豁免）：
 *  skiff-（F4 问答）/ acp-（F4c 程序化）/ rebuild-（v1.22.4 重建会话）前缀 */
 function isExternalFaceSession(sessionId) {
 	if (!sessionId) return false;
 	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
 }
-/** 读会话最后一个 assistant/message 文本（skiff-core 同款；仅用于守卫检测，不导出）
+/** 读会话最后一个 assistant/message 文本（skiff-core 同款）
+*  **2026-09-23（S142 D77）起导出**：`unattended-seam.ts` 复用同一读法（本容器纪律：
+*  「同一读法只留一份」——两份 `lastAssistantText` 会在宿主改事件形状时**只修一处**）。
 *  **v1.27.7：剥离 think 块再检测**（用户："不检查think内容（因为不输出）"）——
 *  ` think…` 是模型思考过程，不进入用户可见输出；敏感词检测只针对**最终呈现文本**，
 *  否则 think 内提及内部机制词（思考过程必然推演机制）会误打回。复用 stripThink
@@ -11695,7 +12393,7 @@ function registerOutputGuardHook(ctx) {
 					type: "text",
 					text: buildRebuke(hits)
 				}],
-				source: PLUGIN_SOURCE$1
+				source: PLUGIN_SOURCE
 			}));
 		} catch (error) {
 			console.warn(`[serenity-hooks] output-guard steer failed: ${String(error?.message ?? error)}`);
@@ -11703,6 +12401,235 @@ 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/acp-core.ts
 /** JSON-RPC 错误码（对齐标准） */
 const RPC_ERROR = {
@@ -12456,12 +13383,6 @@ qInput.focus()
 </body>
 </html>`;
 }
-//#endregion
-//#region src/weixin-output-guard.ts
-const PLUGIN_SOURCE = {
-	kind: "plugin",
-	plugin: "dsh-serenity-hooks"
-};
 const manualSessions = /* @__PURE__ */ new Map();
 /**
 * 本轮是否已成功发送（**由桥在每轮开始时清空** `clearSentThisTurn`；闸门只置位不清空——
@@ -14059,7 +14980,7 @@ function registerOpencodeAutoConfig(ctx) {
 		});
 	}
 	try {
-		ctx.on?.call(ctx, "settings/updated", (ns) => {
+		ctx.on?.call(ctx, "settings/document-updated", (ns) => {
 			if (ns === "llm-pi-ai") sync();
 		});
 	} catch {}
@@ -14303,7 +15224,7 @@ function registerDeepseekVisionPatch(ctx, enabled) {
 		});
 	}
 	try {
-		ctx.on?.call(ctx, "settings/updated", (ns) => {
+		ctx.on?.call(ctx, "settings/document-updated", (ns) => {
 			if (ns === "llm-pi-ai") sync();
 		});
 	} catch {}
@@ -14848,6 +15769,7 @@ function renderClock(label, s) {
 	const parts = [
 		`armed=${s.armed}`,
 		`CRO 闸=${readSimpleSettings().croEnabled !== false}`,
+		`无人值守闸=${readSimpleSettings().unattendedEnabled === true}`,
 		`tick 次数=${s.ticks}`,
 		`上次 tick=${ts(s.lastTickAt)}`
 	];
@@ -15165,7 +16087,17 @@ const Config = z.object({
 	}),
 	webFetch: z.object({ enabled: z.boolean().default(true) }),
 	opencodeProvider: z.object({ autoConfigure: z.boolean().default(true) }),
-	visionPatch: z.object({ enabled: z.boolean().default(true) })
+	visionPatch: z.object({ enabled: z.boolean().default(true) }),
+	gatewayEnabled: z.boolean(),
+	rebuildEnabled: z.boolean(),
+	rebuildThresholdK: z.number().min(50).max(4e3),
+	skiffEnabled: z.boolean(),
+	skiffDebugPort: z.number().min(1024).max(65535),
+	acpEnabled: z.boolean(),
+	acpHttpPort: z.number().min(1024).max(65535),
+	publicAskEnabled: z.boolean(),
+	croEnabled: z.boolean(),
+	unattendedEnabled: z.boolean()
 });
 function apply(ctx, config) {
 	try {
@@ -15217,6 +16149,7 @@ function apply(ctx, config) {
 	registerGateway(ctx);
 	registerRebuildTurnHook(ctx);
 	registerOutputGuardHook(ctx);
+	registerUnattendedSeam(ctx);
 	if (config.env) registerEnv(ctx);
 	if (config.opencodeSkills) registerOpencodeSkills(ctx);
 	registerBootstrap(ctx);
@@ -15256,9 +16189,10 @@ function apply(ctx, config) {
 * 任何 live 会话，故 apply 时刻就能解析到，不再需要"等一会儿再试"。
 *
 * 🔒 **必须保留**（它们不是"重试"，删了会引入新缺陷）：
-*  - **反应式再触发**（`agent/session-start` / `session/created` → sync）：宿主重启后
-*    "恢复"旧会话不触发 `session/created`，但**开始对话**会触发 `agent/session-start`
-*    ——这是唯一能把"进程起来时还解析不到、稍后才有会话"这条路径接上的通道。
+*  - **反应式再触发**（`agent/created` / `session/created` → sync）：宿主重启后
+*    "恢复"旧会话不触发 `session/created`，但**开始对话**会触发 `agent/created`
+*    （v0.1.7 前名 `agent/session-start`）——这是唯一能把"进程起来时还解析不到、稍后才有会话"
+*    这条路径接上的通道。
 *  - **`starting` 在飞标志**：防同拍双次 start → `EADDRINUSE`。
 *    （C4 块 A 备注：面宿主亦按面名合并在飞启动，是第二道保险；**本标志仍保留**——
 *    它管的是"解析 root 这段装配流程"的在飞语义，且调试服务的启动替身在测试里被 mock，
@@ -15309,7 +16243,7 @@ function registerSkiff(ctx) {
 			sync();
 		});
 	} catch {}
-	for (const eventName of ["agent/session-start", "session/created"]) try {
+	for (const eventName of ["agent/created", "session/created"]) try {
 		ctx.on(eventName, () => {
 			if (!started) sync();
 		});