@shgroup/dsh-serenity-hooks 1.87.7 → 1.89.0

package/lib/index.js

@@ -1,12 +1,12 @@
 import { i as __toESM, n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
-import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-CvgsUnFW.js";
+import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-WfktvbN8.js";
 import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readSafeModeHiddenTools, i as findGitRoot, l as pathInside, m as readExclusiveTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-CyYJL4F2.js";
-import { A as resolveSessionByTitle, B as readTrajectoryFile, C as listActiveTrajectories, D as parseTrajectoryCode, E as parseSessionContextFromEvents, F as summarize, H as localFileStamp, I as trajectoryDescOf, L as useSession, M as sessionsRoot, N as setActiveSessionInfo, P as showSession, R as TRAJECTORY_FILENAME, T as namingTitleFor, U as localHuman, V as isoLocal, W as localIdStamp, _ as clearActiveSessionInfo, b as findSession, c as replacesDefaultIdentity, g as archiveSession, h as UID_FILENAME, i as listTrajectoryConstraints, j as sessionEvents, k as readTrajectoryUid, l as trajectoryConstraintForSession, n as findDirNameByCode, o as readTrajectoryConstraintAt, p as COGNITIVE_TRAJECTORY_ACTIONS, r as isTrajectoryConstrained, s as readTrajectoryConstraintByCode, t as TRAJECTORY_CONSTRAINT_FILENAME, v as createSession, w as listSessions, x as getActiveSessionInfo, y as extractSessionMdPathFromText, z as TRAJECTORY_LEGACY_FILENAMES } from "./profile-DGt_e-Nx.js";
+import { A as namingTitleFor, B as summarize, C as createSession, E as getActiveSessionInfo, F as resolveSessionByTitle, G as readTrajectoryFile, H as useSession, I as sessionEvents, J as localHuman, K as isoLocal, L as sessionsRoot, M as parseTrajectoryCode, O as listActiveTrajectories, P as readTrajectoryUid, R as setActiveSessionInfo, S as clearActiveSessionInfo, T as findSession, U as TRAJECTORY_FILENAME, V as trajectoryDescOf, W as TRAJECTORY_LEGACY_FILENAMES, Y as localIdStamp, b as UID_FILENAME, c as replacesDefaultIdentity, i as listTrajectoryConstraints, j as parseSessionContextFromEvents, k as listSessions, l as trajectoryCodeForSession, n as findDirNameByCode, o as readTrajectoryConstraintAt, q as localFileStamp, r as isTrajectoryConstrained, s as readTrajectoryConstraintByCode, t as TRAJECTORY_CONSTRAINT_FILENAME, u as trajectoryConstraintForSession, v as COGNITIVE_TRAJECTORY_ACTIONS, w as extractSessionMdPathFromText, x as archiveSession, z as showSession } from "./profile-zxakCNXy.js";
 import { n as checkLocalstoreGitCompliance, o as readStore, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./service-DDmHSglV.js";
-import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-Cq4PsuES.js";
-import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-Ca5UYzF3.js";
+import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-BAMwXu6i.js";
+import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-Bb4GSSFJ.js";
 import { i as sessionsRootDir, n as findSessionLog, r as hasSessionLogById } from "./cleanup-CPl1SSaK.js";
-import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-BI3NRHgC.js";
+import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-DAorSseV.js";
 import { a as readFeishuCredential, c as readWeixinSettings, d as weixinInboundDir, f as weixinSessionIdForTrajectory, i as matchWeixinRoute, n as extractWeixinText, o as readImSettings, r as hasVoiceItem, s as readWeixinCredential, t as extractWeixinMedia, u as sanitizeFileName$1 } from "./route-3OzOAjec.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
 import { c as sendTextMessage, i as getUpdates, l as sendTyping, n as downloadMedia, o as markdownToPlainText, r as getConfig, s as sendFileMessage, t as TypingStatus, u as sniffImageExt } from "./ilink-CsZ-f64q.js";
@@ -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,875 +8850,785 @@ 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(),
-		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();
+	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) {
-			console.warn(`[serenity-hooks] ✗ tick 前置异常: ${String(err?.message ?? err)}（${opts.label}）`);
-			return;
+			result.errors.push({
+				sessionId,
+				message: err instanceof Error ? err.message : String(err)
+			});
+			continue;
 		}
-		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}）`);
+		if (mtimeMs < cutoff) continue;
+		result.scanned++;
+		try {
+			const events = readTailEvents(logPath, TAIL_EVENT_TARGET);
+			const hit = detectInterruptedEnd(events);
+			if (!hit) {
+				result.skipped++;
+				continue;
 			}
-		});
-	};
-	/**
-	* 幂等启动 + 武装门：**已武装 → 原样返回**（防重复起定时器）；
-	* **闸关 → 不武装**（零资源占用）；闸开则**无条件**武装（硬约束二：不判"有无目标"）。
-	*/
-	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)}`);
+			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)
 			});
-		},
-		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;
+	}
+	result.sessions.sort((a, b) => (b.lastEventAt ?? b.mtimeMs) - (a.lastEventAt ?? a.mtimeMs));
+	result.elapsedMs = Date.now() - t0;
+	return result;
 }
-//#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"）
+* 由 CCC 根推导它的 DSH 项目目录名（`--home-yh-home-home-serenity--`）。
 *
-* 守卫（2026-09-21 起**本钟无闸**）：🔴 **恒武装**——原 `wakeSchedulerEnabled` 已砍，
-* 本钟不再有「可被误关的开关」；旧配置残留该键**静默忽略**，且**不**回退 `autopilotEnabled`｜
-* CRO 阶段另有**独立**总闸 `croEnabled`（只停 CRO，**不影响**本注册表投递）｜
-* 补跑窗口 2h（超窗置 missed 留痕）｜同 tick 串行｜唤起后维持 live（人类可介入）。
-*/
-/**
-* 解析条目的 target（`S###` 或完整目录名）→ 目录名 + SESSION.md 路径。
-* @param root CCC 根
-* @param target 条目里的目标标识
-* @returns 命中返回目录信息，未命中 null
+* 规则取自宿主：把绝对路径的 `/` 换成 `-`，并在前后各加 `--`。
+* ⚠️ 这是**推导**，不是真相源 —— 实际目录名以磁盘为准；调用方应在不存在时
+* 回退到"扫整个 sessions root"或直接报未找到。
 */
-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
-	};
+function projectDirNameForCwd(cwd) {
+	return `--${cwd.replace(/\/+$/, "").split("/").filter(Boolean).join("-")}--`;
 }
 /**
-* 🔴 **本钟的全局闸已于 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。
+* 🔴 **为什么要写"先核对副作用"**：中断时可能有「有 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");
+}
 /**
-* 🔴 **本钟的串行域**（C6b 硬约束）：`clock.chain` 是**本实例私有**的——
-* 与 autopilot 的串行链**零共享**。autopilot 每轮跑 CCC 偏见脚本可能阻塞数十秒，
-* 共用链会把一次性唤醒一起卡住（这正是 P1 被否、取 P2 的理由，见 SESSION §12.8②）。
+* 把一个 agent 唤醒（注入一条续跑消息）。
 *
-* **为什么这里是模块级常量**（而不是 `registerWakeScheduler` 的局部量）：本钟的进程态是
-* **进程级可观测面**（`acc-diag` ①b / `containerClocks` 在读），且 `wakeSchedulerState()` /
-* `__resetWakeSchedulerStateForTest()` 是**公开导出**、可在未装配时被调用 ⇒ 实例必须**恒在**
-* （旧实现的 `schedulerRuntime` 也正是模块级常量）。装配只做 `clock.start()`。
+* 两条路径（与 `wake/scheduler.ts` 的 `sendToCognitiveTrajectory` 同源判据）：
+* - **live**：`agents.get(id)` 拿得到 ⇒ 目标在跑（或被加载）⇒ `steer` 当场注入当前轮；
+*   `steer` 不可用则退回 `followup`（宁可排队，不可静默丢）。
+* - **cold-resume**：`sessionController.resolveAgent(id)` 冷载入后同样注入。
+*
+* ⚠️ 冷会话载入**会真起一个 agent**（消耗真实算力）⇒ 调用方必须自己决定要不要，
+* 本函数不做数量限制（那是策略，归调用者）。
 */
