@shgroup/dsh-serenity-hooks 1.72.0 → 1.74.0

package/lib/index.js

@@ -1,12 +1,13 @@
-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-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 { i as __toESM, n as __exportAll } from "./rolldown-runtime-B4iAMlE-.js";
+import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-B2t_aM8L.js";
+import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, g as readUtf8, h as readSafeModeHiddenTools, i as findGitRoot, l as pathInside, m as readExclusiveTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readCognitiveTrajectorySkills, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-CyYJL4F2.js";
+import { A as sessionsRoot, C as namingTitleFor, D as readTrajectoryUid, E as readActiveSessionMd, F as isoLocal, I as localFileStamp, L as localHuman, M as showSession, N as summarize, O as resolveSessionByTitle, P as useSession, R as localIdStamp, S as listSessions, T as parseTrajectoryCode, _ as extractSessionMdPathFromText, a as readTrajectoryConstraintAt, c as registerTrajectorySession$1, d as COGNITIVE_TRAJECTORY_ACTIONS, f as DEFAULT_SESSION_SCOPE, g as createSession, h as clearActiveSessionInfo, j as setActiveSessionInfo, k as sessionEvents$1, l as trajectoryDirNameForSession, m as archiveSession, n as isTrajectoryConstrained, o as readTrajectoryConstraintByCode, p as UID_FILENAME, r as listTrajectoryConstraints, s as trajectoryConstraintForSession, t as TRAJECTORY_CONSTRAINT_FILENAME, u as unregisterTrajectorySession$1, v as findSession, w as parseSessionContextFromEvents, x as listActiveTrajectories, y as getActiveSessionInfo } from "./profile-BVt84mbi.js";
+import { _ as runLocalStore, a as readFeishuCredential, d as weixinSessionIdForTrajectory, f as LOCALSTORE_SCOPES, g as readStore, h as readGitTrack, i as matchWeixinRoute, l as sanitizeFileName$1, m as localstorePath, n as extractWeixinText, o as readWeixinCredential, p as checkLocalstoreGitCompliance, r as hasVoiceItem, s as readWeixinSettings, t as extractWeixinMedia, u as weixinInboundDir } from "./route-COOFLTpU.js";
+import { a as buildTrajectoryBasePrompt, c as createProfilePromptReader, d as resolveConstraintSystemPrompt, f as ACC_VERSION, i as TRAJECTORY_CONSTRAINT_HINT, l as profileMsmWhitelist, n as readSimpleSettings, o as constraintCognitiveTrajectory, p as findPackageRoot, r as registerSettingsSection, s as constraintSystemPromptSource, u as profileToolWhitelist } from "./settings-D8hlqxua.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-DCpoRHP3.js";
 import { REGISTERED_TOOLS } from "./invariant.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 { c as sendTextMessage, i as getUpdates, l as sendTyping, n as downloadMedia, o as markdownToPlainText, r as getConfig, s as sendFileMessage, t as TypingStatus, u as sniffImageExt } from "./ilink-BMk2w2KY.js";
