@shgroup/dsh-serenity-hooks 1.64.0 → 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-DN7g8K7Q.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 整段退场）。协作边界：
 * 互相可见、**无阻塞无等待**。
@@ -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 {
@@ -10788,10 +10789,10 @@ function registerCroTurnTracking(ctx) {
 *
 * ## 所有者令（本模块的存在理由）
 *
-* 「S151 和 S185 的验证都说明，trajectory 倾向于自己做个结构化记录来记录自身 CRO 的执行情况，
+* 「S151 和 S185 的验证都说明，认知轨迹倾向于自己做个结构化记录来记录自身 CRO 的执行情况，
 * 这是个结构化流水账；**我们 ACC 有必要进行 CRO 唤醒的日志记录**，当 CRO 存在时，每次**成功唤醒**
 * 写相关信息，但是保留数量要少，**只保留仅两日**的记录即可，**这个时间是程序化的**」
-* ＋「**这个日志写结构化文件到 trajectory 目录，文件名固定即可**」
+* ＋「**这个日志写结构化文件到认知轨迹目录，文件名固定即可**」
 * ＋「**失败成功都记录**」。
 *
 * ## 它解决什么麻烦（白话）
@@ -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 } : {}
@@ -13444,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 文件里，**谁在跑说不清**；
@@ -14104,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 等
 * 跨领域自然通用词允许。
@@ -14122,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 已删**
 * （零调用者、无触发器、空实现）——仪式真落地时按当时的信号重新设计，**不再靠空占位**。
 */
@@ -14147,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]}]`;
 }
@@ -14233,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`（触发语义，未变）。
@@ -14246,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) {
@@ -14288,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 的教训）。
 */
@@ -14355,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;
@@ -14371,7 +14372,7 @@ const rebuildTodoStates = /* @__PURE__ */ new Map();
 *
 * ## 与 SESSION.md 档的**语义差别**（刻意，不是疏漏）
 *
-* | | SESSION.md 超限（`trajectoryCompactionReminderText`） | 便签超限（本条） |
+* | | SESSION.md 超限（`cognitiveTrajectoryCompactionReminderText`） | 便签超限（本条） |
 * |---|---|---|
 * | 动作 | **重写**（compaction） | **清理／丢弃**（prune） |
 * | 结构义务 | 保 EAP 骨架 ＋ 4 条重写原则 ＋ frontmatter 护栏 | **无** |
@@ -14390,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.`;
 }
@@ -14417,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();
@@ -14453,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";
@@ -14465,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,
@@ -14476,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);
@@ -14608,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) {
@@ -14707,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);
@@ -15185,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,
@@ -15221,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, {
@@ -15242,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);
@@ -15255,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)` });
@@ -15268,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) {
@@ -15312,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,
@@ -15327,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, {
@@ -15448,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, {
@@ -15478,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(", ") || "无"}）` });
@@ -15938,7 +15939,7 @@ const HOST_SERVICES = [
 			name: "resolveAgent",
 			kind: "function"
 		}],
-		impact: "trajectory 冷会话唤醒不可用（只能唤醒已加载的 live 会话）——唤醒注册表投递降级",
+		impact: "cognitive trajectory 冷会话唤醒不可用（只能唤醒已加载的 live 会话）——唤醒注册表投递降级",
 		required: false
 	},
 	{
@@ -17331,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}`] : []
@@ -17389,7 +17390,7 @@ function sessionNameFromMdPath(mdPath) {
 * 它会把 rebuild 静默接到 AGENT_SESSIONS 里最新的另一个会话（临时 skiff 会话 persistent=false、
 * 重启后首条消息前、新会话首条消息都命中该形态），而"接错轨迹"比重建失败危险得多
 * （错误轨迹被继续写入 + 正确轨迹静默丢失）。现在全部候选失败 → 返回 null → 调用方
-* 报错引导用户显式 `container_trajectory use`（响亮失败优于静默接错）。
+* 报错引导用户显式 `cognitive_trajectory use`（响亮失败优于静默接错）。
 * 备选：④ 仅在"同 scope 确无绑定"时兜底——同样会接错轨迹，故不采纳。
 *
 * 每候选 resolve 后 existsSync 校验（相对路径按 root 解析）；全部失败返回 null → 调用方报错引导。
@@ -17449,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);
@@ -17619,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
 				}));
@@ -17627,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"
@@ -17639,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}`);
 		}
 	});
 }
@@ -19383,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; }
@@ -19410,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>
@@ -19424,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 }
@@ -19485,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)
@@ -19493,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' : '')
@@ -19735,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;
 		}
@@ -19778,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",
 	"拦截缝",
 	"装配层",
@@ -19872,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;
@@ -20637,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;
@@ -20855,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);
@@ -20883,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,
@@ -21136,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 {}
 	})();
@@ -21372,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 = [];
@@ -25370,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);