-/** 本钟的装配项（`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];
+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 {
-			const out = await resolved.call(sc, id);
-			if (out?.agent) return {
-				agent: out.agent,
-				how: `cold-resume(${id})`
+			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（宿主契约漂移）"
 			};
-			return { error: `sessionController.resolveAgent 未返回 agent（${id}）: ${String(out?.error ?? "未知原因")}` };
 		} catch (err) {
-			return { error: `冷会话载入失败（${id}）: ${String(err?.message ?? 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)}`
+			};
 		}
-	}
-	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}）`
 	};
 }
+//#endregion
+//#region src/wake/clock.ts
 /**
-* 即时消息正文（**刻意不复用** {@link buildWakeText}）：唤醒文本以「**到点**（登记于…）」开头，
-* 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"。
+* wake/clock.ts — **时钟运行时工厂**（S142 §38 复审候选 C6b，路径 **P2**）
 *
-* ⚠️ **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 递给目标 → **同步回执** → **不落注册表**
+* 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正**：本文件当初是为**两条**独立 5min 时钟抽出的公共引擎：
+*   · 唤醒调度器（`wake/scheduler.ts`，一次性唤醒，D58）—— **现存**
+*   · autopilot 时钟（`autopilot-trajectory.ts`，周期自唤醒，D59）—— 🔴 **已随 v1.35.0 整段退场**
+* 二者的**业务判据完全不同**（谁来扫 / 扫什么 / 投递给谁 / 按什么周期），但**引擎骨架逐字同形**
+* ——进程态 + 快照 + 复位 + `startTimer` + tick 外壳 + 事件接线 + disposer + `timer.unref()`。
+* 本条把**引擎**抽到本工厂，**各钟仍各持自己的定时器与自己的串行链**（现存的那一钟 = 唤醒调度器）。
 *
-* **为什么冷路径落在这里（R↓，2026-09-16 所有者裁决）**：`addWake` 显式拒绝 `at ≤ now`
-* （"时刻必须在未来"——那是"**预约**"语义的地基，不许放宽）⇒ 即时投递**不能**靠一条
-* `at=now` 的注册表条目实现（那还会让调度器把一次性即时投递当 `pending` **每 tick 重试**）。
-* 必须直接走 {@link acquireWakeAgent}（live 优先 → `sessionController.resolveAgent` 冷载入）。
-* 这正对应所有者要的「**会话不活跃则等效于直接 wake**」：**同一条冷载入通路**，只是**不等 tick**。
+* ───────────────────────────────────────────────────────────────────────────
+* 🔴 硬约束一：**两条时钟绝不可共用"排队执行"的链**（这是 P2 与 P1 的分界判据）
 *
-* ⚠️ **承诺边界（不许含糊）**：回执只到「**已注入 / 已起轮**」（宿主调用未抛错），
-* **到不了**"目标已执行/已答复" —— 与 `deliverWake` 同一层。
-* 判"目标真的动了"必须用**文件级判据**（它自己的 SESSION.md），
-* **不得凭回执结案**（§12.B 的 `delivered ≠ 跑了一轮`）。
+* autopilot 每轮要跑该 CCC 的**偏见脚本**（`fetchBiasContent`，超时 60s），可能阻塞数十秒；
+* 若与唤醒调度器共用一条串行链，会把另一条一起**卡住**（一次性唤醒被无关的偏见脚本拖住）。
+* ⇒ 本工厂把 `chain` 作为**每实例私有状态**：`createClock()` 调用一次 = 一条独立的串行域。
+*    实例之间**零共享**（无模块级单例、无共享 Promise、无共享 map）。
+* ⚠️ 若日后有人把 `chain` 提到模块级"省一次分配"，**两条时钟的隔离即刻失效**——不许。
 *
-* 🔴 **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`** ——
-* 预约的本职是"到点唤起"，且在跑时排队不打断是它被实证验收过的行为，不顺手动它。
+* 🔴 硬约束二：**武装门只判全局闸**（`gate()`），**不判"本次有无目标"**
 *
-* **归属**：本函数放在调度器侧而非工具侧 —— "怎么把一句话送到一条轨迹"是**调度器的知识**，
-* 工具只该知道"有这个动作"。这样 `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` 分支执行**：
+* 2026-09-14 F 段实测缺陷：旧实现把"有 live CCC"当**武装前置条件**，而宿主刚重启时 live 会话
+* 必为空，且**"恢复旧会话"不触发 `session/created`**（只有新建会）⇒ 启动瞬间判定落空 =
+* **时钟永久不武装**（实测 6.6h 零 tick）。⇒ 现在「**全局闸开即武装**」，"有无目标"降级为
+* tick 内的廉价判定。**武装与"本次有无目标"是两件事，本工厂不得把二者耦合。**
 *
-*   ```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)   // ← 只有这条分支
-*   ```
+* 🔴 硬约束三：**闸是可选能力，工厂不得替调用方假设"必须有闸"**（v1.34 S-1 解耦 → 2026-09-21 收窄）
 *
-* 而**用户在 UI 里新建会话传的正是 `workspaceId`**（见 `client/sessions/service.d.ts` 的
-* `create({ workspaceId?, cwd?, ... })`）⇒ 用户那条路天然会走到 `attachSession`。
+* 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正：当前零条闸在用** —— 现存唯一那一钟
+* （唤醒调度器）本已无闸，而"曾只余的那一条" `autopilotWakeEnabled` 已随 **v1.35.0 autopilot
+* 整段退场**一并消失 ⇒ `gate` **缺省即常态，不是特例**。**唤醒调度器已无闸**
+* （原 `wakeSchedulerEnabled` 于 2026-09-21 所有者令砍掉 ⇒ 调用方**不传** `gate`
+* ＝ 恒武装、永不因闸跳过、`enabled` 恒 `true`）。工厂取 `gate` **回调**（每次现读），
+* **不做**任何合并或缓存；**缺省无闸是合法形态，不是漏配**。
 *
-* ⇒ 现在与用户**同一条分支**：先由 CCC 根查出 `workspaceId`，再用 `{ workspaceId }` 建。
-*   **`attachToWorkspace` 降级为兜底**（只在"该目录还没有工作区登记"时才会用上），
-*   不再是主路径 —— 因为主路径已经由宿主自己做完。
+* ───────────────────────────────────────────────────────────────────────────
+* 两条时钟**逐项语义差**（`ClockOptions` 的每个可配项都对应下表一行，不是随意的灵活性）：
 *
-* ## 三步（顺序不可换）
-*   ① `sessionController.create({ workspaceId })` —— 与用户同一形态；宿主替我们挂工作区。
-*      **idempotently adopt** ⇒ 重复调用不会建出第二条（不必自造"先查再建"的竞态窗口）。
-*   ② `resolveAgent(sessionId)` —— 拿到**真 agent**。`create` 只返回 id，不给 agent。
-*   ③ `appendBound(...)` —— 落绑定。**必须由本函数写**：`listBoundSessionIds` 是
-*      `acquireWakeAgent` 的唯一选人依据，不写绑定则下一条消息**还是**找不到它
-*      （那就成了"建了但永远用不上"，比不建更坏）。
+* | 项 | 唤醒调度器 | autopilot | 工厂表达 |
+* |----|-----------|-----------|---------|
+* | `chain` | 有（全局串行） | 有（全局串行） | **总是私有**（硬约束一） |
+* | `lastTickLog` | 有（逐行摘要） | **无** | `logFrom` 不给 = 不记 |
+* | `ticks` 记账 | 工厂在 body **完成后**记 | **本钟**在同步段记 | `bodyCountsTick` + `begin` |
+* | body 返回类型 | `string[]`（人读摘要） | `void` | 泛型 `T` |
+* | 启动日志 | 固定串 | 含启用 CCC 计数 | `startLog: () => string` |
+* | body 异常兜底 | 留痕 + `console.warn` | 同 | 工厂统一（**吞异常不改语义**） |
 *
-* 🔴 **为什么定位到 CCC 根这一级、不是轨迹目录**：会话的 cwd 决定它落在哪个 CCC
-*    （`cccRootForCwd` 上溯 `.serenity`）。目标轨迹本就住在该 CCC 的 `AGENT_SESSIONS/` 下
-*    ⇒ 落到 CCC 根才让它**进同一个 CCC**；落到轨迹目录会让它变成一个**不同 CCC**的会话。
+* ───────────────────────────────────────────────────────────────────────────
+* **本工厂是"加法式"重构**（P2 的性质）：不新增任何判定逻辑，只把同形骨架收成一份代码；
+* 两个模块仍各自导出 `wakeSchedulerState()` / `autopilotClockState()` 与各自的
+* `__reset…ForTest()`，**对外可观测面（字段名与语义）零变化**——`acc-diag` ①b 段、
+* `surface/observation.ts:containerClocks()` 与面板都在读它们（见该文件 :225–250 的设计红线）。
 *
-* @returns 命中返回 agent 与取得方式；任一步失败返回**带原因**的 error（不静默、不误报成功）
+* 为什么**不**取 P1（真合并成一个 `setInterval` + 两条策略）——2026-09-15 所有者裁决：
+* P1 只多省 ~20 行，却要把 `armed` 拆成"宿主 + 每策略"两层、并强行分开串行域，
+* 即**动两条正在跑的时钟的骨架**；**不值当**（裁决原文见 SESSION §12.8②）。
 */
-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` 一个地方。
+* tick 周期（**5 分钟**）。
 *
-* ## 三者顺序不可换
+* 2026-09-15 S142「ACC 侧 autopilot 退场」：本值原从 `autopilot-core.ts` 导入（`TICK_MS`），
+* 但该模块随 autopilot 退场，而**本模块的唯一消费者是唤醒调度器**（`wake-scheduler`）——
+* 值本身与 autopilot 无关 ⇒ 随消费者归位到本模块（不再依赖 autopilot 判据层）。
 *
-* 必须在 ③b（投开场白）**之后**调用：
-* - 开场白让 `titleInput.count` > 0，是标题得以成立的前提；
-* - 放在之后还有**降级好处**：万一 `rename` 失败，宿主自己的 fallback 标题仍在
-*   （难看但存在），而不是两者皆无。
+* ⚠️ 语义不得变：该值同时是**报告文案的来源**（"等下个 Nmin tick"），历史上曾因文案写死
+* 10min 与实现 5min 不符而误导排查（§12.7 文案纠错）。
+*/
+const TICK_MS = 3e5;
+/**
+* 挂事件 → 触发 `start()`（**每个事件一次 try/catch 吞异常**：事件通道缺失不阻断时钟）。
 *
-* @returns 回执片段（成功 `, titled` ／ 失败 `, ⚠️ 标题未写（原因）`）—— **必须出声**，
-*   否则"标题没写"会表现成"这条轨迹就是这名字"（D186：守卫可以拒绝，但不许不出声）。
+* 为什么吞异常：宿主（headless profile 等）可能没有事件通道；**启动时已 `start()` 过一次**，
+* 事件只是"跟上面板开关 / 新会话"的热启动补丁，缺它不该让整个装配抛错。
+* @param on 宿主的 `on`（可能不存在）
+* @param ctx `on` 的 `this`（宿主 API 常要求绑定）
+* @param clock 目标时钟
+* @param events 事件名列表（回调恒为 `() => clock.start()`）
 */
-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)}）`;
-	}
+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 {}
 }
 /**
-* 把刚建的会话挂进 **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 追加到回执里的短注记（成功/跳过为空串，失败带原因）
+* 顺序忠实于既有实现：`start()` 先武装并立即跑一次 tick → 再挂事件。
+* 拆卸由调用方经 `registerDisposer(ctx, label, clock.dispose)` 落到宿主的 `ctx.effect`。
+* @param opts 见 {@link ClockOptions}（每项对应一条既有的语义差）
+* @returns 该钟的 `{start, dispose, snapshot, reset}`
 */
