@shgroup/dsh-serenity-hooks 1.97.0 → 1.99.0

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.97.0",
+  "version": "1.99.0",
   "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/index.js

@@ -9055,73 +9055,123 @@ const ZSTD_MAGIC = Buffer.from([
 /** 默认回看窗口：8 小时（owner 2026-10-22 定） */
 const DEFAULT_LOOKBACK_MS = 288e5;
 /**
-* 每次从文件尾部读取的字节数。
+* 尾部读取的**渐进块**（从小到大，够用就停）。
 *
-* 🔴 **2026-10-24 从 1 MiB 提到 8 MiB**：与 `TAIL_EVENT_TARGET` 提到 400 配套。
-* 1 MiB 常常装不下 400 个事件（大 step 的 `tool/result` 单条就可几十 KB）——
-* 那样"要 400 个"只是愿望，实际被字节数截断（**两种上限里小的那个说了算**）。
+* 🔴🔴 **2026-10-24 A108：从"一次读满 8 MiB"改成"渐进扩块、见到证据就停"。**
+*
+* 修前：不管需要多少，**先 `readSync` 读满 8 MiB**，再线性扫一遍帧魔数（O(8 MiB)），
+* 然后解压到**攒够 400 条事件**为止 —— 而 400 只是一个**猜的数**：
+* 实测最长单轮 482 行、某会话 `turn/start` 落在 400 条之外 **83 行** ⇒ **证据被截断**，
+* 于是「这一轮没跑完」被读成「这一轮早就干净收尾了」⇒ **漏唤醒**。这就是 A108。
+*
+* ⇒ 现在的判据换成**「要的是证据，不是条数」**：从尾部往前，**一旦同时见到
+*   `turn/start` 与 `turn/end` 就停**（那两条就是判定所需的全部证据）。
+*
+* 💰 实测代价（本机 13 个窗口内会话，中位 3 次）：
+*    · 单会话 **0.2 ~ 54 ms**（多数 1~9 ms）｜13 个合计 **132 ms**；
+*    · 实际读取量多数 **64 KiB**（最多的一个才 4 MiB）—— **远小于修前的恒定 8 MiB**。
+* ⇒ 所以这既是**修正确性**，也是**省开销**（不是"用性能换正确"）。
+*/
+const TAIL_CHUNKS = [
+	65536,
+	262144,
+	1 << 20,
+	4 << 20,
+	8 << 20
+];
+/**
+* 尾部读取的**硬上限**（渐进块的最大一档）。
+*
+* ⚠️ 它仍然存在，因为"扫到边界为止"在病态日志上可能无界（一整轮几十万条事件）。
+* 与修前的区别：修前它是**起点**（无条件读满），现在它是**兜底**（扩到这里还没有证据才算不可判定）。
 */
 const TAIL_WINDOW_BYTES = 8 << 20;
 /**
-* 需要凑够的末尾事件数。
+* 从文件尾部**渐进扩块**倒序解压，**见到判定所需的证据就停**。
 *
-* 🔴🔴 **2026-10-24 从 60 提到 400 —— 这是"啥都扫不到"的直接成因（实测，不是估算）**。
+* ## 与修前的两点不同（都对 A108 负责）
 *
-* 原值 60 的前提是「`turn/end` + `step/end` + `end-seed` 三个事件就在尾部附近」——
-* 那个前提**在"轮内被打断"时完全不成立**：
-*   · 一轮跑到一半死掉 ⇒ 尾部全是 `tool/call` / `tool/result` / `assistant/message` / `step/start`，
-*     **一条 `turn/start`／`turn/end` 都凑不齐**；
-*   · 实测本机 10 个窗口内会话，**4 个**在 60 事件窗口里凑不到 `turn/start`
-*     （被误判成"没开轮"）⇒ 换成 400 事件**全部命中**（turn=56/105/192/24）。
-*   · 最坏一条：57 MB 的日志里，一个 step 就可能塞进几十个 `tool/call`。
+* 1. **不再一次读满 8 MiB**：按 {@link TAIL_CHUNKS} 从 64 KiB 起扩，够用就停。
+*    实测多数会话 64 KiB 就够（见 `TAIL_CHUNKS` 的代价段落）。
+* 2. **停止条件从"攒够 N 条"改成"见到证据"**。⛔ 不要再退回"攒够 400 条" ——
+*    那个数**必然**在长轮次上截断（实测被挤出 83 行）。
 *
-* ⚠️ **这不是"调参"，是判据前提变了**：一旦允许"轮内任意位置中断"这个形态，
-*    尾部窗口就**必须**宽到能跨过一整轮的碎片。
-* 💰 成本：解压帧数上升（实测 6 会话 × 400 事件仍是**几十毫秒**量级）——
-*    用几十毫秒换"不再漏掉一整类"，划算。
-*/
-const TAIL_EVENT_TARGET = 400;
-/**
-* 从文件尾部倒序解压，凑够 `want` 个事件。
+* ## 🔴 什么是「证据」（这里踩过一次，写清楚免得后人重犯）
 *
-* 多帧 zstd 必须**按帧边界**切：从后往前找魔数，每帧用下一帧起始位置当结束边界。
-* 任何一帧解压失败就停下（返回已拿到的）—— 再往前更可能不完整。
+* **必需证据 = 见到一条 `turn/start`**。理由：
+* - 判定形态 B（轮内死掉）只需"最后一条 `turn/start` 之后没有 `turn/end`"——
+*   而**进程死在轮内时，宿主根本没机会写 `turn/end`** ⇒ 若要求"必须见到 turn/end"，
+*   **这一整类会被判成"不可判定"**（我第一版就是这么写的，被 `形态 B` 用例当场打红）。
+* - `turn/end` 是**可选证据**：见到它能让形态 A（收尾原因）也成立，但它**不是判定的前提**。
+*
+* ⇒ 停止条件：**见到 `turn/start` 即可停**（`turn/end` 顺手见到更好）。
+* ⇒ 只有**连一条 `turn/start` 都见不到**才报 `exhausted`（那才是真的"不知道"）——
+*   典型成因：一整轮长到 8 MiB 都装不下它的起点。
+*
+* ⚠️ 另一种"见不到 turn/start"的合法情况：**日志里从来没有过轮**（空会话／只有 header）。
+*   ⇒ 那种情况扩到**全文**（`winBytes >= st.size`）仍见不到 ⇒ 判 `exhausted: false`
+*   （**"没有轮"是确定的，不是不知道**），由判据函数返回 null ⇒ 进 `skipped`。
 */
-function readTailEvents(logPath, want) {
-	if (zstdDecompressSync === void 0) return [];
+function readTailEvents(logPath) {
+	if (zstdDecompressSync === void 0) return {
+		events: [],
+		exhausted: false
+	};
 	const st = statSync(logPath);
-	const windowBytes = Math.min(TAIL_WINDOW_BYTES, st.size);
-	if (windowBytes < 8) return [];
-	const buf = Buffer.alloc(windowBytes);
+	if (st.size < 8) return {
+		events: [],
+		exhausted: false
+	};
 	const fd = openSync(logPath, "r");
 	try {
-		readSync(fd, buf, 0, windowBytes, st.size - windowBytes);
+		for (const chunk of TAIL_CHUNKS) {
+			const winBytes = Math.min(chunk, st.size);
+			const buf = Buffer.alloc(winBytes);
+			readSync(fd, buf, 0, winBytes, st.size - winBytes);
+			const offsets = [];
+			for (let i = 0; i <= winBytes - ZSTD_MAGIC.length; i++) if (buf[i] === ZSTD_MAGIC[0] && buf[i + 1] === ZSTD_MAGIC[1] && buf[i + 2] === ZSTD_MAGIC[2] && buf[i + 3] === ZSTD_MAGIC[3]) offsets.push(i);
+			const events = [];
+			let sawStart = false;
+			for (let k = offsets.length - 1; k >= 0; k--) {
+				const start = offsets[k];
+				const end = k + 1 < offsets.length ? offsets[k + 1] : winBytes;
+				let text;
+				try {
+					text = zstdDecompressSync(buf.subarray(start, end)).toString("utf8");
+				} catch {
+					break;
+				}
+				const batch = [];
+				for (const line of text.split("\n")) {
+					if (!line.trim()) continue;
+					try {
+						const ev = JSON.parse(line);
+						batch.push(ev);
+						if (ev.type === "turn/start") sawStart = true;
+					} catch {}
+				}
+				events.unshift(...batch);
+				if (sawStart) return {
+					events,
+					exhausted: false
+				};
+			}
+			if (winBytes >= st.size) return {
+				events,
+				exhausted: false
+			};
+			if (winBytes >= TAIL_WINDOW_BYTES) return {
+				events,
+				exhausted: true
+			};
+		}
+		return {
+			events: [],
+			exhausted: true
+		};
 	} finally {
 		closeSync(fd);
 	}
-	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);
 }
 /**
 * 判定一组尾部事件是否「以未完成的轮次结尾」。
@@ -9315,7 +9365,8 @@ function scanInterruptedSessions(projectDir, options = {}) {
 		skipped: 0,
 		errors: [],
 		elapsedMs: 0,
-		excluded: []
+		excluded: [],
+		undecidable: []
 	};
 	if (!existsSync(projectDir)) {
 		result.elapsedMs = Date.now() - t0;
@@ -9356,7 +9407,26 @@ function scanInterruptedSessions(projectDir, options = {}) {
 		if (mtimeMs < cutoff) continue;
 		result.scanned++;
 		try {
-			const events = readTailEvents(logPath, TAIL_EVENT_TARGET);
+			const tail = readTailEvents(logPath);
+			const events = tail.events;
+			/**
+			* 🔴🔴 **A108：拿不到判定所需证据时，报「不可判定」，⛔ 不许塌成「没中断」。**
+			*
+			* `tail.exhausted` 的判据 = 扩到 8 MiB 硬上限仍**没能同时见到** `turn/start` 与 `turn/end`。
+			* 那时两个判据函数都会返回 null（它们只看「见到的那些事件」）——
+			* 而「没证据」与「证据说没事」在返回值上长得一样，**这正是 A108 的漏**。
+			* ⇒ 所以这一格必须**在调用它们之前**分流。
+			*/
+			if (tail.exhausted) {
+				result.undecidable.push({
+					sessionId,
+					logPath,
+					mtimeMs,
+					lastEventAt: typeof events[events.length - 1]?.time === "number" ? events[events.length - 1].time : null,
+					reason: `扩到 ${Math.round(TAIL_WINDOW_BYTES / 1048576)} MiB 硬上限仍未同时见到 turn/start 与 turn/end`
+				});
+				continue;
+			}
 			/**
 			* 🔴🔴 **两种形态都要接**（2026-10-24 owner 报障：「我要求你抓到非工具调用的中断，
 			* 现在什么都抓不到了」）。
@@ -11142,18 +11212,33 @@ function renderInterruptedScan(input) {
 	const { projectDir, lookbackHours, scan } = input;
 	const lines = [];
 	const excludedCount = scan.excluded.length;
+	const undecidableCount = scan.undecidable.length;
 	lines.push(`═══ 末轮未跑完的 dsh 会话（回看 ${lookbackHours}h）═══`);
 	lines.push(`  扫描域: ${projectDir}`);
-	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped}` + (excludedCount > 0 ? ` · 排除在跑 ${excludedCount} 个` : "") + ` · 耗时 ${scan.elapsedMs}ms${scan.errors.length > 0 ? ` · 读取失败 ${scan.errors.length}` : ""}`);
+	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped}` + (excludedCount > 0 ? ` · 排除在跑 ${excludedCount} 个` : "") + ` · 不可判定 ${undecidableCount} 个 · 耗时 ${scan.elapsedMs}ms${scan.errors.length > 0 ? ` · 读取失败 ${scan.errors.length}` : ""}`);
 	if (excludedCount > 0) {
 		lines.push(`  ⓘ 窗口内共 ${scan.scanned + excludedCount} 个会话，其中 ${excludedCount} 个**此刻有轮次在跑**，按「正在跑的不该被判为待续」的纪律被排除：`);
 		for (const id of scan.excluded) lines.push(`      - ${id}`);
 		lines.push("    ⚠️ 这些**没有**被检查过。若你认为其中某个其实已死（进程重启后残留的\"在跑\"标记），");
 		lines.push("      请告知 ACC 维护方 —— 那是「在跑」表的判据问题，不是扫描的问题。");
 	}
+	if (undecidableCount > 0) {
+		lines.push("");
+		lines.push(`  ⚠️ **不可判定 ${undecidableCount} 个** —— 这些**既不是"命中"也不是"没事"**，是"判不出来"：`);
+		for (const u of scan.undecidable) {
+			const at = u.lastEventAt !== null ? new Date(u.lastEventAt).toISOString() : "(时间未知)";
+			lines.push(`      - ${u.sessionId}（末事件 ${at}）`);
+			lines.push(`        ${u.reason}`);
+		}
+		lines.push("    ⇒ 成因通常是：**一整轮长到 8 MiB 都装不下它的起点**（`turn/start` 在窗口之外）。");
+		lines.push("    🔴 **是否处理由你决定**（ACC 不代判）。本仓纪律：**宁可多醒不可漏** ⇒ 倾向按\"该接走\"处理。");
+	}
 	if (scan.sessions.length === 0) {
 		lines.push("");
-		lines.push(excludedCount > 0 ? `✓ 被检查的 ${scan.scanned} 个里没有末轮未跑完的 —— 另有 ${excludedCount} 个在跑，未检查（见上）。` : "✓ 没有末轮未跑完的会话 —— 无需处理。");
+		const tails = [];
+		if (excludedCount > 0) tails.push(`另有 ${excludedCount} 个在跑，未检查`);
+		if (undecidableCount > 0) tails.push(`另有 ${undecidableCount} 个**不可判定**`);
+		lines.push(tails.length > 0 ? `✓ 被检查的 ${scan.scanned} 个里没有末轮未跑完的 —— ${tails.join("；")}（见上）。` : "✓ 没有末轮未跑完的会话 —— 无需处理。");
 		return lines.join("\n");
 	}
 	lines.push("");
@@ -11194,14 +11279,22 @@ function renderContinueResult(input) {
 	const { projectDir, lookbackHours, scan, outcomes, dryRun } = input;
 	const lines = [];
 	const excludedCount = scan.excluded.length;
+	const undecidableCount = scan.undecidable.length;
 	const head = dryRun ? "续跑预告（dryRun，未注入任何消息）" : "中断续跑结果";
 	lines.push(`═══ ${head}（回看 ${lookbackHours}h）═══`);
 	lines.push(`  扫描域: ${projectDir}`);
-	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped}` + (excludedCount > 0 ? ` · 排除在跑 ${excludedCount} 个` : "") + ` · 耗时 ${scan.elapsedMs}ms`);
+	lines.push(`  检查 ${scan.scanned} 个 · 命中 ${scan.sessions.length} · 跳过 ${scan.skipped}` + (excludedCount > 0 ? ` · 排除在跑 ${excludedCount} 个` : "") + ` · 不可判定 ${undecidableCount} 个 · 耗时 ${scan.elapsedMs}ms`);
 	if (excludedCount > 0) lines.push(`  ⓘ 另有 ${excludedCount} 个会话**此刻有轮次在跑**，未检查：${scan.excluded.join("、")}`);
+	if (undecidableCount > 0) {
+		lines.push(`  ⚠️ 另有 ${undecidableCount} 个**不可判定**（既非同中、也非没事），**未处理**：` + scan.undecidable.map((u) => u.sessionId).join("、"));
+		lines.push("    ⇒ 若要处理它们，须人工/调用方判断（ACC 不代判）。");
+	}
 	if (scan.sessions.length === 0) {
 		lines.push("");
-		lines.push(excludedCount > 0 ? `✓ 被检查的 ${scan.scanned} 个里没有末轮未跑完的 —— 另有 ${excludedCount} 个在跑，未续（见上）。` : "✓ 没有末轮未跑完的会话 —— 无需续跑。");
+		const tails = [];
+		if (excludedCount > 0) tails.push(`另有 ${excludedCount} 个在跑，未续`);
+		if (undecidableCount > 0) tails.push(`另有 ${undecidableCount} 个不可判定`);
+		lines.push(tails.length > 0 ? `✓ 被检查的 ${scan.scanned} 个里没有末轮未跑完的 —— ${tails.join("；")}（见上）。` : "✓ 没有末轮未跑完的会话 —— 无需续跑。");
 		return lines.join("\n");
 	}
 	lines.push("");
@@ -11336,43 +11429,18 @@ function createCognitiveTrajectoryTool(ctx) {
 	return defineTool({
 		name: "cognitive_trajectory",
 		description: [
-			"A COGNITIVE TRAJECTORY is a durable body (SESSION.md) that outlives every conversation carrying it.",
-			"AXIOM 1 — THE TRAJECTORY IS THE SUBJECT; THE CONVERSATION IS ITS CARRIER. Rebuilding the carrier replaces the conversation and leaves SESSION.md byte-identical.",
-			"AXIOM 2 — A TRAJECTORY HAS NO LIFECYCLE. It never completes, closes, or expires, and age never counts against it. The only thing that changes is WHERE it is stored: archive moves it out of the active list without touching its directory.",
-			"AXIOM 3 — IDENTITY IS THE CODE: the fixed-position segment of the directory name `YYYY-MM-DD--<code>[--<desc>]`. The code (not the summary, not the title) is the unique identifier, and create --id lets you choose it.",
-			"DOES NOT: this tool never deletes a trajectory, never edits SESSION.md content, and never schedules recurring work (that is cro-guide).",
-			"ENTITIES. TRAJECTORY = a directory under AGENT_SESSIONS/ holding SESSION.md. CARRIER = a dsh session bound to it. BINDING DECLARATION = the file `<trajectory>/current.dsh_session_bind` — ONE FILE PER TRAJECTORY, a single slot, never a table.",
-			"IMMUTABLE 1 — ONE SESSION BELONGS TO AT MOST ONE TRAJECTORY, FOR LIFE. use refuses to move a session that already carries a different trajectory. There is NO --force override (retired 2026-10-20; passing it returns a refusal explaining why). To give another trajectory a carrier, open a new session.",
-			"IMMUTABLE 2 — ONE TRAJECTORY HAS AT MOST ONE CURRENT CARRIER, and THE BINDING DECLARATION IS THE ONLY TRUTH. If several dsh sessions happen to be open, only the one named in the declaration carries the trajectory; the others are simply unbound. Never infer a binding from \"a session looks active\".",
-			"IMMUTABLE 3 — A DECLARATION WHOSE SESSION NO LONGER EXISTS COUNTS AS UNBOUND. No cleanup is ever required, and a stale declaration is deliberately left in place: it records who carried this trajectory last.",
-			"ACTIONS, GROUPED BY EFFECT — read the grouping before choosing, because it answers \"does this change what I am bound to?\":",
-			"(A) LIFECYCLE — changes which cognitive trajectory THIS conversation is bound to:",
-			"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 did not finish — reason.kind is \"interrupted\" (process died; the host synthesised the closer on resume) OR \"aborted\" (terminated normally: restart, dispose, user cancel). Both mean \"this turn did not complete\"; picking only one misses an entire class. 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 \"the last turn did not finish\", 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).",
-			"want THIS conversation to move ⇒ use. It refuses if this session already carries another trajectory (IMMUTABLE 1) — that refusal is the design, not an error to work around.",
-			"want to make another trajectory act ⇒ send-now. The target needs no prior setup: if it has no live session, one is created and bound automatically, and your message is injected.",
-			"RECEIPTS (read no more than is written): send-now returns a synchronous receipt meaning exactly \"injected / turn started\" — NEVER \"the target ran or replied\". To prove the target actually moved, read its SESSION.md.",
-			"send-now never queues behind the current turn: a busy target is steered mid-turn (read in the CURRENT turn), an idle target starts a turn at once.",
-			"send-later is fire-and-forget by design: no receipt, no recall, no panel.",
-			"ASYMMETRY (deliberate): send-now may create a missing carrier; send-later NEVER does. Scheduling for a trajectory that never existed is almost always a mistyped name, and auto-creating would hide that error.",
-			"CARRIER GUARD: send-now auto-creates a carrier ONLY for a trajectory that has never had one. If a declaration exists but its session is gone, it refuses and says so — one trajectory keeps one carrier. Two independent gates can refuse: (a) the declared session cannot be resolved at all; (b) it existed and is now gone.",
-			"PARAMETERS: create needs --desc <desc> [--id <code>] [--goal], OR --issue <ticket> (exactly one), PLUS --summary (≤20 chars).",
-			"use needs --name + --summary (≤20 chars). --force is ACCEPTED BUT REFUSED (retired): it exists only to explain why.",
-			"rebuild needs --summary (next-phase, ≤20 chars) + optional --note (≤200 chars, task focus for the rebuilt self).",
-			"send-now needs target + message. send-later needs target + at (RFC3339 with timezone, or +30m / +2h) + message.",
-			"target/name accept a code (S### or custom), a full AGENT_SESSIONS directory name, or a fuzzy keyword.",
-			"AUTHORIZATION (read before creating anything): create and send-now both cost real work and must serve a human intent. Call create only when the user asked for a new line of work (or confirmed it) — never to \"tidy up\" or pre-provision what nobody requested. When in doubt, ask instead of creating. This is a behavioral rule, not a mechanical gate: treat it as etiquette with a cost.",
-			"uid: READS a legacy TRAJECTORY-UID only. Setting one is retired — a trajectory's code is its identity now; use create --id <code>.",
-			"summary is appended to the dsh session title as <code>-<date>-<summary>; the code and date stay server-derived unless you pass --id.",
-			"SELF-DECLARATION MANUAL — how to write your own charter (PROMPT.md), declare yourself resident",
-			"(trajectory.json `resident.serves`), or restrict yourself (tool/model whitelists):",
-			"container_admin config docs trajectory-self. Read it before changing any file in your own directory."
-		].join(" "),
+			"A cognitive trajectory is a durable body — its SESSION.md — that outlives every conversation carrying it.",
+			"Three axioms hold. The trajectory is the subject and the conversation is only its carrier, so rebuilding the carrier leaves SESSION.md byte for byte identical. A trajectory has no lifecycle: it never completes, closes, or expires, and its age never counts against it — only where it is stored changes, so archiving removes it from the active list without touching its directory. And identity is the code, the fixed `YYYY-MM-DD--<code>[--<desc>]` segment of the directory name, never the summary or the title; create --id chooses it.",
+			"What this tool never does: it never deletes a trajectory, never edits the content of SESSION.md, and never schedules recurring work, because that belongs to cro-guide.",
+			"A trajectory is a directory under AGENT_SESSIONS/ holding a SESSION.md, a carrier is a dsh session bound to one, and the binding declaration is the file current.dsh_session_bind inside the trajectory: one file per trajectory, a single slot, never a table.",
+			"Three rules are immutable. A session belongs to at most one trajectory for its whole life, so use refuses a session already carrying another, and there is no --force override — that flag was retired on 2026-10-20 and now only explains why; to give another trajectory a carrier, open a new session. A trajectory has at most one current carrier, and the binding declaration is the only truth about which, so other open sessions are simply unbound; never infer a binding from a session looking active. A declaration whose session no longer exists counts as unbound, and no cleanup is required, because a stale declaration deliberately records who carried the trajectory last.",
+			"Actions are grouped by effect, and the grouping answers one question: would this change what I am bound to? The lifecycle group does change this conversation's binding — list, show, create, use, rebuild, and archive, where archiving is one-way, never overwrites, and leaves content untouched. The delivery group sends one message to another trajectory and leaves your own binding alone — send-now and send-later. One action is a reference rather than an operation: cro-guide explains how to give a trajectory its own program deciding when it should be woken. The inspection action is read-only: interrupted returns the dsh sessions whose last turn did not finish. A turn is unfinished when its reason.kind is \"interrupted\", meaning the process died, or \"aborted\", meaning it ended normally through a restart, a dispose, or a cancel; both mean the turn did not complete, so taking only one would miss a whole class. It schedules nothing, continues nothing, and mutates no log — deciding whether and when to resume belongs to the caller. The criterion is exactly \"the last turn did not finish\", never \"was ever interrupted\", since one long session may have been interrupted dozens of times and already recovered. Each hit also names the turn number and the tools that made a call without a result, but those side effects are unknown, so do not re-run them blindly.",
+			"Choose by rule, not by guess. Not yet bound and starting new work: create, which activates itself at once when there is no prior binding. Already bound and recording a separate future line: also create, since that leaves your binding intact and you can activate it later with send-now. Want this conversation to move: use, and treat its refusal — when the session already carries another trajectory — as the design rather than an error to work around. Want another trajectory to act: send-now, whose target needs no prior setup, since a live session is created, bound, and injected when none exists.",
+			"Read a receipt for no more than it says. send-now returns a synchronous receipt meaning the message was injected and the turn started; it never means the target ran or replied, and to prove the target moved you must read its SESSION.md. send-now never queues behind the current turn — a busy target is steered mid-turn while an idle one starts at once. send-later is fire-and-forget by design, with no receipt and no recall.",
+			"The asymmetry is deliberate: send-now may create a missing carrier, send-later never does, because scheduling work for a trajectory that never existed is almost always a mistyped name. A carrier guard applies to send-now: it creates a carrier automatically only for a trajectory that has never had one, and otherwise refuses, either because a declaration exists but its session is gone or because the declared session cannot be resolved at all — one trajectory keeps one carrier.",
+			"For parameters: create needs --desc with optional --id and --goal, or --issue instead, exactly one of those two forms, plus --summary of at most 20 characters. use needs --name and --summary. rebuild needs --summary naming the next phase in at most 20 characters, plus an optional --note of at most 200 characters stating the task focus for the rebuilt self. send-now needs a target and a message; send-later needs a target, an instant as RFC 3339 with a timezone or a relative form like +30m or +2h, and a message. A target or name may be a code such as S### or a custom one, a full AGENT_SESSIONS directory name, or a fuzzy keyword. --force is still accepted but always refused, being retired and existing only to explain why. uid reads a legacy TRAJECTORY-UID only, since setting one is retired and the code is now the identity. summary is appended to the dsh session title alongside the code and date, which stay server-derived unless you pass --id.",
+			"Two rules of conduct, not operations. create and send-now both cost real work and must serve a human intent, so call create only when the user asked for a new line of work or confirmed one — never to tidy up and never to pre-provision what nobody requested; when in doubt, ask. That is etiquette with a cost rather than a mechanical gate. And to describe yourself rather than operate: your own charter in PROMPT.md, a resident declaration through resident.serves in trajectory.json, and self-restriction by tool and model whitelists all live in container_admin config docs trajectory-self — read that chapter before changing any file in your own directory."
+		].join("\n\n"),
 		parameters: {
 			action: {
 				type: "string",

package/lib/trajectory/interrupted.d.ts

@@ -56,6 +56,22 @@
 export declare const ZSTD_AVAILABLE: boolean;
 /** 默认回看窗口：8 小时（owner 2026-10-22 定） */
 export declare const DEFAULT_LOOKBACK_MS: number;
+/**
+ * 🔵 **`TAIL_EVENT_TARGET`（原值 400）已于 2026-10-24 A108 删除** —— 它是**猜的数**，
+ * 而猜错的代价是**漏唤醒**：实测最长单轮 482 行，某会话的 `turn/start` 落在 400 条之外
+ * **83 行** ⇒ 证据被截断 ⇒「没跑完」被读成「早就干净收尾」。
+ *
+ * ## 换成什么了
+ * 停止条件改成**「见到证据就停」**（同时见到 `turn/start` 与 `turn/end`），见
+ * {@link readTailEvents} 与 {@link TAIL_CHUNKS}。
+ *
+ * 🔴 **宿主自己的权威判据也不数条数**：`@deepseek-ai/dsh-session` 的 `openTurnClosers`
+ * **遍历全量事件**、只维护一个 `openTurn` 状态（`turn/start` 置、`turn/end` 清），
+ * 扫完 `openTurn !== null` 即"这一轮没收"。它**没有窗口**。
+ * ⚠️ 我们不照搬它，是因为它要读**全量**日志（崩溃恢复只在载入时做一次，负担得起），
+ * 而本扫描**每 5min × 全部会话** —— 照搬会烧穿。⇒ 我们取它的**结论形态**（要证据、要能说"不知道"），
+ * 不取它的**读法**（全量）。
+ */
 /** 日志里被我们识别的事件形状（只取用得到的字段） */
 interface SessionEvent {
     type?: string;
@@ -138,6 +154,27 @@ export interface ScanResult {
      *   任何"我替你把某些东西藏起来"的实现，都必须报告藏了几个、藏了谁。
      */
     excluded: string[];
+    /**
+     * 🔴🔴 **A108 第二半（2026-10-24）：判不出来的那些。**
+     *
+     * **为什么必须单开一桶**：修前「扩到上限仍见不到轮次边界」与「确实没有未完成轮次」
+     * **返回值一模一样**（都是"没命中"）⇒ **"不知道"被塌成"没中断"** ⇒ 漏唤醒。
+     *
+     * 判据：`exhausted` ＝ 扩到 {@link TAIL_WINDOW_BYTES} 硬上限仍**没能同时见到**
+     * `turn/start` 与 `turn/end`。典型成因：**一整轮长到 8 MiB 都装不下**。
+     *
+     * ⚠️ **这两条口径不许合并**（与 `excluded` 同理，D245 同族）：
+     * - `skipped` ＝ **看过了，判定是"没事"**；
+     * - `undecidable` ＝ **没看到足够的东西，不敢判**。
+     * ⇒ 调用方拿到 `undecidable` 非空时**必须自己决定**（本仓纪律：宁可多醒不可漏）。
+     */
+    undecidable: Array<{
+        sessionId: string;
+        logPath: string;
+        mtimeMs: number;
+        lastEventAt: number | null;
+        reason: string;
+    }>;
 }
 /**
  * 尾部窗口里**最后一条 `turn/start` 的轮号**（D244 输出面，给调用方做 A108 的现场判断）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.97.0",
+  "version": "1.99.0",
   "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": {