@shgroup/dsh-serenity-hooks 1.88.0 → 1.89.0

package/lib/index.js

@@ -8631,7 +8631,7 @@ function formatCroLogLine(entry) {
 	const head = oneline(entry.promptDigest.head);
 	return [
 		oneline(entry.at),
-		entry.ok ? "ok" : entry.notReady === true ? "not-ready" : "fail",
+		entry.ok ? "ok" : entry.notReady === true ? "not-ready" : entry.noWake === true ? "no-wake" : "fail",
 		`tick=${entry.tick}`,
 		oneline(entry.detail),
 		`reason=${reason}`,
@@ -8652,7 +8652,7 @@ function parseCroLogLine(line) {
 	const at = parts[0];
 	if (Number.isNaN(Date.parse(at))) return null;
 	const mark = parts[1];
-	if (mark !== "ok" && mark !== "fail" && mark !== "not-ready") return null;
+	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) : "";
@@ -8661,6 +8661,7 @@ function parseCroLogLine(line) {
 		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,
@@ -8820,6 +8821,7 @@ function appendCroWakeLog(root, dirName, input, nowMs = Date.now()) {
 			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,
@@ -8848,112 +8850,509 @@ function appendCroWakeLog(root, dirName, input, nowMs = Date.now()) {
 	}
 }
 //#endregion
-//#region src/wake/clock.ts
+//#region src/trajectory/interrupted.ts
 /**
-* wake/clock.ts — **时钟运行时工厂**（S142 §38 复审候选 C6b，路径 **P2**）
+* 中断轮次发现（`interrupted` 会话扫描）
 *
-* 🔴 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 的分界判据）
+* DSH 的会话日志里，**进程在某一轮完成前退出**（被 kill／崩溃／关机超时）时，
+* 宿主重放时会为该轮补上收尾事件：
 *
-* autopilot 每轮要跑该 CCC 的**偏见脚本**（`fetchBiasContent`，超时 60s），可能阻塞数十秒；
-* 若与唤醒调度器共用一条串行链，会把另一条一起**卡住**（一次性唤醒被无关的偏见脚本拖住）。
-* ⇒ 本工厂把 `chain` 作为**每实例私有状态**：`createClock()` 调用一次 = 一条独立的串行域。
-*    实例之间**零共享**（无模块级单例、无共享 Promise、无共享 map）。
-* ⚠️ 若日后有人把 `chain` 提到模块级"省一次分配"，**两条时钟的隔离即刻失效**——不许。
+* ```jsonl
+* turn/end {"turn":66,"reason":{"kind":"interrupted"}}
+* step/end {"turn":66,"step":85}
+* session/end-seed {}
+* ```
 *
-* 🔴 硬约束二：**武装门只判全局闸**（`gate()`），**不判"本次有无目标"**
+* 宿主**只补收尾，不续跑** —— 那一轮的工作就此停在那里。本模块负责把这些会话找出来，
+* 交给上层（认知轨迹）决定要不要续。
 *
-* 2026-09-14 F 段实测缺陷：旧实现把"有 live CCC"当**武装前置条件**，而宿主刚重启时 live 会话
-* 必为空，且**"恢复旧会话"不触发 `session/created`**（只有新建会）⇒ 启动瞬间判定落空 =
-* **时钟永久不武装**（实测 6.6h 零 tick）。⇒ 现在「**全局闸开即武装**」，"有无目标"降级为
-* tick 内的廉价判定。**武装与"本次有无目标"是两件事，本工厂不得把二者耦合。**
+* ## 判据（三条同时成立，缺一不可）
 *
-* 🔴 硬约束三：**闸是可选能力，工厂不得替调用方假设"必须有闸"**（v1.34 S-1 解耦 → 2026-09-21 收窄）
+* 1. 日志里**最后一条 `turn/end`** 的 `reason.kind === 'interrupted'`；
+* 2. 该 `turn/end` **之后没有新的 `turn/start`**（否则已被后续轮次接续）；
+* 3. ⛔ **不要求**末条是 `session/end-seed`（2026-10-23 放宽，原因见 {@link detectInterruptedEnd}）。
 *
-* 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正：当前零条闸在用** —— 现存唯一那一钟
-* （唤醒调度器）本已无闸，而"曾只余的那一条" `autopilotWakeEnabled` 已随 **v1.35.0 autopilot
-* 整段退场**一并消失 ⇒ `gate` **缺省即常态，不是特例**。**唤醒调度器已无闸**
-* （原 `wakeSchedulerEnabled` 于 2026-09-21 所有者令砍掉 ⇒ 调用方**不传** `gate`
-* ＝ 恒武装、永不因闸跳过、`enabled` 恒 `true`）。工厂取 `gate` **回调**（每次现读），
-* **不做**任何合并或缓存；**缺省无闸是合法形态，不是漏配**。
+* ⚠️ **为什么不能只看"存在过 interrupted"**：一个长会话历史上可能中断几十次
+* （本容器实测单会话 33 次）。只看"曾经中断"会把早已恢复的会话全部当成待续 ⇒ 灾难。
 *
-* ───────────────────────────────────────────────────────────────────────────
-* 两条时钟**逐项语义差**（`ClockOptions` 的每个可配项都对应下表一行，不是随意的灵活性）：
+* 🔴 **为什么原判据要求"末条 = end-seed"是错的**（实测 26 条里漏 2 条）：
+* 重启后宿主会在 end-seed **之后**追加 `agent/inbox/spliced`（把待办消息重新塞进收件箱）
+* ⇒ "末条必须 end-seed"**在恢复动作发生之后就恒不成立**，
+* 而"被恢复过又再次被打断"恰恰是守护最该覆盖的形态。
 *
-* | 项 | 唤醒调度器 | 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 的设计红线）。
+* DSH 日志是 **zstd 多帧追加**（实测单会话 24705 帧 / 47 MB）。原生
+* `zlib.zstdDecompressSync` 只解**第一帧**，对多帧直接报 `Unknown frame descriptor`。
+* ⇒ 采用**尾部窗口 + 倒序逐帧解压**：只读文件末尾 N 字节，从后往前找帧魔数，
+*    解到凑够所需事件数即停。实测 8h 窗口 6 个会话 **20 ms**。
 *
-* 为什么**不**取 P1（真合并成一个 `setInterval` + 两条策略）——2026-09-15 所有者裁决：
-* P1 只多省 ~20 行，却要把 `armed` 拆成"宿主 + 每策略"两层、并强行分开串行域，
-* 即**动两条正在跑的时钟的骨架**；**不值当**（裁决原文见 SESSION §12.8②）。
+* ## 世代识别复用 `cleanup.ts`
+*
+* 日志文件名有多个世代（`session.jsonl` / `session.v3.jsonl.zstd` / `session.v4.jsonl.zstd`…），
+* 宿主按世代写且**迁移保留源文件**。⇒ 本模块**不硬编码文件名**，走
+* {@link findSessionLog}（与清理／体积统计同一判据），避免"新世代对本模块不可见"。
+*
+* ## 边界
+*
+* - **只读**：不改任何会话日志。
+* - **不判周期**：何时扫、扫完做什么归调用方（CCC 的认知轨迹）。本模块只回答
+*   「此刻哪些会话以 interrupted 结尾」。
 */
 /**
-* tick 周期（**5 分钟**）。
+* zstd 解压（**运行时有、类型声明没有**）。
 *
-* 2026-09-15 S142「ACC 侧 autopilot 退场」：本值原从 `autopilot-core.ts` 导入（`TICK_MS`），
-* 但该模块随 autopilot 退场，而**本模块的唯一消费者是唤醒调度器**（`wake-scheduler`）——
-* 值本身与 autopilot 无关 ⇒ 随消费者归位到本模块（不再依赖 autopilot 判据层）。
+* 🔴 为什么不能用 `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;
+/** 每次从文件尾部读取的字节数（够覆盖数百个末尾事件） */
+const TAIL_WINDOW_BYTES = 1 << 20;
+/** 需要凑够的末尾事件数（够跨过 turn/end + step/end + end-seed 即可，留余量） */
+const TAIL_EVENT_TARGET = 60;
+/**
+* 从文件尾部倒序解压，凑够 `want` 个事件。
 *
-* ⚠️ 语义不得变：该值同时是**报告文案的来源**（"等下个 Nmin tick"），历史上曾因文案写死
-* 10min 与实现 5min 不符而误导排查（§12.7 文案纠错）。
+* 多帧 zstd 必须**按帧边界**切：从后往前找魔数，每帧用下一帧起始位置当结束边界。
+* 任何一帧解压失败就停下（返回已拿到的）—— 再往前更可能不完整。
 */
-const TICK_MS = 3e5;
+function readTailEvents(logPath, want) {
+	if (zstdDecompressSync === void 0) return [];
+	const st = statSync(logPath);
+	const windowBytes = Math.min(TAIL_WINDOW_BYTES, st.size);
+	if (windowBytes < 8) return [];
+	const buf = Buffer.alloc(windowBytes);
+	const fd = openSync(logPath, "r");
+	try {
+		readSync(fd, buf, 0, windowBytes, st.size - windowBytes);
+	} finally {
+		closeSync(fd);
+	}
+	const offsets = [];
+	for (let i = 0; i <= windowBytes - 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);
+	if (offsets.length === 0) return [];
+	const events = [];
+	for (let k = offsets.length - 1; k >= 0 && events.length < want; k--) {
+		const start = offsets[k];
+		const end = k + 1 < offsets.length ? offsets[k + 1] : windowBytes;
+		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 {
+				batch.push(JSON.parse(line));
+			} catch {}
+		}
+		events.unshift(...batch);
+	}
+	return events.slice(-want);
+}
 /**
-* 挂事件 → 触发 `start()`（**每个事件一次 try/catch 吞异常**：事件通道缺失不阻断时钟）。
+* 判定一组尾部事件是否「以 interrupted 结尾」。
+* 不命中 → null。
 *
-* 为什么吞异常：宿主（headless profile 等）可能没有事件通道；**启动时已 `start()` 过一次**，
-* 事件只是"跟上面板开关 / 新会话"的热启动补丁，缺它不该让整个装配抛错。
-* @param on 宿主的 `on`（可能不存在）
-* @param ctx `on` 的 `this`（宿主 API 常要求绑定）
-* @param clock 目标时钟
-* @param events 事件名列表（回调恒为 `() => clock.start()`）
+* ## 🔴 2026-10-23 判据放宽（owner 实测：「不是挂在工具调用上的，也要能被 interrupted 筛选到并唤醒」）
+*
+* ### 原判据（v1.87.4 起）为什么漏
+* 原来只认 **末条事件 = `session/end-seed`**。实测（本机 3337 条会话全扫）：
+*   · 末轮 `turn/end[interrupted]` 的会话 **26** 条；
+*   · 其中满足原判据的只有 **24** 条 ⇒ **漏 2 条**，形态逐字为：
+*     `… turn/end[interrupted] -> session/end-seed -> agent/inbox/spliced -> agent/inbox/spliced`
+*   ⇒ 重启后宿主把这**两条**追加在 end-seed 之后（它们是"恢复时把待办消息重新塞进收件箱"），
+*     于是"末条必须 end-seed"这条**在恢复动作发生之后就恒不成立**。
+*   ⚠️ 讽刺的是：**正是那些被恢复过、又再次被打断的会话**最容易长成这样
+*     ⇒ 原判据恰好对"反复中断"的会话失明，而它们才是最需要守护的。
+*
+* ### 新判据（三条，缺一不可）
+* 1. 日志里**最后一条 `turn/end`** 的 `reason.kind === 'interrupted'`；
+* 2. 该 `turn/end` **之后没有新的 `turn/start`**（否则说明它已被后续轮次接续）；
+* 3. ⛔ **不再要求末条是 `end-seed`**。
+*
+* ### 为什么不改成"末条必须是某个白名单"
+* 那就是原缺陷换个白名单再犯一次（`agent/inbox/spliced` 之外还会有别的）。
+* **判据要问的是"最后一轮的结束原因是什么、之后有没有新轮开始"**，
+* 而不是"日志最后一个 token 长什么样"——后者是**载体形态**，前者是**状态**。
+*
+* ### 为什么不会误报"曾经中断但已恢复"
+* 恢复一定伴随 `turn/start`（新一轮）或新的 `turn/end`（`completed` 等）⇒ 判据 1／2 各自挡住。
+* 实测该放宽**不新增误报**：原 24 条全含于新判据（`curOnly = 0`），新增 2 条全是真漏。
 */
-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 {}
+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];
+	if (turnEnd?.data?.reason?.kind !== "interrupted") 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)
+	};
 }
 /**
-* 建一条时钟（**每钟各调一次**——本工厂**不是**单例，调用次数 = 时钟条数）。
+* 找出末轮里发起了但没有结果的工具调用名。
 *
-* 顺序忠实于既有实现：`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
+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
 	};
-	if (opts.logFrom) runtime.lastTickLog = [];
-	const st = {
-		timer: null,
-		chain: Promise.resolve(),
+	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)) 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 events = readTailEvents(logPath, TAIL_EVENT_TARGET);
+			const hit = detectInterruptedEnd(events);
+			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
+			});
+		} 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
@@ -9826,7 +10225,32 @@ async function runCroPhase(ctx, root, registry, log) {
 		} else if (outcome.status === "skipped") {
 			skips += 1;
 			log.push(`· ${root}: ${renderCroOutcome(dirName, outcome)}`);
-		} else if (outcome.status === "no-wake") quiet += 1;
+		} 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)}`);
@@ -9890,10 +10314,71 @@ async function runWakeTick(ctx) {
 			}
 		}
 		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) {
+	try {
+		const agents = hostAgents(ctx);
+		const sc = hostService(ctx, "sessionController");
+		const liveIds = /* @__PURE__ */ new Set();
+		if (typeof agents?.get === "function") for (const id of collectLiveSessionIdsForSafetyNet(ctx)) liveIds.add(id);
+		const scan = scanInterruptedSessions(`${sessionsRootDir()}/${projectDirNameForCwd(root)}`, { liveIds });
+		if (scan.sessions.length === 0) return;
+		const resumeOne = createResumeOne({
+			agents,
+			sessionController: sc,
+			makeMessage: (text) => createUserMessage({
+				content: [{
+					type: "text",
+					text
+				}],
+				source: PLUGIN_SOURCE
+			})
+		});
+		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}: 中断兜底整体失败（已忽略，不影响既有链路）：${String(err?.message ?? err)}`);
+	}
+}
+/** 取容器内**全部** live 会话 id（best-effort，取不到就少排除几个）。 */
+function collectLiveSessionIdsForSafetyNet(ctx) {
+	const out = [];
+	try {
+		const list = hostSessions(ctx)?.list?.() ?? [];
+		for (const s of list) if (typeof s?.id === "string" && s.id) out.push(s.id);
+	} catch {}
+	return out;
+}
+/**
 * 装配调度器（index.ts apply 调用）：5min tick + 生命周期 disposer +
 * 会话出现/settings 变化时热启动（与 autopilot 同款触发面，互不干扰）。
 * @param ctx 插件上下文
@@ -10130,592 +10615,195 @@ ${renderCroSampleSnapshot()}
 · \`scheduling.pendingWakes\` 非空（**已有待办唤醒**）
 · 无 S 前缀格式的情形请自己造 \`dirName\`（\`identity.code\` 会是空串——那是**正常**的，
   编号不是固定格式，硬锚永远是 \`dirName\`）
-
-### 8.4 自测该断言什么（建议清单）
-· 快照缺字段（\`null\` 体积）时不崩 —— 用 \`?? 0\` 之类兜底
-· \`wake:true\` 时 \`prompt\` **确实非空**
-· "已在干活"分支：\`runningSessionIds\` 非空 ⇒ \`wake:false\`
-· 同一个程序**连跑两次**给同样输入 ⇒ 同样输出（除非你刻意用了随机/外部状态，
-  那就必须写进 \`reason\`）
-
-## 9. 一句话
-**吃一份快照，吐一行决策。先自测，绿了再改名。**
-`;
-//#endregion
-//#region src/trajectory/resident.ts
-/**
-* trajectory/resident.ts — **常驻名单**（D173 的兑现口，`cognitive_trajectory resident` 的实现）
-*
-* ## 这条能力的判据（owner 2026-10-20 原话，逐字）
-*
-* > 「常驻的意思就是**自己声明为自己欢迎别人来麻烦自己**，和永不休眠没啥关系，
-* >   **trajectory never ends 悖论的一种实现**」
-*
-* ⇒ **常驻不是资源状态**。它不是"永不休眠"、不是"常驻内存"、不是"不许销毁我的会话"。
-*   一条轨迹**永远存在**（没有生命周期），常驻与否都不改变这一点。
-*
-* ⇒ **它管的是「被找到」，不是「不被销毁」。**
-*   两件事混为一谈，就会去动调度器的载体生命周期 —— 那正是本轨反复踩的"名字撒谎"。
-*
-* ## 因此本模块的三条硬边界
-*
-* 1. **纯读**：不写任何文件、不碰注册表、不碰 `wake/scheduler.ts`。
-* 2. **不进系统提示词**（owner 裁决 Q2：说明类信息按需取，不占每轮 token）。
-* 3. **只报写了 `serves` 的轨迹** —— 只写半个（有 `resident` 没 `serves`）等于
-*    "把自己挂上去却不说能干什么"，按手册的判据那比不写更坏，所以**不列出来**，
-*    但要**单独数出**来，让写的人知道自己的写法没生效。
-*
-* ## 归属（D23）
-* 机制在 ACC（怎么找、按什么顺序、列什么字段）；内容在 CCC（`serves` 那句话写什么）。
-*/
-/**
-* 列出全部**可被找到**的轨迹（按编码排序，确定性）。
-*
-* ⚠️ 读盘失败 / 坏 JSON 一律**跳过该条**（不抛）：一份坏的声明不该让整张名单拿不到。
-*
-* @param root CCC 根
-*/
-function collectResident(root) {
-	const entries = [];
-	const incomplete = [];
-	let names = [];
-	try {
-		names = readdirSync(sessionsRoot(root), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name);
-	} catch {
-		return {
-			entries,
-			incomplete
-		};
-	}
-	for (const dirName of names) {
-		let profile;
-		try {
-			profile = readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
-		} catch {
-			continue;
-		}
-		if (!profile || profile.resident === void 0) continue;
-		const serves = profile.resident.serves;
-		if (serves === void 0 || serves === "") {
-			incomplete.push(profile.code);
-			continue;
-		}
-		entries.push({
-			code: profile.code,
-			dirName: profile.dirName,
-			serves,
-			...profile.model !== void 0 ? { model: profile.model } : {}
-		});
-	}
-	entries.sort((a, b) => a.code < b.code ? -1 : a.code > b.code ? 1 : 0);
-	incomplete.sort();
-	return {
-		entries,
-		incomplete
-	};
-}
-/**
-* 渲染成给模型读的文本（`cognitive_trajectory resident` 的返回值）。
-*
-* 🔴 **空名单也是有效结果**，且必须说清"这意味着什么" —— 否则读者会以为工具坏了。
-*/
-function listResident(root) {
-	const { entries, incomplete } = collectResident(root);
-	const lines = ["═══ 常驻轨迹（自己声明「欢迎别人来麻烦我」）═══", ""];
-	if (entries.length === 0) {
-		lines.push("  （本 CCC 暂无轨迹声明常驻）");
-		lines.push("  ⇒ 这不是错误：常驻是**自愿的自我声明**，没写就是\"不参与被找\"。");
-	} else for (const e of entries) {
-		const model = e.model !== void 0 ? `  [model: ${e.model}]` : "";
-		lines.push(`  · ${e.code}${model}`);
-		lines.push(`      ${e.serves}`);
-	}
-	if (incomplete.length > 0) {
-		lines.push("");
-		lines.push(`  ⚠️ 写了 resident 但**没写 serves**（不会被列出）：${incomplete.join("、")}`);
-		lines.push("     只写半个 = 把自己挂上去却不说能干什么 —— 别人会来问，然后发现问错了人。");
-	}
-	lines.push("");
-	lines.push("── 怎么让自己出现在这里 ──");
-	lines.push("  在你这条轨迹目录的 trajectory.json 里写：");
-	lines.push("    { \"resident\": { \"serves\": \"一句话说清我擅长什么、能帮上什么忙\" } }");
-	lines.push("  ⚠️ 只写这一个字段**不影响任何默认行为**（D183）；其余 key 全部可选。");
-	return lines.join("\n");
-}
-//#endregion
-//#region src/trajectory/live.ts
-/**
-* trajectory/live.ts — 进程内 live 会话取数 + 精简诊断
-*
-* ── 为什么单独成模块（R↓，2026-09-15 S142「ACC 侧 autopilot 退场」S1 搬迁）──
-* 这两个函数原先住在 `autopilot-trajectory.ts`，但它们的**主语不是 autopilot**：
-* `listLiveSessions` 服务 `acc-diag` ① 段的"**哪个会话属于哪个 CCC**"（会话维度，
-* 不是 CCC 维度），而"**独立进程看不到运行时**"正是 `acc-diag` 存在的理由。
-* autopilot 退场后它们必须活下去 ⇒ 独立成模块，不再挂着已死机制的名字。
-*
-* ── 迁移边界（不搬什么，以及为什么）──────────────────────────────────────
-* 原 `diagLive` 还含两段，**均不搬**（其主语是 autopilot，随机制退场）：
-*   · `autopilotCccs`（逐 CCC 目标命中 / agent 定位诊断）—— 依赖 `readAutopilotSettings` /
-*     `getAutopilotStatus` / `resolveTargetAgent`
-*   · `panelResolved`（无参面板请求落到哪个 CCC）—— 面板区块随机制退场
-* 留下的 = **进程 cwd/CCC + live 会话清单**（`acc-diag` ① 段仍需要）。
-*
-* 判据纪律：本模块**不得**反向依赖 autopilot 判据层（那会让退场半途而废）。
-*
-* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
-* **本模块的 `ctx` 参数类型从 `Context` 改为 `unknown`** —— 消除本文件唯一的 `W2` 接触
-* （直接 import 宿主 `cordis` 的类型）。
-*
-* **为什么这是"真解耦"而不是"把类型藏起来"（判据）：** `ctx` 在本模块**从不被解引用** ——
-* 它只被**原样透传**给 `hostSessions(ctx)`，而后者（`host/access.ts`，**L0**）的参数
-* 本就声明为 `ctx: unknown` ⇒ `Context` 这个 import **在语义上是多余的**，
-* 它没有参与任何类型检查，只贡献了一处 L1→宿主 的接触点。
-* 🔵 **证据**：grep 本文件 `ctx` 全部 5 处命中 —— 3 处在参数/调用位、2 处在注释，
-* **零处**属性访问（`ctx.xxx`）。
-*/
-/**
-* 从 dsh 会话 log 读取标题（latest-wins `session/title` 事件）——
-* **标题不在 `sessions.list()` 条目上**（wire/对象均无 title 字段；F3 命名经
-* `sessionTitle.rename` 写进 session log），必须从 events 提取（rebuild 同款读取模式）。
-*/
-function readSessionTitle(session) {
-	try {
-		const events = sessionEvents(session);
-		for (let i = events.length - 1; i >= 0; i--) {
-			const e = events[i];
-			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
-		}
-	} catch {}
-	return null;
-}
-/**
-* 逐条 live 会话（`cccRoot` = 该会话 cwd 的 CCC 归属，无 → null）。
-*
-* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
-* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
-*
-* @param ctx 插件上下文（**只透传**给 L0 取数口，本模块不解引用 ⇒ 类型为 `unknown`）
-* @returns 逐条 live 会话
-*/
-function listLiveSessions(ctx) {
-	const out = [];
-	try {
-		const sessions = hostSessions(ctx);
-		for (const s of sessions?.list?.() ?? []) {
-			const cwd = s?.header?.cwd ?? null;
-			out.push({
-				id: s?.id ?? "",
-				cwd,
-				cccRoot: cwd ? cccRootForCwd(cwd) : null,
-				title: readSessionTitle(s)
-			});
-		}
-	} catch {}
-	return out;
-}
-function diagLive(ctx) {
-	const processCwd = process.cwd();
-	return {
-		processCwd,
-		processCcc: cccRootForCwd(processCwd),
-		liveSessions: listLiveSessions(ctx)
-	};
-}
+
+### 8.4 自测该断言什么（建议清单）
+· 快照缺字段（\`null\` 体积）时不崩 —— 用 \`?? 0\` 之类兜底
+· \`wake:true\` 时 \`prompt\` **确实非空**
+· "已在干活"分支：\`runningSessionIds\` 非空 ⇒ \`wake:false\`
+· 同一个程序**连跑两次**给同样输入 ⇒ 同样输出（除非你刻意用了随机/外部状态，
+  那就必须写进 \`reason\`）
+
+## 9. 一句话
+**吃一份快照，吐一行决策。先自测，绿了再改名。**
+`;
 //#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 === 'interrupted'`；
