@shgroup/dsh-serenity-hooks 1.70.0 → 1.72.0

package/lib/index.js

@@ -1,12 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.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-RzasspMr.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, p as readCognitiveTrajectorySkills, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-C33QWoWZ.js";
-import { A as summarize, C as readTrajectoryUid, D as setActiveSessionInfo, E as sessionsRoot, F as localIdStamp, M as isoLocal, N as localFileStamp, O as setTrajectoryUid, P as localHuman, S as readActiveSessionMd, T as sessionEvents$1, _ as getActiveSessionInfo, a as pruneMissingBindings, b as namingTitleFor, c as setBindingStore, d as UID_FILENAME, f as archiveSession, g as findSession, h as extractSessionMdPathFromText, i as listBoundSessionIds, j as useSession, k as showSession, l as COGNITIVE_TRAJECTORY_ACTIONS, m as createSession, n as PLUGIN_SOURCE, o as readLastBound, p as clearActiveSessionInfo, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND, u as DEFAULT_SESSION_SCOPE, v as listActiveTrajectories, w as resolveSessionByTitle, x as parseSessionContextFromEvents, y as listSessions } from "./message-source-DhA1dVBi.js";
-import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-D_DvgPqy.js";
-import { a as GATEWAY_PORT, c as SKIFF_DEBUG_PORT, d as skiffRoleFor$1, f as skiffSessionInfo$1, i as FACE_PORTS, l as WEIXIN_SEND_PORT, m as ACC_VERSION, n as readSimpleSettings, o as MAIN_WEB_PORT, p as unregisterSkiffSession$1, r as registerSettingsSection, s as MECHANISM_PORTS, u as registerSkiffSession$1 } from "./settings-section-0TPYWug9.js";
-import { a as isSkiffSessionId, c as resolveSkiffKind, f as systemPromptSource, i as createRolePromptReader, l as roleMsmWhitelist, n as buildSkiffBasePrompt, o as readSkiffRoles, r as cognitiveTrajectorySubset, s as resolveRoleSystemPrompt, u as roleToolWhitelist } from "./skiff-role-cwxAt0gE.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-jZYR2GVE.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-Dkoa2oW3.js";
+import { A as sessionEvents$1, C as listSessions, D as readActiveSessionMd, E as parseTrajectoryCode, F as useSession, I as isoLocal, L as localFileStamp, M as setActiveSessionInfo, N as showSession, O as readTrajectoryUid, P as summarize, R as localHuman, S as listActiveTrajectories, T as parseSessionContextFromEvents, _ as createSession, a as readSkiffProfileAt, b as getActiveSessionInfo, c as registerSkiffSession$1, d as unregisterSkiffSession$1, f as COGNITIVE_TRAJECTORY_ACTIONS, g as clearActiveSessionInfo, h as archiveSession, j as sessionsRoot, k as resolveSessionByTitle, l as skiffSessionInfo$1, m as UID_FILENAME, n as isSkiffSession, o as readSkiffProfileByCode, p as DEFAULT_SESSION_SCOPE, r as listSkiffProfiles, s as skiffProfileForSession, t as SKIFF_PROFILE_FILENAME, u as skiffTrajectoryDirNameFor, v as extractSessionMdPathFromText, w as namingTitleFor, y as findSession, z as localIdStamp } from "./profile-DyMJ_bfr.js";
+import { a as readWeixinCredential, c as sanitizeFileName$1, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinInboundDir, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, t as extractWeixinMedia, u as weixinSessionIdForTrajectory } from "./route-f7JlinIt.js";
+import { _ as resolveProfileSystemPrompt, a as GATEWAY_PORT, c as SKIFF_DEBUG_PORT, d as buildSkiffBasePrompt, f as createProfilePromptReader, g as profileToolWhitelist, h as profileSystemPromptSource, i as FACE_PORTS, l as WEIXIN_SEND_PORT, m as profileMsmWhitelist, n as readSimpleSettings, o as MAIN_WEB_PORT, p as profileCognitiveTrajectory, r as registerSettingsSection, s as MECHANISM_PORTS, u as SKIFF_PROFILE_HINT, v as ACC_VERSION, y as findPackageRoot } from "./settings-lt1i3OZv.js";
+import { a as pruneMissingBindings, c as setBindingStore, i as listBoundSessionIds, n as PLUGIN_SOURCE, o as readLastBound, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, t as ACC_MESSAGE_KIND } from "./message-source-kVoNK0C5.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
-import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-BrRcPiQs.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-DEpmE3yi.js";
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
@@ -25,9 +25,9 @@ import * as zlib from "node:zlib";
 import { deriveEventMessage } from "@deepseek-ai/dsh-session";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
