@shgroup/dsh-serenity-hooks 1.104.0 → 1.107.0

package/lib/invariant.js

@@ -147,10 +147,9 @@ const REGISTERED_TOOLS = [
 	"localstore",
 	"container_admin",
 	"im-bridge",
-	"acc-diag",
 	"diagram"
 ];
 /** 条件出现的工具数（`REGISTERED_TOOLS` 的**末段**；`assertManifestProse` 用） */
-const CONDITIONAL_TOOL_COUNT = 3;
+const CONDITIONAL_TOOL_COUNT = 2;
 //#endregion
 export { CONDITIONAL_TOOL_COUNT, REGISTERED_TOOLS, assertManifestProse, verifyToolConsistency };

package/lib/kernel/ccc.d.ts

@@ -126,13 +126,45 @@ interface SerenityConfig {
      */
     im?: ImSettings;
     /**
-     * 专属工具声明（v1.33，S142 §32.11）：**ACC 注册但默认对所有 CCC 隐藏**的工具，
-     * 只有在自己这里声明的 CCC 可见（例：`["acc-diag"]` = ACC 负责人的运行态诊断）。
+     * 轨迹消息订阅（v1.107.0，owner 2026-11-01 令）：
+     * **观察者盯一组成员，任一成员「一轮结束」就通知观察者**。
      *
-     * 归属判据（D23）：**机制在 ACC（通用，任何工具名皆可），声明在 CCC**——
-     * ACC 代码里不出现任何具体 CCC 的名字；未声明（含未配置/配置损坏）⇒ 隐藏。
+     * 🔴 **这是通知，不是控制**（owner 原话「loose notification, not control」）：
+     * 观察者收到的是「某人刚干完一轮活儿」，**不带他干了什么**（owner：「不需要带它做了什么」），
+     * 也不赋予它任何指挥权。要不要看、看了做什么，全由观察者自己决定。
+     *
+     * ## 三件必须固定的语义
+     *
+     * 1. **「一轮结束」的判据 = `agent.status` 由 running → idle**（`cro/turns.ts` D244 已定死：
+     *    `agent/turn-stopping` 是**暂停点**不是轮结束，⛔ 不得用它）。因此本机制**复用**那条事件，
+     *    不新造判据 —— 两个判据并存会立刻分叉。
+     * 2. **频率不设上限**：结束了就通知（owner：「不设定上限，结束了就通知」）。
+     *    ⚠️ 但**不额外防抖**是有依据的：`agent/status` 只在**真实状态跃迁**时发
+     *    （宿主 `AgentLoop.setPhase`，见 `cro/turns.ts` 文件头），所以"抖动"不会发生。
+     * 3. **目标的三种失败面各自显形**（见 `trajectory/subscriptions.ts` 文件头的失败面表）：
+     *    成员解析不出轨迹 / 观察者唤不醒 / 投递失败 —— ⛔ 一个都不许静默。
+     *
+     * ⚠️ **与 CRO 的区别**（别混）：CRO 是「**自己**决定要不要把自己叫起来」（自编程）；
+     * 本节是「**别人**干完活了，告诉我一声」（互观察）。两者都走唤醒链路，但**主语相反**。
      */
-    exclusiveTools?: string[];
+    trajectorySubscriptions?: TrajectorySubscription[];
+}
+/**
+ * 一条轨迹消息订阅：`watcher` 观察 `members`。
+ *
+ * 🔴 **方向性是本结构唯一容易写反的地方**：`watcher` 是**收通知的那个**，
+ * `members` 是**被盯的那组**。写反了照样能跑、只是通知发给了错误的人 —— 没有机械信号，
+ * 所以字段名取"谁看/看谁"而不是"a/b"（D150 同族：字面要能自证方向）。
+ */
+export interface TrajectorySubscription {
+    /** 收通知的轨迹（`S###` 或 AGENT_SESSIONS 目录名） */
+    watcher: string;
+    /** 被观察的轨迹清单（同上格式） */
+    members: string[];
+    /** 这条订阅是否生效（缺省 true —— 写了就是要用） */
+    enabled?: boolean;
+    /** 通知正文里对这个订阅的一句话说明（可选；用于让观察者分辨是哪条订阅触发的） */
+    note?: string;
 }
 /**
  * 🔴 **统一 IM 配置（2026-10-19 owner 定向：「飞书和微信一样，只不过是 account 方实现不同。
@@ -315,24 +347,39 @@ export declare function readUtf8(path: string): string;
  */
 export declare function loadSerenityConfig(root: string, paths?: string[]): SerenityConfig;
 /**
- * 读取 CCC 声明的「专属工具」清单（`exclusiveTools`，v1.33）。
+ * （已删除）`readExclusiveTools` —— v1.106.0 随 `exclusiveTools` 机制整体删除。
+ * 原语义：读 CCC 声明的专属工具清单，fail-closed（读不到 ⇒ 空数组 ⇒ 专属工具保持隐藏）。
+ * 删除理由见 `SerenityConfig.exclusiveTools` 处的注释（表空 ⇒ 不可证伪）。
+ */
+/**
+ * 读取 CCC 声明的轨迹消息订阅表（`trajectorySubscriptions`，v1.107.0）。
+ *
+ * ## 失败方向 = **fail-open，但坏项逐条报告**（与另外两处刻意不同）
+ *
+ * 不订阅 ≠ 危险动作：它只是"没有通知"，不会藏掉任何能力（对比 `safeMode.hiddenTools`
+ * 是 fail-open 因为**隐藏**才是危险方向）。⇒ 整体读不到 ⇒ 空表。
+ *
+ * 🔴 **但"坏项"不能一起吞掉**：配置里写了这一条、却因为成员名写错而**永远不触发**，
+ * 是与 `safeMode.hiddenTools` 写错工具名**同族的静默失效**（写了但不生效，且没人知道）。
+ * ⇒ 本函数返回 `{ subs, problems }`：合法项照常生效，坏项进 `problems` 供调用方响亮告警。
+ * ⚠️ 这与"整表读不到就空表"并不矛盾：前者是**文件级**失败（无法解析），
+ * 后者是**条目级**失败（能解析但内容不成立）—— **两个粒度、两种处置**（D233 同族）。
  *
- * 失败语义：无配置/字段缺失/配置损坏 → **空数组**（= 不声明任何专属工具 ⇒ 专属工具保持隐藏）。
- * 这里选 **fail-closed**（与 im-bridge 的 fail-open 相反）的理由：专属工具的默认态就是"隐藏"，
- * 判据读不到 = 没有证据表明该 CCC 要它；而配置损坏本身已在 `loadSerenityConfig` 响亮告警
- * （不会静默）。im-bridge 相反——隐藏一个**已在使用**的通道才会静默损害能力。
  * @param root CCC 根
  * @param paths 候选配置相对路径
- * @returns 去空白后的工具名列表（非字符串项被丢弃）
+ * @returns `subs` = 干净的订阅表；`problems` = 逐条可读的坏项说明（空数组 = 全好）
  */
