@shgroup/dsh-serenity-hooks 1.39.2 → 1.40.0

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.39.2",
+  "version": "1.40.0",
   "main": "lib/index.js",
   "description": "宁静号 ACC harness（Native Cordis 插件）：给 DSH 装一个「AI 工作区」——11 个工具（container_fs/container_trajectory/dashboard/container_git/msm/praxis/handyman/localstore/container_admin/im-bridge/acc-diag；后两个按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫）+ 轨迹日志与原地重建 + 网页登录入口/微信桥/子角色/对外问答页/trajectory 唤醒注册表。适配 DSH 0.1.5-rc.2（deepseek-ai/deepseek-harness）。",
   "engines": {

package/lib/host/storage-domain.d.ts

@@ -0,0 +1,115 @@
+/**
+ * host/storage-domain.ts — 宿主存储域上的「会话 ↔ 轨迹」绑定表（§0L，S142 2026-09-19）
+ *
+ * 为什么存在（R↓）：绑定的载体原本是 CCC 内的 `AGENT_SESSIONS/.bindings.json`。
+ * owner 裁定（「放 CCC 不合适」）⇒ 改存**宿主自己的存储域**
+ * （`~/.dsh/storages/`，与宿主 `workspace.json` 同处、同类结构、同一套校验）。
+ *
+ * 能力与边界：
+ *  - `openBindingDomain(ctx)`：从插件 ctx 取 `storageDomain`（**经 `hostService` = `ctx.get`**，
+ *    **不是**属性直读——dsp 的 `inject` 不含它，属性直读在真实 cordis 下抛
+ *    `cannot get property "storageDomain" without inject`，同 v1.31.4 的 subagents 陷阱）；
+ *    开域成功返回句柄，任何环节失败返回 `null`（**本模块永不抛错**：宿主对插件 apply 抛错
+ *    = 整个 dsh 启动失败，见 `host/access.ts` 的同类契约）。
+ *  - 句柄的**读是同步的**（`get` / `entries` / `keys` / `size` 走内存），**写才是异步的**
+ *    （`put` / `delete` 等落盘后 resolve）——**这是 §0L 能"向前兼容"的技术前提**：
+ *    既有 10 个调用点全是同步签名，故调用方拿到句柄后读法完全不变。
+ *
+ * 域名约束（实测，`tests/host/storage-domain.test.ts` 钉住）：
+ *   `UNIT_NAME_RE = /^[a-z][a-z0-9_]*$/` ⇒ **`serenity_bindings`（下划线）**；
+ *   连字符形如 `serenity-bindings` **非法**（会在 `defineDomain` 模块加载期抛错）。
+ *
+ * 记录形状：与旧 `.bindings.json` **同名字段**（`dirName` / `mdPath` / `sessionId` / `action`
+ * / `at` / `note` / `supersededAt`）——同形可显著降低迁移风险，也让"双读兜底"易于对账。
+ * 硬锚仍是 **`dirName`**（完整目录名，U4：绝不解析编号前缀）。
+ */
+/** 域名称（下划线；连字符非法——见文件头） */
+export declare const BINDING_DOMAIN_NAME = "serenity_bindings";
+/** 表名 */
+export declare const BINDING_TABLE_NAME = "bindings";
+/** 域格式版本（`DomainSpec.version`；非负整数） */
+export declare const BINDING_DOMAIN_VERSION = 1;
+/**
+ * 一条绑定记录。字段与旧 `.bindings.json` 的 `SessionBoundRecord` **同名同义**
+ * （刻意不重命名：迁移对账不需要映射表，降低出错面）。
+ */
+export interface BindingRecord {
+    /** 🔴 硬锚：完整 `AGENT_SESSIONS` 目录名（不解析编号格式，U4） */
+    dirName: string;
+    /** `SESSION.md` 绝对路径（展示/定位用；**不作锚**——绝对路径绑死机器） */
+    mdPath: string;
+    /** 展示码（`S###` 或任意 CCC 自定义格式；**仅展示**，绝不用于识别） */
+    sessionId?: string;
+    action: string;
+    at: number;
+    note?: string;
+    /** 已被取代（D69：同轨迹多会话只留一条；记录保留、退出"当前"） */
+    supersededAt?: number;
+}
+/** 域内的表句柄（宿主 `KvTable` 的**结构子集**——只取本模块用到的成员，便于替身注入） */
+export interface BindingTableLike {
+    /** 同步读一条（内存） */
+    get(key: string): BindingRecord | undefined;
+    /** 同步快照遍历 */
+    entries(): IterableIterator<[string, BindingRecord]>;
+    /** 当前条数 */
+    readonly size: number;
+    /** 异步落盘写一条 */
+    put(key: string, value: BindingRecord): Promise<void>;
+    /** 异步落盘删一条 */
+    delete(key: string): Promise<boolean>;
+}
+/** 域句柄（宿主 `Domain` 的结构子集） */
+export interface BindingDomainLike {
+    /** 取表句柄（重复调用返回同一实例） */
+    table(name: string): BindingTableLike;
+}
+/** `storageDomain` 设施的结构子集（宿主 `DomainFacility`） */
+export interface DomainFacilityLike {
+    open(spec: unknown): Promise<BindingDomainLike>;
+}
+/**
+ * 构造域规格（宿主 `defineDomain` 的入参形状）。
+ *
+ * 为什么不引 `@deepseek-ai/dsh-storage-domain` 的 `defineDomain`：
+ * 它是**宿主 peer 依赖**（本仓 peer-only 打包，不装它）⇒ 直接 import 会让插件在
+ * 未装该包的运行时**模块加载即失败**。域规格是**纯数据**，手写等价对象即可
+ * （`tests/host/storage-domain.test.ts` 用真实 `defineDomain` 验证本对象被接受）。
+ */
+export declare function bindingDomainSpec(): unknown;
+/**
+ * 从插件 ctx 打开绑定域。**永不抛错**；不可用一律返回 `null`（调用方决定降级）。
+ *
+ * 失败面（全部返回 `null`，调用方回落旧 `.bindings.json`）：
+ *  - 宿主未提供 `storageDomain`（未装载 storage-domain 插件 / 老宿主）；
+ *  - `open` 抛错（域名非法 / 后端缺失 `backend-not-found` / 版本不符 / 记录损坏）；
+ *  - 拿到的服务形状不对（无 `open` 函数）。
+ *
+ * @param ctx 插件上下文（真实 cordis Context；测试可传结构化替身）
+ * @returns 域句柄，或 `null`
+ */
+export declare function openBindingDomain(ctx: unknown): Promise<BindingDomainLike | null>;
+/**
+ * 绑定表的**同步读**封装（句柄缺失时全部返回空，语义 = "域里没有"）。
+ *
+ * 为什么单独包一层（而不是让调用方直接拿 table）：
+ *  ① 句柄可能为 `null`（域不可用）⇒ 让 `null` 检查集中在一处；
+ *  ② 读侧要统一做形状容忍（`asBindingRecord`）。
+ */
+export declare class BindingStore {
+    private readonly domain;
+    constructor(domain: BindingDomainLike | null);
+    /** 域是否可用（`false` ⇒ 调用方应回落旧文件） */
+    get available(): boolean;
+    private table;
+    /** 同步读一条（域不可用 → `undefined`） */
+    get(sessionId: string): BindingRecord | undefined;
+    /** 同步遍历全部 `[会话id, 记录]`（域不可用 → 空） */
+    entries(): Array<[string, BindingRecord]>;
+    /** 异步写一条（域不可用 / 落盘失败 → `false`；**不抛**） */
+    put(sessionId: string, rec: BindingRecord): Promise<boolean>;
+    /** 异步删一条（域不可用 / 失败 → `false`；**不抛**） */
+    delete(sessionId: string): Promise<boolean>;
+}
+/** 由域句柄造 store（`null` 句柄 → 不可用 store，读全空、写全 false） */
+export declare function bindingStore(domain: BindingDomainLike | null): BindingStore;

package/lib/index.js

@@ -2,11 +2,12 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { a as hostSettings, c as hostWebServer, i as hostSessions, n as hostInjected, o as hostSubagents, r as hostService, s as hostWeb, t as hostAgents } from "./access-fiehjxV6.js";
 import { a as findSerenityRoot, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, h as resolveInside, i as findGitRoot, l as pathInside, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readHandymanConfig, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-NlLr_sxy.js";
 import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-Bd_SjEs7.js";
-import { C as localFileStamp, S as isoLocal, _ as sessionsRoot, a as DEFAULT_SESSION_SCOPE, b as summarize, c as createSession, d as getActiveSessionInfo, f as listSessions, g as sessionEvents$1, h as resolveSessionByTitle, i as resolveSessionTrajectoryLabel, l as extractSessionMdPathFromText, m as readActiveSessionMd, o as TRAJECTORY_ACTIONS, p as parseSessionContextFromEvents, r as readLastBound, s as clearActiveSessionInfo, t as appendBound, u as findSession, v as setActiveSessionInfo, x as useSession, y as showSession } from "./trajectory-bound-OyuNkn6e.js";
+import { C as showSession, D as localFileStamp, E as isoLocal, S as setActiveSessionInfo, T as useSession, _ as parseSessionContextFromEvents, a as readLastBound, b as sessionEvents$1, c as supersedeOtherBindings, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as pruneMissingBindings, l as DEFAULT_SESSION_SCOPE, m as findSession, o as resolveSessionTrajectoryLabel, p as extractSessionMdPathFromText, r as migrateBindingsToDomain, s as setBindingStore, t as appendBound, u as TRAJECTORY_ACTIONS, v as readActiveSessionMd, w as summarize, x as sessionsRoot, y as resolveSessionByTitle } from "./trajectory-bound-CQTh86vq.js";
 import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-B2ajFypI.js";
 import { a as readSkiffRoles, c as roleMsmWhitelist, d as systemPromptSource, f as trajectorySubset, i as isSkiffSessionId, l as roleToolWhitelist, n as buildSkiffBasePrompt, o as resolveRoleSystemPrompt, r as createRolePromptReader, s as resolveSkiffKind } from "./skiff-role-CEHL5cek.js";
 import { a as unregisterSkiffSession$1, i as skiffSessionSnapshot$1, n as skiffRoleFor$1, r as skiffSessionInfo$1, t as registerSkiffSession$1 } from "./skiff-registry-FTjoWQTQ.js";
-import { a as WAKE_CATCH_UP_MS, i as registerDisposer, n as sendToTrajectory, o as addWake, r as wakeSchedulerState, s as listWakes, t as registerWakeScheduler } from "./wake-scheduler-D0HDjEO8.js";
+import { r as sessionsRootDir, t as hasSessionLogById } from "./session-cleanup-BtkSmry8.js";
+import { a as WAKE_CATCH_UP_MS, i as registerDisposer, n as sendToTrajectory, o as addWake, r as wakeSchedulerState, s as listWakes, t as registerWakeScheduler } from "./wake-scheduler-UTh4t14k.js";
 import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-DMDUoQum.js";
 import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-CtFYm53S.js";
 import z from "@deepseek-ai/schemastery";
@@ -3285,6 +3286,13 @@ function createTrajectoryTool(ctx) {
 						context: active.context
 					};
 					if (advisory) out.advisory = advisory;
+					if (dsh) {
+						const selfId = String(dsh.header?.id ?? "");
+						const superseded = supersedeOtherBindings(root, info?.dirName ?? targetDirName, selfId === "" ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([selfId]));
+						if (superseded.length > 0) out.supersededBindings = superseded;
+						const pruned = pruneMissingBindings(root, (id) => !hasSessionLogById(sessionsRootDir(), id));
+						if (pruned.length > 0) out.prunedBindings = pruned;
+					}
 					return out;
 				}
 				case "rebuild": {
@@ -3340,7 +3348,7 @@ function createTrajectoryTool(ctx) {
 							"✓ 已即时投递",
 							`  · ${res.detail}`,
 							"  · 语义：**不排队** —— 目标正在跑轮次则**当场注入当前轮**（steer），空闲则立即起一轮（followup）。",
-							"  · ⚠️ 回执只到「已注入/已入队」——**不表示**目标已执行或已答复。判\"目标真的动了\"须看它自己的 SESSION.md（文件级判据）。"
+							"  · ⚠️ 回执只到「已注入 / 已起轮」——**不表示**目标已执行或已答复。判\"目标真的动了\"须看它自己的 SESSION.md（文件级判据）。"
 						].join("\n")
 					};
 				}
