@shgroup/dsh-serenity-hooks 1.77.0 → 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）
@@ -12588,50 +10206,41 @@ function createCognitiveTrajectoryTool(ctx) {
 	return defineTool({
 		name: "cognitive_trajectory",
 		description: [
-			"cognitive_trajectory — one cognitive trajectory: its persistent body (SESSION.md) + its timeline.",
-			"A cognitive trajectory is NOT the conversation: SESSION.md is the durable body and never moves;",
-			"the dsh conversation is only its rebuildable carrier (Ship of Theseus — the carrier is replaced, the cognitive trajectory continues).",
-			"IDENTITY: every trajectory has a CODE — the fixed-position segment of its directory name (YYYY-MM-DD--<code>[--<desc>]).",
-			"The code IS the trajectory's unique identifier, and you can choose it at creation time with create --id.",
-			"A COGNITIVE TRAJECTORY HAS NO LIFECYCLE — it does not complete, close, or expire, and age never counts against it;",
-			"it PERMANENTLY EXISTS. The only thing that ever changes is WHERE it is stored: archive moves it out of the active list",
-			"without touching a single byte of its directory or SESSION.md. There is no reverse action — to restore one, use container_fs mv.",
-			"ACTIONS, grouped by EFFECT (read the grouping before picking one):",
+			"A COGNITIVE TRAJECTORY is a durable body (SESSION.md) that outlives every conversation carrying it.",
+			"AXIOM 1 — THE TRAJECTORY IS THE SUBJECT; THE CONVERSATION IS ITS CARRIER. Rebuilding the carrier replaces the conversation and leaves SESSION.md byte-identical.",
+			"AXIOM 2 — A TRAJECTORY HAS NO LIFECYCLE. It never completes, closes, or expires, and age never counts against it. The only thing that changes is WHERE it is stored: archive moves it out of the active list without touching its directory.",
+			"AXIOM 3 — IDENTITY IS THE CODE: the fixed-position segment of the directory name `YYYY-MM-DD--<code>[--<desc>]`. The code (not the summary, not the title) is the unique identifier, and create --id lets you choose it.",
+			"DOES NOT: this tool never deletes a trajectory, never edits SESSION.md content, and never schedules recurring work (that is cro-guide).",
+			"ENTITIES. TRAJECTORY = a directory under AGENT_SESSIONS/ holding SESSION.md. CARRIER = a dsh session bound to it. BINDING DECLARATION = the file `<trajectory>/current.dsh_session_bind` — ONE FILE PER TRAJECTORY, a single slot, never a table.",
+			"IMMUTABLE 1 — ONE SESSION BELONGS TO AT MOST ONE TRAJECTORY, FOR LIFE. use refuses to move a session that already carries a different trajectory. There is NO --force override (retired 2026-10-20; passing it returns a refusal explaining why). To give another trajectory a carrier, open a new session.",
+			"IMMUTABLE 2 — ONE TRAJECTORY HAS AT MOST ONE CURRENT CARRIER, and THE BINDING DECLARATION IS THE ONLY TRUTH. If several dsh sessions happen to be open, only the one named in the declaration carries the trajectory; the others are simply unbound. Never infer a binding from \"a session looks active\".",
+			"IMMUTABLE 3 — A DECLARATION WHOSE SESSION NO LONGER EXISTS COUNTS AS UNBOUND. No cleanup is ever required, and a stale declaration is deliberately left in place: it records who carried this trajectory last.",
+			"ACTIONS, GROUPED BY EFFECT — read the grouping before choosing, because it answers \"does this change what I am bound to?\":",
 			"(A) LIFECYCLE — changes which cognitive trajectory THIS conversation is bound to:",
-			"list (inventory + stats + anomaly marks) / show (read one SESSION.md) / create (make a NEW cognitive trajectory) /",
-			"use (bind THIS conversation to an existing cognitive trajectory; inline integrity check — silent when fine, problems reported as hints, never errors) /",
-			"rebuild (clear-and-rebuild THIS conversation in place) /",
-			"archive (move a trajectory into the archived area so it leaves the active list; one-way, never overwrites, and its content is left byte-identical).",
-			"(B) DELIVERY — sends ONE message to ANOTHER cognitive trajectory; your own binding is unchanged:",
-			"send-now (deliver RIGHT NOW) / send-later (deliver at ONE future instant).",
-			"(C) REFERENCE — cro-guide (how to give THIS cognitive trajectory its own program that decides when it should be woken).",
+			"list (inventory + stats) / show (read one SESSION.md) / create (make a NEW trajectory) / use (bind THIS conversation) / rebuild (clear-and-rebuild THIS conversation in place) / archive (move a trajectory out of the active list; one-way, never overwrites).",
+			"(B) DELIVERY — sends ONE message to ANOTHER trajectory; your own binding is unchanged: send-now (right now) / send-later (one future instant).",
+			"(C) REFERENCE — cro-guide: how to give a trajectory its own program that decides when it should be woken.",
 			"HOW TO CHOOSE (a rule, not a guess):",
-			"not yet bound + starting new work ⇒ create — with no prior binding it activates immediately, so the new cognitive trajectory has a carrier at once.",
-			"already bound + recording a separate future line ⇒ create — it does NOT steal your binding (you stay on the current cognitive trajectory);",
-			"activate the new one when you want it by sending it a message.",
-			"want THIS conversation to move to another cognitive trajectory ⇒ use (refuses when it would orphan the current binding; --force overrides).",
-			"want to poke another cognitive trajectory ⇒ send-now. Its target needs NO prior setup:",
-			"if the target has no live dsh session, one is created and bound automatically, and your message is injected into it.",
-			"RECEIPTS (read no more than is written): send-now returns a synchronous receipt meaning exactly \"injected / turn started\" —",
-			"NEVER \"the target ran or replied\"; to prove the target actually moved, read its SESSION.md.",
-			"It never queues behind the current turn: a busy target is steered mid-turn (read in the CURRENT turn), an idle target starts a turn at once.",
+			"not yet bound + starting new work ⇒ create (with no prior binding it activates immediately, so the new trajectory has a carrier at once).",
+			"already bound + recording a SEPARATE future line ⇒ create (it does NOT steal your binding; activate the new one later by send-now).",
+			"want THIS conversation to move ⇒ use. It refuses if this session already carries another trajectory (IMMUTABLE 1) — that refusal is the design, not an error to work around.",
+			"want to make another trajectory act ⇒ send-now. The target needs no prior setup: if it has no live session, one is created and bound automatically, and your message is injected.",
+			"RECEIPTS (read no more than is written): send-now returns a synchronous receipt meaning exactly \"injected / turn started\" — NEVER \"the target ran or replied\". To prove the target actually moved, read its SESSION.md.",
+			"send-now never queues behind the current turn: a busy target is steered mid-turn (read in the CURRENT turn), an idle target starts a turn at once.",
 			"send-later is fire-and-forget by design: no receipt, no recall, no panel.",
-			"ASYMMETRY (deliberate — the two differ in whether a missing target is normal): send-now creates a target on demand,",
-			"because sending to a never-used cognitive trajectory is a legitimate intent; send-later does NOT,",
-			"because scheduling for a cognitive trajectory that has never existed is almost always a mistyped name — auto-creating would hide that error behind an empty cognitive trajectory.",
-			"PARAMETERS: create requires --desc <desc> [--id <code>] [--goal] or --issue <ticket> (exactly one) plus --summary (≤20 chars).",
-			"use requires --summary (≤20 chars) and may pass --force to switch away from the currently-bound cognitive trajectory.",
-			"rebuild requires --summary (next-phase summary ≤20 chars) + optional --note (task focus for the rebuilt self).",
-			"send-later requires target (a code or AGENT_SESSIONS dir name) + at (RFC3339 or +30m/+2h) + message.",
-			"send-now requires target + message.",
-			"AUTHORIZATION (read this before creating anything): creating a cognitive trajectory or a dsh carrier costs real work,",
-			"and both are meant to serve a human intent — not to be spawned speculatively. Call create only when the user asked for",
-			"a new line of work (or confirmed it), never to \"tidy up\" or to pre-provision something nobody requested.",
-			"send-now creating a missing carrier on demand is likewise acceptable ONLY for a delivery the user actually wants made;",
-			"it is not a way to start work nobody asked for. When in doubt, ask the user instead of creating.",
-			"⚠️ This is a behavioral rule, not a mechanical gate: nothing stops a careless call. Treat it as etiquette with a cost.",
-			"uid: READS a legacy TRAJECTORY-UID only — setting one is retired (codes replaced it). Use create --id instead.",
-			"The summary is appended to the dsh session title (S###-YYYY-MM-DD-<summary>); the code and date stay server-derived unless you pass --id."
+			"ASYMMETRY (deliberate): send-now may create a missing carrier; send-later NEVER does. Scheduling for a trajectory that never existed is almost always a mistyped name, and auto-creating would hide that error.",
+			"CARRIER GUARD: send-now auto-creates a carrier ONLY for a trajectory that has never had one. If a declaration exists but its session is gone, it refuses and says so — one trajectory keeps one carrier. Two independent gates can refuse: (a) the declared session cannot be resolved at all; (b) it existed and is now gone.",
+			"PARAMETERS: create needs --desc <desc> [--id <code>] [--goal], OR --issue <ticket> (exactly one), PLUS --summary (≤20 chars).",
+			"use needs --name + --summary (≤20 chars). --force is ACCEPTED BUT REFUSED (retired): it exists only to explain why.",
+			"rebuild needs --summary (next-phase, ≤20 chars) + optional --note (≤200 chars, task focus for the rebuilt self).",
+			"send-now needs target + message. send-later needs target + at (RFC3339 with timezone, or +30m / +2h) + message.",
+			"target/name accept a code (S### or custom), a full AGENT_SESSIONS directory name, or a fuzzy keyword.",
+			"AUTHORIZATION (read before creating anything): create and send-now both cost real work and must serve a human intent. Call create only when the user asked for a new line of work (or confirmed it) — never to \"tidy up\" or pre-provision what nobody requested. When in doubt, ask instead of creating. This is a behavioral rule, not a mechanical gate: treat it as etiquette with a cost.",
+			"uid: READS a legacy TRAJECTORY-UID only. Setting one is retired — a trajectory's code is its identity now; use create --id <code>.",
+			"summary is appended to the dsh session title as <code>-<date>-<summary>; the code and date stay server-derived unless you pass --id.",
+			"SELF-DECLARATION MANUAL — how to write your own charter (PROMPT.md), declare yourself resident",
+			"(trajectory.json `resident.serves`), or restrict yourself (tool/model whitelists):",
+			"container_admin config docs trajectory-self. Read it before changing any file in your own directory."
 		].join(" "),
 		parameters: {
 			action: {
@@ -12639,17 +10248,18 @@ function createCognitiveTrajectoryTool(ctx) {
 				enum: [...COGNITIVE_TRAJECTORY_ACTIONS],
 				required: true,
 				description: [
-					"Subcommand — grouped by effect.",
+					"Subcommand — grouped by effect (see Tier 3 of the description).",
 					"LIFECYCLE (changes THIS conversation's binding):",
-					"list (inventory + stats + anomaly marks) / show (a code, dir name, or fuzzy keyword) /",
-					"create (new cognitive trajectory; --id sets its code. Activates itself when you have no binding, otherwise leaves your binding untouched and tells you how to activate it) /",
-					"use (activate context for THIS conversation; inline integrity check — pass silent, problems reported as hints, not errors) /",
+					"list (inventory + stats) / show (a code, dir name, or fuzzy keyword) /",
+					"create (new trajectory; --id sets its code. Activates itself when you have no binding, otherwise leaves your binding untouched and tells you how to activate it) /",
+					"use (activate context for THIS conversation; refuses if this session already carries another trajectory — no override) /",
 					"rebuild (clear-and-rebuild current conversation — requires --summary + optional --note) /",
 					"archive (move a trajectory to the archived area; one-way, refuses to overwrite, content untouched — --dryRun previews).",
 					"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: {
@@ -12686,7 +10296,7 @@ function createCognitiveTrajectoryTool(ctx) {
 			},
 			force: {
 				type: "boolean",
-				description: "use: allow switching away from the currently-bound cognitive trajectory (binding guard override)"
+				description: "use: RETIRED (2026-10-20) — one session belongs to one cognitive trajectory for life, so switching is refused unconditionally. The flag is still ACCEPTED so that an old call gets an explanation instead of an \"unknown argument\" error; it never overrides the guard."
 			},
 			dryRun: {
 				type: "boolean",
@@ -12702,7 +10312,7 @@ function createCognitiveTrajectoryTool(ctx) {
 			},
 			message: {
 				type: "string",
-				description: "send-later/send-now: the single message delivered to the target cognitive trajectory. send-now may create and bind a carrier when the target has no live session — acceptable only for a delivery the user actually wants made (user-intent-driven), not for speculatively starting work."
+				description: "send-later/send-now: the single message delivered to the target cognitive trajectory. send-now may create and bind a carrier ONLY when the target has never had one — acceptable only for a delivery the user actually wants made (user-intent-driven), never for speculatively starting work."
 			}
 		},
 		output: {
@@ -12869,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}`);
 			}
 		}
@@ -12967,46 +10592,69 @@ const localstoreTool = defineTool({
 });
 //#endregion
 //#region src/tools/trajectory-constraint-admin.ts
-/** 轨迹约束 定义教程：概念 ／ `trajectory.json` schema ／ 双白名单 ／ 轨迹纪律 ／ 微信路由 */
-const TRAJECTORY_CONSTRAINT_GUIDE = `═══ 轨迹约束 Guide (2026-10-19 redesigned) ═══
+/**
+* 轨迹约束 定义教程：**只讲「限制面」**（约束面 / 双白名单 / 纪律参与项 / 路由）。
+*
+* 🔴 2026-10-20 拆分（owner 裁 Q2）：本章原先同时承载「描述自己」与「限制自己」。
+* 两者读者与前提不同 —— **描述自己是所有轨迹的常态，限制自己才是特例** ——
+* 故「章程 / 常驻 / 三个载体」已移入 `config docs trajectory-self`。
+* ⛔ **本文件不再重复那份内容**（一个内容一个正文入口，v1.75.0 指针纪律）。
+*/
+const TRAJECTORY_CONSTRAINT_GUIDE = `═══ 轨迹约束 Guide（限制面；2026-10-20 split）═══
 
 **A 轨迹约束 IS a cognitive trajectory — the one whose directory contains \`${TRAJECTORY_CONSTRAINT_FILENAME}\`.**
 That is the whole rule. No role table, no name registry: put the file there and the trajectory
 becomes a 轨迹约束; delete it and it goes back to being an ordinary trajectory (takes effect at once).
 
+⚠️ **本章只讲"限制自己"。** 想写章程（PROMPT.md）或声明常驻（resident）?
+   → \`container_admin config docs trajectory-self\`（那是**所有轨迹**都用得上的自述手册）。
+
   AGENT_SESSIONS/<YYYY-MM-DD--<code>--<desc>>/
     ├─ SESSION.md      ← its persistent body (this IS the workspace — nothing is auto-created)
-    ├─ PROMPT.md       ← its charter (trajectory-level prompt; all trajectories may have one)
+    ├─ PROMPT.md       ← its charter (see trajectory-self; NOT copied here)
     ├─ ${TRAJECTORY_CONSTRAINT_FILENAME}          ← its declaration (this file is what makes it a 轨迹约束)
     └─ continuous-re-occurrence.ts  ← optional CRO program (spawned, never imported)
 
   The older names ${TRAJECTORY_LEGACY_FILENAMES.map((n) => `\`${n}\``).join(" / ")} are still READ
   (the family is checked in that order) — writing goes to \`${TRAJECTORY_FILENAME}\` only.
 
-── ${TRAJECTORY_CONSTRAINT_FILENAME} schema ──
+── ${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)
-    "systemPromptFile": ".opencode/skiff/<role>.md",  // relative to CCC root, hot-reloads on save
-    "systemPrompt": "...",                            // inline fallback; systemPromptFile wins when both are set
-    "uid": "my-handle",                 // optional legacy alias (read-only; the code is the identity now)
+    "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
   }
 
-── Two whitelists, both default-deny ──
-  - \`tools: []\` + non-empty \`msms\` = pure-MSM 轨迹约束 (the usual knowledge-QA shape)
+  🔴 **所有 key 都是可选的：不写 = 不设定 = 不影响默认行为**（owner 2026-10-20 裁决）。
+     ⛔ **"没写" ≠ "写了空数组"**：\`"tools": []\` 是"我一个都不给"（除 \`skill\` 外全隐藏）；
+        **不写 \`tools\`** 是"不收窄"。这两者在旧版被混成同一个意思，害人把自己锁死过。
+
+  ⚠️ 提示词**不在这里**（新形态）：写 \`PROMPT.md\` 即可，**所有轨迹**都适用。
+     旧字段 \`systemPromptFile\` / \`systemPrompt\` 属**兼容期**形态，仍在读、但不再推荐；
+     两者同时存在时 \`PROMPT.md\` 让位规则见 \`trajectory/prompt.ts\`（此处不重复）。
+
+  ⚠️ **只想声明常驻、不想限制自己**：只写 \`"resident"\` 字段，**tools/msms 一个都不要写**。
+     ⇒ 不收窄任何工具面（见下方"两个默认"）。⛔ **不要**为了"空着"而写 \`"tools": []\` —— 那是全隐藏。
+
+── 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
   its own body, so \`session\`/\`keeper\`/\`rebuild\` all default to true. Set false explicitly only
   when you deliberately want that participation off.
 
-── WeChat routing: user → trajectory code ──
-  \`weixin.routes\`: \`[{ "user": "<wx id or *>", "trajectory": "<code>" }]\`
+── IM routing: user → trajectory code（微信 / 飞书同一张表）──
+  \`im.routes\`: \`[{ "user": "<channel user id or *>", "trajectory": "<code>" }]\`
   A route pointing at a code with no such trajectory is a hard error (the message is NOT delivered).
   A trajectory WITHOUT \`${TRAJECTORY_CONSTRAINT_FILENAME}\` is still a legal target — it is just an ordinary trajectory.
 
@@ -13014,7 +10662,9 @@ becomes a 轨迹约束; delete it and it goes back to being an ordinary trajecto
   Everything is read live: saving \`${TRAJECTORY_CONSTRAINT_FILENAME}\` takes effect on the next turn, no restart.
     (The prompt FILE hot-reloads by mtime; the JSON itself is re-read every turn.)
   After editing, run container_admin config apply for an explicit validation + confirmation pass.
-  Skill loading is always available to 轨迹约束 sessions (skills are not whitelisted — they are read-only knowledge).`;
+  Skill loading is always available to 轨迹约束 sessions (skills are not whitelisted — they are read-only knowledge).
+
+  写完之后怎么验 → container_admin config docs trajectory-self 的「写完之后怎么验」段（同一套判据，不复制）。`;
 /** 校验当前 CCC 的 轨迹约束面：msms 均已注册 ／ model ∈ cheap-worker.models ／ 提示词非空 */
 function validateTrajectoryConstraint(root) {
 	const profiles = listTrajectoryConstraints(root);
@@ -13037,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 {
@@ -13053,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
@@ -13094,6 +10757,99 @@ function applyTrajectoryConstraint(root) {
 		note: `constraints are read live from each trajectory's ${TRAJECTORY_CONSTRAINT_FILENAME} — they take effect on the next turn (no restart); ${TRAJECTORY_CONSTRAINT_HINT}`
 	};
 }
+/**
+* 一章的全文。
+*
+* ⚠️ 本函数是**纯常量拼接**（无 IO、无 ctx）：手册正文不随容器状态变化，
+* 唯一随状态变的东西（"我现在是不是轨迹约束"）由 `config list` 回答，不写进正文。
+*/
+const TRAJECTORY_SELF_GUIDE = [
+	"═══ 一条认知轨迹如何描述自己（self-declaration guide）═══",
+	"",
+	"这份手册回答一件事：**我（某条认知轨迹）想给自己做设定时，该写进哪个文件、怎么写、怎么验。**",
+	"",
+	`── 三个载体：想改哪件事，就写进哪个文件 ──
+
+  <trajectory>/SESSION.md     ← 我的**身体**（认知轨迹本体；持久、永不移动）
+  <trajectory>/PROMPT.md      ← 我的**章程**（我是谁、按什么工作；**所有轨迹都可以有**）
+  <trajectory>/trajectory.json ← 我的**声明**（结构化字段；有它才成为"轨迹约束"，见下）
+
+  ⚠️ 三者主语相同（都是这条轨迹）、生命周期相同（随 git 走）、写入频率相同（人偶尔改）
+  ⇒ 这正是它们**该分开而不该合并**的理由：每一项都对应一种**不同的意图**。`,
+	"",
+	`── PROMPT.md：我的章程（推荐所有轨迹都写）──
+
+  写什么：我这名认知轨迹的**身份与工作方式** —— 我负责什么、我的判断依据是什么、
+          我的边界在哪、我怎么跟其他轨迹协作。
+  谁读它：**只有绑定在我身上的会话**读到它（作为系统提示词的一个独立段）。
+  何时生效：**保存即生效**（按 mtime 热重载，无需重启、无需 rebuild）。
+  没有它会怎样：不报错。我拿到的是 ACC 的通用身份 —— 普通轨迹的常态，不是缺陷。
+
+  ⚠️ 与 SESSION.md 的分工（别写重了）：
+     SESSION.md = **发生了什么**（日志、决策、当前状态）
+     PROMPT.md  = **我是谁、怎么工作**（章程；很少改，改了就改变行为）`,
+	"",
+	`── 常驻：自己声明"欢迎别人来麻烦我"（trajectory.json 的 resident 字段）──
+
+  🔴 先排除一个误解：**常驻不是资源状态**。
+     它不是"永不休眠"、不是"常驻内存"、不是"不许销毁我的会话"。
+     一条轨迹**永远存在**（没有生命周期），常驻与否都不改变这一点。
+
+  那它是什么：**我对自己用途的公开声明** —— "我在这儿、我擅长什么、欢迎来麻烦我"。
+     别的轨迹要找人干活时，先查这份名单，而不是靠猜谁可能懂。
+
+  写法：
+    { "resident": { "serves": "一句话说清我擅长什么、能帮上什么忙" } }
+
+  ⚠️ 两个门槛，缺一不可：
+     ① 写了 \`resident\` ⇒ 我进得了别人的候选名单（**可被发现**）
+     ② \`serves\` 非空 ⇒ 别人读了这句话能判断"这事是不是该找你"（**可被判断**）
+     只写半个（有字段、没 serves）等于把自己挂上去却不说能干什么 —— 那比不写更坏，
+     因为别人会来问，然后发现问错了人。
+
+  谁能看见：\`cognitive_trajectory\` 的 **\`resident\` 动作**（只读发现）。
+     **它不进系统提示词**（不占每个请求的 token）—— 只在有人真的要找人时才读。
+     这是 owner 2026-10-20 的裁决：说明类信息按需取，不常驻在上下文里。
+
+  🔴 它**不碰任何默认行为**（D183）：只写 resident 的轨迹，ACC 身份注入、首轮锚定、
+     自动恢复、compact 重注入 **全部照常**。常驻管的是**被找到**，不是**不被销毁**。`,
+	"",
+	`── 🔴 所有 key 都是可选的：不写 = 不设定 = 不影响默认行为 ──
+
+  这条是总规则（owner 2026-10-20 裁决）。下面逐字段说清"不写会怎样"：
+
+  | 字段 | 不写它 | 生效时机 |
+  |---|---|---|
+  | \`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  —— 逐轨迹列出 model/tools/msms 的**生效值**；
+                  没写的字段印 \`(unchanged)\` / \`(unrestricted)\`，不是伪装成某个默认值
+  配置合法吗      container_admin config validate  —— msms 均已注册 / model 在可用表里
+  常驻被看见了吗  cognitive_trajectory action=resident —— 我出现在名单里，且 serves 可读
+
+  ⚠️ 以上四项都是**读取当前真实状态**，不是"保存成功"的回执。保存成功 ≠ 生效（本仓反复踩过）。`
+].join("\n");
 //#endregion
 //#region src/tools/container-admin.ts
 /**
@@ -13236,9 +10992,14 @@ const DOCS_CHAPTERS = [
 		summary: "CCC 配置全表——9 段各是什么、怎么填、填错会怎样（.opencode/serenity.json）",
 		render: () => CCC_CONFIG_REFERENCE
 	},
+	{
+		id: "trajectory-self",
+		summary: "一条轨迹怎么描述自己——章程 PROMPT.md ／ 常驻声明（resident.serves）／ 三个载体的分工 ＋ 写完怎么验",
+		render: () => TRAJECTORY_SELF_GUIDE
+	},
 	{
 		id: "trajectory-constraint",
-		summary: "轨迹约束：一条轨迹怎么被约束（trajectory.json 的 schema ＋ 双白名单）",
+		summary: "轨迹约束（只讲限制面）：trajectory.json 的双白名单 ／ 模型 ／ 纪律参与项 ／ IM 路由",
 		render: () => TRAJECTORY_CONSTRAINT_GUIDE
 	}
 ];
@@ -13250,7 +11011,7 @@ const DOCS_CHAPTERS = [
 function createContainerAdminTool(ctx) {
 	return defineTool({
 		name: "container_admin",
-		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): config — CCC configuration: docs (usage-manual index) / docs <chapter> (one chapter in full) / view (current values) + 轨迹约束 (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference). Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
+		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): config — CCC configuration: docs (usage-manual index) / docs <chapter> (one chapter in full) / view (current values) + 轨迹约束 (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference). TRAJECTORY SELF-DOCS: a cognitive trajectory describing ITSELF — charter (PROMPT.md) / resident declaration / self-restriction (whitelists) ⇒ config docs trajectory-self; the restriction side only ⇒ config docs trajectory-constraint. Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
 		parameters: {
 			domain: {
 				type: "string",
@@ -13650,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"
 		};
@@ -13980,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) {
@@ -14277,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";
@@ -14422,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;
@@ -14461,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
 			};
@@ -14580,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;
@@ -15120,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();
@@ -15190,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;
 }
 /**
@@ -15200,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;
@@ -15213,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);
@@ -15231,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 = {
@@ -15284,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 {
@@ -15296,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 {}
@@ -15348,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 {}
@@ -15843,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),
@@ -15853,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 {}
@@ -15903,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);
@@ -15944,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, {
@@ -15965,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);
@@ -15991,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;
@@ -16003,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) {
@@ -16026,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);
@@ -16076,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,
@@ -16091,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, {
@@ -18104,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;
@@ -18140,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));
@@ -18253,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;
@@ -20299,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") {
@@ -20974,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;
@@ -21042,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}）—— 该消息**未投递**，请改订阅表里的目标编码`);
@@ -21854,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 {}
 	})();
@@ -22118,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 = [];
@@ -23569,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();