@shgroup/dsh-serenity-hooks 1.87.7 → 1.88.0

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.87.7",
+  "version": "1.88.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/{ccc-roots-CvgsUnFW.js → ccc-roots-WfktvbN8.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-DGt_e-Nx.js").then((n) => n.a);
+		const { listTrajectoryConstraints } = await import("./profile-zxakCNXy.js").then((n) => n.a);
 		rolesOf = (root) => {
 			try {
 				return listTrajectoryConstraints(root).map((p) => p.code);

package/lib/im/channels.d.ts

@@ -154,6 +154,46 @@ export declare function imChannelIds(): string[];
  * @param root 本会话 CCC 根（由调用方解析）
  */
 export declare function hasEnabledImChannel(root: string): boolean;
+/**
+ * 可见性判据（**轨迹级**，2026-10-23 owner 令）：
+ * 这个 dsh 会话所属的认知轨迹，是否**被 IM 路由表点名**（= 它才是那个"接线人"）。
+ *
+ * ## 它解决的问题（owner 原话的**去标识改写**，原文含私有角色名，按 D145 不入仓库）
+ *
+ * > 「很多轨迹发消息给我，但是我没空回，它们就会等待我，其实并不是，我希望他们继续工作；
+ * >  所以只有 IM 桥绑定了任意账户的认知轨迹才拥有 `im-bridge` 这个 tool，
+ * >  这样可以确保只有一个接线角色和我联系，其它轨迹和它联系即可，它会自行回复它们的」
+ *
+ * ⇒ 旧判据是 **CCC 级**（{@link hasEnabledImChannel}：本 CCC 有任一启用账号 ⇒ 全体可见）。
+ * 它的后果不是"少一个工具"，而是**一条错误的工作流**：每条轨迹都以为自己该直接对 owner 说话，
+ * 于是发完就**停下来等人回**——而 owner 根本没空逐条回。**工具在，就把等待也带上了。**
+ *
+ * ## 判据（两条，缺一不可）
+ *
+ * 1. 本 CCC 有可用账号（{@link hasEnabledImChannel}）—— 没有账号时路由表也没有意义；
+ * 2. 本会话**绑定的轨迹编码**出现在 `routes[].trajectory` 里。
+ *
+ * ⚠️ **为什么不看 `routes[].user`**：那是"对端是谁"（owner 的通道 id），
+ *    判"这条轨迹能不能说话"只跟**轨迹**有关，与哪个对端无关。
+ *
+ * ⚠️ **`*` 通配也算点名**：`{ user:"*", trajectory:"<某轨迹>" }` 这条路由的含义就是
+ *    "**没人认领的消息都归那条轨迹**" ⇒ 它确实是一条被授权的接线轨迹，必须算可见。
+ *    这与 `matchWeixinRoute` 的通配兜底语义**同源**，不另立规则。
+ *
+ * ## 拿不到轨迹编码时怎么办（fail-closed，与 `exclusive` 同向）
+ *
+ * 会话 → 轨迹编码要读绑定。**取不到就判不可见**：
+ * - 与 `exclusive`（未声明 ⇒ 隐藏）同向；
+ * - 反向（取不到就放行）会让"绑定坏了"表现成"工具还在"，
+ *   而那正是本判据要防的形态（D179：配置说它有、行为说它没有，且零报错）。
+ * ⚠️ 代价明示：绑定读取若短暂失败，该轮会少一个工具；下一轮绑定恢复即回。
+ *    这比"误给一条轨迹发消息的权限"便宜 —— 后者会让它**停下来等 owner**。
+ *
+ * @param root CCC 根
+ * @param trajectoryCode 本会话所属认知轨迹的编码（**由调用方解析**，见 `trajectory/policy/profile.ts`）
+ * @returns true = 该轨迹接线，`im-bridge` 可见
+ */
+export declare function isImWiredTrajectory(root: string, trajectoryCode: string | null | undefined): boolean;
 /** 结果载荷（lossless JSON——工具返回值必须可 JSON 化） */
 export type ImJson = null | boolean | number | string | ImJson[] | {
     [key: string]: ImJson;

package/lib/index.js

@@ -1,12 +1,12 @@
 import { i as __toESM, n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
-import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-CvgsUnFW.js";
+import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-WfktvbN8.js";
 import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readSafeModeHiddenTools, i as findGitRoot, l as pathInside, m as readExclusiveTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-CyYJL4F2.js";
-import { A as resolveSessionByTitle, B as readTrajectoryFile, C as listActiveTrajectories, D as parseTrajectoryCode, E as parseSessionContextFromEvents, F as summarize, H as localFileStamp, I as trajectoryDescOf, L as useSession, M as sessionsRoot, N as setActiveSessionInfo, P as showSession, R as TRAJECTORY_FILENAME, T as namingTitleFor, U as localHuman, V as isoLocal, W as localIdStamp, _ as clearActiveSessionInfo, b as findSession, c as replacesDefaultIdentity, g as archiveSession, h as UID_FILENAME, i as listTrajectoryConstraints, j as sessionEvents, k as readTrajectoryUid, l as trajectoryConstraintForSession, n as findDirNameByCode, o as readTrajectoryConstraintAt, p as COGNITIVE_TRAJECTORY_ACTIONS, r as isTrajectoryConstrained, s as readTrajectoryConstraintByCode, t as TRAJECTORY_CONSTRAINT_FILENAME, v as createSession, w as listSessions, x as getActiveSessionInfo, y as extractSessionMdPathFromText, z as TRAJECTORY_LEGACY_FILENAMES } from "./profile-DGt_e-Nx.js";
+import { A as namingTitleFor, B as summarize, C as createSession, E as getActiveSessionInfo, F as resolveSessionByTitle, G as readTrajectoryFile, H as useSession, I as sessionEvents, J as localHuman, K as isoLocal, L as sessionsRoot, M as parseTrajectoryCode, O as listActiveTrajectories, P as readTrajectoryUid, R as setActiveSessionInfo, S as clearActiveSessionInfo, T as findSession, U as TRAJECTORY_FILENAME, V as trajectoryDescOf, W as TRAJECTORY_LEGACY_FILENAMES, Y as localIdStamp, b as UID_FILENAME, c as replacesDefaultIdentity, i as listTrajectoryConstraints, j as parseSessionContextFromEvents, k as listSessions, l as trajectoryCodeForSession, n as findDirNameByCode, o as readTrajectoryConstraintAt, q as localFileStamp, r as isTrajectoryConstrained, s as readTrajectoryConstraintByCode, t as TRAJECTORY_CONSTRAINT_FILENAME, u as trajectoryConstraintForSession, v as COGNITIVE_TRAJECTORY_ACTIONS, w as extractSessionMdPathFromText, x as archiveSession, z as showSession } from "./profile-zxakCNXy.js";
 import { n as checkLocalstoreGitCompliance, o as readStore, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./service-DDmHSglV.js";
-import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-Cq4PsuES.js";
-import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-Ca5UYzF3.js";
+import { _ as resolveConstraintSystemPrompt, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as profileWriteWhitelist, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as ACC_VERSION, y as findPackageRoot } from "./message-source-BAMwXu6i.js";
+import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-Bb4GSSFJ.js";
 import { i as sessionsRootDir, n as findSessionLog, r as hasSessionLogById } from "./cleanup-CPl1SSaK.js";
-import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-BI3NRHgC.js";
+import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-DAorSseV.js";
 import { a as readFeishuCredential, c as readWeixinSettings, d as weixinInboundDir, f as weixinSessionIdForTrajectory, i as matchWeixinRoute, n as extractWeixinText, o as readImSettings, r as hasVoiceItem, s as readWeixinCredential, t as extractWeixinMedia, u as sanitizeFileName$1 } from "./route-3OzOAjec.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
 import { c as sendTextMessage, i as getUpdates, l as sendTyping, n as downloadMedia, o as markdownToPlainText, r as getConfig, s as sendFileMessage, t as TypingStatus, u as sniffImageExt } from "./ilink-CsZ-f64q.js";
@@ -12391,6 +12391,61 @@ function hasEnabledImChannel(root) {
 	return (settings.accounts ?? []).some((a) => a.enabled !== false);
 }
 /**
+* 可见性判据（**轨迹级**，2026-10-23 owner 令）：
+* 这个 dsh 会话所属的认知轨迹，是否**被 IM 路由表点名**（= 它才是那个"接线人"）。
+*
+* ## 它解决的问题（owner 原话的**去标识改写**，原文含私有角色名，按 D145 不入仓库）
+*
+* > 「很多轨迹发消息给我，但是我没空回，它们就会等待我，其实并不是，我希望他们继续工作；
+* >  所以只有 IM 桥绑定了任意账户的认知轨迹才拥有 `im-bridge` 这个 tool，
+* >  这样可以确保只有一个接线角色和我联系，其它轨迹和它联系即可，它会自行回复它们的」
+*
+* ⇒ 旧判据是 **CCC 级**（{@link hasEnabledImChannel}：本 CCC 有任一启用账号 ⇒ 全体可见）。
+* 它的后果不是"少一个工具"，而是**一条错误的工作流**：每条轨迹都以为自己该直接对 owner 说话，
+* 于是发完就**停下来等人回**——而 owner 根本没空逐条回。**工具在，就把等待也带上了。**
+*
+* ## 判据（两条，缺一不可）
+*
+* 1. 本 CCC 有可用账号（{@link hasEnabledImChannel}）—— 没有账号时路由表也没有意义；
+* 2. 本会话**绑定的轨迹编码**出现在 `routes[].trajectory` 里。
+*
+* ⚠️ **为什么不看 `routes[].user`**：那是"对端是谁"（owner 的通道 id），
+*    判"这条轨迹能不能说话"只跟**轨迹**有关，与哪个对端无关。
+*
+* ⚠️ **`*` 通配也算点名**：`{ user:"*", trajectory:"<某轨迹>" }` 这条路由的含义就是
+*    "**没人认领的消息都归那条轨迹**" ⇒ 它确实是一条被授权的接线轨迹，必须算可见。
+*    这与 `matchWeixinRoute` 的通配兜底语义**同源**，不另立规则。
+*
+* ## 拿不到轨迹编码时怎么办（fail-closed，与 `exclusive` 同向）
+*
+* 会话 → 轨迹编码要读绑定。**取不到就判不可见**：
+* - 与 `exclusive`（未声明 ⇒ 隐藏）同向；
+* - 反向（取不到就放行）会让"绑定坏了"表现成"工具还在"，
+*   而那正是本判据要防的形态（D179：配置说它有、行为说它没有，且零报错）。
+* ⚠️ 代价明示：绑定读取若短暂失败，该轮会少一个工具；下一轮绑定恢复即回。
+*    这比"误给一条轨迹发消息的权限"便宜 —— 后者会让它**停下来等 owner**。
+*
+* @param root CCC 根
+* @param trajectoryCode 本会话所属认知轨迹的编码（**由调用方解析**，见 `trajectory/policy/profile.ts`）
+* @returns true = 该轨迹接线，`im-bridge` 可见
+*/
+function isImWiredTrajectory(root, trajectoryCode) {
+	if (typeof trajectoryCode !== "string" || trajectoryCode.trim() === "") return false;
+	if (!hasEnabledImChannel(root)) return false;
+	let settings;
+	try {
+		settings = readImSettings(root);
+	} catch {
+		return false;
+	}
+	const wanted = trajectoryCode.trim();
+	for (const route of settings.routes ?? []) {
+		const target = typeof route.trajectory === "string" ? route.trajectory.trim() : "";
+		if (target !== "" && target === wanted) return true;
+	}
+	return false;
+}
+/**
 * 错误码 → 可行动提示（模型视角：说清怎么改）。
 *
 * 🔴 `CHANNEL_NOT_CONFIGURED` 的提示**不能写死某一个渠道的字段名**（2026-10-20 Q4 真机验收踩到）：
@@ -12920,7 +12975,7 @@ function computeVisibilitySources(sessionId, root) {
 		}
 		return { deny: [.../* @__PURE__ */ new Set([...SAFE_MODE_DENY_TOOLS, ...declared])] };
 	}));