-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;
-	}
+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
 /**
-* 在 `workspaceRegistry.list()` 里找 **path 等于该 CCC 根** 的那一个。
+* wake/scheduler.ts — 认知轨迹唤醒调度器（D58/D59/D60；S142 2026-09-13）
 *
-* 🔴 **为什么要 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 根是一个**符号链接**（部署上常见：家目录/项目目录被链到别处），
-*   两侧**逐字不等**，只比字符串会**挂错或挂不上**。
+* 一个**中心调度器**（5min tick，复用 autopilot 的节律常量），处理 CCC 唤醒注册表里
+* 到期的条目：把「未来时刻 + 一条 message」投递给目标认知轨迹，**fire-and-forget**
+* （无阻塞、无等待、无回执——发起方不 await，调度器不替模型结果负责）。
 *
-* ⚠️ 归一失败（路径不存在等）时**回落字面比较** —— 不改既有语义，只是多给一次机会。
+* 与 autopilot 的关系（D59）：**两个 tick 各自独立**。autopilot 是每 CCC 单例的
+* 周期自唤醒，逻辑一行不碰；本模块只处理注册表的一次性唤醒条目。
 *
-* @param workspaces registry.list() 的返回
+* 投递路径（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（人类可介入）。
+*/
+/**
+* 解析条目的 target（`S###` 或完整目录名）→ 目录名 + SESSION.md 路径。
 * @param root CCC 根
-* @returns 命中的工作区，无则 undefined
+* @param target 条目里的目标标识
+* @returns 命中返回目录信息，未命中 null
 */
-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;
-		}
+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
 	};
-	const want = canonical(root);
-	return workspaces.find((ws) => typeof ws?.path === "string" && canonical(ws.path) === want);
 }
 /**
-* 本 tick 要扫的 CCC 根集合（**并集**）。
+* 🔴 **本钟的全局闸已于 2026-09-21 砍掉**（所有者令逐字：「**send-later 的开关不再重要了，砍掉**」）。
 *
-* C2（S142 2026-09-15 Q5）：原实现是 `collectLiveCccs`——**只认 live 会话** ⇒
-* "完全冷掉的 CCC 不能自唤醒自己"（已知边界）。现改为 `ccc-roots.listCccs` 的并集枚举
-* （工作区注册表 ∪ 持久化会话 ∪ live 会话）：**没有 live 会话的 CCC 也会被扫到**。
+* **为什么砍**（R↓）：唤醒已从"可选实验能力"长成**全容器的续接绳**（🔵 **术语说明，2026-09-23 补**：
+* **"绳" = 我们对自己用 `send-later` 给自己排的"定时叫醒"条目的俗称** —— 一条链每轮给自己排下一根，
+* 链才不断。本仓注释与 SESSION.md 沿用此说法，**它不是产品名、也不是宿主概念**）——S142/S151/S185 的链、
+* 跨轨迹投递、`send-now`/`send-later` 都走它。留一个"能被误关的开关"的**代价**是
+* "整条链静默停摆且无人告警"（本仓已实测过同族事故：闸关 6.6h 零 tick、断链 1 天 14 小时）；
+* 而**收益**只剩"关掉一个 5min unref 空检查"。⇒ **收益 < 代价，故删闸**（不是改为缺省开——是**没有这个键了**）。
 *
-* ⚠️ 边界（本步**只**改"枚举哪些 CCC"，**不改**"怎么找到要交付的 agent"）：
-* 把 message 交给某条认知轨迹仍必须靠 **live 会话**解析（见本文件
-* `acquireWakeAgent`）；无 live 会话时该 CCC 只是**被扫到、
-* 无交付对象** ⇒ `deliverWake` 返回 `无绑定会话记录…`，条目回 `pending` 并留痕。
-* 因此本函数**不得**让 tick 抛错（异常一律由调用方 tick 兜住，见 `runWakeTick` 的 try）。
-* @param ctx 插件上下文
-* @returns CCC 根列表（无任何来源 → `[]`）
+* ⚠️ **兼容**：旧配置文件里残留的 `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。
 */
-async function collectWakeCccs(ctx) {
-	return (await listCccs(ctx)).map((e) => e.root);
-}
 /**
-* CRO 唤起消息正文（**刻意不复用** {@link buildWakeText} / {@link buildSendText}）。
-*
-* 三种唤起各有自己的**事实**；混用 = 注入一条假陈述（本容器栽过：`buildSendText` 里
-* 那句"消息已入队"就是一条假陈述，见该函数注释）：
-* · `buildWakeText` —— 「**到点**了」（登记过的未来时刻，人/agent 算好的）
-* · `buildSendText` —— 「**有人此刻给我发了一条消息**」
-* · 本函数         —— 「**我自己的程序**看情况判定该叫我了」（**没有到点、也没有人发消息**）
+* 🔴 **本钟的串行域**（C6b 硬约束）：`clock.chain` 是**本实例私有**的——
+* 与 autopilot 的串行链**零共享**。autopilot 每轮跑 CCC 偏见脚本可能阻塞数十秒，
+* 共用链会把一次性唤醒一起卡住（这正是 P1 被否、取 P2 的理由，见 SESSION §12.8②）。
 *
-* 🔴 `reason` 的呈现（设计 §4.2）：**程序没写就明说没写**，不留空白 ——
-* 改成程序判定后，"当时为什么叫了"**不再能从时间表重建**（原因在程序肚子里）；
-* 留空白 = 连"丢在哪一环"都看不出来。写明"未提供"至少把缺口标出来了（CCE：重建 > 保存）。
-* @param dirName 目标轨迹目录名
-* @param mdPath 目标 SESSION.md 绝对路径
-* @param prompt 程序给的唤起提示词
-* @param reason 程序给的判定理由（可为 null）
-* @returns 投递正文
+* **为什么这里是模块级常量**（而不是 `registerWakeScheduler` 的局部量）：本钟的进程态是
+* **进程级可观测面**（`acc-diag` ①b / `containerClocks` 在读），且 `wakeSchedulerState()` /
+* `__resetWakeSchedulerStateForTest()` 是**公开导出**、可在未装配时被调用 ⇒ 实例必须**恒在**
+* （旧实现的 `schedulerRuntime` 也正是模块级常量）。装配只做 `clock.start()`。
 */
-function buildCroWakeText(dirName, mdPath, prompt, reason) {
+/** 本钟的装配项（`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 [
-		`[CRO 唤起] ${dirName} 自带的 continuous-re-occurrence.ts 判定：现在该唤起。`,
+		`[认知轨迹唤醒] 到点（登记于 ${entry.createdAt}，发起者 ${entry.createdBy || "未知"}，id ${entry.id}）。`,
 		`当前时间：${localHuman()}（当地时区）。`,
 		"",
-		`身份锚定：继续 ${dirName} 的认知轨迹（SESSION.md: ${mdPath}）。`,
-		"",
-		`判定理由：${reason ?? "（程序未提供 reason —— 见 CRO 编写指南 §7 坑 3）"}`,
+		`身份锚定：继续 ${target.dirName} 的认知轨迹（SESSION.md: ${target.mdPath}）。`,
 		"",
-		"唤起提示词：",
-		prompt,
+		"唤醒信息：",
+		entry.message,
 		"",
-		"说明：这是由**本轨迹自己的 CRO 程序**按当时情况做的判定（**不是**定时唤醒，**也不是**别人发的消息）。处理完照常把进展写入 SESSION.md。"
+		"任务：按上述唤醒信息继续本轨迹的工作；完成后把进展写入 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 的判据是"情况"，不是"这条消息还没送出去" ⇒ 自愈来自**重判**，不来自重投。
+* 投递一条唤醒（fire-and-forget：`followup` 入队即返回，不等模型结果）。
 * @param ctx 插件上下文
 * @param root CCC 根
-* @param dirName 目标轨迹目录名（= CRO 只能唤起**自己**，设计 §9-8 的倾向）
-* @param prompt 唤起提示词
-* @param reason 判定理由
-* @returns 投递结果（进 tick 日志；**不写注册表**）
+* @param entry 唤醒条目
+* @returns 投递结果（写回 lastResult）
 */
-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}，它按探针**仍可用**，而选人路径却报"无绑定" ⇒ **两处读数打架，不新建载体**（先查绑定文件与归档集）。` };
-	}
+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,
@@ -9726,996 +9638,1172 @@ async function deliverCroWake(ctx, root, dirName, prompt, reason) {
 		acquired.agent.followup(createUserMessage({
 			content: [{
 				type: "text",
-				text: buildCroWakeText(dirName, mdPath, prompt, reason)
+				text: buildWakeText(entry, target)
 			}],
 			source: PLUGIN_SOURCE
 		}));
 	} catch (err) {
 		return {
 			ok: false,
-			detail: `CRO 投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+			detail: `投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
 		};
 	}
 	return {
 		ok: true,
-		detail: `已投递（${acquired.how}）`
+		detail: `已投递 ${target.dirName}（${acquired.how}）`
 	};
 }
 /**
-* CRO 阶段：本 tick 对**每条启用了 CRO 的轨迹**跑一次它自带的程序，按判定投递。
+* 即时消息正文（**刻意不复用** {@link buildWakeText}）：唤醒文本以「**到点**（登记于…）」开头，
+* 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"。
 *
-* ## 为什么放在既有投递**之后**（R↓）
-* · 既有条目（`send-later`）**有到点承诺** ⇒ 优先级天然更高；
-* · CRO 是"看着情况叫"，**晚一拍无成本**（tick 粒度本就是 5min）；
-* · ⇒ 铁律（设计 §5）：**CRO 的任何失败都不影响既有链路** —— 整段由调用方兜住，
-*   且**每条轨迹各自 try/catch**（一条坏程序不得连累同 tick 的其它轨迹）。
+* ⚠️ **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` 链路**一行为不动**，本次改动 = **纯新增**）。
 *
-* ## 日志口径（刻意与既有投递不同）
-* "每 tick × 每条轨迹"都写一行 ⇒ 对"**常态是不唤起**"的 CRO 就是刷屏。
-* ⇒ 逐条只记 **唤起**（`reason` 进日志 —— 设计 §4.2 要求可重建）与 **跳过**（异常，必须看见）；
-*   **不唤起只进汇总行**（`唤起 x，不唤起 y，跳过 z`）。
-* ⚠️ **诚实标注**：因此"某条轨迹当轮**为何没叫**"**不进 tick 日志**（它在程序肚子里）。
-*    要完整的逐次判定审计，须**程序自己**写状态文件（设计 §3.3）——ACC 给不了。
 * @param ctx 插件上下文
 * @param root CCC 根