-export declare function readExclusiveTools(root: string, paths?: string[]): string[];
+export declare function readTrajectorySubscriptions(root: string, paths?: string[]): {
+    subs: TrajectorySubscription[];
+    problems: string[];
+};
 /**
  * 读取 CCC 声明的「安全模式期间隐藏的工具」清单（`safeMode.hiddenTools`，v1.51.4）。
  *
  * 语义（R↓）：**标记文件存在 ⇒ 才生效**。deny = `['bash', ...本清单]`（并集去重）；
  * 标记消失 ⇒ 连同 `bash` 一起解除（调用点在 `syncSafeModeRestriction`，与基础表同一处）。
  *
- * 失败方向 = **fail-open**（与 `exclusiveTools` 的 fail-closed 相反，理由不同）：
+ * 失败方向 = **fail-open**（与已删除的 `exclusiveTools` 的 fail-closed 相反，理由不同）：
  * 未配置 / 字段缺失 / 配置损坏 ⇒ **空数组** = 只隐藏基础表。本键是**附加**屏蔽，
  * 读不到声明就等于"没有证据要求多藏"；且**隐藏是危险方向**（藏掉 agent 真正要用的工具
  * 会静默损害能力），而配置损坏本身已有 `loadSerenityConfig` 的响亮告警（不静默）。

package/lib/kernel/invariant.d.ts

@@ -58,6 +58,6 @@ export declare function assertManifestProse(manifestPath: string, readmePaths: r
  * `review`（C 档，调引擎 `compliance`）／`index`（调 P1 的生成器）／`status` ⇒ **14**。
  * 同规格：**条件可见与否不影响这里列它**（本常量 = "插件**具备**的工具面"）。
  */
