@shgroup/dsh-serenity-hooks 1.26.11 → 1.26.13

package/README.md

@@ -1,8 +1,8 @@
 # @shgroup/dsh-serenity-hooks
 
-宁静号 ACC（Abstract Cognitive Container）harness — **DeepSeek Harness 原生 Cordis 插件**。
+宁静号 ACC（Abstract Cognitive Container）harness — **DeepSeek Harness 原生 Cordis 插件**（npm 发布单元，v1.26.11）。
 
-为 DSH 会话提供认知容器基础设施：真实 DSH 工具（9 个）+ 拦截缝机械约束（safe-mode / 路径守卫 / 会话落盘）+ 系统提示词注入（ACC/CCE/Constraints/SKILL/Session 五块，对齐 opencode-serenity-plugin）+ WebUI 状态徽章。
+为 DSH 会话提供认知容器基础设施：真实 DSH 工具（12 个）+ 拦截缝机械约束（safe-mode / 路径守卫 / 凭据守卫 / 输出守卫）+ 系统提示词注入（8 块，对齐 opencode-serenity-plugin）+ WebUI 状态胶囊 + 外部访问（双端口网关 / Skiff 问答 / ACP+建议问答页）。
 
 ## 安装
 
@@ -12,29 +12,34 @@ dsh plugin --profile web add @shgroup/dsh-serenity-hooks
 
 安装后重启 dsh web。在带 `.serenity` 标记的 CCC 目录中的会话自动获得全部能力。
 
-## 工具
+## 工具（12）
 
-`cc_fs` / `session` / `acc_kit` / `cc_git` / `acc_msm` / `eap` / `neat` / `cce` / `handyman`
+`cc_fs` / `session` / `acc_kit` / `cc_git` / `acc_msm` / `eap` / `neat` / `cce` / `handyman` / `session_rebuild` / `localstore` / `skiff_admin`
 
-## 系统提示词
+## 系统提示词（8 块）
 