-* @param registry 本 tick 已载入的唤醒注册表条目（供快照的 `pendingWakes`；读坏时传 `[]`）
-* @param log 本 tick 的人读摘要（就地追加）
+* @param target `S###` 或 AGENT_SESSIONS 目录名
+* @param message 递送正文
+* @param sender 发起者轨迹标识
+* @returns 投递结果（**同步**返回给调用方）
 */
-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
+async function sendToCognitiveTrajectory(ctx, root, target, message, sender) {
+	const t = resolveWakeTarget(root, target);
+	if (!t) return {
+		ok: false,
+		detail: `目标认知轨迹未命中（${target}）`
 	};
-	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}`);
+	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} 看它的交代文件。`
+				};
 			}
-		} else if (outcome.status === "skipped") {
-			skips += 1;
-			log.push(`· ${root}: ${renderCroOutcome(dirName, outcome)}`);
-		} else if (outcome.status === "no-wake") quiet += 1;
-	} 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;
+			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
+		};
 	}
-	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（超补跑窗口，已清除）`);
+	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)}`
+			};
 		}
-		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}）`);
-			}
+		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)}`
+			};
 		}
-		await runCroPhase(ctx, root, registry.entries, log);
+		return {
+			ok: true,
+			detail: `已投递 ${t.dirName}（${acquired.how}；steer 不可用 ⇒ 退回 followup）: ${String(err?.message ?? err)}${createdNote}`
+		};
 	}
-	return log;
-}
-/**
-* 装配调度器（index.ts apply 调用）：5min tick + 生命周期 disposer +
-* 会话出现/settings 变化时热启动（与 autopilot 同款触发面，互不干扰）。
-* @param ctx 插件上下文
-*/
-function registerWakeScheduler(ctx) {
-	clockOpts.ctx = ctx;
-	clock.start();
-	registerDisposer(ctx, "认知轨迹唤醒调度器", () => clock.dispose());
 }
-//#endregion
-//#region src/cro/guide.ts
 /**
-* cro/guide.ts — CRO 编写指南（**ACC 内置**，S142 §7.8，2026-09-19）
+* 🆕 **给一条「从未被激活过」的轨迹就地建一条 dsh 会话并绑定它**（2026-10-16 owner 令，S142）。
 *
-* ## 为什么指南在 ACC 而不在 CCC（所有者令）
+* 何时用：**只有** `send-now` 在 `acquireWakeAgent` 报「无绑定会话记录」时（见该处的判据说明）。
 *
-* 所有者 2026-09-19：「**ACC 内置，整个机制属于 ACC，CCC 是用户**」。
-* ⇒ 契约 / 调度 / 执行 / 状态暴露 / 容错 / **编写指南** 全在 ACC；
-*   CCC（用户）只负责**写那段程序**。
+* ## 🔴 2026-10-18 根治：改成**和用户操作完全同一个调用形态**
 *
-* ## 🔴 单真相源纪律（本文件的核心约束）
+* owner 原话：「应当和用户操作唤起的会话完全一样才行」。
 *
-* 指南**不复制**契约条款，且**样例快照是"派生"而非"手抄"**：
-* {@link CRO_SAMPLE_SNAPSHOT} 由 {@link buildCroSnapshot} **真正装配**出来 ⇒
-* **schema 一变，样例自动跟着变**，不存在"文档里的样例过期"这一失效模式。
-* （本容器栽过多次"第二真相源"，此处用代码结构而不是纪律去防它。）
+* 上一版（v1.62.1）传的是 `{ cwd: root }`，然后**事后补** `attachSession()` 去挂工作区。
+* 那是**补救**，不是"一样" —— 宿主里那条路径（`sessionController.create` 的
+* `if (workspace !== void 0) await workspace.attachSession(sessionId)`）**只在 `workspaceId` 分支执行**：
 *
-* ## 所有者对本指南的两条明示要求（2026-09-19）
+*   ```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)   // ← 只有这条分支
+*   ```
 *
-* 1. 🔴 **必须备注：CRO 程序是可自测的；测试通过再把文件名改成正式名**；
-* 2. 🔴 **要一并给出测试用的参数**。
-*/
-/**
-* 样例快照输入 —— **代表性数据**（不是真实某条轨迹的现状）。
+* 而**用户在 UI 里新建会话传的正是 `workspaceId`**（见 `client/sessions/service.d.ts` 的
+* `create({ workspaceId?, cwd?, ... })`）⇒ 用户那条路天然会走到 `attachSession`。
 *
-* 取值刻意让它能演示所有者举的"天亮/有人/非高峰 + 已在干活 + 日志过大"场景。
-* 🔒 **路径与轨迹名一律用中性占位**（`/home/user/workspace`、`<S###>` 式示例），
-* 不写任何真实机器路径或私有会话名 —— 本文件随 npm 包发布（2026-10-14 隐私核查）。
+* ⇒ 现在与用户**同一条分支**：先由 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（不静默、不误报成功）
 */
-const CRO_SAMPLE_SNAPSHOT_INPUT = {
-	dirName: "2026-01-01--S001--example-cognitive-trajectory",
-	cccRoot: "/home/user/workspace",
-	nowMs: 17898e8,
-	sessionMdPath: "/home/user/workspace/AGENT_SESSIONS/2026-01-01--S001--example-cognitive-trajectory/SESSION.md",
-	sessionMdBytes: 182e3,
-	sessionMdMtimeMs: 1789799e6,
-	references: [{
-		name: "campaign-100.md",
-		bytes: 41200,
-		mtimeMs: 178979e7
-	}, {
-		name: "auto-exposure.md",
-		bytes: 8400,
-		mtimeMs: 17897e8
-	}],
-	boundSessionIds: ["session-adccc461-9f32-4d9a-a688-9da81fa1ca35"],
-	liveSessionIds: ["session-adccc461-9f32-4d9a-a688-9da81fa1ca35"],
-	runningSessionIds: [],
-	pendingWakes: [{
-		id: "w-20260101-0900-aaaa",
-		at: "2026-01-01T09:30:00+08:00",
-		createdAt: "2026-01-01T07:00:00+08:00",
-		createdBy: "S001"
-	}],
-	scheduler: {
-		armed: true,
-		enabled: true,
-		ticks: 128,
-		lastSkipReason: null
+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
+	};
+}
 /**
-* 🔴 **样例快照（测试参数）** —— **由真实装配器生成**，故**永不与 schema 漂移**。
+* 把刚建的载体会话标题**钉成与 `use` 同一形态**（2026-10-21，owner 报「标题不规范」）。
 *
-* 用途：写 CRO 程序时把它喂给你的程序做自测（见指南 §8「自测」）。
-* @returns 缩进过的快照 JSON 文本
+* ## 为什么单独成函数
+*
+* 它是**全仓第二个**写会话标题的点（第一个是 `use`/`rebuild` 的 `renameDshSessionOnUse`）。
+* 集中在一处，将来若要改命名规则，判据仍在 `namingTitleFor` 一个地方。
+*
+* ## 三者顺序不可换
+*
+* 必须在 ③b（投开场白）**之后**调用：
+* - 开场白让 `titleInput.count` > 0，是标题得以成立的前提；
+* - 放在之后还有**降级好处**：万一 `rename` 失败，宿主自己的 fallback 标题仍在
+*   （难看但存在），而不是两者皆无。
+*
+* @returns 回执片段（成功 `, titled` ／ 失败 `, ⚠️ 标题未写（原因）`）—— **必须出声**，
+*   否则"标题没写"会表现成"这条轨迹就是这名字"（D186：守卫可以拒绝，但不许不出声）。
 */
-function renderCroSampleSnapshot() {
-	return JSON.stringify(buildCroSnapshot(CRO_SAMPLE_SNAPSHOT_INPUT), null, 2);
+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)}）`;
+	}
 }
 /**
-* CRO 编写指南正文（ACC 内置手册；由工具的 guide 动作输出）。
+* 把刚建的会话挂进 **cwd 所属的那个工作区**（2026-10-17 缺陷修复）。
 *
-* 结构照既有 guide 惯例（`MSM_GUIDE` / `cheap-worker(guide=true)`）：
-* 用途 → 位置 → 我给什么 → 你给我什么 → 骨架 → 常见模式 → 坑 → **自测**。
+* 🔴 **为什么必须我们自己做（宿主源码取证，不是推断）**：
+*   `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 追加到回执里的短注记（成功/跳过为空串，失败带原因）
 */
