@shgroup/dsh-serenity-hooks 1.79.1 → 1.79.2

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.79.1",
+  "version": "1.79.2",
   "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

@@ -3,8 +3,8 @@ import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebSe
 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 sessionEvents, B as isoLocal, C as listSessions, E as parseTrajectoryCode, F as trajectoryDescOf, H as localHuman, I as useSession, L as TRAJECTORY_FILENAME, M as setActiveSessionInfo, N as showSession, O as readTrajectoryUid, P as summarize, R as TRAJECTORY_LEGACY_FILENAMES, S as listActiveTrajectories, T as parseSessionContextFromEvents, U as localIdStamp, V as localFileStamp, _ as createSession, a as readTrajectoryConstraintAt, b as getActiveSessionInfo, c as trajectoryConstraintForSession, f as COGNITIVE_TRAJECTORY_ACTIONS, g as clearActiveSessionInfo, h as archiveSession, j as sessionsRoot, k as resolveSessionByTitle, m as UID_FILENAME, n as isTrajectoryConstrained, o as readTrajectoryConstraintByCode, r as listTrajectoryConstraints, s as replacesDefaultIdentity, t as TRAJECTORY_CONSTRAINT_FILENAME, v as extractSessionMdPathFromText, w as namingTitleFor, y as findSession, z as readTrajectoryFile } from "./profile-C7BuyZK7.js";
 import { n as checkLocalstoreGitCompliance, o as readStore, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./service-DDmHSglV.js";
-import { _ as ACC_VERSION, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as resolveConstraintSystemPrompt, 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 findPackageRoot } from "./message-source-BOG0piL8.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-BxDVrxPH.js";
+import { _ as ACC_VERSION, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as resolveConstraintSystemPrompt, 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 findPackageRoot } from "./message-source-BJO5q-rD.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-B4eZD3Hv.js";
 import { n as hasSessionLogById, r as sessionsRootDir } from "./cleanup-C-92qnDs.js";
 import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-Bb4OnEdI.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
@@ -7113,6 +7113,102 @@ function createCheapWorkerTool(ctx) {
 	});
 }
 //#endregion