-* 2. 该 `turn/end` **之后没有新的 `turn/start`**（否则已被后续轮次接续）；
-* 3. ⛔ **不要求**末条是 `session/end-seed`（2026-10-23 放宽，原因见 {@link detectInterruptedEnd}）。
-*
-* ⚠️ **为什么不能只看"存在过 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 结尾」。
-*/
+//#region src/trajectory/resident.ts
 /**
-* zstd 解压（**运行时有、类型声明没有**）。
+* trajectory/resident.ts — **常驻名单**（D173 的兑现口，`cognitive_trajectory resident` 的实现）
 *
-* 🔴 为什么不能用 `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;
-/** 每次从文件尾部读取的字节数（够覆盖数百个末尾事件） */
-const TAIL_WINDOW_BYTES = 1 << 20;
-/** 需要凑够的末尾事件数（够跨过 turn/end + step/end + end-seed 即可，留余量） */
-const TAIL_EVENT_TARGET = 60;
-/**
-* 从文件尾部倒序解压，凑够 `want` 个事件。
+* ## 这条能力的判据（owner 2026-10-20 原话，逐字）
 *
-* 多帧 zstd 必须**按帧边界**切：从后往前找魔数，每帧用下一帧起始位置当结束边界。
-* 任何一帧解压失败就停下（返回已拿到的）—— 再往前更可能不完整。
-*/
-function readTailEvents(logPath, want) {
-	if (zstdDecompressSync === void 0) return [];
-	const st = statSync(logPath);
-	const windowBytes = Math.min(TAIL_WINDOW_BYTES, st.size);
-	if (windowBytes < 8) return [];
-	const buf = Buffer.alloc(windowBytes);
-	const fd = openSync(logPath, "r");
-	try {
-		readSync(fd, buf, 0, windowBytes, st.size - windowBytes);
-	} finally {
-		closeSync(fd);
-	}
-	const offsets = [];
-	for (let i = 0; i <= windowBytes - 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);
-	if (offsets.length === 0) return [];
-	const events = [];
-	for (let k = offsets.length - 1; k >= 0 && events.length < want; k--) {
-		const start = offsets[k];
-		const end = k + 1 < offsets.length ? offsets[k + 1] : windowBytes;
-		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 {
-				batch.push(JSON.parse(line));
-			} catch {}
-		}
-		events.unshift(...batch);
-	}
-	return events.slice(-want);
-}
-/**
-* 判定一组尾部事件是否「以 interrupted 结尾」。
-* 不命中 → null。
+* > 「常驻的意思就是**自己声明为自己欢迎别人来麻烦自己**，和永不休眠没啥关系，
+* >   **trajectory never ends 悖论的一种实现**」
 *
-* ## 🔴 2026-10-23 判据放宽（owner 实测：「不是挂在工具调用上的，也要能被 interrupted 筛选到并唤醒」）
+* ⇒ **常驻不是资源状态**。它不是"永不休眠"、不是"常驻内存"、不是"不许销毁我的会话"。
+*   一条轨迹**永远存在**（没有生命周期），常驻与否都不改变这一点。
 *
-* ### 原判据（v1.87.4 起）为什么漏
-* 原来只认 **末条事件 = `session/end-seed`**。实测（本机 3337 条会话全扫）：
-*   · 末轮 `turn/end[interrupted]` 的会话 **26** 条；
-*   · 其中满足原判据的只有 **24** 条 ⇒ **漏 2 条**，形态逐字为：
-*     `… turn/end[interrupted] -> session/end-seed -> agent/inbox/spliced -> agent/inbox/spliced`
-*   ⇒ 重启后宿主把这**两条**追加在 end-seed 之后（它们是"恢复时把待办消息重新塞进收件箱"），
-*     于是"末条必须 end-seed"这条**在恢复动作发生之后就恒不成立**。
-*   ⚠️ 讽刺的是：**正是那些被恢复过、又再次被打断的会话**最容易长成这样
-*     ⇒ 原判据恰好对"反复中断"的会话失明，而它们才是最需要守护的。
+* ⇒ **它管的是「被找到」，不是「不被销毁」。**
+*   两件事混为一谈，就会去动调度器的载体生命周期 —— 那正是本轨反复踩的"名字撒谎"。
 *
-* ### 新判据（三条，缺一不可）
-* 1. 日志里**最后一条 `turn/end`** 的 `reason.kind === 'interrupted'`；
-* 2. 该 `turn/end` **之后没有新的 `turn/start`**（否则说明它已被后续轮次接续）；
-* 3. ⛔ **不再要求末条是 `end-seed`**。
+* ## 因此本模块的三条硬边界
 *
-* ### 为什么不改成"末条必须是某个白名单"
-* 那就是原缺陷换个白名单再犯一次（`agent/inbox/spliced` 之外还会有别的）。
-* **判据要问的是"最后一轮的结束原因是什么、之后有没有新轮开始"**，
-* 而不是"日志最后一个 token 长什么样"——后者是**载体形态**，前者是**状态**。
+* 1. **纯读**：不写任何文件、不碰注册表、不碰 `wake/scheduler.ts`。
+* 2. **不进系统提示词**（owner 裁决 Q2：说明类信息按需取，不占每轮 token）。
+* 3. **只报写了 `serves` 的轨迹** —— 只写半个（有 `resident` 没 `serves`）等于
+*    "把自己挂上去却不说能干什么"，按手册的判据那比不写更坏，所以**不列出来**，
+*    但要**单独数出**来，让写的人知道自己的写法没生效。
 *
-* ### 为什么不会误报"曾经中断但已恢复"
-* 恢复一定伴随 `turn/start`（新一轮）或新的 `turn/end`（`completed` 等）⇒ 判据 1／2 各自挡住。
-* 实测该放宽**不新增误报**：原 24 条全含于新判据（`curOnly = 0`），新增 2 条全是真漏。
+* ## 归属（D23）
+* 机制在 ACC（怎么找、按什么顺序、列什么字段）；内容在 CCC（`serves` 那句话写什么）。
 */
