@shgroup/dsh-serenity-hooks 1.77.1 → 1.78.0

package/lib/index.js

@@ -1,12 +1,14 @@
 import { i as __toESM, n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
-import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-rwgzt_0F.js";
-import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, g as readUtf8, h as readSafeModeHiddenTools, i as findGitRoot, l as pathInside, m as readExclusiveTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readCognitiveTrajectorySkills, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-CyYJL4F2.js";
-import { A as sessionsRoot, B as localFileStamp, C as namingTitleFor, D as readTrajectoryUid, E as readActiveSessionMd, F as useSession, H as localIdStamp, I as TRAJECTORY_FILENAME, L as TRAJECTORY_LEGACY_FILENAMES, M as showSession, N as summarize, O as resolveSessionByTitle, P as trajectoryDescOf, R as readTrajectoryFile, S as listSessions, T as parseTrajectoryCode, V as localHuman, _ as extractSessionMdPathFromText, a as readTrajectoryConstraintAt, c as registerTrajectorySession$1, d as COGNITIVE_TRAJECTORY_ACTIONS, f as DEFAULT_SESSION_SCOPE, g as createSession, h as clearActiveSessionInfo, j as setActiveSessionInfo, k as sessionEvents$1, l as trajectoryDirNameForSession, m as archiveSession, n as isTrajectoryConstrained, o as readTrajectoryConstraintByCode, p as UID_FILENAME, r as listTrajectoryConstraints, s as trajectoryConstraintForSession, t as TRAJECTORY_CONSTRAINT_FILENAME, u as unregisterTrajectorySession$1, v as findSession, w as parseSessionContextFromEvents, x as listActiveTrajectories, y as getActiveSessionInfo, z as isoLocal } from "./profile-DplLGGqo.js";
-import { _ as runLocalStore, a as readFeishuCredential, d as weixinSessionIdForTrajectory, f as LOCALSTORE_SCOPES, g as readStore, h as readGitTrack, i as matchWeixinRoute, l as sanitizeFileName$1, m as localstorePath, n as extractWeixinText, o as readWeixinCredential, p as checkLocalstoreGitCompliance, r as hasVoiceItem, s as readWeixinSettings, t as extractWeixinMedia, u as weixinInboundDir } from "./route-COOFLTpU.js";
-import { a as buildTrajectoryBasePrompt, c as createProfilePromptReader, d as resolveConstraintSystemPrompt, f as ACC_VERSION, i as TRAJECTORY_CONSTRAINT_HINT, l as profileMsmWhitelist, n as readSimpleSettings, o as constraintCognitiveTrajectory, p as findPackageRoot, r as registerSettingsSection, s as constraintSystemPromptSource, u as profileToolWhitelist } from "./settings-f9WZXcgi.js";
-import { a as listBoundSessionIds, i as carrierState, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND } from "./message-source-CYa8LbbM.js";
+import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-D3ty1C8P.js";
+import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readSafeModeHiddenTools, i as findGitRoot, l as pathInside, m as readExclusiveTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-CyYJL4F2.js";
+import { A as sessionEvents, B as isoLocal, C as listSessions, E as parseTrajectoryCode, F as trajectoryDescOf, H as localHuman, I as useSession, L as TRAJECTORY_FILENAME, M as setActiveSessionInfo, N as showSession, O as readTrajectoryUid, P as summarize, R as TRAJECTORY_LEGACY_FILENAMES, S as listActiveTrajectories, T as parseSessionContextFromEvents, U as localIdStamp, V as localFileStamp, _ as createSession, a as readTrajectoryConstraintAt, b as getActiveSessionInfo, c as trajectoryConstraintForSession, f as COGNITIVE_TRAJECTORY_ACTIONS, g as clearActiveSessionInfo, h as archiveSession, j as sessionsRoot, k as resolveSessionByTitle, m as UID_FILENAME, n as isTrajectoryConstrained, o as readTrajectoryConstraintByCode, r as listTrajectoryConstraints, s as replacesDefaultIdentity, t as TRAJECTORY_CONSTRAINT_FILENAME, v as extractSessionMdPathFromText, w as namingTitleFor, y as findSession, z as readTrajectoryFile } from "./profile-C7BuyZK7.js";
+import { n as checkLocalstoreGitCompliance, o as readStore, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./service-DDmHSglV.js";
+import { _ as ACC_VERSION, a as listBoundSessionIds, d as constraintCognitiveTrajectory, f as constraintSystemPromptSource, g as resolveConstraintSystemPrompt, h as profileToolWhitelist, i as carrierState, l as TRAJECTORY_CONSTRAINT_HINT, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, v as findPackageRoot } from "./message-source-BOG0piL8.js";
+import { A as buildResourceIndex, C as verifyPassword, D as recordToolUsage, E as verifyTotpCode, F as hasTrajectoryPrompt, M as isSafeSkillName, N as truncateContent, O as REFERENCE_DIR, P as TRAJECTORY_PROMPT_FILENAME, S as toWire, T as MECHANISM_PORTS, _ as registerEntrySkillSectionGlobal, a as trajectoryConstraintFor, b as projectKnownWorkspaces, c as trajectoryWorkspaceMdPath, d as CHEAP_WORKER_GUIDE, f as providerAvailabilityError, g as registerEntrySkillSection, h as registerCognitiveTrajectorySkillSection, i as getTrajectoryAgent, j as buildResourceNameSuffix, k as SKILL_ONTOLOGY_FILE, l as unregisterTrajectorySession, m as splitModel, n as createTrajectoryAgent, o as trajectoryConstraintMsmGate, p as requireWhitelistedModel, r as ensureWorkspacePromptSection, s as trajectoryConstraintParticipates, t as askTrajectory, u as workspaceCognitiveTrajectoryLine, v as applyWirePatch, w as FACE_PORTS, x as readAdvancedSettings, y as migrateLegacyLocalstore } from "./session-BxDVrxPH.js";
 import { n as hasSessionLogById, r as sessionsRootDir } from "./cleanup-C-92qnDs.js";
+import { n as readSimpleSettings, r as registerSettingsSection } from "./settings-Bb4OnEdI.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
+import { a as readFeishuCredential, d as weixinSessionIdForTrajectory, i as matchWeixinRoute, l as sanitizeFileName$1, n as extractWeixinText, o as readWeixinCredential, r as hasVoiceItem, s as readWeixinSettings, t as extractWeixinMedia, u as weixinInboundDir } from "./route-Dr0SFD8A.js";
 import { c as sendTextMessage, i as getUpdates, l as sendTyping, n as downloadMedia, o as markdownToPlainText, r as getConfig, s as sendFileMessage, t as TypingStatus, u as sniffImageExt } from "./ilink-BMk2w2KY.js";
 import { a as registerImAccountImpl, i as normalizeAccountChannel, n as getImAccountImpl, r as imAccountChannels } from "./accounts-BHQbakUh.js";
 import { createRequire } from "node:module";
@@ -20,7 +22,7 @@ import { promisify } from "node:util";
 import { platform as platform$1 } from "node:process";
 import { fileURLToPath } from "node:url";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { createHash, createHmac, randomBytes, randomUUID, scryptSync, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { Resvg, initWasm } from "@resvg/resvg-wasm";
 import { createServer, request } from "node:http";
 import * as zlib from "node:zlib";
@@ -1897,2491 +1899,6 @@ async function runMsmAsync(root, args) {
 	}
 }
 //#endregion
-//#region src/trajectory/prompt.ts
-/**
-* trajectory/prompt.ts — **轨迹提示词**（Trajectory Prompt）：一条轨迹"是谁、按什么章程工作"
-*
-* ## 概念（owner 2026-10-19 定向，逐字）
-*
-* > 「参考会话的系统提示词，我们建立**轨迹提示词**概念来代替人格。架构上会好很多」
-*
-* **轨迹提示词** = 一条认知轨迹的**可编辑章程声明**，由 ACC 按固定顺序装配进系统提示词。
-* 三个关键词各是一条判据：
-* - **可编辑**：住在 CCC（盘上），改它**不发版**（D23 归属判据的直接推论）
-* - **声明**：它声明**身份／章程／方法论**，**不声明能力**（能力面归 `trajectory-constraint.json` 白名单与工具 schema）
-* - **固定顺序**：装配顺序由 ACC 定死（见 `seams/system-prompt.ts` 的 ⑧ 位）
-*
-* ## 为什么取代「人格」
-*
-* 「人格」把身份绑在"像不像一个人"上 ⇒ 因为叫人格，它被设计成**可以整体替换**
-* （`persona` 置换 EAP 块，即 review F-05/R-14 那个悬置冲突）。而身份与章程**不该被替换，
-* 只该被特化**。⇒ 本模块把"替换"改成"叠加"：容器层与质量层永远保留，轨迹提示词只往上加。
-*
-* ## 落点（为什么在轨迹目录里）
-*
-* `AGENT_SESSIONS/<轨迹目录>/PROMPT.md`
-*
-* - **跟着轨迹走**：`archive` 时整个目录搬走，章程不会掉队（旧形态 `.opencode/skiff/<name>.md`
-*   与轨迹**分居两处** —— 多条轨迹共用一份文件正是那个后果）。
-* - **每条轨迹都能有**：不只是 轨迹约束。普通轨迹同样需要"我是谁、按什么章程"。
-* - 与 `SESSION.md`（身体：延续/日志）、`trajectory-constraint.json`（约束面：能力）三件并列，
-*   各管一件事，不合并（合并会让"改能力"与"改身份"互相牵连）。
-*
-* ## 兼容（不静默坏）
-*
-* `PROMPT.md` 不存在时**不报错**（普通轨迹常态）。轨迹约束的旧字段 `systemPromptFile`
-* 在兼容期仍被读取——优先级见 {@link resolveTrajectoryPrompt}。
-*/
-/** 轨迹提示词的固定文件名（**判据就是它存在**——不是目录名前缀，也不是配置里的一行） */
-const TRAJECTORY_PROMPT_FILENAME = "PROMPT.md";
-/** 轨迹目录的 PROMPT.md 绝对路径（不论存在与否——调用方自己判存在性） */
-function trajectoryPromptPath(root, dirName) {
-	return join(sessionsRoot(root), dirName, TRAJECTORY_PROMPT_FILENAME);
-}
-/**
-* 该轨迹**有没有**轨迹提示词（单一判据）。
-*
-* 用途：兼容期的"让位"判定 —— 若已有 `PROMPT.md`，轨迹约束 旧字段 `systemPromptFile`
-* 必须**让位**，否则同一份章程会在两处各注入一遍（第 ⑧ 段 ＋ `serenity-轨迹约束` 段）。
-* 🔴 判据只有这一处：别在 轨迹约束那边自己拼路径再判（两处会漂）。
-*/
-function hasTrajectoryPrompt(root, dirName) {
-	try {
-		return existsSync(trajectoryPromptPath(root, dirName));
-	} catch {
-		return false;
-	}
-}
-/**
-* 轨迹提示词的**读取器**（长期热更新；改文件即生效，无需重启）。
-*
-* ## 为什么返回函数而不是字符串（R↓，实证代价）
-*
-* 旧实现把提示词**快照**进系统提示词段的闭包 ⇒ CCC 改了文件必须重启 dsh web 才生效
-* （实测：改完 18KB 提示词，live agent 仍用旧文本）。现形态由系统提示词段的 `text()`
-* **每轮调用**本读取器：按 **mtime + size** 缓存重读（命中缓存零 IO）。
-*
-* ## 三条失败语义（各治一个失败模式）
-*
-* - **文件不存在** ⇒ 返回空串（**不是错误**：普通轨迹没有章程是常态，且删掉即失效
-*   必须是立即可见的——这就是"删掉 PROMPT.md 即恢复默认"的机制）
-* - **读取失败** ⇒ 返回**上次成功内容**（⛔ 绝不返回空：空提示词会让轨迹失去章程），
-*   并按去重标签告警一次
-* - **首次就读不到** ⇒ 空串 ＋ 告警一次（区分"本来没有"与"有但读不了"）
-*
-* @param root CCC 根
-* @param dirName 轨迹目录名（**不是编码**：目录名才是落盘位置）
-*/
-function createTrajectoryPromptReader(root, dirName) {
-	const absPath = trajectoryPromptPath(root, dirName);
-	let cachedMtime = -1;
-	let cachedSize = -1;
-	let cachedText = "";
-	let warned = false;
-	return () => {
-		let st;
-		try {
-			st = statSync(absPath);
-		} catch (err) {
-			const code = err?.code;
-			cachedMtime = -1;
-			cachedSize = -1;
-			cachedText = "";
-			if (code !== "ENOENT" && !warned) {
-				warned = true;
-				console.warn(`[serenity-hooks] ✗ 轨迹提示词不可读（${absPath}）——按"没有章程"处理: ${String(err?.message ?? err)}`);
-			}
-			return "";
-		}
-		try {
-			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] ↻ 轨迹提示词已热重载（${TRAJECTORY_PROMPT_FILENAME}，${text.length} 字符）`);
-			return text;
-		} catch (err) {
-			if (!warned) {
-				warned = true;
-				console.warn(`[serenity-hooks] ✗ 轨迹提示词读取失败（${absPath}）——沿用上次成功内容: ${String(err?.message ?? err)}`);
-			}
-			return cachedText;
-		}
-	};
-}
-/**
-* 装配用的**提示词段**（幂等：无内容 ⇒ 空串，宿主会丢弃空 section/空块）。
-*
-* 标记头 `=== Serenity Trajectory Prompt ===`：
-* ① 让模型知道"下面是**这条轨迹自己的章程**"，不是容器规则；
-* ② 让诊断可以按块名 grep。
-*
-* 🔴 这段**追加**在容器层与质量层之后，**永不替换它们**——那正是本概念相对「人格」的核心修正。
-*/
-function trajectoryPromptBlock(text) {
-	const body = text.trim();
-	if (body === "") return "";
-	return [
-		"",
-		"=== Serenity Trajectory Prompt ===",
-		body,
-		""
-	].join("\n");
-}
-//#endregion
-//#region src/trajectory/carrier.ts
-/**
-* 等待 agent 空闲或销毁。
-* @param ctx 宿主插件上下文（事件通道来源；**结构化访问**，故类型为 `unknown`，见文件头 I2 段）
-* @param agent 目标 agent
-* @returns 空闲、agent 销毁、或会话销毁时结算（永不 reject）
-*/
-function waitAgentIdle(ctx, agent) {
-	return new Promise((resolve) => {
-		let settled = false;
-		const disposers = [];
-		const finish = () => {
-			if (settled) return;
-			settled = true;
-			for (const dispose of disposers) try {
-				dispose();
-			} catch {}
-			resolve();
-		};
-		const subscribe = (name, cb) => {
-			try {
-				const off = ctx.on?.(name, cb);
-				if (typeof off === "function") disposers.push(off);
-			} catch {}
-		};
-		subscribe("agent/status", (payload) => {
-			const p = payload;
-			if (p?.agent === agent && p?.status === "idle") finish();
-		});
-		subscribe("agent/disposed", (payload) => {
-			if (payload?.agent === agent) finish();
-		});
-		const sessionId = agent.session?.id;
-		subscribe("session/disposed", (session) => {
-			const id = session?.id;
-			if (typeof id === "string" && id === sessionId) finish();
-		});
-		if (agent.status === "idle") finish();
-	});
-}
-//#endregion
-//#region src/skills/discovery.ts
-/**
-* skills/discovery.ts — CCC 入口 skill 自动发现（纯逻辑，零 DSH 依赖）
-*
-* 发现全部入口技能（原文全量，不截断）—— **现行三个来源**（原为四个，**来源 3 已于 2026-09-21 删除**）：
-*   0. **`.serenity` 记号文件内容 = 顶层入口 skill 名**（CCC 记号文件的权威语义）—— 最高优先
-*   1. `.dsh/entry-skill` 指针文件（内容 = skill 名）—— 兼容旧约定
-*   2. `.opencode/skills/*-serenity/SKILL.md` —— 自动扫描该 CCC 的顶层入口
-*      （命名模式 `*-serenity`）
-*   ~~3. `.dsh/skills/*-serenity/SKILL.md`（扫 ACC 装进 CCC 的技能副本）~~ —— 🔴 **已删**：
-*      owner 2026-09-21 令「连模板和安装命令一起删」（B 案）。**判据、实测证据与日期逐字记在
-*      `findEntrySkills()` 体内那一段注释里**——本头部只留结论，**不复述判据**（避免两处会漂的真相源）。
-* 按名去重；顺序 = 记号文件 → 指针 → opencode 入口。
-*
-* 任何 CCC 都能自动注入其顶层入口 skill 全文（不硬编码名字）。
-*/
-/** 顶层入口命名模式：目录名以 -serenity 结尾（home-serenity / tg-serenity / acc-serenity …） */
-const SERENITY_SUFFIX = "-serenity";
-function isSerenityEntry(name) {
-	return name.endsWith(SERENITY_SUFFIX);
-}
-/** 扫描某 skills 根下所有 `*-serenity` 目录（含 SKILL.md 的） */
-function scanSerenityDirs(skillsRoot) {
-	if (!existsSync(skillsRoot)) return [];
-	return readdirSync(skillsRoot).filter((name) => isSerenityEntry(name)).map((name) => join(skillsRoot, name)).filter((dir) => statSync(dir).isDirectory() && existsSync(join(dir, "SKILL.md"))).sort();
-}
-/**
-* 防穿越：skill 名必须是简单目录名（拒绝分隔符与 `..`/`.` 路径段）。
-* v1.34.1：导出——轨迹 skill 声明（CCC 数据）的名字也要**先过这一关**才能用于拼路径
-* （规格 `docs/cognitive-trajectory-skill-injection.md` §3「名字安全（必做）」）。
-*/
-function isSafeSkillName(name) {
-	if (name.length === 0) return false;
-	if (name.includes("/") || name.includes("\\")) return false;
-	return !name.split(/[/\\]/).some((seg) => seg === ".." || seg === ".");
-}
-/**
-* 按名在两个 skills 根下定位 SKILL.md（`.dsh/skills` 优先，其次 `.opencode/skills`）。
-* v1.34.1：导出——轨迹 skill 注入复用本函数（不新造发现逻辑）；不安全名在此**先行拒绝**
-* （返回 null，且不发生任何以该名拼出的 fs 访问）。
-*/
-function findSkillMd(root, name) {
-	if (!isSafeSkillName(name)) return null;
-	for (const base of [".dsh", ".opencode"]) {
-		const p = resolve(root, base, "skills", name, "SKILL.md");
-		if (existsSync(p)) return p;
-	}
-	return null;
-}
-/** 发现全部入口技能（原文全量，不截断） */
-function findEntrySkills(root) {
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	const add = (path, source, forcedName) => {
-		if (!existsSync(path)) return;
-		const name = forcedName ?? basename(dirname(path));
-		if (seen.has(name)) return;
-		seen.add(name);
-		out.push({
-			name,
-			content: readFileSync(path, "utf-8"),
-			dir: dirname(path),
-			source
-		});
-	};
-	const marker = resolve(root, ".serenity");
-	if (existsSync(marker)) {
-		const name = readFileSync(marker, "utf-8").trim();
-		if (name) {
-			const md = findSkillMd(root, name);
-			if (md) add(md, "serenity-marker", name);
-		}
-	}
-	const pointer = resolve(root, ".dsh", "entry-skill");
-	if (existsSync(pointer)) {
-		const name = readFileSync(pointer, "utf-8").trim();
-		if (name) {
-			const md = findSkillMd(root, name);
-			if (md) add(md, "pointer", name);
-		}
-	}
-	for (const dir of scanSerenityDirs(resolve(root, ".opencode", "skills"))) add(join(dir, "SKILL.md"), "opencode");
-	return out;
-}
-function truncateContent(content, maxChars) {
-	if (content.length <= maxChars) return content;
-	return content.slice(0, maxChars) + `\n... (truncated, original length ${content.length} chars)`;
-}
-//#endregion
-//#region src/skills/resource-index.ts
-/**
-* resource-index.ts — **两层披露树的第二层**：skill 参考件索引（纯逻辑，零 DSH 依赖）
-*
-* 设计真相源：`docs/serenity-skill-design.md` §4.2（六条硬性规则）＋ §5.1（目录布局）。
-* 一句话：**把 skill 的参考件"有什么"告诉模型，但不把"是什么"塞进去** ——
-* 正文留给第三层（模型按需 `read`）。
-*
-* 为什么由我们生成（R↓，读宿主取证）：宿主 `@deepseek-ai/dsh-skill` 的 `renderSkillContent()`
-* （`lib/index.js` L57-81）**已经**产出 `<skill_resources>` 块，并逐字写着
-* "Load referenced resources only as needed." ⇒ **两层模型是宿主自己给的**；而
-* `SkillSummary` / `SkillDefinition` **没有任何列举子文件的位**（只有 `resourceBase` 一个基址）
-* ⇒ 宿主刻意留给 provider 的正是**这一半：枚举**。
-*
-* 六条硬性规则（逐条对应设计 §4.2，改这里先改那里）：
-*   ① **只枚举，不注入正文** —— 索引里**绝不**出现任何参考文件的正文；
-*   ② **确定性排序** = 相对路径的 **UTF-8 字节序**（🔴 **不用 mtime**：mtime 随检出漂移，
-*      会让每请求的注入文本抖动；对照 `src/cro/core.ts:101` 那份**落盘快照**用 {name,bytes,mtime} ——
-*      **同一件事两处的取舍相反，那个差异是判据不是巧合**）；
-*   ③ **有界 ＋ 响亮** —— 条数/字符各有上限，超出**必须显式写出还剩多少项**，**绝不静默截断**；
-*   ④ **摘要可复现** —— 取该文件首个 `#` 标题（剥 markdown 记号）；取不到 ⇒ 留空，**不编**；
-*   ⑤ **本体文件特殊标注** —— `skill.ttl` 存在 ⇒ 该行标 🧬 ＋ 顶部加一句"已建模"；
-*   ⑥ **范围 = `references/` 一级条目 ＋ `skill.ttl`** —— 子目录**给名字 ＋ 计数、不展开、不读正文**
-*      （🆕 2026-10-11 由**真实输入**逼出的修订：原写"不进子目录"，实测 `references/` 下确实有内容目录，
-*      只报"有 N 个子目录"不给名字 = **不可行动**；折中仍在裁决 Q2「只披露名字、不注入正文」的意图内）。
-*
-* 🔴 本文件**只认 `<skillDir>/skill.ttl`**（owner 裁决 Q6：静默、只认固定名）。
-*    `references/*-domain.ttl`（旧名）一律当**普通参考件**：不特殊对待、不告警 —— 那 14 份由 CCC 自行改名。
-* 🔴 「未建模」不是异常（裁决 Q6 ／ 判据 J9）：无 `skill.ttl` 的**普通 skill** 照常产出索引，
-*    **零告警、零误差** —— 增强必须对普通 skill 完全向后兼容。
-*
-* 🔴 **两个面，两个入口**（2026-10-12 增；owner 裁决 O2）—— 同源、但成本形态不同：
-*    · **载入面** `buildResourceIndex()` —— 完整索引（名字 ＋ 首标题 ＋ 字节），带 `.md` 文件头读取；
-*      在三条路径上各附一次：入口段（`system-prompt.ts` order −50）／轨迹段（`trajectory/skills.ts`
-*      order −45）／目录 provider 的 `get()`（`opencode-skills.ts`）。
-*    · **目录面** `buildResourceNameSuffix()` —— **只有名字**，**不读任何正文**；只挂一处：
-*      目录 provider 的 `list()`（`available_skills` 的 `SkillSummary.description`）。
-*      🔴 为什么目录面在这里：`SkillSummary` 契约里**没有列资源的位**（只有 name/description/whenToUse）
-*      ⇒ `description` 是唯一位置，且必须**自动生成**。
-*    ⇒ 两个面**共用** `collectEntries()`（范围 = 规则⑥只写一遍）。
-*/
-/** 第二层占位口：本 skill 的本体约束文件（固定名，设计 §5.1） */
-const SKILL_ONTOLOGY_FILE = "skill.ttl";
-/** 参考件根（一级；不进子目录） */
-const REFERENCE_DIR = "references";
-/** 摘要长度上限（防单行超长标题把表格撑坏） */
-const EXCERPT_MAX_CHARS = 60;
-/** 读文件头部字节数上限：摘标题只值读这么些（不为一行标题读整个大文件） */
-const HEAD_BYTES = 4096;
-/** 目录计数上限：防病态大树把一次注入拖慢（超出 ⇒ 报 `≥N`，仍然响亮） */
-const DIR_SCAN_MAX_FILES = 1e3;
-/**
-* 递归统计目录下的文件数与总字节（**只统计，不读内容**）。
-* 为什么递归：设计原写"不进子目录"，而**真实输入**显示 `references/` 下确有内容目录
-* （`home-rhetoric/references/corpus-subject-own`／`family-profiles/references/baby-handlebook`／
-* `home-serenity/references/diagram-lab`）⇒ 只报"有 N 个子目录"而**不给名字**是不可行动的。
-* 折中：**给名字 ＋ 计数，仍不展开、仍不读正文**（= 裁决 Q2「只披露名字、不注入正文」的意图内）。
-*/
-function scanDirStats(dir) {
-	let files = 0;
-	let bytes = 0;
-	let capped = false;
-	const walk = (d) => {
-		if (capped || files >= DIR_SCAN_MAX_FILES) {
-			capped = true;
-			return;
-		}
-		let names = [];
-		try {
-			names = readdirSync(d);
-		} catch {
-			return;
-		}
-		for (const name of names) {
-			if (files >= DIR_SCAN_MAX_FILES) {
-				capped = true;
-				return;
-			}
-			const abs = join(d, name);
-			let isDir = false;
-			let size = 0;
-			try {
-				const st = statSync(abs);
-				isDir = st.isDirectory();
-				size = st.size;
-			} catch {
-				continue;
-			}
-			if (isDir) walk(abs);
-			else {
-				files++;
-				bytes += size;
-			}
-		}
-	};
-	walk(dir);
-	return {
-		files,
-		bytes,
-		capped
-	};
-}
-/** 按 UTF-8 **字节序**比较两个相对路径（规则②；不是 locale 比较、不是 mtime）。
-*  参数放宽到 `{ key }`：**未加水**的条目与**已加水**的条目共用同一个比较器 ⇒ 排序规则只写一遍。 */
-function byByteOrder(a, b) {
-	return Buffer.compare(a.key, b.key);
-}
-/**
-* 千分位分组（规则②的延伸：**不依赖 locale**）。
-* 为什么不用 `toLocaleString()`：它随宿主 locale 变 ⇒ 同一目录在不同机器上产出**不同的注入文本**
-* （本仓已有一条「locale 稳健性」的挂账，不再添一处）。
-*/
-function groupThousands(n) {
-	return String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-}
-/**
-* 取 markdown 首个 `#` 标题作摘要（规则④）。
-*
-* 细节（都由"可复现"推导）：
-*   · **跳过 YAML frontmatter**（`---` 开头到下一 `---`）—— 否则题名行会被当成正文标题；
-*   · 只读文件**头部** `HEAD_BYTES`（一行标题不值得读整个大文件）；
-*   · 剥掉行内记号（`*` `` ` `` `_` `#`）与首尾空白，压平内部连续空白；
-*   · 取不到 ⇒ `''`（**留空，不编** —— 编一个摘要等于让索引说假话）；
-*   · 超长截断时**留省略号**（与规则③同一精神：截断要看得见）。
-*/
-function firstHeading(file) {
-	let head;
-	try {
-		head = readFileSync(file, "utf-8").slice(0, HEAD_BYTES);
-	} catch {
-		return "";
-	}
-	const lines = head.split(/\r?\n/);
-	let start = 0;
-	if (lines[0]?.trim() === "---") {
-		for (let i = 1; i < lines.length; i++) if (lines[i]?.trim() === "---") {
-			start = i + 1;
-			break;
-		}
-	}
-	for (let i = start; i < lines.length; i++) {
-		const m = /^#{1,6}\s+(.*)$/.exec(lines[i] ?? "");
-		if (!m) continue;
-		const clean = (m[1] ?? "").replace(/[*`_]/g, "").replace(/\s+/g, " ").trim();
-		if (clean === "") continue;
-		return clean.length > EXCERPT_MAX_CHARS ? `${clean.slice(0, 59)}…` : clean;
-	}
-	return "";
-}
-/**
-* 收集第二层的**条目**（范围 = 规则⑥：`references/` 一级条目 ＋ 固定名本体）。
-*
-* 🔴 **只做 `readdir` / `stat`，不读任何文件正文** —— 两个消费者（第二层索引 ／ 目录面的名字清单）
-*    **共用这一份范围定义**：规则⑥只该有一个家，各写一遍必然漂移。
-* 🔴 返回已按**字节序**排好（规则②：确定性，不用 mtime）。
-*/
-function collectEntries(skillDir) {
-	const entries = [];
-	const refDir = join(skillDir, REFERENCE_DIR);
-	if (existsSync(refDir)) {
-		let names = [];
-		try {
-			names = readdirSync(refDir).sort();
-		} catch {
-			names = [];
-		}
-		for (const name of names) {
-			const abs = join(refDir, name);
-			let isDir = false;
-			try {
-				isDir = statSync(abs).isDirectory();
-			} catch {
-				continue;
-			}
-			const rel = `${REFERENCE_DIR}/${name}`;
-			entries.push({
-				rel,
-				kind: isDir ? "dir" : "file",
-				abs,
-				ontology: false,
-				key: Buffer.from(rel, "utf-8")
-			});
-		}
-	}
-	const ontoAbs = join(skillDir, SKILL_ONTOLOGY_FILE);
-	if (existsSync(ontoAbs)) entries.push({
-		rel: SKILL_ONTOLOGY_FILE,
-		kind: "file",
-		abs: ontoAbs,
-		ontology: true,
-		key: Buffer.from(SKILL_ONTOLOGY_FILE, "utf-8")
-	});
-	entries.sort(byByteOrder);
-	return entries;
-}
-/**
-* 给条目**加水**（字节 ＋ 摘要）—— 这两项都要读盘，因此与"有哪些条目"分开。
-* 读不到 ⇒ `null`（宁可少列，也不列出读不到的项）。
-*/
-function hydrate(entry) {
-	if (entry.kind === "dir") {
-		const { files, bytes, capped } = scanDirStats(entry.abs);
-		return {
-			rel: entry.rel,
-			kind: "dir",
-			bytes,
-			excerpt: `子目录 · ${capped ? `≥${groupThousands(files)}` : groupThousands(files)} 个文件`,
-			ontology: false,
-			key: entry.key
-		};
-	}
-	let bytes;
-	try {
-		bytes = statSync(entry.abs).size;
-	} catch {
-		return null;
-	}
-	return {
-		rel: entry.rel,
-		kind: "file",
-		bytes,
-		excerpt: entry.rel.endsWith(".md") ? firstHeading(entry.abs) : "",
-		ontology: entry.ontology,
-		key: entry.key
-	};
-}
-/** 收集候选（`references/` 一级条目 ＋ 固定名本体），加好水并按字节序排好 */
-function collectItems(skillDir) {
-	const items = [];
-	for (const entry of collectEntries(skillDir)) {
-		const item = hydrate(entry);
-		if (item !== null) items.push(item);
-	}
-	return items;
-}
-/**
-* 生成第二层索引正文。
-*
-* @param skillDir skill 目录绝对路径
-* @param options 上限覆盖（缺省用本模块常量）
-* @returns 索引正文；**无可列项 ⇒ `''`**（规则⑥的一般化：`references/` 与 `skill.ttl` 都没有
-*          ⇒ 整块不产出 —— 空标题是噪声）。调用方按"空串不产出该块"处理。
-*/
-function buildResourceIndex(skillDir, options = {}) {
-	const maxItems = options.maxItems ?? 40;
-	const maxChars = options.maxChars ?? 4096;
-	const items = collectItems(skillDir);
-	if (items.length === 0) return "";
-	const modeled = items.some((i) => i.ontology);
-	const shown = items.slice(0, maxItems);
-	const hidden = items.length - shown.length;
-	const lines = ["### 本 skill 的参考件（第二层 · 按需读取）", "> 这里只有**清单**，没有正文：需要时用 `read` 打开下列路径（相对本 skill 目录）。"];
-	if (modeled) lines.push("> 🧬 **本 skill 已建模**：文字内容以 `skill.ttl` 为总约束。");
-	lines.push("", "| 文件 | 摘要 | 字节 |", "|---|---|---|");
-	for (const item of shown) {
-		const label = item.kind === "dir" ? `${item.rel}/` : item.rel;
-		const excerpt = item.ontology ? "🧬 本 skill 的本体约束（已建模）" : item.excerpt;
-		lines.push(`| ${label} | ${excerpt} | ${groupThousands(item.bytes)} |`);
-	}
-	if (hidden > 0) lines.push("", `…**还有 ${hidden} 项未列出**（本层单次上限 ${maxItems} 项）。`);
-	const body = lines.join("\n");
-	if (body.length <= maxChars) return body;
-	return `${body.slice(0, maxChars)}\n…(第二层索引已按 ${groupThousands(maxChars)} 字符上限截断，原文 ${groupThousands(body.length)} 字符)`;
-}
-/**
-* 收集**只有名字**的第二层清单（目录面专用）。
-*
-* 为什么单独一个入口（而不是复用 `buildResourceIndex`）：**成本形态不同** ——
-* 索引要给每个 `.md` 读文件头取摘要（规则④），而目录面是**每请求 × 每个 skill** 都要算的
-* ⇒ 这条路径**一个字节正文都不读**（只 `readdir`/`stat`）。
-* 范围仍与索引**同源**（共用 `collectEntries` ⇒ 规则⑥只有一个家）。
-*/
-function buildResourceNames(skillDir, options = {}) {
-	const maxItems = options.maxItems ?? 40;
-	const entries = collectEntries(skillDir);
-	const shown = entries.slice(0, maxItems);
-	return {
-		names: shown.map((e) => e.kind === "dir" ? `${basename(e.rel)}/` : basename(e.rel)),
-		hidden: entries.length - shown.length
-	};
-}
-/**
-* 目录面后缀：把名字清单拼成**可直接接在 `description` 后面**的一段文本。
-*
-* 🔴 **自动生成，绝不手写**（手写必与文件树漂）；无可列项 ⇒ `''`（**普通 skill 零噪声** —— 判据 J9）。
-* 🔴 **有界 ＋ 响亮**（规则③）：超上限时写出"另有 N 项"，**绝不静默截断**。
-*/
-function buildResourceNameSuffix(skillDir, options = {}) {
-	const { names, hidden } = buildResourceNames(skillDir, options);
-	if (names.length === 0) return "";
-	const tail = hidden > 0 ? ` …另有 ${hidden} 项` : "";
-	return `（参考件：${names.join(" / ")}${tail}）`;
-}
-//#endregion
-//#region src/trajectory/skills.ts
-/**
-* trajectory/skills.ts — 轨迹 skill 声明解析 + 注入内容装配（纯逻辑，零 DSH 依赖）
-*
-* 接口真相源：`docs/cognitive-trajectory-skill-injection.md` v1.0（§2 数据契约 / §3 注入契约）。
-* 一句话：**轨迹自己声明它要挂哪些 skill**（`SESSION.md` 顶部 YAML frontmatter 的 `skills:`），
-* ACC 在**绑定期间**把这些 skill 的 `SKILL.md` 全文注入系统提示词。
-*
-* 分工（R↓：为什么解析与注册分开）：
-*   · 本模块 = **纯文本层**（解析 / 装配 / 安全判定）——可脱离 DSH 单测；
-*   · `seams/system-prompt.ts` 的 `registerCognitiveTrajectorySkillSection` = **宿主接入层**
-*     （per-agent `ctx.systemPrompt.section`），只做门与注册，不再解析文本。
-*
-* 边界（规格 §2.2）：**不解析** `skills` 以外任何键的语义（CCC 可自由使用，ACC 视而不见）；
-* **不改写** frontmatter（ACC 只读）。
-*/
-/** 全文注入总长上限（字符数；规格 §3「缺省 32 KB」——防上下文爆炸） */
-const COGNITIVE_TRAJECTORY_SKILLS_MAX_CHARS = 32768;
-/** 缺失标记（规格 §3/§6-3 的验收锚点：任何"拿不到全文"的情况都必须带它，绝不静默）
-*  🔴 2026-09-25（S142 分批清死代码·第 1 批）：**降为模块内常量**——全仓唯一消费者在本文件，
-*  导出只服务测试（测试用的是字面量 `'[缺失]'`）⇒ 导出面无意义。 */
-const SKILL_MISSING_MARK = "[缺失]";
-/** 统一缺失提示（规格 §3 逐字约定：`[缺失] <name>（未找到该 skill）`） */
-function missingNotice(name) {
-	return `${SKILL_MISSING_MARK} ${name}（未找到该 skill）`;
-}
-/**
-* 抽取文件顶部 YAML frontmatter 区（规格 §2.1）。
-*
-* 规则：**第一行必须是 `---`**；到下一个 `---` 行为止是 frontmatter 区。
-* 首行不是 `---`，或没有闭合 `---` ⇒ 视为**无 frontmatter**（返回 null）。
-* 边界判断（R↓）：未闭合块按"无 frontmatter"处理而非吞掉整个文件——半个声明块是格式错误，
-* 猜它的意图等于把坏数据当好消息（宁可零注入，也不注入来路不明的半截列表）。
-*
-* @param content SESSION.md 全文
-* @returns frontmatter 区各行（不含两条 `---` 定界行）；无 → null
-*/
-function extractFrontmatter(content) {
-	const lines = content.split(/\r?\n/);
-	if (lines[0] !== "---") return null;
-	for (let i = 1; i < lines.length; i++) if (lines[i] === "---") return lines.slice(1, i);
-	return null;
-}
-/** 行内数组值 `[a, b, c]`（仅当首尾为方括号时视为行内数组；否则返回 null） */
-function parseInlineArray(value) {
-	const trimmed = value.trim();
-	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
-	return trimmed.slice(1, -1).split(",").map((s) => s.trim()).filter((s) => s !== "");
-}
-/**
-* 解析声明（规格 §2.1，**最小实现，不引 YAML 依赖**）。
-*
-* 只认 `skills:` 键；未知键一律忽略（向前兼容，不报错）。两种值形态都支持：
-*   ① 行内数组 `skills: [home-rhetoric, acc-eap]`
-*   ② 缩进列表（`skills:` 后各起一行 `  - a`）
-* 名字：去首尾空白、空项丢弃、**保持书写顺序**（注入顺序 = 书写顺序）、同名去重（保留首次位置）。
-*
-* 未定义形态（不在规格的两种值形态内，如 `skills: a` 裸标量）⇒ **视为无声明**：
-* 本函数只认契约里写明的两种形态，猜第三种等于自造契约（规格 §2.1 只列了 ①②）。
-*
-* @param sessionMd SESSION.md 全文
-* @returns 声明的 skill 名（按书写顺序去重）；无 frontmatter / 无 `skills` 键 / 值为空 → `[]`
-*/
-function parseDeclaredSkills(sessionMd) {
-	const fm = extractFrontmatter(sessionMd);
-	if (!fm) return [];
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	const push = (name) => {
-		const clean = name.trim();
-		if (clean === "" || seen.has(clean)) return;
-		seen.add(clean);
-		out.push(clean);
-	};
-	for (let i = 0; i < fm.length; i++) {
-		const line = fm[i] ?? "";
-		const m = /^skills\s*:(.*)$/.exec(line);
-		if (!m) continue;
-		const rest = (m[1] ?? "").trim();
-		const inline = parseInlineArray(rest);
-		if (inline) {
-			for (const name of inline) push(name);
-			continue;
-		}
-		if (rest !== "") continue;
-		for (let j = i + 1; j < fm.length; j++) {
-			const item = /^\s*-\s*(.*)$/.exec(fm[j] ?? "");
-			if (!item) break;
-			push(item[1] ?? "");
-		}
-	}
-	return out;
-}
-/** SESSION.md 绝对路径（绑定记录存的是绝对路径；非绝对态按 CCC 根解析——防御旧数据） */
-function absoluteMdPath(root, mdPath) {
-	return mdPath.startsWith(root) ? mdPath : resolve(root, mdPath);
-}
-/**
-* 注册门（规格 §3「无绑定 / 无声明 ⇒ 完全不注册该 section」）。
-*
-* 返回 true 的两种情况：
-*   · 文件在且**有非空声明** → 注册（有内容可注入）
-*   · 文件**不在 / 读不到** → 同样注册——此时 section 文本是响亮的 `[缺失]` 提示
-*     （规格 §6-6 要求"不静默"；不注册就等于静默）
-* 其余（文件在但无 frontmatter / 无 `skills` 键 / 值为空）⇒ false，不注册、不产生噪声。
-*/
-function hasCognitiveTrajectorySkillsDeclaration(root, mdPath) {
-	const abs = absoluteMdPath(root, mdPath);
-	if (!existsSync(abs)) return true;
-	try {
-		return parseDeclaredSkills(readFileSync(abs, "utf-8")).length > 0;
-	} catch {
-		return true;
-	}
-}
-/** 去空白 + 丢空项 + 同名去重（保留首次出现位置）——两条声明来源共用同一规范化 */
-function normalizeNames(names) {
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const raw of names) {
-		const clean = raw.trim();
-		if (clean === "" || seen.has(clean)) continue;
-		seen.add(clean);
-		out.push(clean);
-	}
-	return out;
-}
-/**
-* 合并两条声明来源（v1.44.0）：**CCC 级在前，轨迹级追加**，同名去重取首次位置。
-*
-* 两条来源（owner 令 2026-09-20）：
-*   · **CCC 级** = `.opencode/serenity.json` 的 `cognitiveTrajectory.skills`（本 CCC 所有轨迹共有的底座）；
-*   · **轨迹级** = 该轨迹 `SESSION.md` frontmatter 的 `skills:`（这条轨迹额外的）。
-*
-* 为什么是**并集**而不是二选一（R↓）：C1 设计当初否决"纯 CCC 全局"的理由是"会**丢掉
-* per-trajectory**"；并集把两侧都保住——容器给底座，单条轨迹仍可加自己的额外项。
-* 为什么 CCC 级**在前**：底座先立、增量随后，与"入口身份块 order=-50 → 本 section order=-45"
-* 的既有先后观感一致。
-*/
-function mergeSkillNames(cccSkills, trajSkills) {
-	return normalizeNames([...cccSkills, ...trajSkills]);
-}
-/**
-* 装配注入正文（规格 §3）：按**合并后的**顺序拼接各 skill 的 `SKILL.md` 全文，每段带来源抬头
-* `=== skill: <name> ===`；拿不到全文的一律以 `[缺失]` 响亮提示占位（**不静默**）。
-*
-* 安全（规格 §3 🔒）：名字来自 CCC 数据（frontmatter / CCC 配置）⇒ **先过 `isSafeSkillName`**；
-* 不安全 ⇒ 按缺失处理，且不调用 `findSkillMd` ⇒ **不发生任何以该名拼出的 fs 访问**。
-*
-* 长度守卫：复用已导出的 `truncateContent`，**在合并之后**统一截断（两条来源共享同一上限，
-* 不是各给 32 KB——否则上限会随来源数翻倍）。
-*
-* @param root CCC 根
-* @param mdPath 轨迹的 SESSION.md 路径（**来自绑定的 `mdPath`**，不用 label 拼）
-* @param maxChars 总长上限（字符）
-* @param cccSkills CCC 级声明（`readCognitiveTrajectorySkills`；缺省空 = 只有轨迹级，行为与 v1.43 一致）
-* @param onInjectedNames 观测回调（本次请求实际带上的 skill 名；**纯观测**，供用量统计用——
-*        回调抛错被吞，**不影响注入正文**）
-* @returns 注入正文；两条来源皆无声明 → `''`（空串 = 宿主不产出该 section 块）；
-*          SESSION.md 缺失/读失败 → 响亮提示（若同时有 CCC 级声明，则提示在前、正文随后——
-*          **提示不因"别处有内容"而被吞掉**）
-*/
-function buildCognitiveTrajectorySkillsSection(root, mdPath, maxChars = COGNITIVE_TRAJECTORY_SKILLS_MAX_CHARS, cccSkills = [], onInjectedNames) {
-	const abs = absoluteMdPath(root, mdPath);
-	let trajNames = [];
-	let notice = "";
-	if (!existsSync(abs)) notice = `${SKILL_MISSING_MARK} ${abs}（轨迹的 SESSION.md 不存在——skill 声明无从读取；若刚重建/移动过轨迹，请确认绑定记录）`;
-	else try {
-		trajNames = parseDeclaredSkills(readFileSync(abs, "utf-8"));
-	} catch (err) {
-		notice = `${SKILL_MISSING_MARK} ${abs}（SESSION.md 读取失败：${err instanceof Error ? err.message : String(err)}）`;
-	}
-	const names = mergeSkillNames(cccSkills, trajNames);
-	if (names.length === 0) return notice;
-	if (onInjectedNames) try {
-		onInjectedNames(names);
-	} catch {}
-	const blocks = [];
-	for (const name of names) {
-		if (!isSafeSkillName(name)) {
-			blocks.push(`${SKILL_MISSING_MARK} ${name}（名字不安全，已拒绝解析路径）`);
-			continue;
-		}
-		const file = findSkillMd(root, name);
-		if (!file) {
-			blocks.push(missingNotice(name));
-			continue;
-		}
-		try {
-			const index = buildResourceIndex(dirname(file));
-			const body = readFileSync(file, "utf-8");
-			blocks.push(`=== skill: ${name} ===\n${index ? `${body}\n\n${index}` : body}`);
-		} catch {
-			blocks.push(missingNotice(name));
-		}
-	}
-	const body = blocks.join("\n\n");
-	return truncateContent(notice ? `${notice}\n\n${body}` : body, maxChars);
-}
-//#endregion
-//#region src/surface/usage.ts
-/**
-* surface/usage.ts — ACC 用量统计（**skill 加载次数** ＋ **MSM 执行次数**；落该 CCC 的 `_tmp`）
-*
-* ## 所有者令（本模块的存在理由）
-*
-* 「我需要对 ACC 增加一个统计功能，包括 **skill 加载次数统计，msm 执行次数统计**；
-*  要求这个统计**自动生成在 CCC 的 `_tmp` 内的指定文件**」
-* ＋（对齐时确认）「**skill 加载**两个口径**都记、用字段区分**」「**只记名字、不记参数**」
-* 「**重启后读旧文件续算**」。
-*
-* ## 它解决什么麻烦（白话）
-*
-* 在此之前，「**哪些 skill 真的被加载过、哪些 MSM 真的在跑**」在 ACC 侧**一个数都没有** ——
-* 要判断「这东西还有人用吗」，只能靠翻会话记录**猜**。
-* ⇒ 本模块让每个 CCC 留下一份**纯计数**账本：**用了哪个、多少次、第一次和最近一次是什么时候**。
-* 用途 = 清理/精简的**依据**（没有人用的东西与天天在用的东西，不再靠猜）。
-*
-* ## 🔴 铁律（与 `cro/log.ts` 同族）
-*
-* **本模块每个导出函数都不抛错**：读盘 / 解析 / 写盘失败一律返回结构化失败，
-* 由调用方只记一行日志（或什么都不做）⇒ **统计的问题绝不影响工具执行与既有链路**。
-* 调用点在 `tools/post-execute` 的中途 ⇒ **更不能抛**（否则等于用统计打断会话）。
-*
-* ## 🔴 只记名字（所有者令；也是本模块唯一的"不入盘"约束）
-*
-* **绝不写 `arguments`**：MSM 参数里可能有凭据 / 路径 / 正文。
-* ⇒ 本模块只保留**计数键**（skill 名 / MSM 名），并对其做**长度与数量上限**（见常量），
-* 使文件规模**结构上有界**（不需要轮转，也不会被异常名字撑爆）。
-*
-* ## 🔴 重启后必须续算（所有者令）
-*
-* 宿主会被重启（本容器实测 24h 内 3 次）⇒ 计数**不能只活在内存里**：
-* 每次写盘 = **读旧文件 → 在旧值上自增 → 原子写**（`tmp + rename`，与 `wake/registry.ts` /
-* `cro/log.ts` 同款形态）⇒ **进程重启后计数自然延续**，无需额外的 flush/落盘时机。
-*
-* ## 口径（两个字段，勿合并）
-*
-* | 字段 | 含义 | 喂它的地方 |
-* |---|---|---|
-* | `skill.loads` | 模型**主动**调宿主 `skill` 工具（把某 skill 的 `SKILL.md` 全文载入） | `tools/post-execute`（工具名 = `skill`） |
-* | `skill.injections` | ACC **每请求注入**的 skill 段（`cognitiveTrajectory.skills` / 轨迹 frontmatter 声明） | `seams/system-prompt.ts` 的 cognitive-trajectory-skills section 求值回调 |
-* | `msm` | `msm` 工具的一次执行，按 **MSM 名**分桶 | `tools/post-execute`（工具名 = `msm`） |
-*
-* 🔴 **两者差好几个数量级**：`loads` 是模型的**动作**（稀疏），`injections` 是**请求的属性**（稠密）。
-* 合并成一个数就**再也读不出**「这个 skill 是被人主动用的，还是只是被配上了」。
-*/
-/** 落点目录（所有者令：CCC 的 `_tmp` 内） */
-const USAGE_STATS_SUBDIR = "_tmp";
-/** 固定文件名（所有者令「指定文件」；对齐时我取的名字，owner 未反对 ⇒ 定为常量） */
-const USAGE_STATS_FILENAME = "acc-usage.json";
-/** 每个桶的键数上限（**结构上界**，见文件头"只记名字"节） */
-const USAGE_MAX_KEYS_PER_BUCKET = 1e3;
-const USAGE_STATS_VERSION = 1;
-/** 统计文件绝对路径（**纯函数**） */
-function usageStatsPath(root) {
-	return join(root, USAGE_STATS_SUBDIR, USAGE_STATS_FILENAME);
-}
-/** 空账本（**纯函数**） */
-function emptyUsageStats() {
-	return {
-		version: USAGE_STATS_VERSION,
-		updatedAt: isoLocal(0),
-		skill: {
-			loads: {},
-			injections: {}
-		},
-		msm: {}
-	};
-}
-/** 单条计数形状校验（容忍手改：字段缺失/类型不符 ⇒ 丢弃该条，不阻断整档） */
-function asCounter(value) {
-	const c = value;
-	if (!c || typeof c !== "object") return null;
-	if (typeof c.count !== "number" || !Number.isFinite(c.count) || c.count < 0) return null;
-	const firstAt = typeof c.firstAt === "string" ? c.firstAt : "";
-	const lastAt = typeof c.lastAt === "string" ? c.lastAt : firstAt;
-	return {
-		count: Math.floor(c.count),
-		firstAt,
-		lastAt
-	};
-}
-/** 桶校验（非对象 ⇒ 空桶；逐键过滤非法条） */
-function asBucket(value) {
-	const out = {};
-	if (!value || typeof value !== "object") return out;
-	for (const [k, v] of Object.entries(value)) {
-		const c = asCounter(v);
-		if (c) out[k] = c;
-	}
-	return out;
-}
-/**
-* 读取账本（**永不抛**；读坏 ⇒ 空账本 + 返回 error 文本，**不静默吞掉**）。
-* 文件不存在 = 正常初态（`error: null` 且空账本）。
-*/
-function loadUsageStats(root) {
-	const path = usageStatsPath(root);
-	if (!existsSync(path)) return {
-		stats: emptyUsageStats(),
-		error: null
-	};
-	try {
-		const parsed = JSON.parse(readFileSync(path, "utf-8"));
-		const skill = parsed.skill ?? {};
-		return {
-			stats: {
-				version: USAGE_STATS_VERSION,
-				updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : isoLocal(0),
-				skill: {
-					loads: asBucket(skill.loads),
-					injections: asBucket(skill.injections)
-				},
-				msm: asBucket(parsed.msm)
-			},
-			error: null
-		};
-	} catch (err) {
-		return {
-			stats: emptyUsageStats(),
-			error: `用量统计解析失败（${String(err?.message ?? err)}）`
-		};
-	}
-}
-/** 键是否可记（非空 + 不超长；**不截断**——截断会造出一个不存在的名字） */
-function isRecordableUsageName(name) {
-	return typeof name === "string" && name !== "" && [...name].length <= 120;
-}
-/**
-* 在桶上自增一格（**纯函数**：不改入参，返回新桶）。
-* 新键超桶上限 ⇒ **不新增**（但仍自增已有键）⇒ 键数**结构上有界**。
-*/
-function bumpBucket(bucket, name, at, maxKeys = USAGE_MAX_KEYS_PER_BUCKET) {
-	const prev = bucket[name];
-	if (!prev && Object.keys(bucket).length >= maxKeys) return bucket;
-	const next = prev ? {
-		count: prev.count + 1,
-		firstAt: prev.firstAt || at,
-		lastAt: at
-	} : {
-		count: 1,
-		firstAt: at,
-		lastAt: at
-	};
-	return {
-		...bucket,
-		[name]: next
-	};
-}
-/** 从工具入参里取名字（首个命中的键胜出；取不到 ⇒ `null`） */
-function nameFromArgs(args, keys) {
-	if (args === null || typeof args !== "object") return null;
-	const a = args;
-	for (const k of keys) if (isRecordableUsageName(a[k])) return a[k];
-	return null;
-}
-/** `msm` 工具的名字键（`msm(name, args)` 的第一个参数） */
-const MSM_NAME_KEYS = ["name"];
-/** `skill` 工具的名字键（宿主 `skill` 工具用 `name`；另两个是防御性容错） */
-const SKILL_NAME_KEYS = [
-	"name",
-	"skill",
-	"skillName"
-];
-const NOTHING = {
-	ok: true,
-	error: null,
-	recorded: null,
-	name: null,
-	wrote: false
-};
-/**
-* 读 → 自增 → 原子写（**本模块唯一写盘通道；永不抛**）。
-*
-* @param root CCC 根
-* @param mutate 在已载入的账本上做一次自增（返回值 = 本次记录的结论；返回 `NOTHING` 则不写盘）
-* @param nowMs 当前毫秒（可注入 ⇒ 便于测 firstAt/lastAt）
-*/
-function writeThrough(root, mutate, nowMs = Date.now()) {
-	const path = usageStatsPath(root);
-	try {
-		const at = isoLocal(nowMs);
-		const loaded = loadUsageStats(root);
-		const outcome = mutate(loaded.stats, at);
-		if (outcome.recorded === null) return outcome;
-		loaded.stats.updatedAt = at;
-		mkdirSync(join(root, USAGE_STATS_SUBDIR), { recursive: true });
-		const tmp = `${path}.tmp`;
-		writeFileSync(tmp, `${JSON.stringify(loaded.stats, null, 2)}\n`, "utf-8");
-		renameSync(tmp, path);
-		return {
-			...outcome,
-			ok: true,
-			error: null,
-			wrote: true
-		};
-	} catch (err) {
-		return {
-			ok: false,
-			error: `用量统计写入失败（${String(err?.message ?? err)}）`,
-			recorded: null,
-			name: null,
-			wrote: false
-		};
-	}
-}
-/**
-* 记录一次工具调用的用量（**`tools/post-execute` 的喂入口**）。
-*
-* 只认两类工具名；其余一律 `NOTHING`（**不产生文件、不产生噪声**）。
-* 🔴 **不看 `arguments` 的其余内容**——只取名字键。
-*/
-function recordToolUsage(root, toolName, args, nowMs = Date.now()) {
-	if (toolName === "msm") {
-		const name = nameFromArgs(args, MSM_NAME_KEYS);
-		if (!name) return NOTHING;
-		return writeThrough(root, (stats, at) => {
-			stats.msm = bumpBucket(stats.msm, name, at);
-			return {
-				ok: true,
-				error: null,
-				recorded: "msm",
-				name,
-				wrote: false
-			};
-		}, nowMs);
-	}
-	if (toolName === "skill") {
-		const name = nameFromArgs(args, SKILL_NAME_KEYS);
-		if (!name) return NOTHING;
-		return writeThrough(root, (stats, at) => {
-			stats.skill.loads = bumpBucket(stats.skill.loads, name, at);
-			return {
-				ok: true,
-				error: null,
-				recorded: "skill.load",
-				name,
-				wrote: false
-			};
-		}, nowMs);
-	}
-	return NOTHING;
-}
-/**
-* 记录一次 **skill 注入**（每个请求的 skill 段装配时调用）。
-*
-* ⚠️ 与 `recordToolUsage` 不同，本函数的调用频度 = **请求频度**（稠密）：
-* 调用方应**只在真的注入了非空内容时**调用（空 section 由宿主丢弃 ⇒ 不产生噪声）。
-* 一次调用只写一次盘（`names` 内的多个 skill 合并在**同一次**读改写里）。
-*/
-function recordSkillInjections(root, names, nowMs = Date.now()) {
-	const usable = names.filter((n) => isRecordableUsageName(n));
-	if (usable.length === 0) return NOTHING;
-	return writeThrough(root, (stats, at) => {
-		let bucket = stats.skill.injections;
-		for (const n of usable) bucket = bumpBucket(bucket, n, at);
-		stats.skill.injections = bucket;
-		return {
-			ok: true,
-			error: null,
-			recorded: "skill.injection",
-			name: usable.join(","),
-			wrote: false
-		};
-	}, nowMs);
-}
-/** 验证窗口：当前时步 ± 1（容忍时钟漂移/生成延迟） */
-const TOTP_WINDOW = 1;
-/** 输出位数（标准 6 位） */
-const TOTP_DIGITS = 6;
-const B32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-/** base32（无填充，大小写不敏感）→ 字节；非法字符抛错。 */
-function base32Decode(input) {
-	const clean = input.toUpperCase().replace(/[\s=]/g, "");
-	if (clean.length === 0) throw new Error("empty base32");
-	const out = [];
-	let bits = 0;
-	let value = 0;
-	for (const ch of clean) {
-		const idx = B32_ALPHABET.indexOf(ch);
-		if (idx === -1) throw new Error(`invalid base32 char: ${ch}`);
-		value = value << 5 | idx;
-		bits += 5;
-		if (bits >= 8) {
-			out.push(value >>> bits - 8 & 255);
-			bits -= 8;
-		}
-	}
-	return Uint8Array.from(out);
-}
-/** 一个时步的 TOTP code（6 位，前导零保留）。counter = floor(epochSeconds / step) */
-function totpCode(secretBase32, counter) {
-	const key = base32Decode(secretBase32);
-	const msg = Buffer.alloc(8);
-	msg.writeBigUInt64BE(BigInt(counter));
-	const digest = createHmac("sha1", Buffer.from(key)).update(msg).digest();
-	const offset = digest[digest.length - 1] & 15;
-	const bin = (digest[offset] & 127) << 24 | digest[offset + 1] << 16 | digest[offset + 2] << 8 | digest[offset + 3];
-	return String(bin % 10 ** TOTP_DIGITS).padStart(TOTP_DIGITS, "0");
-}
-/** 当前 epoch 秒 */
-function nowEpochSeconds() {
-	return Math.floor(Date.now() / 1e3);
-}
-/**
-* 校验用户输入的 code（允许 ±TOTP_WINDOW 时步漂移，防重放窗口内同 code 复用由
-* 调用方按账号记录最近成功 counter 实现——本函数只做纯算法校验）。
-* @returns 命中的 counter（用于防重放）；不匹配返回 null。
-*/
-function verifyTotpCode(secretBase32, code, nowSeconds = nowEpochSeconds()) {
-	if (!/^\d{6}$/.test(code)) return null;
-	const current = Math.floor(nowSeconds / 30);
-	for (let offset = -1; offset <= TOTP_WINDOW; offset++) if (totpCode(secretBase32, current + offset) === code) return current + offset;
-	return null;
-}
-//#endregion
-//#region src/kernel/ports.ts
-/**
-* 集中端口表。
-* A=宿主主面（插件不监听）/ B=网关（可配，默认关）/ C=微信发送（默认开，仅 loopback）
-* / D=轨迹约束调试（默认关）。
-*/
-const FACE_PORTS = {
-	main: {
-		port: 3080,
-		host: null,
-		defaultEnabled: true,
-		meaning: "宿主 DSH 主 WebUI + 插件 /serenity/* 路由面（**插件不起此 listener**，端口自宿主读）"
-	},
-	gateway: {
-		port: 3081,
-		host: "0.0.0.0",
-		defaultEnabled: false,
-		meaning: "双端口网关（外部登录 + 全量反代宿主主面；host/port 走 plugin 全局配置）"
-	},
-	weixinSend: {
-		port: 3082,
-		host: "127.0.0.1",
-		defaultEnabled: true,
-		meaning: "微信主动发送面（容器外进程 → POST /send；与 3080 显式解耦，不经网关）"
-	}
-};
-FACE_PORTS.main.port;
-/** 网关端口默认值（面 B） */
-const GATEWAY_PORT = FACE_PORTS.gateway.port;
-/** 微信主动发送端口默认值（面 C） */
-const WEIXIN_SEND_PORT = FACE_PORTS.weixinSend.port;
-/**
-* **机制端口**词表（output-guard 用：agent 在**用户可见输出**里提及内部端口即打回）。
-*
-* 由 {@link FACE_PORTS} 机械派生 ⇒ 与面清单**永不漂移**。
-* ⚠️ 修复记录（C4 块 B，2026-09-15）：旧常量硬写 `['3080','3081','3099','3100']`
-* ——**漏 3082**（微信发送面，默认开）⇒ 守卫拦不住"3082"这类提及。现由表派生，四面齐全。
-* ⚠️ 面变更记录（2026-10-15）：**面 E（3100 ACP/问答）已整体退役**（owner 裁「砍掉外部问答」）
-* ⇒ 本词表随之少一项，**无需另改**（这正是"派生而非手抄"的收益）。
-*/
-const MECHANISM_PORTS = Object.keys(FACE_PORTS).map((id) => String(FACE_PORTS[id].port));
-//#endregion
-//#region src/kernel/config.ts
-/**
-* kernel/config.ts — plugin 全局配置读写（结构化，`~/.dsh/serenity-hooks.json`）
-*
-* 归属原则（S142 用户拍板，v1.22）：**plugin 是全局的，CCC 是具体的**——
-* 账号密码/gateway 监听配置是 plugin 级能力，归 plugin 全局文件；
-* CCC 的 localstore.json 只管 CCC 自己的凭据/配置。v1.21.x 曾把
-* `serenityAdvanced` 存进 CCC localstore（归属错误 + 与 DSH settings 开关割裂），
-* 本版本迁移到 plugin 全局文件（migrateLegacyLocalstore 一次性迁移）。
-*
-* 文件：$DSH_HOME/serenity-hooks.json（缺省 ~/.dsh/serenity-hooks.json；
-* env SERENITY_HOOKS_CONFIG 可覆盖——测试/部署注入）。
-* 权限：0600（含账号密码 hash，敏感）。
-*
-* 安全：密码仅存 scrypt hash（node:crypto 内置，零依赖）；wire 层永不返回 hash
-* （GET 只回 user/id，设置面板"密码"字段提交空串 = 不修改）。
-*/
-/** 高级设定节名（localstore.json 顶层） */
-const ADVANCED_SECTION = "serenityAdvanced";
-/** 默认值（工厂——每次返回新对象，防止调用方意外共享引用） */
-function defaultAdvancedSettings() {
-	return {
-		gateway: {
-			enabled: false,
-			host: FACE_PORTS.gateway.host ?? "0.0.0.0",
-			port: GATEWAY_PORT,
-			accounts: [],
-			workspaces: [],
-			cookieSecure: false,
-			allowWorkspaceCreate: true,
-			totpEnabled: false
-		},
-		persona: {
-			mode: "",
-			overrideText: ""
-		},
-		weixinApi: {
-			enabled: true,
-			port: WEIXIN_SEND_PORT
-		}
-	};
-}
-const SCRYPT_KEYLEN = 32;
-/** 生成 scrypt hash（格式 `salt:hex`）；salt 16 字节随机 */
-function hashPassword(password) {
-	const salt = randomBytes(16);
-	const derived = scryptSync(password, salt, SCRYPT_KEYLEN);
-	return `${salt.toString("hex")}:${derived.toString("hex")}`;
-}
-/** 校验密码与存储 hash（timing-safe） */
-function verifyPassword(password, stored) {
-	const idx = stored.indexOf(":");
-	if (idx <= 0) return false;
-	const salt = Buffer.from(stored.slice(0, idx), "hex");
-	const expected = Buffer.from(stored.slice(idx + 1), "hex");
-	const derived = scryptSync(password, salt, SCRYPT_KEYLEN);
-	return expected.length === derived.length && timingSafeEqual(expected, derived);
-}
-/** 全局配置文件路径：env SERENITY_HOOKS_CONFIG 覆盖（测试注入）→ $DSH_HOME → ~/.dsh */
-function globalConfigPath() {
-	const override = process.env.SERENITY_HOOKS_CONFIG;
-	if (override && override !== "") return override;
-	const dshHome = process.env.DSH_HOME ?? join(process.env.HOME ?? "", ".dsh");
-	return join(dshHome, "serenity-hooks.json");
-}
-function readFileSafe(p) {
-	if (!existsSync(p)) return {};
-	try {
-		const v = JSON.parse(readFileSync(p, "utf-8").replace(/^\uFEFF/, ""));
-		if (v && typeof v === "object" && !Array.isArray(v)) return v;
-		return {};
-	} catch {
-		return {};
-	}
-}
-function writeFileSafe(p, data) {
-	writeFileSync(p, JSON.stringify(data, null, 2) + "\n", "utf-8");
-	try {
-		chmodSync(p, 384);
-	} catch {}
-}
-/** 深合并默认值（缺省字段补齐；accounts 数组整体替换） */
-function mergeWithDefaults(raw) {
-	const def = defaultAdvancedSettings();
-	if (raw === null || typeof raw !== "object") return def;
-	const o = raw;
-	const gateway = o.gateway ?? {};
-	const persona = o.persona ?? {};
-	const weixinApi = o.weixinApi ?? {};
-	return {
-		gateway: {
-			enabled: typeof gateway.enabled === "boolean" ? gateway.enabled : def.gateway.enabled,
-			host: typeof gateway.host === "string" && gateway.host !== "" ? gateway.host : def.gateway.host,
-			port: typeof gateway.port === "number" && Number.isInteger(gateway.port) ? gateway.port : def.gateway.port,
-			accounts: Array.isArray(gateway.accounts) ? gateway.accounts.filter((a) => typeof a === "object" && a !== null && typeof a.id === "string" && typeof a.user === "string" && typeof a.passHash === "string") : def.gateway.accounts,
-			workspaces: Array.isArray(gateway.workspaces) ? gateway.workspaces.filter((w) => typeof w === "string" && w !== "") : def.gateway.workspaces,
-			cookieSecure: typeof gateway.cookieSecure === "boolean" ? gateway.cookieSecure : def.gateway.cookieSecure,
-			allowWorkspaceCreate: typeof gateway.allowWorkspaceCreate === "boolean" ? gateway.allowWorkspaceCreate : def.gateway.allowWorkspaceCreate,
-			totpEnabled: typeof gateway.totpEnabled === "boolean" ? gateway.totpEnabled : def.gateway.totpEnabled
-		},
-		persona: {
-			mode: typeof persona.mode === "string" ? persona.mode : def.persona.mode,
-			overrideText: typeof persona.overrideText === "string" ? persona.overrideText : def.persona.overrideText
-		},
-		weixinApi: {
-			enabled: typeof weixinApi.enabled === "boolean" ? weixinApi.enabled : def.weixinApi.enabled,
-			port: typeof weixinApi.port === "number" && Number.isInteger(weixinApi.port) && weixinApi.port >= 0 ? weixinApi.port : def.weixinApi.port
-		}
-	};
-}
-/** 读取全局配置（文件缺失/坏 JSON → 默认值） */
-function readAdvancedSettings() {
-	return mergeWithDefaults(readFileSafe(globalConfigPath()));
-}
-/** 写入全局配置（整体替换） */
-function writeAdvancedSettings(settings) {
-	writeFileSafe(globalConfigPath(), settings);
-}
-/**
-* 部分更新：传入 Partial，深合并到现有值。
-* accounts 传入数组 → 整体替换；accounts 未传 → 保留现有。
-*/
-function updateAdvancedSettings(patch) {
-	const current = readAdvancedSettings();
-	const gw = patch.gateway;
-	const ps = patch.persona;
-	const next = {
-		gateway: gw !== void 0 ? {
-			enabled: typeof gw.enabled === "boolean" ? gw.enabled : current.gateway.enabled,
-			host: typeof gw.host === "string" && gw.host !== "" ? gw.host : current.gateway.host,
-			port: typeof gw.port === "number" && Number.isInteger(gw.port) ? gw.port : current.gateway.port,
-			accounts: Array.isArray(gw.accounts) ? gw.accounts : current.gateway.accounts,
-			workspaces: Array.isArray(gw.workspaces) ? gw.workspaces.filter((w) => typeof w === "string" && w !== "") : current.gateway.workspaces,
-			cookieSecure: typeof gw.cookieSecure === "boolean" ? gw.cookieSecure : current.gateway.cookieSecure,
-			allowWorkspaceCreate: typeof gw.allowWorkspaceCreate === "boolean" ? gw.allowWorkspaceCreate : current.gateway.allowWorkspaceCreate,
-			totpEnabled: typeof gw.totpEnabled === "boolean" ? gw.totpEnabled : current.gateway.totpEnabled
-		} : current.gateway,
-		persona: ps !== void 0 ? {
-			mode: typeof ps.mode === "string" ? ps.mode : current.persona.mode,
-			overrideText: typeof ps.overrideText === "string" ? ps.overrideText : current.persona.overrideText
-		} : current.persona,
-		weixinApi: patch.weixinApi !== void 0 ? {
-			enabled: typeof patch.weixinApi.enabled === "boolean" ? patch.weixinApi.enabled : current.weixinApi.enabled,
-			port: typeof patch.weixinApi.port === "number" && Number.isInteger(patch.weixinApi.port) && patch.weixinApi.port >= 0 ? patch.weixinApi.port : current.weixinApi.port
-		} : current.weixinApi
-	};
-	writeAdvancedSettings(next);
-	return next;
-}
-/**
-* 一次性迁移（v1.21.x → v1.22）：旧版把 `serenityAdvanced` 存在 CCC localstore.json；
-* 新版归 plugin 全局文件。全局文件已存在 → 跳过（幂等）；localstore 无旧节 → 跳过。
-* @param root - CCC 根（localstore.json 所在目录）
-* @returns true = 已迁移（旧节保留在 localstore 供回滚，读取方以全局文件为准）
-*/
-function migrateLegacyLocalstore(root) {
-	if (!root) return false;
-	const gpath = globalConfigPath();
-	if (existsSync(gpath)) return false;
-	const legacy = readFileSafe(join(root, "localstore.json"))[ADVANCED_SECTION];
-	if (legacy === void 0 || legacy === null || typeof legacy !== "object") return false;
-	writeFileSafe(gpath, legacy);
-	return true;
-}
-/** 持久化 → wire（剥离 passHash/totpSecret；只留布尔） */
-function toWire(settings) {
-	return {
-		gateway: {
-			enabled: settings.gateway.enabled,
-			host: settings.gateway.host,
-			port: settings.gateway.port,
-			accounts: settings.gateway.accounts.map((a) => ({
-				id: a.id,
-				user: a.user,
-				hasPassword: a.passHash !== "",
-				hasTotp: typeof a.totpSecret === "string" && a.totpSecret !== ""
-			})),
-			workspaces: [...settings.gateway.workspaces],
-			cookieSecure: settings.gateway.cookieSecure,
-			allowWorkspaceCreate: settings.gateway.allowWorkspaceCreate,
-			totpEnabled: settings.gateway.totpEnabled
-		},
-		persona: settings.persona
-	};
-}
-/**
-* 已知工作区投影（v1.28.0 适配 0.1.2-rc.1 A2 方案 A′）：
-* rc.1 workspace.list unary 删除 → AccountsEditor 白名单下拉的数据源改走 gateway 自有
-* /serenity/config 的 knownWorkspaces（host workspaceRegistry.list() 投影，白名单过滤）。
-* 纯函数可单测。allowPrefixes 空 = 全部放行（向后兼容默认）。
-*/
-function projectKnownWorkspaces(workspaces, allowPrefixes) {
-	return workspaces.filter((w) => typeof w.path === "string" && w.path !== "").filter((w) => allowPrefixes.length === 0 || allowPrefixes.some((p) => w.path.startsWith(p))).map((w) => ({
-		path: w.path,
-		title: typeof w.title === "string" && w.title !== "" ? w.title : w.path
-	}));
-}
-/**
-* wire → 持久化（面板 PUT 用）：
-* accounts 元素可选带 `pass`：非空 → 重新 hash；空/缺省 → 保留现有 hash（按 id 匹配）。
-* 新账号（id 不在现有）必须带非空 pass，否则抛错（无法生成 hash）。
-*/
-function applyWirePatch(wire) {
-	const current = readAdvancedSettings();
-	const patch = {};
-	if (wire.gateway !== void 0) {
-		const gwPatch = { ...current.gateway };
-		if (typeof wire.gateway.enabled === "boolean") gwPatch.enabled = wire.gateway.enabled;
-		if (typeof wire.gateway.host === "string" && wire.gateway.host !== "") gwPatch.host = wire.gateway.host;
-		if (typeof wire.gateway.port === "number" && Number.isInteger(wire.gateway.port)) gwPatch.port = wire.gateway.port;
-		if (Array.isArray(wire.gateway.workspaces)) gwPatch.workspaces = wire.gateway.workspaces.filter((w) => typeof w === "string" && w !== "");
-		if (typeof wire.gateway.cookieSecure === "boolean") gwPatch.cookieSecure = wire.gateway.cookieSecure;
-		if (typeof wire.gateway.allowWorkspaceCreate === "boolean") gwPatch.allowWorkspaceCreate = wire.gateway.allowWorkspaceCreate;
-		if (typeof wire.gateway.totpEnabled === "boolean") gwPatch.totpEnabled = wire.gateway.totpEnabled;
-		if (Array.isArray(wire.gateway.accounts)) {
-			const byId = new Map(current.gateway.accounts.map((a) => [a.id, a]));
-			gwPatch.accounts = wire.gateway.accounts.map((a) => {
-				const existing = byId.get(a.id);
-				const pass = a.pass;
-				const totp = a.totpSecret;
-				const totpReset = a.totpReset === true;
-				if (typeof totp === "string" && totp !== "") try {
-					base32Decode(totp);
-				} catch {
-					throw new Error(`Account "${a.user}" TOTP secret is not valid base32`);
-				}
-				const nextTotp = totpReset ? void 0 : typeof totp === "string" && totp !== "" ? totp : existing?.totpSecret;
-				const withTotp = {
-					id: a.id,
-					user: a.user,
-					...nextTotp === void 0 ? {} : { totpSecret: nextTotp }
-				};
-				if (typeof pass === "string" && pass !== "") return {
-					...withTotp,
-					passHash: hashPassword(pass)
-				};
-				if (existing) return {
-					...withTotp,
-					passHash: existing.passHash
-				};
-				throw new Error(`Account "${a.user}" (id=${a.id}) has no password and no existing hash — new accounts must set a password`);
-			});
-		}
-		patch.gateway = gwPatch;
-	}
-	if (wire.persona !== void 0) {
-		const psPatch = { ...current.persona };
-		if (typeof wire.persona.mode === "string") psPatch.mode = wire.persona.mode;
-		if (typeof wire.persona.overrideText === "string") psPatch.overrideText = wire.persona.overrideText;
-		patch.persona = psPatch;
-	}
-	return updateAdvancedSettings(patch);
-}
-//#endregion
-//#region src/seams/system-prompt.ts
-/** 读取 persona 彩蛋配置（plugin 全局；未配置 → mode='' 彩蛋关闭） */
-function readPersonaSettings() {
-	try {
-		const s = readAdvancedSettings();
-		return {
-			mode: s.persona.mode ?? "",
-			overrideText: s.persona.overrideText ?? ""
-		};
-	} catch {
-		return {
-			mode: "",
-			overrideText: ""
-		};
-	}
-}
-/** 过滤掉对 agent 隐藏的内容（safe-mode 是用户能力，不对 agent 提及）。无 g flag：`.test()` 须逐行独立无状态，避免 lastIndex 游移漏滤（问题A） */
-const HIDDEN_LINES = /安全模式|safe-mode|\.serenity-safe-on/;
-function sanitizeSkillContent(content) {
-	return content.split("\n").filter((line) => !HIDDEN_LINES.test(line)).join("\n");
-}
-/** 1) 身份块：ACC 身份 + CCC 名 + 平台工具说明（需求③ S142：工具清单移出为独立 toolsBlock 放装配末尾——身份先行、工具参考殿后） */
-function identityBlock(root) {
-	const cccName = basename(root);
-	return [
-		"",
-		"=== Serenity ACC ===",
-		`ACC: dsh-serenity-hooks v${ACC_VERSION}`,
-		`CCC: ${cccName}`,
-		"",
-		"You are running inside a Concrete Cognitive Container (CCC) —",
-		"the runtime instance of an Abstract Cognitive Container (ACC).",
-		"The ACC (this plugin) is a cognitive container harness: it provides",
-		"deterministic tools, mechanical constraints, and session continuity.",
-		"The complete built-in tool list is at the end of this prompt under the",
-		"\"Serenity Tools\" heading — read it before using any ACC tool.",
-		"",
-		"  ℹ️ Use relative paths from the CCC root for CCC-internal file operations (read/write/edit/glob/grep etc.), e.g. AGENT_SESSIONS/2026-08-14--S134--x/SESSION.md; Root / absolute SESSION.md paths are identifiers only, not tool arguments",
-		"",
-		"The DSH platform tools remain available too (read/write/edit/glob/grep/web_search/ask_user_question/subagent/workflow/goal and more) — the ACC tools are the serenity-native layer, not the only tools.",
-		"",
-		"Additional MSMs registered by this CCC are available — call msm() with no arguments to list them, or msm(\"<name>\") to execute one.",
-		""
-	].join("\n");
-}
-/**
-* 工具清单块（需求③ S142 用户拍板：工具列表移装配末尾 + MSM 调用示例）：
-* 原 accBlock 内嵌 13 行工具清单 → 独立成块放装配末尾（SKILL 后、Session 前）。
-* 身份先行（认知轨迹开头不被 13 行清单干扰）、工具参考殿后（需要时再看）。
-* 附带 MSM 调用示例（用户拍板：顶层提示词加调用方式说明，避免偶发调用错误——
-* 模型对 msm 参数面/协议 flag 理解不稳）。
-*/
-function toolsBlock() {
-	return [
-		"",
-		"=== Serenity Tools ===",
-		"The ACC (this plugin) provides the following built-in tools:",
-		"",
-		"  container_fs — container filesystem operations (15 subcommands: root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find)",
-		"  cognitive_trajectory — one cognitive trajectory: its persistent body (SESSION.md) + its timeline. Lifecycle: list (inventory + stats) / show / create / use (activate; inline integrity check — silent when fine) / rebuild (clear-and-rebuild this conversation in place, Ship of Theseus); delivery: send-now (deliver one message RIGHT NOW; live target injected immediately, non-live cold-resumed like a direct wake — returns a synchronous receipt) / send-later (one future instant + one message to any cognitive trajectory; fire-and-forget — no receipt, no recall) / cro-guide (the CRO programming guide: how to give THIS cognitive trajectory its own program that decides when it should be woken)",
-		"  dashboard    — always-on container instruments: health (CCC three-principle check + registry integrity) / time (now) / wait (N seconds)",
-		"  container_git— git operations (status/commit/push/log/pull/diff)",
-		"  msm          — execute a registered CCC MSM: msm(name, args); partial name returns candidates; inspect=true shows usage",
-		"  praxis       — actionable theory injection: praxis (index) / praxis eap / praxis neat / praxis cce / praxis ontology",
-		"  ontology     — ontology engineering ENGINE (executable): init (write template) / check (M1-M10 structural; level=strict adds L1-L5 hints) / explain (summary) / verify (V1-V4 runtime compliance) / review (semantic-review prompt) / compliance (axiom-vs-skill checklist). Sibling of `praxis ontology` — that one is the METHOD TEXT, this one RUNS it. path must stay inside the container; the receipt carries the engine exit code (0/1/2/4) and the engine text verbatim, so read it rather than assuming success",
-		"  cheap-worker     — delegate work to a worker agent on the CCC-configured model; one serial child per task, returns its final text. `jobs=[...]` fans out in parallel (cap 10, results keep your order). No loop, no completion code, no progress file. The model is NOT selectable per call (read from the CCC config); a worker's tool set excludes cheap-worker itself",
-		"  serenity-skill-creator — creator for serenity-skills (this container's enhanced skill standard): guide (authoring/optimization method — read first) / create <name> (scaffold SKILL.md + skill.ttl + references/, base-chain import path computed) / check <name> (A1 structural + A2 base-chain; three states: modeled-ok / plain-skill / modeled-but-check-could-not-run) / review <name> (C tier: axiom-vs-text compliance question list, half-mechanical) / index <name> (preview the second-layer resource list the model will see) / status (which skills are modeled). A skill is \"modeled\" iff it has a file named exactly skill.ttl next to SKILL.md; a plain skill is NOT an anomaly. Only `create` writes, and it refuses an existing directory",
-		"  localstore   — ACC local credential/config storage (CCC-root localstore.json; git policy localstore.gitTrack default deny)",
-		"  container_admin — container administration (the maintenance bay): role (轨迹约束 roles: guide/validate/apply/list) / msm (register/deregister/check/guide/catalog/ccc-config) / config (view)",
-		"",
-		"MSM call (registered CCC MSMs, deterministic Mech & Semi-Mech):",
-		"  Execute:       msm(\"<name>\", [\"<arg1>\", \"<arg2>\"])   — run a registered MSM directly (partial name returns matching candidates)",
-		"  Inspect:       msm(\"<name>\", [], inspect=true)       — view that MSM's usage/flags without running",
-		"  Index:         msm()                                 — summary of registered MSMs by skill",
-		"  Manage:        container_admin msm register|deregister|check (registry is ACC-managed — never edit mech-registry.json directly)",
-		""
-	].join("\n");
-}
-/** 2) CCE 块：逐字对齐 osp（CCE 5 行为约束 + H_op 操作熵） */
-function cceBlock() {
-	return [
-		"",
-		"=== Serenity CCE ===",
-		"",
-		"You are operating inside a Cognitive Container governed by Cognitive Continuity",
-		"Engineering (CCE) — the engineering discipline of maintaining identity, accessibility,",
-		"and evolution of a cognitive entity through time under bounded resources.",
-		"",
-		"CCE does not optimize cognition. It preserves the conditions under which cognition",
-		"can continue.",
-		"",
-		"FIVE BEHAVIORAL CONSTRAINTS (engineering requirements, not suggestions):",
-		"",
-		"1. Continuity — every interaction modifies the container's future state. Before",
-		"   acting, consult what came before — prior decisions, abstractions, constraints.",
-		"   You are part of a cognitive trajectory, not a fresh start.",
-		"",
-		"2. Bounded Space — the container has boundaries. Respect them. Do not assume",
-		"   knowledge that has not been accumulated within this container.",
-		"",
-		"3. Entropy is Intrinsic — every cognitive system accumulates entropy (duplication,",
-		"   obsolescence, conflict, fragmentation, drift). When you produce output, consider",
-		"   whether you are adding entropy or reducing it. Favor entropy-reducing actions —",
-		"   organizing, deduplicating, cross-referencing, abstracting.",
-		"",
-		"4. Reconstruction > Preservation — stored artifacts have value only insofar as",
-		"   they enable future cognition to recover the reasoning that produced them. When",
-		"   recording decisions, ensure reconstruction is possible — not just conclusions,",
-		"   but rationale, alternatives considered, and constraints that shaped the choice.",
-		"",
-		"5. Multi-Agent Cognition — the container is shared. Continuity belongs to the",
-		"   container, not to any individual agent. Write for future agents who will enter",
-		"   after you leave. They should be able to pick up where you left off.",
-		"",
-		"OPERATIONAL ENTROPY: The container's health metric is operational cognitive entropy",
-		"(H_op) — the excess cognitive cost for agents to complete tasks due to disorder.",
-		"The container is healthy when H_op ≤ H_critical (agents can still function). The",
-		"continuity condition: organization must at minimum match accumulation (ΔH_org ≥ ΔH_in).",
-		"Your actions affect H_op — unorganized output increases it, organization decreases it.",
-		"",
-		"THIS IS PERSISTENCE ENGINEERING: The goal is not to become greater. The goal is to",
-		"remain coherent. CCE has no terminal KPI — continuity is maintained while the entity",
-		"exists, not optimized toward an endpoint.",
-		""
-	].join("\n");
-}
-/**
-* Principles 块（v1.19.8 合并，S142）：认知容器本体论（why）+ 操作边界（operational
-* boundaries）。原独立 Principles 与 Constraints 合并——同属容器约束体系，先原则
-* 后边界（从抽象到具体，重建视角 R↓）。**注意：Constraints 不再作为独立对齐块存在
-* （spec 修订：同步 osp compacting.ts——Constraints 内容并入本块，工具名仍为平台真实名）。**
-*
-* v1.23.1 persona：`omitMsmPrinciples=true` 时剥离 MSM 原则段（彩蛋替换面）——
-* 用户 persona 文本承接"指令遵循风格"，本体论/关系段/操作边界（安全硬约束）永远保留。
-*/
-function principlesBlock(root, omitMsmPrinciples = false) {
-	const lines = [
-		"",
-		"=== Serenity Principles ===",
-		"Why a cognitive container: all work is cognition — every artifact, decision,",
-		"and line of code is a product of thought; and from cognition, any work can",
-		"be built. In this frame, the world contains no errors — only insufficient",
-		"cognition. A setback is a gap to be filled (read, ask, research), not a",
-		"fault to be hidden. Never disguise or excuse what you do not know;",
-		"not-knowing is a state to be repaired, and reporting it is the first repair.",
-		"",
-		"The session–cognitive-trajectory relation: a session is the rebuildable carrier of a",
-		"cognitive trajectory. SESSION.md is the cognitive trajectory's persistent body — it never moves;",
-		"the current conversation is a temporary work copy that may be discarded and",
-		"rebuilt (cognitive_trajectory rebuild). Identity belongs to the cognitive trajectory, not to any",
-		"session.",
-		""
-	];
-	if (!omitMsmPrinciples) lines.push("MSM principles — machinery before improvisation:", "- Determinism first: use a registered Mech before hand-rolling; reserve", "  Semi-Mech for genuine judgment points.", "- Single source of truth: an MSM is the only decoder of its own usage", "  (--help/--schema); documents must not duplicate it.", "- Registered to act: no tool exists unless it is on the manifest.", "");
-	lines.push("Operational boundaries:", `Root: ${root}`, "  • File access — read/edit/write/grep/glob are confined to Root; paths outside Root are rejected (RR5)", "  • Shell — use msm by default. Note: bash may be disabled", "  • Subagent — copies ALL parent constraints: file boundary, shell rules, session rules (no bypass)", "  • Session-first — before starting multi-step work, propose an existing or new AGENT_SESSIONS entry; wait for user \"use\" or \"使用\" to confirm", "");
-	return lines.join("\n");
-}
-/**
-* 彩蛋 persona 块（v1.23.1，S142 用户需求）：
-* 用户配置的替换文本替代 EAP 块 + MSM 原则段（输出约束/指令遵循约束）。
-* 独立标记头 `=== Serenity Persona ===`（幂等检测兼容）；装配位置 = EAP 原位。
-* mode 空 = 彩蛋关闭 → 返回空串（装配层回退默认 EAP + 完整 Principles）。
-*/
-function personaBlock(mode, overrideText) {
-	if (mode === "" || overrideText.trim() === "") return "";
-	return [
-		"",
-		"=== Serenity Persona ===",
-		overrideText.trimEnd(),
-		""
-	].join("\n");
-}
-/**
-* EAP 自检提示块（DSH 扩展，无 osp 对应——osp 无此块）。
-* 每次输出前的机械自检清单，强化 EAP 表现（E↑ 显式/R↓ 可重建/S↑ 稳定）。
-* 独立块而非塞进 CCE/Constraints：后两者受 osp-alignment 逐字节断言约束。
-*/
-function eapBlock() {
-	return [
-		"",
-		"=== Serenity EAP ===",
-		"Self-check before every output (Explicit Abstraction Principle: the functional",
-		"value of a thought equals its external reconstructability):",
-		"  • E↑ Explicit — variables/entities clearly defined, relationships with",
-		"    direction/cardinality, boundaries drawn; avoid ambiguous words (\"handle\",",
-		"    \"optimize\" → be specific)",
-		"  • R↓ Reconstructable — key decisions record rationale and alternatives;",
-		"    no level-skipping (align the upper layer before descending)",
-		"  • S↑ Stable — structures regenerate repeatably, no reliance on implicit",
-		"    context",
-		""
-	].join("\n");
-}
-/**
-* Metaphor 强化块（v1.19.6，S142；v1.29 星舰意象升级，S142 用户拍板）：
-* 宁静号宇宙隐喻域（星舰/深空/航程/船员）。海船→星舰意象：one starship, one voyage；
-* deep space / launch / docking clamp；Departure Inspection（原 Harbor Inspection）。
-* 隐喻是记忆钩子——形象唤起约束，前述块保持规则精确。每条隐喻 = 一个不可违背的
-* 物理事实 + 行为判据（verdict）。全英文（与 CCE/Constraints 一致）；独立块可
-* 回退；无 osp 对应（dsp 扩展，不进对齐断言参照）。
-* 结构约束（docs/metaphor-domain.md M-1~M-4）：三层骨架不变 + 每条映射约束不变。
-*/
-function metaphorBlock() {
-	return [
-		"",
-		"=== Serenity Metaphor ===",
-		"The Serenity Universe — one starship, one voyage. Metaphors are memory hooks:",
-		"they make constraints vivid, while the rules above stay precise. Each",
-		"metaphor is an unbreakable physical fact; violating one is a behavioral",
-		"violation. The universe is structured in three layers — the Ship (the",
-		"container itself), the Voyage (the cognitive lifecycle), the Crew",
-		"(multi-agent collaboration); every metaphor maps to one protocol",
-		"constraint. Deep space has no mistakes — only stars you have not yet mapped.",
-		"",
-		"THE SHIP — the container itself",
-		"",
-		"1. The Hull → Bounded Space. You exist only inside this ship. Cargo",
-		"   outside the hull (knowledge the container has not accumulated) does",
-		"   not exist; do not assume it. Verdict: citing facts absent from the",
-		"   container = overload.",
-		"",
-		"2. Deck Order → Entropy (H_op). Clutter on deck raises the cost of",
-		"   finding things. H_op ≤ H_critical = the ship stays flight-worthy.",
-		"   Verdict: disorganized output = debris in the hold.",
-		"",
-		"3. Engineering Drawings → EAP. Every part dimensioned (E↑), the",
-		"   drawings rebuild the whole machine (R↓), the drawings are reusable",
-		"   (S↑). Verdict: an undimensioned part = unassemblable.",
-		"",
-		"4. The Machinery → MSM (Mech & Semi-Mech). The ship's equipment is",
-		"   machinery: registered, deterministic, self-describing. Turn the",
-		"   crank of a Mech and the action is exact; the wheel with a helmsman",
-		"   (Semi-Mech) steers where judgment is needed. Verdict: hand-rolling",
-		"   what a machine already does = wasting the crew.",
-		"",
-		"5. The Manifest → Single Source of Truth. Every tool exists only if it",
-		"   is on the manifest (mech-registry); there is exactly one manifest.",
-		"   An MSM self-describes (--help/--schema) — the manifest is the only",
-		"   key. Verdict: duplicating a tool's usage in documents = two",
-		"   contradictory star charts.",
-		"",
-		"THE VOYAGE — the cognitive lifecycle",
-		"",
-		"6. Departure Inspection → First Anchor. The departure inspection = pre-",
-		"   launch checklist: confirm identity (ACC manifesto), the ship's log (SESSION),",
-		"   ballast (constraints) before setting course. Verdict: skipping the",
-		"   inspection and launching directly = flying uninspected.",
-		"",
-		"7. The Ship's Log → Cognitive Trajectory Tracking. SESSION.md is the",
-		"   cognitive trajectory's log —",
-		"   the persistent body of the voyage; sessions are rebuildable carriers of",
-		"   the cognitive trajectory. Discard the carrier, keep the log. Unrecorded =",
-		"   unvoyaged. Verdict: finishing multi-step work without a progress record",
-		"   = a missing page.",
-		"",
-		"8. The Ship of Theseus → Continuity. Planks may be replaced; the ship",
-		"   remains the same. The container can be rebuilt; identity persists.",
-		"   You are part of a cognitive trajectory, not a new ship. Verdict: acting",
-		"   without consulting precedent = a different ship.",
-		"",
-		"THE CREW — multi-agent collaboration",
-		"",
-		"9. Crew Rotation → Multi-Agent Cognition. Other crew members will come",
-		"   after you. When you leave, leave a handover they can pick up",
-		"   (SESSION closed, open problems listed). Verdict: leaving without",
-		"   handover = abandoning ship.",
-		"",
-		"10. Blueprint over Statue → Reconstruction > Preservation. Keep the",
-		"   blueprint, not the statue. Recording only conclusions without",
-		"   rationale = a statue with no blueprint, unreconstructable.",
-		"   Verdict: a decision record without reasons or alternatives =",
-		"   cannot be rebuilt.",
-		""
-	].join("\n");
-}
-/**
-* 运行时状态块 1) safe-mode（S134 v1.16.12）：ON 时告知 agent。
-* v1.19.8 结构重排（S142 用户设计思路）：语义（为什么——无人值守自由）→
-* 机制（什么被禁用）→ 约束（不可做什么）。文案与实现逐项对应（guards.ts）：
-* bash 禁用（restrict deny + decideGuard）、黑名单路径拦截、CCC 治理文件保护；
-* write/edit 等其余工具保留（受路径逃逸/黑名单约束）。
-*/
-function safeModeBlock(root) {
-	if (!isSafeModeOn(root)) return "";
-	const blacklist = readBlacklist(root);
-	return [
-		"",
-		"=== Serenity Safe Mode ===",
-		"Safe mode is ON (enabled by the user). It makes the vessel unattended-capable —",
-		"the hull holds its course without a watch on deck: you may work with fuller",
-		"freedom, pushing work forward autonomously without pausing for approval at",
-		"every step. The guards are not chains; they are the ballast that lets you",
-		"sail unaccompanied.",
-		"",
-		"Operational details:",
-		"- bash is disabled (hidden and blocked)",
-		"- blacklist rules apply to file paths",
-		"- CCC governance files (.serenity, .serenity-safe-on) are protected from agent writes",
-		"- other read/write tools remain available, subject to path-escape and blacklist guards",
-		blacklist.length > 0 ? `\nActive blacklist rules: ${blacklist.map((b) => b.message ?? b.pattern).join(", ")}` : "",
-		"",
-		"Behavior constraints: do not attempt to bypass restrictions; do not write to",
-		"blacklisted paths or governance files.",
-		""
-	].join("\n");
-}
-/**
-* 运行时状态块 2) localstore git 策略（S134 v1.16.12）：localstore.json 存在时按 gitTrack
-* 提示敏感行为约束。deny（缺省）= 本地私有不提交；allow = 进 git（个人私有仓）但敏感数据
-* 只限于该文件内（不外泄到其他文件/对话/日志）。
-*/
-function localstoreBlock(root) {
-	if (!existsSync(localstorePath(root))) return "";
-	return (readGitTrack(root) === "allow" ? [
-		"",
-		"=== Serenity Localstore ===",
-		"localstore.json is committed to git (gitTrack=allow — personal private repository).",
-		"Sensitive data may live in this file, but ONLY in this file: keep credentials and",
-		"secret values confined to localstore.json — never leak them into other files,",
-		"conversation, or logs.",
-		""
-	] : [
-		"",
-		"=== Serenity Localstore ===",
-		"localstore.json is a local private file (gitTrack=deny — not committed to git,",
-		".gitignore enforced). Credentials/config live only on this machine: do not write",
-		"them into conversation or logs; do not attempt to commit this file (container_git will refuse).",
-		""
-	]).join("\n");
-}
-/** 4) SKILL.md 全文：该 CCC 顶层入口 skill 原文（对齐 osp：原文直推，无包裹头；仅过滤治理内容）
-*  ＋ 🆕 **第二层披露树**（serenity-skill P1，设计 §4.2）：每个入口 skill 后附**参考件清单**
-*  （只有文件名与一行标题，**不含正文** —— 正文留给模型按需 `read`）。
-*  索引为空（该 skill 无 `references/` 也无 `skill.ttl`）⇒ **不产出该块**（空标题是噪声）。 */
-function entrySkillSectionText(root) {
-	const skills = findEntrySkills(root);
-	if (skills.length === 0) return "";
-	return skills.map((s) => {
-		const body = sanitizeSkillContent(s.content);
-		if (body.length === 0) return "";
-		const index = buildResourceIndex(s.dir);
-		return index ? `${body}\n\n${index}` : body;
-	}).filter((c) => c.length > 0).join("\n\n");
-}
-/** 活跃会话解析：按 dsh 会话 scope 读标记（隔离；不回退旧全局标记） */
-function resolveActiveSessionInfo(root, scope) {
-	try {
-		const abs = readActiveSessionMd(root, scope);
-		if (!abs) return null;
-		const dirName = basename(dirname(abs));
-		const idMatch = dirName.match(/S(\d{3,})/);
-		return {
-			sessionId: idMatch ? `S${idMatch[1]}` : dirName,
-			dirName,
-			mdPath: abs
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* 5) Session 块：对齐 osp（活跃会话 + todowrite 首位约定）；scope = dsh 会话维度。
-* **平台适配（v1.17.2）**：osp 的 todowrite 首项含 `priority: "low"`（opencode todo 支持），
-* 但 DSH 平台 todowrite schema 无 priority（additionalProperties: false 拒绝）→ agent 照做报
-* `todos[0].priority is not a declared property`。DSH 版去掉 priority 字段（其余逐字对齐 osp）。
-*/
-function sessionBlock(root, scope = DEFAULT_SESSION_SCOPE) {
-	const active = resolveActiveSessionInfo(root, scope);
-	if (!active) return "";
-	return [
-		"",
-		"=== Serenity Session ===",
-		`Active session: ${active.sessionId} — ${active.dirName} (this session is the rebuildable carrier of the cognitive trajectory)`,
-		`SESSION.md path: ${active.mdPath} (the cognitive trajectory's persistent body — stays in place through rebuilds)`,
-		"",
-		"Rules (SESSION.md is the cognitive trajectory log — keep its format & granularity fixed):",
-		"  • Write only when a MILESTONE landed or a DECISION was made — not every round",
-		"  • One entry = one abstraction level, at the highest one that can express it:",
-		"    identity/anchors (rare) › decision (one line + rationale/rejected) › milestone",
-		"    (one line + an evidence pointer, e.g. a commit id). Execution detail — test",
-		"    counts, coverage decimals, per-file readings, step narration — belongs in the",
-		"    COMMIT MESSAGE, not here",
-		"  • Never write a value that changes by the act of writing it (file size; the hash",
-		"    of the commit containing this edit)",
-		"  • Fixed sections, in this order: 身份与边界 / 权威锚点 / 工作纪律 / 决策 / 日志 /",
-		"    当前状态 / 待 owner 裁决.  The 日志 section appends only; 当前状态 and",
-		"    待 owner 裁决 are OVERWRITTEN each round",
-		"  • Reference this session in all subsequent messages",
-		"",
-		"IMPORTANT: Read SESSION.md now to RESUME — not to audit. Sync the todo list from",
-		"the 当前状态 and 待 owner 裁决 sections only.",
-		"",
-		"CRITICAL: When calling todowrite, the first item in the todos array MUST",
-		"always be:",
-		`  { content: "SESSION: ${active.sessionId} — ${active.dirName.replace(/^\d{4}-\d{2}-\d{2}--/, "")}",`,
-		"    status: \"completed\" }",
-		"This preserves the session context across todo updates.",
-		"Do NOT remove or reorder this item — keep it at position 0.",
-		"",
-		"COGNITIVE-TRAJECTORY-ASSISTANT: a background tracker scores your tool use (write/edit=3,",
-		"task=10, read/grep/glob/msm=1, +1 per minute) and reminds you with a",
-		"[COGNITIVE-TRAJECTORY-ASSISTANT · CHECKPOINT] message when the threshold is reached. On every such",
-		"reminder you MUST reply with the exact ACK code:",
-		"  [COGNITIVE-TRAJECTORY-ASSISTANT-recorded-{code}]  — if you recorded progress to SESSION.md",
-		"  [COGNITIVE-TRAJECTORY-ASSISTANT-skipped-{code}]  — if nothing to record this round",
-		"Do not ignore the reminder; do not stop ongoing work. Codes are single-use;",
-		"never reuse a prior code.",
-		""
-	].join("\n");
-}
-/**
-* 完整系统提示词注入文本（v1.19.8 结构精简，S142 重建视角 R↓）：
-* 身份（ACC）→ 世界模型（Metaphor）→ 信念/边界（Principles）→ 时间约束（CCE）
-* → 质量（EAP）→ 状态（SafeMode/Localstore）→ CCC 上下文（SKILL）→ 工具参考（Tools）→ 会话（Session）。
-* 认知展开顺序：我是谁 → 我所在的世界 → 为什么 → 如何一致 → 产物标准 → 当前状态 → 上下文 → 工具参考 → 会话。
-*
-* 需求③（S142 用户拍板）：工具清单从 accBlock 移出为独立 toolsBlock，
-* 放 SKILL 后 Session 前（工具参考殿后，身份先行不被 13 行清单干扰）。
-*
-* v1.23.1 persona（彩蛋）：persona.mode 配置 → EAP 块替换为 Persona 块（输出约束），
-* Principles 剥离 MSM 原则段（指令遵循约束）——用户文本承接两处风格；本体论/关系段/
-* 操作边界（安全硬约束）永远保留。未配置 → 与 v1.23.0 逐字节一致（零影响）。
-*/
-function serenitySystemPrompt(root, scope = DEFAULT_SESSION_SCOPE, dirName) {
-	const persona = readPersonaSettings();
-	const personaOn = persona.mode !== "" && persona.overrideText.trim() !== "";
-	const parts = [
-		identityBlock(root),
-		metaphorBlock(),
-		principlesBlock(root, personaOn),
-		cceBlock(),
-		eapBlock()
-	];
-	if (personaOn) {
-		const expr = personaBlock(persona.mode, persona.overrideText);
-		if (expr !== "") parts.push(expr);
-	}
-	const state = [safeModeBlock(root), localstoreBlock(root)].filter((b) => b !== "").join("\n");
-	if (state) parts.push(state);
-	const skill = entrySkillSectionText(root);
-	if (skill) parts.push(skill);
-	const trajPrompt = dirName === void 0 ? "" : trajectoryPromptBlock(createTrajectoryPromptReader(root, dirName)());
-	if (trajPrompt !== "") parts.push(trajPrompt);
-	parts.push(toolsBlock());
-	const session = sessionBlock(root, scope);
-	if (session) parts.push(session);
-	return parts.join("\n\n");
-}
-/**
-* Code Mode 适配行：当前 scope 以 Code Mode 呈现工具时（run_code 可见），
-* ACC 块按 native 语义指引"直接调用工具"会与"只有 run_code 可直接调用"的执行
-* 塌缩冲突（模型直呼工具名 → UNKNOWN_TOOL，拒绝信息误导）。追加一行说明，
-* 引导经 run_code 程序内 tools.* 调用。both 模式不塌缩，该行不误导（程序内
-* 调用同样合法），故按 run_code 可见性（code|both）统一附加。
-* @param ctx - 插件 ctx（读 tools 注册表）。
-* @param scope - 装配 scope（agent）；无则按全局视图判断。
-* @returns 适配行（含换行前缀）；非 code/both 返回空串。
-*/
-function codeModeAdaptationLine(ctx, scope) {
-	try {
-		if (!(ctx.tools.get("run_code", scope) !== void 0)) return "";
-	} catch {
-		return "";
-	}
-	return [
-		"",
-		"=== Serenity Code Mode ===",
-		"This session renders tools in Code Mode: direct calls to ACC tool names (container_fs/msm etc.) are rejected (UNKNOWN_TOOL).",
-		"Call them inside a single run_code program via the generated SDK bindings: `await tools.container_fs(...)`, `await tools.msm(...)`.",
-		"The program only returns what you print/return — curate your output.",
-		""
-	].join("\n");
-}
-/** 从 assembly context 解析 agent cwd（subagent/后台 agent 同样带 agent）；
-*  无 agent → undefined（不注入）；有 agent 但无 header.cwd（workflow subagent 等）
-*  回退 process.cwd()——**cwd 回落语义取自 `ccc-roots.agentCwdFor`（C2 归一）**，否则这些
-*  agent 系统提示词注入为空（v1.18.6：workflow subagent 无宁静号上下文 bug）。
-*  ⚠️ 本函数比 `agentCwdFor` 多一道「**无 agent ⇒ undefined**」——那是 section 的
-*  "不注入" 语义（`agentCwdFor` 对无 agent 会回落到 process.cwd()），故不能直接替换。 */
-function agentCwd(context) {
-	const agent = context.agent;
-	if (!agent) return void 0;
-	return agentCwdFor(agent);
-}
-/** 从 assembly context 解析 dsh 会话 id（Session 块按会话隔离的 scope） */
-function agentScope$2(context) {
-	return (context.agent?.session)?.id ?? "default";
-}
-/**
-* 该会话**绑定的轨迹目录名**（有 ⇒ 注入第 ⑧ 段「轨迹提示词」；无 ⇒ `undefined`，不注入）。
-*
-* 🔴 为什么用**目录名**而不是编码或 label：`PROMPT.md` 的落盘位置是目录，
-* 而编码只是目录名里的一段。用 label 拼路径 = 把模糊匹配当精确匹配用（本轨已踩过）。
-*
-* ⚠️ 每次装配都重读绑定（**不缓存**）：绑定切换后提示词必须立刻跟上，
-* 这与 `serenity-trajectory-skills` section 的口径一致（动态注入，owner 令 2026-09-20）。
-*/
-function boundDirNameFor(session) {
-	try {
-		const name = readLastBound(session)?.dirName;
-		return typeof name === "string" && name !== "" ? name : void 0;
-	} catch {
-		return;
-	}
-}
-/**
-* 全局注册系统提示词 section（osp system.transform 的 DSH 等价）。
-* text 回调按 context.agent 的 cwd 上溯 .serenity → 返回该 CCC 的完整注入文本；
-* 非 CCC / 无 agent 返回空（不注入）。
-*/
-function registerEntrySkillSectionGlobal(ctx) {
-	try {
-		ctx.systemPrompt.section({
-			name: "serenity-entry",
-			order: -50,
-			text: (context) => {
-				const cwd = agentCwd(context);
-				if (!cwd) return "";
-				const root = cccRootForCwd(cwd);
-				if (!root) return "";
-				const base = serenitySystemPrompt(root, agentScope$2(context), boundDirNameFor(context.agent?.session));
-				const codeLine = codeModeAdaptationLine(ctx, context.scope);
-				return codeLine ? `${base}\n${codeLine}` : base;
-			}
-		});
-		console.log("[serenity-hooks] ✓ 全局入口 skill section 已注册（systemPrompt 就绪）");
-	} catch (err) {
-		console.error(`[serenity-hooks] ✗ 全局入口 skill section 注册失败: ${err.message}（检查 inject 是否含 systemPrompt）`);
-	}
-}
-/**
-* agent 级 scoped 注册（P0-1：抗 preset/动态插件同名 shadow）。
-*
-* 为什么 scoped：DSH 的 systemPrompt section 支持 scoped 层同名 shadow 全局
-* （agent.ctx.systemPrompt.section），且 scope 链最近层胜出。若 ACC 只注册全局
-* section，preset 或动态 Cordis 插件可在 scoped 层注册同名 `serenity-entry`
-* 遮蔽 ACC 身份。scoped 注册在 agent 自身层 = 最近层，任何外部组合无法覆盖。
-* 全局注册保留为 fallback（未走 session-start 的 agent / 冷恢复路径）。
-*
-* text 回调闭包持有 root 与 agent：content 固定（该 agent 的 CCC 身份），
-* code-mode 适配按装配 context.scope 判断（与全局版一致）。
-*/
-const sectionedAgents = /* @__PURE__ */ new Set();
-function registerEntrySkillSection(agent, root) {
-	const key = agent.session.id ?? "global";
-	if (sectionedAgents.has(key)) return false;
-	try {
-		const scope = agent.session.id ?? "default";
-		agent.ctx.systemPrompt.section({
-			name: "serenity-entry",
-			order: -50,
-			text: (context) => {
-				const base = serenitySystemPrompt(root, scope, boundDirNameFor(agent.session));
-				const codeLine = codeModeAdaptationLine(agent.ctx, context.scope);
-				return codeLine ? `${base}\n${codeLine}` : base;
-			}
-		});
-		sectionedAgents.add(key);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* 轨迹 skill 注入 section（规格 `docs/cognitive-trajectory-skill-injection.md` §3，v1.34.1）。
-*
-* **声明来源（两条，并集）**：
-*   · **CCC 级**（v1.44.0，owner 令）= `.opencode/serenity.json` 的 `cognitiveTrajectory.skills`
-*     ——**本 CCC 的每条轨迹都带**（含 轨迹约束角色会话），是容器给的底座；
-*   · **轨迹级** = 该会话绑定的轨迹（`readLastBound(session).mdPath` = 它的 `SESSION.md`）
-*     顶部 frontmatter 的 `skills:`——这条轨迹额外的。
-*   合并规则与顺序见 `cognitive-trajectory-skills.mergeSkillNames`（CCC 级在前，同名去重）。
-*   正文 = 合并清单里各 skill 的 `SKILL.md` 全文（本模块只注册，装配在 `trajectory/skills.ts`）。
-*
-* 为什么是 **per-agent scoped section**（与 `registerEntrySkillSection` 同形）：注入必须
-* **绑定期间持续存在**（a2）——一次性注入会随对话压缩消失，而 section 每次装配重新求值。
-*
-* 为什么**门在注册时、内容在求值时**（R↓，两个失败模式各治一个）：
-*   · 注册门（**无绑定 / 两条来源皆无** ⇒ 不注册）：满足"零配置面不产生空 section、不产生噪声"；
-*   · 求值回调**每请求重读 `readLastBound` + 文件 + CCC 配置**：绑定切换 / 声明或配置被编辑后
-*     自动跟上（**动态注入，不缓存**），且绑定消失时返回 `''`
-*     （宿主 renderSections **丢弃空 section**，不残留噪声）。
-*
-* ⚠️ 路径取自绑定的 `mdPath`（权威记录），**不用** `resolveSessionCognitiveTrajectoryLabel` 的显示 label
-* 去拼路径——label 是模糊匹配的展示码，拼路径即模糊匹配当精确匹配用。
-*
-* @param agent 目标 agent（其 `session` 需有 `header.id` + `header.cwd`）
-* @param root 该 agent 的 CCC 根
-* @returns 是否**本次**完成注册（已注册过 / 门未过 → false）
-*/
-const cognitiveTrajectorySkillAgents = /* @__PURE__ */ new Set();
-function registerCognitiveTrajectorySkillSection(agent, root) {
-	const session = agent.session;
-	const key = session.id ?? "global";
-	if (cognitiveTrajectorySkillAgents.has(key)) return false;
-	const bound = readLastBound(session);
-	if (!bound) return false;
-	if (readCognitiveTrajectorySkills(root).length === 0 && !hasCognitiveTrajectorySkillsDeclaration(root, bound.mdPath)) return false;
-	try {
-		agent.ctx.systemPrompt.section({
-			name: "serenity-trajectory-skills",
-			order: -45,
-			text: () => {
-				const current = readLastBound(session);
-				if (!current) return "";
-				return buildCognitiveTrajectorySkillsSection(root, current.mdPath, COGNITIVE_TRAJECTORY_SKILLS_MAX_CHARS, readCognitiveTrajectorySkills(root), (names) => recordSkillInjections(root, names));
-			}
-		});
-		cognitiveTrajectorySkillAgents.add(key);
-		return true;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/trajectory/delegate/core.ts
-/**
-* trajectory/delegate/core.ts — cheap-worker（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
-*
-* 🆕 2026-10-14（owner 令「删除后台运行能力」）：**进度文件 / stop token / 轮次循环**整族已退场 ——
-* 它们**只**服务于 background 模式。本模块现存 = 前台委派真正需要的三件：
-* 模型串解析 ／ 白名单校验 ／ provider 可用性判读（＋ 使用指引文本）。
-*
-* ## S14（2026-10-19，轨迹中心重构）：此前位于 `role/worker/` 下（该目录已消失）
-*
-* 落点 = `trajectory/delegate/`。判据（判读表 §3.1）：它是**轨迹 × 轨迹**那种合法形态 ——
-* 主语是「主轨迹把活交给子 agent」，既不是某一条轨迹的切面，也不是容器宪法。
-* ⚠️ 它**不属于** `policy/`：policy 管"这条轨迹允许什么"，本模块管"一条轨迹怎么把活派出去"。
-*/
-/** 解析 model 字符串（provider/model）→ {provider, model}；无 / 视为 model-only */
-function splitModel(model) {
-	const idx = model.indexOf("/");
-	if (idx < 0) return {
-		provider: void 0,
-		model
-	};
-	return {
-		provider: model.slice(0, idx),
-		model: model.slice(idx + 1)
-	};
-}
-/** 校验模型在白名单内；不在 → 抛错（用户拍板：只能使用 CCC 配置的模型） */
-function requireWhitelistedModel(model, models) {
-	if (!models.includes(model)) throw new Error(`cheap-worker: model "${model}" is not in the CCC whitelist. Configure .opencode/serenity.json "cheap-worker.models" with one of: ${models.join(", ")}`);
-}
-/**
-* providerAvailabilityError — 判定「**本机有没有该 provider 的 adapter**」，并产出**可执行**的错误文本。
-* 返回 `null` = 全部可用（调用方照常继续）。
-*
-* 🔴 为什么需要它（S142 2026-09-25，owner 在 **Mac** 上实测）：`cheap-worker` 的模型白名单写在
-*   **CCC**（`.opencode/serenity.json`，**随 git 走**），而 provider adapter 由**每台机器的宿主**
-*   注册（profile 配置 / settings 命名空间）⇒ 同一份白名单在一台机器可用、在另一台必失败。
-*   实测症状：宿主抛 `no adapter registered for provider "<p>"`（`dsh-llm`，code `NO_ADAPTER`），
-*   而**前台路径的 `diagnostic` 是空的** ⇒ 调用方（LLM）拿到 `stopReason:"error"` 却**不知道为什么**，
-*   也就无法修正自己的配置 —— 本条把「沉默的失败」变成「可执行的错误」。
-*
-* 数据来源（宿主 `LlmRuntime`）：`listProviders()` = **有 adapter 的路由**；
-* `listConfigurableProviders()` = **已声明但未必激活**的路由（含激活用的 settings 命名空间）。
-*
-* 判据边界：`model` 串里**没有 `/`** 时取不到 provider（沿用 agent 默认路由）⇒ **不判定**（跳过）。
-*/
-function providerAvailabilityError(models, facts) {
-	const registered = new Set(facts.registered.map((r) => r.id));
-	const requested = models.map((m) => ({
-		raw: m,
-		provider: splitModel(m).provider
-	})).filter((e) => typeof e.provider === "string" && e.provider !== "");
-	const missing = [...new Set(requested.filter((e) => !registered.has(e.provider)).map((e) => e.provider))];
-	if (missing.length === 0) return null;
-	const list = (items, cap = 12) => items.length === 0 ? "  (none)" : items.slice(0, cap).map((s) => `  - ${s}`).join("\n") + (items.length > cap ? `\n  … and ${items.length - cap} more` : "");
-	const available = facts.registered.map((r) => r.name ? `${r.id} (${r.name})` : r.id).sort();
-	const declared = (facts.declared ?? []).filter((d) => missing.includes(d.provider));
-	const configPath = facts.configPath ?? "<ccc>/.opencode/serenity.json";
-	const missingList = missing.map((p) => `"${p}"`).join(", ");
-	return [
-		`cheap-worker: provider ${missingList} has no adapter registered on this machine.`,
-		"",
-		"  Requested model(s) :",
-		...requested.map((e) => `    ${e.raw}`),
-		`  Configured in      : ${configPath} → "cheap-worker.models" / "cheap-worker.defaultModel"`,
-		"",
-		"  Why this happens   : the whitelist lives in the CCC (it travels with the repository), while",
-		"                       provider adapters are registered per machine by the host. An entry that",
-		"                       works on one machine can fail on another.",
-		"",
-		"  Available on this machine (registered adapters):",
-		list(available),
-		"",
-		"  Declared but NOT active here (activate via settings, then retry):",
-		list(declared.map((d) => `${d.provider}${d.displayName ? ` (${d.displayName})` : ""}${d.settingsNs ? ` — settings namespace "${d.settingsNs}"` : ""}`)),
-		"",
-		"  Fix (pick one, then retry):",
-		`    1. Point the whitelist at a provider that IS registered here — edit ${configPath}`,
-		"       (\"cheap-worker.models\", and \"cheap-worker.defaultModel\" if that is what you relied on).",
-		`    2. Register/activate provider ${missingList} on this machine (host profile config,`,
-		"       or the settings namespace listed above).",
-		"",
-		"  Do not retry unchanged — the same call fails identically."
-	].join("\n");
-}
-/**
-* cheap-worker 规模化使用指引（guide 子命令输出）。
-*
-* 🆕 2026-10-14：**双模式段已整段退场**（owner 令「删除后台运行能力」）。本指引只描述现行机制：
-* 前台委派（单任务）／前台并行扇出（jobs）／白名单与 provider 预检。
-*/
-const CHEAP_WORKER_GUIDE = `# cheap-worker — Scale-Up Usage Guide (guide)
-
-## What it is
-One delegation primitive: **foreground spawn**. The host starts child agent(s) through its delegation
-service, awaits them, and returns their final text. There is no loop, no completion code, no progress
-file, and no unattended/background run.
-
-| | single | parallel (jobs) |
-|---|---|---|
-| Call | cheap-worker(task, [label]) | cheap-worker(jobs=[{task, label?}, ...]) |
-| Behaviour | one child runs the task once | all children start at once, results keep your order |
-| Cap | — | **10 (fixed, hardcoded)** |
-| Model | CCC config (single source) | same |
-
-## ⚠️ Before using: load eap and design the plan
-Before calling cheap-worker, load eap (acc-eap skill) and design the "scale-up cheap-worker plan" based on the EAP framework.
-
-### 1. Task decomposition (E↑ Explicit)
-- Split large tasks into explicit subtasks: each subtask defines goal / input / boundaries (what to do, what not to do) / acceptance criteria
-- Make dependencies explicit: dependent tasks run serially, independent ones can run in parallel via \`jobs\`
-
-### 2. Prompt design (cheap-worker's task parameter)
-- task must be detailed, fixed, and EAP-compliant: clear goal, drawn boundaries, decidable acceptance criteria
-- the child does NOT share your conversation — restate everything it needs in task
-- Anti-example "handle this file" — ambiguous; good example "read <path>, extract all rows of the「关键决策」table,
-  output a JSON array (fields id/conclusion/evidence), do not modify the original file"
-- Reading/curating or text-writing work (extracting from files, summarizing, writing docs, generating text, etc.):
-  the cheap-worker-internal agent is also required to load eap and organize output per the EAP standard
-
-### 3. Model (CCC-configured, not selectable per call)
-- The model is read from .opencode/serenity.json "cheap-worker.models" — **the caller cannot pass one**
-  (there is no "model" parameter). "cheap-worker.defaultModel" names which entry is used; it falls back to models[0].
-- The CCC is expected to point this whitelist at LOW-COST models: cheap-worker is the bulk-execution channel
-- A child's own recursive subagents inherit the child's model automatically (DSH native)
-
-### 3b. 🔴 Provider availability (per-machine — the whitelist is NOT enough)
-- The whitelist lives in the **CCC** ("serenity.json", it **travels with the repository**), but provider
-  **adapters are registered per machine by the host** (profile config / settings namespace). An entry that
-  works on one machine can fail on another with: "no adapter registered for provider <p>".
-- Before spawning, cheap-worker verifies the provider of the resolved model against the adapters registered
-  **on this machine**; if it is missing it reports the requested model, where it is configured, **the
-  providers that ARE available here**, any declared-but-dormant route (with its settings namespace), and the
-  exact fix — delivered in the result's "diagnostic" field (never an opaque failure, never a created child).
-- ⇒ If you see "has no adapter registered on this machine": edit ".opencode/serenity.json" "cheap-worker.models"
-  (and "cheap-worker.defaultModel") to a provider listed as available, or activate/register the provider on this
-  machine. **Do not retry the same call unchanged** — it fails identically.
-
-### 4. Parallel strategy
-- Independent subtasks: cheap-worker(jobs=[{task,label?},...]) ⇒ fan-out, **cap 10**, results come back
-  **in the order you passed them** (label is only a display name).
-- For programmable pipeline/phase orchestration at scale, use the platform's workflow tool instead.
-
-## Completion criteria
-- The child's run settles; done=true only when stopReason="completed" — otherwise read "diagnostic"
-  (and "output" for whatever partial text was produced).
-`;
-//#endregion
-//#region src/trajectory/session.ts
-/** `provider/model` → agentOptions（由 delegate/core 提供，保持单一实现） */
-const trajectoryAgents = /* @__PURE__ */ new Map();
-/** 查 sessionId 的活体 agent（进程内会话延续用；未注册/已清理 → undefined） */
-function getTrajectoryAgent(sessionId) {
-	return trajectoryAgents.get(sessionId);
-}
-/** 该会话当前绑定的 轨迹约束面（不是 轨迹约束 → null）。**守门与提示词的唯一查询入口。** */
-function trajectoryConstraintFor(root, sessionId) {
-	if (sessionId === void 0) return null;
-	return trajectoryConstraintForSession(root, sessionId, trajectoryDirNameForSession(sessionId));
-}
-function registerTrajectorySession(sessionId, trajectoryDirName, ccc, agent) {
-	trajectoryAgents.set(sessionId, agent);
-	registerTrajectorySession$1(sessionId, trajectoryDirName, ccc);
-}
-function unregisterTrajectorySession(sessionId) {
-	trajectoryAgents.delete(sessionId);
-	unregisterTrajectorySession$1(sessionId);
-}
-/**
-* 该 轨迹约束会话的**工作台路径** = 它自己轨迹的 SESSION.md。
-*
-* 🔴 与旧版的差别：旧版会在这里**自动新建**一个 SESSION（`ensureTrajectorySession`）；
-* 新版**没有新建这个动作** —— 轨迹就是工作台，`trajectory-constraint.json` 与 `SESSION.md` 同处一个目录。
-* ⇒ 语义变成纯粹的"查询：我自己的身体在哪"。
-*
-* @returns SESSION.md 绝对路径；不是 轨迹约束 / 文件不在 → null
-*/
-function trajectoryWorkspaceMdPath(root, sessionId) {
-	if (sessionId === void 0) return null;
-	const dirName = trajectoryDirNameForSession(sessionId);
-	if (dirName === null) return null;
-	const md = join(sessionsRoot(root), dirName, "SESSION.md");
-	return existsSync(md) ? md : null;
-}
-/**
-* 系统提示词中的**工作台纪律块**（S142 用户：只给路径 LLM 不会主动用）。
-*
-* SESSION = 工作台 —— 轨迹约束与主舱同一套机制（**零特调**，用户拍板）：
-* SESSION.md 是持久记忆载体、rebuild 自动从本 SESSION 续接。
-* 注入 agent 系统提示词（用户对话面不可见）。
-*
-* v1.30.13（S142 诊断 D5）：写入纪律**不点名具体工具** —— 旧文案写死 "with write/edit"，
-* 而某个 轨迹约束的工具白名单里根本没有 write/edit ⇒ 指令指向它没有的工具
-* （注入纪律与能力面矛盾，模型只能猜）。现文案改为「用本轨迹被授权的写入通道」。
-*/
-function workspaceCognitiveTrajectoryLine(mdPath) {
-	return [
-		"── Serenity Session Workspace ──",
-		"You ARE a cognitive trajectory: this workspace SESSION is your own persistent body.",
-		`  SESSION.md: ${mdPath}`,
-		"",
-		"Rules of the workspace:",
-		"  1. This SESSION.md is your persistent memory carrier (like the main cabin SESSION) — ",
-		"     read it first when context feels thin or work spans turns.",
-		"  2. Record key decisions/progress/unresolved items INTO this SESSION.md using the write channel",
-		"     your trajectory is actually granted (use whatever write tool or MSM you have — never assume",
-		"     a specific write tool exists; if none is granted, report that instead of pretending to write).",
-		"     Sections: 身份与边界 / 权威锚点 / 工作纪律 / 决策 / 日志 / 当前状态 / 待 owner 裁决.",
-		"     Keep entries at milestone level (one line + evidence pointer); execution detail",
-		"     belongs in commit messages. Keep it current — it is what a rebuild resumes from.",
-		"  3. When context pressure is high, run cognitive_trajectory rebuild — it auto-resumes from THIS SESSION.md.",
-		"  4. Never expose this internal path in user-facing replies (chat stays clean).",
-		"── ──"
-	].join("\n");
-}
-/** 已挂工作台提示词段的 agent（幂等：同一 agent 只注册一次，避免 duplicate section） */
-const workspaceSectionAgents = /* @__PURE__ */ new WeakSet();
-/**
-* 把**工作台纪律块**挂到 agent 的系统提示词段（单一注入点）。
-*
-* 用户原话（S142，2026-09-08）："微信桥的注入机制，每个用户消息都会注入，轨迹约束本身也会注入，
-* 这样就重复，能否微信桥情况下，注入内容直接取 轨迹约束的，这样不用配两遍"。
-*
-* 现形态：工作台行**只**经本函数挂系统提示词段（name `serenity-轨迹约束-workspace`，
-* 动态 `text()` 每轮按 scope 读当前活跃 mdPath）。
-*
-* @returns true = 段已在位；false = 该 agent 挂不上（调用方降级为 question 前缀注入）
-*/
-function ensureWorkspacePromptSection(agent, scope, root) {
-	if (!agent || typeof agent !== "object") return false;
-	if (workspaceSectionAgents.has(agent)) return true;
-	const api = agent.ctx?.systemPrompt;
-	if (typeof api?.section !== "function") return false;
-	try {
-		api.section({
-			name: "serenity-轨迹约束-workspace",
-			order: -55,
-			text: () => {
-				const mdPath = trajectoryWorkspaceMdPath(root, scope);
-				return mdPath ? workspaceCognitiveTrajectoryLine(mdPath) : "";
-			}
-		});
-		workspaceSectionAgents.add(agent);
-		return true;
-	} catch (err) {
-		console.warn(`[serenity-hooks] 轨迹约束 工作台提示词段注册失败（回退 question 注入）: ${String(err?.message ?? err)}`);
-		return false;
-	}
-}
-/** 轨迹约束 agent 挂载的 DSH preset（平台工具面由 preset 决定；白名单再按轨迹过滤） */
-const TRAJECTORY_PRESET = "standard";
-/**
-* 创建（或复用）一个 轨迹约束会话。
-*
-* **固定 sessionId 的 resume-or-create**（v1.27.2）：指定 sessionId 且磁盘已有持久化 log →
-* `ctx.agents.resume`（DSH 持久化语义：sessionId 即身份，历史 + turn 续号延续）；
-* 无 log（首次）→ `ctx.agents.create`。不指定 → 随机 id 恒 create（调试页路径）。
-*
-* @param profile 该 轨迹约束的约束面（来自 `trajectory-constraint.json`）
-* @param sessionId 指定会话 id（可选；微信桥等外部面用固定 id 实现"轨迹 ↔ 会话"长期映射）
-*/
-async function createTrajectoryAgent(ctx, root, profile, defaultModel, sessionId) {
-	if (!ctx.agents) throw new Error("trajectory constraint: ctx.agents unavailable");
-	const model = profile.model?.trim() || defaultModel || "";
-	const id = sessionId ?? `轨迹约束-${profile.code}-${randomUUID()}`;
-	const setup = async (agentCtx) => {
-		try {
-			await agentCtx.get("agentPresets")?.mount?.(agentCtx, TRAJECTORY_PRESET);
-		} catch {}
-	};
-	const handle = await createOrResumeAgent(ctx, id, root, model, setup, sessionId !== void 0);
-	const agent = handle.agent;
-	let readerPath = profile.systemPromptFile?.trim();
-	let reader = createProfilePromptReader(root, profile);
-	const livePrompt = () => {
-		let live = profile;
-		try {
-			const fresh = readTrajectoryConstraintAt(join(sessionsRoot(root), profile.dirName), root);
-			if (fresh) live = fresh;
-		} catch {}
-		const wantPath = live.systemPromptFile?.trim();
-		if (wantPath !== readerPath) {
-			reader = createProfilePromptReader(root, live);
-			readerPath = wantPath;
-		}
-		return reader();
-	};
-	livePrompt();
-	try {
-		agent.ctx.systemPrompt.section({
-			name: "serenity-轨迹约束",
-			order: -60,
-			text: () => {
-				const legacy = hasTrajectoryPrompt(root, profile.dirName) ? "" : livePrompt();
-				return [buildTrajectoryBasePrompt(profile.code), legacy].filter(Boolean).join("\n");
-			}
-		});
-	} catch (err) {
-		console.warn(`[serenity-hooks] 轨迹约束 系统提示词注册失败: ${String(err?.message ?? err)}`);
-	}
-	if (agent?.session) try {
-		registerCognitiveTrajectorySkillSection(agent, root);
-	} catch (err) {
-		console.warn(`[serenity-hooks] 轨迹约束轨迹 skill 注入注册失败（不影响 agent 创建）: ${String(err?.message ?? err)}`);
-	}
-	if (trajectoryWorkspaceMdPath(root, id) !== null) ensureWorkspacePromptSection(agent, id, root);
-	registerTrajectorySession(id, profile.dirName, root, agent);
-	return {
-		handle,
-		agent,
-		sessionId: id,
-		resumed: handle.resumed
-	};
-}
-/** 取 live agent（DSH 文档：`ctx.agents.get(id)` 返回 bare Agent；会话 live 时 resume/create 均不可用） */
-function getLiveAgent(ctx, id) {
-	try {
-		return hostAgents(ctx)?.get?.(id);
-	} catch {
-		return;
-	}
-}
-/** live 复用返回（resumed:true 历史延续；dispose 空操作——live agent 不归本模块所有，不能拆） */
-function liveReuseRef(live, setup) {
-	return setup(live.ctx).catch(() => {}).then(() => ({
-		agent: live,
-		dispose: async () => {},
-		resumed: true
-	}));
-}
-/**
-* resume-or-create 分派：固定 id → 优先 resume（持久化历史延续），失败降级 create；
-* 随机 id（无固定 sessionId）→ 恒 create。
-*
-* **v1.27.3 修复（微信桥"重启后不响应"根因）：live 会话优先复用**——重启后 DSH 把
-* 关闭时仍 live 的持久化会话恢复为 live。此时 resume 报
-* "cannot prepare session X while it is live"、create 报 "session X already exists"
-* ⇒ 唯一可行路径 = `ctx.agents.get(id)` 取 live agent 直接续用。
-*/
-async function createOrResumeAgent(ctx, id, root, model, setup, fixedId) {
-	if (!fixedId) return {
-		...await ctx.agents.create({
-			sessionId: id,
-			meta: {
-				cwd: root,
-				agentPreset: TRAJECTORY_PRESET
-			},
-			setup,
-			...model ? { agentOptions: splitModel(model) } : {}
-		}),
-		resumed: false
-	};
-	const liveAgent = getLiveAgent(ctx, id);
-	if (liveAgent) return liveReuseRef(liveAgent, setup);
-	const agentsWithResume = ctx.agents;
-	if (typeof agentsWithResume.resume !== "function") return {
-		...await ctx.agents.create({
-			sessionId: id,
-			meta: {
-				cwd: root,
-				agentPreset: TRAJECTORY_PRESET
-			},
-			setup,
-			...model ? { agentOptions: splitModel(model) } : {}
-		}),
-		resumed: false
-	};
-	try {
-		return {
-			...await agentsWithResume.resume({
-				resumeSessionId: id,
-				setup,
-				...model ? { agentOptions: splitModel(model) } : {}
-			}),
-			resumed: true
-		};
-	} catch (err) {
-		const liveNow = getLiveAgent(ctx, id);
-		if (liveNow) return liveReuseRef(liveNow, setup);
-		const msg = err instanceof Error ? err.message : String(err);
-		const stack = err instanceof Error ? err.stack ?? "" : "";
-		console.log(`[serenity-hooks] 轨迹约束 resume 失败降级 create (id=${id}): ${msg}`);
-		if (stack) console.log(`[serenity-hooks] 轨迹约束 resume stack:\n${stack.slice(0, 1200)}`);
-		return {
-			...await ctx.agents.create({
-				sessionId: id,
-				meta: {
-					cwd: root,
-					agentPreset: TRAJECTORY_PRESET
-				},
-				setup,
-				...model ? { agentOptions: splitModel(model) } : {}
-			}),
-			resumed: false
-		};
-	}
-}
-/** 会话事件读取（兼容 `snapshotEvents()` 与测试替身的 `.events`） */
-function sessionEvents(session) {
-	const s = session;
-	if (typeof s.snapshotEvents === "function") return s.snapshotEvents();
-	return s.events ?? [];
-}
-/** 读会话最后一个 assistant/message 文本 */
-function lastAssistantText$1(agent) {
-	const events = sessionEvents(agent.session);
-	for (let i = events.length - 1; i >= 0; i--) {
-		const e = events[i];
-		if (e && e.type === "assistant/message") {
-			const text = (e.data?.message?.content ?? e.data?.content ?? []).filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-			if (text) return text;
-		}
-	}
-	return "";
-}
-/** 本轮等待上限（毫秒）：超时即判「本轮无产出」——**绝不**把上一轮的旧答案当本轮答案 */
-const ASK_TURN_TIMEOUT_MS = 18e4;
-/** 会话里 `assistant/message` 的条数（判「本轮是否真的产出了回答」） */
-function countAssistantMessages(session) {
-	let n = 0;
-	for (const e of sessionEvents(session)) if (e?.type === "assistant/message") n += 1;
-	return n;
-}
-/**
-* 等**本轮**产出一条 assistant 消息。
-*
-* ## 为什么不能用 `waitAgentIdle` 单独当判据（2026-10-19 复读缺陷）
-*
-* `waitAgentIdle` 的首行是 `if (agent.status === 'idle') finish()` —— 而 `followup()`
-* 是**异步投递**：刚投出去的这一刻 agent 状态**仍是 idle** ⇒ 等待**立刻结算** ⇒
-* `lastAssistantText()` 读到的是**上一轮的** `assistant/message` ⇒ 桥把它当"本轮答案"转发。
-* 若 CCC 又开了 `fallbackOnNoSend`，同一条旧答案会被反复重发（实测三次间隔 300~400ms、逐字相同）。
-*
-* ## 判据（`idle` 只是"可以开始看"的信号，不是成功信号）
-*
-* ① 期望值 = 调用前 `assistant/message` 的**条数**；
-* ② 成功 ⟺ 该计数**增长**；
-* ③ 超时或有界轮询耗尽 ⇒ `false`（调用方据此给空答案，兜底不触发）。
-*/
-async function waitForTurnAssistant(ctx, agent, beforeAssistantCount, opts = {}) {
-	const timeoutMs = opts.timeoutMs ?? ASK_TURN_TIMEOUT_MS;
-	const grew = () => countAssistantMessages(agent.session) > beforeAssistantCount;
-	if (await Promise.race([waitAgentIdle(ctx, agent).then(() => true), new Promise((resolve) => {
-		setTimeout(() => resolve(false), timeoutMs);
-	})])) return grew();
-	return grew();
-}
-/**
-* 提问一轮：followup → 等**本轮**回答 → 读答案。
-*
-* @param options.timeoutMs 本轮等待上限（测试注入；生产用缺省）
-*/
-async function askTrajectory(ctx, agent, question, options) {
-	const beforeAssistant = countAssistantMessages(agent.session);
-	agent.followup(createUserMessage({
-		content: [{
-			type: "text",
-			text: question
-		}],
-		source: PLUGIN_SOURCE
-	}));
-	return {
-		answer: await waitForTurnAssistant(ctx, agent, beforeAssistant, { timeoutMs: options?.timeoutMs }) ? lastAssistantText$1(agent) : "",
-		sessionId: String(agent.session.id ?? "")
-	};
-}
-/**
-* 轨迹约束会话的轨迹纪律参与判定：**不是 轨迹约束恒 true**（正常参与）；
-* 轨迹约束 按 `trajectory-constraint.json` 的 `cognitiveTrajectory` 子集决定。
-*
-* 注册表缺失（进程刚重启、绑定还没读）⇒ 由 `trajectoryConstraintForSession` 回落持久绑定；
-* 两者都不中 ⇒ 判"不是 轨迹约束" ⇒ 恒 true（正常参与）。**fail-open 是有意的**：
-* 纪律参与项的失败不该让会话失去 keeper/rebuild（那是能力倒退，比多跑一次更糟）。
-*/
-function trajectoryConstraintParticipates(root, sessionId, key) {
-	if (sessionId === void 0) return true;
-	const profile = trajectoryConstraintFor(root, sessionId);
-	if (profile === null) return true;
-	return constraintCognitiveTrajectory(profile)[key];
-}
-/**
-* `msm` 工具的 轨迹约束门控：非 轨迹约束恒放行；轨迹约束会话——
-* exec 非白名单 MSM 拒绝（**不列名单**）、register/deregister 必拒、
-* list 白名单过滤、check/guide/ccc-config 只读放行。
-*/
-function trajectoryConstraintMsmGate(root, sessionId, action, name) {
-	if (sessionId === void 0) return {};
-	const profile = trajectoryConstraintFor(root, sessionId);
-	if (profile === null) return {};
-	if (action === "register" || action === "deregister") return { reject: "register/deregister is not allowed in trajectory-constraint sessions" };
-	if (action === "exec") {
-		if (!name || !profile.msms.includes(name)) return { reject: "MSM not allowed" };
-		return {};
-	}
-	if (action === "list") return { whitelist: profileMsmWhitelist(profile) };
-	return {};
-}
-//#endregion
 //#region src/tools/msm/index.ts
 /**
 * tools/msm/index.ts — msm 工具（v1.30 重构：单入口执行，list/exec 合一）
@@ -12443,6 +9960,107 @@ ${renderCroSampleSnapshot()}
 **吃一份快照，吐一行决策。先自测，绿了再改名。**
 `;
 //#endregion
+//#region src/trajectory/resident.ts
+/**
+* trajectory/resident.ts — **常驻名单**（D173 的兑现口，`cognitive_trajectory resident` 的实现）
+*
+* ## 这条能力的判据（owner 2026-10-20 原话，逐字）
+*
+* > 「常驻的意思就是**自己声明为自己欢迎别人来麻烦自己**，和永不休眠没啥关系，
+* >   **trajectory never ends 悖论的一种实现**」
+*
+* ⇒ **常驻不是资源状态**。它不是"永不休眠"、不是"常驻内存"、不是"不许销毁我的会话"。
+*   一条轨迹**永远存在**（没有生命周期），常驻与否都不改变这一点。
+*
+* ⇒ **它管的是「被找到」，不是「不被销毁」。**
+*   两件事混为一谈，就会去动调度器的载体生命周期 —— 那正是本轨反复踩的"名字撒谎"。
+*
+* ## 因此本模块的三条硬边界
+*
+* 1. **纯读**：不写任何文件、不碰注册表、不碰 `wake/scheduler.ts`。
+* 2. **不进系统提示词**（owner 裁决 Q2：说明类信息按需取，不占每轮 token）。
+* 3. **只报写了 `serves` 的轨迹** —— 只写半个（有 `resident` 没 `serves`）等于
+*    "把自己挂上去却不说能干什么"，按手册的判据那比不写更坏，所以**不列出来**，
+*    但要**单独数出**来，让写的人知道自己的写法没生效。
+*
+* ## 归属（D23）
+* 机制在 ACC（怎么找、按什么顺序、列什么字段）；内容在 CCC（`serves` 那句话写什么）。
+*/
+/**
+* 列出全部**可被找到**的轨迹（按编码排序，确定性）。
+*
+* ⚠️ 读盘失败 / 坏 JSON 一律**跳过该条**（不抛）：一份坏的声明不该让整张名单拿不到。
+*
+* @param root CCC 根
+*/
+function collectResident(root) {
+	const entries = [];
+	const incomplete = [];
+	let names = [];
+	try {
+		names = readdirSync(sessionsRoot(root), { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name);
+	} catch {
+		return {
+			entries,
+			incomplete
+		};
+	}
+	for (const dirName of names) {
+		let profile;
+		try {
+			profile = readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
+		} catch {
+			continue;
+		}
+		if (!profile || profile.resident === void 0) continue;
+		const serves = profile.resident.serves;
+		if (serves === void 0 || serves === "") {
+			incomplete.push(profile.code);
+			continue;
+		}
+		entries.push({
+			code: profile.code,
+			dirName: profile.dirName,
+			serves,
+			...profile.model !== void 0 ? { model: profile.model } : {}
+		});
+	}
+	entries.sort((a, b) => a.code < b.code ? -1 : a.code > b.code ? 1 : 0);
+	incomplete.sort();
+	return {
+		entries,
+		incomplete
+	};
+}
+/**
+* 渲染成给模型读的文本（`cognitive_trajectory resident` 的返回值）。
+*
+* 🔴 **空名单也是有效结果**，且必须说清"这意味着什么" —— 否则读者会以为工具坏了。
+*/
+function listResident(root) {
+	const { entries, incomplete } = collectResident(root);
+	const lines = ["═══ 常驻轨迹（自己声明「欢迎别人来麻烦我」）═══", ""];
+	if (entries.length === 0) {
+		lines.push("  （本 CCC 暂无轨迹声明常驻）");
+		lines.push("  ⇒ 这不是错误：常驻是**自愿的自我声明**，没写就是\"不参与被找\"。");
+	} else for (const e of entries) {
+		const model = e.model !== void 0 ? `  [model: ${e.model}]` : "";
+		lines.push(`  · ${e.code}${model}`);
+		lines.push(`      ${e.serves}`);
+	}
+	if (incomplete.length > 0) {
+		lines.push("");
+		lines.push(`  ⚠️ 写了 resident 但**没写 serves**（不会被列出）：${incomplete.join("、")}`);
+		lines.push("     只写半个 = 把自己挂上去却不说能干什么 —— 别人会来问，然后发现问错了人。");
+	}
+	lines.push("");
+	lines.push("── 怎么让自己出现在这里 ──");
+	lines.push("  在你这条轨迹目录的 trajectory.json 里写：");
+	lines.push("    { \"resident\": { \"serves\": \"一句话说清我擅长什么、能帮上什么忙\" } }");
+	lines.push("  ⚠️ 只写这一个字段**不影响任何默认行为**（D183）；其余 key 全部可选。");
+	return lines.join("\n");
+}
+//#endregion
 //#region src/tools/cognitive-trajectory.ts
 /**
 * trajectory.ts — `cognitive_trajectory` 真实 DSH 工具定义（defineTool）
@@ -12640,7 +10258,8 @@ function createCognitiveTrajectoryTool(ctx) {
 					"DELIVERY (sends one message to ANOTHER cognitive trajectory; your binding is unchanged):",
 					"send-now (deliver RIGHT NOW; the target needs no prior setup — if it has no live session, one is created and bound automatically) /",
 					"send-later (one future instant + one message; fire-and-forget, and it does NOT auto-create a target).",
-					"REFERENCE: cro-guide (no parameters: prints the CRO programming guide, including a ready-to-use sample snapshot)"
+					"REFERENCE: cro-guide (no parameters: prints the CRO programming guide, including a ready-to-use sample snapshot) /",
+					"resident (READ-ONLY: the roster of trajectories that declared themselves RESIDENT — \"I am here, this is what I am good at, come bother me\". It lists each code with its own `serves` sentence, plus any code that wrote `resident` without `serves` (half a declaration is worse than none: people ask, then find they asked the wrong one). ⚠️ Residency is NOT a resource state — it does not mean \"never sleeps\" or \"never destroyed\"; a trajectory permanently exists either way. It governs BEING FOUND, not being kept alive, and it never touches the scheduler)."
 				].join(" ")
 			},
 			name: {
@@ -12860,6 +10479,21 @@ function createCognitiveTrajectoryTool(ctx) {
 					};
 				}
 				case "cro-guide": return CRO_GUIDE;
+				case "resident":
+ /**
+				* 常驻名单（D173 兑现，owner 2026-10-20）。
+				*
+				* 🔴 **这个动作的存在本身就是一条判据**：v1.77.1 的手册曾承诺"通过本工具的
+				* 常驻名单动作按需查询"，而**那个动作当时并不存在**（D179(a)，S196 踩到）。
+				* ⇒ 现在它真的存在了。
+				*
+				* 🔴 **纯读**（不碰 fs 写、不碰注册表、不碰调度器）：D173 的判据是
+				* 「常驻」管的是**被找到**，不是**不被销毁** —— 两件事混为一谈就会去动
+				* `wake/scheduler.ts` 的载体生命周期，那正是本轨反复踩的"名字撒谎"。
+				*
+				* 🔴 **不进系统提示词**（owner 裁决 Q2：说明类信息按需取，不占每轮 token）。
+				*/
+				return listResident(root);
 				default: throw new Error(`Unknown action: ${args.action}`);
 			}
 		}
@@ -12986,26 +10620,33 @@ becomes a 轨迹约束; delete it and it goes back to being an ordinary trajecto
 
 ── ${TRAJECTORY_CONSTRAINT_FILENAME} schema（限制面部分）──
   {
-    "model": "provider/model",          // optional; falls back to cheap-worker.defaultModel
-    "tools": ["read","grep","msm",...], // non-MSM toolbar whitelist — anything not listed is REMOVED from the schema
-    "msms":  ["msm-a","msm-b"],         // MSM whitelist — msm exec may only run these; register/deregister always refused
-    "cognitiveTrajectory": { "session": true, "keeper": true, "rebuild": true },  // defaults TRUE (see below)
+    "model": "provider/model",          // optional; **不写 = 用会话当前模型**（不回退 cheap-worker；每轮生效）
+    "tools": ["read","grep","msm",...], // optional; **不写 = 不收窄**。显式 [] = 全隐藏（除 skill）
+    "msms":  ["msm-a","msm-b"],         // optional; **不写 = 不收窄**。register/deregister 恒拒
+    "cognitiveTrajectory": { "session": true, "keeper": true, "rebuild": true },  // 缺省 TRUE（见下）
+    "resident": { "serves": "..." },    // optional; 对外用途自述（见 trajectory-self 章）
     "cro": { "host": "<machine name>" } // optional: which machine may run this trajectory's CRO program
   }
 
+  🔴 **所有 key 都是可选的：不写 = 不设定 = 不影响默认行为**（owner 2026-10-20 裁决）。
+     ⛔ **"没写" ≠ "写了空数组"**：\`"tools": []\` 是"我一个都不给"（除 \`skill\` 外全隐藏）；
+        **不写 \`tools\`** 是"不收窄"。这两者在旧版被混成同一个意思，害人把自己锁死过。
+
   ⚠️ 提示词**不在这里**（新形态）：写 \`PROMPT.md\` 即可，**所有轨迹**都适用。
      旧字段 \`systemPromptFile\` / \`systemPrompt\` 属**兼容期**形态，仍在读、但不再推荐；
      两者同时存在时 \`PROMPT.md\` 让位规则见 \`trajectory/prompt.ts\`（此处不重复）。
 
-  ⚠️ **只想声明常驻、不想限制自己**：只写 \`"resident"\` 字段、**不写 tools/msms**。
-     空白名单 = **不收窄任何工具面**（见下方"两个默认"）—— 但请注意你仍因此"成为轨迹约束"，
-     只是没有实际限制。
+  ⚠️ **只想声明常驻、不想限制自己**：只写 \`"resident"\` 字段，**tools/msms 一个都不要写**。
+     ⇒ 不收窄任何工具面（见下方"两个默认"）。⛔ **不要**为了"空着"而写 \`"tools": []\` —— 那是全隐藏。
 
-── Two whitelists, both default-deny ──
-  - \`tools: []\` + non-empty \`msms\` = pure-MSM 轨迹约束 (the usual knowledge-QA shape)
-  - 空 \`tools\` + 空 \`msms\` = **无限制**（普通行为；常驻自述用的就是这一格）
+── Two whitelists: UNSET means unrestricted, EMPTY means nothing ──
+  - **字段缺省（没写）** = **不收窄**（这条轨迹只放别的设定，比如只写 resident）
+  - \`"tools": []\`（显式空数组）= **全隐藏**，除恒可用的 \`skill\`
+  - \`tools\` + non-empty \`msms\` = pure-MSM trajectory (the usual knowledge-QA shape)
   - non-empty \`msms\` ⇒ the \`msm\` tool is added automatically (the only entry point for MSMs)
-  - anything outside both lists is invisible in the schema, not merely rejected at call time
+  - anything outside a **declared** whitelist is invisible in the schema, not merely rejected at call time
+  🔴 判据是**字段在不在**，不是**数组空不空**（D181）。旧版把两者混成"空 = 全拒"，
+     于是「只想声明常驻」的人被静默锁死 —— 那是本仓实测踩过的坑（D179(b)）。
 
 ── cognitiveTrajectory: why the defaults are TRUE ──
   The workspace of a 轨迹约束 is its own SESSION.md. Setting these to false would cut it off from
@@ -13046,7 +10687,7 @@ function validateTrajectoryConstraint(root) {
 				return true;
 			}
 		})())) issues.push(`trajectory "${p.code}": no trajectory prompt (add ${TRAJECTORY_PROMPT_FILENAME} in the trajectory dir — recommended — or the legacy systemPromptFile/systemPrompt)`);
-		for (const m of p.msms) if (!registered.has(m)) issues.push(`trajectory "${p.code}": msms "${m}" is not registered in mech-registry.json`);
+		for (const m of p.msms ?? []) if (!registered.has(m)) issues.push(`trajectory "${p.code}": msms "${m}" is not registered in mech-registry.json`);
 		if (p.model && allowedModels && !allowedModels.has(p.model)) issues.push(`trajectory "${p.code}": model "${p.model}" not in cheap-worker.models (${[...allowedModels].join(", ") || "(none)"})`);
 	}
 	return {
@@ -13062,16 +10703,29 @@ function listTrajectoryConstraintSummary(root) {
 		roles: [],
 		note: `no 轨迹约束 trajectories in this CCC (no trajectory has ${TRAJECTORY_CONSTRAINT_FILENAME})`
 	};
-	const items = profiles.map((p) => ({
-		name: p.code,
-		dirName: p.dirName,
-		model: p.model ?? "(cheap-worker default)",
-		msms: p.msms,
-		tools: p.tools,
-		cognitiveTrajectory: constraintCognitiveTrajectory(p),
-		promptSource: constraintSystemPromptSource(p, hasTrajectoryPrompt(root, p.dirName)),
-		...p.systemPromptFile ? { systemPromptFile: p.systemPromptFile } : {}
-	}));
+	const items = profiles.map((p) => {
+		/**
+		* 🔴 三个字段的读数必须**如实表达三态**（D179(c)＋D181，S196 就是被这里的旧读数误导的）。
+		*
+		* | 文件里 | 打印 | 为什么不能印别的 |
+		* |---|---|---|
+		* | 没写 `model` | `'(unchanged)'` | 旧文案印 `'(cheap-worker default)'` ⇒ **暗示会回退到杂工模型**，而实际是**不动**。那是一次**空头承诺**：用户以为要被换模型，其实是误解 |
+		* | 没写 `tools`/`msms` | `'(unrestricted)'` | 缺省 = **不收窄**（D181）。印 `[]` 会让人以为"我被全隐藏了" |
+		* | 写了 `[]` | `'[]'` | 显式空数组 = **全隐藏**，与上一行**恰好相反**，必须能一眼分辨 |
+		*/
+		const wl = (v, whenUnset) => v === void 0 ? whenUnset : v;
+		return {
+			name: p.code,
+			dirName: p.dirName,
+			model: p.model ?? "(unchanged)",
+			msms: wl(p.msms, "(unrestricted)"),
+			tools: wl(p.tools, "(unrestricted)"),
+			...p.resident !== void 0 ? { resident: p.resident.serves !== void 0 ? p.resident.serves : "(no serves)" } : {},
+			cognitiveTrajectory: constraintCognitiveTrajectory(p),
+			promptSource: constraintSystemPromptSource(p, hasTrajectoryPrompt(root, p.dirName)),
+			...p.systemPromptFile ? { systemPromptFile: p.systemPromptFile } : {}
+		};
+	});
 	return {
 		roles: items,
 		count: items.length
@@ -13153,28 +10807,46 @@ const TRAJECTORY_SELF_GUIDE = [
      只写半个（有字段、没 serves）等于把自己挂上去却不说能干什么 —— 那比不写更坏，
      因为别人会来问，然后发现问错了人。
 
-  谁能看见：通过 cognitive_trajectory 的常驻名单动作按需查询。
+  谁能看见：\`cognitive_trajectory\` 的 **\`resident\` 动作**（只读发现）。
      **它不进系统提示词**（不占每个请求的 token）—— 只在有人真的要找人时才读。
-     这是 owner 2026-10-20 的裁决：说明类信息按需取，不常驻在上下文里。`,
+     这是 owner 2026-10-20 的裁决：说明类信息按需取，不常驻在上下文里。
+
+  🔴 它**不碰任何默认行为**（D183）：只写 resident 的轨迹，ACC 身份注入、首轮锚定、
+     自动恢复、compact 重注入 **全部照常**。常驻管的是**被找到**，不是**不被销毁**。`,
 	"",
-	`── 想限制自己（白名单 / 模型 / 纪律参与项）──
+	`── 🔴 所有 key 都是可选的：不写 = 不设定 = 不影响默认行为 ──
 
-  写 \`trajectory.json\` 即成为**轨迹约束**（判据是**文件存在**，不是某个字段存在）。
-  删掉它 ⇒ 当场退回普通轨迹。
+  这条是总规则（owner 2026-10-20 裁决）。下面逐字段说清"不写会怎样"：
 
-  ⚠️ 一个必须知道的连带后果：**写 trajectory.json 会把我变成受约束的轨迹**。
-     所以如果你只想"描述自己"（章程、常驻），**不需要**建这个文件 ——
-     章程走 PROMPT.md；常驻字段确实也在这个文件里，但**只写 resident、不写 tools/msms**
-     时，白名单为空 = 不收窄任何工具面（见下一章"两个默认"）。
+  | 字段 | 不写它 | 生效时机 |
+  |---|---|---|
+  | \`model\` | 用会话当前的模型（**不会**回退到 cheap-worker） | **每轮**（改文件下一轮即生效） |
+  | \`tools\` | **不收窄**工具面 | 每轮 |
+  | \`msms\` | **不收窄** MSM 面 | 每轮 |
+  | \`resident\` | 不出现在常驻名单里（不参与"被找"） | 每轮 |
+  | \`cognitiveTrajectory\` | 三项纪律全参与（true） | 每轮 |
+  | \`systemPromptFile\` / \`systemPrompt\` | 用 ACC 的通用身份（**不替换**） | 保存即生效 |
+
+  🔴 **"没写" 与 "写了空数组" 是两种意思**：
+      \`"tools": []\`（显式空数组）= **我一个都不给** ⇒ 除 \`skill\` 外全部工具被隐藏。
+      **不写 \`tools\`** = **不收窄** ⇒ 工具面完全不变。
+      ⇒ 想只声明常驻？那就**只写 resident**，别的键一个都不要写。
+
+  🔴 **写 \`trajectory.json\` 本身不改任何默认行为** —— 它只是"我把设定放这儿了"。
+      只有当某个 key **真的取代了默认**（目前唯一一个是自带章程 systemPrompt*）时，
+      这条轨迹才不再注入 ACC 身份。其余字段都不影响。`,
+	"",
+	`── 想限制自己（白名单 / 模型 / 纪律参与项）──
 
   schema、双白名单、纪律参与项的完整说明 → container_admin config docs trajectory-constraint`,
 	"",
 	`── 写完之后怎么验（别只看文档，要能机械判定）──
 
   章程生效了吗    改 PROMPT.md 后**在同一会话里**看下一轮的系统提示词段是否变化（保存即生效）
-  我是轨迹约束吗  container_admin config list  —— 我的编码出现在列表里即成立
-  配置合法吗      container_admin config validate  —— msms 均已注册 / model 在可用表里 / 提示词非空
-  常驻被看见了吗  cognitive_trajectory 的常驻名单动作 —— 我出现在名单里，且 serves 可读
+  我声明了什么    container_admin config list  —— 逐轨迹列出 model/tools/msms 的**生效值**；
+                  没写的字段印 \`(unchanged)\` / \`(unrestricted)\`，不是伪装成某个默认值
+  配置合法吗      container_admin config validate  —— msms 均已注册 / model 在可用表里
+  常驻被看见了吗  cognitive_trajectory action=resident —— 我出现在名单里，且 serves 可读
 
   ⚠️ 以上四项都是**读取当前真实状态**，不是"保存成功"的回执。保存成功 ≠ 生效（本仓反复踩过）。`
 ].join("\n");
@@ -13739,11 +11411,12 @@ function decideGuard(input) {
 	if (input.trajectoryConstraint !== void 0 && input.trajectoryConstraint !== null) {
 		const profile = input.trajectoryConstraint;
 		if (toolName === "skill") return { kind: "allow" };
-		if (profile.msms.includes(toolName)) return {
+		if ((profile.msms ?? []).includes(toolName)) return {
 			deny: `"${toolName}" is a registered MSM, not a direct tool in this trajectory — call it through the msm tool: msm("${toolName}", ["<args>"]) (pass "--help" or inspect=true for usage)`,
 			kind: "deny"
 		};
-		if (!profileToolWhitelist(profile).has(toolName)) return {
+		const whitelist = profileToolWhitelist(profile);
+		if (whitelist !== null && !whitelist.has(toolName)) return {
 			deny: "tool not allowed in this 轨迹约束 trajectory",
 			kind: "deny"
 		};
@@ -14069,6 +11742,15 @@ function syncTrajectoryConstraintToolVisibility(agent, root) {
 		return;
 	}
 	const allowed = profileToolWhitelist(profile);
+	if (allowed === null) {
+		if (existing !== void 0) {
+			try {
+				existing.dispose();
+			} catch {}
+			trajectoryConstraintRestrictions.delete(sessionId);
+		}
+		return;
+	}
 	const resident = REGISTERED_TOOLS.slice(0, REGISTERED_TOOLS.length - 3);
 	const tiers = [REGISTERED_TOOLS, resident];
 	for (const names of tiers) {
@@ -14366,7 +12048,7 @@ const DEFAULT_FAKE_INITIAL_MESSAGES = ["You are the operator agent of Serenity
 * 统一经 sessionEvents() 读取（snapshotEvents() 优先，.events 兜底）。
 */
 function hasUserMessageHistory(session) {
-	return sessionEvents$1(session).some((event) => {
+	return sessionEvents(session).some((event) => {
 		const e = event;
 		if (e.type !== "user/message") return false;
 		return e.data?.source?.kind === "user";
@@ -14511,7 +12193,7 @@ function createEpochPromotion(promoteEvents, requiredSignals = 1, maxRoundsFallb
 		let boundary = -1;
 		let signalCount = 0;
 		let rounds = 0;
-		const events = sessionEvents$1(session);
+		const events = sessionEvents(session);
 		if (events.length > 0) for (const event of events) {
 			const e = event;
 			const seq = typeof e.seq === "number" ? e.seq : 0;
@@ -14550,7 +12232,7 @@ function createEpochPromotion(promoteEvents, requiredSignals = 1, maxRoundsFallb
 			const loopSid = session.id;
 			const loopCwd = session.header?.cwd ?? process.cwd();
 			const loopRoot = cccRootForCwd(loopCwd);
-			if (typeof loopSid === "string" && (loopSid.startsWith("cheap-worker-") || loopRoot !== null && isTrajectoryConstrained(loopRoot, loopSid))) return {
+			if (typeof loopSid === "string" && (loopSid.startsWith("cheap-worker-") || loopRoot !== null && replacesDefaultIdentity(trajectoryConstraintFor(loopRoot, loopSid)))) return {
 				boundary: -1,
 				promoted: true
 			};
@@ -14669,7 +12351,7 @@ function registerBootstrap(ctx) {
 			const depth = session?.header?.delegationDepth ?? 0;
 			const sid = typeof session?.id === "string" ? session.id : void 0;
 			if (sid === void 0) return;
-			if (sid.startsWith("cheap-worker-") || isTrajectoryConstrained(root, sid)) return;
+			if (sid.startsWith("cheap-worker-") || replacesDefaultIdentity(trajectoryConstraintFor(root, sid))) return;
 			if (depth === 0) {
 				if (hasUserMessageHistory(session)) return;
 			} else if (anchoredSessions.has(sid)) return;
@@ -15209,12 +12891,209 @@ function registerKeeper(ctx, opts = {}) {
 	});
 }
 //#endregion
+//#region src/trajectory/model-runtime.ts
+/**
+* trajectory/model-runtime.ts — **`trajectory.json` 的 `model` 字段：每轮求值 ＋ 运行时热切换**
+*
+* ## 这个模块存在的唯一理由（owner 2026-10-20 令，逐字）
+*
+* > 「我认为认知轨迹作为统一概念 **设定不应根据入口不同而有变化 所以应当直接生效 运行时热加载**」
+*
+* ## 旧实现错在哪（D182 的事实底数）
+*
+* `model` 的**唯一消费点**曾是 `createTrajectoryAgent` 建 agent 时，而它的**唯一调用方**是
+* IM 入站路由 ⇒ 对**已经存在的会话**（web 会话、`send-now` 冷启的载体……）**完全不生效**。
+* 而 `container_admin config list` 把它印成 `'(cheap-worker default)'`，看上去像个统一设定。
+* ⇒ **同一个字段在 A 入口生效、在 B 入口不生效** —— 正是 owner 要禁的形态。
+*
+* ## 修法：接宿主**自带**的原语，不复刻语义
+*
+* `@deepseek-ai/dsh-agent` 导出 `installModelSelection(agentCtx, selection)`，它挂三条缝：
+*
+* | 缝 | 作用 |
+* |---|---|
+* | `system-prompt/assemble` | 把选中路由写进提示词变量快照（保证"这一步用哪个模型"一致） |
+* | **`agent/request`** | **把冻结的调用配置替换成 `selection.current`** ⇒ 这就是"下一轮生效" |
+* | `agent/pre-step` | 路由变化时追加 `[model changed: …]` 持久提示 |
+*
+* 🔴 **为什么必须直接调它而不是自己挂 `agent/request`**（本仓既有纪律）：
+* 自己复刻就要重做第三条的三态判断（reject／空步／aborted）与 `requestHeader` 比对，
+* **复刻错了会得到与事实相反的结论**。宿主已实现 ⇒ 直接调用。
+*
+* 🔴 **跨宿主档位**：`_tmp/host-*` 全部 **10 个**快照（`0.1.5-rc.1` … `0.2.1-rc.2`）
+* 逐个核对，该导出**全部存在且签名一致**（唯一差异在宿主内部的提示 `source` 形状，
+* **不由我们构造**）⇒ 无需宿主升级、无需分档分支。
+*
+* ## 三条硬边界（少一条就会重演 S196 的坑）
+*
+* 1. **未写 `model` ⇒ 不装这条缝**（`undefined` 原样返回）。⛔ **绝不回退 `cheap-worker.defaultModel`**
+*    —— 那个回退把"我想声明自述"变成"我被降级到杂工模型"，而用户完全不会预期到。
+* 2. **切换会留下宿主的 `[model changed: …]` 提示**。这是**特性不是噪声**：
+*    否则模型不知道自己换了，它会照旧解释上方那些由**另一个模型**生成的回合。
+* 3. **模型名非法 ⇒ 不切 ＋ 响亮告警**，绝不静默停在旧模型上（"改了没生效"是最难查的一类）。
+*
+* ## 归属（D23）
+* **机制在 ACC**（怎么读、怎么装、何时刷新、非法怎么办）；**内容在 CCC**（`trajectory.json` 写哪个模型）。
+*/
+/**
+* 从轨迹声明里取模型选择（**每轮调用**，故不缓存）。
+*
+* @param root CCC 根
+* @param dirName 轨迹目录名
+* @returns `{ provider?, model }`；**未写 `model` ⇒ `undefined`（= 不动当前模型）**
+*
+* ⚠️ 读盘失败／坏 JSON ⇒ `undefined` 并**不抛**：一次读失败不该让整轮失败
+*   （`readTrajectoryConstraintAt` 内部已对坏 JSON 告警）。
+*/
+function readModelSelection(root, dirName) {
+	let profile;
+	try {
+		profile = readTrajectoryConstraintAt(join(sessionsRoot(root), dirName), root);
+	} catch {
+		return;
+	}
+	const raw = profile?.model?.trim();
+	if (raw === void 0 || raw === "") return void 0;
+	const { provider, model } = splitModel(raw);
+	if (model.trim() === "") return void 0;
+	return provider === void 0 ? { model } : {
+		provider,
+		model
+	};
+}
+/** 已装的模型选择（进程级；`sessionId → selection`，与 tool-restrictions 同构） */
+const installed = /* @__PURE__ */ new Map();
+/** 会话销毁时清理 */
+function forgetModelRuntime(sessionId) {
+	const cur = installed.get(sessionId);
+	if (cur === void 0) return;
+	try {
+		cur.dispose();
+	} catch {}
+	installed.delete(sessionId);
+}
+/**
+* 给这个 agent 装**模型运行时热切换**（每轮重读 `trajectory.json`）。
+*
+* 🔴 **只在轨迹声明了 `model` 时装**（D182 边界 ①）：
+* 装了缝而 `current` 为 `undefined` 会**覆盖**宿主已有的模型选择 ⇒ 等于把会话的模型清空。
+* 故"没写" **必须** 表现为"这条缝不存在"，而不是"缝在、值为空"。
+*
+* 🔴 **每轮刷新**：`agent/pre-step` 每步都调它，求值器**重读磁盘**
+* （`readTrajectoryConstraintAt` 无缓存）⇒ 改 `trajectory.json` 下一轮即生效，
+* **与"谁创建了这个会话"无关**（这就是 owner 的令）。
+*
+* @param agent 目标 agent
+* @param root CCC 根
+* @param dirName 该 agent 绑定的轨迹目录名
+* @returns 是否装了缝（`false` = 该轨迹没声明 model，未改动任何东西）
+*/
+function syncTrajectoryModel(agent, root, dirName) {
+	const sessionId = agent.session?.id ?? "global";
+	const wanted = readModelSelection(root, dirName);
+	if (wanted === void 0) {
+		forgetModelRuntime(sessionId);
+		return false;
+	}
+	const existing = installed.get(sessionId);
+	if (existing !== void 0) {
+		existing.current = wanted;
+		return true;
+	}
+	const install = resolveInstallModelSelection();
+	if (install === null) {
+		console.warn(`[serenity-hooks] ✗ 轨迹 "${dirName}" 声明了 model，但**宿主未导出 installModelSelection** ⇒ 模型热切换无法生效（当前会话模型保持不变）。这是宿主契约变化，请核对 @deepseek-ai/dsh-agent 的导出。`);
+		return false;
+	}
+	const selection = {
+		current: wanted,
+		assembled: void 0
+	};
+	try {
+		const dispose = install(agent.ctx, selection);
+		installed.set(sessionId, {
+			...selection,
+			dispose
+		});
+		return true;
+	} catch (err) {
+		console.warn(`[serenity-hooks] ✗ 轨迹 "${dirName}" 的模型热切换装配失败（会话模型保持不变）: ${String(err?.message ?? err)}`);
+		return false;
+	}
+}
+/**
+* 取宿主的 `installModelSelection`。
+*
+* 🔴 **为什么是 `createRequire` 动态取，而不是顶层 `import`**（R↓，两个理由）：
+* ① 本仓对 `@deepseek-ai/dsh-agent` 的**全部**引用此前都是 `import type`（零运行时依赖）；
+*    改成顶层运行时 import 会把它变成**硬依赖**——而它是 `peerDependencies`，
+*    宿主没装好时**整个插件起不来**，那比"模型不切换"严重得多。
+* ② 这是一个**可选能力**：拿不到就告警并保持会话原模型（`null` 分支），插件其余部分照常工作。
+*
+* ⚠️ 本仓是 ESM（`package.json` `"type": "module"`）⇒ **裸 `require` 不可用**，
+* 必须走 `createRequire(import.meta.url)`（同 `diagram/rasterize.ts` 的既有做法）。
+*
+* ⚠️ 解析结果**缓存**（成功或确实没有都缓存）：避免每轮重复 require 与重复告警刷屏。
+*/
+let resolveCache;
+function resolveInstallModelSelection() {
+	if (resolveCache !== void 0) return resolveCache;
+	try {
+		const mod = createRequire(import.meta.url)("@deepseek-ai/dsh-agent");
+		resolveCache = typeof mod.installModelSelection === "function" ? mod.installModelSelection : null;
+	} catch {
+		resolveCache = null;
+	}
+	return resolveCache;
+}
+//#endregion
 //#region src/seams/context.ts
+/**
+* 该会话的轨迹**是否自带章程**（= 该不该旁路 ACC 身份类默认行为）。D183。
+*
+* 🔴 判据唯一入口 = `replacesDefaultIdentity`（见 `policy/profile.ts` 的判据表）。
+* ⛔ 不要在这里写 `isTrajectoryConstrained` —— 那个只回答"有没有声明"，
+* 用它做旁路就是 owner 2026-10-20 指出的那个 bug（只写 resident 也丢身份）。
+*/
+function hasTrajectoryOwnCharter(root, sessionId) {
+	if (typeof sessionId !== "string" || sessionId === "") return false;
+	try {
+		return replacesDefaultIdentity(trajectoryConstraintFor(root, sessionId));
+	} catch {
+		return false;
+	}
+}
+/**
+* 该 agent 绑定的轨迹目录名（没有 ⇒ `null`）。
+*
+* 🔴 判据唯一入口 = `trajectoryConstraintFor`（它内部并取"持久绑定 + 内存注册表"两来源，
+* 见 `policy/profile.ts` 的 R↓）。⛔ 不要在这里另写一套解析 —— 两份判据会漂。
+*/
+function trajectoryDirNameOf(agent, root) {
+	const sessionId = agent.session?.id;
+	if (typeof sessionId !== "string" || sessionId === "") return null;
+	try {
+		return trajectoryConstraintFor(root, sessionId)?.dirName ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 同步该 agent 的**模型热切换**（D182）。
+*
+* 🔴 把它做成"按 agent 解析目录名 ⇒ 交给 `trajectory/model-runtime`"的薄适配，
+* 是为了让 `model-runtime` 保持**零 seams 依赖**（可独立单测）。
+*/
+function syncTrajectoryModelForSession(agent, root) {
+	const dirName = trajectoryDirNameOf(agent, root);
+	if (dirName === null) return;
+	syncTrajectoryModel(agent, root, dirName);
+}
 const DEFAULT_ENTRY_SKILL_MAX_CHARS = 3e4;
 /** 从 dsh 会话日志读标题（latest-wins `session/title` 事件；无返回 null）——供标题 reconcile（U3） */
 function readDshSessionTitle(session) {
 	try {
-		const events = sessionEvents$1(session);
+		const events = sessionEvents(session);
 		for (let i = events.length - 1; i >= 0; i--) {
 			const e = events[i];
 			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
@@ -15279,7 +13158,7 @@ function shouldAutoRestore(agent, root) {
 	if (session.header?.parentSession) return false;
 	if (session.id?.startsWith("cheap-worker-")) return false;
 	const cccRoot = root !== void 0 ? root : cccRootForCwd(session.header?.cwd ?? process.cwd());
-	if (cccRoot && isTrajectoryConstrained(cccRoot, session.id)) return false;
+	if (cccRoot && hasTrajectoryOwnCharter(cccRoot, session.id)) return false;
 	return true;
 }
 /**
@@ -15289,7 +13168,7 @@ function shouldAutoRestore(agent, root) {
 */
 function shouldRestoreActive(agent, root) {
 	if (!shouldAutoRestore(agent, root)) return false;
-	return sessionEvents$1(agent.session).length > 0;
+	return sessionEvents(agent.session).length > 0;
 }
 function registerContext(ctx, opts = {}) {
 	const configPaths = opts.configPaths ?? DEFAULT_SERENITY_CONFIG_PATHS;
@@ -15302,7 +13181,7 @@ function registerContext(ctx, opts = {}) {
 		} catch {}
 		if (!root) return;
 		const key = agentKey(agent);
-		if (isTrajectoryConstrained(root, key)) return;
+		if (hasTrajectoryOwnCharter(root, key)) return;
 		registerEntrySkillSection(agent, root);
 		registerCognitiveTrajectorySkillSection(agent, root);
 		const scope = agentScope(agent);
@@ -15320,7 +13199,7 @@ function registerContext(ctx, opts = {}) {
 					};
 				}
 				if (!restored) {
-					const info = parseSessionContextFromEvents(sessionEvents$1(dshSession));
+					const info = parseSessionContextFromEvents(sessionEvents(dshSession));
 					if (info) {
 						const abs = info.mdPath.startsWith(root) ? info.mdPath : resolve(root, info.mdPath);
 						if (existsSync(abs)) restored = {
@@ -15373,6 +13252,9 @@ function registerContext(ctx, opts = {}) {
 		try {
 			syncHostScheduleToolHiding(agent, root);
 		} catch {}
+		try {
+			syncTrajectoryModelForSession(agent, root);
+		} catch {}
 	};
 	if (opts.seedOnStart ?? true) ctx.on("agent/created", async (payload) => {
 		try {
@@ -15385,10 +13267,15 @@ function registerContext(ctx, opts = {}) {
 		const root = cccRootForCwd(cwd);
 		const key = agentKey(agent);
 		const downstream = await next();
-		if (root) try {
-			syncTrajectoryConstraintToolVisibility(agent, root);
-		} catch {}
-		if (root && isTrajectoryConstrained(root, key)) return downstream;
+		if (root) {
+			try {
+				syncTrajectoryConstraintToolVisibility(agent, root);
+			} catch {}
+			try {
+				syncTrajectoryModelForSession(agent, root);
+			} catch {}
+		}
+		if (root && hasTrajectoryOwnCharter(root, key)) return downstream;
 		try {
 			syncCccToolVisibility(agent, root);
 		} catch {}
@@ -15437,7 +13324,10 @@ function registerCompactRetention(ctx, opts = {}) {
 		const cwd = agent.session?.header?.cwd ?? process.cwd();
 		const root = cccRootForCwd(cwd);
 		if (!root) return;
-		if (isTrajectoryConstrained(root, String(session.id ?? ""))) return;
+		const sid = String(session.id ?? "");
+		try {
+			if (replacesDefaultIdentity(trajectoryConstraintFor(root, sid))) return;
+		} catch {}
 		try {
 			agent.inject(accMessage(root, configPaths, entrySkillMaxChars));
 		} catch {}
@@ -15932,7 +13822,8 @@ function registerStatusApi(ctx, opts = {}) {
 					const settings = readAdvancedSettings();
 					let known = [];
 					try {
-						known = projectKnownWorkspaces(hostService(ctx, "workspaceRegistry")?.list?.() ?? [], settings.gateway.workspaces);
+						const registry = hostService(ctx, "workspaceRegistry");
+						known = projectKnownWorkspaces(registry?.list?.() ?? [], settings.gateway.workspaces);
 					} catch {}
 					sendJson$2(res, 200, {
 						config: toWire(settings),
@@ -15942,7 +13833,8 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (req.method === "PUT") {
 					const raw = await readBody$2(req, 131072);
-					const saved = applyWirePatch(JSON.parse(raw).config ?? {});
+					const body = JSON.parse(raw);
+					const saved = applyWirePatch(body.config ?? {});
 					try {
 						ctx.emit?.("serenity/config-updated");
 					} catch {}
@@ -15992,11 +13884,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { readWeixinSettings } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 					const { weixinBridgeStatus } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { imCredentialBound } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { imCredentialBound } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 					const { normalizeAccountChannel } = await import("./accounts-BHQbakUh.js").then((n) => n.t);
 					const accounts = (settings.accounts ?? []).map((a) => {
 						const channel = normalizeAccountChannel(a.channel);
@@ -16033,7 +13925,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { fetchQRCode } = await import("./ilink-BMk2w2KY.js").then((n) => n.a);
 					const { randomUUID } = await import("node:crypto");
 					for (const [key, v] of weixinLogins) if (Date.now() - v.startedAt > WEIXIN_LOGIN_TTL_MS) weixinLogins.delete(key);
-					const { readWeixinSettings } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { readWeixinSettings } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -16054,7 +13946,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { removeWeixinAccount } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -16080,8 +13972,8 @@ function registerStatusApi(ctx, opts = {}) {
 							trajectory: code
 						});
 					}
-					const { saveWeixinRoutes } = await import("./route-COOFLTpU.js").then((n) => n.c);
-					const { findDirNameByCode } = await import("./profile-DplLGGqo.js").then((n) => n.i);
+					const { saveWeixinRoutes } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
+					const { findDirNameByCode } = await import("./profile-C7BuyZK7.js").then((n) => n.i);
 					for (const r of routes) if (findDirNameByCode(root, r.trajectory) === null) {
 						sendJson$2(res, 400, { error: `unknown trajectory: ${r.trajectory} (no such trajectory code in ${root})` });
 						return;
@@ -16092,7 +13984,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -16115,7 +14007,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$2(res, 400, { error: "appId 与 appSecret 都必须填（只填一个等于没绑）" });
 						return;
 					}
-					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					const before = readWeixinSettings(root);
 					const accountId = (body.accountId ?? "").trim() !== "" ? body.accountId.trim() : nextFeishuAccountId(before);
@@ -16165,7 +14057,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./ilink-BMk2w2KY.js").then((n) => n.a);
-				const { readWeixinSettings } = await import("./route-COOFLTpU.js").then((n) => n.c);
+				const { readWeixinSettings } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -16180,7 +14072,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-COOFLTpU.js").then((n) => n.c);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-Dr0SFD8A.js").then((n) => n.c);
 						const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -18193,7 +16085,7 @@ function parseAnchorMdPath(session) {
 	try {
 		const nodes = [...session.surface.nodes];
 		if (nodes.length === 0) return null;
-		const events = sessionEvents$1(session);
+		const events = sessionEvents(session);
 		if (events.length === 0) return null;
 		const event = events[nodes[0]];
 		if (!event) return null;
@@ -18229,7 +16121,7 @@ function sessionNameFromMdPath(mdPath) {
 function resolveSessionMdPath(root, scope, session) {
 	const candidates = [];
 	candidates.push(getActiveSessionInfo(scope)?.mdPath ?? null);
-	const events = sessionEvents$1(session);
+	const events = sessionEvents(session);
 	if (events.length > 0) candidates.push(parseSessionContextFromEvents(events)?.mdPath ?? null);
 	candidates.push(readLastBound(session)?.mdPath ?? null);
 	candidates.push(parseAnchorMdPath(session));
@@ -18342,7 +16234,7 @@ function performRebuild(session, pending, meter) {
 	if (targets.length === 0) return false;
 	if (meter) {
 		let shadowedTokenCount = 0;
-		const events = sessionEvents$1(session);
+		const events = sessionEvents(session);
 		for (const seq of targets) {
 			const event = events[seq];
 			if (!event) continue;
@@ -20388,7 +18280,7 @@ function isExternalFaceSession(sessionId, root) {
 *  否则 think 内提及内部机制词（思考过程必然推演机制）会误打回。复用 stripThink
 *  （v1.26.8 状态机，弃正则——同 v1.27.1 微信桥回复链路）。 */
 function lastAssistantText(agent) {
-	const events = sessionEvents$1(agent.session);
+	const events = sessionEvents(agent.session);
 	for (let i = events.length - 1; i >= 0; i--) {
 		const e = events[i];
 		if (e && e.type === "assistant/message") {
@@ -21063,7 +18955,7 @@ const MEDIA_MAX_BYTES = 20971520;
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-rwgzt_0F.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-D3ty1C8P.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -21131,7 +19023,7 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const { findDirNameByCode } = await import("./profile-DplLGGqo.js").then((n) => n.i);
+	const { findDirNameByCode } = await import("./profile-C7BuyZK7.js").then((n) => n.i);
 	if (findDirNameByCode(root, target.role) === null) {
 		const detail = `目标 CCC "${target.ccc}" 内没有编码为 "${target.role}" 的认知轨迹`;
 		console.error(`[serenity-hooks] ✗ human-channel: ${detail}（account=${input.account} user=${input.user}）—— 该消息**未投递**，请改订阅表里的目标编码`);
@@ -21943,7 +19835,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-rwgzt_0F.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-D3ty1C8P.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -22207,7 +20099,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-rwgzt_0F.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-D3ty1C8P.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -23658,7 +21550,7 @@ function createImBridgeTool() {
 */
 function readSessionTitle(session) {
 	try {
-		const events = sessionEvents$1(session);
+		const events = sessionEvents(session);
 		for (let i = events.length - 1; i >= 0; i--) {
 			const e = events[i];
 			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();