-//#region src/fs-ops.ts
+//#region src/tools/fs/service.ts
 /**
-* fs-ops.ts — container_fs 纯操作层（cc_fs → container_fs，v1.30；零 DSH 依赖，可独立单测）
+* tools/fs/service.ts — container_fs 纯操作层（cc_fs → container_fs，v1.30；零 DSH 依赖，可独立单测）
 *
 * 行为对齐 osp（opencode-serenity-plugin/src/fs/file-system-tool.ts）——osp 是 ACC 工具 spec：
 *   - rm：目录需 recursive 才删除；非空目录无 recursive → [SKIP]；保护 .serenity 与 CCC 根；dry-run 预览
@@ -416,12 +416,12 @@ function runCcFs(root, args) {
 	}
 }
 //#endregion
-//#region src/tools/cc-fs.ts
+//#region src/tools/fs/index.ts
 /**
-* cc-fs.ts — container_fs 真实 DSH 工具定义（defineTool）（v1.30：cc_fs → container_fs）
+* tools/fs/index.ts — container_fs 真实 DSH 工具定义（defineTool）（v1.30：cc_fs → container_fs）
 *
 * 进程内注册（取代 v0.1 的 bash spawn runner）：zod/schemastery 参数校验、
-* 规范 JSON 输出、纯 render 投影。逻辑在 fs-ops.ts（可单测）。
+* 规范 JSON 输出、纯 render 投影。逻辑在 tools/fs/service.ts（可单测）。
 */
 function renderText$11(value) {
 	return [{
@@ -504,7 +504,7 @@ const ccFsTool = defineTool({
 	}
 });
 //#endregion
-//#region src/kit-ops.ts
+//#region src/tools/kit/service.ts
 const KIT_ACTIONS = [
 	"health",
 	"time",
@@ -513,7 +513,7 @@ const KIT_ACTIONS = [
 async function runKit(root, args, hostCtx) {
 	switch (args.action) {
 		case "health": {
-			const { containerStatus } = await Promise.resolve().then(() => container_status_exports);
+			const { containerStatus } = await Promise.resolve().then(() => observation_exports);
 			const s = containerStatus({
 				root,
 				hostCtx
@@ -567,9 +567,9 @@ async function runKit(root, args, hostCtx) {
 	}
 }
 //#endregion
-//#region src/tools/kit.ts
+//#region src/tools/kit/index.ts
 /**
-* kit.ts — dashboard 真实 DSH 工具定义（defineTool）（v1.30：acc_kit → dashboard）
+* tools/kit/index.ts — dashboard 真实 DSH 工具定义（defineTool）（v1.30：acc_kit → dashboard）
 */
 function renderText$10(value) {
 	return [{
@@ -607,9 +607,9 @@ function createKitTool(ctx) {
 	});
 }
 //#endregion
-//#region src/git-ops.ts
+//#region src/tools/git/service.ts
 /**
-* git-ops.ts — container_git 纯操作层（cc_git → container_git，v1.30；零 DSH 依赖）
+* tools/git/service.ts — container_git 纯操作层（cc_git → container_git，v1.30；零 DSH 依赖）
 *
 * 行为对齐 osp（opencode-serenity-plugin/src/git/cc-git-tool.ts）——osp 是 ACC 工具 spec：
 *   - status：JSON {clean, files:[{status,file}], summary, ahead, behind}
@@ -910,9 +910,9 @@ function runGit(root, args) {
 	}
 }
 //#endregion
-//#region src/tools/git.ts
+//#region src/tools/git/index.ts
 /**
-* git.ts — container_git 真实 DSH 工具定义（defineTool）（v1.30：cc_git → container_git）
+* tools/git/index.ts — container_git 真实 DSH 工具定义（defineTool）（v1.30：cc_git → container_git）
 */
 function renderText$9(value) {
 	return [{
@@ -971,9 +971,9 @@ const gitTool = defineTool({
 	}
 });
 //#endregion
-//#region src/weixin-send-endpoint.ts
+//#region src/im/endpoint.ts
 /**
-* weixin-send-endpoint.ts — 主动发送入口地址的**零依赖叶模块**（v1.30.9，S142）
+* im/endpoint.ts — 主动发送入口地址的**零依赖叶模块**（v1.30.9，S142）
 *
 * 为什么单独一个模块（R↓）：地址的读者是 `msm-ops.buildMsmEnv`（把地址注入 MSM 子进程 env），
 * 写者才是 `weixin-send-api`（监听器启停）。若 msm-ops 直接 import weixin-send-api，
@@ -981,7 +981,7 @@ const gitTool = defineTool({
 * 后果实测：`acc-extras` / `ops` / `skiff-admin` 三个测试套件因解析不到宿主包而**整文件加载失败**
 * （它们只用到 MSM 注册表逻辑）。叶模块把「读」与「写」解耦：读者零依赖，写者自己承担重量。
 *
-* 同款先例：`host/effect.ts`（拆卸登记）、`agent-idle.ts`（等待结算）。
+* 同款先例：`host/effect.ts`（拆卸登记）、`role/worker/idle.ts`（等待结算）。
 */
 let endpoint = null;
 /** 设置当前入口地址（weixin-send-api 启停时调用；null = 未启动） */
@@ -993,9 +993,9 @@ function weixinSendEndpoint() {
 	return endpoint;
 }
 //#endregion
-//#region src/msm-ops.ts
+//#region src/tools/msm/service.ts
 /**
-* msm-ops.ts — msm 纯操作层（acc_msm → msm 执行 + container_admin 管理面，v1.30；零 DSH 依赖）
+* tools/msm/service.ts — msm 纯操作层（acc_msm → msm 执行 + container_admin 管理面，v1.30；零 DSH 依赖）
 *
 * MSM（Mech & Semi-Mech）框架：exec 执行 / register|deregister|check 管理。
 * 复用 CCC 的 mech-registry.json（v1 或数组格式）。cwd 钉在 CCC 根。
@@ -1023,7 +1023,7 @@ function bunExecutablePath() {
 	bunExeCache = null;
 	return null;
 }
-/** CCC 名：从 .serenity 解析（review P2-2 统一收口到 ccc.ts readCccName——跳 # 注释/空行首非空行；此处保留导出名兼容内部调用） */
+/** CCC 名：从 .serenity 解析（review P2-2 统一收口到 kernel/ccc.ts readCccName——跳 # 注释/空行首非空行；此处保留导出名兼容内部调用） */
 function readCccName(root) {
 	return readCccName$1(root);
 }
@@ -1823,149 +1823,142 @@ async function runMsmAsync(root, args) {
 	}
 }
 //#endregion
-//#region src/cheap-worker-ops.ts
+//#region src/trajectory/prompt.ts
 /**
-* cheap-worker-ops.ts — cheap-worker（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
+* trajectory/prompt.ts — **轨迹提示词**（Trajectory Prompt）：一条轨迹"是谁、按什么章程工作"
 *
-* 🆕 2026-10-14（owner 令「删除后台运行能力」）：**进度文件 / stop token / 轮次循环**整族已退场 ——
-* 它们**只**服务于 background 模式。本模块现存 = 前台委派真正需要的三件：
-* 模型串解析 ／ 白名单校验 ／ provider 可用性判读（＋ 使用指引文本）。
+* ## 概念（owner 2026-10-19 定向，逐字）
+*
+* > 「参考会话的系统提示词，我们建立**轨迹提示词**概念来代替人格。架构上会好很多」
+*
+* **轨迹提示词** = 一条认知轨迹的**可编辑章程声明**，由 ACC 按固定顺序装配进系统提示词。
+* 三个关键词各是一条判据：
+* - **可编辑**：住在 CCC（盘上），改它**不发版**（D23 归属判据的直接推论）
+* - **声明**：它声明**身份／章程／方法论**，**不声明能力**（能力面归 `skiff.json` 白名单与工具 schema）
+* - **固定顺序**：装配顺序由 ACC 定死（见 `seams/system-prompt.ts` 的 ⑧ 位）
+*
+* ## 为什么取代「人格」
+*
+* 「人格」把身份绑在"像不像一个人"上 ⇒ 因为叫人格，它被设计成**可以整体替换**
+* （`persona` 置换 EAP 块，即 review F-05/R-14 那个悬置冲突）。而身份与章程**不该被替换，
+* 只该被特化**。⇒ 本模块把"替换"改成"叠加"：容器层与质量层永远保留，轨迹提示词只往上加。
+*
+* ## 落点（为什么在轨迹目录里）
+*
+* `AGENT_SESSIONS/<轨迹目录>/PROMPT.md`
+*
+* - **跟着轨迹走**：`archive` 时整个目录搬走，章程不会掉队（旧形态 `.opencode/skiff/<name>.md`
+*   与轨迹**分居两处** —— 多条轨迹共用一份文件正是那个后果）。
+* - **每条轨迹都能有**：不只是 skiff。普通轨迹同样需要"我是谁、按什么章程"。
+* - 与 `SESSION.md`（身体：延续/日志）、`skiff.json`（约束面：能力）三件并列，
+*   各管一件事，不合并（合并会让"改能力"与"改身份"互相牵连）。
+*
+* ## 兼容（不静默坏）
+*
+* `PROMPT.md` 不存在时**不报错**（普通轨迹常态）。skiff 的旧字段 `systemPromptFile`
+* 在兼容期仍被读取——优先级见 {@link resolveTrajectoryPrompt}。
 */
-/** 解析 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)
-	};
+/** 轨迹提示词的固定文件名（**判据就是它存在**——不是目录名前缀，也不是配置里的一行） */
+const TRAJECTORY_PROMPT_FILENAME = "PROMPT.md";
+/** 轨迹目录的 PROMPT.md 绝对路径（不论存在与否——调用方自己判存在性） */
+function trajectoryPromptPath(root, dirName) {
+	return join(sessionsRoot(root), dirName, TRAJECTORY_PROMPT_FILENAME);
 }
-/** 校验模型在白名单内；不在 → 抛错（用户拍板：只能使用 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(", ")}`);
+/**
+* 该轨迹**有没有**轨迹提示词（单一判据）。
+*
+* 用途：兼容期的"让位"判定 —— 若已有 `PROMPT.md`，skiff 旧字段 `systemPromptFile`
+* 必须**让位**，否则同一份章程会在两处各注入一遍（第 ⑧ 段 ＋ `serenity-skiff` 段）。
+* 🔴 判据只有这一处：别在 skiff 那边自己拼路径再判（两处会漂）。
+*/
+function hasTrajectoryPrompt(root, dirName) {
+	try {
+		return existsSync(trajectoryPromptPath(root, dirName));
+	} catch {
+		return false;
+	}
 }
 /**
-* 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"` 却**不知道为什么**，
-*   也就无法修正自己的配置 —— 本条把「沉默的失败」变成「可执行的错误」。
+* ## 为什么返回函数而不是字符串（R↓，实证代价）
 *
-* 数据来源（宿主 `LlmRuntime`）：`listProviders()` = **有 adapter 的路由**；
-* `listConfigurableProviders()` = **已声明但未必激活**的路由（含激活用的 settings 命名空间）。
+* 旧实现把提示词**快照**进系统提示词段的闭包 ⇒ CCC 改了文件必须重启 dsh web 才生效
+* （实测：改完 18KB 提示词，live agent 仍用旧文本）。现形态由系统提示词段的 `text()`
+* **每轮调用**本读取器：按 **mtime + size** 缓存重读（命中缓存零 IO）。
 *
-* 判据边界：`model` 串里**没有 `/`** 时取不到 provider（沿用 agent 默认路由）⇒ **不判定**（跳过）。
+* ## 三条失败语义（各治一个失败模式）
+*
+* - **文件不存在** ⇒ 返回空串（**不是错误**：普通轨迹没有章程是常态，且删掉即失效
+*   必须是立即可见的——这就是"删掉 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 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(", ");
+function trajectoryPromptBlock(text) {
+	const body = text.trim();
+	if (body === "") return "";
 	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."
+		"=== Serenity Trajectory Prompt ===",
+		body,
+		""
 	].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/agent-idle.ts
+//#region src/role/worker/idle.ts
 /**
 * 等待 agent 空闲或销毁。
 * @param ctx 宿主插件上下文（事件通道来源；**结构化访问**，故类型为 `unknown`，见文件头 I2 段）
@@ -2006,9 +1999,9 @@ function waitAgentIdle(ctx, agent) {
 	});
 }
 //#endregion
-//#region src/skills-discovery.ts
+//#region src/skills/discovery.ts
 /**
-* skills-discovery.ts — CCC 入口 skill 自动发现（纯逻辑，零 DSH 依赖）
+* skills/discovery.ts — CCC 入口 skill 自动发现（纯逻辑，零 DSH 依赖）
 *
 * 发现全部入口技能（原文全量，不截断）—— **现行三个来源**（原为四个，**来源 3 已于 2026-09-21 删除**）：
 *   0. **`.serenity` 记号文件内容 = 顶层入口 skill 名**（CCC 记号文件的权威语义）—— 最高优先
@@ -2112,7 +2105,7 @@ function truncateContent(content, maxChars) {
 * 六条硬性规则（逐条对应设计 §4.2，改这里先改那里）：
 *   ① **只枚举，不注入正文** —— 索引里**绝不**出现任何参考文件的正文；
 *   ② **确定性排序** = 相对路径的 **UTF-8 字节序**（🔴 **不用 mtime**：mtime 随检出漂移，
-*      会让每请求的注入文本抖动；对照 `src/cro.ts:101` 那份**落盘快照**用 {name,bytes,mtime} ——
+*      会让每请求的注入文本抖动；对照 `src/wake/cro.ts:101` 那份**落盘快照**用 {name,bytes,mtime} ——
 *      **同一件事两处的取舍相反，那个差异是判据不是巧合**）；
 *   ③ **有界 ＋ 响亮** —— 条数/字符各有上限，超出**必须显式写出还剩多少项**，**绝不静默截断**；
 *   ④ **摘要可复现** —— 取该文件首个 `#` 标题（剥 markdown 记号）；取不到 ⇒ 留空，**不编**；
@@ -2128,7 +2121,7 @@ function truncateContent(content, maxChars) {
 *
 * 🔴 **两个面，两个入口**（2026-10-12 增；owner 裁决 O2）—— 同源、但成本形态不同：
 *    · **载入面** `buildResourceIndex()` —— 完整索引（名字 ＋ 首标题 ＋ 字节），带 `.md` 文件头读取；
-*      在三条路径上各附一次：入口段（`system-prompt.ts` order −50）／轨迹段（`cognitive-trajectory-skills.ts`
+*      在三条路径上各附一次：入口段（`system-prompt.ts` order −50）／轨迹段（`trajectory/skills.ts`
 *      order −45）／目录 provider 的 `get()`（`opencode-skills.ts`）。
 *    · **目录面** `buildResourceNameSuffix()` —— **只有名字**，**不读任何正文**；只挂一处：
 *      目录 provider 的 `list()`（`available_skills` 的 `SkillSummary.description`）。
@@ -2389,9 +2382,9 @@ function buildResourceNameSuffix(skillDir, options = {}) {
 	return `（参考件：${names.join(" / ")}${tail}）`;
 }
 //#endregion
-//#region src/cognitive-trajectory-skills.ts
+//#region src/trajectory/skills.ts
 /**
-* cognitive-trajectory-skills.ts — 轨迹 skill 声明解析 + 注入内容装配（纯逻辑，零 DSH 依赖）
+* trajectory/skills.ts — 轨迹 skill 声明解析 + 注入内容装配（纯逻辑，零 DSH 依赖）
 *
 * 接口真相源：`docs/cognitive-trajectory-skill-injection.md` v1.0（§2 数据契约 / §3 注入契约）。
 * 一句话：**轨迹自己声明它要挂哪些 skill**（`SESSION.md` 顶部 YAML frontmatter 的 `skills:`），
@@ -2589,9 +2582,9 @@ function buildCognitiveTrajectorySkillsSection(root, mdPath, maxChars = COGNITIV
 	return truncateContent(notice ? `${notice}\n\n${body}` : body, maxChars);
 }
 //#endregion
-//#region src/usage-stats.ts
+//#region src/surface/usage.ts
 /**
-* usage-stats.ts — ACC 用量统计（**skill 加载次数** ＋ **MSM 执行次数**；落该 CCC 的 `_tmp`）
+* surface/usage.ts — ACC 用量统计（**skill 加载次数** ＋ **MSM 执行次数**；落该 CCC 的 `_tmp`）
 *
 * ## 所有者令（本模块的存在理由）
 *
@@ -2607,7 +2600,7 @@ function buildCognitiveTrajectorySkillsSection(root, mdPath, maxChars = COGNITIV
 * ⇒ 本模块让每个 CCC 留下一份**纯计数**账本：**用了哪个、多少次、第一次和最近一次是什么时候**。
 * 用途 = 清理/精简的**依据**（没有人用的东西与天天在用的东西，不再靠猜）。
 *
-* ## 🔴 铁律（与 `cro-log.ts` 同族）
+* ## 🔴 铁律（与 `wake/cro-log.ts` 同族）
 *
 * **本模块每个导出函数都不抛错**：读盘 / 解析 / 写盘失败一律返回结构化失败，
 * 由调用方只记一行日志（或什么都不做）⇒ **统计的问题绝不影响工具执行与既有链路**。
@@ -2622,8 +2615,8 @@ function buildCognitiveTrajectorySkillsSection(root, mdPath, maxChars = COGNITIV
 * ## 🔴 重启后必须续算（所有者令）
 *
 * 宿主会被重启（本容器实测 24h 内 3 次）⇒ 计数**不能只活在内存里**：
-* 每次写盘 = **读旧文件 → 在旧值上自增 → 原子写**（`tmp + rename`，与 `wake-registry.ts` /
-* `cro-log.ts` 同款形态）⇒ **进程重启后计数自然延续**，无需额外的 flush/落盘时机。
+* 每次写盘 = **读旧文件 → 在旧值上自增 → 原子写**（`tmp + rename`，与 `wake/registry.ts` /
+* `wake/cro-log.ts` 同款形态）⇒ **进程重启后计数自然延续**，无需额外的 flush/落盘时机。
 *
 * ## 口径（两个字段，勿合并）
 *
@@ -2906,9 +2899,9 @@ function verifyTotpCode(secretBase32, code, nowSeconds = nowEpochSeconds()) {
 	return null;
 }
 //#endregion
-//#region src/config-ops.ts
+//#region src/kernel/config.ts
 /**
-* config-ops.ts — plugin 全局配置读写（结构化，`~/.dsh/serenity-hooks.json`）
+* kernel/config.ts — plugin 全局配置读写（结构化，`~/.dsh/serenity-hooks.json`）
 *
 * 归属原则（S142 用户拍板，v1.22）：**plugin 是全局的，CCC 是具体的**——
 * 账号密码/gateway 监听配置是 plugin 级能力，归 plugin 全局文件；
@@ -3583,7 +3576,7 @@ function sessionBlock(root, scope = DEFAULT_SESSION_SCOPE) {
 * Principles 剥离 MSM 原则段（指令遵循约束）——用户文本承接两处风格；本体论/关系段/
 * 操作边界（安全硬约束）永远保留。未配置 → 与 v1.23.0 逐字节一致（零影响）。
 */
-function serenitySystemPrompt(root, scope = DEFAULT_SESSION_SCOPE) {
+function serenitySystemPrompt(root, scope = DEFAULT_SESSION_SCOPE, dirName) {
 	const persona = readPersonaSettings();
 	const personaOn = persona.mode !== "" && persona.overrideText.trim() !== "";
 	const parts = [
@@ -3591,12 +3584,18 @@ function serenitySystemPrompt(root, scope = DEFAULT_SESSION_SCOPE) {
 		metaphorBlock(),
 		principlesBlock(root, personaOn),
 		cceBlock(),
-		personaOn ? personaBlock(persona.mode, persona.overrideText) : eapBlock()
+		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);
@@ -3643,6 +3642,23 @@ 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 返回空（不注入）。
@@ -3657,9 +3673,7 @@ function registerEntrySkillSectionGlobal(ctx) {
 				if (!cwd) return "";
 				const root = cccRootForCwd(cwd);
 				if (!root) return "";
-				const scope = agentScope$2(context);
-				if (isSkiffSessionId(scope)) return "";
-				const base = serenitySystemPrompt(root, scope);
+				const base = serenitySystemPrompt(root, agentScope$2(context), boundDirNameFor(context.agent?.session));
 				const codeLine = codeModeAdaptationLine(ctx, context.scope);
 				return codeLine ? `${base}\n${codeLine}` : base;
 			}
@@ -3691,8 +3705,7 @@ function registerEntrySkillSection(agent, root) {
 			name: "serenity-entry",
 			order: -50,
 			text: (context) => {
-				if (isSkiffSessionId(scope)) return "";
-				const base = serenitySystemPrompt(root, scope);
+				const base = serenitySystemPrompt(root, scope, boundDirNameFor(agent.session));
 				const codeLine = codeModeAdaptationLine(agent.ctx, context.scope);
 				return codeLine ? `${base}\n${codeLine}` : base;
 			}
@@ -3712,7 +3725,7 @@ function registerEntrySkillSection(agent, root) {
 *   · **轨迹级** = 该会话绑定的轨迹（`readLastBound(session).mdPath` = 它的 `SESSION.md`）
 *     顶部 frontmatter 的 `skills:`——这条轨迹额外的。
 *   合并规则与顺序见 `cognitive-trajectory-skills.mergeSkillNames`（CCC 级在前，同名去重）。
-*   正文 = 合并清单里各 skill 的 `SKILL.md` 全文（本模块只注册，装配在 `cognitive-trajectory-skills.ts`）。
+*   正文 = 合并清单里各 skill 的 `SKILL.md` 全文（本模块只注册，装配在 `trajectory/skills.ts`）。
 *
 * 为什么是 **per-agent scoped section**（与 `registerEntrySkillSection` 同形）：注入必须
 * **绑定期间持续存在**（a2）——一次性注入会随对话压缩消失，而 section 每次装配重新求值。
@@ -3755,13 +3768,152 @@ function registerCognitiveTrajectorySkillSection(agent, root) {
 	}
 }
 //#endregion
-//#region src/skiff-core.ts
-const skiffAgents = /* @__PURE__ */ new Map();
-/** 查 sessionId 的 Skiff 角色名（无 → null） */
-function skiffRoleFor(sessionId) {
-	return skiffRoleFor$1(sessionId);
+//#region src/role/worker/core.ts
+/**
+* role/worker/core.ts — cheap-worker（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
+*
+* 🆕 2026-10-14（owner 令「删除后台运行能力」）：**进度文件 / stop token / 轮次循环**整族已退场 ——
+* 它们**只**服务于 background 模式。本模块现存 = 前台委派真正需要的三件：
+* 模型串解析 ／ 白名单校验 ／ provider 可用性判读（＋ 使用指引文本）。
+*/
+/** 解析 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(", ")}`);
 }
-/** 查 sessionId 的会话绑定（role + ccc；无 → null）——v1.25.10 追问校验 */
+/**
+* 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/role/skiff/core.ts
+/** `provider/model` → agentOptions（由 worker/core 提供，保持单一实现） */
+const skiffAgents = /* @__PURE__ */ new Map();
+/** 查 sessionId 的会话绑定（轨迹 ＋ ccc；无 → null）——追问校验 */
 function skiffSessionInfo(sessionId) {
 	return skiffSessionInfo$1(sessionId);
 }
@@ -3769,76 +3921,80 @@ function skiffSessionInfo(sessionId) {
 function getSkiffAgent(sessionId) {
 	return skiffAgents.get(sessionId);
 }
-function registerSkiffSession(sessionId, role, ccc, agent) {
+/** 该会话当前绑定的 skiff 约束面（不是 skiff → null）。**守门与提示词的唯一查询入口。** */
+function skiffProfileFor(root, sessionId) {
+	if (sessionId === void 0) return null;
+	return skiffProfileForSession(root, sessionId, skiffTrajectoryDirNameFor(sessionId));
+}
+function registerSkiffSession(sessionId, trajectoryDirName, ccc, agent) {
 	skiffAgents.set(sessionId, agent);
-	registerSkiffSession$1(sessionId, role, ccc);
+	registerSkiffSession$1(sessionId, trajectoryDirName, ccc);
 }
 function unregisterSkiffSession(sessionId) {
 	skiffAgents.delete(sessionId);
 	unregisterSkiffSession$1(sessionId);
 }
-/** 自动创建的 bound 标记（readLastBound 恢复判定——只恢复本机制建的；手工 use 的旧 bound 不认） */
-const AUTO_BOUND_NOTE_PREFIX = "auto-created for skiff role";
 /**
-* 系统提示词中的**工作台纪律块**（v1.30.4 升级：从单行路径 → 完整 ACC 层约束）。
-* 用户点破（S142）：只给路径 LLM 不会主动用——需注入「已绑定 + 使用纪律 + 动作指引」。
-* SESSION = 工作台——skiff 与主舱同一套机制（零特调，用户拍板）：
-* 自动绑定已生效（无需 cognitive_trajectory use）、SESSION.md 是持久记忆载体、rebuild 自动从本 SESSION 续接。
+* 该 skiff 会话的**工作台路径** = 它自己轨迹的 SESSION.md。
+*
+* 🔴 与旧版的差别：旧版会在这里**自动新建**一个 SESSION（`ensureSkiffSession`）；
+* 新版**没有新建这个动作** —— 轨迹就是工作台，`skiff.json` 与 `SESSION.md` 同处一个目录。
+* ⇒ 语义变成纯粹的"查询：我自己的身体在哪"。
+*
+* @returns SESSION.md 绝对路径；不是 skiff / 文件不在 → null
+*/
+function skiffWorkspaceMdPath(root, sessionId) {
+	if (sessionId === void 0) return null;
+	const dirName = skiffTrajectoryDirNameFor(sessionId);
+	if (dirName === null) return null;
+	const md = join(sessionsRoot(root), dirName, "SESSION.md");
+	return existsSync(md) ? md : null;
+}
+/**
+* 系统提示词中的**工作台纪律块**（S142 用户：只给路径 LLM 不会主动用）。
+*
+* SESSION = 工作台 —— skiff 与主舱同一套机制（**零特调**，用户拍板）：
+* SESSION.md 是持久记忆载体、rebuild 自动从本 SESSION 续接。
 * 注入 agent 系统提示词（用户对话面不可见）。
 *
-* v1.30.13（S142 诊断 D5）：写入纪律**不点名具体工具**。旧文案写死 "with write/edit"，
-* 而某角色的工具白名单已移除 write/edit（写能力收归 CCC 的 session-write MSM）
-* → 指令指向它根本没有的工具（注入纪律与能力面矛盾，模型只能猜）。
-* 现文案改为「用本角色被授权的写入通道」——ACC 只声明义务（写进工作台），
-* 具体通道由 CCC 的角色配置与角色提示词决定（ACC/CCC 归属二分；也不把某个 CCC 的
-* MSM 名硬编码进 ACC 源码）。
+* v1.30.13（S142 诊断 D5）：写入纪律**不点名具体工具** —— 旧文案写死 "with write/edit"，
+* 而某个 skiff 的工具白名单里根本没有 write/edit ⇒ 指令指向它没有的工具
+* （注入纪律与能力面矛盾，模型只能猜）。现文案改为「用本轨迹被授权的写入通道」。
 */
 function workspaceCognitiveTrajectoryLine(mdPath) {
 	return [
 		"── Serenity Session Workspace ──",
-		"This role session is AUTO-BOUND to a cognitive trajectory workspace SESSION (no cognitive_trajectory use needed):",
+		"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 role is actually granted (use whatever write tool or MSM this role has — never assume",
+		"     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",
-		"     (no manual use; do not switch to or read other SESSIONs unless the user explicitly asks).",
+		"     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）。
-* WeakSet → agent 被回收即自动清理，无泄漏。
-*/
+/** 已挂工作台提示词段的 agent（幂等：同一 agent 只注册一次，避免 duplicate section） */
 const workspaceSectionAgents = /* @__PURE__ */ new WeakSet();
 /**
-* 把**工作台纪律块**挂到 agent 的系统提示词段（单一真相源，v1.30.13 用户需求）。
+* 把**工作台纪律块**挂到 agent 的系统提示词段（单一注入点）。
 *
 * 用户原话（S142，2026-09-08）："微信桥的注入机制，每个用户消息都会注入，skiff 本身也会注入，
 * 这样就重复，能否微信桥情况下，注入内容直接取 skiff 的，这样不用配两遍"。
 *
-* 现状（改前）：`createSkiffAgent` 把 `workspaceCognitiveTrajectoryLine(mdPath)` 塞进基础段
-* （创建时一次快照），微信桥又**每条消息**把同一文本拼进 question（v1.30.4 为覆盖
-* "live/existing 快路径不重挂提示词"而加）→ 新建 agent 首轮起即重复，且每轮重复付 token。
+* 现形态：工作台行**只**经本函数挂系统提示词段（name `serenity-skiff-workspace`，
+* 动态 `text()` 每轮按 scope 读当前活跃 mdPath）。
 *
-* 现形态（单一注入点）：工作台行**只**经本函数挂系统提示词段（name `serenity-skiff-workspace`，
-* 动态 `text()` 每轮按 scope 读当前活跃 mdPath → 绑定变化自动跟随，无需重挂）：
-*  - `createSkiffAgent` 调它（不再把工作台行拼进基础段）；
-*  - 微信桥对 live/existing agent 调它（不再拼 question）。
-*
-* @returns true = 段已在位（本次注册成功或此前已注册）；false = 该 agent 无法挂系统提示词段
-*   （宿主 systemPrompt 缺失/注册抛错）→ 调用方降级为 question 前缀注入（约束必须在场）
+* @returns true = 段已在位；false = 该 agent 挂不上（调用方降级为 question 前缀注入）
 */
-function ensureWorkspacePromptSection(agent, scope) {
+function ensureWorkspacePromptSection(agent, scope, root) {
 	if (!agent || typeof agent !== "object") return false;
 	if (workspaceSectionAgents.has(agent)) return true;
 	const api = agent.ctx?.systemPrompt;
@@ -3848,7 +4004,7 @@ function ensureWorkspacePromptSection(agent, scope) {
 			name: "serenity-skiff-workspace",
 			order: -55,
 			text: () => {
-				const mdPath = getActiveSessionInfo(scope)?.mdPath;
+				const mdPath = skiffWorkspaceMdPath(root, scope);
 				return mdPath ? workspaceCognitiveTrajectoryLine(mdPath) : "";
 			}
 		});
@@ -3859,90 +4015,22 @@ function ensureWorkspacePromptSection(agent, scope) {
 		return false;
 	}
 }
-/**
-* 确保启用 session 能力的 skiff 会话拥有**专属 SESSION**（工作台）：
-* 懒绑定 + 幂等（per skiff 会话 scope 隔离——微信多用户各自独立，永不共享同一份）。
-*
-* 判定链：
-* ⓪ **临时身份不建工作台**（v1.30.9，S142 用户报"SESSION 爆炸"根治）：`persistent=false`
-*    （调试页等**无固定会话 id**的临时 agent）→ null。理由（R↓）：这些 agent 每次
-*    调用都是新 id、无身份延续，为其建 SESSION = 每次问答留一个永久空目录（无界熵增）；
-*    用户模型「skiff 本质是临时会话机制」——工作台属于**持久身份**，不属于单次调用。
-* ① 角色未启用 session 能力（cognitiveTrajectory.session !== true）→ null（现状零变化）
-* ② 已有**本机制自动创建**的 bound（note 前缀 auto-created）→ 恢复（重启/续接记得）
-* ②b 内存活跃记录（同 scope）→ 恢复 + **自愈补写绑定**（防御纵深：绑定写失败/事件形态未落盘时
-*    仍复用同一 SESSION，而不是每条消息新建一个——v1.30.5 及更早"每条消息一个 SESSION"的放大效应）
-* ③ 无 → 自动创建专属 SESSION（createSession desc=`<role> skiff`——编号自动递增，用户不关心是谁）
-*
-* @param persistent 该 skiff 会话是否有**持久身份**（固定会话 id）。默认 true（向后兼容调用点）；
-*   `createSkiffAgent` 传 `sessionId !== undefined`，微信桥的 existing 快路径传 true。
-* @returns 绑定后的 SESSION.md 绝对路径（供提示词注入）；不适用/失败 → null
-*/
-function ensureSkiffSession(root, agent, roleName, role, persistent = true) {
-	if (!cognitiveTrajectorySubset(role).session) return null;
-	if (!persistent) return null;
-	const session = agent.session;
-	const scope = String(agent.session.id ?? agent.id);
-	const lastBound = session ? readLastBound(session) : null;
-	if (lastBound && lastBound.note?.startsWith(AUTO_BOUND_NOTE_PREFIX) && existsSync(lastBound.mdPath)) {
-		setActiveSessionInfo(scope, {
-			sessionId: lastBound.sessionId ?? "",
-			dirName: lastBound.dirName,
-			mdPath: lastBound.mdPath
-		});
-		return lastBound.mdPath;
-	}
-	const inMemory = getActiveSessionInfo(scope);
-	if (inMemory?.mdPath && existsSync(inMemory.mdPath)) {
-		appendBound(session, "reconcile", {
-			dirName: inMemory.dirName,
-			mdPath: inMemory.mdPath,
-			...inMemory.sessionId ? { sessionId: inMemory.sessionId } : {},
-			note: `${AUTO_BOUND_NOTE_PREFIX} ${roleName}`
-		});
-		return inMemory.mdPath;
-	}
-	const desc = `${roleName} skiff`;
-	const created = createSession({
-		root,
-		desc,
-		dryRun: false
-	});
-	const mdPath = join(created.sessionPath, "SESSION.md");
-	setActiveSessionInfo(scope, {
-		sessionId: created.sessionId,
-		dirName: created.dirName,
-		mdPath
-	});
-	appendBound(session, "create", {
-		dirName: created.dirName,
-		mdPath,
-		sessionId: created.sessionId,
-		note: `${AUTO_BOUND_NOTE_PREFIX} ${roleName}`
-	});
-	return mdPath;
-}
-/** Skiff agent 挂载的 DSH preset（v1.25.3 修复：read/grep/glob 等平台工具由 preset 决定工具面；
-*  cheap-worker 经 composeFrom 继承父、skiff 无父上下文——直接挂 DSH 默认 standard preset；
-*  guard 角色白名单再按角色过滤可见/可用面——白名单外工具仍 deny） */
+/** skiff agent 挂载的 DSH preset（平台工具面由 preset 决定；白名单再按轨迹过滤） */
 const SKIFF_PRESET = "standard";
 /**
-* 创建 Skiff agent：标准 DSH agent + cwd=CCC root + 角色模型 +
-* standard preset（平台工具面）+ scoped 系统提示词（基础提示词 + CCC 定义段，全替换 ACC 默认注入）。
+* 创建（或复用）一个 skiff 会话。
 *
-* **固定 sessionId 的 resume-or-create（v1.27.2，微信桥 id collision 修复）**：
-* 指定 sessionId 且磁盘已有持久化 log → `ctx.agents.resume`（DSH 持久化语义：
-* sessionId 即身份，已持久化会话必须 resume——历史 + turn 续号延续，同用户长期记忆保留）；
-* 无 log（首次）/持久化未配置 → `ctx.agents.create`（新建）。不指定 sessionId →
-* 随机 id 恒 create（调试页默认路径）。
+* **固定 sessionId 的 resume-or-create**（v1.27.2）：指定 sessionId 且磁盘已有持久化 log →
+* `ctx.agents.resume`（DSH 持久化语义：sessionId 即身份，历史 + turn 续号延续）；
+* 无 log（首次）→ `ctx.agents.create`。不指定 → 随机 id 恒 create（调试页路径）。
 *
-* @param sessionId 指定会话 id（可选；微信桥等外部面用固定 id 实现用户↔会话长期映射——
-*   不传则随机生成 skiff-<role>-<uuid>，调试页默认路径）
+* @param profile 该 skiff 的约束面（来自 `skiff.json`）
+* @param sessionId 指定会话 id（可选；微信桥等外部面用固定 id 实现"轨迹 ↔ 会话"长期映射）
 */
-async function createSkiffAgent(ctx, root, roleName, role, defaultModel, sessionId) {
+async function createSkiffAgent(ctx, root, profile, defaultModel, sessionId) {
 	if (!ctx.agents) throw new Error("skiff: ctx.agents unavailable");
-	const model = role.model?.trim() || defaultModel || "";
-	const id = sessionId ?? `skiff-${roleName}-${randomUUID()}`;
+	const model = profile.model?.trim() || defaultModel || "";
+	const id = sessionId ?? `skiff-${profile.code}-${randomUUID()}`;
 	const setup = async (agentCtx) => {
 		try {
 			await agentCtx.get("agentPresets")?.mount?.(agentCtx, SKIFF_PRESET);
@@ -3950,49 +4038,30 @@ async function createSkiffAgent(ctx, root, roleName, role, defaultModel, session
 	};
 	const handle = await createOrResumeAgent(ctx, id, root, model, setup, sessionId !== void 0);
 	const agent = handle.agent;
-	const kind = resolveSkiffKind(role, sessionId !== void 0);
-	const rolePrompt = kind === "persistent" ? createRolePromptReader(root, role) : (() => {
-		let snapshot = "";
+	let readerPath = profile.systemPromptFile?.trim();
+	let reader = createProfilePromptReader(root, profile);
+	const livePrompt = () => {
+		let live = profile;
 		try {
-			snapshot = resolveRoleSystemPrompt(root, role);
-		} catch (err) {
-			console.warn(`[serenity-hooks] skiff 角色 "${roleName}" 系统提示词解析失败（回退仅基础段）: ${String(err?.message ?? err)}`);
+			const fresh = readSkiffProfileAt(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 () => snapshot;
-	})();
-	rolePrompt();
-	let workspaceMdPath = null;
-	try {
-		workspaceMdPath = ensureSkiffSession(root, agent, roleName, role, kind === "persistent");
-	} catch (err) {
-		console.warn(`[serenity-hooks] skiff 角色 "${roleName}" 专属 SESSION 处理失败（不影响 agent 创建）: ${String(err?.message ?? err)}`);
-	}
+		return reader();
+	};
+	livePrompt();
 	try {
-		let readerPath = role?.systemPromptFile?.trim();
-		let reader = rolePrompt;
-		const liveRolePrompt = () => {
-			let live = role;
-			try {
-				const fresh = readSkiffRoles(root).get(roleName);
-				if (fresh) live = fresh;
-			} catch {}
-			const wantPath = live?.systemPromptFile?.trim();
-			if (wantPath !== readerPath) {
-				reader = kind === "persistent" ? createRolePromptReader(root, live) : (() => {
-					let snapshot = "";
-					try {
-						snapshot = resolveRoleSystemPrompt(root, live);
-					} catch {}
-					return () => snapshot;
-				})();
-				readerPath = wantPath;
-			}
-			return reader();
-		};
 		agent.ctx.systemPrompt.section({
 			name: "serenity-skiff",
 			order: -60,
-			text: () => [buildSkiffBasePrompt(roleName), liveRolePrompt()].filter(Boolean).join("\n")
+			text: () => {
+				const legacy = hasTrajectoryPrompt(root, profile.dirName) ? "" : livePrompt();
+				return [buildSkiffBasePrompt(profile.code), legacy].filter(Boolean).join("\n");
+			}
 		});
 	} catch (err) {
 		console.warn(`[serenity-hooks] skiff 系统提示词注册失败: ${String(err?.message ?? err)}`);
@@ -4002,8 +4071,8 @@ async function createSkiffAgent(ctx, root, roleName, role, defaultModel, session
 	} catch (err) {
 		console.warn(`[serenity-hooks] skiff 轨迹 skill 注入注册失败（不影响 agent 创建）: ${String(err?.message ?? err)}`);
 	}
-	if (workspaceMdPath) ensureWorkspacePromptSection(agent, id);
-	registerSkiffSession(id, roleName, root, agent);
+	if (skiffWorkspaceMdPath(root, id) !== null) ensureWorkspacePromptSection(agent, id, root);
+	registerSkiffSession(id, profile.dirName, root, agent);
 	return {
 		handle,
 		agent,
@@ -4029,14 +4098,12 @@ function liveReuseRef(live, setup) {
 }
 /**
 * resume-or-create 分派：固定 id → 优先 resume（持久化历史延续），失败降级 create；
-* 随机 id（无固定 sessionId）→ 恒 create。返回 handle + resumed 标志。
+* 随机 id（无固定 sessionId）→ 恒 create。
 *
 * **v1.27.3 修复（微信桥"重启后不响应"根因）：live 会话优先复用**——重启后 DSH 把
-* 关闭时仍 live 的持久化会话恢复为 live（crash/restart 恢复语义）。此时 resume 报
-* "cannot prepare session X while it is live"（session-persistence coordinator 显式
-* 拒绝 live 会话）、create 报 "session X already exists"（磁盘有持久化 log 必拒）→
-* 微信桥 catch 吞错 → 用户消息无回复。唯一可行路径 = `ctx.agents.get(id)` 取 live
-* agent 直接续用（resumed:true；角色提示词重挂与内存注册表登记由 createSkiffAgent 统一做）。
+* 关闭时仍 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 {
@@ -4096,18 +4163,13 @@ async function createOrResumeAgent(ctx, id, root, model, setup, fixedId) {
 		};
 	}
 }
-/**
-* 会话事件读取（v1.28.0 适配 0.1.2-rc.1）：rc.1 Session 移除 `.events` 属性 → `snapshotEvents()` 方法。
-* 兼容双形态（运行时 rc.1 snapshotEvents；测试替身 events）——同一函数两处语义，测试注入零侵入。
-* 注：与 cognitive-trajectory-ops.ts 导出的共享 `sessionEvents` 同构（v1.28.1 收敛基准）。本模块保留本地副本
-* 以维持独立 import 面（零 DSH 依赖测试替身形态一致）；若未来重构可统一 import 共享版。
-*/
+/** 会话事件读取（兼容 `snapshotEvents()` 与测试替身的 `.events`） */
 function sessionEvents(session) {
 	const s = session;
 	if (typeof s.snapshotEvents === "function") return s.snapshotEvents();
 	return s.events ?? [];
 }
-/** 读会话最后一个 assistant/message 文本（cheap-worker 同款） */
+/** 读会话最后一个 assistant/message 文本 */
 function lastAssistantText$1(agent) {
 	const events = sessionEvents(agent.session);
 	for (let i = events.length - 1; i >= 0; i--) {
@@ -4119,62 +4181,45 @@ function lastAssistantText$1(agent) {
 	}
 	return "";
 }
-/** events → 可读轨迹（user/assistant 文本 + 工具调用 + 工具结果；单条解析失败跳过） */
-function eventsToCognitiveTrajectory(events) {
-	const out = [];
-	for (const raw of events) try {
-		const ev = raw;
-		if (ev.type === "user/message") {
-			const text = extractText(ev.data);
-			if (text) out.push({
-				role: "user",
-				text
-			});
-		} else if (ev.type === "assistant/message") {
-			const d = ev.data;
-			const text = (d?.message?.content ?? d?.content ?? []).filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-			const calls = d?.message?.tool_calls ?? [];
-			if (text) out.push({
-				role: "assistant",
-				text
-			});
-			for (const c of calls ?? []) {
-				const args = typeof c.arguments === "string" ? c.arguments : JSON.stringify(c.arguments ?? {});
-				out.push({
-					role: "assistant",
-					text: `→ ${c.name ?? "(tool)"} ${truncate(args, 300)}`,
-					tool: c.name
-				});
-			}
-		} else if (ev.type === "tool/result") {
-			const outText = extractText(ev.data);
-			if (outText) out.push({
-				role: "tool",
-				text: truncate(outText, 500),
-				tool: String(ev.data?.name ?? "")
-			});
-		}
-	} catch {}
-	return out;
-}
-function extractText(data) {
-	const content = data?.content;
-	if (!Array.isArray(content)) return "";
-	return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+/** 本轮等待上限（毫秒）：超时即判「本轮无产出」——**绝不**把上一轮的旧答案当本轮答案 */
+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;
 }
-function truncate(s, n) {
-	return s.length > n ? `${s.slice(0, n)}…` : s;
+/**
+* 等**本轮**产出一条 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 → 等 idle → 读答案 + 轨迹。
-* @param eventsStart 轨迹起点：显式传 0 = 全量轨迹（会话追问时页面重绘完整时间线，
-*   v1.25.10 用户拍板）；不传（undefined）= 本轮增量（followup 前 events 之后）
-* @param options.includeCognitiveTrajectory 是否计算轨迹（v1.26.10 起供**对外面**传 false 跳过计算——
-*   原消费方 = 3100 公开问答页 / ACP JSON-RPC，**该面已于 2026-10-15 退役** ⇒ 现无生产调用方传 false；
-*   3099 调试页默认 true 保留）
+* 提问一轮：followup → 等**本轮**回答 → 读答案。
+*
+* @param options.timeoutMs 本轮等待上限（测试注入；生产用缺省）
 */
-async function askSkiff(ctx, agent, question, eventsStart, options) {
-	const before = eventsStart === void 0 ? sessionEvents(agent.session).length : eventsStart;
+async function askSkiff(ctx, agent, question, options) {
+	const beforeAssistant = countAssistantMessages(agent.session);
 	agent.followup(createUserMessage({
 		content: [{
 			type: "text",
@@ -4182,49 +4227,46 @@ async function askSkiff(ctx, agent, question, eventsStart, options) {
 		}],
 		source: PLUGIN_SOURCE
 	}));
-	await waitAgentIdle(ctx, agent);
-	const answer = lastAssistantText$1(agent);
-	const cognitiveTrajectory = options?.includeCognitiveTrajectory === false ? [] : eventsToCognitiveTrajectory(sessionEvents(agent.session).slice(before));
 	return {
-		answer,
-		sessionId: String(agent.session.id ?? ""),
-		cognitiveTrajectory
+		answer: await waitForTurnAssistant(ctx, agent, beforeAssistant, { timeoutMs: options?.timeoutMs }) ? lastAssistantText$1(agent) : "",
+		sessionId: String(agent.session.id ?? "")
 	};
 }
 /**
-* Skiff 会话的轨迹纪律参与判定：非 skiff 会话恒 true（正常参与）；
-* skiff 会话按角色 cognitiveTrajectory 子集（session/keeper/rebuild）决定；
-* 注册表缺失（进程重启遗留等）→ 保守旁路（false，完全独立）。
+* skiff 会话的轨迹纪律参与判定：**不是 skiff 恒 true**（正常参与）；
+* skiff 按 `skiff.json` 的 `cognitiveTrajectory` 子集决定。
+*
+* 注册表缺失（进程刚重启、绑定还没读）⇒ 由 `skiffProfileForSession` 回落持久绑定；
+* 两者都不中 ⇒ 判"不是 skiff" ⇒ 恒 true（正常参与）。**fail-open 是有意的**：
+* 纪律参与项的失败不该让会话失去 keeper/rebuild（那是能力倒退，比多跑一次更糟）。
 */
 function skiffCognitiveTrajectoryEnabled(root, sessionId, key) {
-	if (!isSkiffSessionId(sessionId)) return true;
-	const roleName = sessionId ? skiffRoleFor(sessionId) : null;
-	if (!roleName) return false;
-	const role = readSkiffRoles(root).get(roleName);
-	return cognitiveTrajectorySubset(role)[key];
+	if (sessionId === void 0) return true;
+	const profile = skiffProfileFor(root, sessionId);
+	if (profile === null) return true;
+	return profileCognitiveTrajectory(profile)[key];
 }
 /**
-* msm 工具的 Skiff 门控：非 skiff 会话恒放行；skiff 会话——
-* exec 非白名单 MSM 拒绝（不列名单）、register/deregister 必拒、
+* `msm` 工具的 skiff 门控：非 skiff 恒放行；skiff 会话——
+* exec 非白名单 MSM 拒绝（**不列名单**）、register/deregister 必拒、
 * list 白名单过滤、check/guide/ccc-config 只读放行。
 */
 function skiffMsmGate(root, sessionId, action, name) {
-	if (!isSkiffSessionId(sessionId)) return {};
-	const roleName = sessionId ? skiffRoleFor(sessionId) : null;
-	const role = roleName ? readSkiffRoles(root).get(roleName) : void 0;
-	if (!roleName || !role) return { reject: "MSM not allowed in this skiff session" };
+	if (sessionId === void 0) return {};
+	const profile = skiffProfileFor(root, sessionId);
+	if (profile === null) return {};
 	if (action === "register" || action === "deregister") return { reject: "register/deregister is not allowed in skiff sessions" };
 	if (action === "exec") {
-		if (!name || !(role.msms ?? []).includes(name)) return { reject: "MSM not allowed" };
+		if (!name || !profile.msms.includes(name)) return { reject: "MSM not allowed" };
 		return {};
 	}
-	if (action === "list") return { whitelist: roleMsmWhitelist(role) };
+	if (action === "list") return { whitelist: profileMsmWhitelist(profile) };
 	return {};
 }
 //#endregion
-//#region src/tools/msm.ts
+//#region src/tools/msm/index.ts
 /**
-* msm.ts — msm 工具（v1.30 重构：单入口执行，list/exec 合一）
+* tools/msm/index.ts — msm 工具（v1.30 重构：单入口执行，list/exec 合一）
 *
 * 设计（S142 用户拍板"msm 单入口同意 + 参数简易高效"）：
 *   acc_msm（8 action enum）→ msm（3 参数：name + args + inspect）——
@@ -4334,7 +4376,7 @@ const msmTool = defineTool({
 * ⇒ 正文**不再内嵌**（58 KB 塞进 TS 模板字符串还要转义论文里 4 处 ```mermaid 围栏——
 *   本容器为此踩过四次），改为**随包的静态资产 ＋ 运行时读取**：
 *     资产 = `assets/eap-paper.md`（**逐字**来自上游论文，未经改写）
-*     读取 = `loadEapPaper()`（进程内缓存一次；同 `voyage-page.ts` 的既有先例）
+*     读取 = `loadEapPaper()`（进程内缓存一次；同 `surface/voyage/page.ts` 的既有先例）
 *
 * 🔴 **单一真相源**：正文只在 `assets/eap-paper.md` 一个地方。本文件负责**定位与读取**，
 *    `praxis.ts` 只负责**路由**。二者都不得内嵌任何论文片段——否则又是"第二份会漂的正文"。
@@ -8282,7 +8324,7 @@ const DIAGRAM_FONT_STACK = `'Noto Sans', 'DejaVu Sans', '${DIAGRAM_CJK_FONT_FAMI
 /**
 * 包根 = **向上找到含 `package.json` 的那一级**。
 *
-* 🔴 为什么不能照抄 `voyage-page.ts` 的「`..` 一次」：那个文件在 `src/` 根下，一次 `..` 恰好是包根；
+* 🔴 为什么不能照抄 `surface/voyage/page.ts` 的「`..` 一次」：那个文件在 `src/` 根下，一次 `..` 恰好是包根；
 * 本模块在 `src/diagram/` 里 ⇒ 开发态（vitest 直接跑 TS 源码）一次 `..` 只到 `src/`，
 * 于是去找 `src/assets/…` —— **实测 ENOENT**（测试全红，且现象是"字体不在"，与真因"路径层级算错"
 * 长得完全不同）。按 `package.json` 上溯对**开发态（src/diagram）与发布态（lib/diagram）都成立**。
@@ -9436,9 +9478,9 @@ function createCheapWorkerTool(ctx) {
 	});
 }
 //#endregion
-//#region src/session-cleanup.ts
+//#region src/trajectory/cleanup.ts
 /**
-* session-cleanup.ts — DSH 平台旧会话自动清理（v1.29，S142 需求③）
+* trajectory/cleanup.ts — DSH 平台旧会话自动清理（v1.29，S142 需求③）
 *
 * 背景（实证）：DSH 会话物理存储 = `$DSH_HOME/sessions/`（缺省 ~/.dsh/sessions；
 * base bundle cordis.patch.yml root: dshHomePath('sessions')）。磁盘布局：
@@ -9455,7 +9497,7 @@ function createCheapWorkerTool(ctx) {
 *
 * 本模块纯逻辑（零 ctx 依赖）：传入 sessionsRoot + liveIds，可单测。
 */
-var session_cleanup_exports = /* @__PURE__ */ __exportAll({
+var cleanup_exports = /* @__PURE__ */ __exportAll({
 	collectEligibleSessions: () => collectEligibleSessions,
 	cutoffDaysAgo: () => cutoffDaysAgo,
 	findSessionLog: () => findSessionLog,
@@ -9645,9 +9687,9 @@ function cutoffDaysAgo(days, nowMs = Date.now()) {
 	return nowMs - days * DAY_MS;
 }
 //#endregion
-//#region src/wake-registry.ts
+//#region src/wake/registry.ts
 /**
-* wake-registry.ts — 认知轨迹唤醒注册表（D58，S142 2026-09-13）
+* wake/registry.ts — 认知轨迹唤醒注册表（D58，S142 2026-09-13）
 *
 * 需求（用户原话）：一个 CCC 内允许多个认知轨迹任意形态并行；某个认知轨迹可以
 * **预定未来唤醒自己或别人**，本质上是一次「未来时刻 + 一条 message」的投递；「周期自唤醒」
@@ -9659,7 +9701,7 @@ function cutoffDaysAgo(days, nowMs = Date.now()) {
 *  - 状态机：`pending` →（投递成功）`delivered`｜（超补跑窗口）`missed`｜（`wake rm` 物理移除）
 *  - 投递即终结：一次性，不重投（无回执语义——发起方不 await，见设计文档 §2）
 *
-* 调度与投递在 `wake-scheduler.ts`（需要 ctx），本模块保持纯净。
+* 调度与投递在 `wake/scheduler.ts`（需要 ctx），本模块保持纯净。
 */
 /** 注册表相对 CCC 根的路径（与 `.bindings.json` 同居 AGENT_SESSIONS/） */
 const WAKE_REGISTRY_REL_PATH = "AGENT_SESSIONS/wake-registry.json";
@@ -10001,9 +10043,9 @@ function listWakes(root, opts = {}) {
 	};
 }
 //#endregion
-//#region src/cro.ts
+//#region src/wake/cro.ts
 /**
-* cro.ts — CRO（Continuous Re-Occurrence · 持续再发生）机制层（S142 §7.8，2026-09-19）
+* wake/cro.ts — CRO（Continuous Re-Occurrence · 持续再发生）机制层（S142 §7.8，2026-09-19）
 *
 * ## 这东西用来干什么（白话）
 *
@@ -10044,7 +10086,7 @@ function listWakes(root, opts = {}) {
 * ## 🔴 铁律：CRO 的任何失败，绝不影响既有机制（设计 §5）
 *
 * `send-later` / `send-now` / 唤醒表的投递**照常工作**。
-* 先例 = `weixin-hook.ts` 的**旁路容忍**（"超时 kill / 非 0 退出 / spawn 失败 → 仅日志返回，绝不抛"）。
+* 先例 = `im/hook.ts` 的**旁路容忍**（"超时 kill / 非 0 退出 / spawn 失败 → 仅日志返回，绝不抛"）。
 * ⇒ 本模块的**每一个**导出函数**都不抛错**（返回结构化失败）。
 */
 /** 入口文件名（**全写**，所有者令 2026-09-19；不改缩写） */
@@ -10063,7 +10105,7 @@ const CRO_TIMEOUT_MS = 6e4;
 const CRO_STDOUT_MAX = 65536;
 /** 绑定文件体积上限（它只是个机器名 ⇒ 超过这个数一定是写错了，不读） */
 const CRO_HOST_FILE_MAX = 1024;
-/** SESSION.md 文件名（与 `cognitive-trajectory-ops.ts` 同值；此处本地常量避免反向依赖） */
+/** SESSION.md 文件名（与 `trajectory/core.ts` 同值；此处本地常量避免反向依赖） */
 const SESSION_MD = "SESSION.md";
 /**
 * 展示码派生（**只用于展示**，不作识别依据 —— §0I U4：锚永远是 `dirName`）。
@@ -10188,7 +10230,7 @@ function parseCroOutput(stdout) {
 * CRO 程序路径：`<CCC 根>/AGENT_SESSIONS/<dirName>/continuous-re-occurrence.ts`。
 *
 * ⚠️ 路径逃逸校验（`resolveInside`）：`dirName` 来自配置/工具入参，
-* 必须确保解析后仍在 CCC 根内（同 `weixin-hook.ts:160` 手法）。**抛错由调用方吞**。
+* 必须确保解析后仍在 CCC 根内（同 `im/hook.ts:160` 手法）。**抛错由调用方吞**。
 * @param root CCC 根
 * @param dirName 轨迹目录名
 * @returns 绝对路径
@@ -10365,7 +10407,7 @@ function listCroCognitiveTrajectories(root) {
 /**
 * 执行一次 CRO 程序（**永不抛** —— 旁路容忍铁律）。
 *
-* runner 顺序（照 `weixin-hook.ts:171-174` 的 bun 优先 / node 兜底）：
+* runner 顺序（照 `im/hook.ts:171-174` 的 bun 优先 / node 兜底）：
 * `bun` → `process.execPath`（同运行时）。
 * 判据：`ENOENT`（二进制不存在）⇒ 试下一个；**其余失败视为最终结果**
 * （程序自己报错就是报错，不该用另一个 runner 掩盖——与 hook 一致）。
@@ -10627,9 +10669,9 @@ function registerDisposer(ctx, label, cleanup) {
 	}
 }
 //#endregion
-//#region src/cro-turns.ts
+//#region src/wake/cro-turns.ts
 /**
-* cro-turns.ts — 「这条轨迹是否正在跑轮次」的追踪（设计 §3.2，2026-09-19 S142）
+* wake/cro-turns.ts — 「这条轨迹是否正在跑轮次」的追踪（设计 §3.2，2026-09-19 S142）
 *
 * ## 为什么需要这个模块（CRO 唯一需要 ACC 新增的状态）
 *
@@ -10643,7 +10685,7 @@ function registerDisposer(ctx, label, cleanup) {
 * | 事件 | 动作 | 出处 |
 * |---|---|---|
 * | `agent/created` | 标记「在跑」 | `host/contract.ts`（dsp 已在 `seams/context.ts` 订阅）。⚠️ v0.1.7 前名为 `agent/session-start`；新事件 `@mode = serial` ⇒ 处理函数须快速返回 |
-* | `agent/turn-stopping` | 清除标记 | `host/contract.ts:277`（dsp 已在 `rebuild.ts:442` 等 4 处订阅） |
+* | `agent/turn-stopping` | 清除标记 | `host/contract.ts:277`（dsp 已在 `trajectory/rebuild.ts:442` 等 4 处订阅） |
 * | `agent/disposed` | **清该载体的项** | `host/contract.ts:280` |
 * | `session/disposed` | **清该载体的项** | `host/contract.ts:283` |
 *
@@ -10755,13 +10797,13 @@ function runningCarriersOf(boundSessionIds, nowMs, ttlMs = TURN_TTL_MS) {
 * 🔴 **本处顺带更正 §2.7 的一处分档**：本文件原被列在"剩余 3 个属**真依赖**档"里，
 * 但**逐符号查证后与那个判断不符** ——
 *   · `Context`：`ctx` 只被**结构化访问**（原码本就写着 `ctx as unknown as { on: … }`）
-*     ⇒ 该注解未提供任何类型保证（与 `agent-idle.ts` 同档）。
+*     ⇒ 该注解未提供任何类型保证（与 `role/worker/idle.ts` 同档）。
 *   · `Agent`：**导入后从未使用** —— 事件 payload 一律按 `{ agent?: unknown }` 解构，
 *     再交给 `sessionIdOf(...)`（它收 `unknown`）。⇒ **纯粹是死 import**。
 * ⇒ **判据（本件再证一次，且比上一件更硬）**：分档**必须逐符号看"它有没有参与类型检查"**，
 *   **不能按文件整档划分** —— 同一个文件里可以并存"真依赖符号"与"纯名义符号"。
-* 🔵 **剩余 2 个文件**才是真依赖档：`rebuild.ts` 用 `Session`/`SessionEvent`/
-*   `deriveEventMessage`/`Agent` 等**真调用**的类型；`wake-scheduler.ts` 用 `Agent` 的
+* 🔵 **剩余 2 个文件**才是真依赖档：`trajectory/rebuild.ts` 用 `Session`/`SessionEvent`/
+*   `deriveEventMessage`/`Agent` 等**真调用**的类型；`wake/scheduler.ts` 用 `Agent` 的
 *   `followup`/`steer`（**真调用**）⇒ 它们走 §2.7-③ **选项 (b)** 或把中立接口下沉到 L0，
 *   **另立一件**（D85 一次只改一件事）。
 * @param ctx 插件上下文（**结构化访问** `on`，故类型为 `unknown`，见下方 I2 说明）
@@ -10803,9 +10845,9 @@ function registerCroTurnTracking(ctx) {
 	});
 }
 //#endregion
-//#region src/cro-log.ts
+//#region src/wake/cro-log.ts
 /**
-* cro-log.ts — CRO 唤起日志（**ACC 侧**，每轨迹一份固定名文件，2026-09-20 S142 §7.16）
+* wake/cro-log.ts — CRO 唤起日志（**ACC 侧**，每轨迹一份固定名文件，2026-09-20 S142 §7.16）
 *
 * ## 所有者令（本模块的存在理由）
 *
@@ -10837,11 +10879,11 @@ function registerCroTurnTracking(ctx) {
 * ## 🔴 轮转（所有者明示「程序化的」）
 *
 * **写入时按窗裁剪**：每次落盘只保留 `at >= now - CRO_LOG_RETENTION_MS` 的条目，
-* 随后**原子写**（`tmp + rename`，与 `wake-registry.ts` 同款形态）。
+* 随后**原子写**（`tmp + rename`，与 `wake/registry.ts` 同款形态）。
 * ⇒ 清理与写入**是同一笔操作** ⇒ **结构上不存在"忘了清"的可能**（比"另设一个每 tick 的清理步"更硬：
 * 那多一个"可能忘了跑"的面）。窗宽是**常量**，**无配置键、无人工清理动作**。
 *
-* ## 🔴 铁律（与 `cro.ts` 同族）
+* ## 🔴 铁律（与 `wake/cro.ts` 同族）
 *
 * **本模块的每个导出函数都不抛错**：写盘 / 裁剪 / 解析失败一律返回结构化失败，
 * 由调用方只记一行 tick 日志 ⇒ **CRO 流水的问题绝不影响投递与既有链路**（设计 §5）。
@@ -11007,12 +11049,12 @@ function appendCroWakeLog(root, dirName, input, nowMs = Date.now()) {
 	}
 }
 //#endregion
-//#region src/clock-runtime.ts
+//#region src/wake/clock.ts
 /**
-* clock-runtime.ts — **时钟运行时工厂**（S142 §38 复审候选 C6b，路径 **P2**）
+* wake/clock.ts — **时钟运行时工厂**（S142 §38 复审候选 C6b，路径 **P2**）
 *
 * 🔴 2026-09-25（S142 分批清死代码·第 1 批）**更正**：本文件当初是为**两条**独立 5min 时钟抽出的公共引擎：
-*   · 唤醒调度器（`wake-scheduler.ts`，一次性唤醒，D58）—— **现存**
+*   · 唤醒调度器（`wake/scheduler.ts`，一次性唤醒，D58）—— **现存**
 *   · autopilot 时钟（`autopilot-trajectory.ts`，周期自唤醒，D59）—— 🔴 **已随 v1.35.0 整段退场**
 * 二者的**业务判据完全不同**（谁来扫 / 扫什么 / 投递给谁 / 按什么周期），但**引擎骨架逐字同形**
 * ——进程态 + 快照 + 复位 + `startTimer` + tick 外壳 + 事件接线 + disposer + `timer.unref()`。
@@ -11059,7 +11101,7 @@ function appendCroWakeLog(root, dirName, input, nowMs = Date.now()) {
 * **本工厂是"加法式"重构**（P2 的性质）：不新增任何判定逻辑，只把同形骨架收成一份代码；
 * 两个模块仍各自导出 `wakeSchedulerState()` / `autopilotClockState()` 与各自的
 * `__reset…ForTest()`，**对外可观测面（字段名与语义）零变化**——`acc-diag` ①b 段、
-* `container-status.ts:containerClocks()` 与面板都在读它们（见该文件 :225–250 的设计红线）。
+* `surface/observation.ts:containerClocks()` 与面板都在读它们（见该文件 :225–250 的设计红线）。
 *
 * 为什么**不**取 P1（真合并成一个 `setInterval` + 两条策略）——2026-09-15 所有者裁决：
 * P1 只多省 ~20 行，却要把 `armed` 拆成"宿主 + 每策略"两层、并强行分开串行域，
@@ -11215,9 +11257,9 @@ function createClock(opts) {
 	return api;
 }
 //#endregion
-//#region src/wake-scheduler.ts
+//#region src/wake/scheduler.ts
 /**
-* wake-scheduler.ts — 认知轨迹唤醒调度器（D58/D59/D60；S142 2026-09-13）
+* wake/scheduler.ts — 认知轨迹唤醒调度器（D58/D59/D60；S142 2026-09-13）
 *
 * 一个**中心调度器**（5min tick，复用 autopilot 的节律常量），处理 CCC 唤醒注册表里
 * 到期的条目：把「未来时刻 + 一条 message」投递给目标认知轨迹，**fire-and-forget**
@@ -11964,9 +12006,9 @@ function registerWakeScheduler(ctx) {
 	registerDisposer(ctx, "认知轨迹唤醒调度器", () => clock.dispose());
 }
 //#endregion
-//#region src/cro-guide.ts
+//#region src/wake/cro-guide.ts
 /**
-* cro-guide.ts — CRO 编写指南（**ACC 内置**，S142 §7.8，2026-09-19）
+* wake/cro-guide.ts — CRO 编写指南（**ACC 内置**，S142 §7.8，2026-09-19）
 *
 * ## 为什么指南在 ACC 而不在 CCC（所有者令）
 *
@@ -12212,7 +12254,7 @@ ${renderCroSampleSnapshot()}
 * 动作面现行 **8 个**：list / show / create / use / rebuild / **`send-now`** / **`send-later`** / **`cro-guide`**。
 * 🔴 2026-09-16（所有者裁决）：**第 7 个动作 `send-message`（即时投递）**
 *    ——与 `wake-later` 共用取用通路，差别只在**时刻**（现在 vs 未来）与**回执**（有 vs 无）；
-*    实现落在 `wake-scheduler.ts` 的 `sendToTrajectory()`（"怎么把一句话送到一条轨迹"是调度器的知识）。
+*    实现落在 `wake/scheduler.ts` 的 `sendToTrajectory()`（"怎么把一句话送到一条轨迹"是调度器的知识）。
 *    设计稿 = `docs/cognitive-trajectory-send-message-design.md`（v0.2 定稿）。
 * 🔴 2026-09-17（所有者裁决 · **命名 A 案**）：**两个投递动作更名** —— `wake-later` → **`send-later`**、
 *    `send-message` → **`send-now`**。判据（R↓）：两者本是**同一条投递通路**（同取用机制 / 同载荷 /
@@ -12350,6 +12392,8 @@ function createCognitiveTrajectoryTool(ctx) {
 			"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.",
@@ -12376,12 +12420,13 @@ function createCognitiveTrajectoryTool(ctx) {
 			"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> [--goal] or --issue <ticket> (exactly one) plus --summary (≤20 chars).",
+			"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 (S### or AGENT_SESSIONS dir name) + at (RFC3339 or +30m/+2h) + message.",
+			"send-later requires target (a code or AGENT_SESSIONS dir name) + at (RFC3339 or +30m/+2h) + message.",
 			"send-now requires target + message.",
-			"The summary is appended to the dsh session title (S###-YYYY-MM-DD-<summary>); the S### id and date stay server-derived."
+			"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."
 		].join(" "),
 		parameters: {
 			action: {
@@ -12391,8 +12436,8 @@ function createCognitiveTrajectoryTool(ctx) {
 				description: [
 					"Subcommand — grouped by effect.",
 					"LIFECYCLE (changes THIS conversation's binding):",
-					"list (inventory + stats + anomaly marks) / show (S### or dir name or fuzzy keyword) /",
-					"create (new cognitive trajectory; activates itself when you have no binding, otherwise leaves your binding untouched and tells you how to activate it) /",
+					"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) /",
 					"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).",
@@ -12404,11 +12449,11 @@ function createCognitiveTrajectoryTool(ctx) {
 			},
 			name: {
 				type: "string",
-				description: "show/use/archive/uid identifier — S### / dir name / UID / fuzzy keyword"
+				description: "show/use/archive/uid identifier — a trajectory code (S### or a custom code) / dir name / legacy UID / fuzzy keyword"
 			},
 			uid: {
 				type: "string",
-				description: `uid: the trajectory's unique identifier (a separate, optional handle independent of its code and name — file ${UID_FILENAME} inside the trajectory dir). Omit to READ it; pass a value to SET it; pass "" to CLEAR it (falls back to the code). Allowed [A-Za-z0-9._-], ≤64, case-sensitive, must be unique across trajectories.`
+				description: `uid: READ-ONLY legacy field. Omit to read a trajectory's legacy ${UID_FILENAME}. Passing any value is REJECTED — setting a UID is retired (2026-10-19); a trajectory's code is its unique identity now, and you choose it at creation with create --id <code>.`
 			},
 			note: {
 				type: "string",
@@ -12418,6 +12463,10 @@ function createCognitiveTrajectoryTool(ctx) {
 				type: "string",
 				description: "create: short description (any language, ≤5 words; mutually exclusive with issue)"
 			},
+			id: {
+				type: "string",
+				description: "create: the trajectory CODE to assign (its stable unique identity — this is what you later pass as name/target). Omit to auto-assign S###. Allowed [A-Za-z0-9._-], starts alphanumeric, ≤64, must NOT contain Chinese or \"--\" (that is the dir-name separator); must not collide with an active trajectory code."
+			},
 			issue: {
 				type: "string",
 				description: "create: ticket number (e.g. apaas-26116; dir named YYYY-MM-DD--<issue>; mutually exclusive with desc)"
@@ -12471,6 +12520,7 @@ function createCognitiveTrajectoryTool(ctx) {
 						root,
 						desc: args.desc,
 						issue: args.issue,
+						id: args.id,
 						goal: args.goal,
 						dryRun: isDryRun
 					});
@@ -12572,26 +12622,18 @@ function createCognitiveTrajectoryTool(ctx) {
 					};
 				}
 				case "uid": {
-					if (!args.name) throw new Error("uid requires name (S### / dir name / existing UID)");
-					if (args.uid === void 0) {
-						const entry = findSession(join(root, "AGENT_SESSIONS"), args.name);
-						if (!entry) throw new Error(`Trajectory not found: "${args.name}"`);
-						const cur = readTrajectoryUid(entry.path);
-						return {
-							ok: true,
-							dirName: entry.dirName,
-							uid: cur,
-							note: cur === null ? `未设定 UID ⇒ 用编码指认（${entry.dirName.match(/--(S\d{3,})--/)?.[1] ?? "无编码"}）。` : `当前 UID = ${cur}（文件 ${UID_FILENAME}）`
-						};
-					}
-					const next = args.uid === "" ? null : String(args.uid);
-					const r = setTrajectoryUid(join(root, "AGENT_SESSIONS"), args.name, next);
+					if (!args.name) throw new Error("uid requires name (code / S### / dir name / existing UID)");
+					const entry = findSession(join(root, "AGENT_SESSIONS"), args.name);
+					if (!entry) throw new Error(`Trajectory not found: "${args.name}"`);
+					const cur = readTrajectoryUid(entry.path);
+					if (args.uid !== void 0) throw new Error("Setting a trajectory UID has been retired (2026-10-19). A trajectory's code IS its unique identity now, and you can choose it at creation time: cognitive_trajectory create --id <code> --desc <desc> --summary <summary>. Existing TRAJECTORY-UID files are still READ (so old handles keep resolving) — they are just never written.");
 					return {
 						ok: true,
-						dirName: r.dirName,
-						uid: r.uid,
-						message: r.uid === null ? `已清除 UID ⇒ "${r.dirName}" 回到用编码指认` : `已设定 UID = "${r.uid}" ⇒ 所有支持编码的动作（show/use/archive/send-now/send-later/uid）现在也接受它`,
-						path: r.path
+						dirName: entry.dirName,
+						code: parseTrajectoryCode(entry.dirName),
+						uid: cur,
+						retired: true,
+						note: cur === null ? `未设定遗留 UID ⇒ 用编码指认（${parseTrajectoryCode(entry.dirName) ?? "无编码"}）。UID 写入已退役；要一条可指定的标识，请用 create --id 起新轨迹。` : `遗留 UID = ${cur}（文件 ${UID_FILENAME}，只读兼容）——仍可用它指认本条轨迹。⚠️ 写入已退役：新轨迹用 create --id 指定编码。`
 					};
 				}
 				case "send-later": {
@@ -12672,12 +12714,12 @@ function advisoryHint(dirName, mdPath) {
 	return null;
 }
 //#endregion
-//#region src/tools/localstore.ts
+//#region src/tools/localstore/index.ts
 /**
 * localstore.ts — localstore 真实 DSH 工具定义（defineTool）
 *
 * ACC 标准本地凭据/配置存储（S133 设计，S134 重设计：CCC 根 localstore.json）。
-* 进程内注册，零 DSH 依赖逻辑在 localstore-ops.ts（可单测）。
+* 进程内注册，零 DSH 依赖逻辑在 tools/localstore/service.ts（可单测）。
 * doc 子命令输出存储规范，agent 可直接用 fs 工具（read/write）自己读写。
 */
 const ACTIONS$1 = [
@@ -12730,106 +12772,96 @@ const localstoreTool = defineTool({
 });
 //#endregion
 //#region src/tools/skiff-admin.ts
-/** Skiff 定义教程（核心）：概念 / schema / 认知 MSM 写法 / 双白名单 / 轨迹纪律 / 示例角色 */
-const SKIFF_GUIDE = `═══ Skiff Definition Guide (F4, experimental) ═══
+/** Skiff 定义教程：概念 ／ `skiff.json` schema ／ 双白名单 ／ 轨迹纪律 ／ 微信路由 */
+const SKIFF_GUIDE = `═══ Skiff Guide (2026-10-19 redesigned) ═══
 
-Skiff = 宁静号放出的独立小艇——完整 cognitive trajectory（在宁静号内全知全能）的**任意子集角色**。
-由本 CCC（.opencode/serenity.json skiff.roles）定义：能力面（双白名单）+ 轨迹纪律子集 + 系统提示词。
-dsp 只提供机制（双白名单强制 + 基础提示词 + 调试问答页）；角色内容完全由 CCC 发挥。
+**A skiff IS a cognitive trajectory — the one whose directory contains \`${SKIFF_PROFILE_FILENAME}\`.**
+That is the whole rule. No role table, no name registry: put the file there and the trajectory
+becomes a skiff; delete it and it goes back to being an ordinary trajectory (takes effect at once).
 
-── 角色配置 schema ──
-  { "skiff": { "roles": {
-      "<role-name>": {
-        "model": "provider/model",             // 角色模型（CCC 直接指定，无白名单校验；缺省回退 cheap-worker.defaultModel）
-        "msms": ["msm-a", "msm-b"],            // MSM 白名单（独立）：msm 工具只能执行这些；register/deregister 必拒
-        "tools": ["read","grep","glob",...],   // 非 MSM 工具白名单（独立）：白名单外工具一律不可用（guard 强制）
-        "cognitiveTrajectory": { "session": false, "keeper": false, "rebuild": false },  // 轨迹纪律子集（缺省全关 = 完全独立）
-        // 角色人格/认知边界/风格（CCC 完整定义；dsp 只给基础提示词）
-        "systemPromptFile": ".opencode/skiff/<role>.md"   // ★ 推荐：引用 md 文件（相对 CCC 根；超长提示词在 JSON 内嵌不可读）
-        // "systemPrompt": "..."                          // 兼容：内嵌字符串仍可用；两者都设时 systemPromptFile 优先
-      }
-  } } }
+  AGENT_SESSIONS/<YYYY-MM-DD--<code>--<desc>>/
+    ├─ SESSION.md      ← its persistent body (this IS the workspace — nothing is auto-created)
+    ├─ ${SKIFF_PROFILE_FILENAME}          ← its constraints (this file is what makes it a skiff)
+    └─ TRAJECTORY-UID  ← legacy, read-only (superseded by the code)
 
-── 双白名单语义（全按白名单暴露，白名单外全隐藏）──
-  - tools 空 + msms 非空 = 纯 MSM 角色（认知问答典型形态）
-  - msms 非空 → msm 工具自动可用（MSM 通道）
-  - 白名单外工具即使 DSH 未来新增也自动被挡（guard 按角色判定，不枚举工具名——完备性）
+── ${SKIFF_PROFILE_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",  // recommended: relative to CCC root, hot-reloads on save
+    "systemPrompt": "..."                             // inline fallback; systemPromptFile wins when both are set
+  }
 
-── 认知 MSM 写法（读知识 / 操作能力）──
-  - 读知识：脚本读 CCC 内文件（SERENITY_ROOT env 注入）→ 输出答案/摘要（如 cognitive-qa）
-  - 操作能力：脚本调用既有家庭工具/服务（SSH/API/文件操作）——角色能力上限 = 白名单 MSM 的实际行为
-  - 例：cognitive-qa（读 docs/references 回答）、review-scan（读代码出审查意见）、review-fix（写修复）
-  - 注意：MSM 在脚本层执行（bun），文件访问不受 agent 工具面约束——"只读"语义靠 CCC 自写 MSM 自觉
+── Two whitelists, both default-deny ──
+  - \`tools: []\` + non-empty \`msms\` = pure-MSM skiff (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
 
-── 轨迹纪律子集（cognitiveTrajectory）──
-  - session/keeper/rebuild 默认 false：Skiff 完全独立（不建 SESSION.md、无 keeper 提醒、无 rebuild 压力检测）
-  - 开启某项 = 该角色参与对应轨迹机制（如 keeper=true 计分提醒按角色生效）
+── cognitiveTrajectory: why the defaults are TRUE ──
+  The workspace of a skiff 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.
 
-── 示例角色 ──
-  qa-readonly: { "msms": ["cognitive-qa"], "tools": [], "cognitiveTrajectory": {} }
-      → 认知问答（仅 MSM 通道，无直接工具，完全独立）
-  code-review: { "msms": ["review-scan","review-fix"], "tools": ["read","grep","glob","write","edit"], "cognitiveTrajectory": { "keeper": true } }
-      → 有操作能力（可写修复），参与 keeper 轨迹机制
+── WeChat routing: user → trajectory code ──
+  \`weixin.routes\`: \`[{ "user": "<wx 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 \`${SKIFF_PROFILE_FILENAME}\` is still a legal target — it is just an ordinary trajectory.
 
-── 运行 ──
-  调试：设置面板「Serenity」页 Skiff 区块开启 → http://127.0.0.1:<debugPort> 问答页实测
-  🔴 外部程序化接入（2026-10-15 起改走官方）：本插件自造的 ACP 面（HTTP JSON-RPC 3100 ／
-    建议问答页）**已整体退役**（owner 裁「砍掉外部问答」）。现在要程序化/远程接入，走宿主
-    自带的官方 ACP server：dsh --profile acp（纯 stdio、零认证）＋ 任一 ACP 客户端
-    （手机端如 Agmente / ACP UI）经隧道接入。详见 S142 的接入指南文档。
-  启停 = 人工（设置面板开关，不随插件加载自动启动）；未开启零资源占用
-  生效机制：角色配置**实时读取**（改 .opencode/serenity.json → 刷新调试页即生效）；
-  改配置后用 container_admin role apply 做显式校验 + 应用确认（绑定 CCC + 角色清单）
-  会话追问（v1.25.10）：调试页持有当前会话，追问自动续接（同会话上下文延续）；
-  「新对话」按钮开新会话；进程重启后旧会话不可续（WebUI 仍可见历史）
-  注意：skill 加载对 skiff **恒可用**（不设白名单——读知识面，无写能力）`;
-/** 校验当前 CCC 的 skiff 配置：roles schema 合法 / msms 均已注册 / model ∈ cheap-worker.models / systemPrompt 非空 */
+── Operating it ──
+  Debug page: Settings → Serenity → enable the Skiff block → http://127.0.0.1:<debugPort>
+  Everything is read live: saving \`${SKIFF_PROFILE_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 role apply for an explicit validation + confirmation pass.
+  Skill loading is always available to skiff sessions (skills are not whitelisted — they are read-only knowledge).`;
+/** 校验当前 CCC 的 skiff 约束面：msms 均已注册 ／ model ∈ cheap-worker.models ／ 提示词非空 */
 function validateSkiffConfig(root) {
-	const roles = readSkiffRoles(root);
+	const profiles = listSkiffProfiles(root);
 	const issues = [];
-	if (roles.size === 0) return {
+	if (profiles.length === 0) return {
 		ok: true,
 		issues: [],
 		roleCount: 0,
-		note: "no skiff roles defined (skiff disabled — zero impact)"
+		note: `no skiff trajectories in this CCC (no trajectory has ${SKIFF_PROFILE_FILENAME} — zero impact)`
 	};
 	const registered = new Set(loadMsmEntries(root).map((e) => e.name));
 	const hc = readCheapWorkerConfig(root);
 	const allowedModels = hc ? new Set(hc.models) : null;
-	for (const [name, role] of roles) {
-		try {
-			if (!resolveRoleSystemPrompt(root, role).trim()) issues.push(`role "${name}": system prompt is empty (define systemPromptFile (recommended) or systemPrompt)`);
-		} catch (err) {
-			issues.push(`role "${name}": ${String(err?.message ?? err)}`);
-		}
-		for (const m of role.msms ?? []) if (!registered.has(m)) issues.push(`role "${name}": msms "${m}" is not registered in mech-registry.json`);
-		if (role.model && allowedModels && !allowedModels.has(role.model)) issues.push(`role "${name}": model "${role.model}" not in cheap-worker.models (${[...allowedModels].join(", ") || "(none)"})`);
+	for (const p of profiles) {
+		if (!(hasTrajectoryPrompt(root, p.dirName) || (() => {
+			try {
+				return resolveProfileSystemPrompt(root, p).trim() !== "";
+			} catch (err) {
+				issues.push(`trajectory "${p.code}": ${String(err?.message ?? err)}`);
+				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`);
+		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 {
 		ok: issues.length === 0,
 		issues,
-		roleCount: roles.size
+		roleCount: profiles.length
 	};
 }
-/** 列出当前 CCC 已定义角色（名 / 模型 / msms / tools / 轨迹纪律摘要） */
+/** 列出当前 CCC 的 skiff 轨迹（编码 ／ 模型 ／ msms ／ tools ／ 纪律摘要 ／ 提示词来源） */
 function listSkiffRoles(root) {
-	const roles = readSkiffRoles(root);
-	if (roles.size === 0) return {
+	const profiles = listSkiffProfiles(root);
+	if (profiles.length === 0) return {
 		roles: [],
-		note: "no skiff roles defined (skiff disabled)"
-	};
-	const items = [...roles.entries()].map(([name, role]) => ({
-		name,
-		model: role.model ?? "(cheap-worker default)",
-		msms: role.msms ?? [],
-		tools: role.tools ?? [],
-		cognitiveTrajectory: {
-			session: role.cognitiveTrajectory?.session === true,
-			keeper: role.cognitiveTrajectory?.keeper === true,
-			rebuild: role.cognitiveTrajectory?.rebuild === true
-		},
-		promptSource: systemPromptSource(role),
-		...role.systemPromptFile ? { systemPromptFile: role.systemPromptFile } : {}
+		note: `no skiff trajectories in this CCC (no trajectory has ${SKIFF_PROFILE_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: profileCognitiveTrajectory(p),
+		promptSource: profileSystemPromptSource(p),
+		...p.systemPromptFile ? { systemPromptFile: p.systemPromptFile } : {}
 	}));
 	return {
 		roles: items,
@@ -12837,29 +12869,29 @@ function listSkiffRoles(root) {
 	};
 }
 /**
-* 应用当前 skiff 配置（v1.25.3，S142 用户：改了 json 应该有个生效机制）。
+* 应用当前 skiff 配置（S142 用户：改了 json 应该有个生效机制）。
 *
-* 语义：配置是**每次请求实时读取**的（v1.25.2）——apply 不是"推送"，而是**显式校验 + 应用确认**：
-* ① 校验配置合法（复用 validate：msms 注册 / model 白名单 / systemPrompt 非空）
+* 语义：约束面是**每轮实时读取**的 ⇒ apply 不是"推送"，而是**显式校验 + 应用确认**：
+* ① 校验合法（复用 validate：msms 注册 / model 白名单 / 提示词非空）
 * ② 非法 → 报告问题清单，不应用（提示修复后重跑 apply）
-* ③ 合法 → 应用确认：绑定 CCC + 角色清单 + 说明（调试页刷新即生效）
+* ③ 合法 → 应用确认：绑定 CCC + 轨迹清单 + 说明（下一轮即生效）
 */
 function applySkiffConfig(root) {
 	const validation = validateSkiffConfig(root);
-	const roles = readSkiffRoles(root);
+	const profiles = listSkiffProfiles(root);
 	if (!validation.ok) return {
 		applied: false,
 		cccRoot: root,
-		roleCount: roles.size,
+		roleCount: profiles.length,
 		issues: validation.issues,
 		hint: "fix the issues above, then run container_admin role apply again"
 	};
 	return {
 		applied: true,
 		cccRoot: root,
-		roleCount: roles.size,
-		roles: [...roles.keys()],
-		note: "roles are read live from .opencode/serenity.json — the skiff debug page reflects changes on refresh; skill loading is always available to skiff sessions (not whitelisted)"
+		roleCount: profiles.length,
+		roles: profiles.map((p) => p.code),
+		note: `constraints are read live from each trajectory's ${SKIFF_PROFILE_FILENAME} — they take effect on the next turn (no restart); ${SKIFF_PROFILE_HINT}`
 	};
 }
 //#endregion
@@ -13002,18 +13034,18 @@ function createContainerAdminTool(ctx) {
 	});
 }
 //#endregion
-//#region src/im-bridge.ts
+//#region src/im/channels.ts
 /**
-* im-bridge.ts — IM 发送能力层（v1.31.0，S142 用户洞察）
+* im/channels.ts — IM 发送能力层（v1.31.0，S142 用户洞察）
 *
 * 用户原话：「既然微信桥是我们 ACC 提供的，那么 weixin-send 应该是我们 ACC 提供的能力，
 * 当用户配置了微信桥则可用，不配置则不可见」＋「设定一个复杂的多层工具，叫 im-bridge，
 * 里面有微信，然后保留后续可能兼容别的 im 的空间」。
 *
 * 分层（E↑）：
-*   `tools/im-bridge.ts`（工具面：参数 → 结果渲染）
+*   `tools/im/channels.ts`（工具面：参数 → 结果渲染）
 *     → **本模块**（通道注册表 + 可见性判据 + 动作分发 + 错误码翻译）
-*       → 通道实现（`im-weixin.ts`：协议/凭据/账号/记录）
+*       → 通道实现（`im/weixin-channel.ts`：协议/凭据/账号/记录）
 *
 * 边界（R↓）：
 * - **本模块零宿主依赖**（不 import cordis/agent）——可见性判定与分发都是纯逻辑，可独立单测。
@@ -13286,16 +13318,15 @@ function isWriteTool(toolName, action) {
 */
 function decideGuard(input) {
 	const { root, toolName, safeModeOn, blacklist, pathArg, action } = input;
-	if (input.skiffSessionId !== void 0 && isSkiffSessionId(input.skiffSessionId)) {
+	if (input.skiffProfile !== void 0 && input.skiffProfile !== null) {
+		const profile = input.skiffProfile;
 		if (toolName === "skill") return { kind: "allow" };
-		const roleName = input.skiffSessionId ? skiffRoleFor$1(input.skiffSessionId) : null;
-		const role = roleName ? readSkiffRoles(root).get(roleName) : void 0;
-		if ((role?.msms ?? []).includes(toolName)) return {
-			deny: `"${toolName}" is a registered MSM, not a direct tool in this role — call it through the msm tool: msm("${toolName}", ["<args>"]) (pass "--help" or inspect=true for usage)`,
+		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 (!roleToolWhitelist(role).has(toolName)) return {
-			deny: "tool not allowed in this skiff role",
+		if (!profileToolWhitelist(profile).has(toolName)) return {
+			deny: "tool not allowed in this skiff trajectory",
 			kind: "deny"
 		};
 	}
@@ -13450,7 +13481,7 @@ function syncSafeModeRestriction(agent, root) {
 	});
 	writeRestrictDiag(root);
 }
-/** 条件可见的 IM 工具名（与 tools/im-bridge.ts 的注册名一致） */
+/** 条件可见的 IM 工具名（与 tools/im/channels.ts 的注册名一致） */
 const IM_BRIDGE_TOOL_NAME = "im-bridge";
 /** agent key → restrict disposer（im-bridge 隐藏状态；key 同安全模式 = 会话 id） */
 const imBridgeRestrictions = /* @__PURE__ */ new Map();
@@ -13582,26 +13613,25 @@ const exclusiveRestrictions = /* @__PURE__ */ new Map();
 */
 const skiffRoleRestrictions = /* @__PURE__ */ new Map();
 /**
-* 同步 **Skiff 会话的工具面**：把角色白名单之外的工具**从 schema 移除**（不是"看得到但被拒"）。
+* 同步 **skiff 会话的工具面**：把白名单之外的工具**从 schema 移除**（不是"看得到但被拒"）。
 *
 * ## 为什么必须有这条（owner 2026-10-19：「工具清单也要热加载」）
 *
-* 在它之前，skiff 角色白名单**只由运行时守卫拦截**（`decideGuard` 的 skiff 分支）：
-* 工具全部出现在模型 schema 里，调用时才被 `tool not allowed in this skiff role` 打回。
-* ⇒ 两个真实后果：
+* 在它之前，skiff 白名单**只由运行时守卫拦截**（`decideGuard` 的 skiff 分支）：
+* 工具全部出现在模型 schema 里，调用时才被打回。⇒ 两个真实后果：
 *  ① **模型看得见它不该有的工具** —— 它会去试，试了才撞墙（一轮白烧，且错误文案泛化，
 *     看不出"是不在清单里"还是"临时性拒绝"）；
-*  ② **配置变动在 schema 上永远不生效** —— 改 `skiff.roles.<r>.tools` 只影响"调用是否放行"，
-*     不影响"模型看得见什么"。这正是 owner 报的"工具清单不热加载"。
+*  ② **配置变动在 schema 上永远不生效** —— 改 `skiff.json` 的 `tools` 只影响"调用是否放行"。
 *
 * ## 判据与降级
 *
-* - deny 集合 = **`REGISTERED_TOOLS` − 角色白名单**（只对**我们自己注册的**工具算，
+* - deny 集合 = **`REGISTERED_TOOLS` − 白名单**（只对**我们自己注册的**工具算，
 *   不去动宿主的工具 —— 宿主的工具由各自的条件同步管）。
 * - ⚠️ **未注册的名字会让整次 restrict 失败**（宿主契约逐字 "unknown names … fail"），
 *   而 `diagram` 是按开关注册的 ⇒ 与 `hideAllFor` 同款**两档尝试**（先全覆盖，失败退常驻段）。
-* - 读不到角色（配置删了/角色被移除）⇒ **不动**（fail-open）：此时守卫仍会拦，
-*   最坏是"又变成看得见但调不动"，而不是把工具全删光。
+* - 读不到约束面（不是 skiff / 配置删了）⇒ **撤销既有隐藏**（回到"无约束"）：
+*   ⛔ 不能只是 `return` —— 那会把上一步的隐藏**永久留在**一个已不再是 skiff 的会话上
+*   （这正是 owner 说的"删掉 `skiff.json` 就该立刻恢复"）。
 * - 幂等：算出来的 deny 签名不变就跳过（不每步重建 schema）。
 *
 * @param agent 目标会话
@@ -13609,20 +13639,20 @@ const skiffRoleRestrictions = /* @__PURE__ */ new Map();
 */
 function syncSkiffRoleToolVisibility(agent, root) {
 	const sessionId = agent.session.id ?? "global";
-	if (!isSkiffSessionId(sessionId)) return;
-	const roleName = skiffRoleFor$1(sessionId);
-	if (!roleName) return;
-	let allowed;
-	try {
-		const role = readSkiffRoles(root).get(roleName);
-		if (!role) return;
-		allowed = roleToolWhitelist(role);
-	} catch {
+	const profile = skiffProfileForSession(root, sessionId);
+	const existing = skiffRoleRestrictions.get(sessionId);
+	if (profile === null) {
+		if (existing !== void 0) {
+			try {
+				existing.dispose();
+			} catch {}
+			skiffRoleRestrictions.delete(sessionId);
+		}
 		return;
 	}
+	const allowed = profileToolWhitelist(profile);
 	const resident = REGISTERED_TOOLS.slice(0, REGISTERED_TOOLS.length - 3);
 	const tiers = [REGISTERED_TOOLS, resident];
-	const existing = skiffRoleRestrictions.get(sessionId);
 	for (const names of tiers) {
 		const deny = names.filter((n) => !allowed.has(n));
 		const signature = [...deny].sort().join(",");
@@ -13857,6 +13887,7 @@ function registerGuards(ctx, opts = {}) {
 		const pathArg = extractPathArg(exec);
 		const action = extractAction(exec);
 		const sessionId = exec?.agent?.session?.id;
+		const skiffProfile = skiffProfileForSession(root, sessionId);
 		return decideGuard({
 			root,
 			toolName: exec.name,
@@ -13864,7 +13895,7 @@ function registerGuards(ctx, opts = {}) {
 			blacklist,
 			pathArg,
 			action,
-			skiffSessionId: sessionId
+			skiffProfile
 		});
 	};
 	ctx.on("tools/pre-execute", async (exec, next) => {
@@ -14099,7 +14130,9 @@ function createEpochPromotion(promoteEvents, requiredSignals = 1, maxRoundsFallb
 				promoted: true
 			};
 			const loopSid = session.id;
-			if (typeof loopSid === "string" && (loopSid.startsWith("cheap-worker-") || isSkiffSessionId(loopSid))) return {
+			const loopCwd = session.header?.cwd ?? process.cwd();
+			const loopRoot = cccRootForCwd(loopCwd);
+			if (typeof loopSid === "string" && (loopSid.startsWith("cheap-worker-") || loopRoot !== null && isSkiffSession(loopRoot, loopSid))) return {
 				boundary: -1,
 				promoted: true
 			};
@@ -14212,12 +14245,13 @@ function registerBootstrap(ctx) {
 	});
 	ctx.on("agent/inbox/inserted", ({ agent, message }) => {
 		try {
-			if (!agentRoot(agent)) return;
+			const root = agentRoot(agent);
+			if (!root) return;
 			const session = agent.session;
 			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-") || isSkiffSessionId(sid)) return;
+			if (sid.startsWith("cheap-worker-") || isSkiffSession(root, sid)) return;
 			if (depth === 0) {
 				if (hasUserMessageHistory(session)) return;
 			} else if (anchoredSessions.has(sid)) return;
@@ -14347,9 +14381,9 @@ function registerBootstrap(ctx) {
 	}, { prepend: true });
 }
 //#endregion
-//#region src/cognitive-trajectory-assistant.ts
+//#region src/trajectory/assistant.ts
 /**
-* cognitive-trajectory-assistant.ts — 关卡化注入的统一命名与风格门面（v0.3，S142）
+* trajectory/assistant.ts — 关卡化注入的统一命名与风格门面（v0.3，S142）
 *
 * 概念（用户拍板 2026-09-05）：dsp 全部"过程中动态提示注入"统一命名为
 * cognitive-trajectory-assistant（轨迹助航员）。关卡设计思想塑造**结构与时机**
@@ -14409,7 +14443,7 @@ const ACK_PREFIX = `${ASSISTANT_PREFIX}-recorded`;
 * ⇒ 分家：**只用一次的交界材料**写进这份**临时便签**（无格式义务、无留档义务、可随时丢弃）。
 *
 * ## 🔴 三处引用同一常量（单一真相源）
-* **写侧** = `seams/keeper.ts` 的 `rebuildReminderText()`｜**读侧** = `rebuild.ts` 的重建锚点｜
+* **写侧** = `seams/keeper.ts` 的 `rebuildReminderText()`｜**读侧** = `trajectory/rebuild.ts` 的重建锚点｜
 * **体积提醒** = `seams/keeper.ts` 的 `rebuildTodoReminderText()`。
 * 文件名一旦漂移，写侧写的东西读侧就找不到 —— **且没有任何机械信号会报警**。
 *
@@ -14488,7 +14522,7 @@ function reminderText(code) {
 *   使用者若要查看当前占用/阈值：看面板（`rebuildThresholdK` 滑块 + 状态显示）——那是给人看的。
 *
 * v1.31.1 交接协议（S142 用户需求"要求 LLM 将当前手头事项写在 SESSION.md 尾部，并要求
-* rebuild 后去读并处理"）：**写侧** = 这里；**读侧** = rebuild 锚点（rebuild.ts）。
+* rebuild 后去读并处理"）：**写侧** = 这里；**读侧** = rebuild 锚点（trajectory/rebuild.ts）。
 * 两侧共用 cognitive-trajectory-assistant 的常量（单一真相源）。
 *
 * 🔴 **v1.49.0（owner 2026-09-26 裁决："砍掉 in-flight，这正是目的"）**：写侧**不再**指向
@@ -14820,22 +14854,23 @@ function agentScope(agent) {
 * - cheap-worker 杂工：sessionId 固定 `cheap-worker-` 前缀（tools/cheap-worker.ts 生成）
 * 三者都不恢复（避免把主会话激活注入子上下文，违背 v1.16.2 scope 隔离）。
 */
-function shouldAutoRestore(agent) {
+function shouldAutoRestore(agent, root) {
 	const session = agent.session;
 	if (!session) return false;
 	if (session.header?.origin === "subagent") return false;
 	if (session.header?.parentSession) return false;
 	if (session.id?.startsWith("cheap-worker-")) return false;
-	if (isSkiffSessionId(session.id)) return false;
+	const cccRoot = root !== void 0 ? root : cccRootForCwd(session.header?.cwd ?? process.cwd());
+	if (cccRoot && isSkiffSession(cccRoot, session.id)) return false;
 	return true;
 }
 /**
 * 恢复触发判定（S134 泄漏修复 v1.16.13）：根会话 **且已有对话历史**（续跑/恢复的会话）
-* 才自动恢复上次激活的宁静号会话——全新会话（新任务，如 apaas-26116）无历史 → 不恢复，
+* 才自动恢复上次激活的宁静号会话——全新会话（新任务）无历史 → 不恢复，
 * 避免把过去的 SESSION 上下文注入新任务（跨任务污染）。
 */
-function shouldRestoreActive(agent) {
-	if (!shouldAutoRestore(agent)) return false;
+function shouldRestoreActive(agent, root) {
+	if (!shouldAutoRestore(agent, root)) return false;
 	return sessionEvents$1(agent.session).length > 0;
 }
 function registerContext(ctx, opts = {}) {
@@ -14849,7 +14884,7 @@ function registerContext(ctx, opts = {}) {
 		} catch {}
 		if (!root) return;
 		const key = agentKey(agent);
-		if (isSkiffSessionId(key)) return;
+		if (isSkiffSession(root, key)) return;
 		registerEntrySkillSection(agent, root);
 		registerCognitiveTrajectorySkillSection(agent, root);
 		const scope = agentScope(agent);
@@ -14935,7 +14970,7 @@ function registerContext(ctx, opts = {}) {
 		if (root) try {
 			syncSkiffRoleToolVisibility(agent, root);
 		} catch {}
-		if (isSkiffSessionId(key)) return downstream;
+		if (root && isSkiffSession(root, key)) return downstream;
 		try {
 			syncCccToolVisibility(agent, root);
 		} catch {}
@@ -14979,12 +15014,12 @@ function registerCompactRetention(ctx, opts = {}) {
 	ctx.on("session/event", (session, event) => {
 		if (event.type !== "compaction/end") return;
 		if (event.data.error) return;
-		if (isSkiffSessionId(String(session.id ?? ""))) return;
 		const agent = ctx.agents.get(session.id);
 		if (!agent) return;
 		const cwd = agent.session?.header?.cwd ?? process.cwd();
 		const root = cccRootForCwd(cwd);
 		if (!root) return;
+		if (isSkiffSession(root, String(session.id ?? ""))) return;
 		try {
 			agent.inject(accMessage(root, configPaths, entrySkillMaxChars));
 		} catch {}
@@ -15051,9 +15086,9 @@ function loadOpencodeSkill(skillDir) {
 	};
 }
 //#endregion
-//#region src/status.ts
+//#region src/surface/status.ts
 /**
-* status.ts — 状态与安全模式操作（纯逻辑，零 DSH 依赖，可独立单测）
+* surface/status.ts — 状态与安全模式操作（纯逻辑，零 DSH 依赖，可独立单测）
 *
 * WebUI 停靠栏的数据源：ACC 版本 / CCC 根 / safe-mode 状态 / 黑名单 / keeper 阈值 / cheap-worker 模型。
 * setSafeMode 直接读写 .serenity-safe-on 标记（守卫实时读取，写即生效）。
@@ -15188,7 +15223,7 @@ function setSafeMode(root, on) {
 	return { on: isSafeModeOn(root) };
 }
 //#endregion
-//#region src/api.ts
+//#region src/surface/http.ts
 const ROUTE_PATH = "/serenity/status";
 const UPLOAD_PATH = "/serenity/image-upload";
 const FILE_UPLOAD_PATH = "/serenity/file-upload";
@@ -15329,7 +15364,7 @@ function requireWebUi(req, res, message) {
 * 它就会**静默返回另一个 CCC 的路径**，于是面板把**别人的轨迹/技能/安全模式**当成你的显示出来。
 * 这比"显示未激活"危险得多 —— 用户会据此做判断（以为自己的 safe-mode 开着、以为那是自己的轨迹）。
 *
-* 修法与既有先例一致（`rebuild.ts` 对"跨轨迹猜测"的裁决：**响亮失败优于静默接错**）：
+* 修法与既有先例一致（`trajectory/rebuild.ts` 对"跨轨迹猜测"的裁决：**响亮失败优于静默接错**）：
 * **多个候选 ⇒ 不猜**。只有当 live sessions 里的 CCC 根**唯一**时才采用它
 * （那正是 v1.22.2 要救的场景：单 CCC 部署 + 远程访问缺 sessionId）；
 * 一旦出现**两个及以上**不同 CCC 根，就退回进程 cwd（→ 面板显示"未激活"），绝不挑一个顶替。
@@ -15539,11 +15574,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
-					const { weixinBridgeStatus } = await Promise.resolve().then(() => weixin_bridge_exports);
+					const { readWeixinSettings } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { weixinBridgeStatus } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { readWeixinCredential } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
+					const { readWeixinCredential } = await import("./route-f7JlinIt.js").then((n) => n.s);
 					const accounts = (settings.accounts ?? []).map((a) => ({
 						accountId: a.accountId,
 						name: a.name ?? void 0,
@@ -15572,10 +15607,10 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				const root = chk.root;
 				if (body.action === "login-start") {
-					const { fetchQRCode } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
+					const { fetchQRCode } = await import("./ilink-DEpmE3yi.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("./weixin-route-D_DvgPqy.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./route-f7JlinIt.js").then((n) => n.s);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15596,24 +15631,36 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
-					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
+					const { removeWeixinAccount } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
 					sendJson$3(res, 200, { removed: body.accountId });
 					return;
 				}
 				if (body.action === "save-routes") {
-					const routes = body.routes ?? [];
-					if (!Array.isArray(routes) || routes.some((r) => typeof r?.user !== "string" || typeof r?.role !== "string" || r.user === "" || r.role === "")) {
-						sendJson$3(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
+					const raw = body.routes ?? [];
+					if (!Array.isArray(raw)) {
+						sendJson$3(res, 400, { error: "invalid routes (expected [{user, trajectory}, ...])" });
 						return;
 					}
-					const { saveWeixinRoutes } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
-					const { readSkiffRoles } = await import("./skiff-role-cwxAt0gE.js").then((n) => n.d);
-					const roles = readSkiffRoles(root);
-					for (const r of routes) if (!roles.has(r.role)) {
-						sendJson$3(res, 400, { error: `unknown role: ${r.role} (not in ${root} skiff.roles)` });
+					const routes = [];
+					for (const r of raw) {
+						const user = typeof r?.user === "string" ? r.user : "";
+						const code = typeof r?.trajectory === "string" && r.trajectory !== "" ? r.trajectory : typeof r?.role === "string" ? r.role : "";
+						if (user === "" || code === "") {
+							sendJson$3(res, 400, { error: "invalid routes (each row needs non-empty user and trajectory)" });
+							return;
+						}
+						routes.push({
+							user,
+							trajectory: code
+						});
+					}
+					const { saveWeixinRoutes } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { findDirNameByCode } = await import("./profile-DyMJ_bfr.js").then((n) => n.i);
+					for (const r of routes) if (findDirNameByCode(root, r.trajectory) === null) {
+						sendJson$3(res, 400, { error: `unknown trajectory: ${r.trajectory} (no such trajectory code in ${root})` });
 						return;
 					}
 					saveWeixinRoutes(root, routes);
@@ -15622,8 +15669,8 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
-					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
 						sendJson$3(res, 400, { error: "启用前请先扫码绑定至少一个账号" });
@@ -15632,7 +15679,7 @@ function registerStatusApi(ctx, opts = {}) {
 					setWeixinEnabled(root, enabled);
 					if (enabled) syncCccBridge(ctx, root);
 					else {
-						const { stopCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
+						const { stopCccBridge } = await Promise.resolve().then(() => bridge_exports);
 						stopCccBridge(root);
 					}
 					sendJson$3(res, 200, { enabled });
@@ -15665,8 +15712,8 @@ function registerStatusApi(ctx, opts = {}) {
 					sendJson$3(res, 200, { status: "expired" });
 					return;
 				}
-				const { pollQRStatus } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
-				const { readWeixinSettings } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
+				const { pollQRStatus } = await import("./ilink-DEpmE3yi.js").then((n) => n.a);
+				const { readWeixinSettings } = await import("./route-f7JlinIt.js").then((n) => n.s);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15681,8 +15728,8 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-D_DvgPqy.js").then((n) => n.u);
-						const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-f7JlinIt.js").then((n) => n.s);
+						const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
 							accountId,
@@ -15730,7 +15777,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const id = s.id ?? s.header?.id;
 					if (id) liveIds.add(id);
 				}
-				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await Promise.resolve().then(() => session_cleanup_exports);
+				const { sessionsRootDir, collectEligibleSessions, performCleanup, cutoffDaysAgo } = await Promise.resolve().then(() => cleanup_exports);
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
@@ -15786,9 +15833,9 @@ function requireCcc(root) {
 	};
 }
 //#endregion
-//#region src/voyage-vocab.ts
+//#region src/surface/voyage/vocab.ts
 /**
-* voyage-vocab.ts — 航行页词表改为**按当前 CCC 运行时注入**（纯逻辑，零 DSH 依赖）
+* surface/voyage/vocab.ts — 航行页词表改为**按当前 CCC 运行时注入**（纯逻辑，零 DSH 依赖）
 *
 * ## 为什么需要它（owner 2026-10-18 报的缺陷）
 * 资产 `assets/serenity-voyage.html` 的词表是**构建期扫描容器写死的常量**：
@@ -15906,7 +15953,7 @@ function injectVoyageVocab(html, live) {
 	return html.replace(VOCAB_LINE_RE, () => `var VOCAB = ${JSON.stringify(merged)};`);
 }
 //#endregion
-//#region src/voyage-page.ts
+//#region src/surface/voyage/page.ts
 const VOYAGE_PATH = "/serenity/voyage";
 /**
 * 资产相对包根的路径。
@@ -15915,9 +15962,15 @@ const VOYAGE_PATH = "/serenity/voyage";
 * `dsh-develop pack-check` 的 `required` 已把它列为发布前硬断言。
 */
 const VOYAGE_ASSET = "assets/serenity-voyage.html";
-/** 包根 = 本模块所在目录的上一级（构建产物在 `lib/`，与 `assets/` 同级；同 constants.ts 定位法） */
+/**
+* 包根 = 含本包 `package.json` 的目录。
+* 🔴 **不许写死层数**：本模块自身位置随目录重构变化（曾 `src/surface/voyage/page.ts`，现
+* `src/surface/voyage/page.ts`），而发布态是从打包入口 `lib/index.js` 反推 ⇒ 两种布局深度不同，
+* 写死 `'..'` 必在其中一个布局下静默指错（实测：搬进 `surface/voyage/` 后路由直接读不到资产 → 500）。
+* ⇒ 交给 {@link findPackageRoot} 按**内容**定位。
+*/
 function packageRootPath() {
-	return join(dirname(fileURLToPath(import.meta.url)), "..");
+	return findPackageRoot() ?? join(dirname(fileURLToPath(import.meta.url)), "..");
 }
 /** 资产绝对路径（导出以便测试与 pack-check 共用同一判据来源） */
 function voyageAssetPath() {
@@ -15933,7 +15986,7 @@ function loadVoyageHtml(assetPath = voyageAssetPath()) {
 	}
 	return readFileSync(assetPath, "utf-8");
 }
-/** 发 JSON（错误分支用；与 api.ts 的 sendJson 同形，但本模块不依赖它，保持零耦合） */
+/** 发 JSON（错误分支用；与 surface/http.ts 的 sendJson 同形，但本模块不依赖它，保持零耦合） */
 function sendJson$2(res, status, body) {
 	res.statusCode = status;
 	res.setHeader("content-type", "application/json; charset=utf-8");
@@ -15942,7 +15995,7 @@ function sendJson$2(res, status, body) {
 /**
 * 注册 `/serenity/voyage`（GET）。
 * @param opts.assetPath 覆盖资产路径（测试用；生产不传）
-* @param opts.resolveRoot 解析本次请求所属 CCC 根（生产由 api.ts 的 resolveWorkspace 提供）。
+* @param opts.resolveRoot 解析本次请求所属 CCC 根（生产由 surface/http.ts 的 resolveWorkspace 提供）。
 *   🔴 **2026-10-18 新增**：词表按请求所属 CCC **运行时注入**（owner 报「在别的 CCC 点开
 *   显示的还是 home-serenity 的信息」）。不传 ⇒ 不注入（保持资产原样 = 旧行为）。
 */
@@ -16534,9 +16587,9 @@ function summarizeHostContract(report) {
 	return `${required.length > 0 ? `host contract BROKEN (${required.length} required)` : `host contract degraded (${optional.length} optional)`}: ${report.issues.map((i) => i.detail).join("; ")}`;
 }
 //#endregion
-//#region src/face-host.ts
+//#region src/surface/faces.ts
 /**
-* face-host.ts — **面宿主**：插件自起 HTTP listener 的唯一生命周期处（C4 块 A，S142 2026-09-15）
+* surface/faces.ts — **面宿主**：插件自起 HTTP listener 的唯一生命周期处（C4 块 A，S142 2026-09-15）
 *
 * ## 现状 → 本模块要收掉什么（取证：`…/acc-c4c5-current-state.md` §①/§③ 3.1）
 *
@@ -16545,7 +16598,7 @@ function summarizeHostContract(report) {
 * ⇒ 仍保有面 B/C/D 三个；本段保留"当年是四个"的记述，因为下方"两套拆卸"的病史由它解释。
 * 此前四处各写一份同款样板：`createServer` + `server.once('error')` +
 * `listen(port, host)` + 模块级 `active` 变量 + `close()`；拆卸也分裂成**两套**——
-* `seams/lifecycle.ts` 有一个聚合 disposer，而 `gateway.ts` 与 `weixin-send-api.ts`
+* `seams/lifecycle.ts` 有一个聚合 disposer，而 `gateway/server.ts` 与 `im/send.ts`
 * **各自另注册**一个（D/E 干脆没有自己的 disposer）。
 *
 * 本模块把"listener 生命周期"收成一处：**active 表 + 统一 listen/close + 统一错误与端口占用
@@ -16554,7 +16607,7 @@ function summarizeHostContract(report) {
 * ## 🔴 共享的是「生命周期与样板」，**绝不是**「路由 / 监听器 / 鉴权」
 *
 * 每个面**保留自己的 listener、自己的路由、自己的鉴权**（`handler` 内部原样不动）：
-*   · **A ↔ C 解耦**（`weixin-send-api.ts:4-7`）：3080 会被 3081 原样反代（连请求头），
+*   · **A ↔ C 解耦**（`im/send.ts:4-7`）：3080 会被 3081 原样反代（连请求头），
 *     把 3082 的端点挂到 3080 上 = 已登录的外部家庭账号即可冒充 bot 发消息
 *     ⇒ 本模块**不提供**"把面挂到别的面"的能力，也不共享路由表；
 *   · （原 **E ↔ D** 共用会话核心但各自独立 listener 一条，**随 E 退役删除**）；
@@ -16977,16 +17030,16 @@ ${csrf ? `<input type="hidden" name="csrf" value="${csrf}">` : ""}
 </div></body></html>`;
 }
 //#endregion
-//#region src/gateway-proxy.ts
+//#region src/gateway/proxy.ts
 /**
-* gateway-proxy.ts — F1 双端口网关：代理辅助纯逻辑（v1.22.1-1.22.3 稳定性修复）
+* gateway/proxy.ts — F1 双端口网关：代理辅助纯逻辑（v1.22.1-1.22.3 稳定性修复）
 *
-* 从 gateway.ts 拆分（S142 熵点治理，v1.22.8）：
+* 从 gateway/server.ts 拆分（S142 熵点治理，v1.22.8）：
 *  - crypto.randomUUID polyfill（非安全上下文修复，v1.22.0）
 *  - 反代请求头构造（信任栅栏修复：Host + Origin 同步改写 loopback，v1.22.1）
 *  - workspace 白名单过滤（响应 items 前缀过滤 + create 校验 + 403 RPC 响应，v1.22）
 *  - HTML polyfill 注入（幂等 marker）
-* 纯函数设计（可单测）；gateway.ts 装配层 import 使用。
+* 纯函数设计（可单测）；gateway/server.ts 装配层 import 使用。
 */
 /**
 * 经第二端口 http://LAN-IP:3081 访问 = 非安全上下文 → DSH client 的
@@ -17120,7 +17173,7 @@ function buildProxyHeaders(reqHeaders, mainPort, bodyOverride) {
 	return headers;
 }
 //#endregion
-//#region src/gateway-dsh-auth.ts
+//#region src/gateway/dsh-auth.ts
 /** 从一组 set-cookie 头提取 `dsh-auth-*` cookie（browser-auth sessionCookie 首段） */
 function pickDshCookie(setCookieHeader) {
 	const entries = Array.isArray(setCookieHeader) ? setCookieHeader : setCookieHeader === void 0 ? [] : [setCookieHeader];
@@ -17183,7 +17236,7 @@ function createDshCookieProvider(connection, authority) {
 	};
 }
 //#endregion
-//#region src/gateway.ts
+//#region src/gateway/server.ts
 /** 面名（C4 块 A：listener 生命周期归 `face-host`） */
 const FACE_GATEWAY = "gateway";
 /** 读取请求体（≤ maxBytes；超限 reject） */
@@ -17626,7 +17679,7 @@ function registerGateway(ctx) {
 	});
 }
 //#endregion
-//#region src/rebuild.ts
+//#region src/trajectory/rebuild.ts
 var rebuild_exports = /* @__PURE__ */ __exportAll({
 	buildRebuildAnchor: () => buildRebuildAnchor,
 	performRebuild: () => performRebuild,
@@ -17704,11 +17757,10 @@ function parseAnchorMdPath(session) {
 		return null;
 	}
 }
-/** 从 SESSION.md 绝对路径派生会话名（S###；issue 目录回退完整目录名） */
+/** 从 SESSION.md 绝对路径派生会话名（编码；issue 目录回退完整目录名） */
 function sessionNameFromMdPath(mdPath) {
 	const dirName = basename(dirname(mdPath));
-	const idMatch = dirName.match(/--S(\d{3,})--/);
-	return idMatch ? `S${idMatch[1]}` : dirName;
+	return parseTrajectoryCode(dirName) ?? dirName;
 }
 /**
 * 稳固的 SESSION.md 定位（多层候选 + 存在性校验，**绝不输出虚假路径**）：
@@ -17901,9 +17953,8 @@ function renameAfterRebuild(ctx, agent, pending) {
 	try {
 		const mdPath = pending.mdPath;
 		const dirName = basename(dirname(mdPath));
-		const idMatch = dirName.match(/--S(\d{3,})--/);
 		const info = {
-			sessionId: idMatch ? `S${idMatch[1]}` : dirName.replace(/^\d{4}-\d{2}-\d{2}--/, ""),
+			sessionId: parseTrajectoryCode(dirName) ?? dirName.replace(/^\d{4}-\d{2}-\d{2}--/, ""),
 			dirName,
 			mdPath
 		};
@@ -19636,7 +19687,7 @@ f.parseInline;
 b.parse;
 x.lex;
 //#endregion
-//#region src/skiff-debug.ts
+//#region src/role/skiff/debug.ts
 /** 面名（C4 块 A） */
 const FACE_SKIFF_DEBUG = "skiff-debug";
 /** 监听地址：**只绑 loopback**（本面无认证——仅靠 loopback 挡住外部） */
@@ -20031,12 +20082,12 @@ async function handle(ctx, defaultRoot, webPort, req, res) {
 				return;
 			}
 			const ccc = typeof body.ccc === "string" && body.ccc !== "" ? body.ccc : defaultRoot;
-			const roleName = typeof body.role === "string" ? body.role : "";
+			const code = typeof body.role === "string" ? body.role : "";
 			const question = typeof body.question === "string" ? body.question : "";
 			const sessionId = typeof body.sessionId === "string" && body.sessionId !== "" ? body.sessionId : void 0;
-			const role = readSkiffRoles(ccc).get(roleName);
-			if (!roleName || !role) {
-				sendJson$1(res, 400, { error: `unknown role: ${roleName} (ccc: ${ccc})` });
+			const profile = code !== "" ? readSkiffProfileByCode(ccc, code) : null;
+			if (!profile) {
+				sendJson$1(res, 400, { error: `unknown skiff trajectory: ${code} (no trajectory with code "${code}" has ${SKIFF_PROFILE_FILENAME} in ${ccc})` });
 				return;
 			}
 			if (!question.trim()) {
@@ -20052,22 +20103,21 @@ async function handle(ctx, defaultRoot, webPort, req, res) {
 					sendJson$1(res, 400, { error: "session is not recoverable (process restarted or session unknown) — start a new conversation" });
 					return;
 				}
-				if (info.role !== roleName || info.ccc !== ccc) {
-					sendJson$1(res, 400, { error: `session "${sessionId}" belongs to role "${info.role}" in another CCC — start a new conversation` });
+				if (info.trajectoryDirName !== profile.dirName || info.ccc !== ccc) {
+					sendJson$1(res, 400, { error: `session "${sessionId}" belongs to trajectory "${info.trajectoryDirName}" in another CCC — start a new conversation` });
 					return;
 				}
 				agent = live;
 				continued = true;
 			}
 			const hc = readCheapWorkerConfig(ccc);
-			if (!agent) agent = (await createSkiffAgent(ctx, ccc, roleName, role, hc?.defaultModel)).agent;
-			const result = await askSkiff(ctx, agent, question, 0);
+			if (!agent) agent = (await createSkiffAgent(ctx, ccc, profile, hc?.defaultModel)).agent;
+			const result = await askSkiff(ctx, agent, question);
 			sendJson$1(res, 200, {
 				answer: result.answer,
 				answer_html: renderSkiffMarkdown(result.answer),
 				sessionId: result.sessionId,
-				continued,
-				cognitiveTrajectory: result.cognitiveTrajectory
+				continued
 			});
 			return;
 		}
@@ -20077,9 +20127,9 @@ async function handle(ctx, defaultRoot, webPort, req, res) {
 	}
 }
 //#endregion
-//#region src/output-guard.ts
+//#region src/guard/filter.ts
 /**
-* output-guard.ts — 最终输出敏感词检测 + 打回重生成（v1.26.3，S142 用户需求）
+* guard/filter.ts — 最终输出敏感词检测 + 打回重生成（v1.26.3，S142 用户需求）
 *
 * 认知容器对外提供认知结果时，**支撑宁静号自身的凭据与机制**不应透露给用户。
 * 用户拍板方案（讨论稿定稿）：不做工具结果 redaction（那是模型工作内存），
@@ -20216,14 +20266,22 @@ function buildRebuke(hits) {
 /** 打回状态（按 agent 会话跟踪连续命中轮数） */
 const rebukeStates = /* @__PURE__ */ new Map();
 //#endregion
-//#region src/output-guard-seam.ts
-/** 外部面会话判定（v1.26.3 用户拍板：仅外部面检测，本地维护会话豁免）：
-*  skiff-（F4 问答）/ rebuild-（v1.22.4 重建会话）前缀。
-*  🔴 `acp-` 分支保留但**已是死判据**（无生产者；面 E 已于 2026-10-15 退役）——
-*  理由与"为何不擅自删"见文件头注释。 */
-function isExternalFaceSession(sessionId) {
+//#region src/guard/seam.ts
+/**
+* 外部面会话判定（v1.26.3 用户拍板：仅外部面检测，本地维护会话豁免）。
+*
+* 🔴 **2026-10-19 判据更换**：skiff 那一条从「sessionId 前缀 `skiff-`」改为
+* **「该会话绑定的轨迹有 `skiff.json`」**（owner 重做令）。前缀判据在新模型下是
+* **错的**——skiff 的身份是轨迹，不再由 id 前缀表达；继续用前缀会漏掉所有
+* "挂在 skiff 轨迹上、但 id 不带前缀"的会话（典型 = 微信桥按轨迹派生的会话 id）。
+*
+* ⚠️ `rebuild-` 前缀保留（那是另一件事：重建会话同属对外面，与 skiff 无关）；
+* `acp-` 分支保留但**已是死判据**（无生产者；面 E 已于 2026-10-15 退役）——
+* 理由与"为何不擅自删"见文件头注释。
+*/
+function isExternalFaceSession(sessionId, root) {
 	if (!sessionId) return false;
-	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
+	return isSkiffSession(root, sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
 }
 /** 读会话最后一个 assistant/message 文本（skiff-core 同款）
 *  **v1.63.3 起唯一的导出理由消失**：原导出是给 `unattended-seam.ts` 复用的（D77），
@@ -20253,10 +20311,11 @@ function registerOutputGuardHook(ctx) {
 	ctx.on("agent/turn-stopping", (payload) => {
 		const agent = payload?.agent;
 		if (!agent) return;
-		if (!isExternalFaceSession(String(agent.session.id ?? ""))) return;
+		const sessionId = String(agent.session.id ?? "");
 		const cwd = agent.session.header?.cwd ?? process.cwd();
 		const root = cccRootForCwd(cwd);
 		if (!root) return;
+		if (!isExternalFaceSession(sessionId, root)) return;
 		const id = agent.id;
 		const text = lastAssistantText(agent);
 		if (!text) return;
@@ -20288,12 +20347,12 @@ function registerOutputGuardHook(ctx) {
 	});
 }
 //#endregion
-//#region src/human-channel.ts
+//#region src/im/inbound.ts
 /**
-* human-channel.ts — 人机信道的**机制层**（机器级；2026-09-26 owner 定案 ⇒ 方案 §2.6）
+* im/inbound.ts — 人机信道的**机制层**（机器级；2026-09-26 owner 定案 ⇒ 方案 §2.6）
 *
 * ## 为什么单独一个模块（方案 §5-12）
-* 今天"机制"与"渠道实现"混在 `weixin-bridge.ts` 里。P0-2 要立的这条不变量是**机器级**的 ——
+* 今天"机制"与"渠道实现"混在 `im/bridge.ts` 里。P0-2 要立的这条不变量是**机器级**的 ——
 * 它**跨 CCC**、且与"微信"无关（飞书桥／邮件桥同样要守）⇒ 抽到这里；`weixin-bridge` 只做接线。
 *
 * ## 本模块唯一的不变量
@@ -20314,7 +20373,7 @@ function registerOutputGuardHook(ctx) {
 *  ② **订阅表查询 ＋ 入站路由决策**（P0-3：`(账号, 用户) → (CCC, 角色)`）—— 见 §订阅表
 *  ③ **机器级留痕**（P0-3：未投递 ／ 目标不存在 ／ 表残缺）—— 见 §留痕。
 *     🔴 为什么这些必须机器级：它们**没有目标 CCC** ⇒ 落进任何 CCC 都是"编一个"目标。
-* **不碰**：轮询循环、凭据解析、会话投递 —— 那些是**渠道实现**，留在 `weixin-bridge.ts`。
+* **不碰**：轮询循环、凭据解析、会话投递 —— 那些是**渠道实现**，留在 `im/bridge.ts`。
 * ⇒ 本模块**零 DSH 依赖**（只有 `node:crypto` ／ `node:fs`），可独立单测。
 */
 /**
@@ -20664,9 +20723,9 @@ function registerWeixinOutputGuard(ctx) {
 	guardActive = true;
 }
 //#endregion
-//#region src/weixin-hook.ts
+//#region src/im/hook.ts
 /**
-* weixin-hook.ts — 微信桥消息记录 hook（F4c-3 扩展，v1.27.13 用户需求）
+* im/hook.ts — 微信桥消息记录 hook（F4c-3 扩展，v1.27.13 用户需求）
 *
 * 需求：微信桥发生的所有消息记录，支持 hook——允许 CCC 通过自行编写 hook
 * 脚本进行**持久性保存**（存哪/存成什么/是否入库，全归 CCC 决定——ACC 不绑定存储）。
@@ -20823,8 +20882,107 @@ function invokeWeixinHook(root, hookRel, event) {
 	return activeRunner(root, hookRel, event);
 }
 //#endregion
-//#region src/weixin-bridge.ts
-var weixin_bridge_exports = /* @__PURE__ */ __exportAll({
+//#region src/im/accounts.ts
+const impls = /* @__PURE__ */ new Map();
+/** 注册账号实现（`index.ts` 装配时调用；重复 channel 覆盖——测试与热重载友好） */
+function registerImAccountImpl(impl) {
+	impls.set(impl.channel, impl);
+}
+/** 取实现（未注册 ⇒ `null`，由调用方**响亮出声**，不要静默跳过） */
+function getImAccountImpl(channel) {
+	return impls.get(channel) ?? null;
+}
+/** 已注册的实现名（诊断与错误文案用；顺序 = 注册顺序） */
+function imAccountChannels() {
+	return [...impls.keys()];
+}
+/**
+* 账号行的渠道归一（**单一处**）。
+*
+* 缺省 `weixin`：老配置平移到 `im` 段时不必补这个字段——owner 的"统一配置"
+* 要能直接吃旧数据（与 `route.ts` 的 `normalizeImSection` 保持同一口径）。
+*/
+function normalizeAccountChannel(channel) {
+	const v = (channel ?? "").trim();
+	return v === "" ? "weixin" : v;
+}
+//#endregion
+//#region src/im/weixin-account.ts
+/** 轮询间隔（getupdates 失败后重试；成功 = 立即续，长轮询本身 hold 35s） */
+const POLL_RETRY_MS = 3e3;
+/**
+* 微信的凭据就绪判据：**有 token** 才算绑定（baseUrl 留空 = 走官方默认）。
+* 与既有装配处逐字同义（原 `if (token === '') { …跳过… }`）。
+*/
+function weixinCredentialReady(cred) {
+	return typeof cred.token === "string" && cred.token.trim() !== "";
+}
+let deps = null;
+/** 装配时注入依赖（`bridge.ts` 在模块初始化末尾调用一次；见 `installWeixinAccountImpl`） */
+function setWeixinLoopDeps(d) {
+	deps = d;
+}
+/** 单账号轮询循环（**函数体逐字照搬自 bridge.ts 的 `runAccountLoop`，仅改类型与依赖来源**） */
+async function runWeixinAccountLoop(input, loop) {
+	if (!deps) {
+		loop.lastError = "weixin 实现未注入依赖（装配顺序错误）";
+		return;
+	}
+	const d = deps;
+	const ctx = input.ctx;
+	const cred = input.cred;
+	let buf = "";
+	while (!loop.stopped) {
+		loop.lastPollAt = Date.now();
+		try {
+			const resp = await d.getUpdates({
+				baseUrl: cred.baseUrl,
+				token: cred.token,
+				getUpdatesBuf: buf,
+				timeoutMs: 35e3
+			});
+			buf = resp.get_updates_buf ?? buf;
+			for (const msg of resp.msgs ?? []) {
+				if (loop.stopped) break;
+				if (msg.message_type !== 1) continue;
+				if (input.machine) await d.handleMachineIncoming(ctx, input.accountId, cred, msg);
+				else await d.handleIncoming(ctx, input.root, input.accountId, cred, msg);
+			}
+		} catch (err) {
+			loop.lastError = err instanceof Error ? err.message : String(err);
+			await new Promise((r) => setTimeout(r, POLL_RETRY_MS));
+		}
+	}
+}
+/** 微信账号实现（登记的 channel 名 = `weixin`；与配置里的取值一致） */
+const weixinAccountImpl = {
+	channel: "weixin",
+	isReady: weixinCredentialReady,
+	notReadyReason: () => "**无 token**（未绑定）",
+	startLoop(input) {
+		const loop = {
+			stopped: false,
+			lastPollAt: 0
+		};
+		runWeixinAccountLoop(input, loop);
+		return loop;
+	}
+};
+/**
+* 注册微信实现**并注入依赖**（`bridge.ts` 调用；幂等——重复注册覆盖同名 channel）。
+*
+* ⚠️ 必须在首次 `syncHumanChannel` / `syncCccBridge` **之前**发生。
+* `bridge.ts` 在**模块求值时**调用它一次（不是等到 `registerWeixinBridge`）——
+* 因为测试与面板会**直接**调 `syncCccBridge`，那时装配入口还没跑过；
+* 若依赖装配入口注册，那些路径会全部走进"未实现"分支（本轮实测：12 例红，根因就是它）。
+*/
+function installWeixinAccountImpl(d) {
+	setWeixinLoopDeps(d);
+	registerImAccountImpl(weixinAccountImpl);
+}
+//#endregion
+//#region src/im/bridge.ts
+var bridge_exports = /* @__PURE__ */ __exportAll({
 	handleIncoming: () => handleIncoming,
 	handleMachineIncoming: () => handleMachineIncoming,
 	manualOutputFallbackNeeded: () => manualOutputFallbackNeeded,
@@ -20843,14 +21001,12 @@ const bridges = /* @__PURE__ */ new Map();
 *
 * 机器级 poller **不属于任何 CCC**（这正是"上移 ACC 层"的含义：谁轮询不再由 CCC 数量决定）。
 * 用途有二：① `runAccountLoop` 的 `root` 形参在机器级模式下不被使用，传它以示"无根"；
-* ② 归属表（`human-channel.ts`）按 root 区分拥有者 ⇒ 机器级用这个哨兵值，
+* ② 归属表（`im/inbound.ts`）按 root 区分拥有者 ⇒ 机器级用这个哨兵值，
 *    与任何**真实** CCC 根都不会撞（真根一律是绝对路径）。
 */
 const MACHINE_SCOPE = "<machine>";
 /** 机器级 poller（账号 id → 循环）。与 `bridges` **互斥**：同一时刻只有一种模式在跑。 */
 const machineLoops = /* @__PURE__ */ new Map();
-/** 轮询间隔（getupdates 失败后重试延迟；成功 = 立即续轮询） */
-const POLL_RETRY_MS = 3e3;
 /** 媒体大小上限（M6：20MB，对齐 vlm-describe；超限降级告知不落盘） */
 const MEDIA_MAX_BYTES = 20971520;
 /** typing_ticket 缓存（每 (accountId, fromUserId)；getconfig 一次后续复用——对齐参考实现 typingTicketCache） */
@@ -20901,31 +21057,16 @@ async function sendTypingStop(cred, accountId, fromUserId) {
 		console.log(`[serenity-hooks] weixin-bridge typing stop skipped: ${err instanceof Error ? err.message : String(err)}`);
 	}
 }
-/** 单账号轮询循环：getupdates 长轮询 → 逐消息分发 → 回复回写 */
-async function runAccountLoop(ctx, root, accountId, cred, loop, machine = false) {
-	let buf = "";
-	while (!loop.stopped) {
-		loop.lastPollAt = Date.now();
-		try {
-			const resp = await getUpdates({
-				baseUrl: cred.baseUrl,
-				token: cred.token,
-				getUpdatesBuf: buf,
-				timeoutMs: 35e3
-			});
-			buf = resp.get_updates_buf ?? buf;
-			for (const msg of resp.msgs ?? []) {
-				if (loop.stopped) break;
-				if (msg.message_type !== 1) continue;
-				if (machine) await handleMachineIncoming(ctx, accountId, cred, msg);
-				else await handleIncoming(ctx, root, accountId, cred, msg);
-			}
-		} catch (err) {
-			loop.lastError = err instanceof Error ? err.message : String(err);
-			await new Promise((r) => setTimeout(r, POLL_RETRY_MS));
-		}
-	}
-}
+/**
+* 🔴 **2026-10-19（P2）`runAccountLoop` 已迁出本文件** —— 逐字搬到
+* `im/weixin-account.ts`，成为 `ImAccountImpl` 的一个实现（微信）。
+*
+* 为什么搬：装配处原先把渠道写死在这里（`channel !== 'weixin'` ⇒ 跳过）。
+* owner 定向「飞书和微信一样，只不过是 account 方实现不同」⇒ 起循环这个动作
+* 归**账号自己的实现**，装配处只按 `channel` 查派发表。
+* ⚠️ 依赖（`getUpdates` / `handleIncoming` / `handleMachineIncoming`）通过
+* `installWeixinAccountImpl` **注入**，避免 `bridge ⇄ weixin-account` 互相 import 成环。
+*/
 /**
 * 手动输出模式的**机制标记**（v1.30.10 引入；v1.30.16 按 S142 用户"这个词不能让 ACC 定义，
 * 要让 CCC 定义"重构）。
@@ -20970,7 +21111,7 @@ function manualOutputFallbackNeeded(input) {
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-RzasspMr.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-jZYR2GVE.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -20989,7 +21130,7 @@ async function resolveCccRootByAlias(ctx, alias) {
 * 三档（方案 §3.1，**刻意分档**）：
 *  - **未命中** ⇒ 不投递 ＋ **留痕**（`console.warn`，静默档：这是"表里没有你"，不是错误）
 *  - **表残缺** ⇒ **响亮出声**（`console.error`；且**独立于是否命中**）
-*  - **目标不存在**（CCC ／ 角色）⇒ **响亮报错**（`console.error`；不静默丢弃）
+*  - **目标不存在**（CCC ／ **轨迹**）⇒ **响亮报错**（`console.error`；不静默丢弃）
 *
 * @param input.cccFallback 过渡期回退（方案 Q5）；**机器级模式传 `null`** ⇒ 未命中即不投递
 */
@@ -21000,7 +21141,7 @@ async function resolveInboundTarget(ctx, input) {
 		user: input.user,
 		fallback: input.cccFallback ? {
 			ccc: input.cccFallback.root,
-			role: input.cccFallback.role
+			role: input.cccFallback.trajectory
 		} : null
 	});
 	for (const defect of route.defects) {
@@ -21040,10 +21181,10 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const role = readSkiffRoles(root).get(target.role);
-	if (!role) {
-		const detail = `目标 CCC "${target.ccc}" 未定义 skiff 角色 "${target.role}"`;
-		console.error(`[serenity-hooks] ✗ human-channel: ${detail}（account=${input.account} user=${input.user}）—— 该消息**未投递**，请改订阅表或该 CCC 的 skiff.roles`);
+	const { findDirNameByCode } = await import("./profile-DyMJ_bfr.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}）—— 该消息**未投递**，请改订阅表里的目标编码`);
 		appendHumanChannelAudit({
 			kind: "inbound-target-missing",
 			account: input.account,
@@ -21054,10 +21195,11 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
+	const profile = readSkiffProfileByCode(root, target.role);
 	return {
 		root,
-		roleName: target.role,
-		role
+		trajectory: target.role,
+		profile
 	};
 }
 /**
@@ -21093,18 +21235,18 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 	if (preset) resolved = preset.target;
 	else {
 		if (!settings.enabled) return;
-		const cccRole = matchWeixinRoute(settings.routes ?? [], fromUserId);
+		const cccTarget = matchWeixinRoute(settings.routes ?? [], fromUserId);
 		resolved = await resolveInboundTarget(ctx, {
 			account: accountId,
 			user: fromUserId,
-			cccFallback: cccRole ? {
+			cccFallback: cccTarget ? {
 				root,
-				role: cccRole
+				trajectory: cccTarget
 			} : null
 		});
 	}
 	if (!resolved) return;
-	const { roleName, role } = resolved;
+	const { trajectory, profile } = resolved;
 	root = resolved.root;
 	if (!text && mediaRefs.length === 0) {
 		if (hasVoiceItem(msg)) await sendTextMessage({
@@ -21117,19 +21259,25 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 		return;
 	}
 	try {
-		const sessionId = weixinSessionIdFor(fromUserId);
+		const sessionId = weixinSessionIdForTrajectory(trajectory);
 		const existing = getSkiffAgent(sessionId);
 		const hc = readCheapWorkerConfig(root);
-		if (existing) try {
-			ensureSkiffSession(root, existing, roleName, role, true);
-		} catch (err) {
-			console.warn(`[serenity-hooks] weixin-bridge ensure 失败（不影响处理）: ${String(err?.message ?? err)}`);
-		}
 		const ref = existing ? {
 			agent: existing,
 			sessionId,
 			resumed: true
-		} : await createSkiffAgent(ctx, root, roleName, role, hc?.defaultModel, sessionId);
+		} : await createSkiffAgent(ctx, root, profile ?? {
+			dirName: trajectory,
+			code: trajectory,
+			path: "",
+			tools: [],
+			msms: [],
+			cognitiveTrajectory: {
+				session: true,
+				keeper: true,
+				rebuild: true
+			}
+		}, hc?.defaultModel, sessionId);
 		if (!ref.resumed) await sendTextMessage({
 			baseUrl: cred.baseUrl,
 			token: cred.token,
@@ -21186,9 +21334,9 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 				}
 			}
 			const parts = [];
-			const activeWorkspace = getActiveSessionInfo(sessionId);
-			if (activeWorkspace?.mdPath) {
-				if (!ensureWorkspacePromptSection(ref.agent, sessionId)) parts.push(workspaceCognitiveTrajectoryLine(activeWorkspace.mdPath));
+			const workspaceMd = skiffWorkspaceMdPath(root, sessionId) ?? getActiveSessionInfo(sessionId)?.mdPath ?? null;
+			if (workspaceMd) {
+				if (!ensureWorkspacePromptSection(ref.agent, sessionId, root)) parts.push(workspaceCognitiveTrajectoryLine(workspaceMd));
 			}
 			const manualOutput = settings.autoReplyWithLastMessage === false;
 			if (text) parts.push(text);
@@ -21199,7 +21347,7 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 					root,
 					accountId,
 					userId: fromUserId,
-					role: roleName
+					role: trajectory
 				});
 				parts.push(weixinManualOutputMarker(root, accountId, fromUserId));
 			} else forgetManualOutputSession(sessionId);
@@ -21210,13 +21358,13 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 				accountId,
 				userId: fromUserId,
 				sessionId,
-				role: roleName,
+				role: trajectory,
 				text,
 				media: hookMedia
 			})).catch((err) => {
 				console.log(`[serenity-hooks] weixin hook incoming error: ${err instanceof Error ? err.message : String(err)}`);
 			});
-			const answer = (await askSkiff(ctx, ref.agent, question, void 0, { includeCognitiveTrajectory: false })).answer ?? "";
+			const answer = (await askSkiff(ctx, ref.agent, question)).answer ?? "";
 			if (manualOutput) {
 				if (!manualOutputFallbackNeeded({
 					fallbackOnNoSend: settings.fallbackOnNoSend,
@@ -21232,13 +21380,13 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 					text: reply,
 					contextToken: msg.context_token
 				});
-				console.warn(`[serenity-hooks] ⚠ weixin 输出兜底：agent 本轮未发送（闸门打回用尽）→ 桥转发最终文本（session=${sessionId}, role=${roleName}）`);
+				console.warn(`[serenity-hooks] ⚠ weixin 输出兜底：agent 本轮未发送（闸门打回用尽）→ 桥转发最终文本（session=${sessionId}, trajectory=${trajectory}）`);
 				if (hookRel) invokeWeixinHook(root, hookRel, buildOutgoingHookEvent({
 					cccRoot: root,
 					accountId,
 					userId: fromUserId,
 					sessionId,
-					role: roleName,
+					role: trajectory,
 					reply,
 					source: "reply-fallback"
 				})).catch((err) => {
@@ -21260,7 +21408,7 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 				accountId,
 				userId: fromUserId,
 				sessionId,
-				role: roleName,
+				role: trajectory,
 				reply
 			})).catch((err) => {
 				console.log(`[serenity-hooks] weixin hook outgoing error: ${err instanceof Error ? err.message : String(err)}`);
@@ -21305,7 +21453,7 @@ async function handleMachineIncoming(ctx, accountId, cred, msg) {
 * 已存在（配置变化热重建）→ 先停旧循环再启动新的。
 *
 * 🔴 **P0-2（2026-09-27，方案 §2.6）：一账号一 poller** —— 起循环**之前**先过机器级归属判定
-* （`human-channel.ts`）：身份被**别的** CCC 占着的账号**不起循环**，只留一条响亮日志。
+* （`im/inbound.ts`）：身份被**别的** CCC 占着的账号**不起循环**，只留一条响亮日志。
 * 身份 = **凭据 token 的哈希**（不是 `accountId`：那是每 CCC 的本地标签，跨 CCC 无意义）。
 * 先 `releasePollersOf(root)` 再重新 claim —— 热重建语义与"归属粘住不漂"的论证见该函数注释。
 */
@@ -21320,10 +21468,23 @@ function syncCccBridge(ctx, root) {
 	if (!settings.enabled) return;
 	const requests = [];
 	const creds = /* @__PURE__ */ new Map();
+	/** 账号 id → 它的实现（P2：按 `channel` 查派发表） */
+	const implByAccount = /* @__PURE__ */ new Map();
 	for (const account of settings.accounts ?? []) {
 		if (account.enabled === false) continue;
+		const channel = normalizeAccountChannel(account.channel);
+		const impl = getImAccountImpl(channel);
+		if (!impl) {
+			if (!warnedChannels.has(`${account.accountId}:${channel}`)) {
+				warnedChannels.add(`${account.accountId}:${channel}`);
+				console.warn(`[serenity-hooks] ⚠ weixin-bridge: 账号 ${account.accountId}（ccc=${root}）的渠道 "${channel}" **本机未实现** ⇒ 不起循环（已实现：${imAccountChannels().join(", ") || "(无)"}）`);
+			}
+			continue;
+		}
 		const cred = readWeixinCredential(root, account.accountId);
 		if (!cred) continue;
+		if (!impl.isReady(cred)) continue;
+		implByAccount.set(account.accountId, impl);
 		creds.set(account.accountId, cred);
 		requests.push({
 			root,
@@ -21339,13 +21500,16 @@ function syncCccBridge(ctx, root) {
 	};
 	for (const claim of plan.claims) {
 		const cred = creds.get(claim.accountId);
-		if (!cred) continue;
-		const loop = {
-			stopped: false,
-			lastPollAt: 0
-		};
+		const impl = implByAccount.get(claim.accountId);
+		if (!cred || !impl) continue;
+		const loop = impl.startLoop({
+			ctx,
+			root,
+			accountId: claim.accountId,
+			cred,
+			machine: false
+		});
 		bridge.loops.set(claim.accountId, loop);
-		runAccountLoop(ctx, root, claim.accountId, cred, loop);
 	}
 	commitPollerClaims(plan);
 	if (bridge.loops.size > 0) {
@@ -21396,6 +21560,8 @@ function syncMachinePollers(ctx, hc) {
 	stopCccBridges();
 	const requests = [];
 	const creds = /* @__PURE__ */ new Map();
+	/** 账号 id → 它的实现（P2：**按 `channel` 查派发表**，不再写死 weixin） */
+	const implByAccount = /* @__PURE__ */ new Map();
 	for (const account of hc.accounts) {
 		const id = account.id;
 		if (account.enabled === false) continue;
@@ -21403,23 +21569,27 @@ function syncMachinePollers(ctx, hc) {
 			console.warn("[serenity-hooks] ⚠ human-channel: 机器级账号表有一行**缺 `id`** ⇒ 跳过（该行无法被订阅表引用）");
 			continue;
 		}
-		if (account.channel !== "weixin") {
-			if (!warnedChannels.has(`${id}:${account.channel ?? ""}`)) {
-				warnedChannels.add(`${id}:${account.channel ?? ""}`);
-				console.warn(`[serenity-hooks] ⚠ human-channel: 账号 ${id} 的渠道 "${account.channel ?? "(未填)"}" **本机未实现** ⇒ 不起 poller（当前只有 weixin）`);
+		const channel = normalizeAccountChannel(account.channel);
+		const impl = getImAccountImpl(channel);
+		if (!impl) {
+			if (!warnedChannels.has(`${id}:${channel}`)) {
+				warnedChannels.add(`${id}:${channel}`);
+				console.warn(`[serenity-hooks] ⚠ human-channel: 账号 ${id} 的渠道 "${account.channel ?? "(未填)"}" **本机未实现** ⇒ 不起 poller（已实现：${imAccountChannels().join(", ") || "(无)"}）`);
 			}
 			continue;
 		}
 		const token = (account.token ?? "").trim();
-		if (token === "") {
-			console.warn(`[serenity-hooks] ⚠ human-channel: 账号 ${id} **无 token**（未绑定）⇒ 不起 poller`);
-			continue;
-		}
-		creds.set(id, {
+		const cred = {
 			token,
 			baseUrl: "",
 			userId: account.userId
-		});
+		};
+		if (!impl.isReady(cred)) {
+			console.warn(`[serenity-hooks] ⚠ human-channel: 账号 ${id} ${impl.notReadyReason?.(cred) ?? "**凭据不全**"} ⇒ 不起 poller`);
+			continue;
+		}
+		implByAccount.set(id, impl);
+		creds.set(id, cred);
 		requests.push({
 			root: MACHINE_SCOPE,
 			accountId: id,
@@ -21431,13 +21601,16 @@ function syncMachinePollers(ctx, hc) {
 	stopMachineLoops();
 	for (const claim of plan.claims) {
 		const cred = creds.get(claim.accountId);
-		if (!cred) continue;
-		const loop = {
-			stopped: false,
-			lastPollAt: 0
-		};
+		const impl = implByAccount.get(claim.accountId);
+		if (!cred || !impl) continue;
+		const loop = impl.startLoop({
+			ctx,
+			root: MACHINE_SCOPE,
+			accountId: claim.accountId,
+			cred,
+			machine: true
+		});
 		machineLoops.set(claim.accountId, loop);
-		runAccountLoop(ctx, MACHINE_SCOPE, claim.accountId, cred, loop, true);
 	}
 	commitPollerClaims(plan);
 	if (machineLoops.size > 0) console.log(`[serenity-hooks] ✓ human-channel: 机器级 poller accounts=${[...machineLoops.keys()].join(",")}（与 CCC 无关）`);
@@ -21469,7 +21642,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-RzasspMr.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-jZYR2GVE.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -21521,8 +21694,8 @@ async function sendProactiveText(input) {
 	const account = resolveWeixinAccount(root, input.accountId);
 	if (!account.ok) return account;
 	const { accountId, cred } = account;
-	const sessionId = weixinSessionIdFor(toUserId);
-	const role = matchWeixinRoute(settings.routes ?? [], toUserId) ?? "";
+	const trajectory = matchWeixinRoute(settings.routes ?? [], toUserId) ?? "";
+	const sessionId = weixinSessionIdForTrajectory(trajectory !== "" ? trajectory : sanitizeFileName$1(toUserId) || "unknown");
 	try {
 		await sendTextMessage({
 			baseUrl: cred.baseUrl,
@@ -21542,7 +21715,7 @@ async function sendProactiveText(input) {
 		accountId,
 		userId: toUserId,
 		sessionId,
-		role,
+		role: trajectory,
 		reply: markdownToPlainText(input.text),
 		source: "proactive"
 	})).catch((err) => {
@@ -21553,7 +21726,7 @@ async function sendProactiveText(input) {
 		accountId,
 		userId: toUserId,
 		sessionId,
-		role
+		role: trajectory
 	};
 }
 /**
@@ -21589,15 +21762,35 @@ function registerWeixinBridge(ctx) {
 		ctx.on("session/created", () => syncHumanChannel(ctx));
 	} catch {}
 }
+/**
+* 🔴 **P2 装配：微信实现登记进"账号实现派发表"**（模块求值时执行，不是等 `apply`）。
+*
+* ## 为什么必须在模块求值时做（本轮实测教训）
+*
+* 首版把这句放在 `registerWeixinBridge` 里 ⇒ 全量测试 **12 例红**，报的全是
+* 「`weixinBridgeStatus()` 空数组」。根因：测试与设置面板会**直接**调 `syncCccBridge` /
+* `syncHumanChannel`，那时装配入口还没跑过 ⇒ 派发表是空的 ⇒ 每条账号都走进
+* 「渠道未实现」分支（那分支是给**真正**未实现的渠道用的）。
+*
+* ⇒ 判据：**"谁能被调"决定"注册要在哪儿发生"**，不能按"装配流程"想当然。
+*
+* 注入的是本模块自己的函数（`getUpdates` / `handleIncoming` / `handleMachineIncoming`）——
+* 不需要 `weixin-account.ts import 回 bridge.ts`，避免两个文件互相 import 成环。
+*/
+installWeixinAccountImpl({
+	getUpdates,
+	handleIncoming,
+	handleMachineIncoming
+});
 //#endregion
-//#region src/weixin-send-api.ts
+//#region src/im/send.ts
 /** 请求体上限（文本消息远小于此；防滥用） */
 const MAX_BODY_BYTES = 65536;
 /** 文本长度上限（微信侧单条消息实践上限；超限拒绝而非静默截断） */
 const WEIXIN_SEND_MAX_TEXT = 4e3;
 /**
 * 面名（C4 块 A：listener 生命周期归 `face-host`，面向宿主提供规格）。
-* 本面=面 C（端口语义见 `ports.ts` 的 `FACE_PORTS.weixinSend`）。
+* 本面=面 C（端口语义见 `kernel/ports.ts` 的 `FACE_PORTS.weixinSend`）。
 */
 const FACE_WEIXIN_SEND = "weixin-send-api";
 /** 监听地址：**只绑 loopback**（本面不变量——不经网关、公网不可达，故不做共享密钥） */
@@ -21705,7 +21898,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-RzasspMr.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-jZYR2GVE.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -21980,9 +22173,9 @@ function registerLifecycle(ctx) {
 	registerDisposer(ctx, "self-started resources (gateway/weixin/skiff-debug faces + weixin bridges)", disposeAll);
 }
 //#endregion
-//#region src/web-fetch-provider.ts
+//#region src/patches/web-fetch.ts
 /**
-* web-fetch-provider.ts — fake-ip / TUN 网络下的 web_fetch provider（v1.30.12，S142）
+* patches/web-fetch.ts — fake-ip / TUN 网络下的 web_fetch provider（v1.30.12，S142）
 *
 * 问题（用户报告 + 实证）：`web_fetch` 在本机恒失败，报
 *   `URL hostname "X" resolves to a non-public IP address`（`WEB_BLOCKED_URL`）。
@@ -22171,7 +22364,7 @@ async function registerWebFetchProvider(ctx) {
 	}
 }
 //#endregion
-//#region src/opencode-provider.ts
+//#region src/patches/opencode-provider.ts
 /** `llm-pi-ai` 的 settings 命名空间（宿主 `dsh-llm-pi-ai` 的 `NS`） */
 const LLM_PI_AI_NAMESPACE = "llm-pi-ai";
 /**
@@ -22880,9 +23073,9 @@ function registerDeepseekVisionPatch(ctx, enabled) {
 	registerDisposer(ctx, "deepseek vision patch retry timer", clearRetry);
 }
 //#endregion
-//#region src/im-weixin.ts
+//#region src/im/weixin-channel.ts
 /**
-* im-weixin.ts — 微信通道实现（`im-bridge` 的通道之一，v1.31.0）
+* im/weixin-channel.ts — 微信通道实现（`im-bridge` 的通道之一，v1.31.0）
 *
 * 能力归 ACC（S142 用户洞察）：本文件吸收原 CCC MSM `.opencode/skills/home-serenity/scripts/
 * weixin-send.ts` 的 `send` / `send-file` / `users` 语义——协议、凭据、账号选择、别名解析、
@@ -22988,13 +23181,13 @@ const weixinChannel = {
 			text: input.caption
 		});
 		if (settings.hook) {
-			const role = matchWeixinRoute(settings.routes ?? [], input.userId) ?? "";
+			const trajectory = matchWeixinRoute(settings.routes ?? [], input.userId) ?? "";
 			invokeWeixinHook(input.root, settings.hook, buildOutgoingHookEvent({
 				cccRoot: input.root,
 				accountId: account.accountId,
 				userId: input.userId,
-				sessionId: weixinSessionIdFor(input.userId),
-				role,
+				sessionId: weixinSessionIdForTrajectory(trajectory !== "" ? trajectory : sanitizeFileName$1(input.userId) || "unknown"),
+				role: trajectory,
 				reply: input.caption ? `[文件] ${sent.fileName} — ${input.caption}` : `[文件] ${sent.fileName}`,
 				source: "proactive",
 				file: {
@@ -23024,7 +23217,7 @@ const weixinChannel = {
 		})));
 		const routes = (settings.routes ?? []).map((route) => ({
 			user: route.user,
-			role: route.role
+			role: route.trajectory
 		}));
 		return {
 			enabled: settings.enabled === true,
@@ -23038,13 +23231,13 @@ const weixinChannel = {
 //#endregion
 //#region src/tools/im-bridge.ts
 /**
-* im-bridge.ts（工具面）— IM 消息发送工具（v1.31.0）
+* im/channels.ts（工具面）— IM 消息发送工具（v1.31.0）
 *
 * 用户洞察（S142）：微信桥是 ACC 提供的 → **发送能力也应是 ACC 的工具**；
 * 「当用户配置了微信桥则可用，不配置则不可见」。
 *
 * 本文件只做工具面三件事：① 从 agent 会话解析**本会话 CCC**（R4：不接受目标 CCC）
-* ② 把参数交给 `im-bridge.ts`（能力层）分发 ③ 渲染结果/错误。
+* ② 把参数交给 `im/channels.ts`（能力层）分发 ③ 渲染结果/错误。
 *
 * 可见性不在这里判定：`seams/context.ts` 在会话就绪时按 CCC 配置
 * `agent.ctx.tools.restrict({ deny: ['im-bridge'] })` 把本工具从**未配置通道**的
@@ -23119,9 +23312,9 @@ function createImBridgeTool() {
 	});
 }
 //#endregion
-//#region src/live-sessions.ts
+//#region src/trajectory/live.ts
 /**
-* live-sessions.ts — 进程内 live 会话取数 + 精简诊断
+* trajectory/live.ts — 进程内 live 会话取数 + 精简诊断
 *
 * ── 为什么单独成模块（R↓，2026-09-15 S142「ACC 侧 autopilot 退场」S1 搬迁）──
 * 这两个函数原先住在 `autopilot-trajectory.ts`，但它们的**主语不是 autopilot**：
@@ -23198,9 +23391,9 @@ function diagLive(ctx) {
 	};
 }
 //#endregion
-//#region src/container-status.ts
+//#region src/surface/observation.ts
 /**
-* container-status.ts — 容器状态模型的**取数层唯一出口**（C5「观察面归一」，S142 2026-09-15）
+* surface/observation.ts — 容器状态模型的**取数层唯一出口**（C5「观察面归一」，S142 2026-09-15）
 *
 * 为什么存在（R↓）：ACC 有多个观察面（`dashboard health` / `acc-diag` / WebUI 面板 /
 * 系统提示词注入），它们读的是同一批宿主事实。此前"这些事实怎么取"写在**每个消费方各自的
@@ -23218,15 +23411,15 @@ function diagLive(ctx) {
 * 依赖分层（为什么本模块"重"而 `kit-ops` / `status` 保持"轻"）：
 *  {@link containerClocks} 必须读 `wake-scheduler` 的进程内快照，而该模块带 **@deepseek-ai 值依赖**
 *  （`dsh-llm` 的 `createUserMessage`）。故本模块**只能**被本就重型或异步的消费方使用：
-*  `diag-ops`（静态 import）、`api.ts` / `kit-ops`（`await import(...)`，与 `api.ts` 既有的
+*  `diag-ops`（静态 import）、`surface/http.ts` / `kit-ops`（`await import(...)`，与 `surface/http.ts` 既有的
 *  "保持静态链纯净"约定一致）。**轻链模块不得静态 import 本模块**。
 *
 * 已有的单一真相源继续指向原处（**不复制**）：
-*  L0 根解析 `ccc.ts findSerenityRoot`｜L1/L2 根与枚举 `ccc-roots.ts`｜宿主契约 `host/contract.ts`
-*  ｜CCC 配置 `ccc.ts loadSerenityConfig`｜注册表 `msm-ops.ts`｜时钟 `wake-scheduler.ts`
-*  ｜唤醒注册表 `wake-registry.ts`。
+*  L0 根解析 `kernel/ccc.ts findSerenityRoot`｜L1/L2 根与枚举 `kernel/ccc-roots.ts`｜宿主契约 `host/contract.ts`
+*  ｜CCC 配置 `kernel/ccc.ts loadSerenityConfig`｜注册表 `tools/msm/service.ts`｜时钟 `wake/scheduler.ts`
+*  ｜唤醒注册表 `wake/registry.ts`。
 */
-var container_status_exports = /* @__PURE__ */ __exportAll({
+var observation_exports = /* @__PURE__ */ __exportAll({
 	checkRegistryHealth: () => checkRegistryHealth,
 	checkRegistryQuality: () => checkRegistryQuality,
 	containerClocks: () => containerClocks,
@@ -23247,7 +23440,7 @@ function containerIdentity(root) {
 }
 /**
 * 三原则取数。
-* ⚠️ 与 `ccc.ts` 的 P1/P2 原语是**同一实现**（`existsSync(.serenity)` / `findGitRoot`），
+* ⚠️ 与 `kernel/ccc.ts` 的 P1/P2 原语是**同一实现**（`existsSync(.serenity)` / `findGitRoot`），
 * 本函数只把它们组装成"一次检查"的形状；判定语义未变（P1 要求文件非空、P2 要求 `.git` 存在）。
 */
 function containerPrinciples(root) {
@@ -23271,7 +23464,7 @@ function containerPrinciples(root) {
 	};
 }
 /**
-* **判据 A —— 注册表「结构完整性」**（原 `kit-ops.ts checkRegistryHealth`，C5 迁入本模块）。
+* **判据 A —— 注册表「结构完整性」**（原 `tools/kit/service.ts checkRegistryHealth`，C5 迁入本模块）。
 *
 * 回答的问题：**这张表坏没坏**——文件能不能被安全解析（JSON 合法 / 顶层形状 / entry 字段类型 /
 * name 全局唯一 / path 在根内且脚本存在）。
@@ -23366,7 +23559,7 @@ function checkRegistryHealth(root) {
 * 时钟的进程内状态（"为什么这轮没被唤起"的第一手判据）。
 *
 * 🔴 **只读快照，不重算**（设计红线）：`armed`/`ticks`/`lastTickAt`/`lastSkipReason` 只存在于
-* 调度器自己的模块级运行时对象里（`wake-scheduler.ts schedulerRuntime`）。任何"从配置或文件
+* 调度器自己的模块级运行时对象里（`wake/scheduler.ts schedulerRuntime`）。任何"从配置或文件
 * 重新推导"得到的值都会与真实调度器的状态不一致——那比没有可观测量更糟（会给出假的"一切正常"）。
 */
 function containerClocks() {
@@ -23410,11 +23603,11 @@ function containerStatus(opts = {}) {
 	};
 }
 //#endregion
-//#region src/diag-ops.ts
+//#region src/tools/diag/service.ts
 /**
-* diag-ops.ts — `acc-diag` 报告装配（v1.33，S142 §32.11；2026-09-15 段数收缩）
+* tools/diag/service.ts — `acc-diag` 报告装配（v1.33，S142 §32.11；2026-09-15 段数收缩）
 *
-* 为什么单独成模块（R↓）：工具面（`tools/acc-diag.ts`）只做"取 CCC 根 + 渲染"，
+* 为什么单独成模块（R↓）：工具面（`tools/diag/index.ts`）只做"取 CCC 根 + 渲染"，
 * 装配逻辑放这里 ⇒ 纯函数可单测、不依赖 DSH 工具注册。
 *
 * 为什么**无动作参数**：诊断是低频动作（§32.9 收敛取向），一次调用即出全报告，
@@ -23426,7 +23619,7 @@ function containerStatus(opts = {}) {
 *   ①b 唤醒时钟 —— `containerClocks().wake`（唤醒调度器进程内快照：武装态/计数/上次跳过原因）
 *   ③  唤醒注册表 —— `wake-registry.json` 的**在办条目**（state / at / target / lastResult）+ 补跑窗口
 *       （🔴 2026-09-19 §0Q 甲案：终态条目**结案即清除** ⇒ 本段只列在办项，不再是"历史全量"；
-*        历史由 SESSION.md / 工具输出承担——该承诺原本就写在 `wake-registry.ts` 注释里，本次做实）
+*        历史由 SESSION.md / 工具输出承担——该承诺原本就写在 `wake/registry.ts` 注释里，本次做实）
 *
 * ── 2026-09-15：段数由四降为三（S142「ACC 侧 autopilot 退场」§1 二阶裁定）─────────────
 * ACC 侧 autopilot 整段退场后，报告里两段的**主语消失**，故删除（不是"暂时关掉"）：
@@ -23442,7 +23635,7 @@ function containerStatus(opts = {}) {
 * 条目到期 / 补跑窗口 / 目标可解析 / CCC 闸）。**不得**以"顺手保留 ④"的方式把它偷偷带回。
 *
 * C5「观察面归一」（2026-09-15）：① 走 `diagLive`（那是**live 运行态**的独有取数，没有第二个
-* 来源）；①b 时钟与 ③ 注册表经 `container-status.ts` 取（唯一取数出口）——**投影仍在本文件**
+* 来源）；①b 时钟与 ③ 注册表经 `surface/observation.ts` 取（唯一取数出口）——**投影仍在本文件**
 * （诊断段不含 `message`，面板含；这是渲染差异，不是取数差异）。
 */
 /** 人读渲染一行时钟状态（"为何没有 tick" 的第一手判据） */
@@ -23513,9 +23706,9 @@ function renderAccDiag(r) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/tools/acc-diag.ts
+//#region src/tools/diag/index.ts
 /**
-* acc-diag.ts（工具面）— ACC 负责人专用的运行态诊断（v1.33，S142 §32.11）
+* tools/diag/index.ts（工具面）— ACC 负责人专用的运行态诊断（v1.33，S142 §32.11）
 *
 * 用户裁决（2026-09-14）：「不要 diag-live 了；或者变成一个隐藏 tool **只对 home-serenity 可见**，
 * 做成我们专属的运行时诊断工具」。⇒ 合并原 `diag`（脚本侧条件链）+ `diag-live`（进程内运行态），
@@ -23535,7 +23728,7 @@ function renderAccDiag(r) {
 * （① live 运行态 / ①b 唤醒时钟 / ③ 唤醒注册表）。
 *
 * ⚠️ 2026-09-15（ACC 侧 autopilot 退场，S142）：原四段降为三段——原 ②「面板解析」与
-* ④「唤起条件链」的主语随机制消失，已删（见 `../diag-ops.ts` 文件头；④ 的缺口已登记）。
+* ④「唤起条件链」的主语随机制消失，已删（见 `tools/diag/service.ts` 文件头；④ 的缺口已登记）。
 */
 function createAccDiagTool(ctx) {
 	return defineTool({
@@ -24809,7 +25002,7 @@ async function resolveSkiffRoot(ctx) {
 			}
 		}
 	} catch {}
-	for (const r of liveRoots) if (readSkiffRoles(r).size > 0) return r;
+	for (const r of liveRoots) if (listSkiffProfiles(r).length > 0) return r;
 	const fromCwd = cccRootForCwd(process.cwd());
 	if (fromCwd) return fromCwd;
 	if (liveRoots[0]) return liveRoots[0];