@shgroup/dsh-serenity-hooks 1.47.3 → 1.47.4

package/lib/index.js

@@ -2,13 +2,11 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { a as hostSessions, c as hostWeb, i as hostService, l as hostWebServer, n as hostInjected, o as hostSettings, r as hostLlm, s as hostSubagents, t as hostAgents } from "./access-CNccNtgf.js";
 import { a as findSerenityRoot, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, g as resolveInside, i as findGitRoot, l as pathInside, m as readTrajectorySkills, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readHandymanConfig, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-DG4Oc7I1.js";
 import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-NpTWo0-c.js";
-import { C as showSession, D as localFileStamp, E as isoLocal, S as setActiveSessionInfo, T as useSession, _ as parseSessionContextFromEvents, a as pruneMissingBindings, b as sessionEvents$1, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as readActiveSessionMd, w as summarize, x as sessionsRoot, y as resolveSessionByTitle } from "./message-source-aR-FJ38L.js";
+import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-yuCgrbU6.js";
 import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-CWMRa36W.js";
 import { a as unregisterSkiffSession$1, i as skiffSessionSnapshot$1, n as skiffRoleFor$1, o as ACC_VERSION, r as skiffSessionInfo$1, t as registerSkiffSession$1 } from "./skiff-registry-BjIX_KD1.js";
 import { a as readSkiffRoles, c as roleMsmWhitelist, d as systemPromptSource, f as trajectorySubset, i as isSkiffSessionId, l as roleToolWhitelist, n as buildSkiffBasePrompt, o as resolveRoleSystemPrompt, r as createRolePromptReader, s as resolveSkiffKind } from "./skiff-role-KqQA6pkr.js";
 import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-DxMwlCv9.js";
-import { r as sessionsRootDir, t as hasSessionLogById } from "./session-cleanup-BtkSmry8.js";
-import { a as registerDisposer, c as WAKE_CATCH_UP_MS, i as registerCroTurnTracking, l as addWake, n as sendToTrajectory, o as CRO_FILENAME, r as wakeSchedulerState, s as buildCroSnapshot, t as registerWakeScheduler, u as listWakes } from "./wake-scheduler-BR4hD8Vj.js";
 import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-CtFYm53S.js";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
@@ -2085,7 +2083,9 @@ function truncateContent(content, maxChars) {
 */
 /** 全文注入总长上限（字符数；规格 §3「缺省 32 KB」——防上下文爆炸） */
 const TRAJECTORY_SKILLS_MAX_CHARS = 32768;
-/** 缺失标记（规格 §3/§6-3 的验收锚点：任何"拿不到全文"的情况都必须带它，绝不静默） */
+/** 缺失标记（规格 §3/§6-3 的验收锚点：任何"拿不到全文"的情况都必须带它，绝不静默）
+*  🔴 2026-09-25（S142 分批清死代码·第 1 批）：**降为模块内常量**——全仓唯一消费者在本文件，
+*  导出只服务测试（测试用的是字面量 `'[缺失]'`）⇒ 导出面无意义。 */
 const SKILL_MISSING_MARK = "[缺失]";
 /** 统一缺失提示（规格 §3 逐字约定：`[缺失] <name>（未找到该 skill）`） */
 function missingNotice(name) {
@@ -3298,14 +3298,22 @@ function sessionBlock(root, scope = DEFAULT_SESSION_SCOPE) {
 		`Active session: ${active.sessionId} — ${active.dirName} (this session is the rebuildable carrier of the trajectory)`,
 		`SESSION.md path: ${active.mdPath} (the trajectory's persistent body — stays in place through rebuilds)`,
 		"",
-		"Rules:",
-		"  • Record all progress into this SESSION.md",
-		"  • Update the \"进度记录\" section after advancing work",
+		"Rules (SESSION.md is the trajectory log — keep its format & granularity fixed):",
+		"  • Write only when a MILESTONE landed or a DECISION was made — not every round",
+		"  • One entry = one abstraction level, at the highest one that can express it:",
+		"    identity/anchors (rare) › decision (one line + rationale/rejected) › milestone",
+		"    (one line + an evidence pointer, e.g. a commit id). Execution detail — test",
+		"    counts, coverage decimals, per-file readings, step narration — belongs in the",
+		"    COMMIT MESSAGE, not here",
+		"  • Never write a value that changes by the act of writing it (file size; the hash",
+		"    of the commit containing this edit)",
+		"  • Fixed sections, in this order: 身份与边界 / 权威锚点 / 工作纪律 / 决策 / 日志 /",
+		"    当前状态 / 待 owner 裁决.  The 日志 section appends only; 当前状态 and",
+		"    待 owner 裁决 are OVERWRITTEN each round",
 		"  • Reference this session in all subsequent messages",
 		"",
-		"IMPORTANT: Read SESSION.md now. Parse the \"剩余工作\" / \"进度记录\" /",
-		"\"变更日志\" sections and call todowrite to synchronize the built-in todo",
-		"list. Keep todos in sync with SESSION.md as work progresses.",
+		"IMPORTANT: Read SESSION.md now to RESUME — not to audit. Sync the todo list from",
+		"the 当前状态 and 待 owner 裁决 sections only.",
 		"",
 		"CRITICAL: When calling todowrite, the first item in the todos array MUST",
 		"always be:",
@@ -3569,7 +3577,9 @@ function workspaceTrajectoryLine(mdPath) {
 		"  2. Record key decisions/progress/unresolved items INTO this SESSION.md using the write channel",
 		"     your role is actually granted (use whatever write tool or MSM this role has — never assume",
 		"     a specific write tool exists; if none is granted, report that instead of pretending to write).",
-		"     Sections: 目标 / 状态 / 关键决策 / 进度记录 / 未解决的问题. Keep it current — it is",
+		"     Sections: 身份与边界 / 权威锚点 / 工作纪律 / 决策 / 日志 / 当前状态 / 待 owner 裁决.",
+		"     Keep entries at milestone level (one line + evidence pointer); execution detail",
+		"     belongs in commit messages. Keep it current — it is",
 		"     what a rebuild resumes from.",
 		"  3. When context pressure is high, run container_trajectory rebuild — it auto-resumes from THIS SESSION.md",
 		"     (no manual use; do not switch to or read other SESSIONs unless the user explicitly asks).",
@@ -4651,6 +4661,2095 @@ function createHandymanTool(ctx) {
 	});
 }
 //#endregion
+//#region src/session-cleanup.ts
+/**
+* session-cleanup.ts — DSH 平台旧会话自动清理（v1.29，S142 需求③）
+*
+* 背景（实证）：DSH 会话物理存储 = `$DSH_HOME/sessions/`（缺省 ~/.dsh/sessions；
+* base bundle cordis.patch.yml root: dshHomePath('sessions')）。磁盘布局：
+*   <root>/--<project-slug>--/<encoded-session-id>/session[.vN].jsonl(.zstd)
+* **世代（v1.31.13 补）**：宿主自 DSH 0.1.5 起按世代写文件，且迁移**保留源文件**
+* ⇒ 一个会话目录常见 v0 与 v3 两个文件并存。本模块用 `sessionLogArtifacts()` 统一枚举世代。
+* DSH **无删除会话 API**（PersistenceCoordinator 仅 create/append/load/inspect/borrow，
+* 无 delete/purge；workspace archiveSession 只加归档集不删文件）——物理删除只能直接
+* 删文件。删除后一致性（利好）：sessionPersistence.list() = readdir 扫描磁盘现存 →
+* 物理删后 list 不再返回；WorkspaceRegistry 下次启动重建 header index 自动消失。
+*
+* 方案（S142 用户拍板）：lastActive 基准 + 手动触发 + 不过滤不归档直接物理删；
+* 安全底线 = live 会话保护跳过（删正在运行的会话 = 灾难）。
+*
+* 本模块纯逻辑（零 ctx 依赖）：传入 sessionsRoot + liveIds，可单测。
+*/
+var session_cleanup_exports = /* @__PURE__ */ __exportAll({
+	collectEligibleSessions: () => collectEligibleSessions,
+	cutoffDaysAgo: () => cutoffDaysAgo,
+	findSessionLog: () => findSessionLog,
+	hasSessionLogById: () => hasSessionLogById,
+	performCleanup: () => performCleanup,
+	sessionLogArtifacts: () => sessionLogArtifacts,
+	sessionLogBytesById: () => sessionLogBytesById,
+	sessionsRootDir: () => sessionsRootDir
+});
+/** DSH 会话 root：env DSH_HOME → ~/.dsh（config-ops globalConfigPath 同款推导） */
+function sessionsRootDir() {
+	const dshHome = process.env.DSH_HOME ?? join(process.env.HOME ?? "", ".dsh");
+	return join(dshHome, "sessions");
+}
+/** 一天的毫秒数 */
+const DAY_MS = 864e5;
+/**
+* 扫描 sessions root，列出可清理候选：
+* - 递归 `<root>/<project>/<session-id>/session.jsonl(.zstd)`（任意深度下找 *session* 文件）
+* - 过滤 live（liveIds 集合）——安全底线
+* - 过滤 lastActive >= cutoffMs（最后活动未达阈值 → 保留）
+* root 不存在/为空 → 返回 []（非错误）。
+*/
+function collectEligibleSessions(root, cutoffMs, liveIds = /* @__PURE__ */ new Set()) {
+	if (!existsSync(root)) return [];
+	const out = [];
+	for (const project of readdirSync(root, { withFileTypes: true })) {
+		if (!project.isDirectory()) continue;
+		const projectPath = join(root, project.name);
+		for (const entry of readdirSync(projectPath, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const dirPath = join(projectPath, entry.name);
+			const artifacts = sessionLogArtifacts(dirPath);
+			if (artifacts.length === 0) continue;
+			const log = findSessionLog(dirPath);
+			if (log === null) continue;
+			if (liveIds.has(entry.name)) continue;
+			let mtime = Number.NEGATIVE_INFINITY;
+			for (const artifact of artifacts) try {
+				mtime = Math.max(mtime, statSync(artifact.path).mtimeMs);
+			} catch {}
+			if (!Number.isFinite(mtime)) continue;
+			if (mtime >= cutoffMs) continue;
+			out.push({
+				id: entry.name,
+				project: project.name,
+				logPath: log,
+				lastActiveMs: mtime
+			});
+		}
+	}
+	return out;
+}
+/**
+* 会话日志文件名识别：`session.jsonl` / `session.jsonl.zstd`（= **v0 世代**）/
+* `session.v<N>.jsonl[.zstd]`（= 第 N 世代，DSH 0.1.5 起按世代写文件）。
+* 出处：`@deepseek-ai/dsh-session-persistence-jsonl` 的 `parseSessionFormatLogFilename` 同款形态。
+*/
+const SESSION_LOG_RE = /^session(?:\.v(\d+))?\.jsonl(\.zstd)?$/;
+/**
+* 列出会话目录下的**全部日志世代**，按代递增排序（同代内 `.jsonl` 在前、`.zstd` 在后 = 后者更代表"当前书写格式"）。
+*
+* 为什么需要（R↓，v1.31.13 修复）：宿主自 0.1.5 起改成**按世代写文件**，且迁移**保留源文件**
+* ⇒ 同一会话常见 `session.jsonl.zstd`（v0）与 `session.v3.jsonl.zstd`（v3）**并存**。
+* 旧实现只认前两个名字 → 新格式会话对本模块**完全不可见**（静默 no-op：清理永远不生效、磁盘只涨）。
+*/
+function sessionLogArtifacts(sessionDirPath) {
+	let names;
+	try {
+		names = readdirSync(sessionDirPath);
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const name of names) {
+		const m = SESSION_LOG_RE.exec(name);
+		if (m === null) continue;
+		out.push({
+			name,
+			generation: m[1] === void 0 ? 0 : Number(m[1]),
+			path: join(sessionDirPath, name)
+		});
+	}
+	return out.sort((a, b) => a.generation - b.generation || (a.name.endsWith(".zstd") ? 1 : 0) - (b.name.endsWith(".zstd") ? 1 : 0));
+}
+/**
+* 在会话目录下找 session 日志文件；无 → null。
+* 多世代并存时返回**最高世代**（= 宿主 `findLog` 选中的当前世代；旧行为对单文件目录完全一致）。
+*/
+function findSessionLog(sessionDirPath) {
+	const artifacts = sessionLogArtifacts(sessionDirPath);
+	const latest = artifacts[artifacts.length - 1];
+	return latest === void 0 ? null : latest.path;
+}
+/**
+* 执行清理（用户拍板：直接物理删，不过滤不归档；dryRun 预览不删）。
+* 删除 = rmSync 整个会话目录（recursive + force）。失败逐个记 errors 不中断。
+*/
+function performCleanup(root, cutoffMs, liveIds = /* @__PURE__ */ new Set(), opts = {}) {
+	const candidates = collectEligibleSessions(root, cutoffMs, liveIds);
+	if (opts.dryRun) return {
+		candidates,
+		result: null
+	};
+	const result = {
+		deleted: [],
+		errors: []
+	};
+	for (const c of candidates) {
+		const dir = dirOf(c.logPath);
+		try {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
+			result.deleted.push(c.id);
+		} catch (e) {
+			result.errors.push({
+				id: c.id,
+				reason: e.message
+			});
+		}
+	}
+	return {
+		candidates,
+		result
+	};
+}
+/** 从日志路径取会话目录（父目录） */
+function dirOf(logPath) {
+	return logPath.slice(0, logPath.lastIndexOf("/")) || logPath;
+}
+/**
+* 某一 dsh 会话（目录名 / 会话 id）的**当前世代日志体积**（字节）。
+*
+* 为什么要它（S142 §0y「旧会话累积 ⇒ dsh 内存崩溃」，所有者令）：
+*   · 宿主恢复/继续一条会话必须**重放全部事件**（`scanLog` → `materializeAppendBatch`）
+*     ⇒ **代价 ∝ 日志体积**；
+*   · 实测（`_tmp/measure-session-load.mjs`，照宿主 `scanZstdFrames` 复刻）：
+*     一条 **72.2 MB**（zstd）的日志 = 35 559 个 frame / 252.6 MB 文本 / 62 680 条事件，
+*     **光是读一遍峰值 RSS +1 175 MB**（探针什么都不保留）；
+*   · 而宿主的解析缓存 `COLD_LOG_MEMO_MAX_ENTRIES = 2` 是**按条数限、不按字节限**的
+*     （`dsh-session-persistence-jsonl/lib/index.js:2175`）⇒ 两条巨日志 = 上限内。
+* 🔴 **在本函数之前，ACC 侧没有任何地方知道"绑定的这条会话日志多大"——这个信号根本不存在。**
+* 这是"靠 agent 自觉 rebuild 不够"的机制层原因（keeper 的 K 量的是**模型上下文**，压缩后回落；
+* 而**日志文件只增不减** ⇒ rebuild 提醒永远不会因为"日志 72 MB"触发）。
+*
+* 只认会话目录（含任意世代日志）；返回**最高世代**的日志（= 宿主 `findLog` 选中的当前世代）。
+* 未命中 / 不可读 → null（非错误，调用方按"未知"处理）。
+* @param root - DSH 会话 root（{@link sessionsRootDir}）
+* @param sessionId - 会话目录名（`.bindings.json` 的键，含 `session-` 前缀）或裸 id
+* @returns 字节数 + 日志绝对路径；未命中 → null
+*/
+function sessionLogBytesById(root, sessionId) {
+	if (sessionId === "" || !existsSync(root)) return null;
+	const dirName = sessionId.startsWith("session-") ? sessionId : `session-${sessionId}`;
+	for (const project of readdirSync(root, { withFileTypes: true })) {
+		if (!project.isDirectory()) continue;
+		const log = findSessionLog(join(root, project.name, dirName));
+		if (log === null) continue;
+		try {
+			return {
+				bytes: statSync(log).size,
+				path: log
+			};
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+/**
+* **(c) 绑定一致性兜底**的判据：某会话的日志**是否仍在磁盘上**。
+*
+* 🔴 **fail-closed**：sessions root 本身不存在时**一律返回 true（当作"在"）**——
+* 否则换 `DSH_HOME` / 换机器会让"全部绑定看起来都悬空"，进而误清整张绑定表。
+* 只有"root 在、而这个会话目录确实不在"才算悬空。
+* @param sessionRoot - DSH 会话 root（{@link sessionsRootDir}）
+* @param sessionId - 会话目录名（`.bindings.json` 的键）或裸 id
+*/
+function hasSessionLogById(sessionRoot, sessionId) {
+	if (!existsSync(sessionRoot)) return true;
+	return sessionLogBytesById(sessionRoot, sessionId) !== null;
+}
+/** 便捷：默认 N 天前为 cutoff（供 API/调用方） */
+function cutoffDaysAgo(days, nowMs = Date.now()) {
+	return nowMs - days * DAY_MS;
+}
+//#endregion
+//#region src/wake-registry.ts
+/**
+* wake-registry.ts — trajectory 唤醒注册表（D58，S142 2026-09-13）
+*
+* 需求（用户原话）：一个 CCC 内允许多个 trajectory 任意形态并行；某个 trajectory 可以
+* **预定未来唤醒自己或别人**，本质上是一次「未来时刻 + 一条 message」的投递；「周期自唤醒」
+* 曾是它的特例（原 ACC autopilot / D59，该机制已于 2026-09-15 整段退场）。协作边界：
+* 互相可见、**无阻塞无等待**。
+*
+* 本模块只负责**注册表本身**（纯数据层，无宿主依赖，可单测）：
+*  - 落点：CCC 内 `AGENT_SESSIONS/wake-registry.json`（随 CCC git，人可读可审计）
+*  - 状态机：`pending` →（投递成功）`delivered`｜（超补跑窗口）`missed`｜（`wake rm` 物理移除）
+*  - 投递即终结：一次性，不重投（无回执语义——发起方不 await，见设计文档 §2）
+*
+* 调度与投递在 `wake-scheduler.ts`（需要 ctx），本模块保持纯净。
+*/
+/** 注册表相对 CCC 根的路径（与 `.bindings.json` 同居 AGENT_SESSIONS/） */
+const WAKE_REGISTRY_REL_PATH = "AGENT_SESSIONS/wake-registry.json";
+/** 注册表格式版本（结构变更时 +1；读取端只接受本版本） */
+const WAKE_REGISTRY_VERSION = 1;
+/**
+* 补跑窗口（缺省 2h）：dsh 停机期间到期的条目，若迟到不超过本窗口则补投，
+* 超过则置 `missed` 留痕（不补投——避免"半夜该做的事早上突然连环跑"）。
+*/
+const WAKE_CATCH_UP_MS = 72e5;
+/** 注册表绝对路径 */
+function wakeRegistryPath(root) {
+	return join(root, WAKE_REGISTRY_REL_PATH);
+}
+/** 空注册表 */
+function emptyRegistry() {
+	return {
+		version: WAKE_REGISTRY_VERSION,
+		entries: []
+	};
+}
+/** 条目形状校验（容忍手改：字段缺失/类型不符 → 丢弃该条，不阻断整表） */
+function asEntry$2(value) {
+	const e = value;
+	if (!e || typeof e.id !== "string" || typeof e.target !== "string") return null;
+	if (typeof e.at !== "string" || typeof e.message !== "string") return null;
+	const state = e.state === "delivered" || e.state === "missed" || e.state === "cancelled" ? e.state : "pending";
+	return {
+		id: e.id,
+		target: e.target,
+		at: e.at,
+		message: e.message,
+		state,
+		createdBy: typeof e.createdBy === "string" ? e.createdBy : "",
+		createdAt: typeof e.createdAt === "string" ? e.createdAt : "",
+		attempts: typeof e.attempts === "number" && Number.isFinite(e.attempts) ? e.attempts : 0,
+		lastResult: typeof e.lastResult === "string" ? e.lastResult : null,
+		deliveredAt: typeof e.deliveredAt === "string" ? e.deliveredAt : null
+	};
+}
+/**
+* 读注册表。文件缺失 → 空表；损坏 → 空表 + error（不抛错，调用方决定是否告警）。
+* @param root CCC 根
+* @returns 注册表与读取错误（无错为 null）
+*/
+function loadWakeRegistry(root) {
+	const path = wakeRegistryPath(root);
+	if (!existsSync(path)) return {
+		registry: emptyRegistry(),
+		error: null
+	};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
+		const entries = [];
+		for (const item of raw) {
+			const e = asEntry$2(item);
+			if (e) entries.push(e);
+		}
+		return {
+			registry: {
+				version: WAKE_REGISTRY_VERSION,
+				entries
+			},
+			error: null
+		};
+	} catch (err) {
+		return {
+			registry: emptyRegistry(),
+			error: `唤醒注册表解析失败（${String(err?.message ?? err)}）`
+		};
+	}
+}
+/** 原子写（tmp + rename；与 .bindings.json 同款形态） */
+function saveWakeRegistry(root, registry) {
+	const path = wakeRegistryPath(root);
+	try {
+		mkdirSync(dirname(path), { recursive: true });
+		const tmp = `${path}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify({
+			version: WAKE_REGISTRY_VERSION,
+			entries: registry.entries
+		}, null, 2)}\n`, "utf-8");
+		renameSync(tmp, path);
+		return {
+			ok: true,
+			error: null
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: `唤醒注册表写入失败（${String(err?.message ?? err)}）`
+		};
+	}
+}
+/** 条目 id：`w-<当地到分钟>-<4 hex>`（可读 + 低碰撞；不复用由"物理移除"保证） */
+function newWakeId(nowMs, rand = Math.random) {
+	return `w-${localIdStamp(nowMs)}-${Math.floor(rand() * 65536).toString(16).padStart(4, "0")}`;
+}
+/**
+* 解析唤醒时刻。接受两种写法（设计文档 §7）：
+*  - 绝对：RFC3339（含时区偏移，如 `2026-09-14T09:00:00+08:00`）
+*  - 相对：`+30m` / `+2h`（便于 agent 直接登记"半小时后"）
+* @param input 用户/agent 传入的时刻串
+* @param nowMs 当前时刻（相对写法基准）
+* @returns `{ ok, ms }` 或 `{ ok: false, error }`
+*/
+function parseWakeAt(input, nowMs) {
+	const raw = input.trim();
+	if (raw === "") return {
+		ok: false,
+		error: "时刻为空"
+	};
+	const rel = /^\+(\d+(?:\.\d+)?)([mhd])$/.exec(raw);
+	if (rel) {
+		const n = Number(rel[1]);
+		const unit = rel[2];
+		return {
+			ok: true,
+			ms: nowMs + n * (unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5)
+		};
+	}
+	const ms = Date.parse(raw);
+	if (!Number.isFinite(ms)) return {
+		ok: false,
+		error: `时刻无法解析（须 RFC3339 或 +30m/+2h）: ${raw}`
+	};
+	return {
+		ok: true,
+		ms
+	};
+}
+/**
+* 登记一条唤醒。
+* @param root CCC 根
+* @param input 目标 trajectory / 时刻串 / message / 发起者 / 当前时刻
+* @returns 成功返回条目，失败返回稳定错误文案（不抛错）
+*/
+function addWake(root, input) {
+	const target = input.target.trim();
+	if (target === "") return {
+		ok: false,
+		error: "target 为空（须 S### 或 AGENT_SESSIONS 目录名）"
+	};
+	const message = input.message.trim();
+	if (message === "") return {
+		ok: false,
+		error: "message 为空（唤醒必须携带一条信息）"
+	};
+	const parsed = parseWakeAt(input.at, input.nowMs);
+	if (!parsed.ok) return {
+		ok: false,
+		error: parsed.error
+	};
+	if (parsed.ms <= input.nowMs) return {
+		ok: false,
+		error: "时刻必须在未来（唤醒只允许可预期的未来）"
+	};
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error
+	};
+	const entry = {
+		id: newWakeId(input.nowMs),
+		target,
+		at: isoLocal(parsed.ms),
+		message,
+		state: "pending",
+		createdBy: input.createdBy,
+		createdAt: isoLocal(input.nowMs),
+		attempts: 0,
+		lastResult: null,
+		deliveredAt: null
+	};
+	registry.entries.push(entry);
+	const saved = saveWakeRegistry(root, registry);
+	if (!saved.ok) return {
+		ok: false,
+		error: saved.error ?? "写入失败"
+	};
+	return {
+		ok: true,
+		entry
+	};
+}
+/**
+* 到期切分（纯函数，可单测）：
+*  - `due`：`state === 'pending'` 且 `now >= at`（在补跑窗口内）→ 应投递
+*  - `expired`：`state === 'pending'` 且 `now - at > catchUpMs` → 应置 missed（不投递）
+* @param registry 注册表
+* @param nowMs 当前时刻
+* @param catchUpMs 补跑窗口
+*/
+function splitDueWakes(registry, nowMs, catchUpMs = WAKE_CATCH_UP_MS) {
+	const due = [];
+	const expired = [];
+	for (const e of registry.entries) {
+		if (e.state !== "pending") continue;
+		const at = Date.parse(e.at);
+		if (!Number.isFinite(at) || nowMs < at) continue;
+		if (nowMs - at > catchUpMs) expired.push(e);
+		else due.push(e);
+	}
+	return {
+		due,
+		expired
+	};
+}
+/**
+* 🔴 结案并**移除**一条（owner 2026-09-19 裁定「**直接删**」，S142 §0Q 甲案）。
+*
+* ## 为什么删（R↓）
+*
+* 本模块原本是「`pending` → 终态」但**终态条目永不移除** ⇒ 文件**只增**（实测 308 KB / 143+ 条）。
+* owner 明令「应当**唤醒后就清理**的」⇒ 终态即删。
+*
+* **审计不丢**：由 **SESSION.md 与工具输出**承担——这正是本文件 `removeWake` 的既有注释承诺
+* （*"审计由 SESSION.md 与工具输出承担——注册表只保留在办项"*）。
+* ⚠️ 此前该承诺**并未兑现**（`updateWake` 只改 state 从不删行）⇒ 本次是**把承诺做实**。
+*
+* ## 与 `updateWake` 的分工（**别混用**）
+*
+* - `updateWake`：**仍在办**的推进（失败重试 `state:'pending'` + `attempts+1`）⇒ **保留行**；
+* - `finalizeWake`：**不再办**的归宿（投递成功 / 超窗 missed）⇒ 写终态后**同一笔事务里删掉**。
+*
+* 🔴 **为什么两个动作要同一次写盘**：若先 `updateWake(delivered)` 再 `removeWake`，
+* 中间被打断会留下一条"已终结但没删"的条目 ⇒ 又回到只增。
+* 故本函数**读一次、改一次、删一次、写一次**（单次原子落盘）。
+*
+* @param root CCC 根
+* @param id 条目 id
+* @param terminal 终态（`delivered` / `missed` / `cancelled`）——写入仅用于**日志文案**，
+*                 随即整行移除；保留该参数是为了让调用点语义自明（"它归到哪一档了"）。
+* @param result 人读结果（进日志，不进表）
+* @returns `removed` = 被移除的条目（供调用方打印"它是什么"）；不存在 → 稳定错误码
+*/
+function finalizeWake(root, id, terminal, result) {
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error,
+		removed: null
+	};
+	const idx = registry.entries.findIndex((e) => e.id === id);
+	if (idx < 0) return {
+		ok: false,
+		error: `wake_not_found: ${id}`,
+		removed: null
+	};
+	const [removed] = registry.entries.splice(idx, 1);
+	const saved = saveWakeRegistry(root, registry);
+	if (!saved.ok) return {
+		ok: false,
+		error: saved.error,
+		removed: null
+	};
+	return {
+		ok: true,
+		error: null,
+		removed: {
+			...removed,
+			state: terminal,
+			lastResult: result
+		}
+	};
+}
+/**
+* 一次性清除**存量终态条目**（`delivered` / `missed` / `cancelled`）。
+*
+* ## 为什么需要（不是可选）
+*
+* 本函数上线前，表里已积压 143+ 条终态记录（308 KB）⇒ **只改行为不改存量 = 文件不再涨但仍很大**。
+* 故首次运行须清一次。**幂等**（无终态条目时空转，不写盘）。
+*
+* 审计不丢：与 `finalizeWake` 同理（终态本就属性"已结案"，其史由 SESSION.md 承担）。
+* @param root CCC 根
+* @returns 清掉几条（0 = 本来就没有）
+*/
+function purgeFinalizedWakes(root) {
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error,
+		purged: 0
+	};
+	const kept = registry.entries.filter((e) => e.state === "pending");
+	const purged = registry.entries.length - kept.length;
+	if (purged === 0) return {
+		ok: true,
+		error: null,
+		purged: 0
+	};
+	const saved = saveWakeRegistry(root, {
+		...registry,
+		entries: kept
+	});
+	if (!saved.ok) return {
+		ok: false,
+		error: saved.error,
+		purged: 0
+	};
+	return {
+		ok: true,
+		error: null,
+		purged
+	};
+}
+/**
+* 更新一条（状态推进；调用方给最终状态与结果文案）。
+*
+* ⚠️ **只用于"仍在办"的推进**（主要是失败重试）。**终态请用 `finalizeWake`**——
+* 否则该行会永远留下（这正是本表过去只增的根因，见 `finalizeWake` 注释）。
+* @param root CCC 根
+* @param id 条目 id
+* @param patch 要写入的字段
+* @returns 写入结果
+*/
+function updateWake(root, id, patch) {
+	const { registry, error } = loadWakeRegistry(root);
+	if (error) return {
+		ok: false,
+		error
+	};
+	const entry = registry.entries.find((e) => e.id === id);
+	if (!entry) return {
+		ok: false,
+		error: `wake_not_found: ${id}`
+	};
+	Object.assign(entry, patch);
+	return saveWakeRegistry(root, registry);
+}
+/** 列条目（默认全量；`pendingOnly` 只列在办项——面板/工具用） */
+function listWakes(root, opts = {}) {
+	const { registry, error } = loadWakeRegistry(root);
+	return {
+		entries: [...opts.pendingOnly ? registry.entries.filter((e) => e.state === "pending") : registry.entries].sort((a, b) => Date.parse(a.at) - Date.parse(b.at)),
+		error
+	};
+}
+//#endregion
+//#region src/cro.ts
+/**
+* cro.ts — CRO（Continuous Re-Occurrence · 持续再发生）机制层（S142 §7.8，2026-09-19）
+*
+* ## 这东西用来干什么（白话）
+*
+* 今天叫醒一条轨迹的方式是「几点几分叫我」。但**该不该醒，往往不是时间说了算**：
+* 比如 S185 应该「天亮 + 家里有人 + 非高峰」才醒；已经在干活就不该再叫；
+* 日志太大了，下次叫它时该让它先整理。
+*
+* CRO 让**一条轨迹自己带一段程序**，由 ACC 在每次检查时跑它，
+* **由这段程序决定「现在该不该叫我、叫我的时候说什么」**。
+*
+* ## 归属（所有者 2026-09-19 定：**机制属 ACC，CCC 是用户**）
+*
+* | 面 | 归谁 | 内容 |
+* |---|---|---|
+* | **机制** | 🔴 **ACC（本模块）** | 契约 / 调度 / 执行 / 状态暴露 / 容错 |
+* | **程序** | 🔴 **CCC（用户）** | 那段判定的 TS 代码，放**轨迹自己的目录**里 |
+*
+* ⇒ 与 `send-later` 同构：**工具在 ACC，用它在 CCC**。
+*
+* ## 命名（防混淆，写死）
+*
+* **`CRO` = 那段程序**（实体名），**不是** ACC 标准 §0.1 三环节（发生/存储/**再发生**）的第三环本身。
+* 命名来源 = §0.3「**Trajectory 在寻找 Agent**」——CRO 是「再发生」这一环的自动化。
+*
+* ## 位置与形态（设计 §2）
+*
+* `<CCC 根>/AGENT_SESSIONS/<轨迹目录>/continuous-re-occurrence.ts`
+* · **文件名全写**（所有者令）；· **程序只有一个**：**文件在 = 启用，不在 = 禁用**（无 enabled 字段、无注册表）。
+*
+* ## 🔴 运行契约 = B 案（**ACC 只 spawn，从不 import**）
+*
+* 所有者 2026-09-19：「**B 是设计，A 只是文档友好**」。
+* 若 ACC **import** 那段 TS，会出现两件事：
+*   ① ACC 依赖 CCC 的**源码路径**（npm 装机版在别处 ⇒ 两条路径都要活 = 两个真相源）；
+*   ② **用户程序语法错会让 ACC 启动失败** ⇒ **一个用户程序的错误放倒整个容器**。
+* ⇒ 进程边界把这两件事同时挡掉：**路径只需一个（文件系统），错误被隔离在子进程里**。
+*
+* ## 🔴 铁律：CRO 的任何失败，绝不影响既有机制（设计 §5）
+*
+* `send-later` / `send-now` / 唤醒表的投递**照常工作**。
+* 先例 = `weixin-hook.ts` 的**旁路容忍**（"超时 kill / 非 0 退出 / spawn 失败 → 仅日志返回，绝不抛"）。
+* ⇒ 本模块的**每一个**导出函数**都不抛错**（返回结构化失败）。
+*/
+/** 入口文件名（**全写**，所有者令 2026-09-19；不改缩写） */
+const CRO_FILENAME = "continuous-re-occurrence.ts";
+/** 硬超时（沿用 `biasProvider` 先例的 60s；设计 §5 情形 2） */
+const CRO_TIMEOUT_MS = 6e4;
+/** stdout 上限（防一个坏程序把日志撑爆；沿用 hook 截断思路） */
+const CRO_STDOUT_MAX = 65536;
+/** SESSION.md 文件名（与 `trajectory-ops.ts` 同值；此处本地常量避免反向依赖） */
+const SESSION_MD = "SESSION.md";
+/**
+* 展示码派生（**只用于展示**，不作识别依据 —— §0I U4：锚永远是 `dirName`）。
+*
+* 判据（设计 §1）：**编号不是固定格式，不同 CCC 格式不同**（本容器 `S###`，别处可能是 issue 号
+* 或自定义前缀）⇒ 这里只做**尽力而为的展示性提取**，取不到就返回空串。
+* 🔴 **绝不**因为取不到就拒绝服务——`dirName` 才是硬锚。
+* @param dirName 轨迹目录名
+* @returns `S###` 形态的展示码；取不到 ⇒ `''`
+*/
+function deriveCode(dirName) {
+	const m = /(?:^|--)S(\d{2,})(?:--|$)/.exec(dirName);
+	return m ? `S${m[1]}` : "";
+}
+/** epoch ms → 当地 ISO（不可解析 ⇒ null） */
+function isoOrNull(ms) {
+	return typeof ms === "number" && Number.isFinite(ms) ? isoLocal(ms) : null;
+}
+/**
+* 装配快照（**纯函数**：只做数据整形，不读 fs、不看 ctx）⇒ 可穷举测试。
+* @param input 已读好的原始数据
+* @returns 喂给 CRO 程序的快照
+*/
+function buildCroSnapshot(input) {
+	return {
+		version: 1,
+		identity: {
+			dirName: input.dirName,
+			code: deriveCode(input.dirName),
+			cccRoot: input.cccRoot
+		},
+		time: {
+			now: isoLocal(input.nowMs),
+			nowMs: input.nowMs,
+			nowLocal: new Date(input.nowMs).toString()
+		},
+		body: {
+			sessionMdPath: input.sessionMdPath,
+			sessionMdBytes: input.sessionMdBytes,
+			sessionMdMtime: isoOrNull(input.sessionMdMtimeMs),
+			references: input.references.map((r) => ({
+				name: r.name,
+				bytes: r.bytes,
+				mtime: isoLocal(r.mtimeMs)
+			}))
+		},
+		binding: {
+			boundSessionIds: input.boundSessionIds,
+			liveSessionIds: input.liveSessionIds,
+			runningSessionIds: input.runningSessionIds
+		},
+		scheduling: {
+			pendingWakes: input.pendingWakes,
+			scheduler: input.scheduler
+		}
+	};
+}
+/**
+* 解析 CRO 程序 stdout（**纯函数** ⇒ 可穷举测试）。
+*
+* ## 边界（设计 §4.1）
+* · `wake` 缺省 / `false` ⇒ **不唤起**（**这是常态**）——`prompt` 可省；
+* · `wake: true` 但 `prompt` 空 / 非串 ⇒ 🔴 **非法** ⇒ 返回错误（调用方**跳过本轮**，不投递空消息）；
+* · 非 JSON / 非对象 ⇒ 错误。
+*
+* ## 🔴 为什么 `reason` 重要（CCE：重建 > 保存）
+* 改成程序判定后，**「当时为什么叫了」不再能从时间表重建**（原因在程序肚子里：
+* 可能有随机、可能看了外部数据）⇒ 要求程序自报理由，把「决策依据」重新变成**可重建的**。
+* ⇒ **强烈建议但不强制**（强制会让简单程序难写；设计 §9-6 待裁，本版取"建议"）。
+*
+* @param stdout 程序标准输出（可含前后空白；允许多行 JSON 文本）
+* @returns 决策 或 结构化错误
+*/
+function parseCroOutput(stdout) {
+	const text = stdout.trim();
+	if (text === "") return {
+		ok: false,
+		error: "cro-empty-output",
+		detail: "程序没有输出（期望 stdout 一行 JSON）"
+	};
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch (err) {
+		return {
+			ok: false,
+			error: "cro-bad-json",
+			detail: `输出不是合法 JSON: ${String(err?.message ?? err)}`
+		};
+	}
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {
+		ok: false,
+		error: "cro-bad-json",
+		detail: "输出必须是 JSON 对象"
+	};
+	const obj = raw;
+	const wake = obj.wake === true;
+	const reason = typeof obj.reason === "string" && obj.reason.trim() !== "" ? obj.reason.trim() : null;
+	if (!wake) return {
+		ok: true,
+		decision: {
+			wake: false,
+			prompt: null,
+			reason
+		}
+	};
+	if (typeof obj.prompt !== "string" || obj.prompt.trim() === "") return {
+		ok: false,
+		error: "cro-missing-prompt",
+		detail: "wake=true 但 prompt 缺失或为空"
+	};
+	return {
+		ok: true,
+		decision: {
+			wake: true,
+			prompt: obj.prompt.trim(),
+			reason
+		}
+	};
+}
+/**
+* CRO 程序路径：`<CCC 根>/AGENT_SESSIONS/<dirName>/continuous-re-occurrence.ts`。
+*
+* ⚠️ 路径逃逸校验（`resolveInside`）：`dirName` 来自配置/工具入参，
+* 必须确保解析后仍在 CCC 根内（同 `weixin-hook.ts:160` 手法）。**抛错由调用方吞**。
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @returns 绝对路径
+*/
+function croScriptPath(root, dirName) {
+	return resolveInside(root, join("AGENT_SESSIONS", dirName, CRO_FILENAME));
+}
+/**
+* 列出**启用了 CRO 的轨迹目录名**（供调度器每 tick 扫描，设计 §6.1）。
+*
+* ## 判据与形态（R↓）
+* · 判据 = **文件在不在**（同 §2.1）——**没有注册表**，所以"谁启用了"只能靠**扫目录**：
+*   `AGENT_SESSIONS/` 下每个目录查一次 `<目录>/continuous-re-occurrence.ts`。
+* · **一次 readdir + 每个目录一次 existsSync**：N 条轨迹的代价是 O(N) 次 `stat`，
+*   每 5min 一次 —— 与既有 `listSessions` 同量级，可接受。
+* · 跳过 **`_` 前缀**（`_archived` / `_skiff-logs` / `_weixin-logs` = 系统与日志目录）
+*   与 **`.` 前缀**（隐藏）——它们**不是轨迹**，且扫它们纯属浪费。
+* · 🔴 **本函数绝不抛错**（返回 `[]`）——它跑在调度器 tick 内，任何异常都可能影响既有链路
+*   （设计 §5 铁律）。目录读不到（不存在 / 权限）⇒ `[]` = "没有轨迹启用 CRO"，语义正确。
+*
+* ⚠️ **为什么不做缓存**：缓存会引入"文件删了但缓存还在"的失效模式（本容器栽过的"第二真相源"），
+* 而这里省下的只是一次 `readdir`——**不值当**。
+*
+* @param root CCC 根
+* @returns 启用了 CRO 的轨迹目录名（**排序后**，保证同 tick 顺序稳定、便于日志比对）
+*/
+function listCroTrajectories(root) {
+	const rootDir = sessionsRoot(root);
+	let entries;
+	try {
+		entries = readdirSync(rootDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const e of entries) {
+		if (!e.isDirectory()) continue;
+		if (e.name.startsWith("_") || e.name.startsWith(".")) continue;
+		try {
+			if (existsSync(join(rootDir, e.name, "continuous-re-occurrence.ts"))) out.push(e.name);
+		} catch {}
+	}
+	return out.sort();
+}
+/**
+* 执行一次 CRO 程序（**永不抛** —— 旁路容忍铁律）。
+*
+* runner 顺序（照 `weixin-hook.ts:171-174` 的 bun 优先 / node 兜底）：
+* `bun` → `process.execPath`（同运行时）。
+* 判据：`ENOENT`（二进制不存在）⇒ 试下一个；**其余失败视为最终结果**
+* （程序自己报错就是报错，不该用另一个 runner 掩盖——与 hook 一致）。
+* @param scriptAbs 程序绝对路径
+* @param stdinJson 喂给程序的快照 JSON
+* @param timeoutMs 硬超时
+* @returns 执行结果（含输出的解析交由 `parseCroOutput`）
+*/
+async function runCroProcess(scriptAbs, stdinJson, timeoutMs = CRO_TIMEOUT_MS) {
+	const runners = [["bun", [scriptAbs]], [process.execPath, [scriptAbs]]];
+	for (const [cmd, args] of runners) {
+		const res = await runCroOnce(cmd, args, stdinJson, timeoutMs);
+		if (!res.ok && res.code === "ENOENT") continue;
+		return res;
+	}
+	return {
+		ok: false,
+		stdout: "",
+		error: "CRO 执行失败（bun 与 node 均不可用）",
+		code: "cro-no-runner"
+	};
+}
+/** 单次 spawn（Promise 化 + 超时 kill + 输出截断 + **绝不抛**） */
+function runCroOnce(cmd, args, stdinJson, timeoutMs) {
+	return new Promise((resolvePromise) => {
+		let settled = false;
+		let stdout = "";
+		let stderr = "";
+		let child = null;
+		try {
+			child = spawn(cmd, args, {
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				env: { ...process.env }
+			});
+		} catch (err) {
+			return resolvePromise({
+				ok: false,
+				stdout: "",
+				error: String(err),
+				code: "SPAWN_ERR"
+			});
+		}
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			child?.kill("SIGKILL");
+			resolvePromise({
+				ok: false,
+				stdout,
+				error: `CRO 执行超时（>${Math.round(timeoutMs / 1e3)}s，已 kill）`,
+				code: "cro-timeout"
+			});
+		}, timeoutMs);
+		child.stdin?.on("error", () => {});
+		try {
+			child.stdin?.write(stdinJson);
+			child.stdin?.end();
+		} catch {}
+		child.stdout?.on("data", (d) => {
+			stdout = (stdout + d.toString()).slice(0, CRO_STDOUT_MAX);
+		});
+		child.stderr?.on("data", (d) => {
+			stderr = (stderr + d.toString()).slice(0, CRO_STDOUT_MAX);
+		});
+		child.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolvePromise({
+				ok: false,
+				stdout,
+				error: String(err.message ?? err),
+				code: err.code
+			});
+		});
+		child.on("close", (code) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			if (code === 0) resolvePromise({
+				ok: true,
+				stdout,
+				error: null
+			});
+			else {
+				const detail = stderr.trim().split("\n")[0] ?? "";
+				resolvePromise({
+					ok: false,
+					stdout,
+					error: `CRO 程序退出码 ${code}${detail ? `：${detail}` : ""}`,
+					code: "cro-exit-nonzero"
+				});
+			}
+		});
+	});
+}
+/** 读目录清单（不存在/读失败 ⇒ 空数组；**不回退抛错**） */
+function readDirEntries(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => {
+			const p = join(dir, e.name);
+			try {
+				const st = statSync(p);
+				return {
+					name: e.name,
+					bytes: st.size,
+					mtimeMs: st.mtimeMs
+				};
+			} catch {
+				return null;
+			}
+		}).filter((x) => x !== null);
+	} catch {
+		return [];
+	}
+}
+/** 读 SESSION.md 体积与 mtime（不存在/读失败 ⇒ null） */
+function readMdStat(mdPath) {
+	try {
+		const st = statSync(mdPath);
+		return {
+			bytes: st.size,
+			mtimeMs: st.mtimeMs
+		};
+	} catch {
+		return {
+			bytes: null,
+			mtimeMs: null
+		};
+	}
+}
+/** 读取快照所需的 fs 侧数据（**纯读取，不抛**） */
+function readCroSnapshotInput(root, dirName, nowMs, extras) {
+	const dir = join(sessionsRoot(root), dirName);
+	const mdPath = join(dir, SESSION_MD);
+	const md = readMdStat(mdPath);
+	return {
+		dirName,
+		cccRoot: root,
+		nowMs,
+		sessionMdPath: mdPath,
+		sessionMdBytes: md.bytes,
+		sessionMdMtimeMs: md.mtimeMs,
+		references: readDirEntries(join(dir, "references")),
+		boundSessionIds: extras.boundSessionIds,
+		liveSessionIds: extras.liveSessionIds,
+		runningSessionIds: extras.runningSessionIds,
+		pendingWakes: extras.pendingWakes,
+		scheduler: extras.scheduler
+	};
+}
+/**
+* 评估一条轨迹的 CRO 程序：**文件在 ⇒ 跑它；不在 ⇒ 未启用**（设计 §2.1）。
+*
+* 🔴 **本函数永不抛错**（旁路容忍铁律）：任何失败都返回 `{status:'skipped'}`，
+* 调用方据此**跳过本轮**、**不影响既有投递链路**。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @param snapshotInput 已读好的快照输入
+* @param deps 可注入依赖（测试用）
+* @returns 四态结果
+*/
+async function evaluateCro(root, dirName, snapshotInput, deps = {}) {
+	let scriptAbs;
+	try {
+		scriptAbs = croScriptPath(root, dirName);
+	} catch (err) {
+		return {
+			status: "disabled",
+			detail: `CRO 路径非法（须在 CCC 根内）：${String(err?.message ?? err)}`
+		};
+	}
+	if (!existsSync(scriptAbs)) return {
+		status: "disabled",
+		detail: `未启用（无 ${CRO_FILENAME}）`
+	};
+	const snapshot = buildCroSnapshot(snapshotInput);
+	let stdinJson;
+	try {
+		stdinJson = JSON.stringify(snapshot);
+	} catch (err) {
+		return {
+			status: "skipped",
+			detail: `快照序列化失败：${String(err?.message ?? err)}`,
+			code: "cro-snapshot"
+		};
+	}
+	const run = await (deps.runner ?? runCroProcess)(scriptAbs, stdinJson, deps.timeoutMs ?? 6e4);
+	if (!run.ok) return {
+		status: "skipped",
+		detail: run.error ?? "CRO 执行失败",
+		...run.code ? { code: run.code } : {}
+	};
+	const parsed = parseCroOutput(run.stdout);
+	if (!parsed.ok) return {
+		status: "skipped",
+		detail: parsed.detail ?? parsed.error,
+		code: parsed.error
+	};
+	const decision = parsed.decision;
+	if (!decision.wake) return {
+		status: "no-wake",
+		decision,
+		detail: decision.reason ?? "程序判定：不唤起"
+	};
+	return {
+		status: "wake",
+		decision,
+		prompt: decision.prompt,
+		detail: decision.reason ?? "程序判定：唤起"
+	};
+}
+/** 人读一行（日志用；`evaluateCro` 结果的稳定摘要） */
+function renderCroOutcome(dirName, outcome) {
+	switch (outcome.status) {
+		case "disabled": return `${dirName}: CRO ${outcome.detail}`;
+		case "skipped": return `${dirName}: CRO 跳过本轮（${outcome.detail}）`;
+		case "no-wake": return `${dirName}: CRO 不唤起（${outcome.detail}）`;
+		case "wake": return `${dirName}: CRO 唤起（${outcome.detail}）`;
+	}
+}
+//#endregion
+//#region src/host/effect.ts
+/** 已告警的标签（进程级去重：重复装配/多测试替身不刷屏，但绝不静默） */
+const warnedLabels = /* @__PURE__ */ new Set();
+/**
+* 登记一个卸载时执行的清理。
+* @param ctx 宿主插件上下文
+* @param label 日志标签（定位是哪个资源未装配）
+* @param cleanup 卸载时执行；抛错被吞掉（不阻断其它清理）
+* @returns 是否成功装配（false = 宿主无 `ctx.effect`，已告警）
+*/
+function registerDisposer(ctx, label, cleanup) {
+	const effect = ctx?.effect;
+	if (typeof effect !== "function") {
+		if (!warnedLabels.has(label)) {
+			warnedLabels.add(label);
+			console.warn(`[serenity-hooks] ✗ 资源拆卸未装配（${label}）：ctx.effect 不可用（宿主契约缺失）`);
+		}
+		return false;
+	}
+	try {
+		effect.call(ctx, () => () => {
+			try {
+				cleanup();
+			} catch (err) {
+				console.warn(`[serenity-hooks] ✗ 资源清理失败（${label}）: ${String(err?.message ?? err)}`);
+			}
+		}, `dsh-serenity-hooks: ${label}`);
+		return true;
+	} catch (err) {
+		console.warn(`[serenity-hooks] ✗ 资源拆卸注册失败（${label}）: ${String(err?.message ?? err)}`);
+		return false;
+	}
+}
+//#endregion
+//#region src/cro-turns.ts
+/** 一次「在跑」记录的 TTL（见文件头的方向性判据） */
+const TURN_TTL_MS = 18e5;
+/**
+* 进程内的「正在跑」表（键 = 载体 dsh 会话 id）。
+*
+* ⚠️ **仅内存**：进程重启即空 —— 这是**可接受的**，因为重启后宿主会重发
+* `agent/created`（或至少下一次 `turn-stopping` 会清掉残留），且空表 = "没有在跑"，
+* 落到上面那条**便宜**的误判方向。
+*/
+const runningBySession = /* @__PURE__ */ new Map();
+/** 取载体 id（事件 payload 的 `agent` 面；取不到 ⇒ null） */
+function sessionIdOf$3(agent) {
+	const id = agent?.session?.id;
+	return typeof id === "string" && id !== "" ? id : null;
+}
+/** 标记「在跑」（`agent/created` + `agent/status=running` 调用） */
+function markTurnRunning(sessionId, nowMs, turn = null) {
+	if (!sessionId) return;
+	runningBySession.set(sessionId, {
+		at: nowMs,
+		turn
+	});
+}
+/** 清除「在跑」（`turn-stopping` / disposed 调用） */
+function clearTurnRunning(sessionId) {
+	if (!sessionId) return;
+	runningBySession.delete(sessionId);
+}
+/**
+* 列出**当前在跑**的载体 id（按 TTL 过滤 + **顺手清除过期项**）。
+*
+* 🔴 **本函数带副作用（清理）是刻意的**：它是"异常路径兜底"的唯一执行点——
+* 只过滤不清除会让表留下永不过期的僵尸项（正是"只增不清"病）。
+* @param nowMs 当前时刻
+* @param ttlMs TTL（缺省 {@link TURN_TTL_MS}）
+* @returns 在跑的载体 id 列表（顺序不保证）
+*/
+function listRunningSessionIds(nowMs, ttlMs = TURN_TTL_MS) {
+	const out = [];
+	for (const [id, rec] of runningBySession) {
+		if (nowMs - rec.at > ttlMs) {
+			runningBySession.delete(id);
+			continue;
+		}
+		out.push(id);
+	}
+	return out;
+}
+/**
+* 按轨迹聚合：该轨迹**是否有载体在跑**（`listBoundSessionIds` 给候选，再与在跑集求交）。
+* @param boundSessionIds 绑定该轨迹的载体 id
+* @param nowMs 当前时刻
+* @param ttlMs TTL
+* @returns 在跑的载体 id（**可能多条**；空数组 = 没有在跑）
+*/
+function runningCarriersOf(boundSessionIds, nowMs, ttlMs = TURN_TTL_MS) {
+	const running = new Set(listRunningSessionIds(nowMs, ttlMs));
+	return boundSessionIds.filter((id) => running.has(id));
+}
+/**
+* 装配追踪（`index.ts` apply 调用）：订阅四个既有事件 + 拆卸。
+*
+* **为什么订阅四个而不是两个**（R↓）：
+* · 前两个（`agent/created` / `turn-stopping`）负责**语义**——"在不在跑"；
+* · 后两个（`agent/disposed` / `session/disposed`）负责**生命周期**——
+*   载体没了必须清项，否则表按载体只增（本模块的头号风险）。
+*
+* ⚠️ **失败不抛**：任一事件通道缺失 ⇒ 响亮日志 + 该订阅跳过（**apply 不可成为启动单点**，
+* 与 `registerDeepseekVisionPatch` 等既有装配同款纪律）。
+* @param ctx 插件上下文
+*/
+function registerCroTurnTracking(ctx) {
+	const on = (event, handler) => {
+		try {
+			ctx.on(event, handler);
+		} catch (err) {
+			console.log(`[serenity-hooks] ✗ CRO turn 追踪未装配（${event} 不可用）: ${String(err?.message ?? err)}`);
+		}
+	};
+	on("agent/created", (payload) => {
+		const id = sessionIdOf$3(payload?.agent);
+		if (id) markTurnRunning(id, Date.now());
+	});
+	on("agent/status", (payload) => {
+		const p = payload;
+		const id = sessionIdOf$3(p?.agent);
+		if (!id) return;
+		const turn = typeof p.turn === "number" ? p.turn : null;
+		if (p.status === "running") markTurnRunning(id, Date.now(), turn);
+		else if (p.status === "idle") clearTurnRunning(id);
+	});
+	on("agent/turn-stopping", (payload) => {
+		const id = sessionIdOf$3(payload?.agent);
+		if (id) clearTurnRunning(id);
+	});
+	on("agent/disposed", (payload) => {
+		const id = sessionIdOf$3(payload?.agent);
+		if (id) clearTurnRunning(id);
+	});
+	on("session/disposed", (payload) => {
+		const id = payload?.id;
+		if (typeof id === "string" && id !== "") clearTurnRunning(id);
+	});
+	registerDisposer(ctx, "cro turn tracking", () => {
+		runningBySession.clear();
+	});
+}
+//#endregion
+//#region src/cro-log.ts
+/**
+* cro-log.ts — CRO 唤起日志（**ACC 侧**，每轨迹一份固定名文件，2026-09-20 S142 §7.16）
+*
+* ## 所有者令（本模块的存在理由）
+*
+* 「S151 和 S185 的验证都说明，trajectory 倾向于自己做个结构化记录来记录自身 CRO 的执行情况，
+* 这是个结构化流水账；**我们 ACC 有必要进行 CRO 唤醒的日志记录**，当 CRO 存在时，每次**成功唤醒**
+* 写相关信息，但是保留数量要少，**只保留仅两日**的记录即可，**这个时间是程序化的**」
+* ＋「**这个日志写结构化文件到 trajectory 目录，文件名固定即可**」
+* ＋「**失败成功都记录**」。
+*
+* ## 它解决什么麻烦（白话）
+*
+* 在此之前「ACC 到底叫过谁、叫了几次、哪次**没叫成**」**ACC 自己一个字都不留** ——
+* 要查只能去读**被叫的那个程序**写的记录；程序没写 / 写坏 / 被换掉 ⇒ **这段历史就是空白**。
+* ⇒ 本模块让 ACC **自己那一侧**留一份只记两天的流水，使「唤起历史」**不再依赖被观测者是否老实**。
+*
+* ## 🔴 为什么**不是**第二真相源（本容器铁律，勿删此论证）
+*
+* 轨迹目录里因此**并排两个文件、主语各一**：
+*
+* | 文件 | 谁写 | 主语 | 回答 |
+* |---|---|---|---|
+* | `<轨迹目录>/cro-state.json`（CCC 侧程序自建，名字自定） | **CCC 的 CRO 程序** | 程序 | 「**我判了什么**」（含"没叫"的判定、心跳阈值、环境谓词） |
+* | `<轨迹目录>/cro-wake-log.json`（**本模块**） | **ACC** | ACC | 「**我把什么送出去了、送成没有**」 |
+*
+* **内容不重叠**：本模块**不复制**判定细节（不存 `lastDecision` / 阈值 / 谓词）；
+* 而程序**不可能**知道投递结果（CRO 投递是 fire-and-forget）。
+* ⇒ 两者**互补**：完整审计 = 两者合看（本模块 = 投递面｜程序状态 = 判定面）。
+*
+* ## 🔴 轮转（所有者明示「程序化的」）
+*
+* **写入时按窗裁剪**：每次落盘只保留 `at >= now - CRO_LOG_RETENTION_MS` 的条目，
+* 随后**原子写**（`tmp + rename`，与 `wake-registry.ts` 同款形态）。
+* ⇒ 清理与写入**是同一笔操作** ⇒ **结构上不存在"忘了清"的可能**（比"另设一个每 tick 的清理步"更硬：
+* 那多一个"可能忘了跑"的面）。窗宽是**常量**，**无配置键、无人工清理动作**。
+*
+* ## 🔴 铁律（与 `cro.ts` 同族）
+*
+* **本模块的每个导出函数都不抛错**：写盘 / 裁剪 / 解析失败一律返回结构化失败，
+* 由调用方只记一行 tick 日志 ⇒ **CRO 流水的问题绝不影响投递与既有链路**（设计 §5）。
+*
+* ## 保留量级（实测，非估计）
+*
+* 实测最高 = S185 的 40min 心跳（≈36 条/天）；两天窗 ⇒ **≤ ~80 条、< 20 KB**。
+* 最坏（某程序每 5min 都叫）⇒ 288 条/天 ⇒ 两天 **≤ ~600 条、< 100 KB** —— 轮转**自带上限**。
+*/
+/** 固定文件名（所有者令：「文件名固定即可」）——与程序自建的 `cro-state.json` 并排、主语分明 */
+const CRO_LOG_FILENAME = "cro-wake-log.json";
+/** 保留窗 = 2 日（所有者令「只保留仅两日」）；**常量** ⇒ 「这个时间是程序化的」 */
+const CRO_LOG_RETENTION_MS = 1728e5;
+const CRO_LOG_VERSION = 1;
+/** 日志绝对路径 */
+function croWakeLogPath(root, dirName) {
+	return join(sessionsRoot(root), dirName, CRO_LOG_FILENAME);
+}
+function emptyLog$1() {
+	return {
+		version: CRO_LOG_VERSION,
+		entries: []
+	};
+}
+/** 条目形状校验（容忍手改：字段缺失/类型不符 → 丢弃该条，不阻断整档） */
+function asEntry$1(value) {
+	const e = value;
+	if (!e || typeof e !== "object") return null;
+	if (typeof e.at !== "string" || e.at === "") return null;
+	if (typeof e.ok !== "boolean") return null;
+	if (typeof e.detail !== "string") return null;
+	const digest = e.promptDigest ?? {};
+	return {
+		at: e.at,
+		ok: e.ok,
+		detail: e.detail,
+		tick: typeof e.tick === "number" ? e.tick : 0,
+		reason: typeof e.reason === "string" ? e.reason : null,
+		promptDigest: {
+			length: typeof digest.length === "number" ? digest.length : 0,
+			head: typeof digest.head === "string" ? digest.head : ""
+		}
+	};
+}
+/** 提示词摘要（长度 + 前 N 字；超长不截断标记——长度字段本身就是信号） */
+function summarizeCroPrompt(prompt) {
+	const text = typeof prompt === "string" ? prompt : "";
+	return {
+		length: [...text].length,
+		head: [...text].slice(0, 80).join("")
+	};
+}
+/**
+* 读取日志（**永不抛**；读坏 ⇒ 当作空档 + 返回 error 文本）。
+* @param root CCC 根
+* @param dirName 轨迹目录名
+*/
+function loadCroWakeLog(root, dirName) {
+	const path = croWakeLogPath(root, dirName);
+	if (!existsSync(path)) return {
+		log: emptyLog$1(),
+		error: null
+	};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
+		const entries = [];
+		for (const item of raw) {
+			const e = asEntry$1(item);
+			if (e) entries.push(e);
+		}
+		return {
+			log: {
+				version: CRO_LOG_VERSION,
+				entries
+			},
+			error: null
+		};
+	} catch (err) {
+		return {
+			log: emptyLog$1(),
+			error: `CRO 流水解析失败（${String(err?.message ?? err)}）`
+		};
+	}
+}
+/**
+* 按窗裁剪（**纯函数** ⇒ 可穷举测试）。
+*
+* 判据：`Date.parse(at) >= nowMs - windowMs` 保留；反之丢弃。
+* 🔴 **`at` 不可解析者一律丢弃**（本模块只写 `isoLocal()` 产物 ⇒ 不可解析 = 被手改或损坏），
+* **并在返回值里报数**（`dropped`）——**不静默吞掉**（本容器反复栽的"安静失败"纪律）。
+*/
+function pruneCroLogEntries(entries, nowMs, windowMs = CRO_LOG_RETENTION_MS) {
+	const floor = nowMs - windowMs;
+	const kept = [];
+	let pruned = 0;
+	let dropped = 0;
+	for (const e of entries) {
+		const t = Date.parse(e.at);
+		if (Number.isNaN(t)) {
+			dropped += 1;
+			continue;
+		}
+		if (t >= floor) kept.push(e);
+		else pruned += 1;
+	}
+	return {
+		kept,
+		pruned,
+		dropped
+	};
+}
+/**
+* 追加一条唤起记录并按窗裁剪（**本模块主入口；永不抛**）。
+*
+* 顺序 = 读 → 追加 → 裁剪 → **原子写**。任一步失败 ⇒ `{ok:false, error}`，
+* **不抛**（调用方只记一行 tick 日志；**绝不影响投递**）。
+*
+* 无 CRO 的轨迹**不会**因本函数产生文件：只有真的发生过一次唤起尝试才会建/写该档
+* （所有者令「**当 CRO 存在时**」）。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @param input 本次唤起尝试（成败都记）
+* @param nowMs 当前毫秒（可注入 ⇒ 便于测裁剪边界）
+* @returns 写入结果与裁剪计数
+*/
+function appendCroWakeLog(root, dirName, input, nowMs = Date.now()) {
+	const path = croWakeLogPath(root, dirName);
+	try {
+		const loaded = loadCroWakeLog(root, dirName);
+		const entry = {
+			at: isoLocal(nowMs),
+			ok: input.ok,
+			detail: input.detail,
+			tick: input.tick,
+			reason: input.reason,
+			promptDigest: summarizeCroPrompt(input.prompt)
+		};
+		const { kept, pruned, dropped } = pruneCroLogEntries([...loaded.log.entries, entry], nowMs);
+		mkdirSync(dirname(path), { recursive: true });
+		const tmp = `${path}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify({
+			version: CRO_LOG_VERSION,
+			entries: kept
+		}, null, 2)}\n`, "utf-8");
+		renameSync(tmp, path);
+		return {
+			ok: true,
+			error: null,
+			kept: kept.length,
+			pruned,
+			dropped
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: `CRO 流水写入失败（${String(err?.message ?? err)}）`,
+			kept: 0,
+			pruned: 0,
+			dropped: 0
+		};
+	}
+}
+//#endregion
+//#region src/clock-runtime.ts
+/**
+* clock-runtime.ts — **时钟运行时工厂**（S142 §38 复审候选 C6b，路径 **P2**）
+*
+* 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正**：本文件当初是为**两条**独立 5min 时钟抽出的公共引擎：
+*   · 唤醒调度器（`wake-scheduler.ts`，一次性唤醒，D58）—— **现存**
+*   · autopilot 时钟（`autopilot-trajectory.ts`，周期自唤醒，D59）—— 🔴 **已随 v1.35.0 整段退场**
+* 二者的**业务判据完全不同**（谁来扫 / 扫什么 / 投递给谁 / 按什么周期），但**引擎骨架逐字同形**
+* ——进程态 + 快照 + 复位 + `startTimer` + tick 外壳 + 事件接线 + disposer + `timer.unref()`。
+* 本条把**引擎**抽到本工厂，**各钟仍各持自己的定时器与自己的串行链**（现存的那一钟 = 唤醒调度器）。
+*
+* ───────────────────────────────────────────────────────────────────────────
+* 🔴 硬约束一：**两条时钟绝不可共用"排队执行"的链**（这是 P2 与 P1 的分界判据）
+*
+* autopilot 每轮要跑该 CCC 的**偏见脚本**（`fetchBiasContent`，超时 60s），可能阻塞数十秒；
+* 若与唤醒调度器共用一条串行链，会把另一条一起**卡住**（一次性唤醒被无关的偏见脚本拖住）。
+* ⇒ 本工厂把 `chain` 作为**每实例私有状态**：`createClock()` 调用一次 = 一条独立的串行域。
+*    实例之间**零共享**（无模块级单例、无共享 Promise、无共享 map）。
+* ⚠️ 若日后有人把 `chain` 提到模块级"省一次分配"，**两条时钟的隔离即刻失效**——不许。
+*
+* 🔴 硬约束二：**武装门只判全局闸**（`gate()`），**不判"本次有无目标"**
+*
+* 2026-09-14 F 段实测缺陷：旧实现把"有 live CCC"当**武装前置条件**，而宿主刚重启时 live 会话
+* 必为空，且**"恢复旧会话"不触发 `session/created`**（只有新建会）⇒ 启动瞬间判定落空 =
+* **时钟永久不武装**（实测 6.6h 零 tick）。⇒ 现在「**全局闸开即武装**」，"有无目标"降级为
+* tick 内的廉价判定。**武装与"本次有无目标"是两件事，本工厂不得把二者耦合。**
+*
+* 🔴 硬约束三：**闸是可选能力，工厂不得替调用方假设"必须有闸"**（v1.34 S-1 解耦 → 2026-09-21 收窄）
+*
+* 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正：当前零条闸在用** —— 现存唯一那一钟
+* （唤醒调度器）本已无闸，而"曾只余的那一条" `autopilotWakeEnabled` 已随 **v1.35.0 autopilot
+* 整段退场**一并消失 ⇒ `gate` **缺省即常态，不是特例**。**唤醒调度器已无闸**
+* （原 `wakeSchedulerEnabled` 于 2026-09-21 所有者令砍掉 ⇒ 调用方**不传** `gate`
+* ＝ 恒武装、永不因闸跳过、`enabled` 恒 `true`）。工厂取 `gate` **回调**（每次现读），
+* **不做**任何合并或缓存；**缺省无闸是合法形态，不是漏配**。
+*
+* ───────────────────────────────────────────────────────────────────────────
+* 两条时钟**逐项语义差**（`ClockOptions` 的每个可配项都对应下表一行，不是随意的灵活性）：
+*
+* | 项 | 唤醒调度器 | autopilot | 工厂表达 |
+* |----|-----------|-----------|---------|
+* | `chain` | 有（全局串行） | 有（全局串行） | **总是私有**（硬约束一） |
+* | `lastTickLog` | 有（逐行摘要） | **无** | `logFrom` 不给 = 不记 |
+* | `ticks` 记账 | 工厂在 body **完成后**记 | **本钟**在同步段记 | `bodyCountsTick` + `begin` |
+* | body 返回类型 | `string[]`（人读摘要） | `void` | 泛型 `T` |
+* | 启动日志 | 固定串 | 含启用 CCC 计数 | `startLog: () => string` |
+* | body 异常兜底 | 留痕 + `console.warn` | 同 | 工厂统一（**吞异常不改语义**） |
+*
+* ───────────────────────────────────────────────────────────────────────────
+* **本工厂是"加法式"重构**（P2 的性质）：不新增任何判定逻辑，只把同形骨架收成一份代码；
+* 两个模块仍各自导出 `wakeSchedulerState()` / `autopilotClockState()` 与各自的
+* `__reset…ForTest()`，**对外可观测面（字段名与语义）零变化**——`acc-diag` ①b 段、
+* `container-status.ts:containerClocks()` 与面板都在读它们（见该文件 :225–250 的设计红线）。
+*
+* 为什么**不**取 P1（真合并成一个 `setInterval` + 两条策略）——2026-09-15 所有者裁决：
+* P1 只多省 ~20 行，却要把 `armed` 拆成"宿主 + 每策略"两层、并强行分开串行域，
+* 即**动两条正在跑的时钟的骨架**；**不值当**（裁决原文见 SESSION §12.8②）。
+*/
+/**
+* tick 周期（**5 分钟**）。
+*
+* 2026-09-15 S142「ACC 侧 autopilot 退场」：本值原从 `autopilot-core.ts` 导入（`TICK_MS`），
+* 但该模块随 autopilot 退场，而**本模块的唯一消费者是唤醒调度器**（`wake-scheduler`）——
+* 值本身与 autopilot 无关 ⇒ 随消费者归位到本模块（不再依赖 autopilot 判据层）。
+*
+* ⚠️ 语义不得变：该值同时是**报告文案的来源**（"等下个 Nmin tick"），历史上曾因文案写死
+* 10min 与实现 5min 不符而误导排查（§12.7 文案纠错）。
+*/
+const TICK_MS = 3e5;
+/**
+* 挂事件 → 触发 `start()`（**每个事件一次 try/catch 吞异常**：事件通道缺失不阻断时钟）。
+*
+* 为什么吞异常：宿主（headless profile 等）可能没有事件通道；**启动时已 `start()` 过一次**，
+* 事件只是"跟上面板开关 / 新会话"的热启动补丁，缺它不该让整个装配抛错。
+* @param on 宿主的 `on`（可能不存在）
+* @param ctx `on` 的 `this`（宿主 API 常要求绑定）
+* @param clock 目标时钟
+* @param events 事件名列表（回调恒为 `() => clock.start()`）
+*/
+function attachClockEvents(ctx, clock, events) {
+	const on = ctx?.on;
+	if (typeof on !== "function") return;
+	for (const name of events) try {
+		on.call(ctx, name, () => clock.start());
+	} catch {}
+}
+/**
+* 建一条时钟（**每钟各调一次**——本工厂**不是**单例，调用次数 = 时钟条数）。
+*
+* 顺序忠实于既有实现：`start()` 先武装并立即跑一次 tick → 再挂事件。
+* 拆卸由调用方经 `registerDisposer(ctx, label, clock.dispose)` 落到宿主的 `ctx.effect`。
+* @param opts 见 {@link ClockOptions}（每项对应一条既有的语义差）
+* @returns 该钟的 `{start, dispose, snapshot, reset}`
+*/
+function createClock(opts) {
+	const runtime = {
+		armed: false,
+		armedAt: null,
+		lastTickAt: null,
+		ticks: 0,
+		lastSkipReason: null
+	};
+	if (opts.logFrom) runtime.lastTickLog = [];
+	const st = {
+		timer: null,
+		chain: Promise.resolve(),
+		runtime,
+		wired: false,
+		opts
+	};
+	/** 记一次 tick（工厂内部与 body 共用同一实现——只有一处会计逻辑） */
+	const countTick = () => {
+		runtime.lastTickAt = Date.now();
+		runtime.ticks += 1;
+	};
+	/** 逐行打印（`logFrom` 缺省 ⇒ 本钟无 tick 日志，整段为死代码路径） */
+	const emit = (lines) => {
+		if (!opts.logFrom) return;
+		for (const line of lines) console.log(`${opts.logFrom.prefix}${line}`);
+	};
+	const tick = () => {
+		if (opts.gate !== void 0 && !opts.gate()) {
+			runtime.lastSkipReason = opts.gateOffReason ?? null;
+			return;
+		}
+		if (opts.begin) try {
+			opts.begin();
+		} catch (err) {
+			console.warn(`[serenity-hooks] ✗ tick 前置异常: ${String(err?.message ?? err)}（${opts.label}）`);
+			return;
+		}
+		st.chain = st.chain.then(async () => {
+			try {
+				const value = await opts.body();
+				if (!opts.bodyCountsTick) countTick();
+				if (opts.logFrom) {
+					runtime.lastTickLog = opts.logFrom.lines(value);
+					emit(runtime.lastTickLog);
+				}
+			} catch (err) {
+				const msg = `✗ tick 异常: ${String(err?.message ?? err)}`;
+				if (opts.logFrom) runtime.lastTickLog = [msg];
+				console.warn(`[serenity-hooks] ${msg}（${opts.label}）`);
+			}
+		});
+	};
+	/**
+	* 幂等启动 + 武装门：**已武装 → 原样返回**（防重复起定时器）；
+	* **闸关 → 不武装**（零资源占用）；闸开则**无条件**武装（硬约束二：不判"有无目标"）。
+	*/
+	const start = () => {
+		if (st.timer) return;
+		if (opts.events && !st.wired) {
+			st.wired = true;
+			attachClockEvents(opts.ctx, api, opts.events);
+		}
+		if (opts.gate !== void 0 && !opts.gate()) return;
+		st.timer = setInterval(tick, TICK_MS);
+		st.timer.unref();
+		runtime.armed = true;
+		runtime.armedAt = Date.now();
+		console.log(opts.startLog());
+		if (opts.immediate !== false) tick();
+	};
+	const dispose = () => {
+		if (st.timer) {
+			clearInterval(st.timer);
+			st.timer = null;
+		}
+		runtime.armed = false;
+		runtime.armedAt = null;
+		opts.onDispose?.();
+	};
+	const api = {
+		start,
+		dispose,
+		snapshot: () => ({
+			enabled: opts.gate === void 0 ? true : opts.gate(),
+			...runtime,
+			...runtime.lastTickLog ? { lastTickLog: [...runtime.lastTickLog] } : {}
+		}),
+		noteSkipReason: (reason) => {
+			runtime.lastSkipReason = reason;
+		},
+		countTick,
+		enqueue: (work) => {
+			st.chain = st.chain.then(work, () => void 0).then(() => void 0, (err) => {
+				console.warn(`[serenity-hooks] ✗ 串行任务异常（${opts.label}）: ${String(err?.message ?? err)}`);
+			});
+		},
+		reset: () => {
+			if (st.timer) {
+				clearInterval(st.timer);
+				st.timer = null;
+			}
+			runtime.armed = false;
+			runtime.armedAt = null;
+			runtime.lastTickAt = null;
+			runtime.ticks = 0;
+			runtime.lastSkipReason = null;
+			if (opts.logFrom) runtime.lastTickLog = [];
+			st.wired = false;
+			opts.onReset?.();
+		}
+	};
+	return api;
+}
+//#endregion
+//#region src/wake-scheduler.ts
+/**
+* 解析条目的 target（`S###` 或完整目录名）→ 目录名 + SESSION.md 路径。
+* @param root CCC 根
+* @param target 条目里的目标标识
+* @returns 命中返回目录信息，未命中 null
+*/
+function resolveWakeTarget(root, target) {
+	const found = findSession(sessionsRoot(root), target);
+	if (!found) return null;
+	const mdPath = join(found.path, "SESSION.md");
+	if (!existsSync(mdPath)) return null;
+	return {
+		dirName: basename(found.path),
+		mdPath
+	};
+}
+/**
+* 🔴 **本钟的全局闸已于 2026-09-21 砍掉**（所有者令逐字：「**send-later 的开关不再重要了，砍掉**」）。
+*
+* **为什么砍**（R↓）：唤醒已从"可选实验能力"长成**全容器的续接绳**（🔵 **术语说明，2026-09-23 补**：
+* **"绳" = 我们对自己用 `send-later` 给自己排的"定时叫醒"条目的俗称** —— 一条链每轮给自己排下一根，
+* 链才不断。本仓注释与 SESSION.md 沿用此说法，**它不是产品名、也不是宿主概念**）——S142/S151/S185 的链、
+* 跨轨迹投递、`send-now`/`send-later` 都走它。留一个"能被误关的开关"的**代价**是
+* "整条链静默停摆且无人告警"（本仓已实测过同族事故：闸关 6.6h 零 tick、断链 1 天 14 小时）；
+* 而**收益**只剩"关掉一个 5min unref 空检查"。⇒ **收益 < 代价，故删闸**（不是改为缺省开——是**没有这个键了**）。
+*
+* ⚠️ **兼容**：旧配置文件里残留的 `wakeSchedulerEnabled` **静默忽略**（无回退键、无告警噪声；
+* 与旧 `bootstrap` 段的处置先例一致）。**机制本身一行未动**（所有者："我说的只是开关"）。
+*
+* 历史（勿误读）：v1.34 S-1 曾把两闸解耦（周期自唤醒 `autopilotWakeEnabled` / 本钟 `wakeSchedulerEnabled`），
+* 理由是"关 auto-trajectory 不得连带关一次性唤醒"；随 ACC 侧 autopilot 于 v1.35.0 整段退场，
+* 两闸只剩本钟一座 ⇒ 现已整座移除。详见 `docs/trajectory-scheduling.md` §S-1 与 v1.44 CHANGELOG。
+*/
+/**
+* 🔴 **本钟的串行域**（C6b 硬约束）：`clock.chain` 是**本实例私有**的——
+* 与 autopilot 的串行链**零共享**。autopilot 每轮跑 CCC 偏见脚本可能阻塞数十秒，
+* 共用链会把一次性唤醒一起卡住（这正是 P1 被否、取 P2 的理由，见 SESSION §12.8②）。
+*
+* **为什么这里是模块级常量**（而不是 `registerWakeScheduler` 的局部量）：本钟的进程态是
+* **进程级可观测面**（`acc-diag` ①b / `containerClocks` 在读），且 `wakeSchedulerState()` /
+* `__resetWakeSchedulerStateForTest()` 是**公开导出**、可在未装配时被调用 ⇒ 实例必须**恒在**
+* （旧实现的 `schedulerRuntime` 也正是模块级常量）。装配只做 `clock.start()`。
+*/
+/** 本钟的装配项（`ctx` 由 {@link registerWakeScheduler} 在装配点填入） */
+const clockOpts = {
+	label: "trajectory 唤醒调度器",
+	ctx: void 0,
+	events: ["session/created", "serenity/settings-changed"],
+	body: () => runWakeTick(clockOpts.ctx),
+	logFrom: {
+		prefix: "[serenity-hooks] trajectory 唤醒 ",
+		lines: (lines) => lines
+	},
+	startLog: () => "[serenity-hooks] ✓ trajectory 唤醒调度器启动（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 目标 trajectory 目录名
+* @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);
+	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 { error: `无绑定会话记录（AGENT_SESSIONS/.bindings.json 中无 ${dirName}）——目标轨迹需先被 container_trajectory use 激活过` };
+}
+/** 唤醒消息（唤起即投递正文：身份锚定 + 唤醒信息 + 任务） */
+function buildWakeText(entry, target) {
+	return [
+		`[trajectory 唤醒] 到点（登记于 ${entry.createdAt}，发起者 ${entry.createdBy || "未知"}，id ${entry.id}）。`,
+		`当前时间：${localHuman()}（当地时区）。`,
+		"",
+		`身份锚定：继续 ${target.dirName} 的 trajectory（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: `目标 trajectory 未命中（${entry.target}）`
+	};
+	const acquired = await acquireWakeAgent(ctx, root, target.dirName);
+	if ("error" in acquired) return {
+		ok: false,
+		detail: acquired.error,
+		notReady: acquired.notReady === true
+	};
+	try {
+		acquired.agent.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text: buildWakeText(entry, target)
+			}],
+			source: PLUGIN_SOURCE
+		}));
+	} catch (err) {
+		return {
+			ok: false,
+			detail: `投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+		};
+	}
+	return {
+		ok: true,
+		detail: `已投递 ${target.dirName}（${acquired.how}）`
+	};
+}
+/**
+* 即时消息正文（**刻意不复用** {@link buildWakeText}）：唤醒文本以「**到点**（登记于…）」开头，
+* 对即时投递那是**错的事实**。本函数显式区分"这是即时消息、不是到点唤醒"。
+*
+* ⚠️ **v1.39.2 起"已入队"这句话必须删掉**（S142 §0r，所有者令「不排队、直接即时注入」）：
+* 旧文案写"消息已进入你的队列；你此前若正在跑轮次，它在本轮结束后生效"——
+* 那是**旧的 followup 语义**；现在在跑的目标走 `steer`（当场注入当前轮），
+* 留着这句话就是**注入一条假陈述**（比没有更坏：目标会误判自己看到它的时机）。
+* @param target 目标轨迹（目录名 + SESSION.md）
+* @param message 递送正文
+* @param sender 发起者轨迹标识（供目标与人类识别来源）
+*/
+function buildSendText(target, message, sender) {
+	return [
+		`[即时消息] 来自 ${sender || "未知轨迹"}。当前时间：${localHuman()}（当地时区）。`,
+		"",
+		`身份锚定：继续 ${target.dirName} 的 trajectory（SESSION.md: ${target.mdPath}）。`,
+		"",
+		"消息：",
+		message,
+		"",
+		"说明：这是**即时投递**（不是到点唤醒）——它**不排队**：目标正在跑轮次就**当场注入当前轮**，目标空闲则立即起一轮。处理完照常把进展写入 SESSION.md。"
+	].join("\n");
+}
+/**
+* 即时投递（`container_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`** ——
+* 预约的本职是"到点唤起"，且在跑时排队不打断是它被实证验收过的行为，不顺手动它。
+*
+* **归属**：本函数放在调度器侧而非工具侧 —— "怎么把一句话送到一条轨迹"是**调度器的知识**，
+* 工具只该知道"有这个动作"。这样 `trajectory.ts` 完全不碰调度器内部（v1.35.0 硬约束①：
+* `send-later` 链路**一行为不动**，本次改动 = **纯新增**）。
+*
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param target `S###` 或 AGENT_SESSIONS 目录名
+* @param message 递送正文
+* @param sender 发起者轨迹标识
+* @returns 投递结果（**同步**返回给调用方）
+*/
+async function sendToTrajectory(ctx, root, target, message, sender) {
+	const t = resolveWakeTarget(root, target);
+	if (!t) return {
+		ok: false,
+		detail: `目标 trajectory 未命中（${target}）`
+	};
+	const acquired = await acquireWakeAgent(ctx, root, t.dirName);
+	if ("error" in acquired) return {
+		ok: false,
+		detail: acquired.error
+	};
+	const agent = acquired.agent;
+	const make = () => createUserMessage({
+		content: [{
+			type: "text",
+			text: buildSendText(t, message, sender)
+		}],
+		source: PLUGIN_SOURCE
+	});
+	if (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}；目标空闲 ⇒ followup 立即起轮）`
+		};
+	}
+	try {
+		agent.steer(make());
+		return {
+			ok: true,
+			detail: `已即时注入 ${t.dirName}（${acquired.how}；目标在跑 ⇒ steer 当场注入当前轮）`
+		};
+	} 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)}`
+		};
+	}
+}
+/**
+* 本 tick 要扫的 CCC 根集合（**并集**）。
+*
+* C2（S142 2026-09-15 Q5）：原实现是 `collectLiveCccs`——**只认 live 会话** ⇒
+* "完全冷掉的 CCC 不能自唤醒自己"（已知边界）。现改为 `ccc-roots.listCccs` 的并集枚举
+* （工作区注册表 ∪ 持久化会话 ∪ live 会话）：**没有 live 会话的 CCC 也会被扫到**。
+*
+* ⚠️ 边界（本步**只**改"枚举哪些 CCC"，**不改**"怎么找到要交付的 agent"）：
+* 把 message 交给某条 trajectory 仍必须靠 **live 会话**解析（见本文件
+* `acquireWakeAgent`）；无 live 会话时该 CCC 只是**被扫到、
+* 无交付对象** ⇒ `deliverWake` 返回 `无绑定会话记录…`，条目回 `pending` 并留痕。
+* 因此本函数**不得**让 tick 抛错（异常一律由调用方 tick 兜住，见 `runWakeTick` 的 try）。
+* @param ctx 插件上下文
+* @returns CCC 根列表（无任何来源 → `[]`）
+*/
+async function collectWakeCccs(ctx) {
+	return (await listCccs(ctx)).map((e) => e.root);
+}
+/**
+* CRO 唤起消息正文（**刻意不复用** {@link buildWakeText} / {@link buildSendText}）。
+*
+* 三种唤起各有自己的**事实**；混用 = 注入一条假陈述（本容器栽过：`buildSendText` 里
+* 那句"消息已入队"就是一条假陈述，见该函数注释）：
+* · `buildWakeText` —— 「**到点**了」（登记过的未来时刻，人/agent 算好的）
+* · `buildSendText` —— 「**有人此刻给我发了一条消息**」
+* · 本函数         —— 「**我自己的程序**看情况判定该叫我了」（**没有到点、也没有人发消息**）
+*
+* 🔴 `reason` 的呈现（设计 §4.2）：**程序没写就明说没写**，不留空白 ——
+* 改成程序判定后，"当时为什么叫了"**不再能从时间表重建**（原因在程序肚子里）；
+* 留空白 = 连"丢在哪一环"都看不出来。写明"未提供"至少把缺口标出来了（CCE：重建 > 保存）。
+* @param dirName 目标轨迹目录名
+* @param mdPath 目标 SESSION.md 绝对路径
+* @param prompt 程序给的唤起提示词
+* @param reason 程序给的判定理由（可为 null）
+* @returns 投递正文
+*/
+function buildCroWakeText(dirName, mdPath, prompt, reason) {
+	return [
+		`[CRO 唤起] ${dirName} 自带的 continuous-re-occurrence.ts 判定：现在该唤起。`,
+		`当前时间：${localHuman()}（当地时区）。`,
+		"",
+		`身份锚定：继续 ${dirName} 的 trajectory（SESSION.md: ${mdPath}）。`,
+		"",
+		`判定理由：${reason ?? "（程序未提供 reason —— 见 CRO 编写指南 §7 坑 3）"}`,
+		"",
+		"唤起提示词：",
+		prompt,
+		"",
+		"说明：这是由**本轨迹自己的 CRO 程序**按当时情况做的判定（**不是**定时唤醒，**也不是**别人发的消息）。处理完照常把进展写入 SESSION.md。"
+	].join("\n");
+}
+/**
+* 投递一条 CRO 唤起（**fire-and-forget**，与 {@link deliverWake} 同层）。
+*
+* · **取用通路复用** {@link acquireWakeAgent}（live 优先 → 冷载入）：这是调度器侧唯一的
+*   "怎么把一句话送到一条轨迹"的知识 ⇒ 不另立第二条（设计 §9-2 的倾向：复用投递面）。
+* · 🔴 **不落唤醒表**（设计 §6.3）：CRO 是"**持续判定**"，不是"**某个未来时刻**"。
+*   落表会给 §0Q（投递即删、表只保在办）**增加一个新的写入源**。
+* · 用 `followup`（不用 `steer`）：CRO 由**调度器**发起，与 `send-later` 同层；
+*   `steer`（当场注入当前轮）是 `send-now` 的语义 —— 那是人类/agent 的**即时动作**。
+* · 🔴 **失败不回滚、不重试**（与条目投递不同）：下一 tick 会**重新判定**——
+*   CRO 的判据是"情况"，不是"这条消息还没送出去" ⇒ 自愈来自**重判**，不来自重投。
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param dirName 目标轨迹目录名（= CRO 只能唤起**自己**，设计 §9-8 的倾向）
+* @param prompt 唤起提示词
+* @param reason 判定理由
+* @returns 投递结果（进 tick 日志；**不写注册表**）
+*/
+async function deliverCroWake(ctx, root, dirName, prompt, reason) {
+	const mdPath = join(sessionsRoot(root), dirName, "SESSION.md");
+	const acquired = await acquireWakeAgent(ctx, root, dirName);
+	if ("error" in acquired) return {
+		ok: false,
+		detail: acquired.error,
+		notReady: acquired.notReady === true
+	};
+	try {
+		acquired.agent.followup(createUserMessage({
+			content: [{
+				type: "text",
+				text: buildCroWakeText(dirName, mdPath, prompt, reason)
+			}],
+			source: PLUGIN_SOURCE
+		}));
+	} catch (err) {
+		return {
+			ok: false,
+			detail: `CRO 投递失败（${acquired.how}）: ${String(err?.message ?? err)}`
+		};
+	}
+	return {
+		ok: true,
+		detail: `已投递（${acquired.how}）`
+	};
+}
+/**
+* CRO 阶段：本 tick 对**每条启用了 CRO 的轨迹**跑一次它自带的程序，按判定投递。
+*
+* ## 为什么放在既有投递**之后**（R↓）
+* · 既有条目（`send-later`）**有到点承诺** ⇒ 优先级天然更高；
+* · CRO 是"看着情况叫"，**晚一拍无成本**（tick 粒度本就是 5min）；
+* · ⇒ 铁律（设计 §5）：**CRO 的任何失败都不影响既有链路** —— 整段由调用方兜住，
+*   且**每条轨迹各自 try/catch**（一条坏程序不得连累同 tick 的其它轨迹）。
+*
+* ## 日志口径（刻意与既有投递不同）
+* "每 tick × 每条轨迹"都写一行 ⇒ 对"**常态是不唤起**"的 CRO 就是刷屏。
+* ⇒ 逐条只记 **唤起**（`reason` 进日志 —— 设计 §4.2 要求可重建）与 **跳过**（异常，必须看见）；
+*   **不唤起只进汇总行**（`唤起 x，不唤起 y，跳过 z`）。
+* ⚠️ **诚实标注**：因此"某条轨迹当轮**为何没叫**"**不进 tick 日志**（它在程序肚子里）。
+*    要完整的逐次判定审计，须**程序自己**写状态文件（设计 §3.3）——ACC 给不了。
+* @param ctx 插件上下文
+* @param root CCC 根
+* @param registry 本 tick 已载入的唤醒注册表条目（供快照的 `pendingWakes`；读坏时传 `[]`）
+* @param log 本 tick 的人读摘要（就地追加）
+*/
+async function runCroPhase(ctx, root, registry, log) {
+	if (readSimpleSettings().croEnabled === false) {
+		log.push("CRO 阶段：已关闭（croEnabled=false）——既有唤醒投递不受影响");
+		return;
+	}
+	let dirs;
+	try {
+		dirs = listCroTrajectories(root);
+	} catch {
+		return;
+	}
+	if (dirs.length === 0) return;
+	const nowMs = Date.now();
+	const s = wakeSchedulerState();
+	const scheduler = {
+		armed: s.armed,
+		enabled: s.enabled,
+		ticks: s.ticks,
+		lastSkipReason: s.lastSkipReason
+	};
+	const agents = hostAgents(ctx);
+	let wakes = 0;
+	let quiet = 0;
+	let skips = 0;
+	for (const dirName of dirs) try {
+		const bound = listBoundSessionIds(root, dirName);
+		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}`}`);
+			if (!res.notReady) {
+				const rec = appendCroWakeLog(root, dirName, {
+					ok: res.ok,
+					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;
+	} catch (err) {
+		skips += 1;
+		log.push(`· ${root}: ${dirName}: CRO 内部异常（已忽略，不影响既有链路）: ${String(err?.message ?? err)}`);
+	}
+	log.push(`· ${root}: CRO 评估 ${dirs.length} 条（唤起 ${wakes}，不唤起 ${quiet}，跳过 ${skips}）`);
+}
+/** 一次调度 tick：遍历已知 CCC → 到期项串行投递 / 超窗项置 missed；返回人读摘要 */
+async function runWakeTick(ctx) {
+	const log = [];
+	const roots = await collectWakeCccs(ctx).catch(() => []);
+	if (roots.length === 0) {
+		clock.noteSkipReason("无已知 CCC 可扫（等某个会话/工作区出现）");
+		return log;
+	}
+	clock.noteSkipReason(null);
+	for (const root of roots) {
+		const purged = purgeFinalizedWakes(root);
+		if (purged.ok && purged.purged > 0) log.push(`· ${root}: 清除 ${purged.purged} 条已结案记录（存量首清）`);
+		const { registry, error } = loadWakeRegistry(root);
+		if (error) {
+			log.push(`✗ ${root}: ${error}`);
+			await runCroPhase(ctx, root, [], log);
+			continue;
+		}
+		const { due, expired } = splitDueWakes(registry, Date.now(), WAKE_CATCH_UP_MS);
+		for (const e of expired) {
+			finalizeWake(root, e.id, "missed", `超过补跑窗口（${WAKE_CATCH_UP_MS / 36e5}h）未投递`);
+			log.push(`· ${root}: ${e.id} → missed（超补跑窗口，已清除）`);
+		}
+		for (const e of due) {
+			const res = await deliverWake(ctx, root, e);
+			if (res.notReady) {
+				log.push(`· ${root}: ${e.id} → 跳过（宿主服务未就绪，下个 tick 再试；不计失败）`);
+				continue;
+			}
+			if (res.ok) {
+				finalizeWake(root, e.id, "delivered", res.detail);
+				log.push(`· ${root}: ${e.id} → delivered（已清除）`);
+			} else {
+				updateWake(root, e.id, {
+					state: "pending",
+					attempts: e.attempts + 1,
+					lastResult: res.detail
+				});
+				log.push(`· ${root}: ${e.id} → 重试（${res.detail}）`);
+			}
+		}
+		await runCroPhase(ctx, root, registry.entries, log);
+	}
+	return log;
+}
+/**
+* 装配调度器（index.ts apply 调用）：5min tick + 生命周期 disposer +
+* 会话出现/settings 变化时热启动（与 autopilot 同款触发面，互不干扰）。
+* @param ctx 插件上下文
+*/
+function registerWakeScheduler(ctx) {
+	clockOpts.ctx = ctx;
+	clock.start();
+	registerDisposer(ctx, "trajectory 唤醒调度器", () => clock.dispose());
+}
+//#endregion
 //#region src/cro-guide.ts
 /**
 * cro-guide.ts — CRO 编写指南（**ACC 内置**，S142 §7.8，2026-09-19）
@@ -4928,39 +7027,6 @@ function currentBoundDirName(exec, scope) {
 	return getActiveSessionInfo(scope)?.dirName ?? null;
 }
 /**
-* 清洗 + 截断会话概括（需求② S142 用户拍板：编号日期后加 ≤20 字内容概括）。
-* 规则（服务端统一，不信任 LLM 输入）：
-*   - 去控制字符/换行/回车/制表（防标题注入/多行污染）
-*   - trim（去首尾空白）
-*   - 截断 ≤20 字符（按 Unicode 码点——中英混排统一；emoji 等代理对按码点保留）
-*   - 去 `/`（防标题被误读为路径分隔）
-* @returns 清洗后的概括（空输入 → 空串；调用方决定是否允许空）
-*/
-function sanitizeSessionSummary(summary) {
-	return [...summary.replace(/[\u0000-\u001f\u007f]/g, "").replace(/\//g, "").trim()].slice(0, 20).join("");
-}
-/**
-* 从激活会话派生命名标题（v1.22.9 格式修正 + 需求② 概括）：
-* F3 原始需求是 **`S###-日期`**（如 `S143-2026-08-26`）——从 `sessionId` 派生，
-* 而非完整目录名（`2026-08-24--S142--...` 超长 + 中文，不符合用户拍板格式）。
-* 需求②（S142 用户拍板）：编号日期后加 ≤20 字内容概括 → `S###-YYYY-MM-DD-<概括>`
-* ——概括来自显式 summary 参数（服务端截断/清洗，可靠不靠猜）；编号日期仍固定派生。
-* 无 S### 编号（issue 会话等）→ 回退目录名。
-* @param active 激活会话信息（sessionId + dirName）
-* @param summary 内容概括（≤20 字，服务端清洗截断；空 → 不带概括的 `S###-日期`）
-* @returns `S143-2026-08-26-概括` / `S143-2026-08-26` / 原目录名
-*/
-function namingTitleFor(active, summary) {
-	const sid = active.sessionId;
-	if (typeof sid === "string" && /^S\d+$/.test(sid)) {
-		const date = active.dirName.match(/^(\d{4}-\d{2}-\d{2})--/)?.[1] ?? "";
-		const cleaned = summary ? sanitizeSessionSummary(summary) : "";
-		const base = date ? `${sid}-${date}` : sid;
-		return cleaned ? `${base}-${cleaned}` : base;
-	}
-	return active.dirName;
-}
-/**
 * use 激活宁静号会话后，把当前 dsh 会话重命名为命名标题（`S###-日期[-概括]`）。
 * v1.27.1：**永远开启**（不再有 naming.enabled 门控）——仅 sessionTitle 服务
 * 存在性守卫；失败不静默——返回结果对象而非 null（v1.22.9），调用方决定可见性。
@@ -6928,8 +8994,9 @@ function registerBootstrap(ctx) {
 * L6 结算）仅在本模块注释与内部文档出现，永不浮现在提示词文本。
 *
 * 结算（settlement）挂点：D6 用户拍板——若 CCC 有标准 SESSION 复盘仪式，
-* 结算视图归 trajectory-assistant。当前 close/archive 无复盘摘要 → 机制
-* 延后，仅留 onSettlement 导出 seam（OP-1，无调用者）。
+* 结算视图归 trajectory-assistant。当前 close/archive 无复盘摘要 ⇒ 机制延后。
+* 🔴 2026-09-25（S142 分批清死代码·第 1 批）：原先那个 `onSettlement(cb)` **空 seam 已删**
+* （零调用者、无触发器、空实现）——仪式真落地时按当时的信号重新设计，**不再靠空占位**。
 */
 /** 可见提示词前缀用词（跨领域自然词，D8：无游戏黑话） */
 const EVENT_LABEL = {
@@ -8110,13 +10177,13 @@ function registerStatusApi(ctx, opts = {}) {
 				const url = new URL(req.url ?? "/", "http://127.0.0.1");
 				const daysParam = Number(url.searchParams.get("olderThanDays") ?? "30");
 				const days = Number.isFinite(daysParam) && daysParam >= 1 ? daysParam : 30;
-				const sessions = ctx.get("sessions");
+				const sessions = hostSessions(ctx);
 				const liveIds = /* @__PURE__ */ new Set();
 				if (sessions?.list) for (const s of sessions.list()) {
 					const id = s.id ?? s.header?.id;
 					if (id) liveIds.add(id);
 				}
-				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await import("./session-cleanup-BtkSmry8.js").then((n) => n.n);
+				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await Promise.resolve().then(() => session_cleanup_exports);
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
@@ -10125,11 +12192,12 @@ function renameAfterRebuild(ctx, agent, pending) {
 		const mdPath = pending.mdPath;
 		const dirName = basename(dirname(mdPath));
 		const idMatch = dirName.match(/--S(\d{3,})--/);
-		const title = namingTitleFor({
+		const info = {
 			sessionId: idMatch ? `S${idMatch[1]}` : dirName.replace(/^\d{4}-\d{2}-\d{2}--/, ""),
 			dirName,
 			mdPath
-		}, pending.summary);
+		};
+		const title = namingTitleFor(info, pending.summary);
 		const titles = hostService(ctx, "sessionTitle");
 		if (!titles || typeof titles.rename !== "function") {
 			console.warn("[serenity-hooks] rebuild 后重命名跳过: sessionTitle 服务不可用");