+import { a as registerImAccountImpl, i as normalizeAccountChannel, n as getImAccountImpl, r as imAccountChannels } from "./accounts-BHQbakUh.js";
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
@@ -977,11 +978,11 @@ const gitTool = defineTool({
 *
 * 为什么单独一个模块（R↓）：地址的读者是 `msm-ops.buildMsmEnv`（把地址注入 MSM 子进程 env），
 * 写者才是 `weixin-send-api`（监听器启停）。若 msm-ops 直接 import weixin-send-api，
-* 静态依赖链会拖进整条微信桥栈（weixin-bridge → skiff-core → `@deepseek-ai/dsh-llm`）——
-* 后果实测：`acc-extras` / `ops` / `skiff-admin` 三个测试套件因解析不到宿主包而**整文件加载失败**
+* 静态依赖链会拖进整条微信桥栈（weixin-bridge → trajectory-session → `@deepseek-ai/dsh-llm`）——
+* 后果实测：`acc-extras` / `ops` / `trajectory-constraint-admin` 三个测试套件因解析不到宿主包而**整文件加载失败**
 * （它们只用到 MSM 注册表逻辑）。叶模块把「读」与「写」解耦：读者零依赖，写者自己承担重量。
 *
-* 同款先例：`host/effect.ts`（拆卸登记）、`role/worker/idle.ts`（等待结算）。
+* 同款先例：`host/effect.ts`（拆卸登记）、`trajectory/carrier.ts`（等待结算）。
 */
 let endpoint = null;
 /** 设置当前入口地址（weixin-send-api 启停时调用；null = 未启动） */
@@ -1083,18 +1084,19 @@ Directory of ACC capabilities — each area lists where to go for details (guide
                          acc_msm 已并入 msm（执行+发现）与 container_admin（管理）——msm("<name>", ["<args>"])；inspect=true 查用法
                          cheap-worker（杂工 agent 编排——guide 子命令：cheap-worker guide）
                          专属工具（**默认对所有 CCC 隐藏**，只有在自己 exclusiveTools 里点名的 CCC 可见）→ acc-diag（运行态诊断）
-  ④ 角色与对外面      → container_admin role（Skiff 认知子集角色：guide/validate/apply/list——skiff_admin 已并入）
-                         3099 Skiff 调试问答页（人工调试面）。外部程序化接入用官方 dsh --profile acp
+  ④ 轨迹约束与对外面  → container_admin config（轨迹约束四动作 guide/validate/apply/list——**原 role 域已并入 config**，旧名作过渡别名仍可用；说明类配置走**两层菜单** config docs 目录 ／ config docs <章节> 详情）
+                         外部程序化接入用官方 dsh --profile acp
                          ＋ 现成 ACP 客户端；本插件不提供 ACP 面
   ⑤ 自主与接入        → cognitive_trajectory send-now（跨轨迹的**即时**递送，**不排队**：live 目标在跑就当场注入当前轮、空闲则立即起轮；非 live 冷载入——等效于直接 wake；**有同步回执**）
                          cognitive_trajectory send-later（跨轨迹的"未来时刻 + 一条 message"；fire-and-forget，无回执无回收）
                          weixin 微信桥（配置/扫码/路由/消息 hook——CCC 侧 weixin-doctor MSM：msm("weixin-doctor", ["guide"])）
-  ⑥ CCC 配置总览      → container_admin msm ccc-config（9 段：cheap-worker/sessionKeeper/localstore/hooks/safeMode/skiff/cognitiveTrajectory/weixin/**exclusiveTools**）
+  ⑥ CCC 配置总览      → container_admin config docs config（按章详情——9 段全表）
+                          或 container_admin msm ccc-config（同一份正文的旧入口，保留）
   ⑦ 注册表与安全      → mech-registry.json 由 container_admin msm register/deregister 管理（写保护——不可直接编辑）
                          dashboard health 输出 registry 完整性检查；损坏恢复指引见 health registry.issues
                          CCC 级开关：exclusiveTools（声明专属工具）/ safeMode.blacklist（写路径黑名单）
                          / safeMode.hiddenTools（**安全模式开启期间**额外隐藏的工具，v1.51.4）
-                         CCC 级 skill 供给：cognitiveTrajectory.skills（v1.44.0——**本 CCC 每条轨迹都带**，含 skiff 会话；与轨迹自己的 frontmatter 声明取并集）
+                         CCC 级 skill 供给：cognitiveTrajectory.skills（v1.44.0——**本 CCC 每条轨迹都带**，含 轨迹约束会话；与轨迹自己的 frontmatter 声明取并集）
 
 每区：一句话定位 + 详细入口（工具名 / guide 子命令）。详情永远以对应工具的 guide/ccc-config 为单一真相源。
 `;
@@ -1151,7 +1153,12 @@ msm("<name>", ["--list"])           — list all MSMs
 msm("<name>", ["--schema", "<n>"])  — view a specific MSM's parameter schema
 msm("<name>", ["--format=json"])    — JSON output mode (remaining args passed through losslessly)
 `;
-/** CCC 配置参考（对齐 osp ccc-config action） */
+/**
+* CCC 配置参考（对齐 osp ccc-config action）。
+*
+* 🔴 **2026-10-19 起导出**：`container_admin config docs config` 的两层菜单把它作为
+* 「config」章正文返回。**不另写一份**——同一段说明有第二份副本就会漂（本轨反复踩过）。
+*/
 const CCC_CONFIG_REFERENCE = `═══ CCC Configuration Reference ═══
 
 CCC-level features are configured in .opencode/serenity.json.
@@ -1227,15 +1234,15 @@ safe-mode 由 WebUI 开关控制（写 .serenity-safe-on 标记）；黑名单
   Config:
     { "safeMode": { "blacklist": [".secrets/"], "hiddenTools": ["workflow", "job_kill"] } }
 
-── 6. skiff.roles（F4 认知子集角色）──
-Skiff 角色 = 全知全能 cognitive trajectory 的任意子集（CCC 定义）。每角色独立模型 + 双白名单
+── 6. 轨迹约束.roles（F4 认知子集角色）──
+轨迹约束角色 = 全知全能 cognitive trajectory 的任意子集（CCC 定义）。每角色独立模型 + 双白名单
 （MSM 白名单 msms[] 与非 MSM 工具白名单 tools[]，白名单外全隐藏；skill 加载恒可用）。
 cognitive trajectory 纪律子集（session/keeper/rebuild 参与项）默认全关 = 完全独立。
 systemPrompt 内联 或 systemPromptFile（.md 引用，推荐）——角色会话的完整人格/边界提示词。
-validate 校验 / apply 生效 / list 查看：container_admin role <guide|validate|apply|list>（skiff_admin 已并入）。
+validate 校验 / apply 生效 / list 查看：container_admin config <guide|validate|apply|list>（原 role 域已并入 config，旧名作过渡别名仍可用）。
 
   Config:
-    { "skiff": { "roles": {
+    { "轨迹约束": { "roles": {
         "qa": {
           "model": "provider/model",
           "msms": ["web-search", "vlm-describe"],
@@ -1255,12 +1262,12 @@ CCC 的一条 cognitive trajectory = 持久身体（SESSION.md）+ 时间轴（A
 运行态诊断（ACC 负责人专用）：acc-diag（① live 运行态 / ①b 唤醒时钟 / ③ 唤醒注册表）。
 
 ▸ cognitiveTrajectory.skills（v1.44.0，**CCC 级 skill 供给**；owner 令 2026-09-20「要求实现我的诉求……
-  注入是动态注入就行；create 先不触发吧；**skiff 也支持**」）：
+  注入是动态注入就行；create 先不触发吧；**轨迹约束也支持**」）：
   **本 CCC 的每条轨迹都带这些 skill**——声明的 skill 全文在该轨迹**被绑定期间**注入系统提示词
   （**动态注入**：每请求重新求值、不缓存 ⇒ 改配置或改 frontmatter **即时生效**，无需重新 use、无需重启）。
   两条声明来源**并集**（不是二选一）：本键 **cognitiveTrajectory.skills**（容器给的底座，**在前**）
   ＋ 轨迹自己 SESSION.md 顶部 frontmatter 的 skills:（这条轨迹额外的，**追加**；同名去重）。
-  ✅ **含 skiff 角色会话**（旁路的是 ACC 身份与纪律；skill 是"工作资料"，照给）。
+  ✅ **含 轨迹约束角色会话**（旁路的是 ACC 身份与纪律；skill 是"工作资料"，照给）。
   守卫：名字先过安全校验才用于拼路径（防穿越）｜**合并后**统一 32 KB 上限截断｜找不到响亮写 [缺失]。
   ⚠️ 与 create **无关**（create 刻意不夺绑定，U6）⇒ 注入的门是"**存在绑定**"（cognitive_trajectory use）。
   失败语义：未配置 / 字段缺失 / 配置损坏 ⇒ **空数组**（= 无 CCC 级供给；轨迹级声明照旧生效）。
@@ -1268,7 +1275,7 @@ CCC 的一条 cognitive trajectory = 持久身体（SESSION.md）+ 时间轴（A
 
   Config:
     { "cognitiveTrajectory": {
-        "skills": ["acc-session", "cce"],   // v1.44.0：本 CCC 的每条轨迹都带（含 skiff 会话）
+        "skills": ["acc-session", "cce"],   // v1.44.0：本 CCC 的每条轨迹都带（含 轨迹约束会话）
         "autopilot": {                   // 原 autopilotTrajectory 段，字段不变（旧键仍回退读）
           "enabled": true,
           "intervalHours": 2,
@@ -1282,7 +1289,7 @@ CCC 的一条 cognitive trajectory = 持久身体（SESSION.md）+ 时间轴（A
 CCC 级微信个人号接入（iLink 协议）：dsh 一进程多 CCC，每 CCC 独立对接微信桥。
 账号/路由/开关在此文件；**bot_token 凭据在 CCC localstore credential scope**
 （扫码绑定后自动写入，永不进 git 明文面）。
-路由 user → role：exact 优先，* 通配兜底；role 必须 ∈ 该 CCC skiff.roles。
+路由 user → role：exact 优先，* 通配兜底；role 必须 ∈ 该 CCC 轨迹约束.roles。
 面板（WebUI 设置 → 微信桥）可扫码绑定/移除账号/编辑路由；msm("weixin-doctor", ["status"|"diag"|"verify"|"guide"]) 排查 + 大而全指南。凭据主动查看：localstore get WEIXIN_<ACCOUNT>_TOKEN。
   ▸ 主动发送（v1.31.0：**ACC 工具 im-bridge**）：调
     im-bridge({channel:"weixin", action:"send", user:"<别名|id>", text:"<文本>"}) 给用户发消息——
@@ -1290,7 +1297,7 @@ CCC 级微信个人号接入（iLink 协议）：dsh 一进程多 CCC，每 CCC
     成功后触发 outgoing hook（source="proactive"）。文件用 action:"send-file" + file:"<CCC 内路径>"
     （逃逸/缺失/超 20MB 拒绝）+ 可选 caption。**可见性**：本 CCC 配置了 IM 通道
     （weixin.enabled=true）才出现在模型工具清单里；未配置 → 由 guards 逐 agent
-    tools.restrict({deny:['im-bridge']}) 移除（不是"看得到但被拒"）。skiff 角色另需在
+    tools.restrict({deny:['im-bridge']}) 移除（不是"看得到但被拒"）。轨迹约束角色另需在
     roles.<role>.tools 白名单列出 im-bridge。
     历史（v1.30.9~v1.30.x）：CCC 侧 MSM weixin-send（走 loopback HTTP 入口 3082）——
     v1.31.0 已退役（脚本删除 + 注册表注销）；3082 入口保留给**非 agent 调用者**。
@@ -1834,7 +1841,7 @@ async function runMsmAsync(root, args) {
 * **轨迹提示词** = 一条认知轨迹的**可编辑章程声明**，由 ACC 按固定顺序装配进系统提示词。
 * 三个关键词各是一条判据：
 * - **可编辑**：住在 CCC（盘上），改它**不发版**（D23 归属判据的直接推论）
-* - **声明**：它声明**身份／章程／方法论**，**不声明能力**（能力面归 `skiff.json` 白名单与工具 schema）
+* - **声明**：它声明**身份／章程／方法论**，**不声明能力**（能力面归 `trajectory-constraint.json` 白名单与工具 schema）
 * - **固定顺序**：装配顺序由 ACC 定死（见 `seams/system-prompt.ts` 的 ⑧ 位）
 *
 * ## 为什么取代「人格」
@@ -1849,13 +1856,13 @@ async function runMsmAsync(root, args) {
 *
 * - **跟着轨迹走**：`archive` 时整个目录搬走，章程不会掉队（旧形态 `.opencode/skiff/<name>.md`
 *   与轨迹**分居两处** —— 多条轨迹共用一份文件正是那个后果）。
-* - **每条轨迹都能有**：不只是 skiff。普通轨迹同样需要"我是谁、按什么章程"。
-* - 与 `SESSION.md`（身体：延续/日志）、`skiff.json`（约束面：能力）三件并列，
+* - **每条轨迹都能有**：不只是 轨迹约束。普通轨迹同样需要"我是谁、按什么章程"。
+* - 与 `SESSION.md`（身体：延续/日志）、`trajectory-constraint.json`（约束面：能力）三件并列，
 *   各管一件事，不合并（合并会让"改能力"与"改身份"互相牵连）。
 *
 * ## 兼容（不静默坏）
 *
-* `PROMPT.md` 不存在时**不报错**（普通轨迹常态）。skiff 的旧字段 `systemPromptFile`
+* `PROMPT.md` 不存在时**不报错**（普通轨迹常态）。轨迹约束的旧字段 `systemPromptFile`
 * 在兼容期仍被读取——优先级见 {@link resolveTrajectoryPrompt}。
 */
 /** 轨迹提示词的固定文件名（**判据就是它存在**——不是目录名前缀，也不是配置里的一行） */
@@ -1867,9 +1874,9 @@ function trajectoryPromptPath(root, dirName) {
 /**
 * 该轨迹**有没有**轨迹提示词（单一判据）。
 *
-* 用途：兼容期的"让位"判定 —— 若已有 `PROMPT.md`，skiff 旧字段 `systemPromptFile`
-* 必须**让位**，否则同一份章程会在两处各注入一遍（第 ⑧ 段 ＋ `serenity-skiff` 段）。
-* 🔴 判据只有这一处：别在 skiff 那边自己拼路径再判（两处会漂）。
+* 用途：兼容期的"让位"判定 —— 若已有 `PROMPT.md`，轨迹约束 旧字段 `systemPromptFile`
+* 必须**让位**，否则同一份章程会在两处各注入一遍（第 ⑧ 段 ＋ `serenity-轨迹约束` 段）。
+* 🔴 判据只有这一处：别在 轨迹约束那边自己拼路径再判（两处会漂）。
 */
 function hasTrajectoryPrompt(root, dirName) {
 	try {
@@ -1958,7 +1965,7 @@ function trajectoryPromptBlock(text) {
 	].join("\n");
 }
 //#endregion
-//#region src/role/worker/idle.ts
+//#region src/trajectory/carrier.ts
 /**
 * 等待 agent 空闲或销毁。
 * @param ctx 宿主插件上下文（事件通道来源；**结构化访问**，故类型为 `unknown`，见文件头 I2 段）
@@ -2105,7 +2112,7 @@ function truncateContent(content, maxChars) {
 * 六条硬性规则（逐条对应设计 §4.2，改这里先改那里）：
 *   ① **只枚举，不注入正文** —— 索引里**绝不**出现任何参考文件的正文；
 *   ② **确定性排序** = 相对路径的 **UTF-8 字节序**（🔴 **不用 mtime**：mtime 随检出漂移，
-*      会让每请求的注入文本抖动；对照 `src/wake/cro.ts:101` 那份**落盘快照**用 {name,bytes,mtime} ——
+*      会让每请求的注入文本抖动；对照 `src/cro/core.ts:101` 那份**落盘快照**用 {name,bytes,mtime} ——
 *      **同一件事两处的取舍相反，那个差异是判据不是巧合**）；
 *   ③ **有界 ＋ 响亮** —— 条数/字符各有上限，超出**必须显式写出还剩多少项**，**绝不静默截断**；
 *   ④ **摘要可复现** —— 取该文件首个 `#` 标题（剥 markdown 记号）；取不到 ⇒ 留空，**不编**；
@@ -2600,7 +2607,7 @@ function buildCognitiveTrajectorySkillsSection(root, mdPath, maxChars = COGNITIV
 * ⇒ 本模块让每个 CCC 留下一份**纯计数**账本：**用了哪个、多少次、第一次和最近一次是什么时候**。
 * 用途 = 清理/精简的**依据**（没有人用的东西与天天在用的东西，不再靠猜）。
 *
-* ## 🔴 铁律（与 `wake/cro-log.ts` 同族）
+* ## 🔴 铁律（与 `cro/log.ts` 同族）
 *
 * **本模块每个导出函数都不抛错**：读盘 / 解析 / 写盘失败一律返回结构化失败，
 * 由调用方只记一行日志（或什么都不做）⇒ **统计的问题绝不影响工具执行与既有链路**。
@@ -2616,7 +2623,7 @@ function buildCognitiveTrajectorySkillsSection(root, mdPath, maxChars = COGNITIV
 *
 * 宿主会被重启（本容器实测 24h 内 3 次）⇒ 计数**不能只活在内存里**：
 * 每次写盘 = **读旧文件 → 在旧值上自增 → 原子写**（`tmp + rename`，与 `wake/registry.ts` /
-* `wake/cro-log.ts` 同款形态）⇒ **进程重启后计数自然延续**，无需额外的 flush/落盘时机。
+* `cro/log.ts` 同款形态）⇒ **进程重启后计数自然延续**，无需额外的 flush/落盘时机。
 *
 * ## 口径（两个字段，勿合并）
 *
@@ -2899,6 +2906,48 @@ function verifyTotpCode(secretBase32, code, nowSeconds = nowEpochSeconds()) {
 	return null;
 }
 //#endregion
+//#region src/kernel/ports.ts
+/**
+* 集中端口表。
+* A=宿主主面（插件不监听）/ B=网关（可配，默认关）/ C=微信发送（默认开，仅 loopback）
+* / D=轨迹约束调试（默认关）。
+*/
+const FACE_PORTS = {
+	main: {
+		port: 3080,
+		host: null,
+		defaultEnabled: true,
+		meaning: "宿主 DSH 主 WebUI + 插件 /serenity/* 路由面（**插件不起此 listener**，端口自宿主读）"
+	},
+	gateway: {
+		port: 3081,
+		host: "0.0.0.0",
+		defaultEnabled: false,
+		meaning: "双端口网关（外部登录 + 全量反代宿主主面；host/port 走 plugin 全局配置）"
+	},
+	weixinSend: {
+		port: 3082,
+		host: "127.0.0.1",
+		defaultEnabled: true,
+		meaning: "微信主动发送面（容器外进程 → POST /send；与 3080 显式解耦，不经网关）"
+	}
+};
+FACE_PORTS.main.port;
+/** 网关端口默认值（面 B） */
+const GATEWAY_PORT = FACE_PORTS.gateway.port;
+/** 微信主动发送端口默认值（面 C） */
+const WEIXIN_SEND_PORT = FACE_PORTS.weixinSend.port;
+/**
+* **机制端口**词表（output-guard 用：agent 在**用户可见输出**里提及内部端口即打回）。
+*
+* 由 {@link FACE_PORTS} 机械派生 ⇒ 与面清单**永不漂移**。
+* ⚠️ 修复记录（C4 块 B，2026-09-15）：旧常量硬写 `['3080','3081','3099','3100']`
+* ——**漏 3082**（微信发送面，默认开）⇒ 守卫拦不住"3082"这类提及。现由表派生，四面齐全。
+* ⚠️ 面变更记录（2026-10-15）：**面 E（3100 ACP/问答）已整体退役**（owner 裁「砍掉外部问答」）
+* ⇒ 本词表随之少一项，**无需另改**（这正是"派生而非手抄"的收益）。
+*/
+const MECHANISM_PORTS = Object.keys(FACE_PORTS).map((id) => String(FACE_PORTS[id].port));
+//#endregion
 //#region src/kernel/config.ts
 /**
 * kernel/config.ts — plugin 全局配置读写（结构化，`~/.dsh/serenity-hooks.json`）
@@ -3221,7 +3270,7 @@ function toolsBlock() {
 		"  cheap-worker     — delegate work to a worker agent on the CCC-configured model; one serial child per task, returns its final text. `jobs=[...]` fans out in parallel (cap 10, results keep your order). No loop, no completion code, no progress file. The model is NOT selectable per call (read from the CCC config); a worker's tool set excludes cheap-worker itself",
 		"  serenity-skill-creator — creator for serenity-skills (this container's enhanced skill standard): guide (authoring/optimization method — read first) / create <name> (scaffold SKILL.md + skill.ttl + references/, base-chain import path computed) / check <name> (A1 structural + A2 base-chain; three states: modeled-ok / plain-skill / modeled-but-check-could-not-run) / review <name> (C tier: axiom-vs-text compliance question list, half-mechanical) / index <name> (preview the second-layer resource list the model will see) / status (which skills are modeled). A skill is \"modeled\" iff it has a file named exactly skill.ttl next to SKILL.md; a plain skill is NOT an anomaly. Only `create` writes, and it refuses an existing directory",
 		"  localstore   — ACC local credential/config storage (CCC-root localstore.json; git policy localstore.gitTrack default deny)",
-		"  container_admin — container administration (the maintenance bay): role (Skiff roles: guide/validate/apply/list) / msm (register/deregister/check/guide/catalog/ccc-config) / config (view)",
+		"  container_admin — container administration (the maintenance bay): role (轨迹约束 roles: guide/validate/apply/list) / msm (register/deregister/check/guide/catalog/ccc-config) / config (view)",
 		"",
 		"MSM call (registered CCC MSMs, deterministic Mech & Semi-Mech):",
 		"  Execute:       msm(\"<name>\", [\"<arg1>\", \"<arg2>\"])   — run a registered MSM directly (partial name returns matching candidates)",
@@ -3721,7 +3770,7 @@ function registerEntrySkillSection(agent, root) {
 *
 * **声明来源（两条，并集）**：
 *   · **CCC 级**（v1.44.0，owner 令）= `.opencode/serenity.json` 的 `cognitiveTrajectory.skills`
-*     ——**本 CCC 的每条轨迹都带**（含 skiff 角色会话），是容器给的底座；
+*     ——**本 CCC 的每条轨迹都带**（含 轨迹约束角色会话），是容器给的底座；
 *   · **轨迹级** = 该会话绑定的轨迹（`readLastBound(session).mdPath` = 它的 `SESSION.md`）
 *     顶部 frontmatter 的 `skills:`——这条轨迹额外的。
 *   合并规则与顺序见 `cognitive-trajectory-skills.mergeSkillNames`（CCC 级在前，同名去重）。
@@ -3768,13 +3817,19 @@ function registerCognitiveTrajectorySkillSection(agent, root) {
 	}
 }
 //#endregion
-//#region src/role/worker/core.ts
+//#region src/trajectory/delegate/core.ts
 /**
-* role/worker/core.ts — cheap-worker（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
+* trajectory/delegate/core.ts — cheap-worker（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
 *
 * 🆕 2026-10-14（owner 令「删除后台运行能力」）：**进度文件 / stop token / 轮次循环**整族已退场 ——
 * 它们**只**服务于 background 模式。本模块现存 = 前台委派真正需要的三件：
 * 模型串解析 ／ 白名单校验 ／ provider 可用性判读（＋ 使用指引文本）。
+*
+* ## S14（2026-10-19，轨迹中心重构）：此前位于 `role/worker/` 下（该目录已消失）
+*
+* 落点 = `trajectory/delegate/`。判据（判读表 §3.1）：它是**轨迹 × 轨迹**那种合法形态 ——
+* 主语是「主轨迹把活交给子 agent」，既不是某一条轨迹的切面，也不是容器宪法。
+* ⚠️ 它**不属于** `policy/`：policy 管"这条轨迹允许什么"，本模块管"一条轨迹怎么把活派出去"。
 */
 /** 解析 model 字符串（provider/model）→ {provider, model}；无 / 视为 model-only */
 function splitModel(model) {
@@ -3910,42 +3965,38 @@ Before calling cheap-worker, load eap (acc-eap skill) and design the "scale-up c
   (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);
-}
+//#region src/trajectory/session.ts
+/** `provider/model` → agentOptions（由 delegate/core 提供，保持单一实现） */
+const trajectoryAgents = /* @__PURE__ */ new Map();
 /** 查 sessionId 的活体 agent（进程内会话延续用；未注册/已清理 → undefined） */
-function getSkiffAgent(sessionId) {
-	return skiffAgents.get(sessionId);
+function getTrajectoryAgent(sessionId) {
+	return trajectoryAgents.get(sessionId);
 }
-/** 该会话当前绑定的 skiff 约束面（不是 skiff → null）。**守门与提示词的唯一查询入口。** */
-function skiffProfileFor(root, sessionId) {
+/** 该会话当前绑定的 轨迹约束面（不是 轨迹约束 → null）。**守门与提示词的唯一查询入口。** */
+function trajectoryConstraintFor(root, sessionId) {
 	if (sessionId === void 0) return null;
-	return skiffProfileForSession(root, sessionId, skiffTrajectoryDirNameFor(sessionId));
+	return trajectoryConstraintForSession(root, sessionId, trajectoryDirNameForSession(sessionId));
 }
-function registerSkiffSession(sessionId, trajectoryDirName, ccc, agent) {
-	skiffAgents.set(sessionId, agent);
-	registerSkiffSession$1(sessionId, trajectoryDirName, ccc);
+function registerTrajectorySession(sessionId, trajectoryDirName, ccc, agent) {
+	trajectoryAgents.set(sessionId, agent);
+	registerTrajectorySession$1(sessionId, trajectoryDirName, ccc);
 }
-function unregisterSkiffSession(sessionId) {
-	skiffAgents.delete(sessionId);
-	unregisterSkiffSession$1(sessionId);
+function unregisterTrajectorySession(sessionId) {
+	trajectoryAgents.delete(sessionId);
+	unregisterTrajectorySession$1(sessionId);
 }
 /**
-* 该 skiff 会话的**工作台路径** = 它自己轨迹的 SESSION.md。
+* 该 轨迹约束会话的**工作台路径** = 它自己轨迹的 SESSION.md。
 *
-* 🔴 与旧版的差别：旧版会在这里**自动新建**一个 SESSION（`ensureSkiffSession`）；
-* 新版**没有新建这个动作** —— 轨迹就是工作台，`skiff.json` 与 `SESSION.md` 同处一个目录。
+* 🔴 与旧版的差别：旧版会在这里**自动新建**一个 SESSION（`ensureTrajectorySession`）；
+* 新版**没有新建这个动作** —— 轨迹就是工作台，`trajectory-constraint.json` 与 `SESSION.md` 同处一个目录。
 * ⇒ 语义变成纯粹的"查询：我自己的身体在哪"。
 *
-* @returns SESSION.md 绝对路径；不是 skiff / 文件不在 → null
+* @returns SESSION.md 绝对路径；不是 轨迹约束 / 文件不在 → null
 */
-function skiffWorkspaceMdPath(root, sessionId) {
+function trajectoryWorkspaceMdPath(root, sessionId) {
 	if (sessionId === void 0) return null;
-	const dirName = skiffTrajectoryDirNameFor(sessionId);
+	const dirName = trajectoryDirNameForSession(sessionId);
 	if (dirName === null) return null;
 	const md = join(sessionsRoot(root), dirName, "SESSION.md");
 	return existsSync(md) ? md : null;
@@ -3953,12 +4004,12 @@ function skiffWorkspaceMdPath(root, sessionId) {
 /**
 * 系统提示词中的**工作台纪律块**（S142 用户：只给路径 LLM 不会主动用）。
 *
-* SESSION = 工作台 —— skiff 与主舱同一套机制（**零特调**，用户拍板）：
+* SESSION = 工作台 —— 轨迹约束与主舱同一套机制（**零特调**，用户拍板）：
 * SESSION.md 是持久记忆载体、rebuild 自动从本 SESSION 续接。
 * 注入 agent 系统提示词（用户对话面不可见）。
 *
 * v1.30.13（S142 诊断 D5）：写入纪律**不点名具体工具** —— 旧文案写死 "with write/edit"，
-* 而某个 skiff 的工具白名单里根本没有 write/edit ⇒ 指令指向它没有的工具
+* 而某个 轨迹约束的工具白名单里根本没有 write/edit ⇒ 指令指向它没有的工具
 * （注入纪律与能力面矛盾，模型只能猜）。现文案改为「用本轨迹被授权的写入通道」。
 */
 function workspaceCognitiveTrajectoryLine(mdPath) {
@@ -3986,10 +4037,10 @@ const workspaceSectionAgents = /* @__PURE__ */ new WeakSet();
 /**
 * 把**工作台纪律块**挂到 agent 的系统提示词段（单一注入点）。
 *
-* 用户原话（S142，2026-09-08）："微信桥的注入机制，每个用户消息都会注入，skiff 本身也会注入，
-* 这样就重复，能否微信桥情况下，注入内容直接取 skiff 的，这样不用配两遍"。
+* 用户原话（S142，2026-09-08）："微信桥的注入机制，每个用户消息都会注入，轨迹约束本身也会注入，
+* 这样就重复，能否微信桥情况下，注入内容直接取 轨迹约束的，这样不用配两遍"。
 *
-* 现形态：工作台行**只**经本函数挂系统提示词段（name `serenity-skiff-workspace`，
+* 现形态：工作台行**只**经本函数挂系统提示词段（name `serenity-轨迹约束-workspace`，
 * 动态 `text()` 每轮按 scope 读当前活跃 mdPath）。
 *
 * @returns true = 段已在位；false = 该 agent 挂不上（调用方降级为 question 前缀注入）
@@ -4001,39 +4052,39 @@ function ensureWorkspacePromptSection(agent, scope, root) {
 	if (typeof api?.section !== "function") return false;
 	try {
 		api.section({
-			name: "serenity-skiff-workspace",
+			name: "serenity-轨迹约束-workspace",
 			order: -55,
 			text: () => {
-				const mdPath = skiffWorkspaceMdPath(root, scope);
+				const mdPath = trajectoryWorkspaceMdPath(root, scope);
 				return mdPath ? workspaceCognitiveTrajectoryLine(mdPath) : "";
 			}
 		});
 		workspaceSectionAgents.add(agent);
 		return true;
 	} catch (err) {
-		console.warn(`[serenity-hooks] skiff 工作台提示词段注册失败（回退 question 注入）: ${String(err?.message ?? err)}`);
+		console.warn(`[serenity-hooks] 轨迹约束 工作台提示词段注册失败（回退 question 注入）: ${String(err?.message ?? err)}`);
 		return false;
 	}
 }
-/** skiff agent 挂载的 DSH preset（平台工具面由 preset 决定；白名单再按轨迹过滤） */
-const SKIFF_PRESET = "standard";
+/** 轨迹约束 agent 挂载的 DSH preset（平台工具面由 preset 决定；白名单再按轨迹过滤） */
+const TRAJECTORY_PRESET = "standard";
 /**
-* 创建（或复用）一个 skiff 会话。
+* 创建（或复用）一个 轨迹约束会话。
 *
 * **固定 sessionId 的 resume-or-create**（v1.27.2）：指定 sessionId 且磁盘已有持久化 log →
 * `ctx.agents.resume`（DSH 持久化语义：sessionId 即身份，历史 + turn 续号延续）；
 * 无 log（首次）→ `ctx.agents.create`。不指定 → 随机 id 恒 create（调试页路径）。
 *
-* @param profile 该 skiff 的约束面（来自 `skiff.json`）
+* @param profile 该 轨迹约束的约束面（来自 `trajectory-constraint.json`）
 * @param sessionId 指定会话 id（可选；微信桥等外部面用固定 id 实现"轨迹 ↔ 会话"长期映射）
 */
-async function createSkiffAgent(ctx, root, profile, defaultModel, sessionId) {
-	if (!ctx.agents) throw new Error("skiff: ctx.agents unavailable");
+async function createTrajectoryAgent(ctx, root, profile, defaultModel, sessionId) {
+	if (!ctx.agents) throw new Error("轨迹约束: ctx.agents unavailable");
 	const model = profile.model?.trim() || defaultModel || "";
-	const id = sessionId ?? `skiff-${profile.code}-${randomUUID()}`;
+	const id = sessionId ?? `轨迹约束-${profile.code}-${randomUUID()}`;
 	const setup = async (agentCtx) => {
 		try {
-			await agentCtx.get("agentPresets")?.mount?.(agentCtx, SKIFF_PRESET);
+			await agentCtx.get("agentPresets")?.mount?.(agentCtx, TRAJECTORY_PRESET);
 		} catch {}
 	};
 	const handle = await createOrResumeAgent(ctx, id, root, model, setup, sessionId !== void 0);
@@ -4043,7 +4094,7 @@ async function createSkiffAgent(ctx, root, profile, defaultModel, sessionId) {
 	const livePrompt = () => {
 		let live = profile;
 		try {
-			const fresh = readSkiffProfileAt(join(sessionsRoot(root), profile.dirName), root);
+			const fresh = readTrajectoryConstraintAt(join(sessionsRoot(root), profile.dirName), root);
 			if (fresh) live = fresh;
 		} catch {}
 		const wantPath = live.systemPromptFile?.trim();
@@ -4056,23 +4107,23 @@ async function createSkiffAgent(ctx, root, profile, defaultModel, sessionId) {
 	livePrompt();
 	try {
 		agent.ctx.systemPrompt.section({
-			name: "serenity-skiff",
+			name: "serenity-轨迹约束",
 			order: -60,
 			text: () => {
 				const legacy = hasTrajectoryPrompt(root, profile.dirName) ? "" : livePrompt();
-				return [buildSkiffBasePrompt(profile.code), legacy].filter(Boolean).join("\n");
+				return [buildTrajectoryBasePrompt(profile.code), legacy].filter(Boolean).join("\n");
 			}
 		});
 	} catch (err) {
-		console.warn(`[serenity-hooks] skiff 系统提示词注册失败: ${String(err?.message ?? err)}`);
+		console.warn(`[serenity-hooks] 轨迹约束 系统提示词注册失败: ${String(err?.message ?? err)}`);
 	}
 	if (agent?.session) try {
 		registerCognitiveTrajectorySkillSection(agent, root);
 	} catch (err) {
-		console.warn(`[serenity-hooks] skiff 轨迹 skill 注入注册失败（不影响 agent 创建）: ${String(err?.message ?? err)}`);
+		console.warn(`[serenity-hooks] 轨迹约束轨迹 skill 注入注册失败（不影响 agent 创建）: ${String(err?.message ?? err)}`);
 	}
-	if (skiffWorkspaceMdPath(root, id) !== null) ensureWorkspacePromptSection(agent, id, root);
-	registerSkiffSession(id, profile.dirName, root, agent);
+	if (trajectoryWorkspaceMdPath(root, id) !== null) ensureWorkspacePromptSection(agent, id, root);
+	registerTrajectorySession(id, profile.dirName, root, agent);
 	return {
 		handle,
 		agent,
@@ -4111,7 +4162,7 @@ async function createOrResumeAgent(ctx, id, root, model, setup, fixedId) {
 			sessionId: id,
 			meta: {
 				cwd: root,
-				agentPreset: SKIFF_PRESET
+				agentPreset: TRAJECTORY_PRESET
 			},
 			setup,
 			...model ? { agentOptions: splitModel(model) } : {}
@@ -4126,7 +4177,7 @@ async function createOrResumeAgent(ctx, id, root, model, setup, fixedId) {
 			sessionId: id,
 			meta: {
 				cwd: root,
-				agentPreset: SKIFF_PRESET
+				agentPreset: TRAJECTORY_PRESET
 			},
 			setup,
 			...model ? { agentOptions: splitModel(model) } : {}
@@ -4147,14 +4198,14 @@ async function createOrResumeAgent(ctx, id, root, model, setup, fixedId) {
 		if (liveNow) return liveReuseRef(liveNow, setup);
 		const msg = err instanceof Error ? err.message : String(err);
 		const stack = err instanceof Error ? err.stack ?? "" : "";
-		console.log(`[serenity-hooks] skiff resume 失败降级 create (id=${id}): ${msg}`);
-		if (stack) console.log(`[serenity-hooks] skiff resume stack:\n${stack.slice(0, 1200)}`);
+		console.log(`[serenity-hooks] 轨迹约束 resume 失败降级 create (id=${id}): ${msg}`);
+		if (stack) console.log(`[serenity-hooks] 轨迹约束 resume stack:\n${stack.slice(0, 1200)}`);
 		return {
 			...await ctx.agents.create({
 				sessionId: id,
 				meta: {
 					cwd: root,
-					agentPreset: SKIFF_PRESET
+					agentPreset: TRAJECTORY_PRESET
 				},
 				setup,
 				...model ? { agentOptions: splitModel(model) } : {}
@@ -4218,7 +4269,7 @@ async function waitForTurnAssistant(ctx, agent, beforeAssistantCount, opts = {})
 *
 * @param options.timeoutMs 本轮等待上限（测试注入；生产用缺省）
 */
-async function askSkiff(ctx, agent, question, options) {
+async function askTrajectory(ctx, agent, question, options) {
 	const beforeAssistant = countAssistantMessages(agent.session);
 	agent.followup(createUserMessage({
 		content: [{
@@ -4233,29 +4284,29 @@ async function askSkiff(ctx, agent, question, options) {
 	};
 }
 /**
-* skiff 会话的轨迹纪律参与判定：**不是 skiff 恒 true**（正常参与）；
-* skiff 按 `skiff.json` 的 `cognitiveTrajectory` 子集决定。
+* 轨迹约束会话的轨迹纪律参与判定：**不是 轨迹约束恒 true**（正常参与）；
+* 轨迹约束 按 `trajectory-constraint.json` 的 `cognitiveTrajectory` 子集决定。
 *
-* 注册表缺失（进程刚重启、绑定还没读）⇒ 由 `skiffProfileForSession` 回落持久绑定；
-* 两者都不中 ⇒ 判"不是 skiff" ⇒ 恒 true（正常参与）。**fail-open 是有意的**：
+* 注册表缺失（进程刚重启、绑定还没读）⇒ 由 `trajectoryConstraintForSession` 回落持久绑定；
+* 两者都不中 ⇒ 判"不是 轨迹约束" ⇒ 恒 true（正常参与）。**fail-open 是有意的**：
 * 纪律参与项的失败不该让会话失去 keeper/rebuild（那是能力倒退，比多跑一次更糟）。
 */
-function skiffCognitiveTrajectoryEnabled(root, sessionId, key) {
+function trajectoryConstraintParticipates(root, sessionId, key) {
 	if (sessionId === void 0) return true;
-	const profile = skiffProfileFor(root, sessionId);
+	const profile = trajectoryConstraintFor(root, sessionId);
 	if (profile === null) return true;
-	return profileCognitiveTrajectory(profile)[key];
+	return constraintCognitiveTrajectory(profile)[key];
 }
 /**
-* `msm` 工具的 skiff 门控：非 skiff 恒放行；skiff 会话——
+* `msm` 工具的 轨迹约束门控：非 轨迹约束恒放行；轨迹约束会话——
 * exec 非白名单 MSM 拒绝（**不列名单**）、register/deregister 必拒、
 * list 白名单过滤、check/guide/ccc-config 只读放行。
 */
-function skiffMsmGate(root, sessionId, action, name) {
+function trajectoryConstraintMsmGate(root, sessionId, action, name) {
 	if (sessionId === void 0) return {};
-	const profile = skiffProfileFor(root, sessionId);
+	const profile = trajectoryConstraintFor(root, sessionId);
 	if (profile === null) return {};
-	if (action === "register" || action === "deregister") return { reject: "register/deregister is not allowed in skiff sessions" };
+	if (action === "register" || action === "deregister") return { reject: "register/deregister is not allowed in 轨迹约束 sessions" };
 	if (action === "exec") {
 		if (!name || !profile.msms.includes(name)) return { reject: "MSM not allowed" };
 		return {};
@@ -4342,7 +4393,7 @@ const msmTool = defineTool({
 		if (!root) throw new Error(NO_CCC_FROM_AGENT_CWD);
 		const sessionId = agentSessionId$1(exec);
 		const name = args.name;
-		const gate = skiffMsmGate(root, sessionId, name ? "exec" : "list", name);
+		const gate = trajectoryConstraintMsmGate(root, sessionId, name ? "exec" : "list", name);
 		if (gate.reject) throw new Error(gate.reject);
 		if (!name || name.trim() === "") return gate.whitelist ? "MSMs allowed in this role:\n" + [...gate.whitelist].join("\n") : buildMsmIndex(root);
 		const clean = name.trim();
@@ -10043,9 +10094,9 @@ function listWakes(root, opts = {}) {
 	};
 }
 //#endregion
-//#region src/wake/cro.ts
+//#region src/cro/core.ts
 /**
-* wake/cro.ts — CRO（Continuous Re-Occurrence · 持续再发生）机制层（S142 §7.8，2026-09-19）
+* cro/core.ts — CRO（Continuous Re-Occurrence · 持续再发生）机制层（S142 §7.8，2026-09-19）
 *
 * ## 这东西用来干什么（白话）
 *
@@ -10375,7 +10426,7 @@ function parseCroHostBinding(raw) {
 *   `AGENT_SESSIONS/` 下每个目录查一次 `<目录>/continuous-re-occurrence.ts`。
 * · **一次 readdir + 每个目录一次 existsSync**：N 条轨迹的代价是 O(N) 次 `stat`，
 *   每 5min 一次 —— 与既有 `listSessions` 同量级，可接受。
-* · 跳过 **`_` 前缀**（`_archived` / `_skiff-logs` / `_weixin-logs` = 系统与日志目录）
+* · 跳过 **`_` 前缀**（`_archived` / `_轨迹约束-logs` / `_weixin-logs` = 系统与日志目录）
 *   与 **`.` 前缀**（隐藏）——它们**不是轨迹**，且扫它们纯属浪费。
 * · 🔴 **本函数绝不抛错**（返回 `[]`）——它跑在调度器 tick 内，任何异常都可能影响既有链路
 *   （设计 §5 铁律）。目录读不到（不存在 / 权限）⇒ `[]` = "没有轨迹启用 CRO"，语义正确。
@@ -10669,9 +10720,9 @@ function registerDisposer(ctx, label, cleanup) {
 	}
 }
 //#endregion
-//#region src/wake/cro-turns.ts
+//#region src/cro/turns.ts
 /**
-* wake/cro-turns.ts — 「这条轨迹是否正在跑轮次」的追踪（设计 §3.2，2026-09-19 S142）
+* cro/turns.ts — 「这条轨迹是否正在跑轮次」的追踪（设计 §3.2，2026-09-19 S142）
 *
 * ## 为什么需要这个模块（CRO 唯一需要 ACC 新增的状态）
 *
@@ -10797,7 +10848,7 @@ function runningCarriersOf(boundSessionIds, nowMs, ttlMs = TURN_TTL_MS) {
 * 🔴 **本处顺带更正 §2.7 的一处分档**：本文件原被列在"剩余 3 个属**真依赖**档"里，
 * 但**逐符号查证后与那个判断不符** ——
 *   · `Context`：`ctx` 只被**结构化访问**（原码本就写着 `ctx as unknown as { on: … }`）
-*     ⇒ 该注解未提供任何类型保证（与 `role/worker/idle.ts` 同档）。
+*     ⇒ 该注解未提供任何类型保证（与 `trajectory/carrier.ts` 同档）。
 *   · `Agent`：**导入后从未使用** —— 事件 payload 一律按 `{ agent?: unknown }` 解构，
 *     再交给 `sessionIdOf(...)`（它收 `unknown`）。⇒ **纯粹是死 import**。
 * ⇒ **判据（本件再证一次，且比上一件更硬）**：分档**必须逐符号看"它有没有参与类型检查"**，
@@ -10845,9 +10896,9 @@ function registerCroTurnTracking(ctx) {
 	});
 }
 //#endregion
-//#region src/wake/cro-log.ts
+//#region src/cro/log.ts
 /**
-* wake/cro-log.ts — CRO 唤起日志（**ACC 侧**，每轨迹一份固定名文件，2026-09-20 S142 §7.16）
+* cro/log.ts — CRO 唤起日志（**ACC 侧**，每轨迹一份固定名文件，2026-09-20 S142 §7.16）
 *
 * ## 所有者令（本模块的存在理由）
 *
@@ -10883,7 +10934,7 @@ function registerCroTurnTracking(ctx) {
 * ⇒ 清理与写入**是同一笔操作** ⇒ **结构上不存在"忘了清"的可能**（比"另设一个每 tick 的清理步"更硬：
 * 那多一个"可能忘了跑"的面）。窗宽是**常量**，**无配置键、无人工清理动作**。
 *
-* ## 🔴 铁律（与 `wake/cro.ts` 同族）
+* ## 🔴 铁律（与 `cro/core.ts` 同族）
 *
 * **本模块的每个导出函数都不抛错**：写盘 / 裁剪 / 解析失败一律返回结构化失败，
 * 由调用方只记一行 tick 日志 ⇒ **CRO 流水的问题绝不影响投递与既有链路**（设计 §5）。
@@ -12006,9 +12057,9 @@ function registerWakeScheduler(ctx) {
 	registerDisposer(ctx, "认知轨迹唤醒调度器", () => clock.dispose());
 }
 //#endregion
-//#region src/wake/cro-guide.ts
+//#region src/cro/guide.ts
 /**
-* wake/cro-guide.ts — CRO 编写指南（**ACC 内置**，S142 §7.8，2026-09-19）
+* cro/guide.ts — CRO 编写指南（**ACC 内置**，S142 §7.8，2026-09-19）
 *
 * ## 为什么指南在 ACC 而不在 CCC（所有者令）
 *
@@ -12771,20 +12822,20 @@ const localstoreTool = defineTool({
 	}
 });
 //#endregion
-//#region src/tools/skiff-admin.ts
-/** Skiff 定义教程：概念 ／ `skiff.json` schema ／ 双白名单 ／ 轨迹纪律 ／ 微信路由 */
-const SKIFF_GUIDE = `═══ Skiff Guide (2026-10-19 redesigned) ═══
+//#region src/tools/trajectory-constraint-admin.ts
+/** 轨迹约束 定义教程：概念 ／ `trajectory-constraint.json` schema ／ 双白名单 ／ 轨迹纪律 ／ 微信路由 */
+const TRAJECTORY_CONSTRAINT_GUIDE = `═══ 轨迹约束 Guide (2026-10-19 redesigned) ═══
 
-**A skiff IS a cognitive trajectory — the one whose directory contains \`${SKIFF_PROFILE_FILENAME}\`.**
+**A 轨迹约束 IS a cognitive trajectory — the one whose directory contains \`${TRAJECTORY_CONSTRAINT_FILENAME}\`.**
 That is the whole rule. No role table, no name registry: put the file there and the trajectory
-becomes a skiff; delete it and it goes back to being an ordinary trajectory (takes effect at once).
+becomes a 轨迹约束; delete it and it goes back to being an ordinary trajectory (takes effect at once).
 
   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_CONSTRAINT_FILENAME}          ← its constraints (this file is what makes it a 轨迹约束)
     └─ TRAJECTORY-UID  ← legacy, read-only (superseded by the code)
 
-── ${SKIFF_PROFILE_FILENAME} schema ──
+── ${TRAJECTORY_CONSTRAINT_FILENAME} schema ──
   {
     "model": "provider/model",          // optional; falls back to cheap-worker.defaultModel
     "tools": ["read","grep","msm",...], // non-MSM toolbar whitelist — anything not listed is REMOVED from the schema
@@ -12795,35 +12846,34 @@ becomes a skiff; delete it and it goes back to being an ordinary trajectory (tak
   }
 
 ── Two whitelists, both default-deny ──
-  - \`tools: []\` + non-empty \`msms\` = pure-MSM skiff (the usual knowledge-QA shape)
+  - \`tools: []\` + non-empty \`msms\` = pure-MSM 轨迹约束 (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: why the defaults are TRUE ──
-  The workspace of a skiff is its own SESSION.md. Setting these to false would cut it off from
+  The workspace of a 轨迹约束 is its own SESSION.md. Setting these to false would cut it off from
   its own body, so \`session\`/\`keeper\`/\`rebuild\` all default to true. Set false explicitly only
   when you deliberately want that participation off.
 
 ── WeChat routing: user → trajectory code ──
   \`weixin.routes\`: \`[{ "user": "<wx id or *>", "trajectory": "<code>" }]\`
   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.
+  A trajectory WITHOUT \`${TRAJECTORY_CONSTRAINT_FILENAME}\` is still a legal target — it is just an ordinary trajectory.
 
 ── 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.
+  Everything is read live: saving \`${TRAJECTORY_CONSTRAINT_FILENAME}\` takes effect on the next turn, no restart.
     (The prompt FILE hot-reloads by mtime; the JSON itself is re-read every turn.)
-  After editing, run container_admin 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 profiles = listSkiffProfiles(root);
+  After editing, run container_admin config apply for an explicit validation + confirmation pass.
+  Skill loading is always available to 轨迹约束 sessions (skills are not whitelisted — they are read-only knowledge).`;
+/** 校验当前 CCC 的 轨迹约束面：msms 均已注册 ／ model ∈ cheap-worker.models ／ 提示词非空 */
+function validateTrajectoryConstraint(root) {
+	const profiles = listTrajectoryConstraints(root);
 	const issues = [];
 	if (profiles.length === 0) return {
 		ok: true,
 		issues: [],
-		roleCount: 0,
-		note: `no skiff trajectories in this CCC (no trajectory has ${SKIFF_PROFILE_FILENAME} — zero impact)`
+		constraintCount: 0,
+		note: `no 轨迹约束 trajectories in this CCC (no trajectory has ${TRAJECTORY_CONSTRAINT_FILENAME} — zero impact)`
 	};
 	const registered = new Set(loadMsmEntries(root).map((e) => e.name));
 	const hc = readCheapWorkerConfig(root);
@@ -12831,7 +12881,7 @@ function validateSkiffConfig(root) {
 	for (const p of profiles) {
 		if (!(hasTrajectoryPrompt(root, p.dirName) || (() => {
 			try {
-				return resolveProfileSystemPrompt(root, p).trim() !== "";
+				return resolveConstraintSystemPrompt(root, p).trim() !== "";
 			} catch (err) {
 				issues.push(`trajectory "${p.code}": ${String(err?.message ?? err)}`);
 				return true;
@@ -12843,15 +12893,15 @@ function validateSkiffConfig(root) {
 	return {
 		ok: issues.length === 0,
 		issues,
-		roleCount: profiles.length
+		constraintCount: profiles.length
 	};
 }
-/** 列出当前 CCC 的 skiff 轨迹（编码 ／ 模型 ／ msms ／ tools ／ 纪律摘要 ／ 提示词来源） */
-function listSkiffRoles(root) {
-	const profiles = listSkiffProfiles(root);
+/** 列出当前 CCC 的轨迹约束（编码 ／ 模型 ／ msms ／ tools ／ 纪律摘要 ／ 提示词来源） */
+function listTrajectoryConstraintSummary(root) {
+	const profiles = listTrajectoryConstraints(root);
 	if (profiles.length === 0) return {
 		roles: [],
-		note: `no skiff trajectories in this CCC (no trajectory has ${SKIFF_PROFILE_FILENAME})`
+		note: `no 轨迹约束 trajectories in this CCC (no trajectory has ${TRAJECTORY_CONSTRAINT_FILENAME})`
 	};
 	const items = profiles.map((p) => ({
 		name: p.code,
@@ -12859,8 +12909,8 @@ function listSkiffRoles(root) {
 		model: p.model ?? "(cheap-worker default)",
 		msms: p.msms,
 		tools: p.tools,
-		cognitiveTrajectory: profileCognitiveTrajectory(p),
-		promptSource: profileSystemPromptSource(p),
+		cognitiveTrajectory: constraintCognitiveTrajectory(p),
+		promptSource: constraintSystemPromptSource(p, hasTrajectoryPrompt(root, p.dirName)),
 		...p.systemPromptFile ? { systemPromptFile: p.systemPromptFile } : {}
 	}));
 	return {
@@ -12869,51 +12919,91 @@ function listSkiffRoles(root) {
 	};
 }
 /**
-* 应用当前 skiff 配置（S142 用户：改了 json 应该有个生效机制）。
+* 应用当前 轨迹约束 配置（S142 用户：改了 json 应该有个生效机制）。
 *
 * 语义：约束面是**每轮实时读取**的 ⇒ apply 不是"推送"，而是**显式校验 + 应用确认**：
 * ① 校验合法（复用 validate：msms 注册 / model 白名单 / 提示词非空）
 * ② 非法 → 报告问题清单，不应用（提示修复后重跑 apply）
 * ③ 合法 → 应用确认：绑定 CCC + 轨迹清单 + 说明（下一轮即生效）
 */
-function applySkiffConfig(root) {
-	const validation = validateSkiffConfig(root);
-	const profiles = listSkiffProfiles(root);
+function applyTrajectoryConstraint(root) {
+	const validation = validateTrajectoryConstraint(root);
+	const profiles = listTrajectoryConstraints(root);
 	if (!validation.ok) return {
 		applied: false,
 		cccRoot: root,
-		roleCount: profiles.length,
+		constraintCount: profiles.length,
 		issues: validation.issues,
-		hint: "fix the issues above, then run container_admin role apply again"
+		hint: "fix the issues above, then run container_admin config apply again"
 	};
 	return {
 		applied: true,
 		cccRoot: root,
-		roleCount: profiles.length,
+		constraintCount: 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}`
+		note: `constraints are read live from each trajectory's ${TRAJECTORY_CONSTRAINT_FILENAME} — they take effect on the next turn (no restart); ${TRAJECTORY_CONSTRAINT_HINT}`
 	};
 }
 //#endregion
+//#region src/tools/config-docs.ts
+/**
+* 渲染**目录**（第一层）。
+*
+* 🔴 只调 `summary`，**绝不调 `render`** —— 目录若触发正文，就退化成"整份长文"。
+* 这条不是性能优化，是**判据**：它保证 `docs` 的输出大小与章数成正比，与正文长度无关。
+*/
+function renderDocsIndex(chapters) {
+	const lines = [
+		"═══ CCC 配置说明 · 目录 ═══",
+		"",
+		"说明类内容已超过单次返回的合适篇幅 ⇒ 先读目录，再按章取详情。",
+		"",
+		"用法：container_admin config docs <章节>",
+		""
+	];
+	for (const ch of chapters) lines.push(`  ${ch.id.padEnd(14)}${ch.summary}`);
+	lines.push("");
+	lines.push("相关：container_admin msm catalog（工具/能力目录——与本章录互指，不互相复制）");
+	return lines.join("\n");
+}
+/**
+* 解析一个章节参数（第二层）。
+*
+* 不存在 ⇒ 返回 `null`，由调用方给出**带候选清单**的拒绝 ——
+* "不知道这个章节" 与 "这一章是空的" 必须可区分（否则用户以为功能没有）。
+*/
+function findDocsChapter(chapters, id) {
+	const want = id.trim().toLowerCase();
+	if (want === "") return null;
+	return chapters.find((c) => c.id.toLowerCase() === want) ?? null;
+}
+//#endregion
 //#region src/tools/container-admin.ts
 /**
 * container-admin.ts — container_admin（v1.30：机务舱——容器管理面统一入口）
 *
-* 合并自：
-*   · skiff_admin（F4 Skiff 认知子集角色：guide/validate/apply/list）
-*   · acc_msm 管理面（register/deregister/check/guide/catalog/ccc-config）
-*     —— msm 工具只管执行+发现；一切「管理容器」的操作归本工具
+* ## 域结构（2026-10-19 owner 两条令后：**两域**）
 *
-* 语义（用户拍板"skiff_admin 及系列 admin 合并成 container_admin"）：
+* | 域 | 管什么 |
+* |---|---|
+* | `config` | **本 CCC 的全部配置面**：说明目录/按章详情 ＋ 轨迹约束（原 `role` 域，已并入） |
+* | `msm`    | MSM 注册表管理 ＋ 手册（register/deregister/check/guide/catalog/ccc-config） |
+*
+* 🔴 **`role` 域已并入 `config`**（owner 2026-10-19 裁「1 并入」）。为什么不是三个平行域：
+* `role` 管的本来就是"某条轨迹的约束面"——**一组配置**，与 `config` 是同一抽象层的两半。
+* 分着放的代价是：用户在 `config` 里看不到"轨迹怎么约束"，得先知道 `role` 这个词存在。
+* ⚠️ **旧 `role` 域仍被接受**（过渡别名，指向同一实现）——存量 CCC 的文档/脚本里到处是
+* `container_admin role validate`（实测本仓 30 处），硬切会让它们全部变成"未知域"。
+* 别名**只保留读取路径**：schema 的 `enum` 只列新名，文案只教新名。
+*
+* ## 三个动作名为什么是这三个（P3 的实现形态）
+* - `config docs`（无参）→ **使用说明目录**（第一层；只索引不复制）
+* - `config docs <chapter>` → **使用说明详情**（第二层；按章获得）
+* - `config view` → 配置**现值**（原来是唯一动作；现在是"看当前填了什么"）
+*
+* 归属（D23）：**机制在 ACC**（有哪几章、怎么路由、怎么校验），**内容在 CCC**（填什么）。
+* 语义（用户拍板"轨迹约束_admin 及系列 admin 合并成 container_admin"）：
 *   container = CCC（具体认知容器）；admin = 管理操作。
-*   类比 The Manifest（清单维护——工具注册表）+ Crew（角色管理）+ 机务（配置/手册）。
-*
-* 参数极简（LLM 直觉）：domain（管理域）+ action（该域子命令）+ 少量业务参数。
-*
-* v1.34.1（⑥ C6a）：由 `export const containerAdminTool` 改为**工厂**
-* `createContainerAdminTool(ctx)`——原为 autopilot 域传进程内运行态事实（全局闸 / live 会话 /
-* agent 可解析性）。该域已于 2026-09-15 随 ACC 侧 autopilot 整段退场删除（所有者裁决 (a)）：
-* `ctx` 现**无消费者**，工厂形态保留只是为了让装配点签名不再变动（见 index.ts 注册处）。
 */
 function agentSessionId(exec) {
 	return exec.agent?.session?.id ?? "";
@@ -12924,9 +13014,13 @@ function renderText$1(value) {
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
 	}];
 }
+/** 过渡别名表：旧域 → 新域（只读兼容；文案不教它） */
+const DOMAIN_ALIASES = { role: "config" };
 /** 合法 domain 名（拒绝文案与 schema enum 同源——不得各写一份） */
 const DOMAIN_NAMES = Object.keys({
-	role: [
+	config: [
+		"docs",
+		"view",
 		"guide",
 		"validate",
 		"apply",
@@ -12939,23 +13033,43 @@ const DOMAIN_NAMES = Object.keys({
 		"guide",
 		"catalog",
 		"ccc-config"
-	],
-	config: ["view"]
+	]
 });
+/**
+* 说明目录的章节（P3 两层菜单的**唯一注册处**）。
+*
+* 🔴 加一章 = 在这里加一项（`render` 惰性求值）。**正文不复制**：
+* 每章的真相源就在它自己的函数里（`CCC_CONFIG_REFERENCE` / `TRAJECTORY_CONSTRAINT_GUIDE`）——
+* 本表只做**切分与路由**，避免"同一段说明有第二份会漂的副本"。
+*/
+const DOCS_CHAPTERS = [{
+	id: "config",
+	summary: "CCC 配置全表——9 段各是什么、怎么填、填错会怎样（.opencode/serenity.json）",
+	render: () => CCC_CONFIG_REFERENCE
+}, {
+	id: "trajectory-constraint",
+	summary: "轨迹约束：一条轨迹怎么被约束（trajectory-constraint.json 的 schema ＋ 双白名单）",
+	render: () => TRAJECTORY_CONSTRAINT_GUIDE
+}];
 function createContainerAdminTool(ctx) {
 	return defineTool({
 		name: "container_admin",
-		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): role — Skiff cognitive-subset roles (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference); config — view CCC configuration. Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
+		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): config — CCC configuration: docs (usage-manual index) / docs <chapter> (one chapter in full) / view (current values) + 轨迹约束 (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference). Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
 		parameters: {
 			domain: {
 				type: "string",
 				enum: DOMAIN_NAMES,
 				required: true,
-				description: "Management domain: role (Skiff roles) / msm (MSM registry + manuals) / config (CCC config view)"
+				description: "Management domain: config (CCC configuration + 轨迹约束) / msm (MSM registry + manuals)"
 			},
 			action: {
 				type: "string",
-				description: "Domain subcommand (see domain descriptions; e.g. role: validate/apply/list/guide; msm: register/deregister/check/guide/catalog/ccc-config)"
+				description: "Domain subcommand. config: docs / view / guide / validate / apply / list; msm: register / deregister / check / guide / catalog / ccc-config"
+			},
+			/** 第二层菜单参数：`config docs <chapter>`（缺省 = 目录） */
+			chapter: {
+				type: "string",
+				description: "config docs only: chapter id (omit for the index; e.g. config / trajectory-constraint)"
 			},
 			name: {
 				type: "string",
@@ -12994,18 +13108,35 @@ function createContainerAdminTool(ctx) {
 			const root = cccRootForExec(exec);
 			if (!root) throw new Error(NO_CCC_FROM_AGENT_CWD);
 			const sessionId = agentSessionId(exec);
-			const domain = args.domain;
+			const rawDomain = String(args.domain ?? "");
+			const domain = DOMAIN_ALIASES[rawDomain] ?? rawDomain;
 			const action = args.action ?? "";
+			if (!DOMAIN_NAMES.includes(domain)) throw new Error(`container_admin requires domain: ${DOMAIN_NAMES.join(" | ")}`);
 			if (domain === "msm" && (action === "register" || action === "deregister")) {
-				const gate = skiffMsmGate(root, sessionId, action, args.name);
+				const gate = trajectoryConstraintMsmGate(root, sessionId, action, args.name);
 				if (gate.reject) throw new Error(gate.reject);
 			}
-			if (domain === "role") switch (action) {
-				case "guide": return { guide: SKIFF_GUIDE };
-				case "validate": return validateSkiffConfig(root);
-				case "apply": return applySkiffConfig(root);
-				case "list": return listSkiffRoles(root);
-				default: throw new Error(`container_admin role requires action: guide | validate | apply | list`);
+			if (domain === "config") switch (action) {
+				case "docs": {
+					const chapter = args.chapter?.trim() ?? "";
+					if (chapter === "") return {
+						docs: renderDocsIndex(DOCS_CHAPTERS),
+						chapters: DOCS_CHAPTERS.map((c) => c.id)
+					};
+					const found = findDocsChapter(DOCS_CHAPTERS, chapter);
+					if (found === null) throw new Error(`container_admin config docs: unknown chapter "${chapter}". Available: ${DOCS_CHAPTERS.map((c) => c.id).join(" | ")} (omit the chapter for the index)`);
+					return {
+						chapter: found.id,
+						docs: found.render()
+					};
+				}
+				case "view":
+				case "": return { config: runMsm(root, { action: "ccc-config" }) };
+				case "guide": return { guide: TRAJECTORY_CONSTRAINT_GUIDE };
+				case "validate": return validateTrajectoryConstraint(root);
+				case "apply": return applyTrajectoryConstraint(root);
+				case "list": return listTrajectoryConstraintSummary(root);
+				default: throw new Error(`container_admin config requires action: docs | view | guide | validate | apply | list`);
 			}
 			if (domain === "msm") {
 				const mgmtActions = [
@@ -13028,7 +13159,6 @@ function createContainerAdminTool(ctx) {
 					usage: args.usage
 				});
 			}
-			if (domain === "config") return { config: runMsm(root, { action: "ccc-config" }) };
 			throw new Error(`container_admin requires domain: ${DOMAIN_NAMES.join(" | ")}`);
 		}
 	});
@@ -13280,7 +13410,7 @@ const SENSITIVE_CREDENTIAL_FILES = /* @__PURE__ */ new Set(["localstore.json"]);
 * MSM 注册表写保护（需求⑤b S142 用户拍板："msm注册的文件需要写保护起来，避免CCC意外写坏搞崩自己"）：
 * mech-registry.json 是 CCC 执行层地基（坏 → loadMsmEntries 抛 → container_admin/output-guard 全崩，
 * register 也崩 → 自锁）。**写 deny、读 allow**（与 localstore 读 deny 语义区分 R6——注册表是
-* 结构核心不是秘密，需被 output-guard/skiff-admin 读取建 MSM 词表）。
+* 结构核心不是秘密，需被 output-guard/trajectory-constraint-admin 读取建 MSM 词表）。
 *
 * 单级化（需求⑤a）后**唯一合法注册表 = cccName 聚合档**
 * `.opencode/skills/<cccName>/references/mech-registry.json`（cccName = .serenity 首行）。
@@ -13318,15 +13448,15 @@ function isWriteTool(toolName, action) {
 */
 function decideGuard(input) {
 	const { root, toolName, safeModeOn, blacklist, pathArg, action } = input;
-	if (input.skiffProfile !== void 0 && input.skiffProfile !== null) {
-		const profile = input.skiffProfile;
+	if (input.trajectoryConstraint !== void 0 && input.trajectoryConstraint !== null) {
+		const profile = input.trajectoryConstraint;
 		if (toolName === "skill") return { kind: "allow" };
 		if (profile.msms.includes(toolName)) return {
 			deny: `"${toolName}" is a registered MSM, not a direct tool in this trajectory — call it through the msm tool: msm("${toolName}", ["<args>"]) (pass "--help" or inspect=true for usage)`,
 			kind: "deny"
 		};
 		if (!profileToolWhitelist(profile).has(toolName)) return {
-			deny: "tool not allowed in this skiff trajectory",
+			deny: "tool not allowed in this 轨迹约束 trajectory",
 			kind: "deny"
 		};
 	}
@@ -13611,17 +13741,17 @@ const exclusiveRestrictions = /* @__PURE__ */ new Map();
 * 每次 pre-step 都重算白名单，只有**算出来的结果变了**才重新发 restrict
 * —— 配置不变就不重复发（restrict 会重建 schema，没必要每步都做）。
 */
-const skiffRoleRestrictions = /* @__PURE__ */ new Map();
+const trajectoryConstraintRestrictions = /* @__PURE__ */ new Map();
 /**
-* 同步 **skiff 会话的工具面**：把白名单之外的工具**从 schema 移除**（不是"看得到但被拒"）。
+* 同步 **轨迹约束会话的工具面**：把白名单之外的工具**从 schema 移除**（不是"看得到但被拒"）。
 *
 * ## 为什么必须有这条（owner 2026-10-19：「工具清单也要热加载」）
 *
-* 在它之前，skiff 白名单**只由运行时守卫拦截**（`decideGuard` 的 skiff 分支）：
+* 在它之前，轨迹约束白名单**只由运行时守卫拦截**（`decideGuard` 的 轨迹约束 分支）：
 * 工具全部出现在模型 schema 里，调用时才被打回。⇒ 两个真实后果：
 *  ① **模型看得见它不该有的工具** —— 它会去试，试了才撞墙（一轮白烧，且错误文案泛化，
 *     看不出"是不在清单里"还是"临时性拒绝"）；
-*  ② **配置变动在 schema 上永远不生效** —— 改 `skiff.json` 的 `tools` 只影响"调用是否放行"。
+*  ② **配置变动在 schema 上永远不生效** —— 改 `trajectory-constraint.json` 的 `tools` 只影响"调用是否放行"。
 *
 * ## 判据与降级
 *
@@ -13629,24 +13759,24 @@ const skiffRoleRestrictions = /* @__PURE__ */ new Map();
 *   不去动宿主的工具 —— 宿主的工具由各自的条件同步管）。
 * - ⚠️ **未注册的名字会让整次 restrict 失败**（宿主契约逐字 "unknown names … fail"），
 *   而 `diagram` 是按开关注册的 ⇒ 与 `hideAllFor` 同款**两档尝试**（先全覆盖，失败退常驻段）。
-* - 读不到约束面（不是 skiff / 配置删了）⇒ **撤销既有隐藏**（回到"无约束"）：
-*   ⛔ 不能只是 `return` —— 那会把上一步的隐藏**永久留在**一个已不再是 skiff 的会话上
-*   （这正是 owner 说的"删掉 `skiff.json` 就该立刻恢复"）。
+* - 读不到约束面（不是 轨迹约束 / 配置删了）⇒ **撤销既有隐藏**（回到"无约束"）：
+*   ⛔ 不能只是 `return` —— 那会把上一步的隐藏**永久留在**一个已不再是 轨迹约束的会话上
+*   （这正是 owner 说的"删掉 `trajectory-constraint.json` 就该立刻恢复"）。
 * - 幂等：算出来的 deny 签名不变就跳过（不每步重建 schema）。
 *
 * @param agent 目标会话
 * @param root  CCC 根
 */
-function syncSkiffRoleToolVisibility(agent, root) {
+function syncTrajectoryConstraintToolVisibility(agent, root) {
 	const sessionId = agent.session.id ?? "global";
-	const profile = skiffProfileForSession(root, sessionId);
-	const existing = skiffRoleRestrictions.get(sessionId);
+	const profile = trajectoryConstraintForSession(root, sessionId);
+	const existing = trajectoryConstraintRestrictions.get(sessionId);
 	if (profile === null) {
 		if (existing !== void 0) {
 			try {
 				existing.dispose();
 			} catch {}
-			skiffRoleRestrictions.delete(sessionId);
+			trajectoryConstraintRestrictions.delete(sessionId);
 		}
 		return;
 	}
@@ -13662,7 +13792,7 @@ function syncSkiffRoleToolVisibility(agent, root) {
 				try {
 					existing.dispose();
 				} catch {}
-				skiffRoleRestrictions.delete(sessionId);
+				trajectoryConstraintRestrictions.delete(sessionId);
 			}
 			return;
 		}
@@ -13671,10 +13801,10 @@ function syncSkiffRoleToolVisibility(agent, root) {
 				try {
 					existing.dispose();
 				} catch {}
-				skiffRoleRestrictions.delete(sessionId);
+				trajectoryConstraintRestrictions.delete(sessionId);
 			}
 			const dispose = agent.ctx.tools.restrict({ deny: [...deny] });
-			skiffRoleRestrictions.set(sessionId, {
+			trajectoryConstraintRestrictions.set(sessionId, {
 				signature,
 				deny,
 				dispose
@@ -13686,13 +13816,13 @@ function syncSkiffRoleToolVisibility(agent, root) {
 	}
 }
 /** 会话销毁清理（lifecycle 调用） */
-function forgetSkiffRoleToolVisibility(sessionId) {
-	const existing = skiffRoleRestrictions.get(sessionId);
+function forgetTrajectoryConstraintToolVisibility(sessionId) {
+	const existing = trajectoryConstraintRestrictions.get(sessionId);
 	if (!existing) return;
 	try {
 		existing.dispose();
 	} catch {}
-	skiffRoleRestrictions.delete(sessionId);
+	trajectoryConstraintRestrictions.delete(sessionId);
 }
 /**
 * 同步专属工具可见性（v1.33）。
@@ -13887,7 +14017,7 @@ function registerGuards(ctx, opts = {}) {
 		const pathArg = extractPathArg(exec);
 		const action = extractAction(exec);
 		const sessionId = exec?.agent?.session?.id;
-		const skiffProfile = skiffProfileForSession(root, sessionId);
+		const trajectoryConstraint = trajectoryConstraintForSession(root, sessionId);
 		return decideGuard({
 			root,
 			toolName: exec.name,
@@ -13895,7 +14025,7 @@ function registerGuards(ctx, opts = {}) {
 			blacklist,
 			pathArg,
 			action,
-			skiffProfile
+			trajectoryConstraint
 		});
 	};
 	ctx.on("tools/pre-execute", async (exec, next) => {
@@ -14132,7 +14262,7 @@ function createEpochPromotion(promoteEvents, requiredSignals = 1, maxRoundsFallb
 			const loopSid = session.id;
 			const loopCwd = session.header?.cwd ?? process.cwd();
 			const loopRoot = cccRootForCwd(loopCwd);
-			if (typeof loopSid === "string" && (loopSid.startsWith("cheap-worker-") || loopRoot !== null && isSkiffSession(loopRoot, loopSid))) return {
+			if (typeof loopSid === "string" && (loopSid.startsWith("cheap-worker-") || loopRoot !== null && isTrajectoryConstrained(loopRoot, loopSid))) return {
 				boundary: -1,
 				promoted: true
 			};
@@ -14251,7 +14381,7 @@ function registerBootstrap(ctx) {
 			const depth = session?.header?.delegationDepth ?? 0;
 			const sid = typeof session?.id === "string" ? session.id : void 0;
 			if (sid === void 0) return;
-			if (sid.startsWith("cheap-worker-") || isSkiffSession(root, sid)) return;
+			if (sid.startsWith("cheap-worker-") || isTrajectoryConstrained(root, sid)) return;
 			if (depth === 0) {
 				if (hasUserMessageHistory(session)) return;
 			} else if (anchoredSessions.has(sid)) return;
@@ -14565,7 +14695,7 @@ function forgetLogbookCompactionState(scope) {
 * 解析**活跃** SESSION.md 绝对路径（缓存 60s）。
 *
 * 候选链（刻意比 rebuild 的完整链短——这里每个工具调用都要跑，贵候选不划算）：
-* ① `getActiveSessionInfo(scope).mdPath`（`cognitive_trajectory use` / skiff 绑定 / 重启恢复都会写）
+* ① `getActiveSessionInfo(scope).mdPath`（`cognitive_trajectory use` / 轨迹约束 绑定 / 重启恢复都会写）
 * ② `readLastBound(session).mdPath`（`.bindings.json` 权威绑定——重启后内存空时兜底）
 * 两者都拿不到 → null（**不猜**：宁可不提醒，也不去猜别的轨迹——对齐 v1.30.13 D4 的教训）。
 */
@@ -14694,10 +14824,10 @@ function registerKeeper(ctx, opts = {}) {
 		const root = cccRootForCwd(cwd);
 		if (!root) return next();
 		const sessionId = exec.agent?.session?.id;
-		const skiffKeeper = skiffCognitiveTrajectoryEnabled(root, sessionId, "keeper");
-		const skiffRebuild = skiffCognitiveTrajectoryEnabled(root, sessionId, "rebuild");
+		const 轨迹约束Keeper = trajectoryConstraintParticipates(root, sessionId, "keeper");
+		const 轨迹约束Rebuild = trajectoryConstraintParticipates(root, sessionId, "rebuild");
 		const tracker = trackerFor(exec);
-		const shouldRemind = skiffKeeper ? tracker.step(exec.name) : false;
+		const shouldRemind = 轨迹约束Keeper ? tracker.step(exec.name) : false;
 		const downstream = await next();
 		try {
 			recordToolUsage(root, exec.name, exec.arguments);
@@ -14710,7 +14840,7 @@ function registerKeeper(ctx, opts = {}) {
 				text: reminderText(code)
 			});
 		}
-		if (skiffRebuild) {
+		if (轨迹约束Rebuild) {
 			const session = exec.agent?.session;
 			if (session) {
 				const pressure = readContextPressure(ctx, session);
@@ -14730,7 +14860,7 @@ function registerKeeper(ctx, opts = {}) {
 				}
 			}
 		}
-		if (skiffCognitiveTrajectoryEnabled(root, sessionId, "session")) {
+		if (trajectoryConstraintParticipates(root, sessionId, "session")) {
 			const limitKB = readSessionMdMaxKB(root, opts.configPaths);
 			if (limitKB > 0) {
 				const scope = sessionId ?? "global";
@@ -14753,7 +14883,7 @@ function registerKeeper(ctx, opts = {}) {
 				} else compactionStates.delete(scope);
 			}
 		}
-		if (skiffCognitiveTrajectoryEnabled(root, sessionId, "session")) {
+		if (trajectoryConstraintParticipates(root, sessionId, "session")) {
 			const scope = sessionId ?? "global";
 			const session = exec.agent?.session;
 			const mdPath = resolveActiveSessionMdPath(root, scope, session);
@@ -14861,7 +14991,7 @@ function shouldAutoRestore(agent, root) {
 	if (session.header?.parentSession) return false;
 	if (session.id?.startsWith("cheap-worker-")) return false;
 	const cccRoot = root !== void 0 ? root : cccRootForCwd(session.header?.cwd ?? process.cwd());
-	if (cccRoot && isSkiffSession(cccRoot, session.id)) return false;
+	if (cccRoot && isTrajectoryConstrained(cccRoot, session.id)) return false;
 	return true;
 }
 /**
@@ -14884,7 +15014,7 @@ function registerContext(ctx, opts = {}) {
 		} catch {}
 		if (!root) return;
 		const key = agentKey(agent);
-		if (isSkiffSession(root, key)) return;
+		if (isTrajectoryConstrained(root, key)) return;
 		registerEntrySkillSection(agent, root);
 		registerCognitiveTrajectorySkillSection(agent, root);
 		const scope = agentScope(agent);
@@ -14968,9 +15098,9 @@ function registerContext(ctx, opts = {}) {
 		const key = agentKey(agent);
 		const downstream = await next();
 		if (root) try {
-			syncSkiffRoleToolVisibility(agent, root);
+			syncTrajectoryConstraintToolVisibility(agent, root);
 		} catch {}
-		if (root && isSkiffSession(root, key)) return downstream;
+		if (root && isTrajectoryConstrained(root, key)) return downstream;
 		try {
 			syncCccToolVisibility(agent, root);
 		} catch {}
@@ -15019,7 +15149,7 @@ function registerCompactRetention(ctx, opts = {}) {
 		const cwd = agent.session?.header?.cwd ?? process.cwd();
 		const root = cccRootForCwd(cwd);
 		if (!root) return;
-		if (isSkiffSession(root, String(session.id ?? ""))) return;
+		if (isTrajectoryConstrained(root, String(session.id ?? ""))) return;
 		try {
 			agent.inject(accMessage(root, configPaths, entrySkillMaxChars));
 		} catch {}
@@ -15312,7 +15442,7 @@ function saveFileToTmp(root, fileName, data) {
 	writeFileSync(join(dir, filename), bytes);
 	return `${FILE_UPLOAD_DIR}/${filename}`;
 }
-function readBody$3(req, maxBytes) {
+function readBody$2(req, maxBytes) {
 	return new Promise((resolve, reject) => {
 		let data = "";
 		req.on("data", (chunk) => {
@@ -15326,7 +15456,7 @@ function readBody$3(req, maxBytes) {
 		req.on("error", reject);
 	});
 }
-function sendJson$3(res, code, body) {
+function sendJson$2(res, code, body) {
 	const payload = JSON.stringify(body);
 	res.writeHead(code, {
 		"content-type": "application/json; charset=utf-8",
@@ -15351,7 +15481,7 @@ function senderIsWebUi(req) {
 */
 function requireWebUi(req, res, message) {
 	if (senderIsWebUi(req)) return true;
-	sendJson$3(res, 403, { error: message });
+	sendJson$2(res, 403, { error: message });
 	return false;
 }
 /**
@@ -15360,7 +15490,7 @@ function requireWebUi(req, res, message) {
 *
 * 🔴🔴 **2026-10-18 修缺陷（owner 报「在别的 CCC 点开显示的还是 home-serenity 的信息」）**：
 * 旧实现第 ③ 步是「**遍历 live sessions 找第一个 CCC 会话的 cwd**」—— 那是**跨工作区猜测**：
-* 只要 sessionId 缺失或那条会话查不到（ACP/skiff 会话、尚未 materialize 的会话、远程访问），
+* 只要 sessionId 缺失或那条会话查不到（ACP/轨迹约束会话、尚未 materialize 的会话、远程访问），
 * 它就会**静默返回另一个 CCC 的路径**，于是面板把**别人的轨迹/技能/安全模式**当成你的显示出来。
 * 这比"显示未激活"危险得多 —— 用户会据此做判断（以为自己的 safe-mode 开着、以为那是自己的轨迹）。
 *
@@ -15409,11 +15539,11 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$2(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "图片落盘仅限 WebUI（client 专用）")) return;
-				const raw = await readBody$3(req, 20971520);
+				const raw = await readBody$2(req, 20971520);
 				const body = JSON.parse(raw);
 				const workspace = resolveWorkspace(ctx, {
 					sessionId: body.sessionId,
@@ -15421,12 +15551,12 @@ function registerStatusApi(ctx, opts = {}) {
 				});
 				const root = cccRootForCwd(workspace);
 				if (!root) {
-					sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+					sendJson$2(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 					return;
 				}
-				sendJson$3(res, 200, { path: saveImageToTmp(root, body.mediaType ?? "", body.data ?? "") });
+				sendJson$2(res, 200, { path: saveImageToTmp(root, body.mediaType ?? "", body.data ?? "") });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15436,11 +15566,11 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$2(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "文件落盘仅限 WebUI（client 专用）")) return;
-				const raw = await readBody$3(req, 20971520);
+				const raw = await readBody$2(req, 20971520);
 				const body = JSON.parse(raw);
 				const workspace = resolveWorkspace(ctx, {
 					sessionId: body.sessionId,
@@ -15448,12 +15578,12 @@ function registerStatusApi(ctx, opts = {}) {
 				});
 				const root = cccRootForCwd(workspace);
 				if (!root) {
-					sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+					sendJson$2(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 					return;
 				}
-				sendJson$3(res, 200, { path: saveFileToTmp(root, body.name ?? "", body.data ?? "") });
+				sendJson$2(res, 200, { path: saveFileToTmp(root, body.name ?? "", body.data ?? "") });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15469,7 +15599,7 @@ function registerStatusApi(ctx, opts = {}) {
 						workspace: url.searchParams.get("workspace") ?? void 0
 					}), configPaths);
 					const runtime = ctx.get("codeRuntime");
-					sendJson$3(res, 200, {
+					sendJson$2(res, 200, {
 						...status,
 						...runtime === void 0 ? { codeRuntime: null } : { codeRuntime: {
 							language: runtime.language,
@@ -15480,7 +15610,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (req.method === "POST") {
 					if (!requireWebUi(req, res, "safe-mode 切换仅限 WebUI（agent 不可自行开关）")) return;
-					const raw = await readBody$3(req, 65536);
+					const raw = await readBody$2(req, 65536);
 					const body = JSON.parse(raw);
 					const workspace = resolveWorkspace(ctx, {
 						sessionId: body.sessionId,
@@ -15488,19 +15618,19 @@ function registerStatusApi(ctx, opts = {}) {
 					});
 					const root = cccRootForCwd(workspace);
 					if (!root) {
-						sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+						sendJson$2(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 						return;
 					}
 					const result = setSafeMode(root, body.on === true);
-					sendJson$3(res, 200, {
+					sendJson$2(res, 200, {
 						...getStatus(workspace, configPaths),
 						...result
 					});
 					return;
 				}
-				sendJson$3(res, 405, { error: "method not allowed" });
+				sendJson$2(res, 405, { error: "method not allowed" });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15516,24 +15646,24 @@ function registerStatusApi(ctx, opts = {}) {
 					try {
 						known = projectKnownWorkspaces(hostService(ctx, "workspaceRegistry")?.list?.() ?? [], settings.gateway.workspaces);
 					} catch {}
-					sendJson$3(res, 200, {
+					sendJson$2(res, 200, {
 						config: toWire(settings),
 						knownWorkspaces: known
 					});
 					return;
 				}
 				if (req.method === "PUT") {
-					const raw = await readBody$3(req, 131072);
+					const raw = await readBody$2(req, 131072);
 					const saved = applyWirePatch(JSON.parse(raw).config ?? {});
 					try {
 						ctx.emit?.("serenity/config-updated");
 					} catch {}
-					sendJson$3(res, 200, { config: toWire(saved) });
+					sendJson$2(res, 200, { config: toWire(saved) });
 					return;
 				}
-				sendJson$3(res, 405, { error: "method not allowed" });
+				sendJson$2(res, 405, { error: "method not allowed" });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15543,7 +15673,7 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "GET") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$2(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -15552,12 +15682,12 @@ function registerStatusApi(ctx, opts = {}) {
 					workspace: url.searchParams.get("workspace") ?? void 0
 				});
 				const root = cccRootForCwd(workspace) ?? "";
-				sendJson$3(res, 200, { cccs: await listCccs(ctx, {
+				sendJson$2(res, 200, { cccs: await listCccs(ctx, {
 					defaultRoot: root,
 					withRoles: true
 				}) });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15571,21 +15701,26 @@ function registerStatusApi(ctx, opts = {}) {
 				if (req.method === "GET") {
 					const chk = requireCcc(url.searchParams.get("ccc") ?? void 0);
 					if (!chk.ok) {
-						sendJson$3(res, 400, { error: chk.error });
+						sendJson$2(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { readWeixinSettings } = await import("./route-COOFLTpU.js").then((n) => n.c);
 					const { weixinBridgeStatus } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { readWeixinCredential } = await import("./route-f7JlinIt.js").then((n) => n.s);
-					const accounts = (settings.accounts ?? []).map((a) => ({
-						accountId: a.accountId,
-						name: a.name ?? void 0,
-						enabled: a.enabled !== false,
-						bound: readWeixinCredential(chk.root, a.accountId) !== null
-					}));
-					sendJson$3(res, 200, {
+					const { imCredentialBound } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { normalizeAccountChannel } = await import("./accounts-BHQbakUh.js").then((n) => n.t);
+					const accounts = (settings.accounts ?? []).map((a) => {
+						const channel = normalizeAccountChannel(a.channel);
+						return {
+							accountId: a.accountId,
+							name: a.name ?? void 0,
+							enabled: a.enabled !== false,
+							channel,
+							bound: imCredentialBound(chk.root, a.accountId, channel)
+						};
+					});
+					sendJson$2(res, 200, {
 						enabled: settings.enabled === true,
 						botType: settings.botType ?? void 0,
 						accounts,
@@ -15595,22 +15730,22 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$2(res, 405, { error: "method not allowed" });
 					return;
 				}
-				const raw = await readBody$3(req, 131072);
+				const raw = await readBody$2(req, 131072);
 				const body = JSON.parse(raw);
 				const chk = requireCcc(body.ccc);
 				if (!chk.ok) {
-					sendJson$3(res, 400, { error: chk.error });
+					sendJson$2(res, 400, { error: chk.error });
 					return;
 				}
 				const root = chk.root;
 				if (body.action === "login-start") {
-					const { fetchQRCode } = await import("./ilink-DEpmE3yi.js").then((n) => n.a);
+					const { fetchQRCode } = await import("./ilink-BMk2w2KY.js").then((n) => n.a);
 					const { randomUUID } = await import("node:crypto");
 					for (const [key, v] of weixinLogins) if (Date.now() - v.startedAt > WEIXIN_LOGIN_TTL_MS) weixinLogins.delete(key);
-					const { readWeixinSettings } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { readWeixinSettings } = await import("./route-COOFLTpU.js").then((n) => n.c);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15619,7 +15754,7 @@ function registerStatusApi(ctx, opts = {}) {
 						startedAt: Date.now(),
 						polling: false
 					});
-					sendJson$3(res, 200, {
+					sendJson$2(res, 200, {
 						qrcode: qr.qrcode,
 						qrcode_img_content: qr.qrcode_img_content,
 						loginKey
@@ -15628,20 +15763,20 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "remove-account") {
 					if (!body.accountId) {
-						sendJson$3(res, 400, { error: "missing accountId" });
+						sendJson$2(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { removeWeixinAccount } = await import("./route-COOFLTpU.js").then((n) => n.c);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
-					sendJson$3(res, 200, { removed: body.accountId });
+					sendJson$2(res, 200, { removed: body.accountId });
 					return;
 				}
 				if (body.action === "save-routes") {
 					const raw = body.routes ?? [];
 					if (!Array.isArray(raw)) {
-						sendJson$3(res, 400, { error: "invalid routes (expected [{user, trajectory}, ...])" });
+						sendJson$2(res, 400, { error: "invalid routes (expected [{user, trajectory}, ...])" });
 						return;
 					}
 					const routes = [];
@@ -15649,7 +15784,7 @@ function registerStatusApi(ctx, opts = {}) {
 						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)" });
+							sendJson$2(res, 400, { error: "invalid routes (each row needs non-empty user and trajectory)" });
 							return;
 						}
 						routes.push({
@@ -15657,23 +15792,23 @@ function registerStatusApi(ctx, opts = {}) {
 							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);
+					const { saveWeixinRoutes } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { findDirNameByCode } = await import("./profile-BVt84mbi.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})` });
+						sendJson$2(res, 400, { error: `unknown trajectory: ${r.trajectory} (no such trajectory code in ${root})` });
 						return;
 					}
 					saveWeixinRoutes(root, routes);
-					sendJson$3(res, 200, { saved: routes.length });
+					sendJson$2(res, 200, { saved: routes.length });
 					return;
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./route-f7JlinIt.js").then((n) => n.s);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./route-COOFLTpU.js").then((n) => n.c);
 					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
-						sendJson$3(res, 400, { error: "启用前请先扫码绑定至少一个账号" });
+						sendJson$2(res, 400, { error: "启用前请先扫码绑定至少一个账号" });
 						return;
 					}
 					setWeixinEnabled(root, enabled);
@@ -15682,12 +15817,41 @@ function registerStatusApi(ctx, opts = {}) {
 						const { stopCccBridge } = await Promise.resolve().then(() => bridge_exports);
 						stopCccBridge(root);
 					}
-					sendJson$3(res, 200, { enabled });
+					sendJson$2(res, 200, { enabled });
 					return;
 				}
-				sendJson$3(res, 400, { error: `unsupported action: ${body.action ?? ""}` });
+				if (body.action === "add-feishu-account") {
+					const appId = (body.appId ?? "").trim();
+					const appSecret = (body.appSecret ?? "").trim();
+					if (appId === "" || appSecret === "") {
+						sendJson$2(res, 400, { error: "appId 与 appSecret 都必须填（只填一个等于没绑）" });
+						return;
+					}
+					const { readWeixinSettings, upsertWeixinAccount, writeFeishuCredential, nextFeishuAccountId } = await import("./route-COOFLTpU.js").then((n) => n.c);
+					const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
+					const before = readWeixinSettings(root);
+					const accountId = (body.accountId ?? "").trim() !== "" ? body.accountId.trim() : nextFeishuAccountId(before);
+					upsertWeixinAccount(root, {
+						accountId,
+						name: (body.name ?? "").trim() !== "" ? body.name.trim() : void 0,
+						channel: "feishu",
+						enabled: true
+					});
+					writeFeishuCredential(root, accountId, {
+						appId,
+						appSecret
+					});
+					if (before.enabled) syncCccBridge(ctx, root);
+					sendJson$2(res, 200, {
+						accountId,
+						channel: "feishu",
+						saved: true
+					});
+					return;
+				}
+				sendJson$2(res, 400, { error: `unsupported action: ${body.action ?? ""}` });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15698,22 +15862,22 @@ function registerStatusApi(ctx, opts = {}) {
 			try {
 				if (!requireWebUi(req, res, "微信桥配置仅限 WebUI（client 专用）")) return;
 				if (req.method !== "GET") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$2(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const key = new URL(req.url ?? "/", "http://127.0.0.1").searchParams.get("key") ?? "";
 				const login = weixinLogins.get(key);
 				if (!login) {
-					sendJson$3(res, 404, { error: "login not found or expired" });
+					sendJson$2(res, 404, { error: "login not found or expired" });
 					return;
 				}
 				if (Date.now() - login.startedAt > WEIXIN_LOGIN_TTL_MS) {
 					weixinLogins.delete(key);
-					sendJson$3(res, 200, { status: "expired" });
+					sendJson$2(res, 200, { status: "expired" });
 					return;
 				}
-				const { pollQRStatus } = await import("./ilink-DEpmE3yi.js").then((n) => n.a);
-				const { readWeixinSettings } = await import("./route-f7JlinIt.js").then((n) => n.s);
+				const { pollQRStatus } = await import("./ilink-BMk2w2KY.js").then((n) => n.a);
+				const { readWeixinSettings } = await import("./route-COOFLTpU.js").then((n) => n.c);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15722,13 +15886,13 @@ function registerStatusApi(ctx, opts = {}) {
 				switch (status.status) {
 					case "confirmed": {
 						if (!status.bot_token) {
-							sendJson$3(res, 200, {
+							sendJson$2(res, 200, {
 								status: "error",
 								error: "confirmed but no bot_token"
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-f7JlinIt.js").then((n) => n.s);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./route-COOFLTpU.js").then((n) => n.c);
 						const { syncCccBridge } = await Promise.resolve().then(() => bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -15743,7 +15907,7 @@ function registerStatusApi(ctx, opts = {}) {
 						});
 						syncCccBridge(ctx, login.root);
 						weixinLogins.delete(key);
-						sendJson$3(res, 200, {
+						sendJson$2(res, 200, {
 							status: "confirmed",
 							accountId,
 							tokenSaved: true
@@ -15752,14 +15916,14 @@ function registerStatusApi(ctx, opts = {}) {
 					}
 					case "expired":
 						weixinLogins.delete(key);
-						sendJson$3(res, 200, { status: "expired" });
+						sendJson$2(res, 200, { status: "expired" });
 						return;
 					default:
-						sendJson$3(res, 200, { status: status.status ?? "wait" });
+						sendJson$2(res, 200, { status: status.status ?? "wait" });
 						return;
 				}
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15781,7 +15945,7 @@ function registerStatusApi(ctx, opts = {}) {
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
-					sendJson$3(res, 200, {
+					sendJson$2(res, 200, {
 						root,
 						olderThanDays: days,
 						dryRun: true,
@@ -15795,12 +15959,12 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$2(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "会话清理仅限 WebUI（client 专用）")) return;
 				const { result } = performCleanup(root, cutoffDaysAgo(days), liveIds);
-				sendJson$3(res, 200, {
+				sendJson$2(res, 200, {
 					root,
 					olderThanDays: days,
 					dryRun: false,
@@ -15808,7 +15972,7 @@ function registerStatusApi(ctx, opts = {}) {
 					errors: result.errors
 				});
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$2(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15987,7 +16151,7 @@ function loadVoyageHtml(assetPath = voyageAssetPath()) {
 	return readFileSync(assetPath, "utf-8");
 }
 /** 发 JSON（错误分支用；与 surface/http.ts 的 sendJson 同形，但本模块不依赖它，保持零耦合） */
-function sendJson$2(res, status, body) {
+function sendJson$1(res, status, body) {
 	res.statusCode = status;
 	res.setHeader("content-type", "application/json; charset=utf-8");
 	res.end(JSON.stringify(body));
@@ -16005,14 +16169,14 @@ function registerVoyageApi(ctx, opts = {}) {
 		path: VOYAGE_PATH,
 		handler: (req, res) => {
 			if (req.method !== "GET") {
-				sendJson$2(res, 405, { error: "method not allowed" });
+				sendJson$1(res, 405, { error: "method not allowed" });
 				return;
 			}
 			let html;
 			try {
 				html = loadVoyageHtml(opts.assetPath ?? voyageAssetPath());
 			} catch (err) {
-				sendJson$2(res, 500, { error: `voyage asset unavailable: ${err?.message ?? String(err)}` });
+				sendJson$1(res, 500, { error: `voyage asset unavailable: ${err?.message ?? String(err)}` });
 				return;
 			}
 			let root = null;
@@ -16170,7 +16334,7 @@ const HOST_SERVICES = [
 			name: "get",
 			kind: "function"
 		}],
-		impact: "skiff/cheap-worker 无法创建或复用 agent",
+		impact: "轨迹约束/cheap-worker 无法创建或复用 agent",
 		required: true
 	},
 	{
@@ -16593,7 +16757,7 @@ function summarizeHostContract(report) {
 *
 * ## 现状 → 本模块要收掉什么（取证：`…/acc-c4c5-current-state.md` §①/§③ 3.1）
 *
-* 插件自己 spawn 了**三个** node:http 监听器（B 3081 网关 / C 3082 微信发送 / D 3099 Skiff 调试）。
+* 插件自己 spawn 了**三个** node:http 监听器（B 3081 网关 / C 3082 微信发送 / D 3099 轨迹约束调试）。
 * ⚠️ **2026-10-15 变更**：原为四个（含 **E 3100 ACP+问答**），E 已随 owner「砍掉外部问答」令**整面退役**
 * ⇒ 仍保有面 B/C/D 三个；本段保留"当年是四个"的记述，因为下方"两套拆卸"的病史由它解释。
 * 此前四处各写一份同款样板：`createServer` + `server.once('error')` +
@@ -16650,10 +16814,6 @@ var FaceStartCancelled = class extends Error {
 		this.name = "FaceStartCancelled";
 	}
 };
-/** 面是否在监听 */
-function faceActive(name) {
-	return faces.has(name);
-}
 /** 面的实际监听端口（未在监听 → null） */
 function facePort(name) {
 	return faces.get(name)?.handle.port ?? null;
@@ -17240,7 +17400,7 @@ function createDshCookieProvider(connection, authority) {
 /** 面名（C4 块 A：listener 生命周期归 `face-host`） */
 const FACE_GATEWAY = "gateway";
 /** 读取请求体（≤ maxBytes；超限 reject） */
-function readBody$2(req, maxBytes) {
+function readBody$1(req, maxBytes) {
 	return new Promise((resolve, reject) => {
 		let data = "";
 		req.on("data", (chunk) => {
@@ -17367,7 +17527,7 @@ async function startGateway(config, getAccounts, getDshCookie) {
 		const session = authed(req);
 		if (session !== void 0) {
 			if (req.method === "POST" && isWorkspaceCreatePath(url.pathname)) {
-				readBody$2(req, 131072).then((body) => {
+				readBody$1(req, 131072).then((body) => {
 					const { rpcId, path } = parseWorkspaceCreateBody(body);
 					if (!allowWorkspaceCreate) {
 						res.writeHead(403, { "content-type": "application/json" });
@@ -17768,9 +17928,9 @@ function sessionNameFromMdPath(mdPath) {
 * → ②b **权威绑定**（`AGENT_SESSIONS/.bindings.json`，本会话持久绑定）→ ③ surface 首条锚点
 * （events 异常时兜底）。
 *
-* v1.30.13（S142 用户"微信桥 + skiff 会话锚定要准确"，诊断 D4）：**移除**原 ④「全局最新未完成
+* v1.30.13（S142 用户"微信桥 + 轨迹约束会话锚定要准确"，诊断 D4）：**移除**原 ④「全局最新未完成
 * 会话」（`findLatestActiveSessionMd`）。理由（R↓）：④ 是**跨轨迹**猜测——候选①②③全空时，
-* 它会把 rebuild 静默接到 AGENT_SESSIONS 里最新的另一个会话（临时 skiff 会话 persistent=false、
+* 它会把 rebuild 静默接到 AGENT_SESSIONS 里最新的另一个会话（临时 轨迹约束会话 persistent=false、
 * 重启后首条消息前、新会话首条消息都命中该形态），而"接错轨迹"比重建失败危险得多
 * （错误轨迹被继续写入 + 正确轨迹静默丢失）。现在全部候选失败 → 返回 null → 调用方
 * 报错引导用户显式 `cognitive_trajectory use`（响亮失败优于静默接错）。
@@ -19687,234 +19847,16 @@ f.parseInline;
 b.parse;
 x.lex;
 //#endregion
-//#region src/role/skiff/debug.ts
-/** 面名（C4 块 A） */
-const FACE_SKIFF_DEBUG = "skiff-debug";
-/** 监听地址：**只绑 loopback**（本面无认证——仅靠 loopback 挡住外部） */
-const SKIFF_DEBUG_HOST = FACE_PORTS.skiffDebug.host ?? "127.0.0.1";
-function skiffDebugActive() {
-	return faceActive(FACE_SKIFF_DEBUG);
-}
-function readBody$1(req) {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		req.on("data", (c) => chunks.push(c));
-		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-		req.on("error", reject);
-	});
-}
-function sendJson$1(res, status, payload) {
-	const body = JSON.stringify(payload);
-	res.writeHead(status, {
-		"Content-Type": "application/json; charset=utf-8",
-		"Cache-Control": "no-store"
-	});
-	res.end(body);
-}
-function sendHtml(res, html) {
-	res.writeHead(200, {
-		"Content-Type": "text/html; charset=utf-8",
-		"Cache-Control": "no-store"
-	});
-	res.end(html);
-}
-/** 问答页 HTML：CCC 切换器 + 角色下拉 + 输入 + 答案区 + 轨迹区（JS 渲染）+ WebUI 链接 */
-function skiffDebugPage(cccs, defaultRoot, webPort) {
-	const data = jscSafeJsonText(JSON.stringify(cccs).replace(/</g, "\\u003c"));
-	return `<!DOCTYPE html>
-<html lang="zh">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Skiff Debug — CCC cognitive subset roles</title>
-<style>
-  :root { color-scheme: light dark; }
-  body { font-family: system-ui, -apple-system, sans-serif; margin: 0; padding: 24px; background: #f6f7f9; color: #1f2328; }
-  @media (prefers-color-scheme: dark) { body { background: #1a1b1e; color: #e6e6e6; } }
-  main { max-width: 720px; margin: 0 auto; }
-  h1 { font-size: 18px; margin: 0 0 4px; }
-  .sub { opacity: .65; font-size: 13px; margin-bottom: 16px; }
-  .ccc { display: inline-block; padding: 3px 10px; border-radius: 999px; background: rgba(11,168,117,.12); color: #0ba875; font-size: 12px; font-weight: 600; margin-bottom: 12px; word-break: break-all; }
-  @media (prefers-color-scheme: dark) { .ccc { color: #3ddc9a; } }
-  .sessionbar { display: flex; align-items: center; gap: 10px; margin-bottom: 4px; }
-  .session-badge { font-family: ui-monospace, SFMono-Regular, monospace; font-size: 12px; padding: 3px 10px; border-radius: 999px; background: rgba(127,127,127,.12); word-break: break-all; }
-  .session-badge.continued { background: rgba(11,168,117,.12); color: #0ba875; }
-  @media (prefers-color-scheme: dark) { .session-badge.continued { color: #3ddc9a; } }
-  button.ghost { background: transparent; color: #57606a; border: 1px solid #d0d7de; padding: 4px 12px; font-size: 12px; border-radius: 8px; cursor: pointer; margin-top: 0; }
-  @media (prefers-color-scheme: dark) { button.ghost { color: #8b949e; border-color: #3a3d42; } }
-  button.ghost:hover { background: rgba(127,127,127,.1); }
-  label { font-size: 13px; font-weight: 600; display: block; margin: 12px 0 4px; }
-  select, textarea { width: 100%; box-sizing: border-box; padding: 8px 10px; border-radius: 8px; border: 1px solid #d0d7de; background: #fff; color: inherit; font-size: 14px; }
-  @media (prefers-color-scheme: dark) { select, textarea { background: #26282c; border-color: #3a3d42; } }
-  textarea { min-height: 72px; resize: vertical; }
-  button { margin-top: 12px; padding: 9px 18px; border-radius: 8px; border: 0; background: #0ba875; color: #fff; font-size: 14px; font-weight: 600; cursor: pointer; }
-  button:disabled { opacity: .55; cursor: wait; }
-  #answer { background: #fff; border: 1px solid #d0d7de; border-radius: 8px; padding: 12px; margin-top: 16px; font-size: 14px; line-height: 1.6; min-height: 48px; word-break: break-word; }
-  @media (prefers-color-scheme: dark) { #answer { background: #26282c; border-color: #3a3d42; } }
-  /* Markdown 渲染（v1.25.8）：代码/标题/列表/引用/think 折叠 */
-  #answer p { margin: 6px 0; }
-  #answer h1, #answer h2, #answer h3 { margin: 12px 0 6px; font-size: 15px; line-height: 1.4; }
-  #answer h1 { font-size: 17px; }
-  #answer code { background: rgba(127,127,127,.14); border-radius: 4px; padding: 1px 5px; font-size: 13px; font-family: ui-monospace, SFMono-Regular, monospace; }
-  #answer pre { background: rgba(127,127,127,.1); border-radius: 8px; padding: 10px 12px; overflow-x: auto; margin: 8px 0; }
-  #answer pre code { background: none; padding: 0; font-size: 13px; line-height: 1.5; }
-  #answer ul, #answer ol { margin: 6px 0; padding-left: 22px; }
-  #answer li { margin: 2px 0; }
-  #answer blockquote { margin: 6px 0; padding: 2px 12px; border-left: 3px solid rgba(127,127,127,.35); opacity: .88; }
-  #answer a { color: #0ba875; text-decoration: underline; }
-  details.think { margin: 8px 0; border: 1px solid rgba(210,153,34,.4); border-radius: 8px; background: rgba(210,153,34,.06); }
-  details.think summary { cursor: pointer; padding: 6px 10px; font-size: 12px; color: #d29922; font-weight: 600; user-select: none; list-style-position: inside; }
-  details.think summary:hover { opacity: .8; }
-  details.think .think-body { padding: 2px 12px 10px; font-size: 13px; opacity: .78; white-space: normal; }
-  #cognitiveTrajectory { margin-top: 12px; font-size: 13px; }
-  .t-entry { border-left: 2px solid #d0d7de; padding: 6px 10px; margin: 6px 0; border-radius: 0 6px 6px 0; background: rgba(127,127,127,.06); white-space: pre-wrap; word-break: break-word; }
-  .t-user { border-left-color: #0ba875; }
-  .t-tool { border-left-color: #d29922; opacity: .85; font-family: ui-monospace, monospace; font-size: 12px; }
-  .t-role { font-weight: 600; font-size: 11px; text-transform: uppercase; letter-spacing: .04em; opacity: .6; margin-bottom: 2px; }
-  .muted { opacity: .6; font-size: 13px; }
-  a { color: #0ba875; }
-  .err { color: #cf222e; white-space: pre-wrap; }
-</style>
-</head>
-<body>
-<main>
-  <h1>Skiff Debug</h1>
-  <div class="sub">宁静号轨迹的子集角色问答页（实验性）。可切换 CCC；同一会话可追问，点「新对话」另起一条；回答在服务端渲染，think 块折叠。</div>
-  <div class="ccc" id="cccBadge"></div>
-  <div class="sessionbar">
-    <span id="sessionBadge" class="session-badge muted">（新会话）</span>
-    <button id="newChat" type="button" class="ghost">新对话</button>
-  </div>
-  <label for="ccc">认知容器</label>
-  <select id="ccc"></select>
-  <label for="role">角色</label>
-  <select id="role"></select>
-  <label for="q">问题</label>
-  <textarea id="q" placeholder="向该角色提问…（追问直接继续输入）"></textarea>
-  <button id="ask">提问</button>
-  <div id="answer" class="muted">等待提问…</div>
-  <div id="cognitiveTrajectory"></div>
-  <p class="muted"><a href="${`http://127.0.0.1:${webPort}`}" target="_blank" rel="noopener">在 dsh WebUI 查看完整会话</a>（会话列表搜索 sessionId；WebUI 有完整交互）</p>
-</main>
-<script id="skiff-data" type="application/json" data-default="${escapeHtml(defaultRoot)}">${data}<\/script>
-<script>
-const CCCS = JSON.parse(document.getElementById('skiff-data').textContent)
-const defaultRoot = document.getElementById('skiff-data').dataset.default
-const cccSel = document.getElementById('ccc')
-const roleSel = document.getElementById('role')
-const badge = document.getElementById('cccBadge')
-const sessionBadge = document.getElementById('sessionBadge')
-const newChatBtn = document.getElementById('newChat')
-const btn = document.getElementById('ask')
-const answer = document.getElementById('answer')
-const traj = document.getElementById('cognitiveTrajectory')
-const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]))
-let sessionId = ''
-function shortId(id) { return id.length > 24 ? id.slice(0, 18) + '…' + id.slice(-6) : id }
-function renderSessionBadge() {
-  sessionBadge.textContent = sessionId ? '会话 ' + shortId(sessionId) + '（追问续接）' : '（新会话）'
-  sessionBadge.className = 'session-badge' + (sessionId ? ' continued' : '')
-}
-function newConversation() {
-  sessionId = ''
-  renderSessionBadge()
-  answer.className = 'muted'
-  answer.textContent = '已开启新对话'
-  traj.innerHTML = ''
-  document.getElementById('q').value = ''
-}
-function currentCcc() {
-  return CCCS.find((c) => c.root === cccSel.value) || (CCCS[0] || { root: '', name: '', roles: [] })
-}
-function fillCccs() {
-  cccSel.innerHTML = CCCS.map((c) => {
-    const n = c.roles.length
-    return '<option value="' + esc(c.root) + '">' + esc(c.name) + (n ? ' (' + n + ' 角色)' : ' (无角色)') + '</option>'
-  }).join('') || '<option value="">(未发现 CCC)</option>'
-  if (defaultRoot) cccSel.value = CCCS.some((c) => c.root === defaultRoot) ? defaultRoot : (CCCS[0] && CCCS[0].root)
-  fillRoles()
-}
-function fillRoles() {
-  const c = currentCcc()
-  badge.textContent = 'CCC: ' + c.root
-  roleSel.innerHTML = (c.roles && c.roles.length)
-    ? c.roles.map((r) => '<option value="' + esc(r) + '">' + esc(r) + '</option>').join('')
-    : '<option value="">(未配置角色)</option>'
-}
-cccSel.addEventListener('change', () => { fillRoles(); newConversation() })
-roleSel.addEventListener('change', () => newConversation())
-newChatBtn.addEventListener('click', newConversation)
-fillCccs()
-renderSessionBadge()
-btn.addEventListener('click', async () => {
-  const c = currentCcc()
-  const role = roleSel.value
-  const q = document.getElementById('q').value.trim()
-  if (!c.root || !role || !q) { answer.className = 'err'; answer.textContent = '请选择认知容器与角色并输入问题'; return }
-  btn.disabled = true
-  answer.className = 'muted'
-  answer.textContent = '运行中…'
-  traj.innerHTML = ''
-  try {
-    const res = await fetch('/ask', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ ccc: c.root, role, question: q, sessionId: sessionId || undefined }) })
-    const data = await res.json()
-    if (!res.ok) {
-      // 会话不可恢复/绑定不匹配 → 前端清空 sessionId 重建（用户拍板：切换即新对话）
-      sessionId = ''
-      renderSessionBadge()
-      throw new Error(data.error || ('HTTP ' + res.status))
-    }
-    answer.className = ''
-    answer.innerHTML = data.answer_html || esc(data.answer || '') || '（空回答）'
-    sessionId = data.sessionId || sessionId
-    renderSessionBadge()
-    renderCognitiveTrajectory(data.cognitiveTrajectory || [], data.sessionId || '')
-  } catch (err) {
-    answer.className = 'err'
-    answer.textContent = String(err.message || err)
-  } finally {
-    btn.disabled = false
-  }
-})
-function renderCognitiveTrajectory(entries, sessionId) {
-  if (entries.length === 0) { traj.innerHTML = '<div class="muted">（本轮无轨迹）</div>'; return }
-  traj.innerHTML = '<div class="sub">本轮轨迹 · ' + esc(sessionId) + '</div>' + entries.map((e) => {
-    const cls = e.role === 'user' ? 't-user' : (e.role === 'tool' ? 't-tool' : '')
-    const role = e.role === 'tool' ? 'tool' + (e.tool ? ' · ' + esc(e.tool) : '') : e.role
-    return '<div class="t-entry ' + cls + '"><div class="t-role">' + role + '</div>' + esc(e.text) + '</div>'
-  }).join('')
-}
-<\/script>
-</body>
-</html>`;
-}
-function escapeHtml(s) {
-	return s.replace(/[&<>"']/g, (c) => ({
-		"&": "&amp;",
-		"<": "&lt;",
-		">": "&gt;",
-		"\"": "&quot;",
-		"'": "&#39;"
-	})[c] ?? c);
-}
+//#region src/surface/text.ts
 /**
-* JSC (Safari/iOS) JSON.parse 快速路径正则兼容化（v1.26.9，S142 调研定稿）。
-*
-* 背景：WebKit bug 200190「JavaScriptCore's Regex can't match the content」——JSC 的
-* JSON.parse 用**内部正则**预校验字符串；内容含**原始** `\u2028`（行分隔符）/`\u2029`
-* （段分隔符）时正则无法匹配 → 对**合法 JSON** 也抛
-* `SyntaxError: The string did not match the expected pattern`（sentry-javascript #2487 同源）。
-* JSON.stringify **不转义** `\u2028`/`\u2029`/`\uFEFF`（它们都是合法 JSON 字符串字符）→
-* 在 JSON **文本层**把它们替换为 `\uXXXX` 转义序列：JSON.parse 后语义完全一致（还原原字符），
-* 且 JSC 正则看到的是常规 ASCII 转义（与 JSON.stringify 对控制字符的输出同形态，安全）。
-*
-* 3099 调试页客户端 `await res.json()` 与页面内嵌 JSON 均需此兼容层
-* ——iOS Safari 用户实测"复杂回答"触发。（原同批还列了 3100 问答页，该面已退役，2026-10-15）
-*
-* @param jsonText JSON.stringify 的输出文本；原地等价替换，返回 JSC 安全文本
+* 剥离 `<think>…</think>` 块（v1.27.1，微信桥用户反馈："过微信桥回复给用户的消息，
+* 要去掉 think 标签，用户不应看到"）。复用 extractThinkBlocks 状态机（v1.26.8，
+* 弃正则）——提取后**只保留正文**（占位符替换为空，think 内容丢弃），
+* 未闭合 think 优雅截断。适用于纯文本输出面（微信等不支持 think 折叠的通道）。
 */
-function jscSafeJsonText(jsonText) {
-	return jsonText.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029").replace(/\uFEFF/g, "\\uFEFF");
+function stripThink(raw) {
+	const { body } = extractThinkBlocks(raw);
+	return body.replace(/\u0001T(\d+)\u0001/g, "");
 }
 /**
 * 提取 `<think>…</think>` 块（v1.26.8：**状态机扫描，弃正则**——用户批评"老用正则不是个办法"）。
@@ -19992,140 +19934,6 @@ function matchCloseThink(s, contentStart) {
 	}
 	return -1;
 }
-/**
-* Markdown 渲染（v1.25.9，正经库 marked 服务端渲染——替代手写正则渲染器，S142 用户要求）：
-* ① 提取 `<think>…</think>` 块（v1.26.8 状态机扫描，占位符 \u0001T<idx>\u0001）
-* ② 正文与 think 内容**先 escapeHtml 再 marked.parse**（GFM + breaks）——markdown 语法不受
-*    转义影响，原始 HTML 注入被消除（安全）；代码块内 `<` 显示为实体（可接受）
-* ③ think 占位符：默认还原为 `<details class="think">` 折叠卡（🧠 思考过程，默认收起）；
-*    **hideThink=true（v1.26.4，public 口）→ 直接移除**（思考过程对普通用户不展示）
-* @param hideThink 为 true 时 `<think>` 内容完全不渲染（public 问答页体验）
-*/
-function renderSkiffMarkdown(raw, hideThink = false) {
-	const { body, thinks } = extractThinkBlocks(raw);
-	const parsed = f.parse(escapeHtml(body), {
-		breaks: true,
-		gfm: true
-	});
-	return (typeof parsed === "string" ? parsed : "").replace(/\u0001T(\d+)\u0001/g, (_m, idx) => {
-		if (hideThink) return "";
-		const inner = thinks[Number(idx)] ?? "";
-		const innerHtml = inner === "" ? "" : f.parse(escapeHtml(inner), {
-			breaks: true,
-			gfm: true
-		});
-		return `<details class="think"><summary>🧠 思考过程</summary><div class="think-body">${typeof innerHtml === "string" ? innerHtml : ""}</div></details>`;
-	});
-}
-/**
-* 剥离 `<think>…</think>` 块（v1.27.1，微信桥用户反馈："过微信桥回复给用户的消息，
-* 要去掉 think 标签，用户不应看到"）。复用 extractThinkBlocks 状态机（v1.26.8，
-* 弃正则）——提取后**只保留正文**（占位符替换为空，think 内容丢弃），
-* 未闭合 think 优雅截断。适用于纯文本输出面（微信等不支持 think 折叠的通道）。
-*/
-function stripThink(raw) {
-	const { body } = extractThinkBlocks(raw);
-	return body.replace(/\u0001T(\d+)\u0001/g, "");
-}
-/**
-* 本面的规格（C4 块 A/④：**只提供** name/port/host/enabled/handler）。
-* 路由/鉴权/HTML 全部仍归本模块的 {@link handle}（面宿主不介入面语义）。
-*/
-function skiffDebugSpec(ctx, root, port, webPort) {
-	return {
-		name: FACE_SKIFF_DEBUG,
-		port,
-		host: SKIFF_DEBUG_HOST,
-		enabled: () => readSimpleSettings().skiffEnabled,
-		handler: (req, res) => handle(ctx, root, webPort, req, res)
-	};
-}
-/**
-* 启动调试问答服务（单实例；重复启动幂等返回既有实例）。
-*
-* **CCC 绑定（v1.25.2 用户指出）**：服务绑定一个默认 CCC root（调用方 resolveSkiffRoot
-* 解析：live 会话中**含 skiff.roles 的 CCC 优先**）；v1.25.4 起页面可**手工切换**到
-* 其它候选 CCC（live 会话发现的全部 CCC）；角色配置**每次请求实时读取**（不缓存快照）。
-*
-* C4 块 A：listener 的创建/监听/错误/端口占用/关闭归 `face-host`（本函数只提供规格 + 记日志）。
-*
-* @param root 默认绑定的 CCC 根（首次加载选中；角色配置读取 + skiff agent cwd）
-* @param port 调试端口（仅 127.0.0.1）
-* @param webPort 主 WebUI 端口（WebUI 链接）
-*/
-async function startSkiffDebugServer(ctx, root, port, webPort) {
-	if (skiffDebugActive()) return;
-	const handle = await startFace(skiffDebugSpec(ctx, root, port, webPort));
-	console.log(`[serenity-hooks] ✓ Skiff 调试问答页: http://127.0.0.1:${handle.port}（默认 CCC: ${root}，WebUI: ${webPort}）`);
-}
-function stopSkiffDebugServer() {
-	stopFace(FACE_SKIFF_DEBUG);
-}
-async function handle(ctx, defaultRoot, webPort, req, res) {
-	try {
-		const url = (req.url ?? "/").split("?")[0] ?? "/";
-		if (req.method === "GET" && url === "/") {
-			sendHtml(res, skiffDebugPage(await listCccs(ctx, {
-				defaultRoot,
-				withRoles: true
-			}), defaultRoot, webPort));
-			return;
-		}
-		if (req.method === "POST" && url === "/ask") {
-			let body;
-			try {
-				const parsed = JSON.parse(await readBody$1(req));
-				if (parsed === null || typeof parsed !== "object") throw new Error("not an object");
-				body = parsed;
-			} catch {
-				sendJson$1(res, 400, { error: "invalid JSON body" });
-				return;
-			}
-			const ccc = typeof body.ccc === "string" && body.ccc !== "" ? body.ccc : defaultRoot;
-			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 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()) {
-				sendJson$1(res, 400, { error: "empty question" });
-				return;
-			}
-			let agent;
-			let continued = false;
-			if (sessionId) {
-				const info = skiffSessionInfo(sessionId);
-				const live = getSkiffAgent(sessionId);
-				if (!info || !live) {
-					sendJson$1(res, 400, { error: "session is not recoverable (process restarted or session unknown) — start a new conversation" });
-					return;
-				}
-				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, 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
-			});
-			return;
-		}
-		sendJson$1(res, 404, { error: "not found" });
-	} catch (err) {
-		sendJson$1(res, 500, { error: err?.message ?? String(err) });
-	}
-}
 //#endregion
 //#region src/guard/filter.ts
 /**
@@ -20168,9 +19976,9 @@ const MECHANISM_WORDS = [
 	"拦截缝",
 	"装配层",
 	"acp-core",
-	"skiff-core",
-	"skiff-registry",
-	"skiff-role",
+	"trajectory-session",
+	"trajectory-window",
+	"trajectory-constraint",
 	"output-guard"
 ];
 /**
@@ -20270,20 +20078,20 @@ const rebukeStates = /* @__PURE__ */ new Map();
 /**
 * 外部面会话判定（v1.26.3 用户拍板：仅外部面检测，本地维护会话豁免）。
 *
-* 🔴 **2026-10-19 判据更换**：skiff 那一条从「sessionId 前缀 `skiff-`」改为
-* **「该会话绑定的轨迹有 `skiff.json`」**（owner 重做令）。前缀判据在新模型下是
-* **错的**——skiff 的身份是轨迹，不再由 id 前缀表达；继续用前缀会漏掉所有
-* "挂在 skiff 轨迹上、但 id 不带前缀"的会话（典型 = 微信桥按轨迹派生的会话 id）。
+* 🔴 **2026-10-19 判据更换**：轨迹约束那一条从「sessionId 前缀 `轨迹约束-`」改为
+* **「该会话绑定的轨迹有 `trajectory-constraint.json`」**（owner 重做令）。前缀判据在新模型下是
+* **错的**——轨迹约束的身份是轨迹，不再由 id 前缀表达；继续用前缀会漏掉所有
+* "挂在 轨迹约束轨迹上、但 id 不带前缀"的会话（典型 = 微信桥按轨迹派生的会话 id）。
 *
-* ⚠️ `rebuild-` 前缀保留（那是另一件事：重建会话同属对外面，与 skiff 无关）；
+* ⚠️ `rebuild-` 前缀保留（那是另一件事：重建会话同属对外面，与 轨迹约束 无关）；
 * `acp-` 分支保留但**已是死判据**（无生产者；面 E 已于 2026-10-15 退役）——
 * 理由与"为何不擅自删"见文件头注释。
 */
 function isExternalFaceSession(sessionId, root) {
 	if (!sessionId) return false;
-	return isSkiffSession(root, sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
+	return isTrajectoryConstrained(root, sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
 }
-/** 读会话最后一个 assistant/message 文本（skiff-core 同款）
+/** 读会话最后一个 assistant/message 文本（trajectory-session 同款）
 *  **v1.63.3 起唯一的导出理由消失**：原导出是给 `unattended-seam.ts` 复用的（D77），
 *  该文件已随无人值守功能整条退役 ⇒ 现只有本模块自己用（`isLeak` 的调用点）。
 *  ⚠️ 保持 `export` 无害（它有测试覆盖，且将来"同一读法只留一份"的纪律仍成立），
@@ -20597,188 +20405,63 @@ function appendHumanChannelAudit(event) {
 		})}\n`, "utf-8");
 	} catch {}
 }
-const manualSessions = /* @__PURE__ */ new Map();
-/**
-* 本轮是否已成功发送（**由桥在每轮开始时清空** `clearSentThisTurn`；闸门只置位不清空——
-* v1.30.17 起桥要在 `askSkiff` 返回后读它决定是否兜底，故 turn-stopping 不再结算清空）。
-*/
-const sentThisTurn = /* @__PURE__ */ new Set();
-/** 连续打回计数（成功发送即清零） */
-const rebukeCounts = /* @__PURE__ */ new Map();
-/** 闸门是否装配成功（v1.30.17：桥据此判断能否信任"未发送"这一判定——未装配时不兜底，防重复发送） */
-let guardActive = false;
-/** 桥：登记手动模式会话（每轮 incoming 都调用，幂等覆盖） */
-function noteManualOutputSession(sessionId, session) {
-	if (typeof sessionId !== "string" || sessionId === "") return;
-	manualSessions.set(sessionId, session);
-}
-/** 桥：非手动模式 / 会话失效 → 注销（闸门随之失效，零干预） */
-function forgetManualOutputSession(sessionId) {
-	manualSessions.delete(sessionId);
-	sentThisTurn.delete(sessionId);
-	rebukeCounts.delete(sessionId);
-}
-/** 本轮是否已成功发送（测试/诊断用；桥在每轮结束时读它决定是否兜底） */
-function hasSentThisTurn(sessionId) {
-	return sentThisTurn.has(sessionId);
-}
-/**
-* 桥：**每轮开始时**清空本会话的"已发送"标记（turn 边界由桥掌握——v1.30.17）。
-* 闸门侧不再于 turn-stopping 结算清空，否则桥读不到本轮结果、无法兜底。
-*/
-function clearSentThisTurn(sessionId) {
-	sentThisTurn.delete(sessionId);
-}
-/** 闸门是否装配成功（未装配 → 桥不做兜底：宁可静默也不冒重复发送的风险） */
-function isWeixinOutputGuardActive() {
-	return guardActive;
-}
-/** 从 agent / 会话对象取会话 id（形状宽容） */
-function sessionIdOf$1(value) {
-	const v = value;
-	const id = v?.session?.id ?? v?.id;
-	return typeof id === "string" && id !== "" ? id : null;
-}
+//#endregion
+//#region src/im/hook.ts
 /**
-* 工具调用是否为「成功的微信发送」。
+* im/hook.ts — 微信桥消息记录 hook（F4c-3 扩展，v1.27.13 用户需求）
 *
-* v1.31.0 起有两种合法形态（标记与闸门同时认，迁移期并存）：
-* - `im-bridge({channel:"weixin", action:"send"|"send-file", …})` —— ACC 工具（推荐）
-* - `msm("weixin-send", ["send"|"send-file", …])` —— CCC MSM（v1.30.x 通道，逐步退役）
+* 需求：微信桥发生的所有消息记录，支持 hook——允许 CCC 通过自行编写 hook
+* 脚本进行**持久性保存**（存哪/存成什么/是否入库，全归 CCC 决定——ACC 不绑定存储）。
+*
+* 设计（docs/weixin-message-hook-design.md v0.1，三项拍板 H1~H6）：
+* - **双向触发**（H1）：incoming（用户→bot，媒体落盘后）+ outgoing（bot→用户，发送成功后）
+* - **脚本 + stdin JSON**（H2）：serenity.json weixin.hook = CCC 根相对脚本路径；
+*   每次消息事件 spawn 一次，事件 JSON 单行经 stdin 传入（bun 优先 / node 兜底，biasProvider 先例）
+* - **旁路容忍**（H3）：异步 fire-and-forget + 超时 kill + 失败仅日志——微信桥可靠性不受影响
+* - **不含会话凭据**（H5）：事件只有记录所需字段（无 context_token / bot_token——最小暴露面）
+*
+* 定位：Mech 纯逻辑（事件构造纯函数 + 执行器确定性），可独立单测。
 */
-function isSuccessfulWeixinSend(exec, result) {
-	const e = exec;
-	if (result?.isError === true) return false;
-	const args = e?.arguments;
-	if (e?.name === "im-bridge") {
-		if ((typeof args?.channel === "string" ? args.channel : "") !== "weixin") return false;
-		const action = typeof args?.action === "string" ? args.action : "";
-		return action === "send" || action === "send-file";
-	}
-	if (e?.name === "msm") return args?.name === "weixin-send";
-	return false;
+/** hook 执行超时（旁路记录足够；超时 kill 防挂死脚本） */
+const WEIXIN_HOOK_TIMEOUT_MS = 15e3;
+/** hook stderr/stdout 日志截断（防脚本刷屏） */
+const HOOK_LOG_MAX = 500;
+/** 构造 incoming 事件对象（纯函数，可测） */
+function buildIncomingHookEvent(input) {
+	return {
+		event: "incoming",
+		ts: Date.now(),
+		cccRoot: input.cccRoot,
+		accountId: input.accountId,
+		userId: input.userId,
+		sessionId: input.sessionId,
+		role: input.role,
+		message: {
+			text: input.text,
+			media: input.media
+		}
+	};
 }
-/** 打回消息（机制事实 + 标记；怎么做由 CCC 角色提示词定义） */
-function buildManualOutputRebuke(session) {
-	return [
-		"[serenity:weixin-manual-output] no send detected in this turn — the user has received NOTHING.",
-		`ccc=${session.root} account=${session.accountId} user=${session.userId}`,
-		`im-bridge({channel:"weixin", action:"send", account:"${session.accountId}", user:"${session.userId}", text:"<回复>"})`
-	].join("\n");
+/** 构造 outgoing 事件对象（纯函数，可测） */
+function buildOutgoingHookEvent(input) {
+	return {
+		event: "outgoing",
+		ts: Date.now(),
+		cccRoot: input.cccRoot,
+		accountId: input.accountId,
+		userId: input.userId,
+		sessionId: input.sessionId,
+		role: input.role,
+		reply: input.reply,
+		...input.source && input.source !== "reply" ? { source: input.source } : {},
+		...input.file ? { file: input.file } : {}
+	};
 }
 /**
-* 装配闸门（index.ts apply 调用）。
-* 只对**已登记的手动模式会话**生效——其他会话（主舱/其他 skiff 会话）零干预。
-*/
-function registerWeixinOutputGuard(ctx) {
-	try {
-		ctx.on("tools/post-execute", async (exec, result, next) => {
-			const downstream = await next();
-			try {
-				const sessionId = sessionIdOf$1(exec?.agent);
-				if (sessionId && manualSessions.has(sessionId) && isSuccessfulWeixinSend(exec, result)) {
-					sentThisTurn.add(sessionId);
-					rebukeCounts.delete(sessionId);
-				}
-			} catch {}
-			return downstream;
-		});
-	} catch {
-		console.warn("[serenity-hooks] ✗ weixin 输出闸门未装配：tools/post-execute 不可用");
-		return;
-	}
-	try {
-		ctx.on("agent/turn-stopping", (payload) => {
-			const agent = payload?.agent;
-			if (!agent) return;
-			const sessionId = sessionIdOf$1(agent);
-			if (!sessionId) return;
-			const session = manualSessions.get(sessionId);
-			if (!session) return;
-			if (sentThisTurn.has(sessionId)) return;
-			const count = (rebukeCounts.get(sessionId) ?? 0) + 1;
-			if (count > 2) {
-				rebukeCounts.delete(sessionId);
-				console.warn(`[serenity-hooks] ✗ weixin 输出闸门：连续 2 次打回后仍未发送（session=${sessionId}, role=${session.role}）——本轮用户将收不到 agent 自己发的消息`);
-				return;
-			}
-			rebukeCounts.set(sessionId, count);
-			try {
-				agent.steer(createUserMessage({
-					content: [{
-						type: "text",
-						text: buildManualOutputRebuke(session)
-					}],
-					source: PLUGIN_SOURCE
-				}));
-				console.log(`[serenity-hooks] weixin 输出闸门：打回 ${count}/2（session=${sessionId}, turn=${payload.turn ?? "?"}）`);
-			} catch (error) {
-				console.warn(`[serenity-hooks] ✗ weixin 输出闸门 steer 失败: ${String(error?.message ?? error)}`);
-			}
-		});
-	} catch {
-		console.warn("[serenity-hooks] ✗ weixin 输出闸门未装配：agent/turn-stopping 不可用");
-		return;
-	}
-	guardActive = true;
-}
-//#endregion
-//#region src/im/hook.ts
-/**
-* im/hook.ts — 微信桥消息记录 hook（F4c-3 扩展，v1.27.13 用户需求）
-*
-* 需求：微信桥发生的所有消息记录，支持 hook——允许 CCC 通过自行编写 hook
-* 脚本进行**持久性保存**（存哪/存成什么/是否入库，全归 CCC 决定——ACC 不绑定存储）。
-*
-* 设计（docs/weixin-message-hook-design.md v0.1，三项拍板 H1~H6）：
-* - **双向触发**（H1）：incoming（用户→bot，媒体落盘后）+ outgoing（bot→用户，发送成功后）
-* - **脚本 + stdin JSON**（H2）：serenity.json weixin.hook = CCC 根相对脚本路径；
-*   每次消息事件 spawn 一次，事件 JSON 单行经 stdin 传入（bun 优先 / node 兜底，biasProvider 先例）
-* - **旁路容忍**（H3）：异步 fire-and-forget + 超时 kill + 失败仅日志——微信桥可靠性不受影响
-* - **不含会话凭据**（H5）：事件只有记录所需字段（无 context_token / bot_token——最小暴露面）
-*
-* 定位：Mech 纯逻辑（事件构造纯函数 + 执行器确定性），可独立单测。
-*/
-/** hook 执行超时（旁路记录足够；超时 kill 防挂死脚本） */
-const WEIXIN_HOOK_TIMEOUT_MS = 15e3;
-/** hook stderr/stdout 日志截断（防脚本刷屏） */
-const HOOK_LOG_MAX = 500;
-/** 构造 incoming 事件对象（纯函数，可测） */
-function buildIncomingHookEvent(input) {
-	return {
-		event: "incoming",
-		ts: Date.now(),
-		cccRoot: input.cccRoot,
-		accountId: input.accountId,
-		userId: input.userId,
-		sessionId: input.sessionId,
-		role: input.role,
-		message: {
-			text: input.text,
-			media: input.media
-		}
-	};
-}
-/** 构造 outgoing 事件对象（纯函数，可测） */
-function buildOutgoingHookEvent(input) {
-	return {
-		event: "outgoing",
-		ts: Date.now(),
-		cccRoot: input.cccRoot,
-		accountId: input.accountId,
-		userId: input.userId,
-		sessionId: input.sessionId,
-		role: input.role,
-		reply: input.reply,
-		...input.source && input.source !== "reply" ? { source: input.source } : {},
-		...input.file ? { file: input.file } : {}
-	};
-}
-/**
-* 执行一次 hook：spawn CCC 根脚本，事件 JSON 单行经 stdin 传入。
-* 旁路容忍（H3）：超时 kill / 非 0 退出 / spawn 失败 → 仅日志返回 {ok:false}，绝不抛（不阻断微信桥）。
-* 路径逃逸校验：脚本必须解析在 CCC 根内（resolveInside——resolveInside 抛错也吞为 {ok:false}）。
-* 脚本缺失 → {ok:false}（配置了但未实现——日志提示；不视为异常）。
+* 执行一次 hook：spawn CCC 根脚本，事件 JSON 单行经 stdin 传入。
+* 旁路容忍（H3）：超时 kill / 非 0 退出 / spawn 失败 → 仅日志返回 {ok:false}，绝不抛（不阻断微信桥）。
+* 路径逃逸校验：脚本必须解析在 CCC 根内（resolveInside——resolveInside 抛错也吞为 {ok:false}）。
+* 脚本缺失 → {ok:false}（配置了但未实现——日志提示；不视为异常）。
 */
 async function runWeixinHook(root, hookRel, event, timeoutMs = WEIXIN_HOOK_TIMEOUT_MS) {
 	let scriptAbs;
@@ -20882,31 +20565,6 @@ function invokeWeixinHook(root, hookRel, event) {
 	return activeRunner(root, hookRel, event);
 }
 //#endregion
-//#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;
@@ -20980,138 +20638,145 @@ function installWeixinAccountImpl(d) {
 	setWeixinLoopDeps(d);
 	registerImAccountImpl(weixinAccountImpl);
 }
-//#endregion
-//#region src/im/bridge.ts
-var bridge_exports = /* @__PURE__ */ __exportAll({
-	handleIncoming: () => handleIncoming,
-	handleMachineIncoming: () => handleMachineIncoming,
-	manualOutputFallbackNeeded: () => manualOutputFallbackNeeded,
-	registerWeixinBridge: () => registerWeixinBridge,
-	resolveWeixinAccount: () => resolveWeixinAccount,
-	sendProactiveText: () => sendProactiveText,
-	stopAllBridges: () => stopAllBridges,
-	stopCccBridge: () => stopCccBridge,
-	syncCccBridge: () => syncCccBridge,
-	syncHumanChannel: () => syncHumanChannel,
-	weixinBridgeStatus: () => weixinBridgeStatus
-});
-const bridges = /* @__PURE__ */ new Map();
+const manualSessions = /* @__PURE__ */ new Map();
 /**
-* 🔴 **机器级 poller 的"根"哨兵**（P0-3 A）—— 它**不是一个目录**。
-*
-* 机器级 poller **不属于任何 CCC**（这正是"上移 ACC 层"的含义：谁轮询不再由 CCC 数量决定）。
-* 用途有二：① `runAccountLoop` 的 `root` 形参在机器级模式下不被使用，传它以示"无根"；
-* ② 归属表（`im/inbound.ts`）按 root 区分拥有者 ⇒ 机器级用这个哨兵值，
-*    与任何**真实** CCC 根都不会撞（真根一律是绝对路径）。
+* 本轮是否已成功发送（**由桥在每轮开始时清空** `clearSentThisTurn`；闸门只置位不清空——
+* v1.30.17 起桥要在 `askTrajectory` 返回后读它决定是否兜底，故 turn-stopping 不再结算清空）。
 */
-const MACHINE_SCOPE = "<machine>";
-/** 机器级 poller（账号 id → 循环）。与 `bridges` **互斥**：同一时刻只有一种模式在跑。 */
-const machineLoops = /* @__PURE__ */ new Map();
-/** 媒体大小上限（M6：20MB，对齐 vlm-describe；超限降级告知不落盘） */
-const MEDIA_MAX_BYTES = 20971520;
-/** typing_ticket 缓存（每 (accountId, fromUserId)；getconfig 一次后续复用——对齐参考实现 typingTicketCache） */
-const typingTicketByUser = /* @__PURE__ */ new Map();
-function typingCacheKey(accountId, fromUserId) {
-	return `${accountId}|${fromUserId}`;
+const sentThisTurn = /* @__PURE__ */ new Set();
+/** 连续打回计数（成功发送即清零） */
+const rebukeCounts = /* @__PURE__ */ new Map();
+/** 闸门是否装配成功（v1.30.17：桥据此判断能否信任"未发送"这一判定——未装配时不兜底，防重复发送） */
+let guardActive = false;
+/** 桥：登记手动模式会话（每轮 incoming 都调用，幂等覆盖） */
+function noteManualOutputSession(sessionId, session) {
+	if (typeof sessionId !== "string" || sessionId === "") return;
+	manualSessions.set(sessionId, session);
 }
-/** 处理开始：getconfig（无缓存时）→ sendtyping status=1（微信侧显示"正在输入..."）。
-*  任何失败静默（typing 不影响主流程——对齐参考实现 typingCallbacks try/catch 吞错）。 */
-async function sendTypingStart(cred, accountId, fromUserId, contextToken) {
-	try {
-		const key = typingCacheKey(accountId, fromUserId);
-		let ticket = typingTicketByUser.get(key);
-		if (!ticket) {
-			ticket = (await getConfig({
-				baseUrl: cred.baseUrl,
-				token: cred.token,
-				ilinkUserId: fromUserId,
-				contextToken: contextToken ?? ""
-			})).typing_ticket;
-			if (ticket) typingTicketByUser.set(key, ticket);
-		}
-		if (!ticket) return;
-		await sendTyping({
-			baseUrl: cred.baseUrl,
-			token: cred.token,
-			ilinkUserId: fromUserId,
-			typingTicket: ticket,
-			status: TypingStatus.TYPING
-		});
-	} catch (err) {
-		console.log(`[serenity-hooks] weixin-bridge typing start skipped: ${err instanceof Error ? err.message : String(err)}`);
-	}
+/** 桥：非手动模式 / 会话失效 → 注销（闸门随之失效，零干预） */
+function forgetManualOutputSession(sessionId) {
+	manualSessions.delete(sessionId);
+	sentThisTurn.delete(sessionId);
+	rebukeCounts.delete(sessionId);
 }
-/** 处理结束（含异常路径 finally）：sendtyping status=0；缓存保留（ticket 可复用）。 */
-async function sendTypingStop(cred, accountId, fromUserId) {
-	try {
-		const ticket = typingTicketByUser.get(typingCacheKey(accountId, fromUserId));
-		if (!ticket) return;
-		await sendTyping({
-			baseUrl: cred.baseUrl,
-			token: cred.token,
-			ilinkUserId: fromUserId,
-			typingTicket: ticket,
-			status: TypingStatus.CANCEL
-		});
-	} catch (err) {
-		console.log(`[serenity-hooks] weixin-bridge typing stop skipped: ${err instanceof Error ? err.message : String(err)}`);
-	}
+/** 本轮是否已成功发送（测试/诊断用；桥在每轮结束时读它决定是否兜底） */
+function hasSentThisTurn(sessionId) {
+	return sentThisTurn.has(sessionId);
 }
 /**
-* 🔴 **2026-10-19（P2）`runAccountLoop` 已迁出本文件** —— 逐字搬到
-* `im/weixin-account.ts`，成为 `ImAccountImpl` 的一个实现（微信）。
-*
-* 为什么搬：装配处原先把渠道写死在这里（`channel !== 'weixin'` ⇒ 跳过）。
-* owner 定向「飞书和微信一样，只不过是 account 方实现不同」⇒ 起循环这个动作
-* 归**账号自己的实现**，装配处只按 `channel` 查派发表。
-* ⚠️ 依赖（`getUpdates` / `handleIncoming` / `handleMachineIncoming`）通过
-* `installWeixinAccountImpl` **注入**，避免 `bridge ⇄ weixin-account` 互相 import 成环。
+* 桥：**每轮开始时**清空本会话的"已发送"标记（turn 边界由桥掌握——v1.30.17）。
+* 闸门侧不再于 turn-stopping 结算清空，否则桥读不到本轮结果、无法兜底。
 */
+function clearSentThisTurn(sessionId) {
+	sentThisTurn.delete(sessionId);
+}
+/** 闸门是否装配成功（未装配 → 桥不做兜底：宁可静默也不冒重复发送的风险） */
+function isWeixinOutputGuardActive() {
+	return guardActive;
+}
+/** 从 agent / 会话对象取会话 id（形状宽容） */
+function sessionIdOf$1(value) {
+	const v = value;
+	const id = v?.session?.id ?? v?.id;
+	return typeof id === "string" && id !== "" ? id : null;
+}
 /**
-* 手动输出模式的**机制标记**（v1.30.10 引入；v1.30.16 按 S142 用户"这个词不能让 ACC 定义，
-* 要让 CCC 定义"重构）。
-*
-* 边界（R↓）：ACC 只提供**机制与数据**——"桥不转发最终文本"这个事实 + 三个已填好的参数值
-* （CCC 根 / 账号 / 用户 id）。**纪律措辞归 CCC**：怎么写、必须怎么做、后果是什么，全部写在
-* CCC 的角色提示词文件里（如 `.opencode/skiff/<role>.md` 的「输出通道」节），CCC 可随时改，
-* 且 v1.30.15 起角色提示词热重载——改完立即生效，无需 ACC 发版。
-*
-* 为什么不用 ACC 写措辞（历史教训）：v1.30.10~v1.30.15 由 ACC 内嵌一段纪律文案，用户实测
-* "约束不够，LLM 不听"——且措辞迭代要动插件代码 + 发版 + 重启；把措辞放 CCC 才能快速迭代，
-* 也符合"ACC 管机制、CCC 管内容"的归属二分。
+* 工具调用是否为「成功的微信发送」。
 *
-* 标记格式（稳定，供 CCC 提示词引用；v1.31.0 起为 ACC 工具形态）：
-* ```
-* [serenity:weixin-manual-output]
-* im-bridge({channel:"weixin", action:"send", account:"<account>", user:"<user>", text:"<回复>"})
-* ```
+* v1.31.0 起有两种合法形态（标记与闸门同时认，迁移期并存）：
+* - `im-bridge({channel:"weixin", action:"send"|"send-file", …})` —— ACC 工具（推荐）
+* - `msm("weixin-send", ["send"|"send-file", …])` —— CCC MSM（v1.30.x 通道，逐步退役）
 */
-function weixinManualOutputMarker(root, accountId, userId) {
-	return ["[serenity:weixin-manual-output]", `im-bridge({channel:"weixin", action:"send", account:"${accountId}", user:"${userId}", text:"<回复>"})`].join("\n");
+function isSuccessfulWeixinSend(exec, result) {
+	const e = exec;
+	if (result?.isError === true) return false;
+	const args = e?.arguments;
+	if (e?.name === "im-bridge") {
+		if ((typeof args?.channel === "string" ? args.channel : "") !== "weixin") return false;
+		const action = typeof args?.action === "string" ? args.action : "";
+		return action === "send" || action === "send-file";
+	}
+	if (e?.name === "msm") return args?.name === "weixin-send";
+	return false;
+}
+/** 打回消息（机制事实 + 标记；怎么做由 CCC 角色提示词定义） */
+function buildManualOutputRebuke(session) {
+	return [
+		"[serenity:weixin-manual-output] no send detected in this turn — the user has received NOTHING.",
+		`ccc=${session.root} account=${session.accountId} user=${session.userId}`,
+		`im-bridge({channel:"weixin", action:"send", account:"${session.accountId}", user:"${session.userId}", text:"<回复>"})`
+	].join("\n");
 }
 /**
-* 手动输出模式的**兜底判定**（纯函数，v1.30.17——把决策矩阵从装配里抽出来，可独立测试）。
-*
-* 四个条件同时成立才兜底：
-* ① CCC 显式开启 `fallbackOnNoSend`（缺省 false = 严格静默，向后兼容）
-* ② 机械闸门**已装配**（未装配时无法判定"是否发送过" → 宁可静默也不冒重复发送风险）
-* ③ 本轮**没有**成功发送（agent 自己发过 → 输出权归 agent，桥不插话）
-* ④ 有最终文本可转发（空文本无意义）
+* 装配闸门（index.ts apply 调用）。
+* 只对**已登记的手动模式会话**生效——其他会话（主舱/其他 轨迹约束会话）零干预。
 */
-function manualOutputFallbackNeeded(input) {
-	return input.fallbackOnNoSend === true && input.guardActive && !input.sentThisTurn && input.answer !== "";
+function registerWeixinOutputGuard(ctx) {
+	try {
+		ctx.on("tools/post-execute", async (exec, result, next) => {
+			const downstream = await next();
+			try {
+				const sessionId = sessionIdOf$1(exec?.agent);
+				if (sessionId && manualSessions.has(sessionId) && isSuccessfulWeixinSend(exec, result)) {
+					sentThisTurn.add(sessionId);
+					rebukeCounts.delete(sessionId);
+				}
+			} catch {}
+			return downstream;
+		});
+	} catch {
+		console.warn("[serenity-hooks] ✗ weixin 输出闸门未装配：tools/post-execute 不可用");
+		return;
+	}
+	try {
+		ctx.on("agent/turn-stopping", (payload) => {
+			const agent = payload?.agent;
+			if (!agent) return;
+			const sessionId = sessionIdOf$1(agent);
+			if (!sessionId) return;
+			const session = manualSessions.get(sessionId);
+			if (!session) return;
+			if (sentThisTurn.has(sessionId)) return;
+			const count = (rebukeCounts.get(sessionId) ?? 0) + 1;
+			if (count > 2) {
+				rebukeCounts.delete(sessionId);
+				console.warn(`[serenity-hooks] ✗ weixin 输出闸门：连续 2 次打回后仍未发送（session=${sessionId}, role=${session.role}）——本轮用户将收不到 agent 自己发的消息`);
+				return;
+			}
+			rebukeCounts.set(sessionId, count);
+			try {
+				agent.steer(createUserMessage({
+					content: [{
+						type: "text",
+						text: buildManualOutputRebuke(session)
+					}],
+					source: PLUGIN_SOURCE
+				}));
+				console.log(`[serenity-hooks] weixin 输出闸门：打回 ${count}/2（session=${sessionId}, turn=${payload.turn ?? "?"}）`);
+			} catch (error) {
+				console.warn(`[serenity-hooks] ✗ weixin 输出闸门 steer 失败: ${String(error?.message ?? error)}`);
+			}
+		});
+	} catch {
+		console.warn("[serenity-hooks] ✗ weixin 输出闸门未装配：agent/turn-stopping 不可用");
+		return;
+	}
+	guardActive = true;
 }
+//#endregion
+//#region src/im/inbound-event.ts
+/** 媒体大小上限（M6：20MB，对齐 vlm-describe；超限降级告知不落盘） */
+const MEDIA_MAX_BYTES = 20971520;
 /**
 * 订阅表里的 `ccc` **别名 → CCC 根**（P0-3）。
 *
-* 别名取值与面板下拉**同源**（方案 §2.3：`listCccs({withRoles:true})` 的下拉）⇒
-* 先按 **`CccEntry.name`**（= CCC 根目录名，`basename(root)`）匹配；再退一步接受**绝对路径**
-* （手写配置时人会直接粘路径）。两条都试 ⇒ 两种写法都可用，且**不引入第二张名字表**。
-* @returns 命中的 CCC 根；枚举里没有 ⇒ `null`（调用方**响亮报错**，不静默丢弃）
+* 别名取值与面板下拉**同源** ⇒ 先按 `CccEntry.name`（= CCC 根目录名）匹配；
+* 再退一步接受**绝对路径**（手写配置时人会直接粘路径）。两条都试
+* ⇒ 两种写法都可用，且**不引入第二张名字表**。
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-jZYR2GVE.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-B2t_aM8L.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -21128,11 +20793,9 @@ async function resolveCccRootByAlias(ctx, alias) {
 * 判据**，差别只有一格 —— **有没有 CCC 级回退**（`cccFallback`）。写两遍必然分叉。
 *
 * 三档（方案 §3.1，**刻意分档**）：
-*  - **未命中** ⇒ 不投递 ＋ **留痕**（`console.warn`，静默档：这是"表里没有你"，不是错误）
-*  - **表残缺** ⇒ **响亮出声**（`console.error`；且**独立于是否命中**）
-*  - **目标不存在**（CCC ／ **轨迹**）⇒ **响亮报错**（`console.error`；不静默丢弃）
-*
-* @param input.cccFallback 过渡期回退（方案 Q5）；**机器级模式传 `null`** ⇒ 未命中即不投递
+*  - **未命中** ⇒ 不投递 ＋ **留痕**（静默档：这是"表里没有你"，不是错误）
+*  - **表残缺** ⇒ **响亮出声**（且**独立于是否命中**）
+*  - **目标不存在**（CCC ／ **轨迹**）⇒ **响亮报错**（不静默丢弃）
 */
 async function resolveInboundTarget(ctx, input) {
 	const route = planInboundRoute({
@@ -21181,7 +20844,7 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const { findDirNameByCode } = await import("./profile-DyMJ_bfr.js").then((n) => n.i);
+	const { findDirNameByCode } = await import("./profile-BVt84mbi.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}）—— 该消息**未投递**，请改订阅表里的目标编码`);
@@ -21195,7 +20858,7 @@ async function resolveInboundTarget(ctx, input) {
 		});
 		return null;
 	}
-	const profile = readSkiffProfileByCode(root, target.role);
+	const profile = readTrajectoryConstraintByCode(root, target.role);
 	return {
 		root,
 		trajectory: target.role,
@@ -21203,33 +20866,21 @@ async function resolveInboundTarget(ctx, input) {
 	};
 }
 /**
-* 处理单条微信消息：路由 → skiff 会话（固定 id 创建/延续）→ 提问 → 回复回写。
+* **一条入站消息的主流程**（通道中立）。
 *
-* 会话语义：`weixinSessionIdFor(fromUserId)` 固定可重建——同用户长期同一会话；
-* 进程内已有（getSkiffAgent 命中）→ 延续；无（首次/进程重启）→ createSkiffAgent
-* 固定 id resume-or-create（v1.27.2）：磁盘已有持久化 log → resume（历史延续，
-* 重启后记忆保留——真正的"同用户长期延续"）；无 log（首次）→ create。
-* "新的对话已开始"通知仅真正首次（create）时发送；resume/进程内延续不发。
+* 职责：路由 → 固定会话 id 创建/延续 → 提问 → 回复（或被闸门拦下后兜底）。
+* 语料（媒体）由事件自带 `fetch()`；出站走的 `io`。
 *
-* 完善（v1.27.3）：
-* - **语音支持**：`voice_item.text` = 微信服务端自带语音转写 → 与文本同路径进对话
-*   （无需下载/ASR）；语音无转写 → 降级提示"暂时无法解析"
-* - **正在输入**：处理前 sendtyping 1（微信显示"正在输入..."），处理后（含异常）0
-* - **媒体接收（图片/文件）**：桥侧 CDN 下载 + AES 解密 → 落盘 CCC 根
-*   `_tmp/weixin-inbound/<userhash>/` → question 注入「存在性 + 路径」（ACC 层只保证
-*   可达性——"让会话知道文件的存在并可以拿到"；识别/解析归角色 LLM 决策，不编排）。
-*   降级不静默：下载失败 / 超 20MB → 注入说明进对话；typing 窗口覆盖下载（M7）。
+* 🔴 **本函数没有任何 iLink 概念** —— 这是 B1 的判据。任何 `context_token` /
+* `item_list` / `message_type` 出现在这里，就说明抽缝没抽干净。
 *
-* 🔴 **P0-3（2026-09-27）：路由改由机器级订阅表决定**（本函数的 `root` 入参退为
-* **回退目标**）。两档语义刻意分开（方案 §3.1）：**未命中 ⇒ 不投递 ＋ 留痕**（静默档）；
-* **目标不存在（CCC ／ 角色）⇒ 响亮报错**（`console.error` ＋ 机器级留痕）。两者都
-* **不是**"投给默认角色"。
+* @param preset 机器级模式：目标已解析好 ⇒ **不再自行路由**，且**不看本 CCC 的 `enabled`**
 */
-async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
-	const fromUserId = msg.from_user_id;
+async function handleInboundEvent(ctx, root, accountId, io, event, preset) {
+	const fromUserId = event.userId;
 	if (!fromUserId) return;
-	const text = extractWeixinText(msg);
-	const mediaRefs = extractWeixinMedia(msg);
+	const text = event.text;
+	const mediaRefs = event.media;
 	const settings = readWeixinSettings(root);
 	let resolved;
 	if (preset) resolved = preset.target;
@@ -21249,24 +20900,22 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 	const { trajectory, profile } = resolved;
 	root = resolved.root;
 	if (!text && mediaRefs.length === 0) {
-		if (hasVoiceItem(msg)) await sendTextMessage({
-			baseUrl: cred.baseUrl,
-			token: cred.token,
+		if (event.hasVoice) await io.sendText({
 			toUserId: fromUserId,
 			text: "（抱歉，暂时无法解析这条语音消息，请尝试发送文字）",
-			contextToken: msg.context_token
+			replyRef: event.replyRef
 		}).catch(() => {});
 		return;
 	}
 	try {
 		const sessionId = weixinSessionIdForTrajectory(trajectory);
-		const existing = getSkiffAgent(sessionId);
+		const existing = getTrajectoryAgent(sessionId);
 		const hc = readCheapWorkerConfig(root);
 		const ref = existing ? {
 			agent: existing,
 			sessionId,
 			resumed: true
-		} : await createSkiffAgent(ctx, root, profile ?? {
+		} : await createTrajectoryAgent(ctx, root, profile ?? {
 			dirName: trajectory,
 			code: trajectory,
 			path: "",
@@ -21278,25 +20927,22 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 				rebuild: true
 			}
 		}, hc?.defaultModel, sessionId);
-		if (!ref.resumed) await sendTextMessage({
-			baseUrl: cred.baseUrl,
-			token: cred.token,
+		if (!ref.resumed) await io.sendText({
 			toUserId: fromUserId,
 			text: "（新的对话已开始）",
-			contextToken: msg.context_token
+			replyRef: event.replyRef
 		}).catch(() => {});
-		await sendTypingStart(cred, accountId, fromUserId, msg.context_token);
+		await io.typingStart?.({
+			toUserId: fromUserId,
+			replyRef: event.replyRef
+		});
 		try {
 			const mediaNotes = [];
 			const degradedNotes = [];
 			const hookMedia = [];
 			for (const mediaRef of mediaRefs) {
-				const mediaType = mediaRef.kind === "image" ? "image_item" : "file_item";
 				const label = mediaRef.kind === "image" ? "一张图片" : `文件 ${mediaRef.fileName ?? "(未命名)"}`;
-				const result = await downloadMedia({
-					item: mediaRef.item,
-					mediaType
-				});
+				const result = await mediaRef.fetch();
 				if (!result) {
 					hookMedia.push({
 						kind: mediaRef.kind,
@@ -21316,7 +20962,7 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 				try {
 					const inboundDir = weixinInboundDir(root, fromUserId);
 					mkdirSync(inboundDir, { recursive: true });
-					const fname = mediaRef.kind === "image" ? `img_${Date.now()}_${randomBytes(4).toString("hex")}.${sniffImageExt(result.data)}` : sanitizeFileName$1(result.fileName ?? "") || `file_${Date.now()}_${randomBytes(4).toString("hex")}`;
+					const fname = mediaRef.kind === "image" ? `img_${Date.now()}_${randomBytes(4).toString("hex")}.${sniffImageExt(result.data)}` : sanitizeFileName$1(result.fileName ?? mediaRef.fileName ?? "") || `file_${Date.now()}_${randomBytes(4).toString("hex")}`;
 					const abs = join(inboundDir, fname);
 					writeFileSync(abs, result.data);
 					const rel = relative(root, abs);
@@ -21330,11 +20976,11 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 						kind: mediaRef.kind,
 						relPath: null
 					});
-					degradedNotes.push(`（媒体保存失败，请重试）`);
+					degradedNotes.push("（媒体保存失败，请重试）");
 				}
 			}
 			const parts = [];
-			const workspaceMd = skiffWorkspaceMdPath(root, sessionId) ?? getActiveSessionInfo(sessionId)?.mdPath ?? null;
+			const workspaceMd = trajectoryWorkspaceMdPath(root, sessionId) ?? getActiveSessionInfo(sessionId)?.mdPath ?? null;
 			if (workspaceMd) {
 				if (!ensureWorkspacePromptSection(ref.agent, sessionId, root)) parts.push(workspaceCognitiveTrajectoryLine(workspaceMd));
 			}
@@ -21349,7 +20995,7 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 					userId: fromUserId,
 					role: trajectory
 				});
-				parts.push(weixinManualOutputMarker(root, accountId, fromUserId));
+				parts.push(manualOutputMarker(accountId, fromUserId));
 			} else forgetManualOutputSession(sessionId);
 			const question = parts.join("\n");
 			const hookRel = settings.hook;
@@ -21362,9 +21008,9 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 				text,
 				media: hookMedia
 			})).catch((err) => {
-				console.log(`[serenity-hooks] weixin hook incoming error: ${err instanceof Error ? err.message : String(err)}`);
+				console.log(`[serenity-hooks] im hook incoming error: ${err instanceof Error ? err.message : String(err)}`);
 			});
-			const answer = (await askSkiff(ctx, ref.agent, question)).answer ?? "";
+			const answer = (await askTrajectory(ctx, ref.agent, question)).answer ?? "";
 			if (manualOutput) {
 				if (!manualOutputFallbackNeeded({
 					fallbackOnNoSend: settings.fallbackOnNoSend,
@@ -21373,14 +21019,12 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 					answer
 				})) return;
 				const reply = markdownToPlainText(stripThink(answer));
-				await sendTextMessage({
-					baseUrl: cred.baseUrl,
-					token: cred.token,
+				await io.sendText({
 					toUserId: fromUserId,
 					text: reply,
-					contextToken: msg.context_token
+					replyRef: event.replyRef
 				});
-				console.warn(`[serenity-hooks] ⚠ weixin 输出兜底：agent 本轮未发送（闸门打回用尽）→ 桥转发最终文本（session=${sessionId}, trajectory=${trajectory}）`);
+				console.warn(`[serenity-hooks] ⚠ im 输出兜底：agent 本轮未发送（闸门打回用尽）→ 桥转发最终文本（session=${sessionId}, trajectory=${trajectory}）`);
 				if (hookRel) invokeWeixinHook(root, hookRel, buildOutgoingHookEvent({
 					cccRoot: root,
 					accountId,
@@ -21390,18 +21034,16 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 					reply,
 					source: "reply-fallback"
 				})).catch((err) => {
-					console.log(`[serenity-hooks] weixin hook outgoing(reply-fallback) error: ${err instanceof Error ? err.message : String(err)}`);
+					console.log(`[serenity-hooks] im hook outgoing(reply-fallback) error: ${err instanceof Error ? err.message : String(err)}`);
 				});
 				return;
 			}
 			if (answer === "") return;
 			const reply = markdownToPlainText(stripThink(answer));
-			await sendTextMessage({
-				baseUrl: cred.baseUrl,
-				token: cred.token,
+			await io.sendText({
 				toUserId: fromUserId,
 				text: reply,
-				contextToken: msg.context_token
+				replyRef: event.replyRef
 			});
 			if (hookRel) invokeWeixinHook(root, hookRel, buildOutgoingHookEvent({
 				cccRoot: root,
@@ -21411,28 +21053,369 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 				role: trajectory,
 				reply
 			})).catch((err) => {
-				console.log(`[serenity-hooks] weixin hook outgoing error: ${err instanceof Error ? err.message : String(err)}`);
+				console.log(`[serenity-hooks] im hook outgoing error: ${err instanceof Error ? err.message : String(err)}`);
 			});
 		} finally {
-			await sendTypingStop(cred, accountId, fromUserId);
+			await io.typingStop?.({ toUserId: fromUserId });
 		}
 	} catch (err) {
 		const msg = err instanceof Error ? err.message : String(err);
-		console.log(`[serenity-hooks] weixin-bridge error (ccc=${root}): ${msg}`);
+		console.log(`[serenity-hooks] im-bridge error (ccc=${root}): ${msg}`);
 		const stack = err instanceof Error ? err.stack : void 0;
-		if (stack) console.log(`[serenity-hooks] weixin-bridge stack:\n${stack.slice(0, 1500)}`);
+		if (stack) console.log(`[serenity-hooks] im-bridge stack:\n${stack.slice(0, 1500)}`);
+	}
+}
+/**
+* 手动输出模式的**机制标记**（v1.30.10 引入；v1.30.16 按「ACC 管机制、CCC 管措辞」重构）。
+*
+* 边界（R↓）：ACC 只提供**机制与数据**——"桥不转发最终文本"这个事实 + 三个已填好的参数值。
+* **纪律措辞归 CCC**：怎么写、必须怎么做、后果是什么，全部写在轨迹的 `PROMPT.md` 里。
+*/
+function manualOutputMarker(accountId, userId) {
+	return ["[serenity:weixin-manual-output]", `im-bridge({channel:"weixin", action:"send", account:"${accountId}", user:"${userId}", text:"<回复>"})`].join("\n");
+}
+/**
+* 手动输出模式的**兜底判定**（纯函数，v1.30.17——把决策矩阵从装配里抽出来，可独立测试）。
+*
+* 四个条件同时成立才兜底：
+* ① CCC 显式开启 `fallbackOnNoSend`（缺省 false = 严格静默）
+* ② 机械闸门**已装配**（未装配时无法判定"是否发送过" → 宁可静默也不冒重复发送风险）
+* ③ 本轮**没有**成功发送（agent 自己发过 → 输出权归 agent，桥不插话）
+* ④ 有最终文本可转发（空文本无意义）
+*/
+function manualOutputFallbackNeeded(input) {
+	return input.fallbackOnNoSend === true && input.guardActive && !input.sentThisTurn && input.answer !== "";
+}
+//#endregion
+//#region src/im/feishu-account.ts
+/** 去重集合上限（飞书重推窗口有限；限量防内存无界增长） */
+const SEEN_LIMIT = 2e3;
+/** 已处理过的 message_id（超时重推去重；按账号隔离） */
+const seenByAccount = /* @__PURE__ */ new Map();
+/** 取 SDK（未注入 ⇒ 动态 import 真包） */
+async function loadFeishuSdk() {
+	return await import("./lib-TxscFKeo.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+}
+/**
+* 账号 → 长连接客户端（`ImAccountLoop` 的形状是面板既有契约，**不加字段** ——
+* 加字段会逼面板与 `im-bridge status` 认识一个通道特有的东西）。
+* 用途：`stopped` 置位后能真正 `close()` 掉连接（只置标志位而不关连接 = 假停止）。
+*/
+const wsByAccount = /* @__PURE__ */ new Map();
+function seenSet(accountId) {
+	let s = seenByAccount.get(accountId);
+	if (!s) {
+		s = /* @__PURE__ */ new Set();
+		seenByAccount.set(accountId, s);
+	}
+	return s;
+}
+/**
+* 飞书凭据就绪判据：**appId 与 appSecret 都非空**。
+* （微信只需 token；飞书是双要素，缺任一起不了长连接。）
+*/
+function feishuCredentialReady(cred) {
+	const appId = typeof cred.appId === "string" ? cred.appId.trim() : "";
+	const secret = typeof cred.token === "string" ? cred.token.trim() : "";
+	return appId !== "" && secret !== "";
+}
+/**
+* 从飞书 `im.message.receive_v1` 事件里取出**中立入站事件**。
+*
+* 🔴 这是 P3 唯一的"形状翻译"处，与 `bridge.ts` 里 iLink 的那一处对称。
+* ⚠️ 用户标识用 **open_id**（不是 chat_id）：路由表是"人 → 轨迹"，
+*    而 chat_id 在群里会变、在单聊里也与人不是一一对应。
+* @returns 无可用发送者/消息体 ⇒ `null`（调用方丢弃并**出声**，不静默）
+*/
+function feishuEventToInbound(data) {
+	const sender = data.sender;
+	const message = data.message;
+	const userId = sender?.sender_id?.open_id;
+	if (!userId || !message?.message_id) return null;
+	let text = null;
+	if (message.message_type === "text" && typeof message.content === "string") try {
+		const parsed = JSON.parse(message.content);
+		text = (typeof parsed.text === "string" ? parsed.text.trim() : "").replace(/@_user_\d+/g, "").trim();
+		if (text === "") text = null;
+	} catch {
+		text = null;
+	}
+	return {
+		userId,
+		text,
+		media: [],
+		hasVoice: false,
+		replyRef: void 0
+	};
+}
+/**
+* 造出站动作面（飞书）。
+*
+* 🔴 `content` 必须是 **JSON 字符串**：`JSON.stringify({ text })` —— 这是官方形态，
+* 直接给裸文本会被服务端拒绝（且错误码不直观）。
+*/
+function feishuIo(client) {
+	const c = client;
+	return { sendText: async ({ toUserId, text }) => {
+		const create = c.im?.v1?.message?.create;
+		if (typeof create !== "function") throw new Error("飞书 SDK 缺少 im.v1.message.create");
+		await create({
+			params: { receive_id_type: "open_id" },
+			data: {
+				receive_id: toUserId,
+				msg_type: "text",
+				content: JSON.stringify({ text: markdownToPlainText(text) })
+			}
+		});
+	} };
+}
+/**
+* 单账号的飞书长连接循环。
+*
+* 与微信的**关键结构差别**：微信是 `while` 轮询，飞书是**事件回调**（长连接推）。
+* 所以这里的"循环"其实是"建连一次，然后等回调"；`stopped` 靠 `close()` 兑现。
+*/
+async function runFeishuAccountLoop(input, loop) {
+	const cred = input.cred;
+	const appId = cred.appId ?? "";
+	const appSecret = cred.token ?? "";
+	if (!appId || !appSecret) {
+		loop.lastError = "飞书凭据不全（缺 appId 或 appSecret）";
+		return;
+	}
+	const Lark = await loadFeishuSdk();
+	const client = new Lark.Client({
+		appId,
+		appSecret
+	});
+	const dispatcher = new Lark.EventDispatcher({});
+	const queue = [];
+	let draining = false;
+	const drain = async () => {
+		if (draining) return;
+		draining = true;
+		try {
+			while (queue.length > 0 && !loop.stopped) {
+				const item = queue.shift();
+				loop.lastPollAt = Date.now();
+				try {
+					const event = feishuEventToInbound(item.data);
+					if (!event) {
+						loop.lastError = "收到飞书事件但取不出发送者/消息体";
+						continue;
+					}
+					const msgId = item.data.message?.message_id ?? "";
+					if (msgId !== "") {
+						const seen = seenSet(input.accountId);
+						if (seen.has(msgId)) continue;
+						seen.add(msgId);
+						if (seen.size > SEEN_LIMIT) {
+							const oldest = seen.values().next().value;
+							if (oldest !== void 0) seen.delete(oldest);
+						}
+					}
+					const ctx = input.ctx;
+					const io = feishuIo(client);
+					if (input.machine) {
+						const target = await resolveInboundTarget(ctx, {
+							account: input.accountId,
+							user: event.userId,
+							cccFallback: null
+						});
+						if (!target) continue;
+						await handleInboundEvent(ctx, target.root, input.accountId, io, event, { target });
+					} else await handleInboundEvent(ctx, input.root, input.accountId, io, event);
+				} catch (err) {
+					loop.lastError = err instanceof Error ? err.message : String(err);
+				}
+			}
+		} finally {
+			draining = false;
+		}
+	};
+	dispatcher.register({ "im.message.receive_v1": (data) => {
+		queue.push({ data });
+		drain();
+	} });
+	const ws = new Lark.WSClient({
+		appId,
+		appSecret
+	});
+	wsByAccount.set(input.accountId, ws);
+	try {
+		await ws.start({ eventDispatcher: dispatcher });
+	} catch (err) {
+		loop.lastError = `飞书长连接建立失败: ${err instanceof Error ? err.message : String(err)}`;
+	}
+}
+/** 飞书账号实现（登记名 = `feishu`；与配置里的 `channel` 取值一致） */
+const feishuAccountImpl = {
+	channel: "feishu",
+	isReady: feishuCredentialReady,
+	notReadyReason: () => "**缺 appId 或 appSecret**（未绑定）",
+	startLoop(input) {
+		const loop = {
+			stopped: false,
+			lastPollAt: 0
+		};
+		runFeishuAccountLoop(input, loop);
+		return loop;
+	}
+};
+/**
+* 注册飞书实现（`bridge.ts` 在**模块求值时**调用）。
+*
+* ⚠️ 与微信同款教训（续 220 实测 12 例红）：注册必须在**模块求值**时发生，
+* 不能等 `apply` —— 测试与面板会**直接**调 `syncCccBridge` / `syncHumanChannel`。
+*/
+function installFeishuAccountImpl() {
+	registerImAccountImpl(feishuAccountImpl);
+}
+//#endregion
+//#region src/im/bridge.ts
+var bridge_exports = /* @__PURE__ */ __exportAll({
+	handleIncoming: () => handleIncoming,
+	handleMachineIncoming: () => handleMachineIncoming,
+	registerWeixinBridge: () => registerWeixinBridge,
+	resolveInboundTarget: () => resolveInboundTarget,
+	resolveWeixinAccount: () => resolveWeixinAccount,
+	sendProactiveText: () => sendProactiveText,
+	stopAllBridges: () => stopAllBridges,
+	stopCccBridge: () => stopCccBridge,
+	syncCccBridge: () => syncCccBridge,
+	syncHumanChannel: () => syncHumanChannel,
+	weixinBridgeStatus: () => weixinBridgeStatus
+});
+const bridges = /* @__PURE__ */ new Map();
+/**
+* 🔴 **机器级 poller 的"根"哨兵**（P0-3 A）—— 它**不是一个目录**。
+*
+* 机器级 poller **不属于任何 CCC**（这正是"上移 ACC 层"的含义：谁轮询不再由 CCC 数量决定）。
+* 用途有二：① `runAccountLoop` 的 `root` 形参在机器级模式下不被使用，传它以示"无根"；
+* ② 归属表（`im/inbound.ts`）按 root 区分拥有者 ⇒ 机器级用这个哨兵值，
+*    与任何**真实** CCC 根都不会撞（真根一律是绝对路径）。
+*/
+const MACHINE_SCOPE = "<machine>";
+/** 机器级 poller（账号 id → 循环）。与 `bridges` **互斥**：同一时刻只有一种模式在跑。 */
+const machineLoops = /* @__PURE__ */ new Map();
+/** typing_ticket 缓存（每 (accountId, fromUserId)；getconfig 一次后续复用——对齐参考实现 typingTicketCache） */
+const typingTicketByUser = /* @__PURE__ */ new Map();
+function typingCacheKey(accountId, fromUserId) {
+	return `${accountId}|${fromUserId}`;
+}
+/** 处理开始：getconfig（无缓存时）→ sendtyping status=1（微信侧显示"正在输入..."）。
+*  任何失败静默（typing 不影响主流程——对齐参考实现 typingCallbacks try/catch 吞错）。 */
+async function sendTypingStart(cred, accountId, fromUserId, contextToken) {
+	try {
+		const key = typingCacheKey(accountId, fromUserId);
+		let ticket = typingTicketByUser.get(key);
+		if (!ticket) {
+			ticket = (await getConfig({
+				baseUrl: cred.baseUrl,
+				token: cred.token,
+				ilinkUserId: fromUserId,
+				contextToken: contextToken ?? ""
+			})).typing_ticket;
+			if (ticket) typingTicketByUser.set(key, ticket);
+		}
+		if (!ticket) return;
+		await sendTyping({
+			baseUrl: cred.baseUrl,
+			token: cred.token,
+			ilinkUserId: fromUserId,
+			typingTicket: ticket,
+			status: TypingStatus.TYPING
+		});
+	} catch (err) {
+		console.log(`[serenity-hooks] weixin-bridge typing start skipped: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+/** 处理结束（含异常路径 finally）：sendtyping status=0；缓存保留（ticket 可复用）。 */
+async function sendTypingStop(cred, accountId, fromUserId) {
+	try {
+		const ticket = typingTicketByUser.get(typingCacheKey(accountId, fromUserId));
+		if (!ticket) return;
+		await sendTyping({
+			baseUrl: cred.baseUrl,
+			token: cred.token,
+			ilinkUserId: fromUserId,
+			typingTicket: ticket,
+			status: TypingStatus.CANCEL
+		});
+	} catch (err) {
+		console.log(`[serenity-hooks] weixin-bridge typing stop skipped: ${err instanceof Error ? err.message : String(err)}`);
 	}
 }
 /**
+* 🔴 **2026-10-19（P2）`runAccountLoop` 已迁出本文件** —— 逐字搬到
+* `im/weixin-account.ts`，成为 `ImAccountImpl` 的一个实现（微信）。
+*
+* 为什么搬：装配处原先把渠道写死在这里（`channel !== 'weixin'` ⇒ 跳过）。
+* owner 定向「飞书和微信一样，只不过是 account 方实现不同」⇒ 起循环这个动作
+* 归**账号自己的实现**，装配处只按 `channel` 查派发表。
+* ⚠️ 依赖（`getUpdates` / `handleIncoming` / `handleMachineIncoming`）通过
+* `installWeixinAccountImpl` **注入**，避免 `bridge ⇄ weixin-account` 互相 import 成环。
+*/
+/**
+* 处理单条**微信**消息：把 iLink 形状的 `msg` 归一成**中立入站事件**，
+* 再交给通道中立的 `handleInboundEvent`（`im/inbound-event.ts`）走主流程。
+*
+* ## 🔴 2026-10-19（B1）：本函数已退化为**薄适配器**，主流程不在本文件
+*
+* 原因：`handleIncoming` 原先同时承担两件不同的事 —— ① "iLink 消息长什么样"
+* ② "一条已到达的消息该投到哪、怎么答、怎么记账"。接第二家 IM 时只有 ① 需要新写，
+* 而 ② 应该**被两家共用**。两者混在一个函数里 ⇒ 飞书接进来只能复制一整份主流程。
+*
+* ⇒ 主流程搬到 `im/inbound-event.ts`，本函数只做**形状翻译**：
+*   `msg`（iLink）＋ `cred`（iLink 凭据）→ `ImInboundEvent` ＋ `ImAccountIo`。
+*
+* ## 为什么保留这个签名（而不是让调用方直接调新的主流程）
+*
+* 全仓约 50 处测试按 iLink 形状驱动本函数，而 B1 的验收判据是「**微信行为逐字不变**」
+* （用例数守恒 ＋ 真机一条微信）。保留签名 ⇒ 那 50 处**逐字不动**，判据可复算。
+*
+* 会话语义（不变）：会话 id 由**轨迹编码**派生 ⇒ 同一条轨迹恒同一条 dsh 会话；
+* 进程内已有 → 延续；无 → 固定 id resume-or-create。
+*/
+async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
+	const fromUserId = msg.from_user_id;
+	if (!fromUserId) return;
+	await handleInboundEvent(ctx, root, accountId, {
+		sendText: async ({ toUserId, text, replyRef }) => {
+			await sendTextMessage({
+				baseUrl: cred.baseUrl,
+				token: cred.token,
+				toUserId,
+				text,
+				contextToken: replyRef
+			});
+		},
+		typingStart: ({ toUserId, replyRef }) => sendTypingStart(cred, accountId, toUserId, replyRef),
+		typingStop: ({ toUserId }) => sendTypingStop(cred, accountId, toUserId)
+	}, {
+		userId: fromUserId,
+		text: extractWeixinText(msg),
+		media: extractWeixinMedia(msg).map((ref) => ({
+			kind: ref.kind,
+			fileName: ref.fileName,
+			fetch: () => downloadMedia({
+				item: ref.item,
+				mediaType: ref.kind === "image" ? "image_item" : "file_item"
+			}).then((r) => r ? {
+				data: r.data,
+				fileName: r.fileName
+			} : null)
+		})),
+		hasVoice: hasVoiceItem(msg),
+		replyRef: msg.context_token
+	}, preset);
+}
+/**
 * **机器级 poller 的单条消息入口**（P0-3 A）。
 *
 * 与 `handleIncoming` 的唯一差别：**目标由机器级订阅表逐条解析，且没有 CCC 级回退**
 * （方案 §3.1：机器级模式下**未命中 = 不投递**，不是"投给默认角色"）。
-* 解析出来后把**目标根**当 `root` 交给 `handleIncoming`（并带上 `preset` ⇒ 它不再自行路由、
-* 也不看目标 CCC 的 `weixin.enabled`）。
-*
-* 🔴 为什么"起 poller"与"路由"必须同批（本件即 P0-2 的后半）：机器级 poller 收到消息时
-* **不知道它属于哪个 CCC** —— 那个答案是订阅表给的。没有订阅表 ⇒ **能收不能投**。
+* 解析出来后把**目标根**当 `root` 交给 `handleIncoming`（并带上 `preset`）。
 *
 * 🔵 **导出供测试直接驱动**（与 `handleIncoming` 同款：它俩都是"单条消息的入口"，
 * 生产路径 `runAccountLoop` 只是循环壳）。
@@ -21449,6 +21432,35 @@ async function handleMachineIncoming(ctx, accountId, cred, msg) {
 	await handleIncoming(ctx, target.root, accountId, cred, msg, { target });
 }
 /**
+* **按渠道读凭据**（P3 起的单一入口）。
+*
+* 为什么必须抽成一个函数：CCC 级桥（`syncCccBridge`）与机器级 poller（`syncMachinePollers`）
+* 是**两条装配路径**，原先各自写着"怎么从 localstore 取微信 token"。接第二家渠道时若两边各写一份，
+* 必然分叉（一家改了另一家忘改，且**没有任何机械信号**）。
+*
+* 两种取法的**真实差别**（不是风格差异）：
+* - **CCC 级**：凭据在 localstore（`WEIXIN_<A>_TOKEN` / `FEISHU_<A>_APPID|SECRET`）。
+* - **机器级**：凭据在插件设置行（`account.token`）——那是宿主设置面，不经 localstore。
+*
+* ⇒ 本函数只负责**把"渠道"翻译成"该读哪套字段"**，返回统一形状 `ImAccountCredential`。
+*   微信的 appId 恒 undefined；飞书把 appSecret 装进 `token`（让两边共用同一个就绪判据位置）。
+*/
+function readImCredentialByChannel(root, accountId, channel) {
+	if (channel === "feishu") {
+		const f = readFeishuCredential(root, accountId);
+		return f ? {
+			appId: f.appId,
+			token: f.appSecret
+		} : null;
+	}
+	const w = readWeixinCredential(root, accountId);
+	return w ? {
+		token: w.token,
+		baseUrl: w.baseUrl,
+		userId: w.userId
+	} : null;
+}
+/**
 * 启动/重建某 CCC 的桥：读配置 → 对每个 enabled + 有凭据的账号启动轮询循环。
 * 已存在（配置变化热重建）→ 先停旧循环再启动新的。
 *
@@ -21481,7 +21493,7 @@ function syncCccBridge(ctx, root) {
 			}
 			continue;
 		}
-		const cred = readWeixinCredential(root, account.accountId);
+		const cred = readImCredentialByChannel(root, account.accountId, channel);
 		if (!cred) continue;
 		if (!impl.isReady(cred)) continue;
 		implByAccount.set(account.accountId, impl);
@@ -21489,7 +21501,7 @@ function syncCccBridge(ctx, root) {
 		requests.push({
 			root,
 			accountId: account.accountId,
-			identity: accountIdentity(root, account.accountId, cred.token)
+			identity: accountIdentity(root, account.accountId, cred.token ?? "")
 		});
 	}
 	const plan = planPollerClaims(requests, pollerOwners());
@@ -21579,10 +21591,12 @@ function syncMachinePollers(ctx, hc) {
 			continue;
 		}
 		const token = (account.token ?? "").trim();
+		const appIdRaw = account.appId;
 		const cred = {
 			token,
 			baseUrl: "",
-			userId: account.userId
+			userId: account.userId,
+			...channel === "feishu" && typeof appIdRaw === "string" ? { appId: appIdRaw.trim() } : {}
 		};
 		if (!impl.isReady(cred)) {
 			console.warn(`[serenity-hooks] ⚠ human-channel: 账号 ${id} ${impl.notReadyReason?.(cred) ?? "**凭据不全**"} ⇒ 不起 poller`);
@@ -21642,7 +21656,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-jZYR2GVE.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-B2t_aM8L.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -21782,6 +21796,14 @@ installWeixinAccountImpl({
 	handleIncoming,
 	handleMachineIncoming
 });
+/**
+* 🆕 **P3 装配：飞书实现登记进同一张派发表**（同样是模块求值时）。
+*
+* 飞书不需要注入依赖 —— 它的收（`WSClient`）与发（`im.v1.message.create`）都在 SDK 里，
+* 主流程则复用 `im/inbound-event.ts`。⇒ 这一行就是"微信与飞书成为并列实现"的**最后一块**：
+* 派发表有了两个条目，装配处一行没改（它只按 `channel` 查表）。
+*/
+installFeishuAccountImpl();
 //#endregion
 //#region src/im/send.ts
 /** 请求体上限（文本消息远小于此；防滥用） */
@@ -21898,7 +21920,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-jZYR2GVE.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-B2t_aM8L.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -22118,7 +22140,7 @@ function sessionIdOf(value) {
 /** 单会话内存态清理（幂等；无对应状态即 no-op） */
 function cleanupSessionState(sessionId) {
 	try {
-		unregisterSkiffSession(sessionId);
+		unregisterTrajectorySession(sessionId);
 	} catch {}
 	try {
 		clearActiveSessionInfo(sessionId);
@@ -22139,7 +22161,7 @@ function cleanupSessionState(sessionId) {
 		forgetHostScheduleToolHiding(sessionId);
 	} catch {}
 	try {
-		forgetSkiffRoleToolVisibility(sessionId);
+		forgetTrajectoryConstraintToolVisibility(sessionId);
 	} catch {}
 	try {
 		forgetLogbookCompactionState(sessionId);
@@ -22170,7 +22192,7 @@ function registerLifecycle(ctx) {
 			stopAllBridges();
 		} catch {}
 	};
-	registerDisposer(ctx, "self-started resources (gateway/weixin/skiff-debug faces + weixin bridges)", disposeAll);
+	registerDisposer(ctx, "self-started resources (gateway/weixin/trajectory-debug faces + weixin bridges)", disposeAll);
 }
 //#endregion
 //#region src/patches/web-fetch.ts
@@ -22764,7 +22786,7 @@ async function applyOpencodeAutoConfigOnce(ctx, env) {
 *
 * 为什么要重试：`llm-pi-ai` 只在**它自己的** `ctx.inject(['settings'])` 回调里注册命名空间，
 * 与本插件 apply **无先后保证**（两者都依赖 settings 服务）。首次读取拿到 undefined 是常态而非错误
-* （与 skiff 的 CCC root 重试同款问题、同款处置：v1.30.13 实证"只在 apply 时试一次 → 永不重试"）。
+* （与 轨迹约束的 CCC root 重试同款问题、同款处置：v1.30.13 实证"只在 apply 时试一次 → 永不重试"）。
 */
 const NAMESPACE_RETRY_DELAYS_MS$1 = [
 	1e3,
@@ -22776,7 +22798,7 @@ const NAMESPACE_RETRY_DELAYS_MS$1 = [
 /**
 * 装配 opencode 路由自动配置。
 *
-* 触发面（三层，与 skiff 同款；R↓：单点触发在同装载竞态下必然漏）：
+* 触发面（三层，与 轨迹约束 同款；R↓：单点触发在同装载竞态下必然漏）：
 *   ① apply 时立即试一次
 *   ② 命名空间尚未注册 → 退避重试（1s/3s/8s/20s/40s）
 *   ③ `settings/updated` → 再试（用户热改 settings.yaml 加路由时自愈；自身写入触发的复评是幂等空转）
@@ -24371,7 +24393,7 @@ function renderDsl(model) {
 * 🔴 **为什么 PNG 是必需的**：宿主的对话内图片通路**白名单只有光栅格式**
 * （`image/png|jpeg|webp|gif`，见 `dsh-attachment/types.d.ts`）⇒ **SVG 进不去**。
 *
-* 🔴 **开关**：由 `index.ts` 门控（**关时不注册** ⇒ 工具根本不进模型工具清单），同 skiff 口径。
+* 🔴 **开关**：由 `index.ts` 门控（**关时不注册** ⇒ 工具根本不进模型工具清单），同 轨迹约束 口径。
 *
 * ## 🔴 两条**宿主契约**（2026-09-29 现场取证；第 ① 条是本文件第一版写错的地方）
 *
@@ -24741,10 +24763,6 @@ const Config = z.object({
 	opencodeSkills: z.boolean().default(true),
 	gateway: z.object({ enabled: z.boolean().default(false) }),
 	rebuild: z.object({ thresholdK: z.number().min(50).max(4e3).default(400) }),
-	skiff: z.object({
-		enabled: z.boolean().default(false),
-		debugPort: z.number().min(1024).max(65535).default(SKIFF_DEBUG_PORT)
-	}),
 	webFetch: z.object({ enabled: z.boolean().default(true) }),
 	opencodeProvider: z.object({ autoConfigure: z.boolean().default(true) }),
 	visionPatch: z.object({ enabled: z.boolean().default(true) }),
@@ -24757,8 +24775,6 @@ const Config = z.object({
 	}),
 	gatewayEnabled: z.boolean().volatile(),
 	rebuildThresholdK: z.number().min(50).max(4e3).volatile(),
-	skiffEnabled: z.boolean().volatile(),
-	skiffDebugPort: z.number().min(1024).max(65535).volatile(),
 	croEnabled: z.boolean().volatile(),
 	diagramEnabled: z.boolean().volatile()
 });
@@ -24825,7 +24841,6 @@ function apply(ctx, config) {
 	if (config.env) registerEnv(ctx);
 	if (config.opencodeSkills) registerOpencodeSkills(ctx);
 	registerBootstrap(ctx);
-	registerSkiff(ctx);
 	registerCroTurnTracking(ctx);
 	registerWakeScheduler(ctx);
 	registerWeixinBridge(ctx);
@@ -24849,7 +24864,7 @@ function apply(ctx, config) {
 *   ① 听宿主的**真事件** `settings/document-updated`（ns = 我们那张设置页）——顺带说明为什么不用
 *      我们自己的 `serenity/settings-changed`：那个事件**全仓没有任何 `emit` 点**（只有 `ctx.on` 侧
 *      在用）＝**死通道**，照着它接线等于接了个永远不响的铃；
-*   ② 兜底再挂 `agent/created` ／ `session/created`（与 skiff 同款做法，那两条在实测里确实会 fire）
+*   ② 兜底再挂 `agent/created` ／ `session/created`（与 轨迹约束 同款做法，那两条在实测里确实会 fire）
 *      —— 宿主事件面若换名，至少还有这一条能自愈；
 *   ③ 启动时同步一次（apply 时按当前配置定初始态）。
 * 🔴 **关的时候要注销**（不是"留着但不响应"）：与"关时不注册"同一口径 —— 工具不出现在模型清单里。
@@ -24887,139 +24902,5 @@ function registerDiagramTool(ctx) {
 	} catch {}
 	sync();
 }
-/**
-* F4 Skiff 调试服务装配：启停 = 人工（设置面板 Skiff 区块开关，settings 持久化）。
-* settings-changed 事件触发同步（skiffEnabled 开 → 启动调试服务；关 → 停止）。
-* 角色配置（skiff.roles）从当前 CCC 根读取（含 skiff.roles 的 CCC 优先，进程 cwd 次之）。
-*
-* v1.30.13（S142 诊断 D1）：**CCC root 解析失败不再"永不重试"**。旧实现只在 apply 时
-* 同步一次——此刻通常还没有 live 会话，进程 cwd（服务启动目录）也不在 CCC 内 →
-* `resolveSkiffRoot` 返回 null → 打印一行警告后**永不重试**（实证：重启日志
-* `✗ Skiff 调试服务未启动：无法定位 CCC root`，`ss -ltn` 无 3099；同批 ACP 因容忍
-* `root ?? undefined` 而正常启动 —— ⚠️ **该对照已随面 E 退役而失效**（2026-10-15），
-* 但本条记录的**病因与修法不受影响**（Skiff 侧仍是"首次未定位 → 曾永不重试"）。
-*
-* v1.30.14（重启日志实证后的收敛）：**并发启动守卫** + 首次未定位降级为信息级日志。
-*  - 实证（v1.30.13 重启日志）：定时触发与"会话就绪"事件几乎同时到达 → 两次 sync 都
-*    看到 `started === false` → **两次 start**（第一次绑定成功、第二次 `EADDRINUSE` 刷错误日志）。
-*    → 加 `starting` 在飞标志（启动 Promise settle 前不再重复发起）。
-*  - 首次未定位**不是失败**（apply 时无 live 会话是常态）→ 用 `console.log` 说明"等待 live 会话"。
-*
-* v1.35（C2，S142 2026-09-15 Q5）：**退避重试定时器退场**。原形态是 ① 启动同步
-* ② 退避重试（1s/3s/8s/20s/40s） ③ 会话就绪事件再触发。C2 把 CCC 发现面归一后，
-* ② 的病灶（"apply 时刻解析不到根"）改由 **`resolveSkiffRoot` 第 ④ 档（ccc-roots 的
-* **并集**枚举：工作区注册表 ∪ 持久化会话 ∪ live 会话）** 从源头消掉——持久来源不依赖
-* 任何 live 会话，故 apply 时刻就能解析到，不再需要"等一会儿再试"。
-*
-* 🔒 **必须保留**（它们不是"重试"，删了会引入新缺陷）：
-*  - **反应式再触发**（`agent/created` / `session/created` → sync）：宿主重启后
-*    "恢复"旧会话不触发 `session/created`，但**开始对话**会触发 `agent/created`
-*    （v0.1.7 前名 `agent/session-start`）——这是唯一能把"进程起来时还解析不到、稍后才有会话"
-*    这条路径接上的通道。
-*  - **`starting` 在飞标志**：防同拍双次 start → `EADDRINUSE`。
-*    （C4 块 A 备注：面宿主亦按面名合并在飞启动，是第二道保险；**本标志仍保留**——
-*    它管的是"解析 root 这段装配流程"的在飞语义，且调试服务的启动替身在测试里被 mock，
-*     面宿主的 active 表在那种场景下为空，不能当作 `started` 的替代。）
-*  - **`informedRoot` 信息级日志**（只报一次，不刷屏）、`serenity/settings-changed` 监听、
-*    启动时那次 `sync()`。
-*/
-function registerSkiff(ctx) {
-	let started = false;
-	let starting = false;
-	let informedRoot = false;
-	/** 已解析到的根（成功后缓存，避免每次 sync 重复解析） */
-	let resolvedRoot = null;
-	const sync = async () => {
-		const s = readSimpleSettings();
-		if (s.skiffEnabled) {
-			if (started || starting) return;
-			starting = true;
-			try {
-				const root = resolvedRoot ?? await resolveSkiffRoot(ctx);
-				if (!root) {
-					if (!informedRoot) {
-						informedRoot = true;
-						console.log("[serenity-hooks] Skiff 调试服务等待 CCC root（此刻无已知 CCC；会话就绪即试）");
-					}
-					return;
-				}
-				resolvedRoot = root;
-				const webPort = readWebPort(ctx);
-				await startSkiffDebugServer(ctx, root, s.skiffDebugPort, webPort);
-				started = true;
-			} catch (err) {
-				console.error(`[serenity-hooks] ✗ Skiff 调试服务启动失败: ${String(err?.message ?? err)}`);
-			} finally {
-				starting = false;
-			}
-			return;
-		}
-		if (started) {
-			stopSkiffDebugServer();
-			started = false;
-		}
-		resolvedRoot = null;
-		informedRoot = false;
-	};
-	try {
-		ctx.on("serenity/settings-changed", () => {
-			sync();
-		});
-	} catch {}
-	for (const eventName of ["agent/created", "session/created"]) try {
-		ctx.on(eventName, () => {
-			if (!started) sync();
-		});
-	} catch {}
-	sync();
-}
-/**
-* 解析 Skiff 调试服务绑定的 CCC 根（v1.25.2 用户指出：skiff 必须绑定 CCC）：
-* ① live 会话中**配置了 skiff.roles 的 CCC 优先**（用户认知中的绑定目标）
-* ② 回退进程 cwd 上溯 .serenity
-* ③ 再回退任一 live 会话的 CCC
-* ④ **（v1.35 / C2 新增）ccc-roots 枚举出的 CCC——仅在唯一候选时采用**
-*
-* 第 ④ 档为什么存在：①②③ 全部依赖 live 会话或进程 cwd；宿主重启、浏览器尚未重连时
-* 三者可能同时落空，而 `ccc-roots.listCccs` 的**持久来源**（工作区注册表 / 持久化会话）
-* 不依赖 live 会话 ⇒ 这正是"apply 时刻就能解析到根"的那条路，也是退避重试定时器
-* 得以退场的原因。
-*
-* ④ 的收敛条件（**不猜**）：只在候选**唯一**时采用；多个候选 → 返回 `null`
-* （留着让 ①②③ 的语义与人类的显式选择决定，不代替人拍板）。
-*
-* ⚠️ ①②③ 的**逐条优先级不变**；④ 只追加在末尾。
-*/
-async function resolveSkiffRoot(ctx) {
-	const liveRoots = [];
-	try {
-		const sessions = hostSessions(ctx);
-		for (const s of sessions?.list?.() ?? []) {
-			const cwd = s?.header?.cwd;
-			if (typeof cwd === "string") {
-				const r = cccRootForCwd(cwd);
-				if (r && !liveRoots.includes(r)) liveRoots.push(r);
-			}
-		}
-	} catch {}
-	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];
-	try {
-		const entries = await listCccs(ctx);
-		if (entries.length === 1) return entries[0].root;
-	} catch {}
-	return null;
-}
-/** 主 WebUI 端口（WebUI 链接；webServer 未装配回退集中端口表的 main 面端口） */
-function readWebPort(ctx) {
-	try {
-		const ws = hostWebServer(ctx);
-		return typeof ws?.port === "number" ? ws.port : MAIN_WEB_PORT;
-	} catch {
-		return MAIN_WEB_PORT;
-	}
-}
 //#endregion
 export { Config, apply, humanChannelAccountSchema, humanChannelSubscriptionSchema, inject, name };