@shgroup/dsh-serenity-hooks 1.70.0 → 1.72.0

package/lib/{message-source-DhA1dVBi.js → profile-DyMJ_bfr.js}

@@ -1,9 +1,10 @@
-import { r as cccRootForCwd } from "./ccc-roots-RzasspMr.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { _ as resolveInside, g as readUtf8 } from "./ccc-Dkoa2oW3.js";
 import { basename, dirname, join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-//#region src/time.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+//#region src/kernel/time.ts
 /**
-* time.ts — ACC **时间呈现的单一真相源**（S142 2026-09-17，所有者令：「统一 ACC 所有使用时间的地方使用当地时区」）
+* kernel/time.ts — ACC **时间呈现的单一真相源**（S142 2026-09-17，所有者令：「统一 ACC 所有使用时间的地方使用当地时区」）
 *
 * ── 存在的理由：**把"时刻"与"呈现"分开**（R↓）
 *
@@ -87,9 +88,9 @@ function localIdStamp(value = Date.now()) {
 	return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}`;
 }
 //#endregion
-//#region src/cognitive-trajectory-ops.ts
+//#region src/trajectory/core.ts
 /**
-* cognitive-trajectory-ops.ts — 轨迹工具纯操作层（零 DSH 依赖，可独立单测）
+* trajectory/core.ts — 轨迹工具纯操作层（零 DSH 依赖，可独立单测）
 *
 * 行为对齐 osp（opencode-serenity-plugin/src/session/lib.ts）——osp 是 ACC 工具 spec。
 *
@@ -212,10 +213,44 @@ function readAllSessions(sessionsDir) {
 		return [];
 	}
 }
-/** 提取目录名中的会话 ID（S### 或 issue 名）；无匹配返回 '' */
+/** 目录名的日期前缀（`createSession` 恒写；`isSessionDirName` 同源判据） */
+const DIR_DATE_PREFIX_RE = /^\d{4}-\d{2}-\d{2}--/;
+/** 合法编码：`[A-Za-z0-9]` 开头，其后 `[A-Za-z0-9._-]`，≤64，**不含 `--`** */
+const CODE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+/**
+* 校验轨迹编码形态。**这是写入侧（create --id）与外部输入的唯一闸门。**
+*
+* 判据三条（R↓）：
+* ① `CODE_PATTERN` —— 只允许交流安全字符：编码会被逐字打在命令、消息、日志里，
+*    含空格/引号/中文会在 shell、JSON、markdown 各需一套转义（旧 UID 的同一条理由，D158）；
+* ② **不得含 `--`** —— 目录名解析用它当分隔符（见上）；
+* ③ 长度上限 64（同旧 UID；够长以致不会撞名，够短以致能打出来）。
+*
+* ⚠️ 大小写**敏感**：`S142` 与 `s142` 是两个不同编码（编码不是近似匹配语义）。
+*/
+function isValidTrajectoryCode(code) {
+	return CODE_PATTERN.test(code) && !code.includes("--");
+}
+/**
+* 从目录名解析轨迹编码（固定位置 = 剥掉日期前缀后的第一段）。
+*
+* @returns 编码；目录名不带日期前缀（非本工具建的 / 损坏）→ `null`
+*/
+function parseTrajectoryCode(dirName) {
+	if (!DIR_DATE_PREFIX_RE.test(dirName)) return null;
+	const rest = dirName.replace(DIR_DATE_PREFIX_RE, "");
+	const sep = rest.indexOf("--");
+	const code = sep === -1 ? rest : rest.slice(0, sep);
+	return code === "" ? null : code;
+}
+/**
+* 展示用会话 ID（`list` 面板 / 绑定记录的 `sessionId` 字段）。
+*
+* 🔴 2026-10-19 起**编码即 ID**，不再只认 `S###` —— 旧实现只匹配 `--S(\d{3,})--`，
+* 自定义编码（owner 令允许的那类）会全被渲染成空串。无编码 → `''`（不是目录名：调用方各有回退）。
+*/
 function extractSessionId(dirName) {
-	const m = dirName.match(/--S(\d{3,})--/);
-	return m ? `S${m[1]}` : "";
+	return parseTrajectoryCode(dirName) ?? "";
 }
 /**
 * UID 的声明文件名（**固定名、住在轨迹目录内**）。
@@ -233,19 +268,32 @@ function extractSessionId(dirName) {
 * | **独立小文件**（选定） | 与目录名、SESSION.md **都解耦**；改标识符不动正文、不动目录名；删文件即"回到用编码" |
 *
 * ## 语义边界（R↓）
-* - **可选**：文件不存在 ⇒ 用编码（`S###`），**不是错误**。
+* - **可选**：文件不存在 ⇒ 用编码，**不是错误**。
 * - **只用于"被指认"**：它是 `findSession` 的一个**解析分支**，不参与排序、不参与展示优先级、
 *   **不改变**目录名与 SESSION.md 一个字节（与 `archive` 同一条纪律：只换指认方式，不动本体）。
-* - **唯一性**：由 `setTrajectoryUid` 在写入时保证（重复即拒绝）。读取侧不做全表唯一性断言 ——
-*   外部手工造的重复应由写入侧拦，读取侧只能"第一个命中"，那是注入侧的职责不是解析侧的。
+*
+* ## 🔴 2026-10-19：**写入侧退役，读取侧保留**
+*
+* owner 追加令裁 B 案：「取消 `S###` 与 UID 的二元性 —— 编码就是唯一标识，用户可指定」。
+* UID 当初存在的**唯一理由**是「命名很可能由于变化而变化」（D158），而现在的编码
+* **本身就稳定且可指定**（`create --id`）⇒ 该理由被覆盖 ⇒ **二元性取消**。
+*
+* 处置（**不对称，刻意**）：
+* - **写**：`setTrajectoryUid()` **已删除**（`uid` 动作改为报"已退役"并指向 `create --id`）；
+* - **读**：本文件与 `findSession` 的 UID 分支**保留** —— 存量文件（本仓 = S142 的
+*   `serenity-acc-maintainer`）仍能按它指认，**不因退役而失去能力**。
+*
+* ⚠️ **为什么不物理删除那些文件**：删了就丢掉一个仍在被读的指认通道（能力倒退），
+* 而保留的成本是零（文件不存在 ⇒ `readFileSync` 失败 ⇒ null）。
+* 判据：**退役的是"产生新标识"这种能力，不是"旧标识还在被用"这个事实。**
 */
 const UID_FILENAME = "TRAJECTORY-UID";
-/** UID 合法形态：**保守**（只允许交流安全的字符）—— 它会被用在命令行、消息文本、日志里 */
+/** UID 合法形态（**只读兼容用**；新编码的形态校验见 `isValidTrajectoryCode`） */
 const UID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 /**
-* 校验 UID 形态。
+* 校验 UID 形态（**只读兼容路径** —— 写入侧已退役，见 `UID_FILENAME` 的 R↓ 段）。
 *
-* 为什么保守（R↓）：UID 是**给人和 agent 在对话里互相指认用的**（owner：「用于交流」）⇒
+* 为什么保守：UID 是**给人和 agent 在对话里互相指认用的**（owner：「用于交流」）⇒
 * 它必须能**逐字打出来**。含空格/引号/中文的 UID 会在 shell、JSON、markdown 里各自需要一套转义
 * ⇒ "用于交流"这个目的当场失败。⇒ 限定 `[A-Za-z0-9._-]`，首字符必须字母数字，上限 64。
 *
@@ -260,7 +308,7 @@ function isValidUid(uid) {
 *
 * 🔴 **形态非法的文件按"没设定"处理，而不是报错**：解析侧出现在**每一次** `findSession` 里
 * （show/use/archive/send-now/send-later 全走它），在那里抛错会让一个坏文件**炸掉整条轨迹的所有操作**
-* —— 惩罚远大于问题本身。坏 UID 由 `setTrajectoryUid` 在**写入侧**拦住（那里才该响亮失败）。
+* —— 惩罚远大于问题本身。而写入侧已退役 ⇒ 坏文件只可能来自外部手改，更不该连坐。
 */
 function readTrajectoryUid(sessionPath) {
 	try {
@@ -271,58 +319,33 @@ function readTrajectoryUid(sessionPath) {
 	}
 }
 /**
-* 设定 / 清除一条轨迹的 UID。
-*
-* @param sessionsDir AGENT_SESSIONS 绝对路径
-* @param key 定位用（目录名 / S### / 既有 UID / 唯一模糊串）
-* @param uid 新 UID；`null` ⇒ **删除声明文件**（回到"用编码"）
-* @throws UID 形态非法 ／ 已被**别的**轨迹占用 ／ 目标轨迹不存在
-*/
-function setTrajectoryUid(sessionsDir, key, uid) {
-	const target = findSession(sessionsDir, key);
-	if (!target) throw new Error(`Trajectory not found: "${key}". Use "list" to see available trajectories.`);
-	const file = join(target.path, UID_FILENAME);
-	if (uid === null) {
-		rmSync(file, { force: true });
-		return {
-			dirName: target.dirName,
-			uid: null,
-			path: file
-		};
-	}
-	if (!isValidUid(uid)) throw new Error(`Invalid trajectory UID: "${uid}". 允许 [A-Za-z0-9._-]，首字符须字母或数字，长度 ≤64（它要被逐字打出来用于交流 ⇒ 不容忍需要转义的字符）`);
-	const clash = readAllSessions(sessionsDir).find((s) => s.dirName !== target.dirName && readTrajectoryUid(s.path) === uid);
-	if (clash) throw new Error(`UID "${uid}" 已被 ${clash.dirName} 占用（唯一标识符必须唯一；先解除它或换一个）`);
-	writeFileSync(file, uid + "\n", "utf-8");
-	return {
-		dirName: target.dirName,
-		uid,
-		path: file
-	};
-}
-/**
 * 根据 key 查找轨迹。
 *
 * 解析顺序（**越精确越靠前**，且**前三级都不做模糊**）：
-* ① 目录名精确 ／ ② **UID 精确** ／ ③ 编码 `S###`（允许 `S31`→`031`）／ ④ 唯一模糊子串（多个则报错）
+* ① 目录名精确 ／ ② **编码精确** ／ ③ **UID 精确（只读兼容）** ／ ④ 唯一模糊子串（多个则报错）
+*
+* 🔴 **2026-10-19 起编码排在 UID 之前**（旧顺序相反）：编码现在是**一等标识**
+* （owner：「固定为目录中的固定位置编码」＋「允许用户指定」），而 UID 已退役为兼容层。
+* 顺序对结果无实质影响（两者都属精确匹配、形态互斥 —— 编码不含 `--`），
+* 但把顺序写死，避免后来者以为"编码是模糊匹配的一种"或"UID 优先"。
 *
-* 🔴 **UID 排在编码之前**是因为 owner 定的语义：UID 是"单独设定"的**交流标识**
-* （"不设定就还是用编码"⇒ 设定之后，用 UID 指认就该与编码同等可靠）。
-* 它与目录名都属**精确匹配**、彼此不会混淆（UID 形态不含 `--`，目录名必含）⇒ 顺序对结果无实质影响，
-* 但把这个顺序写死，避免后来者以为"UID 是模糊匹配的一种"。
+* 🔵 `S31` → `S031` 的**数字补零**兼容保留（存量用户习惯）；它现在只是编码匹配的一个特例：
+* 编码恰为 `S###` 形态时允许省前导零。
 */
 function findSession(sessionsDir, key) {
 	const all = readAllSessions(sessionsDir);
 	const byName = all.find((s) => s.dirName === key);
 	if (byName) return byName;
+	const byCode = all.find((s) => parseTrajectoryCode(s.dirName) === key);
+	if (byCode) return byCode;
+	const padded = key.match(/^S(\d{1,})$/);
+	if (padded) {
+		const want = `S${padded[1].padStart(3, "0")}`;
+		const byPadded = all.find((s) => parseTrajectoryCode(s.dirName) === want);
+		if (byPadded) return byPadded;
+	}
 	const byUid = all.find((s) => readTrajectoryUid(s.path) === key);
 	if (byUid) return byUid;
-	const searchId = key.replace(/^S/, "").padStart(3, "0");
-	const byId = all.find((s) => {
-		const m = s.dirName.match(/--S(\d{3,})--/);
-		return m && m[1] === searchId;
-	});
-	if (byId) return byId;
 	const lower = key.toLowerCase();
 	const fuzzy = all.filter((s) => s.dirName.toLowerCase().includes(lower));
 	if (fuzzy.length === 1) return fuzzy[0] ?? null;
@@ -380,6 +403,12 @@ function createSession(opts) {
 	const datePrefix = localDate(now);
 	if (!desc && !issue) throw new Error("create requires either --desc or --issue");
 	if (desc && issue) throw new Error("--desc and --issue are mutually exclusive");
+	const requestedId = opts.id?.trim();
+	if (requestedId !== void 0 && requestedId !== "") {
+		if (!isValidTrajectoryCode(requestedId)) throw new Error(`Invalid trajectory code: "${requestedId}". 允许 [A-Za-z0-9._-]、首字符须字母或数字、长度 ≤64，且**不得含中文与 "--"**（"--" 是目录名分隔符，含它就把"固定位置编码"这个前提破坏掉）`);
+		const clash = readAllSessions(sessionsDir).find((s) => parseTrajectoryCode(s.dirName) === requestedId);
+		if (clash) throw new Error(`Trajectory code "${requestedId}" is already in use by ${clash.dirName}. Codes are the trajectory's unique identity — pick another, or operate on the existing one by that code.`);
+	}
 	if (issue) {
 		if (issue.length > 100) throw new Error(`issue too long: ${issue.length} chars (max 100)`);
 		const dirName = `${datePrefix}--${sanitizeDirName(issue)}`;
@@ -403,31 +432,35 @@ function createSession(opts) {
 	if (!desc || desc.length === 0) throw new Error("description cannot be empty");
 	if (desc.length > 200) throw new Error(`description too long: ${desc.length} chars (max 200)`);
 	const sessions = readAllSessions(sessionsDir);
-	let maxId = 0;
-	for (const s of sessions) {
-		const m = s.dirName.match(/--S(\d{3,})--/);
-		if (m) {
-			const num = parseInt(m[1], 10);
-			if (num > maxId) maxId = num;
+	let code;
+	if (requestedId !== void 0 && requestedId !== "") code = requestedId;
+	else {
+		let maxId = 0;
+		for (const s of sessions) {
+			const m = parseTrajectoryCode(s.dirName)?.match(/^S(\d{3,})$/);
+			if (m) {
+				const num = parseInt(m[1], 10);
+				if (num > maxId) maxId = num;
+			}
 		}
+		code = `S${String(maxId + 1).padStart(3, "0")}`;
 	}
-	const nextId = String(maxId + 1).padStart(3, "0");
-	const dirName = `${datePrefix}--S${nextId}--${sanitizeDirName(desc)}`;
+	const dirName = `${datePrefix}--${code}--${sanitizeDirName(desc)}`;
 	const sessionPath = join(sessionsDir, dirName);
 	if (!dryRun && existsSync(sessionPath)) throw new Error(`Session directory already exists: "${dirName}"`);
 	if (dryRun) return {
-		message: `[dry-run] Would create: ${dirName}/\n  goal=${goal ?? "(none)"}`,
+		message: `[dry-run] Would create: ${dirName}/\n  code=${code}\n  goal=${goal ?? "(none)"}`,
 		dirName,
 		sessionPath,
-		sessionId: `S${nextId}`
+		sessionId: code
 	};
 	mkdirSync(sessionPath, { recursive: true });
-	writeFileSync(join(sessionPath, SESSION_MD), sessionMdTemplate(desc, `S${nextId}`, goal, now), "utf-8");
+	writeFileSync(join(sessionPath, SESSION_MD), sessionMdTemplate(desc, code, goal, now), "utf-8");
 	return {
-		message: `Created: ${dirName}/ (S${nextId})`,
+		message: `Created: ${dirName}/ (${code})`,
 		dirName,
 		sessionPath,
-		sessionId: `S${nextId}`
+		sessionId: code
 	};
 }
 /**
@@ -564,9 +597,8 @@ function parseSessionContextFromEvents(events) {
 				filePath = join(md, SESSION_MD);
 			} else continue;
 			if (!isSessionDirName(dirName)) continue;
-			const idMatch = dirName.match(/--S(\d{3,})--/);
 			return {
-				sessionId: idMatch ? `S${idMatch[1]}` : dirName,
+				sessionId: parseTrajectoryCode(dirName) ?? dirName,
 				dirName,
 				mdPath: filePath
 			};
@@ -718,432 +750,214 @@ function archiveSession(root, key, dryRun = false) {
 	};
 }
 //#endregion
-//#region src/cognitive-trajectory-bound.ts
-/**
-* cognitive-trajectory-bound.ts — SESSION 绑定持久化（CCC 内 `AGENT_SESSIONS/.bindings.json`）
-*
-* 目标（S142 用户拍板，方案 v1.0）：让「dsh 会话（载体）↔ SESSION（宁静号轨迹）」
-* 的绑定坚固——LLM 不能因智力因素（幻觉/理解偏差）在过程中或 cognitive_trajectory rebuild 后
-* 自行更换 SESSION。
-*
-* 存储形态（v1.30.6 起，S142 review F-01）：绑定**不再写入 dsh 会话日志**。
-* 原因（宿主契约实证）：dsp 的自定义事件 `serenity/bound` 既不在宿主的
-* `KNOWN_SESSION_EVENT_TYPES`（生成静态集，明确说明 out-of-repo 插件事件不在其中），
-* 而 `Session.append` 构造事件时只写 `{type,seq,time,data,surfaceOp?,sourceEventSeqs?}`
-* ——**没有写入 envelope `ignorable` 标记的通道**；宿主的 `assertEventsSupported`
-* （session-persistence/coordinator.ts:1248-1252，调用点含恢复/HMR 路径）会拒绝任何
-* "未知且非 ignorable" 的事件 → 含该事件的会话在冷加载时可能抛
-* `SessionFormatUnsupportedError`。v1.29.1~v1.30.5 的设计文档虽写明要带
-* `ignorable: true`（docs/session-binding-hardening-research.md:53），但类型层声明
-* 不等于持久层标记，实际从未落盘。
-*
-* 现形态：每 CCC 一个 JSON 文件 `AGENT_SESSIONS/.bindings.json`（原子写：tmp + rename），
-* 以 dsh 会话 id 为键，latest-wins 覆盖。**向后兼容**：读取时若文件中无该会话记录，
-* 仍回落到扫描会话日志中的旧 `serenity/bound` 事件（老会话的绑定不丢）。
-*
-* 编码无关（U4）：绑定锚 = **完整 AGENT_SESSIONS 目录名**（磁盘唯一存在），
-* sessionId（S###/apaas-xxx/自定义）仅是派生展示字段——绝不假设 S 前缀。
-*/
-/** 旧形态事件类型（v1.29.1~v1.30.5 写入会话日志；v1.30.6 起只读不写——兼容存量绑定） */
-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;
+//#region src/role/skiff/registry.ts
+const skiffSessions = /* @__PURE__ */ new Map();
+/** 登记/更新一个会话 → 轨迹的映射 */
+function registerSkiffSession(sessionId, trajectoryDirName, ccc) {
+	skiffSessions.set(sessionId, {
+		trajectoryDirName,
+		ccc
+	});
 }
-/** 域记录 → 本模块记录形状（同名字段，无需映射表；见 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 unregisterSkiffSession(sessionId) {
+	skiffSessions.delete(sessionId);
 }
-/** 本模块记录 → 域记录形状 */
-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 } : {}
-	};
+/** 查会话承载的轨迹目录名（无 → null）；`guards`/`system-prompt` 的同步热路径用 */
+function skiffTrajectoryDirNameFor(sessionId) {
+	const b = skiffSessions.get(sessionId);
+	return b === void 0 || b.trajectoryDirName === "" ? null : b.trajectoryDirName;
 }
-/**
-* §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;
+/** 查会话的完整绑定（轨迹 + CCC；无 → null）——追问延续时校验 (轨迹, CCC) 未串味 */
+function skiffSessionInfo(sessionId) {
+	return skiffSessions.get(sessionId) ?? null;
+}
+//#endregion
+//#region src/role/skiff/profile.ts
+/**
+* role/skiff/profile.ts — **skiff 的唯一判据**：目录下有 `skiff.json` 的认知轨迹（零 DSH 依赖，可独立单测）
+*
+* ## 🔴 owner 2026-10-19 重做令（逐字，本文件存在的全部理由）
+*
+* > 「skiff 复杂的约束和提示词体系都干掉，改为这样的实现：
+* > **skiff 本身是认知轨迹的一个特殊情况，即目录下拥有 `skiff.json` 的认知轨迹自动是一个 skiff**
+* > （json 里配置上个版本就有的各种约束），**会话跑在认知轨迹上且发现 `skiff.json`，则运行时实现各类约束**」
+*
+* ## 旧模型 → 新模型（**一条判据取代四条**）
+*
+* | 项 | 旧 | 新 |
+* |---|---|---|
+* | skiff 是什么 | `serenity.json` 的 `skiff.roles.<name>` 一条配置 | **轨迹目录里有 `skiff.json`** |
+* | 怎么认出 skiff 会话 | dsh sessionId 前缀 `skiff-` | **它绑定的轨迹有 `skiff.json`** |
+* | 工作台从哪来 | `ensureSkiffSession` 另建一个 SESSION | **就是该轨迹自己的 SESSION.md** |
+* | 身份 | 角色名 | **轨迹编码**（`trajectory/core.ts` 的 `parseTrajectoryCode`） |
+*
+* ⇒ 收益（owner：「理解难度大幅下降」的实际内容）：四个各自会漂的机制收敛为**一条文件存在性判据**。
+* 删掉 `skiff.json` ⇒ 该轨迹**当场**退化为普通轨迹（工具面、提示词、keeper 全部恢复默认）。
+*
+* ## 归属（D23）
+* **机制在 ACC**（文件叫什么、怎么读、怎么判、缺省值、如何施加约束）；
+* **内容在 CCC**（`skiff.json` 里填什么：模型、白名单、提示词路径）。
+* ⇒ ACC 代码里**不出现任何具体角色名**，也不读 `serenity.json` 的 skiff 段（该段已退役）。
+*/
+var profile_exports = /* @__PURE__ */ __exportAll({
+	SKIFF_PROFILE_FILENAME: () => SKIFF_PROFILE_FILENAME,
+	findDirNameByCode: () => findDirNameByCode,
+	isSkiffSession: () => isSkiffSession,
+	listSkiffProfiles: () => listSkiffProfiles,
+	readSkiffProfileAt: () => readSkiffProfileAt,
+	readSkiffProfileByCode: () => readSkiffProfileByCode,
+	skiffProfileForSession: () => skiffProfileForSession
+});
+/** `skiff.json` 的固定文件名（**判据就是它存在**——不是目录名前缀，也不是配置里的一行） */
+const SKIFF_PROFILE_FILENAME = "skiff.json";
+/**
+* 已告警过的坏 `skiff.json`（进程级去重：同一坏文件不刷屏，但**绝不静默**）。
+*
+* 🔴 为什么必须响亮（同源先例 = `loadSerenityConfig` 的 F-07）：一份坏 JSON 会让
+* **工具白名单静默失效**——而白名单正是 skiff 的权限边界 ⇒ 静默 = 权限面悄悄放开或收死，
+* 两种都查不到原因。
+*/
+const warnedBrokenProfiles = /* @__PURE__ */ new Set();
+/** 活跃轨迹目录名（跳过 `_`/`.` 前缀 —— 归档区与日志区不是轨迹；判据同 `readAllSessions`） */
+function activeTrajectoryDirNames(root) {
 	try {
-		file = readBindingsFile(join(root, BINDINGS_REL_PATH));
+		return readdirSync(sessionsRoot(root), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
 	} 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 [];
 	}
-	if (out.migrated > 0) migratedRoots.add(root);
-	return out;
 }
-/** 已补过迁移的 CCC 根（进程内去重；跨进程各补一次是可接受的——迁移幂等） */
-const migratedRoots = /* @__PURE__ */ new Set();
 /**
-* **按 CCC 惰性补迁移**（§0L 修正，S142 2026-09-19）。
-*
-* 🔴 为什么需要它（实测缺陷，R↓）：
-* 装载期那次迁移用的是 `process.cwd()` —— 而 dsh **服务进程的 cwd 是用户家目录**，
-* **不是 CCC 根**（实测 `acc-diag`：`进程 cwd: <家目录> ｜ 进程 CCC: （无）`）。
-* ⇒ 迁移读的是一个**不存在的文件**，静默迁移 0 条
-* （症状：发布后 `~/.dsh/storages/serenity_bindings.json` **没出现**）。
+* 读一个目录下的 `skiff.json`（**纯读，不施加约束**）。
 *
-* 现在改为：**任何一次能定位到 CCC 根的路径**都顺手补一次迁移（幂等 + 进程内去重）。
-* 这样无论服务从哪个 cwd 启动，只要那条 CCC 有会话活动，它的绑定就会被带上。
+* @param trajectoryDir 轨迹目录绝对路径
+* @param root CCC 根（仅用于 `systemPromptFile` 的逃逸拒绝）
+* @returns 归一后的约束面；**无该文件 → `null`（= 这不是 skiff，常态，不是错误）**
 *
-* @param root CCC 根
+* ⚠️ **形态容错**：数组元素非字符串 → 丢弃该项（不整份作废）；`cognitiveTrajectory`
+* 缺项 → 各自取 **true**（见 R↓）；`model` 空白 → undefined（回退缺省）。
+* 坏 JSON ⇒ 告警 + `null`（**按"不是 skiff"处理**：宁可让它退回普通轨迹，也不要带着
+* 半份读不懂的权限面运行）。
 */
-function ensureBindingsMigrated(root) {
-	if (!domainStore?.available) return;
-	if (migratedRoots.has(root)) return;
+function readSkiffProfileAt(trajectoryDir, root) {
+	const dirName = trajectoryDir.split("/").filter(Boolean).pop() ?? "";
+	const code = parseTrajectoryCode(dirName);
+	if (code === null) return null;
+	const file = join(trajectoryDir, SKIFF_PROFILE_FILENAME);
+	if (!existsSync(file)) return null;
+	let raw;
 	try {
-		migrateBindingsToDomain(root);
-	} catch {}
-}
-/**
-* 域内读一条（同步）。域不可用 → `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;
-	return header;
-}
-/** 绑定文件绝对路径（由会话 cwd 上溯 .serenity 定位 CCC 根）；无法定位返回 null */
-function bindingsPathFor(session) {
-	const header = sessionHeader(session);
-	if (typeof header?.cwd !== "string") return null;
-	const root = cccRootForCwd(header.cwd);
-	if (!root) return null;
-	ensureBindingsMigrated(root);
-	return join(root, BINDINGS_REL_PATH);
-}
-function readBindingsFile(path) {
-	if (!existsSync(path)) return {
-		version: BINDINGS_VERSION,
-		sessions: {}
-	};
-	try {
-		const sessions = JSON.parse(readFileSync(path, "utf-8")).sessions;
-		if (!sessions || typeof sessions !== "object") return {
-			version: BINDINGS_VERSION,
-			sessions: {}
-		};
-		return {
-			version: BINDINGS_VERSION,
-			sessions
-		};
-	} catch {
-		return {
-			version: BINDINGS_VERSION,
-			sessions: {}
-		};
-	}
-}
-/** 原子写：同目录 tmp + rename（避免半写文件被后续读取） */
-function writeBindingsFile(path, data) {
-	mkdirSync(dirname(path), { recursive: true });
-	const tmp = `${path}.tmp`;
-	writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
-	renameSync(tmp, path);
-}
-/** 记录形状校验（容忍手改/旧数据） */
-function asBoundRecord(value) {
-	const r = value;
-	if (!r || typeof r.dirName !== "string" || typeof r.mdPath !== "string") return null;
-	return r;
-}
-/** 旧形态：从会话日志扫最后一条 `serenity/bound`（兼容 v1.30.5 及更早写入的绑定） */
-function readLegacyBoundFromEvents(session) {
-	const events = sessionEvents(session);
-	for (let i = events.length - 1; i >= 0; i--) {
-		const ev = events[i];
-		if (!ev || ev.type !== SESSION_BOUND_EVENT) continue;
-		const rec = asBoundRecord(ev.data);
-		if (rec) return rec;
+		raw = JSON.parse(readUtf8(file));
+	} catch (err) {
+		if (!warnedBrokenProfiles.has(file)) {
+			warnedBrokenProfiles.add(file);
+			console.warn(`[serenity-hooks] ✗ ${SKIFF_PROFILE_FILENAME} 解析失败 ⇒ 该轨迹**按普通轨迹处理**（工具白名单与提示词约束全部不施加）。请修 JSON: ${file} — ${String(err?.message ?? err)}`);
+		}
+		return null;
 	}
-	return null;
-}
-/**
-* 读取会话当前绑定（权威，latest-wins）。
-*
-* 读取顺序（§0L，S142 2026-09-19）：
-*  1. **宿主存储域**（域可用时的权威来源）；
-*  2. **旧文件** `.bindings.json`（域不可用 ⇒ 零回归回落；域可用但该会话未迁移 ⇒ 兜底）；
-*  3. **旧事件形态** `serenity/bound`（v1.30.5 及更早的存量）。
-* 无绑定返回 null。
-*/
-function readLastBound(session) {
-	const id = sessionHeader(session)?.id;
-	if (typeof id === "string") {
-		const fromDomain = readFromDomain(id);
-		if (fromDomain) return fromDomain;
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+		if (!warnedBrokenProfiles.has(file)) {
+			warnedBrokenProfiles.add(file);
+			console.warn(`[serenity-hooks] ✗ ${SKIFF_PROFILE_FILENAME} 顶层不是对象 ⇒ 按普通轨迹处理: ${file}`);
+		}
+		return null;
 	}
-	const path = bindingsPathFor(session);
-	if (path && typeof id === "string") {
-		const rec = asBoundRecord(readBindingsFile(path).sessions[id]);
-		if (rec) return rec;
+	const obj = raw;
+	const strList = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.trim() !== "").map((x) => x.trim()) : [];
+	/** 布尔缺省 **true**（R↓ 见接口：工作台就是这条轨迹自己的身体） */
+	const boolOrTrue = (v) => typeof v === "boolean" ? v : true;
+	const ct = obj.cognitiveTrajectory && typeof obj.cognitiveTrajectory === "object" ? obj.cognitiveTrajectory : {};
+	const model = typeof obj.model === "string" && obj.model.trim() !== "" ? obj.model.trim() : void 0;
+	const systemPrompt = typeof obj.systemPrompt === "string" ? obj.systemPrompt : void 0;
+	const rawFile = typeof obj.systemPromptFile === "string" ? obj.systemPromptFile.trim() : "";
+	let systemPromptFile;
+	if (rawFile !== "") try {
+		resolveInside(root, rawFile);
+		systemPromptFile = rawFile;
+	} catch (err) {
+		console.warn(`[serenity-hooks] ✗ ${SKIFF_PROFILE_FILENAME} 的 systemPromptFile 越界，已忽略（其余约束仍生效）: ${file} — ${String(err?.message ?? err)}`);
 	}
-	return readLegacyBoundFromEvents(session);
-}
-/** 目录名 → 轨迹标签（`--S###--` 命中取 `S###`；未命中原样返回——编码无关 U4） */
-function cognitiveTrajectoryLabel(dirName) {
-	const m = dirName.match(/--S(\d{3,})--/);
-	return m ? `S${m[1]}` : dirName;
+	return {
+		dirName,
+		code,
+		path: file,
+		...model !== void 0 ? { model } : {},
+		tools: strList(obj.tools),
+		msms: strList(obj.msms),
+		cognitiveTrajectory: {
+			session: boolOrTrue(ct.session),
+			keeper: boolOrTrue(ct.keeper),
+			rebuild: boolOrTrue(ct.rebuild)
+		},
+		...systemPrompt !== void 0 ? { systemPrompt } : {},
+		...systemPromptFile !== void 0 ? { systemPromptFile } : {}
+	};
 }
 /**
-* **调用方自身**所属 cognitive trajectory 的标签（审计字段 `createdBy` 的唯一正解）。
-*
-* 三级来源，逐级回退（R↓：为什么不用单一来源）：
-*  1. `readLastBound(session)` —— **持久 bound**，权威（重启存活、不受别的会话激活污染）
-*  2. `getActiveSessionInfo(scope)` —— 本 dsh 会话的**内存**激活（按 scope 隔离）
-*  3. `getLastActiveSessionInfo()` —— **全局**最近激活指针（无绑定的会话兼容回退）
-*
-* ⚠️ 为何单列成本函数（S142 §30.12.1 实测缺陷）：唤醒注册表的 `createdBy` 原先直接取第 3 级
-* 全局指针，而它记录的是"**进程内最近一次被激活的 cognitive trajectory**"——多会话并发时必然张冠李戴
-* （实测：S142 登记唤醒被写成 `by=S060`）。`createdBy` 是 D60「以可审计替代入口栅」的**唯一凭证**，
-* 失真即替代控制失效 ⇒ 必须以"调用方自己是谁"为准，全局指针只作最后兜底。
+* 按**轨迹编码**解析 skiff 约束面（`list`/`admin`/调试页/路由解析用）。
 *
-* @param session 调用方 dsh 会话对象（需 `header.id` + `header.cwd`）
-* @param scope 调用方 dsh 会话 id（取不到传空串）
-* @returns 轨迹标签（`S###` 或完整目录名）；三级全落空 → 空串（渲染为 `?`）
+* @returns 约束面；轨迹不存在 ／ 无 `skiff.json` → `null`
 */
-function resolveSessionCognitiveTrajectoryLabel(session, scope) {
-	const bound = session ? readLastBound(session) : null;
-	if (bound?.dirName) return cognitiveTrajectoryLabel(bound.dirName);
-	const scoped = scope !== "" ? getActiveSessionInfo(scope) : null;
-	if (scoped) return scoped.sessionId;
-	return getLastActiveSessionInfo()?.sessionId ?? "";
+function readSkiffProfileByCode(root, code) {
+	const dirName = findDirNameByCode(root, code);
+	if (dirName === null) return null;
+	return readSkiffProfileAt(join(sessionsRoot(root), dirName), root);
 }
-/**
-* 反向查：绑定到某 cognitive trajectory 目录名的 dsh 会话 id（**按绑定时间倒序，最新在前**）。
-*
-* 用途（wake-scheduler 冷唤醒）：.bindings.json 以 **sessionId 为键**，而唤醒条目的
-* target 是**目录名**——需要值侧扫描做反向索引。冷会话被唤醒时必须先知道"哪个 dsh
-* 会话承载这条轨迹"，这是唯一的权威来源（标题只作回退，见 v1.29.2 R2）。
-*
-* @param root CCC 根
-* @param dirName AGENT_SESSIONS 目录名（完整名，如 `2026-09-01--S151--x--auto`）
-* @returns 会话 id 列表（最新绑定在前）；无绑定 → `[]`
-*/
-function listBoundSessionIds(root, dirName) {
-	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
-		});
+/** 扫全部活跃轨迹，返回全部 skiff。**顺序按目录名**（确定性，便于对读）。 */
+function listSkiffProfiles(root) {
+	const out = [];
+	for (const name of activeTrajectoryDirNames(root)) {
+		const p = readSkiffProfileAt(join(sessionsRoot(root), name), root);
+		if (p) out.push(p);
 	}
-	return hits.sort((a, b) => b.at - a.at).map((h) => h.id);
+	return out;
 }
 /**
-* 🔴 **「只留一条」的唯一判据**（2026-09-21 收进单一实现；此前同一判据在域侧/文件侧各写一遍）。
+* 编码 → 轨迹目录名（活跃轨迹内）。找不到 → `null`。
 *
-* 判据：同 `dirName` ∧ **不是** `keepIds` 里的 ∧ **尚未** `supersededAt`。
-* 域侧与文件侧**同判据**——历史缺陷（2026-09-19）正是"只在一侧收集 ⇒ 返回值恒空"，
-* 见 {@link supersedeOtherBindings} 的注释。
-*
-* @param fileSessions 旧文件表的记录集
-* @param domainEntries 域侧条目（域不可用时传 `undefined` = 不参与判定）
+* ⚠️ 与 `findSession` 的分工：这里**只按编码精确**匹配（不做模糊），
+* 因为它的调用方（路由 / 约束施加）要的是**确定性**，模糊匹配会把"手抖打错的名字"
+* 静默投到一条相近的轨迹上——那正是最难查的一类串味。
 */
-function collectSupersedeTargets(dirName, keepIds, fileSessions, domainEntries) {
-	const toMark = /* @__PURE__ */ new Set();
-	if (domainEntries) for (const [id, raw] of domainEntries) {
-		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(fileSessions)) {
-		const rec = asBoundRecord(raw);
-		if (!rec || rec.dirName !== dirName) continue;
-		if (keepIds.has(id) || rec.supersededAt !== void 0) continue;
-		toMark.add(id);
-	}
-	return toMark;
+function findDirNameByCode(root, code) {
+	for (const name of activeTrajectoryDirNames(root)) if (parseTrajectoryCode(name) === code) return name;
+	return null;
 }
 /**
-* **(c) 绑定一致性兜底**（S142 §0y，所有者 2026-09-18 裁「c 也算个兜底」）：
-* 删除指向**已不存在**的 dsh 会话的绑定记录。
+* **会话级**判据（J2）：这个 dsh 会话是不是 skiff 会话 —— 唯一入口。
 *
-* 为什么需要：`.bindings.json` **只增不清**，而 DSH 会话目录会被
-* `session-cleanup`（本仓既有机制）物理删除 ⇒ 表里必然残留**悬空 id**。
-* 悬空记录本身无害，但它会**污染反向索引**（`listBoundSessionIds` 是唤醒选人的唯一入口），
-* 让"这条轨迹到底还有没有可用会话"变得不可判。
+* 判据 = **它绑定的轨迹有 `skiff.json`**（不是 sessionId 前缀，也不是配置里有没有角色）。
 *
-* 🔴 **安全性由调用方的判据负责**（本函数是纯函数，不认识文件系统）：
-* `isMissing` 必须是 **fail-closed** 的（读不到 ⇒ 返回 false = "不当作缺失"），
-* 见 `hasSessionLogById`。判据写错会**清掉整张表**，故此处刻意不提供默认实现。
+* ## 为什么"绑定的轨迹"从两个来源取（R↓，一个失败模式）
+* ① **持久绑定**（`readLastBound`，宿主存储域/`.bindings.json`）—— 权威，跨重启成立；
+* ② **内存注册表**（`skiff/registry`）—— 覆盖绑定的**窗口期**（轨迹刚定、bound 还没落盘）。
+* ⇒ 只取 ① 会在建会话的第一轮判成"不是 skiff"（工具面不收窄，模型看见不该有的工具）；
+*    只取 ② 会在进程重启后全判成"不是"（skiff 失去约束，**权限面静默放开**）。
+* ⇒ **两来源并取**，都不中才 `null`。
 *
 * @param root CCC 根
-* @param isMissing 判据：该会话 id 是否**确认**已不存在（false = 保留）
-* @returns 被删除的会话 id（升序稳定；未删任何一条 → `[]`）
+* @param sessionId dsh 会话 id
+* @param boundDirName 调用方已解析的绑定目录名（可选；给了就省一次读绑定）
+* @returns 约束面；不是 skiff 会话 → `null`
 */
-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();
+function skiffProfileForSession(root, sessionId, boundDirName) {
+	const dirName = boundDirName ?? registeredDirName(sessionId);
+	if (dirName === null || dirName === "") return null;
+	return readSkiffProfileAt(join(sessionsRoot(root), dirName), root);
+}
+/** 内存登记的轨迹目录名（注册表单一真相源在 `./registry.ts`；此处只做一次转发） */
+function registeredDirName(sessionId) {
+	if (typeof sessionId !== "string" || sessionId === "") return null;
+	return skiffTrajectoryDirNameFor(sessionId);
 }
 /**
-* 写入绑定（latest-wins 覆盖该会话记录）。
-*
-* 绑定持久化尽力而为：无法定位 CCC 根 / 无会话 id / 写盘失败 → 返回 false，不阻断主流程。
+* 该 dsh 会话**是不是** skiff 会话（布尔形态的 `skiffProfileForSession`）。
 *
-* 🔴 **同时是「只留一条」（D69）的唯一写入口**（2026-09-21 起）：每写一条，就在**同一次 RMW** 里
-* 把同轨迹的**其它**条标 `supersededAt`（自己除外）。⇒ 任何调用路径（`create`/`activate`/`switch`/
-* `rebuild`/`reconcile`）**都自动满足"只留一条"**，调用方**不需要**（也**不应当**）自己算 selfId。
-*
-* @param session 目标 dsh 会话（需 `header.id` + `header.cwd` 可定位 CCC 根）
-* @param action 绑定动作
-* @param rec 绑定记录（dirName + mdPath 必填；sessionId 可选展示码）
+* 存在的理由：调用点很多只要一个"是/不是"（seams 的旁路判定），
+* 让它们各自写 `!== null` 会把判据散开；**判据只能有一个入口**。
 */
-function appendBound(session, action, rec) {
-	const path = bindingsPathFor(session);
-	const id = sessionHeader(session)?.id;
-	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] = record;
-		const targets = collectSupersedeTargets(rec.dirName, /* @__PURE__ */ new Set([id]), file.sessions, domainStore?.available ? domainStore.entries() : void 0);
-		for (const other of targets) {
-			const otherRec = asBoundRecord(file.sessions[other]);
-			if (!otherRec) continue;
-			otherRec.supersededAt = record.at;
-			file.sessions[other] = otherRec;
-		}
-		writeBindingsFile(path, file);
-		if (domainStore?.available) for (const other of targets) {
-			const raw = domainStore.get(other);
-			if (!raw) continue;
-			domainStore.put(other, toDomainRecord({
-				...fromDomainRecord(raw),
-				supersededAt: record.at
-			})).catch(() => {});
-		}
-		return true;
-	} catch {
-		return domainStore?.available === true;
-	}
+function isSkiffSession(root, sessionId) {
+	return skiffProfileForSession(root, sessionId) !== null;
 }
 //#endregion
-//#region src/message-source.ts
-/** ACC 注入消息的 kind —— 唤醒 / 打回 / keeper 提醒 / 锚定轮 / rebuild 交接等一律同值。 */
-const ACC_MESSAGE_KIND = "plugin:dsh-serenity-hooks";
-/** ACC 注入消息的统一来源值（各缝共用；需要 `form` 时按 `ContextFormed` 另加字段）。 */
-const PLUGIN_SOURCE = { kind: ACC_MESSAGE_KIND };
-//#endregion
-export { summarize as A, readTrajectoryUid as C, setActiveSessionInfo as D, sessionsRoot as E, localIdStamp as F, isoLocal as M, localFileStamp as N, setTrajectoryUid as O, localHuman as P, readActiveSessionMd as S, sessionEvents as T, getActiveSessionInfo as _, pruneMissingBindings as a, namingTitleFor as b, setBindingStore as c, UID_FILENAME as d, archiveSession as f, findSession as g, extractSessionMdPathFromText as h, listBoundSessionIds as i, useSession as j, showSession as k, COGNITIVE_TRAJECTORY_ACTIONS as l, createSession as m, PLUGIN_SOURCE as n, readLastBound as o, clearActiveSessionInfo as p, appendBound as r, resolveSessionCognitiveTrajectoryLabel as s, ACC_MESSAGE_KIND as t, DEFAULT_SESSION_SCOPE as u, listActiveTrajectories as v, resolveSessionByTitle as w, parseSessionContextFromEvents as x, listSessions as y };
+export { sessionEvents as A, listSessions as C, readActiveSessionMd as D, parseTrajectoryCode as E, useSession as F, isoLocal as I, localFileStamp as L, setActiveSessionInfo as M, showSession as N, readTrajectoryUid as O, summarize as P, localHuman as R, listActiveTrajectories as S, parseSessionContextFromEvents as T, createSession as _, readSkiffProfileAt as a, getActiveSessionInfo as b, registerSkiffSession as c, unregisterSkiffSession as d, COGNITIVE_TRAJECTORY_ACTIONS as f, clearActiveSessionInfo as g, archiveSession as h, profile_exports as i, sessionsRoot as j, resolveSessionByTitle as k, skiffSessionInfo as l, UID_FILENAME as m, isSkiffSession as n, readSkiffProfileByCode as o, DEFAULT_SESSION_SCOPE as p, listSkiffProfiles as r, skiffProfileForSession as s, SKIFF_PROFILE_FILENAME as t, skiffTrajectoryDirNameFor as u, extractSessionMdPathFromText as v, namingTitleFor as w, getLastActiveSessionInfo as x, findSession as y, localIdStamp as z };