@@ -7029,7 +7037,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const id = s.id ?? s.header?.id;
 					if (id) liveIds.add(id);
 				}
-				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await import("./session-cleanup-B6IHZgww.js");
+				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await import("./session-cleanup-BtkSmry8.js").then((n) => n.n);
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
@@ -7512,6 +7520,17 @@ const HOST_SERVICES = [
 		}],
 		impact: "双端口网关无法换取 dsh cookie → 外部反代 401",
 		required: false
+	},
+	{
+		id: "storageDomain",
+		name: "storageDomain",
+		access: "lazy",
+		members: [{
+			name: "open",
+			kind: "function"
+		}],
+		impact: "轨迹绑定无处可存 → §0L 整体不可用（须退回\"写会话日志\"备选方案）",
+		required: false
 	}
 ];
 /** dsp 被验证过的宿主版本范围（与 package.json peerDependencies 同源，单一真相源） */
@@ -14436,6 +14455,161 @@ function createAccDiagTool(ctx) {
 	});
 }
 //#endregion
+//#region src/host/storage-domain.ts
+/**
+* host/storage-domain.ts — 宿主存储域上的「会话 ↔ 轨迹」绑定表（§0L，S142 2026-09-19）
+*
+* 为什么存在（R↓）：绑定的载体原本是 CCC 内的 `AGENT_SESSIONS/.bindings.json`。
+* owner 裁定（「放 CCC 不合适」）⇒ 改存**宿主自己的存储域**
+* （`~/.dsh/storages/`，与宿主 `workspace.json` 同处、同类结构、同一套校验）。
+*
+* 能力与边界：
+*  - `openBindingDomain(ctx)`：从插件 ctx 取 `storageDomain`（**经 `hostService` = `ctx.get`**，
+*    **不是**属性直读——dsp 的 `inject` 不含它，属性直读在真实 cordis 下抛
+*    `cannot get property "storageDomain" without inject`，同 v1.31.4 的 subagents 陷阱）；
+*    开域成功返回句柄，任何环节失败返回 `null`（**本模块永不抛错**：宿主对插件 apply 抛错
+*    = 整个 dsh 启动失败，见 `host/access.ts` 的同类契约）。
+*  - 句柄的**读是同步的**（`get` / `entries` / `keys` / `size` 走内存），**写才是异步的**
+*    （`put` / `delete` 等落盘后 resolve）——**这是 §0L 能"向前兼容"的技术前提**：
+*    既有 10 个调用点全是同步签名，故调用方拿到句柄后读法完全不变。
+*
+* 域名约束（实测，`tests/host/storage-domain.test.ts` 钉住）：
+*   `UNIT_NAME_RE = /^[a-z][a-z0-9_]*$/` ⇒ **`serenity_bindings`（下划线）**；
+*   连字符形如 `serenity-bindings` **非法**（会在 `defineDomain` 模块加载期抛错）。
+*
+* 记录形状：与旧 `.bindings.json` **同名字段**（`dirName` / `mdPath` / `sessionId` / `action`
+* / `at` / `note` / `supersededAt`）——同形可显著降低迁移风险，也让"双读兜底"易于对账。
+* 硬锚仍是 **`dirName`**（完整目录名，U4：绝不解析编号前缀）。
+*/
+/** 域名称（下划线；连字符非法——见文件头） */
+const BINDING_DOMAIN_NAME = "serenity_bindings";
+/** 表名 */
+const BINDING_TABLE_NAME = "bindings";
+const passthroughSchema = {
+	parse: (v) => v,
+	safeParse: (v) => ({
+		success: true,
+		data: v
+	})
+};
+/**
+* 构造域规格（宿主 `defineDomain` 的入参形状）。
+*
+* 为什么不引 `@deepseek-ai/dsh-storage-domain` 的 `defineDomain`：
+* 它是**宿主 peer 依赖**（本仓 peer-only 打包，不装它）⇒ 直接 import 会让插件在
+* 未装该包的运行时**模块加载即失败**。域规格是**纯数据**，手写等价对象即可
+* （`tests/host/storage-domain.test.ts` 用真实 `defineDomain` 验证本对象被接受）。
+*/
+function bindingDomainSpec() {
+	return {
+		name: BINDING_DOMAIN_NAME,
+		version: 1,
+		tables: { [BINDING_TABLE_NAME]: { valueSchema: passthroughSchema } }
+	};
+}
+/** 读侧形状容忍（手改 / 旧数据 / 未来字段）：只要求 `dirName` 是字符串 */
+function asBindingRecord(value) {
+	const r = value;
+	if (!r || typeof r !== "object" || typeof r.dirName !== "string") return null;
+	return r;
+}
+/**
+* 从插件 ctx 打开绑定域。**永不抛错**；不可用一律返回 `null`（调用方决定降级）。
+*
+* 失败面（全部返回 `null`，调用方回落旧 `.bindings.json`）：
+*  - 宿主未提供 `storageDomain`（未装载 storage-domain 插件 / 老宿主）；
+*  - `open` 抛错（域名非法 / 后端缺失 `backend-not-found` / 版本不符 / 记录损坏）；
+*  - 拿到的服务形状不对（无 `open` 函数）。
+*
+* @param ctx 插件上下文（真实 cordis Context；测试可传结构化替身）
+* @returns 域句柄，或 `null`
+*/
+async function openBindingDomain(ctx) {
+	const facility = hostService(ctx, "storageDomain");
+	if (!facility || typeof facility.open !== "function") return null;
+	try {
+		const domain = await facility.open(bindingDomainSpec());
+		if (!domain || typeof domain.table !== "function") return null;
+		const table = domain.table(BINDING_TABLE_NAME);
+		if (!table || typeof table.get !== "function") return null;
+		return domain;
+	} catch {
+		return null;
+	}
+}
+/**
+* 绑定表的**同步读**封装（句柄缺失时全部返回空，语义 = "域里没有"）。
+*
+* 为什么单独包一层（而不是让调用方直接拿 table）：
+*  ① 句柄可能为 `null`（域不可用）⇒ 让 `null` 检查集中在一处；
+*  ② 读侧要统一做形状容忍（`asBindingRecord`）。
+*/
+var BindingStore = class {
+	domain;
+	constructor(domain) {
+		this.domain = domain;
+	}
+	/** 域是否可用（`false` ⇒ 调用方应回落旧文件） */
+	get available() {
+		return this.domain !== null;
+	}
+	table() {
+		if (!this.domain) return null;
+		try {
+			return this.domain.table(BINDING_TABLE_NAME);
+		} catch {
+			return null;
+		}
+	}
+	/** 同步读一条（域不可用 → `undefined`） */
+	get(sessionId) {
+		try {
+			const rec = this.table()?.get(sessionId);
+			return rec ? asBindingRecord(rec) ?? void 0 : void 0;
+		} catch {
+			return;
+		}
+	}
+	/** 同步遍历全部 `[会话id, 记录]`（域不可用 → 空） */
+	entries() {
+		const out = [];
+		try {
+			const t = this.table();
+			if (!t) return out;
+			for (const [k, v] of t.entries()) {
+				const rec = asBindingRecord(v);
+				if (rec) out.push([k, rec]);
+			}
+		} catch {}
+		return out;
+	}
+	/** 异步写一条（域不可用 / 落盘失败 → `false`；**不抛**） */
+	async put(sessionId, rec) {
+		try {
+			const t = this.table();
+			if (!t) return false;
+			await t.put(sessionId, rec);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/** 异步删一条（域不可用 / 失败 → `false`；**不抛**） */
+	async delete(sessionId) {
+		try {
+			const t = this.table();
+			if (!t) return false;
+			return await t.delete(sessionId);
+		} catch {
+			return false;
+		}
+	}
+};
+/** 由域句柄造 store（`null` 句柄 → 不可用 store，读全空、写全 false） */
+function bindingStore(domain) {
+	return new BindingStore(domain);
+}
+//#endregion
 //#region src/index.ts
 const name = "dsh-serenity-hooks";
 /** 主动调用的服务；其余（agent 事件）随 harness 装配必然存在
@@ -14487,6 +14661,19 @@ function apply(ctx, config) {
 		if (report !== null && report.issues.length > 0) console.warn(`[serenity-hooks] ${summarizeHostContract(report)}`);
 	} catch {}
 	registerImChannel(weixinChannel);
+	(async () => {
+		try {
+			const domain = await openBindingDomain(ctx);
+			setBindingStore(bindingStore(domain));
+			if (domain) {
+				const root = process.cwd();
+				const stats = migrateBindingsToDomain(root);
+				if (stats.migrated > 0) console.log(`[serenity-hooks] §0L 绑定已迁移入宿主存储域：${stats.migrated} 条（跳过 ${stats.skipped}）`);
+			} else console.log("[serenity-hooks] §0L 存储域不可用 → 绑定继续走 CCC 内 .bindings.json（向前兼容回落）");
+		} catch {
+			setBindingStore(null);
+		}
+	})();
 	if (config.tools) {
 		ctx.tools.register(ccFsTool);
 		ctx.tools.register(createTrajectoryTool(ctx));

package/lib/{session-cleanup-B6IHZgww.js → session-cleanup-BtkSmry8.js}

@@ -1,3 +1,4 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { join } from "node:path";
 import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
 //#region src/session-cleanup.ts
@@ -19,6 +20,16 @@ import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
 *
 * 本模块纯逻辑（零 ctx 依赖）：传入 sessionsRoot + liveIds，可单测。
 */
+var session_cleanup_exports = /* @__PURE__ */ __exportAll({
+	collectEligibleSessions: () => collectEligibleSessions,
+	cutoffDaysAgo: () => cutoffDaysAgo,
+	findSessionLog: () => findSessionLog,
+	hasSessionLogById: () => hasSessionLogById,
+	performCleanup: () => performCleanup,
+	sessionLogArtifacts: () => sessionLogArtifacts,
+	sessionLogBytesById: () => sessionLogBytesById,
+	sessionsRootDir: () => sessionsRootDir
+});
 /** DSH 会话 root：env DSH_HOME → ~/.dsh（config-ops globalConfigPath 同款推导） */
 function sessionsRootDir() {
 	const dshHome = process.env.DSH_HOME ?? join(process.env.HOME ?? "", ".dsh");
@@ -142,9 +153,61 @@ function performCleanup(root, cutoffMs, liveIds = /* @__PURE__ */ new Set(), opt
 function dirOf(logPath) {
 	return logPath.slice(0, logPath.lastIndexOf("/")) || logPath;
 }
+/**
+* 某一 dsh 会话（目录名 / 会话 id）的**当前世代日志体积**（字节）。
+*
+* 为什么要它（S142 §0y「旧会话累积 ⇒ dsh 内存崩溃」，所有者令）：
+*   · 宿主恢复/继续一条会话必须**重放全部事件**（`scanLog` → `materializeAppendBatch`）
+*     ⇒ **代价 ∝ 日志体积**；
+*   · 实测（`_tmp/measure-session-load.mjs`，照宿主 `scanZstdFrames` 复刻）：
+*     一条 **72.2 MB**（zstd）的日志 = 35 559 个 frame / 252.6 MB 文本 / 62 680 条事件，
+*     **光是读一遍峰值 RSS +1 175 MB**（探针什么都不保留）；
+*   · 而宿主的解析缓存 `COLD_LOG_MEMO_MAX_ENTRIES = 2` 是**按条数限、不按字节限**的
+*     （`dsh-session-persistence-jsonl/lib/index.js:2175`）⇒ 两条巨日志 = 上限内。
+* 🔴 **在本函数之前，ACC 侧没有任何地方知道"绑定的这条会话日志多大"——这个信号根本不存在。**
+* 这是"靠 agent 自觉 rebuild 不够"的机制层原因（keeper 的 K 量的是**模型上下文**，压缩后回落；
+* 而**日志文件只增不减** ⇒ rebuild 提醒永远不会因为"日志 72 MB"触发）。
+*
+* 只认会话目录（含任意世代日志）；返回**最高世代**的日志（= 宿主 `findLog` 选中的当前世代）。
+* 未命中 / 不可读 → null（非错误，调用方按"未知"处理）。
+* @param root - DSH 会话 root（{@link sessionsRootDir}）
+* @param sessionId - 会话目录名（`.bindings.json` 的键，含 `session-` 前缀）或裸 id
+* @returns 字节数 + 日志绝对路径；未命中 → null
+*/
+function sessionLogBytesById(root, sessionId) {
+	if (sessionId === "" || !existsSync(root)) return null;
+	const dirName = sessionId.startsWith("session-") ? sessionId : `session-${sessionId}`;
+	for (const project of readdirSync(root, { withFileTypes: true })) {
+		if (!project.isDirectory()) continue;
+		const log = findSessionLog(join(root, project.name, dirName));
+		if (log === null) continue;
+		try {
+			return {
+				bytes: statSync(log).size,
+				path: log
+			};
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+/**
+* **(c) 绑定一致性兜底**的判据：某会话的日志**是否仍在磁盘上**。
+*
+* 🔴 **fail-closed**：sessions root 本身不存在时**一律返回 true（当作"在"）**——
+* 否则换 `DSH_HOME` / 换机器会让"全部绑定看起来都悬空"，进而误清整张绑定表。
+* 只有"root 在、而这个会话目录确实不在"才算悬空。
+* @param sessionRoot - DSH 会话 root（{@link sessionsRootDir}）
+* @param sessionId - 会话目录名（`.bindings.json` 的键）或裸 id
+*/
+function hasSessionLogById(sessionRoot, sessionId) {
+	if (!existsSync(sessionRoot)) return true;
+	return sessionLogBytesById(sessionRoot, sessionId) !== null;
+}
 /** 便捷：默认 N 天前为 cutoff（供 API/调用方） */
 function cutoffDaysAgo(days, nowMs = Date.now()) {
 	return nowMs - days * DAY_MS;
 }
 //#endregion
-export { cutoffDaysAgo, performCleanup, sessionsRootDir };
+export { session_cleanup_exports as n, sessionsRootDir as r, hasSessionLogById as t };

package/lib/session-cleanup.d.ts

@@ -73,6 +73,41 @@ export declare function performCleanup(root: string, cutoffMs: number, liveIds?:
     candidates: CandidateSession[];
     result: CleanupResult | null;
 };
+/**
+ * 某一 dsh 会话（目录名 / 会话 id）的**当前世代日志体积**（字节）。
+ *
+ * 为什么要它（S142 §0y「旧会话累积 ⇒ dsh 内存崩溃」，所有者令）：
+ *   · 宿主恢复/继续一条会话必须**重放全部事件**（`scanLog` → `materializeAppendBatch`）
+ *     ⇒ **代价 ∝ 日志体积**；
+ *   · 实测（`_tmp/measure-session-load.mjs`，照宿主 `scanZstdFrames` 复刻）：
+ *     一条 **72.2 MB**（zstd）的日志 = 35 559 个 frame / 252.6 MB 文本 / 62 680 条事件，
+ *     **光是读一遍峰值 RSS +1 175 MB**（探针什么都不保留）；
+ *   · 而宿主的解析缓存 `COLD_LOG_MEMO_MAX_ENTRIES = 2` 是**按条数限、不按字节限**的
+ *     （`dsh-session-persistence-jsonl/lib/index.js:2175`）⇒ 两条巨日志 = 上限内。
+ * 🔴 **在本函数之前，ACC 侧没有任何地方知道"绑定的这条会话日志多大"——这个信号根本不存在。**
+ * 这是"靠 agent 自觉 rebuild 不够"的机制层原因（keeper 的 K 量的是**模型上下文**，压缩后回落；
+ * 而**日志文件只增不减** ⇒ rebuild 提醒永远不会因为"日志 72 MB"触发）。
+ *
+ * 只认会话目录（含任意世代日志）；返回**最高世代**的日志（= 宿主 `findLog` 选中的当前世代）。
+ * 未命中 / 不可读 → null（非错误，调用方按"未知"处理）。
+ * @param root - DSH 会话 root（{@link sessionsRootDir}）
+ * @param sessionId - 会话目录名（`.bindings.json` 的键，含 `session-` 前缀）或裸 id
+ * @returns 字节数 + 日志绝对路径；未命中 → null
+ */
+export declare function sessionLogBytesById(root: string, sessionId: string): {
+    bytes: number;
+    path: string;
+} | null;
+/**
+ * **(c) 绑定一致性兜底**的判据：某会话的日志**是否仍在磁盘上**。
+ *
+ * 🔴 **fail-closed**：sessions root 本身不存在时**一律返回 true（当作"在"）**——
+ * 否则换 `DSH_HOME` / 换机器会让"全部绑定看起来都悬空"，进而误清整张绑定表。
+ * 只有"root 在、而这个会话目录确实不在"才算悬空。
+ * @param sessionRoot - DSH 会话 root（{@link sessionsRootDir}）
+ * @param sessionId - 会话目录名（`.bindings.json` 的键）或裸 id
+ */
+export declare function hasSessionLogById(sessionRoot: string, sessionId: string): boolean;
 /** 便捷：默认 N 天前为 cutoff（供 API/调用方） */
 export declare function cutoffDaysAgo(days: number, nowMs?: number): number;
 export {};

package/lib/{trajectory-bound-OyuNkn6e.js → trajectory-bound-CQTh86vq.js}

@@ -526,6 +526,107 @@ const SESSION_BOUND_EVENT = "serenity/bound";
 /** 绑定文件相对 CCC 根的路径 */
 const BINDINGS_REL_PATH = "AGENT_SESSIONS/.bindings.json";
 const BINDINGS_VERSION = 1;
+let domainStore = null;
+/**
+* 注入域句柄（装载期调用一次）。传 `null` = 域不可用 ⇒ 全部退回旧文件行为。
+* 幂等：重复调用以后者为准（HMR / 重载场景）。
+*/
+function setBindingStore(store) {
+	domainStore = store;
+}
+/** 域记录 → 本模块记录形状（同名字段，无需映射表；见 host/storage-domain.ts 头注） */
+function fromDomainRecord(rec) {
+	return {
+		dirName: rec.dirName,
+		mdPath: rec.mdPath,
+		...rec.sessionId ? { sessionId: rec.sessionId } : {},
+		action: rec.action ?? "activate",
+		at: typeof rec.at === "number" ? rec.at : 0,
+		...rec.note ? { note: rec.note } : {},
+		...rec.supersededAt !== void 0 ? { supersededAt: rec.supersededAt } : {}
+	};
+}
+/** 本模块记录 → 域记录形状 */
+function toDomainRecord(rec) {
+	return {
+		dirName: rec.dirName,
+		mdPath: rec.mdPath,
+		...rec.sessionId ? { sessionId: rec.sessionId } : {},
+		action: rec.action,
+		at: rec.at,
+		...rec.note ? { note: rec.note } : {},
+		...rec.supersededAt !== void 0 ? { supersededAt: rec.supersededAt } : {}
+	};
+}
+/**
+* §0L **一次性迁移**：把某个 CCC 的旧 `.bindings.json` 全量灌入宿主存储域。
+*
+* 设计要点（R↓）：
+*  - **幂等**：只写域里**尚不存在**的键（`skip existing`）。⇒ 重复调用（每次启动都调）
+*    不会覆盖域里的新状态，也不会因并发而互相踩踏。
+*  - **不删旧文件**：迁移只读不写旧表（owner「向前兼容」的第二道保险仍在）。
+*  - **不丢绑定**：逐条迁移，单条失败不影响其余（返回计数供诊断）。
+*  - **失败静默**：域写不可用 ⇒ 返回 `{migrated:0, skipped:0, failed:0}`，不抛错
+*    （装载期调用，不能成为启动单点）。
+*
+* @param root CCC 根（`AGENT_SESSIONS/.bindings.json` 所在）
+* @returns 迁移计数（诊断用；`migrated` = 本次真正灌入的条数）
+*/
+function migrateBindingsToDomain(root) {
+	const out = {
+		migrated: 0,
+		skipped: 0,
+		failed: 0
+	};
+	if (!domainStore?.available) return out;
+	let file;
+	try {
+		file = readBindingsFile(join(root, BINDINGS_REL_PATH));
+	} catch {
+		return out;
+	}
+	for (const [id, raw] of Object.entries(file.sessions)) {
+		const rec = asBoundRecord(raw);
+		if (!rec) continue;
+		if (domainStore.get(id)) {
+			out.skipped += 1;
+			continue;
+		}
+		try {
+			domainStore.put(id, toDomainRecord(rec)).catch(() => {});
+			out.migrated += 1;
+		} catch {
+			out.failed += 1;
+		}
+	}
+	return out;
+}
+/**
+* 域内读一条（同步）。域不可用 → `undefined`（调用方据此回落文件）。
+* @param sessionId dsh 会话 id
+*/
+function readFromDomain(sessionId) {
+	if (!domainStore?.available) return void 0;
+	const rec = domainStore.get(sessionId);
+	return rec ? fromDomainRecord(rec) : void 0;
+}
+/**
+* 域内取**某轨迹的全部绑定**（同步；已排除 superseded —— 与 `listBoundSessionIds` 同判据）。
+* 域不可用 → `null`（**注意与"空结果"区分**：null = 回落文件，[] = 域里确实没有）。
+*/
+function listFromDomain(dirName) {
+	if (!domainStore?.available) return null;
+	const out = [];
+	for (const [id, raw] of domainStore.entries()) {
+		const rec = fromDomainRecord(raw);
+		if (rec.dirName !== dirName) continue;
+		out.push({
+			id,
+			rec
+		});
+	}
+	return out;
+}
 function sessionHeader(session) {
 	const header = session?.header;
 	if (!header || typeof header !== "object") return null;
@@ -586,12 +687,21 @@ function readLegacyBoundFromEvents(session) {
 	return null;
 }
 /**
-* 读取会话当前绑定（权威，latest-wins）：文件记录优先，无则回落旧事件形态。
+* 读取会话当前绑定（权威，latest-wins）。
+*
+* 读取顺序（§0L，S142 2026-09-19）：
+*  1. **宿主存储域**（域可用时的权威来源）；
+*  2. **旧文件** `.bindings.json`（域不可用 ⇒ 零回归回落；域可用但该会话未迁移 ⇒ 兜底）；
+*  3. **旧事件形态** `serenity/bound`（v1.30.5 及更早的存量）。
 * 无绑定返回 null。
 */
 function readLastBound(session) {
-	const path = bindingsPathFor(session);
 	const id = sessionHeader(session)?.id;
+	if (typeof id === "string") {
+		const fromDomain = readFromDomain(id);
+		if (fromDomain) return fromDomain;
+	}
+	const path = bindingsPathFor(session);
 	if (path && typeof id === "string") {
 		const rec = asBoundRecord(readBindingsFile(path).sessions[id]);
 		if (rec) return rec;
@@ -639,11 +749,24 @@ function resolveSessionTrajectoryLabel(session, scope) {
 * @returns 会话 id 列表（最新绑定在前）；无绑定 → `[]`
 */
 function listBoundSessionIds(root, dirName) {
-	const file = readBindingsFile(join(root, BINDINGS_REL_PATH));
 	const hits = [];
+	const fromDomain = listFromDomain(dirName);
+	if (fromDomain !== null) {
+		for (const { id, rec } of fromDomain) {
+			if (rec.supersededAt !== void 0) continue;
+			hits.push({
+				id,
+				at: typeof rec.at === "number" ? rec.at : 0
+			});
+		}
+		if (hits.length > 0) return hits.sort((a, b) => b.at - a.at).map((h) => h.id);
+	}
+	const file = readBindingsFile(join(root, BINDINGS_REL_PATH));
 	for (const [id, raw] of Object.entries(file.sessions)) {
 		const rec = asBoundRecord(raw);
 		if (!rec || rec.dirName !== dirName) continue;
+		if (rec.supersededAt !== void 0) continue;
+		if (hits.some((h) => h.id === id)) continue;
 		hits.push({
 			id,
 			at: typeof rec.at === "number" ? rec.at : 0
@@ -652,6 +775,108 @@ function listBoundSessionIds(root, dirName) {
 	return hits.sort((a, b) => b.at - a.at).map((h) => h.id);
 }
 /**
+* **(b) 同一 trajectory 多 live 会话的机械守卫**（S142 §0y，所有者 2026-09-18 裁「b 做」）。
+*
+* 把绑定到 `dirName` 的**其它**会话 id 标记为 `supersededAt` —— **保留记录**（沿革/正向查询不丢），
+* 只切断"**唤醒还会找到它**"这条路。语义上即"解绑"，且**不动那个会话本身**（它仍可被人工使用）。
+*
+* 为什么必须有机制（R↓）：`.bindings.json` 的语义是"latest-wins 覆盖**本条会话记录**"，
+* 对**同一 trajectory 的其它会话**没有任何约束 ⇒ 多代会话自然堆积（实测 S142 4 代 / S185 2 代），
+* 而 `acquireWakeAgent` 是"遍历全部绑定 id、任一条 live 就用它"——**两条 live 都能被选中**。
+*
+* @param root CCC 根
+* @param dirName 目标 trajectory 目录名
+* @param keepIds 保留（不标记）的会话 id 集合——通常是"当前正在 use 的这条"
+* @returns **实际被标记**的会话 id（升序稳定；供调用方如实报告，未标记任何一条 → `[]`）
+*/
+function supersedeOtherBindings(root, dirName, keepIds) {
+	const path = join(root, BINDINGS_REL_PATH);
+	const file = readBindingsFile(path);
+	const at = Date.now();
+	/**
+	* 需要退休的会话 id 集合。
+	*
+	* 🔴 必须取**域 ∪ 文件的并集**（实测缺陷，2026-09-19）：
+	* 首版实现只在**文件循环**里 `marked.push(id)`，于是"记录只在域里"时
+	* 返回值恒为 `[]` —— 而调用方（`tools/trajectory.ts` 的 `use`）**靠这个返回值**决定
+	* 是否回报 `supersededBindings`，并且早先用 `marked.length === 0` 短路**跳过了写盘**。
+	* ⇒ 症状是"D69 只留一条**静默不生效**"（记录没被标记，返回也看不出异常）。
+	* 由 `tests/trajectory-bound.test.ts` 的 D69 域路径用例抓到。
+	*/
+	const toMark = /* @__PURE__ */ new Set();
+	if (domainStore?.available) for (const [id, raw] of domainStore.entries()) {
+		const rec = fromDomainRecord(raw);
+		if (rec.dirName !== dirName) continue;
+		if (keepIds.has(id) || rec.supersededAt !== void 0) continue;
+		toMark.add(id);
+	}
+	for (const [id, raw] of Object.entries(file.sessions)) {
+		const rec = asBoundRecord(raw);
+		if (!rec || rec.dirName !== dirName) continue;
+		if (keepIds.has(id) || rec.supersededAt !== void 0) continue;
+		toMark.add(id);
+	}
+	if (toMark.size === 0) return [];
+	if (domainStore?.available) for (const id of toMark) {
+		const raw = domainStore.get(id);
+		if (!raw) continue;
+		domainStore.put(id, toDomainRecord({
+			...fromDomainRecord(raw),
+			supersededAt: at
+		})).catch(() => {});
+	}
+	for (const id of toMark) {
+		const rec = asBoundRecord(file.sessions[id]);
+		if (!rec) continue;
+		rec.supersededAt = at;
+		file.sessions[id] = rec;
+	}
+	try {
+		writeBindingsFile(path, file);
+	} catch {}
+	return [...toMark].sort();
+}
+/**
+* **(c) 绑定一致性兜底**（S142 §0y，所有者 2026-09-18 裁「c 也算个兜底」）：
+* 删除指向**已不存在**的 dsh 会话的绑定记录。
+*
+* 为什么需要：`.bindings.json` **只增不清**，而 DSH 会话目录会被
+* `session-cleanup`（本仓既有机制）物理删除 ⇒ 表里必然残留**悬空 id**。
+* 悬空记录本身无害，但它会**污染反向索引**（`listBoundSessionIds` 是唤醒选人的唯一入口），
+* 让"这条轨迹到底还有没有可用会话"变得不可判。
+*
+* 🔴 **安全性由调用方的判据负责**（本函数是纯函数，不认识文件系统）：
+* `isMissing` 必须是 **fail-closed** 的（读不到 ⇒ 返回 false = "不当作缺失"），
+* 见 `hasSessionLogById`。判据写错会**清掉整张表**，故此处刻意不提供默认实现。
+*
+* @param root CCC 根
+* @param isMissing 判据：该会话 id 是否**确认**已不存在（false = 保留）
+* @returns 被删除的会话 id（升序稳定；未删任何一条 → `[]`）
+*/
+function pruneMissingBindings(root, isMissing) {
+	const path = join(root, BINDINGS_REL_PATH);
+	const file = readBindingsFile(path);
+	const toRemove = /* @__PURE__ */ new Set();
+	const judge = (id) => {
+		try {
+			return isMissing(id);
+		} catch {
+			return false;
+		}
+	};
+	if (domainStore?.available) {
+		for (const [id] of domainStore.entries()) if (judge(id)) toRemove.add(id);
+	}
+	for (const id of Object.keys(file.sessions)) if (judge(id)) toRemove.add(id);
+	if (toRemove.size === 0) return [];
+	if (domainStore?.available) for (const id of toRemove) domainStore.delete(id).catch(() => {});
+	for (const id of toRemove) delete file.sessions[id];
+	try {
+		writeBindingsFile(path, file);
+	} catch {}
+	return [...toRemove].sort();
+}
+/**
 * 写入绑定（latest-wins 覆盖该会话记录）。
 *
 * 绑定持久化尽力而为：无法定位 CCC 根 / 无会话 id / 写盘失败 → 返回 false，不阻断主流程。
@@ -662,22 +887,25 @@ function listBoundSessionIds(root, dirName) {
 function appendBound(session, action, rec) {
 	const path = bindingsPathFor(session);
 	const id = sessionHeader(session)?.id;
-	if (!path || typeof id !== "string") return false;
+	if (typeof id !== "string") return false;
+	const record = {
+		dirName: rec.dirName,
+		mdPath: rec.mdPath,
+		...rec.sessionId ? { sessionId: rec.sessionId } : {},
+		action,
+		at: Date.now(),
+		...rec.note ? { note: rec.note } : {}
+	};
+	if (domainStore?.available) domainStore.put(id, toDomainRecord(record)).catch(() => {});
+	if (!path) return domainStore?.available === true;
 	try {
 		const file = readBindingsFile(path);
-		file.sessions[id] = {
-			dirName: rec.dirName,
-			mdPath: rec.mdPath,
-			...rec.sessionId ? { sessionId: rec.sessionId } : {},
-			action,
-			at: Date.now(),
-			...rec.note ? { note: rec.note } : {}
-		};
+		file.sessions[id] = record;
 		writeBindingsFile(path, file);
 		return true;
 	} catch {
-		return false;
+		return domainStore?.available === true;
 	}
 }
 //#endregion
-export { localFileStamp as C, isoLocal as S, localIdStamp as T, sessionsRoot as _, DEFAULT_SESSION_SCOPE as a, summarize as b, createSession as c, getActiveSessionInfo as d, listSessions as f, sessionEvents as g, resolveSessionByTitle as h, resolveSessionTrajectoryLabel as i, extractSessionMdPathFromText as l, readActiveSessionMd as m, listBoundSessionIds as n, TRAJECTORY_ACTIONS as o, parseSessionContextFromEvents as p, readLastBound as r, clearActiveSessionInfo as s, appendBound as t, findSession as u, setActiveSessionInfo as v, localHuman as w, useSession as x, showSession as y };
+export { showSession as C, localFileStamp as D, isoLocal as E, localHuman as O, setActiveSessionInfo as S, useSession as T, parseSessionContextFromEvents as _, readLastBound as a, sessionEvents as b, supersedeOtherBindings as c, clearActiveSessionInfo as d, createSession as f, listSessions as g, getActiveSessionInfo as h, pruneMissingBindings as i, localIdStamp as k, DEFAULT_SESSION_SCOPE as l, findSession as m, listBoundSessionIds as n, resolveSessionTrajectoryLabel as o, extractSessionMdPathFromText as p, migrateBindingsToDomain as r, setBindingStore as s, appendBound as t, TRAJECTORY_ACTIONS as u, readActiveSessionMd as v, summarize as w, sessionsRoot as x, resolveSessionByTitle as y };

package/lib/trajectory-bound.d.ts

@@ -23,6 +23,7 @@
  * 编码无关（U4）：绑定锚 = **完整 AGENT_SESSIONS 目录名**（磁盘唯一存在），
  * sessionId（S###/apaas-xxx/自定义）仅是派生展示字段——绝不假设 S 前缀。
  */
+import { type BindingStore } from './host/storage-domain.js';
 type SessionBoundAction = 'activate' | 'switch' | 'create' | 'rebuild' | 'reconcile' | 'release';
 interface SessionBoundRecord {
     dirName: string;
@@ -31,13 +32,55 @@ interface SessionBoundRecord {
     action: SessionBoundAction;
     at: number;
     note?: string;
+    /**
+     * **(b) 已被取代标记**（S142 §0y，所有者 2026-09-18 裁「b 做」）。
+     *
+     * 语义：这条绑定**仍然存在**（沿革不丢、正向 `readLastBound` 仍能查到"我曾属于哪条轨迹"），
+     * 但**不再作为唤醒候选**（{@link listBoundSessionIds} 过滤掉）——这正是"解绑"的机械形态。
+     *
+     * 为什么需要（实证）：`.bindings.json` 只增不清——实测 S142 名下挂 **4 代**、S185 挂 **2 代**，
+     * 同一 trajectory 因此可以有**两条 live 会话**：各持一份完整上下文（内存翻倍）
+     * 且**都在写同一批文件**（双写者）。
+     */
+    supersededAt?: number;
 }
 /** 绑定文件相对 CCC 根的路径 */
 export declare const BINDINGS_REL_PATH = "AGENT_SESSIONS/.bindings.json";
+/**
+ * 注入域句柄（装载期调用一次）。传 `null` = 域不可用 ⇒ 全部退回旧文件行为。
+ * 幂等：重复调用以后者为准（HMR / 重载场景）。
+ */
+export declare function setBindingStore(store: BindingStore | null): void;
+/** 当前域句柄（诊断用；`null` = 未接线/不可用） */
+export declare function getBindingStore(): BindingStore | null;
+/**
+ * §0L **一次性迁移**：把某个 CCC 的旧 `.bindings.json` 全量灌入宿主存储域。
+ *
+ * 设计要点（R↓）：
+ *  - **幂等**：只写域里**尚不存在**的键（`skip existing`）。⇒ 重复调用（每次启动都调）
+ *    不会覆盖域里的新状态，也不会因并发而互相踩踏。
+ *  - **不删旧文件**：迁移只读不写旧表（owner「向前兼容」的第二道保险仍在）。
+ *  - **不丢绑定**：逐条迁移，单条失败不影响其余（返回计数供诊断）。
+ *  - **失败静默**：域写不可用 ⇒ 返回 `{migrated:0, skipped:0, failed:0}`，不抛错
+ *    （装载期调用，不能成为启动单点）。
+ *
+ * @param root CCC 根（`AGENT_SESSIONS/.bindings.json` 所在）
+ * @returns 迁移计数（诊断用；`migrated` = 本次真正灌入的条数）
+ */
+export declare function migrateBindingsToDomain(root: string): {
+    migrated: number;
+    skipped: number;
+    failed: number;
+};
 /** 绑定文件绝对路径（由会话 cwd 上溯 .serenity 定位 CCC 根）；无法定位返回 null */
 export declare function bindingsPathFor(session: unknown): string | null;
 /**
- * 读取会话当前绑定（权威，latest-wins）：文件记录优先，无则回落旧事件形态。
+ * 读取会话当前绑定（权威，latest-wins）。
+ *
+ * 读取顺序（§0L，S142 2026-09-19）：
+ *  1. **宿主存储域**（域可用时的权威来源）；
+ *  2. **旧文件** `.bindings.json`（域不可用 ⇒ 零回归回落；域可用但该会话未迁移 ⇒ 兜底）；
+ *  3. **旧事件形态** `serenity/bound`（v1.30.5 及更早的存量）。
  * 无绑定返回 null。
  */
 export declare function readLastBound(session: unknown): SessionBoundRecord | null;
@@ -73,6 +116,40 @@ export declare function resolveSessionTrajectoryLabel(session: unknown, scope: s
  * @returns 会话 id 列表（最新绑定在前）；无绑定 → `[]`
  */
 export declare function listBoundSessionIds(root: string, dirName: string): string[];
+/**
+ * **(b) 同一 trajectory 多 live 会话的机械守卫**（S142 §0y，所有者 2026-09-18 裁「b 做」）。
+ *
+ * 把绑定到 `dirName` 的**其它**会话 id 标记为 `supersededAt` —— **保留记录**（沿革/正向查询不丢），
+ * 只切断"**唤醒还会找到它**"这条路。语义上即"解绑"，且**不动那个会话本身**（它仍可被人工使用）。
+ *
+ * 为什么必须有机制（R↓）：`.bindings.json` 的语义是"latest-wins 覆盖**本条会话记录**"，
+ * 对**同一 trajectory 的其它会话**没有任何约束 ⇒ 多代会话自然堆积（实测 S142 4 代 / S185 2 代），
+ * 而 `acquireWakeAgent` 是"遍历全部绑定 id、任一条 live 就用它"——**两条 live 都能被选中**。
+ *
+ * @param root CCC 根
+ * @param dirName 目标 trajectory 目录名
+ * @param keepIds 保留（不标记）的会话 id 集合——通常是"当前正在 use 的这条"
+ * @returns **实际被标记**的会话 id（升序稳定；供调用方如实报告，未标记任何一条 → `[]`）
+ */
+export declare function supersedeOtherBindings(root: string, dirName: string, keepIds: ReadonlySet<string>): string[];
+/**
+ * **(c) 绑定一致性兜底**（S142 §0y，所有者 2026-09-18 裁「c 也算个兜底」）：
+ * 删除指向**已不存在**的 dsh 会话的绑定记录。
+ *
+ * 为什么需要：`.bindings.json` **只增不清**，而 DSH 会话目录会被
+ * `session-cleanup`（本仓既有机制）物理删除 ⇒ 表里必然残留**悬空 id**。
+ * 悬空记录本身无害，但它会**污染反向索引**（`listBoundSessionIds` 是唤醒选人的唯一入口），
+ * 让"这条轨迹到底还有没有可用会话"变得不可判。
+ *
+ * 🔴 **安全性由调用方的判据负责**（本函数是纯函数，不认识文件系统）：
+ * `isMissing` 必须是 **fail-closed** 的（读不到 ⇒ 返回 false = "不当作缺失"），
+ * 见 `hasSessionLogById`。判据写错会**清掉整张表**，故此处刻意不提供默认实现。
+ *
+ * @param root CCC 根
+ * @param isMissing 判据：该会话 id 是否**确认**已不存在（false = 保留）
+ * @returns 被删除的会话 id（升序稳定；未删任何一条 → `[]`）
+ */
+export declare function pruneMissingBindings(root: string, isMissing: (sessionId: string) => boolean): string[];
 /**
  * 写入绑定（latest-wins 覆盖该会话记录）。
  *

package/lib/{wake-scheduler-D0HDjEO8.js → wake-scheduler-UTh4t14k.js}

@@ -1,6 +1,6 @@
 import { r as hostService, t as hostAgents } from "./access-fiehjxV6.js";
 import { o as listCccs } from "./ccc-roots-Bd_SjEs7.js";
-import { S as isoLocal, T as localIdStamp, _ as sessionsRoot, n as listBoundSessionIds, u as findSession, w as localHuman } from "./trajectory-bound-OyuNkn6e.js";
+import { E as isoLocal, O as localHuman, k as localIdStamp, m as findSession, n as listBoundSessionIds, x as sessionsRoot } from "./trajectory-bound-CQTh86vq.js";
 import { t as readSimpleSettings } from "./settings-section-DMDUoQum.js";
 import { basename, dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -572,6 +572,7 @@ function wakeSchedulerState() {
 * @param root CCC 根
 * @param dirName 目标 trajectory 目录名
 * @returns 命中返回 agent 与取得方式（how 进 lastResult，便于诊断）；未命中返回原因
+*   （原因带 `notReady` = **环境未就绪**而非投递失败，调用方**不得**据此记一次失败）
 */
 async function acquireWakeAgent(ctx, root, dirName) {
 	const agents = hostAgents(ctx);
@@ -586,7 +587,10 @@ async function acquireWakeAgent(ctx, root, dirName) {
 	if (ids.length > 0) {
 		const sc = hostService(ctx, "sessionController");
 		const resolved = sc?.resolveAgent;
-		if (typeof resolved !== "function") return { error: `目标会话未加载且 sessionController 不可用（headless profile？）——绑定 id: ${ids[0]}` };
+		if (typeof resolved !== "function") return {
+			error: `宿主尚未就绪：目标会话未加载，且 sessionController 服务此刻不可用（重启后的启动窗口，或本进程确实无该服务）——绑定 id: ${ids[0]}`,
+			notReady: true
+		};
 		const id = ids[0];
 		try {
 			const out = await resolved.call(sc, id);
@@ -631,7 +635,8 @@ async function deliverWake(ctx, root, entry) {
 	const acquired = await acquireWakeAgent(ctx, root, target.dirName);
 	if ("error" in acquired) return {
 		ok: false,
-		detail: acquired.error
+		detail: acquired.error,
+		notReady: acquired.notReady === true
 	};
 	try {
 		acquired.agent.followup(createUserMessage({
@@ -811,6 +816,10 @@ async function runWakeTick(ctx) {
 		}
 		for (const e of due) {
 			const res = await deliverWake(ctx, root, e);
+			if (res.notReady) {
+				log.push(`· ${root}: ${e.id} → 跳过（宿主服务未就绪，下个 tick 再试；不计失败）`);
+				continue;
+			}
 			updateWake(root, e.id, {
 				state: res.ok ? "delivered" : "pending",
 				attempts: e.attempts + 1,

package/lib/wake-scheduler.d.ts

@@ -14,7 +14,8 @@
  *     → 回退：live 会话标题匹配
  *  3. agent：**live 优先**（`ctx.agents.get`）→ 冷会话走 `ctx.sessionController.resolveAgent`
  *     （宿主实现：live 优先 + resume 去重 + 由会话元数据恢复 preset）
- *     → `sessionController` 缺席（headless profile）⇒ 仅投递 live 目标，**不静默**
+ *     → `sessionController` 缺席 ⇒ 仅投递 live 目标，**不静默**（v1.39.3：**归为"环境未就绪"**
+ *       而非"投递失败"，见 `WakeDeliveryResult.notReady` —— 启动那一拍早于懒服务就绪是常态）
  *  4. 投递：`agent.followup(...)`（"Queue an ordinary follow-up turn and wake the driver"）
  *
  * 守卫（I-4 默认 + v1.34 S-1 解耦）：全局 `wakeSchedulerEnabled`（**缺省开**；**不再**回退旧键
@@ -28,6 +29,19 @@ import { type WakeEntry } from './wake-registry.js';
 interface WakeDeliveryResult {
     ok: boolean;
     detail: string;
+    /**
+     * 🔴 **环境未就绪**（不是投递失败）——只有一种情形：目标需要**冷载入**，而宿主此刻**还没把
+     * 懒服务 `sessionController` 供上来**（典型 = `dsh web` 刚重启：时钟武装时**立刻跑一次 tick**，
+     * 那一拍早于懒服务就绪、也早于会话恢复）。
+     *
+     * 为什么要把它和"真失败"分开（2026-09-17 实测，S142 §0t）：
+     * 旧实现把这一情形当成投递失败写进条目 ⇒ ① `attempts` 无端 +1 ② `lastResult` 留下一条
+     * **误导性错误**（原文猜"headless profile？"，而真因是**重启窗口**，属**假陈述**）
+     * ③ 注册表/面板里出现"失败的投递"，**每次 restart 都必然复现**——一个**假告警发生器**
+     * （所有者 2026-09-17 就是被它引来的）。而消息**从未丢失**：下一个 tick 就投成功了。
+     * ⇒ 判据：**"宿主服务还没起来"不是投递结果**，不得计入条目。
+     */
+    notReady?: boolean;
 }
 /**
  * 调度器**进程态**（诊断用，模块级 = 进程级，正是诊断对象）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.39.2",
+  "version": "1.40.0",
   "description": "宁静号 ACC harness（Native Cordis 插件）——给 DeepSeek Harness 装一个「AI 工作区」：11 个工具（container_fs/container_trajectory/dashboard/container_git/msm/praxis/handyman/localstore/container_admin/im-bridge/acc-diag）+ 机械约束（安全模式/工作区围墙/密钥守卫/对外输出守卫）+ 工作日志与原地重建 + 网页登录入口/微信桥/子角色/对外问答页/trajectory 唤醒注册表。适配 DSH 0.1.5-rc.2。",
   "license": "MIT",
   "repository": {