-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];
-	if (turnEnd?.data?.reason?.kind !== "interrupted") 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)
-	};
-}
 /**
-* 找出末轮里发起了但没有结果的工具调用名。
+* 列出全部**可被找到**的轨迹（按编码排序，确定性）。
 *
-* ⚠️ **尽力而为**，非权威：尾部窗口可能截断更早的调用。上层应把它当
-* "**可能**未完成的副作用"清单，而不是"确定未完成"。
-*/
-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--/`）。
+* ⚠️ 读盘失败 / 坏 JSON 一律**跳过该条**（不抛）：一份坏的声明不该让整张名单拿不到。
 *
-* @param projectDir DSH 项目目录（其下每个子目录是一个会话）
-* @param options.lookbackMs 回看窗口（缺省 8h）
-* @param options.now 注入"当前时刻"（测试用）
-* @param options.liveIds 需要跳过的会话 id（正在跑的会话不该被判为待续）
+* @param root CCC 根
 */
-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
-	};
-	if (!existsSync(projectDir)) {
-		result.elapsedMs = Date.now() - t0;
-		return result;
-	}
-	let entries;
+function collectResident(root) {
+	const entries = [];
+	const incomplete = [];
+	let names = [];
 	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;
+		names = readdirSync(sessionsRoot(root), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name);
+	} catch {
+		return {
+			entries,
+			incomplete
+		};
 	}
-	for (const sessionId of entries) {
-		if (liveIds.has(sessionId)) continue;
-		const dirPath = join(projectDir, sessionId);
-		const logPath = findSessionLog(dirPath);
-		if (logPath === null) continue;
-		let mtimeMs;
+	for (const dirName of names) {
+		let profile;
 		try {
-			mtimeMs = statSync(logPath).mtimeMs;
-		} catch (err) {
-			result.errors.push({
-				sessionId,
-				message: err instanceof Error ? err.message : String(err)
-			});
+			profile = readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
+		} catch {
 			continue;
 		}
-		if (mtimeMs < cutoff) continue;
-		result.scanned++;
-		try {
-			const events = readTailEvents(logPath, TAIL_EVENT_TARGET);
-			const hit = detectInterruptedEnd(events);
-			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
-			});
-		} catch (err) {
-			result.errors.push({
-				sessionId,
-				message: err instanceof Error ? err.message : String(err)
-			});
+		if (!profile || profile.resident === void 0) continue;
+		const serves = profile.resident.serves;
+		if (serves === void 0 || serves === "") {
+			incomplete.push(profile.code);
+			continue;
 		}
+		entries.push({
+			code: profile.code,
+			dirName: profile.dirName,
+			serves,
+			...profile.model !== void 0 ? { model: profile.model } : {}
+		});
 	}
-	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("-")}--`;
+	entries.sort((a, b) => a.code < b.code ? -1 : a.code > b.code ? 1 : 0);
+	incomplete.sort();
+	return {
+		entries,
+		incomplete
+	};
 }
 /**
-* 续跑正文（**简单、稳定、不含版本号**）。
-*
-* 判据（为什么这么短）：本动作的用途是**把被打断的会话推回工作状态**，
-* 不是替它重述任务 —— 被打断那一轮的上下文就在它自己的日志里。
-* ⇒ 正文只做三件事：① 说明发生了什么；② 提示**先核对副作用**；③ 让它接着做。
+* 渲染成给模型读的文本（`cognitive_trajectory resident` 的返回值）。
 *
-* 🔴 **为什么要写"先核对副作用"**：中断时可能有「有 call 无 result」的工具调用，
-* 它们的副作用**未知**（可能已写文件 / 已发消息）。若模型把那一轮整段重放，
-* 会**重复执行**。这句话是给模型的护栏，不是客套。
+* 🔴 **空名单也是有效结果**，且必须说清"这意味着什么" —— 否则读者会以为工具坏了。
 */