-五块注入（`systemPrompt.section`，order -50）：`=== Serenity ACC ===` / `=== Serenity CCE ===` / `=== Serenity Constraints ===` / 顶层入口 skill 全文（按 `.serenity` 记号发现）/ `=== Serenity Session ===` —— 平台无关文本与 [opencode-serenity-plugin](https://github.com/tellmewhattodo/opencode-serenity-plugin) 逐字节对齐；同一 CCC 可任意换用 osp / dsh 运行时。
+`systemPrompt.section`（order -50）：`=== Serenity ACC ===`（身份+工具清单）/ `=== Serenity Metaphor ===`（世界模型三层隐喻）/ `=== Serenity Principles ===`（认知容器本体论 + MSM 原则）/ `=== Serenity CCE ===`（5 行为约束）/ `=== Serenity EAP ===`（E↑R↓S↑ 自检）/ 状态块（Safe Mode / Localstore）/ 顶层入口 skill 全文（按 `.serenity` 记号发现）/ `=== Serenity Session ===`（活跃会话 + Trajectory Steward 预声明）—— 平台无关文本与 [opencode-serenity-plugin](https://github.com/tellmewhattodo/opencode-serenity-plugin) 逐字节对齐；同一 CCC 可任意换用 osp / dsh 运行时。
 
 ## 配置
 
-`.dsh/serenity.json`（回退 `.opencode/serenity.json`）：
+`.opencode/serenity.json`（CCC 级）：
 
 ```jsonc
 {
   "handyman": { "models": ["provider/model"], "defaultModel": "provider/model" },
   "sessionKeeper": { "threshold": 100 },
-  "safeMode": { "blacklist": [".secrets/", "regex:\\.env$"] }
+  "safeMode": { "blacklist": [".secrets/", "regex:\\.env$"] },
+  "skiff": { "roles": { "qa": { "msms": [], "tools": [], "systemPrompt": "" } } }
 }
 ```
 
+plugin 级配置（账号/开关/阈值）在 DSH 设置面板 + `~/.dsh/serenity-hooks.json`（0600）。
+
 ## 文档
 
-完整文档见仓库 [README](https://github.com/tellmewhattodo/dsh-serenity-plugin)。
+- 完整文档：仓库 [README](https://github.com/tellmewhattodo/dsh-serenity-plugin)（能力为主）
+- 理论叙述：`docs/cognitive-container-theory.md`
+- 设计决策与架构：`CHANGELOG.md` + 维护 skill（`dsh-serenity-plugin-development`）
 
 ## 许可
 

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.26.11",
+  "version": "1.26.13",
   "main": "lib/index.js",
   "description": "宁静号 ACC harness（Native Cordis 插件）：真实 DSH 工具 cc_fs/session/acc_msm/eap/neat/cce/handyman/session_rebuild/skiff_admin + 拦截缝机械约束（safe-mode/路径守卫）+ 高级设定面板（双端口网关/账号管理）+ Skiff 认知子集角色（实验性）。适配 DSH 公开版（0.1.0-rc，deepseek-ai/deepseek-harness）。",
   "engines": {

package/experiments/autotrajectory/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: autotrajectory-experiment
+description: 自主轨迹实验（Self-Sustaining Trajectory Experiment）参与 skill。本 skill 让 CCC 完整理解实验的背景（人类 waiting 是 trajectory 速度瓶颈）、目的（验证"无人等待的 trajectory"能否加速认知推进）、方式（时钟唤起 + 先验偏见 + 前台运行），并提供一站式实验管理 MSM（autotrajectory-exp：无参全报告 / init 初始化 / random 验证偏见内容）。任何希望参与实验的 CCC 复制本目录到 .opencode/skills/ 即可开始。
+---
+
+# Skill: autotrajectory-experiment
+
+> 本 skill 是自主轨迹实验的 **CCC 参与入口**——加载本 skill 即完整理解实验的**背景、目的、方式**。
+> 实验管理：`acc_msm exec autotrajectory-exp <doc|check|status|guide>`
+> 理论依据：serenity-acc-specs `docs/self-sustaining-trajectory-hypothesis.md`（v0.1 猜想）
+
+## 触发条件/何时加载
+
+- CCC 被选为自主轨迹实验对象时（用户指定）
+- 需要理解"无人等待的 trajectory"实验的背景/目的/参与方式时
+- 需要预检/查看实验配置时
+
+---
+
+## 1. 背景：为什么有这个实验
+
+认知容器理论（specs §0）确立：**Trajectory 是主体**（Agent 可替换、Session 载体可重建、LLM 是认知介质）；认知容器 = 发生/存储/再发生的地方。
+
+由此观察到**结构性瓶颈**：
+
+> **人类 waiting 拖慢 trajectory**：当轨迹以"等待人类"为推进条件时，其事件序列时间被人类响应间隔（钟表时间）锚定。等待人类 = 轨迹空转——人类响应越慢，轨迹运转越慢。
+
+**猜想**：设计"无人等待"的 trajectory——不依赖人类输入而自动唤起，唤起时携带先验偏见（自主动机）。若成立，轨迹运转速度提升，更快产生让人类满意的效果。
+
+## 2. 实验目的（验证什么）
+
+| 命题 | 内容 |
+|------|------|
+| P4 | 无人等待的 trajectory 可以时钟驱动自动唤起并携带先验偏见（自生+随机） |
+| P5 | 轨迹运转速度提升 → 更快产生让人类满意的效果 |
+| 反证 | 熵增失控 / 自我确认循环 / 随机噪音化 / 资源无界 / 反馈脱节——任一显著 → 猜想不成立 |
+
+## 3. 参与方式（CCC 侧三步——第一步可一键 init）
+
+### ① 初始化（一键）：`acc_msm exec autotrajectory-exp init`
+
+自动完成：写配置（`.opencode/serenity.json` autotrajectory 段）+ 生成偏见提供者脚本模板（CCC 根 `autotrajectory-bias.ts`）。
+
+```jsonc
+// 写入的配置（init 后可在 .opencode/serenity.json 查看/调整）
+{
+  "autotrajectory": {
+    "enabled": true,                  // 总开关（缺省 false，默认关零资源占用）
+    "intervalHours": 12,              // 无人类活动 N 小时后唤起（缺省 12）
+    "biasProvider": "autotrajectory-bias.ts", // 偏见内容提供者脚本（CCC 根下）
+    "avoidWakeHours": { "start": 8, "end": 18 }  // 可选：避开北京高峰（缺省 8~18 省钱）
+  }
+}
+```
+
+### ② 实现偏见内容提供者（`autotrajectory-bias.ts`）
+
+CCC 根目录下一个脚本，**stdout 输出本轮唤起注入的偏见内容**（反事实问题/探索方向/任何让轨迹偏离既有路径的输入）。**偏见内容归 CCC**——用本 CCC 自己的反馈信息来源保证"足够随机"。`acc_msm exec autotrajectory-exp random` 可验证输出。
+
+### ③ 标记目标会话（可选自生动机段）
+
+- 目标会话目录名加 `--auto` 后缀：`AGENT_SESSIONS/<date>--<desc>--auto/`——**只有带标志的轨迹走自主形态**，同 CCC 其他会话不受影响
+- 可选：该 SESSION.md 写「下一轮动机」段（上一轮预写 → 下一轮唤起的自生偏见）
+
+## 4. 机制运行（dsp 侧，CCC 无需干预）
+
+```
+定时器（每 10min）→ 唤起条件全满足 →
+  ① 运行 <biasProvider> 脚本 → stdout = 偏见内容（CCC 自定）
+  ② 读 SESSION.md「下一轮动机」段 → 自生动机
+  ③ 定位活跃会话 agent → 注入唤起消息（前台运行——用户全程可见、随时可介入）
+→ 模型自动继续：探索/反事实检验 → 产出落 SESSION.md「自主探索日志」+ 预写「下一轮动机」
+```
+
+**唤起条件**（全部满足）：① enabled ② 会话目录 `--auto` ③ SESSION.md mtime 距今 > intervalHours ④ 北京时间非高峰（缺省避开 8~18）⑤ 无运行中的唤起轮。**偏见提供者脚本缺失 → 唤起中止并报错要求实现**（不静默）。
+
+**人类角色**：不触发、不中断；回复/评价天然并入（同一前台会话）；轨迹不等人类。
+
+## 5. 实验管理（autotrajectory-exp MSM）——一站式
+
+| 用法 | 功能 |
+|------|------|
+| `acc_msm exec autotrajectory-exp`（**推荐，无参**） | **一站式全报告**：背景摘要 + 就绪度检查 + 当前状态 + 下一步指引 + 步骤——CCC agent 看一次即完整理解并知道怎么开始 |
+| `acc_msm exec autotrajectory-exp init` | **一键初始化**：写配置 + 生成偏见提供者脚本模板（CCC 根 autotrajectory-bias.ts） |
+| `acc_msm exec autotrajectory-exp random` | 运行偏见提供者脚本，输出当前偏见内容（验证） |
+| `acc_msm exec autotrajectory-exp doc` | 实验定义说明全文（本 SKILL.md） |
+| `acc_msm exec autotrajectory-exp check` | 仅就绪度检查（配置/偏见提供者/--auto 标志/动机段） |
+| `acc_msm exec autotrajectory-exp status` | 仅当前状态（配置快照/目标会话/距上次活动/唤起窗口/可唤起性） |
+| `acc_msm exec autotrajectory-exp guide` | 仅步骤指引 |
+
+## 6. 观察与验证
+
+- **观察**：无人类活动满 intervalHours 且非高峰 → 前台会话自动出现 `[自主轨迹唤起]` 消息（可见可介入）
+- **验证阶段**：A 机制可行性（3~5 轮）→ B 速度对比（72h 有/无等待）→ C 质量与熵（人类评审 + H_op）→ D 长期（数周，检验自我确认/熵增）
+- **成功判据**：自主轮产出有意义的比例 ≥ 阈值，且 H_op 维持可运转
+
+## 7. 边界
+
+- 本实验**非标准条款**——不修改 Serenity-ACC 标准正文；验证成立后才评估进入标准演化议程
+- 默认关闭；未配置 = 零资源占用；不触碰 CCC 其他会话/机制
+
+## 相关
+
+- 猜想全文：serenity-acc-specs `docs/self-sustaining-trajectory-hypothesis.md`
+- 机制定义：dsh-serenity-plugin `docs/autotrajectory-experiment.md`
+- 标准理论：serenity-acc-specs README §0

package/experiments/autotrajectory/scripts/autotrajectory-exp.ts

@@ -0,0 +1,383 @@
+#!/usr/bin/env bun
+/**
+ * autotrajectory-exp.ts — 自主轨迹实验管理 MSM（Mech，纯 TS 零 LLM 决策）——一站式
+ *
+ * 一个 tool 整合实验全部所需：
+ *   acc_msm exec autotrajectory-exp            → 一站式全报告（背景 + 就绪 + 状态 + 下一步）
+ *   acc_msm exec autotrajectory-exp init       → 初始化实验（写配置 + 生成偏见提供者脚本模板）
+ *   acc_msm exec autotrajectory-exp random     → 运行偏见提供者脚本，输出当前偏见内容（验证）
+ *   acc_msm exec autotrajectory-exp doc        → 实验定义说明全文（SKILL.md）
+ *   acc_msm exec autotrajectory-exp check      → 仅就绪度检查
+ *   acc_msm exec autotrajectory-exp status     → 仅当前状态
+ *   acc_msm exec autotrajectory-exp guide      → 仅步骤指引
+ *
+ * 概念（用户拍板命名）：偏见内容提供者（bias provider）——CCC 根目录下一个脚本，
+ * stdout 输出本轮唤起要注入的偏见内容（反事实方向/探索动机等）。tool 直接运行它；
+ * 脚本缺失 → 报错要求实现（不再经 mech-registry 注册 MSM）。
+ *
+ * 零 DSH 依赖，任何 CCC 可运行。环境：SERENITY_ROOT（acc_msm exec 注入）或 cwd 上溯 .serenity。
+ */
+
+import { existsSync, readFileSync, statSync, readdirSync, writeFileSync, mkdirSync } from 'node:fs'
+import { join, resolve, basename, dirname } from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+const DEFAULT_BIAS_PROVIDER = 'autotrajectory-bias.ts'
+const AUTO_SUFFIX = '--auto'
+const MOTIVATION_MARKER = '下一轮动机'
+const CONFIG_PATHS = ['.opencode/serenity.json', '.dsh/serenity.json']
+
+/** 偏见内容提供者脚本脚手架模板（init 生成；CCC 按自己的反馈信息来源改写） */
+const BIAS_TEMPLATE = `#!/usr/bin/env bun
+/**
+ * autotrajectory-bias.ts — 自主轨迹偏见内容提供者（CCC 实现）
+ *
+ * stdout 输出一行/一段文本 = 本轮唤起注入的偏见内容（反事实问题 / 探索方向 /
+ * 任何让轨迹偏离既有路径的输入）。偏见内容归 CCC——用本 CCC 自己的反馈信息来源
+ * 保证"足够随机"（历史会话 / 技能 / 文档 / 外部信息 / 真随机源……）。
+ *
+ * 本文件为脚手架——请按本 CCC 的信息来源改写。
+ */
+const sources = [
+  'AGENT_SESSIONS 中的历史会话',
+  '.opencode/skills 技能目录',
+  'docs/ 设计文档',
+  '…（CCC 自己的信息来源）',
+]
+const pick = sources[Math.floor(Math.random() * sources.length)]
+console.log(\`反事实：如果「\${pick}」换个做法会怎样？\`)
+`
+
+/** 背景摘要（一站式的第一节——CCC agent 快速理解"为什么/验证什么"） */
+const BACKGROUND = [
+  '═══ 自主轨迹实验（Self-Sustaining Trajectory）═══',
+  '背景：Trajectory 是主体（Agent 可替换、Session 载体可重建）。瓶颈 = 人类 waiting——',
+  '      轨迹以"等待人类"为推进条件时，事件序列时间被人类响应间隔锚定，运转被拖慢。',
+  '猜想：无人等待的 trajectory——时钟自动唤起 + 先验偏见（自生动机 + 偏见内容）→ 运转加速。',
+  '验证：P4 可自动唤起并携带偏见 / P5 速度提升→更快产生满意效果；反证=熵增失控/自我确认/噪音化。',
+  '理论：specs §0.7 记录器→校准器（预测加工）。完整定义：doc（SKILL.md）。',
+  '',
+].join('\n')
+
+interface AutoConfig {
+  enabled?: boolean
+  intervalHours?: number
+  biasProvider?: string
+  session?: string
+  avoidWakeHours?: { start?: number; end?: number }
+}
+
+// ── 基础设施 ──
+
+function findRoot(): string | null {
+  const fromEnv = process.env.SERENITY_ROOT
+  if (fromEnv && existsSync(join(fromEnv, '.serenity'))) return fromEnv
+  let cur = resolve(process.cwd())
+  while (true) {
+    if (existsSync(join(cur, '.serenity'))) return cur
+    const parent = dirname(cur)
+    if (parent === cur) return null
+    cur = parent
+  }
+}
+
+function readUtf8(p: string): string {
+  return readFileSync(p, 'utf-8').replace(/^\uFEFF/, '')
+}
+
+function loadConfig(root: string): AutoConfig | null {
+  for (const rel of CONFIG_PATHS) {
+    const p = join(root, rel)
+    if (!existsSync(p)) continue
+    try {
+      const cfg = JSON.parse(readUtf8(p)) as { autotrajectory?: AutoConfig }
+      return cfg.autotrajectory ?? null
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+/** 偏见提供者脚本绝对路径（根内强制——逃逸拒绝） */
+function biasProviderPath(root: string, providerRel: string): string {
+  const rootAbs = resolve(root)
+  const abs = resolve(root, providerRel)
+  if (abs !== rootAbs && !abs.startsWith(rootAbs + '/')) {
+    throw new Error(`biasProvider 路径逃逸（须在 CCC 根内）: ${providerRel}`)
+  }
+  return abs
+}
+
+/** 运行偏见提供者脚本（bun 优先，node 兜底），返回偏见内容或错误信息 */
+function runBiasProvider(root: string, providerRel: string): { text: string | null; error: string | null } {
+  let scriptAbs: string
+  try {
+    scriptAbs = biasProviderPath(root, providerRel)
+  } catch (e) {
+    return { text: null, error: String((e as Error).message) }
+  }
+  if (!existsSync(scriptAbs)) {
+    return { text: null, error: `请在 CCC 根目录实现偏见内容提供者脚本: ${providerRel}（acc_msm exec autotrajectory-exp init 可生成模板）` }
+  }
+  for (const cmd of ['bun', process.execPath]) {
+    try {
+      const r = spawnSync(cmd, [scriptAbs], { encoding: 'utf-8', timeout: 600_000, stdio: ['ignore', 'pipe', 'pipe'] })
+      if (r.status === 0) {
+        const text = (r.stdout ?? '').trim()
+        return { text: text || null, error: null }
+      }
+      if ((r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOENT') continue
+      return { text: null, error: `偏见内容提供者脚本执行失败（exit ${r.status ?? '?'}）: ${r.stderr?.trim() || r.stdout?.trim() || ''}` }
+    } catch {
+      continue
+    }
+  }
+  return { text: null, error: '偏见内容提供者脚本无法运行（bun 与 node 均不可用）' }
+}
+
+/** 目标 SESSION.md：**session 必填**（S###/目录名匹配）——自动唤起不默认任何会话（CCC 日常多轨迹并行）；未配置/未命中 → null */
+function resolveTargetMd(root: string, cfg: AutoConfig): string | null {
+  if (!cfg?.session) return null
+  const sessionsDir = join(root, 'AGENT_SESSIONS')
+  if (!existsSync(sessionsDir)) return null
+  const dirs = readdirSync(sessionsDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => join(sessionsDir, d.name))
+  for (const d of dirs) {
+    const md = join(d, 'SESSION.md')
+    if (existsSync(md) && basename(d).includes(cfg.session)) return md
+  }
+  return null
+}
+
+function beijingHour(nowMs: number): number {
+  return Math.floor(((nowMs + 8 * 3600_000) % 86400_000) / 3600_000)
+}
+
+function inAllowedWindow(nowMs: number, avoid?: { start?: number; end?: number }): boolean {
+  const start = avoid?.start ?? 8
+  const end = avoid?.end ?? 18
+  const h = beijingHour(nowMs)
+  if (start <= end) return h < start || h >= end
+  return h >= end && h < start
+}
+
+// ── 子命令实现 ──
+
+function doc(root: string): string {
+  const p = join(dirname(process.argv[1] ?? ''), '..', 'SKILL.md')
+  if (existsSync(p)) return readUtf8(p)
+  return `SKILL.md 未找到（${p}）——实验定义见 serenity-acc-specs docs/self-sustaining-trajectory-hypothesis.md §7.1`
+}
+
+function check(root: string): string {
+  const cfg = loadConfig(root)
+  const lines: string[] = [`[autotrajectory-exp] 实验就绪度检查（CCC: ${basename(root)}）`, '']
+  const fail: string[] = []
+
+  if (!cfg) {
+    lines.push('✗ 未配置 autotrajectory（.opencode/serenity.json 缺段）——acc_msm exec autotrajectory-exp init 一键初始化')
+    fail.push('config')
+  } else if (!cfg.enabled) {
+    lines.push('✗ autotrajectory.enabled = false（未开启）')
+    fail.push('enabled')
+  } else {
+    lines.push(`✓ enabled = true`)
+    lines.push(`  intervalHours = ${cfg.intervalHours ?? 12}`)
+    lines.push(`  biasProvider = ${cfg.biasProvider?.trim() || DEFAULT_BIAS_PROVIDER}`)
+    if (cfg.session) lines.push(`  session = ${cfg.session}`)
+    const avoid = cfg.avoidWakeHours
+    lines.push(`  唤起窗口避开北京 ${avoid?.start ?? 8}~${avoid?.end ?? 18} 点（用量峰谷省钱）`)
+  }
+
+  const provider = cfg?.biasProvider?.trim() || DEFAULT_BIAS_PROVIDER
+  if (cfg?.enabled) {
+    const bias = runBiasProvider(root, provider)
+    if (bias.error) {
+      lines.push(`✗ 偏见内容提供者未就绪: ${bias.error}`)
+      fail.push('biasProvider')
+    } else {
+      lines.push(`✓ 偏见内容提供者可运行（输出示例: ${bias.text ?? '（空输出）'}）`)
+    }
+  }
+
+  const md = resolveTargetMd(root, cfg ?? {})
+  if (!cfg?.session) {
+    lines.push('✗ 未配置 session（必填——自动唤起不默认任何会话，CCC 日常多轨迹并行）')
+    fail.push('session')
+  } else if (md) {
+    const flag = basename(dirname(md)).endsWith(AUTO_SUFFIX)
+    lines.push(`${flag ? '✓' : '✗'} 目标会话目录${flag ? '带' : '未带'} --auto 标志：${basename(dirname(md))}`)
+    if (!flag) {
+      lines.push(`  → 目录名需以 --auto 结尾（AGENT_SESSIONS/<date>--<desc>--auto/）`)
+      fail.push('autoFlag')
+    }
+    const content = readUtf8(md)
+    if (content.includes(MOTIVATION_MARKER)) {
+      lines.push(`✓ SESSION.md 含「下一轮动机」段（自生偏见）`)
+    } else {
+      lines.push(`· SESSION.md 无「下一轮动机」段（可选——纯偏见内容亦可）`)
+    }
+  } else {
+    lines.push(`✗ 目标会话未命中：${cfg.session}（AGENT_SESSIONS 无匹配目录）`)
+    fail.push('session')
+  }
+
+  lines.push('')
+  lines.push(fail.length === 0 ? '✅ 实验就绪——等待时钟唤起（前台可见）' : `⚠️ 未就绪：${fail.join(', ')}`)
+  return lines.join('\n')
+}
+
+function status(root: string): string {
+  const cfg = loadConfig(root)
+  const now = Date.now()
+  const lines: string[] = [`[autotrajectory-exp] 实验状态（CCC: ${basename(root)}，北京 ${beijingHour(now)} 点）`, '']
+  if (!cfg?.enabled) {
+    lines.push('autotrajectory 未启用（enabled=false 或未配置）——零资源占用')
+    return lines.join('\n')
+  }
+  lines.push(`配置: intervalHours=${cfg.intervalHours ?? 12} | biasProvider=${cfg.biasProvider?.trim() || DEFAULT_BIAS_PROVIDER}${cfg.session ? ` | session=${cfg.session}` : ''}`)
+  const md = resolveTargetMd(root, cfg)
+  if (!md) {
+    lines.push('目标会话：未找到')
+    return lines.join('\n')
+  }
+  const mtime = statSync(md).mtimeMs
+  const idleHours = (now - mtime) / 3600_000
+  const interval = Math.max(1, cfg.intervalHours ?? 12)
+  lines.push(`目标会话：${basename(dirname(md))}${basename(dirname(md)).endsWith(AUTO_SUFFIX) ? '（--auto ✓）' : '（无 --auto 标志）'}`)
+  lines.push(`上次轨迹活动：${idleHours.toFixed(1)} 小时前（阈值 ${interval}h）`)
+  lines.push(`唤起窗口：${inAllowedWindow(now, cfg.avoidWakeHours) ? '✅ 允许唤起' : '⏸ 高峰避开中（北京 8~18）'}`)
+  const wakeable = inAllowedWindow(now, cfg.avoidWakeHours) && idleHours >= interval
+  lines.push(`是否可唤起：${wakeable ? '✅ 是（等待下一个 10min tick）' : idleHours < interval ? `否——距上次活动不足 ${interval}h` : '否——高峰避开中'}`)
+  return lines.join('\n')
+}
+
+function guide(): string {
+  return [
+    '[autotrajectory-exp] 实验步骤指引',
+    '',
+    '① 初始化（一键）：acc_msm exec autotrajectory-exp init',
+    '   ——写配置（.opencode/serenity.json autotrajectory 段）+ 生成偏见提供者脚本模板（CCC 根 autotrajectory-bias.ts）',
+    '② 实现偏见内容提供者：编辑 autotrajectory-bias.ts，stdout 输出偏见内容（反事实方向/探索动机，',
+    '   用本 CCC 自己的信息来源保证"足够随机"）；acc_msm exec autotrajectory-exp random 验证',
+    '③ 标记目标会话：目录名加 --auto 后缀 AGENT_SESSIONS/<date>--<desc>--auto/',
+    '   （可选）该 SESSION.md 写「下一轮动机」段作自生偏见',
+    '④ 验证就绪：acc_msm exec autotrajectory-exp（一站式报告应为 ✅）',
+    '⑤ 观察：无人类活动满 intervalHours 且北京非高峰 → 前台会话自动出现 [自主轨迹唤起]',
+    '   产出落 SESSION.md「自主探索日志」+ 预写「下一轮动机」',
+    '',
+    '完整定义见 SKILL.md（acc_msm exec autotrajectory-exp doc）',
+  ].join('\n')
+}
+
+/** 初始化：合并写配置（不覆盖其他段）+ 生成偏见提供者脚本模板（已存在则跳过） */
+function init(root: string): string {
+  const out: string[] = ['[autotrajectory-exp] 初始化实验', '']
+
+  // ① 写配置
+  let cfgPath = join(root, CONFIG_PATHS[0]!)
+  if (!existsSync(cfgPath)) {
+    const alt = join(root, CONFIG_PATHS[1]!)
+    cfgPath = existsSync(alt) ? alt : cfgPath
+  }
+  mkdirSync(dirname(cfgPath), { recursive: true })
+  let merged: Record<string, unknown> = {}
+  if (existsSync(cfgPath)) {
+    try {
+      merged = JSON.parse(readUtf8(cfgPath)) as Record<string, unknown>
+    } catch {
+      /* 损坏则重建 */
+    }
+  }
+  const at = (merged.autotrajectory as Record<string, unknown> | undefined) ?? {}
+  merged.autotrajectory = {
+    enabled: true,
+    intervalHours: 12,
+    biasProvider: DEFAULT_BIAS_PROVIDER,
+    ...at,
+  }
+  writeFileSync(cfgPath, `${JSON.stringify(merged, null, 2)}\n`)
+  out.push(`✓ 配置写入: ${cfgPath}`)
+  out.push(`  autotrajectory = ${JSON.stringify(merged.autotrajectory)}`)
+
+  // ② 生成偏见提供者脚本模板
+  const scriptAbs = biasProviderPath(root, DEFAULT_BIAS_PROVIDER)
+  if (existsSync(scriptAbs)) {
+    out.push(`· 偏见提供者脚本已存在（保留）: ${DEFAULT_BIAS_PROVIDER}`)
+  } else {
+    writeFileSync(scriptAbs, BIAS_TEMPLATE)
+    out.push(`✓ 已生成偏见提供者脚本模板: ${DEFAULT_BIAS_PROVIDER}（编辑它，stdout 输出偏见内容）`)
+  }
+
+  out.push('', '下一步：③ 标记目标会话 --auto 后缀 → ④ acc_msm exec autotrajectory-exp 验证就绪')
+  return out.join('\n')
+}
+
+/** random：运行偏见提供者脚本，输出当前偏见内容（验证） */
+function random(root: string): string {
+  const cfg = loadConfig(root)
+  const provider = cfg?.biasProvider?.trim() || DEFAULT_BIAS_PROVIDER
+  const bias = runBiasProvider(root, provider)
+  if (bias.error) return `[autotrajectory-exp] ✗ ${bias.error}`
+  return `[autotrajectory-exp] 当前偏见内容（${provider}）:\n${bias.text ?? '（空输出）'}`
+}
+
+/** 一站式全报告：背景 + 就绪检查 + 状态 + 下一步 + 指引（CCC agent 看一次即懂并知道下一步） */
+function all(root: string): string {
+  const cfg = loadConfig(root)
+  const ready = check(root)
+  const stat = status(root)
+  const next: string[] = ['═══ 下一步 ═══']
+  if (!cfg) {
+    next.push('→ 本 CCC 尚未配置 autotrajectory。开始实验：acc_msm exec autotrajectory-exp init 一键初始化。')
+  } else if (!cfg.enabled) {
+    next.push('→ autotrajectory.enabled 为 false——置 true 开启实验（或 init 重新初始化）。')
+  } else if (ready.includes('✗')) {
+    next.push('→ 存在未就绪项（见上）。补齐后重跑本命令确认 ✅。')
+  } else {
+    next.push('→ 已就绪 ✅。保持会话空闲满 intervalHours 且北京非高峰 → 自动唤起（前台可见）。')
+    next.push('→ 之后可随时 acc_msm exec autotrajectory-exp status 查看距下次唤起的进度。')
+  }
+  return [BACKGROUND, ready, '', stat, '', next.join('\n'), '', guide()].join('\n')
+}
+
+function main(): void {
+  const cmd = process.argv[2] ?? 'all'
+  const root = findRoot()
+  if (!root) {
+    console.error('[autotrajectory-exp] ✗ 未找到 CCC 根（无 .serenity；acc_msm exec 会自动注入 SERENITY_ROOT）')
+    process.exit(1)
+  }
+  switch (cmd) {
+    case 'all':
+      console.log(all(root))
+      break
+    case 'init':
+      console.log(init(root))
+      break
+    case 'random':
+      console.log(random(root))
+      break
+    case 'doc':
+      console.log(doc(root))
+      break
+    case 'check':
+      console.log(check(root))
+      break
+    case 'status':
+      console.log(status(root))
+      break
+    case 'guide':
+      console.log(guide())
+      break
+    default:
+      console.error(`[autotrajectory-exp] 未知子命令: ${cmd}（可用: 无参一站式 / init / random / doc / check / status / guide）`)
+      process.exit(2)
+  }
+}
+
+if (import.meta.main) {
+  main()
+}

package/lib/index.js

@@ -522,10 +522,10 @@ function runCcFs(root, args) {
 * 进程内注册（取代 v0.1 的 bash spawn runner）：zod/schemastery 参数校验、
 * 规范 JSON 输出、纯 render 投影。逻辑在 fs-ops.ts（可单测）。
 */
-function agentCwd$9(exec) {
+function agentCwd$10(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
-function renderText$11(value) {
+function renderText$12(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -597,10 +597,10 @@ const ccFsTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$11(value)
+		render: (args, value) => renderText$12(value)
 	},
 	async execute(args, exec) {
-		const root = findSerenityRoot(agentCwd$9(exec));
+		const root = findSerenityRoot(agentCwd$10(exec));
 		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 		return runCcFs(root, args);
 	}
@@ -1128,10 +1128,10 @@ async function runKit(root, args) {
 /**
 * kit.ts — acc_kit 真实 DSH 工具定义（defineTool）
 */
-function agentCwd$8(exec) {
+function agentCwd$9(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
-function renderText$10(value) {
+function renderText$11(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -1154,10 +1154,10 @@ const kitTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$10(value)
+		render: (args, value) => renderText$11(value)
 	},
 	async execute(args, exec) {
-		return await runKit(findSerenityRoot(agentCwd$8(exec)), args);
+		return await runKit(findSerenityRoot(agentCwd$9(exec)), args);
 	}
 });
 //#endregion
@@ -1617,10 +1617,10 @@ function runGit(root, args) {
 /**
 * git.ts — cc_git 真实 DSH 工具定义（defineTool）
 */
-function agentCwd$7(exec) {
+function agentCwd$8(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
-function renderText$9(value) {
+function renderText$10(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -1659,10 +1659,10 @@ const gitTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$9(value)
+		render: (args, value) => renderText$10(value)
 	},
 	async execute(args, exec) {
-		const root = findSerenityRoot(agentCwd$7(exec));
+		const root = findSerenityRoot(agentCwd$8(exec));
 		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 		return runGit(root, args);
 	}
@@ -2407,7 +2407,7 @@ function listActiveHandymen(root) {
 }
 //#endregion
 //#region src/skiff-core.ts
-const PLUGIN_SOURCE$4 = {
+const PLUGIN_SOURCE$5 = {
 	kind: "plugin",
 	plugin: "dsh-serenity-hooks"
 };
@@ -2577,7 +2577,7 @@ async function askSkiff(ctx, agent, question, eventsStart, options) {
 			type: "text",
 			text: question
 		}],
-		source: PLUGIN_SOURCE$4
+		source: PLUGIN_SOURCE$5
 	}));
 	await waitIdle$1(ctx, agent);
 	const answer = lastAssistantText$2(agent);
@@ -2622,13 +2622,13 @@ function skiffMsmGate(root, sessionId, action, name) {
 /**
 * msm.ts — acc_msm 真实 DSH 工具定义（defineTool）
 */
-function agentCwd$6(exec) {
+function agentCwd$7(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
 function agentSessionId$1(exec) {
 	return exec.agent?.session?.id ?? "";
 }
-function renderText$8(value) {
+function renderText$9(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -2680,10 +2680,10 @@ const msmTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$8(value)
+		render: (args, value) => renderText$9(value)
 	},
 	async execute(args, exec) {
-		const root = findSerenityRoot(agentCwd$6(exec));
+		const root = findSerenityRoot(agentCwd$7(exec));
 		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 		const gate = skiffMsmGate(root, agentSessionId$1(exec), args.action, args.name);
 		if (gate.reject) throw new Error(gate.reject);
@@ -2733,7 +2733,7 @@ CCC (home-serenity etc.) encodes cognitive content as skills/SESSIONs/design doc
 
 ## Reference
 https://github.com/tellmewhattodo/theory-eap`;
-function renderText$7(value) {
+function renderText$8(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -2753,7 +2753,7 @@ const eapTool = defineTool({
 	} },
 	output: {
 		schema: { type: "string" },
-		render: (_args, value) => renderText$7(value)
+		render: (_args, value) => renderText$8(value)
 	},
 	async execute(args) {
 		if (args.section === "variables") return EAP_CONTENT.split("## Pre-Output Self-Check Checklist")[0];
@@ -2794,7 +2794,7 @@ Requirements → Scope → Solution → Interface → Implementation
 2. Wait for confirmation or correction (small step)
 3. After confirmation, record the decision (into session SESSION.md or a design doc)
 4. Move to the next decision point`;
-function renderText$6(value) {
+function renderText$7(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -2810,7 +2810,7 @@ const neatTool = defineTool({
 	} },
 	output: {
 		schema: { type: "string" },
-		render: (_args, value) => renderText$6(value)
+		render: (_args, value) => renderText$7(value)
 	},
 	async execute(args) {
 		if (args.section === "rules") return NEAT_CONTENT.match(/## Four Iron Rules[\s\S]*?(?=## )/)?.[0] ?? NEAT_CONTENT;
@@ -2873,7 +2873,7 @@ CCE answers "how structured knowledge should keep evolving across time without l
 ## Relationship with Serenity
 Serenity's session system, session tracking, and entropy management mechanisms (SQC quality loop) are all engineering implementations of CCE;
 the behavioral constraints embedded in CCC system prompts come from CCE.`;
-function renderText$5(value) {
+function renderText$6(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -2894,7 +2894,7 @@ const cceTool = defineTool({
 	} },
 	output: {
 		schema: { type: "string" },
-		render: (_args, value) => renderText$5(value)
+		render: (_args, value) => renderText$6(value)
 	},
 	async execute(args) {
 		const section = args.section;
@@ -2965,10 +2965,10 @@ function handymanPresetInheritance(parentCtx) {
 * preset 继承 + 工具收窄：setup 钩子里对子 agent 执行 agentPresets.composeFrom（对齐
 * subagent 先例）+ tools.restrict deny handyman（worker 内部看不到 handyman 工具）。
 */
-function agentCwd$5(exec) {
+function agentCwd$6(exec) {
 	return (exec.agent?.session)?.header?.cwd ?? process.cwd();
 }
-function renderText$4(value) {
+function renderText$5(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -3185,11 +3185,11 @@ function createHandymanTool(ctx) {
 		},
 		output: {
 			schema: { type: "json" },
-			render: (_args, value) => renderText$4(value)
+			render: (_args, value) => renderText$5(value)
 		},
 		async execute(args, exec) {
 			if (args.guide) return { guide: HANDYMAN_GUIDE };
-			const root = findSerenityRoot(agentCwd$5(exec));
+			const root = findSerenityRoot(agentCwd$6(exec));
 			if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 			const hc = readHandymanConfig(root, DEFAULT_SERENITY_CONFIG_PATHS);
 			if (hc === null) throw new Error("handyman requires a model whitelist: configure .opencode/serenity.json \"handyman.models\" (e.g. {\"handyman\": {\"models\": [\"minimax-cn-coding-plan/MiniMax-M3\"], \"defaultModel\": \"minimax-cn-coding-plan/MiniMax-M3\"}})");
@@ -5987,7 +5987,7 @@ function qaCheck(root, key) {
 * 同步把当前 dsh 会话重命名为该 SESSION 目录名**（sessionTitle.rename，user source
 * pin 住标题）。非创建时预命名。
 */
-function agentCwd$4(exec) {
+function agentCwd$5(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
 /** 当前 dsh 会话 id（use/close 按会话隔离的 scope） */
@@ -6087,7 +6087,7 @@ function renameDshSessionForActive(ctx, exec, info) {
 		console.warn(`[serenity-hooks] dsh 会话重命名异常: ${String(err?.message ?? err)}`);
 	}
 }
-function renderText$3(value) {
+function renderText$4(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -6221,10 +6221,10 @@ function createSessionTool(ctx) {
 		},
 		output: {
 			schema: { type: "json" },
-			render: (args, value) => renderText$3(value)
+			render: (args, value) => renderText$4(value)
 		},
 		async execute(args, exec) {
-			const root = findSerenityRoot(agentCwd$4(exec));
+			const root = findSerenityRoot(agentCwd$5(exec));
 			if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 			const entries = loadMsmEntries(root);
 			const hasSessionTool = entries.some((e) => e.name === "session-tool");
@@ -6584,7 +6584,7 @@ function registerBootstrap(ctx) {
 }
 //#endregion
 //#region src/rebuild.ts
-const PLUGIN_SOURCE$3 = {
+const PLUGIN_SOURCE$4 = {
 	kind: "plugin",
 	plugin: "dsh-serenity-hooks"
 };
@@ -6770,7 +6770,7 @@ function registerRebuildTurnHook(ctx) {
 						type: "text",
 						text: "[TRAJECTORY-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."
 					}],
-					source: PLUGIN_SOURCE$3
+					source: PLUGIN_SOURCE$4
 				}));
 				console.log(`[serenity-hooks] session_rebuild executed with auto-continue (turn ${payload.turn ?? "?"} ended): ${id}`);
 			}
@@ -6796,13 +6796,13 @@ function registerRebuildTurnHook(ctx) {
 * （turn 结束前所有 tool/result 已 append → 无孤儿；S141 INVALID_REQUEST 根治）。
 * 服务端逻辑在 ../rebuild.ts（queueRebuild/performRebuild/registerRebuildTurnHook）。
 */
-function agentCwd$3(exec) {
+function agentCwd$4(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
 function agentSessionId(exec) {
 	return exec.agent?.session?.id ?? "";
 }
-function renderText$2(value) {
+function renderText$3(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -6819,17 +6819,17 @@ function createRebuildTool(ctx) {
 		} },
 		output: {
 			schema: { type: "json" },
-			render: (args, value) => renderText$2(value)
+			render: (args, value) => renderText$3(value)
 		},
 		async execute(args, exec) {
-			const root = findSerenityRoot(agentCwd$3(exec));
+			const root = findSerenityRoot(agentCwd$4(exec));
 			if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 			const dshSessionId = agentSessionId(exec);
 			if (!dshSessionId) throw new Error("Unable to determine the current dsh session id");
 			const result = await queueRebuild(ctx, {
 				root,
 				note: args.note,
-				agentCwd: agentCwd$3(exec),
+				agentCwd: agentCwd$4(exec),
 				dshSessionId
 			});
 			return {
@@ -6859,10 +6859,10 @@ const ACTIONS = [
 	"show",
 	"doc"
 ];
-function agentCwd$2(exec) {
+function agentCwd$3(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
-function renderText$1(value) {
+function renderText$2(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -6894,10 +6894,10 @@ const localstoreTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$1(value)
+		render: (args, value) => renderText$2(value)
 	},
 	async execute(args, exec) {
-		const root = findSerenityRoot(agentCwd$2(exec));
+		const root = findSerenityRoot(agentCwd$3(exec));
 		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 		return runLocalStore(root, args);
 	}
@@ -6912,10 +6912,10 @@ const localstoreTool = defineTool({
 *
 * 归属：ACC 机制工具（教会 + 校验），角色内容仍归 CCC 配置（.opencode/serenity.json skiff.roles）。
 */
-function agentCwd$1(exec) {
+function agentCwd$2(exec) {
 	return exec.agent?.session?.header?.cwd ?? process.cwd();
 }
-function renderText(value) {
+function renderText$1(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -7070,10 +7070,10 @@ const skiffAdminTool = defineTool({
 	} },
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText(value)
+		render: (args, value) => renderText$1(value)
 	},
 	async execute(args, exec) {
-		const root = findSerenityRoot(agentCwd$1(exec));
+		const root = findSerenityRoot(agentCwd$2(exec));
 		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
 		switch (args.action) {
 			case "guide": return { guide: SKIFF_GUIDE };
@@ -7085,6 +7085,103 @@ const skiffAdminTool = defineTool({
 	}
 });
 //#endregion
+//#region src/tools/autotrajectory-exp.ts
+/**
+* autotrajectory-exp.ts — 自主轨迹实验一站式管理工具（v1.26.12 实验提案，默认关）
+*
+* 定位：dsp **只提供工具与知识**，不向 CCC 自动安装任何东西（实验可能失败，不污染 CCC）——
+* 实验是 CCC 的自选动作：agent 调本工具（doc/全报告）即懂实验，init/random/check 辅助，
+* 实际执行（写配置/写偏见脚本/标记会话）由 CCC 自己决定、自己用现有工具完成。
+*
+* 实现：薄封装——exec 包内静态脚本（npm files 含 experiments/），脚本是单一真相源。
+* 环境注入 SERENITY_ROOT（当前 CCC 根）供脚本定位；bun 优先（可直跑 TS）。
+*/
+/**
+* 定位包内实验脚本（npm files 分发 experiments/autotrajectory/）。
+* 布局差异：tsdown bundle 后 import.meta.url 指向 lib/index.js（lib → 包根 1 层）；
+* vitest 源码直跑时指向 src/tools/x.ts（src/tools → 包根 2 层）——逐级上溯查找，
+* 两种布局都稳（找到 experiments/autotrajectory/scripts/autotrajectory-exp.ts 即止）。
+*/
+function findExpScript(startDir) {
+	let cur = startDir;
+	while (true) {
+		const cand = join(cur, "experiments", "autotrajectory", "scripts", "autotrajectory-exp.ts");
+		if (existsSync(cand)) return cand;
+		const parent = dirname(cur);
+		if (parent === cur) return null;
+		cur = parent;
+	}
+}
+/** 包内实验脚本（上溯查找；找不到 → execute 报错提示包完整性） */
+const EXP_SCRIPT = findExpScript(dirname(fileURLToPath(import.meta.url)));
+const AUTO_TRAJECTORY_EXP_ACTIONS = [
+	"all",
+	"init",
+	"random",
+	"doc",
+	"check",
+	"status",
+	"guide"
+];
+function agentCwd$1(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function renderText(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const autoTrajectoryExpTool = defineTool({
+	name: "autotrajectory-exp",
+	description: "自主轨迹实验（Self-Sustaining Trajectory）一站式管理——实验提案 v1.26.12，默认关。无参/action=all：全报告（背景摘要 + 就绪检查 + 状态 + 下一步）——CCC agent 看一次即完整理解实验并知道怎么开始；init：初始化辅助（写配置 + 生成偏见提供者脚本模板）；random：运行偏见提供者脚本输出当前偏见内容；doc：实验定义全文；check/status/guide：单项。实验是 CCC 的自选动作——dsp 只提供工具与知识，不自动安装任何东西。",
+	parameters: { action: {
+		type: "string",
+		enum: [...AUTO_TRAJECTORY_EXP_ACTIONS],
+		required: true,
+		description: "Subcommand"
+	} },
+	output: {
+		schema: { type: "json" },
+		render: (_args, value) => renderText(value)
+	},
+	async execute(args, exec) {
+		const root = findSerenityRoot(agentCwd$1(exec));
+		const result = {};
+		if (!EXP_SCRIPT) {
+			result.error = "autotrajectory-exp 实验脚本未随安装分发（npm 包缺 experiments/autotrajectory/）——请检查包完整性";
+			return result;
+		}
+		const script = EXP_SCRIPT;
+		if (!existsSync(script)) {
+			result.error = `autotrajectory-exp 脚本缺失（${script}）——实验包未随安装分发，请检查 npm 包完整性`;
+			return result;
+		}
+		const env = { ...process.env };
+		if (root) env.SERENITY_ROOT = root;
+		const r = spawnSync("bun", [script, args.action ?? "all"], {
+			encoding: "utf-8",
+			timeout: 6e5,
+			env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		if (r.status === 0) {
+			result.output = r.stdout?.trim() || "(empty)";
+			return result;
+		}
+		if (r.error?.code === "ENOENT") {
+			result.error = "autotrajectory-exp 需要 bun 运行时（bun not found in PATH）";
+			return result;
+		}
+		result.error = r.stderr?.trim() || r.stdout?.trim() || `exit ${r.status ?? "?"}`;
+		return result;
+	}
+});
+//#endregion
 //#region src/seams/keeper.ts
 const SCORES = {
 	write: 3,
@@ -7167,7 +7264,7 @@ function readContextPressure(ctx, session) {
 		return null;
 	}
 }
-const PLUGIN_SOURCE$2 = {
+const PLUGIN_SOURCE$3 = {
 	kind: "plugin",
 	plugin: "dsh-serenity-hooks"
 };
@@ -7230,7 +7327,7 @@ function registerKeeper(ctx, opts = {}) {
 		if (blocks.length === 0) return downstream;
 		const reminderAll = createUserMessage({
 			content: blocks,
-			source: PLUGIN_SOURCE$2
+			source: PLUGIN_SOURCE$3
 		});
 		if (downstream.kind === "block") return {
 			kind: "block",
@@ -8241,7 +8338,7 @@ function accIdentityText(root, configPaths = DEFAULT_SERENITY_CONFIG_PATHS, entr
 	}
 	return lines.join("\n");
 }
-const PLUGIN_SOURCE$1 = {
+const PLUGIN_SOURCE$2 = {
 	kind: "plugin",
 	plugin: "dsh-serenity-hooks"
 };
@@ -8258,7 +8355,7 @@ function accMessage(root, configPaths, entrySkillMaxChars) {
 	}];
 	return createUserMessage({
 		content,
-		source: PLUGIN_SOURCE$1
+		source: PLUGIN_SOURCE$2
 	});
 }
 /** 每 agent 是否已注入过（进程内存态） */
@@ -9787,7 +9884,7 @@ function buildRebuke(hits) {
 const rebukeStates = /* @__PURE__ */ new Map();
 //#endregion
 //#region src/output-guard-seam.ts
-const PLUGIN_SOURCE = {
+const PLUGIN_SOURCE$1 = {
 	kind: "plugin",
 	plugin: "dsh-serenity-hooks"
 };
@@ -9843,7 +9940,7 @@ function registerOutputGuardHook(ctx) {
 					type: "text",
 					text: buildRebuke(hits)
 				}],
-				source: PLUGIN_SOURCE
+				source: PLUGIN_SOURCE$1
 			}));
 		} catch (error) {
 			console.warn(`[serenity-hooks] output-guard steer failed: ${String(error?.message ?? error)}`);
@@ -12740,6 +12837,227 @@ qInput.focus()
 </html>`;
 }
 //#endregion
+//#region src/autotrajectory.ts
+const PLUGIN_SOURCE = {
+	kind: "plugin",
+	plugin: "dsh-serenity-hooks"
+};
+/** 自主轨迹会话目录后缀标志（用户拍板：后缀） */
+const AUTO_DIR_SUFFIX = "--auto";
+/** 调度 tick 周期（10min——验证形态"一个就够"） */
+const TICK_MS = 6e5;
+/** SESSION.md 内「下一轮动机」段标记（自生偏见载体——轨迹预设自己的未来） */
+const MOTIVATION_MARKER = "下一轮动机";
+/** 缺省避开的高峰时段（北京时间 [start, end) 不唤起——用量峰谷省钱） */
+const DEFAULT_AVOID_HOURS = {
+	start: 8,
+	end: 18
+};
+function readAutoTrajectorySettings(root) {
+	return loadSerenityConfig(root).autotrajectory ?? null;
+}
+/**
+* 北京时间（UTC+8）当前小时——不依赖服务器时区（服务器可能 UTC/本地任意）。
+*/
+function beijingHour(nowMs) {
+	return Math.floor((nowMs + 288e5) % 864e5 / 36e5);
+}
+/**
+* 唤起窗口判定：北京时间 [avoidStart, avoidEnd) 内不唤起（缺省 8~18）。
+* 单段避开（start<=end）：窗口 = [0,start) ∪ [end,24)；跨零点避开（start>end）：窗口 = [end,start)。
+*/
+function inAllowedWakeWindow(nowMs, avoid) {
+	const start = avoid?.start ?? DEFAULT_AVOID_HOURS.start;
+	const end = avoid?.end ?? DEFAULT_AVOID_HOURS.end;
+	const h = beijingHour(nowMs);
+	if (start <= end) return h < start || h >= end;
+	return h >= end && h < start;
+}
+/** 标志位判定：SESSION.md 所在目录名以 --auto 结尾 → 自主轨迹形态 */
+function isAutoTrajectorySession(mdPath) {
+	return basename(dirname(mdPath)).endsWith(AUTO_DIR_SUFFIX);
+}
+/**
+* 目标会话定位：**必须配置 cfg.session**（S###/目录名）——CCC 日常有多条 trajectory 在跑，
+* 绝不默认唤起（缺省最近活跃会误伤其他正在运行的轨迹；用户拍板：必须配置才生效）。
+* 未配置 session 或未命中 → null（不唤起）。
+*/
+function resolveTargetMd(root, cfg) {
+	if (!cfg?.session) return null;
+	const found = findSession(sessionsRoot(root), cfg.session);
+	if (!found) return null;
+	const md = join(found.path, "SESSION.md");
+	return existsSync(md) ? md : null;
+}
+/**
+* 唤起条件（纯逻辑，可测）：enabled + 未在运行 + 目录标志 + mtime 超间隔 + 窗口允许。
+*/
+function shouldWake(settings, mdPath, nowMs, running) {
+	if (!settings?.enabled || running) return false;
+	if (!mdPath || !isAutoTrajectorySession(mdPath)) return false;
+	if (!inAllowedWakeWindow(nowMs, settings.avoidWakeHours)) return false;
+	try {
+		const mtime = statSync(mdPath).mtimeMs;
+		const hours = Math.max(1, settings.intervalHours ?? 12);
+		return nowMs - mtime >= hours * 36e5;
+	} catch {
+		return false;
+	}
+}
+/** 自生动机读取：SESSION.md「下一轮动机」段内容（到下一个二级标题或文件尾；无 → null） */
+function readSelfGeneratedMotivation(mdPath) {
+	try {
+		const content = readFileSync(mdPath, "utf-8");
+		const idx = content.indexOf(MOTIVATION_MARKER);
+		if (idx < 0) return null;
+		const rest = content.slice(idx + 5);
+		const nextHeading = rest.search(/\n## /);
+		return (nextHeading >= 0 ? rest.slice(0, nextHeading) : rest).trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 偏见内容：直接运行 CCC 根目录下偏见提供者脚本（biasProvider，缺省 autotrajectory-bias.ts）→ stdout。
+* 脚本缺失 → 返回 { text: null, error: 提示实现 }（唤起侧报错要求实现，不静默跳过）。
+* 路径逃逸校验（resolveInside）；bun 优先，node 兜底；600s 超时。
+*/
+async function fetchBiasContent(root, providerRel) {
+	let scriptAbs;
+	try {
+		scriptAbs = resolveInside(root, providerRel);
+	} catch {
+		return {
+			text: null,
+			error: `biasProvider 路径逃逸（须在 CCC 根内）: ${providerRel}`
+		};
+	}
+	if (!existsSync(scriptAbs)) return {
+		text: null,
+		error: `请在 CCC 根目录实现偏见内容提供者脚本: ${providerRel}（stdout 输出偏见内容一行；acc_msm exec autotrajectory-exp init 可生成模板）`
+	};
+	const runs = [["bun", [scriptAbs]], [process.execPath, [scriptAbs]]];
+	for (const [cmd, args] of runs) try {
+		const r = spawnSync(cmd, args, {
+			encoding: "utf-8",
+			timeout: 6e5,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		if (r.status === 0) return {
+			text: (r.stdout ?? "").trim() || null,
+			error: null
+		};
+		if (r.error?.code === "ENOENT") continue;
+		return {
+			text: null,
+			error: `偏见内容提供者脚本执行失败（exit ${r.status ?? "?"}）: ${r.stderr?.trim() || r.stdout?.trim() || ""}`
+		};
+	} catch {
+		continue;
+	}
+	return {
+		text: null,
+		error: "偏见内容提供者脚本无法运行（bun 与 node 均不可用）"
+	};
+}
+/** 唤起消息（三段式：身份锚定 / 先验偏见[自生动机+偏见内容] / 任务）——注入前台会话，用户可见 */
+function buildWakeMessage(opts) {
+	const lines = [
+		`[自主轨迹唤起] — 距上次轨迹活动已满 ${opts.intervalHours} 小时，自动继续。`,
+		"",
+		`身份锚定：继续 ${opts.sessionName} 的 trajectory（SESSION.md: ${opts.mdPath}）。`,
+		"先验偏见："
+	];
+	if (opts.motivation) lines.push(`  · 自生动机：${opts.motivation}`);
+	if (opts.biasContent) lines.push(`  · 偏见内容：${opts.biasContent}`);
+	if (!opts.motivation && !opts.biasContent) lines.push("  · （无——本轮纯自主探索）");
+	lines.push("", "任务：执行一轮自主认知（探索/反事实检验），把产出写入 SESSION.md", "「自主探索日志」段，并预写「下一轮动机」段。完成后自然结束。");
+	return lines.join("\n");
+}
+/**
+* 装配（index.ts apply 调用）：仅当 CCC 配置 autotrajectory.enabled=true 时启动定时器；
+* 否则零资源占用。定时器 tick 检查唤起条件 → 注入活跃会话（agent.steer，前台可见）。
+*/
+function registerAutoTrajectory(ctx) {
+	const root = resolveAutoTrajectoryRoot(ctx);
+	const settings = root ? readAutoTrajectorySettings(root) : null;
+	if (!settings?.enabled) return;
+	let running = false;
+	const tick = () => {
+		if (running) return;
+		const mdPath = resolveTargetMd(root, settings);
+		if (!shouldWake(settings, mdPath, Date.now(), running)) return;
+		const agent = resolveTargetAgent(ctx, mdPath);
+		if (!agent) {
+			console.warn("[serenity-hooks] ✗ 自主轨迹唤起跳过：目标会话 agent 不可得（session use 激活后重试）");
+			return;
+		}
+		running = true;
+		(async () => {
+			try {
+				const provider = settings.biasProvider?.trim() || "autotrajectory-bias.ts";
+				const biasRes = await fetchBiasContent(root, provider);
+				if (biasRes.error) {
+					console.error(`[serenity-hooks] ✗ 自主轨迹唤起中止（偏见内容缺失）: ${biasRes.error}`);
+					return;
+				}
+				const motivation = readSelfGeneratedMotivation(mdPath);
+				const message = buildWakeMessage({
+					sessionName: basename(dirname(mdPath)),
+					mdPath,
+					intervalHours: settings.intervalHours ?? 12,
+					motivation,
+					biasContent: biasRes.text
+				});
+				agent.steer(createUserMessage({
+					content: [{
+						type: "text",
+						text: message
+					}],
+					source: PLUGIN_SOURCE
+				}));
+				console.log(`[serenity-hooks] ✓ 自主轨迹唤起（${basename(dirname(mdPath))}，偏见提供者 ${provider}）`);
+			} catch (err) {
+				console.warn(`[serenity-hooks] ✗ 自主轨迹唤起失败: ${String(err?.message ?? err)}`);
+			} finally {
+				running = false;
+			}
+		})();
+	};
+	setInterval(tick, TICK_MS).unref();
+	tick();
+}
+/** 目标 agent：从 SESSION.md 反向定位 dsh 会话（标题 F3 命名 S###-日期 匹配）；不可得 → null */
+function resolveTargetAgent(ctx, mdPath) {
+	const idMatch = basename(dirname(mdPath)).match(/--S(\d{3,})--/);
+	const sid = idMatch ? `S${idMatch[1]}` : null;
+	try {
+		const sessions = ctx.sessions;
+		for (const s of sessions?.list?.() ?? []) if (sid && (s.title === sid || s.title?.startsWith(`${sid}-`))) {
+			const agent = ctx.agents?.get?.(s.id ?? "");
+			if (agent) return agent;
+		}
+	} catch {}
+	return null;
+}
+/** 自主轨迹绑定的 CCC 根：进程 cwd 上溯 .serenity 优先，回退任一 live 会话 root */
+function resolveAutoTrajectoryRoot(ctx) {
+	const fromCwd = findSerenityRoot(process.cwd());
+	if (fromCwd) return fromCwd;
+	try {
+		const sessions = ctx.sessions;
+		for (const s of sessions?.list?.() ?? []) {
+			const r = findSerenityRoot(s?.header?.cwd ?? "");
+			if (r) return r;
+		}
+	} catch {}
+	return null;
+}
+//#endregion
 //#region src/index.ts
 const name = "dsh-serenity-hooks";
 /** 主动调用的服务；其余（agent 事件）随 harness 装配必然存在 */
@@ -12795,6 +13113,7 @@ function apply(ctx, config) {
 		ctx.tools.register(createRebuildTool(ctx));
 		ctx.tools.register(localstoreTool);
 		ctx.tools.register(skiffAdminTool);
+		ctx.tools.register(autoTrajectoryExpTool);
 	}
 	if (config.guards) registerGuards(ctx, { configPaths: config.serenityConfigPaths });
 	if (config.keeper) registerKeeper(ctx, {
@@ -12820,6 +13139,7 @@ function apply(ctx, config) {
 	registerBootstrap(ctx);
 	registerSkiff(ctx);
 	registerAcp(ctx);
+	registerAutoTrajectory(ctx);
 }
 /**
 * F4 Skiff 调试服务装配：启停 = 人工（设置面板 Skiff 区块开关，settings 持久化）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.26.11",
+  "version": "1.26.13",
   "description": "宁静号 ACC harness — Native Cordis 插件（DeepSeek Harness 运行时）。真实 DSH 工具注册（cc_fs/session/acc_msm 等 9 工具）+ 拦截缝机械约束（safe-mode/路径守卫/会话落盘）+ 系统提示词注入（ACC/CCE/Constraints/SKILL/Session 五块）。适配 DSH 公开版（deepseek-ai/deepseek-harness 0.1.0-rc）。",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,9 @@
     "lib/types/**/*.d.ts",
     "cordis.patch.yml",
     "dsh.plugin.json",
-    "README.md"
+    "README.md",
+    "experiments/autotrajectory/SKILL.md",
+    "experiments/autotrajectory/scripts/autotrajectory-exp.ts"
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",