-	out.push(sourceOf("imBridge", () => hasEnabledImChannel(root) ? { deny: [] } : { deny: [IM_BRIDGE_TOOL_NAME] }));
+	out.push(sourceOf("imBridge", () => isImWiredTrajectory(root, trajectoryCodeForSession(root, sessionId)) ? { deny: [] } : { deny: [IM_BRIDGE_TOOL_NAME] }));
 	out.push(sourceOf("exclusive", () => {
 		const declared = readExclusiveTools(root);
 		return { deny: EXCLUSIVE_TOOL_NAMES.filter((t) => !declared.includes(t)) };
@@ -15113,7 +15168,7 @@ function registerStatusApi(ctx, opts = {}) {
 						});
 					}
 					const { saveWeixinRoutes } = await import("./route-3OzOAjec.js").then((n) => n.l);
-					const { findDirNameByCode } = await import("./profile-DGt_e-Nx.js").then((n) => n.a);
+					const { findDirNameByCode } = await import("./profile-zxakCNXy.js").then((n) => n.a);
 					for (const r of routes) if (findDirNameByCode(root, r.trajectory) === null) {
 						sendJson$2(res, 400, { error: `unknown trajectory: ${r.trajectory} (no such trajectory code in ${root})` });
 						return;
@@ -20156,7 +20211,7 @@ const MEDIA_MAX_BYTES = 20971520;
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-WfktvbN8.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -20224,7 +20279,7 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const { findDirNameByCode } = await import("./profile-DGt_e-Nx.js").then((n) => n.a);
+	const { findDirNameByCode } = await import("./profile-zxakCNXy.js").then((n) => n.a);
 	if (findDirNameByCode(root, target.role) === null) {
 		const detail = `目标 CCC "${target.ccc}" 内没有编码为 "${target.role}" 的认知轨迹`;
 		console.error(`[serenity-hooks] ✗ human-channel: ${detail}（account=${input.account} user=${input.user}）—— 该消息**未投递**，请改订阅表里的目标编码`);
@@ -21178,7 +21233,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-WfktvbN8.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -21471,7 +21526,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-CvgsUnFW.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-WfktvbN8.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];

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

@@ -1,8 +1,8 @@
-import { r as cccRootForCwd } from "./ccc-roots-CvgsUnFW.js";
+import { r as cccRootForCwd } from "./ccc-roots-WfktvbN8.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-DGt_e-Nx.js";
+import { D as getLastActiveSessionInfo, E as getActiveSessionInfo, I as sessionEvents, L as sessionsRoot, M as parseTrajectoryCode, _ as readBindDeclaration, g as listBindDeclarations, h as isBindUsable, m as claimBinding } from "./profile-zxakCNXy.js";
 import { dirname, join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/kernel/constants.ts
 /** 常量（纯模块，零 DSH 依赖） */
@@ -260,328 +260,6 @@ function buildTrajectoryBasePrompt(code) {
 	].join("\n");
 }
 //#endregion
-//#region src/trajectory/bind-file.ts
-/**
-* trajectory/bind-file.ts — **当前载体绑定 = 认知轨迹目录里的自我交代**（判决 D172，owner 2026-10-20）
-*
-* ## owner 的原话（这是本模块的全部设计依据）
-*
-* > 「**认知轨迹自己交代永远是最好的交代**」
-* > 「绑定表是没有意义的，绑定关系必须**运行时按照规则探测**，绑定表本质就搞成**第二真相源**了」
-* > 「依赖文件系统，定义一个 `.dsh_session_bind` 后缀（加入 gitignore）；每个认知轨迹目录内放一个
-* >  `current.dsh_session_bind`，**以这个为绑定真相源**」
-*
-* ## 为什么这是对的（而不是又一张表）
-*
-* 旧的 `.bindings.json` ＋ 宿主存储域是**旁路索引**：它描述的对象（轨迹目录）与它自己**分离**，
-* ⇒ 一旦两者不一致就必须写代码去对账，而**对账失败没有任何机械信号**（本轨反复踩的形状）。
-*
-* 新形态把这条信息**放回它描述的对象的内部**：
-*
-* ```text
-* <轨迹目录>/
-*   SESSION.md                 ← 身体
-*   PROMPT.md                  ← 章程
-*   trajectory.json            ← 声明（约束面 / uid / cro.host）
-*   current.dsh_session_bind   ← 🆕 **此刻谁在承载它**（单个文件 ⇒ 结构上不可能有两个）
-* ```
-*
-* ## 🔴 两条不变量由**形态本身**保证，不靠记账
-*
-* | 不变量 | 保证方式 |
-* |---|---|
-* | 一条轨迹**至多一个**当前载体 | 它是**一个文件**，写入即整体覆盖（原子 rename） |
-* | 一个载体**至多一条**轨迹 | 写入前扫全部轨迹的 bind 文件，**该会话 id 已出现在别处 ⇒ 拒绝** |
-*
-* ⚠️ 旧形态靠 `supersededAt` 标记"退掉"，而**标记是可以忘的**；覆盖不会忘。
-*
-* ## 零依赖纪律（同 `policy/files.ts`）
-* 只用 `node:fs` / `node:path` ⇒ 谁 import 它都不会成环。每个读函数**永不抛**。
-*
-* ## 🔴 第三条不变量（owner 2026-10-20 追加）：「文件里写的 sessionId 可能已经不存在了
-* ——这个情况下就**视同没绑定**，就正确了」
-*
-* 这一条让整个设计**自洽**：**绑定的有效性由「那个会话真实存在」决定，不由「文件存在」决定。**
-*
-* ```text
-* 文件在 ＋ 会话在  ⇒ 有效绑定
-* 文件在 ＋ 会话没了 ⇒ **视同没绑定**（过期文件自动失效，不需要任何人来清理）
-* 文件不在         ⇒ 没绑定
-* ```
-*
-* ⇒ 因此**不需要**任何"清理陈旧绑定"的机制，也不需要 `reconcile` 去对账 —— 对账这件事本身消失。
-* 代价是**每次取用都要验一次会话是否还在**（`ctx.agents.get` 或 `sessionController.resolveAgent`
-* 或宿主会话清单），**这是运行时探测**，正是 owner 要的那种判据。
-*
-* ⚠️ 本模块**只负责读写文件**；"会话是否还在"必须由**调用方**（持有宿主上下文）来验 ——
-* 把那条判断放在这里会迫使本模块拿到 `ctx`，从而破坏零依赖与可单测性。
-* 调用方正确用法见 {@link isBindUsable}。
-*
-* ## 🔴 第四条：**完整生命周期**（owner 2026-10-20 追加：「调用 use 会覆盖掉这个文件，
-* 完整生命周期要实现，请注意」）
-*
-* 文件是**一个槽位**，不是追加日志。⇒ 每次改变归属都是一次**状态迁移**，
-* 四个动作必须**成对**出现，否则槽位会留下无法解释的残留：
-*
-* | 迁移 | 何时 | 必须做什么 |
-* |---|---|---|
-* | **acquire** | 会话首次认领轨迹 | 写槽位（该会话此前不持有任何轨迹） |
-* | **switch** | 会话从轨迹 A **改到** B | 🔴 **先清 A 的槽位，再写 B** —— 只写 B 会让 A 永远指着一个不再属于它的会话 |
-* | **release** | 会话主动解绑 / 会话将死 | **清掉槽位**（不是写空串，是删文件） |
-* | **takeover** | 载体换代（rebuild / 崩溃后重建） | 覆盖写：旧会话退位，新会话入位（**必须显式声明**） |
-*
-* 🔴 **最容易漏的是 switch 的"先清 A"**：旧实现（`.bindings.json`）天然支持"一个会话多条记录"，
-* 所以从来没暴露过这个问题；新形态是**单槽位**，不清 A 就会得到
-* 「A 与 B 都说这个会话属于自己」—— 正是 owner 要禁的"一个会话绑两条轨迹"，
-* 只不过这次是**残留**而不是**主动绑定**，更难发现。
-*
-* ⇒ 因此**不要**直接调 {@link writeBindDeclaration} 来改归属；一律走
-* {@link transitionBinding}（它把四条迁移的配对关系写死在一处）。
-*/
-/** 绑定文件的固定名（**owner 指定**：`current.dsh_session_bind`） */
-const BIND_FILENAME = "current.dsh_session_bind";
-/**
-* 绑定文件的**族**（认族不认名，D167 通用纪律）。
-*
-* 目前只有一代。留成数组是**为了下一次改名不重演历史**：本仓已在
-* `skiff.json → trajectory-constraint.json → trajectory.json` 上栽过两次
-* （上游改名、下游写死旧名 ⇒ 症状与真因在读数上完全不像）。
-*/
-const BIND_FILENAME_FAMILY = [BIND_FILENAME];
-/** 轨迹归档区的目录名（**自持一份，不从 `core.ts` import**）。 */
-const ARCHIVED_DIR_NAME = "_archived";
-/** 校验一条声明（容忍手改 / 部分字段缺失） */
-function asDeclaration(value) {
-	const d = value;
-	if (!d || typeof d !== "object") return null;
-	if (typeof d.sessionId !== "string" || d.sessionId === "") return null;
-	return {
-		sessionId: d.sessionId,
-		at: typeof d.at === "number" ? d.at : 0,
-		action: typeof d.action === "string" && d.action !== "" ? d.action : "activate",
-		...typeof d.note === "string" && d.note !== "" ? { note: d.note } : {},
-		...d.createdAsUser === true ? { createdAsUser: true } : {}
-	};
-}
-/** 某轨迹目录里绑定文件的绝对路径 */
-function bindFilePath(trajectoryDir) {
-	return join(trajectoryDir, BIND_FILENAME);
-}
-/**
-* 读一条轨迹的**当前载体声明**。
-*
-* @param trajectoryDir 轨迹目录绝对路径
-* @returns 声明；文件不存在 / 坏 JSON / 形状不符 ⇒ `null`（**永不抛**）
-*/
-function readBindDeclaration(trajectoryDir) {
-	for (const name of BIND_FILENAME_FAMILY) {
-		const p = join(trajectoryDir, name);
-		try {
-			if (!existsSync(p)) continue;
-			return asDeclaration(JSON.parse(readFileSync(p, "utf-8")));
-		} catch {}
-	}
-	return null;
-}
-/**
-* 写一条轨迹的**当前载体声明**（原子：同目录 tmp + rename）。
-*
-* 🔴 **不做唯一性检查** —— 那是 `claimBinding` 的职责。本函数只负责"这份文件长成什么样"。
-* 分开的理由：唯一性检查需要**扫全部轨迹**，而写只需要一个目录 ⇒ 让不扫盘的地方能便宜地写。
-*/
-function writeBindDeclaration(trajectoryDir, decl) {
-	const path = bindFilePath(trajectoryDir);
-	const tmp = `${path}.tmp`;
-	try {
-		mkdirSync(dirname(path), { recursive: true });
-		writeFileSync(tmp, `${JSON.stringify(decl, null, 2)}\n`, "utf-8");
-		renameSync(tmp, path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* 清掉一条轨迹的当前载体声明（解绑）。
-* @returns 文件原本存在且已删除 ⇒ true
-*/
-function clearBindDeclaration(trajectoryDir) {
-	try {
-		const path = bindFilePath(trajectoryDir);
-		if (!existsSync(path)) return false;
-		renameSync(path, `${path}.del`);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* 列出某 CCC 下**全部轨迹的当前载体声明**（`dirName → 声明`）。
-*
-* 这是**反向查询**（会话 → 轨迹 / 轨迹 → 会话）的唯一入口，取代旧的旁路表扫描。
-* 跳过 `_` / `.` 前缀目录（归档区与运行时区不是轨迹，判据同 `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 = [];
-	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;
-}
-/**
-* **这条绑定还作数吗**（第三条不变量的机械形态）。
-*
-* 判据（owner 原话：「文件里写的 sessionId 可能已经不存在了，这个情况下就视同没绑定」）：
-*
-* | 文件 | 会话存在？ | 结论 |
-* |---|---|---|
-* | 无 | — | `absent` |
-* | 有 | 是 | **`usable`** |
-* | 有 | 否 | **`stale`** ⇒ **视同没绑定** |
-*
-* 🔴 **为什么"会话存在"必须由调用方给**：判断它要问宿主（`ctx.agents.get` /
-* `sessionController.resolveAgent` / 会话清单），而本模块是零依赖层。
-* ⇒ 这里只收一个 **`alive: (sessionId) => boolean`** 探针，把判断留在外面，本函数仍是纯逻辑、可单测。
-*
-* ⚠️ **`stale` 不删文件**：删除是写操作，而"视同没绑定"已经足够。
-* 留着过期文件反而有用 —— 它记录了"这条轨迹上一次由谁承载"（沿革不丢，同旧 `supersededAt` 的意图）。
-*
-* @param decl {@link readBindDeclaration} 的结果
-* @param alive 探针：该会话 id 此刻是否真实存在（**由调用方用宿主事实实现**）
-* @returns `absent` ／ `usable` ／ `stale`，以及（usable 时的）声明
-*/
-function isBindUsable(decl, alive) {
-	if (decl === null) return { state: "absent" };
-	try {
-		return alive(decl.sessionId) ? {
-			state: "usable",
-			decl
-		} : {
-			state: "stale",
-			decl
-		};
-	} catch {
-		return {
-			state: "stale",
-			decl
-		};
-	}
-}
-/**
-* 找出**已经占用**某个 dsh 会话 id 的那条轨迹（唯一性判据）。
-*
-* @param sessionsRoot `<CCC>/AGENT_SESSIONS`
-* @param sessionId 待检查的会话 id
-* @returns 占用它的轨迹目录名；无人占用 ⇒ `null`
-*/
-function findTrajectoryHolding(sessionsRoot, sessionId) {
-	for (const { dirName, decl } of listBindDeclarations(sessionsRoot)) if (decl.sessionId === sessionId) return dirName;
-	return null;
-}
-/**
-* **认领**：把某条轨迹的当前载体设成 `sessionId`，并**当场执行两条不变量**。
-*
-* 这是全仓**唯一**允许改变绑定关系的写入口：`appendBound` 与迁移脚本都走这里。
-* 集中成一处的理由 = 不变量只能有一个实现，否则迟早出现"某条路径忘了检查"（本仓已多次踩）。
-*
-* ## 判据（任一不成立即**拒绝**，不写）
-*
-* 1. **载体唯一**：`sessionId` 已安家在**另一条**轨迹 ⇒ 拒绝（一个会话不能绑两条轨迹）。
-*    ⚠️ 若它已安家在**本条**轨迹 ⇒ 幂等通过（重复 `use` 同一条轨迹是合法重入）。
-* 2. **轨迹唯一**：本条轨迹已由**另一个** `sessionId` 承载 ⇒ **拒绝**，除非 `takeover`。
-*    `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, replaced?, released? }` 或 `{ ok: false, code, detail }`（**不抛**，由调用方决定如何呈现）
-*
-* 🔴 **2026-10-20 追加 `replaced`（由一条 skiff 轨迹的实测逼出）**：`released` 只覆盖
-* 「这个会话此前安家在**另一条**轨迹」那一格（跨轨迹清理）；而**同一轨迹换载体**时被顶掉的那个
-* 会话 id 此前**没有任何出口** ⇒ 调用方无法在回执里说出"你顶掉了谁"。
-* 静默换代正是"一条轨迹感觉有两个载体"的成因 ⇒ 顶掉谁必须能被读出来。
-*/
-function claimBinding(sessionsRoot, dirName, decl, opts = {}) {
-	const holder = findTrajectoryHolding(sessionsRoot, decl.sessionId);
-	if (holder !== null && holder !== dirName) return {
-		ok: false,
-		code: "SESSION_TAKEN",
-		detail: `会话 ${decl.sessionId} 已经承载轨迹「${holder}」，不能同时再承载「${dirName}」。一个会话只能属于一条认知轨迹 —— 要给「${dirName}」开一个载体，请新建一条会话。`
-	};
-	const cur = readBindDeclaration(join(sessionsRoot, dirName));
-	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;
-	}
-	if (!writeBindDeclaration(join(sessionsRoot, dirName), decl)) return {
-		ok: false,
-		code: "WRITE_FAILED",
-		detail: `写 ${BIND_FILENAME} 失败：${join(sessionsRoot, dirName)}`
-	};
-	const replaced = cur !== null && cur.sessionId !== decl.sessionId ? cur.sessionId : void 0;
-	return {
-		ok: true,
-		...replaced === void 0 ? {} : { replaced },
-		...released === void 0 ? {} : { released }
-	};
-}
-//#endregion
 //#region src/trajectory/bound.ts
 /**
 * trajectory/bound.ts — 「会话 ↔ 认知轨迹」绑定（**2026-10-20 重做：归属 = 轨迹自己的交代**）

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

@@ -930,6 +930,328 @@ function archiveSession(root, key, dryRun = false) {
 	};
 }
 //#endregion
+//#region src/trajectory/bind-file.ts
+/**
+* trajectory/bind-file.ts — **当前载体绑定 = 认知轨迹目录里的自我交代**（判决 D172，owner 2026-10-20）
+*
+* ## owner 的原话（这是本模块的全部设计依据）
+*
+* > 「**认知轨迹自己交代永远是最好的交代**」
+* > 「绑定表是没有意义的，绑定关系必须**运行时按照规则探测**，绑定表本质就搞成**第二真相源**了」
+* > 「依赖文件系统，定义一个 `.dsh_session_bind` 后缀（加入 gitignore）；每个认知轨迹目录内放一个
+* >  `current.dsh_session_bind`，**以这个为绑定真相源**」
+*
+* ## 为什么这是对的（而不是又一张表）
+*
+* 旧的 `.bindings.json` ＋ 宿主存储域是**旁路索引**：它描述的对象（轨迹目录）与它自己**分离**，
+* ⇒ 一旦两者不一致就必须写代码去对账，而**对账失败没有任何机械信号**（本轨反复踩的形状）。
+*
+* 新形态把这条信息**放回它描述的对象的内部**：
+*
+* ```text
+* <轨迹目录>/
+*   SESSION.md                 ← 身体
+*   PROMPT.md                  ← 章程
+*   trajectory.json            ← 声明（约束面 / uid / cro.host）
+*   current.dsh_session_bind   ← 🆕 **此刻谁在承载它**（单个文件 ⇒ 结构上不可能有两个）
+* ```
+*
+* ## 🔴 两条不变量由**形态本身**保证，不靠记账
+*
+* | 不变量 | 保证方式 |
+* |---|---|
+* | 一条轨迹**至多一个**当前载体 | 它是**一个文件**，写入即整体覆盖（原子 rename） |
+* | 一个载体**至多一条**轨迹 | 写入前扫全部轨迹的 bind 文件，**该会话 id 已出现在别处 ⇒ 拒绝** |
+*
+* ⚠️ 旧形态靠 `supersededAt` 标记"退掉"，而**标记是可以忘的**；覆盖不会忘。
+*
+* ## 零依赖纪律（同 `policy/files.ts`）
+* 只用 `node:fs` / `node:path` ⇒ 谁 import 它都不会成环。每个读函数**永不抛**。
+*
+* ## 🔴 第三条不变量（owner 2026-10-20 追加）：「文件里写的 sessionId 可能已经不存在了
+* ——这个情况下就**视同没绑定**，就正确了」
+*
+* 这一条让整个设计**自洽**：**绑定的有效性由「那个会话真实存在」决定，不由「文件存在」决定。**
+*
+* ```text
+* 文件在 ＋ 会话在  ⇒ 有效绑定
+* 文件在 ＋ 会话没了 ⇒ **视同没绑定**（过期文件自动失效，不需要任何人来清理）
+* 文件不在         ⇒ 没绑定
+* ```
+*
+* ⇒ 因此**不需要**任何"清理陈旧绑定"的机制，也不需要 `reconcile` 去对账 —— 对账这件事本身消失。
+* 代价是**每次取用都要验一次会话是否还在**（`ctx.agents.get` 或 `sessionController.resolveAgent`
+* 或宿主会话清单），**这是运行时探测**，正是 owner 要的那种判据。
+*
+* ⚠️ 本模块**只负责读写文件**；"会话是否还在"必须由**调用方**（持有宿主上下文）来验 ——
+* 把那条判断放在这里会迫使本模块拿到 `ctx`，从而破坏零依赖与可单测性。
+* 调用方正确用法见 {@link isBindUsable}。
+*
+* ## 🔴 第四条：**完整生命周期**（owner 2026-10-20 追加：「调用 use 会覆盖掉这个文件，
+* 完整生命周期要实现，请注意」）
+*
+* 文件是**一个槽位**，不是追加日志。⇒ 每次改变归属都是一次**状态迁移**，
+* 四个动作必须**成对**出现，否则槽位会留下无法解释的残留：
+*
+* | 迁移 | 何时 | 必须做什么 |
+* |---|---|---|
+* | **acquire** | 会话首次认领轨迹 | 写槽位（该会话此前不持有任何轨迹） |
+* | **switch** | 会话从轨迹 A **改到** B | 🔴 **先清 A 的槽位，再写 B** —— 只写 B 会让 A 永远指着一个不再属于它的会话 |
+* | **release** | 会话主动解绑 / 会话将死 | **清掉槽位**（不是写空串，是删文件） |
+* | **takeover** | 载体换代（rebuild / 崩溃后重建） | 覆盖写：旧会话退位，新会话入位（**必须显式声明**） |
+*
+* 🔴 **最容易漏的是 switch 的"先清 A"**：旧实现（`.bindings.json`）天然支持"一个会话多条记录"，
+* 所以从来没暴露过这个问题；新形态是**单槽位**，不清 A 就会得到
+* 「A 与 B 都说这个会话属于自己」—— 正是 owner 要禁的"一个会话绑两条轨迹"，
+* 只不过这次是**残留**而不是**主动绑定**，更难发现。
+*
+* ⇒ 因此**不要**直接调 {@link writeBindDeclaration} 来改归属；一律走
+* {@link transitionBinding}（它把四条迁移的配对关系写死在一处）。
+*/
+/** 绑定文件的固定名（**owner 指定**：`current.dsh_session_bind`） */
+const BIND_FILENAME = "current.dsh_session_bind";
+/**
+* 绑定文件的**族**（认族不认名，D167 通用纪律）。
+*
+* 目前只有一代。留成数组是**为了下一次改名不重演历史**：本仓已在
+* `skiff.json → trajectory-constraint.json → trajectory.json` 上栽过两次
+* （上游改名、下游写死旧名 ⇒ 症状与真因在读数上完全不像）。
+*/
+const BIND_FILENAME_FAMILY = [BIND_FILENAME];
+/** 轨迹归档区的目录名（**自持一份，不从 `core.ts` import**）。 */
+const ARCHIVED_DIR_NAME = "_archived";
+/** 校验一条声明（容忍手改 / 部分字段缺失） */
+function asDeclaration(value) {
+	const d = value;
+	if (!d || typeof d !== "object") return null;
+	if (typeof d.sessionId !== "string" || d.sessionId === "") return null;
+	return {
+		sessionId: d.sessionId,
+		at: typeof d.at === "number" ? d.at : 0,
+		action: typeof d.action === "string" && d.action !== "" ? d.action : "activate",
+		...typeof d.note === "string" && d.note !== "" ? { note: d.note } : {},
+		...d.createdAsUser === true ? { createdAsUser: true } : {}
+	};
+}
+/** 某轨迹目录里绑定文件的绝对路径 */
+function bindFilePath(trajectoryDir) {
+	return join(trajectoryDir, BIND_FILENAME);
+}
+/**
+* 读一条轨迹的**当前载体声明**。
+*
+* @param trajectoryDir 轨迹目录绝对路径
+* @returns 声明；文件不存在 / 坏 JSON / 形状不符 ⇒ `null`（**永不抛**）
+*/
+function readBindDeclaration(trajectoryDir) {
+	for (const name of BIND_FILENAME_FAMILY) {
+		const p = join(trajectoryDir, name);
+		try {
+			if (!existsSync(p)) continue;
+			return asDeclaration(JSON.parse(readFileSync(p, "utf-8")));
+		} catch {}
+	}
+	return null;
+}
+/**
+* 写一条轨迹的**当前载体声明**（原子：同目录 tmp + rename）。
+*
+* 🔴 **不做唯一性检查** —— 那是 `claimBinding` 的职责。本函数只负责"这份文件长成什么样"。
+* 分开的理由：唯一性检查需要**扫全部轨迹**，而写只需要一个目录 ⇒ 让不扫盘的地方能便宜地写。
+*/
+function writeBindDeclaration(trajectoryDir, decl) {
+	const path = bindFilePath(trajectoryDir);
+	const tmp = `${path}.tmp`;
+	try {
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(tmp, `${JSON.stringify(decl, null, 2)}\n`, "utf-8");
+		renameSync(tmp, path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 清掉一条轨迹的当前载体声明（解绑）。
+* @returns 文件原本存在且已删除 ⇒ true
+*/
+function clearBindDeclaration(trajectoryDir) {
+	try {
+		const path = bindFilePath(trajectoryDir);
+		if (!existsSync(path)) return false;
+		renameSync(path, `${path}.del`);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 列出某 CCC 下**全部轨迹的当前载体声明**（`dirName → 声明`）。
+*
+* 这是**反向查询**（会话 → 轨迹 / 轨迹 → 会话）的唯一入口，取代旧的旁路表扫描。
+* 跳过 `_` / `.` 前缀目录（归档区与运行时区不是轨迹，判据同 `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 = [];
+	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;
+}
+/**
+* **这条绑定还作数吗**（第三条不变量的机械形态）。
+*
+* 判据（owner 原话：「文件里写的 sessionId 可能已经不存在了，这个情况下就视同没绑定」）：
+*
+* | 文件 | 会话存在？ | 结论 |
+* |---|---|---|
+* | 无 | — | `absent` |
+* | 有 | 是 | **`usable`** |
+* | 有 | 否 | **`stale`** ⇒ **视同没绑定** |
+*
+* 🔴 **为什么"会话存在"必须由调用方给**：判断它要问宿主（`ctx.agents.get` /
+* `sessionController.resolveAgent` / 会话清单），而本模块是零依赖层。
+* ⇒ 这里只收一个 **`alive: (sessionId) => boolean`** 探针，把判断留在外面，本函数仍是纯逻辑、可单测。
+*
+* ⚠️ **`stale` 不删文件**：删除是写操作，而"视同没绑定"已经足够。
+* 留着过期文件反而有用 —— 它记录了"这条轨迹上一次由谁承载"（沿革不丢，同旧 `supersededAt` 的意图）。
+*
+* @param decl {@link readBindDeclaration} 的结果
+* @param alive 探针：该会话 id 此刻是否真实存在（**由调用方用宿主事实实现**）
+* @returns `absent` ／ `usable` ／ `stale`，以及（usable 时的）声明
+*/
+function isBindUsable(decl, alive) {
+	if (decl === null) return { state: "absent" };
+	try {
+		return alive(decl.sessionId) ? {
+			state: "usable",
+			decl
+		} : {
+			state: "stale",
+			decl
+		};
+	} catch {
+		return {
+			state: "stale",
+			decl
+		};
+	}
+}
+/**
+* 找出**已经占用**某个 dsh 会话 id 的那条轨迹（唯一性判据）。
+*
+* @param sessionsRoot `<CCC>/AGENT_SESSIONS`
+* @param sessionId 待检查的会话 id
+* @returns 占用它的轨迹目录名；无人占用 ⇒ `null`
+*/
+function findTrajectoryHolding(sessionsRoot, sessionId) {
+	for (const { dirName, decl } of listBindDeclarations(sessionsRoot)) if (decl.sessionId === sessionId) return dirName;
+	return null;
+}
+/**
+* **认领**：把某条轨迹的当前载体设成 `sessionId`，并**当场执行两条不变量**。
+*
+* 这是全仓**唯一**允许改变绑定关系的写入口：`appendBound` 与迁移脚本都走这里。
+* 集中成一处的理由 = 不变量只能有一个实现，否则迟早出现"某条路径忘了检查"（本仓已多次踩）。
+*
+* ## 判据（任一不成立即**拒绝**，不写）
+*
+* 1. **载体唯一**：`sessionId` 已安家在**另一条**轨迹 ⇒ 拒绝（一个会话不能绑两条轨迹）。
+*    ⚠️ 若它已安家在**本条**轨迹 ⇒ 幂等通过（重复 `use` 同一条轨迹是合法重入）。
+* 2. **轨迹唯一**：本条轨迹已由**另一个** `sessionId` 承载 ⇒ **拒绝**，除非 `takeover`。
+*    `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, replaced?, released? }` 或 `{ ok: false, code, detail }`（**不抛**，由调用方决定如何呈现）
+*
+* 🔴 **2026-10-20 追加 `replaced`（由一条 skiff 轨迹的实测逼出）**：`released` 只覆盖
+* 「这个会话此前安家在**另一条**轨迹」那一格（跨轨迹清理）；而**同一轨迹换载体**时被顶掉的那个
+* 会话 id 此前**没有任何出口** ⇒ 调用方无法在回执里说出"你顶掉了谁"。
+* 静默换代正是"一条轨迹感觉有两个载体"的成因 ⇒ 顶掉谁必须能被读出来。
+*/
+function claimBinding(sessionsRoot, dirName, decl, opts = {}) {
+	const holder = findTrajectoryHolding(sessionsRoot, decl.sessionId);
+	if (holder !== null && holder !== dirName) return {
+		ok: false,
+		code: "SESSION_TAKEN",
+		detail: `会话 ${decl.sessionId} 已经承载轨迹「${holder}」，不能同时再承载「${dirName}」。一个会话只能属于一条认知轨迹 —— 要给「${dirName}」开一个载体，请新建一条会话。`
+	};
+	const cur = readBindDeclaration(join(sessionsRoot, dirName));
+	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;
+	}
+	if (!writeBindDeclaration(join(sessionsRoot, dirName), decl)) return {
+		ok: false,
+		code: "WRITE_FAILED",
+		detail: `写 ${BIND_FILENAME} 失败：${join(sessionsRoot, dirName)}`
+	};
+	const replaced = cur !== null && cur.sessionId !== decl.sessionId ? cur.sessionId : void 0;
+	return {
+		ok: true,
+		...replaced === void 0 ? {} : { replaced },
+		...released === void 0 ? {} : { released }
+	};
+}
+//#endregion
 //#region src/trajectory/policy/window.ts
 /** sessionId → 绑定的轨迹（**进程内**；跨重启的权威来源是 `trajectory/bound.ts` 的持久绑定） */
 const trajectorySessions = /* @__PURE__ */ new Map();
@@ -992,6 +1314,7 @@ var profile_exports = /* @__PURE__ */ __exportAll({
 	readTrajectoryConstraintAt: () => readTrajectoryConstraintAt,
 	readTrajectoryConstraintByCode: () => readTrajectoryConstraintByCode,
 	replacesDefaultIdentity: () => replacesDefaultIdentity,
+	trajectoryCodeForSession: () => trajectoryCodeForSession,
 	trajectoryConstraintForSession: () => trajectoryConstraintForSession
 });
 /**
@@ -1181,6 +1504,41 @@ function registeredDirName(sessionId) {
 	return trajectoryDirNameForSession(sessionId);
 }
 /**
+* **会话 → 认知轨迹编码**（供工具可见性这类"只有 sessionId、没有 agent 对象"的调用方用）。
+*
+* ## 为什么需要它（而不是复用 `trajectoryConstraintForSession`）
+*
+* 那条路的判据是"**绑定的轨迹有 `trajectory-constraint.json`**"——它回答的是
+* 「这条会话是不是一条**约束会话**」。而工具可见性问的是另一个问题：
+* 「这条会话属于**哪条**轨迹」。前者对**普通轨迹**恒返回 `null`（它们没有约束文件），
+* ⇒ 拿它去判 IM 接线，会把所有普通轨迹一律判成"无归属"。
+*
+* ## 两个来源并取（与 `trajectoryConstraintForSession` 同一条纪律）
+*
+* ① **内存注册表**（`window.ts`）——覆盖"刚 `use`、绑定还没落盘"的窗口期；
+* ② **持久绑定**（`listBindDeclarations` 扫 `current.dsh_session_bind`）——跨重启成立。
+*
+* ⇒ 只取 ① 会在重启后全判成"没归属"（工具**静默消失**）；
+*    只取 ② 会在建会话的第一轮判成"没归属"（同样是静默）。
+* 🔴 **这条纪律不是新发明的**：`trajectoryConstraintForSession` 的注释里已经付过一次代价。
+*
+* @param root CCC 根
+* @param sessionId dsh 会话 id
+* @returns 轨迹编码（`S###` 或自定义码）；解析不到 ⇒ `null`
+*/
+function trajectoryCodeForSession(root, sessionId) {
+	if (typeof sessionId !== "string" || sessionId === "") return null;
+	const fromMemory = registeredDirName(sessionId);
+	if (fromMemory !== null && fromMemory !== "") return parseTrajectoryCode(fromMemory) ?? fromMemory;
+	try {
+		for (const { dirName, decl } of listBindDeclarations(sessionsRoot(root))) {
+			if (decl.sessionId !== sessionId) continue;
+			return parseTrajectoryCode(dirName) ?? dirName;
+		}
+	} catch {}
+	return null;
+}
+/**
 * 该 dsh 会话**是不是** 轨迹约束会话（布尔形态的 `trajectoryConstraintForSession`）。
 *
 * 存在的理由：调用点很多只要一个"是/不是"（seams 的旁路判定），
@@ -1224,4 +1582,4 @@ function replacesDefaultIdentity(profile) {
 	return hasFile || hasInline;
 }
 //#endregion
-export { resolveSessionByTitle as A, readTrajectoryFile as B, listActiveTrajectories as C, parseTrajectoryCode as D, parseSessionContextFromEvents as E, summarize as F, localFileStamp as H, trajectoryDescOf as I, useSession as L, sessionsRoot as M, setActiveSessionInfo as N, readActiveSessionMd as O, showSession as P, TRAJECTORY_FILENAME as R, getLastActiveSessionInfo as S, namingTitleFor as T, localHuman as U, isoLocal as V, localIdStamp as W, clearActiveSessionInfo as _, profile_exports as a, findSession as b, replacesDefaultIdentity as c, trajectoryDirNameForSession as d, unregisterTrajectorySession as f, archiveSession as g, UID_FILENAME as h, listTrajectoryConstraints as i, sessionEvents as j, readTrajectoryUid as k, trajectoryConstraintForSession as l, DEFAULT_SESSION_SCOPE as m, findDirNameByCode as n, readTrajectoryConstraintAt as o, COGNITIVE_TRAJECTORY_ACTIONS as p, isTrajectoryConstrained as r, readTrajectoryConstraintByCode as s, TRAJECTORY_CONSTRAINT_FILENAME as t, registerTrajectorySession as u, createSession as v, listSessions as w, getActiveSessionInfo as x, extractSessionMdPathFromText as y, TRAJECTORY_LEGACY_FILENAMES as z };
+export { namingTitleFor as A, summarize as B, createSession as C, getLastActiveSessionInfo as D, getActiveSessionInfo as E, resolveSessionByTitle as F, readTrajectoryFile as G, useSession as H, sessionEvents as I, localHuman as J, isoLocal as K, sessionsRoot as L, parseTrajectoryCode as M, readActiveSessionMd as N, listActiveTrajectories as O, readTrajectoryUid as P, setActiveSessionInfo as R, clearActiveSessionInfo as S, findSession as T, TRAJECTORY_FILENAME as U, trajectoryDescOf as V, TRAJECTORY_LEGACY_FILENAMES as W, localIdStamp as Y, readBindDeclaration as _, profile_exports as a, UID_FILENAME as b, replacesDefaultIdentity as c, registerTrajectorySession as d, trajectoryDirNameForSession as f, listBindDeclarations as g, isBindUsable as h, listTrajectoryConstraints as i, parseSessionContextFromEvents as j, listSessions as k, trajectoryCodeForSession as l, claimBinding as m, findDirNameByCode as n, readTrajectoryConstraintAt as o, unregisterTrajectorySession as p, localFileStamp as q, isTrajectoryConstrained as r, readTrajectoryConstraintByCode as s, TRAJECTORY_CONSTRAINT_FILENAME as t, trajectoryConstraintForSession as u, COGNITIVE_TRAJECTORY_ACTIONS as v, extractSessionMdPathFromText as w, archiveSession as x, DEFAULT_SESSION_SCOPE as y, showSession as z };

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

@@ -1,8 +1,8 @@
-import { n as agentCwdFor, r as cccRootForCwd, s as hostAgents } from "./ccc-roots-CvgsUnFW.js";
+import { n as agentCwdFor, r as cccRootForCwd, s as hostAgents } from "./ccc-roots-WfktvbN8.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-DGt_e-Nx.js";
+import { K as isoLocal, L as sessionsRoot, N as readActiveSessionMd, d as registerTrajectorySession$1, f as trajectoryDirNameForSession, o as readTrajectoryConstraintAt, p as unregisterTrajectorySession$1, u as trajectoryConstraintForSession, y as DEFAULT_SESSION_SCOPE } from "./profile-zxakCNXy.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-Cq4PsuES.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-BAMwXu6i.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-BI3NRHgC.js → settings-DAorSseV.js}

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

package/lib/trajectory/policy/profile.d.ts

@@ -161,6 +161,30 @@ export declare function findDirNameByCode(root: string, code: string): string |
  * @returns 约束面；不是 轨迹约束会话 → `null`
  */
 export declare function trajectoryConstraintForSession(root: string, sessionId: string | undefined, boundDirName?: string | null): TrajectoryConstraint | null;
+/**
+ * **会话 → 认知轨迹编码**（供工具可见性这类"只有 sessionId、没有 agent 对象"的调用方用）。
+ *
+ * ## 为什么需要它（而不是复用 `trajectoryConstraintForSession`）
+ *
+ * 那条路的判据是"**绑定的轨迹有 `trajectory-constraint.json`**"——它回答的是
+ * 「这条会话是不是一条**约束会话**」。而工具可见性问的是另一个问题：
+ * 「这条会话属于**哪条**轨迹」。前者对**普通轨迹**恒返回 `null`（它们没有约束文件），
+ * ⇒ 拿它去判 IM 接线，会把所有普通轨迹一律判成"无归属"。
+ *
+ * ## 两个来源并取（与 `trajectoryConstraintForSession` 同一条纪律）
+ *
+ * ① **内存注册表**（`window.ts`）——覆盖"刚 `use`、绑定还没落盘"的窗口期；
+ * ② **持久绑定**（`listBindDeclarations` 扫 `current.dsh_session_bind`）——跨重启成立。
+ *
+ * ⇒ 只取 ① 会在重启后全判成"没归属"（工具**静默消失**）；
+ *    只取 ② 会在建会话的第一轮判成"没归属"（同样是静默）。
+ * 🔴 **这条纪律不是新发明的**：`trajectoryConstraintForSession` 的注释里已经付过一次代价。
+ *
+ * @param root CCC 根
+ * @param sessionId dsh 会话 id
+ * @returns 轨迹编码（`S###` 或自定义码）；解析不到 ⇒ `null`
+ */
+export declare function trajectoryCodeForSession(root: string, sessionId: string | undefined): string | null;
 /**
  * 该 dsh 会话**是不是** 轨迹约束会话（布尔形态的 `trajectoryConstraintForSession`）。
  *

package/package.json

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