+//#region src/trajectory/alive.ts
+/**
+* trajectory/alive.ts — **"这个 dsh 会话还活着吗"的唯一判据**（owner 2026-10-20 裁决）
+*
+* ## owner 的原话（本模块的全部设计依据）
+*
+* > 「死应该包含归档判断；只有 ① 或者 ②且不在归档集 才算活」
+* > 「use 只要被调用了，可以无条件覆盖绑定到当前会话（这说明当前会话肯定活着啊）」
+*
+* ## 为什么必须收成一个判据（在此之前有三个互不一致的判据）
+*
+* | # | 判据 | 旧实现位置 | 单独使用时的漏洞 |
+* |---|---|---|---|
+* | ① | 进程内 loaded agent | `hostAgents(ctx).get(id)` | 冷会话全判死 |
+* | ② | 磁盘上有会话日志 | `hasSessionLogById()` | **归档后日志逐字节不动** ⇒ 归档会话判活 |
+* | ③ | 宿主归档集 | `workspaceRegistry.archivedSessionIds` | 旧 dsp **零引用**（整个仓库 0 处） |
+*
+* 宿主的归档语义是**只往集合里加一个 id、不动日志**（`dsh-workspace` 的
+* `archiveSession` 注释：「Archiving never touches workspace accounting」）。
+* ⇒ 只问 ② 的实现在归档上**必然判错**，而那个错误没有任何机械信号。
+*
+* ## 判据（owner 给定，逐字实现）
+*
+* ```text
+* 活 ⟺ ①                       （进程内 loaded ⇒ 一定在）
+*    ∨ (② ∧ 不在归档集)          （日志在、且没人把它归档掉）
+* ```
+*
+* 🔴 **一处对原话的收紧（必须说出来，不许默默改）**：owner 的 ① 未附加"不在归档集"，
+* 而本模块把**归档判定排在最前** —— 即 `归档 ∧ live ⇒ 判死`。理由：归档是**人对这条会话
+* 的处置声明**（宿主会把它从所有分组面隐藏），若仍被当成载体，唤醒调度器会去驱动一条
+* **使用者以为已经收起来**的会话。⚠️ 与字面规则的差异仅此一格；`use` 不受影响
+* （见下方 §use 逃生门），因此真需要复活一条已归档会话时**仍然有受支持的路**。
+*
+* ## 🔴 `use` 的逃生门（owner 第二条，写在调用点）
+*
+* **`use` 不查存活**：它被调用这件事本身证明**当前会话活着**（本模块的被测对象是
+* "别人写的那个 id"，而 `use` 手里拿的是**自己**）。⇒ `use` 走无条件覆盖
+* （`claimBinding` 的 `takeover`），因此**判据再严也不会把一条轨迹锁死**。
+* 这条逃生门是判据可以取严的前提，两者必须一起存在。
+*
+* ## 依赖纪律
+*
+* 纯判据 `isSessionAlive` 零依赖、可单测；宿主面只在 `hostAliveProbe` 里，
+* 且**不抛错**（服务缺失 ⇒ 该维度作废，而不是让 ACC 工具整块失败）。
+*/
+/** 宿主侧的归档集读取（不可用 ⇒ 空集 = 该维度作废，**不是**把所有会话判死） */
+function archivedIdsOf(ctx) {
+	try {
+		const ids = hostService(ctx, "workspaceRegistry")?.archivedSessionIds;
+		return new Set(Array.isArray(ids) ? ids : []);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/**
+* **宿主面的判活探针**（`(sessionId) => boolean`）——所有需要"这条会话还活着吗"的
+* 生产代码都应当用这一个，不要自己拼 `agents.get` ＋ `hasSessionLogById`。
+*
+* 语义 = {@link isSessionAlive}，其中：
+*  · `liveIds` 因为宿主只给 `get(id)` 而**按 id 逐次问**（不是集合）；
+*  · `archivedIds` 在**首次调用时**取一次快照并在闭包内复用（每 tick 一个探针，
+*    归档集在一个 tick 内不变）—— 避免为每条轨迹重复读存储域。
+*
+* ⚠️ **快照的代价**：同一探针内若有人中途归档了某会话，本探针直到下次新建才看见。
+*    调度器是每 tick 新建一个探针（见 `wake/scheduler.ts`），故实际窗口 ≤1 tick。
+*
+* @param ctx 插件上下文（取 `agents` 与 `workspaceRegistry`）
+* @returns 探针；**永不抛**
+*/
+function hostAliveProbe(ctx) {
+	let archived;
+	const archivedOnce = () => archived ??= archivedIdsOf(ctx);
+	return (sessionId) => {
+		if (typeof sessionId !== "string" || sessionId === "") return false;
+		if (archivedOnce().has(sessionId)) return false;
+		try {
+			if (hostAgents(ctx)?.get?.(sessionId)) return true;
+		} catch {}
+		try {
+			return hasSessionLogById(sessionsRootDir(), sessionId);
+		} catch {
+			return true;
+		}
+	};
+}
+/**
+* 判据只有**两个**出口，别再开第三个：
+*  · {@link isSessionAlive} —— 纯判据（给定事实），单测的靶子；
+*  · {@link hostAliveProbe} —— 生产入口（自己去宿主与磁盘取事实）。
+*
+* ⚠️ 曾有一个 `aliveFactsFor`（把探针摊平成 `SessionAliveFacts`），**全仓零调用点**，
+* 已删除 —— 留一个"看起来有用、实际无人调用"的导出，会让下一个人以为存在第二条判活路径
+* （本仓同族教训：`cheapWorkerPresetInheritance` 全仓零调用点 ⇒ 接线断了却看不出来）。
+*/
+//#endregion
 //#region src/wake/registry.ts
 /**
 * wake/registry.ts — 认知轨迹唤醒注册表（D58，S142 2026-09-13）
@@ -9065,7 +9161,7 @@ function wakeSchedulerState() {
 */
 async function acquireWakeAgent(ctx, root, dirName) {
 	const agents = hostAgents(ctx);
-	const ids = listBoundSessionIds(root, dirName);
+	const ids = listBoundSessionIds(root, dirName, hostAliveProbe(ctx));
 	for (const id of ids) {
 		const live = agents?.get?.(id);
 		if (live) return {
@@ -9221,14 +9317,7 @@ async function sendToCognitiveTrajectory(ctx, root, target, message, sender) {
 	let createdNote = "";
 	if ("error" in acquired) {
 		if (!acquired.notReady && acquired.noBinding === true) {
-			const carrier = carrierState(root, t.dirName, (id) => {
-				if (hostAgents(ctx)?.get?.(id)) return true;
-				try {
-					return hasSessionLogById(sessionsRootDir(), id);
-				} catch {
-					return true;
-				}
-			});
+			const carrier = carrierState(root, t.dirName, hostAliveProbe(ctx));
 			if (carrier.state !== "never") {
 				const why = carrier.state === "occupied" ? `该轨迹曾经由会话 ${carrier.sessionId} 承载，而它此刻不在了` : `该轨迹当前由会话 ${carrier.sessionId} 承载`;
 				return {
@@ -9613,7 +9702,7 @@ async function runCroPhase(ctx, root, registry, log) {
 			log.push(`· ${root}: ${dirName}: CRO 机器绑定未通过（${verdict.code}）：${verdict.detail}`);
 			continue;
 		}
-		const bound = listBoundSessionIds(root, dirName);
+		const bound = listBoundSessionIds(root, dirName, hostAliveProbe(ctx));
 		const running = runningCarriersOf(bound, nowMs);
 		const outcome = await evaluateCro(root, dirName, readCroSnapshotInput(root, dirName, nowMs, {
 			boundSessionIds: bound,
@@ -10380,10 +10469,12 @@ function createCognitiveTrajectoryTool(ctx) {
 					const info = getActiveSessionInfo(scope);
 					if (info) renameDshSessionForActive(ctx, exec, info, args.summary);
 					const dsh = agentDshSession(exec);
-					if (dsh && info) appendBound(dsh, "activate", {
+					let bound = null;
+					if (dsh && info) bound = appendBound(dsh, "activate", {
 						dirName: info.dirName,
 						mdPath: info.mdPath,
-						sessionId: info.sessionId
+						sessionId: info.sessionId,
+						alive: hostAliveProbe(ctx)
 					});
 					const advisory = advisoryHint(targetEntry.dirName, join(targetEntry.path, "SESSION.md"));
 					const out = {
@@ -10392,6 +10483,11 @@ function createCognitiveTrajectoryTool(ctx) {
 						context: active.context
 					};
 					if (advisory) out.advisory = advisory;
+					if (bound === true) out.binding = "written";
+					else if (bound === false) {
+						out.binding = "not-written";
+						out.bindingHint = `绑定未写入：本会话取不到可用的 header（id / cwd 缺一不可）⇒ 按契约「绑定声明是唯一真相」，「${info?.dirName ?? targetEntry.dirName}」此刻仍是**未绑定**。 会话标题变了**不能**当作绑定成功的证据（改名走的是另一条通路）。 详见宿主日志里的 \`✗ 绑定未写入（SESSION_HEADER_UNRESOLVED）\`。`;
+					}
 					return out;
 				}
 				case "rebuild": {
@@ -14652,8 +14748,11 @@ const HOST_SERVICES = [
 		members: [{
 			name: "list",
 			kind: "function"
+		}, {
+			name: "archivedSessionIds",
+			kind: "value"
 		}],
-		impact: "工作区白名单下拉为空（外部访问配置受限）",
+		impact: "CCC 自动发现回落失效 ＋ **归档状态不可知**（已归档会话会被误判成活载体）",
 		required: false
 	},
 	{

package/lib/{message-source-BOG0piL8.js → message-source-BJO5q-rD.js}

@@ -326,6 +326,8 @@ const BIND_FILENAME = "current.dsh_session_bind";
 * （上游改名、下游写死旧名 ⇒ 症状与真因在读数上完全不像）。
 */
 const BIND_FILENAME_FAMILY = [BIND_FILENAME];
+/** 轨迹归档区的目录名（**自持一份，不从 `core.ts` import**）。 */
+const ARCHIVED_DIR_NAME = "_archived";
 /** 校验一条声明（容忍手改 / 部分字段缺失） */
 function asDeclaration(value) {
 	const d = value;
@@ -397,24 +399,44 @@ function clearBindDeclaration(trajectoryDir) {
 * 这是**反向查询**（会话 → 轨迹 / 轨迹 → 会话）的唯一入口，取代旧的旁路表扫描。
 * 跳过 `_` / `.` 前缀目录（归档区与运行时区不是轨迹，判据同 `activeTrajectoryDirNames`）。
 *
+* 🔴 **2026-10-20（owner 裁决「死包含归档判断」配套）：`_archived/` 必须**再扫一层**。**
+*
+* 修之前：归档目录整体被跳过 ⇒ **已归档轨迹的绑定声明对唯一性检查完全隐形**。
+* 后果：承载过它的 dsh 会话看起来"无归属"，可以被 `use` 到另一条轨迹上 ——
+* 这正是 IMMUTABLE 1「一个会话终身只属于一条轨迹」要禁的事，而且是**静默**发生的。
+*
+* 为什么只扫归档区、不扫别的 `_` 目录：归档区里的**确实是轨迹**（只是不再活跃），
+* 而 `_轨迹约束-logs` / `_weixin-logs` / `_corpus` 是日志与数据区，它们里面不会有
+* `current.dsh_session_bind`（真有一个也只是垃圾，读到会被 `asDeclaration` 挡掉）。
+* ⇒ 只多付一次 `_archived` 的 readdir，不改变"活跃清单"的语义（那是 `readAllSessions` 的事）。
+*
 * @param sessionsRoot `<CCC>/AGENT_SESSIONS`
 * @returns 有交代的轨迹；**永不抛**（目录读不到 ⇒ 空表）
 */
 function listBindDeclarations(sessionsRoot) {
 	const out = [];
-	let names;
-	try {
-		names = readdirSync(sessionsRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name);
-	} catch {
-		return out;
-	}
-	for (const dirName of names) {
-		const decl = readBindDeclaration(join(sessionsRoot, dirName));
-		if (decl) out.push({
+	const collect = (dir, into) => {
+		let names;
+		try {
+			names = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name);
+		} catch {
+			return;
+		}
+		for (const dirName of names) {
+			const decl = readBindDeclaration(join(dir, dirName));
+			if (decl) into(dirName, decl);
+		}
+	};
+	collect(sessionsRoot, (dirName, decl) => out.push({
+		dirName,
+		decl
+	}));
+	collect(join(sessionsRoot, ARCHIVED_DIR_NAME), (dirName, decl) => {
+		if (!out.some((r) => r.dirName === dirName)) out.push({
 			dirName,
 			decl
 		});
-	}
+	});
 	return out;
 }
 /**
@@ -481,10 +503,24 @@ function findTrajectoryHolding(sessionsRoot, sessionId) {
 *    `takeover` = 载体换代（`rebuild` / 崩溃后新建），由调用方**显式**声明；
 *    绝不默认允许 —— 静默换代正是"一条轨迹长出两个载体"的成因。
 *
+* 🔴 **2026-10-20（owner 裁决，S196 实测逼出）：第 ② 条只在"旧载体还活着"时成立。**
+*
+* 修之前：`claimBinding` **完全不问存活**，只要文件里有别的 `sessionId` 就拒。
+* 而读侧（`listBoundSessionIds(…, alive)`）却按 IMMUTABLE 3 把过期声明当"没绑定"
+* ⇒ **同一条轨迹，两个函数给出相反的答案**。S196 就是撞上这一格：
+* 它的绑定文件指着 `session-52d680ae`（**已在宿主归档集里** = 死），
+* 而 `use` 被 `TRAJECTORY_OCCUPIED` 拒掉，回执还说"成功"（另有一条 D186 的静默问题）。
+*
+* ⇒ 判据（第三条不变量的**写侧形态**）：**旧载体会死 ⇒ 本条轨迹算空槽，直接写**。
+*    `alive` 不传时**沿用"文件在就算占用"**的旧语义（保守、向后兼容）——
+*    ⚠️ 那是"读不到宿主事实"的降级，**不是**"它一定活着"；
+*    生产调用点必须显式传 {@link hostAliveProbe}。
+*
 * @param sessionsRoot `<CCC>/AGENT_SESSIONS`
 * @param dirName 目标轨迹目录名
 * @param decl 要写入的声明
 * @param opts.takeover 允许顶掉本条轨迹现有的另一个载体
+* @param opts.alive 探针：**旧载体**是否还活着（缺省 ⇒ 一律当活 = 旧语义）
 * @returns `{ ok: true }` 或 `{ ok: false, code, detail }`（**不抛**，由调用方决定如何呈现）
 */
 function claimBinding(sessionsRoot, dirName, decl, opts = {}) {
@@ -495,11 +531,13 @@ function claimBinding(sessionsRoot, dirName, decl, opts = {}) {
 		detail: `会话 ${decl.sessionId} 已经承载轨迹「${holder}」，不能同时再承载「${dirName}」。一个会话只能属于一条认知轨迹 —— 要给「${dirName}」开一个载体，请新建一条会话。`
 	};
 	const cur = readBindDeclaration(join(sessionsRoot, dirName));
-	if (cur !== null && cur.sessionId !== decl.sessionId && opts.takeover !== true) return {
-		ok: false,
-		code: "TRAJECTORY_OCCUPIED",
-		detail: `轨迹「${dirName}」当前已由会话 ${cur.sessionId} 承载（${cur.action}，${new Date(cur.at).toISOString()}）。如需换代（rebuild / 重建载体），调用方必须显式声明 takeover —— 静默换代会让一条轨迹出现两个载体。`
-	};
+	if (cur !== null && cur.sessionId !== decl.sessionId && opts.takeover !== true) {
+		if (opts.alive === void 0 ? true : opts.alive(cur.sessionId)) return {
+			ok: false,
+			code: "TRAJECTORY_OCCUPIED",
+			detail: `轨迹「${dirName}」当前已由会话 ${cur.sessionId} 承载（${cur.action}，${new Date(cur.at).toISOString()}）。如需换代（rebuild / 重建载体），调用方必须显式声明 takeover —— 静默换代会让一条轨迹出现两个载体。`
+		};
+	}
 	let released;
 	if (holder !== null && holder !== dirName) {
 		if (clearBindDeclaration(join(sessionsRoot, holder))) released = holder;
@@ -657,6 +695,13 @@ function resolveSessionCognitiveTrajectoryLabel(session, scope) {
 * 那是"读不到宿主事实"的降级，**不是**"会话一定在"。需要严格判的一方请显式传探针
 * （唤醒选人是这种：见 `wake/scheduler.ts`）。
 *
+* 🔴 **2026-10-20（owner 裁决）：生产调用点必须传探针，两个调用点都已接上。**
+* 缺省分支**保留**只为两件事：① 既有单测的向后兼容；② 诊断面"只读文件"的显式用法。
+* ⛔ 不要新增不传探针的生产调用点 —— 那等于把"归档会话算活"的漏洞再开一次
+* （本仓同族已踩：`carrierState` ＋ CRO 快照两处都漏传过）。
+* 生产一律用 `trajectory/alive.ts` 的 `hostAliveProbe(ctx)`（判据 ＝ owner 定的
+* 「① 进程内 loaded ∨ ② 日志在且未被归档」）。
+*
 * @param root CCC 根
 * @param dirName 轨迹目录名
 * @param alive 探针：该 dsh 会话 id 此刻是否真实存在
@@ -678,14 +723,20 @@ function listBoundSessionIds(root, dirName, alive) {
 function appendBound(session, action, rec) {
 	const id = sessionHeader(session)?.id;
 	const root = rootOf(session);
-	if (typeof id !== "string" || id === "" || root === null) return false;
+	if (typeof id !== "string" || id === "" || root === null) {
+		console.warn(`[serenity-hooks] ✗ 绑定未写入（SESSION_HEADER_UNRESOLVED）：会话对象取不到可用的 header（id=${typeof id === "string" && id !== "" ? id : "(空/非字符串)"}，root=${root ?? "null（header.cwd 缺失或上溯不到 .serenity）"}） ⇒ 轨迹「${rec.dirName}」的 current.dsh_session_bind **未被改写**。 排查：该会话的 header.cwd 是否指向某个含 .serenity 的目录； 无 cwd 的会话（如某些程序性创建的载体）**不会**写绑定。`);
+		return false;
+	}
 	const result = claimBinding(sessionsRoot(root), rec.dirName, {
 		sessionId: id,
 		at: Date.now(),
 		action,
 		...rec.note !== void 0 ? { note: rec.note } : {},
 		...rec.createdAsUser === true ? { createdAsUser: true } : {}
-	}, { takeover: rec.takeover === true });
+	}, {
+		takeover: rec.takeover === true,
+		...rec.alive !== void 0 ? { alive: rec.alive } : {}
+	});
 	if (!result.ok) {
 		console.warn(`[serenity-hooks] ✗ 绑定未写入（${result.code}）：${result.detail}`);
 		return false;

package/lib/{session-BxDVrxPH.js → session-B4eZD3Hv.js}

@@ -2,7 +2,7 @@ import { n as agentCwdFor, r as cccRootForCwd, s as hostAgents } from "./ccc-roo
 import { g as readUtf8, o as isSafeModeOn, p as readCognitiveTrajectorySkills, u as readBlacklist } from "./ccc-CyYJL4F2.js";
 import { B as isoLocal, D as readActiveSessionMd, a as readTrajectoryConstraintAt, c as trajectoryConstraintForSession, d as unregisterTrajectorySession$1, j as sessionsRoot, l as registerTrajectorySession$1, p as DEFAULT_SESSION_SCOPE, u as trajectoryDirNameForSession } from "./profile-C7BuyZK7.js";
 import { a as readGitTrack, i as localstorePath } from "./service-DDmHSglV.js";
-import { _ as ACC_VERSION, d as constraintCognitiveTrajectory, m as profileMsmWhitelist, n as PLUGIN_SOURCE, o as readLastBound, p as createProfilePromptReader, u as buildTrajectoryBasePrompt } from "./message-source-BOG0piL8.js";
+import { _ as ACC_VERSION, d as constraintCognitiveTrajectory, m as profileMsmWhitelist, n as PLUGIN_SOURCE, o as readLastBound, p as createProfilePromptReader, u as buildTrajectoryBasePrompt } from "./message-source-BJO5q-rD.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/trajectory/alive.d.ts

@@ -0,0 +1,95 @@
+/**
+ * trajectory/alive.ts — **"这个 dsh 会话还活着吗"的唯一判据**（owner 2026-10-20 裁决）
+ *
+ * ## owner 的原话（本模块的全部设计依据）
+ *
+ * > 「死应该包含归档判断；只有 ① 或者 ②且不在归档集 才算活」
+ * > 「use 只要被调用了，可以无条件覆盖绑定到当前会话（这说明当前会话肯定活着啊）」
+ *
+ * ## 为什么必须收成一个判据（在此之前有三个互不一致的判据）
+ *
+ * | # | 判据 | 旧实现位置 | 单独使用时的漏洞 |
+ * |---|---|---|---|
+ * | ① | 进程内 loaded agent | `hostAgents(ctx).get(id)` | 冷会话全判死 |
+ * | ② | 磁盘上有会话日志 | `hasSessionLogById()` | **归档后日志逐字节不动** ⇒ 归档会话判活 |
+ * | ③ | 宿主归档集 | `workspaceRegistry.archivedSessionIds` | 旧 dsp **零引用**（整个仓库 0 处） |
+ *
+ * 宿主的归档语义是**只往集合里加一个 id、不动日志**（`dsh-workspace` 的
+ * `archiveSession` 注释：「Archiving never touches workspace accounting」）。
+ * ⇒ 只问 ② 的实现在归档上**必然判错**，而那个错误没有任何机械信号。
+ *
+ * ## 判据（owner 给定，逐字实现）
+ *
+ * ```text
+ * 活 ⟺ ①                       （进程内 loaded ⇒ 一定在）
+ *    ∨ (② ∧ 不在归档集)          （日志在、且没人把它归档掉）
+ * ```
+ *
+ * 🔴 **一处对原话的收紧（必须说出来，不许默默改）**：owner 的 ① 未附加"不在归档集"，
+ * 而本模块把**归档判定排在最前** —— 即 `归档 ∧ live ⇒ 判死`。理由：归档是**人对这条会话
+ * 的处置声明**（宿主会把它从所有分组面隐藏），若仍被当成载体，唤醒调度器会去驱动一条
+ * **使用者以为已经收起来**的会话。⚠️ 与字面规则的差异仅此一格；`use` 不受影响
+ * （见下方 §use 逃生门），因此真需要复活一条已归档会话时**仍然有受支持的路**。
+ *
+ * ## 🔴 `use` 的逃生门（owner 第二条，写在调用点）
+ *
+ * **`use` 不查存活**：它被调用这件事本身证明**当前会话活着**（本模块的被测对象是
+ * "别人写的那个 id"，而 `use` 手里拿的是**自己**）。⇒ `use` 走无条件覆盖
+ * （`claimBinding` 的 `takeover`），因此**判据再严也不会把一条轨迹锁死**。
+ * 这条逃生门是判据可以取严的前提，两者必须一起存在。
+ *
+ * ## 依赖纪律
+ *
+ * 纯判据 `isSessionAlive` 零依赖、可单测；宿主面只在 `hostAliveProbe` 里，
+ * 且**不抛错**（服务缺失 ⇒ 该维度作废，而不是让 ACC 工具整块失败）。
+ */
+/**
+ * 判活所需的三个事实（**纯数据**，由调用方去宿主/磁盘取）。
+ *
+ * 分开的理由与 `bind-file.ts` 的 `isBindUsable` 同款：把"判断"与"取数"拆开，
+ * 判据可单测、不依赖 cordis。
+ */
+export interface SessionAliveFacts {
+    /** ① 进程内 loaded（`hostAgents.get` 命中即算） */
+    readonly liveIds: ReadonlySet<string>;
+    /** ③ 宿主归档集（`workspaceRegistry.archivedSessionIds`） */
+    readonly archivedIds: ReadonlySet<string>;
+    /** ② 磁盘上还有这条会话的日志（`hasSessionLogById`） */
+    readonly hasLog: (sessionId: string) => boolean;
+}
+/**
+ * **唯一的存活判据**（owner 2026-10-20）。
+ *
+ * @param sessionId dsh 会话 id（`session-<uuid>`，或 `skiff-*` 这类无前缀的）
+ * @param facts 三个事实
+ * @returns 活 ⇒ true
+ *
+ * 🔴 求值顺序是**判据的一部分**（不是优化）：归档先于 live，
+ * 因为"归档"是对会话的**处置声明**，而 live 只说明字节还在内存里。
+ */
+export declare function isSessionAlive(sessionId: string, facts: SessionAliveFacts): boolean;
+/**
+ * **宿主面的判活探针**（`(sessionId) => boolean`）——所有需要"这条会话还活着吗"的
+ * 生产代码都应当用这一个，不要自己拼 `agents.get` ＋ `hasSessionLogById`。
+ *
+ * 语义 = {@link isSessionAlive}，其中：
+ *  · `liveIds` 因为宿主只给 `get(id)` 而**按 id 逐次问**（不是集合）；
+ *  · `archivedIds` 在**首次调用时**取一次快照并在闭包内复用（每 tick 一个探针，
+ *    归档集在一个 tick 内不变）—— 避免为每条轨迹重复读存储域。
+ *
+ * ⚠️ **快照的代价**：同一探针内若有人中途归档了某会话，本探针直到下次新建才看见。
+ *    调度器是每 tick 新建一个探针（见 `wake/scheduler.ts`），故实际窗口 ≤1 tick。
+ *
+ * @param ctx 插件上下文（取 `agents` 与 `workspaceRegistry`）
+ * @returns 探针；**永不抛**
+ */
+export declare function hostAliveProbe(ctx: unknown): (sessionId: string) => boolean;
+/**
+ * 判据只有**两个**出口，别再开第三个：
+ *  · {@link isSessionAlive} —— 纯判据（给定事实），单测的靶子；
+ *  · {@link hostAliveProbe} —— 生产入口（自己去宿主与磁盘取事实）。
+ *
+ * ⚠️ 曾有一个 `aliveFactsFor`（把探针摊平成 `SessionAliveFacts`），**全仓零调用点**，
+ * 已删除 —— 留一个"看起来有用、实际无人调用"的导出，会让下一个人以为存在第二条判活路径
+ * （本仓同族教训：`cheapWorkerPresetInheritance` 全仓零调用点 ⇒ 接线断了却看不出来）。
+ */

package/lib/trajectory/bind-file.d.ts

@@ -85,6 +85,8 @@ export declare const BIND_FILENAME = "current.dsh_session_bind";
  * （上游改名、下游写死旧名 ⇒ 症状与真因在读数上完全不像）。
  */
 export declare const BIND_FILENAME_FAMILY: readonly ["current.dsh_session_bind"];
+/** 轨迹归档区的目录名（**自持一份，不从 `core.ts` import**）。 */
+export declare const ARCHIVED_DIR_NAME = "_archived";
 /**
  * 绑定文件的内容（**自我交代**：不只是"谁"，还有"何时、为何、谁建的"）。
  *
@@ -129,6 +131,17 @@ export declare function clearBindDeclaration(trajectoryDir: string): boolean;
  * 这是**反向查询**（会话 → 轨迹 / 轨迹 → 会话）的唯一入口，取代旧的旁路表扫描。
  * 跳过 `_` / `.` 前缀目录（归档区与运行时区不是轨迹，判据同 `activeTrajectoryDirNames`）。
  *
+ * 🔴 **2026-10-20（owner 裁决「死包含归档判断」配套）：`_archived/` 必须**再扫一层**。**
+ *
+ * 修之前：归档目录整体被跳过 ⇒ **已归档轨迹的绑定声明对唯一性检查完全隐形**。
+ * 后果：承载过它的 dsh 会话看起来"无归属"，可以被 `use` 到另一条轨迹上 ——
+ * 这正是 IMMUTABLE 1「一个会话终身只属于一条轨迹」要禁的事，而且是**静默**发生的。
+ *
+ * 为什么只扫归档区、不扫别的 `_` 目录：归档区里的**确实是轨迹**（只是不再活跃），
+ * 而 `_轨迹约束-logs` / `_weixin-logs` / `_corpus` 是日志与数据区，它们里面不会有
+ * `current.dsh_session_bind`（真有一个也只是垃圾，读到会被 `asDeclaration` 挡掉）。
+ * ⇒ 只多付一次 `_archived` 的 readdir，不改变"活跃清单"的语义（那是 `readAllSessions` 的事）。
+ *
  * @param sessionsRoot `<CCC>/AGENT_SESSIONS`
  * @returns 有交代的轨迹；**永不抛**（目录读不到 ⇒ 空表）
  */
@@ -210,14 +223,29 @@ export declare function findTrajectoryHolding(sessionsRoot: string, sessionId: s
  *    `takeover` = 载体换代（`rebuild` / 崩溃后新建），由调用方**显式**声明；
  *    绝不默认允许 —— 静默换代正是"一条轨迹长出两个载体"的成因。
  *
+ * 🔴 **2026-10-20（owner 裁决，S196 实测逼出）：第 ② 条只在"旧载体还活着"时成立。**
+ *
+ * 修之前：`claimBinding` **完全不问存活**，只要文件里有别的 `sessionId` 就拒。
+ * 而读侧（`listBoundSessionIds(…, alive)`）却按 IMMUTABLE 3 把过期声明当"没绑定"
+ * ⇒ **同一条轨迹，两个函数给出相反的答案**。S196 就是撞上这一格：
+ * 它的绑定文件指着 `session-52d680ae`（**已在宿主归档集里** = 死），
+ * 而 `use` 被 `TRAJECTORY_OCCUPIED` 拒掉，回执还说"成功"（另有一条 D186 的静默问题）。
+ *
+ * ⇒ 判据（第三条不变量的**写侧形态**）：**旧载体会死 ⇒ 本条轨迹算空槽，直接写**。
+ *    `alive` 不传时**沿用"文件在就算占用"**的旧语义（保守、向后兼容）——
+ *    ⚠️ 那是"读不到宿主事实"的降级，**不是**"它一定活着"；
+ *    生产调用点必须显式传 {@link hostAliveProbe}。
+ *
  * @param sessionsRoot `<CCC>/AGENT_SESSIONS`
  * @param dirName 目标轨迹目录名
  * @param decl 要写入的声明
  * @param opts.takeover 允许顶掉本条轨迹现有的另一个载体
+ * @param opts.alive 探针：**旧载体**是否还活着（缺省 ⇒ 一律当活 = 旧语义）
  * @returns `{ ok: true }` 或 `{ ok: false, code, detail }`（**不抛**，由调用方决定如何呈现）
  */
 export declare function claimBinding(sessionsRoot: string, dirName: string, decl: BindDeclaration, opts?: {
     takeover?: boolean;
+    alive?: (sessionId: string) => boolean;
 }): {
     ok: true;
     released?: string;

package/lib/trajectory/bound.d.ts

@@ -91,6 +91,13 @@ export declare function resolveSessionCognitiveTrajectoryLabel(session: unknown,
  * 那是"读不到宿主事实"的降级，**不是**"会话一定在"。需要严格判的一方请显式传探针
  * （唤醒选人是这种：见 `wake/scheduler.ts`）。
  *
+ * 🔴 **2026-10-20（owner 裁决）：生产调用点必须传探针，两个调用点都已接上。**
+ * 缺省分支**保留**只为两件事：① 既有单测的向后兼容；② 诊断面"只读文件"的显式用法。
+ * ⛔ 不要新增不传探针的生产调用点 —— 那等于把"归档会话算活"的漏洞再开一次
+ * （本仓同族已踩：`carrierState` ＋ CRO 快照两处都漏传过）。
+ * 生产一律用 `trajectory/alive.ts` 的 `hostAliveProbe(ctx)`（判据 ＝ owner 定的
+ * 「① 进程内 loaded ∨ ② 日志在且未被归档」）。
+ *
  * @param root CCC 根
  * @param dirName 轨迹目录名
  * @param alive 探针：该 dsh 会话 id 此刻是否真实存在
@@ -129,6 +136,14 @@ export declare function appendBound(session: unknown, action: SessionBoundAction
     createdAsUser?: boolean;
     /** 允许顶掉该轨迹现有的另一个载体（rebuild / 崩溃后重建载体时**必须显式**声明） */
     takeover?: boolean;
+    /**
+     * 探针：该轨迹**现有载体**是否还活着（决定"算不算占用"）。
+     *
+     * 🔴 2026-10-20（owner 裁决）：**死载体不构成占用**。
+     * 不传 ⇒ 同一条轨迹现有的任何声明都算占用（旧语义，保守拒绝）。
+     * 生产调用点应当传 {@link hostAliveProbe}（`trajectory/alive.ts`）。
+     */
+    alive?: (sessionId: string) => boolean;
 }): boolean;
 /**
  * 这条轨迹**是否曾经有过载体**（判"要不要允许自建"）。

package/package.json

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