@shgroup/dsh-serenity-hooks 1.63.2 → 1.65.0

package/lib/index.js

@@ -1,12 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-GIJ3A_tw.js";
-import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readExclusiveTools, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-B0ZGL9lx.js";
-import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-B4P3Uw6D.js";
-import { a as readGitTrack, c as unsetEntry, i as localstorePath, l as writeEntry, n as checkLocalstoreGitCompliance, o as readStore, r as getEntry, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./localstore-ops-DMs_ovHo.js";
-import { a as FACE_PORTS, c as MECHANISM_PORTS, d as registerSkiffSession$1, f as skiffRoleFor$1, h as ACC_VERSION, i as ACP_PORT, l as SKIFF_DEBUG_PORT, m as unregisterSkiffSession$1, n as readSimpleSettings, o as GATEWAY_PORT, p as skiffSessionInfo$1, r as registerSettingsSection, s as MAIN_WEB_PORT, u as WEIXIN_SEND_PORT } from "./settings-section-DGUQZo5j.js";
-import { a as readSkiffRoles, c as roleMsmWhitelist, d as systemPromptSource, f as trajectorySubset, i as isSkiffSessionId, l as roleToolWhitelist, n as buildSkiffBasePrompt, o as resolveRoleSystemPrompt, r as createRolePromptReader, s as resolveSkiffKind } from "./skiff-role-B615L9MV.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-RMzGU-CJ.js";
+import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readSafeModeHiddenTools, i as findGitRoot, l as pathInside, m as readExclusiveTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readCognitiveTrajectorySkills, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-C33QWoWZ.js";
+import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as COGNITIVE_TRAJECTORY_ACTIONS, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionCognitiveTrajectoryLabel, u as DEFAULT_SESSION_SCOPE, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source--2veY0JU.js";
+import { a as readGitTrack, c as unsetEntry, i as localstorePath, l as writeEntry, n as checkLocalstoreGitCompliance, o as readStore, r as getEntry, s as runLocalStore, t as LOCALSTORE_SCOPES } from "./localstore-ops-ylQoPz1Q.js";
+import { a as FACE_PORTS, c as MECHANISM_PORTS, d as registerSkiffSession$1, f as skiffRoleFor$1, h as ACC_VERSION, i as ACP_PORT, l as SKIFF_DEBUG_PORT, m as unregisterSkiffSession$1, n as readSimpleSettings, o as GATEWAY_PORT, p as skiffSessionInfo$1, r as registerSettingsSection, s as MAIN_WEB_PORT, u as WEIXIN_SEND_PORT } from "./settings-section-B1YzjFz6.js";
+import { a as isSkiffSessionId, c as resolveSkiffKind, f as systemPromptSource, i as createRolePromptReader, l as roleMsmWhitelist, n as buildSkiffBasePrompt, o as readSkiffRoles, r as cognitiveTrajectorySubset, s as resolveRoleSystemPrompt, u as roleToolWhitelist } from "./skiff-role-Boc4SKct.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
-import { a as readWeixinCredential, c as weixinInboundDir, i as matchWeixinRoute, l as weixinSessionIdFor, n as extractWeixinText, o as readWeixinSettings, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-Aheyq3fN.js";
+import { a as readWeixinCredential, c as weixinInboundDir, i as matchWeixinRoute, l as weixinSessionIdFor, n as extractWeixinText, o as readWeixinSettings, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-BoSC-uPp.js";
 import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-BrRcPiQs.js";
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
@@ -1073,7 +1073,7 @@ const NPX_BIN = process.platform === "win32" ? "npx.cmd" : "npx";
 const ACC_CATALOG = `═══ ACC Usage Catalog ═══
 Directory of ACC capabilities — each area lists where to go for details (guides live with their feature; this catalog only points).
 
-  ① 轨迹本体          → container_trajectory（list/show/create/use + rebuild 超限重建 + send-now 即时投递 + send-later 未来一次性唤醒
+  ① 轨迹本体          → cognitive_trajectory（list/show/create/use + rebuild 超限重建 + send-now 即时投递 + send-later 未来一次性唤醒
                           + cro-guide CRO 编写指南）
                          原 logbook 已并入（v1.33 用户裁决：废除 logbook 词）；close/archive 删（归档走 container_fs mv），
                          health/qa/summary 分别并入 use / list，hook-develop-guide 并进 container_admin msm guide
@@ -1087,15 +1087,15 @@ Directory of ACC capabilities — each area lists where to go for details (guide
   ④ 角色与对外面      → container_admin role（Skiff 认知子集角色：guide/validate/apply/list——skiff_admin 已并入）
                          3099 Skiff 调试问答页（人工调试面）。🔴 2026-10-15：自造 ACP 面已退役
                          ⇒ 外部程序化接入改走官方 dsh --profile acp ＋ 现成 ACP 客户端
-  ⑤ 自主与接入        → container_trajectory send-now（跨轨迹的**即时**递送，**不排队**：live 目标在跑就当场注入当前轮、空闲则立即起轮；非 live 冷载入——等效于直接 wake；**有同步回执**）
-                         container_trajectory send-later（跨轨迹的"未来时刻 + 一条 message"；fire-and-forget，无回执无回收）
+  ⑤ 自主与接入        → 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/trajectory/weixin/**exclusiveTools**）
+  ⑥ CCC 配置总览      → container_admin msm ccc-config（9 段：cheap-worker/sessionKeeper/localstore/hooks/safeMode/skiff/cognitiveTrajectory/weixin/**exclusiveTools**）
   ⑦ 注册表与安全      → 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 供给：trajectory.skills（v1.44.0——**本 CCC 每条轨迹都带**，含 skiff 会话；与轨迹自己的 frontmatter 声明取并集）
+                         CCC 级 skill 供给：cognitiveTrajectory.skills（v1.44.0——**本 CCC 每条轨迹都带**，含 skiff 会话；与轨迹自己的 frontmatter 声明取并集）
 
 每区：一句话定位 + 详细入口（工具名 / guide 子命令）。详情永远以对应工具的 guide/ccc-config 为单一真相源。
 `;
@@ -1181,7 +1181,7 @@ cheap-worker（杂工）工具可用模型白名单（provider/model 列表）
     { "cheap-worker": { "models": ["minimax-cn-coding-plan/MiniMax-M3"], "defaultModel": "minimax-cn-coding-plan/MiniMax-M3" } }
 
 ── 2. sessionKeeper.threshold / sessionKeeper.sessionMdMaxKB ──
-trajectory-assistant（TRAJECTORY-ASSISTANT · CHECKPOINT）提醒机制的积分阈值（非 headless 主 agent）。
+cognitive-trajectory-assistant（COGNITIVE-TRAJECTORY-ASSISTANT · CHECKPOINT）提醒机制的积分阈值（非 headless 主 agent）。
 按工具调用加权 + 耗时计分；达到阈值注入提醒，要求模型回复 ACK 码。
 
   Config:
@@ -1191,7 +1191,7 @@ trajectory-assistant（TRAJECTORY-ASSISTANT · CHECKPOINT）提醒机制的积
   默认：150
 
   ▸ sessionMdMaxKB（v1.31.1 新增，v1.31.2 缺省 100→200）：**活跃 SESSION.md 体积上限（KB，缺省 200；0 = 关闭）**。
-    超过 → 注入 [TRAJECTORY-ASSISTANT · LOGBOOK COMPACTION] 提醒：暂停当前工作 →
+    超过 → 注入 [COGNITIVE-TRAJECTORY-ASSISTANT · LOGBOOK COMPACTION] 提醒：暂停当前工作 →
     加载 eap（praxis eap）→ 按 EAP 分层骨架重写 SESSION.md。四条原则（ACC 内嵌，随提醒给出）：
     ① 保留 EAP 分层骨架（不压成时间流水账）② 内容可外移到 references 文件
     （AGENT_SESSIONS/<会话>/references/*.md，SESSION.md 留链接）③ 允许整合/删除不重要事项
@@ -1229,9 +1229,9 @@ safe-mode 由 WebUI 开关控制（写 .serenity-safe-on 标记）；黑名单
     { "safeMode": { "blacklist": [".secrets/"], "hiddenTools": ["workflow", "job_kill"] } }
 
 ── 6. skiff.roles（F4 认知子集角色）──
-Skiff 角色 = 全知全能 trajectory 的任意子集（CCC 定义）。每角色独立模型 + 双白名单
+Skiff 角色 = 全知全能 cognitive trajectory 的任意子集（CCC 定义）。每角色独立模型 + 双白名单
 （MSM 白名单 msms[] 与非 MSM 工具白名单 tools[]，白名单外全隐藏；skill 加载恒可用）。
-trajectory 纪律子集（session/keeper/rebuild 参与项）默认全关 = 完全独立。
+cognitive trajectory 纪律子集（session/keeper/rebuild 参与项）默认全关 = 完全独立。
 systemPrompt 内联 或 systemPromptFile（.md 引用，推荐）——角色会话的完整人格/边界提示词。
 validate 校验 / apply 生效 / list 查看：container_admin role <guide|validate|apply|list>（skiff_admin 已并入）。
 
@@ -1244,31 +1244,31 @@ validate 校验 / apply 生效 / list 查看：container_admin role <guide|valid
           "systemPromptFile": ".opencode/skiff/qa.md"
         } } } }
 
-── 7. container_trajectory（轨迹 + 唤醒注册表，D58）──
-CCC 的一条 trajectory = 持久身体（SESSION.md）+ 时间轴（AGENT_SESSIONS/ 目录 + 唤醒注册表）。
+── 7. cognitive_trajectory（轨迹 + 唤醒注册表，D58）──
+CCC 的一条 cognitive trajectory = 持久身体（SESSION.md）+ 时间轴（AGENT_SESSIONS/ 目录 + 唤醒注册表）。
 一个 CCC 内可多条并行；条目全部由人类/agent 显式登记。
 ⚠️ ACC 不再提供**周期自唤醒**（原 autopilot，2026-09-15 整段退场：机制/时钟/container_admin autopilot
 域/面板区块一并删除）。自主巡航改由 CCC 自己驱动（home-serenity 侧 msm autopilot-round 每轮自排下一轮，
-真相源 = S151 SESSION.md §1/§1b/§1c）。**本轮的 trajectory.autopilot 配置段保留**（见下表）——
+真相源 = S151 SESSION.md §1/§1b/§1c）。**本轮的 cognitiveTrajectory.autopilot 配置段保留**（见下表）——
 它现由 **CCC 侧脚本**读取，ACC 不再消费该段。
-唤醒注册表（container_trajectory send-later）：唤醒 = 未来时刻 + 一条 message，可唤醒自己或别的 trajectory；
+唤醒注册表（cognitive_trajectory send-later）：唤醒 = 未来时刻 + 一条 message，可唤醒自己或别的 cognitive trajectory；
 落点 AGENT_SESSIONS/wake-registry.json，中心调度器到点投递（fire-and-forget；无回执、无回收）。
 运行态诊断（ACC 负责人专用）：acc-diag（① live 运行态 / ①b 唤醒时钟 / ③ 唤醒注册表）。
 
-▸ trajectory.skills（v1.44.0，**CCC 级 skill 供给**；owner 令 2026-09-20「要求实现我的诉求……
+▸ cognitiveTrajectory.skills（v1.44.0，**CCC 级 skill 供给**；owner 令 2026-09-20「要求实现我的诉求……
   注入是动态注入就行；create 先不触发吧；**skiff 也支持**」）：
   **本 CCC 的每条轨迹都带这些 skill**——声明的 skill 全文在该轨迹**被绑定期间**注入系统提示词
   （**动态注入**：每请求重新求值、不缓存 ⇒ 改配置或改 frontmatter **即时生效**，无需重新 use、无需重启）。
-  两条声明来源**并集**（不是二选一）：本键 **trajectory.skills**（容器给的底座，**在前**）
+  两条声明来源**并集**（不是二选一）：本键 **cognitiveTrajectory.skills**（容器给的底座，**在前**）
   ＋ 轨迹自己 SESSION.md 顶部 frontmatter 的 skills:（这条轨迹额外的，**追加**；同名去重）。
   ✅ **含 skiff 角色会话**（旁路的是 ACC 身份与纪律；skill 是"工作资料"，照给）。
   守卫：名字先过安全校验才用于拼路径（防穿越）｜**合并后**统一 32 KB 上限截断｜找不到响亮写 [缺失]。
-  ⚠️ 与 create **无关**（create 刻意不夺绑定，U6）⇒ 注入的门是"**存在绑定**"（container_trajectory use）。
+  ⚠️ 与 create **无关**（create 刻意不夺绑定，U6）⇒ 注入的门是"**存在绑定**"（cognitive_trajectory use）。
   失败语义：未配置 / 字段缺失 / 配置损坏 ⇒ **空数组**（= 无 CCC 级供给；轨迹级声明照旧生效）。
   归属（D23）：**机制在 ACC**（读取 + 合并 + 注入 + 守卫），**声明在 CCC**（本键）。
 
   Config:
-    { "trajectory": {
+    { "cognitiveTrajectory": {
         "skills": ["acc-session", "cce"],   // v1.44.0：本 CCC 的每条轨迹都带（含 skiff 会话）
         "autopilot": {                   // 原 autopilotTrajectory 段，字段不变（旧键仍回退读）
           "enabled": true,
@@ -2036,7 +2036,7 @@ function scanSerenityDirs(skillsRoot) {
 /**
 * 防穿越：skill 名必须是简单目录名（拒绝分隔符与 `..`/`.` 路径段）。
 * v1.34.1：导出——轨迹 skill 声明（CCC 数据）的名字也要**先过这一关**才能用于拼路径
-* （规格 `docs/trajectory-skill-injection.md` §3「名字安全（必做）」）。
+* （规格 `docs/cognitive-trajectory-skill-injection.md` §3「名字安全（必做）」）。
 */
 function isSafeSkillName(name) {
 	if (name.length === 0) return false;
@@ -2129,7 +2129,7 @@ function truncateContent(content, maxChars) {
 *
 * 🔴 **两个面，两个入口**（2026-10-12 增；owner 裁决 O2）—— 同源、但成本形态不同：
 *    · **载入面** `buildResourceIndex()` —— 完整索引（名字 ＋ 首标题 ＋ 字节），带 `.md` 文件头读取；
-*      在三条路径上各附一次：入口段（`system-prompt.ts` order −50）／轨迹段（`trajectory-skills.ts`
+*      在三条路径上各附一次：入口段（`system-prompt.ts` order −50）／轨迹段（`cognitive-trajectory-skills.ts`
 *      order −45）／目录 provider 的 `get()`（`opencode-skills.ts`）。
 *    · **目录面** `buildResourceNameSuffix()` —— **只有名字**，**不读任何正文**；只挂一处：
 *      目录 provider 的 `list()`（`available_skills` 的 `SkillSummary.description`）。
@@ -2390,24 +2390,24 @@ function buildResourceNameSuffix(skillDir, options = {}) {
 	return `（参考件：${names.join(" / ")}${tail}）`;
 }
 //#endregion
-//#region src/trajectory-skills.ts
+//#region src/cognitive-trajectory-skills.ts
 /**
-* trajectory-skills.ts — 轨迹 skill 声明解析 + 注入内容装配（纯逻辑，零 DSH 依赖）
+* cognitive-trajectory-skills.ts — 轨迹 skill 声明解析 + 注入内容装配（纯逻辑，零 DSH 依赖）
 *
-* 接口真相源：`docs/trajectory-skill-injection.md` v1.0（§2 数据契约 / §3 注入契约）。
+* 接口真相源：`docs/cognitive-trajectory-skill-injection.md` v1.0（§2 数据契约 / §3 注入契约）。
 * 一句话：**轨迹自己声明它要挂哪些 skill**（`SESSION.md` 顶部 YAML frontmatter 的 `skills:`），
 * ACC 在**绑定期间**把这些 skill 的 `SKILL.md` 全文注入系统提示词。
 *
 * 分工（R↓：为什么解析与注册分开）：
 *   · 本模块 = **纯文本层**（解析 / 装配 / 安全判定）——可脱离 DSH 单测；
-*   · `seams/system-prompt.ts` 的 `registerTrajectorySkillSection` = **宿主接入层**
+*   · `seams/system-prompt.ts` 的 `registerCognitiveTrajectorySkillSection` = **宿主接入层**
 *     （per-agent `ctx.systemPrompt.section`），只做门与注册，不再解析文本。
 *
 * 边界（规格 §2.2）：**不解析** `skills` 以外任何键的语义（CCC 可自由使用，ACC 视而不见）；
 * **不改写** frontmatter（ACC 只读）。
 */
 /** 全文注入总长上限（字符数；规格 §3「缺省 32 KB」——防上下文爆炸） */
-const TRAJECTORY_SKILLS_MAX_CHARS = 32768;
+const COGNITIVE_TRAJECTORY_SKILLS_MAX_CHARS = 32768;
 /** 缺失标记（规格 §3/§6-3 的验收锚点：任何"拿不到全文"的情况都必须带它，绝不静默）
 *  🔴 2026-09-25（S142 分批清死代码·第 1 批）：**降为模块内常量**——全仓唯一消费者在本文件，
 *  导出只服务测试（测试用的是字面量 `'[缺失]'`）⇒ 导出面无意义。 */
@@ -2496,7 +2496,7 @@ function absoluteMdPath(root, mdPath) {
 *     （规格 §6-6 要求"不静默"；不注册就等于静默）
 * 其余（文件在但无 frontmatter / 无 `skills` 键 / 值为空）⇒ false，不注册、不产生噪声。
 */
-function hasTrajectorySkillsDeclaration(root, mdPath) {
+function hasCognitiveTrajectorySkillsDeclaration(root, mdPath) {
 	const abs = absoluteMdPath(root, mdPath);
 	if (!existsSync(abs)) return true;
 	try {
@@ -2521,7 +2521,7 @@ function normalizeNames(names) {
 * 合并两条声明来源（v1.44.0）：**CCC 级在前，轨迹级追加**，同名去重取首次位置。
 *
 * 两条来源（owner 令 2026-09-20）：
-*   · **CCC 级** = `.opencode/serenity.json` 的 `trajectory.skills`（本 CCC 所有轨迹共有的底座）；
+*   · **CCC 级** = `.opencode/serenity.json` 的 `cognitiveTrajectory.skills`（本 CCC 所有轨迹共有的底座）；
 *   · **轨迹级** = 该轨迹 `SESSION.md` frontmatter 的 `skills:`（这条轨迹额外的）。
 *
 * 为什么是**并集**而不是二选一（R↓）：C1 设计当初否决"纯 CCC 全局"的理由是"会**丢掉
@@ -2545,14 +2545,14 @@ function mergeSkillNames(cccSkills, trajSkills) {
 * @param root CCC 根
 * @param mdPath 轨迹的 SESSION.md 路径（**来自绑定的 `mdPath`**，不用 label 拼）
 * @param maxChars 总长上限（字符）
-* @param cccSkills CCC 级声明（`readTrajectorySkills`；缺省空 = 只有轨迹级，行为与 v1.43 一致）
+* @param cccSkills CCC 级声明（`readCognitiveTrajectorySkills`；缺省空 = 只有轨迹级，行为与 v1.43 一致）
 * @param onInjectedNames 观测回调（本次请求实际带上的 skill 名；**纯观测**，供用量统计用——
 *        回调抛错被吞，**不影响注入正文**）
 * @returns 注入正文；两条来源皆无声明 → `''`（空串 = 宿主不产出该 section 块）；
 *          SESSION.md 缺失/读失败 → 响亮提示（若同时有 CCC 级声明，则提示在前、正文随后——
 *          **提示不因"别处有内容"而被吞掉**）
 */
-function buildTrajectorySkillsSection(root, mdPath, maxChars = TRAJECTORY_SKILLS_MAX_CHARS, cccSkills = [], onInjectedNames) {
+function buildCognitiveTrajectorySkillsSection(root, mdPath, maxChars = COGNITIVE_TRAJECTORY_SKILLS_MAX_CHARS, cccSkills = [], onInjectedNames) {
 	const abs = absoluteMdPath(root, mdPath);
 	let trajNames = [];
 	let notice = "";
@@ -2631,7 +2631,7 @@ function buildTrajectorySkillsSection(root, mdPath, maxChars = TRAJECTORY_SKILLS
 * | 字段 | 含义 | 喂它的地方 |
 * |---|---|---|
 * | `skill.loads` | 模型**主动**调宿主 `skill` 工具（把某 skill 的 `SKILL.md` 全文载入） | `tools/post-execute`（工具名 = `skill`） |
-* | `skill.injections` | ACC **每请求注入**的 skill 段（`trajectory.skills` / 轨迹 frontmatter 声明） | `seams/system-prompt.ts` 的 trajectory-skills section 求值回调 |
+* | `skill.injections` | ACC **每请求注入**的 skill 段（`cognitiveTrajectory.skills` / 轨迹 frontmatter 声明） | `seams/system-prompt.ts` 的 cognitive-trajectory-skills section 求值回调 |
 * | `msm` | `msm` 工具的一次执行，按 **MSM 名**分桶 | `tools/post-execute`（工具名 = `msm`） |
 *
 * 🔴 **两者差好几个数量级**：`loads` 是模型的**动作**（稀疏），`injections` 是**请求的属性**（稠密）。
@@ -3220,7 +3220,7 @@ function toolsBlock() {
 		"The ACC (this plugin) provides the following built-in tools:",
 		"",
 		"  container_fs — container filesystem operations (15 subcommands: root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find)",
-		"  container_trajectory — one trajectory: its persistent body (SESSION.md) + its timeline. Lifecycle: list (inventory + stats) / show / create / use (activate; inline integrity check — silent when fine) / rebuild (clear-and-rebuild this conversation in place, Ship of Theseus); delivery: send-now (deliver one message RIGHT NOW; live target injected immediately, non-live cold-resumed like a direct wake — returns a synchronous receipt) / send-later (one future instant + one message to any trajectory; fire-and-forget — no receipt, no recall) / cro-guide (the CRO programming guide: how to give THIS trajectory its own program that decides when it should be woken)",
+		"  cognitive_trajectory — one cognitive trajectory: its persistent body (SESSION.md) + its timeline. Lifecycle: list (inventory + stats) / show / create / use (activate; inline integrity check — silent when fine) / rebuild (clear-and-rebuild this conversation in place, Ship of Theseus); delivery: send-now (deliver one message RIGHT NOW; live target injected immediately, non-live cold-resumed like a direct wake — returns a synchronous receipt) / send-later (one future instant + one message to any cognitive trajectory; fire-and-forget — no receipt, no recall) / cro-guide (the CRO programming guide: how to give THIS cognitive trajectory its own program that decides when it should be woken)",
 		"  dashboard    — always-on container instruments: health (CCC three-principle check + registry integrity) / time (now) / wait (N seconds)",
 		"  container_git— git operations (status/commit/push/log/pull/diff)",
 		"  msm          — execute a registered CCC MSM: msm(name, args); partial name returns candidates; inspect=true shows usage",
@@ -3256,7 +3256,7 @@ function cceBlock() {
 		"",
 		"1. Continuity — every interaction modifies the container's future state. Before",
 		"   acting, consult what came before — prior decisions, abstractions, constraints.",
-		"   You are part of a trajectory, not a fresh start.",
+		"   You are part of a cognitive trajectory, not a fresh start.",
 		"",
 		"2. Bounded Space — the container has boundaries. Respect them. Do not assume",
 		"   knowledge that has not been accumulated within this container.",
@@ -3307,10 +3307,10 @@ function principlesBlock(root, omitMsmPrinciples = false) {
 		"fault to be hidden. Never disguise or excuse what you do not know;",
 		"not-knowing is a state to be repaired, and reporting it is the first repair.",
 		"",
-		"The session-trajectory relation: a session is the rebuildable carrier of a",
-		"trajectory. SESSION.md is the trajectory's persistent body — it never moves;",
+		"The session–cognitive-trajectory relation: a session is the rebuildable carrier of a",
+		"cognitive trajectory. SESSION.md is the cognitive trajectory's persistent body — it never moves;",
 		"the current conversation is a temporary work copy that may be discarded and",
-		"rebuilt (container_trajectory rebuild). Identity belongs to the trajectory, not to any",
+		"rebuilt (cognitive_trajectory rebuild). Identity belongs to the cognitive trajectory, not to any",
 		"session.",
 		""
 	];
@@ -3409,15 +3409,16 @@ function metaphorBlock() {
 		"   ballast (constraints) before setting course. Verdict: skipping the",
 		"   inspection and launching directly = flying uninspected.",
 		"",
-		"7. The Ship's Log → Trajectory Tracking. SESSION.md is the trajectory's log —",
+		"7. The Ship's Log → Cognitive Trajectory Tracking. SESSION.md is the",
+		"   cognitive trajectory's log —",
 		"   the persistent body of the voyage; sessions are rebuildable carriers of",
-		"   the trajectory. Discard the carrier, keep the log. Unrecorded =",
+		"   the cognitive trajectory. Discard the carrier, keep the log. Unrecorded =",
 		"   unvoyaged. Verdict: finishing multi-step work without a progress record",
 		"   = a missing page.",
 		"",
 		"8. The Ship of Theseus → Continuity. Planks may be replaced; the ship",
 		"   remains the same. The container can be rebuilt; identity persists.",
-		"   You are part of a trajectory, not a new ship. Verdict: acting",
+		"   You are part of a cognitive trajectory, not a new ship. Verdict: acting",
 		"   without consulting precedent = a different ship.",
 		"",
 		"THE CREW — multi-agent collaboration",
@@ -3532,10 +3533,10 @@ function sessionBlock(root, scope = DEFAULT_SESSION_SCOPE) {
 	return [
 		"",
 		"=== Serenity Session ===",
-		`Active session: ${active.sessionId} — ${active.dirName} (this session is the rebuildable carrier of the trajectory)`,
-		`SESSION.md path: ${active.mdPath} (the trajectory's persistent body — stays in place through rebuilds)`,
+		`Active session: ${active.sessionId} — ${active.dirName} (this session is the rebuildable carrier of the cognitive trajectory)`,
+		`SESSION.md path: ${active.mdPath} (the cognitive trajectory's persistent body — stays in place through rebuilds)`,
 		"",
-		"Rules (SESSION.md is the trajectory log — keep its format & granularity fixed):",
+		"Rules (SESSION.md is the cognitive trajectory log — keep its format & granularity fixed):",
 		"  • Write only when a MILESTONE landed or a DECISION was made — not every round",
 		"  • One entry = one abstraction level, at the highest one that can express it:",
 		"    identity/anchors (rare) › decision (one line + rationale/rejected) › milestone",
@@ -3559,12 +3560,12 @@ function sessionBlock(root, scope = DEFAULT_SESSION_SCOPE) {
 		"This preserves the session context across todo updates.",
 		"Do NOT remove or reorder this item — keep it at position 0.",
 		"",
-		"TRAJECTORY-ASSISTANT: a background tracker scores your tool use (write/edit=3,",
+		"COGNITIVE-TRAJECTORY-ASSISTANT: a background tracker scores your tool use (write/edit=3,",
 		"task=10, read/grep/glob/msm=1, +1 per minute) and reminds you with a",
-		"[TRAJECTORY-ASSISTANT · CHECKPOINT] message when the threshold is reached. On every such",
+		"[COGNITIVE-TRAJECTORY-ASSISTANT · CHECKPOINT] message when the threshold is reached. On every such",
 		"reminder you MUST reply with the exact ACK code:",
-		"  [TRAJECTORY-ASSISTANT-recorded-{code}]  — if you recorded progress to SESSION.md",
-		"  [TRAJECTORY-ASSISTANT-skipped-{code}]  — if nothing to record this round",
+		"  [COGNITIVE-TRAJECTORY-ASSISTANT-recorded-{code}]  — if you recorded progress to SESSION.md",
+		"  [COGNITIVE-TRAJECTORY-ASSISTANT-skipped-{code}]  — if nothing to record this round",
 		"Do not ignore the reminder; do not stop ongoing work. Codes are single-use;",
 		"never reuse a prior code.",
 		""
@@ -3704,15 +3705,15 @@ function registerEntrySkillSection(agent, root) {
 	}
 }
 /**
-* 轨迹 skill 注入 section（规格 `docs/trajectory-skill-injection.md` §3，v1.34.1）。
+* 轨迹 skill 注入 section（规格 `docs/cognitive-trajectory-skill-injection.md` §3，v1.34.1）。
 *
 * **声明来源（两条，并集）**：
-*   · **CCC 级**（v1.44.0，owner 令）= `.opencode/serenity.json` 的 `trajectory.skills`
+*   · **CCC 级**（v1.44.0，owner 令）= `.opencode/serenity.json` 的 `cognitiveTrajectory.skills`
 *     ——**本 CCC 的每条轨迹都带**（含 skiff 角色会话），是容器给的底座；
 *   · **轨迹级** = 该会话绑定的轨迹（`readLastBound(session).mdPath` = 它的 `SESSION.md`）
 *     顶部 frontmatter 的 `skills:`——这条轨迹额外的。
-*   合并规则与顺序见 `trajectory-skills.mergeSkillNames`（CCC 级在前，同名去重）。
-*   正文 = 合并清单里各 skill 的 `SKILL.md` 全文（本模块只注册，装配在 `trajectory-skills.ts`）。
+*   合并规则与顺序见 `cognitive-trajectory-skills.mergeSkillNames`（CCC 级在前，同名去重）。
+*   正文 = 合并清单里各 skill 的 `SKILL.md` 全文（本模块只注册，装配在 `cognitive-trajectory-skills.ts`）。
 *
 * 为什么是 **per-agent scoped section**（与 `registerEntrySkillSection` 同形）：注入必须
 * **绑定期间持续存在**（a2）——一次性注入会随对话压缩消失，而 section 每次装配重新求值。
@@ -3723,21 +3724,21 @@ function registerEntrySkillSection(agent, root) {
 *     自动跟上（**动态注入，不缓存**），且绑定消失时返回 `''`
 *     （宿主 renderSections **丢弃空 section**，不残留噪声）。
 *
-* ⚠️ 路径取自绑定的 `mdPath`（权威记录），**不用** `resolveSessionTrajectoryLabel` 的显示 label
+* ⚠️ 路径取自绑定的 `mdPath`（权威记录），**不用** `resolveSessionCognitiveTrajectoryLabel` 的显示 label
 * 去拼路径——label 是模糊匹配的展示码，拼路径即模糊匹配当精确匹配用。
 *
 * @param agent 目标 agent（其 `session` 需有 `header.id` + `header.cwd`）
 * @param root 该 agent 的 CCC 根
 * @returns 是否**本次**完成注册（已注册过 / 门未过 → false）
 */
-const trajectorySkillAgents = /* @__PURE__ */ new Set();
-function registerTrajectorySkillSection(agent, root) {
+const cognitiveTrajectorySkillAgents = /* @__PURE__ */ new Set();
+function registerCognitiveTrajectorySkillSection(agent, root) {
 	const session = agent.session;
 	const key = session.id ?? "global";
-	if (trajectorySkillAgents.has(key)) return false;
+	if (cognitiveTrajectorySkillAgents.has(key)) return false;
 	const bound = readLastBound(session);
 	if (!bound) return false;
-	if (readTrajectorySkills(root).length === 0 && !hasTrajectorySkillsDeclaration(root, bound.mdPath)) return false;
+	if (readCognitiveTrajectorySkills(root).length === 0 && !hasCognitiveTrajectorySkillsDeclaration(root, bound.mdPath)) return false;
 	try {
 		agent.ctx.systemPrompt.section({
 			name: "serenity-trajectory-skills",
@@ -3745,10 +3746,10 @@ function registerTrajectorySkillSection(agent, root) {
 			text: () => {
 				const current = readLastBound(session);
 				if (!current) return "";
-				return buildTrajectorySkillsSection(root, current.mdPath, TRAJECTORY_SKILLS_MAX_CHARS, readTrajectorySkills(root), (names) => recordSkillInjections(root, names));
+				return buildCognitiveTrajectorySkillsSection(root, current.mdPath, COGNITIVE_TRAJECTORY_SKILLS_MAX_CHARS, readCognitiveTrajectorySkills(root), (names) => recordSkillInjections(root, names));
 			}
 		});
-		trajectorySkillAgents.add(key);
+		cognitiveTrajectorySkillAgents.add(key);
 		return true;
 	} catch {
 		return false;
@@ -3783,7 +3784,7 @@ const AUTO_BOUND_NOTE_PREFIX = "auto-created for skiff role";
 * 系统提示词中的**工作台纪律块**（v1.30.4 升级：从单行路径 → 完整 ACC 层约束）。
 * 用户点破（S142）：只给路径 LLM 不会主动用——需注入「已绑定 + 使用纪律 + 动作指引」。
 * SESSION = 工作台——skiff 与主舱同一套机制（零特调，用户拍板）：
-* 自动绑定已生效（无需 container_trajectory use）、SESSION.md 是持久记忆载体、rebuild 自动从本 SESSION 续接。
+* 自动绑定已生效（无需 cognitive_trajectory use）、SESSION.md 是持久记忆载体、rebuild 自动从本 SESSION 续接。
 * 注入 agent 系统提示词（用户对话面不可见）。
 *
 * v1.30.13（S142 诊断 D5）：写入纪律**不点名具体工具**。旧文案写死 "with write/edit"，
@@ -3793,10 +3794,10 @@ const AUTO_BOUND_NOTE_PREFIX = "auto-created for skiff role";
 * 具体通道由 CCC 的角色配置与角色提示词决定（ACC/CCC 归属二分；也不把某个 CCC 的
 * MSM 名硬编码进 ACC 源码）。
 */
-function workspaceTrajectoryLine(mdPath) {
+function workspaceCognitiveTrajectoryLine(mdPath) {
 	return [
 		"── Serenity Session Workspace ──",
-		"This role session is AUTO-BOUND to a trajectory workspace SESSION (no container_trajectory use needed):",
+		"This role session is AUTO-BOUND to a cognitive trajectory workspace SESSION (no cognitive_trajectory use needed):",
 		`  SESSION.md: ${mdPath}`,
 		"",
 		"Rules of the workspace:",
@@ -3809,7 +3810,7 @@ function workspaceTrajectoryLine(mdPath) {
 		"     Keep entries at milestone level (one line + evidence pointer); execution detail",
 		"     belongs in commit messages. Keep it current — it is",
 		"     what a rebuild resumes from.",
-		"  3. When context pressure is high, run container_trajectory rebuild — it auto-resumes from THIS SESSION.md",
+		"  3. When context pressure is high, run cognitive_trajectory rebuild — it auto-resumes from THIS SESSION.md",
 		"     (no manual use; do not switch to or read other SESSIONs unless the user explicitly asks).",
 		"  4. Never expose this internal path in user-facing replies (chat stays clean).",
 		"── ──"
@@ -3826,7 +3827,7 @@ const workspaceSectionAgents = /* @__PURE__ */ new WeakSet();
 * 用户原话（S142，2026-09-08）："微信桥的注入机制，每个用户消息都会注入，skiff 本身也会注入，
 * 这样就重复，能否微信桥情况下，注入内容直接取 skiff 的，这样不用配两遍"。
 *
-* 现状（改前）：`createSkiffAgent` 把 `workspaceTrajectoryLine(mdPath)` 塞进基础段
+* 现状（改前）：`createSkiffAgent` 把 `workspaceCognitiveTrajectoryLine(mdPath)` 塞进基础段
 * （创建时一次快照），微信桥又**每条消息**把同一文本拼进 question（v1.30.4 为覆盖
 * "live/existing 快路径不重挂提示词"而加）→ 新建 agent 首轮起即重复，且每轮重复付 token。
 *
@@ -3849,7 +3850,7 @@ function ensureWorkspacePromptSection(agent, scope) {
 			order: -55,
 			text: () => {
 				const mdPath = getActiveSessionInfo(scope)?.mdPath;
-				return mdPath ? workspaceTrajectoryLine(mdPath) : "";
+				return mdPath ? workspaceCognitiveTrajectoryLine(mdPath) : "";
 			}
 		});
 		workspaceSectionAgents.add(agent);
@@ -3868,7 +3869,7 @@ function ensureWorkspacePromptSection(agent, scope) {
 *    （调试页等**无固定会话 id**的临时 agent）→ null。理由（R↓）：这些 agent 每次
 *    调用都是新 id、无身份延续，为其建 SESSION = 每次问答留一个永久空目录（无界熵增）；
 *    用户模型「skiff 本质是临时会话机制」——工作台属于**持久身份**，不属于单次调用。
-* ① 角色未启用 session 能力（trajectory.session !== true）→ null（现状零变化）
+* ① 角色未启用 session 能力（cognitiveTrajectory.session !== true）→ null（现状零变化）
 * ② 已有**本机制自动创建**的 bound（note 前缀 auto-created）→ 恢复（重启/续接记得）
 * ②b 内存活跃记录（同 scope）→ 恢复 + **自愈补写绑定**（防御纵深：绑定写失败/事件形态未落盘时
 *    仍复用同一 SESSION，而不是每条消息新建一个——v1.30.5 及更早"每条消息一个 SESSION"的放大效应）
@@ -3879,7 +3880,7 @@ function ensureWorkspacePromptSection(agent, scope) {
 * @returns 绑定后的 SESSION.md 绝对路径（供提示词注入）；不适用/失败 → null
 */
 function ensureSkiffSession(root, agent, roleName, role, persistent = true) {
-	if (!trajectorySubset(role).session) return null;
+	if (!cognitiveTrajectorySubset(role).session) return null;
 	if (!persistent) return null;
 	const session = agent.session;
 	const scope = String(agent.session.id ?? agent.id);
@@ -3977,7 +3978,7 @@ async function createSkiffAgent(ctx, root, roleName, role, defaultModel, session
 		console.warn(`[serenity-hooks] skiff 系统提示词注册失败: ${String(err?.message ?? err)}`);
 	}
 	if (agent?.session) try {
-		registerTrajectorySkillSection(agent, root);
+		registerCognitiveTrajectorySkillSection(agent, root);
 	} catch (err) {
 		console.warn(`[serenity-hooks] skiff 轨迹 skill 注入注册失败（不影响 agent 创建）: ${String(err?.message ?? err)}`);
 	}
@@ -4078,7 +4079,7 @@ async function createOrResumeAgent(ctx, id, root, model, setup, fixedId) {
 /**
 * 会话事件读取（v1.28.0 适配 0.1.2-rc.1）：rc.1 Session 移除 `.events` 属性 → `snapshotEvents()` 方法。
 * 兼容双形态（运行时 rc.1 snapshotEvents；测试替身 events）——同一函数两处语义，测试注入零侵入。
-* 注：与 trajectory-ops.ts 导出的共享 `sessionEvents` 同构（v1.28.1 收敛基准）。本模块保留本地副本
+* 注：与 cognitive-trajectory-ops.ts 导出的共享 `sessionEvents` 同构（v1.28.1 收敛基准）。本模块保留本地副本
 * 以维持独立 import 面（零 DSH 依赖测试替身形态一致）；若未来重构可统一 import 共享版。
 */
 function sessionEvents(session) {
@@ -4099,7 +4100,7 @@ function lastAssistantText$1(agent) {
 	return "";
 }
 /** events → 可读轨迹（user/assistant 文本 + 工具调用 + 工具结果；单条解析失败跳过） */
-function eventsToTrajectory(events) {
+function eventsToCognitiveTrajectory(events) {
 	const out = [];
 	for (const raw of events) try {
 		const ev = raw;
@@ -4148,7 +4149,7 @@ function truncate(s, n) {
 * 提问一轮：followup → 等 idle → 读答案 + 轨迹。
 * @param eventsStart 轨迹起点：显式传 0 = 全量轨迹（会话追问时页面重绘完整时间线，
 *   v1.25.10 用户拍板）；不传（undefined）= 本轮增量（followup 前 events 之后）
-* @param options.includeTrajectory 是否计算轨迹（v1.26.10 起供**对外面**传 false 跳过计算——
+* @param options.includeCognitiveTrajectory 是否计算轨迹（v1.26.10 起供**对外面**传 false 跳过计算——
 *   原消费方 = 3100 公开问答页 / ACP JSON-RPC，**该面已于 2026-10-15 退役** ⇒ 现无生产调用方传 false；
 *   3099 调试页默认 true 保留）
 */
@@ -4163,24 +4164,24 @@ async function askSkiff(ctx, agent, question, eventsStart, options) {
 	}));
 	await waitAgentIdle(ctx, agent);
 	const answer = lastAssistantText$1(agent);
-	const trajectory = options?.includeTrajectory === false ? [] : eventsToTrajectory(sessionEvents(agent.session).slice(before));
+	const cognitiveTrajectory = options?.includeCognitiveTrajectory === false ? [] : eventsToCognitiveTrajectory(sessionEvents(agent.session).slice(before));
 	return {
 		answer,
 		sessionId: String(agent.session.id ?? ""),
-		trajectory
+		cognitiveTrajectory
 	};
 }
 /**
 * Skiff 会话的轨迹纪律参与判定：非 skiff 会话恒 true（正常参与）；
-* skiff 会话按角色 trajectory 子集（session/keeper/rebuild）决定；
+* skiff 会话按角色 cognitiveTrajectory 子集（session/keeper/rebuild）决定；
 * 注册表缺失（进程重启遗留等）→ 保守旁路（false，完全独立）。
 */
-function skiffTrajectoryEnabled(root, sessionId, key) {
+function skiffCognitiveTrajectoryEnabled(root, sessionId, key) {
 	if (!isSkiffSessionId(sessionId)) return true;
 	const roleName = sessionId ? skiffRoleFor(sessionId) : null;
 	if (!roleName) return false;
 	const role = readSkiffRoles(root).get(roleName);
-	return trajectorySubset(role)[key];
+	return cognitiveTrajectorySubset(role)[key];
 }
 /**
 * msm 工具的 Skiff 门控：非 skiff 会话恒放行；skiff 会话——
@@ -9626,9 +9627,9 @@ function cutoffDaysAgo(days, nowMs = Date.now()) {
 //#endregion
 //#region src/wake-registry.ts
 /**
-* wake-registry.ts — trajectory 唤醒注册表（D58，S142 2026-09-13）
+* wake-registry.ts — 认知轨迹唤醒注册表（D58，S142 2026-09-13）
 *
-* 需求（用户原话）：一个 CCC 内允许多个 trajectory 任意形态并行；某个 trajectory 可以
+* 需求（用户原话）：一个 CCC 内允许多个认知轨迹任意形态并行；某个认知轨迹可以
 * **预定未来唤醒自己或别人**，本质上是一次「未来时刻 + 一条 message」的投递；「周期自唤醒」
 * 曾是它的特例（原 ACC autopilot / D59，该机制已于 2026-09-15 整段退场）。协作边界：
 * 互相可见、**无阻塞无等待**。
@@ -9661,7 +9662,7 @@ function emptyRegistry() {
 	};
 }
 /** 条目形状校验（容忍手改：字段缺失/类型不符 → 丢弃该条，不阻断整表） */
-function asEntry$2(value) {
+function asEntry$1(value) {
 	const e = value;
 	if (!e || typeof e.id !== "string" || typeof e.target !== "string") return null;
 	if (typeof e.at !== "string" || typeof e.message !== "string") return null;
@@ -9695,7 +9696,7 @@ function loadWakeRegistry(root) {
 		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
 		const entries = [];
 		for (const item of raw) {
-			const e = asEntry$2(item);
+			const e = asEntry$1(item);
 			if (e) entries.push(e);
 		}
 		return {
@@ -9774,7 +9775,7 @@ function parseWakeAt(input, nowMs) {
 /**
 * 登记一条唤醒。
 * @param root CCC 根
-* @param input 目标 trajectory / 时刻串 / message / 发起者 / 当前时刻
+* @param input 目标认知轨迹 / 时刻串 / message / 发起者 / 当前时刻
 * @returns 成功返回条目，失败返回稳定错误文案（不抛错）
 */
 function addWake(root, input) {
@@ -10042,7 +10043,7 @@ const CRO_TIMEOUT_MS = 6e4;
 const CRO_STDOUT_MAX = 65536;
 /** 绑定文件体积上限（它只是个机器名 ⇒ 超过这个数一定是写错了，不读） */
 const CRO_HOST_FILE_MAX = 1024;
-/** SESSION.md 文件名（与 `trajectory-ops.ts` 同值；此处本地常量避免反向依赖） */
+/** SESSION.md 文件名（与 `cognitive-trajectory-ops.ts` 同值；此处本地常量避免反向依赖） */
 const SESSION_MD = "SESSION.md";
 /**
 * 展示码派生（**只用于展示**，不作识别依据 —— §0I U4：锚永远是 `dirName`）。
@@ -10323,7 +10324,7 @@ function parseCroHostBinding(raw) {
 * @param root CCC 根
 * @returns 启用了 CRO 的轨迹目录名（**排序后**，保证同 tick 顺序稳定、便于日志比对）
 */
-function listCroTrajectories(root) {
+function listCroCognitiveTrajectories(root) {
 	const rootDir = sessionsRoot(root);
 	let entries;
 	try {
@@ -10668,7 +10669,7 @@ const TURN_TTL_MS = 18e5;
 */
 const runningBySession = /* @__PURE__ */ new Map();
 /** 取载体 id（事件 payload 的 `agent` 面；取不到 ⇒ null） */
-function sessionIdOf$3(agent) {
+function sessionIdOf$2(agent) {
 	const id = agent?.session?.id;
 	return typeof id === "string" && id !== "" ? id : null;
 }
@@ -10754,23 +10755,23 @@ function registerCroTurnTracking(ctx) {
 		}
 	};
 	on("agent/created", (payload) => {
-		const id = sessionIdOf$3(payload?.agent);
+		const id = sessionIdOf$2(payload?.agent);
 		if (id) markTurnRunning(id, Date.now());
 	});
 	on("agent/status", (payload) => {
 		const p = payload;
-		const id = sessionIdOf$3(p?.agent);
+		const id = sessionIdOf$2(p?.agent);
 		if (!id) return;
 		const turn = typeof p.turn === "number" ? p.turn : null;
 		if (p.status === "running") markTurnRunning(id, Date.now(), turn);
 		else if (p.status === "idle") clearTurnRunning(id);
 	});
 	on("agent/turn-stopping", (payload) => {
-		const id = sessionIdOf$3(payload?.agent);
+		const id = sessionIdOf$2(payload?.agent);
 		if (id) clearTurnRunning(id);
 	});
 	on("agent/disposed", (payload) => {
-		const id = sessionIdOf$3(payload?.agent);
+		const id = sessionIdOf$2(payload?.agent);
 		if (id) clearTurnRunning(id);
 	});
 	on("session/disposed", (payload) => {
@@ -10788,10 +10789,10 @@ function registerCroTurnTracking(ctx) {
 *
 * ## 所有者令（本模块的存在理由）
 *
-* 「S151 和 S185 的验证都说明，trajectory 倾向于自己做个结构化记录来记录自身 CRO 的执行情况，
+* 「S151 和 S185 的验证都说明，认知轨迹倾向于自己做个结构化记录来记录自身 CRO 的执行情况，
 * 这是个结构化流水账；**我们 ACC 有必要进行 CRO 唤醒的日志记录**，当 CRO 存在时，每次**成功唤醒**
 * 写相关信息，但是保留数量要少，**只保留仅两日**的记录即可，**这个时间是程序化的**」
-* ＋「**这个日志写结构化文件到 trajectory 目录，文件名固定即可**」
+* ＋「**这个日志写结构化文件到认知轨迹目录，文件名固定即可**」
 * ＋「**失败成功都记录**」。
 *
 * ## 它解决什么麻烦（白话）
@@ -10839,14 +10840,14 @@ const CRO_LOG_VERSION = 1;
 function croWakeLogPath(root, dirName) {
 	return join(sessionsRoot(root), dirName, CRO_LOG_FILENAME);
 }
-function emptyLog$1() {
+function emptyLog() {
 	return {
 		version: CRO_LOG_VERSION,
 		entries: []
 	};
 }
 /** 条目形状校验（容忍手改：字段缺失/类型不符 → 丢弃该条，不阻断整档） */
-function asEntry$1(value) {
+function asEntry(value) {
 	const e = value;
 	if (!e || typeof e !== "object") return null;
 	if (typeof e.at !== "string" || e.at === "") return null;
@@ -10881,7 +10882,7 @@ function summarizeCroPrompt(prompt) {
 function loadCroWakeLog(root, dirName) {
 	const path = croWakeLogPath(root, dirName);
 	if (!existsSync(path)) return {
-		log: emptyLog$1(),
+		log: emptyLog(),
 		error: null
 	};
 	try {
@@ -10889,7 +10890,7 @@ function loadCroWakeLog(root, dirName) {
 		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
 		const entries = [];
 		for (const item of raw) {
-			const e = asEntry$1(item);
+			const e = asEntry(item);
 			if (e) entries.push(e);
 		}
 		return {
@@ -10901,7 +10902,7 @@ function loadCroWakeLog(root, dirName) {
 		};
 	} catch (err) {
 		return {
-			log: emptyLog$1(),
+			log: emptyLog(),
 			error: `CRO 流水解析失败（${String(err?.message ?? err)}）`
 		};
 	}
@@ -11196,10 +11197,10 @@ function createClock(opts) {
 //#endregion
 //#region src/wake-scheduler.ts
 /**
-* wake-scheduler.ts — trajectory 唤醒调度器（D58/D59/D60；S142 2026-09-13）
+* wake-scheduler.ts — 认知轨迹唤醒调度器（D58/D59/D60；S142 2026-09-13）
 *
 * 一个**中心调度器**（5min tick，复用 autopilot 的节律常量），处理 CCC 唤醒注册表里
-* 到期的条目：把「未来时刻 + 一条 message」投递给目标 trajectory，**fire-and-forget**
+* 到期的条目：把「未来时刻 + 一条 message」投递给目标认知轨迹，**fire-and-forget**
 * （无阻塞、无等待、无回执——发起方不 await，调度器不替模型结果负责）。
 *
 * 与 autopilot 的关系（D59）：**两个 tick 各自独立**。autopilot 是每 CCC 单例的
@@ -11251,7 +11252,7 @@ function resolveWakeTarget(root, target) {
 *
 * 历史（勿误读）：v1.34 S-1 曾把两闸解耦（周期自唤醒 `autopilotWakeEnabled` / 本钟 `wakeSchedulerEnabled`），
 * 理由是"关 auto-trajectory 不得连带关一次性唤醒"；随 ACC 侧 autopilot 于 v1.35.0 整段退场，
-* 两闸只剩本钟一座 ⇒ 现已整座移除。详见 `docs/trajectory-scheduling.md` §S-1 与 v1.44 CHANGELOG。
+* 两闸只剩本钟一座 ⇒ 现已整座移除。详见 `docs/cognitive-trajectory-scheduling.md` §S-1 与 v1.44 CHANGELOG。
 */
 /**
 * 🔴 **本钟的串行域**（C6b 硬约束）：`clock.chain` 是**本实例私有**的——
@@ -11265,15 +11266,15 @@ function resolveWakeTarget(root, target) {
 */
 /** 本钟的装配项（`ctx` 由 {@link registerWakeScheduler} 在装配点填入） */
 const clockOpts = {
-	label: "trajectory 唤醒调度器",
+	label: "认知轨迹唤醒调度器",
 	ctx: void 0,
 	events: ["session/created", "serenity/settings-changed"],
 	body: () => runWakeTick(clockOpts.ctx),
 	logFrom: {
-		prefix: "[serenity-hooks] trajectory 唤醒 ",
+		prefix: "[serenity-hooks] 认知轨迹唤醒 ",
 		lines: (lines) => lines
 	},
-	startLog: () => "[serenity-hooks] ✓ trajectory 唤醒调度器启动（5min tick）"
+	startLog: () => "[serenity-hooks] ✓ 认知轨迹唤醒调度器启动（5min tick）"
 };
 const clock = createClock(clockOpts);
 /** 调度器进程态快照（只读）。
@@ -11286,7 +11287,7 @@ function wakeSchedulerState() {
 * 取目标 agent：live 优先 → 冷会话走 sessionController.resolveAgent → 标题回退。
 * @param ctx 插件上下文
 * @param root CCC 根
-* @param dirName 目标 trajectory 目录名
+* @param dirName 目标认知轨迹目录名
 * @returns 命中返回 agent 与取得方式（how 进 lastResult，便于诊断）；未命中返回原因
 *   （原因带 `notReady` = **环境未就绪**而非投递失败，调用方**不得**据此记一次失败）
 *
@@ -11331,17 +11332,17 @@ async function acquireWakeAgent(ctx, root, dirName) {
 		}
 	}
 	return {
-		error: `无绑定会话记录（AGENT_SESSIONS/.bindings.json 中无 ${dirName}）——目标轨迹需先被 container_trajectory use 激活过`,
+		error: `无绑定会话记录（AGENT_SESSIONS/.bindings.json 中无 ${dirName}）——目标轨迹需先被 cognitive_trajectory use 激活过`,
 		noBinding: true
 	};
 }
 /** 唤醒消息（唤起即投递正文：身份锚定 + 唤醒信息 + 任务） */
 function buildWakeText(entry, target) {
 	return [
-		`[trajectory 唤醒] 到点（登记于 ${entry.createdAt}，发起者 ${entry.createdBy || "未知"}，id ${entry.id}）。`,
+		`[认知轨迹唤醒] 到点（登记于 ${entry.createdAt}，发起者 ${entry.createdBy || "未知"}，id ${entry.id}）。`,
 		`当前时间：${localHuman()}（当地时区）。`,
 		"",
-		`身份锚定：继续 ${target.dirName} 的 trajectory（SESSION.md: ${target.mdPath}）。`,
+		`身份锚定：继续 ${target.dirName} 的认知轨迹（SESSION.md: ${target.mdPath}）。`,
 		"",
 		"唤醒信息：",
 		entry.message,
@@ -11360,7 +11361,7 @@ async function deliverWake(ctx, root, entry) {
 	const target = resolveWakeTarget(root, entry.target);
 	if (!target) return {
 		ok: false,
-		detail: `目标 trajectory 未命中（${entry.target}）`
+		detail: `目标认知轨迹未命中（${entry.target}）`
 	};
 	const acquired = await acquireWakeAgent(ctx, root, target.dirName);
 	if ("error" in acquired) return {
@@ -11403,7 +11404,7 @@ function buildSendText(target, message, sender) {
 	return [
 		`[即时消息] 来自 ${sender || "未知轨迹"}。当前时间：${localHuman()}（当地时区）。`,
 		"",
-		`身份锚定：继续 ${target.dirName} 的 trajectory（SESSION.md: ${target.mdPath}）。`,
+		`身份锚定：继续 ${target.dirName} 的认知轨迹（SESSION.md: ${target.mdPath}）。`,
 		"",
 		"消息：",
 		message,
@@ -11412,7 +11413,7 @@ function buildSendText(target, message, sender) {
 	].join("\n");
 }
 /**
-* 即时投递（`container_trajectory send-now`）——与 `send-later`（预约）**共用取用通路**（`acquireWakeAgent`），
+* 即时投递（`cognitive_trajectory send-now`）——与 `send-later`（预约）**共用取用通路**（`acquireWakeAgent`），
 * 区别只在**时刻**（现在 vs 未来）与**回执**（有 vs 无）：
 *   · `send-later`（原 `wake-later`）：未来时刻 + 一条 message → 落注册表 → 本文件的调度器到点投递（**fire-and-forget，无回执**）
 *   · `send-now`（原 `send-message`）：**此刻**把一条 message 递给目标 → **同步回执** → **不落注册表**
@@ -11439,7 +11440,7 @@ function buildSendText(target, message, sender) {
 * 预约的本职是"到点唤起"，且在跑时排队不打断是它被实证验收过的行为，不顺手动它。
 *
 * **归属**：本函数放在调度器侧而非工具侧 —— "怎么把一句话送到一条轨迹"是**调度器的知识**，
-* 工具只该知道"有这个动作"。这样 `trajectory.ts` 完全不碰调度器内部（v1.35.0 硬约束①：
+* 工具只该知道"有这个动作"。这样 `cognitive-trajectory.ts` 完全不碰调度器内部（v1.35.0 硬约束①：
 * `send-later` 链路**一行为不动**，本次改动 = **纯新增**）。
 *
 * @param ctx 插件上下文
@@ -11449,11 +11450,11 @@ function buildSendText(target, message, sender) {
 * @param sender 发起者轨迹标识
 * @returns 投递结果（**同步**返回给调用方）
 */
-async function sendToTrajectory(ctx, root, target, message, sender) {
+async function sendToCognitiveTrajectory(ctx, root, target, message, sender) {
 	const t = resolveWakeTarget(root, target);
 	if (!t) return {
 		ok: false,
-		detail: `目标 trajectory 未命中（${target}）`
+		detail: `目标认知轨迹未命中（${target}）`
 	};
 	let acquired = await acquireWakeAgent(ctx, root, t.dirName);
 	let createdNote = "";
@@ -11558,7 +11559,7 @@ async function createAndBindTarget(ctx, root, dirName) {
 	const sc = hostService(ctx, "sessionController");
 	const create = sc?.create;
 	if (typeof create !== "function") return {
-		error: "目标无活跃 dsh 会话，且 sessionController.create 不可用（绑定 id: 无）——无法就地创建载体；请先对该轨迹执行一次 container_trajectory use",
+		error: "目标无活跃 dsh 会话，且 sessionController.create 不可用（绑定 id: 无）——无法就地创建载体；请先对该轨迹执行一次 cognitive_trajectory use",
 		notReady: true
 	};
 	const ws = findWorkspaceByPath(listWorkspaces(ctx) ?? [], root);
@@ -11693,7 +11694,7 @@ function findWorkspaceByPath(workspaces, root) {
 * （工作区注册表 ∪ 持久化会话 ∪ live 会话）：**没有 live 会话的 CCC 也会被扫到**。
 *
 * ⚠️ 边界（本步**只**改"枚举哪些 CCC"，**不改**"怎么找到要交付的 agent"）：
-* 把 message 交给某条 trajectory 仍必须靠 **live 会话**解析（见本文件
+* 把 message 交给某条认知轨迹仍必须靠 **live 会话**解析（见本文件
 * `acquireWakeAgent`）；无 live 会话时该 CCC 只是**被扫到、
 * 无交付对象** ⇒ `deliverWake` 返回 `无绑定会话记录…`，条目回 `pending` 并留痕。
 * 因此本函数**不得**让 tick 抛错（异常一律由调用方 tick 兜住，见 `runWakeTick` 的 try）。
@@ -11726,7 +11727,7 @@ function buildCroWakeText(dirName, mdPath, prompt, reason) {
 		`[CRO 唤起] ${dirName} 自带的 continuous-re-occurrence.ts 判定：现在该唤起。`,
 		`当前时间：${localHuman()}（当地时区）。`,
 		"",
-		`身份锚定：继续 ${dirName} 的 trajectory（SESSION.md: ${mdPath}）。`,
+		`身份锚定：继续 ${dirName} 的认知轨迹（SESSION.md: ${mdPath}）。`,
 		"",
 		`判定理由：${reason ?? "（程序未提供 reason —— 见 CRO 编写指南 §7 坑 3）"}`,
 		"",
@@ -11808,7 +11809,7 @@ async function runCroPhase(ctx, root, registry, log) {
 	}
 	let dirs;
 	try {
-		dirs = listCroTrajectories(root);
+		dirs = listCroCognitiveTrajectories(root);
 	} catch {
 		return;
 	}
@@ -11940,7 +11941,7 @@ async function runWakeTick(ctx) {
 function registerWakeScheduler(ctx) {
 	clockOpts.ctx = ctx;
 	clock.start();
-	registerDisposer(ctx, "trajectory 唤醒调度器", () => clock.dispose());
+	registerDisposer(ctx, "认知轨迹唤醒调度器", () => clock.dispose());
 }
 //#endregion
 //#region src/cro-guide.ts
@@ -11973,10 +11974,10 @@ function registerWakeScheduler(ctx) {
 * 不写任何真实机器路径或私有会话名 —— 本文件随 npm 包发布（2026-10-14 隐私核查）。
 */
 const CRO_SAMPLE_SNAPSHOT_INPUT = {
-	dirName: "2026-01-01--S001--example-trajectory",
+	dirName: "2026-01-01--S001--example-cognitive-trajectory",
 	cccRoot: "/home/user/workspace",
 	nowMs: 17898e8,
-	sessionMdPath: "/home/user/workspace/AGENT_SESSIONS/2026-01-01--S001--example-trajectory/SESSION.md",
+	sessionMdPath: "/home/user/workspace/AGENT_SESSIONS/2026-01-01--S001--example-cognitive-trajectory/SESSION.md",
 	sessionMdBytes: 182e3,
 	sessionMdMtimeMs: 1789799e6,
 	references: [{
@@ -12181,18 +12182,18 @@ ${renderCroSampleSnapshot()}
 **吃一份快照，吐一行决策。先自测，绿了再改名。**
 `;
 //#endregion
-//#region src/tools/trajectory.ts
+//#region src/tools/cognitive-trajectory.ts
 /**
-* trajectory.ts — `container_trajectory` 真实 DSH 工具定义（defineTool）
+* trajectory.ts — `cognitive_trajectory` 真实 DSH 工具定义（defineTool）
 *
 * v1.33（S142 §32 用户裁决）：由 `logbook` **更名并收敛为 `trajectory`**（v1.34：工具名再硬切为
-* `container_trajectory`，无别名）——trajectory 是一等概念
+* `container_trajectory`，无别名）——cognitive trajectory 是一等概念
 * （SESSION.md 是它的持久身体），本工具管它的**载体生命周期 + 一次性时间安排**。
 * 动作面现行 **8 个**：list / show / create / use / rebuild / **`send-now`** / **`send-later`** / **`cro-guide`**。
 * 🔴 2026-09-16（所有者裁决）：**第 7 个动作 `send-message`（即时投递）**
 *    ——与 `wake-later` 共用取用通路，差别只在**时刻**（现在 vs 未来）与**回执**（有 vs 无）；
 *    实现落在 `wake-scheduler.ts` 的 `sendToTrajectory()`（"怎么把一句话送到一条轨迹"是调度器的知识）。
-*    设计稿 = `docs/trajectory-send-message-design.md`（v0.2 定稿）。
+*    设计稿 = `docs/cognitive-trajectory-send-message-design.md`（v0.2 定稿）。
 * 🔴 2026-09-17（所有者裁决 · **命名 A 案**）：**两个投递动作更名** —— `wake-later` → **`send-later`**、
 *    `send-message` → **`send-now`**。判据（R↓）：两者本是**同一条投递通路**（同取用机制 / 同载荷 /
 *    同落点语义），只差**时刻**；而「唤醒（冷载入）」是**两条路径共有**的属性，不配做区分
@@ -12211,7 +12212,7 @@ ${renderCroSampleSnapshot()}
 *     归档能力由 `container_fs mv → _archived/` 承担
 *   · `hook-develop-guide` → **淘汰**（v1.34.1：SEP 整体废除——「能落 harness 已有原语，
 *     就不要自造协议 + 脚本管道」；轨迹挂哪些 skill 改由 SESSION.md frontmatter 声明 +
-*     `systemPrompt.section` 注入，见 `docs/trajectory-skill-injection.md`）
+*     `systemPrompt.section` 注入，见 `docs/cognitive-trajectory-skill-injection.md`）
 *   · autopilot 面（all/init/random/diag/doc/check/status/guide）→ `container_admin` 的 autopilot 域
 *   · `wake-add`/`wake-list`/`wake-rm` → **`wake-later`**（v1.33 收敛；**2026-09-17 更名 `send-later`**）
 *   · 2026-09-20（CRO 落地）：新增 **`cro-guide`** —— CRO 编写指南的出口（纯读）。
@@ -12319,40 +12320,40 @@ function renderText$3(value) {
 	}];
 }
 /**
-* 创建 trajectory 工具（原 logbook；v1.33 S142 §32 更名 + 动作收敛）。
+* 创建 cognitive trajectory 工具（原 logbook；v1.33 S142 §32 更名 + 动作收敛）。
 * 闭包捕获插件 ctx → use 后可调 ctx.sessionTitle.rename。
 */
-function createTrajectoryTool(ctx) {
+function createCognitiveTrajectoryTool(ctx) {
 	return defineTool({
-		name: "container_trajectory",
+		name: "cognitive_trajectory",
 		description: [
-			"container_trajectory — one trajectory: its persistent body (SESSION.md) + its timeline.",
-			"A trajectory is NOT the conversation: SESSION.md is the durable body and never moves;",
-			"the dsh conversation is only its rebuildable carrier (Ship of Theseus — the carrier is replaced, the trajectory continues).",
+			"cognitive_trajectory — one cognitive trajectory: its persistent body (SESSION.md) + its timeline.",
+			"A cognitive trajectory is NOT the conversation: SESSION.md is the durable body and never moves;",
+			"the dsh conversation is only its rebuildable carrier (Ship of Theseus — the carrier is replaced, the cognitive trajectory continues).",
 			"ACTIONS, grouped by EFFECT (read the grouping before picking one):",
-			"(A) LIFECYCLE — changes which trajectory THIS conversation is bound to:",
-			"list (inventory + stats + anomaly marks) / show (read one SESSION.md) / create (make a NEW trajectory) /",
-			"use (bind THIS conversation to an existing trajectory; inline integrity check — silent when fine, problems reported as hints, never errors) /",
+			"(A) LIFECYCLE — changes which cognitive trajectory THIS conversation is bound to:",
+			"list (inventory + stats + anomaly marks) / show (read one SESSION.md) / create (make a NEW cognitive trajectory) /",
+			"use (bind THIS conversation to an existing cognitive trajectory; inline integrity check — silent when fine, problems reported as hints, never errors) /",
 			"rebuild (clear-and-rebuild THIS conversation in place).",
-			"(B) DELIVERY — sends ONE message to ANOTHER trajectory; your own binding is unchanged:",
+			"(B) DELIVERY — sends ONE message to ANOTHER cognitive trajectory; your own binding is unchanged:",
 			"send-now (deliver RIGHT NOW) / send-later (deliver at ONE future instant).",
-			"(C) REFERENCE — cro-guide (how to give THIS trajectory its own program that decides when it should be woken).",
+			"(C) REFERENCE — cro-guide (how to give THIS cognitive trajectory its own program that decides when it should be woken).",
 			"HOW TO CHOOSE (a rule, not a guess):",
-			"not yet bound + starting new work ⇒ create — with no prior binding it activates immediately, so the new trajectory has a carrier at once.",
-			"already bound + recording a separate future line ⇒ create — it does NOT steal your binding (you stay on the current trajectory);",
+			"not yet bound + starting new work ⇒ create — with no prior binding it activates immediately, so the new cognitive trajectory has a carrier at once.",
+			"already bound + recording a separate future line ⇒ create — it does NOT steal your binding (you stay on the current cognitive trajectory);",
 			"activate the new one when you want it by sending it a message.",
-			"want THIS conversation to move to another trajectory ⇒ use (refuses when it would orphan the current binding; --force overrides).",
-			"want to poke another trajectory ⇒ send-now. Its target needs NO prior setup:",
+			"want THIS conversation to move to another cognitive trajectory ⇒ use (refuses when it would orphan the current binding; --force overrides).",
+			"want to poke another cognitive trajectory ⇒ send-now. Its target needs NO prior setup:",
 			"if the target has no live dsh session, one is created and bound automatically, and your message is injected into it.",
 			"RECEIPTS (read no more than is written): send-now returns a synchronous receipt meaning exactly \"injected / turn started\" —",
 			"NEVER \"the target ran or replied\"; to prove the target actually moved, read its SESSION.md.",
 			"It never queues behind the current turn: a busy target is steered mid-turn (read in the CURRENT turn), an idle target starts a turn at once.",
 			"send-later is fire-and-forget by design: no receipt, no recall, no panel.",
 			"ASYMMETRY (deliberate — the two differ in whether a missing target is normal): send-now creates a target on demand,",
-			"because sending to a never-used trajectory is a legitimate intent; send-later does NOT,",
-			"because scheduling for a trajectory that has never existed is almost always a mistyped name — auto-creating would hide that error behind an empty trajectory.",
+			"because sending to a never-used cognitive trajectory is a legitimate intent; send-later does NOT,",
+			"because scheduling for a cognitive trajectory that has never existed is almost always a mistyped name — auto-creating would hide that error behind an empty cognitive trajectory.",
 			"PARAMETERS: create requires --desc <desc> [--goal] or --issue <ticket> (exactly one) plus --summary (≤20 chars).",
-			"use requires --summary (≤20 chars) and may pass --force to switch away from the currently-bound trajectory.",
+			"use requires --summary (≤20 chars) and may pass --force to switch away from the currently-bound cognitive trajectory.",
 			"rebuild requires --summary (next-phase summary ≤20 chars) + optional --note (task focus for the rebuilt self).",
 			"send-later requires target (S### or AGENT_SESSIONS dir name) + at (RFC3339 or +30m/+2h) + message.",
 			"send-now requires target + message.",
@@ -12361,16 +12362,16 @@ function createTrajectoryTool(ctx) {
 		parameters: {
 			action: {
 				type: "string",
-				enum: [...TRAJECTORY_ACTIONS],
+				enum: [...COGNITIVE_TRAJECTORY_ACTIONS],
 				required: true,
 				description: [
 					"Subcommand — grouped by effect.",
 					"LIFECYCLE (changes THIS conversation's binding):",
 					"list (inventory + stats + anomaly marks) / show (S### or dir name or fuzzy keyword) /",
-					"create (new trajectory; activates itself when you have no binding, otherwise leaves your binding untouched and tells you how to activate it) /",
+					"create (new cognitive trajectory; activates itself when you have no binding, otherwise leaves your binding untouched and tells you how to activate it) /",
 					"use (activate context for THIS conversation; inline integrity check — pass silent, problems reported as hints, not errors) /",
 					"rebuild (clear-and-rebuild current conversation — requires --summary + optional --note).",
-					"DELIVERY (sends one message to ANOTHER trajectory; your binding is unchanged):",
+					"DELIVERY (sends one message to ANOTHER cognitive trajectory; your binding is unchanged):",
 					"send-now (deliver RIGHT NOW; the target needs no prior setup — if it has no live session, one is created and bound automatically) /",
 					"send-later (one future instant + one message; fire-and-forget, and it does NOT auto-create a target).",
 					"REFERENCE: cro-guide (no parameters: prints the CRO programming guide, including a ready-to-use sample snapshot)"
@@ -12402,7 +12403,7 @@ function createTrajectoryTool(ctx) {
 			},
 			force: {
 				type: "boolean",
-				description: "use: allow switching away from the currently-bound trajectory (binding guard override)"
+				description: "use: allow switching away from the currently-bound cognitive trajectory (binding guard override)"
 			},
 			dryRun: {
 				type: "boolean",
@@ -12410,7 +12411,7 @@ function createTrajectoryTool(ctx) {
 			},
 			target: {
 				type: "string",
-				description: "send-later/send-now: target trajectory (S### or AGENT_SESSIONS directory name)"
+				description: "send-later/send-now: target cognitive trajectory (S### or AGENT_SESSIONS directory name)"
 			},
 			at: {
 				type: "string",
@@ -12418,7 +12419,7 @@ function createTrajectoryTool(ctx) {
 			},
 			message: {
 				type: "string",
-				description: "send-later/send-now: the single message delivered to the target trajectory"
+				description: "send-later/send-now: the single message delivered to the target cognitive trajectory"
 			}
 		},
 		output: {
@@ -12468,7 +12469,7 @@ function createTrajectoryTool(ctx) {
 					return [
 						message,
 						`⚠ 本轨迹【未】被激活 —— 当前已绑定 ${priorBound}，保绑定优先（不夺走你正在用的轨迹）。`,
-						`  要激活它（并在它名下开一条会话）：用 container_trajectory send-now 向 ${result.dirName} 投一条消息 ——`,
+						`  要激活它（并在它名下开一条会话）：用 cognitive_trajectory send-now 向 ${result.dirName} 投一条消息 ——`,
 						`  目标若没有活跃 dsh 会话，会自动创建一条并把「使用提示词 ＋ 你的消息」一并注入。`
 					].join("\n");
 				}
@@ -12482,7 +12483,7 @@ function createTrajectoryTool(ctx) {
 					const currentDir = currentBoundDirName(exec, scope);
 					const switching = currentDir !== null && targetDirName !== currentDir;
 					const force = args.force === true;
-					if (switching && !force) throw new Error(`Session is bound to ${currentDir}. Switching to ${targetDirName} would orphan the current trajectory. Re-run with --force to switch (or close the current session first).`);
+					if (switching && !force) throw new Error(`Session is bound to ${currentDir}. Switching to ${targetDirName} would orphan the current cognitive trajectory. Re-run with --force to switch (or close the current session first).`);
 					const active = useSession(root, args.name, scope);
 					const info = getActiveSessionInfo(scope);
 					if (info) renameDshSessionForActive(ctx, exec, info, args.summary);
@@ -12536,7 +12537,7 @@ function createTrajectoryTool(ctx) {
 						target: args.target,
 						at: args.at,
 						message: args.message,
-						createdBy: resolveSessionTrajectoryLabel(exec.agent?.session, wakeScope === "default" ? "" : wakeScope),
+						createdBy: resolveSessionCognitiveTrajectoryLabel(exec.agent?.session, wakeScope === "default" ? "" : wakeScope),
 						nowMs: Date.now()
 					});
 					if (!res.ok) return {
@@ -12551,7 +12552,7 @@ function createTrajectoryTool(ctx) {
 				case "send-now": {
 					if (!args.target || !args.message) throw new Error("send-now requires target (S### or dir name) + message");
 					const sendScope = agentScope$1(exec);
-					const res = await sendToTrajectory(ctx, root, args.target, args.message, resolveSessionTrajectoryLabel(exec.agent?.session, sendScope === "default" ? "" : sendScope));
+					const res = await sendToCognitiveTrajectory(ctx, root, args.target, args.message, resolveSessionCognitiveTrajectoryLabel(exec.agent?.session, sendScope === "default" ? "" : sendScope));
 					if (!res.ok) return {
 						ok: false,
 						error: res.detail
@@ -12579,7 +12580,7 @@ function createTrajectoryTool(ctx) {
 */
 function renderWakeEntry(e) {
 	return [
-		"═══ trajectory 唤醒（1 条）═══",
+		"═══ cognitive trajectory 唤醒（1 条）═══",
 		`  · ${e.id}  [${e.state}]  at=${e.at}  target=${e.target}  by=${e.createdBy || "?"}`,
 		`      message: ${e.message.length > 120 ? `${e.message.slice(0, 120)}…` : e.message}`,
 		"",
@@ -12672,7 +12673,7 @@ const localstoreTool = defineTool({
 /** Skiff 定义教程（核心）：概念 / schema / 认知 MSM 写法 / 双白名单 / 轨迹纪律 / 示例角色 */
 const SKIFF_GUIDE = `═══ Skiff Definition Guide (F4, experimental) ═══
 
-Skiff = 宁静号放出的独立小艇——完整 trajectory（在宁静号内全知全能）的**任意子集角色**。
+Skiff = 宁静号放出的独立小艇——完整 cognitive trajectory（在宁静号内全知全能）的**任意子集角色**。
 由本 CCC（.opencode/serenity.json skiff.roles）定义：能力面（双白名单）+ 轨迹纪律子集 + 系统提示词。
 dsp 只提供机制（双白名单强制 + 基础提示词 + 调试问答页）；角色内容完全由 CCC 发挥。
 
@@ -12682,7 +12683,7 @@ dsp 只提供机制（双白名单强制 + 基础提示词 + 调试问答页）
         "model": "provider/model",             // 角色模型（CCC 直接指定，无白名单校验；缺省回退 cheap-worker.defaultModel）
         "msms": ["msm-a", "msm-b"],            // MSM 白名单（独立）：msm 工具只能执行这些；register/deregister 必拒
         "tools": ["read","grep","glob",...],   // 非 MSM 工具白名单（独立）：白名单外工具一律不可用（guard 强制）
-        "trajectory": { "session": false, "keeper": false, "rebuild": false },  // 轨迹纪律子集（缺省全关 = 完全独立）
+        "cognitiveTrajectory": { "session": false, "keeper": false, "rebuild": false },  // 轨迹纪律子集（缺省全关 = 完全独立）
         // 角色人格/认知边界/风格（CCC 完整定义；dsp 只给基础提示词）
         "systemPromptFile": ".opencode/skiff/<role>.md"   // ★ 推荐：引用 md 文件（相对 CCC 根；超长提示词在 JSON 内嵌不可读）
         // "systemPrompt": "..."                          // 兼容：内嵌字符串仍可用；两者都设时 systemPromptFile 优先
@@ -12700,14 +12701,14 @@ dsp 只提供机制（双白名单强制 + 基础提示词 + 调试问答页）
   - 例：cognitive-qa（读 docs/references 回答）、review-scan（读代码出审查意见）、review-fix（写修复）
   - 注意：MSM 在脚本层执行（bun），文件访问不受 agent 工具面约束——"只读"语义靠 CCC 自写 MSM 自觉
 
-── 轨迹纪律子集（trajectory）──
+── 轨迹纪律子集（cognitiveTrajectory）──
   - session/keeper/rebuild 默认 false：Skiff 完全独立（不建 SESSION.md、无 keeper 提醒、无 rebuild 压力检测）
   - 开启某项 = 该角色参与对应轨迹机制（如 keeper=true 计分提醒按角色生效）
 
 ── 示例角色 ──
-  qa-readonly: { "msms": ["cognitive-qa"], "tools": [], "trajectory": {} }
+  qa-readonly: { "msms": ["cognitive-qa"], "tools": [], "cognitiveTrajectory": {} }
       → 认知问答（仅 MSM 通道，无直接工具，完全独立）
-  code-review: { "msms": ["review-scan","review-fix"], "tools": ["read","grep","glob","write","edit"], "trajectory": { "keeper": true } }
+  code-review: { "msms": ["review-scan","review-fix"], "tools": ["read","grep","glob","write","edit"], "cognitiveTrajectory": { "keeper": true } }
       → 有操作能力（可写修复），参与 keeper 轨迹机制
 
 ── 运行 ──
@@ -12762,10 +12763,10 @@ function listSkiffRoles(root) {
 		model: role.model ?? "(cheap-worker default)",
 		msms: role.msms ?? [],
 		tools: role.tools ?? [],
-		trajectory: {
-			session: role.trajectory?.session === true,
-			keeper: role.trajectory?.keeper === true,
-			rebuild: role.trajectory?.rebuild === true
+		cognitiveTrajectory: {
+			session: role.cognitiveTrajectory?.session === true,
+			keeper: role.cognitiveTrajectory?.keeper === true,
+			rebuild: role.cognitiveTrajectory?.rebuild === true
 		},
 		promptSource: systemPromptSource(role),
 		...role.systemPromptFile ? { systemPromptFile: role.systemPromptFile } : {}
@@ -12941,447 +12942,6 @@ function createContainerAdminTool(ctx) {
 	});
 }
 //#endregion
-//#region src/unattended-ops.ts
-/**
-* unattended-ops.ts — 无人值守代理回复（unattended proxy）机制层（S142 **D77**，owner 2026-09-23 提案）
-*
-* ## 这东西用来干什么（白话）
-*
-* 用户发个任务就走开。现在模型干完一段就停下来等回话，用户不在 ⇒ **会话挂在那儿不动**。
-* 本机制 = 用户走开后，系统**代替用户说一句"继续"**：让它自己跑完；干完了用一个**验证码**报告；
-* 卡住了先自己想办法；真不能定的**写下来等用户回来**。
-*
-* ## 归属（D23：ACC 管机制与数据，CCC 管措辞与纪律）
-*
-* | 面 | 归谁 | 内容 |
-* |---|---|---|
-* | **机制** | 🔴 **ACC（本模块）** | 触发判定 / 验证码 / 四选一结构 / 轮上限 / 流水 |
-* | **不可代批的*具体内容*** | **CCC 纪律** | ACC 只给**通用下限**（{@link UNATTENDED_BLOCKED_FLOOR}），CCC 可加严 |
-*
-* 🔵 下限之所以落在 ACC（而不是"完全交给 CCC"）：**没有这张清单，"自行解决"＝把所有把关点自动放行**。
-* 最终内容仍待 owner 一句（设计 §13-5）——本版先给**保守下限**，CCC 只能在其上加严、不得放宽。
-*
-* ## 🔴 核心原则：单一续驱者（single-driver）
-*
-* > **一个会话同一时刻只应有一个"续驱者"：用户 ／ CRO ／ 自排绳 ／ 无人值守代理。**
-*
-* 口径（owner 2026-09-23 19:1x 裁决）= **窄口径：只排除「有 CRO 程序的轨迹」**。
-* 原「宽口径」（任何自排唤醒都排除）**作废** —— 它会让本机制**永远够不着靠续接绳活着的会话**，
-* 等于**放弃"代替旧机制"**（绳因此退化为**长周期保险丝**：6–12h 一条）。
-*
-* ## 🔴 铁律（与 `cro.ts` / `cro-log.ts` 同族，勿破）
-*
-* **本模块的每个导出函数都不抛错**：写盘 / 解析 / 裁剪失败一律返回结构化失败。
-* ⇒ 代理机制的任何问题**不影响 turn 收尾**、不影响既有链路（唤醒投递 / 输出守卫 / rebuild）。
-*
-* ## 🔴 为什么不构成第二真相源（勿删此论证）
-*
-* | 载体 | 谁写 | 主语 | 回答 |
-* |---|---|---|---|
-* | `<轨迹目录>/unattended-log.json`（**本模块**） | **ACC** | ACC | 「**我注入了什么、判了什么、放过没有**」 |
-* | `<轨迹目录>/SESSION.md` | **LLM（CCC）** | CCC | 「**这轮发生了什么、为什么这么定**」 |
-*
-* **内容不重叠**：本模块只记**机械事实**（轮次 / 验证码 / 判定理由码 / 是否放过），**不写散文**；
-* LLM 侧的散文与理由归 SESSION.md。完整审计 = 两者合看（本模块 = 注入面｜SESSION.md = 判断面）。
-*
-* ## 🔴 验证码形态（禁用 4 位字母码）
-*
-* 注入文本**自带**"请回复 ABCD" ⇒ 模型**复述指令**即**假完成**（高概率，不是小概率）
-* ⇒ 用**每轮新生成**的 nonce ＋ **包装 ＋ 独占一行**（`[[UNATTENDED-DONE:<hex>]]`），
-* 明写「**旧码作废**」，校验**只认当前轮**（防上下文里的旧码复活）。
-* 先例 = `cheap-worker` background 的 `SERENITY_CHEAP_WORKER_DONE_<16hex>`（同族实现）。
-*/
-/** 完成码包装前缀（**独占一行**才有意义；见文件头"禁用 4 位字母码"） */
-const UNATTENDED_DONE_PREFIX = "[[UNATTENDED-DONE:";
-/** 注入消息的**首行标记**（幂等可辨：模型与事后审计都能一眼看出这是代理消息，不是用户消息） */
-const UNATTENDED_PROXY_MARK = "[[UNATTENDED-PROXY v1]]";
-/** 🔴 合成消息**固定身份句**（owner 已裁：「形如用户消息，但首句自报身份与权限边界」） */
-const UNATTENDED_IDENTITY_LINE = "无人值守代理 · 非本人";
-/** 生成一枚新 nonce（**每轮一枚**；旧码作废由调用方在文本里声明） */
-function newNonce() {
-	return randomBytes(8).toString("hex");
-}
-/** 完成码全文（注入文本展示用；校验走 {@link hasDoneToken}） */
-function doneToken(nonce) {
-	return `${UNATTENDED_DONE_PREFIX}${nonce}]]`;
-}
-/**
-* 出现过的完成码 nonce 列表（按出现顺序、去重；**小写归一**）。
-* 容忍 8–64 位 hex（模型可能手抄多/少几个字符 ⇒ 那就不匹配，属预期：只认本轮那枚）。
-*/
-function parseDoneNonces(text) {
-	if (typeof text !== "string" || text === "") return [];
-	const re = /\[\[UNATTENDED-DONE:([0-9a-fA-F]{8,64})\]\]/g;
-	const out = [];
-	let m;
-	while ((m = re.exec(text)) !== null) {
-		const n = (m[1] ?? "").toLowerCase();
-		if (n !== "" && !out.includes(n)) out.push(n);
-	}
-	return out;
-}
-/** 触及即停（写待办/交接，**不循环**）——**CCC 的纪律更严则从严** */
-const UNATTENDED_BLOCKED_FLOOR = [
-	"发布 / 发版",
-	"对外发送（邮件 / 微信 / 对外面输出）",
-	"删除与不可逆操作（rm / 归档 / force push）",
-	"凭据与权限变更",
-	"花钱（外部 API 大额调用 / GPU 长任务）",
-	"代用户拍板（替人做决定）"
-];
-/** 四选一正文（{@link buildProxyMessage} 与 {@link buildFalseNotifyRebuke} 共用，避免两份措辞漂移） */
-function proxyBody(input) {
-	return [
-		`A) 已完成、且用户回来会满意 ⇒ 交码 ＋ 附完成凭据（做了什么 / 怎么验的 / 产物路径）`,
-		`B) 已成功向用户发出通知、要停下等他主动回来 ⇒ 交码 ＋ 写明走了哪个通道（**必须真有发送记录**）`,
-		`C) 需要确认但可自决 ⇒ 按「**最保守且可逆**」的选项继续做完（⚠️ **不要交码**，直接做）`,
-		`D) 触及不可代批边界 ⇒ **立即停**，把问题写进待办 / 交接，然后交码`,
-		``,
-		`不可代批的**通用下限**（你所在 CCC 的纪律更严则从严）：${(input.blocked ?? UNATTENDED_BLOCKED_FLOOR).join(" / ")}`,
-		``,
-		`交码 = **独占一行、逐字复制下面这一行**（旧码一律作废，只认本轮这个）：`,
-		``,
-		`    ${doneToken(input.nonce)}`,
-		``,
-		`禁止：把本条当真实用户的授权；禁止把本指令文本复述成回答；禁止什么都没做只回一个码；`,
-		`禁止借机发起**新的长任务**（代理只推进"已在办"的事）。`
-	].join("\n");
-}
-/** 组装一次代理注入消息（**形如用户消息，但首句自报身份与权限边界**） */
-function buildProxyMessage(input) {
-	return [
-		`${UNATTENDED_PROXY_MARK} round=${input.round}/${input.maxRounds} nonce=${input.nonce}`,
-		`${UNATTENDED_IDENTITY_LINE} —— 这条消息是**系统代用户发的**，不是用户本人；我没有任何权限替你拍板。`,
-		``,
-		`用户不在场。你只能以下列**四条之一**收束本轮：`,
-		``,
-		proxyBody(input)
-	].join("\n");
-}
-/**
-* 组装一次**假完成打回**消息（设计 §7 的机械核验分支：声称已通知用户，但本轮无发送记录）。
-*
-* ⚠️ 同样带**新 nonce**：它是一次"再来一轮"，不是"放过"。
-*/
-function buildFalseNotifyRebuke(input) {
-	return [
-		`${UNATTENDED_PROXY_MARK} round=${input.round}/${input.maxRounds} nonce=${input.nonce}`,
-		`${UNATTENDED_IDENTITY_LINE} —— 这条消息是**系统代用户发的**，不是用户本人。`,
-		``,
-		`🔴 你交的码是对的，但**你声称已通知用户，而我这边查不到任何发送记录** ⇒ **不算合法收束**。`,
-		`要么**真的发**（走可用通道；发成之后再交码），要么改走 A / C / D。其余口径同下。`,
-		``,
-		proxyBody(input)
-	].join("\n");
-}
-/**
-* 「收尾文本**声称**已联系用户」的**启发式**判据（设计 §7 的触发器，**不是**判据本身）。
-*
-* 🔴 机械判据 = **ACC 侧的发送记录**（{@link hasOutboundSendSince}）；本函数只回答"**要不要去查记录**"。
-* 误判方向（明标）：**误报**（模型换了个说法没被匹配到）⇒ 退回"只认码"，不产生假放过；
-* **误报**（正常措辞被当成声称）⇒ 多打回一轮（有轮上限兜底）。⇒ 偏严，符合设计 §11
-* 把"谎称已发消息"列为失败模式的取向。
-*/
-const NOTIFY_CLAIM_PATTERNS = [
-	/已(经)?(成功)?(向|给|和)?\s*(用户|您|你|他|她|本人|主人)?[^\n。]{0,16}(发送|发出|告知|通知|联系|留言|汇报)/,
-	/\b(?:notified|informed|messaged|contacted)\s+(?:the\s+)?user\b/i,
-	/\b(?:sent|sending)\s+(?:a\s+)?(?:message|notification|notice)\s+to\s+(?:the\s+)?user\b/i,
-	/\bI\s+(?:have\s+)?(?:notified|informed|messaged|contacted)\b/i
-];
-/** 收尾文本是否**声称**已联系用户（见 {@link NOTIFY_CLAIM_PATTERNS} 的误判方向说明） */
-function claimsUserNotification(text) {
-	if (typeof text !== "string" || text === "") return false;
-	return NOTIFY_CLAIM_PATTERNS.some((re) => re.test(text));
-}
-/**
-* **不许开**的会话（设计 §3 的"建议写死"，本版**确实写死**）：
-* `skiff-`（F4 问答 / **微信桥会话也是这个前缀** —— 桥那侧的"用户"是**家人**，
-* 代理替家人说话 = **冒充**）｜ `acp-`（对外程序化面 —— ⚠️ **2026-10-15 起已成死判据**：
-* 该前缀从无生产者且面 E 已退役；理由与"为何保留"见 `output-guard-seam.ts` 文件头）｜
-* `cheap-worker-`（自主 worker，已有自己的完成码循环）。
-*
-* ⚠️ **`rebuild-` 不在排除面**（与 `output-guard-seam.ts` 的取向**刻意不同**）：重建会话是
-* **同一轨迹的载体**（内部维护面），不是对外面；把它排除会让"重建后就没人推了"。
-*/
-function isProxyExcludedSessionId(sessionId) {
-	if (typeof sessionId !== "string" || sessionId === "") return true;
-	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("cheap-worker-");
-}
-/**
-* 一次判定的**唯一入口**（纯函数）。
-*
-* 顺序即语义（R↓，勿随意调换）：
-*  1. **闸/空间/会话资格**（关着、不在 CCC、非主会话、排除面）⇒ skip；
-*  2. **单一续驱者**：用户刚发起 ⇒ skip（人就在场）；该轨迹有 CRO ⇒ skip（程序在驱动）；
-*  3. **合法收束优先于轮上限** —— 最后一轮交的码必须算数（否则等于永远收不了尾）；
-*  4. 交码 ＋ 声称已通知 ＋ **无发送记录** ⇒ 假完成，走下一轮（reason=`false-notify`）；
-*  5. 墙钟 / 轮上限 ⇒ cap（**停下不动**，退回改造前的行为，不产生新风险）；
-*  6. 其余 ⇒ inject 下一轮。
-*/
-function decideUnattendedAction(f) {
-	if (!f.enabled) return {
-		action: "skip",
-		reason: "mode-off",
-		round: 0
-	};
-	if (!f.root) return {
-		action: "skip",
-		reason: "not-in-ccc",
-		round: 0
-	};
-	if (!f.isMainSession) return {
-		action: "skip",
-		reason: "not-main-session",
-		round: 0
-	};
-	if (f.sessionIdExcluded) return {
-		action: "skip",
-		reason: "excluded-session",
-		round: 0
-	};
-	if (f.userInitiated) return {
-		action: "skip",
-		reason: "user-initiated",
-		round: 0
-	};
-	if (f.hasCroProgram) return {
-		action: "skip",
-		reason: "cro-programmed",
-		round: 0
-	};
-	const run = f.run;
-	if (run !== null && f.doneNonce !== null && f.doneNonce.toLowerCase() === run.nonce.toLowerCase() && run) {
-		if (f.claimsNotify && !f.outboundSeen) {
-			if (run.round >= 15) return {
-				action: "cap",
-				reason: "round-cap",
-				round: run.round
-			};
-			return {
-				action: "inject",
-				reason: "false-notify",
-				round: run.round + 1
-			};
-		}
-		return {
-			action: "accept",
-			reason: "done-code",
-			round: run.round
-		};
-	}
-	if (run && f.nowMs - run.startedAt > 72e5) return {
-		action: "cap",
-		reason: "wall-clock",
-		round: run.round
-	};
-	if (run && run.round >= 15) return {
-		action: "cap",
-		reason: "round-cap",
-		round: run.round
-	};
-	const round = (run?.round ?? 0) + 1;
-	return {
-		action: "inject",
-		reason: run === null ? "first-stop" : f.doneNonce !== null ? "stale-code" : "no-legal-closure",
-		round
-	};
-}
-/** 键 = 载体（dsh 会话 id）——与 `cro-turns.ts` 同款选择（事件本身就以 agent/session 为主语） */
-const runs = /* @__PURE__ */ new Map();
-/** 取该会话的代理段（无 ⇒ null） */
-function getProxyRun(sessionId) {
-	return runs.get(sessionId) ?? null;
-}
-/** 开始 / 推进一段代理（`startedAt` 由调用方给出 ⇒ 跨轮保留首次值） */
-function setProxyRun(sessionId, run) {
-	if (!sessionId) return;
-	runs.set(sessionId, run);
-}
-/** 结束该会话的代理段（放过 / 上限 / 用户回来 / 载体销毁） */
-function clearProxyRun(sessionId) {
-	if (!sessionId) return;
-	runs.delete(sessionId);
-}
-/**
-* 「该载体最近一次由**真实用户**发起的轮次号」（会话 id → turn）。
-*
-* ⚠️ 只留**一条**（不是集合）：`claimed` 的 `turn` 单调递增，留最新一条即可回答
-* "本轮是不是用户发起的"，且**表的大小 = 会话数**（本容器栽过 5 次"只增不清"，此处结构性避免）。
-*/
-const userTurns = /* @__PURE__ */ new Map();
-/** 记下"这个载体的这一轮是真实用户发起的" */
-function noteUserTurn(sessionId, turn) {
-	if (!sessionId || typeof turn !== "number") return;
-	userTurns.set(sessionId, turn);
-}
-/** 该载体的这一轮是否由真实用户发起（判据 = `noteUserTurn` 写入的最新一条） */
-function isUserTurn(sessionId, turn) {
-	if (!sessionId || typeof turn !== "number") return false;
-	return userTurns.get(sessionId) === turn;
-}
-/** 清掉该载体的用户轮次记录（载体销毁时） */
-function clearUserTurn(sessionId) {
-	if (!sessionId) return;
-	userTurns.delete(sessionId);
-}
-/** 清空全部进程内运行态（disposer；**不碰磁盘**） */
-function clearUnattendedState() {
-	runs.clear();
-	userTurns.clear();
-	outboundSends.clear();
-}
-/** 发送记录保留窗（超出即丢：它只服务"这一轮到底发没发"这个瞬时问题） */
-const UNATTENDED_OUTBOUND_TTL_MS = 216e5;
-const outboundSends = /* @__PURE__ */ new Map();
-/**
-* 记一次**成功的**出站发送（`im-bridge` 工具面在通道返回成功后调用）。
-*
-* ⚠️ **覆盖边界（诚实标注）**：只覆盖 **ACC 自己这条通道**（`im-bridge` 的 send / send-file）。
-* CCC 自有的发送通道（如 `mail-tool` MSM）**ACC 看不见** ⇒ 那类"已通知"落到
-* {@link hasOutboundSendSince} = false ⇒ 会被判成假完成。⇒ 本版口径：**代理模式下"联系用户"
-* 只认 ACC 通道**；这与设计 §7 的原话（im-bridge 记日志）一致，边界写在此处以免误读。
-*/
-function noteOutboundSend(root, atMs = Date.now()) {
-	if (!root) return;
-	const list = outboundSends.get(root) ?? [];
-	list.push(atMs);
-	const cutoff = atMs - UNATTENDED_OUTBOUND_TTL_MS;
-	const kept = list.filter((t) => t >= cutoff).slice(-20);
-	outboundSends.set(root, kept);
-}
-/** 自 `sinceMs` 起该 CCC 是否有过成功出站发送（**只读，不清表**——清理归写入侧的裁剪） */
-function hasOutboundSendSince(root, sinceMs, nowMs = Date.now()) {
-	if (!root) return false;
-	const list = outboundSends.get(root);
-	if (!list || list.length === 0) return false;
-	const floor = Math.max(sinceMs, nowMs - UNATTENDED_OUTBOUND_TTL_MS);
-	return list.some((t) => t >= floor && t <= nowMs);
-}
-/** 固定文件名（与 `cro-wake-log.json` 并排、主语分明：那份记"我叫了什么"，这份记"我代说了什么"） */
-const UNATTENDED_LOG_FILENAME = "unattended-log.json";
-/** 保留窗 = 2 日（与 CRO 流水同值；**常量** ⇒ 无需人工清理动作） */
-const UNATTENDED_LOG_RETENTION_MS = 1728e5;
-const UNATTENDED_LOG_VERSION = 1;
-/** 日志绝对路径 */
-function unattendedLogPath(root, dirName) {
-	return join(sessionsRoot(root), dirName, UNATTENDED_LOG_FILENAME);
-}
-function emptyLog() {
-	return {
-		version: UNATTENDED_LOG_VERSION,
-		entries: []
-	};
-}
-/** 条目形状校验（容忍手改：字段缺失/类型不符 ⇒ 丢弃该条，不阻断整档） */
-function asEntry(value) {
-	const e = value;
-	if (!e || typeof e !== "object") return null;
-	if (typeof e.at !== "string" || e.at === "") return null;
-	if (e.event !== "inject" && e.event !== "accept" && e.event !== "cap" && e.event !== "yield") return null;
-	if (typeof e.reason !== "string") return null;
-	return {
-		at: e.at,
-		event: e.event,
-		round: typeof e.round === "number" ? e.round : 0,
-		nonce: typeof e.nonce === "string" ? e.nonce : null,
-		reason: e.reason,
-		sessionId: typeof e.sessionId === "string" ? e.sessionId : ""
-	};
-}
-/** 读取流水（**永不抛**；读坏 ⇒ 当作空档 + 返回 error 文本） */
-function loadUnattendedLog(root, dirName) {
-	const path = unattendedLogPath(root, dirName);
-	if (!existsSync(path)) return {
-		log: emptyLog(),
-		error: null
-	};
-	try {
-		const parsed = JSON.parse(readFileSync(path, "utf-8"));
-		const raw = Array.isArray(parsed.entries) ? parsed.entries : [];
-		const entries = [];
-		for (const item of raw) {
-			const e = asEntry(item);
-			if (e) entries.push(e);
-		}
-		return {
-			log: {
-				version: UNATTENDED_LOG_VERSION,
-				entries
-			},
-			error: null
-		};
-	} catch (err) {
-		return {
-			log: emptyLog(),
-			error: `无人值守流水解析失败（${String(err?.message ?? err)}）`
-		};
-	}
-}
-/**
-* 按窗裁剪（**纯函数** ⇒ 可穷举测试）。
-* 🔴 `at` 不可解析者**一律丢弃**并在返回值里报数（`dropped`）——**不静默吞掉**（同 `cro-log.ts` 纪律）。
-*/
-function pruneUnattendedLogEntries(entries, nowMs, windowMs = UNATTENDED_LOG_RETENTION_MS) {
-	const floor = nowMs - windowMs;
-	const kept = [];
-	let pruned = 0;
-	let dropped = 0;
-	for (const e of entries) {
-		const t = Date.parse(e.at);
-		if (Number.isNaN(t)) {
-			dropped += 1;
-			continue;
-		}
-		if (t >= floor) kept.push(e);
-		else pruned += 1;
-	}
-	return {
-		kept,
-		pruned,
-		dropped
-	};
-}
-/**
-* 追加一条流水并按窗裁剪（**本模块的落盘入口；永不抛**）。
-*
-* 顺序 = 读 → 追加 → 裁剪 → **原子写**（tmp + rename）。任一步失败 ⇒ `{ok:false, error}`，**不抛**
-* ——调用方只记一行 console 日志 ⇒ **代理机制的问题绝不影响 turn 收尾**。
-*/
-function appendUnattendedLog(root, dirName, entry, nowMs = Date.now()) {
-	if (!root || !dirName) return {
-		ok: false,
-		error: "缺少 CCC 根或轨迹目录名",
-		kept: 0
-	};
-	const path = unattendedLogPath(root, dirName);
-	try {
-		const loaded = loadUnattendedLog(root, dirName);
-		const full = {
-			at: isoLocal(nowMs),
-			...entry
-		};
-		const { kept } = pruneUnattendedLogEntries([...loaded.log.entries, full], nowMs);
-		mkdirSync(dirname(path), { recursive: true });
-		const tmp = `${path}.tmp`;
-		writeFileSync(tmp, `${JSON.stringify({
-			version: UNATTENDED_LOG_VERSION,
-			entries: kept
-		}, null, 2)}\n`, "utf-8");
-		renameSync(tmp, path);
-		return {
-			ok: true,
-			error: null,
-			kept: kept.length
-		};
-	} catch (err) {
-		return {
-			ok: false,
-			error: `无人值守流水写入失败（${String(err?.message ?? err)}）`,
-			kept: 0
-		};
-	}
-}
-//#endregion
 //#region src/im-bridge.ts
 /**
 * im-bridge.ts — IM 发送能力层（v1.31.0，S142 用户洞察）
@@ -13532,19 +13092,17 @@ async function runImBridge(root, req) {
 		const resolved = channel.resolveUser(root, rawUser);
 		if (!resolved) return fail("ALIAS_UNKNOWN", `unknown user "${rawUser}"`);
 		try {
-			const sent = await channel.send({
-				root,
-				userId: resolved.id,
-				text,
-				accountId: req.account
-			});
-			noteOutboundSend(root);
 			return {
 				ok: true,
 				channel: channelId,
 				action,
 				detail: {
-					...sent,
+					...await channel.send({
+						root,
+						userId: resolved.id,
+						text,
+						accountId: req.account
+					}),
 					user: resolved.alias ?? resolved.id
 				}
 			};
@@ -13563,21 +13121,19 @@ async function runImBridge(root, req) {
 		const file = readCccFile(root, fileArg);
 		if (!file.ok) return fail(file.code, file.error);
 		try {
-			const sent = await channel.sendFile({
-				root,
-				userId: resolved.id,
-				data: file.data,
-				fileName: file.fileName,
-				caption: req.caption,
-				accountId: req.account
-			});
-			noteOutboundSend(root);
 			return {
 				ok: true,
 				channel: channelId,
 				action,
 				detail: {
-					...sent,
+					...await channel.sendFile({
+						root,
+						userId: resolved.id,
+						data: file.data,
+						fileName: file.fileName,
+						caption: req.caption,
+						accountId: req.account
+					}),
 					user: resolved.alias ?? resolved.id
 				}
 			};
@@ -13889,7 +13445,7 @@ function forgetImBridgeVisibility(sessionId) {
 *
 * 🔴 **为什么要在 CCC 内屏蔽（owner 原话：「这和 CRO 冲突，要求在宁静号激活情况下屏蔽掉」）**：
 * 宿主从 `0.2.1-rc.2` 起自带一套**模型可见的定时器工具**（`ctx.schedule` 服务 + 这 4 个工具）。
-* 而宁静号的唤醒/巡航走的是**另一套**机制：`container_trajectory send-later` → 落 CCC 的
+* 而宁静号的唤醒/巡航走的是**另一套**机制：`cognitive_trajectory send-later` → 落 CCC 的
 * `AGENT_SESSIONS/wake-registry.json` → 由**中心调度器 5min tick 统一投递**（D58）。
 * 两套并存会产生**三个具体问题**（不是"重复功能"这种审美问题）：
 *  ① **两处真相源**：宿主的 schedule 状态在宿主域、我们的在 CCC 文件里，**谁在跑说不清**；
@@ -14011,7 +13567,7 @@ function forgetExclusiveToolsVisibility(sessionId) {
 *
 * 🔴 **为什么需要它（缺陷根因）**：工具是 `apply()` 里 `ctx.tools.register(...)` 注册到**宿主级**的
 * ⇒ 它们出现在**每一个**会话的工具清单里，**与会话 cwd 无关**。其余各缝（身份注入 ／ guards ／
-* keeper ／ output-guard ／ unattended ／ bootstrap）都已有 `if (!root) return` 这道门，
+* keeper ／ output-guard ／ bootstrap）都已有 `if (!root) return` 这道门，
 * **唯独"工具可见性"这一层没有** ⇒ 在非 CCC 目录开会话时，模型仍看得见这 14 个工具，
 * 于是会去调 —— 调了才抛 `No CCC found`。**那是运行时报错，不是事先不可见**。
 *
@@ -14549,12 +14105,12 @@ function registerBootstrap(ctx) {
 	}, { prepend: true });
 }
 //#endregion
-//#region src/trajectory-assistant.ts
+//#region src/cognitive-trajectory-assistant.ts
 /**
-* trajectory-assistant.ts — 关卡化注入的统一命名与风格门面（v0.3，S142）
+* cognitive-trajectory-assistant.ts — 关卡化注入的统一命名与风格门面（v0.3，S142）
 *
 * 概念（用户拍板 2026-09-05）：dsp 全部"过程中动态提示注入"统一命名为
-* trajectory-assistant（轨迹助航员）。关卡设计思想塑造**结构与时机**
+* cognitive-trajectory-assistant（轨迹助航员）。关卡设计思想塑造**结构与时机**
 * （何时/何地注入），**不用于提示词用词**（D8 词法原则）——纯游戏黑话
 * （BOSS/XP/level-up）禁止出现在提示词文本；CHECKPOINT/LIMIT/TUTORIAL 等
 * 跨领域自然通用词允许。
@@ -14567,7 +14123,7 @@ function registerBootstrap(ctx) {
 * L6 结算）仅在本模块注释与内部文档出现，永不浮现在提示词文本。
 *
 * 结算（settlement）挂点：D6 用户拍板——若 CCC 有标准 SESSION 复盘仪式，
-* 结算视图归 trajectory-assistant。当前 close/archive 无复盘摘要 ⇒ 机制延后。
+* 结算视图归 cognitive-trajectory-assistant。当前 close/archive 无复盘摘要 ⇒ 机制延后。
 * 🔴 2026-09-25（S142 分批清死代码·第 1 批）：原先那个 `onSettlement(cb)` **空 seam 已删**
 * （零调用者、无触发器、空实现）——仪式真落地时按当时的信号重新设计，**不再靠空占位**。
 */
@@ -14592,8 +14148,8 @@ const EVENT_LABEL = {
 	scratchPrune: "SCRATCH PRUNE"
 };
 /** 家族标识（所有动态注入统一前缀） */
-const ASSISTANT_PREFIX = "TRAJECTORY-ASSISTANT";
-/** 完整 token：`[TRAJECTORY-ASSISTANT · <LABEL>]` */
+const ASSISTANT_PREFIX = "COGNITIVE-TRAJECTORY-ASSISTANT";
+/** 完整 token：`[COGNITIVE-TRAJECTORY-ASSISTANT · <LABEL>]` */
 function eventToken(event) {
 	return `[${ASSISTANT_PREFIX} · ${EVENT_LABEL[event]}]`;
 }
@@ -14678,7 +14234,7 @@ function reminderText(code) {
 * 简短留自由度（不提"加载 eap 工具"，模型自知；只说修订 skill + 新建 skill 落 SESSION）。
 *
 * escalated=true（v1.23.3）：连续多轮超阈值仍未 rebuild → 升级强制语气
-* （STOP and rebuild now，持续注入直到调用 container_trajectory rebuild）。
+* （STOP and rebuild now，持续注入直到调用 cognitive_trajectory rebuild）。
 *
 * 需求①（S142 用户拍板，v1.28.0）：百分比比例 → K 数值——**判定**改为绝对
 * `projectedTokens ≥ thresholdK*1000`（触发语义，未变）。
@@ -14691,16 +14247,16 @@ function reminderText(code) {
 *
 * v1.31.1 交接协议（S142 用户需求"要求 LLM 将当前手头事项写在 SESSION.md 尾部，并要求
 * rebuild 后去读并处理"）：**写侧** = 这里；**读侧** = rebuild 锚点（rebuild.ts）。
-* 两侧共用 trajectory-assistant 的常量（单一真相源）。
+* 两侧共用 cognitive-trajectory-assistant 的常量（单一真相源）。
 *
 * 🔴 **v1.49.0（owner 2026-09-26 裁决："砍掉 in-flight，这正是目的"）**：写侧**不再**指向
 * SESSION.md 末尾的段，改指**独立便签文件** `REBUILD-TODO_FILENAME`（轨迹目录下）——
 * 理由见该常量的头注（持久文件 vs 只用一次的交界材料必须分家）。
 */
 function rebuildReminderText(escalated = false) {
-	const handover = ` Before rebuilding, write your current in-flight items (the exact step you are in the middle of, what is not finished yet, and what the next action is) into "${REBUILD_TODO_FILENAME}" in this trajectory's directory — create it if it does not exist. That file is a scratch note for the handover only: no format obligation, no archival duty, safe to discard at any time. The rebuilt conversation reads it first and continues from it.`;
-	if (escalated) return `${eventToken("limitMandatory")} Context usage has reached the configured rebuild threshold — you have been reminded repeatedly and have NOT called the container_trajectory rebuild action. This is now mandatory: STOP at the current task step, preserve valuable cognition into the CCC skills (or write a new-skill proposal into SESSION.md), then call container_trajectory rebuild immediately, passing --summary "<content summary ≤20 chars>" (required; the dsh session title is renamed to S###-YYYY-MM-DD-<summary> after rebuild).${handover} The conversation will be cleared and rebuilt in place; SESSION.md is the persistent trajectory and stays in place — identity continues from it. Do not continue working without rebuilding; this reminder persists until you call container_trajectory rebuild.`;
-	return `${eventToken("limit")} Context usage has reached the configured rebuild threshold. This session is the rebuildable carrier of the trajectory: SESSION.md is the persistent body, this conversation is only a temporary work copy. Before rebuilding: if this conversation produced valuable cognition, revise the relevant existing skill of this CCC (structure it with eap); if a new skill is warranted, write a short proposal into SESSION.md for the user to review — do not create it yourself.${handover} ACT NOW: at the next natural pause (end of the current task step), call the container_trajectory rebuild action — passing --summary "<content summary ≤20 chars>" describing the next work phase (required; the dsh session title is renamed to S###-YYYY-MM-DD-<summary> after rebuild) — to clear and rebuild this conversation: the current copy is discarded, identity continues from SESSION.md. If you are in the middle of an unbreakable step, continue it, then rebuild at its end. Do not ignore this; rebuild is the expected action, not an option.`;
+	const handover = ` Before rebuilding, write your current in-flight items (the exact step you are in the middle of, what is not finished yet, and what the next action is) into "${REBUILD_TODO_FILENAME}" in this cognitive trajectory's directory — create it if it does not exist. That file is a scratch note for the handover only: no format obligation, no archival duty, safe to discard at any time. The rebuilt conversation reads it first and continues from it.`;
+	if (escalated) return `${eventToken("limitMandatory")} Context usage has reached the configured rebuild threshold — you have been reminded repeatedly and have NOT called the cognitive_trajectory rebuild action. This is now mandatory: STOP at the current task step, preserve valuable cognition into the CCC skills (or write a new-skill proposal into SESSION.md), then call cognitive_trajectory rebuild immediately, passing --summary "<content summary ≤20 chars>" (required; the dsh session title is renamed to S###-YYYY-MM-DD-<summary> after rebuild).${handover} The conversation will be cleared and rebuilt in place; SESSION.md is the persistent cognitive trajectory and stays in place — identity continues from it. Do not continue working without rebuilding; this reminder persists until you call cognitive_trajectory rebuild.`;
+	return `${eventToken("limit")} Context usage has reached the configured rebuild threshold. This session is the rebuildable carrier of the cognitive trajectory: SESSION.md is the persistent body, this conversation is only a temporary work copy. Before rebuilding: if this conversation produced valuable cognition, revise the relevant existing skill of this CCC (structure it with eap); if a new skill is warranted, write a short proposal into SESSION.md for the user to review — do not create it yourself.${handover} ACT NOW: at the next natural pause (end of the current task step), call the cognitive_trajectory rebuild action — passing --summary "<content summary ≤20 chars>" describing the next work phase (required; the dsh session title is renamed to S###-YYYY-MM-DD-<summary> after rebuild) — to clear and rebuild this conversation: the current copy is discarded, identity continues from SESSION.md. If you are in the middle of an unbreakable step, continue it, then rebuild at its end. Do not ignore this; rebuild is the expected action, not an option.`;
 }
 /** 读取会话 contextPressure 投影（sessionProjections 可选服务；未装配返回 null） */
 function readContextPressure(ctx, session) {
@@ -14733,7 +14289,7 @@ function forgetLogbookCompactionState(scope) {
 * 解析**活跃** SESSION.md 绝对路径（缓存 60s）。
 *
 * 候选链（刻意比 rebuild 的完整链短——这里每个工具调用都要跑，贵候选不划算）：
-* ① `getActiveSessionInfo(scope).mdPath`（`container_trajectory use` / skiff 绑定 / 重启恢复都会写）
+* ① `getActiveSessionInfo(scope).mdPath`（`cognitive_trajectory use` / skiff 绑定 / 重启恢复都会写）
 * ② `readLastBound(session).mdPath`（`.bindings.json` 权威绑定——重启后内存空时兜底）
 * 两者都拿不到 → null（**不猜**：宁可不提醒，也不去猜别的轨迹——对齐 v1.30.13 D4 的教训）。
 */
@@ -14800,13 +14356,13 @@ function readSessionMdMaxKB(root, configPaths, now = Date.now) {
 * ③ 允许整合不重要事项（被取代的决策 / 已解决问题 / 中间态）
 * ④ 自主裁量权充分允许（唯一硬要求 = 骨架 + 未决项/决策理由/下一步仍可重建）
 */
-function trajectoryCompactionReminderText(input) {
+function cognitiveTrajectoryCompactionReminderText(input) {
 	const { sizeKB, limitKB, mdPath, escalated = false } = input;
 	const facts = `SESSION.md is ${sizeKB} KB (limit ${limitKB} KB): ${mdPath}`;
 	const principles = "Load eap (praxis eap) first, then rewrite SESSION.md under these principles: (1) keep the EAP layered skeleton — a stable section structure, not a chronological dump; (2) move detail out — long evidence chains, logs and reference material belong in separate files (e.g. AGENT_SESSIONS/<session>/references/*.md) linked from SESSION.md; (3) merge or drop what no longer matters — superseded decisions, resolved issues, intermediate states; (4) you have full discretion on how far to go: the only hard requirements are the skeleton and that every still-open item, decision rationale and next step stays recoverable (reconstruction over preservation).";
-	const frontmatterGuard = "Keep the YAML frontmatter at the top of the file exactly as it is — it carries this trajectory's skill declarations.";
+	const frontmatterGuard = "Keep the YAML frontmatter at the top of the file exactly as it is — it carries this cognitive trajectory's skill declarations.";
 	if (escalated) return `${eventToken("compaction")} ${facts} — you have been reminded repeatedly and have NOT compacted SESSION.md. This is now mandatory: STOP the current task step, load eap (praxis eap), rewrite SESSION.md, then resume. ${principles} ${frontmatterGuard} This reminder persists until the file is under the limit.`;
-	return `${eventToken("compaction")} ${facts}. Pause the current work and compact this trajectory's log (SESSION.md) before continuing — that log is the persistent body of this trajectory, and its size is operational entropy (H_op) the container pays on every read. ${principles} ${frontmatterGuard} After rewriting, resume the paused work; this reminder stops once the file is under the limit.`;
+	return `${eventToken("compaction")} ${facts}. Pause the current work and compact this cognitive trajectory's log (SESSION.md) before continuing — that log is the persistent body of this cognitive trajectory, and its size is operational entropy (H_op) the container pays on every read. ${principles} ${frontmatterGuard} After rewriting, resume the paused work; this reminder stops once the file is under the limit.`;
 }
 /** 连续超限轮数达此值 → 语气升级（对齐 COMPACTION_ESCALATE_AFTER / REBUILD_ESCALATE_AFTER） */
 const REBUILD_TODO_ESCALATE_AFTER = 3;
@@ -14816,7 +14372,7 @@ const rebuildTodoStates = /* @__PURE__ */ new Map();
 *
 * ## 与 SESSION.md 档的**语义差别**（刻意，不是疏漏）
 *
-* | | SESSION.md 超限（`trajectoryCompactionReminderText`） | 便签超限（本条） |
+* | | SESSION.md 超限（`cognitiveTrajectoryCompactionReminderText`） | 便签超限（本条） |
 * |---|---|---|
 * | 动作 | **重写**（compaction） | **清理／丢弃**（prune） |
 * | 结构义务 | 保 EAP 骨架 ＋ 4 条重写原则 ＋ frontmatter 护栏 | **无** |
@@ -14835,7 +14391,7 @@ const rebuildTodoStates = /* @__PURE__ */ new Map();
 function rebuildTodoReminderText(input) {
 	const { sizeKB, limitKB, mdPath, escalated = false } = input;
 	const facts = `${REBUILD_TODO_FILENAME} is ${sizeKB} KB (limit ${limitKB} KB): ${mdPath}`;
-	const action = "This file is a scratch note for the rebuild handover — it carries no archival duty and you may discard it wholesale at any time. Prune it now, writing in the spirit of eap (praxis eap): (1) delete what is already done; (2) delete what has been superseded; (3) delete what is already recorded in SESSION.md — that file is the trajectory's persistent body, this one only carries what the next self needs once. Do not restructure it into a formal document: the only mechanical constraint on this file is its size.";
+	const action = "This file is a scratch note for the rebuild handover — it carries no archival duty and you may discard it wholesale at any time. Prune it now, writing in the spirit of eap (praxis eap): (1) delete what is already done; (2) delete what has been superseded; (3) delete what is already recorded in SESSION.md — that file is the cognitive trajectory's persistent body, this one only carries what the next self needs once. Do not restructure it into a formal document: the only mechanical constraint on this file is its size.";
 	if (escalated) return `${eventToken("scratchPrune")} ${facts} — you have been reminded repeatedly and have NOT pruned it. Prune it now. ${action} This reminder persists until the file is under the limit.`;
 	return `${eventToken("scratchPrune")} ${facts}. ${action} This reminder stops once the file is under the limit.`;
 }
@@ -14862,8 +14418,8 @@ function registerKeeper(ctx, opts = {}) {
 		const root = cccRootForCwd(cwd);
 		if (!root) return next();
 		const sessionId = exec.agent?.session?.id;
-		const skiffKeeper = skiffTrajectoryEnabled(root, sessionId, "keeper");
-		const skiffRebuild = skiffTrajectoryEnabled(root, sessionId, "rebuild");
+		const skiffKeeper = skiffCognitiveTrajectoryEnabled(root, sessionId, "keeper");
+		const skiffRebuild = skiffCognitiveTrajectoryEnabled(root, sessionId, "rebuild");
 		const tracker = trackerFor(exec);
 		const shouldRemind = skiffKeeper ? tracker.step(exec.name) : false;
 		const downstream = await next();
@@ -14898,7 +14454,7 @@ function registerKeeper(ctx, opts = {}) {
 				}
 			}
 		}
-		if (skiffTrajectoryEnabled(root, sessionId, "session")) {
+		if (skiffCognitiveTrajectoryEnabled(root, sessionId, "session")) {
 			const limitKB = readSessionMdMaxKB(root, opts.configPaths);
 			if (limitKB > 0) {
 				const scope = sessionId ?? "global";
@@ -14910,7 +14466,7 @@ function registerKeeper(ctx, opts = {}) {
 					st.consecutive += 1;
 					blocks.push({
 						type: "text",
-						text: trajectoryCompactionReminderText({
+						text: cognitiveTrajectoryCompactionReminderText({
 							sizeKB: Math.round(size / 1024),
 							limitKB,
 							mdPath,
@@ -14921,7 +14477,7 @@ function registerKeeper(ctx, opts = {}) {
 				} else compactionStates.delete(scope);
 			}
 		}
-		if (skiffTrajectoryEnabled(root, sessionId, "session")) {
+		if (skiffCognitiveTrajectoryEnabled(root, sessionId, "session")) {
 			const scope = sessionId ?? "global";
 			const session = exec.agent?.session;
 			const mdPath = resolveActiveSessionMdPath(root, scope, session);
@@ -15053,7 +14609,7 @@ function registerContext(ctx, opts = {}) {
 		const key = agentKey(agent);
 		if (isSkiffSessionId(key)) return;
 		registerEntrySkillSection(agent, root);
-		registerTrajectorySkillSection(agent, root);
+		registerCognitiveTrajectorySkillSection(agent, root);
 		const scope = agentScope(agent);
 		if (shouldRestoreActive(agent) && getActiveSessionInfo(scope) === null) try {
 			if (loadSerenityConfig(root, configPaths).hooks?.autoRestoreSession ?? true) {
@@ -15152,7 +14708,7 @@ function registerContext(ctx, opts = {}) {
 				syncHostScheduleToolHiding(agent, root);
 			} catch {}
 			registerEntrySkillSection(agent, root);
-			registerTrajectorySkillSection(agent, root);
+			registerCognitiveTrajectorySkillSection(agent, root);
 		}
 		if (!root || injected.has(key) || downstream.kind !== "enter") return downstream;
 		injected.add(key);
@@ -15630,11 +15186,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
 					const { weixinBridgeStatus } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { readWeixinCredential } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
+					const { readWeixinCredential } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
 					const accounts = (settings.accounts ?? []).map((a) => ({
 						accountId: a.accountId,
 						name: a.name ?? void 0,
@@ -15666,7 +15222,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { fetchQRCode } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
 					const { randomUUID } = await import("node:crypto");
 					for (const [key, v] of weixinLogins) if (Date.now() - v.startedAt > WEIXIN_LOGIN_TTL_MS) weixinLogins.delete(key);
-					const { readWeixinSettings } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15687,7 +15243,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
+					const { removeWeixinAccount } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -15700,8 +15256,8 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$3(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
 						return;
 					}
-					const { saveWeixinRoutes } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
-					const { readSkiffRoles } = await import("./skiff-role-B615L9MV.js").then((n) => n.u);
+					const { saveWeixinRoutes } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
+					const { readSkiffRoles } = await import("./skiff-role-Boc4SKct.js").then((n) => n.d);
 					const roles = readSkiffRoles(root);
 					for (const r of routes) if (!roles.has(r.role)) {
 						sendJson$3(res, 400, { error: `unknown role: ${r.role} (not in ${root} skiff.roles)` });
@@ -15713,7 +15269,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -15757,7 +15313,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const { pollQRStatus } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
-				const { readWeixinSettings } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
+				const { readWeixinSettings } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15772,7 +15328,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-Aheyq3fN.js").then((n) => n.u);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-BoSC-uPp.js").then((n) => n.u);
 						const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -15893,7 +15449,7 @@ function registerAcpAccountsApi(ctx) {
 						return;
 					}
 					const { acpChannelStatus, listAcpRoots } = await Promise.resolve().then(() => acp_auth_exports);
-					const { listCccs } = await import("./ccc-roots-GIJ3A_tw.js").then((n) => n.a);
+					const { listCccs } = await import("./ccc-roots-RMzGU-CJ.js").then((n) => n.a);
 					const st = acpChannelStatus(chk.root);
 					const all = (await listCccs(ctx)).map((e) => e.root);
 					sendJson$3(res, 200, {
@@ -15923,7 +15479,7 @@ function registerAcpAccountsApi(ctx) {
 						sendJson$3(res, 400, { error: "invalid account (accountId 与 role 均必填)" });
 						return;
 					}
-					const { readSkiffRoles } = await import("./skiff-role-B615L9MV.js").then((n) => n.u);
+					const { readSkiffRoles } = await import("./skiff-role-Boc4SKct.js").then((n) => n.d);
 					const roles = readSkiffRoles(root);
 					if (!roles.has(account.role)) {
 						sendJson$3(res, 400, { error: `role "${account.role}" 不在该 CCC 的 skiff.roles 里（现有：${[...roles.keys()].join(", ") || "无"}）` });
@@ -16383,7 +15939,7 @@ const HOST_SERVICES = [
 			name: "resolveAgent",
 			kind: "function"
 		}],
-		impact: "trajectory 冷会话唤醒不可用（只能唤醒已加载的 live 会话）——唤醒注册表投递降级",
+		impact: "cognitive trajectory 冷会话唤醒不可用（只能唤醒已加载的 live 会话）——唤醒注册表投递降级",
 		required: false
 	},
 	{
@@ -17776,13 +17332,13 @@ function buildRebuildAnchor(root, sessionName, activeMdPath, anchorMessages = DE
 	const sessionLine = sessionDir !== "AGENT_SESSIONS" ? `- Serenity session: ${sessionName !== "" ? `${sessionName} (${sessionDir})` : sessionDir}` : null;
 	const focusLine = sanitizeFocusLine(focus);
 	return [
-		`${eventToken("rebuild")} The conversation has been cleared and rebuilt (Ship of Theseus: the carrier is replaced, the trajectory continues).`,
+		`${eventToken("rebuild")} The conversation has been cleared and rebuilt (Ship of Theseus: the carrier is replaced, the cognitive trajectory continues).`,
 		"",
 		...anchorMessages.flatMap((text) => [stripAckSuffix(text), ""]),
 		sessionName !== "" ? `Continue the work of ${sessionName}.` : "Continue the current work.",
 		...sessionLine ? [sessionLine] : [],
-		`- Persistent trajectory — SESSION.md path: ${rel}`,
-		`  (the trajectory's persistent body — stays in place through rebuilds)`,
+		`- Persistent cognitive trajectory — SESSION.md path: ${rel}`,
+		`  (the cognitive trajectory's persistent body — stays in place through rebuilds)`,
 		`- Read that SESSION.md first (goal/decisions/progress/unresolved), then continue from the last checkpoint.`,
 		`- Then read the handover scratch note: ${todoRel} (path: ${todoAbs}) — the previous self paused mid-task and left its in-flight items there. That file carries no format obligation and may be discarded at any time; it is NOT the authoritative state. If it is missing, infer the in-flight items from SESSION.md's latest progress entries.`,
 		...focusLine ? [`- Task focus: ${focusLine}`] : []
@@ -17834,7 +17390,7 @@ function sessionNameFromMdPath(mdPath) {
 * 它会把 rebuild 静默接到 AGENT_SESSIONS 里最新的另一个会话（临时 skiff 会话 persistent=false、
 * 重启后首条消息前、新会话首条消息都命中该形态），而"接错轨迹"比重建失败危险得多
 * （错误轨迹被继续写入 + 正确轨迹静默丢失）。现在全部候选失败 → 返回 null → 调用方
-* 报错引导用户显式 `container_trajectory use`（响亮失败优于静默接错）。
+* 报错引导用户显式 `cognitive_trajectory use`（响亮失败优于静默接错）。
 * 备选：④ 仅在"同 scope 确无绑定"时兜底——同样会接错轨迹，故不采纳。
 *
 * 每候选 resolve 后 existsSync 校验（相对路径按 root 解析）；全部失败返回 null → 调用方报错引导。
@@ -17894,7 +17450,7 @@ async function queueRebuild(ctx, opts) {
 	const session = ctx.sessions?.get?.(dshSessionId);
 	if (!session) throw new Error(`Unable to locate dsh session ${dshSessionId} (session may be closed)`);
 	const mdPath = resolveSessionMdPath(root, dshSessionId, session);
-	if (!mdPath) throw new Error("Unable to determine the active SESSION.md for this session — checked (in order): in-memory activation (container_trajectory use in this process), [SESSION CONTEXT] events in this conversation, AGENT_SESSIONS/.bindings.json (authoritative binding), rebuild anchor in the surface. None matched an existing SESSION.md. Run \"container_trajectory use <S###> --summary <内容概括 ≤20 字>\" to bind this conversation to a trajectory, then retry container_trajectory rebuild. (No global fallback is applied on purpose — guessing could resume a different trajectory.)");
+	if (!mdPath) throw new Error("Unable to determine the active SESSION.md for this session — checked (in order): in-memory activation (cognitive_trajectory use in this process), [SESSION CONTEXT] events in this conversation, AGENT_SESSIONS/.bindings.json (authoritative binding), rebuild anchor in the surface. None matched an existing SESSION.md. Run \"cognitive_trajectory use <S###> --summary <内容概括 ≤20 字>\" to bind this conversation to a cognitive trajectory, then retry cognitive_trajectory rebuild. (No global fallback is applied on purpose — guessing could resume a different cognitive trajectory.)");
 	const sessionName = getActiveSessionInfo(dshSessionId)?.sessionId ?? sessionNameFromMdPath(mdPath);
 	const focus = note && note.trim() !== "" ? note : void 0;
 	const anchor = buildRebuildAnchor(root, sessionName, mdPath, DEFAULT_ANCHOR_MESSAGES, focus);
@@ -18064,7 +17620,7 @@ function registerRebuildTurnHook(ctx) {
 				agent.steer(createUserMessage({
 					content: [{
 						type: "text",
-						text: `${eventToken("rebuild")} The conversation has been cleared and rebuilt. Follow the anchor instructions above now: read the persistent trajectory (SESSION.md) and continue the work automatically from the last checkpoint.`
+						text: `${eventToken("rebuild")} The conversation has been cleared and rebuilt. Follow the anchor instructions above now: read the persistent cognitive trajectory (SESSION.md) and continue the work automatically from the last checkpoint.`
 					}],
 					source: PLUGIN_SOURCE
 				}));
@@ -18072,7 +17628,7 @@ function registerRebuildTurnHook(ctx) {
 					sessionId: id,
 					event: "rebuilt"
 				});
-				console.log(`[serenity-hooks] container_trajectory rebuild executed with auto-continue (turn ${payload.turn ?? "?"} ended): ${id}`);
+				console.log(`[serenity-hooks] cognitive_trajectory rebuild executed with auto-continue (turn ${payload.turn ?? "?"} ended): ${id}`);
 			} else writeRebuildDiag(resolveSerenityRootFor(agent), {
 				sessionId: id,
 				event: "empty-surface"
@@ -18084,7 +17640,7 @@ function registerRebuildTurnHook(ctx) {
 				event: "failed",
 				detail: msg
 			});
-			console.warn(`[serenity-hooks] container_trajectory rebuild failed: ${msg}`);
+			console.warn(`[serenity-hooks] cognitive_trajectory rebuild failed: ${msg}`);
 		}
 	});
 }
@@ -19828,7 +19384,7 @@ function skiffDebugPage(cccs, defaultRoot, webPort) {
   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; }
-  #trajectory { margin-top: 12px; font-size: 13px; }
+  #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; }
@@ -19855,7 +19411,7 @@ function skiffDebugPage(cccs, defaultRoot, webPort) {
   <textarea id="q" placeholder="向该角色提问…（追问直接继续输入）"></textarea>
   <button id="ask">提问</button>
   <div id="answer" class="muted">等待提问…</div>
-  <div id="trajectory"></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>
@@ -19869,7 +19425,7 @@ const sessionBadge = document.getElementById('sessionBadge')
 const newChatBtn = document.getElementById('newChat')
 const btn = document.getElementById('ask')
 const answer = document.getElementById('answer')
-const traj = document.getElementById('trajectory')
+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 }
@@ -19930,7 +19486,7 @@ btn.addEventListener('click', async () => {
     answer.innerHTML = data.answer_html || esc(data.answer || '') || '（空回答）'
     sessionId = data.sessionId || sessionId
     renderSessionBadge()
-    renderTrajectory(data.trajectory || [], data.sessionId || '')
+    renderCognitiveTrajectory(data.cognitiveTrajectory || [], data.sessionId || '')
   } catch (err) {
     answer.className = 'err'
     answer.textContent = String(err.message || err)
@@ -19938,7 +19494,7 @@ btn.addEventListener('click', async () => {
     btn.disabled = false
   }
 })
-function renderTrajectory(entries, sessionId) {
+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' : '')
@@ -20180,7 +19736,7 @@ async function handle(ctx, defaultRoot, webPort, req, res) {
 				answer_html: renderSkiffMarkdown(result.answer),
 				sessionId: result.sessionId,
 				continued,
-				trajectory: result.trajectory
+				cognitiveTrajectory: result.cognitiveTrajectory
 			});
 			return;
 		}
@@ -20223,9 +19779,9 @@ const MECHANISM_WORDS = [
 	"agent/turn-stopping",
 	"tools/pre-execute",
 	"tools/post-execute",
-	"Trajectory Steward",
-	"TRAJECTORY-STEWARD",
-	"TRAJECTORY-ASSISTANT",
+	"Cognitive Trajectory Steward",
+	"COGNITIVE-TRAJECTORY-STEWARD",
+	"COGNITIVE-TRAJECTORY-ASSISTANT",
 	"first-anchor",
 	"拦截缝",
 	"装配层",
@@ -20317,7 +19873,7 @@ const CATEGORY_GUIDE = {
 * v1.26.10 只列裸词（如 "3080"）模型仍不知道是什么/怎么规避；现在按类说明：
 * "3080" → 内部服务端口，不要提及内部端口/地址/端点）。
 * R↓ 安全性：命中词本就已在被拦截回复中进入会话（已暴露面），打回重复一次不扩大暴露；
-* steer 是 plugin source 消息不回显给用户（3100 对外响应已不含 trajectory → 打回文本不达外部用户）。
+* steer 是 plugin source 消息不回显给用户（3100 对外响应已不含 cognitive trajectory → 打回文本不达外部用户）。
 */
 function buildRebuke(hits) {
 	const count = hits.length;
@@ -20338,8 +19894,10 @@ function isExternalFaceSession(sessionId) {
 	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
 }
 /** 读会话最后一个 assistant/message 文本（skiff-core 同款）
-*  **2026-09-23（S142 D77）起导出**：`unattended-seam.ts` 复用同一读法（本容器纪律：
-*  「同一读法只留一份」——两份 `lastAssistantText` 会在宿主改事件形状时**只修一处**）。
+*  **v1.63.3 起唯一的导出理由消失**：原导出是给 `unattended-seam.ts` 复用的（D77），
+*  该文件已随无人值守功能整条退役 ⇒ 现只有本模块自己用（`isLeak` 的调用点）。
+*  ⚠️ 保持 `export` 无害（它有测试覆盖，且将来"同一读法只留一份"的纪律仍成立），
+*  但**不要**再写成"为了 X 复用才导出"——那个 X 不存在了。
 *  **v1.27.7：剥离 think 块再检测**（用户："不检查think内容（因为不输出）"）——
 *  ` think…` 是模型思考过程，不进入用户可见输出；敏感词检测只针对**最终呈现文本**，
 *  否则 think 内提及内部机制词（思考过程必然推演机制）会误打回。复用 stripThink
@@ -20398,235 +19956,6 @@ function registerOutputGuardHook(ctx) {
 	});
 }
 //#endregion
-//#region src/unattended-seam.ts
-/**
-* unattended-seam.ts — 无人值守代理回复的**拦截缝**（S142 **D77**，owner 2026-09-23 令「我需要的是一个机制」）
-*
-* ## 停在哪、怎么接（设计 §4 的裁决：**A 的通道 ＋ B 的措辞**）
-*
-* 复用的是**已验证过的**通道——`agent/turn-stopping`（serial）里 `agent.steer()`：
-* 宿主语义 = "**listener 反对就打回**，机器重读 inbox：有新 steer ⇒ 再跑一步，没有 ⇒ 关轮"
-* （`host/contract.ts` 的 `HOST_EVENTS` 原文）。因此：
-* · **轮不结束**（语义正是"有人打回"）⇒ **零新机械**；
-* · 文本**写成代理用户的话**（B 的措辞）+ **首句自报身份**（owner 已裁）。
-*
-* 模板 = `output-guard-seam.ts`（同一缝位、同一 `createUserMessage + PLUGIN_SOURCE` 形态）。
-*
-* ## 🔴「这轮是不是真实用户发起的」怎么判（本机制**唯一**的新机械；2026-09-23 取证）
-*
-* 交接块把它列为"动手前必须先查清的一件事"，取证结论（读宿主类型面，非猜测）：
-*
-* | 事实 | 出处 |
-* |---|---|
-* | 每条进入 inbox 的消息都发 `agent/inbox/inserted { agent, message }`；**在轮内离开 inbox 时**发 `agent/inbox/claimed { agent, message, turn }` | `@deepseek-ai/dsh-agent` README（Inbox 段）＋ `runtime-types.d.ts` |
-* | `claimed.turn` = **拥有该消息的那一轮**；`turn-stopping.turn` = **即将关闭的那一轮** ⇒ 两者同编号可直接比对 | `runtime-types.d.ts` 同一文件两处 `turn` 声明 |
-* | 消息来源可辨：`MessageSourceMap` 里**真实用户** = `kind: 'user'`（`user` ／ `user-rpc` 两种形态**同 kind**）；**ACC 自己注入**的一律 `kind: 'plugin:dsh-serenity-hooks'`（v1.47.0 改；旧值 = `'plugin'`） | `@deepseek-ai/dsh-llm` `src/message.ts` 的 `MessageSourceMap`（合并和类型）＋ 本仓 `message-source.ts`（**唯一**声明处与常量处） |
-*
-* ⇒ **判据 = 「这一轮 claim 到的消息里，有没有 `source.kind === 'user'`」**。
-* 没有现成信号时本可退化为"记账法"（我们知道自己投过什么），**但不必**：宿主已给出一手信号。
-*
-* ## 🔴 为什么"用户发起的轮"要跳过（这是设计 §3-③ 的本意，别当成漏洞）
-*
-* 用户**刚说完话**⇒ 人就在跟前，代理插话既是冒充也是浪费。**"用户说完走开"那种情形**
-* 由**绳（长周期保险丝）／其它非用户发起的唤醒**覆盖：那条轮**不是**用户发起的 ⇒ 代理接手，
-* 一路推进到**合法收束**。⇒ 两个机制合起来才等于"用户走开后会话还能自己跑完"。
-*
-* ## 🔴 铁律（与 `unattended-ops.ts` 同族）
-*
-* **本模块的任何失败都不得影响 turn 收尾**：所有 handler 包 try/catch，异常只记一行 console。
-*/
-/** 取载体 id（payload 的 `agent` 面；取不到 ⇒ 空串） */
-function sessionIdOf$2(agent) {
-	const id = agent?.session?.id;
-	return typeof id === "string" ? id : "";
-}
-/** 取会话对象（payload 的 `agent.session`） */
-function sessionOf(agent) {
-	return agent?.session;
-}
-/** 取会话 cwd（`header.cwd`；取不到回落进程 cwd——与 `output-guard-seam.ts` 同款读法） */
-function cwdOf(agent) {
-	return sessionOf(agent)?.header?.cwd ?? process.cwd();
-}
-/** 是否 **CCC 内主会话**（`delegationDepth` 缺省 0；子代理 / 无头运行不算） */
-function isMainSession(agent) {
-	return (sessionOf(agent)?.header?.delegationDepth ?? 0) === 0;
-}
-/**
-* 该会话所属轨迹**是否带 CRO 程序**（窄口径的唯一排除项）。
-* 判据 = 轨迹目录下存在 `continuous-re-occurrence.ts`（与 `cro.ts` 同源：**文件在 = 启用**）。
-* 无绑定（未挂在任何轨迹上）⇒ false（没有程序在驱动它）。
-*/
-function hasCroProgram(session, root) {
-	const dirName = readLastBound(session)?.dirName;
-	if (!dirName) return false;
-	return existsSync(join(sessionsRoot(root), dirName, CRO_FILENAME));
-}
-/** 落一条流水（**永不抛**；无绑定 ⇒ 无落点，只回 false 由调用方记 console） */
-function logEvent(session, root, entry, nowMs) {
-	const dirName = readLastBound(session)?.dirName;
-	if (!dirName) return false;
-	const res = appendUnattendedLog(root, dirName, entry, nowMs);
-	if (!res.ok) console.log(`[serenity-hooks] unattended: 流水未落盘 — ${res.error ?? "未知原因"}`);
-	return res.ok;
-}
-/**
-* 一轮收尾（`agent/turn-stopping`）的完整处置。
-*
-* 顺序：**取事实 → 纯函数判定 → 执行**（判定全在 `unattended-ops.ts`，本函数只做 I/O 与 steer）。
-* @returns 便于用例观察的判定结果文本（生产不使用返回值）
-*/
-function handleTurnStopping(agent, turn) {
-	if (readSimpleSettings().unattendedEnabled !== true) return "skip:mode-off";
-	const sessionId = sessionIdOf$2(agent);
-	if (sessionId === "") return "skip:no-session-id";
-	const root = cccRootForCwd(cwdOf(agent));
-	if (root === null) return "skip:not-in-ccc";
-	const session = sessionOf(agent);
-	const nowMs = Date.now();
-	const run = getProxyRun(sessionId);
-	const text = lastAssistantText(agent);
-	const nonces = parseDoneNonces(text);
-	const sessionIdExcluded = isProxyExcludedSessionId(sessionId);
-	const userInitiated = turn === null ? true : isUserTurn(sessionId, turn);
-	const cro = !sessionIdExcluded && !userInitiated && isMainSession(agent) ? hasCroProgram(session, root) : false;
-	const verdict = decideUnattendedAction({
-		enabled: true,
-		root,
-		isMainSession: isMainSession(agent),
-		sessionIdExcluded,
-		userInitiated,
-		hasCroProgram: cro,
-		run,
-		nowMs,
-		doneNonce: nonces.length > 0 ? nonces[nonces.length - 1] ?? null : null,
-		claimsNotify: claimsUserNotification(text),
-		outboundSeen: run !== null && hasOutboundSendSince(root, run.startedAt, nowMs)
-	});
-	if (verdict.action === "skip") return `skip:${verdict.reason}`;
-	if (verdict.action === "accept" || verdict.action === "cap") {
-		clearProxyRun(sessionId);
-		logEvent(session, root, {
-			event: verdict.action,
-			round: verdict.round,
-			nonce: run?.nonce ?? null,
-			reason: verdict.reason,
-			sessionId
-		}, nowMs);
-		console.log(`[serenity-hooks] unattended: ${verdict.action} (${verdict.reason}, round=${verdict.round}, session=${sessionId})`);
-		return `${verdict.action}:${verdict.reason}`;
-	}
-	const nonce = newNonce();
-	const startedAt = run?.startedAt ?? nowMs;
-	setProxyRun(sessionId, {
-		round: verdict.round,
-		nonce,
-		startedAt
-	});
-	const message = verdict.reason === "false-notify" ? buildFalseNotifyRebuke({
-		round: verdict.round,
-		maxRounds: 15,
-		nonce
-	}) : buildProxyMessage({
-		round: verdict.round,
-		maxRounds: 15,
-		nonce
-	});
-	try {
-		agent.steer(createUserMessage({
-			content: [{
-				type: "text",
-				text: message
-			}],
-			source: PLUGIN_SOURCE
-		}));
-	} catch (error) {
-		clearProxyRun(sessionId);
-		logEvent(session, root, {
-			event: "cap",
-			round: verdict.round,
-			nonce,
-			reason: "steer-failed",
-			sessionId
-		}, nowMs);
-		console.warn(`[serenity-hooks] unattended: steer 失败（本轮放弃） — ${String(error?.message ?? error)}`);
-		return "cap:steer-failed";
-	}
-	logEvent(session, root, {
-		event: "inject",
-		round: verdict.round,
-		nonce,
-		reason: verdict.reason,
-		sessionId
-	}, nowMs);
-	console.log(`[serenity-hooks] unattended: inject round=${verdict.round}/15 (${verdict.reason}, session=${sessionId})`);
-	return `inject:${verdict.reason}`;
-}
-/**
-* 装配无人值守代理缝（`index.ts` apply 调用）。
-*
-* 订阅三个事件（**都已在 `host/contract.ts` 白名单里**，新增的 `agent/inbox/claimed` 同批登记）：
-* · `agent/inbox/claimed` —— 记「真实用户发起的轮次」；用户回来时**让位**（清代理段 + 记流水）;
-* · `agent/turn-stopping` —— 判定 + 注入（本机制主体）；
-* · `agent/disposed` / `session/disposed` —— 载体销毁清表（**本容器栽过 5 次"只增不清"**）。
-*/
-function registerUnattendedSeam(ctx) {
-	const on = (event, handler) => {
-		try {
-			ctx.on(event, handler);
-		} catch (err) {
-			console.log(`[serenity-hooks] ✗ 无人值守代理未装配（${event} 不可用）: ${String(err?.message ?? err)}`);
-		}
-	};
-	on("agent/inbox/claimed", (payload) => {
-		try {
-			const p = payload;
-			const sessionId = sessionIdOf$2(p?.agent);
-			if (sessionId === "") return;
-			if (p.message?.source?.kind !== "user") return;
-			noteUserTurn(sessionId, (typeof p.turn === "number" ? p.turn : null) ?? -1);
-			const run = getProxyRun(sessionId);
-			if (!run) return;
-			clearProxyRun(sessionId);
-			const root = cccRootForCwd(cwdOf(p.agent));
-			if (root) logEvent(sessionOf(p.agent), root, {
-				event: "yield",
-				round: run.round,
-				nonce: run.nonce,
-				reason: "user-returned",
-				sessionId
-			}, Date.now());
-			console.log(`[serenity-hooks] unattended: yield — 用户回来了 (session=${sessionId}, round=${run.round})`);
-		} catch (err) {
-			console.log(`[serenity-hooks] unattended: claimed 观察失败 — ${String(err?.message ?? err)}`);
-		}
-	});
-	on("agent/turn-stopping", (payload) => {
-		try {
-			const p = payload;
-			if (!p?.agent) return;
-			handleTurnStopping(p.agent, typeof p.turn === "number" ? p.turn : null);
-		} catch (err) {
-			console.log(`[serenity-hooks] unattended: turn-stopping 处置失败（已忽略） — ${String(err?.message ?? err)}`);
-		}
-	});
-	on("agent/disposed", (payload) => {
-		const sessionId = sessionIdOf$2(payload?.agent);
-		if (sessionId === "") return;
-		clearProxyRun(sessionId);
-		clearUserTurn(sessionId);
-	});
-	on("session/disposed", (payload) => {
-		const id = payload?.id;
-		if (typeof id !== "string" || id === "") return;
-		clearProxyRun(id);
-		clearUserTurn(id);
-	});
-	registerDisposer(ctx, "unattended proxy", () => {
-		clearUnattendedState();
-	});
-}
-//#endregion
 //#region src/human-channel.ts
 /**
 * human-channel.ts — 人机信道的**机制层**（机器级；2026-09-26 owner 定案 ⇒ 方案 §2.6）
@@ -21309,7 +20638,7 @@ function manualOutputFallbackNeeded(input) {
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-GIJ3A_tw.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-RMzGU-CJ.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -21527,7 +20856,7 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 			const parts = [];
 			const activeWorkspace = getActiveSessionInfo(sessionId);
 			if (activeWorkspace?.mdPath) {
-				if (!ensureWorkspacePromptSection(ref.agent, sessionId)) parts.push(workspaceTrajectoryLine(activeWorkspace.mdPath));
+				if (!ensureWorkspacePromptSection(ref.agent, sessionId)) parts.push(workspaceCognitiveTrajectoryLine(activeWorkspace.mdPath));
 			}
 			const manualOutput = settings.autoReplyWithLastMessage === false;
 			if (text) parts.push(text);
@@ -21555,7 +20884,7 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 			})).catch((err) => {
 				console.log(`[serenity-hooks] weixin hook incoming error: ${err instanceof Error ? err.message : String(err)}`);
 			});
-			const answer = (await askSkiff(ctx, ref.agent, question, void 0, { includeTrajectory: false })).answer ?? "";
+			const answer = (await askSkiff(ctx, ref.agent, question, void 0, { includeCognitiveTrajectory: false })).answer ?? "";
 			if (manualOutput) {
 				if (!manualOutputFallbackNeeded({
 					fallbackOnNoSend: settings.fallbackOnNoSend,
@@ -21808,7 +21137,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-GIJ3A_tw.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-RMzGU-CJ.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -22044,7 +21373,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-GIJ3A_tw.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-RMzGU-CJ.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -24901,7 +24230,6 @@ function renderClock(label, s) {
 	const parts = [
 		`armed=${s.armed}`,
 		`CRO 闸=${readSimpleSettings().croEnabled !== false}`,
-		`无人值守闸=${readSimpleSettings().unattendedEnabled === true}`,
 		`tick 次数=${s.ticks}`,
 		`上次 tick=${ts(s.lastTickAt)}`
 	];
@@ -26022,7 +25350,6 @@ const Config = z.object({
 	skiffEnabled: z.boolean().volatile(),
 	skiffDebugPort: z.number().min(1024).max(65535).volatile(),
 	croEnabled: z.boolean().volatile(),
-	unattendedEnabled: z.boolean().volatile(),
 	diagramEnabled: z.boolean().volatile(),
 	acpFaceEnabled: z.boolean().volatile(),
 	acpFacePort: z.number().min(1024).max(65535).volatile()
@@ -26044,7 +25371,7 @@ function apply(ctx, config) {
 	})();
 	if (config.tools) {
 		ctx.tools.register(ccFsTool);
-		ctx.tools.register(createTrajectoryTool(ctx));
+		ctx.tools.register(createCognitiveTrajectoryTool(ctx));
 		ctx.tools.register(createKitTool(ctx));
 		ctx.tools.register(gitTool);
 		ctx.tools.register(msmTool);
@@ -26080,7 +25407,6 @@ function apply(ctx, config) {
 	registerGateway(ctx);
 	registerRebuildTurnHook(ctx);
 	registerOutputGuardHook(ctx);
-	registerUnattendedSeam(ctx);
 	if (config.env) registerEnv(ctx);
 	if (config.opencodeSkills) registerOpencodeSkills(ctx);
 	registerBootstrap(ctx);