-const CRO_GUIDE = `CRO（Continuous Re-Occurrence · 持续再发生）编写指南
-
-## 0. 这是什么（一句话）
-让一条轨迹**自己带一段程序**，由 ACC 在每次检查时跑它，
-**由这段程序决定「现在该不该叫我、叫我的时候说什么」**。
-
-今天的唤醒只认时间（"3 点叫我"）；CRO 让它认**情况**（"天亮且家里有人才叫我"）。
-
-## 1. 它在系统里的位置
-· **机制属 ACC**（本指南、契约、调度、执行、容错都在 ACC）
-· **程序属 CCC**（你写的那段 TS，放在**你自己轨迹的目录**里）
-· **执行者** = ACC 的唤醒调度器（每 5 分钟一次 tick）
-
-## 2. 文件放哪、叫什么
-  <CCC 根>/AGENT_SESSIONS/<轨迹目录>/continuous-re-occurrence.ts
-
-🔴 **文件名必须全写**（不许用缩写）。
-🔴 **程序只有一个**：**文件在 = 启用；文件不在 = 禁用**。
-   —— 没有**逐条**开关、没有注册表、没有 enabled 字段。
-🔴 **但上面那条只管"这一条"** —— 另有一个**全局总闸** \`croEnabled\`
-   （设置面板「**CRO（轨迹自编程唤起）**」，缺省**开**）：
-   关掉**只停 CRO 阶段** —— \`send-later\` / \`send-now\` / 唤醒表投递**照常工作**。
-   ⚠️ 所以「**文件在**」**不等于**「**一定会跑**」：总闸关掉时 ACC **根本不调用**你的程序
-   （tick 日志里会记一行跳过理由 —— 这是为了让你事后能分辨
-   「**总闸关着没跑**」和「**跑了、程序自己判了不叫**」这两件完全不同的事）。
-
-## 2b. 🔴 机器绑定（**必须指定，否则不运行** —— 所有者令 2026-10-15）
-
-同目录再放一个文件：
-
-  <CCC 根>/AGENT_SESSIONS/<轨迹目录>/cro-host-binding
-
-内容 = **一行机器名**（就是本机 \`hostname\`）。也支持 \`#\` 注释行，方便留痕：
-
-  # 这条轨迹的自唤醒只在 CCC 宿主机上跑
-  yh-Standard-PC-Q35-ICH9-2009
-
-**语义（三条，缺一不可）**：
-· **只许这一台** —— 文件名里写的那台；别处**不跑**；
-· 🔴 **fail-closed** —— **没写这个文件 ⇒ 不跑**（不是"没写就随便跑"）；
-· **检查者是唤醒器**（ACC），**不是**你的程序 —— 你的程序**根本不会被调用**。
-
-**为什么要有它**：CRO 程序本身**随 git 走**（它在你轨迹目录里，会跟着 CCC 到第二台机器）。
-没有这道门，**同一段程序会在两台机器各跑一次**（同一轨迹被叫两次）。
-有了它，第二台机器读到"绑给了别人"就**正确地不跑**。
-
-⚠️ **两条与它有关的纪律**：
-1. 🔴 **不要把这个文件加进 \`.gitignore\`** —— 它**必须**跟着仓走。
-   否则第二台机器读到的是"没绑"，结果**碰巧一样**（也不跑），
-   但你的判据从「**明确绑给了别人**」退化成「**什么都没说**」⇒ 排查时看不出真因。
-2. 🔴 **tick 日志会区分两种跳过**：
-   「\`not-bound\` 你没绑」与「\`bound-to-other\` 你绑给了别人」是**两件事**，文案不同。
-   （2026-10-15 有过一次教训：两种不同的原因报同一句话，害排查指错方向。）
-
-**改绑 / 解除**：直接改这个文件（或删掉 ⇒ 变回"没绑 ⇒ 不跑"）。**没有额外命令**。
-
-## 3. 我给你什么（输入）
-ACC 把这条轨迹的状态做成一个 **JSON 快照**，从 **stdin** 喂给你的程序。
-字段分四组：identity（身份）/ time（时间）/ body（轨迹身体）/ binding + scheduling（绑定与调度）。
-
-⚠️ **给的是"快照"，不是"无限能力"**：ACC 看不见的东西（比如"你上次判了什么"）
-   **物理上给不了**（那是你进程里的内存）。那类状态**归你自己**——
-   写在你自己的轨迹目录里（例如一个 state.json），自己读自己写。
-
-## 4. 你给我什么（输出）
-向 **stdout** 写 **一行 JSON**：
-
-  { "wake": true,  "prompt": "唤起时的提示词", "reason": "判定理由（可选）" }
-  { "wake": false }                                  // 不唤起
-
-· \`wake\` 缺省 / false ⇒ **不唤起**（**这是常态**，缺省是"不打扰"）
-· \`wake: true\` 时 \`prompt\` **必须非空**（否则视为非法，本轮跳过、不投递空消息）
-· 🔴 \`reason\` **强烈建议填**：见 §7 坑 3
-
-## 5. 骨架
-
-  // continuous-re-occurrence.ts
-  let raw = ''
-  process.stdin.on('data', (d) => { raw += d })
-  process.stdin.on('end', () => {
-    const s = JSON.parse(raw)                 // 轨迹状态快照
-    // ... 在这里写你的判定 ...
-    process.stdout.write(JSON.stringify({ wake: false }))
-  })
-
-例（所有者举的 S185 那类情形，仅示意）：
-
-  const tooBig = (s.body.sessionMdBytes ?? 0) > 150_000
-  const busy   = s.binding.runningSessionIds.length > 0
-  if (busy) return out({ wake: false, reason: '已在干活' })
-  if (tooBig) return out({ wake: true, prompt: '你的 SESSION.md 已很大，请先压缩再继续。', reason: '日志超限' })
-
-## 6. 常见模式
-· **环境谓词**（天亮/有人/非高峰）：ACC 给不了这些 —— **你自己去拿**（查设备、读传感器、
-  查你自己的程序）。这就是"程序和程序可以互相访问"的用法。快照里的 \`time\` 只是给你一个时间锚。
-· **已在工作就别叫**：看 \`binding.runningSessionIds\`（非空 = 有载体正在跑轮次）。
-  ⚠️ 注意它和 \`liveSessionIds\` 不同：**会话活着 ≠ 在干活**。
-· **要求它先自整理**：不需要新机制 —— **就是 \`prompt\` 的一种写法**
-  （如"你的 SESSION.md 已 180 KB，请先压缩再继续"）。
-· **次数上限 / 连续 N 次才叫**：ACC 不给你计数器（**给不了**）⇒ **自己目录里写状态文件**。
-
-## 7. 坑
-1. **不许阻塞等输入**：你只从 stdin 拿一次快照，不要在程序里 readline / prompt 等用户输入。
-2. **硬超时 60 秒**：超时会被 SIGKILL、本轮跳过。外部查询请自己设更短的超时。
-3. 🔴 **一定要填 \`reason\`**：改成程序判定之后，"当时为什么叫了"**不再能从时间表重建**——
-   原因在**你的程序肚子里**（可能有随机、可能看了外部数据）。不写 reason，
-   以后出事**无法复现**。这条不是形式主义，是**可重建性**的要求。
-4. **失败只影响你自己**：程序报错/超时/输出非法 ⇒ 记一行 + **跳过本轮**，
-   **绝不会影响** \`send-later\` / \`send-now\` 等既有机制。所以你可以放心试。
-5. 🔴 **不要提前用正式文件名**：见 §8。
-
-## 8. 🔴 自测（**测试通过再把文件名改成正式的**）
-CRO 程序**是可以自测的** —— 因为它只做一件事：**吃一份快照 JSON，吐一行决策 JSON**。
-（纯函数式的边界 ⇒ 不需要真机、不需要等 5 分钟 tick、不需要调度器。）
-
-### 8.1 推荐流程：**用开发名写，绿了再改名**
-因为「**文件在 = 启用**」**没有逐条开关**（总闸是全局的，管不了单条），
-**改名这个动作本身就是上线动作**：
-
-  1. 先用**开发名**写（如 \`continuous-re-occurrence.dev.ts\`）
-     —— 开发名**不会**被 ACC 启用（启用只认正式名 exact match），可以放心留一半
-  2. 配一个自测（如 \`continuous-re-occurrence.dev.test.ts\`），喂几份快照断言输出
-  3. **全部绿了** ⇒ 改名为 \`continuous-re-occurrence.ts\` ⇒ **这一刻才生效**
-
-⚠️ 若你跳过自测直接上正式名：半成品会被当成生效程序，**报错并跳过本轮**（不会搞坏系统，
-  但那条轨迹的 CRO 就是空转的）。**报错是安全网，不是工作流。**
-
-### 8.2 手工试跑（最快的一条路）
-把样例快照喂给你的程序，看它吐什么：
-
-  # 用开发名试跑（推荐 bun；node 需能跑 TS）
-  bun continuous-re-occurrence.dev.ts < sample-snapshot.json
-
-  # 或直接管道
-  echo '<一行快照 JSON>' | bun continuous-re-occurrence.dev.ts
-
-### 8.3 测试用的参数
-**样例快照 = 由 ACC 的装配器实时生成**（故**永不与 schema 漂移**，schema 一变它跟着变）。
-取法：**运行本指南所在工具的 guide 动作**，或用同一机制导出；内容是：
-
-\`\`\`json
-${renderCroSampleSnapshot()}
-\`\`\`
-
-该样例刻意覆盖了：
-· \`body.sessionMdBytes\` = 182000（**日志过大**那一档）
-· \`binding.runningSessionIds\` = []（**空闲**；把它填成一个 id 就能测"已在干活"分支）
-· \`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
+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;
+	}
+}
 /**
-* trajectory/resident.ts — **常驻名单**（D173 的兑现口，`cognitive_trajectory resident` 的实现）
+* 在 `workspaceRegistry.list()` 里找 **path 等于该 CCC 根** 的那一个。
 *
-* ## 这条能力的判据（owner 2026-10-20 原话，逐字）
+* 🔴 **为什么要 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 根是一个**符号链接**（部署上常见：家目录/项目目录被链到别处），
+*   两侧**逐字不等**，只比字符串会**挂错或挂不上**。
 *
-* > 「常驻的意思就是**自己声明为自己欢迎别人来麻烦自己**，和永不休眠没啥关系，
-* >   **trajectory never ends 悖论的一种实现**」
+* ⚠️ 归一失败（路径不存在等）时**回落字面比较** —— 不改既有语义，只是多给一次机会。
 *
-* ⇒ **常驻不是资源状态**。它不是"永不休眠"、不是"常驻内存"、不是"不许销毁我的会话"。
-*   一条轨迹**永远存在**（没有生命周期），常驻与否都不改变这一点。
+* @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}）。
 *
-* 1. **纯读**：不写任何文件、不碰注册表、不碰 `wake/scheduler.ts`。
-* 2. **不进系统提示词**（owner 裁决 Q2：说明类信息按需取，不占每轮 token）。
-* 3. **只报写了 `serves` 的轨迹** —— 只写半个（有 `resident` 没 `serves`）等于
-*    "把自己挂上去却不说能干什么"，按手册的判据那比不写更坏，所以**不列出来**，
-*    但要**单独数出**来，让写的人知道自己的写法没生效。
+* 三种唤起各有自己的**事实**；混用 = 注入一条假陈述（本容器栽过：`buildSendText` 里
+* 那句"消息已入队"就是一条假陈述，见该函数注释）：
+* · `buildWakeText` —— 「**到点**了」（登记过的未来时刻，人/agent 算好的）
+* · `buildSendText` —— 「**有人此刻给我发了一条消息**」
+* · 本函数         —— 「**我自己的程序**看情况判定该叫我了」（**没有到点、也没有人发消息**）
 *
-* ## 归属（D23）
-* 机制在 ACC（怎么找、按什么顺序、列什么字段）；内容在 CCC（`serves` 那句话写什么）。
+* 🔴 `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} 同层）。
 *