-export declare const REGISTERED_TOOLS: readonly ["container_fs", "cognitive_trajectory", "dashboard", "container_git", "msm", "praxis", "ontology", "serenity-skill-creator", "localstore", "container_admin", "im-bridge", "acc-diag", "diagram"];
+export declare const REGISTERED_TOOLS: readonly ["container_fs", "cognitive_trajectory", "dashboard", "container_git", "msm", "praxis", "ontology", "serenity-skill-creator", "localstore", "container_admin", "im-bridge", "diagram"];
 /** 条件出现的工具数（`REGISTERED_TOOLS` 的**末段**；`assertManifestProse` 用） */
-export declare const CONDITIONAL_TOOL_COUNT = 3;
+export declare const CONDITIONAL_TOOL_COUNT = 2;

package/lib/message-source-BTIe2cVO.js

@@ -0,0 +1,254 @@
+import { r as cccRootForCwd } from "./ccc-roots-DPMwBywc.js";
+import { T as sessionsRoot, a as readBindDeclaration, b as parseTrajectoryCode, h as getLastActiveSessionInfo, i as listBindDeclarations, m as getActiveSessionInfo, r as isBindUsable, t as claimBinding, w as sessionEvents } from "./bind-file-B0TuOP89.js";
+import { join } from "node:path";
+//#region src/trajectory/bound.ts
+/**
+* trajectory/bound.ts — 「会话 ↔ 认知轨迹」绑定（**2026-10-20 重做：归属 = 轨迹自己的交代**）
+*
+* ## 判决 D172（owner 2026-10-20 原话，这是整个文件的设计依据）
+*
+* > 「**认知轨迹自己交代永远是最好的交代**」
+* > 「绑定表是没有意义的，绑定关系必须**运行时按照规则探测**，绑定表本质就搞成**第二真相源**了」
+* > 「依赖文件系统…每个认知轨迹目录内放一个 `current.dsh_session_bind`，**以这个为绑定真相源**」
+* > 「文件里写的 sessionId **可能已经不存在了**，这个情况下就**视同没绑定**，就正确了」
+*
+* ## 旧形态为什么错（不是"性能不够"，是"真相源放错地方"）
+*
+* 旧实现用 **`.bindings.json` ＋ 宿主存储域** 两张旁路索引记录"谁承载谁"。
+* 它们是**旁路**：描述的对象（轨迹目录）与自己分离 ⇒ 一旦不一致就要写代码对账，
+* 而**对账失败没有任何机械信号**（本轨反复踩的形状：症状与真因在读数上完全不像）。
+*
+* 新形态：归属写在**轨迹目录自己里面**（`current.dsh_session_bind`）。
+* 判据不再是"表里有没有一条记录"，而是"**这一刻谁真的在承载它**"。
+*
+* ## 🔴 三条不变量（前两条由**形态**保证，第三条由**探针**保证）
+*
+* | # | 不变量 | 保证方式 |
+* |---|---|---|
+* | 1 | 一条轨迹**至多一个**当前载体 | 它是**一个文件**，写入即整体原子覆盖 |
+* | 2 | 一个载体**至多一条**轨迹 | 写入前扫全部轨迹的交代，该 id 已在别处 ⇒ **拒绝** |
+* | 3 | **会话不存在 ⇒ 视同没绑定** | `isBindUsable(decl, alive)`（探针由调用方给） |
+*
+* ⚠️ 旧的 `supersededAt`（"只留一条"靠标记退掉）**整条退役**：标记可以忘，覆盖不会忘。
+* 存量里带 `supersededAt` 的记录在迁移时**直接跳过**（它们本就不是"当前"）。
+*
+* ## 零依赖与不抛
+* 读函数**永不抛**；写函数返回布尔 / 结构化结果，由调用方决定如何呈现。
+*/
+/**
+* 从 dsh 会话对象取 `header.id` / `header.cwd`。
+* @returns 取不到 ⇒ `null`
+*/
+function sessionHeader(session) {
+	const header = session?.header;
+	if (!header || typeof header !== "object") return null;
+	return header;
+}
+/** 由会话对象定位 CCC 根（上溯 `.serenity`）；定位不到 ⇒ `null` */
+function rootOf(session) {
+	const cwd = sessionHeader(session)?.cwd;
+	if (typeof cwd !== "string") return null;
+	return cccRootForCwd(cwd);
+}
+/** 目录名 → 轨迹标签（固定位置编码；非本工具建的目录回退整名——编码无关 U4） */
+function cognitiveTrajectoryLabel(dirName) {
+	return parseTrajectoryCode(dirName) ?? dirName;
+}
+/**
+* 把一条「轨迹自我交代」投影成对外的 `SessionBoundRecord`。
+*
+* 🔴 **`sessionId` 的语义在这里对齐**：旧记录里 `sessionId` 是**展示码**（`S###`），
+* 新绑定文件里是**dsh 会话 id**（它是硬锚）。历史调用方有两类读法，故两个字段都给：
+*  · `sessionId` → **dsh 会话 id**（新语义，硬锚）
+*  · `sessionId2` → 展示码（由轨迹目录名派生；旧语义）
+* 这样"我要这个会话的 id"与"我要显示成 S###"各自有确定字段，不再靠猜。
+*/
+function toRecord(dirName, decl, root) {
+	return {
+		dirName,
+		mdPath: join(root, "AGENT_SESSIONS", dirName, "SESSION.md"),
+		sessionId: decl.sessionId,
+		sessionId2: cognitiveTrajectoryLabel(dirName),
+		at: decl.at,
+		action: decl.action,
+		...decl.note !== void 0 ? { note: decl.note } : {},
+		...decl.createdAsUser === true ? { createdAsUser: true } : {}
+	};
+}
+/** @deprecated D172：存储域已退役；保留为空实现，装载期调用点无需改动 */
+function setBindingStore(_store) {}
+/**
+* 读**这个会话**当前承载哪条轨迹（正向：会话 → 轨迹）。
+*
+* 判据（D172）：扫全部轨迹的自我交代，找 `sessionId === 本会话 id` 且**仍然 usable** 的那条。
+*
+* 🔴 为什么这里是"扫"而不是"查表"：**归属是算出来的，不是记下来的**。
+* 本 CCC 的轨迹数是**数十**量级，每次读盘只读每个目录里的一个小文件；比维护一份会漂的索引便宜。
+*
+* ⚠️ **不验"会话是否还活着"**：本函数回答的是"这个**活着的**会话属于谁"——
+* 调用方手里就拿着那个会话对象，它显然存在。`alive` 探针只在**反向**（轨迹 → 会话）才需要。
+*
+* @returns 记录（含 `dirName` / `mdPath` / dsh `sessionId`）；无 ⇒ `null`
+*/
+function readLastBound(session) {
+	const id = sessionHeader(session)?.id;
+	const root = rootOf(session);
+	if (typeof id !== "string" || id === "" || root === null) return readLegacyBoundFromEvents(session);
+	for (const { dirName, decl } of listBindDeclarations(sessionsRoot(root))) if (decl.sessionId === id) return toRecord(dirName, decl, root);
+	return readLegacyBoundFromEvents(session);
+}
+/** 旧形态事件类型（v1.29.1~v1.30.5 写入会话日志；只读兼容，**永不写**） */
+const SESSION_BOUND_EVENT = "serenity/bound";
+/** 从会话日志扫最后一条 `serenity/bound`（兼容存量；坏记录跳过） */
+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 d = ev.data;
+		if (!d || typeof d.dirName !== "string" || typeof d.mdPath !== "string") continue;
+		return {
+			dirName: d.dirName,
+			mdPath: d.mdPath,
+			sessionId: typeof d.sessionId === "string" ? d.sessionId : "",
+			at: typeof d.at === "number" ? d.at : 0,
+			action: typeof d.action === "string" ? d.action : "activate"
+		};
+	}
+	return null;
+}
+/**
+* **调用方自身**所属轨迹的标签（审计字段 `createdBy` 的唯一正解）。
+*
+* 三级来源（逐级回退，理由见旧实现注释与 S142 §30.12.1 实测）：
+*  1. `readLastBound(session)` —— 持久归属（重启存活）
+*  2. `getActiveSessionInfo(scope)` —— 本会话的内存激活（按 scope 隔离）
+*  3. `getLastActiveSessionInfo()` —— 全局最近激活指针（最后兜底）
+*/
+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 ?? "";
+}
+/**
+* 反向查：**此刻**承载某条轨迹的 dsh 会话 id（按 `at` 倒序，最新在前）。
+*
+* D172 起判据 = **轨迹自己的交代 ＋ "那个会话还在"**：
+*  · 文件不存在 ⇒ 没绑定
+*  · 文件在但 `alive` 说不存在 ⇒ **视同没绑定**（owner 原话），**不算候选**
+*
+* ⚠️ **`alive` 缺省时怎么判**：调用方没给探针 ⇒ 只能信文件（`usable`）。
+* 那是"读不到宿主事实"的降级，**不是**"会话一定在"。需要严格判的一方请显式传探针
+* （唤醒选人是这种：见 `wake/scheduler.ts`）。
+*
+* 🔴 **2026-10-20（owner 裁决）：生产调用点必须传探针，两个调用点都已接上。**
+* 缺省分支**保留**只为两件事：① 既有单测的向后兼容；② 诊断面"只读文件"的显式用法。
+* ⛔ 不要新增不传探针的生产调用点 —— 那等于把"归档会话算活"的漏洞再开一次
+* （本仓同族已踩：`carrierState` ＋ CRO 快照两处都漏传过）。
+* 生产一律用 `trajectory/alive.ts` 的 `hostAliveProbe(ctx)`（判据 ＝ owner 定的
+* 「① 进程内 loaded ∨ ② 日志在且未被归档」）。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @param alive 探针：该 dsh 会话 id 此刻是否真实存在
+* @returns 会话 id 列表（本形态**至多一条**——一个文件只装一个 id）；无 ⇒ `[]`
+*/
+function listBoundSessionIds(root, dirName, alive) {
+	const decl = readBindDeclaration(join(sessionsRoot(root), dirName));
+	if (decl === null) return [];
+	return (alive ? isBindUsable(decl, alive).state === "usable" : isBindUsable(decl, () => true).state === "usable") ? [decl.sessionId] : [];
+}
+/**
+* 把一条轨迹的当前载体写成 `sessionId`（**唯一写入口**，内部走 `claimBinding` 的两条不变量）。
+*
+* 旧签名 `appendBound(session, action, rec)` 保持不变：`session` 提供 `header.id` / `header.cwd`，
+* `rec.dirName` 指明写哪条轨迹的交代。
+*
+* @returns 写入成功 ⇒ `{ ok: true, replaced?, released? }`（**每条轨迹只有一个文件，没有"追加"语义，只有"覆盖"**）；
+*          失败 ⇒ `{ ok: false, code, detail }`，**`code` 指名是哪一条守卫拒的**
+*
+* 🔴 **为什么从 `boolean` 改成分级结果（2026-10-20，一条 skiff 轨迹实测逼出）**：
+* 本函数有**两条完全不同的失败路径** —— ① header 守卫（id / root 取不到）② `claimBinding` 拒绝
+* （`SESSION_TAKEN` / `TRAJECTORY_OCCUPIED` / `WRITE_FAILED`）。日志侧早已分开（D186），
+* **但回执侧只有一句 header 文案** ⇒ 调用方被指向错误的方向（那位实测者第一轮就照文案去找 header，
+* 真因是槽位被占）。⇒ 结果必须**带码**，让回执能说出是哪一半。
+*/
+function appendBound(session, action, rec) {
+	const id = sessionHeader(session)?.id;
+	const root = rootOf(session);
+	if (typeof id !== "string" || id === "" || root === null) {
+		const detail = `会话对象取不到可用的 header（id=${typeof id === "string" && id !== "" ? id : "(空/非字符串)"}，root=${root ?? "null（header.cwd 缺失或上溯不到 .serenity）"}） ⇒ 轨迹「${rec.dirName}」的 current.dsh_session_bind **未被改写**。 排查：该会话的 header.cwd 是否指向某个含 .serenity 的目录； 无 cwd 的会话（如某些程序性创建的载体）**不会**写绑定。`;
+		console.warn(`[serenity-hooks] ✗ 绑定未写入（SESSION_HEADER_UNRESOLVED）：${detail}`);
+		return {
+			ok: false,
+			code: "SESSION_HEADER_UNRESOLVED",
+			detail
+		};
+	}
+	const header = sessionHeader(session);
+	if (header?.origin === "subagent") {
+		const detail = `会话 ${id} 是 **subagent 子会话**（header.origin="subagent"${header.parentSession ? `，parentSession=${header.parentSession}` : ""}），不能作为轨迹「${rec.dirName}」的载体 ⇒ current.dsh_session_bind **未被改写**。\n  原因：子会话的消息投递权归宿主 subagent routing，ACC 唤醒/投递会被宿主以 \`session/agent-busy\`（is owned by subagent routing）拒绝 ⇒ 该轨迹**每一条**到点唤醒都送不出去。
+  正确做法：在**根会话**（不是子会话）里执行 cognitive_trajectory use。`;
+		console.warn(`[serenity-hooks] ✗ 绑定未写入（SESSION_IS_SUBAGENT）：${detail}`);
+		return {
+			ok: false,
+			code: "SESSION_IS_SUBAGENT",
+			detail
+		};
+	}
+	const result = claimBinding(sessionsRoot(root), rec.dirName, {
+		sessionId: id,
+		at: Date.now(),
+		action,
+		...rec.note !== void 0 ? { note: rec.note } : {},
+		...rec.createdAsUser === true ? { createdAsUser: true } : {}
+	}, {
+		takeover: rec.takeover === true,
+		...rec.alive !== void 0 ? { alive: rec.alive } : {}
+	});
+	if (!result.ok) {
+		console.warn(`[serenity-hooks] ✗ 绑定未写入（${result.code}）：${result.detail}`);
+		return {
+			ok: false,
+			code: result.code,
+			detail: result.detail
+		};
+	}
+	return {
+		ok: true,
+		...result.replaced === void 0 ? {} : { replaced: result.replaced },
+		...result.released === void 0 ? {} : { released: result.released }
+	};
+}
+/**
+* 这条轨迹**是否曾经有过载体**（判"要不要允许自建"）。
+*
+* 🔴 这是 owner 第 2 条的判据来源：**"绑定表空"≠"从未有过会话"**。
+* 旧实现拿"未退的绑定条目为空"当"没绑定"，于是一条轨迹的载体被退掉之后就
+* 又长出一个新的（实测：S196 在同一分钟出现第二个载体）。
+*
+* 新判据 = **轨迹目录里有没有交代文件**（哪怕它指向的会话已不存在 ⇒ 有过，就不再自动建）。
+*
+* @returns `'never'`（从未有过 ⇒ 允许自建）／`'occupied'`（有过 ⇒ 禁止自建）／`'live'`（此刻有效）
+*/
+function carrierState(root, dirName, alive) {
+	const decl = readBindDeclaration(join(sessionsRoot(root), dirName));
+	if (decl === null) return { state: "never" };
+	return isBindUsable(decl, alive).state === "usable" ? {
+		state: "live",
+		sessionId: decl.sessionId
+	} : {
+		state: "occupied",
+		sessionId: decl.sessionId
+	};
+}
+//#endregion
+//#region src/kernel/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 { listBoundSessionIds as a, setBindingStore as c, carrierState as i, PLUGIN_SOURCE as n, readLastBound as o, appendBound as r, resolveSessionCognitiveTrajectoryLabel as s, ACC_MESSAGE_KIND as t };

