@shgroup/dsh-serenity-hooks 1.105.0 → 1.108.0

package/lib/scheduler-B0pB9mxI.js

@@ -0,0 +1,3603 @@
+import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
+import { c as hostAgents, o as listCccs, u as hostService } from "./ccc-roots-DPMwBywc.js";
+import { g as resolveInside } from "./ccc-BmpE3cQz.js";
+import { F as isoLocal, L as localHuman, P as readTrajectoryFile, R as localIdStamp, T as sessionsRoot, b as parseTrajectoryCode, j as TRAJECTORY_FILENAME, k as trajectoryDescOf, p as findSession, v as namingTitleFor } from "./bind-file-B0TuOP89.js";
+import { a as listBoundSessionIds, i as carrierState, n as PLUGIN_SOURCE, r as appendBound } from "./message-source-BTIe2cVO.js";
+import { i as sessionsRootDir, n as findSessionLog, r as hasSessionLogById } from "./cleanup-CPl1SSaK.js";
+import { n as readSimpleSettings } from "./settings-DY4_DYYY.js";
+import { basename, dirname, join } from "node:path";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { hostname } from "node:os";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import * as nodeZlib from "node:zlib";
+//#region src/wake/registry.ts
+/**
+* wake/registry.ts — 认知轨迹唤醒注册表（D58，S142 2026-09-13）
+*
+* 需求（用户原话）：一个 CCC 内允许多个认知轨迹任意形态并行；某个认知轨迹可以
+* **预定未来唤醒自己或别人**，本质上是一次「未来时刻 + 一条 message」的投递；「周期自唤醒」
+* 曾是它的特例（原 ACC autopilot / D59，该机制已于 2026-09-15 整段退场）。协作边界：
+* 互相可见、**无阻塞无等待**。
+*
+* 本模块只负责**注册表本身**（纯数据层，无宿主依赖，可单测）：
+*  - 落点：CCC 内 `AGENT_SESSIONS/wake-registry.json`（随 CCC git，人可读可审计）
+*  - 状态机：`pending` →（投递成功）`delivered`｜（超补跑窗口）`missed`｜（`wake rm` 物理移除）
+*  - 投递即终结：一次性，不重投（无回执语义——发起方不 await，见设计文档 §2）
+*
+* 调度与投递在 `wake/scheduler.ts`（需要 ctx），本模块保持纯净。
+*/
+/** 注册表相对 CCC 根的路径（与 `.bindings.json` 同居 AGENT_SESSIONS/） */
+const WAKE_REGISTRY_REL_PATH = "AGENT_SESSIONS/wake-registry.json";
+/** 注册表格式版本（结构变更时 +1；读取端只接受本版本） */
+const WAKE_REGISTRY_VERSION = 1;
+/**
+* 补跑窗口（缺省 2h）：dsh 停机期间到期的条目，若迟到不超过本窗口则补投，
+* 超过则置 `missed` 留痕（不补投——避免"半夜该做的事早上突然连环跑"）。
+*/
+const WAKE_CATCH_UP_MS = 72e5;
+/** 注册表绝对路径 */
+function wakeRegistryPath(root) {
+	return join(root, WAKE_REGISTRY_REL_PATH);
+}
+/** 空注册表 */
+function emptyRegistry() {
+	return {
+		version: WAKE_REGISTRY_VERSION,
+		entries: []
+	};
+}
+/** 条目形状校验（容忍手改：字段缺失/类型不符 → 丢弃该条，不阻断整表） */
+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;
+	const state = e.state === "delivered" || e.state === "missed" || e.state === "cancelled" ? e.state : "pending";
+	return {
+		id: e.id,
+		target: e.target,
+		at: e.at,
+		message: e.message,
+		state,
+		createdBy: typeof e.createdBy === "string" ? e.createdBy : "",
+		createdAt: typeof e.createdAt === "string" ? e.createdAt : "",
+		attempts: typeof e.attempts === "number" && Number.isFinite(e.attempts) ? e.attempts : 0,
+		lastResult: typeof e.lastResult === "string" ? e.lastResult : null,
+		deliveredAt: typeof e.deliveredAt === "string" ? e.deliveredAt : null
+	};
+}
+/**
+* 读注册表。文件缺失 → 空表；损坏 → 空表 + error（不抛错，调用方决定是否告警）。
+* @param root CCC 根
+* @returns 注册表与读取错误（无错为 null）
+*/
+function loadWakeRegistry(root) {
+	const path = wakeRegistryPath(root);
+	if (!existsSync(path)) return {
+		registry: emptyRegistry(),
+		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$1(item);
+			if (e) entries.push(e);
+		}
+		return {
+			registry: {
+				version: WAKE_REGISTRY_VERSION,
+				entries
+			},
+			error: null
+		};
+	} catch (err) {
+		return {
+			registry: emptyRegistry(),
+			error: `唤醒注册表解析失败（${String(err?.message ?? err)}）`
+		};
+	}
+}
+/** 原子写（tmp + rename；与 .bindings.json 同款形态） */
+function saveWakeRegistry(root, registry) {
+	const path = wakeRegistryPath(root);
+	try {
+		mkdirSync(dirname(path), { recursive: true });
+		const tmp = `${path}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify({
+			version: WAKE_REGISTRY_VERSION,
+			entries: registry.entries
+		}, null, 2)}\n`, "utf-8");
+		renameSync(tmp, path);
+		return {
+			ok: true,
+			error: null
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: `唤醒注册表写入失败（${String(err?.message ?? err)}）`
+		};
+	}
+}
+/** 条目 id：`w-<当地到分钟>-<4 hex>`（可读 + 低碰撞；不复用由"物理移除"保证） */
+function newWakeId(nowMs, rand = Math.random) {
+	return `w-${localIdStamp(nowMs)}-${Math.floor(rand() * 65536).toString(16).padStart(4, "0")}`;
+}
+/**
+* 解析唤醒时刻。接受两种写法（设计文档 §7）：
+*  - 绝对：RFC3339（含时区偏移，如 `2026-09-14T09:00:00+08:00`）
+*  - 相对：`+30m` / `+2h`（便于 agent 直接登记"半小时后"）
+* @param input 用户/agent 传入的时刻串
+* @param nowMs 当前时刻（相对写法基准）
+* @returns `{ ok, ms }` 或 `{ ok: false, error }`
+*/
+function parseWakeAt(input, nowMs) {
+	const raw = input.trim();
+	if (raw === "") return {
+		ok: false,
+		error: "时刻为空"
+	};
+	const rel = /^\+(\d+(?:\.\d+)?)([mhd])$/.exec(raw);
+	if (rel) {
+		const n = Number(rel[1]);
+		const unit = rel[2];
+		return {
+			ok: true,
+			ms: nowMs + n * (unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5)
+		};
+	}
+	const ms = Date.parse(raw);
+	if (!Number.isFinite(ms)) return {
+		ok: false,
+		error: `时刻无法解析（须 RFC3339 或 +30m/+2h）: ${raw}`
+	};
+	return {
+		ok: true,
+		ms
+	};
+}
+/**
+* 登记一条唤醒。
+* @param root CCC 根
+* @param input 目标认知轨迹 / 时刻串 / message / 发起者 / 当前时刻
+* @returns 成功返回条目，失败返回稳定错误文案（不抛错）
+*/
+function addWake(root, input) {
+	const target = input.target.trim();
+	if (target === "") return {
+		ok: false,
+		error: "target 为空（须 S### 或 AGENT_SESSIONS 目录名）"
+	};
+	const message = input.message.trim();
+	if (message === "") return {
+		ok: false,
+		error: "message 为空（唤醒必须携带一条信息）"
+	};
+	const parsed = parseWakeAt(input.at, input.nowMs);
+	if (!parsed.ok) return {
+		ok: false,
+		error: parsed.error
+	};
+	if (parsed.ms <= input.nowMs) return {
+		ok: false,
+		error: "时刻必须在未来（唤醒只允许可预期的未来）"
+	};
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error
+	};
+	const entry = {
+		id: newWakeId(input.nowMs),
+		target,
+		at: isoLocal(parsed.ms),
+		message,
+		state: "pending",
+		createdBy: input.createdBy,
+		createdAt: isoLocal(input.nowMs),
+		attempts: 0,
+		lastResult: null,
+		deliveredAt: null
+	};
+	registry.entries.push(entry);
+	const saved = saveWakeRegistry(root, registry);
+	if (!saved.ok) return {
+		ok: false,
+		error: saved.error ?? "写入失败"
+	};
+	return {
+		ok: true,
+		entry
+	};
+}
+/**
+* 到期切分（纯函数，可单测）：
+*  - `due`：`state === 'pending'` 且 `now >= at`（在补跑窗口内）→ 应投递
+*  - `expired`：`state === 'pending'` 且 `now - at > catchUpMs` → 应置 missed（不投递）
+* @param registry 注册表
+* @param nowMs 当前时刻
+* @param catchUpMs 补跑窗口
+*/
+function splitDueWakes(registry, nowMs, catchUpMs = WAKE_CATCH_UP_MS) {
+	const due = [];
+	const expired = [];
+	for (const e of registry.entries) {
+		if (e.state !== "pending") continue;
+		const at = Date.parse(e.at);
+		if (!Number.isFinite(at) || nowMs < at) continue;
+		if (nowMs - at > catchUpMs) expired.push(e);
+		else due.push(e);
+	}
+	return {
+		due,
+		expired
+	};
+}
+/**
+* 🔴 结案并**移除**一条（owner 2026-09-19 裁定「**直接删**」，S142 §0Q 甲案）。
+*
+* ## 为什么删（R↓）
+*
+* 本模块原本是「`pending` → 终态」但**终态条目永不移除** ⇒ 文件**只增**（实测 308 KB / 143+ 条）。
+* owner 明令「应当**唤醒后就清理**的」⇒ 终态即删。
+*
+* **审计不丢**：由 **SESSION.md 与工具输出**承担——这正是本文件 `removeWake` 的既有注释承诺
+* （*"审计由 SESSION.md 与工具输出承担——注册表只保留在办项"*）。
+* ⚠️ 此前该承诺**并未兑现**（`updateWake` 只改 state 从不删行）⇒ 本次是**把承诺做实**。
+*
+* ## 与 `updateWake` 的分工（**别混用**）
+*
+* - `updateWake`：**仍在办**的推进（失败重试 `state:'pending'` + `attempts+1`）⇒ **保留行**；
+* - `finalizeWake`：**不再办**的归宿（投递成功 / 超窗 missed）⇒ 写终态后**同一笔事务里删掉**。
+*
+* 🔴 **为什么两个动作要同一次写盘**：若先 `updateWake(delivered)` 再 `removeWake`，
+* 中间被打断会留下一条"已终结但没删"的条目 ⇒ 又回到只增。
+* 故本函数**读一次、改一次、删一次、写一次**（单次原子落盘）。
+*
+* @param root CCC 根
+* @param id 条目 id
+* @param terminal 终态（`delivered` / `missed` / `cancelled`）——写入仅用于**日志文案**，
+*                 随即整行移除；保留该参数是为了让调用点语义自明（"它归到哪一档了"）。
+* @param result 人读结果（进日志，不进表）
+* @returns `removed` = 被移除的条目（供调用方打印"它是什么"）；不存在 → 稳定错误码
+*/
+function finalizeWake(root, id, terminal, result) {
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error,
+		removed: null
+	};
+	const idx = registry.entries.findIndex((e) => e.id === id);
+	if (idx < 0) return {
+		ok: false,
+		error: `wake_not_found: ${id}`,
+		removed: null
+	};
+	const [removed] = registry.entries.splice(idx, 1);
+	const saved = saveWakeRegistry(root, registry);
+	if (!saved.ok) return {
+		ok: false,
+		error: saved.error,
+		removed: null
+	};
+	return {
+		ok: true,
+		error: null,
+		removed: {
+			...removed,
+			state: terminal,
+			lastResult: result
+		}
+	};
+}
+/**
+* 一次性清除**存量终态条目**（`delivered` / `missed` / `cancelled`）。
+*
+* ## 为什么需要（不是可选）
+*
+* 本函数上线前，表里已积压 143+ 条终态记录（308 KB）⇒ **只改行为不改存量 = 文件不再涨但仍很大**。
+* 故首次运行须清一次。**幂等**（无终态条目时空转，不写盘）。
+*
+* 审计不丢：与 `finalizeWake` 同理（终态本就属性"已结案"，其史由 SESSION.md 承担）。
+* @param root CCC 根
+* @returns 清掉几条（0 = 本来就没有）
+*/
+function purgeFinalizedWakes(root) {
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error,
+		purged: 0
+	};
+	const kept = registry.entries.filter((e) => e.state === "pending");
+	const purged = registry.entries.length - kept.length;
+	if (purged === 0) return {
+		ok: true,
+		error: null,
+		purged: 0
+	};
+	const saved = saveWakeRegistry(root, {
+		...registry,
+		entries: kept
+	});
+	if (!saved.ok) return {
+		ok: false,
+		error: saved.error,
+		purged: 0
+	};
+	return {
+		ok: true,
+		error: null,
+		purged
+	};
+}
+/**
+* 更新一条（状态推进；调用方给最终状态与结果文案）。
+*
+* ⚠️ **只用于"仍在办"的推进**（主要是失败重试）。**终态请用 `finalizeWake`**——
+* 否则该行会永远留下（这正是本表过去只增的根因，见 `finalizeWake` 注释）。
+* @param root CCC 根
+* @param id 条目 id
+* @param patch 要写入的字段
+* @returns 写入结果
+*/
+function updateWake(root, id, patch) {
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error
+	};
+	const entry = registry.entries.find((e) => e.id === id);
+	if (!entry) return {
+		ok: false,
+		error: `wake_not_found: ${id}`
+	};
+	Object.assign(entry, patch);
+	return saveWakeRegistry(root, registry);
+}
+/** 列条目（默认全量；`pendingOnly` 只列在办项——面板/工具用） */
+function listWakes(root, opts = {}) {
+	const { registry, error } = loadWakeRegistry(root);
+	return {
+		entries: [...opts.pendingOnly ? registry.entries.filter((e) => e.state === "pending") : registry.entries].sort((a, b) => Date.parse(a.at) - Date.parse(b.at)),
+		error
+	};
+}
+//#endregion
+//#region src/trajectory/user-carrier.ts
+/**
+* trajectory/user-carrier.ts — **造一条与"用户人工创建"基本一致的 dsh 会话载体**（判决 D171，owner 2026-10-20 裁 B）
+*
+* ## 这个文件解决什么（白话）
+*
+* `send-now` 在目标没有活跃会话时会**就地建一条**。它一直能建、也能挂工作区，
+* 但建出来的东西与用户在 UI 里新建的那条**在宿主眼里不是同一种东西**：
+*
+* | 宿主投影 | 用户建 | 我们自建（修前实测） |
+* |---|---|---|
+* | `title` | 自动生成 | **永远 `null`** |
+* | `titleInput.count` | ≥1 | **0** |
+* | 假首轮（对齐声明 ＋ EAP） | 注入 | **被自家递归守卫挡掉** |
+*
+* ## 🔴 根因（读宿主源码，不是推断）
+*
+* `dsh-session-title` 的 `sessionTitleUserMessageOf()` **第一行**就是：
+*
+* ```js
+* if (event.type !== "user/message" || event.data.source.kind !== "user") return void 0
+* ```
+*
+* 而 ACC 投递的消息一律是 `{ kind: 'plugin:dsh-serenity-hooks' }`（`kernel/message-source.ts`）
+* ⇒ **宿主从头到尾不把它当"有真人说过话"的会话** ⇒ 自动命名不触发、`titleInput` 恒 0。
+*
+* ## owner 的裁决 = B：**模拟一个用户开场白**
+*
+* `MessageSourceMap` 里 `user: { kind: 'user' }`，而 `UserMessage.source` 是**任意**
+* `MessageSource` ⇒ `createUserMessage({ content, source: { kind: 'user' } })` **类型合法、
+* 零改 DSH**（D4 仍成立）。
+*
+* ## 🔴 这是一次**明知故犯的伪造**，代价写在这里，不许悄悄付
+*
+* 1. **伪造用户身份**：与 D160「不再造历史」方向相反。范围**仅限**"载体开场白"这一条消息，
+*    且正文**逐字自证**是模拟的（{@link CARRIER_OPENING_MARK}）⇒ 将来翻日志的人一眼能看出。
+* 2. **污染所有者语料**：`session-corpus` 的"所有者发言"判据**必须**排除这条
+*    （判据 = 正文含 {@link CARRIER_OPENING_MARK}）⇒ 否则统计"owner 说过什么"会算进一句
+*    机器写的开场白。**这一条是同批改动，不是待办。**
+* 3. **与假首轮的先后**：开场白必须让假首轮先注入（同一次 `agent/inbox/inserted` 里
+*    prepend 天然排在真实消息之前），否则 `hasUserMessageHistory` 会把假首轮挡掉。
+*    ⇒ 单测钉死顺序，不靠"应该会"。
+*
+* ## 归属（D23）
+* 机制在 ACC（怎么建、建什么形状）；**内容归 CCC**（开场白正文由调用方给）。
+*
+* ## 与 `trajectory/carrier.ts` 的关系
+* 🔴 **两个文件、两件事**，名字刻意区分：`carrier.ts` 回答"**这条载体跑完没有**"（等待空闲／销毁竞速）；
+* 本文件回答"**怎么造一条载体**"。合在一起会让两条互不相关的依赖链卷成一团。
+*/
+/**
+* 模拟开场白的**自证标记**（逐字）。
+*
+* 🔴 三个用途，缺一不可：
+* ① 人类翻日志时能一眼看出"这不是真主说的"；
+* ② `session-corpus` 用它**排除**语料（不污染"所有者发言"）；
+* ③ 单测反向钉住：真实用户发言里**不会**出现这串 ⇒ 断言"语料里 0 条含它"才有意义。
+*/
+const CARRIER_OPENING_MARK = "[ACC 代用户开场]";
+/**
+* 构造模拟开场白的正文。
+*
+* ⚠️ **不含版本号／日期／模型名**（D159：任务书里不得写死版本号 ⇒ 写与版本无关的判据）。
+* 正文只描述"这是谁、要接着做什么"，不描述"哪一版干的"。
+*
+* @param code 轨迹编码（`S###` 或自定义）
+* @param desc 轨迹目录名里那段可读描述（**人起的**，不另造第二真相源）
+* @returns 一条自证是模拟的开场白正文
+*/
+function buildCarrierOpening(code, desc) {
+	const label = desc.trim() === "" ? code : `${code}（${desc}）`;
+	return [
+		`${CARRIER_OPENING_MARK} 激活认知轨迹 ${label}，接着它 SESSION.md 里的工作往下做。`,
+		"",
+		"（这条开场白由 ACC 代为发出。如此做的目的只有一个：让程序性创建的会话与用户在界面里",
+		"人工创建的会话，在宿主侧具有相同的投影 —— 有标题、有首轮对齐声明。它不是任何人的发言。）"
+	].join("\n");
+}
+/**
+* 投一条"用户形态"的消息进目标 agent（**B 的核心动作**）。
+*
+* 🔴 为什么单独成函数而不是就地写：这是**全仓唯一**允许 `kind:'user'` 的地方。
+* 集中在一处，将来若要收紧（或 owner 改主意回 A），只有一个点要改。
+*
+* @param agent 目标 agent（须有 `followup`）
+* @param text 开场白正文（**必须**由 {@link buildCarrierOpening} 产出，以带上自证标记）
+* @returns 投递是否成功（失败返回 false，由调用方决定降级 —— 不抛）
+*/
+function deliverCarrierOpening(agent, text) {
+	if (typeof agent.followup !== "function") return false;
+	try {
+		agent.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text
+			}],
+			source: { kind: "user" }
+		}));
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/trajectory/alive.ts
+/**
+* trajectory/alive.ts — **"这个 dsh 会话还活着吗"的唯一判据**（owner 2026-10-20 裁决）
+*
+* ## owner 的原话（本模块的全部设计依据）
+*
+* > 「死应该包含归档判断；只有 ① 或者 ②且不在归档集 才算活」
+* > 「use 只要被调用了，可以无条件覆盖绑定到当前会话（这说明当前会话肯定活着啊）」
+*
+* ## 为什么必须收成一个判据（在此之前有三个互不一致的判据）
+*
+* | # | 判据 | 旧实现位置 | 单独使用时的漏洞 |
+* |---|---|---|---|
+* | ① | 进程内 loaded agent | `hostAgents(ctx).get(id)` | 冷会话全判死 |
+* | ② | 磁盘上有会话日志 | `hasSessionLogById()` | **归档后日志逐字节不动** ⇒ 归档会话判活 |
+* | ③ | 宿主归档集 | `workspaceRegistry.archivedSessionIds` | 旧 dsp **零引用**（整个仓库 0 处） |
+*
+* 宿主的归档语义是**只往集合里加一个 id、不动日志**（`dsh-workspace` 的
+* `archiveSession` 注释：「Archiving never touches workspace accounting」）。
+* ⇒ 只问 ② 的实现在归档上**必然判错**，而那个错误没有任何机械信号。
+*
+* ## 判据（owner 给定，逐字实现）
+*
+* ```text
+* 活 ⟺ ①                       （进程内 loaded ⇒ 一定在）
+*    ∨ (② ∧ 不在归档集)          （日志在、且没人把它归档掉）
+* ```
+*
+* 🔴 **一处对原话的收紧（必须说出来，不许默默改）**：owner 的 ① 未附加"不在归档集"，
+* 而本模块把**归档判定排在最前** —— 即 `归档 ∧ live ⇒ 判死`。理由：归档是**人对这条会话
+* 的处置声明**（宿主会把它从所有分组面隐藏），若仍被当成载体，唤醒调度器会去驱动一条
+* **使用者以为已经收起来**的会话。⚠️ 与字面规则的差异仅此一格；`use` 不受影响
+* （见下方 §use 逃生门），因此真需要复活一条已归档会话时**仍然有受支持的路**。
+*
+* ## 🔴 `use` 的逃生门（owner 第二条，写在调用点）
+*
+* **`use` 不查存活**：它被调用这件事本身证明**当前会话活着**（本模块的被测对象是
+* "别人写的那个 id"，而 `use` 手里拿的是**自己**）。⇒ `use` 走无条件覆盖
+* （`claimBinding` 的 `takeover`），因此**判据再严也不会把一条轨迹锁死**。
+* 这条逃生门是判据可以取严的前提，两者必须一起存在。
+*
+* ## 依赖纪律
+*
+* 纯判据 `isSessionAlive` 零依赖、可单测；宿主面只在 `hostAliveProbe` 里，
+* 且**不抛错**（服务缺失 ⇒ 该维度作废，而不是让 ACC 工具整块失败）。
+*/
+/** 宿主侧的归档集读取（不可用 ⇒ 空集 = 该维度作废，**不是**把所有会话判死） */
+function archivedIdsOf(ctx) {
+	try {
+		const ids = hostService(ctx, "workspaceRegistry")?.archivedSessionIds;
+		return new Set(Array.isArray(ids) ? ids : []);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/**
+* **宿主面的判活探针**（`(sessionId) => boolean`）——所有需要"这条会话还活着吗"的
+* 生产代码都应当用这一个，不要自己拼 `agents.get` ＋ `hasSessionLogById`。
+*
+* 语义 = {@link isSessionAlive}，其中：
+*  · `liveIds` 因为宿主只给 `get(id)` 而**按 id 逐次问**（不是集合）；
+*  · `archivedIds` 在**首次调用时**取一次快照并在闭包内复用（每 tick 一个探针，
+*    归档集在一个 tick 内不变）—— 避免为每条轨迹重复读存储域。
+*
+* ⚠️ **快照的代价**：同一探针内若有人中途归档了某会话，本探针直到下次新建才看见。
+*    调度器是每 tick 新建一个探针（见 `wake/scheduler.ts`），故实际窗口 ≤1 tick。
+*
+* @param ctx 插件上下文（取 `agents` 与 `workspaceRegistry`）
+* @returns 探针；**永不抛**
+*/
+function hostAliveProbe(ctx) {
+	let archived;
+	const archivedOnce = () => archived ??= archivedIdsOf(ctx);
+	return (sessionId) => {
+		if (typeof sessionId !== "string" || sessionId === "") return false;
+		if (archivedOnce().has(sessionId)) return false;
+		try {
+			if (hostAgents(ctx)?.get?.(sessionId)) return true;
+		} catch {}
+		try {
+			return hasSessionLogById(sessionsRootDir(), sessionId);
+		} catch {
+			return true;
+		}
+	};
+}
+/**
+* 判据只有**两个**出口，别再开第三个：
+*  · {@link isSessionAlive} —— 纯判据（给定事实），单测的靶子；
+*  · {@link hostAliveProbe} —— 生产入口（自己去宿主与磁盘取事实）。
+*
+* ⚠️ 曾有一个 `aliveFactsFor`（把探针摊平成 `SessionAliveFacts`），**全仓零调用点**，
+* 已删除 —— 留一个"看起来有用、实际无人调用"的导出，会让下一个人以为存在第二条判活路径
+* （本仓同族教训：`cheapWorkerPresetInheritance` 全仓零调用点 ⇒ 接线断了却看不出来）。
+*/
+//#endregion
+//#region src/cro/core.ts
+/**
+* cro/core.ts — CRO（Continuous Re-Occurrence · 持续再发生）机制层（S142 §7.8，2026-09-19）
+*
+* ## 这东西用来干什么（白话）
+*
+* 今天叫醒一条轨迹的方式是「几点几分叫我」。但**该不该醒，往往不是时间说了算**：
+* 比如 S185 应该「天亮 + 家里有人 + 非高峰」才醒；已经在干活就不该再叫；
+* 日志太大了，下次叫它时该让它先整理。
+*
+* CRO 让**一条轨迹自己带一段程序**，由 ACC 在每次检查时跑它，
+* **由这段程序决定「现在该不该叫我、叫我的时候说什么」**。
+*
+* ## 归属（所有者 2026-09-19 定：**机制属 ACC，CCC 是用户**）
+*
+* | 面 | 归谁 | 内容 |
+* |---|---|---|
+* | **机制** | 🔴 **ACC（本模块）** | 契约 / 调度 / 执行 / 状态暴露 / 容错 |
+* | **程序** | 🔴 **CCC（用户）** | 那段判定的 TS 代码，放**轨迹自己的目录**里 |
+*
+* ⇒ 与 `send-later` 同构：**工具在 ACC，用它在 CCC**。
+*
+* ## 命名（防混淆，写死）
+*
+* **`CRO` = 那段程序**（实体名），**不是** ACC 标准 §0.1 三环节（发生/存储/**再发生**）的第三环本身。
+* 命名来源 = §0.3「**Trajectory 在寻找 Agent**」——CRO 是「再发生」这一环的自动化。
+*
+* ## 位置与形态（设计 §2）
+*
+* `<CCC 根>/AGENT_SESSIONS/<轨迹目录>/continuous-re-occurrence.ts`
+* · **文件名全写**（所有者令）；· **程序只有一个**：**文件在 = 启用，不在 = 禁用**（无 enabled 字段、无注册表）。
+*
+* ## 🔴 运行契约 = B 案（**ACC 只 spawn，从不 import**）
+*
+* 所有者 2026-09-19：「**B 是设计，A 只是文档友好**」。
+* 若 ACC **import** 那段 TS，会出现两件事：
+*   ① ACC 依赖 CCC 的**源码路径**（npm 装机版在别处 ⇒ 两条路径都要活 = 两个真相源）；
+*   ② **用户程序语法错会让 ACC 启动失败** ⇒ **一个用户程序的错误放倒整个容器**。
+* ⇒ 进程边界把这两件事同时挡掉：**路径只需一个（文件系统），错误被隔离在子进程里**。
+*
+* ## 🔴 铁律：CRO 的任何失败，绝不影响既有机制（设计 §5）
+*
+* `send-later` / `send-now` / 唤醒表的投递**照常工作**。
+* 先例 = `im/hook.ts` 的**旁路容忍**（"超时 kill / 非 0 退出 / spawn 失败 → 仅日志返回，绝不抛"）。
+* ⇒ 本模块的**每一个**导出函数**都不抛错**（返回结构化失败）。
+*/
+/** 入口文件名（**全写**，所有者令 2026-09-19；不改缩写） */
+const CRO_FILENAME = "continuous-re-occurrence.ts";
+/**
+* 机器绑定文件名（**全写**，与 `CRO_FILENAME` 同风格）。
+*
+* 🔴 **它随 CCC git 走是设计意图，不是缺陷**：
+* 绑定声明必须跟着**轨迹**走，才能在第二台机器上被读到、并被判为"不是我的"。
+* （这正是机器绑定的整个目的 —— 见 `resolveCroHostBinding` 的头注。）
+*/
+const CRO_HOST_FILENAME = "cro-host-binding";
+/** 硬超时（沿用 `biasProvider` 先例的 60s；设计 §5 情形 2） */
+const CRO_TIMEOUT_MS = 6e4;
+/** stdout 上限（防一个坏程序把日志撑爆；沿用 hook 截断思路） */
+const CRO_STDOUT_MAX = 65536;
+/** 绑定文件体积上限（它只是个机器名 ⇒ 超过这个数一定是写错了，不读） */
+const CRO_HOST_FILE_MAX = 1024;
+/** SESSION.md 文件名（与 `trajectory/core.ts` 同值；此处本地常量避免反向依赖） */
+const SESSION_MD = "SESSION.md";
+/**
+* 展示码派生（**只用于展示**，不作识别依据 —— §0I U4：锚永远是 `dirName`）。
+*
+* 判据（设计 §1）：**编号不是固定格式，不同 CCC 格式不同**（本容器 `S###`，别处可能是 issue 号
+* 或自定义前缀）⇒ 这里只做**尽力而为的展示性提取**，取不到就返回空串。
+* 🔴 **绝不**因为取不到就拒绝服务——`dirName` 才是硬锚。
+* @param dirName 轨迹目录名
+* @returns `S###` 形态的展示码；取不到 ⇒ `''`
+*/
+function deriveCode(dirName) {
+	const m = /(?:^|--)S(\d{2,})(?:--|$)/.exec(dirName);
+	return m ? `S${m[1]}` : "";
+}
+/** epoch ms → 当地 ISO（不可解析 ⇒ null） */
+function isoOrNull(ms) {
+	return typeof ms === "number" && Number.isFinite(ms) ? isoLocal(ms) : null;
+}
+/**
+* 装配快照（**纯函数**：只做数据整形，不读 fs、不看 ctx）⇒ 可穷举测试。
+* @param input 已读好的原始数据
+* @returns 喂给 CRO 程序的快照
+*/
+function buildCroSnapshot(input) {
+	return {
+		version: 1,
+		identity: {
+			dirName: input.dirName,
+			code: deriveCode(input.dirName),
+			cccRoot: input.cccRoot
+		},
+		time: {
+			now: isoLocal(input.nowMs),
+			nowMs: input.nowMs,
+			nowLocal: new Date(input.nowMs).toString()
+		},
+		body: {
+			sessionMdPath: input.sessionMdPath,
+			sessionMdBytes: input.sessionMdBytes,
+			sessionMdMtime: isoOrNull(input.sessionMdMtimeMs),
+			references: input.references.map((r) => ({
+				name: r.name,
+				bytes: r.bytes,
+				mtime: isoLocal(r.mtimeMs)
+			}))
+		},
+		binding: {
+			boundSessionIds: input.boundSessionIds,
+			liveSessionIds: input.liveSessionIds,
+			runningSessionIds: input.runningSessionIds
+		},
+		scheduling: {
+			pendingWakes: input.pendingWakes,
+			scheduler: input.scheduler
+		}
+	};
+}
+/**
+* 解析 CRO 程序 stdout（**纯函数** ⇒ 可穷举测试）。
+*
+* ## 边界（设计 §4.1）
+* · `wake` 缺省 / `false` ⇒ **不唤起**（**这是常态**）——`prompt` 可省；
+* · `wake: true` 但 `prompt` 空 / 非串 ⇒ 🔴 **非法** ⇒ 返回错误（调用方**跳过本轮**，不投递空消息）；
+* · 非 JSON / 非对象 ⇒ 错误。
+*
+* ## 🔴 为什么 `reason` 重要（CCE：重建 > 保存）
+* 改成程序判定后，**「当时为什么叫了」不再能从时间表重建**（原因在程序肚子里：
+* 可能有随机、可能看了外部数据）⇒ 要求程序自报理由，把「决策依据」重新变成**可重建的**。
+* ⇒ **强烈建议但不强制**（强制会让简单程序难写；设计 §9-6 待裁，本版取"建议"）。
+*
+* @param stdout 程序标准输出（可含前后空白；允许多行 JSON 文本）
+* @returns 决策 或 结构化错误
+*/
+function parseCroOutput(stdout) {
+	const text = stdout.trim();
+	if (text === "") return {
+		ok: false,
+		error: "cro-empty-output",
+		detail: "程序没有输出（期望 stdout 一行 JSON）"
+	};
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch (err) {
+		return {
+			ok: false,
+			error: "cro-bad-json",
+			detail: `输出不是合法 JSON: ${String(err?.message ?? err)}`
+		};
+	}
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {
+		ok: false,
+		error: "cro-bad-json",
+		detail: "输出必须是 JSON 对象"
+	};
+	const obj = raw;
+	const wake = obj.wake === true;
+	const reason = typeof obj.reason === "string" && obj.reason.trim() !== "" ? obj.reason.trim() : null;
+	if (!wake) return {
+		ok: true,
+		decision: {
+			wake: false,
+			prompt: null,
+			reason
+		}
+	};
+	if (typeof obj.prompt !== "string" || obj.prompt.trim() === "") return {
+		ok: false,
+		error: "cro-missing-prompt",
+		detail: "wake=true 但 prompt 缺失或为空"
+	};
+	return {
+		ok: true,
+		decision: {
+			wake: true,
+			prompt: obj.prompt.trim(),
+			reason
+		}
+	};
+}
+/**
+* CRO 程序路径：`<CCC 根>/AGENT_SESSIONS/<dirName>/continuous-re-occurrence.ts`。
+*
+* ⚠️ 路径逃逸校验（`resolveInside`）：`dirName` 来自配置/工具入参，
+* 必须确保解析后仍在 CCC 根内（同 `im/hook.ts:160` 手法）。**抛错由调用方吞**。
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @returns 绝对路径
+*/
+function croScriptPath(root, dirName) {
+	return resolveInside(root, join("AGENT_SESSIONS", dirName, CRO_FILENAME));
+}
+/**
+* 解析机器绑定 —— 「**这条轨迹由哪台机器负责自唤醒**」（所有者令 2026-10-15）。
+*
+* ## 所有者裁定的语义（逐字，D135）
+*
+* 「**CRO 必须指定绑定机器，否则不运行，唤醒器 检查这个**」⇒ 三条同时成立：
+* ① **只许这一台**（白名单，不是"排除这一台"）；
+* ② **fail-closed** —— **没绑 = 不跑**（不是"没绑 = 随便跑"）；
+* ③ **检查者在唤醒器**（本函数由 `runCroPhase` 调用，不是程序自己判）。
+*
+* ## 绑定键 = 机器名（所有者 2026-10-15 裁「用 hostname 吧，比较合理」）
+*
+* ⚠️ **已接受的取舍**：本机机器名是 QEMU 机型派生的默认形
+* （`yh-Standard-PC-Q35-ICH9-2009`）⇒ 同法新建的同名用户 VM 会取到同一个名字。
+* 所有者 2026-10-15 明确「**不改名，家里就这几台机器没必要**」⇒ **风险由所有者接受**。
+*
+* ## 🔴 为什么必须是三态，「没绑」不能并进「绑给别人」
+*
+* 2026-10-15 已发生过**同族事故**：`send-now` 失败时报的是「无绑定会话记录」，
+* 而真因是"那条轨迹不可寻址"—— **文案相同、原因不同**，害得排查方向错了一次
+* （S142 §日志 续 129 / D134）。
+* ⇒ 绑定这一层**不许再造同样的坑**：「你没绑」与「你绑给了别人」是**两件不同的事**，
+*   日志必须分开写 —— 否则将来"为什么这条轨迹不跑了"会又一次指错方向。
+*
+* ## 文件形态（刻意的极简）
+*
+* · 位置 = `<轨迹目录>/cro-host-binding`（与 CRO 程序**同级**）
+* · 内容 = **一行机器名**（首尾空白裁掉；只取第一行有效内容）
+* · 不用 JSON —— 它只有一个值，JSON 只会多一种写错的方式
+* · 支持 `#` 注释行与空行（方便人写、方便留痕）
+*
+* 🔴 **它必须随 git 入库**（不是"运行态"）：绑定声明要**跟着轨迹走到第二台机器**，
+*   在那里被判成「绑给了别人」而**正确地不跑** —— 那就是本机制在工作。
+*   ⇒ ⛔ **不要把它加进 `.gitignore`**（那会让第二台机器读到"没绑"而同样不跑，
+*   表面上结果一样，但**判据从"明确绑给别人"退化成"什么都没说"**，失去可诊断性）。
+*
+* ## 为什么读文件而不是读快照字段
+*
+* 快照（`CroSnapshot`）是喂给**程序**的；而本判定发生在**程序被 spawn 之前**
+* —— 程序还没跑，没有快照可读。⇒ 只能读文件。（这也是"机制属 ACC"的体现：
+* ACC 在调用用户程序前先判定自己该不该调用。）
+*
+* ## 🆕 2026-10-19 owner 裁 Q2：**声明文件里的 `cro.host` 优先，独立文件回落**
+*
+* 收拢后机器名住在 `<轨迹目录>/trajectory.json` 的 `cro.host` 字段里。
+* 判据（**两代并读，不硬切**）：**声明面里有合法 `cro.host` ⇒ 用它；否则回落 `cro-host-binding` 文件**。
+*
+* 🔴 **为什么这里绝不能硬切**（比别处更硬的一条，逐字保留原裁定）：
+* 硬切之后，**第二台机器**读到的是「没绑」而不是「绑给了别人」——
+* 两者都导致"不跑"，**表面结果相同，但判据退化**（失去可诊断性）。
+* ⇒ 只要还有一台机器可能装着旧版本，两条路都必须能读。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @param selfHost 本机机器名（**注入** ⇒ 可测；生产调用方传 `hostname()`）
+* @returns 判定结果（**永不抛** —— 旁路容忍铁律）
+*/
+function resolveCroHostBinding(root, dirName, selfHost) {
+	const self = String(selfHost ?? "").trim();
+	let fileAbs;
+	try {
+		fileAbs = resolveInside(root, join("AGENT_SESSIONS", dirName, CRO_HOST_FILENAME));
+	} catch (err) {
+		return {
+			allowed: false,
+			bound: null,
+			self,
+			code: "read-error",
+			detail: `绑定文件路径非法（已忽略）：${String(err?.message ?? err)}`
+		};
+	}
+	const fromJson = readCroHostFromDeclaration(root, dirName);
+	if (fromJson !== null) return verdictFor(fromJson, self);
+	let raw;
+	try {
+		if (!existsSync(fileAbs)) return {
+			allowed: false,
+			bound: null,
+			self,
+			code: "not-bound",
+			detail: `未绑定机器（缺 ${CRO_HOST_FILENAME}，且 ${TRAJECTORY_FILENAME} 里也没有 cro.host）⇒ 按"必须指定"不运行`
+		};
+		const st = statSync(fileAbs);
+		if (st.size > CRO_HOST_FILE_MAX) return {
+			allowed: false,
+			bound: null,
+			self,
+			code: "read-error",
+			detail: `绑定文件过大（${st.size} B > ${CRO_HOST_FILE_MAX} B）⇒ 判为写错，不运行`
+		};
+		raw = readFileSync(fileAbs, "utf-8");
+	} catch (err) {
+		return {
+			allowed: false,
+			bound: null,
+			self,
+			code: "read-error",
+			detail: `绑定文件读取失败 ⇒ 不运行：${String(err?.message ?? err)}`
+		};
+	}
+	const bound = parseCroHostBinding(raw);
+	if (bound === null) return {
+		allowed: false,
+		bound: null,
+		self,
+		code: "not-bound",
+		detail: `绑定文件为空（只有注释/空行）⇒ 按"必须指定"不运行`
+	};
+	return verdictFor(bound, self);
+}
+/**
+* 从**声明文件**（`trajectory.json` 族）里取 `cro.host`（取不到 ⇒ `null`）。
+*
+* 🔴 **永不抛**：本函数跑在 tick 内（旁路容忍铁律）；坏 JSON / 结构不符一律按"没给"处理，
+* 于是**自然回落到独立文件那条路** —— 这正是两代并读想要的降级方向。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @returns 机器名；没给 ⇒ `null`
+*/
+function readCroHostFromDeclaration(root, dirName) {
+	try {
+		const cro = readTrajectoryFile(join(sessionsRoot(root), dirName))?.data?.["cro"];
+		if (!cro || typeof cro !== "object" || Array.isArray(cro)) return null;
+		const host = cro["host"];
+		if (typeof host !== "string") return null;
+		const trimmed = host.trim();
+		return trimmed === "" ? null : trimmed;
+	} catch {
+		return null;
+	}
+}
+/**
+* 已解析出的机器名 → 判定结果（三种态的唯一收敛点）。
+*
+* 🔴 **抽出来的理由**：两条读取路（声明文件 / 独立文件）必须给出**同一种**判定语义；
+* 各写一份迟早会漂（"声明面绑给别人"与"文件面绑给别人"在日志里长得不一样就糟了）。
+*/
+function verdictFor(bound, self) {
+	if (bound === self) return {
+		allowed: true,
+		bound,
+		self,
+		code: "bound-to-self",
+		detail: `已绑定本机（${bound}）`
+	};
+	return {
+		allowed: false,
+		bound,
+		self,
+		code: "bound-to-other",
+		detail: `绑定给别的机器（绑定=${bound}，本机=${self}）⇒ 本机不运行`
+	};
+}
+/**
+* 解析绑定文件正文 ⇒ 机器名（取不到 ⇒ `null`）。
+*
+* 规则（刻意宽松：**只认一行，其余都当注释**）：
+* · 逐行扫；跳过空行与 `#` 开头的行；
+* · **第一条有效行** = 机器名（裁首尾空白）；
+* · 无有效行 ⇒ `null`。
+* @param raw 文件正文
+* @returns 机器名；无有效内容 ⇒ `null`
+*/
+function parseCroHostBinding(raw) {
+	for (const line of String(raw ?? "").split(/\r?\n/)) {
+		const t = line.trim();
+		if (t === "" || t.startsWith("#")) continue;
+		return t;
+	}
+	return null;
+}
+/**
+* 列出**启用了 CRO 的轨迹目录名**（供调度器每 tick 扫描，设计 §6.1）。
+*
+* ## 判据与形态（R↓）
+* · 判据 = **文件在不在**（同 §2.1）——**没有注册表**，所以"谁启用了"只能靠**扫目录**：
+*   `AGENT_SESSIONS/` 下每个目录查一次 `<目录>/continuous-re-occurrence.ts`。
+* · **一次 readdir + 每个目录一次 existsSync**：N 条轨迹的代价是 O(N) 次 `stat`，
+*   每 5min 一次 —— 与既有 `listSessions` 同量级，可接受。
+* · 跳过 **`_` 前缀**（`_archived` / `_轨迹约束-logs` / `_weixin-logs` = 系统与日志目录）
+*   与 **`.` 前缀**（隐藏）——它们**不是轨迹**，且扫它们纯属浪费。
+* · 🔴 **本函数绝不抛错**（返回 `[]`）——它跑在调度器 tick 内，任何异常都可能影响既有链路
+*   （设计 §5 铁律）。目录读不到（不存在 / 权限）⇒ `[]` = "没有轨迹启用 CRO"，语义正确。
+*
+* ⚠️ **为什么不做缓存**：缓存会引入"文件删了但缓存还在"的失效模式（本容器栽过的"第二真相源"），
+* 而这里省下的只是一次 `readdir`——**不值当**。
+*
+* @param root CCC 根
+* @returns 启用了 CRO 的轨迹目录名（**排序后**，保证同 tick 顺序稳定、便于日志比对）
+*/
+function listCroCognitiveTrajectories(root) {
+	const rootDir = sessionsRoot(root);
+	let entries;
+	try {
+		entries = readdirSync(rootDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const e of entries) {
+		if (!e.isDirectory()) continue;
+		if (e.name.startsWith("_") || e.name.startsWith(".")) continue;
+		try {
+			if (existsSync(join(rootDir, e.name, "continuous-re-occurrence.ts"))) out.push(e.name);
+		} catch {}
+	}
+	return out.sort();
+}
+/**
+* 执行一次 CRO 程序（**永不抛** —— 旁路容忍铁律）。
+*
+* runner 顺序（照 `im/hook.ts:171-174` 的 bun 优先 / node 兜底）：
+* `bun` → `process.execPath`（同运行时）。
+* 判据：`ENOENT`（二进制不存在）⇒ 试下一个；**其余失败视为最终结果**
+* （程序自己报错就是报错，不该用另一个 runner 掩盖——与 hook 一致）。
+* @param scriptAbs 程序绝对路径
+* @param stdinJson 喂给程序的快照 JSON
+* @param timeoutMs 硬超时
+* @returns 执行结果（含输出的解析交由 `parseCroOutput`）
+*/
+async function runCroProcess(scriptAbs, stdinJson, timeoutMs = CRO_TIMEOUT_MS) {
+	const runners = [["bun", [scriptAbs]], [process.execPath, [scriptAbs]]];
+	for (const [cmd, args] of runners) {
+		const res = await runCroOnce(cmd, args, stdinJson, timeoutMs);
+		if (!res.ok && res.code === "ENOENT") continue;
+		return res;
+	}
+	return {
+		ok: false,
+		stdout: "",
+		error: "CRO 执行失败（bun 与 node 均不可用）",
+		code: "cro-no-runner"
+	};
+}
+/** 单次 spawn（Promise 化 + 超时 kill + 输出截断 + **绝不抛**） */
+function runCroOnce(cmd, args, stdinJson, timeoutMs) {
+	return new Promise((resolvePromise) => {
+		let settled = false;
+		let stdout = "";
+		let stderr = "";
+		let child = null;
+		try {
+			child = spawn(cmd, args, {
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				env: { ...process.env }
+			});
+		} catch (err) {
+			return resolvePromise({
+				ok: false,
+				stdout: "",
+				error: String(err),
+				code: "SPAWN_ERR"
+			});
+		}
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			child?.kill("SIGKILL");
+			resolvePromise({
+				ok: false,
+				stdout,
+				error: `CRO 执行超时（>${Math.round(timeoutMs / 1e3)}s，已 kill）`,
+				code: "cro-timeout"
+			});
+		}, timeoutMs);
+		child.stdin?.on("error", () => {});
+		try {
+			child.stdin?.write(stdinJson);
+			child.stdin?.end();
+		} catch {}
+		child.stdout?.on("data", (d) => {
+			stdout = (stdout + d.toString()).slice(0, CRO_STDOUT_MAX);
+		});
+		child.stderr?.on("data", (d) => {
+			stderr = (stderr + d.toString()).slice(0, CRO_STDOUT_MAX);
+		});
+		child.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolvePromise({
+				ok: false,
+				stdout,
+				error: String(err.message ?? err),
+				code: err.code
+			});
+		});
+		child.on("close", (code) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			if (code === 0) resolvePromise({
+				ok: true,
+				stdout,
+				error: null
+			});
+			else {
+				const detail = stderr.trim().split("\n")[0] ?? "";
+				resolvePromise({
+					ok: false,
+					stdout,
+					error: `CRO 程序退出码 ${code}${detail ? `：${detail}` : ""}`,
+					code: "cro-exit-nonzero"
+				});
+			}
+		});
+	});
+}
+/** 读目录清单（不存在/读失败 ⇒ 空数组；**不回退抛错**） */
+function readDirEntries(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => {
+			const p = join(dir, e.name);
+			try {
+				const st = statSync(p);
+				return {
+					name: e.name,
+					bytes: st.size,
+					mtimeMs: st.mtimeMs
+				};
+			} catch {
+				return null;
+			}
+		}).filter((x) => x !== null);
+	} catch {
+		return [];
+	}
+}
+/** 读 SESSION.md 体积与 mtime（不存在/读失败 ⇒ null） */
+function readMdStat(mdPath) {
+	try {
+		const st = statSync(mdPath);
+		return {
+			bytes: st.size,
+			mtimeMs: st.mtimeMs
+		};
+	} catch {
+		return {
+			bytes: null,
+			mtimeMs: null
+		};
+	}
+}
+/** 读取快照所需的 fs 侧数据（**纯读取，不抛**） */
+function readCroSnapshotInput(root, dirName, nowMs, extras) {
+	const dir = join(sessionsRoot(root), dirName);
+	const mdPath = join(dir, SESSION_MD);
+	const md = readMdStat(mdPath);
+	return {
+		dirName,
+		cccRoot: root,
+		nowMs,
+		sessionMdPath: mdPath,
+		sessionMdBytes: md.bytes,
+		sessionMdMtimeMs: md.mtimeMs,
+		references: readDirEntries(join(dir, "references")),
+		boundSessionIds: extras.boundSessionIds,
+		liveSessionIds: extras.liveSessionIds,
+		runningSessionIds: extras.runningSessionIds,
+		pendingWakes: extras.pendingWakes,
+		scheduler: extras.scheduler
+	};
+}
+/**
+* 评估一条轨迹的 CRO 程序：**文件在 ⇒ 跑它；不在 ⇒ 未启用**（设计 §2.1）。
+*
+* 🔴 **本函数永不抛错**（旁路容忍铁律）：任何失败都返回 `{status:'skipped'}`，
+* 调用方据此**跳过本轮**、**不影响既有投递链路**。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @param snapshotInput 已读好的快照输入
+* @param deps 可注入依赖（测试用）
+* @returns 四态结果
+*/
+async function evaluateCro(root, dirName, snapshotInput, deps = {}) {
+	let scriptAbs;
+	try {
+		scriptAbs = croScriptPath(root, dirName);
+	} catch (err) {
+		return {
+			status: "disabled",
+			detail: `CRO 路径非法（须在 CCC 根内）：${String(err?.message ?? err)}`
+		};
+	}
+	if (!existsSync(scriptAbs)) return {
+		status: "disabled",
+		detail: `未启用（无 ${CRO_FILENAME}）`
+	};
+	const snapshot = buildCroSnapshot(snapshotInput);
+	let stdinJson;
+	try {
+		stdinJson = JSON.stringify(snapshot);
+	} catch (err) {
+		return {
+			status: "skipped",
+			detail: `快照序列化失败：${String(err?.message ?? err)}`,
+			code: "cro-snapshot"
+		};
+	}
+	const run = await (deps.runner ?? runCroProcess)(scriptAbs, stdinJson, deps.timeoutMs ?? 6e4);
+	if (!run.ok) return {
+		status: "skipped",
+		detail: run.error ?? "CRO 执行失败",
+		...run.code ? { code: run.code } : {}
+	};
+	const parsed = parseCroOutput(run.stdout);
+	if (!parsed.ok) return {
+		status: "skipped",
+		detail: parsed.detail ?? parsed.error,
+		code: parsed.error
+	};
+	const decision = parsed.decision;
+	if (!decision.wake) return {
+		status: "no-wake",
+		decision,
+		detail: decision.reason ?? "程序判定：不唤起"
+	};
+	return {
+		status: "wake",
+		decision,
+		prompt: decision.prompt,
+		detail: decision.reason ?? "程序判定：唤起"
+	};
+}
+/** 人读一行（日志用；`evaluateCro` 结果的稳定摘要） */
+function renderCroOutcome(dirName, outcome) {
+	switch (outcome.status) {
+		case "disabled": return `${dirName}: CRO ${outcome.detail}`;
+		case "skipped": return `${dirName}: CRO 跳过本轮（${outcome.detail}）`;
+		case "no-wake": return `${dirName}: CRO 不唤起（${outcome.detail}）`;
+		case "wake": return `${dirName}: CRO 唤起（${outcome.detail}）`;
+	}
+}
+//#endregion
+//#region src/host/effect.ts
+/** 已告警的标签（进程级去重：重复装配/多测试替身不刷屏，但绝不静默） */
+const warnedLabels = /* @__PURE__ */ new Set();
+/**
+* 登记一个卸载时执行的清理。
+* @param ctx 宿主插件上下文
+* @param label 日志标签（定位是哪个资源未装配）
+* @param cleanup 卸载时执行；抛错被吞掉（不阻断其它清理）
+* @returns 是否成功装配（false = 宿主无 `ctx.effect`，已告警）
+*/
+function registerDisposer(ctx, label, cleanup) {
+	const effect = ctx?.effect;
+	if (typeof effect !== "function") {
+		if (!warnedLabels.has(label)) {
+			warnedLabels.add(label);
+			console.warn(`[serenity-hooks] ✗ 资源拆卸未装配（${label}）：ctx.effect 不可用（宿主契约缺失）`);
+		}
+		return false;
+	}
+	try {
+		effect.call(ctx, () => () => {
+			try {
+				cleanup();
+			} catch (err) {
+				console.warn(`[serenity-hooks] ✗ 资源清理失败（${label}）: ${String(err?.message ?? err)}`);
+			}
+		}, `dsh-serenity-hooks: ${label}`);
+		return true;
+	} catch (err) {
+		console.warn(`[serenity-hooks] ✗ 资源拆卸注册失败（${label}）: ${String(err?.message ?? err)}`);
+		return false;
+	}
+}
+//#endregion
+//#region src/cro/turns.ts
+/**
+* cro/turns.ts — 「这条轨迹是否正在跑轮次」的追踪（设计 §3.2，2026-09-19 S142）
+*
+* ## 为什么需要这个模块（CRO 唯一需要 ACC 新增的状态）
+*
+* CRO 程序要能回答「**已经在工作则停止**」这类问题 ⇒ 输入快照里必须有
+* 「**哪些载体正在跑轮次**」。而这件事**今天判不出来**：
+* 调度器只掌握**会话 live 与否**，而 **`live ≠ 在跑`**——
+* 一条会话可以 live 而空闲（本会话此刻就是活的反例）。
+*
+* ## 怎么夹出来（用**既有的**契约事件，不需要新宿主能力）
+*
+* | 事件 | 动作 | 出处 |
+* |---|---|---|
+* | `agent/status` = `running` | **置位**「在跑」 | 宿主 `AgentLoop.setPhase`：`emit("agent/status", { status })`，**只在状态真的变化时发** |
+* | `agent/status` = `idle` | **清位** | 同上；`kick()` 的 `finally` 一定 `setPhase({kind:'idle'})` |
+* | `agent/disposed` | **清该载体的项** | `host/contract.ts` |
+* | `session/disposed` | **清该载体的项** | `host/contract.ts` |
+*
+* 🔴 **`agent/turn-stopping` 刻意不订阅** —— 它是「轮末暂停点」不是「轮结束」，见下方 D244 段。
+*
+* ## 🔴🔴 D243（2026-10-24）：**⛔ 不许用 `agent/created` 标记「在跑」**
+*
+* **修前**：`agent/created` 也 `markTurnRunning(...)`。**为什么这是错的** —— 该事件是
+* `AgentRegistry.announce(agent, source)` 发的，而 `source` 明确包含 **`resume`**：
+* 宿主**每次重启**都会把 persisted 会话重新载入并 announce ⇒ 每个被**载入**的会话都被打成"在跑"，
+* 而**它那一轮早随旧进程死掉了** ⇒ `turn-stopping` 永不到达 ⇒ 该假标记活满 `TURN_TTL_MS`（30 min）。
+*
+* **代价（两个面，都已实测）**：
+* - **面一**：CRO 守卫拿它否决唤起 ⇒ **重启后聋 30 分钟**（guard 已在自己域绕开）。
+* - **面二**：`cognitive_trajectory interrupted` 拿它当排除集 ⇒ **把最该被接走的会话藏起来**
+*   （实测：判据命中 5 条，生产入口报「检查 5 · 命中 0」）。
+*
+* **判据**：`agent/created` 证明的是「**载体被发布了**」，**不是**「有轮次在跑」。
+* 「载入」与「在跑」互不蕴含（与 D225 同族：*字段名/字面形态不是语义*）。
+* ⇒ **唯一权威 = `agent/status`**（宿主 `status` getter：`phase.kind === 'idle' | 'maintenance'`
+* 才是 idle，其余皆 running），且它在**每次真实状态跃迁**时发 —— 正是我们要的粒度。
+*
+* **代价与兜底**：删掉 `agent/created` 后，本表在"宿主重启后、某会话真正开跑之前"为空
+* ⇒ 落到文件尾那条**便宜**的误判方向（报"没跑"），不会被拿来藏会话。
+*
+* ## 🔴🔴 D244（2026-10-24）：**⛔ `agent/turn-stopping` 不得清表**
+*
+* **它看起来最像"收轮"，其实不是。** 宿主 `AgentLoop.turn()` 原文：
+*
+* ```js
+* if (turnEnds && this.inbox.nextStep.length === 0) {
+*     await this.dispatch.serial("agent/turn-stopping", { turn, signal })  // 暂停点
+*     signal.throwIfAborted()
+* }
+* if (turnEnds && this.inbox.nextStep.length === 0) break                  // 只有 nextStep 空才真结束
+* target = "next-step"                                                     // 否则同轮继续
+* ```
+*
+* ⇒ 任何监听者在 `turn-stopping` 回调里 `steer`（往 `next-step` 塞消息）⇒ **同一轮继续跑**，
+*   而 `turn/start` **不重发**、`agent/status` 也**不重发**（状态没变，还是 running）。
+*
+* 🔴 **实测代价**（真机 2026-10-24 18:1x）：`trajectory/rebuild.ts` 的 auto-continue 正是
+*   在 `turn-stopping` 里 `agent.steer(...)` ⇒ 一条轮**连跑 9 分钟**
+*   （`turn/start(32)` 18:12:00 → `turn/end(32)` 18:21:27），而本表**整段时间都是空的**
+*   ⇒ `interrupted` 的排除失效 ⇒ `steer` 被塞进**正在跑的那一轮**（对它是误导）。
+*   ⚠️ D243 之前这一格被 `agent/created` 的假置位**掩盖**；D243 删掉它 ⇒ 洞才暴露。
+*   ⇒ **D243 的方向是对的，它只是揭开了一个更老的语义误解**。
+*
+* ⇒ **清理只认 `agent/status = idle`**（`kick()` 的 `finally` 一定 `setPhase({kind:'idle'})`）。
+* ⚠️ **已知窄代价**：`runMaintenance` 期间 `status` 也是 `idle` ⇒ 压缩等内部工作时不置位。
+*   判可接受：那时没有 CRO 该救的轮；方向落到那条**便宜**的误判（报"没跑"）。
+* ⛔ **不要把 `clearTurnRunning` 加回 `turn-stopping`** —— 等于重新打开那个 9 分钟的洞。
+*
+* ## 🔴 清理设计（**这是本模块最容易被做坏的地方**）
+*
+* ⚠️ 本容器栽过 **5 次**「只增不清」的病（wake-registry / keeper 三表 / pendingRebuilds …），
+* 而 `agent/disposed` 在 `HOST_EVENTS` 里的 impact 原文**恰好就是**
+* 「*per-会话内存态不清理（**长跑泄漏**）*」⇒ **本模块属于该已登记病族，必须在设计期就带清理**。
+*
+* **三层清理**（D244 起第 1 层已从 `turn-stopping` 换成 `status=idle`）：
+* 1. **正常路径**：`agent/status = idle` ⇒ 清除该项；
+* 2. **载体销毁**：`agent/disposed` / `session/disposed` ⇒ 清除该项；
+* 3. 🔴 **异常路径（前两层都漏掉的兜底）**：读取时按 **TTL** 过滤——
+*    超过 `TURN_TTL_MS` 未刷新的项**视为不在跑**（并顺手清除）。
+*    触发场景：进程被 kill / 卡死 / 事件丢失（这些情况下 `idle` 永远不会来）。
+*
+* ## TTL 取值的**方向性判据**（R↓，别用"感觉合适"）
+*
+* 两种误判的代价**不对称**：
+* · **误报"在跑"**（实际没跑）⇒ CRO 可能**不唤起** ⇒ **漏排 = 硬故障**（链停滞）；
+* · **误报"没跑"**（实际在跑）⇒ CRO 可能**多唤起**一次 ⇒ **多排 = 常态成本**（既有纪律：
+*   「漏排是硬故障、多排是常态成本」）。
+*
+* ⇒ **不确定时宁可报"没跑"**（选便宜的那种错）⇒ **TTL 不宜过长**。
+* 取 **30 分钟**：单轮静默超过 30 分钟仍无 `idle` 的情形罕见；
+* 而真发生了，代价只是一次可能多余的唤起（5min tick 限制频率，且 CRO 程序自己还能看
+* `pendingWakes` / `lastWakeAt` 二次判）。
+*
+* ## 键的选择
+*
+* **以载体（dsh 会话 id）为键**——因为事件本身就以 agent/session 为主语，直接映射最省。
+* **查询时按轨迹聚合**（`listBoundSessionIds` → 「任一载体在跑」⇒ 该轨迹在跑）。
+* ⚠️ 这也天然处理了「同一轨迹多载体」（S142 曾挂 4 条）的情形。
+*/
+/** 一次「在跑」记录的 TTL（见文件头的方向性判据） */
+const TURN_TTL_MS = 18e5;
+/**
+* 进程内的「正在跑」表（键 = 载体 dsh 会话 id）。
+*
+* ⚠️ **仅内存**：进程重启即空 —— 这是**可接受的，且是刻意选的**：
+* 空表 = "没有在跑" ⇒ 落到上面那条**便宜**的误判方向（漏排是硬故障、多排是常态成本）。
+* 🔴 **D243**：刻意**不**在重启后用 `agent/created` 去"补"这张表 —— 那会把「载入」当「在跑」。
+*/
+const runningBySession = /* @__PURE__ */ new Map();
+/** 取载体 id（事件 payload 的 `agent` 面；取不到 ⇒ null） */
+function sessionIdOf(agent) {
+	const id = agent?.session?.id;
+	return typeof id === "string" && id !== "" ? id : null;
+}
+/** 标记「在跑」（**唯一**生产调用点 = `agent/status=running`；另供测试与 CRO 自检置位） */
+function markTurnRunning(sessionId, nowMs, turn = null) {
+	if (!sessionId) return;
+	runningBySession.set(sessionId, {
+		at: nowMs,
+		turn
+	});
+}
+/** 清除「在跑」（`turn-stopping` / disposed 调用） */
+function clearTurnRunning(sessionId) {
+	if (!sessionId) return;
+	runningBySession.delete(sessionId);
+}
+/**
+* 列出**当前在跑**的载体 id（按 TTL 过滤 + **顺手清除过期项**）。
+*
+* 🔴 **本函数带副作用（清理）是刻意的**：它是"异常路径兜底"的唯一执行点——
+* 只过滤不清除会让表留下永不过期的僵尸项（正是"只增不清"病）。
+* @param nowMs 当前时刻
+* @param ttlMs TTL（缺省 {@link TURN_TTL_MS}）
+* @returns 在跑的载体 id 列表（顺序不保证）
+*/
+function listRunningSessionIds(nowMs, ttlMs = TURN_TTL_MS) {
+	const out = [];
+	for (const [id, rec] of runningBySession) {
+		if (nowMs - rec.at > ttlMs) {
+			runningBySession.delete(id);
+			continue;
+		}
+		out.push(id);
+	}
+	return out;
+}
+/**
+* 按轨迹聚合：该轨迹**是否有载体在跑**（`listBoundSessionIds` 给候选，再与在跑集求交）。
+* @param boundSessionIds 绑定该轨迹的载体 id
+* @param nowMs 当前时刻
+* @param ttlMs TTL
+* @returns 在跑的载体 id（**可能多条**；空数组 = 没有在跑）
+*/
+function runningCarriersOf(boundSessionIds, nowMs, ttlMs = TURN_TTL_MS) {
+	const running = new Set(listRunningSessionIds(nowMs, ttlMs));
+	return boundSessionIds.filter((id) => running.has(id));
+}
+/**
+* 装配追踪（`index.ts` apply 调用）：订阅四个既有事件 + 拆卸。
+*
+* **为什么订阅四个而不是两个**（R↓）：
+* · 前两个（`agent/status` / `turn-stopping`）负责**语义**——"在不在跑"；
+* · 后两个（`agent/disposed` / `session/disposed`）负责**生命周期**——
+*   载体没了必须清项，否则表按载体只增（本模块的头号风险）。
+*
+* 🔴 **D243：`agent/created` 已于 2026-10-24 从订阅清单中移除**（原先共 5 个）。
+*    理由与代价见**文件头 D243 段**；一句话：它是「载体被发布」的信，不是「轮次在跑」的信。
+*
+* ⚠️ **失败不抛**：任一事件通道缺失 ⇒ 响亮日志 + 该订阅跳过（**apply 不可成为启动单点**，
+* 与 `registerDeepseekVisionPatch` 等既有装配同款纪律）。
+*
+* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
+* **两个宿主 import 全部清除**（`Context`（cordis）＋ `Agent`（`@deepseek-ai/dsh-agent`）），
+* `ctx` 参数类型 → `unknown`。
+*
+* 🔴 **本处顺带更正 §2.7 的一处分档**：本文件原被列在"剩余 3 个属**真依赖**档"里，
+* 但**逐符号查证后与那个判断不符** ——
+*   · `Context`：`ctx` 只被**结构化访问**（原码本就写着 `ctx as unknown as { on: … }`）
+*     ⇒ 该注解未提供任何类型保证（与 `trajectory/carrier.ts` 同档）。
+*   · `Agent`：**导入后从未使用** —— 事件 payload 一律按 `{ agent?: unknown }` 解构，
+*     再交给 `sessionIdOf(...)`（它收 `unknown`）。⇒ **纯粹是死 import**。
+* ⇒ **判据（本件再证一次，且比上一件更硬）**：分档**必须逐符号看"它有没有参与类型检查"**，
+*   **不能按文件整档划分** —— 同一个文件里可以并存"真依赖符号"与"纯名义符号"。
+* 🔵 **剩余 2 个文件**才是真依赖档：`trajectory/rebuild.ts` 用 `Session`/`SessionEvent`/
+*   `deriveEventMessage`/`Agent` 等**真调用**的类型；`wake/scheduler.ts` 用 `Agent` 的
+*   `followup`/`steer`（**真调用**）⇒ 它们走 §2.7-③ **选项 (b)** 或把中立接口下沉到 L0，
+*   **另立一件**（D85 一次只改一件事）。
+* @param ctx 插件上下文（**结构化访问** `on`，故类型为 `unknown`，见下方 I2 说明）
+*/
+function registerCroTurnTracking(ctx) {
+	const on = (event, handler) => {
+		try {
+			ctx.on(event, handler);
+		} catch (err) {
+			console.log(`[serenity-hooks] ✗ CRO turn 追踪未装配（${event} 不可用）: ${String(err?.message ?? err)}`);
+		}
+	};
+	on("agent/status", (payload) => {
+		const p = payload;
+		const id = sessionIdOf(p?.agent);
+		if (!id) return;
+		if (p.status === "running") markTurnRunning(id, Date.now());
+		else if (p.status === "idle") clearTurnRunning(id);
+	});
+	on("agent/disposed", (payload) => {
+		const id = sessionIdOf(payload?.agent);
+		if (id) clearTurnRunning(id);
+	});
+	on("session/disposed", (payload) => {
+		const id = payload?.id;
+		if (typeof id === "string" && id !== "") clearTurnRunning(id);
+	});
+	registerDisposer(ctx, "cro turn tracking", () => {
+		runningBySession.clear();
+	});
+}
+//#endregion
+//#region src/cro/log.ts
+/**
+* cro/log.ts — CRO 唤起日志（**ACC 侧**，每轨迹一份固定名文件，2026-09-20 S142 §7.16）
+*
+* ## 所有者令（本模块的存在理由）
+*
+* 「S151 和 S185 的验证都说明，认知轨迹倾向于自己做个结构化记录来记录自身 CRO 的执行情况，
+* 这是个结构化流水账；**我们 ACC 有必要进行 CRO 唤醒的日志记录**，当 CRO 存在时，每次**成功唤醒**
+* 写相关信息，但是保留数量要少，**只保留仅两日**的记录即可，**这个时间是程序化的**」
+* ＋「**这个日志写结构化文件到认知轨迹目录，文件名固定即可**」
+* ＋「**失败成功都记录**」。
+*
+* ## 它解决什么麻烦（白话）
+*
+* 在此之前「ACC 到底叫过谁、叫了几次、哪次**没叫成**」**ACC 自己一个字都不留** ——
+* 要查只能去读**被叫的那个程序**写的记录；程序没写 / 写坏 / 被换掉 ⇒ **这段历史就是空白**。
+* ⇒ 本模块让 ACC **自己那一侧**留一份只记两天的流水，使「唤起历史」**不再依赖被观测者是否老实**。
+*
+* ## 🔴 为什么**不是**第二真相源（本容器铁律，勿删此论证）
+*
+* 轨迹目录里因此**并排两个文件、主语各一**：
+*
+* | 文件 | 谁写 | 主语 | 回答 |
+* |---|---|---|---|
+* | `<轨迹目录>/cro-state.json`（CCC 侧程序自建，名字自定） | **CCC 的 CRO 程序** | 程序 | 「**我判了什么**」（含"没叫"的判定、心跳阈值、环境谓词） |
+* | `<轨迹目录>/cro-wake-log.log`（**本模块**） | **ACC** | ACC | 「**我把什么送出去了、送成没有**」 |
+*
+* **内容不重叠**：本模块**不复制**判定细节（不存 `lastDecision` / 阈值 / 谓词）；
+* 而程序**不可能**知道投递结果（CRO 投递是 fire-and-forget）。
+* ⇒ 两者**互补**：完整审计 = 两者合看（本模块 = 投递面｜程序状态 = 判定面）。
+*
+* ## 🔴 形态 = 纯文本行，不是 JSON（owner 2026-10-19 裁 Q1）
+*
+* owner 原话：「**日志不要写 json，不合适，日志直接写纯文本 `.log` 就行**」。
+* ⇒ 一行一条，**tab 分隔**（终端里按制表位对齐，`grep` / `cut` / `awk` 直接可用）：
+*
+* ```text
+* # ACC CRO 唤起流水（纯文本 · tab 分隔 · 时间 / 结果 / tick / 方式 / 理由 / 提示词摘要）
+* 2026-10-19T22:15:03+08:00	ok	tick=82	已投递（live）	reason=心跳：距上次 44m	prompt=17:请先整理你的 SESSION.md
+* ```
+*
+* 🔴 **`#` 开头是注释 / 表头行，解析时跳过** —— 纯文本档案缺了表头，下一个人（或半年后的我）
+* 打开只看到一堆制表符，那是把 R 推给读者。
+* 🔴 **坏行跳过而非报错**（与 JSON 版的 `asEntry()` 同口径）：手改 / 半行 / 截断都不得让整档失效。
+*
+* ## 🔴 两代并读（**不硬切**，本容器反复栽过的形态）
+*
+* 旧名 `cro-wake-log.json` **仍然读**（存量轨迹里可能正有那份）；
+* **只写新 `.log`**。读侧判据 = **「新档在就只读新档，否则回落旧档」**。
+*
+* 🔴 **首次写入 = 迁移，不是覆盖**：那一刻 `loadCroWakeLog` 读到的仍是旧档条目，
+* 它们与新条目一起过裁剪、一起落进新档 ⇒ **窗内的旧记录不会凭空消失**；
+* 而旧档此后不再被读（新档已在）⇒ **不会重复计入**，也不需要删除动作。
+* ⚠️ 这条**只能靠读源码知道**（写出来的档看不出它继承过谁）⇒ 故在此明写。
+*
+* ## 🔴 轮转（所有者明示「程序化的」）
+*
+* **写入时按窗裁剪**：每次落盘只保留 `at >= now - CRO_LOG_RETENTION_MS` 的条目，
+* 随后**原子写**（`tmp + rename`，与 `wake/registry.ts` 同款形态）。
+* ⇒ 清理与写入**是同一笔操作** ⇒ **结构上不存在"忘了清"的可能**（比"另设一个每 tick 的清理步"更硬：
+* 那多一个"可能忘了跑"的面）。窗宽是**常量**，**无配置键、无人工清理动作**。
+*
+* ## 🔴 铁律（与 `cro/core.ts` 同族）
+*
+* **本模块的每个导出函数都不抛错**：写盘 / 裁剪 / 解析失败一律返回结构化失败，
+* 由调用方只记一行 tick 日志 ⇒ **CRO 流水的问题绝不影响投递与既有链路**（设计 §5）。
+*
+* ## 保留量级（实测，非估计）
+*
+* 实测最高 = S185 的 40min 心跳（≈36 条/天）；两天窗 ⇒ **≤ ~80 条、< 20 KB**。
+* 最坏（某程序每 5min 都叫）⇒ 288 条/天 ⇒ 两天 **≤ ~600 条、< 100 KB** —— 轮转**自带上限**。
+*/
+/** 固定文件名（所有者令：「文件名固定即可」）——与程序自建的 `cro-state.json` 并排、主语分明 */
+const CRO_LOG_FILENAME = "cro-wake-log.log";
+/**
+* 🔴 **读取族 = 新名在前、旧名在后**（认族，不认"当前叫什么"）。
+*
+* 本容器已两次栽在"上游改名、下游写死旧名"：`skiff.json` → `trajectory-constraint.json` 那次，
+* 症状是「写不进去」，而真因是「文件名对不上」，两者在读数上完全不像。
+* ⇒ 上游再改名只往族里加一项。
+*/
+const CRO_LOG_LEGACY_FILENAMES = ["cro-wake-log.json"];
+/** 保留窗 = 2 日（所有者令「只保留仅两日」）；**常量** ⇒ 「这个时间是程序化的」 */
+const CRO_LOG_RETENTION_MS = 1728e5;
+/** 纯文本档案的表头行（解析时跳过；人打开时先看到它） */
+const CRO_LOG_HEADER = "# ACC CRO 唤起流水（纯文本 · tab 分隔 · 时间 / 结果 / tick / 方式 / 理由 / 提示词摘要）";
+/** 日志绝对路径（**写入目标** = 新名） */
+function croWakeLogPath(root, dirName) {
+	return join(sessionsRoot(root), dirName, CRO_LOG_FILENAME);
+}
+/** 旧档绝对路径（**只读**，用于两代并读） */
+function croWakeLogLegacyPath(root, dirName, filename) {
+	return join(sessionsRoot(root), dirName, filename);
+}
+function emptyLog() {
+	return {
+		version: 1,
+		entries: []
+	};
+}
+/**
+* 抹掉会破坏**行结构**的字符（tab / CR / LF）。
+*
+* 🔴 只抹这三个：它们是**分隔符**，混进来会让一行变成两行或错位；
+* 其余字符（`|`、`]`、中文标点）**原样保留** —— 那些是内容，抹了就是把 E 降了。
+*/
+function oneline(text) {
+	return text.replace(/[\t\r\n]+/g, " ");
+}
+/** 一条记录 → 纯文本行（tab 分隔、字段带前缀便于人读） */
+function formatCroLogLine(entry) {
+	const reason = entry.reason === null ? "" : oneline(entry.reason);
+	const head = oneline(entry.promptDigest.head);
+	return [
+		oneline(entry.at),
+		entry.ok ? "ok" : entry.notReady === true ? "not-ready" : entry.noWake === true ? "no-wake" : "fail",
+		`tick=${entry.tick}`,
+		oneline(entry.detail),
+		`reason=${reason}`,
+		`prompt=${entry.promptDigest.length}:${head}`
+	].join("	");
+}
+/**
+* 纯文本行 → 记录（**坏行返回 null 而不是抛**）。
+*
+* 判据：字段数不足 / 时间不可解析 / `ok` 标记不认识 ⇒ `null`（跳过该行，其余照读）。
+* 🔴 `at` 必须**可被 `Date.parse` 解析**才收 —— 那是裁剪的前提，
+* 收一条解析不了的时间等于让它在此档里永久驻留（轮转对它失效）。
+*/
+function parseCroLogLine(line) {
+	if (line === "" || line.startsWith("#")) return null;
+	const parts = line.split("	");
+	if (parts.length < 6) return null;
+	const at = parts[0];
+	if (Number.isNaN(Date.parse(at))) return null;
+	const mark = parts[1];
+	if (mark !== "ok" && mark !== "fail" && mark !== "not-ready" && mark !== "no-wake") return null;
+	const tickM = /^tick=(\d+)$/.exec(parts[2]);
+	if (!tickM) return null;
+	const reasonRaw = parts[4].startsWith("reason=") ? parts[4].slice(7) : "";
+	const promptM = /^prompt=(\d+):([\s\S]*)$/.exec(parts[5]);
+	return {
+		at,
+		ok: mark === "ok",
+		...mark === "not-ready" ? { notReady: true } : {},
+		...mark === "no-wake" ? { noWake: true } : {},
+		detail: parts[3],
+		tick: Number(tickM[1]),
+		reason: reasonRaw === "" ? null : reasonRaw,
+		promptDigest: {
+			length: promptM ? Number(promptM[1]) : 0,
+			head: promptM ? promptM[2] : ""
+		}
+	};
+}
+/** 全文 → 记录（跳过表头与坏行；**永不抛**） */
+function parseCroLogText(text) {
+	const entries = [];
+	for (const line of text.split("\n")) {
+		const e = parseCroLogLine(line);
+		if (e) entries.push(e);
+	}
+	return entries;
+}
+/** JSON 旧档 → 记录（字段缺失/类型不符 ⇒ 丢弃该条，不阻断整档） */
+function parseCroLogJson(text) {
+	const parsed = JSON.parse(text);
+	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 entries;
+}
+/** 旧档条目形状校验（容忍手改） */
+function asEntry(value) {
+	const e = value;
+	if (!e || typeof e !== "object") return null;
+	if (typeof e.at !== "string" || e.at === "") return null;
+	if (typeof e.ok !== "boolean") return null;
+	if (typeof e.detail !== "string") return null;
+	const digest = e.promptDigest ?? {};
+	return {
+		at: e.at,
+		ok: e.ok,
+		detail: e.detail,
+		tick: typeof e.tick === "number" ? e.tick : 0,
+		reason: typeof e.reason === "string" ? e.reason : null,
+		promptDigest: {
+			length: typeof digest.length === "number" ? digest.length : 0,
+			head: typeof digest.head === "string" ? digest.head : ""
+		}
+	};
+}
+/** 提示词摘要（长度 + 前 N 字；超长不截断标记——长度字段本身就是信号） */
+function summarizeCroPrompt(prompt) {
+	const text = typeof prompt === "string" ? prompt : "";
+	return {
+		length: [...text].length,
+		head: [...text].slice(0, 80).join("")
+	};
+}
+/**
+* 读取日志（**永不抛**；读坏 ⇒ 当作空档 + 返回 error 文本）。
+*
+* 🔴 **两代并读的判据**：新档在 ⇒ **只读新档**；否则按族回落旧档。
+* 这样首次写入之后旧档自然退场，**不需要删除动作、也不会重复计入**。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+*/
+function loadCroWakeLog(root, dirName) {
+	const path = croWakeLogPath(root, dirName);
+	if (existsSync(path)) try {
+		return {
+			log: {
+				version: 1,
+				entries: parseCroLogText(readFileSync(path, "utf-8"))
+			},
+			error: null
+		};
+	} catch (err) {
+		return {
+			log: emptyLog(),
+			error: `CRO 流水解析失败（${String(err?.message ?? err)}）`
+		};
+	}
+	for (const legacy of CRO_LOG_LEGACY_FILENAMES) {
+		const legacyPath = croWakeLogLegacyPath(root, dirName, legacy);
+		if (!existsSync(legacyPath)) continue;
+		try {
+			return {
+				log: {
+					version: 1,
+					entries: parseCroLogJson(readFileSync(legacyPath, "utf-8"))
+				},
+				error: null
+			};
+		} catch (err) {
+			return {
+				log: emptyLog(),
+				error: `CRO 流水解析失败（${String(err?.message ?? err)}）`
+			};
+		}
+	}
+	return {
+		log: emptyLog(),
+		error: null
+	};
+}
+/**
+* 按窗裁剪（**纯函数** ⇒ 可穷举测试）。
+*
+* 判据：`Date.parse(at) >= nowMs - windowMs` 保留；反之丢弃。
+* 🔴 **`at` 不可解析者一律丢弃**（本模块只写 `isoLocal()` 产物 ⇒ 不可解析 = 被手改或损坏），
+* **并在返回值里报数**（`dropped`）——**不静默吞掉**（本容器反复栽的"安静失败"纪律）。
+*/
+function pruneCroLogEntries(entries, nowMs, windowMs = CRO_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
+	};
+}
+/** 记录集 → 落盘全文（表头 ＋ 逐行 ＋ 末尾换行） */
+function renderCroLogText(entries) {
+	return `${[CRO_LOG_HEADER, ...entries.map(formatCroLogLine)].join("\n")}\n`;
+}
+/**
+* 追加一条唤起记录并按窗裁剪（**本模块主入口；永不抛**）。
+*
+* 顺序 = 读 → 追加 → 裁剪 → **原子写**。任一步失败 ⇒ `{ok:false, error}`，
+* **不抛**（调用方只记一行 tick 日志；**绝不影响投递**）。
+*
+* 无 CRO 的轨迹**不会**因本函数产生文件：只有真的发生过一次唤起尝试才会建/写该档
+* （所有者令「**当 CRO 存在时**」）。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @param input 本次唤起尝试（成败都记）
+* @param nowMs 当前毫秒（可注入 ⇒ 便于测裁剪边界）
+* @returns 写入结果与裁剪计数
+*/
+function appendCroWakeLog(root, dirName, input, nowMs = Date.now()) {
+	const path = croWakeLogPath(root, dirName);
+	try {
+		const loaded = loadCroWakeLog(root, dirName);
+		const entry = {
+			at: isoLocal(nowMs),
+			ok: input.ok,
+			...input.notReady === true ? { notReady: true } : {},
+			...input.noWake === true ? { noWake: true } : {},
+			detail: input.detail,
+			tick: input.tick,
+			reason: input.reason,
+			promptDigest: summarizeCroPrompt(input.prompt)
+		};
+		const { kept, pruned, dropped } = pruneCroLogEntries([...loaded.log.entries, entry], nowMs);
+		mkdirSync(dirname(path), { recursive: true });
+		const tmp = `${path}.tmp`;
+		writeFileSync(tmp, renderCroLogText(kept), "utf-8");
+		renameSync(tmp, path);
+		return {
+			ok: true,
+			error: null,
+			kept: kept.length,
+			pruned,
+			dropped
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: `CRO 流水写入失败（${String(err?.message ?? err)}）`,
+			kept: 0,
+			pruned: 0,
+			dropped: 0
+		};
+	}
+}
+//#endregion
+//#region src/trajectory/interrupted.ts
+/**
+* 中断轮次发现（`interrupted` 会话扫描）
+*
+* ## 这个模块解决什么
+*
+* DSH 的会话日志里，**进程在某一轮完成前退出**（被 kill／崩溃／关机超时）时，
+* 宿主重放时会为该轮补上收尾事件：
+*
+* ```jsonl
+* turn/end {"turn":66,"reason":{"kind":"interrupted"}}
+* step/end {"turn":66,"step":85}
+* session/end-seed {}
+* ```
+*
+* 宿主**只补收尾，不续跑** —— 那一轮的工作就此停在那里。本模块负责把这些会话找出来，
+* 交给上层（认知轨迹）决定要不要续。
+*
+* ## 判据（三条同时成立，缺一不可）
+*
+* 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 次）。只看"曾经中断"会把早已恢复的会话全部当成待续 ⇒ 灾难。
+*
+* 🔴 **为什么原判据要求"末条 = end-seed"是错的**（实测 26 条里漏 2 条）：
+* 重启后宿主会在 end-seed **之后**追加 `agent/inbox/spliced`（把待办消息重新塞进收件箱）
+* ⇒ "末条必须 end-seed"**在恢复动作发生之后就恒不成立**，
+* 而"被恢复过又再次被打断"恰恰是守护最该覆盖的形态。
+*
+* ## 为什么不整文件解压
+*
+* DSH 日志是 **zstd 多帧追加**（实测单会话 24705 帧 / 47 MB）。原生
+* `zlib.zstdDecompressSync` 只解**第一帧**，对多帧直接报 `Unknown frame descriptor`。
+* ⇒ 采用**尾部窗口 + 倒序逐帧解压**：只读文件末尾 N 字节，从后往前找帧魔数，
+*    解到凑够所需事件数即停。实测 8h 窗口 6 个会话 **20 ms**。
+*
+* ## 世代识别复用 `cleanup.ts`
+*
+* 日志文件名有多个世代（`session.jsonl` / `session.v3.jsonl.zstd` / `session.v4.jsonl.zstd`…），
+* 宿主按世代写且**迁移保留源文件**。⇒ 本模块**不硬编码文件名**，走
+* {@link findSessionLog}（与清理／体积统计同一判据），避免"新世代对本模块不可见"。
+*
+* ## 边界
+*
+* - **只读**：不改任何会话日志。
+* - **不判周期**：何时扫、扫完做什么归调用方（CCC 的认知轨迹）。本模块只回答
+*   「此刻哪些会话以 interrupted 结尾」。
+*/
+/**
+* zstd 解压（**运行时有、类型声明没有**）。
+*
+* 🔴 为什么不能用 `import { zstdDecompressSync } from 'node:zlib'`：
+* 本仓 `@types/node@^20` 的声明里**没有** zstd 系列（Node 22.15+ 才进声明）。
+* 而运行时本机 v22.22.1 **确实有**（实测 `typeof require('zlib').zstdDecompressSync === 'function'`）。
+* ⇒ 用命名空间导入 + 局部断言，并**在运行时校验**；缺失时走明确降级（返回空，不静默瞎猜）。
+*/
+const zstdDecompressSync = nodeZlib.zstdDecompressSync;
+/** zstd 帧魔数（小端 `28 B5 2F FD`） */
+const ZSTD_MAGIC = Buffer.from([
+	40,
+	181,
+	47,
+	253
+]);
+/** 默认回看窗口：8 小时（owner 2026-10-22 定） */
+const DEFAULT_LOOKBACK_MS = 288e5;
+/**
+* 尾部读取的**渐进块**（从小到大，够用就停）。
+*
+* 🔴🔴 **2026-10-24 A108：从"一次读满 8 MiB"改成"渐进扩块、见到证据就停"。**
+*
+* 修前：不管需要多少，**先 `readSync` 读满 8 MiB**，再线性扫一遍帧魔数（O(8 MiB)），
+* 然后解压到**攒够 400 条事件**为止 —— 而 400 只是一个**猜的数**：
+* 实测最长单轮 482 行、某会话 `turn/start` 落在 400 条之外 **83 行** ⇒ **证据被截断**，
+* 于是「这一轮没跑完」被读成「这一轮早就干净收尾了」⇒ **漏唤醒**。这就是 A108。
+*
+* ⇒ 现在的判据换成**「要的是证据，不是条数」**：从尾部往前，**一旦同时见到
+*   `turn/start` 与 `turn/end` 就停**（那两条就是判定所需的全部证据）。
+*
+* 💰 实测代价（本机 13 个窗口内会话，中位 3 次）：
+*    · 单会话 **0.2 ~ 54 ms**（多数 1~9 ms）｜13 个合计 **132 ms**；
+*    · 实际读取量多数 **64 KiB**（最多的一个才 4 MiB）—— **远小于修前的恒定 8 MiB**。
+* ⇒ 所以这既是**修正确性**，也是**省开销**（不是"用性能换正确"）。
+*/
+const TAIL_CHUNKS = [
+	65536,
+	262144,
+	1 << 20,
+	4 << 20,
+	8 << 20
+];
+/**
+* 尾部读取的**硬上限**（渐进块的最大一档）。
+*
+* ⚠️ 它仍然存在，因为"扫到边界为止"在病态日志上可能无界（一整轮几十万条事件）。
+* 与修前的区别：修前它是**起点**（无条件读满），现在它是**兜底**（扩到这里还没有证据才算不可判定）。
+*/
+const TAIL_WINDOW_BYTES = 8 << 20;
+/**
+* 从文件尾部**渐进扩块**倒序解压，**见到判定所需的证据就停**。
+*
+* ## 与修前的两点不同（都对 A108 负责）
+*
+* 1. **不再一次读满 8 MiB**：按 {@link TAIL_CHUNKS} 从 64 KiB 起扩，够用就停。
+*    实测多数会话 64 KiB 就够（见 `TAIL_CHUNKS` 的代价段落）。
+* 2. **停止条件从"攒够 N 条"改成"见到证据"**。⛔ 不要再退回"攒够 400 条" ——
+*    那个数**必然**在长轮次上截断（实测被挤出 83 行）。
+*
+* ## 🔴 什么是「证据」（这里踩过一次，写清楚免得后人重犯）
+*
+* **必需证据 = 见到一条 `turn/start`**。理由：
+* - 判定形态 B（轮内死掉）只需"最后一条 `turn/start` 之后没有 `turn/end`"——
+*   而**进程死在轮内时，宿主根本没机会写 `turn/end`** ⇒ 若要求"必须见到 turn/end"，
+*   **这一整类会被判成"不可判定"**（我第一版就是这么写的，被 `形态 B` 用例当场打红）。
+* - `turn/end` 是**可选证据**：见到它能让形态 A（收尾原因）也成立，但它**不是判定的前提**。
+*
+* ⇒ 停止条件：**见到 `turn/start` 即可停**（`turn/end` 顺手见到更好）。
+* ⇒ 只有**连一条 `turn/start` 都见不到**才报 `exhausted`（那才是真的"不知道"）——
+*   典型成因：一整轮长到 8 MiB 都装不下它的起点。
+*
+* ⚠️ 另一种"见不到 turn/start"的合法情况：**日志里从来没有过轮**（空会话／只有 header）。
+*   ⇒ 那种情况扩到**全文**（`winBytes >= st.size`）仍见不到 ⇒ 判 `exhausted: false`
+*   （**"没有轮"是确定的，不是不知道**），由判据函数返回 null ⇒ 进 `skipped`。
+*/
+function readTailEvents(logPath) {
+	if (zstdDecompressSync === void 0) return {
+		events: [],
+		exhausted: false
+	};
+	const st = statSync(logPath);
+	if (st.size < 8) return {
+		events: [],
+		exhausted: false
+	};
+	const fd = openSync(logPath, "r");
+	try {
+		for (const chunk of TAIL_CHUNKS) {
+			const winBytes = Math.min(chunk, st.size);
+			const buf = Buffer.alloc(winBytes);
+			readSync(fd, buf, 0, winBytes, st.size - winBytes);
+			const offsets = [];
+			for (let i = 0; i <= winBytes - ZSTD_MAGIC.length; i++) if (buf[i] === ZSTD_MAGIC[0] && buf[i + 1] === ZSTD_MAGIC[1] && buf[i + 2] === ZSTD_MAGIC[2] && buf[i + 3] === ZSTD_MAGIC[3]) offsets.push(i);
+			const events = [];
+			let sawStart = false;
+			for (let k = offsets.length - 1; k >= 0; k--) {
+				const start = offsets[k];
+				const end = k + 1 < offsets.length ? offsets[k + 1] : winBytes;
+				let text;
+				try {
+					text = zstdDecompressSync(buf.subarray(start, end)).toString("utf8");
+				} catch {
+					break;
+				}
+				const batch = [];
+				for (const line of text.split("\n")) {
+					if (!line.trim()) continue;
+					try {
+						const ev = JSON.parse(line);
+						batch.push(ev);
+						if (ev.type === "turn/start") sawStart = true;
+					} catch {}
+				}
+				events.unshift(...batch);
+				if (sawStart) return {
+					events,
+					exhausted: false
+				};
+			}
+			if (winBytes >= st.size) return {
+				events,
+				exhausted: false
+			};
+			if (winBytes >= TAIL_WINDOW_BYTES) return {
+				events,
+				exhausted: true
+			};
+		}
+		return {
+			events: [],
+			exhausted: true
+		};
+	} finally {
+		closeSync(fd);
+	}
+}
+/**
+* 判定一组尾部事件是否「以未完成的轮次结尾」。
+* 不命中 → null。
+*
+* ## 🔴🔴 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` ⇒ **「被正常终止」这一大类全部漏掉**，而它恰恰是
+* **发布重启／换宿主** 最常见的形态（比崩溃常见得多）。
+*
+* 🔴 **这两条是同一个状态的两种成因，不是"一个对一个不对"**：
+* 判据问的是「**这一轮有没有收完**」，不是「进程死得惨不惨」。
+* 拿死法当判据 ⇒ 换一种死法就漏一批（这正是 owner 反复看到的"还是没修好"）。
+*
+* ### 为什么不能只加 `aborted` 就完事
+* `aborted.reason.kind` 里还可能有 `hook`（宿主主动 hook 取消）——它同属"没跑完"。
+* ⇒ 本判据**只看外层 `kind`**，理由：外层已经回答了"这一轮收完了吗"，
+*   内层回答的是"谁让它停的"，**那是另一个问题**，混进来会让判据随"谁取消的"漂移。
+*
+* ### ⛔ 刻意**不**纳入的形态（保守边界，写明理由）
+* - `error`：本轮**收完了**（宿主记了错误收尾），它不是"停在这里等人续"；
+* - 完全没有 `turn/end` 的开轮（例如日志末尾是 `turn/start` 后再无事件）：
+*   那**也可能是"进程正活着、这一轮正在跑"**，与真中断在读数上不可分
+*   ⇒ 纳入会误唤醒在跑的会话。⚠️ 这是**已知边界**，不是遗漏。
+*
+* ### 为什么不会误报"曾经中断但已恢复"
+* 恢复一定伴随 `turn/start`（新一轮）或新的 `turn/end`（`completed` 等）⇒ 判据 1／2 各自挡住。
+*/
+/**
+* 「这一轮没跑完」的 `turn/end.reason.kind` 取值域。
+*
+* 🔴🔴 **2026-10-24（owner 报障）**：原判据只认 `'interrupted'` 一个词 ⇒
+* **「被正常终止」整类漏扫**。两个值对应的形态见 {@link detectInterruptedEnd} 的头注。
+*
+* ⚠️ **这是判据的唯一取值点** —— 别在别处再写一份字面量（两份会漂）。
+*/
+const UNFINISHED_KINDS = /* @__PURE__ */ new Set(["interrupted", "aborted"]);
+/**
+* 尾部窗口里**最后一条 `turn/start` 的轮号**（D244 输出面，给调用方做 A108 的现场判断）。
+*
+* ⚠️ 与 {@link detectUnclosedTurn} 不同：**它不判"是否未收尾"**，只**如实报告窗口里有什么**。
+* 分开的理由：前者是判据（会 deciding 命中），后者是读数（零判据风险）——
+* 把读数塞进判据函数，调用方就没法在"判据因为窗口截断而沉默"时看出**为什么**沉默。
+*
+* @returns 轮号；窗口内没有 `turn/start` 或轮号缺失 ⇒ `null`
+*/
+function lastTurnStartTurnOf(events) {
+	for (let i = events.length - 1; i >= 0; i--) if (events[i]?.type === "turn/start") {
+		const t = events[i]?.data?.turn;
+		return typeof t === "number" ? t : null;
+	}
+	return null;
+}
+/**
+* 尾部窗口里**最后一条 `turn/end` 的 `reason.kind`**（同上：读数，不是判据）。
+* @returns kind；窗口内没有 `turn/end`（形态 B 的典型）或 kind 缺失 ⇒ `null`
+*/
+function lastTurnEndKindOf(events) {
+	for (let i = events.length - 1; i >= 0; i--) if (events[i]?.type === "turn/end") {
+		const k = events[i]?.data?.reason?.kind;
+		return typeof k === "string" ? k : null;
+	}
+	return null;
+}
+/**
+* 命中判定（**形态 A：靠 `turn/end.reason.kind`**）。
+*
+* ⚠️ **本函数刻意不判「开了没收」** —— 那种形态与「此刻正在跑」在日志读数上**不可分**，
+* 只有扫描层手里有 `liveIds`（正在跑的会话 id）才判得准。
+* ⇒ 分工：**本函数判"收尾原因"，`scanInterruptedSessions` 判"开了没收"**（见 `detectUnclosedTurn`）。
+* ⛔ 不要把这些情形塞进本函数 —— 会让它同时依赖"日志形态"与"进程状态"，那种判据无法单独证伪。
+*
+* @returns 命中时给出被中断的轮次与"可能有副作用"的工具名；不命中 null
+*/
+function detectInterruptedEnd(events) {
+	if (events.length === 0) return null;
+	let idx = -1;
+	for (let i = events.length - 1; i >= 0; i--) if (events[i]?.type === "turn/end") {
+		idx = i;
+		break;
+	}
+	if (idx < 0) return null;
+	const turnEnd = events[idx];
+	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;
+	return {
+		turn,
+		pendingTools: findPendingTools(events, turn)
+	};
+}
+/**
+* 命中判定（**形态 B：一轮开了却没收**）—— 🔴🔴 **2026-10-24 owner 报障的正解**。
+*
+* ## 为什么这一格以前整类漏掉
+*
+* 进程在**轮内任意位置**死掉时，宿主**永远没机会写 `turn/end`**
+* ⇒ 日志就停在 `tool/call` ／ `step/start` ／ `assistant/message` 上。
+* 修前 `detectInterruptedEnd` 首行是 `if (idx < 0) return null`（找不到 turn/end 就放弃）
+* ⇒ **这一整类被判成"没中断"**。
+*
+* ## 判据
+* **最后一条 `turn/start` 之后没有 `turn/end`** ⇒ 那一轮开了没收。
+*
+* ## 为什么必须由**扫描层**调用（而不是并进 `detectInterruptedEnd`）
+* 「开了没收」与「此刻正在跑」在**日志读数上完全一样**。
+* 唯一能分开它们的东西是 `liveIds`（宿主报的"此刻在跑的会话"）——
+* 而那是**扫描层**的参数，不是日志的属性。
+* ⇒ 本函数只回答"日志形态是不是开了没收"，**由调用方保证已排除在跑的会话**。
+* ⚠️ 判据纪律：两个不同的问题（日志形态 ／ 进程状态）**不许塞进同一个函数**，
+*    否则那个函数无法被单独证伪（改任一侧都可能让测试红，而说不清是哪侧错了）。
+*
+* @param events 尾部事件
+* @returns 命中时给出未收尾的轮次与"可能有副作用"的工具名；没有未收尾的轮次 ⇒ null
+*/
+function detectUnclosedTurn(events) {
+	if (events.length === 0) return null;
+	let lastEnd = -1;
+	for (let i = events.length - 1; i >= 0; i--) if (events[i]?.type === "turn/end") {
+		lastEnd = i;
+		break;
+	}
+	let startIdx = -1;
+	for (let i = events.length - 1; i >= 0; i--) if (events[i]?.type === "turn/start") {
+		startIdx = i;
+		break;
+	}
+	if (startIdx < 0 || startIdx < lastEnd) return null;
+	/**
+	* ⚠️ **不要拿 `session/end-seed` 当"已封口"判据**（我第一版这样写，当场被真机用例打红）。
+	*
+	* 真实日志里最常见的恢复形态就是
+	*   `turn/end[interrupted] → session/end-seed → turn/start(新轮)`
+	* —— `end-seed` 是**上一轮**的收尾标记，**不是新一轮的**。
+	* 拿它判"新一轮已封口" ⇒ 会把「新一轮开了就死」误判成"已接续" ⇒ **又回到"啥都扫不到"**。
+	*
+	* ⇒ 判据保持最简：**最后一条 `turn/start` 是否晚于最后一条 `turn/end`**。
+	*   "会不会重复拉起正在跑的会话"由 `liveIds` 负责（扫描层），不是本函数的事。
+	*/
+	const t = events[startIdx]?.data?.turn;
+	const turn = typeof t === "number" ? t : null;
+	return {
+		turn,
+		pendingTools: findPendingTools(events, turn)
+	};
+}
+/**
+* 找出末轮里发起了但没有结果的工具调用名。
+*
+* ⚠️ **尽力而为**，非权威：尾部窗口可能截断更早的调用。上层应把它当
+* "**可能**未完成的副作用"清单，而不是"确定未完成"。
+*/
+function findPendingTools(events, turn) {
+	if (turn === null) return [];
+	const called = /* @__PURE__ */ new Map();
+	const resolved = /* @__PURE__ */ new Set();
+	for (const e of events) {
+		const data = e.data;
+		if (!data || data.turn !== turn) continue;
+		if (e.type === "tool/call" && typeof data.callId === "string" && typeof data.name === "string") called.set(data.callId, data.name);
+		else if (e.type === "tool/result" && typeof data.callId === "string") resolved.add(data.callId);
+	}
+	return [...called].filter(([callId]) => !resolved.has(callId)).map(([, name]) => name);
+}
+/**
+* 扫描一个 **project 目录**（形如 `<sessions-root>/--home-yh-home-home-serenity--/`）。
+*
+* @param projectDir DSH 项目目录（其下每个子目录是一个会话）
+* @param options.lookbackMs 回看窗口（缺省 8h）
+* @param options.now 注入"当前时刻"（测试用）
+* @param options.liveIds 需要跳过的会话 id（正在跑的会话不该被判为待续）
+*/
+function scanInterruptedSessions(projectDir, options = {}) {
+	const t0 = Date.now();
+	const lookbackMs = options.lookbackMs ?? 288e5;
+	const cutoff = (options.now ?? Date.now()) - lookbackMs;
+	const liveIds = options.liveIds ?? /* @__PURE__ */ new Set();
+	const result = {
+		sessions: [],
+		scanned: 0,
+		skipped: 0,
+		errors: [],
+		elapsedMs: 0,
+		excluded: [],
+		undecidable: []
+	};
+	if (!existsSync(projectDir)) {
+		result.elapsedMs = Date.now() - t0;
+		return result;
+	}
+	let entries;
+	try {
+		entries = readdirSync(projectDir);
+	} catch (err) {
+		result.errors.push({
+			sessionId: "*",
+			message: err instanceof Error ? err.message : String(err)
+		});
+		result.elapsedMs = Date.now() - t0;
+		return result;
+	}
+	for (const sessionId of entries) {
+		if (liveIds.has(sessionId)) {
+			const lp = findSessionLog(join(projectDir, sessionId));
+			if (lp !== null) try {
+				if (statSync(lp).mtimeMs >= cutoff) result.excluded.push(sessionId);
+			} catch {}
+			continue;
+		}
+		const dirPath = join(projectDir, sessionId);
+		const logPath = findSessionLog(dirPath);
+		if (logPath === null) continue;
+		let mtimeMs;
+		try {
+			mtimeMs = statSync(logPath).mtimeMs;
+		} catch (err) {
+			result.errors.push({
+				sessionId,
+				message: err instanceof Error ? err.message : String(err)
+			});
+			continue;
+		}
+		if (mtimeMs < cutoff) continue;
+		result.scanned++;
+		try {
+			const tail = readTailEvents(logPath);
+			const events = tail.events;
+			/**
+			* 🔴🔴 **A108：拿不到判定所需证据时，报「不可判定」，⛔ 不许塌成「没中断」。**
+			*
+			* `tail.exhausted` 的判据 = 扩到 8 MiB 硬上限仍**没能同时见到** `turn/start` 与 `turn/end`。
+			* 那时两个判据函数都会返回 null（它们只看「见到的那些事件」）——
+			* 而「没证据」与「证据说没事」在返回值上长得一样，**这正是 A108 的漏**。
+			* ⇒ 所以这一格必须**在调用它们之前**分流。
+			*/
+			if (tail.exhausted) {
+				result.undecidable.push({
+					sessionId,
+					logPath,
+					mtimeMs,
+					lastEventAt: typeof events[events.length - 1]?.time === "number" ? events[events.length - 1].time : null,
+					reason: `扩到 ${Math.round(TAIL_WINDOW_BYTES / 1048576)} MiB 硬上限仍未同时见到 turn/start 与 turn/end`
+				});
+				continue;
+			}
+			/**
+			* 🔴🔴 **两种形态都要接**（2026-10-24 owner 报障：「我要求你抓到非工具调用的中断，
+			* 现在什么都抓不到了」）。
+			*
+			* - 形态 A `detectInterruptedEnd`：日志里有 `turn/end`，且它的 `reason.kind` 是
+			*   `interrupted`（崩溃后被 resume 补收尾）／`aborted`（被正常终止）。
+			* - 形态 B `detectUnclosedTurn`：**日志里压根没有 `turn/end`** —— 进程在轮内任意位置死掉，
+			*   宿主没机会写收尾 ⇒ 日志停在 `tool/call` / `step/start` / `assistant/message`。
+			*   ⚠️ **这一格必须靠"已排除在跑的会话"才成立**，而 `liveIds` 恰好在本函数手里
+			*   （循环开头 `if (liveIds.has(sessionId)) continue`）⇒ 这就是它该待在这里、而不是
+			*   并进 `detectInterruptedEnd` 的原因。
+			*
+			* 实测（本机 10 个窗口内会话）：**4 条**只能由形态 B 抓到（末条 `tool/call` / `step/start`），
+			* 修前全落到 `skipped`。
+			*/
+			const formA = detectInterruptedEnd(events);
+			const formB = formA === null ? detectUnclosedTurn(events) : null;
+			const hit = formA ?? formB;
+			if (!hit) {
+				result.skipped++;
+				continue;
+			}
+			const tailTime = events[events.length - 1]?.time;
+			result.sessions.push({
+				sessionId,
+				logPath,
+				turn: hit.turn,
+				lastEventAt: typeof tailTime === "number" ? tailTime : null,
+				mtimeMs,
+				pendingTools: hit.pendingTools,
+				form: formA !== null ? "interrupted-end" : "unclosed",
+				lastTurnEndKind: lastTurnEndKindOf(events),
+				lastTurnStartTurn: lastTurnStartTurnOf(events)
+			});
+		} catch (err) {
+			result.errors.push({
+				sessionId,
+				message: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	result.sessions.sort((a, b) => (b.lastEventAt ?? b.mtimeMs) - (a.lastEventAt ?? a.mtimeMs));
+	result.elapsedMs = Date.now() - t0;
+	return result;
+}
+/**
+* 由 CCC 根推导它的 DSH 项目目录名（`--home-yh-home-home-serenity--`）。
+*
+* 规则取自宿主：把绝对路径的 `/` 换成 `-`，并在前后各加 `--`。
+* ⚠️ 这是**推导**，不是真相源 —— 实际目录名以磁盘为准；调用方应在不存在时
+* 回退到"扫整个 sessions root"或直接报未找到。
+*/
+function projectDirNameForCwd(cwd) {
+	return `--${cwd.replace(/\/+$/, "").split("/").filter(Boolean).join("-")}--`;
+}
+/**
+* 续跑正文（**简单、稳定、不含版本号**）。
+*
+* 判据（为什么这么短）：本动作的用途是**把被打断的会话推回工作状态**，
+* 不是替它重述任务 —— 被打断那一轮的上下文就在它自己的日志里。
+* ⇒ 正文只做三件事：① 说明发生了什么；② 提示**先核对副作用**；③ 让它接着做。
+*
+* 🔴 **为什么要写"先核对副作用"**：中断时可能有「有 call 无 result」的工具调用，
+* 它们的副作用**未知**（可能已写文件 / 已发消息）。若模型把那一轮整段重放，
+* 会**重复执行**。这句话是给模型的护栏，不是客套。
+*/
+function buildContinueText(sessionId, turn, pendingTools) {
+	const lines = [];
+	lines.push("[中断续跑] 上一条进程在本轮完成前退出，该轮已被中止。现在继续。");
+	lines.push("");
+	lines.push(`会话: ${sessionId}${turn === null ? "" : ` ／ 被中断的轮次: turn ${turn}`}`);
+	if (pendingTools.length > 0) {
+		lines.push("");
+		lines.push(`⚠️ 中断时这些工具「有调用、无结果」（副作用未知，**可能已经执行**）: ${pendingTools.join(", ")}`);
+		lines.push("   ⇒ 先核对它们是否已生效（文件是否已写、消息是否已发），再决定要不要重做。");
+		lines.push("   ⛔ 不要把被中断的那一轮整段重放。");
+	}
+	lines.push("");
+	lines.push("请接着完成该轮未完成的工作；完成后把进展写入本轨迹的 SESSION.md。");
+	return lines.join("\n");
+}
+/**
+* 把一个 agent 唤醒（注入一条续跑消息）。
+*
+* 两条路径（与 `wake/scheduler.ts` 的 `sendToCognitiveTrajectory` 同源判据）：
+* - **live**：`agents.get(id)` 拿得到 ⇒ 目标在跑（或被加载）⇒ `steer` 当场注入当前轮；
+*   `steer` 不可用则退回 `followup`（宁可排队，不可静默丢）。
+* - **cold-resume**：`sessionController.resolveAgent(id)` 冷载入后同样注入。
+*
+* ⚠️ 冷会话载入**会真起一个 agent**（消耗真实算力）⇒ 调用方必须自己决定要不要，
+* 本函数不做数量限制（那是策略，归调用者）。
+*/
+function createResumeOne(deps) {
+	return async (hit) => {
+		const { sessionId } = hit;
+		const text = buildContinueText(sessionId, hit.turn, hit.pendingTools);
+		let agent;
+		let how;
+		const live = deps.agents?.get?.(sessionId);
+		if (live) {
+			agent = live;
+			how = "live";
+		} else {
+			const sc = deps.sessionController;
+			const resolve = sc?.resolveAgent;
+			if (typeof resolve !== "function" || sc === void 0) return {
+				sessionId,
+				ok: false,
+				error: "宿主 sessionController 不可用（重启启动窗口？）—— 稍后重试"
+			};
+			try {
+				const out = await resolve.call(sc, sessionId);
+				if (!out?.agent) return {
+					sessionId,
+					ok: false,
+					error: `冷载入未返回 agent: ${String(out?.error ?? "未知原因")}`
+				};
+				agent = out.agent;
+				how = "cold-resume";
+			} catch (err) {
+				return {
+					sessionId,
+					ok: false,
+					error: `冷载入失败: ${err instanceof Error ? err.message : String(err)}`
+				};
+			}
+		}
+		const a = agent;
+		try {
+			if (typeof a.steer === "function" && a.status === "running") {
+				a.steer(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+steer`
+				};
+			}
+			if (typeof a.followup === "function") {
+				a.followup(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+followup`
+				};
+			}
+			if (typeof a.steer === "function") {
+				a.steer(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+steer`
+				};
+			}
+			return {
+				sessionId,
+				ok: false,
+				how,
+				error: "agent 既无 steer 也无 followup（宿主契约漂移）"
+			};
+		} catch (err) {
+			if (typeof a.followup === "function") try {
+				a.followup(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+followup(steer 失败后退回)`
+				};
+			} catch (err2) {
+				return {
+					sessionId,
+					ok: false,
+					error: `steer 与 followup 均失败: ${String(err2?.message ?? err2)}`
+				};
+			}
+			return {
+				sessionId,
+				ok: false,
+				error: `注入失败: ${err instanceof Error ? err.message : String(err)}`
+			};
+		}
+	};
+}
+//#endregion
+//#region src/wake/clock.ts
+/**
+* wake/clock.ts — **时钟运行时工厂**（S142 §38 复审候选 C6b，路径 **P2**）
+*
+* 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正**：本文件当初是为**两条**独立 5min 时钟抽出的公共引擎：
+*   · 唤醒调度器（`wake/scheduler.ts`，一次性唤醒，D58）—— **现存**
+*   · autopilot 时钟（`autopilot-trajectory.ts`，周期自唤醒，D59）—— 🔴 **已随 v1.35.0 整段退场**
+* 二者的**业务判据完全不同**（谁来扫 / 扫什么 / 投递给谁 / 按什么周期），但**引擎骨架逐字同形**
+* ——进程态 + 快照 + 复位 + `startTimer` + tick 外壳 + 事件接线 + disposer + `timer.unref()`。
+* 本条把**引擎**抽到本工厂，**各钟仍各持自己的定时器与自己的串行链**（现存的那一钟 = 唤醒调度器）。
+*
+* ───────────────────────────────────────────────────────────────────────────
+* 🔴 硬约束一：**两条时钟绝不可共用"排队执行"的链**（这是 P2 与 P1 的分界判据）
+*
+* autopilot 每轮要跑该 CCC 的**偏见脚本**（`fetchBiasContent`，超时 60s），可能阻塞数十秒；
+* 若与唤醒调度器共用一条串行链，会把另一条一起**卡住**（一次性唤醒被无关的偏见脚本拖住）。
+* ⇒ 本工厂把 `chain` 作为**每实例私有状态**：`createClock()` 调用一次 = 一条独立的串行域。
+*    实例之间**零共享**（无模块级单例、无共享 Promise、无共享 map）。
+* ⚠️ 若日后有人把 `chain` 提到模块级"省一次分配"，**两条时钟的隔离即刻失效**——不许。
+*
+* 🔴 硬约束二：**武装门只判全局闸**（`gate()`），**不判"本次有无目标"**
+*
+* 2026-09-14 F 段实测缺陷：旧实现把"有 live CCC"当**武装前置条件**，而宿主刚重启时 live 会话
+* 必为空，且**"恢复旧会话"不触发 `session/created`**（只有新建会）⇒ 启动瞬间判定落空 =
+* **时钟永久不武装**（实测 6.6h 零 tick）。⇒ 现在「**全局闸开即武装**」，"有无目标"降级为
+* tick 内的廉价判定。**武装与"本次有无目标"是两件事，本工厂不得把二者耦合。**
+*
+* 🔴 硬约束三：**闸是可选能力，工厂不得替调用方假设"必须有闸"**（v1.34 S-1 解耦 → 2026-09-21 收窄）
+*
+* 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正：当前零条闸在用** —— 现存唯一那一钟
+* （唤醒调度器）本已无闸，而"曾只余的那一条" `autopilotWakeEnabled` 已随 **v1.35.0 autopilot
+* 整段退场**一并消失 ⇒ `gate` **缺省即常态，不是特例**。**唤醒调度器已无闸**
+* （原 `wakeSchedulerEnabled` 于 2026-09-21 所有者令砍掉 ⇒ 调用方**不传** `gate`
+* ＝ 恒武装、永不因闸跳过、`enabled` 恒 `true`）。工厂取 `gate` **回调**（每次现读），
+* **不做**任何合并或缓存；**缺省无闸是合法形态，不是漏配**。
+*
+* ───────────────────────────────────────────────────────────────────────────
+* 两条时钟**逐项语义差**（`ClockOptions` 的每个可配项都对应下表一行，不是随意的灵活性）：
+*
+* | 项 | 唤醒调度器 | autopilot | 工厂表达 |
+* |----|-----------|-----------|---------|
+* | `chain` | 有（全局串行） | 有（全局串行） | **总是私有**（硬约束一） |
+* | `lastTickLog` | 有（逐行摘要） | **无** | `logFrom` 不给 = 不记 |
+* | `ticks` 记账 | 工厂在 body **完成后**记 | **本钟**在同步段记 | `bodyCountsTick` + `begin` |
+* | body 返回类型 | `string[]`（人读摘要） | `void` | 泛型 `T` |
+* | 启动日志 | 固定串 | 含启用 CCC 计数 | `startLog: () => string` |
+* | body 异常兜底 | 留痕 + `console.warn` | 同 | 工厂统一（**吞异常不改语义**） |
+*
+* ───────────────────────────────────────────────────────────────────────────
+* **本工厂是"加法式"重构**（P2 的性质）：不新增任何判定逻辑，只把同形骨架收成一份代码；
+* 两个模块仍各自导出 `wakeSchedulerState()` / `autopilotClockState()` 与各自的
+* `__reset…ForTest()`，**对外可观测面（字段名与语义）零变化**——`acc-diag` ①b 段、
+* `surface/observation.ts:containerClocks()` 与面板都在读它们（见该文件 :225–250 的设计红线）。
+*
+* 为什么**不**取 P1（真合并成一个 `setInterval` + 两条策略）——2026-09-15 所有者裁决：
+* P1 只多省 ~20 行，却要把 `armed` 拆成"宿主 + 每策略"两层、并强行分开串行域，
+* 即**动两条正在跑的时钟的骨架**；**不值当**（裁决原文见 SESSION §12.8②）。
+*/
+/**
+* tick 周期（**5 分钟**）。
+*
+* 2026-09-15 S142「ACC 侧 autopilot 退场」：本值原从 `autopilot-core.ts` 导入（`TICK_MS`），
+* 但该模块随 autopilot 退场，而**本模块的唯一消费者是唤醒调度器**（`wake-scheduler`）——
+* 值本身与 autopilot 无关 ⇒ 随消费者归位到本模块（不再依赖 autopilot 判据层）。
+*
+* ⚠️ 语义不得变：该值同时是**报告文案的来源**（"等下个 Nmin tick"），历史上曾因文案写死
+* 10min 与实现 5min 不符而误导排查（§12.7 文案纠错）。
+*/
+const TICK_MS = 3e5;
+/**
+* 挂事件 → 触发 `start()`（**每个事件一次 try/catch 吞异常**：事件通道缺失不阻断时钟）。
+*
+* 为什么吞异常：宿主（headless profile 等）可能没有事件通道；**启动时已 `start()` 过一次**，
+* 事件只是"跟上面板开关 / 新会话"的热启动补丁，缺它不该让整个装配抛错。
+* @param on 宿主的 `on`（可能不存在）
+* @param ctx `on` 的 `this`（宿主 API 常要求绑定）
+* @param clock 目标时钟
+* @param events 事件名列表（回调恒为 `() => clock.start()`）
+*/
+function attachClockEvents(ctx, clock, events) {
+	const on = ctx?.on;
+	if (typeof on !== "function") return;
+	for (const name of events) try {
+		on.call(ctx, name, () => clock.start());
+	} catch {}
+}
+/**
+* 建一条时钟（**每钟各调一次**——本工厂**不是**单例，调用次数 = 时钟条数）。
+*
+* 顺序忠实于既有实现：`start()` 先武装并立即跑一次 tick → 再挂事件。
+* 拆卸由调用方经 `registerDisposer(ctx, label, clock.dispose)` 落到宿主的 `ctx.effect`。
+* @param opts 见 {@link ClockOptions}（每项对应一条既有的语义差）
+* @returns 该钟的 `{start, dispose, snapshot, reset}`
+*/
+function createClock(opts) {
+	const runtime = {
+		armed: false,
+		armedAt: null,
+		lastTickAt: null,
+		ticks: 0,
+		lastSkipReason: null
+	};
+	if (opts.logFrom) runtime.lastTickLog = [];
+	const st = {
+		timer: null,
+		chain: Promise.resolve(),
+		runtime,
+		wired: false,
+		opts
+	};
+	/** 记一次 tick（工厂内部与 body 共用同一实现——只有一处会计逻辑） */
+	const countTick = () => {
+		runtime.lastTickAt = Date.now();
+		runtime.ticks += 1;
+	};
+	/** 逐行打印（`logFrom` 缺省 ⇒ 本钟无 tick 日志，整段为死代码路径） */
+	const emit = (lines) => {
+		if (!opts.logFrom) return;
+		for (const line of lines) console.log(`${opts.logFrom.prefix}${line}`);
+	};
+	const tick = () => {
+		if (opts.gate !== void 0 && !opts.gate()) {
+			runtime.lastSkipReason = opts.gateOffReason ?? null;
+			return;
+		}
+		if (opts.begin) try {
+			opts.begin();
+		} catch (err) {
+			console.warn(`[serenity-hooks] ✗ tick 前置异常: ${String(err?.message ?? err)}（${opts.label}）`);
+			return;
+		}
+		st.chain = st.chain.then(async () => {
+			try {
+				const value = await opts.body();
+				if (!opts.bodyCountsTick) countTick();
+				if (opts.logFrom) {
+					runtime.lastTickLog = opts.logFrom.lines(value);
+					emit(runtime.lastTickLog);
+				}
+			} catch (err) {
+				const msg = `✗ tick 异常: ${String(err?.message ?? err)}`;
+				if (opts.logFrom) runtime.lastTickLog = [msg];
+				console.warn(`[serenity-hooks] ${msg}（${opts.label}）`);
+			}
+		});
+	};
+	/**
+	* 幂等启动 + 武装门：**已武装 → 原样返回**（防重复起定时器）；
+	* **闸关 → 不武装**（零资源占用）；闸开则**无条件**武装（硬约束二：不判"有无目标"）。
+	*/
+	const start = () => {
+		if (st.timer) return;
+		if (opts.events && !st.wired) {
+			st.wired = true;
+			attachClockEvents(opts.ctx, api, opts.events);
+		}
+		if (opts.gate !== void 0 && !opts.gate()) return;
+		st.timer = setInterval(tick, TICK_MS);
+		st.timer.unref();
+		runtime.armed = true;
+		runtime.armedAt = Date.now();
+		console.log(opts.startLog());
+		if (opts.immediate !== false) tick();
+	};
+	const dispose = () => {
+		if (st.timer) {
+			clearInterval(st.timer);
+			st.timer = null;
+		}
+		runtime.armed = false;
+		runtime.armedAt = null;
+		opts.onDispose?.();
+	};
+	const api = {
+		start,
+		dispose,
+		snapshot: () => ({
+			enabled: opts.gate === void 0 ? true : opts.gate(),
+			...runtime,
+			...runtime.lastTickLog ? { lastTickLog: [...runtime.lastTickLog] } : {}
+		}),
+		noteSkipReason: (reason) => {
+			runtime.lastSkipReason = reason;
+		},
+		countTick,
+		enqueue: (work) => {
+			st.chain = st.chain.then(work, () => void 0).then(() => void 0, (err) => {
+				console.warn(`[serenity-hooks] ✗ 串行任务异常（${opts.label}）: ${String(err?.message ?? err)}`);
+			});
+		},
+		reset: () => {
+			if (st.timer) {
+				clearInterval(st.timer);
+				st.timer = null;
+			}
+			runtime.armed = false;
+			runtime.armedAt = null;
+			runtime.lastTickAt = null;
+			runtime.ticks = 0;
+			runtime.lastSkipReason = null;
+			if (opts.logFrom) runtime.lastTickLog = [];
+			st.wired = false;
+			opts.onReset?.();
+		}
+	};
+	return api;
+}
+//#endregion
+//#region src/wake/scheduler.ts
+/**
+* wake/scheduler.ts — 认知轨迹唤醒调度器（D58/D59/D60；S142 2026-09-13）
+*
+* 一个**中心调度器**（5min tick，复用 autopilot 的节律常量），处理 CCC 唤醒注册表里
+* 到期的条目：把「未来时刻 + 一条 message」投递给目标认知轨迹，**fire-and-forget**
+* （无阻塞、无等待、无回执——发起方不 await，调度器不替模型结果负责）。
+*
+* 与 autopilot 的关系（D59）：**两个 tick 各自独立**。autopilot 是每 CCC 单例的
+* 周期自唤醒，逻辑一行不碰；本模块只处理注册表的一次性唤醒条目。
+*
+* 投递路径（P-1 证据链见 SESSION.md §30.6）：
+*  1. target（S### / 目录名）→ 目录名 + SESSION.md
+*  2. 目标 dsh 会话 id：`.bindings.json` 里绑定该目录名的会话（按绑定时间倒序，权威）
+*     → 回退：live 会话标题匹配
+*  3. agent：**live 优先**（`ctx.agents.get`）→ 冷会话走 `ctx.sessionController.resolveAgent`
+*     （宿主实现：live 优先 + resume 去重 + 由会话元数据恢复 preset）
+*     → `sessionController` 缺席 ⇒ 仅投递 live 目标，**不静默**（v1.39.3：**归为"环境未就绪"**
+*       而非"投递失败"，见 `WakeDeliveryResult.notReady` —— 启动那一拍早于懒服务就绪是常态）
+*  4. 投递：`agent.followup(...)`（"Queue an ordinary follow-up turn and wake the driver"）
+*
+* 守卫（2026-09-21 起**本钟无闸**）：🔴 **恒武装**——原 `wakeSchedulerEnabled` 已砍，
+* 本钟不再有「可被误关的开关」；旧配置残留该键**静默忽略**，且**不**回退 `autopilotEnabled`｜
+* CRO 阶段另有**独立**总闸 `croEnabled`（只停 CRO，**不影响**本注册表投递）｜
+* 补跑窗口 2h（超窗置 missed 留痕）｜同 tick 串行｜唤起后维持 live（人类可介入）。
+*/
+var scheduler_exports = /* @__PURE__ */ __exportAll({
+	buildCroWakeText: () => buildCroWakeText,
+	buildSendText: () => buildSendText,
+	buildWakeText: () => buildWakeText,
+	deliverWake: () => deliverWake,
+	registerWakeScheduler: () => registerWakeScheduler,
+	resolveWakeTarget: () => resolveWakeTarget,
+	sendToCognitiveTrajectory: () => sendToCognitiveTrajectory,
+	wakeSchedulerState: () => wakeSchedulerState
+});
+/**
+* 解析条目的 target（`S###` 或完整目录名）→ 目录名 + SESSION.md 路径。
+* @param root CCC 根
+* @param target 条目里的目标标识
+* @returns 命中返回目录信息，未命中 null
+*/
+function resolveWakeTarget(root, target) {
+	const found = findSession(sessionsRoot(root), target);
+	if (!found) return null;
+	const mdPath = join(found.path, "SESSION.md");
+	if (!existsSync(mdPath)) return null;
+	return {
+		dirName: basename(found.path),
+		mdPath
+	};
+}
+/**
+* 🔴 **本钟的全局闸已于 2026-09-21 砍掉**（所有者令逐字：「**send-later 的开关不再重要了，砍掉**」）。
+*
+* **为什么砍**（R↓）：唤醒已从"可选实验能力"长成**全容器的续接绳**（🔵 **术语说明，2026-09-23 补**：
+* **"绳" = 我们对自己用 `send-later` 给自己排的"定时叫醒"条目的俗称** —— 一条链每轮给自己排下一根，
+* 链才不断。本仓注释与 SESSION.md 沿用此说法，**它不是产品名、也不是宿主概念**）——S142/S151/S185 的链、
+* 跨轨迹投递、`send-now`/`send-later` 都走它。留一个"能被误关的开关"的**代价**是
+* "整条链静默停摆且无人告警"（本仓已实测过同族事故：闸关 6.6h 零 tick、断链 1 天 14 小时）；
+* 而**收益**只剩"关掉一个 5min unref 空检查"。⇒ **收益 < 代价，故删闸**（不是改为缺省开——是**没有这个键了**）。
+*
+* ⚠️ **兼容**：旧配置文件里残留的 `wakeSchedulerEnabled` **静默忽略**（无回退键、无告警噪声；
+* 与旧 `bootstrap` 段的处置先例一致）。**机制本身一行未动**（所有者："我说的只是开关"）。
+*
+* 历史（勿误读）：v1.34 S-1 曾把两闸解耦（周期自唤醒 `autopilotWakeEnabled` / 本钟 `wakeSchedulerEnabled`），
+* 理由是"关 auto-trajectory 不得连带关一次性唤醒"；随 ACC 侧 autopilot 于 v1.35.0 整段退场，
+* 两闸只剩本钟一座 ⇒ 现已整座移除。详见 `docs/cognitive-trajectory-scheduling.md` §S-1 与 v1.44 CHANGELOG。
+*/
+/**
+* 🔴 **本钟的串行域**（C6b 硬约束）：`clock.chain` 是**本实例私有**的——
+* 与 autopilot 的串行链**零共享**。autopilot 每轮跑 CCC 偏见脚本可能阻塞数十秒，
+* 共用链会把一次性唤醒一起卡住（这正是 P1 被否、取 P2 的理由，见 SESSION §12.8②）。
+*
+* **为什么这里是模块级常量**（而不是 `registerWakeScheduler` 的局部量）：本钟的进程态是
+* **进程级可观测面**（`acc-diag` ①b / `containerClocks` 在读），且 `wakeSchedulerState()` /
+* `__resetWakeSchedulerStateForTest()` 是**公开导出**、可在未装配时被调用 ⇒ 实例必须**恒在**
+* （旧实现的 `schedulerRuntime` 也正是模块级常量）。装配只做 `clock.start()`。
+*/
+/** 本钟的装配项（`ctx` 由 {@link registerWakeScheduler} 在装配点填入） */
+const clockOpts = {
+	label: "认知轨迹唤醒调度器",
+	ctx: void 0,
+	events: ["session/created", "serenity/settings-changed"],
+	body: () => runWakeTick(clockOpts.ctx),
+	logFrom: {
+		prefix: "[serenity-hooks] 认知轨迹唤醒 ",
+		lines: (lines) => lines
+	},
+	startLog: () => "[serenity-hooks] ✓ 认知轨迹唤醒调度器启动（5min tick）"
+};
+const clock = createClock(clockOpts);
+/** 调度器进程态快照（只读）。
+*  ⚠️ `enabled` 对**本钟已无意义**（2026-09-21 起无闸 ⇒ 恒 `true`）；保留字段只为沿用工厂快照形状。
+*  "这轮为什么没被唤起"现在看 `armed` / `lastSkipReason`（tick 内真实原因）+ **CRO 闸**（见 `croEnabled`）。 */
+function wakeSchedulerState() {
+	return clock.snapshot();
+}
+/**
+* 取目标 agent：live 优先 → 冷会话走 sessionController.resolveAgent → 标题回退。
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param dirName 目标认知轨迹目录名
+* @returns 命中返回 agent 与取得方式（how 进 lastResult，便于诊断）；未命中返回原因
+*   （原因带 `notReady` = **环境未就绪**而非投递失败，调用方**不得**据此记一次失败）
+*
+* 🔴 **前置条件：本轨迹名下必须有一条「未取代」的绑定记录**（2026-09-20 回源码答复 S151 实测）：
+* 选人是**遍历 `listBoundSessionIds(root, dirName)` 给出的 id**（按绑定时间倒序），**live 只是这条
+* 记录的一个加分项**——「绑定里的那条恰好 live ⇒ 直接注入」，否则走冷载入。
+* ⇒ **「有 live 会话」≠「有绑定」**：会话活着但该轨迹**零条未取代绑定**时，本函数**直接返回
+* `无绑定会话记录…`**（`send-now` / `send-later` 到点投递同此判据）。
+* 实证（2026-09-20）：S142 三条旧绑定于 **08:03** 被 `supersededAt` 取代（D69「同轨迹只留一条」），
+* 而当前载体的绑定**直到 17:05 那次 rebuild 才写入**（`queueRebuild` 内的 `appendBound(action:'rebuild')`）
+* ⇒ **10:42 的 `send-now` 落在这个窗口里** ⇒ 报"无绑定会话记录"（当时确有 live 会话）。
+* ⚠️ 已知**注释漂移**：本行上方"→ 标题回退"在函数体内**没有对应分支**（标题回退属 v1.29.2 R2，
+* 现行实现已只认绑定）；**仅登记，未改**（改它属 ACC 代码改动，须具名令）。
+*/
+async function acquireWakeAgent(ctx, root, dirName) {
+	const agents = hostAgents(ctx);
+	const ids = listBoundSessionIds(root, dirName, hostAliveProbe(ctx));
+	for (const id of ids) {
+		const live = agents?.get?.(id);
+		if (live) return {
+			agent: live,
+			how: `live(bound ${id})`
+		};
+	}
+	if (ids.length > 0) {
+		const sc = hostService(ctx, "sessionController");
+		const resolved = sc?.resolveAgent;
+		if (typeof resolved !== "function") return {
+			error: `宿主尚未就绪：目标会话未加载，且 sessionController 服务此刻不可用（重启后的启动窗口，或本进程确实无该服务）——绑定 id: ${ids[0]}`,
+			notReady: true
+		};
+		const id = ids[0];
+		try {
+			const out = await resolved.call(sc, id);
+			if (out?.agent) return {
+				agent: out.agent,
+				how: `cold-resume(${id})`
+			};
+			return { error: `sessionController.resolveAgent 未返回 agent（${id}）: ${String(out?.error ?? "未知原因")}` };
+		} catch (err) {
+			return { error: `冷会话载入失败（${id}）: ${String(err?.message ?? err)}` };
+		}
+	}
+	return {
+		/**
+		* 🔴 **文案改指真相源（2026-10-23，guard 实测报障）**：原写「`AGENT_SESSIONS/.bindings.json` 中无 X」，
+		* 而 D172 之后绑定真相源 = **`<轨迹目录>/current.dsh_session_bind`**，`.bindings.json`
+		* **已退役且不在盘上**（实测不存在）⇒ 照旧文案排查的人会去翻一个**不存在的文件**。
+		*/
+		error: `无绑定会话记录（AGENT_SESSIONS/${dirName}/current.dsh_session_bind 不存在或无有效会话）——目标轨迹需先被 cognitive_trajectory use 激活过，或由 send-now 自动创建载体`,
+		noBinding: true
+	};
+}
+/** 唤醒消息（唤起即投递正文：身份锚定 + 唤醒信息 + 任务） */
+function buildWakeText(entry, target) {
+	return [
+		`[认知轨迹唤醒] 到点（登记于 ${entry.createdAt}，发起者 ${entry.createdBy || "未知"}，id ${entry.id}）。`,
+		`当前时间：${localHuman()}（当地时区）。`,
+		"",
+		`身份锚定：继续 ${target.dirName} 的认知轨迹（SESSION.md: ${target.mdPath}）。`,
+		"",
+		"唤醒信息：",
+		entry.message,
+		"",
+		"任务：按上述唤醒信息继续本轨迹的工作；完成后把进展写入 SESSION.md。"
+	].join("\n");
+}
+/**
+* 投递一条唤醒（fire-and-forget：`followup` 入队即返回，不等模型结果）。
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param entry 唤醒条目
+* @returns 投递结果（写回 lastResult）
+*/
+async function deliverWake(ctx, root, entry) {
+	const target = resolveWakeTarget(root, entry.target);
+	if (!target) return {
+		ok: false,
+		detail: `目标认知轨迹未命中（${entry.target}）`
+	};
+	const acquired = await acquireWakeAgent(ctx, root, target.dirName);
+	if ("error" in acquired) return {
+		ok: false,
+		detail: acquired.error,
+		notReady: acquired.notReady === true
+	};
+	try {
+		acquired.agent.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text: buildWakeText(entry, target)
+			}],
+			source: PLUGIN_SOURCE
+		}));
+	} catch (err) {
+		return {
+			ok: false,
+			detail: `投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+		};
+	}
+	return {
+		ok: true,
+		detail: `已投递 ${target.dirName}（${acquired.how}）`
+	};
+}
+/**
+* 即时消息正文（**刻意不复用** {@link buildWakeText}）：唤醒文本以「**到点**（登记于…）」开头，
+* 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"。
+*
+* ⚠️ **v1.39.2 起"已入队"这句话必须删掉**（S142 §0r，所有者令「不排队、直接即时注入」）：
+* 旧文案写"消息已进入你的队列；你此前若正在跑轮次，它在本轮结束后生效"——
+* 那是**旧的 followup 语义**；现在在跑的目标走 `steer`（当场注入当前轮），
+* 留着这句话就是**注入一条假陈述**（比没有更坏：目标会误判自己看到它的时机）。
+* @param target 目标轨迹（目录名 + SESSION.md）
+* @param message 递送正文
+* @param sender 发起者轨迹标识（供目标与人类识别来源）
+*/
+function buildSendText(target, message, sender) {
+	return [
+		`[即时消息] 来自 ${sender || "未知轨迹"}。当前时间：${localHuman()}（当地时区）。`,
+		"",
+		`身份锚定：继续 ${target.dirName} 的认知轨迹（SESSION.md: ${target.mdPath}）。`,
+		"",
+		"消息：",
+		message,
+		"",
+		"说明：这是**即时投递**（不是到点唤醒）——它**不排队**：目标正在跑轮次就**当场注入当前轮**，目标空闲则立即起一轮。处理完照常把进展写入 SESSION.md。"
+	].join("\n");
+}
+/**
+* 即时投递（`cognitive_trajectory send-now`）——与 `send-later`（预约）**共用取用通路**（`acquireWakeAgent`），
+* 区别只在**时刻**（现在 vs 未来）与**回执**（有 vs 无）：
+*   · `send-later`（原 `wake-later`）：未来时刻 + 一条 message → 落注册表 → 本文件的调度器到点投递（**fire-and-forget，无回执**）
+*   · `send-now`（原 `send-message`）：**此刻**把一条 message 递给目标 → **同步回执** → **不落注册表**
+*
+* **为什么冷路径落在这里（R↓，2026-09-16 所有者裁决）**：`addWake` 显式拒绝 `at ≤ now`
+* （"时刻必须在未来"——那是"**预约**"语义的地基，不许放宽）⇒ 即时投递**不能**靠一条
+* `at=now` 的注册表条目实现（那还会让调度器把一次性即时投递当 `pending` **每 tick 重试**）。
+* 必须直接走 {@link acquireWakeAgent}（live 优先 → `sessionController.resolveAgent` 冷载入）。
+* 这正对应所有者要的「**会话不活跃则等效于直接 wake**」：**同一条冷载入通路**，只是**不等 tick**。
+*
+* ⚠️ **承诺边界（不许含糊）**：回执只到「**已注入 / 已起轮**」（宿主调用未抛错），
+* **到不了**"目标已执行/已答复" —— 与 `deliverWake` 同一层。
+* 判"目标真的动了"必须用**文件级判据**（它自己的 SESSION.md），
+* **不得凭回执结案**（§12.B 的 `delivered ≠ 跑了一轮`）。
+*
+* 🔴 **v1.39.2 语义变更（S142 §0r，所有者 2026-09-17 令：「希望 send message 时不排队，
+* 可以直接作为提示词即时注入进去」）**：
+* 旧实现一律 `followup`（宿主注释：*Queue an ordinary follow-up turn*）⇒ 目标**正在跑轮次**时
+* 消息**排在轮次边界**（即旧文案的"不打断当前轮"）。现按宿主 `agent.status` 分流：
+*   · `status === 'idle'` ⇒ `followup`（宿主**同步**把 status 置 running ⇒ **立即起轮**，本就不排队）
+*   · 否则（在跑）      ⇒ **`steer`** —— **当场注入当前轮**，这才是"不排队"的关键路径
+* ⚠️ **fail-safe**：`steer` 抛错 ⇒ **退回 `followup`**：**宁可排队，不可静默丢消息**。
+* ⚠️ **只改 `send-now`**：`send-later`（{@link deliverWake}）**保持 `followup`** ——
+* 预约的本职是"到点唤起"，且在跑时排队不打断是它被实证验收过的行为，不顺手动它。
+*
+* **归属**：本函数放在调度器侧而非工具侧 —— "怎么把一句话送到一条轨迹"是**调度器的知识**，
+* 工具只该知道"有这个动作"。这样 `cognitive-trajectory.ts` 完全不碰调度器内部（v1.35.0 硬约束①：
+* `send-later` 链路**一行为不动**，本次改动 = **纯新增**）。
+*
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param target `S###` 或 AGENT_SESSIONS 目录名
+* @param message 递送正文
+* @param sender 发起者轨迹标识
+* @returns 投递结果（**同步**返回给调用方）
+*/
+async function sendToCognitiveTrajectory(ctx, root, target, message, sender) {
+	const t = resolveWakeTarget(root, target);
+	if (!t) return {
+		ok: false,
+		detail: `目标认知轨迹未命中（${target}）`
+	};
+	let acquired = await acquireWakeAgent(ctx, root, t.dirName);
+	let createdNote = "";
+	if ("error" in acquired) {
+		if (!acquired.notReady && acquired.noBinding === true) {
+			const carrier = carrierState(root, t.dirName, hostAliveProbe(ctx));
+			if (carrier.state !== "never") {
+				const why = carrier.state === "occupied" ? `该轨迹曾经由会话 ${carrier.sessionId} 承载，而它此刻不在了` : `该轨迹当前由会话 ${carrier.sessionId} 承载`;
+				return {
+					ok: false,
+					detail: `${t.dirName}：${why} ⇒ **拒绝自动新建载体**（一条轨迹至多一个载体）。\n  · 要让它重新跑起来：把那个会话恢复，或用 cognitive_trajectory rebuild 换代（显式 takeover）。\n  · 不明所以就先 cognitive_trajectory show ${t.dirName} 看它的交代文件。`
+				};
+			}
+			acquired = await createAndBindTarget(ctx, root, t.dirName);
+			if ("error" in acquired) return {
+				ok: false,
+				detail: acquired.error
+			};
+			createdNote = `；目标原本无活跃 dsh 会话 ⇒ **已自动创建并绑定**一条（${acquired.how}）`;
+		} else return {
+			ok: false,
+			detail: acquired.error
+		};
+	}
+	const agent = acquired.agent;
+	const make = () => createUserMessage({
+		content: [{
+			type: "text",
+			text: buildSendText(t, message, sender)
+		}],
+		source: PLUGIN_SOURCE
+	});
+	const freshCarrier = createdNote !== "";
+	if (freshCarrier || agent.status === "idle") {
+		try {
+			agent.followup(make());
+		} catch (err) {
+			return {
+				ok: false,
+				detail: `投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+			};
+		}
+		return {
+			ok: true,
+			detail: `已即时投递 ${t.dirName}（${acquired.how}；${freshCarrier ? "刚建的载体 ⇒ followup 排队，锚定先于任务" : "目标空闲 ⇒ followup 立即起轮"}）${createdNote}`
+		};
+	}
+	try {
+		agent.steer(make());
+		return {
+			ok: true,
+			detail: `已即时注入 ${t.dirName}（${acquired.how}；目标在跑 ⇒ steer 当场注入当前轮）${createdNote}`
+		};
+	} catch (err) {
+		try {
+			agent.followup(make());
+		} catch (err2) {
+			return {
+				ok: false,
+				detail: `投递失败（${acquired.how}）: steer 与 followup 均失败: ${String(err?.message ?? err)} / ${String(err2?.message ?? err2)}`
+			};
+		}
+		return {
+			ok: true,
+			detail: `已投递 ${t.dirName}（${acquired.how}；steer 不可用 ⇒ 退回 followup）: ${String(err?.message ?? err)}${createdNote}`
+		};
+	}
+}
+/**
+* 🆕 **给一条「从未被激活过」的轨迹就地建一条 dsh 会话并绑定它**（2026-10-16 owner 令，S142）。
+*
+* 何时用：**只有** `send-now` 在 `acquireWakeAgent` 报「无绑定会话记录」时（见该处的判据说明）。
+*
+* ## 🔴 2026-10-18 根治：改成**和用户操作完全同一个调用形态**
+*
+* owner 原话：「应当和用户操作唤起的会话完全一样才行」。
+*
+* 上一版（v1.62.1）传的是 `{ cwd: root }`，然后**事后补** `attachSession()` 去挂工作区。
+* 那是**补救**，不是"一样" —— 宿主里那条路径（`sessionController.create` 的
+* `if (workspace !== void 0) await workspace.attachSession(sessionId)`）**只在 `workspaceId` 分支执行**：
+*
+*   ```js
+*   if (request.workspaceId !== void 0) workspace = registry.get(request.workspaceId)
+*   const cwd = workspace?.path ?? request.cwd ?? this.defaultCwd
+*   ...
+*   if (workspace !== void 0) await workspace.attachSession(sessionId)   // ← 只有这条分支
+*   ```
+*
+* 而**用户在 UI 里新建会话传的正是 `workspaceId`**（见 `client/sessions/service.d.ts` 的
+* `create({ workspaceId?, cwd?, ... })`）⇒ 用户那条路天然会走到 `attachSession`。
+*
+* ⇒ 现在与用户**同一条分支**：先由 CCC 根查出 `workspaceId`，再用 `{ workspaceId }` 建。
+*   **`attachToWorkspace` 降级为兜底**（只在"该目录还没有工作区登记"时才会用上），
+*   不再是主路径 —— 因为主路径已经由宿主自己做完。
+*
+* ## 三步（顺序不可换）
+*   ① `sessionController.create({ workspaceId })` —— 与用户同一形态；宿主替我们挂工作区。
+*      **idempotently adopt** ⇒ 重复调用不会建出第二条（不必自造"先查再建"的竞态窗口）。
+*   ② `resolveAgent(sessionId)` —— 拿到**真 agent**。`create` 只返回 id，不给 agent。
+*   ③ `appendBound(...)` —— 落绑定。**必须由本函数写**：`listBoundSessionIds` 是
+*      `acquireWakeAgent` 的唯一选人依据，不写绑定则下一条消息**还是**找不到它
+*      （那就成了"建了但永远用不上"，比不建更坏）。
+*
+* 🔴 **为什么定位到 CCC 根这一级、不是轨迹目录**：会话的 cwd 决定它落在哪个 CCC
+*    （`cccRootForCwd` 上溯 `.serenity`）。目标轨迹本就住在该 CCC 的 `AGENT_SESSIONS/` 下
+*    ⇒ 落到 CCC 根才让它**进同一个 CCC**；落到轨迹目录会让它变成一个**不同 CCC**的会话。
+*
+* @returns 命中返回 agent 与取得方式；任一步失败返回**带原因**的 error（不静默、不误报成功）
+*/
+async function createAndBindTarget(ctx, root, dirName) {
+	const sc = hostService(ctx, "sessionController");
+	const create = sc?.create;
+	if (typeof create !== "function") return {
+		error: "目标无活跃 dsh 会话，且 sessionController.create 不可用（绑定 id: 无）——无法就地创建载体；请先对该轨迹执行一次 cognitive_trajectory use",
+		notReady: true
+	};
+	const ws = findWorkspaceByPath(listWorkspaces(ctx) ?? [], root);
+	const workspaceId = typeof ws?.id === "string" && ws.id !== "" ? ws.id : void 0;
+	let sessionId = "";
+	try {
+		const out = await create.call(sc, workspaceId !== void 0 ? { workspaceId } : { cwd: root });
+		sessionId = String(out?.sessionId ?? "");
+	} catch (err) {
+		return { error: `就地创建会话失败（${dirName}）: ${String(err?.message ?? err)}` };
+	}
+	if (!sessionId) return { error: `就地创建会话未返回 sessionId（${dirName}）` };
+	const resolved = sc?.resolveAgent;
+	if (typeof resolved !== "function") return {
+		error: `会话已建（${sessionId}）但 sessionController.resolveAgent 不可用`,
+		notReady: true
+	};
+	let agent;
+	try {
+		const out = await resolved.call(sc, sessionId);
+		agent = out?.agent;
+		if (!agent) return { error: `会话已建（${sessionId}）但 resolveAgent 未返回 agent: ${String(out?.error ?? "未知原因")}` };
+	} catch (err) {
+		return { error: `会话已建（${sessionId}）但载入失败: ${String(err?.message ?? err)}` };
+	}
+	const bound = appendBound({ header: {
+		id: sessionId,
+		cwd: root
+	} }, "activate", {
+		dirName,
+		mdPath: join(root, "AGENT_SESSIONS", dirName, "SESSION.md"),
+		note: "auto-created by send-now",
+		createdAsUser: true
+	});
+	const openingNote = deliverCarrierOpening(agent, buildCarrierOpening(parseTrajectoryCode(dirName) ?? dirName, trajectoryDescOf(dirName))) ? ", opening-as-user" : ", ⚠️ 开场白未投递";
+	const titleNote = renameCarrierTitle(ctx, agent, root, dirName);
+	const wsNote = workspaceId !== void 0 ? "" : await attachToWorkspace(ctx, root, sessionId);
+	const viaNote = workspaceId !== void 0 ? ", via-workspaceId(=用户同一形态)" : ", via-cwd+attach";
+	const how = `auto-create(${sessionId}${bound.ok ? ", bound" : `, ⚠️ 绑定写入失败（${bound.code}）`}${viaNote}${openingNote}${titleNote}${wsNote})`;
+	return {
+		agent,
+		how
+	};
+}
+/**
+* 把刚建的载体会话标题**钉成与 `use` 同一形态**（2026-10-21，owner 报「标题不规范」）。
+*
+* ## 为什么单独成函数
+*
+* 它是**全仓第二个**写会话标题的点（第一个是 `use`/`rebuild` 的 `renameDshSessionOnUse`）。
+* 集中在一处，将来若要改命名规则，判据仍在 `namingTitleFor` 一个地方。
+*
+* ## 三者顺序不可换
+*
+* 必须在 ③b（投开场白）**之后**调用：
+* - 开场白让 `titleInput.count` > 0，是标题得以成立的前提；
+* - 放在之后还有**降级好处**：万一 `rename` 失败，宿主自己的 fallback 标题仍在
+*   （难看但存在），而不是两者皆无。
+*
+* @returns 回执片段（成功 `, titled` ／ 失败 `, ⚠️ 标题未写（原因）`）—— **必须出声**，
+*   否则"标题没写"会表现成"这条轨迹就是这名字"（D186：守卫可以拒绝，但不许不出声）。
+*/
+function renameCarrierTitle(ctx, agent, root, dirName) {
+	try {
+		const titles = hostService(ctx, "sessionTitle");
+		if (!titles || typeof titles.rename !== "function") return ", ⚠️ 标题未写（sessionTitle 不可用）";
+		const session = agent.session;
+		if (!session || typeof session !== "object") return ", ⚠️ 标题未写（无 session）";
+		const title = namingTitleFor({
+			sessionId: parseTrajectoryCode(dirName) ?? dirName,
+			dirName,
+			mdPath: join(root, "AGENT_SESSIONS", dirName, "SESSION.md")
+		});
+		titles.rename(session, title);
+		return ", titled";
+	} catch (err) {
+		return `, ⚠️ 标题未写（${String(err?.message ?? err)}）`;
+	}
+}
+/**
+* 把刚建的会话挂进 **cwd 所属的那个工作区**（2026-10-17 缺陷修复）。
+*
+* 🔴 **为什么必须我们自己做（宿主源码取证，不是推断）**：
+*   `sessionController.create()` 里 `attachSession` **只在 `workspaceId` 分支执行** ——
+*   `dsh-api-session-controller/lib/index.js` 的 `create()`：
+*     ```
+*     if (request.workspaceId !== void 0) workspace = registry.get(request.workspaceId)
+*     const cwd = workspace?.path ?? request.cwd ?? this.defaultCwd
+*     ...
+*     if (workspace !== void 0) await workspace.attachSession(sessionId)   // ← 只有这条分支挂工作区
+*     ```
+*   我们传的是 `{ cwd }`（**必须如此**：`workspaceId` 与 `cwd` 互斥，而工作区 id 是宿主的内部 uuid，
+*   我们又得按"这条轨迹住在哪个 CCC"来建会话）⇒ **建出来的会话从不登记进任何工作区**。
+*
+* 🔴 **症状（现场实证，本机真实数据）**：`send-now` 自动建出的那条会话
+*   （`note` = `auto-created by send-now`）header `cwd` 确实是某个 CCC 根，
+*   **却不在**该工作区的 `sessionIds` 里
+*   （同一个 CCC 的另外两条会话都在）⇒ WebUI 里它不属于那个工作区。
+*
+* 🔴 **为什么按 `path` 找而不是"拿第一个"**：多个 CCC 并存（本机实有 5 个工作区）
+*   ⇒ 拿第一个必然挂错。判据 = `workspace.path === root`（宿主 `Workspace.path` 是
+*   **realpath 规范化**后的规范路径；`root` 已是 `cccRootForCwd` 上溯出来的真实目录，
+*   两侧同一来源，故可直接比）。
+*
+* ⚠️ **失败不阻断投递**：工作区归属影响的是"在 WebUI 里归哪个工作区"，
+*   而消息投递已经完成 ⇒ 把原因**如实写进回执**，不吞、也不把成功改成失败。
+*
+* @param ctx 插件上下文
+* @param root CCC 根（= 该会话的 cwd）
+* @param sessionId 刚建出来的会话 id
+* @returns 追加到回执里的短注记（成功/跳过为空串，失败带原因）
+*/
+async function attachToWorkspace(ctx, root, sessionId) {
+	const workspaces = listWorkspaces(ctx);
+	if (workspaces === void 0) return ", ⚠️ 工作区未挂载（workspaceRegistry 不可用）";
+	const match = findWorkspaceByPath(workspaces, root);
+	if (match === void 0) return "";
+	if (typeof match.attachSession !== "function") return ", ⚠️ 工作区未挂载（attachSession 不可用）";
+	if (Array.isArray(match.sessionIds) && match.sessionIds.includes(sessionId)) return "";
+	try {
+		await match.attachSession(sessionId);
+		return ", workspace-attached";
+	} catch (err) {
+		return `, ⚠️ 工作区挂载失败: ${String(err?.message ?? err)}`;
+	}
+}
+/** `workspaceRegistry.list()` 的读取收口（不可用返回 `undefined`，**与"空列表"区分**） */
+function listWorkspaces(ctx) {
+	const reg = hostService(ctx, "workspaceRegistry");
+	if (typeof reg?.list !== "function") return void 0;
+	try {
+		return reg.list() ?? [];
+	} catch {
+		return;
+	}
+}
+/**
+* 在 `workspaceRegistry.list()` 里找 **path 等于该 CCC 根** 的那一个。
+*
+* 🔴 **为什么要 realpath 归一（不是画蛇添足）**：宿主的 `Workspace.path` 是
+*   **`fs.realpath` 规范化**过的（`entity.d.ts` 逐字：*"Canonical directory path: the
+*   `fs.realpath` of the path given at create time (trailing slashes, `..`, and symlinks
+*   all resolved)"*）。而 `root` 来自 `cccRootForCwd` 的上溯——**上溯用的是字面路径**。
+*   ⇒ 当 CCC 根是一个**符号链接**（部署上常见：家目录/项目目录被链到别处），
+*   两侧**逐字不等**，只比字符串会**挂错或挂不上**。
+*
+* ⚠️ 归一失败（路径不存在等）时**回落字面比较** —— 不改既有语义，只是多给一次机会。
+*
+* @param workspaces registry.list() 的返回
+* @param root CCC 根
+* @returns 命中的工作区，无则 undefined
+*/
+function findWorkspaceByPath(workspaces, root) {
+	const direct = workspaces.find((ws) => ws?.path === root);
+	if (direct !== void 0) return direct;
+	const canonical = (p) => {
+		try {
+			return realpathSync(p);
+		} catch {
+			return p;
+		}
+	};
+	const want = canonical(root);
+	return workspaces.find((ws) => typeof ws?.path === "string" && canonical(ws.path) === want);
+}
+/**
+* 本 tick 要扫的 CCC 根集合（**并集**）。
+*
+* C2（S142 2026-09-15 Q5）：原实现是 `collectLiveCccs`——**只认 live 会话** ⇒
+* "完全冷掉的 CCC 不能自唤醒自己"（已知边界）。现改为 `ccc-roots.listCccs` 的并集枚举
+* （工作区注册表 ∪ 持久化会话 ∪ live 会话）：**没有 live 会话的 CCC 也会被扫到**。
+*
+* ⚠️ 边界（本步**只**改"枚举哪些 CCC"，**不改**"怎么找到要交付的 agent"）：
+* 把 message 交给某条认知轨迹仍必须靠 **live 会话**解析（见本文件
+* `acquireWakeAgent`）；无 live 会话时该 CCC 只是**被扫到、
+* 无交付对象** ⇒ `deliverWake` 返回 `无绑定会话记录…`，条目回 `pending` 并留痕。
+* 因此本函数**不得**让 tick 抛错（异常一律由调用方 tick 兜住，见 `runWakeTick` 的 try）。
+* @param ctx 插件上下文
+* @returns CCC 根列表（无任何来源 → `[]`）
+*/
+async function collectWakeCccs(ctx) {
+	return (await listCccs(ctx)).map((e) => e.root);
+}
+/**
+* CRO 唤起消息正文（**刻意不复用** {@link buildWakeText} / {@link buildSendText}）。
+*
+* 三种唤起各有自己的**事实**；混用 = 注入一条假陈述（本容器栽过：`buildSendText` 里
+* 那句"消息已入队"就是一条假陈述，见该函数注释）：
+* · `buildWakeText` —— 「**到点**了」（登记过的未来时刻，人/agent 算好的）
+* · `buildSendText` —— 「**有人此刻给我发了一条消息**」
+* · 本函数         —— 「**我自己的程序**看情况判定该叫我了」（**没有到点、也没有人发消息**）
+*
+* 🔴 `reason` 的呈现（设计 §4.2）：**程序没写就明说没写**，不留空白 ——
+* 改成程序判定后，"当时为什么叫了"**不再能从时间表重建**（原因在程序肚子里）；
+* 留空白 = 连"丢在哪一环"都看不出来。写明"未提供"至少把缺口标出来了（CCE：重建 > 保存）。
+* @param dirName 目标轨迹目录名
+* @param mdPath 目标 SESSION.md 绝对路径
+* @param prompt 程序给的唤起提示词
+* @param reason 程序给的判定理由（可为 null）
+* @returns 投递正文
+*/
+function buildCroWakeText(dirName, mdPath, prompt, reason) {
+	return [
+		`[CRO 唤起] ${dirName} 自带的 continuous-re-occurrence.ts 判定：现在该唤起。`,
+		`当前时间：${localHuman()}（当地时区）。`,
+		"",
+		`身份锚定：继续 ${dirName} 的认知轨迹（SESSION.md: ${mdPath}）。`,
+		"",
+		`判定理由：${reason ?? "（程序未提供 reason —— 见 CRO 编写指南 §7 坑 3）"}`,
+		"",
+		"唤起提示词：",
+		prompt,
+		"",
+		"说明：这是由**本轨迹自己的 CRO 程序**按当时情况做的判定（**不是**定时唤醒，**也不是**别人发的消息）。处理完照常把进展写入 SESSION.md。"
+	].join("\n");
+}
+/**
+* 投递一条 CRO 唤起（**fire-and-forget**，与 {@link deliverWake} 同层）。
+*
+* · **取用通路复用** {@link acquireWakeAgent}（live 优先 → 冷载入）：这是调度器侧唯一的
+*   "怎么把一句话送到一条轨迹"的知识 ⇒ 不另立第二条（设计 §9-2 的倾向：复用投递面）。
+* · 🔴 **不落唤醒表**（设计 §6.3）：CRO 是"**持续判定**"，不是"**某个未来时刻**"。
+*   落表会给 §0Q（投递即删、表只保在办）**增加一个新的写入源**。
+* · 用 `followup`（不用 `steer`）：CRO 由**调度器**发起，与 `send-later` 同层；
+*   `steer`（当场注入当前轮）是 `send-now` 的语义 —— 那是人类/agent 的**即时动作**。
+* · 🔴 **失败不回滚、不重试**（与条目投递不同）：下一 tick 会**重新判定**——
+*   CRO 的判据是"情况"，不是"这条消息还没送出去" ⇒ 自愈来自**重判**，不来自重投。
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param dirName 目标轨迹目录名（= CRO 只能唤起**自己**，设计 §9-8 的倾向）
+* @param prompt 唤起提示词
+* @param reason 判定理由
+* @returns 投递结果（进 tick 日志；**不写注册表**）
+*/
+async function deliverCroWake(ctx, root, dirName, prompt, reason) {
+	const mdPath = join(sessionsRoot(root), dirName, "SESSION.md");
+	let acquired = await acquireWakeAgent(ctx, root, dirName);
+	/**
+	* 🔴 **载体自举（2026-10-23，guard 实测报障后补）**
+	*
+	* ## 缺陷（真实代价）
+	*
+	* 一条「**生来就是为了被自己的 CRO 叫醒**」的轨迹，**第一次自唤醒在物理上不可能**：
+	* 它是程序化 `create` 出来的 ⇒ 没有载体 ⇒ `noBinding` ⇒ 投递被拒
+	* ⇒ **恰恰在最需要被叫醒的那一刻没有载体可注入**。实测证据：
+	* `cro-wake-log.log` 首行 `fail ... 无绑定会话记录`，而**那一轮的 CRO 判定完全正确**。
+	*
+	* ## 为什么可以自举，以及它与 `send-now` 的分支差在哪
+	*
+	* `send-now` 的自举理由是「完成一次**人/agent 的**意图」；CRO 是**每 5min 自动重判**，
+	* 若照搬会有「**载体爆炸**」风险。故本路径**多一道闸**：
+	*
+	* - 只认 `carrierState === 'never'`（**从未有过载体**）⇒ 建一次；
+	* - `occupied`（有过但那个会话不在了）⇒ **一律不建**，如实报错。
+	*
+	* ⇒ 自举**至多发生一次**（建完就有 `current.dsh_session_bind`，此后 `carrierState` 不再是 `never`）。
+	* 这正是 `carrierState` 那道守卫的语义，与 `send-now` 共用同一条判据（不另立）。
+	*
+	* ⚠️ 只处理 `noBinding`；`notReady`（启动窗口）与冷载入失败**照原样返回** ——
+	* 那些不是"没载体"，建新载体解决不了且可能制造第二条。
+	*/
+	if ("error" in acquired && acquired.noBinding === true) {
+		const carrier = carrierState(root, dirName, hostAliveProbe(ctx));
+		if (carrier.state === "never") {
+			const created = await createAndBindTarget(ctx, root, dirName);
+			if (!("error" in created)) {
+				acquired = created;
+				console.log(`[serenity-hooks] CRO 载体自举：${dirName} 从未有过载体 ⇒ 已自动创建并绑定（${created.how}）`);
+			}
+		} else
+ /**
+		* 🔴 **拒绝自举时必须指名是哪一半**（D186：守卫可以拒绝，但不许不出声）。
+		*
+		* 若照原样把 `acquireWakeAgent` 的 `noBinding` 文案透传出去，`cro-wake-log` 里
+		* 「`current.dsh_session_bind` 不存在或无有效会话」**两种状态长得一模一样**：
+		*   · `never` —— 那条轨迹**生来就没有载体**（本次已自举，不会走到这里）；
+		*   · `occupied` —— **有过载体、那个会话现在不在了**（本分支拒绝自建）。
+		* ⇒ 读日志的人分不出"该去救那个会话"还是"该去查为什么没建起来"，
+		*   而这正是本仓反复付代价的那类缺陷（D131：不靠一句话给状态命名，但**状态不同必须说出来**）。
+		*/
+		acquired = { error: carrier.state === "occupied" ? `CRO 唤起未投递：${dirName} 曾经由会话 ${carrier.sessionId} 承载，而它此刻不在了 ⇒ **拒绝自动新建载体**（一条轨迹至多一个载体，而 CRO 每 5min 重判一次，自建会让载体反复膨胀）。\n  · 要恢复：把那个会话救回来，或用 cognitive_trajectory rebuild 显式换代（takeover）。` : `CRO 唤起未投递：${dirName} 的载体声明指向会话 ${carrier.sessionId}，它按探针**仍可用**，而选人路径却报"无绑定" ⇒ **两处读数打架，不新建载体**（先查绑定文件与归档集）。` };
+	}
+	if ("error" in acquired) return {
+		ok: false,
+		detail: acquired.error,
+		notReady: acquired.notReady === true
+	};
+	try {
+		acquired.agent.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text: buildCroWakeText(dirName, mdPath, prompt, reason)
+			}],
+			source: PLUGIN_SOURCE
+		}));
+	} catch (err) {
+		return {
+			ok: false,
+			detail: `CRO 投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+		};
+	}
+	return {
+		ok: true,
+		detail: `已投递（${acquired.how}）`
+	};
+}
+/**
+* CRO 阶段：本 tick 对**每条启用了 CRO 的轨迹**跑一次它自带的程序，按判定投递。
+*
+* ## 为什么放在既有投递**之后**（R↓）
+* · 既有条目（`send-later`）**有到点承诺** ⇒ 优先级天然更高；
+* · CRO 是"看着情况叫"，**晚一拍无成本**（tick 粒度本就是 5min）；
+* · ⇒ 铁律（设计 §5）：**CRO 的任何失败都不影响既有链路** —— 整段由调用方兜住，
+*   且**每条轨迹各自 try/catch**（一条坏程序不得连累同 tick 的其它轨迹）。
+*
+* ## 日志口径（刻意与既有投递不同）
+* "每 tick × 每条轨迹"都写一行 ⇒ 对"**常态是不唤起**"的 CRO 就是刷屏。
+* ⇒ 逐条只记 **唤起**（`reason` 进日志 —— 设计 §4.2 要求可重建）与 **跳过**（异常，必须看见）；
+*   **不唤起只进汇总行**（`唤起 x，不唤起 y，跳过 z`）。
+* ⚠️ **诚实标注**：因此"某条轨迹当轮**为何没叫**"**不进 tick 日志**（它在程序肚子里）。
+*    要完整的逐次判定审计，须**程序自己**写状态文件（设计 §3.3）——ACC 给不了。
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param registry 本 tick 已载入的唤醒注册表条目（供快照的 `pendingWakes`；读坏时传 `[]`）
+* @param log 本 tick 的人读摘要（就地追加）
+*/
+async function runCroPhase(ctx, root, registry, log) {
+	if (readSimpleSettings().croEnabled === false) {
+		log.push("CRO 阶段：已关闭（croEnabled=false）——既有唤醒投递不受影响");
+		return;
+	}
+	let dirs;
+	try {
+		dirs = listCroCognitiveTrajectories(root);
+	} catch {
+		return;
+	}
+	if (dirs.length === 0) return;
+	const nowMs = Date.now();
+	const s = wakeSchedulerState();
+	const scheduler = {
+		armed: s.armed,
+		enabled: s.enabled,
+		ticks: s.ticks,
+		lastSkipReason: s.lastSkipReason
+	};
+	const agents = hostAgents(ctx);
+	const selfHost = safeHostname();
+	let hostSkips = 0;
+	let wakes = 0;
+	let quiet = 0;
+	let skips = 0;
+	for (const dirName of dirs) try {
+		const verdict = resolveCroHostBinding(root, dirName, selfHost);
+		if (!verdict.allowed) {
+			hostSkips += 1;
+			log.push(`· ${root}: ${dirName}: CRO 机器绑定未通过（${verdict.code}）：${verdict.detail}`);
+			continue;
+		}
+		const bound = listBoundSessionIds(root, dirName, hostAliveProbe(ctx));
+		const running = runningCarriersOf(bound, nowMs);
+		const outcome = await evaluateCro(root, dirName, readCroSnapshotInput(root, dirName, nowMs, {
+			boundSessionIds: bound,
+			liveSessionIds: bound.filter((id) => Boolean(agents?.get?.(id))),
+			runningSessionIds: running,
+			pendingWakes: registry.filter((e) => e.state === "pending" && resolveWakeTarget(root, e.target)?.dirName === dirName).map((e) => ({
+				id: e.id,
+				at: e.at,
+				createdAt: e.createdAt,
+				createdBy: e.createdBy
+			})),
+			scheduler
+		}));
+		if (outcome.status === "wake") {
+			wakes += 1;
+			const res = await deliverCroWake(ctx, root, dirName, outcome.prompt, outcome.decision.reason);
+			log.push(`· ${root}: ${renderCroOutcome(dirName, outcome)} → ${res.ok ? "已投递" : `投递未成功：${res.detail}`}`);
+			{
+				const rec = appendCroWakeLog(root, dirName, {
+					ok: res.ok,
+					...res.notReady === true ? { notReady: true } : {},
+					detail: res.detail,
+					tick: s.ticks,
+					reason: outcome.decision.reason ?? null,
+					prompt: outcome.prompt
+				}, nowMs);
+				if (!rec.ok) log.push(`· ${root}: ${dirName}: CRO 流水写入失败（已忽略，不影响投递）: ${rec.error}`);
+			}
+		} else if (outcome.status === "skipped") {
+			skips += 1;
+			log.push(`· ${root}: ${renderCroOutcome(dirName, outcome)}`);
+		} else if (outcome.status === "no-wake") {
+			quiet += 1;
+			/**
+			* 🔴 **2026-10-23（A102）：`no-wake` 也落盘。**
+			*
+			* 修前这里**只累加计数**、一个字都不写该轨迹的流水 ⇒ 流水**永久停在上一次真唤起处**。
+			* 实测后果（guard 轨迹，真机）：它的 `cro-wake-log.log` 停在 `01:40:55`，
+			* owner 据此认为"守卫从那以后就没工作过"——而真相是它**此后每个 tick 都在被评估**，
+			* 只是判定为"不打扰"。⇒ **「我判了、只是不叫」与「我根本没被评估」在读数上完全一样。**
+			*
+			* 判据同 D209：**可以不出声地判"不打扰"，但"判过"本身要留痕**。
+			* 四态：`ok` ／ `fail` ／ `not-ready` ／ `no-wake`。
+			*
+			* ⚠️ 与 `wake` 分支同一条硬约束：**写流水失败绝不影响投递与既有链路**（设计 §5 铁律）。
+			*/
+			{
+				const rec = appendCroWakeLog(root, dirName, {
+					ok: false,
+					noWake: true,
+					detail: outcome.detail,
+					tick: s.ticks,
+					reason: outcome.decision.reason ?? null
+				}, nowMs);
+				if (!rec.ok) log.push(`· ${root}: ${dirName}: CRO 流水写入失败（已忽略，不影响既有链路）: ${rec.error}`);
+			}
+		}
+	} catch (err) {
+		skips += 1;
+		log.push(`· ${root}: ${dirName}: CRO 内部异常（已忽略，不影响既有链路）: ${String(err?.message ?? err)}`);
+	}
+	log.push(`· ${root}: CRO 评估 ${dirs.length} 条（唤起 ${wakes}，不唤起 ${quiet}，跳过 ${skips}${hostSkips > 0 ? `，非本机绑定 ${hostSkips}` : ""}）`);
+}
+/**
+* 取本机机器名（**永不抛**）。
+*
+* `os.hostname()` 理论上可能抛（极少数环境）⇒ 这里兜底成空串。
+* ⚠️ **空串的后果是"全部不通过"**（`bound === self` 永不成立）⇒ 即 **fail-closed**，
+* 与所有者裁定同向（宁可都不跑，也不会"名字取不到就随便跑"）。
+* @returns 本机机器名；取不到 ⇒ `''`
+*/
+function safeHostname() {
+	try {
+		return hostname();
+	} catch {
+		return "";
+	}
+}
+/** 一次调度 tick：遍历已知 CCC → 到期项串行投递 / 超窗项置 missed；返回人读摘要 */
+async function runWakeTick(ctx) {
+	const log = [];
+	const roots = await collectWakeCccs(ctx).catch(() => []);
+	if (roots.length === 0) {
+		clock.noteSkipReason("无已知 CCC 可扫（等某个会话/工作区出现）");
+		return log;
+	}
+	clock.noteSkipReason(null);
+	for (const root of roots) {
+		const purged = purgeFinalizedWakes(root);
+		if (purged.ok && purged.purged > 0) log.push(`· ${root}: 清除 ${purged.purged} 条已结案记录（存量首清）`);
+		const { registry, error } = loadWakeRegistry(root);
+		if (error) {
+			log.push(`✗ ${root}: ${error}`);
+			await runCroPhase(ctx, root, [], log);
+			continue;
+		}
+		const { due, expired } = splitDueWakes(registry, Date.now(), WAKE_CATCH_UP_MS);
+		for (const e of expired) {
+			finalizeWake(root, e.id, "missed", `超过补跑窗口（${WAKE_CATCH_UP_MS / 36e5}h）未投递`);
+			log.push(`· ${root}: ${e.id} → missed（超补跑窗口，已清除）`);
+		}
+		for (const e of due) {
+			const res = await deliverWake(ctx, root, e);
+			if (res.notReady) {
+				log.push(`· ${root}: ${e.id} → 跳过（宿主服务未就绪，下个 tick 再试；不计失败）`);
+				continue;
+			}
+			if (res.ok) {
+				finalizeWake(root, e.id, "delivered", res.detail);
+				log.push(`· ${root}: ${e.id} → delivered（已清除）`);
+			} else {
+				updateWake(root, e.id, {
+					state: "pending",
+					attempts: e.attempts + 1,
+					lastResult: res.detail
+				});
+				log.push(`· ${root}: ${e.id} → 重试（${res.detail}）`);
+			}
+		}
+		await runCroPhase(ctx, root, registry.entries, log);
+		await runInterruptedSafetyNet(ctx, root, log);
+	}
+	return log;
+}
+/**
+* 🔴🔴 **A104-C′（2026-10-23，owner 点头）：容器级「被重启打断的会话」兜底 —— 每 tick 扫一次并注入。**
+*
+* ## 为什么必须做（不是"多一层保险"，是**已有实测盲窗**）
+*
+* 2026-10-23 实测：`08:02` 一次 `restart-web` 打断了一个会话，此后 **13 分钟无人拉起**。
+* 用真回放（把日志截到争议时刻 ＋ 重压 zstd 帧 ＋ 同一份实现）验证：
+*  - 截到 `08:07:30`／`08:12:40` ⇒ **两次都能判出该会话 `turn/end[interrupted]` 且其后无新 `turn/start`**
+*  - 而那两个 tick **实际都没有叫** ⇒ **判据没错，是"没有被跑起来"**
+*
+* ⇒ 结论：**「守护程序自己修好」≠「一定有人拉起」**。任何单条 CRO 轨迹都可能因为
+*    自身在跑、绑定缺失、阈值保护、程序 bug 而漏掉 —— 而被打断的会话**不会自己恢复**。
+* ⇒ 兜底必须放在**容器自己**身上，且必须**自己完成"发现 + 注入"**（只扫不动没有用）。
+*
+* ## 边界（写在这里免得后人扩大它）
+*
+* - ⚠️ **这会真的起 agent、真烧算力** —— owner 已被告知并点头（2026-10-23）。
+* - 🔴 **必须排除 live 会话**：正在跑的会话不该被再注入一次（否则重复投递）。
+* - 🔴 **与 CRO 并存、不替代**：CRO 是**轨迹自己的策略**（何时该叫由它判），
+*   本兜底只覆盖「**无论谁都没叫**」这一格。两者重复命中时，靠 `live` 排除天然去重。
+* - ⚠️ **本函数任何失败都不得连累既有链路**（设计 §5 铁律）：整体 try/catch 吞掉并留一行日志。
+*/
+async function runInterruptedSafetyNet(ctx, root, log) {
+	const s0 = wakeSchedulerState();
+	const tickNow = s0.ticks + 1;
+	const phase = tickNow <= 1 ? "启动首拍" : tickNow <= 3 ? "刚启动窗口" : "常规 tick";
+	const tickTag = `tick=${s0.ticks}(当前第${tickNow}拍·${phase})`;
+	try {
+		const agents = hostAgents(ctx);
+		const sc = hostService(ctx, "sessionController");
+		/**
+		* 🔴 **A105：live 排除的粒度 =「此刻有没有在跑」，不是「宿主认不认识它」。**
+		*
+		* 修前：`collectLiveSessionIdsForSafetyNet` 取的是 `hostSessions(ctx).list()`
+		* ⇒ 那是**载入状态**（会话对象在本进程里），**不是**轮次状态 ⇒
+		* 一条「已载入、但上一轮被重启打断」的会话会被**误排除**，
+		* 而那恰恰是**最该被接走**的一类（2026-10-23 实测：这正是那次 13 分钟盲窗的形状）。
+		*
+		* ⇒ 现在与权威 `interrupted` 动作**用同一个取数口**（`listRunningSessionIds`），
+		*   两处对"在跑"的认知**不可能再不一致**（A105 的全部目的就是这一条）。
+		*/
+		const liveIds = new Set(listRunningSessionIds(Date.now()));
+		const scan = scanInterruptedSessions(`${sessionsRootDir()}/${projectDirNameForCwd(root)}`, { liveIds });
+		/**
+		* 🔴 **A106：无命中也要出声**（`ok`/`fail`/`not-ready`/`no-wake` 之后缺的第五格）。
+		*
+		* 修前这里 `return`，**一行都不写** ⇒ 宿主日志里没有任何「中断兜底」字样 ⇒
+		* **「我扫了、没东西」与「我没被跑」在读数上完全一样**（D216 同族第四次）。
+		* ⇒ 判据同 A102：**可以不出声地判"没事"，但"判过"本身要留痕**。
+		* ⚠️ 密度很低（每 tick 一行，5min 一次），且**必须带拍号与扫描读数**，
+		*   否则又是一堆分不清是哪一拍的日志行（guard 明确要求）。
+		*/
+		if (scan.sessions.length === 0) {
+			log.push(`· ${root}: 中断兜底 ${tickTag} → 扫 ${scan.scanned} 个 · 命中 0 · 排除在跑 ${liveIds.size} 个 · 跳过 ${scan.skipped} ⇒ 无需注入`);
+			return;
+		}
+		const resumeOne = createResumeOne({
+			agents,
+			sessionController: sc,
+			makeMessage: (text) => createUserMessage({
+				content: [{
+					type: "text",
+					text
+				}],
+				source: PLUGIN_SOURCE
+			})
+		});
+		log.push(`· ${root}: 中断兜底 ${tickTag} → 扫 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 排除在跑 ${liveIds.size} 个`);
+		for (const hit of scan.sessions) try {
+			const out = await resumeOne(hit);
+			log.push(`· ${root}: 中断兜底 ${hit.sessionId}（turn ${hit.turn ?? "?"}）→ ` + (out.ok ? `已注入（${out.how ?? "?"}）` : `未注入：${out.error ?? "未知"}`));
+		} catch (err) {
+			log.push(`· ${root}: 中断兜底 ${hit.sessionId} 注入抛错（已忽略）：${String(err?.message ?? err)}`);
+		}
+	} catch (err) {
+		log.push(`· ${root}: 中断兜底 ${tickTag} 整体失败（已忽略，不影响既有链路）：${String(err?.message ?? err)}`);
+	}
+}
+/**
+* ⚠️ **2026-10-23 A105 已删除 `collectLiveSessionIdsForSafetyNet`。**
+*
+* 它取的是 `hostSessions(ctx).list()` =「宿主认不认识」，而 A105 的结论是
+* 判据必须是「**此刻有没有在跑**」。现在两处（本兜底与权威 `interrupted` 动作）
+* 都走 `listRunningSessionIds()` —— **同一张表、同一个口径**，不可能再打架。
+*
+* 🔴 后人若要"把 live 表也加回来做双保险"：**不要** ——
+*    `live ∧ ¬running` 恰是「已载入、但上一轮被打断」那一类，**它最该被接走**；
+*    加回来就是把最该救的那一格重新排除掉。
+*/
+/**
+* 装配调度器（index.ts apply 调用）：5min tick + 生命周期 disposer +
+* 会话出现/settings 变化时热启动（与 autopilot 同款触发面，互不干扰）。
+* @param ctx 插件上下文
+*/
+function registerWakeScheduler(ctx) {
+	clockOpts.ctx = ctx;
+	clock.start();
+	registerDisposer(ctx, "认知轨迹唤醒调度器", () => clock.dispose());
+}
+//#endregion
+export { DEFAULT_LOOKBACK_MS as a, scanInterruptedSessions as c, registerDisposer as d, buildCroSnapshot as f, listWakes as g, addWake as h, wakeSchedulerState as i, listRunningSessionIds as l, WAKE_CATCH_UP_MS as m, scheduler_exports as n, createResumeOne as o, listCroCognitiveTrajectories as p, sendToCognitiveTrajectory as r, projectDirNameForCwd as s, registerWakeScheduler as t, registerCroTurnTracking as u };