-function buildContinueText(sessionId, turn, pendingTools) {
-	const lines = [];
-	lines.push("[中断续跑] 上一条进程在本轮完成前退出，该轮已被中止。现在继续。");
-	lines.push("");
-	lines.push(`会话: ${sessionId}${turn === null ? "" : ` ／ 被中断的轮次: turn ${turn}`}`);
-	if (pendingTools.length > 0) {
+function listResident(root) {
+	const { entries, incomplete } = collectResident(root);
+	const lines = ["═══ 常驻轨迹（自己声明「欢迎别人来麻烦我」）═══", ""];
+	if (entries.length === 0) {
+		lines.push("  （本 CCC 暂无轨迹声明常驻）");
+		lines.push("  ⇒ 这不是错误：常驻是**自愿的自我声明**，没写就是\"不参与被找\"。");
+	} else for (const e of entries) {
+		const model = e.model !== void 0 ? `  [model: ${e.model}]` : "";
+		lines.push(`  · ${e.code}${model}`);
+		lines.push(`      ${e.serves}`);
+	}
+	if (incomplete.length > 0) {
 		lines.push("");
-		lines.push(`⚠️ 中断时这些工具「有调用、无结果」（副作用未知，**可能已经执行**）: ${pendingTools.join(", ")}`);
-		lines.push("   ⇒ 先核对它们是否已生效（文件是否已写、消息是否已发），再决定要不要重做。");
-		lines.push("   ⛔ 不要把被中断的那一轮整段重放。");
+		lines.push(`  ⚠️ 写了 resident 但**没写 serves**（不会被列出）：${incomplete.join("、")}`);
+		lines.push("     只写半个 = 把自己挂上去却不说能干什么 —— 别人会来问，然后发现问错了人。");
 	}
 	lines.push("");
-	lines.push("请接着完成该轮未完成的工作；完成后把进展写入本轨迹的 SESSION.md。");
+	lines.push("── 怎么让自己出现在这里 ──");
+	lines.push("  在你这条轨迹目录的 trajectory.json 里写：");
+	lines.push("    { \"resident\": { \"serves\": \"一句话说清我擅长什么、能帮上什么忙\" } }");
+	lines.push("  ⚠️ 只写这一个字段**不影响任何默认行为**（D183）；其余 key 全部可选。");
 	return lines.join("\n");
 }
+//#endregion
+//#region src/trajectory/live.ts
 /**
-* 把一个 agent 唤醒（注入一条续跑消息）。
+* trajectory/live.ts — 进程内 live 会话取数 + 精简诊断
 *
-* 两条路径（与 `wake/scheduler.ts` 的 `sendToCognitiveTrajectory` 同源判据）：
-* - **live**：`agents.get(id)` 拿得到 ⇒ 目标在跑（或被加载）⇒ `steer` 当场注入当前轮；
-*   `steer` 不可用则退回 `followup`（宁可排队，不可静默丢）。
-* - **cold-resume**：`sessionController.resolveAgent(id)` 冷载入后同样注入。
+* ── 为什么单独成模块（R↓，2026-09-15 S142「ACC 侧 autopilot 退场」S1 搬迁）──
+* 这两个函数原先住在 `autopilot-trajectory.ts`，但它们的**主语不是 autopilot**：
+* `listLiveSessions` 服务 `acc-diag` ① 段的"**哪个会话属于哪个 CCC**"（会话维度，
+* 不是 CCC 维度），而"**独立进程看不到运行时**"正是 `acc-diag` 存在的理由。
+* autopilot 退场后它们必须活下去 ⇒ 独立成模块，不再挂着已死机制的名字。
 *
-* ⚠️ 冷会话载入**会真起一个 agent**（消耗真实算力）⇒ 调用方必须自己决定要不要，
-* 本函数不做数量限制（那是策略，归调用者）。
+* ── 迁移边界（不搬什么，以及为什么）──────────────────────────────────────
+* 原 `diagLive` 还含两段，**均不搬**（其主语是 autopilot，随机制退场）：
+*   · `autopilotCccs`（逐 CCC 目标命中 / agent 定位诊断）—— 依赖 `readAutopilotSettings` /
+*     `getAutopilotStatus` / `resolveTargetAgent`
+*   · `panelResolved`（无参面板请求落到哪个 CCC）—— 面板区块随机制退场
+* 留下的 = **进程 cwd/CCC + live 会话清单**（`acc-diag` ① 段仍需要）。
+*
+* 判据纪律：本模块**不得**反向依赖 autopilot 判据层（那会让退场半途而废）。
+*
+* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
+* **本模块的 `ctx` 参数类型从 `Context` 改为 `unknown`** —— 消除本文件唯一的 `W2` 接触
+* （直接 import 宿主 `cordis` 的类型）。
+*
+* **为什么这是"真解耦"而不是"把类型藏起来"（判据）：** `ctx` 在本模块**从不被解引用** ——
+* 它只被**原样透传**给 `hostSessions(ctx)`，而后者（`host/access.ts`，**L0**）的参数
+* 本就声明为 `ctx: unknown` ⇒ `Context` 这个 import **在语义上是多余的**，
+* 它没有参与任何类型检查，只贡献了一处 L1→宿主 的接触点。
+* 🔵 **证据**：grep 本文件 `ctx` 全部 5 处命中 —— 3 处在参数/调用位、2 处在注释，
+* **零处**属性访问（`ctx.xxx`）。
 */
-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)}`
-				};
-			}
+/**
+* 从 dsh 会话 log 读取标题（latest-wins `session/title` 事件）——
+* **标题不在 `sessions.list()` 条目上**（wire/对象均无 title 字段；F3 命名经
+* `sessionTitle.rename` 写进 session log），必须从 events 提取（rebuild 同款读取模式）。
+*/
+function readSessionTitle(session) {
+	try {
+		const events = sessionEvents(session);
+		for (let i = events.length - 1; i >= 0; i--) {
+			const e = events[i];
+			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
 		}
-		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)}`
-			};
+	} catch {}
+	return null;
+}
+/**
+* 逐条 live 会话（`cccRoot` = 该会话 cwd 的 CCC 归属，无 → null）。
+*
+* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
+* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
+*
+* @param ctx 插件上下文（**只透传**给 L0 取数口，本模块不解引用 ⇒ 类型为 `unknown`）
+* @returns 逐条 live 会话
+*/
+function listLiveSessions(ctx) {
+	const out = [];
+	try {
+		const sessions = hostSessions(ctx);
+		for (const s of sessions?.list?.() ?? []) {
+			const cwd = s?.header?.cwd ?? null;
+			out.push({
+				id: s?.id ?? "",
+				cwd,
+				cccRoot: cwd ? cccRootForCwd(cwd) : null,
+				title: readSessionTitle(s)
+			});
 		}
+	} catch {}
+	return out;
+}
+function diagLive(ctx) {
+	const processCwd = process.cwd();
+	return {
+		processCwd,
+		processCcc: cccRootForCwd(processCwd),
+		liveSessions: listLiveSessions(ctx)
 	};
 }
 //#endregion