package/lib/observation-BWpkA865.js

@@ -0,0 +1,210 @@
+import { d as readCccName, i as findGitRoot, l as pathInside, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS } from "./ccc-BmpE3cQz.js";
+import { u as ACC_VERSION } from "./rules-BLkYTPUy.js";
+import { i as readDshVersion, t as hostContractReport, v as checkRegistryQuality } from "./contract-BiNzzd77.js";
+import { g as listWakes, i as wakeSchedulerState } from "./scheduler-B0pB9mxI.js";
+import { resolve } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+//#region src/surface/observation.ts
+/**
+* surface/observation.ts — 容器状态模型的**取数层唯一出口**（C5「观察面归一」，S142 2026-09-15）
+*
+* 为什么存在（R↓）：ACC 有多个观察面（`dashboard health` / `acc-diag` / WebUI 面板 /
+* 系统提示词注入），它们读的是同一批宿主事实。此前"这些事实怎么取"写在**每个消费方各自的
+* 函数体里**——同一份状态有几个读者就有几处取数代码。本模块把取数收成一个出口，消费方只留
+* **渲染**（薄渲染）。
+*
+* 本模块**只做取数 + 形状**（设计红线）：
+*  - **文案/格式归渲染点**。本模块给判据与事实（`rooted: true` / `configPath: '.opencode/serenity.json'`），
+*    **不给**人读句子（"✓ .serenity marker found"）。同一份事实在 `dashboard health` 与 `acc-diag`
+*    里的措辞不同，正是因为它属渲染。
+*  - **不合并两条 registry 判据**（见 {@link checkRegistryHealth} / {@link checkRegistryQuality} 的对照注释）。
+*  - **时钟读进程内模块级快照**（{@link containerClocks}）——**不重算**：调度器的武装态/计数只存在于
+*    其模块级运行时对象里，任何"重新推导"得到的都是与真实调度器不一致的假值。
+*
+* 依赖分层（为什么本模块"重"而 `kit-ops` / `status` 保持"轻"）：
+*  {@link containerClocks} 必须读 `wake-scheduler` 的进程内快照，而该模块带 **@deepseek-ai 值依赖**
+*  （`dsh-llm` 的 `createUserMessage`）。故本模块**只能**被本就重型或异步的消费方使用：
+*  `diag-ops`（静态 import）、`surface/http.ts` / `kit-ops`（`await import(...)`，与 `surface/http.ts` 既有的
+*  "保持静态链纯净"约定一致）。**轻链模块不得静态 import 本模块**。
+*
+* 已有的单一真相源继续指向原处（**不复制**）：
+*  L0 根解析 `kernel/ccc.ts findSerenityRoot`｜L1/L2 根与枚举 `kernel/ccc-roots.ts`｜宿主契约 `host/contract.ts`
+*  ｜CCC 配置 `kernel/ccc.ts loadSerenityConfig`｜注册表 `tools/msm/service.ts`｜时钟 `wake/scheduler.ts`
+*  ｜唤醒注册表 `wake/registry.ts`。
+*/
+/** 身份/版本段取数（版本自省是磁盘/常量事实，与 CCC 内容无关） */
+function containerIdentity(root) {
+	return {
+		root,
+		ccc: root ? readCccName(root) : null,
+		accVersion: ACC_VERSION,
+		dshVersion: readDshVersion(),
+		nodeVersion: process.version
+	};
+}
+/**
+* 三原则取数。
+* ⚠️ 与 `kernel/ccc.ts` 的 P1/P2 原语是**同一实现**（`existsSync(.serenity)` / `findGitRoot`），
+* 本函数只把它们组装成"一次检查"的形状；判定语义未变（P1 要求文件非空、P2 要求 `.git` 存在）。
+*/
+function containerPrinciples(root) {
+	const serenityPath = root ? resolve(root, ".serenity") : null;
+	const rooted = serenityPath !== null && existsSync(serenityPath) && statSync(serenityPath).size > 0;
+	const gitRoot = root ? findGitRoot(root) : null;
+	const gitManaged = gitRoot !== null;
+	let configPath = null;
+	if (root) {
+		for (const candidate of DEFAULT_SERENITY_CONFIG_PATHS) if (existsSync(resolve(root, candidate))) {
+			configPath = candidate;
+			break;
+		}
+	}
+	return {
+		rooted,
+		gitManaged,
+		gitRoot,
+		configPath,
+		allPass: rooted && gitManaged && configPath !== null
+	};
+}
+/**
+* **判据 A —— 注册表「结构完整性」**（原 `tools/kit/service.ts checkRegistryHealth`，C5 迁入本模块）。
+*
+* 回答的问题：**这张表坏没坏**——文件能不能被安全解析（JSON 合法 / 顶层形状 / entry 字段类型 /
+* name 全局唯一 / path 在根内且脚本存在）。
+*
+* 🔴 **为什么不与 {@link checkRegistryQuality} 合并**（设计红线，取证见
+* `acc-c4c5-current-state.md` §⑥ 与 §⑤ 观察面 4/5）：两条判据的**主语不同**——
+*  - A 的主语是**文件**："解析它会不会炸"。它**绝不**因为某个 entry 的脚本缺测试文件而报 issue；
+*  - B 的主语是**条目契约**："这条 entry 符合 MSM 的质量规约吗"（DC-M1~M4）。
+*
+* 因此**同一份注册表上两条判据可以给出相反结论**（例：结构完全合法，但没有一条 entry 达标；
+* 或条目全达标，而表里有同名重复 entry）。合并成一个 `ok` 会把"表坏了（要 git restore）"与
+* "表没坏但条目欠火候（去写测试）"两种**修复动作完全不同**的故障压成同一个信号。
+*
+* health 必须**不因坏表抛错**（注册表坏 → `loadMsmEntries` 抛 → `container_admin`/`output-guard`
+* 全崩且自锁无法自救），故本判据独立解析，不走 `loadMsmEntries`。
+*/
+function checkRegistryHealth(root) {
+	const cccName = readCccName(root);
+	if (!cccName) return {
+		path: null,
+		ok: true,
+		present: false,
+		issues: []
+	};
+	const rel = `.opencode/skills/${cccName}/references/mech-registry.json`;
+	const abs = resolve(root, rel);
+	if (!existsSync(abs)) return {
+		path: rel,
+		ok: true,
+		present: false,
+		issues: []
+	};
+	const issues = [];
+	let raw = "";
+	try {
+		raw = readFileSync(abs, "utf-8");
+	} catch (err) {
+		return {
+			path: rel,
+			ok: false,
+			present: true,
+			issues: [`registry unreadable: ${String(err?.message ?? err)}`]
+		};
+	}
+	let data;
+	try {
+		data = JSON.parse(raw.replace(/^\uFEFF/, ""));
+	} catch (err) {
+		return {
+			path: rel,
+			ok: false,
+			present: true,
+			issues: [`registry JSON is broken: ${String(err?.message ?? err)}`, `Fix: restore from git — register/deregister auto-commits the registry (git checkout -- ${rel}; or git restore ${rel})`]
+		};
+	}
+	const entries = Array.isArray(data) ? data : data?.entries;
+	if (!Array.isArray(entries)) return {
+		path: rel,
+		ok: false,
+		present: true,
+		issues: ["registry top-level is neither an array nor a v1 wrapper with entries[]", `Fix: restore from git (git checkout -- ${rel}; or git restore ${rel})`]
+	};
+	const names = /* @__PURE__ */ new Set();
+	for (let i = 0; i < entries.length; i++) {
+		const e = entries[i];
+		if (typeof e !== "object" || e === null) {
+			issues.push(`entry[${i}] is not an object`);
+			continue;
+		}
+		if (typeof e.name !== "string" || e.name === "") issues.push(`entry[${i}]: name missing or not a string`);
+		if (typeof e.path !== "string" || e.path === "") issues.push(`entry[${i}] (${String(e.name ?? "?")}): path missing or not a string`);
+		if (e.skill !== void 0 && typeof e.skill !== "string") issues.push(`entry[${i}] (${String(e.name ?? "?")}): skill not a string`);
+		if (e.category !== void 0 && typeof e.category !== "string") issues.push(`entry[${i}] (${String(e.name ?? "?")}): category not a string`);
+		if (typeof e.name === "string" && e.name !== "") {
+			if (names.has(e.name)) issues.push(`duplicate MSM name: "${e.name}" (entry[${i}]) — loadMsmEntries dedups by name, ambiguity`);
+			names.add(e.name);
+		}
+		if (typeof e.path === "string" && e.path !== "") {
+			const scriptAbs = resolve(root, e.path);
+			if (!pathInside(resolve(root), scriptAbs)) issues.push(`entry[${i}] (${String(e.name ?? "?")}): path "${e.path}" escapes CCC root`);
+			else if (!existsSync(scriptAbs)) issues.push(`entry[${i}] (${String(e.name ?? "?")}): script not found at "${e.path}"`);
+		}
+	}
+	return {
+		path: rel,
+		ok: issues.length === 0,
+		present: true,
+		issues
+	};
+}
+/**
+* 时钟的进程内状态（"为什么这轮没被唤起"的第一手判据）。
+*
+* 🔴 **只读快照，不重算**（设计红线）：`armed`/`ticks`/`lastTickAt`/`lastSkipReason` 只存在于
+* 调度器自己的模块级运行时对象里（`wake/scheduler.ts schedulerRuntime`）。任何"从配置或文件
+* 重新推导"得到的值都会与真实调度器的状态不一致——那比没有可观测量更糟（会给出假的"一切正常"）。
+*/
+function containerClocks() {
+	return { wake: wakeSchedulerState() };
+}
+/** 唤醒注册表取数（文件 IO：每个渲染点自己决定是否要看它） */
+function containerWakes(root) {
+	const { entries, error } = listWakes(root);
+	return {
+		error,
+		entries,
+		pending: entries.filter((e) => e.state === "pending").length
+	};
+}
+/**
+* 核心段组装（`dashboard health` 的取数：身份 + 三原则 + 注册表两判据 + 配置 + 宿主契约）。
+*
+* 时间轴两段（时钟/唤醒注册表）**不在本组装内**：它们是各自独立消费方的需要
+* （`acc-diag` / 开发面诊断），硬塞进来会让只想看三原则的调用方付无谓的 IO。
+* 需要时按名字调 {@link containerClocks} / {@link containerWakes}。
+* （原第三段「autopilot 目标」及其取数函数 `containerAutopilot` 已随 ACC 侧 autopilot 退场删除。）
+*/
+function containerStatus(opts = {}) {
+	const root = opts.root ?? null;
+	const configPaths = opts.configPaths ?? DEFAULT_SERENITY_CONFIG_PATHS;
+	const identity = containerIdentity(root);
+	return {
+		identity,
+		principles: containerPrinciples(root),
+		registry: {
+			structure: root ? checkRegistryHealth(root) : {
+				path: null,
+				ok: true,
+				present: false,
+				issues: []
+			},
+			quality: opts.withRegistryQuality === true && root ? checkRegistryQuality(root) : null
+		},
+		config: root ? loadSerenityConfig(root, configPaths) : null,
+		hostContract: opts.hostCtx !== void 0 ? hostContractReport(opts.hostCtx, identity.dshVersion) : hostContractReport()
+	};
+}
+//#endregion
+export { containerClocks, containerStatus, containerWakes };