-* ⚠️ 读盘失败 / 坏 JSON 一律**跳过该条**（不抛）：一份坏的声明不该让整张名单拿不到。
+* · **取用通路复用** {@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 的人读摘要（就地追加）
 */
-function collectResident(root) {
-	const entries = [];
-	const incomplete = [];
-	let names = [];
+async function runCroPhase(ctx, root, registry, log) {
+	if (readSimpleSettings().croEnabled === false) {
+		log.push("CRO 阶段：已关闭（croEnabled=false）——既有唤醒投递不受影响");
+		return;
+	}
+	let dirs;
 	try {
-		names = readdirSync(sessionsRoot(root), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name);
+		dirs = listCroCognitiveTrajectories(root);
 	} catch {
-		return {
-			entries,
-			incomplete
-		};
+		return;
 	}
-	for (const dirName of names) {
-		let profile;
-		try {
-			profile = readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
-		} catch {
+	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;
 		}
-		if (!profile || profile.resident === void 0) continue;
-		const serves = profile.resident.serves;
-		if (serves === void 0 || serves === "") {
-			incomplete.push(profile.code);
-			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}`);
+			}
 		}
-		entries.push({
-			code: profile.code,
-			dirName: profile.dirName,
-			serves,
-			...profile.model !== void 0 ? { model: profile.model } : {}
-		});
+	} catch (err) {
+		skips += 1;
+		log.push(`· ${root}: ${dirName}: CRO 内部异常（已忽略，不影响既有链路）: ${String(err?.message ?? err)}`);
 	}
-	entries.sort((a, b) => a.code < b.code ? -1 : a.code > b.code ? 1 : 0);
-	incomplete.sort();
-	return {
-		entries,
-		incomplete
-	};
+	log.push(`· ${root}: CRO 评估 ${dirs.length} 条（唤起 ${wakes}，不唤起 ${quiet}，跳过 ${skips}${hostSkips > 0 ? `，非本机绑定 ${hostSkips}` : ""}）`);
 }
 /**
-* 渲染成给模型读的文本（`cognitive_trajectory resident` 的返回值）。
+* 取本机机器名（**永不抛**）。
 *
-* 🔴 **空名单也是有效结果**，且必须说清"这意味着什么" —— 否则读者会以为工具坏了。
+* `os.hostname()` 理论上可能抛（极少数环境）⇒ 这里兜底成空串。
+* ⚠️ **空串的后果是"全部不通过"**（`bound === self` 永不成立）⇒ 即 **fail-closed**，
+* 与所有者裁定同向（宁可都不跑，也不会"名字取不到就随便跑"）。
+* @returns 本机机器名；取不到 ⇒ `''`
 */
-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}`);
+function safeHostname() {
+	try {
+		return hostname();
+	} catch {
+		return "";
 	}
-	if (incomplete.length > 0) {
-		lines.push("");
-		lines.push(`  ⚠️ 写了 resident 但**没写 serves**（不会被列出）：${incomplete.join("、")}`);
-		lines.push("     只写半个 = 把自己挂上去却不说能干什么 —— 别人会来问，然后发现问错了人。");
+}
+/** 一次调度 tick：遍历已知 CCC → 到期项串行投递 / 超窗项置 missed；返回人读摘要 */
+async function runWakeTick(ctx) {
+	const log = [];
+	const roots = await collectWakeCccs(ctx).catch(() => []);
+	if (roots.length === 0) {
+		clock.noteSkipReason("无已知 CCC 可扫（等某个会话/工作区出现）");
+		return log;
 	}
-	lines.push("");
-	lines.push("── 怎么让自己出现在这里 ──");
-	lines.push("  在你这条轨迹目录的 trajectory.json 里写：");
-	lines.push("    { \"resident\": { \"serves\": \"一句话说清我擅长什么、能帮上什么忙\" } }");
-	lines.push("  ⚠️ 只写这一个字段**不影响任何默认行为**（D183）；其余 key 全部可选。");
-	return lines.join("\n");
+	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;
 }
-//#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` ① 段仍需要）。
+* 🔴🔴 **A104-C′（2026-10-23，owner 点头）：容器级「被重启打断的会话」兜底 —— 每 tick 扫一次并注入。**
 *
-* 判据纪律：本模块**不得**反向依赖 autopilot 判据层（那会让退场半途而废）。
+* ## 为什么必须做（不是"多一层保险"，是**已有实测盲窗**）
 *
-* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
-* **本模块的 `ctx` 参数类型从 `Context` 改为 `unknown`** —— 消除本文件唯一的 `W2` 接触
-* （直接 import 宿主 `cordis` 的类型）。
+* 2026-10-23 实测：`08:02` 一次 `restart-web` 打断了一个会话，此后 **13 分钟无人拉起**。
+* 用真回放（把日志截到争议时刻 ＋ 重压 zstd 帧 ＋ 同一份实现）验证：
+*  - 截到 `08:07:30`／`08:12:40` ⇒ **两次都能判出该会话 `turn/end[interrupted]` 且其后无新 `turn/start`**
+*  - 而那两个 tick **实际都没有叫** ⇒ **判据没错，是"没有被跑起来"**
 *
-* **为什么这是"真解耦"而不是"把类型藏起来"（判据）：** `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）。
+* ⇒ 结论：**「守护程序自己修好」≠「一定有人拉起」**。任何单条 CRO 轨迹都可能因为
+*    自身在跑、绑定缺失、阈值保护、程序 bug 而漏掉 —— 而被打断的会话**不会自己恢复**。
+* ⇒ 兜底必须放在**容器自己**身上，且必须**自己完成"发现 + 注入"**（只扫不动没有用）。
 *
-* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
-* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
+* ## 边界（写在这里免得后人扩大它）
 *
-* @param ctx 插件上下文（**只透传**给 L0 取数口，本模块不解引用 ⇒ 类型为 `unknown`）
-* @returns 逐条 live 会话
+* - ⚠️ **这会真的起 agent、真烧算力** —— owner 已被告知并点头（2026-10-23）。
+* - 🔴 **必须排除 live 会话**：正在跑的会话不该被再注入一次（否则重复投递）。
+* - 🔴 **与 CRO 并存、不替代**：CRO 是**轨迹自己的策略**（何时该叫由它判），
+*   本兜底只覆盖「**无论谁都没叫**」这一格。两者重复命中时，靠 `live` 排除天然去重。
+* - ⚠️ **本函数任何失败都不得连累既有链路**（设计 §5 铁律）：整体 try/catch 吞掉并留一行日志。
 */
-function listLiveSessions(ctx) {
-	const out = [];
+async function runInterruptedSafetyNet(ctx, root, log) {
 	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)
-			});
+		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;
 }
-function diagLive(ctx) {
-	const processCwd = process.cwd();
-	return {
-		processCwd,
-		processCcc: cccRootForCwd(processCwd),
-		liveSessions: listLiveSessions(ctx)
-	};
+/**
+* 装配调度器（index.ts apply 调用）：5min tick + 生命周期 disposer +
+* 会话出现/settings 变化时热启动（与 autopilot 同款触发面，互不干扰）。
+* @param ctx 插件上下文
+*/
+function registerWakeScheduler(ctx) {
+	clockOpts.ctx = ctx;
+	clock.start();
+	registerDisposer(ctx, "认知轨迹唤醒调度器", () => clock.dispose());
 }
 //#endregion
-//#region src/trajectory/interrupted.ts
+//#region src/cro/guide.ts
 /**
-* 中断轮次发现（`interrupted` 会话扫描）
-*
-* ## 这个模块解决什么
-*
-* DSH 的会话日志里，**进程在某一轮完成前退出**（被 kill／崩溃／关机超时）时，
-* 宿主重放时会为该轮补上收尾事件：
-*
-* ```jsonl
-* turn/end {"turn":66,"reason":{"kind":"interrupted"}}
-* step/end {"turn":66,"step":85}
-* session/end-seed {}
-* ```
-*
-* 宿主**只补收尾，不续跑** —— 那一轮的工作就此停在那里。本模块负责把这些会话找出来，
-* 交给上层（认知轨迹）决定要不要续。
-*
-* ## 判据（三条同时成立，缺一不可）
+* cro/guide.ts — CRO 编写指南（**ACC 内置**，S142 §7.8，2026-09-19）
 *
-* 1. 日志里**最后一条 `turn/end`** 的 `reason.kind === 'interrupted'`；
-* 2. 该 `turn/end` **之后没有新的 `turn/start`**（否则已被后续轮次接续）；
-* 3. ⛔ **不要求**末条是 `session/end-seed`（2026-10-23 放宽，原因见 {@link detectInterruptedEnd}）。
+* ## 为什么指南在 ACC 而不在 CCC（所有者令）
 *
-* ⚠️ **为什么不能只看"存在过 interrupted"**：一个长会话历史上可能中断几十次
-* （本容器实测单会话 33 次）。只看"曾经中断"会把早已恢复的会话全部当成待续 ⇒ 灾难。
+* 所有者 2026-09-19：「**ACC 内置，整个机制属于 ACC，CCC 是用户**」。
+* ⇒ 契约 / 调度 / 执行 / 状态暴露 / 容错 / **编写指南** 全在 ACC；
+*   CCC（用户）只负责**写那段程序**。
 *
-* 🔴 **为什么原判据要求"末条 = end-seed"是错的**（实测 26 条里漏 2 条）：
-* 重启后宿主会在 end-seed **之后**追加 `agent/inbox/spliced`（把待办消息重新塞进收件箱）
-* ⇒ "末条必须 end-seed"**在恢复动作发生之后就恒不成立**，
-* 而"被恢复过又再次被打断"恰恰是守护最该覆盖的形态。
+* ## 🔴 单真相源纪律（本文件的核心约束）
 *
-* ## 为什么不整文件解压
+* 指南**不复制**契约条款，且**样例快照是"派生"而非"手抄"**：
+* {@link CRO_SAMPLE_SNAPSHOT} 由 {@link buildCroSnapshot} **真正装配**出来 ⇒
+* **schema 一变，样例自动跟着变**，不存在"文档里的样例过期"这一失效模式。
+* （本容器栽过多次"第二真相源"，此处用代码结构而不是纪律去防它。）
 *
-* DSH 日志是 **zstd 多帧追加**（实测单会话 24705 帧 / 47 MB）。原生
-* `zlib.zstdDecompressSync` 只解**第一帧**，对多帧直接报 `Unknown frame descriptor`。
-* ⇒ 采用**尾部窗口 + 倒序逐帧解压**：只读文件末尾 N 字节，从后往前找帧魔数，
-*    解到凑够所需事件数即停。实测 8h 窗口 6 个会话 **20 ms**。
+* ## 所有者对本指南的两条明示要求（2026-09-19）
 *
-* ## 世代识别复用 `cleanup.ts`
+* 1. 🔴 **必须备注：CRO 程序是可自测的；测试通过再把文件名改成正式名**；
+* 2. 🔴 **要一并给出测试用的参数**。
+*/
+/**
+* 样例快照输入 —— **代表性数据**（不是真实某条轨迹的现状）。
 *
-* 日志文件名有多个世代（`session.jsonl` / `session.v3.jsonl.zstd` / `session.v4.jsonl.zstd`…），
-* 宿主按世代写且**迁移保留源文件**。⇒ 本模块**不硬编码文件名**，走
-* {@link findSessionLog}（与清理／体积统计同一判据），避免"新世代对本模块不可见"。
+* 取值刻意让它能演示所有者举的"天亮/有人/非高峰 + 已在干活 + 日志过大"场景。
+* 🔒 **路径与轨迹名一律用中性占位**（`/home/user/workspace`、`<S###>` 式示例），
+* 不写任何真实机器路径或私有会话名 —— 本文件随 npm 包发布（2026-10-14 隐私核查）。
+*/
+const CRO_SAMPLE_SNAPSHOT_INPUT = {
+	dirName: "2026-01-01--S001--example-cognitive-trajectory",
+	cccRoot: "/home/user/workspace",
+	nowMs: 17898e8,
+	sessionMdPath: "/home/user/workspace/AGENT_SESSIONS/2026-01-01--S001--example-cognitive-trajectory/SESSION.md",
+	sessionMdBytes: 182e3,
+	sessionMdMtimeMs: 1789799e6,
+	references: [{
+		name: "campaign-100.md",
+		bytes: 41200,
+		mtimeMs: 178979e7
+	}, {
+		name: "auto-exposure.md",
+		bytes: 8400,
+		mtimeMs: 17897e8
+	}],
+	boundSessionIds: ["session-adccc461-9f32-4d9a-a688-9da81fa1ca35"],
+	liveSessionIds: ["session-adccc461-9f32-4d9a-a688-9da81fa1ca35"],
+	runningSessionIds: [],
+	pendingWakes: [{
+		id: "w-20260101-0900-aaaa",
+		at: "2026-01-01T09:30:00+08:00",
+		createdAt: "2026-01-01T07:00:00+08:00",
+		createdBy: "S001"
+	}],
+	scheduler: {
+		armed: true,
+		enabled: true,
+		ticks: 128,
+		lastSkipReason: null
+	}
+};
+/**
+* 🔴 **样例快照（测试参数）** —— **由真实装配器生成**，故**永不与 schema 漂移**。
 *
-* ## 边界
+* 用途：写 CRO 程序时把它喂给你的程序做自测（见指南 §8「自测」）。
+* @returns 缩进过的快照 JSON 文本
+*/
+function renderCroSampleSnapshot() {
+	return JSON.stringify(buildCroSnapshot(CRO_SAMPLE_SNAPSHOT_INPUT), null, 2);
+}
+/**
+* CRO 编写指南正文（ACC 内置手册；由工具的 guide 动作输出）。
 *
-* - **只读**：不改任何会话日志。
-* - **不判周期**：何时扫、扫完做什么归调用方（CCC 的认知轨迹）。本模块只回答
-*   「此刻哪些会话以 interrupted 结尾」。
+* 结构照既有 guide 惯例（`MSM_GUIDE` / `cheap-worker(guide=true)`）：
+* 用途 → 位置 → 我给什么 → 你给我什么 → 骨架 → 常见模式 → 坑 → **自测**。
 */
+const CRO_GUIDE = `CRO（Continuous Re-Occurrence · 持续再发生）编写指南
+
+## 0. 这是什么（一句话）
+让一条轨迹**自己带一段程序**，由 ACC 在每次检查时跑它，
+**由这段程序决定「现在该不该叫我、叫我的时候说什么」**。
+
+今天的唤醒只认时间（"3 点叫我"）；CRO 让它认**情况**（"天亮且家里有人才叫我"）。
+
+## 1. 它在系统里的位置
+· **机制属 ACC**（本指南、契约、调度、执行、容错都在 ACC）
+· **程序属 CCC**（你写的那段 TS，放在**你自己轨迹的目录**里）
+· **执行者** = ACC 的唤醒调度器（每 5 分钟一次 tick）
+
+## 2. 文件放哪、叫什么
+  <CCC 根>/AGENT_SESSIONS/<轨迹目录>/continuous-re-occurrence.ts
+
+🔴 **文件名必须全写**（不许用缩写）。
+🔴 **程序只有一个**：**文件在 = 启用；文件不在 = 禁用**。
+   —— 没有**逐条**开关、没有注册表、没有 enabled 字段。
+🔴 **但上面那条只管"这一条"** —— 另有一个**全局总闸** \`croEnabled\`
+   （设置面板「**CRO（轨迹自编程唤起）**」，缺省**开**）：
+   关掉**只停 CRO 阶段** —— \`send-later\` / \`send-now\` / 唤醒表投递**照常工作**。
+   ⚠️ 所以「**文件在**」**不等于**「**一定会跑**」：总闸关掉时 ACC **根本不调用**你的程序
+   （tick 日志里会记一行跳过理由 —— 这是为了让你事后能分辨
+   「**总闸关着没跑**」和「**跑了、程序自己判了不叫**」这两件完全不同的事）。
+
+## 2b. 🔴 机器绑定（**必须指定，否则不运行** —— 所有者令 2026-10-15）
+
+同目录再放一个文件：
+
+  <CCC 根>/AGENT_SESSIONS/<轨迹目录>/cro-host-binding
+
+内容 = **一行机器名**（就是本机 \`hostname\`）。也支持 \`#\` 注释行，方便留痕：
+
+  # 这条轨迹的自唤醒只在 CCC 宿主机上跑
+  yh-Standard-PC-Q35-ICH9-2009
+
+**语义（三条，缺一不可）**：
+· **只许这一台** —— 文件名里写的那台；别处**不跑**；
+· 🔴 **fail-closed** —— **没写这个文件 ⇒ 不跑**（不是"没写就随便跑"）；
+· **检查者是唤醒器**（ACC），**不是**你的程序 —— 你的程序**根本不会被调用**。
+
+**为什么要有它**：CRO 程序本身**随 git 走**（它在你轨迹目录里，会跟着 CCC 到第二台机器）。
+没有这道门，**同一段程序会在两台机器各跑一次**（同一轨迹被叫两次）。
+有了它，第二台机器读到"绑给了别人"就**正确地不跑**。
+
+⚠️ **两条与它有关的纪律**：
+1. 🔴 **不要把这个文件加进 \`.gitignore\`** —— 它**必须**跟着仓走。
+   否则第二台机器读到的是"没绑"，结果**碰巧一样**（也不跑），
+   但你的判据从「**明确绑给了别人**」退化成「**什么都没说**」⇒ 排查时看不出真因。
+2. 🔴 **tick 日志会区分两种跳过**：
+   「\`not-bound\` 你没绑」与「\`bound-to-other\` 你绑给了别人」是**两件事**，文案不同。
+   （2026-10-15 有过一次教训：两种不同的原因报同一句话，害排查指错方向。）
+
+**改绑 / 解除**：直接改这个文件（或删掉 ⇒ 变回"没绑 ⇒ 不跑"）。**没有额外命令**。
+
+## 3. 我给你什么（输入）
+ACC 把这条轨迹的状态做成一个 **JSON 快照**，从 **stdin** 喂给你的程序。
+字段分四组：identity（身份）/ time（时间）/ body（轨迹身体）/ binding + scheduling（绑定与调度）。
+
+⚠️ **给的是"快照"，不是"无限能力"**：ACC 看不见的东西（比如"你上次判了什么"）
+   **物理上给不了**（那是你进程里的内存）。那类状态**归你自己**——
+   写在你自己的轨迹目录里（例如一个 state.json），自己读自己写。
+
+## 4. 你给我什么（输出）
+向 **stdout** 写 **一行 JSON**：
+
+  { "wake": true,  "prompt": "唤起时的提示词", "reason": "判定理由（可选）" }
+  { "wake": false }                                  // 不唤起
+
+· \`wake\` 缺省 / false ⇒ **不唤起**（**这是常态**，缺省是"不打扰"）
+· \`wake: true\` 时 \`prompt\` **必须非空**（否则视为非法，本轮跳过、不投递空消息）
+· 🔴 \`reason\` **强烈建议填**：见 §7 坑 3
+
+## 5. 骨架
+
+  // continuous-re-occurrence.ts
+  let raw = ''
+  process.stdin.on('data', (d) => { raw += d })
+  process.stdin.on('end', () => {
+    const s = JSON.parse(raw)                 // 轨迹状态快照
+    // ... 在这里写你的判定 ...
+    process.stdout.write(JSON.stringify({ wake: false }))
+  })
+
+例（所有者举的 S185 那类情形，仅示意）：
+
+  const tooBig = (s.body.sessionMdBytes ?? 0) > 150_000
+  const busy   = s.binding.runningSessionIds.length > 0
+  if (busy) return out({ wake: false, reason: '已在干活' })
+  if (tooBig) return out({ wake: true, prompt: '你的 SESSION.md 已很大，请先压缩再继续。', reason: '日志超限' })
+
+## 6. 常见模式
+· **环境谓词**（天亮/有人/非高峰）：ACC 给不了这些 —— **你自己去拿**（查设备、读传感器、
+  查你自己的程序）。这就是"程序和程序可以互相访问"的用法。快照里的 \`time\` 只是给你一个时间锚。
+· **已在工作就别叫**：看 \`binding.runningSessionIds\`（非空 = 有载体正在跑轮次）。
+  ⚠️ 注意它和 \`liveSessionIds\` 不同：**会话活着 ≠ 在干活**。
+· **要求它先自整理**：不需要新机制 —— **就是 \`prompt\` 的一种写法**
+  （如"你的 SESSION.md 已 180 KB，请先压缩再继续"）。
+· **次数上限 / 连续 N 次才叫**：ACC 不给你计数器（**给不了**）⇒ **自己目录里写状态文件**。
+
+## 7. 坑
+1. **不许阻塞等输入**：你只从 stdin 拿一次快照，不要在程序里 readline / prompt 等用户输入。
+2. **硬超时 60 秒**：超时会被 SIGKILL、本轮跳过。外部查询请自己设更短的超时。
+3. 🔴 **一定要填 \`reason\`**：改成程序判定之后，"当时为什么叫了"**不再能从时间表重建**——
+   原因在**你的程序肚子里**（可能有随机、可能看了外部数据）。不写 reason，
+   以后出事**无法复现**。这条不是形式主义，是**可重建性**的要求。
+4. **失败只影响你自己**：程序报错/超时/输出非法 ⇒ 记一行 + **跳过本轮**，
+   **绝不会影响** \`send-later\` / \`send-now\` 等既有机制。所以你可以放心试。
+5. 🔴 **不要提前用正式文件名**：见 §8。
+
+## 8. 🔴 自测（**测试通过再把文件名改成正式的**）
+CRO 程序**是可以自测的** —— 因为它只做一件事：**吃一份快照 JSON，吐一行决策 JSON**。
+（纯函数式的边界 ⇒ 不需要真机、不需要等 5 分钟 tick、不需要调度器。）
+
+### 8.1 推荐流程：**用开发名写，绿了再改名**
+因为「**文件在 = 启用**」**没有逐条开关**（总闸是全局的，管不了单条），
+**改名这个动作本身就是上线动作**：
+
+  1. 先用**开发名**写（如 \`continuous-re-occurrence.dev.ts\`）
+     —— 开发名**不会**被 ACC 启用（启用只认正式名 exact match），可以放心留一半
+  2. 配一个自测（如 \`continuous-re-occurrence.dev.test.ts\`），喂几份快照断言输出
+  3. **全部绿了** ⇒ 改名为 \`continuous-re-occurrence.ts\` ⇒ **这一刻才生效**
+
+⚠️ 若你跳过自测直接上正式名：半成品会被当成生效程序，**报错并跳过本轮**（不会搞坏系统，
+  但那条轨迹的 CRO 就是空转的）。**报错是安全网，不是工作流。**
+
+### 8.2 手工试跑（最快的一条路）
+把样例快照喂给你的程序，看它吐什么：
+
+  # 用开发名试跑（推荐 bun；node 需能跑 TS）
+  bun continuous-re-occurrence.dev.ts < sample-snapshot.json
+
+  # 或直接管道
+  echo '<一行快照 JSON>' | bun continuous-re-occurrence.dev.ts
+
+### 8.3 测试用的参数
+**样例快照 = 由 ACC 的装配器实时生成**（故**永不与 schema 漂移**，schema 一变它跟着变）。
+取法：**运行本指南所在工具的 guide 动作**，或用同一机制导出；内容是：
+
+\`\`\`json
+${renderCroSampleSnapshot()}
+\`\`\`
+
+该样例刻意覆盖了：
+· \`body.sessionMdBytes\` = 182000（**日志过大**那一档）
+· \`binding.runningSessionIds\` = []（**空闲**；把它填成一个 id 就能测"已在干活"分支）
+· \`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
 /**
-* 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;
-		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++;
+	for (const dirName of names) {
+		let profile;
 		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)
-			});
+			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 } : {}
+		});
 	}
-	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
@@ -12391,6 +12479,61 @@ function hasEnabledImChannel(root) {
 	return (settings.accounts ?? []).some((a) => a.enabled !== false);
 }
 /**
+* 可见性判据（**轨迹级**，2026-10-23 owner 令）：
+* 这个 dsh 会话所属的认知轨迹，是否**被 IM 路由表点名**（= 它才是那个"接线人"）。
+*
+* ## 它解决的问题（owner 原话的**去标识改写**，原文含私有角色名，按 D145 不入仓库）
+*
+* > 「很多轨迹发消息给我，但是我没空回，它们就会等待我，其实并不是，我希望他们继续工作；
+* >  所以只有 IM 桥绑定了任意账户的认知轨迹才拥有 `im-bridge` 这个 tool，
+* >  这样可以确保只有一个接线角色和我联系，其它轨迹和它联系即可，它会自行回复它们的」
+*
+* ⇒ 旧判据是 **CCC 级**（{@link hasEnabledImChannel}：本 CCC 有任一启用账号 ⇒ 全体可见）。
+* 它的后果不是"少一个工具"，而是**一条错误的工作流**：每条轨迹都以为自己该直接对 owner 说话，
+* 于是发完就**停下来等人回**——而 owner 根本没空逐条回。**工具在，就把等待也带上了。**
+*
+* ## 判据（两条，缺一不可）
+*
+* 1. 本 CCC 有可用账号（{@link hasEnabledImChannel}）—— 没有账号时路由表也没有意义；
+* 2. 本会话**绑定的轨迹编码**出现在 `routes[].trajectory` 里。
+*
+* ⚠️ **为什么不看 `routes[].user`**：那是"对端是谁"（owner 的通道 id），
+*    判"这条轨迹能不能说话"只跟**轨迹**有关，与哪个对端无关。
+*
+* ⚠️ **`*` 通配也算点名**：`{ user:"*", trajectory:"<某轨迹>" }` 这条路由的含义就是
+*    "**没人认领的消息都归那条轨迹**" ⇒ 它确实是一条被授权的接线轨迹，必须算可见。
+*    这与 `matchWeixinRoute` 的通配兜底语义**同源**，不另立规则。
+*
+* ## 拿不到轨迹编码时怎么办（fail-closed，与 `exclusive` 同向）
+*
+* 会话 → 轨迹编码要读绑定。**取不到就判不可见**：
+* - 与 `exclusive`（未声明 ⇒ 隐藏）同向；
+* - 反向（取不到就放行）会让"绑定坏了"表现成"工具还在"，
+*   而那正是本判据要防的形态（D179：配置说它有、行为说它没有，且零报错）。
+* ⚠️ 代价明示：绑定读取若短暂失败，该轮会少一个工具；下一轮绑定恢复即回。
+*    这比"误给一条轨迹发消息的权限"便宜 —— 后者会让它**停下来等 owner**。
+*
+* @param root CCC 根
+* @param trajectoryCode 本会话所属认知轨迹的编码（**由调用方解析**，见 `trajectory/policy/profile.ts`）
+* @returns true = 该轨迹接线，`im-bridge` 可见
+*/
+function isImWiredTrajectory(root, trajectoryCode) {
+	if (typeof trajectoryCode !== "string" || trajectoryCode.trim() === "") return false;
+	if (!hasEnabledImChannel(root)) return false;
+	let settings;
+	try {
+		settings = readImSettings(root);
+	} catch {
+		return false;
+	}
+	const wanted = trajectoryCode.trim();
+	for (const route of settings.routes ?? []) {
+		const target = typeof route.trajectory === "string" ? route.trajectory.trim() : "";
+		if (target !== "" && target === wanted) return true;
+	}
+	return false;
+}
+/**
 * 错误码 → 可行动提示（模型视角：说清怎么改）。
 *
 * 🔴 `CHANNEL_NOT_CONFIGURED` 的提示**不能写死某一个渠道的字段名**（2026-10-20 Q4 真机验收踩到）：
@@ -12920,7 +13063,7 @@ function computeVisibilitySources(sessionId, root) {
 		}
 		return { deny: [.../* @__PURE__ */ new Set([...SAFE_MODE_DENY_TOOLS, ...declared])] };
 	}));
-	out.push(sourceOf("imBridge", () => hasEnabledImChannel(root) ? { deny: [] } : { deny: [IM_BRIDGE_TOOL_NAME] }));
+	out.push(sourceOf("imBridge", () => isImWiredTrajectory(root, trajectoryCodeForSession(root, sessionId)) ? { deny: [] } : { deny: [IM_BRIDGE_TOOL_NAME] }));
 	out.push(sourceOf("exclusive", () => {
 		const declared = readExclusiveTools(root);
 		return { deny: EXCLUSIVE_TOOL_NAMES.filter((t) => !declared.includes(t)) };
@@ -15113,7 +15256,7 @@ function registerStatusApi(ctx, opts = {}) {
 						});
 					}
 					const { saveWeixinRoutes } = await import("./route-3OzOAjec.js").then((n) => n.l);
-					const { findDirNameByCode } = await import("./profile-DGt_e-Nx.js").then((n) => n.a);
+					const { findDirNameByCode } = await import("./profile-zxakCNXy.js").then((n) => n.a);
 					for (const r of routes) if (findDirNameByCode(root, r.trajectory) === null) {
 						sendJson$2(res, 400, { error: `unknown trajectory: ${r.trajectory} (no such trajectory code in ${root})` });
 						return;
@@ -20156,7 +20299,7 @@ const MEDIA_MAX_BYTES = 20971520;
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-WfktvbN8.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -20224,7 +20367,7 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const { findDirNameByCode } = await import("./profile-DGt_e-Nx.js").then((n) => n.a);
+	const { findDirNameByCode } = await import("./profile-zxakCNXy.js").then((n) => n.a);
 	if (findDirNameByCode(root, target.role) === null) {
 		const detail = `目标 CCC "${target.ccc}" 内没有编码为 "${target.role}" 的认知轨迹`;
 		console.error(`[serenity-hooks] ✗ human-channel: ${detail}（account=${input.account} user=${input.user}）—— 该消息**未投递**，请改订阅表里的目标编码`);
@@ -21178,7 +21321,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-WfktvbN8.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -21471,7 +21614,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-WfktvbN8.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];