@shgroup/dsh-serenity-hooks 1.72.0 → 1.74.0

package/lib/{message-source-kVoNK0C5.js → message-source-DCpoRHP3.js}

@@ -1,5 +1,5 @@
-import { r as cccRootForCwd } from "./ccc-roots-jZYR2GVE.js";
-import { A as sessionEvents, E as parseTrajectoryCode, b as getActiveSessionInfo, x as getLastActiveSessionInfo } from "./profile-DyMJ_bfr.js";
+import { r as cccRootForCwd } from "./ccc-roots-B2t_aM8L.js";
+import { T as parseTrajectoryCode, b as getLastActiveSessionInfo, k as sessionEvents, y as getActiveSessionInfo } from "./profile-BVt84mbi.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 //#region src/trajectory/bound.ts

package/lib/patches/opencode-provider.d.ts

@@ -191,7 +191,7 @@ export declare function applyOpencodeAutoConfigOnce(ctx: Context, env?: Readonly
 /**
  * 装配 opencode 路由自动配置。
  *
- * 触发面（三层，与 skiff 同款；R↓：单点触发在同装载竞态下必然漏）：
+ * 触发面（三层，与 轨迹约束 同款；R↓：单点触发在同装载竞态下必然漏）：
  *   ① apply 时立即试一次
  *   ② 命名空间尚未注册 → 退避重试（1s/3s/8s/20s/40s）
  *   ③ `settings/updated` → 再试（用户热改 settings.yaml 加路由时自愈；自身写入触发的复评是幂等空转）

package/lib/{profile-DyMJ_bfr.js → profile-BVt84mbi.js}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { _ as resolveInside, g as readUtf8 } from "./ccc-Dkoa2oW3.js";
+import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
+import { _ as resolveInside, g as readUtf8 } from "./ccc-CyYJL4F2.js";
 import { basename, dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
 //#region src/kernel/time.ts
@@ -123,7 +123,7 @@ function localIdStamp(value = Date.now()) {
 *
 * ⚠️ 由此产生一条**必须成立**的配套：`readAllSessions` **跳过 `_` 前缀目录**。
 * 否则归档后的轨迹会继续出现在清单里，"归档"就不是归档了（历史 bug：`_weixin-logs` /
-* `_skiff-logs` / `_corpus` 曾被当成轨迹列出来）。
+* `_轨迹约束-logs` / `_corpus` 曾被当成轨迹列出来）。
 */
 const COGNITIVE_TRAJECTORY_ACTIONS = [
 	"list",
@@ -199,7 +199,7 @@ function readSessionEntry(dirPath) {
 * 读取 AGENT_SESSIONS 中所有**活跃**轨迹，按 mtime 降序。
 *
 * 🔴 **跳过 `_` 前缀目录**（2026-10-18 新增，与归档配套）：
-* `_archived` 是归档区，`_skiff-logs` / `_weixin-logs` / `_corpus` 是**日志与数据区**——
+* `_archived` 是归档区，`_轨迹约束-logs` / `_weixin-logs` / `_corpus` 是**日志与数据区**——
 * 它们**都不是轨迹**。旧实现会把它们当轨迹列出来（历史 bug）。
 * 没有这条，归档后的轨迹仍会出现在清单里 ⇒ **"归档"名不副实**。
 *
@@ -750,72 +750,75 @@ function archiveSession(root, key, dryRun = false) {
 	};
 }
 //#endregion
-//#region src/role/skiff/registry.ts
-const skiffSessions = /* @__PURE__ */ new Map();
+//#region src/trajectory/policy/window.ts
+const 轨迹约束Sessions = /* @__PURE__ */ new Map();
 /** 登记/更新一个会话 → 轨迹的映射 */
-function registerSkiffSession(sessionId, trajectoryDirName, ccc) {
-	skiffSessions.set(sessionId, {
+function registerTrajectorySession(sessionId, trajectoryDirName, ccc) {
+	轨迹约束Sessions.set(sessionId, {
 		trajectoryDirName,
 		ccc
 	});
 }
 /** 解绑（会话销毁 / 轨迹失效 ⇒ 换身份） */
-function unregisterSkiffSession(sessionId) {
-	skiffSessions.delete(sessionId);
+function unregisterTrajectorySession(sessionId) {
+	轨迹约束Sessions.delete(sessionId);
 }
 /** 查会话承载的轨迹目录名（无 → null）；`guards`/`system-prompt` 的同步热路径用 */
-function skiffTrajectoryDirNameFor(sessionId) {
-	const b = skiffSessions.get(sessionId);
+function trajectoryDirNameForSession(sessionId) {
+	const b = 轨迹约束Sessions.get(sessionId);
 	return b === void 0 || b.trajectoryDirName === "" ? null : b.trajectoryDirName;
 }
-/** 查会话的完整绑定（轨迹 + CCC；无 → null）——追问延续时校验 (轨迹, CCC) 未串味 */
-function skiffSessionInfo(sessionId) {
-	return skiffSessions.get(sessionId) ?? null;
-}
 //#endregion
-//#region src/role/skiff/profile.ts
+//#region src/trajectory/policy/profile.ts
 /**
-* role/skiff/profile.ts — **skiff 的唯一判据**：目录下有 `skiff.json` 的认知轨迹（零 DSH 依赖，可独立单测）
+* trajectory/policy/profile.ts — **轨迹约束的唯一判据**：目录下有 `trajectory-constraint.json` 的认知轨迹（零 DSH 依赖，可独立单测）
 *
 * ## 🔴 owner 2026-10-19 重做令（逐字，本文件存在的全部理由）
 *
-* > 「skiff 复杂的约束和提示词体系都干掉，改为这样的实现：
-* > **skiff 本身是认知轨迹的一个特殊情况，即目录下拥有 `skiff.json` 的认知轨迹自动是一个 skiff**
-* > （json 里配置上个版本就有的各种约束），**会话跑在认知轨迹上且发现 `skiff.json`，则运行时实现各类约束**」
+* > 「轨迹约束 复杂的约束和提示词体系都干掉，改为这样的实现：
+* > **轨迹约束本身是认知轨迹的一个特殊情况，即目录下拥有 `trajectory-constraint.json` 的认知轨迹自动是一个 轨迹约束**
+* > （json 里配置上个版本就有的各种约束），**会话跑在认知轨迹上且发现 `trajectory-constraint.json`，则运行时实现各类约束**」
 *
 * ## 旧模型 → 新模型（**一条判据取代四条**）
 *
 * | 项 | 旧 | 新 |
 * |---|---|---|
-* | skiff 是什么 | `serenity.json` 的 `skiff.roles.<name>` 一条配置 | **轨迹目录里有 `skiff.json`** |
-* | 怎么认出 skiff 会话 | dsh sessionId 前缀 `skiff-` | **它绑定的轨迹有 `skiff.json`** |
-* | 工作台从哪来 | `ensureSkiffSession` 另建一个 SESSION | **就是该轨迹自己的 SESSION.md** |
+* | 轨迹约束是什么 | `serenity.json` 的 `轨迹约束.roles.<name>` 一条配置 | **轨迹目录里有 `trajectory-constraint.json`** |
+* | 怎么认出 轨迹约束会话 | dsh sessionId 前缀 `轨迹约束-` | **它绑定的轨迹有 `trajectory-constraint.json`** |
+* | 工作台从哪来 | `ensureTrajectorySession` 另建一个 SESSION | **就是该轨迹自己的 SESSION.md** |
 * | 身份 | 角色名 | **轨迹编码**（`trajectory/core.ts` 的 `parseTrajectoryCode`） |
 *
 * ⇒ 收益（owner：「理解难度大幅下降」的实际内容）：四个各自会漂的机制收敛为**一条文件存在性判据**。
-* 删掉 `skiff.json` ⇒ 该轨迹**当场**退化为普通轨迹（工具面、提示词、keeper 全部恢复默认）。
+* 删掉 `trajectory-constraint.json` ⇒ 该轨迹**当场**退化为普通轨迹（工具面、提示词、keeper 全部恢复默认）。
 *
 * ## 归属（D23）
 * **机制在 ACC**（文件叫什么、怎么读、怎么判、缺省值、如何施加约束）；
-* **内容在 CCC**（`skiff.json` 里填什么：模型、白名单、提示词路径）。
-* ⇒ ACC 代码里**不出现任何具体角色名**，也不读 `serenity.json` 的 skiff 段（该段已退役）。
+* **内容在 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({
-	SKIFF_PROFILE_FILENAME: () => SKIFF_PROFILE_FILENAME,
+	TRAJECTORY_CONSTRAINT_FILENAME: () => TRAJECTORY_CONSTRAINT_FILENAME,
 	findDirNameByCode: () => findDirNameByCode,
-	isSkiffSession: () => isSkiffSession,
-	listSkiffProfiles: () => listSkiffProfiles,
-	readSkiffProfileAt: () => readSkiffProfileAt,
-	readSkiffProfileByCode: () => readSkiffProfileByCode,
-	skiffProfileForSession: () => skiffProfileForSession
+	isTrajectoryConstrained: () => isTrajectoryConstrained,
+	listTrajectoryConstraints: () => listTrajectoryConstraints,
+	readTrajectoryConstraintAt: () => readTrajectoryConstraintAt,
+	readTrajectoryConstraintByCode: () => readTrajectoryConstraintByCode,
+	trajectoryConstraintForSession: () => trajectoryConstraintForSession
 });
-/** `skiff.json` 的固定文件名（**判据就是它存在**——不是目录名前缀，也不是配置里的一行） */
-const SKIFF_PROFILE_FILENAME = "skiff.json";
+/** `trajectory-constraint.json` 的固定文件名（**判据就是它存在**——不是目录名前缀，也不是配置里的一行） */
+const TRAJECTORY_CONSTRAINT_FILENAME = "trajectory-constraint.json";
 /**
-* 已告警过的坏 `skiff.json`（进程级去重：同一坏文件不刷屏，但**绝不静默**）。
+* 已告警过的坏 `trajectory-constraint.json`（进程级去重：同一坏文件不刷屏，但**绝不静默**）。
 *
 * 🔴 为什么必须响亮（同源先例 = `loadSerenityConfig` 的 F-07）：一份坏 JSON 会让
-* **工具白名单静默失效**——而白名单正是 skiff 的权限边界 ⇒ 静默 = 权限面悄悄放开或收死，
+* **工具白名单静默失效**——而白名单正是 轨迹约束的权限边界 ⇒ 静默 = 权限面悄悄放开或收死，
 * 两种都查不到原因。
 */
 const warnedBrokenProfiles = /* @__PURE__ */ new Set();
@@ -828,22 +831,22 @@ function activeTrajectoryDirNames(root) {
 	}
 }
 /**
-* 读一个目录下的 `skiff.json`（**纯读，不施加约束**）。
+* 读一个目录下的 `trajectory-constraint.json`（**纯读，不施加约束**）。
 *
 * @param trajectoryDir 轨迹目录绝对路径
 * @param root CCC 根（仅用于 `systemPromptFile` 的逃逸拒绝）
-* @returns 归一后的约束面；**无该文件 → `null`（= 这不是 skiff，常态，不是错误）**
+* @returns 归一后的约束面；**无该文件 → `null`（= 这不是 轨迹约束，常态，不是错误）**
 *
 * ⚠️ **形态容错**：数组元素非字符串 → 丢弃该项（不整份作废）；`cognitiveTrajectory`
 * 缺项 → 各自取 **true**（见 R↓）；`model` 空白 → undefined（回退缺省）。
-* 坏 JSON ⇒ 告警 + `null`（**按"不是 skiff"处理**：宁可让它退回普通轨迹，也不要带着
+* 坏 JSON ⇒ 告警 + `null`（**按"不是 轨迹约束"处理**：宁可让它退回普通轨迹，也不要带着
 * 半份读不懂的权限面运行）。
 */
-function readSkiffProfileAt(trajectoryDir, root) {
+function readTrajectoryConstraintAt(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);
+	const file = join(trajectoryDir, TRAJECTORY_CONSTRAINT_FILENAME);
 	if (!existsSync(file)) return null;
 	let raw;
 	try {
@@ -851,14 +854,14 @@ function readSkiffProfileAt(trajectoryDir, root) {
 	} catch (err) {
 		if (!warnedBrokenProfiles.has(file)) {
 			warnedBrokenProfiles.add(file);
-			console.warn(`[serenity-hooks] ✗ ${SKIFF_PROFILE_FILENAME} 解析失败 ⇒ 该轨迹**按普通轨迹处理**（工具白名单与提示词约束全部不施加）。请修 JSON: ${file} — ${String(err?.message ?? err)}`);
+			console.warn(`[serenity-hooks] ✗ ${TRAJECTORY_CONSTRAINT_FILENAME} 解析失败 ⇒ 该轨迹**按普通轨迹处理**（工具白名单与提示词约束全部不施加）。请修 JSON: ${file} — ${String(err?.message ?? err)}`);
 		}
 		return null;
 	}
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
 		if (!warnedBrokenProfiles.has(file)) {
 			warnedBrokenProfiles.add(file);
-			console.warn(`[serenity-hooks] ✗ ${SKIFF_PROFILE_FILENAME} 顶层不是对象 ⇒ 按普通轨迹处理: ${file}`);
+			console.warn(`[serenity-hooks] ✗ ${TRAJECTORY_CONSTRAINT_FILENAME} 顶层不是对象 ⇒ 按普通轨迹处理: ${file}`);
 		}
 		return null;
 	}
@@ -875,7 +878,7 @@ function readSkiffProfileAt(trajectoryDir, root) {
 		resolveInside(root, rawFile);
 		systemPromptFile = rawFile;
 	} catch (err) {
-		console.warn(`[serenity-hooks] ✗ ${SKIFF_PROFILE_FILENAME} 的 systemPromptFile 越界，已忽略（其余约束仍生效）: ${file} — ${String(err?.message ?? err)}`);
+		console.warn(`[serenity-hooks] ✗ ${TRAJECTORY_CONSTRAINT_FILENAME} 的 systemPromptFile 越界，已忽略（其余约束仍生效）: ${file} — ${String(err?.message ?? err)}`);
 	}
 	return {
 		dirName,
@@ -894,20 +897,20 @@ function readSkiffProfileAt(trajectoryDir, root) {
 	};
 }
 /**
-* 按**轨迹编码**解析 skiff 约束面（`list`/`admin`/调试页/路由解析用）。
+* 按**轨迹编码**解析 轨迹约束面（`list`/`admin`/调试页/路由解析用）。
 *
-* @returns 约束面；轨迹不存在 ／ 无 `skiff.json` → `null`
+* @returns 约束面；轨迹不存在 ／ 无 `trajectory-constraint.json` → `null`
 */
-function readSkiffProfileByCode(root, code) {
+function readTrajectoryConstraintByCode(root, code) {
 	const dirName = findDirNameByCode(root, code);
 	if (dirName === null) return null;
-	return readSkiffProfileAt(join(sessionsRoot(root), dirName), root);
+	return readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
 }
-/** 扫全部活跃轨迹，返回全部 skiff。**顺序按目录名**（确定性，便于对读）。 */
-function listSkiffProfiles(root) {
+/** 扫全部活跃轨迹，返回全部 轨迹约束。**顺序按目录名**（确定性，便于对读）。 */
+function listTrajectoryConstraints(root) {
 	const out = [];
 	for (const name of activeTrajectoryDirNames(root)) {
-		const p = readSkiffProfileAt(join(sessionsRoot(root), name), root);
+		const p = readTrajectoryConstraintAt(join(sessionsRoot(root), name), root);
 		if (p) out.push(p);
 	}
 	return out;
@@ -924,40 +927,40 @@ function findDirNameByCode(root, code) {
 	return null;
 }
 /**
-* **会话级**判据（J2）：这个 dsh 会话是不是 skiff 会话 —— 唯一入口。
+* **会话级**判据（J2）：这个 dsh 会话是不是 轨迹约束会话 —— 唯一入口。
 *
-* 判据 = **它绑定的轨迹有 `skiff.json`**（不是 sessionId 前缀，也不是配置里有没有角色）。
+* 判据 = **它绑定的轨迹有 `trajectory-constraint.json`**（不是 sessionId 前缀，也不是配置里有没有角色）。
 *
 * ## 为什么"绑定的轨迹"从两个来源取（R↓，一个失败模式）
 * ① **持久绑定**（`readLastBound`，宿主存储域/`.bindings.json`）—— 权威，跨重启成立；
-* ② **内存注册表**（`skiff/registry`）—— 覆盖绑定的**窗口期**（轨迹刚定、bound 还没落盘）。
-* ⇒ 只取 ① 会在建会话的第一轮判成"不是 skiff"（工具面不收窄，模型看见不该有的工具）；
-*    只取 ② 会在进程重启后全判成"不是"（skiff 失去约束，**权限面静默放开**）。
+* ② **内存注册表**（`trajectory/policy/window`）—— 覆盖绑定的**窗口期**（轨迹刚定、bound 还没落盘）。
+* ⇒ 只取 ① 会在建会话的第一轮判成"不是 轨迹约束"（工具面不收窄，模型看见不该有的工具）；
+*    只取 ② 会在进程重启后全判成"不是"（轨迹约束 失去约束，**权限面静默放开**）。
 * ⇒ **两来源并取**，都不中才 `null`。
 *
 * @param root CCC 根
 * @param sessionId dsh 会话 id
 * @param boundDirName 调用方已解析的绑定目录名（可选；给了就省一次读绑定）
-* @returns 约束面；不是 skiff 会话 → `null`
+* @returns 约束面；不是 轨迹约束会话 → `null`
 */
-function skiffProfileForSession(root, sessionId, boundDirName) {
+function trajectoryConstraintForSession(root, sessionId, boundDirName) {
 	const dirName = boundDirName ?? registeredDirName(sessionId);
 	if (dirName === null || dirName === "") return null;
-	return readSkiffProfileAt(join(sessionsRoot(root), dirName), root);
+	return readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
 }
 /** 内存登记的轨迹目录名（注册表单一真相源在 `./registry.ts`；此处只做一次转发） */
 function registeredDirName(sessionId) {
 	if (typeof sessionId !== "string" || sessionId === "") return null;
-	return skiffTrajectoryDirNameFor(sessionId);
+	return trajectoryDirNameForSession(sessionId);
 }
 /**
-* 该 dsh 会话**是不是** skiff 会话（布尔形态的 `skiffProfileForSession`）。
+* 该 dsh 会话**是不是** 轨迹约束会话（布尔形态的 `trajectoryConstraintForSession`）。
 *
 * 存在的理由：调用点很多只要一个"是/不是"（seams 的旁路判定），
 * 让它们各自写 `!== null` 会把判据散开；**判据只能有一个入口**。
 */
-function isSkiffSession(root, sessionId) {
-	return skiffProfileForSession(root, sessionId) !== null;
+function isTrajectoryConstrained(root, sessionId) {
+	return trajectoryConstraintForSession(root, sessionId) !== null;
 }
 //#endregion
-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 };
+export { sessionsRoot as A, namingTitleFor as C, readTrajectoryUid as D, readActiveSessionMd as E, isoLocal as F, localFileStamp as I, localHuman as L, showSession as M, summarize as N, resolveSessionByTitle as O, useSession as P, localIdStamp as R, listSessions as S, parseTrajectoryCode as T, extractSessionMdPathFromText as _, readTrajectoryConstraintAt as a, getLastActiveSessionInfo as b, registerTrajectorySession as c, COGNITIVE_TRAJECTORY_ACTIONS as d, DEFAULT_SESSION_SCOPE as f, createSession as g, clearActiveSessionInfo as h, profile_exports as i, setActiveSessionInfo as j, sessionEvents as k, trajectoryDirNameForSession as l, archiveSession as m, isTrajectoryConstrained as n, readTrajectoryConstraintByCode as o, UID_FILENAME as p, listTrajectoryConstraints as r, trajectoryConstraintForSession as s, TRAJECTORY_CONSTRAINT_FILENAME as t, unregisterTrajectorySession as u, findSession as v, parseSessionContextFromEvents as w, listActiveTrajectories as x, getActiveSessionInfo as y };

package/lib/rolldown-runtime-B4iAMlE-.js

@@ -0,0 +1,35 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/lib/{route-f7JlinIt.js → route-COOFLTpU.js}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS } from "./ccc-Dkoa2oW3.js";
+import { n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
+import { s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS } from "./ccc-CyYJL4F2.js";
 import { join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
@@ -288,7 +288,7 @@ function runLocalStore(root, args) {
 * 职责（零 DSH 依赖，可独立单测）：
 * - 读取 CCC 的 weixin 配置（.opencode/serenity.json weixin 段——结构/路由/开关）
 * - 读取/写入 CCC localstore 的账号凭据（weixin.accounts.<accountId>.token/.baseUrl/.userId）
-* - 微信用户 → skiff 会话 id 映射（固定可重建：skiff-weixin-<sha256(userid)>.slice(1, 17)；
+* - 微信用户 → 轨迹约束会话 id 映射（固定可重建：skiff-weixin-<sha256(userid)>.slice(1, 17)；
 *   v1.27.3 错位一位避开损坏 log）
 * - 路由匹配（exact user → 通配 * 兜底）
 *
@@ -300,8 +300,11 @@ var route_exports = /* @__PURE__ */ __exportAll({
 	extractWeixinMedia: () => extractWeixinMedia,
 	extractWeixinText: () => extractWeixinText,
 	hasVoiceItem: () => hasVoiceItem,
+	imCredentialBound: () => imCredentialBound,
 	matchWeixinRoute: () => matchWeixinRoute,
+	nextFeishuAccountId: () => nextFeishuAccountId,
 	nextWeixinAccountId: () => nextWeixinAccountId,
+	readFeishuCredential: () => readFeishuCredential,
 	readImSettings: () => readImSettings,
 	readWeixinCredential: () => readWeixinCredential,
 	readWeixinSettings: () => readWeixinSettings,
@@ -312,6 +315,7 @@ var route_exports = /* @__PURE__ */ __exportAll({
 	upsertWeixinAccount: () => upsertWeixinAccount,
 	weixinInboundDir: () => weixinInboundDir,
 	weixinSessionIdForTrajectory: () => weixinSessionIdForTrajectory,
+	writeFeishuCredential: () => writeFeishuCredential,
 	writeWeixinCredential: () => writeWeixinCredential
 });
 /** localstore 凭据键前缀（**credential scope**——token 是凭据，走 UPPER_SNAKE 键；
@@ -322,10 +326,10 @@ function accountKeyPart(accountId) {
 	return accountId.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
 }
 /**
-* 微信桥 skiff 会话 id 前缀（守卫识别"外部面"用）。
+* 微信桥 轨迹约束会话 id 前缀（守卫识别"外部面"用）。
 *
-* ⚠️ **2026-10-19 起它只是命名习惯，不再是判据** —— skiff 的身份是**轨迹**，
-* 判据 = 「绑定的轨迹有 `skiff.json`」（`role/skiff/profile.ts` 的 `isSkiffSession`）。
+* ⚠️ **2026-10-19 起它只是命名习惯，不再是判据** —— 轨迹约束的身份是**轨迹**，
+* 判据 = 「绑定的轨迹有 `trajectory-constraint.json`」（`trajectory/policy/profile.ts` 的 `isTrajectoryConstrained`）。
 * 保留前缀只为：① 日志/会话列表里一眼认出这是外部面；② 存量会话目录名不变。
 */
 const WEIXIN_SESSION_PREFIX = "skiff-weixin-";
@@ -339,7 +343,7 @@ const WEIXIN_SESSION_PREFIX = "skiff-weixin-";
 * 对不上旧会话的历史工具清单）。⇒ 那不是"轨迹是一等公民"，那是"用户是一等公民"。
 *
 * 新派生 = **由轨迹编码决定**：同一条轨迹 ⇒ 恒同一条 dsh 会话（无论谁在跟它说话）；
-* 换轨迹 ⇒ 新会话。这正是"skiff 是认知轨迹的一种"。
+* 换轨迹 ⇒ 新会话。这正是"轨迹约束是认知轨迹的一种"。
 *
 * ## 连带删掉的东西
 *
@@ -492,6 +496,42 @@ function clearWeixinCredential(root, accountId) {
 	unsetEntry(root, "credential", lsKey(accountId, "BASEURL"));
 	unsetEntry(root, "credential", lsKey(accountId, "USERID"));
 }
+/** 飞书凭据键（credential scope: FEISHU_<ACCOUNT_ID>_<FIELD>） */
+function feishuLsKey(accountId, field) {
+	return `FEISHU_${accountKeyPart(accountId)}_${field}`;
+}
+/** 读取飞书账号凭据（appId 或 appSecret 缺失 → null——账号未绑定） */
+function readFeishuCredential(root, accountId) {
+	const appId = getEntry(root, "credential", feishuLsKey(accountId, "APPID"));
+	const appSecret = getEntry(root, "credential", feishuLsKey(accountId, "SECRET"));
+	if (!appId || !appSecret) return null;
+	return {
+		appId,
+		appSecret
+	};
+}
+/** 写入飞书账号凭据（面板保存后；两者都必写——只写一半等于没绑） */
+function writeFeishuCredential(root, accountId, cred) {
+	writeEntry(root, "credential", feishuLsKey(accountId, "APPID"), cred.appId);
+	writeEntry(root, "credential", feishuLsKey(accountId, "SECRET"), cred.appSecret);
+}
+/**
+* **按渠道判「该账号是否已绑定凭据」**（面板读数用；单一处）。
+*
+* 🔴 为什么需要它（2026-10-19 P2 面板实测缺陷）：面板原先对所有账号都调
+* `readWeixinCredential`（只看 `WEIXIN_<A>_TOKEN`）。一个**飞书**账号的凭据在
+* `FEISHU_<A>_APPID|SECRET`，走那条读法**必然读到 null** ⇒ 面板把一个配好的飞书账号
+* 显示成「未绑定凭据」，用户据此以为没配上。
+*
+* 判据与装配处**同源**（`im/bridge.ts` 的 `readImCredentialByChannel`）：飞书要 appId **且**
+* appSecret，微信只要有 token。两处若各写一份判据，就会重演"两个读数器给出不同答案"。
+*
+* ⚠️ 只回**布尔**，不回任何凭据值 —— 这是 wire 面。
+*/
+function imCredentialBound(root, accountId, channel) {
+	if ((channel ?? "").trim() === "feishu") return readFeishuCredential(root, accountId) !== null;
+	return readWeixinCredential(root, accountId) !== null;
+}
 /**
 * 路由匹配：exact user 优先，通配 `*` 兜底。
 * @returns 命中的**轨迹编码**；未命中 → null（无路由 → 消息不回复/忽略）
@@ -630,6 +670,19 @@ function nextWeixinAccountId(settings) {
 	while (used.has(`wechat-${n}`)) n++;
 	return `wechat-${n}`;
 }
+/**
+* 生成下一个可用飞书账号 id（`feishu-N`，N 取**最小未占用**）。
+*
+* 与 {@link nextWeixinAccountId} 分开而不是加参数：两者的**前缀不同**，
+* 而前缀是给人看的（面板上一眼分清哪些账号来自哪个渠道）。
+* 判据相同（最小未占用，删中间不跳号）。
+*/
+function nextFeishuAccountId(settings) {
+	const used = new Set((settings.accounts ?? []).map((a) => a.accountId));
+	let n = 1;
+	while (used.has(`feishu-${n}`)) n++;
+	return `feishu-${n}`;
+}
 /** 切换总开关 */
 function setWeixinEnabled(root, enabled) {
 	const next = {
@@ -640,4 +693,4 @@ function setWeixinEnabled(root, enabled) {
 	return next;
 }
 //#endregion
-export { readWeixinCredential as a, sanitizeFileName as c, LOCALSTORE_SCOPES as d, checkLocalstoreGitCompliance as f, runLocalStore as g, readStore as h, matchWeixinRoute as i, weixinInboundDir as l, readGitTrack as m, extractWeixinText as n, readWeixinSettings as o, localstorePath as p, hasVoiceItem as r, route_exports as s, extractWeixinMedia as t, weixinSessionIdForTrajectory as u };
+export { runLocalStore as _, readFeishuCredential as a, route_exports as c, weixinSessionIdForTrajectory as d, LOCALSTORE_SCOPES as f, readStore as g, readGitTrack as h, matchWeixinRoute as i, sanitizeFileName as l, localstorePath as m, extractWeixinText as n, readWeixinCredential as o, checkLocalstoreGitCompliance as p, hasVoiceItem as r, readWeixinSettings as s, extractWeixinMedia as t, weixinInboundDir as u };

package/lib/seams/guards.d.ts

@@ -9,7 +9,7 @@
 import type { Context } from 'cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 import { type BlacklistRule } from '../kernel/ccc.js';
-import { type SkiffProfile } from '../role/skiff/profile.js';
+import { type TrajectoryConstraint } from '../trajectory/policy/profile.js';
 export interface GuardInput {
     root: string;
     toolName: string;
@@ -20,13 +20,13 @@ export interface GuardInput {
     /** container_fs 等复合工具的子命令 action（只读子命令不查黑名单） */
     action?: string;
     /**
-     * 该会话的 skiff 约束面（`null`/`undefined` = 不是 skiff 会话 ⇒ 不判定）。
+     * 该会话的 轨迹约束面（`null`/`undefined` = 不是 轨迹约束会话 ⇒ 不判定）。
      *
      * 🔴 2026-10-19 起传**已解析好的约束面**，不传 sessionId：解判据（"这条轨迹有没有
-     * `skiff.json`"）留在唯一入口 `profile.ts`，守卫只消费结果 ⇒ 纯函数里不再做 IO，
+     * `trajectory-constraint.json`"）留在唯一入口 `profile.ts`，守卫只消费结果 ⇒ 纯函数里不再做 IO，
      * 也不可能出现"守卫的判据与 schema 收窄的判据不一致"。
      */
-    skiffProfile?: SkiffProfile | null;
+    trajectoryConstraint?: TrajectoryConstraint | null;
 }
 interface GuardDecisionResult {
     deny?: string;
@@ -102,21 +102,21 @@ export declare function forgetHostScheduleToolHiding(sessionId: string): void;
 export declare function getExclusiveToolsDiagnostics(): {
     hidden: string[];
 };
-/** Skiff 角色工具面诊断（排查"某工具为什么不在 skiff 的清单里"） */
-export declare function getSkiffRoleVisibilityDiagnostics(): {
+/** 轨迹约束工具面诊断（排查"某工具为什么不在 轨迹约束的清单里"） */
+export declare function getTrajectoryConstraintVisibilityDiagnostics(): {
     keys: string[];
     denyByKey: Record<string, string[]>;
 };
 /**
- * 同步 **skiff 会话的工具面**：把白名单之外的工具**从 schema 移除**（不是"看得到但被拒"）。
+ * 同步 **轨迹约束会话的工具面**：把白名单之外的工具**从 schema 移除**（不是"看得到但被拒"）。
  *
  * ## 为什么必须有这条（owner 2026-10-19：「工具清单也要热加载」）
  *
- * 在它之前，skiff 白名单**只由运行时守卫拦截**（`decideGuard` 的 skiff 分支）：
+ * 在它之前，轨迹约束白名单**只由运行时守卫拦截**（`decideGuard` 的 轨迹约束 分支）：
  * 工具全部出现在模型 schema 里，调用时才被打回。⇒ 两个真实后果：
  *  ① **模型看得见它不该有的工具** —— 它会去试，试了才撞墙（一轮白烧，且错误文案泛化，
  *     看不出"是不在清单里"还是"临时性拒绝"）；
- *  ② **配置变动在 schema 上永远不生效** —— 改 `skiff.json` 的 `tools` 只影响"调用是否放行"。
+ *  ② **配置变动在 schema 上永远不生效** —— 改 `trajectory-constraint.json` 的 `tools` 只影响"调用是否放行"。
  *
  * ## 判据与降级
  *
@@ -124,17 +124,17 @@ export declare function getSkiffRoleVisibilityDiagnostics(): {
  *   不去动宿主的工具 —— 宿主的工具由各自的条件同步管）。
  * - ⚠️ **未注册的名字会让整次 restrict 失败**（宿主契约逐字 "unknown names … fail"），
  *   而 `diagram` 是按开关注册的 ⇒ 与 `hideAllFor` 同款**两档尝试**（先全覆盖，失败退常驻段）。
- * - 读不到约束面（不是 skiff / 配置删了）⇒ **撤销既有隐藏**（回到"无约束"）：
- *   ⛔ 不能只是 `return` —— 那会把上一步的隐藏**永久留在**一个已不再是 skiff 的会话上
- *   （这正是 owner 说的"删掉 `skiff.json` 就该立刻恢复"）。
+ * - 读不到约束面（不是 轨迹约束 / 配置删了）⇒ **撤销既有隐藏**（回到"无约束"）：
+ *   ⛔ 不能只是 `return` —— 那会把上一步的隐藏**永久留在**一个已不再是 轨迹约束的会话上
+ *   （这正是 owner 说的"删掉 `trajectory-constraint.json` 就该立刻恢复"）。
  * - 幂等：算出来的 deny 签名不变就跳过（不每步重建 schema）。
  *
  * @param agent 目标会话
  * @param root  CCC 根
  */
-export declare function syncSkiffRoleToolVisibility(agent: Agent, root: string): void;
+export declare function syncTrajectoryConstraintToolVisibility(agent: Agent, root: string): void;
 /** 会话销毁清理（lifecycle 调用） */
-export declare function forgetSkiffRoleToolVisibility(sessionId: string): void;
+export declare function forgetTrajectoryConstraintToolVisibility(sessionId: string): void;
 /**
  * 同步专属工具可见性（v1.33）。
  *

package/lib/seams/keeper.d.ts

@@ -85,7 +85,7 @@ export declare function __resetLogbookCompactionForTest(): void;
  * 解析**活跃** SESSION.md 绝对路径（缓存 60s）。
  *
  * 候选链（刻意比 rebuild 的完整链短——这里每个工具调用都要跑，贵候选不划算）：
- * ① `getActiveSessionInfo(scope).mdPath`（`cognitive_trajectory use` / skiff 绑定 / 重启恢复都会写）
+ * ① `getActiveSessionInfo(scope).mdPath`（`cognitive_trajectory use` / 轨迹约束 绑定 / 重启恢复都会写）
  * ② `readLastBound(session).mdPath`（`.bindings.json` 权威绑定——重启后内存空时兜底）
  * 两者都拿不到 → null（**不猜**：宁可不提醒，也不去猜别的轨迹——对齐 v1.30.13 D4 的教训）。
  */

package/lib/seams/lifecycle.d.ts

@@ -4,13 +4,13 @@
  * 两个此前缺失的收尾面：
  *
  * ① **会话/agent 销毁 → 清理 per-会话内存态**。dsp 有约 10 处 per-会话 Map
- *    （活跃 SESSION 作用域、skiff 注册表、keeper 计分、guard 白名单缓存、bootstrap
+ *    （活跃 SESSION 作用域、轨迹约束 注册表、keeper 计分、guard 白名单缓存、bootstrap
  *    晋升状态、输出守卫状态…）。此前无人订阅 `agent/disposed` / `session/disposed`
  *    （宿主 0.1.2-rc.1 真实存在：`core/agent/src/runtime-types.ts:175`、
  *    `core/session/src/index.ts:62`），长跑进程里这些 Map 只增不减——且 `waitIdle`
  *    在 agent 先被销毁时永不结算。
  *
- * ② **插件卸载/HMR/profile 重载 → 停掉自起的监听器与轮询器**。skiff 调试页、微信桥轮询
+ * ② **插件卸载/HMR/profile 重载 → 停掉自起的监听器与轮询器**。轨迹约束调试页、微信桥轮询
  *    都是 dsp 自己起的资源（⚠️ 2026-10-15：原同批还有 ACP HTTP 端点，该面已退役）；
  *    此前没有 `ctx.effect` 拆卸，卸载后端口仍被占用（EADDRINUSE）、轮询器重复启动。
  *