@shgroup/dsh-serenity-hooks 1.87.3 → 1.87.5

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.87.3",
+  "version": "1.87.5",
   "main": "lib/index.js",
   "description": "宁静号 ACC harness（Native Cordis 插件）：给 DSH 装一个「AI 工作区」——14 个工具（container_fs/cognitive_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫）+ 认知轨迹日志与原地重建 + 网页登录入口/IM 桥/认知轨迹唤醒注册表。轨迹声明 = 轨迹目录下的 trajectory.json（约束面 + 旧标识 uid + CRO 机器绑定 cro.host；旧名 trajectory-constraint.json / skiff.json 仍在读取族里）；轨迹提示词 = 轨迹目录下的 PROMPT.md（一条轨迹「是谁、按什么章程工作」，所有轨迹通用，追加在容器层与质量层之后，不替换它们）。适配 DSH 0.1.7-rc.1 / 0.2.0-rc.1 / 0.2.1-rc.1（三档，deepseek-ai/deepseek-harness）。",
   "engines": {

package/lib/{ccc-roots-BI_4UVcj.js → ccc-roots-CvgsUnFW.js}

@@ -227,7 +227,7 @@ async function listCccs(ctx, opts = {}) {
 	if (typeof defaultRoot === "string" && defaultRoot !== "" && !c.roots.includes(defaultRoot)) c.roots.unshift(defaultRoot);
 	let rolesOf = null;
 	if (opts.withRoles === true) {
-		const { listTrajectoryConstraints } = await import("./profile-vHheCJiU.js").then((n) => n.a);
+		const { listTrajectoryConstraints } = await import("./profile-DGt_e-Nx.js").then((n) => n.a);
 		rolesOf = (root) => {
 			try {
 				return listTrajectoryConstraints(root).map((p) => p.code);

package/lib/{cleanup-C-92qnDs.js → cleanup-DxX78__Z.js}

@@ -210,4 +210,4 @@ function cutoffDaysAgo(days, nowMs = Date.now()) {
 	return nowMs - days * DAY_MS;
 }
 //#endregion
-export { hasSessionLogById as n, sessionsRootDir as r, cleanup_exports as t };
+export { sessionsRootDir as i, findSessionLog as n, hasSessionLogById as r, cleanup_exports as t };

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-BI_4UVcj.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 { _ 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-vHheCJiU.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 { 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-DRkQwfgh.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-DZXSLLEx.js";
-import { n as hasSessionLogById, r as sessionsRootDir } from "./cleanup-C-92qnDs.js";
-import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-H7TVDayZ.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 { i as sessionsRootDir, n as findSessionLog, r as hasSessionLogById } from "./cleanup-DxX78__Z.js";
+import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-BI3NRHgC.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";
@@ -15,7 +15,7 @@ import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
-import { appendFileSync, chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { appendFileSync, chmodSync, closeSync, cpSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import { homedir, hostname, platform } from "node:os";
 import { promisify } from "node:util";
@@ -24,8 +24,8 @@ import { fileURLToPath } from "node:url";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { createHash, randomBytes } from "node:crypto";
 import { Resvg, initWasm } from "@resvg/resvg-wasm";
+import * as nodeZlib from "node:zlib";
 import { createServer, request } from "node:http";
-import * as zlib from "node:zlib";
 import { deriveEventMessage } from "@deepseek-ai/dsh-session";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
@@ -10190,6 +10190,449 @@ function listResident(root) {
 	return lines.join("\n");
 }
 //#endregion
+//#region src/trajectory/live.ts
+/**
+* trajectory/live.ts — 进程内 live 会话取数 + 精简诊断
+*
+* ── 为什么单独成模块（R↓，2026-09-15 S142「ACC 侧 autopilot 退场」S1 搬迁）──
+* 这两个函数原先住在 `autopilot-trajectory.ts`，但它们的**主语不是 autopilot**：
+* `listLiveSessions` 服务 `acc-diag` ① 段的"**哪个会话属于哪个 CCC**"（会话维度，
+* 不是 CCC 维度），而"**独立进程看不到运行时**"正是 `acc-diag` 存在的理由。
+* autopilot 退场后它们必须活下去 ⇒ 独立成模块，不再挂着已死机制的名字。
+*
+* ── 迁移边界（不搬什么，以及为什么）──────────────────────────────────────
+* 原 `diagLive` 还含两段，**均不搬**（其主语是 autopilot，随机制退场）：
+*   · `autopilotCccs`（逐 CCC 目标命中 / agent 定位诊断）—— 依赖 `readAutopilotSettings` /
+*     `getAutopilotStatus` / `resolveTargetAgent`
+*   · `panelResolved`（无参面板请求落到哪个 CCC）—— 面板区块随机制退场
+* 留下的 = **进程 cwd/CCC + live 会话清单**（`acc-diag` ① 段仍需要）。
+*
+* 判据纪律：本模块**不得**反向依赖 autopilot 判据层（那会让退场半途而废）。
+*
+* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
+* **本模块的 `ctx` 参数类型从 `Context` 改为 `unknown`** —— 消除本文件唯一的 `W2` 接触
+* （直接 import 宿主 `cordis` 的类型）。
+*
+* **为什么这是"真解耦"而不是"把类型藏起来"（判据）：** `ctx` 在本模块**从不被解引用** ——
+* 它只被**原样透传**给 `hostSessions(ctx)`，而后者（`host/access.ts`，**L0**）的参数
+* 本就声明为 `ctx: unknown` ⇒ `Context` 这个 import **在语义上是多余的**，
+* 它没有参与任何类型检查，只贡献了一处 L1→宿主 的接触点。
+* 🔵 **证据**：grep 本文件 `ctx` 全部 5 处命中 —— 3 处在参数/调用位、2 处在注释，
+* **零处**属性访问（`ctx.xxx`）。
+*/
+/**
+* 从 dsh 会话 log 读取标题（latest-wins `session/title` 事件）——
+* **标题不在 `sessions.list()` 条目上**（wire/对象均无 title 字段；F3 命名经
+* `sessionTitle.rename` 写进 session log），必须从 events 提取（rebuild 同款读取模式）。
+*/
+function readSessionTitle(session) {
+	try {
+		const events = sessionEvents(session);
+		for (let i = events.length - 1; i >= 0; i--) {
+			const e = events[i];
+			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
+		}
+	} catch {}
+	return null;
+}
+/**
+* 逐条 live 会话（`cccRoot` = 该会话 cwd 的 CCC 归属，无 → null）。
+*
+* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
+* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
+*
+* @param ctx 插件上下文（**只透传**给 L0 取数口，本模块不解引用 ⇒ 类型为 `unknown`）
+* @returns 逐条 live 会话
+*/
+function listLiveSessions(ctx) {
+	const out = [];
+	try {
+		const sessions = hostSessions(ctx);
+		for (const s of sessions?.list?.() ?? []) {
+			const cwd = s?.header?.cwd ?? null;
+			out.push({
+				id: s?.id ?? "",
+				cwd,
+				cccRoot: cwd ? cccRootForCwd(cwd) : null,
+				title: readSessionTitle(s)
+			});
+		}
+	} catch {}
+	return out;
+}
+function diagLive(ctx) {
+	const processCwd = process.cwd();
+	return {
+		processCwd,
+		processCcc: cccRootForCwd(processCwd),
+		liveSessions: listLiveSessions(ctx)
+	};
+}
+//#endregion
+//#region src/trajectory/interrupted.ts
+/**
+* 中断轮次发现（`interrupted` 会话扫描）
+*
+* ## 这个模块解决什么
+*
+* DSH 的会话日志里，**进程在某一轮完成前退出**（被 kill／崩溃／关机超时）时，
+* 宿主重放时会为该轮补上收尾事件：
+*
+* ```jsonl
+* turn/end {"turn":66,"reason":{"kind":"interrupted"}}
+* step/end {"turn":66,"step":85}
+* session/end-seed {}
+* ```
+*
+* 宿主**只补收尾，不续跑** —— 那一轮的工作就此停在那里。本模块负责把这些会话找出来，
+* 交给上层（认知轨迹）决定要不要续。
+*
+* ## 判据（三条同时成立，缺一不可）
+*
+* 1. 日志**最后一条事件是 `session/end-seed`** —— 这是"上一进程已结束、本进程重放"的标记；
+* 2. 该标记**之前最近的 `turn/end`** 的 `reason.kind === 'interrupted'`；
+* 3. `session/end-seed` 之后**没有新事件**（由判据 1 保证）。
+*
+* ⚠️ **为什么不能只看"存在过 interrupted"**：一个长会话历史上可能中断几十次
+* （本容器实测单会话 33 次）。只看"曾经中断"会把早已恢复的会话全部当成待续 ⇒ 灾难。
+*
+* ## 为什么不整文件解压
+*
+* DSH 日志是 **zstd 多帧追加**（实测单会话 24705 帧 / 47 MB）。原生
+* `zlib.zstdDecompressSync` 只解**第一帧**，对多帧直接报 `Unknown frame descriptor`。
+* ⇒ 采用**尾部窗口 + 倒序逐帧解压**：只读文件末尾 N 字节，从后往前找帧魔数，
+*    解到凑够所需事件数即停。实测 8h 窗口 6 个会话 **20 ms**。
+*
+* ## 世代识别复用 `cleanup.ts`
+*
+* 日志文件名有多个世代（`session.jsonl` / `session.v3.jsonl.zstd` / `session.v4.jsonl.zstd`…），
+* 宿主按世代写且**迁移保留源文件**。⇒ 本模块**不硬编码文件名**，走
+* {@link findSessionLog}（与清理／体积统计同一判据），避免"新世代对本模块不可见"。
+*
+* ## 边界
+*
+* - **只读**：不改任何会话日志。
+* - **不判周期**：何时扫、扫完做什么归调用方（CCC 的认知轨迹）。本模块只回答
+*   「此刻哪些会话以 interrupted 结尾」。
+*/
+/**
+* zstd 解压（**运行时有、类型声明没有**）。
+*
+* 🔴 为什么不能用 `import { zstdDecompressSync } from 'node:zlib'`：
+* 本仓 `@types/node@^20` 的声明里**没有** zstd 系列（Node 22.15+ 才进声明）。
+* 而运行时本机 v22.22.1 **确实有**（实测 `typeof require('zlib').zstdDecompressSync === 'function'`）。
+* ⇒ 用命名空间导入 + 局部断言，并**在运行时校验**；缺失时走明确降级（返回空，不静默瞎猜）。
+*/
+const zstdDecompressSync = nodeZlib.zstdDecompressSync;
+/** zstd 帧魔数（小端 `28 B5 2F FD`） */
+const ZSTD_MAGIC = Buffer.from([
+	40,
+	181,
+	47,
+	253
+]);
+/** 默认回看窗口：8 小时（owner 2026-10-22 定） */
+const DEFAULT_LOOKBACK_MS = 288e5;
+/** 每次从文件尾部读取的字节数（够覆盖数百个末尾事件） */
+const TAIL_WINDOW_BYTES = 1 << 20;
+/** 需要凑够的末尾事件数（够跨过 turn/end + step/end + end-seed 即可，留余量） */
+const TAIL_EVENT_TARGET = 60;
+/**
+* 从文件尾部倒序解压，凑够 `want` 个事件。
+*
+* 多帧 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。
+*/
+function detectInterruptedEnd(events) {
+	if (events.length === 0) return null;
+	if (events[events.length - 1]?.type !== "session/end-seed") return null;
+	let turnEnd;
+	for (let i = events.length - 2; i >= 0; i--) if (events[i]?.type === "turn/end") {
+		turnEnd = events[i];
+		break;
+	}
+	if (!turnEnd || turnEnd.data?.reason?.kind !== "interrupted") 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--/`）。
+*
+* @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 (!existsSync(projectDir)) {
+		result.elapsedMs = Date.now() - t0;
+		return result;
+	}
+	let entries;
+	try {
+		entries = readdirSync(projectDir);
+	} catch (err) {
+		result.errors.push({
+			sessionId: "*",
+			message: err instanceof Error ? err.message : String(err)
+		});
+		result.elapsedMs = Date.now() - t0;
+		return result;
+	}
+	for (const sessionId of entries) {
+		if (liveIds.has(sessionId)) continue;
+		const dirPath = join(projectDir, sessionId);
+		const logPath = findSessionLog(dirPath);
+		if (logPath === null) continue;
+		let mtimeMs;
+		try {
+			mtimeMs = statSync(logPath).mtimeMs;
+		} catch (err) {
+			result.errors.push({
+				sessionId,
+				message: err instanceof Error ? err.message : String(err)
+			});
+			continue;
+		}
+		if (mtimeMs < cutoff) continue;
+		result.scanned++;
+		try {
+			const events = readTailEvents(logPath, TAIL_EVENT_TARGET);
+			const hit = detectInterruptedEnd(events);
+			if (!hit) {
+				result.skipped++;
+				continue;
+			}
+			const tailTime = events[events.length - 1]?.time;
+			result.sessions.push({
+				sessionId,
+				logPath,
+				turn: hit.turn,
+				lastEventAt: typeof tailTime === "number" ? tailTime : null,
+				mtimeMs,
+				pendingTools: hit.pendingTools
+			});
+		} catch (err) {
+			result.errors.push({
+				sessionId,
+				message: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	result.sessions.sort((a, b) => (b.lastEventAt ?? b.mtimeMs) - (a.lastEventAt ?? a.mtimeMs));
+	result.elapsedMs = Date.now() - t0;
+	return result;
+}
+/**
+* 由 CCC 根推导它的 DSH 项目目录名（`--home-yh-home-home-serenity--`）。
+*
+* 规则取自宿主：把绝对路径的 `/` 换成 `-`，并在前后各加 `--`。
+* ⚠️ 这是**推导**，不是真相源 —— 实际目录名以磁盘为准；调用方应在不存在时
+* 回退到"扫整个 sessions root"或直接报未找到。
+*/
+function projectDirNameForCwd(cwd) {
+	return `--${cwd.replace(/\/+$/, "").split("/").filter(Boolean).join("-")}--`;
+}
+/**
+* 续跑正文（**简单、稳定、不含版本号**）。
+*
+* 判据（为什么这么短）：本动作的用途是**把被打断的会话推回工作状态**，
+* 不是替它重述任务 —— 被打断那一轮的上下文就在它自己的日志里。
+* ⇒ 正文只做三件事：① 说明发生了什么；② 提示**先核对副作用**；③ 让它接着做。
+*
+* 🔴 **为什么要写"先核对副作用"**：中断时可能有「有 call 无 result」的工具调用，
+* 它们的副作用**未知**（可能已写文件 / 已发消息）。若模型把那一轮整段重放，
+* 会**重复执行**。这句话是给模型的护栏，不是客套。
+*/
+function buildContinueText(sessionId, turn, pendingTools) {
+	const lines = [];
+	lines.push("[中断续跑] 上一条进程在本轮完成前退出，该轮已被中止。现在继续。");
+	lines.push("");
+	lines.push(`会话: ${sessionId}${turn === null ? "" : ` ／ 被中断的轮次: turn ${turn}`}`);
+	if (pendingTools.length > 0) {
+		lines.push("");
+		lines.push(`⚠️ 中断时这些工具「有调用、无结果」（副作用未知，**可能已经执行**）: ${pendingTools.join(", ")}`);
+		lines.push("   ⇒ 先核对它们是否已生效（文件是否已写、消息是否已发），再决定要不要重做。");
+		lines.push("   ⛔ 不要把被中断的那一轮整段重放。");
+	}
+	lines.push("");
+	lines.push("请接着完成该轮未完成的工作；完成后把进展写入本轨迹的 SESSION.md。");
+	return lines.join("\n");
+}
+/**
+* 把一个 agent 唤醒（注入一条续跑消息）。
+*
+* 两条路径（与 `wake/scheduler.ts` 的 `sendToCognitiveTrajectory` 同源判据）：
+* - **live**：`agents.get(id)` 拿得到 ⇒ 目标在跑（或被加载）⇒ `steer` 当场注入当前轮；
+*   `steer` 不可用则退回 `followup`（宁可排队，不可静默丢）。
+* - **cold-resume**：`sessionController.resolveAgent(id)` 冷载入后同样注入。
+*
+* ⚠️ 冷会话载入**会真起一个 agent**（消耗真实算力）⇒ 调用方必须自己决定要不要，
+* 本函数不做数量限制（那是策略，归调用者）。
+*/
+function createResumeOne(deps) {
+	return async (hit) => {
+		const { sessionId } = hit;
+		const text = buildContinueText(sessionId, hit.turn, hit.pendingTools);
+		let agent;
+		let how;
+		const live = deps.agents?.get?.(sessionId);
+		if (live) {
+			agent = live;
+			how = "live";
+		} else {
+			const sc = deps.sessionController;
+			const resolve = sc?.resolveAgent;
+			if (typeof resolve !== "function" || sc === void 0) return {
+				sessionId,
+				ok: false,
+				error: "宿主 sessionController 不可用（重启启动窗口？）—— 稍后重试"
+			};
+			try {
+				const out = await resolve.call(sc, sessionId);
+				if (!out?.agent) return {
+					sessionId,
+					ok: false,
+					error: `冷载入未返回 agent: ${String(out?.error ?? "未知原因")}`
+				};
+				agent = out.agent;
+				how = "cold-resume";
+			} catch (err) {
+				return {
+					sessionId,
+					ok: false,
+					error: `冷载入失败: ${err instanceof Error ? err.message : String(err)}`
+				};
+			}
+		}
+		const a = agent;
+		try {
+			if (typeof a.steer === "function" && a.status === "running") {
+				a.steer(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+steer`
+				};
+			}
+			if (typeof a.followup === "function") {
+				a.followup(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+followup`
+				};
+			}
+			if (typeof a.steer === "function") {
+				a.steer(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+steer`
+				};
+			}
+			return {
+				sessionId,
+				ok: false,
+				how,
+				error: "agent 既无 steer 也无 followup（宿主契约漂移）"
+			};
+		} catch (err) {
+			if (typeof a.followup === "function") try {
+				a.followup(deps.makeMessage(text));
+				return {
+					sessionId,
+					ok: true,
+					how: `${how}+followup(steer 失败后退回)`
+				};
+			} catch (err2) {
+				return {
+					sessionId,
+					ok: false,
+					error: `steer 与 followup 均失败: ${String(err2?.message ?? err2)}`
+				};
+			}
+			return {
+				sessionId,
+				ok: false,
+				error: `注入失败: ${err instanceof Error ? err.message : String(err)}`
+			};
+		}
+	};
+}
+//#endregion
 //#region src/tools/cognitive-trajectory.ts
 /**
 * trajectory.ts — `cognitive_trajectory` 真实 DSH 工具定义（defineTool）
@@ -10230,6 +10673,102 @@ function listResident(root) {
 * 保留 osp 对齐语义的部分：create 的 `--desc`/`--issue` 二选一、use 激活即重命名 dsh 会话标题（F3）。
 * 活跃会话跟踪：内存 Map（按 dsh 会话 id 隔离）+ 从 events 恢复（S134）。
 */
+/**
+* 当前宿主里**正在跑**的 dsh 会话 id（用于把 live 会话排除出"待续"名单）。
+*
+* 🔴 **为什么必须排除**：一个正在跑的会话，其日志末条**不是** `session/end-seed`
+* （它还在写），所以按判据本来也不会命中；但排除是**双保险** ——
+* 万一某轮刚被中断、宿主还没来得及继续，把 live 会话当"待续"会导致**重复投递**。
+* 拿不到 live 列表时退化为空集（不阻断扫描，只少一层保护）。
+*/
+function collectLiveSessionIds() {
+	const out = /* @__PURE__ */ new Set();
+	try {
+		for (const s of listLiveSessions(void 0)) if (typeof s.id === "string" && s.id) out.add(s.id);
+	} catch {}
+	return out;
+}
+/**
+* 渲染 `interrupted` 扫描结果（人读）。
+*
+* 显示口径：**先给"有没有"，再给每一条的定位信息，最后给边界说明**。
+* ⚠️ 明确写出"这些会话是否续跑由调用方决定" —— 否则读者会以为本动作已经处理了。
+*/
+function renderInterruptedScan(input) {
+	const { projectDir, lookbackHours, scan } = input;
+	const lines = [];
+	lines.push(`═══ 以 interrupted 结尾的 dsh 会话（回看 ${lookbackHours}h）═══`);
+	lines.push(`  扫描域: ${projectDir}`);
+	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped} · 耗时 ${scan.elapsedMs}ms${scan.errors.length > 0 ? ` · 读取失败 ${scan.errors.length}` : ""}`);
+	if (scan.sessions.length === 0) {
+		lines.push("");
+		lines.push("✓ 没有会话以 interrupted 结尾 —— 无需处理。");
+		return lines.join("\n");
+	}
+	lines.push("");
+	for (const s of scan.sessions) {
+		const at = s.lastEventAt !== null ? new Date(s.lastEventAt).toISOString() : "(时间未知)";
+		lines.push(`  · ${s.sessionId}`);
+		lines.push(`      轮次 turn=${s.turn ?? "?"} · 末事件 ${at}`);
+		if (s.pendingTools.length > 0) lines.push(`      ⚠️ 有调用无结果的工具（副作用未知）: ${s.pendingTools.join(", ")}`);
+	}
+	lines.push("");
+	lines.push("判据: 日志末条 = session/end-seed，且其前最近的 turn/end 的 reason.kind = interrupted。");
+	lines.push("🔴 本动作**只读** —— 是否续跑、续哪条、几点续，由调用方（你的认知轨迹）决定。");
+	lines.push("⚠️ 未完成的工具调用「副作用未知」≠「没执行」：它们可能已写文件 / 已发消息。");
+	lines.push("   续跑前应先核对副作用，而不是把那一轮整段重放。");
+	if (scan.errors.length > 0) {
+		lines.push("");
+		lines.push("读取失败（诊断）:");
+		for (const e of scan.errors.slice(0, 10)) lines.push(`  · ${e.sessionId}: ${e.message}`);
+	}
+	return lines.join("\n");
+}
+/**
+* 渲染 `continue-all-interrupted` 的结果（人读）。
+*
+* 三种形态必须能一眼分清：**dryRun（只预告）** ／ **有命中且全成功** ／ **有失败**。
+* ⚠️ 明确写出"已注入 ≠ 已跑完" —— 与 `send-now` 的回执口径一致（D-族：回执只到注入）。
+*/
+function renderContinueResult(input) {
+	const { projectDir, lookbackHours, scan, outcomes, dryRun } = input;
+	const lines = [];
+	const head = dryRun ? "续跑预告（dryRun，未注入任何消息）" : "中断续跑结果";
+	lines.push(`═══ ${head}（回看 ${lookbackHours}h）═══`);
+	lines.push(`  扫描域: ${projectDir}`);
+	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped} · 耗时 ${scan.elapsedMs}ms`);
+	if (scan.sessions.length === 0) {
+		lines.push("");
+		lines.push("✓ 没有会话以 interrupted 结尾 —— 无需续跑。");
+		return lines.join("\n");
+	}
+	lines.push("");
+	if (dryRun) {
+		lines.push("将对这些会话注入续跑消息:");
+		for (const s of scan.sessions) {
+			const at = s.lastEventAt !== null ? new Date(s.lastEventAt).toISOString() : "(时间未知)";
+			lines.push(`  · ${s.sessionId}  turn=${s.turn ?? "?"}  末事件 ${at}`);
+			if (s.pendingTools.length > 0) lines.push(`      副作用未知: ${s.pendingTools.join(", ")}`);
+		}
+		lines.push("");
+		lines.push("要真的执行，去掉 dryRun 再调用一次。");
+		return lines.join("\n");
+	}
+	const okCount = (outcomes ?? []).filter((o) => o.ok).length;
+	const failCount = (outcomes ?? []).length - okCount;
+	lines.push(`结果：已注入 ${okCount} ／ 失败 ${failCount}`);
+	lines.push("");
+	for (const o of outcomes ?? []) lines.push(o.ok ? `  ✓ ${o.sessionId}  (${o.how ?? "已注入"})` : `  ✗ ${o.sessionId}  ${o.error ?? "未知原因"}`);
+	lines.push("");
+	lines.push("⚠️ 回执只到「消息已注入」——**不表示**目标已经跑完或已答复。");
+	lines.push("   要确认它真的动了，去看该会话的日志 / 它自己的 SESSION.md。");
+	if (scan.errors.length > 0) {
+		lines.push("");
+		lines.push("扫描期读取失败（诊断）:");
+		for (const e of scan.errors.slice(0, 10)) lines.push(`  · ${e.sessionId}: ${e.message}`);
+	}
+	return lines.join("\n");
+}
 /** 当前 dsh 会话 id（use/close 按会话隔离的 scope） */
 function agentScope$1(exec) {
 	return exec.agent?.session?.id ?? "default";
@@ -10349,6 +10888,7 @@ function createCognitiveTrajectoryTool(ctx) {
 			"list (inventory + stats) / show (read one SESSION.md) / create (make a NEW trajectory) / use (bind THIS conversation) / rebuild (clear-and-rebuild THIS conversation in place) / archive (move a trajectory out of the active list; one-way, never overwrites).",
 			"(B) DELIVERY — sends ONE message to ANOTHER trajectory; your own binding is unchanged: send-now (right now) / send-later (one future instant).",
 			"(C) REFERENCE — cro-guide: how to give a trajectory its own program that decides when it should be woken.",
+			"(D) INSPECTION — interrupted: list dsh sessions whose LAST turn ended with reason \"interrupted\" (the process died before that turn completed). PURE READ: no periodic scheduling, no auto-continue, no log mutation — deciding IF/WHEN/WHICH to resume belongs to the calling trajectory (this is the \"entry point only\" contract). The criterion is EXACTLY \"ends with interrupted\", NOT \"was ever interrupted\": one long session may have been interrupted dozens of times historically, and treating those as pending would resurrect sessions that already recovered. Each hit reports the turn number and the tool names that had a call but no result (best-effort — those side effects are UNKNOWN, so re-running them blindly is dangerous).",
 			"HOW TO CHOOSE (a rule, not a guess):",
 			"not yet bound + starting new work ⇒ create (with no prior binding it activates immediately, so the new trajectory has a carrier at once).",
 			"already bound + recording a SEPARATE future line ⇒ create (it does NOT steal your binding; activate the new one later by send-now).",
@@ -10388,7 +10928,9 @@ function createCognitiveTrajectoryTool(ctx) {
 					"send-now (deliver RIGHT NOW; the target needs no prior setup — if it has no live session, one is created and bound automatically) /",
 					"send-later (one future instant + one message; fire-and-forget, and it does NOT auto-create a target).",
 					"REFERENCE: cro-guide (no parameters: prints the CRO programming guide, including a ready-to-use sample snapshot) /",
-					"resident (READ-ONLY: the roster of trajectories that declared themselves RESIDENT — \"I am here, this is what I am good at, come bother me\". It lists each code with its own `serves` sentence, plus any code that wrote `resident` without `serves` (half a declaration is worse than none: people ask, then find they asked the wrong one). ⚠️ Residency is NOT a resource state — it does not mean \"never sleeps\" or \"never destroyed\"; a trajectory permanently exists either way. It governs BEING FOUND, not being kept alive, and it never touches the scheduler)."
+					"resident (READ-ONLY: the roster of trajectories that declared themselves RESIDENT — \"I am here, this is what I am good at, come bother me\". It lists each code with its own `serves` sentence, plus any code that wrote `resident` without `serves` (half a declaration is worse than none: people ask, then find they asked the wrong one). ⚠️ Residency is NOT a resource state — it does not mean \"never sleeps\" or \"never destroyed\"; a trajectory permanently exists either way. It governs BEING FOUND, not being kept alive, and it never touches the scheduler).",
+					"INSPECTION: interrupted (READ-ONLY: dsh sessions whose LAST turn ended with reason \"interrupted\" — the process died mid-turn. Accepts an optional lookbackHours (default 8). Deciding whether/when to resume is YOUR job — this action only answers \"which sessions are in that state right now\") /",
+					"continue-all-interrupted (ACTION: same detection as above, but it then INJECTS a short continue message into every hit, waking them. Serial delivery. Supports dryRun to preview without injecting. ⚠️ This really starts agents and spends real compute — use dryRun first if unsure. The receipt means \"injected\", NOT \"the target finished or replied\")."
 				].join(" ")
 			},
 			name: {
@@ -10429,7 +10971,7 @@ function createCognitiveTrajectoryTool(ctx) {
 			},
 			dryRun: {
 				type: "boolean",
-				description: "create: preview mode (no actual changes)"
+				description: "create: preview mode (no actual changes). continue-all-interrupted: preview which sessions WOULD be resumed, injecting nothing."
 			},
 			target: {
 				type: "string",
@@ -10442,6 +10984,10 @@ function createCognitiveTrajectoryTool(ctx) {
 			message: {
 				type: "string",
 				description: "send-later/send-now: the single message delivered to the target cognitive trajectory. send-now may create and bind a carrier ONLY when the target has never had one — acceptable only for a delivery the user actually wants made (user-intent-driven), never for speculatively starting work."
+			},
+			lookbackHours: {
+				type: "number",
+				description: "interrupted / continue-all-interrupted: how far back to look, in hours (default 8). Sessions whose current-generation log was last written earlier than this are not examined at all."
 			}
 		},
 		output: {
@@ -10636,6 +11182,93 @@ function createCognitiveTrajectoryTool(ctx) {
 				* 🔴 **不进系统提示词**（owner 裁决 Q2：说明类信息按需取，不占每轮 token）。
 				*/
 				return listResident(root);
+				case "interrupted": {
+					/**
+					* 以 `interrupted` 结尾的 dsh 会话（owner 2026-10-22 令：**只出入口**）。
+					*
+					* 🔴 **边界（owner 原话：「我们 ACC 不关心周期」）**：本动作**只回答**"此刻哪些会话
+					* 的最后一轮以 interrupted 结束"，**不判周期、不自动续跑、不改日志**。
+					* 何时扫、续谁、怎么续 = 调用方（CCC 的认知轨迹）的事。
+					*
+					* 🔴 **为什么不是"曾经中断过"**：长会话历史上可中断几十次（实测单会话 33 次）；
+					* 按"曾经"判会把早已恢复的会话全部当成待续 ⇒ 灾难。判据在
+					* `trajectory/interrupted.ts` 的 `detectInterruptedEnd`：**末条 = end-seed
+					* 且其前最近的 turn/end 是 interrupted**。
+					*
+					* 🔴 **正在跑的会话要排除**：live 会话不该被判成"待续"（它正在跑，不是中断）。
+					*/
+					const lookbackHours = typeof args.lookbackHours === "number" && args.lookbackHours > 0 ? args.lookbackHours : DEFAULT_LOOKBACK_MS / 36e5;
+					const sessionsRootPath = sessionsRootDir();
+					const cwd = exec.agent?.session?.header?.cwd ?? root;
+					const projectDir = join(sessionsRootPath, projectDirNameForCwd(cwd));
+					return renderInterruptedScan({
+						projectDir,
+						lookbackHours,
+						scan: scanInterruptedSessions(projectDir, {
+							lookbackMs: lookbackHours * 36e5,
+							liveIds: collectLiveSessionIds()
+						})
+					});
+				}
+				case "continue-all-interrupted": {
+					/**
+					* 扫 + 逐条注入续跑消息（owner 2026-10-22 追加令：
+					* 「我希望实现的是 continue-all-interrupted 方法，调用后自动找到 8h 内所有 dsh 会话
+					*   注入简单的 continue 进行唤醒，这样 CCC 就不用动脑子了」）。
+					*
+					* 🔴 **与 `interrupted` 分立而不合并**：前者是**观察**（只读、零副作用），
+					* 后者是**动作**（会真起 agent、真烧算力）。想看一眼清单却误触发全量续跑
+					* 是不可接受的 ⇒ 两个动作各自可调用。
+					*
+					* 🔴 **边界仍是"不判周期"**：何时调用归调用方（CCC 的定时轨迹）。
+					* 本动作只保证"**调用一次就把该做的做完**"。
+					*/
+					const lookbackHours = typeof args.lookbackHours === "number" && args.lookbackHours > 0 ? args.lookbackHours : DEFAULT_LOOKBACK_MS / 36e5;
+					const dryRun = args.dryRun === true;
+					const sessionsRootPath = sessionsRootDir();
+					const cwdRead = exec.agent?.session?.header?.cwd ?? root;
+					const projectDir = join(sessionsRootPath, projectDirNameForCwd(cwdRead));
+					const scan = scanInterruptedSessions(projectDir, {
+						lookbackMs: lookbackHours * 36e5,
+						liveIds: collectLiveSessionIds()
+					});
+					if (dryRun) return renderContinueResult({
+						projectDir,
+						lookbackHours,
+						scan,
+						outcomes: null,
+						dryRun: true
+					});
+					const hostCtx = exec;
+					const resumeOne = createResumeOne({
+						agents: hostAgents(hostCtx),
+						sessionController: hostService(hostCtx, "sessionController"),
+						makeMessage: (text) => createUserMessage({
+							content: [{
+								type: "text",
+								text
+							}],
+							source: PLUGIN_SOURCE
+						})
+					});
+					const outcomes = [];
+					for (const hit of scan.sessions) try {
+						outcomes.push(await resumeOne(hit));
+					} catch (err) {
+						outcomes.push({
+							sessionId: hit.sessionId,
+							ok: false,
+							error: err instanceof Error ? err.message : String(err)
+						});
+					}
+					return renderContinueResult({
+						projectDir,
+						lookbackHours,
+						scan,
+						outcomes,
+						dryRun: false
+					});
+				}
 				default: throw new Error(`Unknown action: ${args.action}`);
 			}
 		}
@@ -14395,7 +15028,7 @@ function registerStatusApi(ctx, opts = {}) {
 						});
 					}
 					const { saveWeixinRoutes } = await import("./route-3OzOAjec.js").then((n) => n.l);
-					const { findDirNameByCode } = await import("./profile-vHheCJiU.js").then((n) => n.a);
+					const { findDirNameByCode } = await import("./profile-DGt_e-Nx.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;
@@ -14543,7 +15176,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const id = s.id ?? s.header?.id;
 					if (id) liveIds.add(id);
 				}
-				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await import("./cleanup-C-92qnDs.js").then((n) => n.t);
+				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await import("./cleanup-DxX78__Z.js").then((n) => n.t);
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
@@ -15908,9 +16541,9 @@ function transformHtmlForProxy(raw, upstreamHeaders) {
 	const enc = String(upstreamHeaders["content-encoding"] ?? "").toLowerCase().trim();
 	const outHeaders = { ...upstreamHeaders };
 	if (enc === "gzip" || enc === "x-gzip" || enc === "deflate" || enc === "br") try {
-		if (enc === "br") body = zlib.brotliDecompressSync(body);
-		else if (enc === "deflate") body = zlib.inflateSync(body);
-		else body = zlib.gunzipSync(body);
+		if (enc === "br") body = nodeZlib.brotliDecompressSync(body);
+		else if (enc === "deflate") body = nodeZlib.inflateSync(body);
+		else body = nodeZlib.gunzipSync(body);
 		delete outHeaders["content-encoding"];
 	} catch {
 		return null;
@@ -19438,7 +20071,7 @@ const MEDIA_MAX_BYTES = 20971520;
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-BI_4UVcj.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -19506,7 +20139,7 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const { findDirNameByCode } = await import("./profile-vHheCJiU.js").then((n) => n.a);
+	const { findDirNameByCode } = await import("./profile-DGt_e-Nx.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}）—— 该消息**未投递**，请改订阅表里的目标编码`);
@@ -20460,7 +21093,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-BI_4UVcj.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -20753,7 +21386,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-BI_4UVcj.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -22431,85 +23064,6 @@ function createImBridgeTool() {
 	});
 }
 //#endregion
-//#region src/trajectory/live.ts
-/**
-* trajectory/live.ts — 进程内 live 会话取数 + 精简诊断
-*
-* ── 为什么单独成模块（R↓，2026-09-15 S142「ACC 侧 autopilot 退场」S1 搬迁）──
-* 这两个函数原先住在 `autopilot-trajectory.ts`，但它们的**主语不是 autopilot**：
-* `listLiveSessions` 服务 `acc-diag` ① 段的"**哪个会话属于哪个 CCC**"（会话维度，
-* 不是 CCC 维度），而"**独立进程看不到运行时**"正是 `acc-diag` 存在的理由。
-* autopilot 退场后它们必须活下去 ⇒ 独立成模块，不再挂着已死机制的名字。
-*
-* ── 迁移边界（不搬什么，以及为什么）──────────────────────────────────────
-* 原 `diagLive` 还含两段，**均不搬**（其主语是 autopilot，随机制退场）：
-*   · `autopilotCccs`（逐 CCC 目标命中 / agent 定位诊断）—— 依赖 `readAutopilotSettings` /
-*     `getAutopilotStatus` / `resolveTargetAgent`
-*   · `panelResolved`（无参面板请求落到哪个 CCC）—— 面板区块随机制退场
-* 留下的 = **进程 cwd/CCC + live 会话清单**（`acc-diag` ① 段仍需要）。
-*
-* 判据纪律：本模块**不得**反向依赖 autopilot 判据层（那会让退场半途而废）。
-*
-* ── 🔴 2026-09-25 I2 收敛（约束文档 §2.7 违反清单，L1 违反之一）────────────────
-* **本模块的 `ctx` 参数类型从 `Context` 改为 `unknown`** —— 消除本文件唯一的 `W2` 接触
-* （直接 import 宿主 `cordis` 的类型）。
-*
-* **为什么这是"真解耦"而不是"把类型藏起来"（判据）：** `ctx` 在本模块**从不被解引用** ——
-* 它只被**原样透传**给 `hostSessions(ctx)`，而后者（`host/access.ts`，**L0**）的参数
-* 本就声明为 `ctx: unknown` ⇒ `Context` 这个 import **在语义上是多余的**，
-* 它没有参与任何类型检查，只贡献了一处 L1→宿主 的接触点。
-* 🔵 **证据**：grep 本文件 `ctx` 全部 5 处命中 —— 3 处在参数/调用位、2 处在注释，
-* **零处**属性访问（`ctx.xxx`）。
-*/
-/**
-* 从 dsh 会话 log 读取标题（latest-wins `session/title` 事件）——
-* **标题不在 `sessions.list()` 条目上**（wire/对象均无 title 字段；F3 命名经
-* `sessionTitle.rename` 写进 session log），必须从 events 提取（rebuild 同款读取模式）。
-*/
-function readSessionTitle(session) {
-	try {
-		const events = sessionEvents(session);
-		for (let i = events.length - 1; i >= 0; i--) {
-			const e = events[i];
-			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
-		}
-	} catch {}
-	return null;
-}
-/**
-* 逐条 live 会话（`cccRoot` = 该会话 cwd 的 CCC 归属，无 → null）。
-*
-* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
-* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
-*
-* @param ctx 插件上下文（**只透传**给 L0 取数口，本模块不解引用 ⇒ 类型为 `unknown`）
-* @returns 逐条 live 会话
-*/
-function listLiveSessions(ctx) {
-	const out = [];
-	try {
-		const sessions = hostSessions(ctx);
-		for (const s of sessions?.list?.() ?? []) {
-			const cwd = s?.header?.cwd ?? null;
-			out.push({
-				id: s?.id ?? "",
-				cwd,
-				cccRoot: cwd ? cccRootForCwd(cwd) : null,
-				title: readSessionTitle(s)
-			});
-		}
-	} catch {}
-	return out;
-}
-function diagLive(ctx) {
-	const processCwd = process.cwd();
-	return {
-		processCwd,
-		processCcc: cccRootForCwd(processCwd),
-		liveSessions: listLiveSessions(ctx)
-	};
-}
-//#endregion
 //#region src/surface/observation.ts
 /**
 * surface/observation.ts — 容器状态模型的**取数层唯一出口**（C5「观察面归一」，S142 2026-09-15）

package/lib/{message-source-DRkQwfgh.js → message-source-Cq4PsuES.js}

@@ -1,6 +1,6 @@
-import { r as cccRootForCwd } from "./ccc-roots-BI_4UVcj.js";
+import { r as cccRootForCwd } from "./ccc-roots-CvgsUnFW.js";
 import { _ as resolveInside, g as readUtf8 } from "./ccc-CyYJL4F2.js";
-import { D as parseTrajectoryCode, M as sessionsRoot, S as getLastActiveSessionInfo, j as sessionEvents, x as getActiveSessionInfo } from "./profile-vHheCJiU.js";
+import { D as parseTrajectoryCode, M as sessionsRoot, S as getLastActiveSessionInfo, j as sessionEvents, x as getActiveSessionInfo } from "./profile-DGt_e-Nx.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/lib/{profile-vHheCJiU.js → profile-DGt_e-Nx.js}

@@ -244,7 +244,9 @@ const COGNITIVE_TRAJECTORY_ACTIONS = [
 	"send-now",
 	"send-later",
 	"cro-guide",
-	"resident"
+	"resident",
+	"interrupted",
+	"continue-all-interrupted"
 ];
 /**
 * 读取 Session 事件序列（v1.28.1 适配 0.1.2-rc.1 补齐）：rc.1 起官方 Session 类

package/lib/{session-DZXSLLEx.js → session-Ca5UYzF3.js}

@@ -1,8 +1,8 @@
-import { n as agentCwdFor, r as cccRootForCwd, s as hostAgents } from "./ccc-roots-BI_4UVcj.js";
+import { n as agentCwdFor, r as cccRootForCwd, s as hostAgents } from "./ccc-roots-CvgsUnFW.js";
 import { g as readUtf8, o as isSafeModeOn, p as readCognitiveTrajectorySkills, u as readBlacklist } from "./ccc-CyYJL4F2.js";
-import { M as sessionsRoot, O as readActiveSessionMd, V as isoLocal, d as trajectoryDirNameForSession, f as unregisterTrajectorySession$1, l as trajectoryConstraintForSession, m as DEFAULT_SESSION_SCOPE, o as readTrajectoryConstraintAt, u as registerTrajectorySession$1 } from "./profile-vHheCJiU.js";
+import { M as sessionsRoot, O as readActiveSessionMd, V as isoLocal, d as trajectoryDirNameForSession, f as unregisterTrajectorySession$1, l as trajectoryConstraintForSession, m as DEFAULT_SESSION_SCOPE, o as readTrajectoryConstraintAt, u as registerTrajectorySession$1 } from "./profile-DGt_e-Nx.js";
 import { a as readGitTrack, i as localstorePath } from "./service-DDmHSglV.js";
-import { d as constraintCognitiveTrajectory, m as profileMsmWhitelist, n as PLUGIN_SOURCE, o as readLastBound, p as createProfilePromptReader, u as buildTrajectoryBasePrompt, v as ACC_VERSION } from "./message-source-DRkQwfgh.js";
+import { d as constraintCognitiveTrajectory, m as profileMsmWhitelist, n as PLUGIN_SOURCE, o as readLastBound, p as createProfilePromptReader, u as buildTrajectoryBasePrompt, v as ACC_VERSION } from "./message-source-Cq4PsuES.js";
 import { basename, dirname, join, resolve } from "node:path";
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";

package/lib/{settings-H7TVDayZ.js → settings-BI3NRHgC.js}

@@ -1,4 +1,4 @@
-import { f as hostSettings } from "./ccc-roots-BI_4UVcj.js";
+import { f as hostSettings } from "./ccc-roots-CvgsUnFW.js";
 //#region src/surface/settings.ts
 /**
 * 设置面板命名空间 = **profile 条目 id**（v0.1.7 起；与旧 `settings.yaml` 段名逐字相同）。

package/lib/trajectory/core.d.ts

@@ -62,8 +62,22 @@
  * 2026-10-20（D173 兑现，owner 令）：「常驻」= 轨迹的**自我声明**，落地为 **`resident`** 只读动作。
  *   判据：它管的是**被找到**，不是**不被销毁** ⇒ 纯读、不碰生命周期、不进系统提示词。
  *   ⚠️ 这也修正了 v1.77.1 的一处说明面失真（手册曾描述一个**不存在**的动作，D179(a)）。
+ * 2026-10-22（owner 令「在 trajectory 加上触发入口即可，剩下的 CCC 搞定」）：新增
+ *   **`interrupted`** —— 列出**以 `interrupted` 结尾**的 dsh 会话（进程在轮次完成前退出）。
+ *   判据（R↓，为何 ACC 只出**入口**不管周期）：**周期性归属调用方的认知轨迹**，
+ *   ACC 只回答"此刻哪些会话以 interrupted 结尾"这一个问题。⇒ 本动作**纯读**、
+ *   **不判周期、不自动续跑、不改任何会话日志**（是否续、续谁、几点续 = CCC 的事）。
+ *   ⚠️ 判据的锋利处：**只认"以 interrupted 结尾"**，不认"曾经中断过"—— 长会话历史上
+ *   可中断几十次（实测单会话 33 次），按"曾经"判会把早已恢复的会话全部当成待续。
+ * 2026-10-22（owner 追加令「我希望实现的是 continue-all-interrupted 方法，调用后自动找到
+ *   8h 内所有 dsh 会话注入简单的 continue 进行唤醒，这样 CCC 就不用动脑子了」）：
+ *   新增 **`continue-all-interrupted`** = `interrupted` 的**动作版**（扫 → 逐条注入续跑消息）。
+ *   判据（R↓，两者为何并存而不合并）：`interrupted` 是**观察**（只读，零副作用），
+ *   `continue-all-interrupted` 是**动作**（会真起 agent、真消耗算力）。
+ *   ⇒ 观察与动作**必须分开可调用** —— 想看一眼清单却误触发全量续跑，是不可接受的副作用。
+ *   ⚠️ 边界不变：ACC 仍**不判周期**（何时调用归调用方），只是把"调用一次要做完什么"补齐。
  */
-type CognitiveTrajectoryAction = 'list' | 'show' | 'create' | 'use' | 'rebuild' | 'archive' | 'uid' | 'send-now' | 'send-later' | 'cro-guide' | 'resident';
+type CognitiveTrajectoryAction = 'list' | 'show' | 'create' | 'use' | 'rebuild' | 'archive' | 'uid' | 'send-now' | 'send-later' | 'cro-guide' | 'resident' | 'interrupted' | 'continue-all-interrupted';
 export declare const COGNITIVE_TRAJECTORY_ACTIONS: readonly CognitiveTrajectoryAction[];
 /**
  * 读取 Session 事件序列（v1.28.1 适配 0.1.2-rc.1 补齐）：rc.1 起官方 Session 类

package/lib/trajectory/interrupted.d.ts

@@ -0,0 +1,171 @@
+/**
+ * 中断轮次发现（`interrupted` 会话扫描）
+ *
+ * ## 这个模块解决什么
+ *
+ * DSH 的会话日志里，**进程在某一轮完成前退出**（被 kill／崩溃／关机超时）时，
+ * 宿主重放时会为该轮补上收尾事件：
+ *
+ * ```jsonl
+ * turn/end {"turn":66,"reason":{"kind":"interrupted"}}
+ * step/end {"turn":66,"step":85}
+ * session/end-seed {}
+ * ```
+ *
+ * 宿主**只补收尾，不续跑** —— 那一轮的工作就此停在那里。本模块负责把这些会话找出来，
+ * 交给上层（认知轨迹）决定要不要续。
+ *
+ * ## 判据（三条同时成立，缺一不可）
+ *
+ * 1. 日志**最后一条事件是 `session/end-seed`** —— 这是"上一进程已结束、本进程重放"的标记；
+ * 2. 该标记**之前最近的 `turn/end`** 的 `reason.kind === 'interrupted'`；
+ * 3. `session/end-seed` 之后**没有新事件**（由判据 1 保证）。
+ *
+ * ⚠️ **为什么不能只看"存在过 interrupted"**：一个长会话历史上可能中断几十次
+ * （本容器实测单会话 33 次）。只看"曾经中断"会把早已恢复的会话全部当成待续 ⇒ 灾难。
+ *
+ * ## 为什么不整文件解压
+ *
+ * DSH 日志是 **zstd 多帧追加**（实测单会话 24705 帧 / 47 MB）。原生
+ * `zlib.zstdDecompressSync` 只解**第一帧**，对多帧直接报 `Unknown frame descriptor`。
+ * ⇒ 采用**尾部窗口 + 倒序逐帧解压**：只读文件末尾 N 字节，从后往前找帧魔数，
+ *    解到凑够所需事件数即停。实测 8h 窗口 6 个会话 **20 ms**。
+ *
+ * ## 世代识别复用 `cleanup.ts`
+ *
+ * 日志文件名有多个世代（`session.jsonl` / `session.v3.jsonl.zstd` / `session.v4.jsonl.zstd`…），
+ * 宿主按世代写且**迁移保留源文件**。⇒ 本模块**不硬编码文件名**，走
+ * {@link findSessionLog}（与清理／体积统计同一判据），避免"新世代对本模块不可见"。
+ *
+ * ## 边界
+ *
+ * - **只读**：不改任何会话日志。
+ * - **不判周期**：何时扫、扫完做什么归调用方（CCC 的认知轨迹）。本模块只回答
+ *   「此刻哪些会话以 interrupted 结尾」。
+ */
+/** zstd 是否可用（不可用时扫描会返回"读不到事件"，而不是假装成功） */
+export declare const ZSTD_AVAILABLE: boolean;
+/** 默认回看窗口：8 小时（owner 2026-10-22 定） */
+export declare const DEFAULT_LOOKBACK_MS: number;
+/** 日志里被我们识别的事件形状（只取用得到的字段） */
+interface SessionEvent {
+    type?: string;
+    time?: number;
+    data?: {
+        turn?: number;
+        step?: number;
+        reason?: {
+            kind?: string;
+        };
+    };
+}
+/** 一个"以 interrupted 结尾"的会话 */
+export interface InterruptedSession {
+    /** 会话目录名（= dsh 会话 id） */
+    sessionId: string;
+    /** 日志绝对路径（当前世代） */
+    logPath: string;
+    /** 被中断的轮次号 */
+    turn: number | null;
+    /** 日志最后一条事件的时间（epoch ms，取不到则 null） */
+    lastEventAt: number | null;
+    /** 日志文件 mtime（epoch ms） */
+    mtimeMs: number;
+    /** 该轮里"有 call 无 result"的工具名（**尽力而为**，可能因尾部窗口截断而不全） */
+    pendingTools: string[];
+}
+/** 扫描结果 */
+export interface ScanResult {
+    /** 以 interrupted 结尾的会话（最新在前） */
+    sessions: InterruptedSession[];
+    /** 窗口内实际检查的会话数 */
+    scanned: number;
+    /** 窗口内但未命中（含正常结束）的会话数 */
+    skipped: number;
+    /** 读取失败条目（诊断用，不阻断） */
+    errors: Array<{
+        sessionId: string;
+        message: string;
+    }>;
+    /** 扫描耗时（ms） */
+    elapsedMs: number;
+}
+/**
+ * 判定一组尾部事件是否「以 interrupted 结尾」。
+ * 不命中 → null。
+ */
+export declare function detectInterruptedEnd(events: SessionEvent[]): {
+    turn: number | null;
+    pendingTools: string[];
+} | null;
+/**
+ * 扫描一个 **project 目录**（形如 `<sessions-root>/--home-yh-home-home-serenity--/`）。
+ *
+ * @param projectDir DSH 项目目录（其下每个子目录是一个会话）
+ * @param options.lookbackMs 回看窗口（缺省 8h）
+ * @param options.now 注入"当前时刻"（测试用）
+ * @param options.liveIds 需要跳过的会话 id（正在跑的会话不该被判为待续）
+ */
+export declare function scanInterruptedSessions(projectDir: string, options?: {
+    lookbackMs?: number;
+    now?: number;
+    liveIds?: ReadonlySet<string>;
+}): ScanResult;
+/**
+ * 由 CCC 根推导它的 DSH 项目目录名（`--home-yh-home-home-serenity--`）。
+ *
+ * 规则取自宿主：把绝对路径的 `/` 换成 `-`，并在前后各加 `--`。
+ * ⚠️ 这是**推导**，不是真相源 —— 实际目录名以磁盘为准；调用方应在不存在时
+ * 回退到"扫整个 sessions root"或直接报未找到。
+ */
+export declare function projectDirNameForCwd(cwd: string): string;
+/** 单条续跑结果 */
+export interface ResumeOutcome {
+    sessionId: string;
+    /** 是否已把消息投进该会话 */
+    ok: boolean;
+    /** 投递路径：live = 已在跑（直接注入）｜cold-resume = 冷载入后注入 */
+    how?: string;
+    /** 失败原因 */
+    error?: string;
+}
+/**
+ * 续跑正文（**简单、稳定、不含版本号**）。
+ *
+ * 判据（为什么这么短）：本动作的用途是**把被打断的会话推回工作状态**，
+ * 不是替它重述任务 —— 被打断那一轮的上下文就在它自己的日志里。
+ * ⇒ 正文只做三件事：① 说明发生了什么；② 提示**先核对副作用**；③ 让它接着做。
+ *
+ * 🔴 **为什么要写"先核对副作用"**：中断时可能有「有 call 无 result」的工具调用，
+ * 它们的副作用**未知**（可能已写文件 / 已发消息）。若模型把那一轮整段重放，
+ * 会**重复执行**。这句话是给模型的护栏，不是客套。
+ */
+export declare function buildContinueText(sessionId: string, turn: number | null, pendingTools: string[]): string;
+/**
+ * 把一个 agent 唤醒（注入一条续跑消息）。
+ *
+ * 两条路径（与 `wake/scheduler.ts` 的 `sendToCognitiveTrajectory` 同源判据）：
+ * - **live**：`agents.get(id)` 拿得到 ⇒ 目标在跑（或被加载）⇒ `steer` 当场注入当前轮；
+ *   `steer` 不可用则退回 `followup`（宁可排队，不可静默丢）。
+ * - **cold-resume**：`sessionController.resolveAgent(id)` 冷载入后同样注入。
+ *
+ * ⚠️ 冷会话载入**会真起一个 agent**（消耗真实算力）⇒ 调用方必须自己决定要不要，
+ * 本函数不做数量限制（那是策略，归调用者）。
+ */
+export declare function createResumeOne(deps: {
+    agents: {
+        get?: (id: string) => unknown;
+    } | undefined;
+    sessionController: {
+        resolveAgent?: (id: string) => Promise<{
+            agent?: unknown;
+            error?: string;
+        }>;
+    } | undefined;
+    makeMessage: (text: string) => unknown;
+}): (hit: {
+    sessionId: string;
+    turn: number | null;
+    pendingTools: string[];
+}) => Promise<ResumeOutcome>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.87.3",
+  "version": "1.87.5",
   "description": "宁静号 ACC harness（Native Cordis 插件）——给 DeepSeek Harness 装一个「AI 工作区」：14 个工具（container_fs/cognitive_trajectory/dashboard/container_git/msm/praxis/ontology/serenity-skill-creator/cheap-worker/localstore/container_admin；另三个 im-bridge/acc-diag/diagram 按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫/对外输出守卫）+ 认知轨迹日志与原地重建 + 网页登录入口/IM 桥/认知轨迹唤醒注册表。轨迹声明 = 轨迹目录下的 trajectory.json（约束面 + 旧标识 uid + CRO 机器绑定 cro.host；旧名 trajectory-constraint.json / skiff.json 仍在读取族里）；轨迹提示词 = 轨迹目录下的 PROMPT.md（一条轨迹「是谁、按什么章程工作」，所有轨迹通用，追加在容器层与质量层之后，不替换它们）。适配 DSH 0.1.7-rc.1 / 0.2.0-rc.1 / 0.2.1-rc.1（三档）。",
   "license": "MIT",
   "repository": {