@shgroup/dsh-serenity-hooks 1.104.0 → 1.107.0

package/lib/profile-BjBn_-be.js

@@ -0,0 +1,336 @@
+import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
+import { g as resolveInside, h as readUtf8 } from "./ccc-BmpE3cQz.js";
+import { N as findTrajectoryFile, T as sessionsRoot, b as parseTrajectoryCode, i as listBindDeclarations, j as TRAJECTORY_FILENAME } from "./bind-file-B0TuOP89.js";
+import { join } from "node:path";
+import { readdirSync } from "node:fs";
+//#region src/trajectory/policy/window.ts
+/** sessionId → 绑定的轨迹（**进程内**；跨重启的权威来源是 `trajectory/bound.ts` 的持久绑定） */
+const trajectorySessions = /* @__PURE__ */ new Map();
+/** 登记/更新一个会话 → 轨迹的映射 */
+function registerTrajectorySession(sessionId, trajectoryDirName, ccc) {
+	trajectorySessions.set(sessionId, {
+		trajectoryDirName,
+		ccc
+	});
+}
+/** 解绑（会话销毁 / 轨迹失效 ⇒ 换身份） */
+function unregisterTrajectorySession(sessionId) {
+	trajectorySessions.delete(sessionId);
+}
+/** 查会话承载的轨迹目录名（无 → null）；`guards`/`system-prompt` 的同步热路径用 */
+function trajectoryDirNameForSession(sessionId) {
+	const b = trajectorySessions.get(sessionId);
+	return b === void 0 || b.trajectoryDirName === "" ? null : b.trajectoryDirName;
+}
+//#endregion
+//#region src/trajectory/policy/profile.ts
+/**
+* trajectory/policy/profile.ts — **轨迹约束的唯一判据**：目录下有 `trajectory-constraint.json` 的认知轨迹（零 DSH 依赖，可独立单测）
+*
+* ## 🔴 owner 2026-10-19 重做令（逐字，本文件存在的全部理由）
+*
+* > 「轨迹约束 复杂的约束和提示词体系都干掉，改为这样的实现：
+* > **轨迹约束本身是认知轨迹的一个特殊情况，即目录下拥有 `trajectory-constraint.json` 的认知轨迹自动是一个 轨迹约束**
+* > （json 里配置上个版本就有的各种约束），**会话跑在认知轨迹上且发现 `trajectory-constraint.json`，则运行时实现各类约束**」
+*
+* ## 旧模型 → 新模型（**一条判据取代四条**）
+*
+* | 项 | 旧 | 新 |
+* |---|---|---|
+* | 轨迹约束是什么 | `serenity.json` 的 `轨迹约束.roles.<name>` 一条配置 | **轨迹目录里有 `trajectory-constraint.json`** |
+* | 怎么认出 轨迹约束会话 | dsh sessionId 前缀 `轨迹约束-` | **它绑定的轨迹有 `trajectory-constraint.json`** |
+* | 工作台从哪来 | `ensureTrajectorySession` 另建一个 SESSION | **就是该轨迹自己的 SESSION.md** |
+* | 身份 | 角色名 | **轨迹编码**（`trajectory/core.ts` 的 `parseTrajectoryCode`） |
+*
+* ⇒ 收益（owner：「理解难度大幅下降」的实际内容）：四个各自会漂的机制收敛为**一条文件存在性判据**。
+* 删掉 `trajectory-constraint.json` ⇒ 该轨迹**当场**退化为普通轨迹（工具面、提示词、keeper 全部恢复默认）。
+*
+* ## 归属（D23）
+* **机制在 ACC**（文件叫什么、怎么读、怎么判、缺省值、如何施加约束）；
+* **内容在 CCC**（`trajectory-constraint.json` 里填什么：模型、白名单、提示词路径）。
+* ⇒ ACC 代码里**不出现任何具体角色名**，也不读 `serenity.json` 的 轨迹约束段（该段已退役）。
+*
+* ## S12（2026-10-19，轨迹中心重构）：此前位于 `role/轨迹约束/` 下（该目录已随本重构消失）
+*
+* 落点 = `trajectory/policy/`。判据（判读表 §3.1）：本文件判的是**某条轨迹的约束面**，
+* 主语是轨迹 ⇒ 它一直就是轨迹切面，只是旧目录把它挂在"角色"这个**平行概念**下。
+* ⚠️ **文件名 `profile` 与 `trajectory-constraint.json` / `TrajectoryConstraint` 等符号名一律不动**：
+* 那是有具体指称的东西（一个固定文件名 ＋ 它的解析结果），不是组织单位。
+*/
+var profile_exports = /* @__PURE__ */ __exportAll({
+	TRAJECTORY_CONSTRAINT_FILENAME: () => TRAJECTORY_CONSTRAINT_FILENAME,
+	findDirNameByCode: () => findDirNameByCode,
+	isTrajectoryConstrained: () => isTrajectoryConstrained,
+	listTrajectoryConstraints: () => listTrajectoryConstraints,
+	readTrajectoryConstraintAt: () => readTrajectoryConstraintAt,
+	readTrajectoryConstraintByCode: () => readTrajectoryConstraintByCode,
+	replacesDefaultIdentity: () => replacesDefaultIdentity,
+	trajectoryCodeForSession: () => trajectoryCodeForSession,
+	trajectoryConstraintForSession: () => trajectoryConstraintForSession
+});
+/**
+* 🆕 **声明文件的文件名**（2026-10-19 owner 裁 Q2：短名 `trajectory.json`）。
+*
+* ⚠️ **判据不是"这个名字在不在"**，而是**族内任一存在**（`TRAJECTORY_FILENAME_FAMILY`）。
+* 这个名字只是**写入目标**与**提示文案里该印的那个**。
+*/
+const TRAJECTORY_CONSTRAINT_FILENAME = TRAJECTORY_FILENAME;
+/**
+* 已告警过的坏 `trajectory-constraint.json`（进程级去重：同一坏文件不刷屏，但**绝不静默**）。
+*
+* 🔴 为什么必须响亮（同源先例 = `loadSerenityConfig` 的 F-07）：一份坏 JSON 会让
+* **工具白名单静默失效**——而白名单正是 轨迹约束的权限边界 ⇒ 静默 = 权限面悄悄放开或收死，
+* 两种都查不到原因。
+*/
+const warnedBrokenProfiles = /* @__PURE__ */ new Set();
+/** 活跃轨迹目录名（跳过 `_`/`.` 前缀 —— 归档区与日志区不是轨迹；判据同 `readAllSessions`） */
+function activeTrajectoryDirNames(root) {
+	try {
+		return readdirSync(sessionsRoot(root), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
+	} catch {
+		return [];
+	}
+}
+/**
+* 读一个目录下的 `trajectory-constraint.json`（**纯读，不施加约束**）。
+*
+* @param trajectoryDir 轨迹目录绝对路径
+* @param root CCC 根（仅用于 `systemPromptFile` 的逃逸拒绝）
+* @returns 归一后的约束面；**无该文件 → `null`（= 这不是 轨迹约束，常态，不是错误）**
+*
+* ⚠️ **形态容错**：数组元素非字符串 → 丢弃该项（不整份作废）；`cognitiveTrajectory`
+* 缺项 → 各自取 **true**（见 R↓）；`model` 空白 → undefined（回退缺省）。
+* 坏 JSON ⇒ 告警 + `null`（**按"不是 轨迹约束"处理**：宁可让它退回普通轨迹，也不要带着
+* 半份读不懂的权限面运行）。
+*/
+function readTrajectoryConstraintAt(trajectoryDir, root) {
+	const dirName = trajectoryDir.split("/").filter(Boolean).pop() ?? "";
+	const code = parseTrajectoryCode(dirName);
+	if (code === null) return null;
+	const found = findTrajectoryFile(trajectoryDir);
+	if (found === null) return null;
+	let raw;
+	try {
+		raw = JSON.parse(readUtf8(found));
+	} catch (err) {
+		if (!warnedBrokenProfiles.has(found)) {
+			warnedBrokenProfiles.add(found);
+			console.warn(`[serenity-hooks] ✗ ${TRAJECTORY_FILENAME} 解析失败 ⇒ 该轨迹**按普通轨迹处理**（工具白名单与提示词约束全部不施加）。请修 JSON: ${found} — ${String(err?.message ?? err)}`);
+		}
+		return null;
+	}
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+		if (!warnedBrokenProfiles.has(found)) {
+			warnedBrokenProfiles.add(found);
+			console.warn(`[serenity-hooks] ✗ ${TRAJECTORY_FILENAME} 顶层不是对象 ⇒ 按普通轨迹处理: ${found}`);
+		}
+		return null;
+	}
+	const obj = raw;
+	const file = found;
+	/**
+	* 白名单字段的**两态**读取（D181，owner 2026-10-20 裁「不写当然不收窄」）：
+	*
+	* | 文件里 | 返回 | 语义 |
+	* |---|---|---|
+	* | 字段**不存在** | `undefined` | **不收窄**（这条轨迹要的是别的设定，比如只写 `resident`） |
+	* | `[]`（显式空数组） | `[]` | **全隐藏**（除恒可用的 `skill`）—— 用户明说了"我一个都不给" |
+	* | `["a","b"]` | `["a","b"]` | 只给这些 |
+	*
+	* 🔴 **为什么不能归一成 `[]`**：那会把"我没提这件事"读成"我要禁止一切"，
+	* 于是「只想声明常驻」的人会被静默锁死（S196 实测踩到，见 D179(b)）。
+	* 判据是**字段在不在**，不是数组空不空。
+	*/
+	const strListMaybe = (v) => v === void 0 ? void 0 : Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.trim() !== "").map((x) => x.trim()) : void 0;
+	/** 布尔缺省 **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] ✗ ${TRAJECTORY_CONSTRAINT_FILENAME} 的 systemPromptFile 越界，已忽略（其余约束仍生效）: ${file} — ${String(err?.message ?? err)}`);
+	}
+	const residentRaw = obj.resident;
+	let resident;
+	if (residentRaw && typeof residentRaw === "object" && !Array.isArray(residentRaw)) {
+		const serves = residentRaw.serves;
+		resident = typeof serves === "string" && serves.trim() !== "" ? { serves: serves.trim() } : {};
+	}
+	const tools = strListMaybe(obj.tools);
+	const msms = strListMaybe(obj.msms);
+	const writes = strListMaybe(obj.writes);
+	/**
+	* 提示词注入模式（owner 2026-10-20）：只搬运，不判决。
+	*
+	* 🔴 判决在 `planPromptInjection()` —— 那里有唯一的合法性表与降级规则。
+	* 这里若也判一次（比如把未知值归一成 append），就会有两处真相：
+	* 一处静默改值、一处告警，读数是矛盾的（D151 同族）。
+	*/
+	const promptRaw = obj.prompt;
+	const prompt = promptRaw !== null && typeof promptRaw === "object" && !Array.isArray(promptRaw) ? {
+		...typeof promptRaw.injection === "string" ? { injection: promptRaw.injection } : {},
+		...strListMaybe(promptRaw.replaces) !== void 0 ? { replaces: strListMaybe(promptRaw.replaces) } : {}
+	} : void 0;
+	return {
+		dirName,
+		code,
+		path: file,
+		...model !== void 0 ? { model } : {},
+		...tools !== void 0 ? { tools } : {},
+		...msms !== void 0 ? { msms } : {},
+		...writes !== void 0 ? { writes } : {},
+		...resident !== void 0 ? { resident } : {},
+		...prompt !== void 0 ? { prompt } : {},
+		cognitiveTrajectory: {
+			session: boolOrTrue(ct.session),
+			keeper: boolOrTrue(ct.keeper),
+			rebuild: boolOrTrue(ct.rebuild)
+		},
+		...systemPrompt !== void 0 ? { systemPrompt } : {},
+		...systemPromptFile !== void 0 ? { systemPromptFile } : {}
+	};
+}
+/**
+* 按**轨迹编码**解析 轨迹约束面（`list`/`admin`/调试页/路由解析用）。
+*
+* @returns 约束面；轨迹不存在 ／ 无 `trajectory-constraint.json` → `null`
+*/
+function readTrajectoryConstraintByCode(root, code) {
+	const dirName = findDirNameByCode(root, code);
+	if (dirName === null) return null;
+	return readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
+}
+/** 扫全部活跃轨迹，返回全部 轨迹约束。**顺序按目录名**（确定性，便于对读）。 */
+function listTrajectoryConstraints(root) {
+	const out = [];
+	for (const name of activeTrajectoryDirNames(root)) {
+		const p = readTrajectoryConstraintAt(join(sessionsRoot(root), name), root);
+		if (p) out.push(p);
+	}
+	return out;
+}
+/**
+* 编码 → 轨迹目录名（活跃轨迹内）。找不到 → `null`。
+*
+* ⚠️ 与 `findSession` 的分工：这里**只按编码精确**匹配（不做模糊），
+* 因为它的调用方（路由 / 约束施加）要的是**确定性**，模糊匹配会把"手抖打错的名字"
+* 静默投到一条相近的轨迹上——那正是最难查的一类串味。
+*/
+function findDirNameByCode(root, code) {
+	const hits = [];
+	for (const name of activeTrajectoryDirNames(root)) if (parseTrajectoryCode(name) === code) hits.push(name);
+	if (hits.length > 1) throw new Error(`编码「${code}」在本 CCC 有 ${hits.length} 条轨迹同时占用，无法确定要施加到哪一条：\n` + hits.map((n) => `  · ${n}`).join("\n") + "\n编码是终身身份（AXIOM 3）⇒ 不替你任选其一。改用**完整目录名**指定。");
+	return hits[0] ?? null;
+}
+/**
+* **会话级**判据（J2）：这个 dsh 会话是不是 轨迹约束会话 —— 唯一入口。
+*
+* 判据 = **它绑定的轨迹有 `trajectory-constraint.json`**（不是 sessionId 前缀，也不是配置里有没有角色）。
+*
+* ## 为什么"绑定的轨迹"从两个来源取（R↓，一个失败模式）
+* ① **持久绑定**（`readLastBound`，宿主存储域/`.bindings.json`）—— 权威，跨重启成立；
+* ② **内存注册表**（`trajectory/policy/window`）—— 覆盖绑定的**窗口期**（轨迹刚定、bound 还没落盘）。
+* ⇒ 只取 ① 会在建会话的第一轮判成"不是 轨迹约束"（工具面不收窄，模型看见不该有的工具）；
+*    只取 ② 会在进程重启后全判成"不是"（轨迹约束 失去约束，**权限面静默放开**）。
+* ⇒ **两来源并取**，都不中才 `null`。
+*
+* @param root CCC 根
+* @param sessionId dsh 会话 id
+* @param boundDirName 调用方已解析的绑定目录名（可选；给了就省一次读绑定）
+* @returns 约束面；不是 轨迹约束会话 → `null`
+*/
+function trajectoryConstraintForSession(root, sessionId, boundDirName) {
+	const dirName = boundDirName ?? registeredDirName(sessionId);
+	if (dirName === null || dirName === "") return null;
+	return readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
+}
+/** 内存登记的轨迹目录名（注册表单一真相源在 `./registry.ts`；此处只做一次转发） */
+function registeredDirName(sessionId) {
+	if (typeof sessionId !== "string" || sessionId === "") return null;
+	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 的旁路判定），
+* 让它们各自写 `!== null` 会把判据散开；**判据只能有一个入口**。
+*
+* 🔴 **D183（owner 2026-10-20）：这里的 `true` 只表示"有声明"，不再等于"该旁路默认行为"。**
+* 要判断后者请用 `replacesDefaultIdentity()` —— 两者**刻意分开**，因为：
+* 「我声明过」与「我声明了什么」是两件事，而旁路 ACC 身份只需要后者成立。
+*/
+function isTrajectoryConstrained(root, sessionId) {
+	return trajectoryConstraintForSession(root, sessionId) !== null;
+}
+/**
+* 这条声明**是否真的取代了该轨迹的默认身份**（= 该不该旁路 ACC 身份/首轮/恢复等默认行为）。
+*
+* ## 为什么需要它（D183，owner 2026-10-20 逐字）
+*
+* > 「这个 `trajectory.json` 中**所有 key 都是可选的；不写就是不设定 不应影响默认行为**」
+*
+* 旧判据是**文件存在** ⇒ 只写一句 `resident`（对外用途自述）就会连带丢掉
+* ACC 身份播种、首轮锚定、自动恢复、compact 重注入 —— **完全超出用户预期**。
+*
+* ## 判据（哪些 key 真的改"这条轨迹是谁"）
+*
+* | key | 取代默认身份？ | 理由 |
+* |---|---|---|
+* | `tools` / `msms` | **否** | 它们收窄**能力**，但"我是谁、我按什么章程工作"没变 ⇒ 仍该拿 ACC 身份 |
+* | `model` | **否** | 换的只是**执行的模型**，不是身份 |
+* | `resident` | **否** | 纯对外自述，D173 明说"不碰任何默认行为" |
+* | `cro.host` | **否** | 管"哪台机器跑 CRO 程序"，与身份无关 |
+* | `cognitiveTrajectory` | **否** | 管"参与哪些纪律"，纪律是叠加不是取代 |
+* | `systemPromptFile` / `systemPrompt` | **是** | 它自带**章程** ⇒ 用户的提示词整段取代 ACC 的 |
+* | `PROMPT.md`（目录里） | **否** | 它**追加**在 ACC 身份之外（v1.72.0 起的机制），不取代 |
+*
+* @returns `true` ⇒ 该轨迹自带章程，应旁路 ACC 身份类默认行为；否则 `false`
+*/
+function replacesDefaultIdentity(profile) {
+	if (!profile) return false;
+	const hasFile = (profile.systemPromptFile ?? "").trim() !== "";
+	const hasInline = (profile.systemPrompt ?? "").trim() !== "";
+	return hasFile || hasInline;
+}
+//#endregion
+export { profile_exports as a, replacesDefaultIdentity as c, registerTrajectorySession as d, trajectoryDirNameForSession as f, listTrajectoryConstraints as i, trajectoryCodeForSession as l, findDirNameByCode as n, readTrajectoryConstraintAt as o, unregisterTrajectorySession as p, isTrajectoryConstrained as r, readTrajectoryConstraintByCode as s, TRAJECTORY_CONSTRAINT_FILENAME as t, trajectoryConstraintForSession as u };

package/lib/{route-CmEoKp9w.js → route-reyv8qcB.js}

@@ -1,6 +1,6 @@
 import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
-import { s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS } from "./ccc-B-h_A7uc.js";
-import { c as unsetEntry, l as writeEntry, r as getEntry } from "./service-Cndtf7q4.js";
+import { s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS } from "./ccc-BmpE3cQz.js";
+import { c as unsetEntry, l as writeEntry, r as getEntry } from "./service-Z3aSR1cn.js";
 import { join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";

package/lib/rules-BLkYTPUy.js

@@ -0,0 +1,261 @@
+import { g as resolveInside, h as readUtf8 } from "./ccc-BmpE3cQz.js";
+import { dirname, join } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/kernel/constants.ts
+/** 常量（纯模块，零 DSH 依赖） */
+/** 本包名 —— 上溯定位包根时的**身份核对**（同名目录家的邻居不会误命中） */
+const PACKAGE_NAME = "@shgroup/dsh-serenity-hooks";
+/** 上溯层数上限（源码态最深 `src/<域>/<子域>/` ／ 发布态 `lib/` ⇒ 8 层足够，且**保证有界**） */
+const MAX_ROOT_ASCENT = 8;
+/**
+* 包根 = 含**本包** `package.json` 的目录。
+*
+* 🔴 为什么不写 `join(here, '..')`：本模块自身的位置**随目录重构变化**
+* （曾 `src/`，现 `src/kernel/`），而发布态是从打包入口 `lib/index.js` 反推 ——
+* 两种布局的深度不同，写死层数**必然在其中一个布局下静默错位**。
+* 实测代价：`src/` → `src/kernel/` 之后，`join(here,'..')` 指到 `src/`（无 package.json）
+* ⇒ `ACC_VERSION` 落进 catch 分支变 `0.0.0`，**没有任何门禁报警**。
+*
+* ⇒ 判据改成**内容**（找带本包名的 package.json）而不是**层数**。
+*
+* @param start 起点目录（缺省 = 本模块所在目录；测试可注入）
+*/
+function findPackageRoot(start) {
+	let dir = start ?? dirname(fileURLToPath(import.meta.url));
+	for (let i = 0; i < MAX_ROOT_ASCENT; i += 1) {
+		try {
+			if (JSON.parse(readFileSync(join(dir, "package.json"), "utf-8")).name === PACKAGE_NAME) return dir;
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* ACC 版本：自动从 package.json 读取（单一真相源，消除与 CHANGELOG 的漂移）。
+* 发布时只需改 package.json 的 version。
+*/
+const ACC_VERSION = (() => {
+	try {
+		const root = findPackageRoot();
+		if (root === null) return "0.0.0";
+		return JSON.parse(readFileSync(join(root, "package.json"), "utf-8")).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+})();
+//#endregion
+//#region src/trajectory/policy/rules.ts
+/**
+* trajectory/policy/rules.ts — 轨迹约束面的**纯逻辑助手**（零 DSH 依赖，可独立单测）
+*
+* ## 2026-10-19 重做后的职责边界（R↓，别再混起来）
+*
+* | 模块 | 管什么 |
+* |---|---|
+* | `./profile.ts` | **判据 + 读盘**（"这是不是 轨迹约束"、"约束面是什么"） |
+* | `./rules.ts`（本文件） | **从约束面派生出的纯函数**（白名单集合、提示词读取器、基础提示词文本） |
+* | `../session-create.ts` | 会话创建/复用、提问、守门查询 |
+*
+* ⇒ 本文件**不再读 `serenity.json`**：`轨迹约束.roles` 整段已退役（owner 2026-10-19 重做）。
+* 它只接收一个已解析好的 `TrajectoryConstraint`，因此**不涉及任何 IO**（除提示词文件，那是刻意懒读的）。
+*
+* ## S12（2026-10-19，轨迹中心重构）
+*
+* 原名 `role/轨迹约束/config.ts`。改名理由（框架 §6.3「角色不是一个概念，是一段历史」）：
+* 它派生的是**某条轨迹的约束面**，与"配置读取"无关（本文件零配置读取，见上一段）
+* ⇒ `config` 这个名字描述的是**它曾经的样子**，`rules` 描述它**现在做的事**。
+*/
+/** 白名单推导 ────────────────────────────────────────────────────────────── */
+/** 提示词来源提示串（`apply` 回执与面板共用；避免两处措辞漂） */
+const TRAJECTORY_CONSTRAINT_HINT = "systemPromptFile hot-reloads by mtime; the rest of trajectory-constraint.json is re-read every turn";
+/**
+* 该轨迹会话**可见**的工具面（tools ∪ `msm`）。
+*
+* 🔴 **返回值 `null` 有专门含义（D181，owner 2026-10-20 裁「不写当然不收窄」）**：
+*
+* | `tools` | `msms` | 返回 | 语义 |
+* |---|---|---|---|
+* | 缺省 | 缺省 | **`null`** | **不收窄任何工具面**（这条轨迹要的是别的设定，如只写 `resident`） |
+* | `[]` | 缺省 | `{'msm'?}` 空/仅 msm | **全隐藏**（除恒可用的 `skill`） |
+* | `['a']` | … | `{'a', …}` | 只给这些 |
+*
+* ⛔ **调用方不许把 `null` 当空集处理** —— 那正是 S196 被锁死的形态（D179(b)）。
+* 判据是**字段在不在**，不是数组空不空。
+*
+* 🔴 `msm` 为什么自动加入：`msms` 非空意味着这个轨迹 **有 MSM 通道**，
+* 而 MSM 的唯一合法调用入口是 `msm` 工具（单入口纪律）——不给它 `msm` 就等于
+* 声明了一堆调不动的能力。⚠️ 这是**并集**，不是覆盖：`tools` 里显式写的照旧生效。
+*
+* @returns 白名单集合；**`null` = 不收窄**（调用方须显式判 `null`）
+*/
+function profileToolWhitelist(profile) {
+	if (!profile) return null;
+	if (profile.tools === void 0 && profile.msms === void 0) return null;
+	const out = /* @__PURE__ */ new Set();
+	for (const t of profile.tools ?? []) out.add(t);
+	if ((profile.msms?.length ?? 0) > 0) out.add("msm");
+	return out;
+}
+/** 该轨迹会话可 exec 的 MSM 白名单（`msm` 工具内部再过滤；独立于工具白名单） */
+function profileMsmWhitelist(profile) {
+	return new Set(profile?.msms ?? []);
+}
+/**
+* 该轨迹可**写**的路径前缀（owner 2026-10-20 令：「轨迹设定自己的写白名单」）。
+*
+* 🔴 与 `profileToolWhitelist` 共用同一条判据（D181/D183）：**字段在不在，不是数组空不空**。
+*
+* | `writes` | 返回 | 语义 |
+* |---|---|---|
+* | 缺省 | **`null`** | 不收窄（写权限 = 路径守卫那几条，与今天一致） |
+* | `[]` | `[]`（空数组） | **一个写都落不下**（显式意图） |
+* | `['a/']` | `['a/']` | 写目标必须落在 `a/` 之内 |
+*
+* ⛔ **调用方不许把 `null` 当 `[]`** —— 那会把"我没想到这件事"读成"我不许写任何东西"，
+* 正是 S196 被静默锁死的形态（D179(b)）。
+*
+* ⚠️ 返回的是**原始条目**（相对 CCC 根或绝对路径都可），解析成绝对路径由调用方按自己的 root 做 ——
+* 本模块不持有 root（判据在 `seams/guards.ts`）。
+*/
+function profileWriteWhitelist(profile) {
+	if (!profile) return null;
+	if (profile.writes === void 0) return null;
+	return profile.writes;
+}
+/** 轨迹纪律参与项（`profile` 缺省已在 `readTrajectoryConstraintAt` 归一为全 true） */
+function constraintCognitiveTrajectory(profile) {
+	return {
+		session: profile?.cognitiveTrajectory.session === true,
+		keeper: profile?.cognitiveTrajectory.keeper === true,
+		rebuild: profile?.cognitiveTrajectory.rebuild === true
+	};
+}
+/**
+* 解析约束面声明的**系统提示词全文**（一次性读取；`create` / `validate` / `list` 用）。
+*
+* 顺序：`systemPromptFile`（**推荐**：超长提示词在 JSON 里内嵌不可读）→ 内嵌 `systemPrompt` → 空串。
+* 文件缺失/逃逸 ⇒ **抛错**（调用方 catch 降级；`validate` 据此报 issue）。
+*
+* ⚠️ 热路径**不用**它（那会用每次工具调用去读盘）——热路径用 `createProfilePromptReader`。
+*/
+function resolveConstraintSystemPrompt(root, profile) {
+	if (!profile) return "";
+	const file = profile.systemPromptFile?.trim();
+	if (file) {
+		const abs = resolveInside(root, file);
+		if (!existsSync(abs)) throw new Error(`轨迹约束 "${profile.code}": systemPromptFile "${file}" not found (resolved: ${abs})`);
+		return readUtf8(abs).trim();
+	}
+	return profile.systemPrompt ?? "";
+}
+/**
+* 提示词来源（`list`/`validate` 展示用）。
+*
+* 🔴 **2026-10-19 修（T4 的漏网面）**：v1.72.0 起提示词有两代来源——**新形态**
+* 是轨迹目录里的 `PROMPT.md`（`trajectory/prompt.ts`，**优先**），旧形态才是
+* `systemPromptFile` / `systemPrompt`。本函数原先只认旧形态 ⇒ 两条只写了 `PROMPT.md`
+* 的轨迹在 `container_admin config list` 里恒显示 `promptSource: 'none'`。
+*
+* 那是**读数器过时**，不是配置缺失：`validate` 侧早已按两条来源判（见
+* `trajectory-constraint-admin.ts` 的 `hasTrajectoryPromptOrLegacy`），而 `list` 侧漏了。
+* ⇒ 返 **四种**值，把"有章程但来源是新形态"这一格单独说出来。
+*
+* @param hasPromptFile 该轨迹目录下**是否真有** `PROMPT.md`（调用方查，本函数不做 IO）
+*/
+function constraintSystemPromptSource(profile, hasPromptFile = false) {
+	if (hasPromptFile) return "trajectory-file";
+	if (profile?.systemPromptFile?.trim()) return "file";
+	if (profile?.systemPrompt?.trim()) return "inline";
+	return "none";
+}
+/**
+* 提示词**读取器**（长期热更新；改文件即生效，无需重启）。
+*
+* 为什么返回函数而不是字符串（R↓，实证代价）：旧实现在创建时把提示词**快照**进系统提示词段闭包
+* ⇒ CCC 改了提示词文件必须重启 dsh web 才生效（实测：改完 18KB 提示词，live agent 仍用旧文本）。
+* 现形态由系统提示词段的 `text()` **每轮调用**本读取器：
+*   - `systemPromptFile`：按 **mtime + size** 缓存重读（命中缓存零 IO；未变不解析）
+*   - 内嵌 `systemPrompt`：静态（改 JSON 仍需重载配置，这与文件热更的差别是**必然**的 —— 文件有 mtime，JSON 没有）
+*   - 读取失败：返回**上次成功内容**（⛔ 绝不返回空——空提示词会让角色失去人格与纪律），并按标签去重告警一次
+*
+* @param root CCC 根
+* @param profile 约束面
+*/
+function createProfilePromptReader(root, profile) {
+	const file = profile?.systemPromptFile?.trim();
+	if (!file) {
+		const inline = profile?.systemPrompt ?? "";
+		return () => inline;
+	}
+	let abs = null;
+	try {
+		abs = resolveInside(root, file);
+	} catch (err) {
+		console.warn(`[serenity-hooks] ✗ 轨迹约束提示词路径非法（${file}）: ${String(err?.message ?? err)}`);
+	}
+	if (abs === null) return () => "";
+	const absPath = abs;
+	let cachedMtime = -1;
+	let cachedSize = -1;
+	let cachedText = "";
+	let warned = false;
+	return () => {
+		try {
+			const st = statSync(absPath);
+			if (st.mtimeMs === cachedMtime && st.size === cachedSize) return cachedText;
+			const text = readUtf8(absPath).trim();
+			const isReload = cachedMtime !== -1;
+			cachedMtime = st.mtimeMs;
+			cachedSize = st.size;
+			cachedText = text;
+			warned = false;
+			if (isReload) console.info(`[serenity-hooks] ↻ 轨迹约束提示词已热重载（${file}，${text.length} 字符）`);
+			return text;
+		} catch (err) {
+			if (!warned) {
+				warned = true;
+				console.warn(`[serenity-hooks] ✗ 轨迹约束提示词读取失败（${file}）——沿用上次成功内容: ${String(err?.message ?? err)}`);
+			}
+			return cachedText;
+		}
+	};
+}
+/**
+* 轨迹约束 基础提示词（dsp 只给这部分；CCC 的 `systemPrompt` 段由调用方拼接）。
+*
+* ## 🔴 为什么**不再枚举**清单（owner 2026-10-19 令）
+*
+* 旧版在这里抄了两份清单（`MSMs: a, b, c` / `Tools: read, grep, …`）。那是**第二真相源**，
+* 而真相源本来就在模型自己手里：
+*   · **工具清单** = 这一轮实际注册给它的 tool schema —— 模型已经看得见，抄一遍只会漂
+*   · **MSM 清单** = `msm()` 无参调用返回的目录 —— 已按白名单过滤，且**每次实时读配置**
+*
+* ⚠️ **漂移不是理论风险，是已发生的缺陷**（2026-10-19）：角色配置早就长到 8 个工具，
+* 而这个函数是从**创建时冻结的快照**求值的 ⇒ 提示词里一直写着旧的 4 个
+* ⇒ 模型照着提示词办事，**它自己以为没有的能力就不去调** ⇒ 症状是"工具用不了"，
+* 而守卫那边（每调用实时读配置）其实是放行的。两个真相源打架，输的总是提示词。
+*
+* ⇒ 现在只声明**边界与发现路径**，不抄内容：清单在哪，怎么取，越界会怎样。
+*
+* @param code 轨迹编码（轨迹约束的身份 —— 不是"角色名"，那个概念已退役）
+*/
+function buildTrajectoryBasePrompt(code) {
+	return [
+		"=== Serenity 轨迹约束 ===",
+		`Cognitive trajectory: ${code} (this is the trajectory you ARE, not a role you play)`,
+		"Your capability boundary is enforced mechanically by this CCC — anything outside it is rejected at the call site, not by your judgment.",
+		"Discover your surface, do not memorize it (both are generated from the live config on every turn):",
+		"  · Your tools are exactly the tool schemas you see in this session — if a tool is not in your schema, it is not available.",
+		"  · Your MSMs are listed by calling msm() with no arguments — that directory is already filtered to this trajectory.",
+		"  · Usage for any MSM: msm(\"<name>\", [], inspect=true) or pass \"--help\" as the first argument.",
+		"Do not infer unavailability from anything you remember or from an earlier list: this surface changes when the CCC configuration changes, and it takes effect without restarting.",
+		"",
+		"---",
+		""
+	].join("\n");
+}
+//#endregion
+export { createProfilePromptReader as a, profileWriteWhitelist as c, findPackageRoot as d, constraintSystemPromptSource as i, resolveConstraintSystemPrompt as l, buildTrajectoryBasePrompt as n, profileMsmWhitelist as o, constraintCognitiveTrajectory as r, profileToolWhitelist as s, TRAJECTORY_CONSTRAINT_HINT as t, ACC_VERSION as u };