@shgroup/dsh-serenity-hooks 1.34.2 → 1.36.0

package/lib/index.js

@@ -5,12 +5,9 @@ import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCw
 import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-B2ajFypI.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-CEHL5cek.js";
 import { a as unregisterSkiffSession$1, i as skiffSessionSnapshot$1, n as skiffRoleFor$1, r as skiffSessionInfo$1, t as registerSkiffSession$1 } from "./skiff-registry-FTjoWQTQ.js";
-import { _ as summarize, a as extractSessionMdPathFromText, d as readActiveSessionMd, f as resolveSessionByTitle, g as showSession, h as setActiveSessionInfo, i as createSession, l as listSessions, m as sessionsRoot, n as TRAJECTORY_ACTIONS, o as findSession, p as sessionEvents$1, r as clearActiveSessionInfo, s as getActiveSessionInfo, t as DEFAULT_SESSION_SCOPE, u as parseSessionContextFromEvents, v as useSession } from "./trajectory-ops-mrXK0H0I.js";
-import { i as resolveSessionTrajectoryLabel, n as listBoundSessionIds, r as readLastBound, t as appendBound } from "./trajectory-bound-Cax1p9ut.js";
-import { a as splitDueWakes, i as loadWakeRegistry, n as addWake, o as updateWake, r as listWakes, t as WAKE_CATCH_UP_MS } from "./wake-registry-CYxIb484.js";
-import { c as biasProviderAbsPath, d as isAutopilotSession, f as judgeWake, g as resolveTargetMd, h as readUtf8, l as fetchBiasContent, p as readAutopilotSettings, r as DEFAULT_BIAS_PROVIDER, s as beijingHour, t as AUTO_DIR_SUFFIX } from "./autopilot-core-DCRkiWEe.js";
-import { c as registerAutopilot, i as autopilotWakeInFlight, l as registerDisposer, n as autopilotGloballyEnabled, o as diagLive, r as autopilotRuntimeFacts, s as getAutopilotStatus, t as autopilotClockState, u as createClock } from "./autopilot-trajectory-D9Znxo75.js";
-import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-DTYZjwUs.js";
+import { _ as sessionsRoot, a as DEFAULT_SESSION_SCOPE, b as summarize, c as createSession, d as getActiveSessionInfo, f as listSessions, g as sessionEvents$1, h as resolveSessionByTitle, i as resolveSessionTrajectoryLabel, l as extractSessionMdPathFromText, m as readActiveSessionMd, n as listBoundSessionIds, o as TRAJECTORY_ACTIONS, p as parseSessionContextFromEvents, r as readLastBound, s as clearActiveSessionInfo, t as appendBound, u as findSession, v as setActiveSessionInfo, x as useSession, y as showSession } from "./trajectory-bound-DETSEBpL.js";
+import { a as splitDueWakes, i as loadWakeRegistry, n as addWake, o as updateWake, r as listWakes, t as WAKE_CATCH_UP_MS } from "./wake-registry-Cj2aSHME.js";
+import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-DMDUoQum.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-CtFYm53S.js";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
@@ -961,7 +958,6 @@ Directory of ACC capabilities — each area lists where to go for details (guide
   ① 轨迹本体          → container_trajectory（list/show/create/use + rebuild 超限重建 + wake-later 未来一次性唤醒）
                          原 logbook 已并入（v1.33 用户裁决：废除 logbook 词）；close/archive 删（归档走 container_fs mv），
                          health/qa/summary 分别并入 use / list，hook-develop-guide 并进 container_admin msm guide
-  ①b 周期自唤醒        → container_admin autopilot（status/init/generate-bias——D59 单例；status 含就绪与下一步）
   ② 认知质量框架      → praxis（eap/neat/cce 三合一——可实践理论注入，section 渐进披露，无参即目录）
   ③ 工具与执行        → container_fs（容器文件系统 15 子命令）/ container_git（git）/ dashboard（health 含注册表检查/time/wait）
                          acc_msm 已并入 msm（执行+发现）与 container_admin（管理）——msm("<name>", ["<args>"])；inspect=true 查用法
@@ -1110,15 +1106,16 @@ validate 校验 / apply 生效 / list 查看：container_admin role <guide|valid
           "systemPromptFile": ".opencode/skiff/qa.md"
         } } } }
 
-── 7. container_trajectory（轨迹：autopilot 自主巡航 + 唤醒注册表，D58）──
-CCC 定义的一条自主 trajectory——时钟到点自动唤起（前台注入，用户可见可介入）。
-**autopilot 是 trajectory 的子集**：周期自唤醒的特例；trajectory 本身是一等概念（一个 CCC 内可多条并行）。
-未配置或 enabled=false → 完全不启动（零资源占用）。多 CCC 独立：每 CCC 自己的配置。
-唤起消息四段式：轨迹焦点 topPrompt（最先注入，稳定锚）→ 身份锚定 → 先验偏见
-（CCC 根脚本 biasProvider 输出）→ 任务。目标会话 session 必填（目录须带 --auto 后缀）。
-诊断/状态/立即唤起：container_admin autopilot（status/init/generate-bias）；ACC 负责人专用运行态诊断见开发面。
+── 7. container_trajectory（轨迹 + 唤醒注册表，D58）──
+CCC 的一条 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 配置段保留**（见下表）——
+它现由 **CCC 侧脚本**读取，ACC 不再消费该段。
 唤醒注册表（container_trajectory wake-later）：唤醒 = 未来时刻 + 一条 message，可唤醒自己或别的 trajectory；
 落点 AGENT_SESSIONS/wake-registry.json，中心调度器到点投递（fire-and-forget；无回执、无回收）。
+运行态诊断（ACC 负责人专用）：acc-diag（① live 运行态 / ①b 唤醒时钟 / ③ 唤醒注册表）。
 
   Config:
     { "trajectory": {
@@ -3375,375 +3372,6 @@ const localstoreTool = defineTool({
 	}
 });
 //#endregion
-//#region src/autopilot-chain.ts
-/**
-* autopilot-chain.ts — **唤起条件链的唯一实现**（"为什么这轮没被唤起"）
-*
-* 为什么单独成模块（R↓，⑥ C6a 的硬约束）：
-* C6 裁决把 autopilot 拆两半——**入口**分两处（CCC 工具面 / 开发面），但**判据只能有一份**。
-* 若开发面另写"文件读取版"，刚消掉的分歧会在开发面复活。故：
-*   · `acc-diag` ④ 段（进程内，带运行态事实）—— `./diag-ops.ts` 调 {@link buildWakeChain}
-*   · 开发面 `dsh-develop diag [--ccc <path>]`（离线 bun 进程，无运行态事实）—— **import 同一实现**
-* 两者的差别**只是传入的 facts**（进程内三项已知 / 离线三项不可知），判据本身不复制。
-*
-* 本模块**零 DSH 依赖**（只 node:fs/path + `ccc.js` + `autopilot-core.js`）——离线 bun 进程
-* 才 import 得动。判据一律取自 {@link judgeWake}（判据唯一真相源），本模块只做**分解与分类**。
-*
-* 判决语义（§12.7 修复，**不得回退**）：
-*   `✗` = 配置/环境问题（需人改，如 enabled=false / session 未命中 / agent 未加载）
-*   `⏸` = 等待中（到点/出窗口/上一轮跑完自会满足——**非**配置问题）
-*   `?` = 不可知（离线通道看不到的运行态；**不**当成满足）
-*   **只有 `✗` 与 `⏸` 都为空、且无 `?` 时才印 ✅**——旧实现只统计 `✗` ⇒ 每天北京 8~18 点
-*   （10 小时）都印「✅ 唤起条件全部满足」而插件实际不唤起（假阳性，已实测复现）。
-*/
-/** 离线通道事实（三项运行态全不可知） */
-const NO_RUNTIME_FACTS = {
-	globalGate: null,
-	running: null,
-	live: null
-};
-/**
-* 组装条件链（**唯一实现**）。
-*
-* @param root CCC 根
-* @param facts 运行态事实（离线通道传 {@link NO_RUNTIME_FACTS}）
-* @param now 当前时刻（测试注入）
-* @param biasProbe 偏见执行（默认 {@link fetchBiasContent}——**不另写 spawn**）
-* @returns 结构化报告（渲染见 {@link renderWakeChain}）
-*/
-async function buildWakeChain(root, facts = NO_RUNTIME_FACTS, now = Date.now(), biasProbe = fetchBiasContent) {
-	const lines = [`═══ 自主轨迹唤起诊断：${basename(root)}（${root}）═══`];
-	const blockers = [];
-	const waiting = [];
-	const unknowns = [];
-	const suggestions = [];
-	const mark = (kind, text) => {
-		const line = `${kind === "ok" ? "✓" : kind === "bad" ? "✗" : kind === "wait" ? "⏸" : kind === "unknown" ? "?" : "·"} ${text}`;
-		lines.push(`  ${line}`);
-		if (kind === "bad") blockers.push(line);
-		if (kind === "wait") waiting.push(line);
-		if (kind === "unknown") unknowns.push(line);
-	};
-	if (facts.globalGate === null) mark("unknown", "周期自唤醒全局闸：不可知（离线通道——只有插件进程能读 DSH 设置）");
-	else if (!facts.globalGate) {
-		mark("bad", "周期自唤醒全局闸关闭（autopilotWakeEnabled=false）——时钟不武装，绝不唤起");
-		suggestions.push("在 DSH 设置面板打开「周期自唤醒」（autopilotWakeEnabled）——关着则本 CCC 永不唤起");
-	} else mark("ok", "周期自唤醒全局闸开启（autopilotWakeEnabled=true）");
-	const cfg = readAutopilotSettings(root);
-	if (!cfg) {
-		mark("bad", "trajectory.autopilot 未配置（.opencode/serenity.json 缺段）");
-		suggestions.push("配置：container_admin autopilot init 一键写入 trajectory.autopilot 段");
-	} else if (!cfg.enabled) {
-		mark("bad", "enabled = false（该 CCC 的周期自唤醒关闭）");
-		suggestions.push("置 trajectory.autopilot.enabled = true");
-	} else mark("ok", "enabled = true");
-	if (cfg) {
-		lines.push(`    配置: intervalHours=${cfg.intervalHours ?? 12} | biasProvider=${cfg.biasProvider?.trim() || "autopilot-bias.ts"}${cfg.session ? ` | session=${cfg.session}` : " | session=未配置"}`);
-		const avoid = cfg.avoidWakeHours;
-		lines.push(`    窗口避开北京 ${avoid?.start ?? 8}~${avoid?.end ?? 18} 点`);
-	}
-	const md = resolveTargetMd(root, cfg ?? {});
-	if (!cfg?.session) {
-		mark("bad", "session 未配置（必填——自动唤起不默认任何会话）");
-		suggestions.push("配置 trajectory.autopilot.session: \"S###\"（目标会话 S###/目录名）");
-	} else if (!md) {
-		mark("bad", `session=${cfg.session} 未命中（AGENT_SESSIONS 无匹配目录；匹配规则 = findSession：补零/去大小写）`);
-		suggestions.push("确认目标会话存在（目录名含该关键字；S### 可省略补零）");
-	} else mark("ok", `session=${cfg.session} 命中（${basename(dirname(md))}）`);
-	if (md) {
-		if (isAutopilotSession(md)) mark("ok", "会话目录带 --auto 标志");
-		else {
-			mark("bad", `会话目录无 --auto 标志（${basename(dirname(md))}）`);
-			suggestions.push(`目录名加 ${AUTO_DIR_SUFFIX} 后缀：AGENT_SESSIONS/<date>--<desc>${AUTO_DIR_SUFFIX}/`);
-		}
-	}
-	const j = judgeWake(cfg, md, now);
-	if (md && j.idleHours !== null) {
-		if (j.intervalOk) mark("ok", `距上次轨迹活动 ${j.idleHours.toFixed(1)}h ≥ 阈值 ${j.interval}h`);
-		else mark("wait", `距上次轨迹活动 ${j.idleHours.toFixed(1)}h < 阈值 ${j.interval}h（等待中——不满足不唤起）`);
-	}
-	const h = beijingHour(now);
-	if (j.windowOk) mark("ok", `当前北京 ${h} 点——在唤起窗口内`);
-	else mark("wait", `当前北京 ${h} 点——高峰避开中（缺省 8~18，用量峰谷省钱）`);
-	if (cfg?.enabled) {
-		const bias = await biasProbe(root, cfg.biasProvider?.trim() || "autopilot-bias.ts");
-		if (bias.error) {
-			mark("bad", `偏见脚本: ${bias.error}`);
-			suggestions.push("实现偏见脚本（container_admin autopilot init 生成模板后编辑）");
-		} else mark("ok", `偏见脚本可运行（输出: ${bias.text ?? "（空）"}）`);
-	}
-	if (facts.live === null) mark("unknown", "目标会话 live 运行态：不可知（离线通道——live 会话/agent 只有插件进程能看到）");
-	else if (facts.live.agentResolved === null) lines.push(`  · live 会话: 本 CCC ${facts.live.sessionCount} 个（agent 可解析性不适用——目标会话未命中）`);
-	else if (facts.live.agentResolved) mark("ok", `目标会话 agent 已定位（本 CCC live 会话 ${facts.live.sessionCount} 个）`);
-	else {
-		mark("bad", `目标会话 agent 未定位（本 CCC live 会话 ${facts.live.sessionCount} 个）`);
-		if (facts.live.diagnosis) lines.push(`    ${facts.live.diagnosis}`);
-		suggestions.push("在 WebUI 打开目标会话（唤起需要 live agent 接收注入）");
-	}
-	if (facts.running === null) mark("unknown", "重入守卫：不可知（离线通道——进行中的唤起轮只有插件进程知道）");
-	else if (facts.running) mark("wait", "该 CCC 已有一轮唤起在进行中（本轮跳过——跑完自然恢复）");
-	else mark("ok", "无进行中的唤起轮");
-	lines.push("");
-	let verdict;
-	let judgement;
-	if (blockers.length === 0 && waiting.length === 0 && unknowns.length === 0) {
-		verdict = "ready";
-		judgement = `✅ 唤起条件全部满足——等待下一个 5min tick 自动唤起（前台可见）`;
-	} else if (blockers.length === 0 && waiting.length === 0) {
-		verdict = "unknown";
-		judgement = `? 已知条件全部满足——但有 ${unknowns.length} 项不可知（${unknowns.length > 0 ? "离线通道看不到运行态" : ""}）；是否真会唤起需插件进程判定（acc-diag）`;
-	} else if (blockers.length === 0) {
-		verdict = "waiting";
-		judgement = `⏸ 尚未满足 ${waiting.length} 项（等待中——到点/出窗口后自动满足，**非**配置问题；见上方 ⏸ 行）`;
-	} else {
-		verdict = "blocked";
-		judgement = `⚠️ 阻断点 ${blockers.length} 项${waiting.length > 0 ? `（另 ${waiting.length} 项等待中）` : ""}（全部满足才唤起）：`;
-	}
-	lines.push(judgement);
-	if (verdict === "blocked") for (const s of suggestions) lines.push(`  → ${s}`);
-	if (verdict !== "blocked" && unknowns.length > 0) lines.push(`  · 不可知项：${unknowns.length} 项（见上方 ? 行——离线通道看不到运行态，**不**当作满足）`);
-	return {
-		root,
-		lines,
-		blockers,
-		waiting,
-		unknowns,
-		suggestions,
-		verdict,
-		judgement
-	};
-}
-/** 条件链渲染（④ 段文本；`renderAccDiag` 与开发面 `diag` 共用） */
-function renderWakeChain(r) {
-	return r.lines.join("\n");
-}
-//#endregion
-//#region src/autopilot-ops.ts
-/**
-* CCC 配置路径回退链（与 `ccc.ts` 的 `DEFAULT_SERENITY_CONFIG_PATHS` 同序）：
-* `.opencode/serenity.json` 优先，不存在则 `.dsh/serenity.json`（**沿用旧脚本语义**）。
-*/
-const CONFIG_PATHS = [".opencode/serenity.json", ".dsh/serenity.json"];
-/** 偏见内容提供者脚本脚手架模板（init 生成；CCC 按自己的反馈信息来源改写） */
-const BIAS_TEMPLATE = `#!/usr/bin/env bun
-/**
- * autopilot-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 记录器→校准器（预测加工）。完整定义：experiments/autopilot-trajectory/SKILL.md。",
-	""
-].join("\n");
-/** 步骤指引（`status` 末节；与 SKILL.md §3「参与方式」同源） */
-const GUIDE = [
-	"[autopilot-trajectory] 实验步骤指引",
-	"",
-	"① 初始化（一键）：container_admin autopilot init",
-	"   ——写配置（.opencode/serenity.json 的 trajectory.autopilot 段）+ 生成偏见提供者脚本模板（CCC 根 autopilot-bias.ts）",
-	"② **定义轨迹焦点（topPrompt）**：编辑配置中的 topPrompt——**CCC 自己填写**本轨迹的核心",
-	"   目标/纪律/质量要求（示例：\"持续深化某领域认知，产出可重建的结论与决策记录\"）。",
-	"   它会在每次唤起时最先注入（[轨迹焦点] 段），作为稳定焦点锚定 trajectory 防漂移——",
-	"   **实验观察：无焦点锚定时多轮唤起轨迹腐化严重（焦点丢失）**。勿留空。",
-	"③ 实现偏见内容提供者：编辑 autopilot-bias.ts，stdout 输出偏见内容（反事实方向/探索动机，",
-	"   用本 CCC 自己的信息来源保证\"足够随机\"）；container_admin autopilot generate-bias 验证",
-	"④ 标记目标会话：目录名加 --auto 后缀 AGENT_SESSIONS/<date>--<desc>--auto/",
-	"   （可选）该 SESSION.md 写「下一轮动机」段作自生偏见",
-	"⑤ 验证就绪：container_admin autopilot status（一站式报告应为 ✅；topPrompt 未定义会 ⚠ 提示）",
-	"⑥ **确认全局闸已开**：DSH 设置面板「周期自唤醒」（autopilotWakeEnabled）——关着则本 CCC 永不唤起",
-	"⑦ 观察：无人类活动满 intervalHours 且北京非高峰 → 前台会话自动出现 [自主轨迹唤起]",
-	"   产出落 SESSION.md「自主探索日志」+ 预写「下一轮动机」",
-	"",
-	"分工：焦点（topPrompt）= 稳定锚，每轮不变；偏见（biasProvider）= 随机探索方向，每轮不同——两者都由 CCC 定义。",
-	"定义全文见 experiments/autopilot-trajectory/SKILL.md（仓库内文档，不再有可执行脚本 entry）",
-	"运行态诊断（live 会话 / agent 定位 / 唤醒注册表 / 本条件链）：专属工具 acc-diag（ACC 负责人）"
-].join("\n");
-/**
-* 条件链事实：全局闸与重入守卫**恒为真值**（二者不需要 ctx）；live 运行态在无 ctx 时标"不可知"。
-* 即"闸关着"在任何进程中路径都**不会**被降级成 `?`（假报告的正是这一类）。
-*/
-function factsFor(root, ctx) {
-	return autopilotRuntimeFacts(ctx ?? null, root);
-}
-/** 就绪检查（= 旧脚本 `check`）：条件链的逐条件报告 + 判决（判据单一真相源 = `buildWakeChain`） */
-async function autopilotCheck(root, ctx) {
-	return buildWakeChain(root, factsFor(root, ctx));
-}
-/**
-* 进程态区块（**进程内新增的增益**——旧脚本永远看不到这一行）：
-* 全局闸 / 时钟是否武装 / 已 tick 次数 / 上次 tick / 上次跳过原因 / 是否有唤起在进行中。
-* "为什么没唤起"的第一手判据：闸关着、时钟没武装时，条件再全绿也不会唤起。
-*/
-function runtimeBlock(root) {
-	const s = autopilotClockState();
-	const ts = (ms) => ms === null ? "（从未）" : new Date(ms).toISOString();
-	const parts = [
-		`全局闸=${s.enabled ? "开" : "关"}`,
-		`时钟已武装=${s.armed}`,
-		`tick 次数=${s.ticks}`,
-		`上次 tick=${ts(s.lastTickAt)}`
-	];
-	if (s.lastSkipReason) parts.push(`上次跳过: ${s.lastSkipReason}`);
-	parts.push(`本轮唤起进行中=${autopilotWakeInFlight(root)}`);
-	return `进程态（本插件进程）：${parts.join(" ｜ ")}`;
-}
-/** 状态快照区块（配置 / 目标 / 空闲时长 / 窗口——数值取自 `autopilot-core` 的同一判据） */
-function stateBlock(root) {
-	const cfg = readAutopilotSettings(root);
-	const now = Date.now();
-	const hour = Math.floor((now + 288e5) % 864e5 / 36e5);
-	const head = `[autopilot-trajectory] 实验状态（CCC: ${basename(root)}，北京 ${hour} 点）`;
-	if (!cfg?.enabled) return [
-		head,
-		"",
-		"trajectory.autopilot 未启用（enabled=false 或未配置）——零资源占用"
-	].join("\n");
-	const lines = [
-		head,
-		"",
-		`配置: intervalHours=${cfg.intervalHours ?? 12} | biasProvider=${cfg.biasProvider?.trim() || "autopilot-bias.ts"}${cfg.session ? ` | session=${cfg.session}` : ""}${cfg.topPrompt?.trim() ? " | topPrompt ✓" : ""}`
-	];
-	const md = resolveTargetMd(root, cfg);
-	if (!md) {
-		lines.push("目标会话：未找到");
-		return lines.join("\n");
-	}
-	const j = judgeWake(cfg, md, now);
-	lines.push(`目标会话：${basename(dirname(md))}${isAutopilotSession(md) ? "（--auto ✓）" : "（无 --auto 标志）"}`);
-	lines.push(`上次轨迹活动：${j.idleHours === null ? "（不可读）" : `${j.idleHours.toFixed(1)} 小时前`}（阈值 ${j.interval}h）`);
-	lines.push(`唤起窗口：${j.windowOk ? "✅ 允许唤起" : "⏸ 高峰避开中（北京 8~18）"}`);
-	lines.push(`是否可唤起：${j.wakeable ? `✅ 时间条件满足（仍须全局闸开 + agent 已定位；见上/下）` : !j.intervalOk ? `否——距上次活动不足 ${j.interval}h` : "否——高峰避开中"}`);
-	return lines.join("\n");
-}
-/** 下一步判据（与旧脚本 `all` 的「下一步」同语义，但改读**条件链判决**——不再自己判一遍） */
-function nextSteps(chain) {
-	const lines = ["═══ 下一步 ═══"];
-	const noCfg = chain.blockers.some((b) => b.includes("trajectory.autopilot 未配置"));
-	const disabled = chain.blockers.some((b) => b.includes("enabled = false"));
-	if (noCfg) lines.push("→ 本 CCC 尚未配置 trajectory.autopilot。开始实验：container_admin autopilot init 一键初始化。");
-	else if (disabled) lines.push("→ trajectory.autopilot.enabled 为 false——置 true 开启实验（或 init 重新初始化）。");
-	else if (chain.verdict === "blocked") lines.push("→ 存在未就绪项（见上）。补齐后重跑本命令确认。");
-	else if (chain.verdict === "waiting") lines.push("→ 条件尚未到点（见上 ⏸ 行）——等待中，非配置问题；到点/出窗口后自动唤起。");
-	else {
-		lines.push("→ 已就绪。保持会话空闲满 intervalHours 且北京非高峰 → 自动唤起（前台可见）。");
-		lines.push("→ 之后可随时 container_admin autopilot status 查看距下次唤起的进度。");
-	}
-	return lines.join("\n");
-}
-/**
-* `status` —— 一站式全报告（背景 + 就绪检查 + 进程态 + 状态 + 下一步 + 指引）。
-* 由进程内数据组装（旧实现是 `bun` 子进程跑脚本，故看不到任何运行态）。
-*/
-async function autopilotStatus(root, ctx) {
-	const chain = await autopilotCheck(root, ctx);
-	return {
-		action: "status",
-		output: [
-			BACKGROUND,
-			renderWakeChain(chain),
-			"",
-			runtimeBlock(root),
-			"",
-			stateBlock(root),
-			"",
-			nextSteps(chain),
-			"",
-			GUIDE
-		].join("\n")
-	};
-}
-/**
-* `init` —— 写/迁移 CCC 配置 + 生成偏见脚本模板。
-*
-* 迁移语义（沿用旧脚本，理由写在码内）：写入**新键** `trajectory.autopilot`（D58）；
-* 旧键 `autopilotTrajectory` / `autotrajectory` 存在则**迁移并删除**——保留两处会形成
-* "改了不生效"的双真相源（读侧新键优先，旧键是死数据）。
-*/
-function autopilotInit(root) {
-	const out = ["[autopilot-trajectory] 初始化实验", ""];
-	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 = {};
-	if (existsSync(cfgPath)) try {
-		merged = JSON.parse(readUtf8(cfgPath));
-	} catch {}
-	const traj = merged.trajectory ?? {};
-	const legacy = merged.autopilotTrajectory ?? merged.autotrajectory;
-	const at = traj.autopilot ?? legacy ?? {};
-	merged.trajectory = {
-		...traj,
-		autopilot: {
-			enabled: true,
-			intervalHours: 12,
-			biasProvider: DEFAULT_BIAS_PROVIDER,
-			topPrompt: "本轨迹的核心焦点：<CCC 填写——例如：持续深化某领域认知，产出可重建的结论与决策记录>",
-			...at
-		}
-	};
-	const migrated = Boolean(legacy);
-	delete merged.autopilotTrajectory;
-	delete merged.autotrajectory;
-	writeFileSync(cfgPath, `${JSON.stringify(merged, null, 2)}\n`);
-	out.push(`✓ 配置写入: ${cfgPath}`);
-	out.push(`  trajectory.autopilot = ${JSON.stringify(merged.trajectory.autopilot)}`);
-	if (migrated) out.push("  ↑ 已从旧键 autopilotTrajectory/autotrajectory 迁移到 trajectory.autopilot（旧键已删除，避免双真相源）");
-	out.push("  ⚠ 请编辑 topPrompt 为**本 CCC 的轨迹焦点**（现为占位——每次唤起最先注入，防轨迹漂移，勿留空）");
-	const scriptAbs = biasProviderAbsPath(root, DEFAULT_BIAS_PROVIDER);
-	if (existsSync(scriptAbs)) out.push(`· 偏见提供者脚本已存在（保留）: ${DEFAULT_BIAS_PROVIDER}`);
-	else {
-		writeFileSync(scriptAbs, BIAS_TEMPLATE);
-		out.push(`✓ 已生成偏见提供者脚本模板: ${DEFAULT_BIAS_PROVIDER}（编辑它，stdout 输出偏见内容）`);
-	}
-	const gate = autopilotGloballyEnabled();
-	out.push(gate ? "✓ 周期自唤醒全局闸已开（autopilotWakeEnabled=true）" : "✗ 周期自唤醒全局闸**关着**（autopilotWakeEnabled=false）——配置写完也不会唤起，请在 DSH 设置面板打开「周期自唤醒」");
-	out.push("", "下一步：② 编辑配置 topPrompt（轨迹焦点——CCC 自己填写本轨迹核心目标，勿留空）→ ③ 标记目标会话 --auto 后缀 → ⑤ container_admin autopilot status 验证就绪");
-	return {
-		action: "init",
-		output: out.join("\n")
-	};
-}
-/**
-* `generate-bias` —— 运行偏见提供者脚本并打印本轮内容（验证用）。
-* **复用 tick 的 {@link fetchBiasContent}**（同一份执行代码：60s 超时 / 8KB 截断 /
-* 旧默认名回退）——不另写 spawn（§12.13）。
-*/
-async function autopilotGenerateBias(root) {
-	const provider = readAutopilotSettings(root)?.biasProvider?.trim() || "autopilot-bias.ts";
-	const bias = await fetchBiasContent(root, provider);
-	if (bias.error) return {
-		action: "generate-bias",
-		output: "",
-		error: bias.error
-	};
-	return {
-		action: "generate-bias",
-		output: `[autopilot-trajectory] 当前偏见内容（${provider}）:\n${bias.text ?? "（空输出）"}`
-	};
-}
-//#endregion
 //#region src/tools/skiff-admin.ts
 /** Skiff 定义教程（核心）：概念 / schema / 认知 MSM 写法 / 双白名单 / 轨迹纪律 / 示例角色 */
 const SKIFF_GUIDE = `═══ Skiff Definition Guide (F4, experimental) ═══
@@ -3895,9 +3523,9 @@ function applySkiffConfig(root) {
 * 参数极简（LLM 直觉）：domain（管理域）+ action（该域子命令）+ 少量业务参数。
 *
 * v1.34.1（⑥ C6a）：由 `export const containerAdminTool` 改为**工厂**
-* `createContainerAdminTool(ctx)`——autopilot 域搬进进程内后，`status` 必须读只有进程内
-* 能看到的事实（全局闸 / live 会话 / agent 可解析性，见 `../autopilot-ops.js`）。
-* 这是本轮唯一为"取 ctx"而做的形态改动（其余域不依赖 ctx，行为不变）。
+* `createContainerAdminTool(ctx)`——原为 autopilot 域传进程内运行态事实（全局闸 / live 会话 /
+* agent 可解析性）。该域已于 2026-09-15 随 ACC 侧 autopilot 整段退场删除（所有者裁决 (a)）：
+* `ctx` 现**无消费者**，工厂形态保留只是为了让装配点签名不再变动（见 index.ts 注册处）。
 */
 function agentSessionId(exec) {
 	return exec.agent?.session?.id ?? "";
@@ -3908,8 +3536,8 @@ function renderText$1(value) {
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
 	}];
 }
-/** 管理面动作映射：domain → 可执行 action（转发到底层 runMsm / skiff 逻辑 / autopilot 进程内实现） */
-const ADMIN_ACTIONS = {
+/** 合法 domain 名（拒绝文案与 schema enum 同源——不得各写一份） */
+const DOMAIN_NAMES = Object.keys({
 	role: [
 		"guide",
 		"validate",
@@ -3924,44 +3552,22 @@ const ADMIN_ACTIONS = {
 		"catalog",
 		"ccc-config"
 	],
-	config: ["view"],
-	autopilot: [
-		"status",
-		"init",
-		"generate-bias"
-	]
-};
-/**
-* autopilot 域动作（`container_admin` 的对外实名）。
-* 三动作的实现在**插件进程内**（`../autopilot-ops.js`）——S142 §12.8 裁决「拆两半、退掉独立脚本」：
-* 旧实现 spawn 包内脚本（独立进程 ⇒ 看不到全局闸 / live 会话 / agent 可解析性 ⇒ 8 项结构性分歧），
-* 现直调进程内实现，与 tick 读**同一份判据**。`diag`/`doc`/`check`/`guide` 仍不在 CCC 工具面
-* （条件链归 `acc-diag` ④ 段 + 开发面 `dsh-develop diag`）。
-*/
-const AUTOPILOT_ACTIONS = [
-	"status",
-	"init",
-	"generate-bias"
-];
+	config: ["view"]
+});
 function createContainerAdminTool(ctx) {
 	return defineTool({
 		name: "container_admin",
-		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): role — Skiff cognitive-subset roles (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference); config — view CCC configuration; autopilot — periodic self-wake (D59): status (one-shot full report: background + readiness + state + next steps) / init (write config + bias-provider script template) / generate-bias (run the CCC bias script — the randomness source belongs to the CCC). Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
+		description: "Container administration (the ship's maintenance bay — one entry for managing the CCC): role — Skiff cognitive-subset roles (guide/validate/apply/list); msm — MSM registry management (register/deregister/check quality DC-M1~M4) + manuals (guide dev manual / catalog ACC capability directory / ccc-config CCC configuration reference); config — view CCC configuration. Execution of registered MSMs belongs to the msm tool; this tool manages the container.",
 		parameters: {
 			domain: {
 				type: "string",
-				enum: [
-					"role",
-					"msm",
-					"config",
-					"autopilot"
-				],
+				enum: DOMAIN_NAMES,
 				required: true,
-				description: "Management domain: role (Skiff roles) / msm (MSM registry + manuals) / config (CCC config view) / autopilot (periodic self-wake)"
+				description: "Management domain: role (Skiff roles) / msm (MSM registry + manuals) / config (CCC config view)"
 			},
 			action: {
 				type: "string",
-				description: "Domain subcommand (see domain descriptions; e.g. role: validate/apply/list/guide; msm: register/deregister/check/guide/catalog/ccc-config; autopilot: status/init/generate-bias)"
+				description: "Domain subcommand (see domain descriptions; e.g. role: validate/apply/list/guide; msm: register/deregister/check/guide/catalog/ccc-config)"
 			},
 			name: {
 				type: "string",
@@ -4034,20 +3640,8 @@ function createContainerAdminTool(ctx) {
 					usage: args.usage
 				});
 			}
-			if (domain === "autopilot") {
-				if (!AUTOPILOT_ACTIONS.includes(action)) throw new Error(`container_admin autopilot requires action: ${ADMIN_ACTIONS.autopilot.join(" | ")}`);
-				const r = action === "init" ? autopilotInit(root) : action === "generate-bias" ? await autopilotGenerateBias(root) : await autopilotStatus(root, ctx);
-				if (r.error) return {
-					error: r.error,
-					action: r.action
-				};
-				return {
-					action: r.action,
-					output: r.output
-				};
-			}
 			if (domain === "config") return { config: runMsm(root, { action: "ccc-config" }) };
-			throw new Error(`container_admin requires domain: role | msm | config | autopilot`);
+			throw new Error(`container_admin requires domain: ${DOMAIN_NAMES.join(" | ")}`);
 		}
 	});
 }
@@ -5032,8 +4626,8 @@ var KeeperTracker = class {
 		return this.score;
 	}
 };
-function reminderText(code, score) {
-	return `${eventToken("checkpoint")} Score threshold reached (${score}). Please acknowledge with [${ACK_PREFIX}-${code}] once progress is synced to the working session (acc-session show). No need to interrupt your work — just acknowledge inline and keep going.`;
+function reminderText(code) {
+	return `${eventToken("checkpoint")} Score threshold reached. Please acknowledge with [${ACK_PREFIX}-${code}] once progress is synced to the working session (acc-session show). No need to interrupt your work — just acknowledge inline and keep going.`;
 }
 /**
 * F2 rebuild 提示（v1.21；v1.22.1 对齐"轨迹跟踪器"概念；v1.23.0 英化 + 载体关系；
@@ -5048,18 +4642,24 @@ function reminderText(code, score) {
 * escalated=true（v1.23.3）：连续多轮超阈值仍未 rebuild → 升级强制语气
 * （STOP and rebuild now，持续注入直到调用 container_trajectory rebuild）。
 *
-* 需求①（S142 用户拍板）：百分比比例 → K 数值——tokensK = 实际占用（千 token），
-* thresholdK = 配置阈值（千 token）；文案 `Context usage at NNNK (threshold NNNK)`。
+* 需求①（S142 用户拍板，v1.28.0）：百分比比例 → K 数值——**判定**改为绝对
+* `projectedTokens ≥ thresholdK*1000`（触发语义，未变）。
+* 🔴 2026-09-16（S142 所有者指令，D64）：**判定用 K，但注入文本里不再给任何数值**——
+*   原文案 `Context usage at NNNK (threshold NNNK)` 属于"向 LLM 透露上下文消耗与限制"，
+*   是非必要信息（LLM 不据此决策，只占注意力）。⇒ 参数退化为仅 `escalated`。
+*   ⚠️ 触发判定与提醒行为**一字未改**（仍读 projectedTokens / thresholdK 比对；仍升级催）；
+*   变的只是**注入文本不再携带 tokensK / thresholdK**。
+*   使用者若要查看当前占用/阈值：看面板（`rebuildThresholdK` 滑块 + 状态显示）——那是给人看的。
 *
 * v1.31.1 交接协议（S142 用户需求"要求 LLM 将当前手头事项写在 SESSION.md 尾部，并要求
 * rebuild 后去读并处理"）：**写侧** = 这里（两条文案都要求把 in-flight 事项写在
 * SESSION.md 末尾的 `IN_FLIGHT_HEADING` 之下）；**读侧** = rebuild 锚点（rebuild.ts）。
 * 两侧共用 trajectory-assistant 的标题常量（单一真相源）。
 */
-function rebuildReminderText(tokensK, thresholdK, escalated = false) {
+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) at the very end of SESSION.md under the heading "${IN_FLIGHT_HEADING}" — the rebuilt conversation reads that section first and continues from it.`;
-	if (escalated) return `${eventToken("limitMandatory")} Context usage at ${Math.round(tokensK)}K (threshold ${Math.round(thresholdK)}K) — 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 at ${Math.round(tokensK)}K (threshold ${Math.round(thresholdK)}K). 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.`;
+	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.`;
 }
 /** 读取会话 contextPressure 投影（sessionProjections 可选服务；未装配返回 null） */
 function readContextPressure(ctx, session) {
@@ -5204,7 +4804,7 @@ function registerKeeper(ctx, opts = {}) {
 			const code = tracker.ack();
 			blocks.push({
 				type: "text",
-				text: reminderText(code, tracker.currentScore)
+				text: reminderText(code)
 			});
 		}
 		if (skiffRebuild && readSimpleSettings().rebuildEnabled) {
@@ -5212,7 +4812,6 @@ function registerKeeper(ctx, opts = {}) {
 			if (session) {
 				const pressure = readContextPressure(ctx, session);
 				if (pressure && pressure.projectedTokens > 0) {
-					const tokensK = pressure.projectedTokens / 1e3;
 					const thresholdK = readSimpleSettings().rebuildThresholdK;
 					if (pressure.projectedTokens >= thresholdK * 1e3) {
 						const key = exec.agent?.session?.id ?? "global";
@@ -5221,7 +4820,7 @@ function registerKeeper(ctx, opts = {}) {
 						const escalated = st.consecutive >= REBUILD_ESCALATE_AFTER;
 						blocks.push({
 							type: "text",
-							text: rebuildReminderText(tokensK, thresholdK, escalated)
+							text: rebuildReminderText(escalated)
 						});
 						rebuildReminderStates.set(key, st);
 					}
@@ -5983,7 +5582,7 @@ function toolsBlock() {
 		"  praxis       — actionable theory injection: praxis (index) / praxis eap / praxis neat / praxis cce",
 		"  handyman     — delegate work to a worker agent on a CCC-whitelisted model; mode=\"foreground\" (default) = one serial child returns its final text; mode=\"background\" = loop-validated worker (completion code + round cap + restart + progress file), jobs=[] orchestrates parallel work",
 		"  localstore   — ACC local credential/config storage (CCC-root localstore.json; git policy localstore.gitTrack default deny)",
-		"  container_admin — container administration (the maintenance bay): role (Skiff roles: guide/validate/apply/list) / msm (register/deregister/check/guide/catalog/ccc-config) / config (view) / autopilot (status/init/generate-bias — periodic self-wake)",
+		"  container_admin — container administration (the maintenance bay): role (Skiff roles: guide/validate/apply/list) / msm (register/deregister/check/guide/catalog/ccc-config) / config (view)",
 		"",
 		"MSM call (registered CCC MSMs, deterministic Mech & Semi-Mech):",
 		"  Execute:       msm(\"<name>\", [\"<arg1>\", \"<arg2>\"])   — run a registered MSM directly (partial name returns matching candidates)",
@@ -6781,7 +6380,6 @@ const FILE_UPLOAD_PATH = "/serenity/file-upload";
 const CONFIG_PATH = "/serenity/config";
 const CCCS_PATH = "/serenity/cccs";
 const PUBLIC_ASK_PATH = "/serenity/public-ask";
-const TRAJECTORY_PATH = "/serenity/trajectory";
 const WEIXIN_PATH = "/serenity/weixin";
 /** 图片落盘目录（CCC 根相对；S142 图片自动识别基础设施——粘贴图片落盘供 agent 经 CCC vlm MSM 自主处理） */
 const IMAGE_UPLOAD_DIR = "_tmp/images_from_user";
@@ -6879,7 +6477,7 @@ function readBody$4(req, maxBytes) {
 		req.on("error", reject);
 	});
 }
-function sendJson$3(res, code, body) {
+function sendJson$4(res, code, body) {
 	const payload = JSON.stringify(body);
 	res.writeHead(code, {
 		"content-type": "application/json; charset=utf-8",
@@ -6904,7 +6502,7 @@ function senderIsWebUi(req) {
 */
 function requireWebUi(req, res, message) {
 	if (senderIsWebUi(req)) return true;
-	sendJson$3(res, 403, { error: message });
+	sendJson$4(res, 403, { error: message });
 	return false;
 }
 /**
@@ -6937,7 +6535,7 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "GET") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -6947,12 +6545,12 @@ function registerStatusApi(ctx, opts = {}) {
 				});
 				const root = cccRootForCwd(workspace);
 				if (!root) {
-					sendJson$3(res, 200, { handymen: [] });
+					sendJson$4(res, 200, { handymen: [] });
 					return;
 				}
-				sendJson$3(res, 200, { handymen: listActiveHandymen(root) });
+				sendJson$4(res, 200, { handymen: listActiveHandymen(root) });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -6962,7 +6560,7 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "图片落盘仅限 WebUI（client 专用）")) return;
@@ -6974,12 +6572,12 @@ function registerStatusApi(ctx, opts = {}) {
 				});
 				const root = cccRootForCwd(workspace);
 				if (!root) {
-					sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+					sendJson$4(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 					return;
 				}
-				sendJson$3(res, 200, { path: saveImageToTmp(root, body.mediaType ?? "", body.data ?? "") });
+				sendJson$4(res, 200, { path: saveImageToTmp(root, body.mediaType ?? "", body.data ?? "") });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -6989,7 +6587,7 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "文件落盘仅限 WebUI（client 专用）")) return;
@@ -7001,12 +6599,12 @@ function registerStatusApi(ctx, opts = {}) {
 				});
 				const root = cccRootForCwd(workspace);
 				if (!root) {
-					sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+					sendJson$4(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 					return;
 				}
-				sendJson$3(res, 200, { path: saveFileToTmp(root, body.name ?? "", body.data ?? "") });
+				sendJson$4(res, 200, { path: saveFileToTmp(root, body.name ?? "", body.data ?? "") });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7022,7 +6620,7 @@ function registerStatusApi(ctx, opts = {}) {
 						workspace: url.searchParams.get("workspace") ?? void 0
 					}), configPaths);
 					const runtime = ctx.get("codeRuntime");
-					sendJson$3(res, 200, {
+					sendJson$4(res, 200, {
 						...status,
 						...runtime === void 0 ? { codeRuntime: null } : { codeRuntime: {
 							language: runtime.language,
@@ -7041,19 +6639,19 @@ function registerStatusApi(ctx, opts = {}) {
 					});
 					const root = cccRootForCwd(workspace);
 					if (!root) {
-						sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+						sendJson$4(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 						return;
 					}
 					const result = setSafeMode(root, body.on === true);
-					sendJson$3(res, 200, {
+					sendJson$4(res, 200, {
 						...getStatus(workspace, configPaths),
 						...result
 					});
 					return;
 				}
-				sendJson$3(res, 405, { error: "method not allowed" });
+				sendJson$4(res, 405, { error: "method not allowed" });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7069,7 +6667,7 @@ function registerStatusApi(ctx, opts = {}) {
 					try {
 						known = projectKnownWorkspaces(hostService(ctx, "workspaceRegistry")?.list?.() ?? [], settings.gateway.workspaces);
 					} catch {}
-					sendJson$3(res, 200, {
+					sendJson$4(res, 200, {
 						config: toWire(settings),
 						knownWorkspaces: known
 					});
@@ -7081,12 +6679,12 @@ function registerStatusApi(ctx, opts = {}) {
 					try {
 						ctx.emit?.("serenity/config-updated");
 					} catch {}
-					sendJson$3(res, 200, { config: toWire(saved) });
+					sendJson$4(res, 200, { config: toWire(saved) });
 					return;
 				}
-				sendJson$3(res, 405, { error: "method not allowed" });
+				sendJson$4(res, 405, { error: "method not allowed" });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7096,7 +6694,7 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "GET") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -7105,12 +6703,12 @@ function registerStatusApi(ctx, opts = {}) {
 					workspace: url.searchParams.get("workspace") ?? void 0
 				});
 				const root = cccRootForCwd(workspace) ?? "";
-				sendJson$3(res, 200, { cccs: await listCccs(ctx, {
+				sendJson$4(res, 200, { cccs: await listCccs(ctx, {
 					defaultRoot: root,
 					withRoles: true
 				}) });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7123,18 +6721,18 @@ function registerStatusApi(ctx, opts = {}) {
 				if (req.method === "PUT") {
 					const raw = await readBody$4(req, 16384);
 					if (JSON.parse(raw).action !== "rotate") {
-						sendJson$3(res, 400, { error: "unsupported action (expected \"rotate\")" });
+						sendJson$4(res, 400, { error: "unsupported action (expected \"rotate\")" });
 						return;
 					}
-					sendJson$3(res, 200, { key: rotatePublicAskKey() });
+					sendJson$4(res, 200, { key: rotatePublicAskKey() });
 					return;
 				}
 				if (req.method !== "GET") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const settings = readAdvancedSettings();
-				const { readSimpleSettings } = await import("./settings-section-DTYZjwUs.js").then((n) => n.r);
+				const { readSimpleSettings } = await import("./settings-section-DMDUoQum.js").then((n) => n.r);
 				const simple = readSimpleSettings();
 				const allowed = settings.publicAsk.allowed;
 				const port = simple.acpHttpPort ?? ACP_HTTP_PORT;
@@ -7143,7 +6741,7 @@ function registerStatusApi(ctx, opts = {}) {
 					name,
 					url: `${base}/c/${encodeURIComponent(name)}`
 				}));
-				sendJson$3(res, 200, {
+				sendJson$4(res, 200, {
 					enabled: simple.publicAskEnabled ?? false,
 					port,
 					key: ensurePublicAskKey(),
@@ -7152,67 +6750,7 @@ function registerStatusApi(ctx, opts = {}) {
 					listUrl: `${base}/`
 				});
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
-			}
-		}
-	});
-	ctx.webServer.register({
-		kind: "exact",
-		path: TRAJECTORY_PATH,
-		handler: async (req, res) => {
-			try {
-				if (req.method === "POST") {
-					if (!requireWebUi(req, res, "立即唤起仅限 WebUI（agent 不可自行唤起）")) return;
-					const raw = await readBody$4(req, 16384);
-					const body = JSON.parse(raw);
-					if (body.action !== "wake") {
-						sendJson$3(res, 400, { error: "unsupported action (expected \"wake\")" });
-						return;
-					}
-					const workspace = resolveWorkspace(ctx, {
-						sessionId: body.sessionId,
-						workspace: body.workspace
-					});
-					const root = cccRootForCwd(workspace);
-					const effectiveRoot = body.ccc?.trim() || !body.workspace && !body.sessionId ? body.ccc?.trim() ?? (await import("./autopilot-trajectory-D9Znxo75.js").then((n) => n.a)).collectAutopilotCccs(ctx)[0] ?? root : root;
-					if (!effectiveRoot) {
-						sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
-						return;
-					}
-					const { performAutopilotWake } = await import("./autopilot-trajectory-D9Znxo75.js").then((n) => n.a);
-					const { readAutopilotSettings } = await import("./autopilot-core-DCRkiWEe.js").then((n) => n.o);
-					const settings = readAutopilotSettings(effectiveRoot);
-					if (!settings) {
-						sendJson$3(res, 400, { error: "Autopilot Trajectory 未配置（.opencode/serenity.json 缺段）" });
-						return;
-					}
-					const result = await performAutopilotWake(ctx, effectiveRoot, settings, { force: true });
-					sendJson$3(res, result.ok ? 200 : 400, result);
-					return;
-				}
-				if (req.method !== "GET") {
-					sendJson$3(res, 405, { error: "method not allowed" });
-					return;
-				}
-				const url = new URL(req.url ?? "/", "http://127.0.0.1");
-				const workspace = resolveWorkspace(ctx, {
-					sessionId: url.searchParams.get("sessionId") ?? void 0,
-					workspace: url.searchParams.get("workspace") ?? void 0
-				});
-				const root = cccRootForCwd(workspace);
-				const { collectAutopilotCccs } = await import("./autopilot-trajectory-D9Znxo75.js").then((n) => n.a);
-				const effectiveRoot = url.searchParams.get("ccc")?.trim() ?? (!url.searchParams.get("workspace") && !url.searchParams.get("sessionId") ? collectAutopilotCccs(ctx)[0] : null) ?? root;
-				if (!effectiveRoot) {
-					sendJson$3(res, 200, { status: null });
-					return;
-				}
-				const { containerAutopilot, containerWakes } = await Promise.resolve().then(() => container_status_exports);
-				sendJson$3(res, 200, {
-					status: containerAutopilot(effectiveRoot),
-					wakes: containerWakes(effectiveRoot).entries
-				});
-			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7226,7 +6764,7 @@ function registerStatusApi(ctx, opts = {}) {
 				if (req.method === "GET") {
 					const chk = requireCcc(url.searchParams.get("ccc") ?? void 0);
 					if (!chk.ok) {
-						sendJson$3(res, 400, { error: chk.error });
+						sendJson$4(res, 400, { error: chk.error });
 						return;
 					}
 					const { readWeixinSettings } = await import("./weixin-route-B2ajFypI.js").then((n) => n.u);
@@ -7240,7 +6778,7 @@ function registerStatusApi(ctx, opts = {}) {
 						enabled: a.enabled !== false,
 						bound: readWeixinCredential(chk.root, a.accountId) !== null
 					}));
-					sendJson$3(res, 200, {
+					sendJson$4(res, 200, {
 						enabled: settings.enabled === true,
 						botType: settings.botType ?? void 0,
 						accounts,
@@ -7250,14 +6788,14 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const raw = await readBody$4(req, 131072);
 				const body = JSON.parse(raw);
 				const chk = requireCcc(body.ccc);
 				if (!chk.ok) {
-					sendJson$3(res, 400, { error: chk.error });
+					sendJson$4(res, 400, { error: chk.error });
 					return;
 				}
 				const root = chk.root;
@@ -7274,7 +6812,7 @@ function registerStatusApi(ctx, opts = {}) {
 						startedAt: Date.now(),
 						polling: false
 					});
-					sendJson$3(res, 200, {
+					sendJson$4(res, 200, {
 						qrcode: qr.qrcode,
 						qrcode_img_content: qr.qrcode_img_content,
 						loginKey
@@ -7283,31 +6821,31 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "remove-account") {
 					if (!body.accountId) {
-						sendJson$3(res, 400, { error: "missing accountId" });
+						sendJson$4(res, 400, { error: "missing accountId" });
 						return;
 					}
 					const { removeWeixinAccount } = await import("./weixin-route-B2ajFypI.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
-					sendJson$3(res, 200, { removed: body.accountId });
+					sendJson$4(res, 200, { removed: body.accountId });
 					return;
 				}
 				if (body.action === "save-routes") {
 					const routes = body.routes ?? [];
 					if (!Array.isArray(routes) || routes.some((r) => typeof r?.user !== "string" || typeof r?.role !== "string" || r.user === "" || r.role === "")) {
-						sendJson$3(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
+						sendJson$4(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
 						return;
 					}
 					const { saveWeixinRoutes } = await import("./weixin-route-B2ajFypI.js").then((n) => n.u);
 					const { readSkiffRoles } = await import("./skiff-role-CEHL5cek.js").then((n) => n.u);
 					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)` });
+						sendJson$4(res, 400, { error: `unknown role: ${r.role} (not in ${root} skiff.roles)` });
 						return;
 					}
 					saveWeixinRoutes(root, routes);
-					sendJson$3(res, 200, { saved: routes.length });
+					sendJson$4(res, 200, { saved: routes.length });
 					return;
 				}
 				if (body.action === "set-enabled") {
@@ -7316,7 +6854,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
-						sendJson$3(res, 400, { error: "启用前请先扫码绑定至少一个账号" });
+						sendJson$4(res, 400, { error: "启用前请先扫码绑定至少一个账号" });
 						return;
 					}
 					setWeixinEnabled(root, enabled);
@@ -7325,12 +6863,12 @@ function registerStatusApi(ctx, opts = {}) {
 						const { stopCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						stopCccBridge(root);
 					}
-					sendJson$3(res, 200, { enabled });
+					sendJson$4(res, 200, { enabled });
 					return;
 				}
-				sendJson$3(res, 400, { error: `unsupported action: ${body.action ?? ""}` });
+				sendJson$4(res, 400, { error: `unsupported action: ${body.action ?? ""}` });
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7341,18 +6879,18 @@ function registerStatusApi(ctx, opts = {}) {
 			try {
 				if (!requireWebUi(req, res, "微信桥配置仅限 WebUI（client 专用）")) return;
 				if (req.method !== "GET") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const key = new URL(req.url ?? "/", "http://127.0.0.1").searchParams.get("key") ?? "";
 				const login = weixinLogins.get(key);
 				if (!login) {
-					sendJson$3(res, 404, { error: "login not found or expired" });
+					sendJson$4(res, 404, { error: "login not found or expired" });
 					return;
 				}
 				if (Date.now() - login.startedAt > WEIXIN_LOGIN_TTL_MS) {
 					weixinLogins.delete(key);
-					sendJson$3(res, 200, { status: "expired" });
+					sendJson$4(res, 200, { status: "expired" });
 					return;
 				}
 				const { pollQRStatus } = await import("./weixin-api-CtFYm53S.js").then((n) => n.u);
@@ -7365,7 +6903,7 @@ function registerStatusApi(ctx, opts = {}) {
 				switch (status.status) {
 					case "confirmed": {
 						if (!status.bot_token) {
-							sendJson$3(res, 200, {
+							sendJson$4(res, 200, {
 								status: "error",
 								error: "confirmed but no bot_token"
 							});
@@ -7386,7 +6924,7 @@ function registerStatusApi(ctx, opts = {}) {
 						});
 						syncCccBridge(ctx, login.root);
 						weixinLogins.delete(key);
-						sendJson$3(res, 200, {
+						sendJson$4(res, 200, {
 							status: "confirmed",
 							accountId,
 							tokenSaved: true
@@ -7395,14 +6933,14 @@ function registerStatusApi(ctx, opts = {}) {
 					}
 					case "expired":
 						weixinLogins.delete(key);
-						sendJson$3(res, 200, { status: "expired" });
+						sendJson$4(res, 200, { status: "expired" });
 						return;
 					default:
-						sendJson$3(res, 200, { status: status.status ?? "wait" });
+						sendJson$4(res, 200, { status: status.status ?? "wait" });
 						return;
 				}
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7424,7 +6962,7 @@ function registerStatusApi(ctx, opts = {}) {
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
-					sendJson$3(res, 200, {
+					sendJson$4(res, 200, {
 						root,
 						olderThanDays: days,
 						dryRun: true,
@@ -7438,12 +6976,12 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				if (req.method !== "POST") {
-					sendJson$3(res, 405, { error: "method not allowed" });
+					sendJson$4(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "会话清理仅限 WebUI（client 专用）")) return;
 				const { result } = performCleanup(root, cutoffDaysAgo(days), liveIds);
-				sendJson$3(res, 200, {
+				sendJson$4(res, 200, {
 					root,
 					olderThanDays: days,
 					dryRun: false,
@@ -7451,7 +6989,7 @@ function registerStatusApi(ctx, opts = {}) {
 					errors: result.errors
 				});
 			} catch (err) {
-				sendJson$3(res, 400, { error: err.message ?? String(err) });
+				sendJson$4(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -7476,6 +7014,68 @@ function requireCcc(root) {
 	};
 }
 //#endregion
+//#region src/voyage-page.ts
+const VOYAGE_PATH = "/serenity/voyage";
+/**
+* 资产相对包根的路径。
+* 🔒 它**必须**同时出现在 `package.json` 的 `files` 白名单里——否则发布包缺文件，
+* 路由会在运行时报「资产不可用」（同 v1.26.15 那次 `files` 漏 chunk 的事故形态）。
+* `dsh-develop pack-check` 的 `required` 已把它列为发布前硬断言。
+*/
+const VOYAGE_ASSET = "assets/serenity-voyage.html";
+/** 包根 = 本模块所在目录的上一级（构建产物在 `lib/`，与 `assets/` 同级；同 constants.ts 定位法） */
+function packageRootPath() {
+	return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+/** 资产绝对路径（导出以便测试与 pack-check 共用同一判据来源） */
+function voyageAssetPath() {
+	return join(packageRootPath(), VOYAGE_ASSET);
+}
+/** 缓存（830 KB，避免每次展开卡片都读盘；进程内只读一次） */
+let cachedHtml = null;
+/** 读取资产全文。读不到即抛错（由 handler 转 500，绝不静默发空页）。 */
+function loadVoyageHtml(assetPath = voyageAssetPath()) {
+	if (assetPath === voyageAssetPath()) {
+		if (cachedHtml === null) cachedHtml = readFileSync(assetPath, "utf-8");
+		return cachedHtml;
+	}
+	return readFileSync(assetPath, "utf-8");
+}
+/** 发 JSON（错误分支用；与 api.ts 的 sendJson 同形，但本模块不依赖它，保持零耦合） */
+function sendJson$3(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json; charset=utf-8");
+	res.end(JSON.stringify(body));
+}
+/**
+* 注册 `/serenity/voyage`（GET）。
+* @param opts.assetPath 覆盖资产路径（测试用；生产不传）
+*/
+function registerVoyageApi(ctx, opts = {}) {
+	ctx.webServer.register({
+		kind: "exact",
+		path: VOYAGE_PATH,
+		handler: (req, res) => {
+			if (req.method !== "GET") {
+				sendJson$3(res, 405, { error: "method not allowed" });
+				return;
+			}
+			let html;
+			try {
+				html = loadVoyageHtml(opts.assetPath ?? voyageAssetPath());
+			} catch (err) {
+				sendJson$3(res, 500, { error: `voyage asset unavailable: ${err?.message ?? String(err)}` });
+				return;
+			}
+			res.statusCode = 200;
+			res.setHeader("content-type", "text/html; charset=utf-8");
+			res.setHeader("cache-control", "private, max-age=86400");
+			res.setHeader("content-length", String(Buffer.byteLength(html)));
+			res.end(html);
+		}
+	});
+}
+//#endregion
 //#region src/seams/env.ts
 /** 纯解析：给定 cwd，返回可注入的 DSH_SERENITY_* 事实（非 CCC 返回空） */
 function resolveSerenityEnv(cwd) {
@@ -12503,6 +12103,244 @@ qInput.focus()
 </html>`;
 }
 //#endregion
+//#region src/host/effect.ts
+/** 已告警的标签（进程级去重：重复装配/多测试替身不刷屏，但绝不静默） */
+const warnedLabels = /* @__PURE__ */ new Set();
+/**
+* 登记一个卸载时执行的清理。
+* @param ctx 宿主插件上下文
+* @param label 日志标签（定位是哪个资源未装配）
+* @param cleanup 卸载时执行；抛错被吞掉（不阻断其它清理）
+* @returns 是否成功装配（false = 宿主无 `ctx.effect`，已告警）
+*/
+function registerDisposer(ctx, label, cleanup) {
+	const effect = ctx?.effect;
+	if (typeof effect !== "function") {
+		if (!warnedLabels.has(label)) {
+			warnedLabels.add(label);
+			console.warn(`[serenity-hooks] ✗ 资源拆卸未装配（${label}）：ctx.effect 不可用（宿主契约缺失）`);
+		}
+		return false;
+	}
+	try {
+		effect.call(ctx, () => () => {
+			try {
+				cleanup();
+			} catch (err) {
+				console.warn(`[serenity-hooks] ✗ 资源清理失败（${label}）: ${String(err?.message ?? err)}`);
+			}
+		}, `dsh-serenity-hooks: ${label}`);
+		return true;
+	} catch (err) {
+		console.warn(`[serenity-hooks] ✗ 资源拆卸注册失败（${label}）: ${String(err?.message ?? err)}`);
+		return false;
+	}
+}
+//#endregion
+//#region src/clock-runtime.ts
+/**
+* clock-runtime.ts — **时钟运行时工厂**（S142 §38 复审候选 C6b，路径 **P2**）
+*
+* 本仓有**两条各自独立运行**的 5min 时钟：
+*   · 唤醒调度器（`wake-scheduler.ts`，一次性唤醒，D58）
+*   · autopilot 时钟（`autopilot-trajectory.ts`，周期自唤醒，D59）
+* 二者的**业务判据完全不同**（谁来扫 / 扫什么 / 投递给谁 / 按什么周期），但**引擎骨架逐字同形**
+* ——进程态 + 快照 + 复位 + `startTimer` + tick 外壳 + 事件接线 + disposer + `timer.unref()`。
+* 本条把**引擎**抽到本工厂，**各钟仍各持自己的定时器与自己的串行链**。
+*
+* ───────────────────────────────────────────────────────────────────────────
+* 🔴 硬约束一：**两条时钟绝不可共用"排队执行"的链**（这是 P2 与 P1 的分界判据）
+*
+* autopilot 每轮要跑该 CCC 的**偏见脚本**（`fetchBiasContent`，超时 60s），可能阻塞数十秒；
+* 若与唤醒调度器共用一条串行链，会把另一条一起**卡住**（一次性唤醒被无关的偏见脚本拖住）。
+* ⇒ 本工厂把 `chain` 作为**每实例私有状态**：`createClock()` 调用一次 = 一条独立的串行域。
+*    实例之间**零共享**（无模块级单例、无共享 Promise、无共享 map）。
+* ⚠️ 若日后有人把 `chain` 提到模块级"省一次分配"，**两条时钟的隔离即刻失效**——不许。
+*
+* 🔴 硬约束二：**武装门只判全局闸**（`gate()`），**不判"本次有无目标"**
+*
+* 2026-09-14 F 段实测缺陷：旧实现把"有 live CCC"当**武装前置条件**，而宿主刚重启时 live 会话
+* 必为空，且**"恢复旧会话"不触发 `session/created`**（只有新建会）⇒ 启动瞬间判定落空 =
+* **时钟永久不武装**（实测 6.6h 零 tick）。⇒ 现在「**全局闸开即武装**」，"有无目标"降级为
+* tick 内的廉价判定。**武装与"本次有无目标"是两件事，本工厂不得把二者耦合。**
+*
+* 🔴 硬约束三：**两条闸必须继续分开传**（v1.34 S-1 解耦）
+*
+* 唤醒调度器 `wakeSchedulerEnabled`（**缺省开**）｜autopilot `autopilotWakeEnabled`
+* （**缺省关**）——取值方向相反。工厂取 `gate` **回调**（每次现读），**不做**任何合并或缓存。
+*
+* ───────────────────────────────────────────────────────────────────────────
+* 两条时钟**逐项语义差**（`ClockOptions` 的每个可配项都对应下表一行，不是随意的灵活性）：
+*
+* | 项 | 唤醒调度器 | autopilot | 工厂表达 |
+* |----|-----------|-----------|---------|
+* | `chain` | 有（全局串行） | 有（全局串行） | **总是私有**（硬约束一） |
+* | `lastTickLog` | 有（逐行摘要） | **无** | `logFrom` 不给 = 不记 |
+* | `ticks` 记账 | 工厂在 body **完成后**记 | **本钟**在同步段记 | `bodyCountsTick` + `begin` |
+* | body 返回类型 | `string[]`（人读摘要） | `void` | 泛型 `T` |
+* | 启动日志 | 固定串 | 含启用 CCC 计数 | `startLog: () => string` |
+* | body 异常兜底 | 留痕 + `console.warn` | 同 | 工厂统一（**吞异常不改语义**） |
+*
+* ───────────────────────────────────────────────────────────────────────────
+* **本工厂是"加法式"重构**（P2 的性质）：不新增任何判定逻辑，只把同形骨架收成一份代码；
+* 两个模块仍各自导出 `wakeSchedulerState()` / `autopilotClockState()` 与各自的
+* `__reset…ForTest()`，**对外可观测面（字段名与语义）零变化**——`acc-diag` ①b 段、
+* `container-status.ts:containerClocks()` 与面板都在读它们（见该文件 :225–250 的设计红线）。
+*
+* 为什么**不**取 P1（真合并成一个 `setInterval` + 两条策略）——2026-09-15 所有者裁决：
+* P1 只多省 ~20 行，却要把 `armed` 拆成"宿主 + 每策略"两层、并强行分开串行域，
+* 即**动两条正在跑的时钟的骨架**；**不值当**（裁决原文见 SESSION §12.8②）。
+*/
+/**
+* tick 周期（**5 分钟**）。
+*
+* 2026-09-15 S142「ACC 侧 autopilot 退场」：本值原从 `autopilot-core.ts` 导入（`TICK_MS`），
+* 但该模块随 autopilot 退场，而**本模块的唯一消费者是唤醒调度器**（`wake-scheduler`）——
+* 值本身与 autopilot 无关 ⇒ 随消费者归位到本模块（不再依赖 autopilot 判据层）。
+*
+* ⚠️ 语义不得变：该值同时是**报告文案的来源**（"等下个 Nmin tick"），历史上曾因文案写死
+* 10min 与实现 5min 不符而误导排查（§12.7 文案纠错）。
+*/
+const TICK_MS = 3e5;
+/**
+* 挂事件 → 触发 `start()`（**每个事件一次 try/catch 吞异常**：事件通道缺失不阻断时钟）。
+*
+* 为什么吞异常：宿主（headless profile 等）可能没有事件通道；**启动时已 `start()` 过一次**，
+* 事件只是"跟上面板开关 / 新会话"的热启动补丁，缺它不该让整个装配抛错。
+* @param on 宿主的 `on`（可能不存在）
+* @param ctx `on` 的 `this`（宿主 API 常要求绑定）
+* @param clock 目标时钟
+* @param events 事件名列表（回调恒为 `() => clock.start()`）
+*/
+function attachClockEvents(ctx, clock, events) {
+	const on = ctx?.on;
+	if (typeof on !== "function") return;
+	for (const name of events) try {
+		on.call(ctx, name, () => clock.start());
+	} catch {}
+}
+/**
+* 建一条时钟（**每钟各调一次**——本工厂**不是**单例，调用次数 = 时钟条数）。
+*
+* 顺序忠实于既有实现：`start()` 先武装并立即跑一次 tick → 再挂事件。
+* 拆卸由调用方经 `registerDisposer(ctx, label, clock.dispose)` 落到宿主的 `ctx.effect`。
+* @param opts 见 {@link ClockOptions}（每项对应一条既有的语义差）
+* @returns 该钟的 `{start, dispose, snapshot, reset}`
+*/
+function createClock(opts) {
+	const runtime = {
+		armed: false,
+		armedAt: null,
+		lastTickAt: null,
+		ticks: 0,
+		lastSkipReason: null
+	};
+	if (opts.logFrom) runtime.lastTickLog = [];
+	const st = {
+		timer: null,
+		chain: Promise.resolve(),
+		runtime,
+		wired: false,
+		opts
+	};
+	/** 记一次 tick（工厂内部与 body 共用同一实现——只有一处会计逻辑） */
+	const countTick = () => {
+		runtime.lastTickAt = Date.now();
+		runtime.ticks += 1;
+	};
+	/** 逐行打印（`logFrom` 缺省 ⇒ 本钟无 tick 日志，整段为死代码路径） */
+	const emit = (lines) => {
+		if (!opts.logFrom) return;
+		for (const line of lines) console.log(`${opts.logFrom.prefix}${line}`);
+	};
+	const tick = () => {
+		if (!opts.gate()) {
+			runtime.lastSkipReason = opts.gateOffReason;
+			return;
+		}
+		if (opts.begin) try {
+			opts.begin();
+		} catch (err) {
+			console.warn(`[serenity-hooks] ✗ tick 前置异常: ${String(err?.message ?? err)}（${opts.label}）`);
+			return;
+		}
+		st.chain = st.chain.then(async () => {
+			try {
+				const value = await opts.body();
+				if (!opts.bodyCountsTick) countTick();
+				if (opts.logFrom) {
+					runtime.lastTickLog = opts.logFrom.lines(value);
+					emit(runtime.lastTickLog);
+				}
+			} catch (err) {
+				const msg = `✗ tick 异常: ${String(err?.message ?? err)}`;
+				if (opts.logFrom) runtime.lastTickLog = [msg];
+				console.warn(`[serenity-hooks] ${msg}（${opts.label}）`);
+			}
+		});
+	};
+	/**
+	* 幂等启动 + 武装门：**已武装 → 原样返回**（防重复起定时器）；
+	* **闸关 → 不武装**（零资源占用）；闸开则**无条件**武装（硬约束二：不判"有无目标"）。
+	*/
+	const start = () => {
+		if (st.timer) return;
+		if (opts.events && !st.wired) {
+			st.wired = true;
+			attachClockEvents(opts.ctx, api, opts.events);
+		}
+		if (!opts.gate()) return;
+		st.timer = setInterval(tick, TICK_MS);
+		st.timer.unref();
+		runtime.armed = true;
+		runtime.armedAt = Date.now();
+		console.log(opts.startLog());
+		if (opts.immediate !== false) tick();
+	};
+	const dispose = () => {
+		if (st.timer) {
+			clearInterval(st.timer);
+			st.timer = null;
+		}
+		runtime.armed = false;
+		runtime.armedAt = null;
+		opts.onDispose?.();
+	};
+	const api = {
+		start,
+		dispose,
+		snapshot: () => ({
+			enabled: opts.gate(),
+			...runtime,
+			...runtime.lastTickLog ? { lastTickLog: [...runtime.lastTickLog] } : {}
+		}),
+		noteSkipReason: (reason) => {
+			runtime.lastSkipReason = reason;
+		},
+		countTick,
+		enqueue: (work) => {
+			st.chain = st.chain.then(work, () => void 0).then(() => void 0, (err) => {
+				console.warn(`[serenity-hooks] ✗ 串行任务异常（${opts.label}）: ${String(err?.message ?? err)}`);
+			});
+		},
+		reset: () => {
+			if (st.timer) {
+				clearInterval(st.timer);
+				st.timer = null;
+			}
+			runtime.armed = false;
+			runtime.armedAt = null;
+			runtime.lastTickAt = null;
+			runtime.ticks = 0;
+			runtime.lastSkipReason = null;
+			if (opts.logFrom) runtime.lastTickLog = [];
+			st.wired = false;
+			opts.onReset?.();
+		}
+	};
+	return api;
+}
+//#endregion
 //#region src/wake-scheduler.ts
 const PLUGIN_SOURCE$1 = {
 	kind: "plugin",
@@ -12665,8 +12503,8 @@ async function deliverWake(ctx, root, entry) {
 * （工作区注册表 ∪ 持久化会话 ∪ live 会话）：**没有 live 会话的 CCC 也会被扫到**。
 *
 * ⚠️ 边界（本步**只**改"枚举哪些 CCC"，**不改**"怎么找到要交付的 agent"）：
-* 把 message 交给某条 trajectory 仍必须靠 **live 会话**解析（见
-* `autopilot-trajectory.resolveTargetAgent`）；无 live 会话时该 CCC 只是**被扫到、
+* 把 message 交给某条 trajectory 仍必须靠 **live 会话**解析（见本文件
+* `acquireWakeAgent`）；无 live 会话时该 CCC 只是**被扫到、
 * 无交付对象** ⇒ `deliverWake` 返回 `无绑定会话记录…`，条目回 `pending` 并留痕。
 * 因此本函数**不得**让 tick 抛错（异常一律由调用方 tick 兜住，见 `runWakeTick` 的 try）。
 * @param ctx 插件上下文
@@ -14566,6 +14404,56 @@ function createImBridgeTool() {
 	});
 }
 //#endregion
+//#region src/live-sessions.ts
+/**
+* 从 dsh 会话 log 读取标题（latest-wins `session/title` 事件）——
+* **标题不在 `sessions.list()` 条目上**（wire/对象均无 title 字段；F3 命名经
+* `sessionTitle.rename` 写进 session log），必须从 events 提取（rebuild 同款读取模式）。
+*/
+function readSessionTitle(session) {
+	try {
+		const events = sessionEvents$1(session);
+		for (let i = events.length - 1; i >= 0; i--) {
+			const e = events[i];
+			if (e?.type === "session/title" && typeof e.data?.title === "string" && e.data.title.trim() !== "") return e.data.title.trim();
+		}
+	} catch {}
+	return null;
+}
+/**
+* 逐条 live 会话（`cccRoot` = 该会话 cwd 的 CCC 归属，无 → null）。
+*
+* CCC 枚举（"本机有哪些 CCC"）**不在这里**，归 `ccc-roots.listCccs`（并集语义）；
+* 本函数保留的是它**独有**的那部分：会话维度 + cwd 归属 + 标题 + id。
+*
+* @param ctx 插件上下文
+* @returns 逐条 live 会话
+*/
+function listLiveSessions(ctx) {
+	const out = [];
+	try {
+		const sessions = hostSessions(ctx);
+		for (const s of sessions?.list?.() ?? []) {
+			const cwd = s?.header?.cwd ?? null;
+			out.push({
+				id: s?.id ?? "",
+				cwd,
+				cccRoot: cwd ? cccRootForCwd(cwd) : null,
+				title: readSessionTitle(s)
+			});
+		}
+	} catch {}
+	return out;
+}
+function diagLive(ctx) {
+	const processCwd = process.cwd();
+	return {
+		processCwd,
+		processCcc: cccRootForCwd(processCwd),
+		liveSessions: listLiveSessions(ctx)
+	};
+}
+//#endregion
 //#region src/container-status.ts
 /**
 * container-status.ts — 容器状态模型的**取数层唯一出口**（C5「观察面归一」，S142 2026-09-15）
@@ -14584,20 +14472,19 @@ function createImBridgeTool() {
 *    其模块级运行时对象里，任何"重新推导"得到的都是与真实调度器不一致的假值。
 *
 * 依赖分层（为什么本模块"重"而 `kit-ops` / `status` 保持"轻"）：
-*  {@link containerClocks} 必须读 `wake-scheduler` / `autopilot-trajectory` 的进程内快照，而这两个
-*  模块带 **@deepseek-ai 值依赖**（`dsh-llm` 的 `createUserMessage`）。故本模块**只能**被本就重型或
-*  异步的消费方使用：`diag-ops`（静态 import）、`api.ts` / `kit-ops`（`await import(...)`，与
-*  `api.ts` 既有的"保持静态链纯净"约定一致）。**轻链模块不得静态 import 本模块**。
+*  {@link containerClocks} 必须读 `wake-scheduler` 的进程内快照，而该模块带 **@deepseek-ai 值依赖**
+*  （`dsh-llm` 的 `createUserMessage`）。故本模块**只能**被本就重型或异步的消费方使用：
+*  `diag-ops`（静态 import）、`api.ts` / `kit-ops`（`await import(...)`，与 `api.ts` 既有的
+*  "保持静态链纯净"约定一致）。**轻链模块不得静态 import 本模块**。
 *
 * 已有的单一真相源继续指向原处（**不复制**）：
 *  L0 根解析 `ccc.ts findSerenityRoot`｜L1/L2 根与枚举 `ccc-roots.ts`｜宿主契约 `host/contract.ts`
-*  ｜CCC 配置 `ccc.ts loadSerenityConfig`｜注册表 `msm-ops.ts`｜时钟 `wake-scheduler.ts` /
-*  `autopilot-trajectory.ts`｜唤醒注册表 `wake-registry.ts`。
+*  ｜CCC 配置 `ccc.ts loadSerenityConfig`｜注册表 `msm-ops.ts`｜时钟 `wake-scheduler.ts`
+*  ｜唤醒注册表 `wake-registry.ts`。
 */
 var container_status_exports = /* @__PURE__ */ __exportAll({
 	checkRegistryHealth: () => checkRegistryHealth,
 	checkRegistryQuality: () => checkRegistryQuality,
-	containerAutopilot: () => containerAutopilot,
 	containerClocks: () => containerClocks,
 	containerIdentity: () => containerIdentity,
 	containerPrinciples: () => containerPrinciples,
@@ -14732,18 +14619,14 @@ function checkRegistryHealth(root) {
 	};
 }
 /**
-* 两条时钟的进程内状态（"为什么这轮没被唤起"的第一手判据）。
+* 时钟的进程内状态（"为什么这轮没被唤起"的第一手判据）。
 *
 * 🔴 **只读快照，不重算**（设计红线）：`armed`/`ticks`/`lastTickAt`/`lastSkipReason` 只存在于
-* 调度器自己的模块级运行时对象里（`wake-scheduler.ts schedulerRuntime` /
-* `autopilot-trajectory.ts` 同规格对象）。任何"从配置或文件重新推导"得到的值都会与真实
-* 调度器的状态不一致——那比没有可观测量更糟（会给出假的"一切正常"）。
+* 调度器自己的模块级运行时对象里（`wake-scheduler.ts schedulerRuntime`）。任何"从配置或文件
+* 重新推导"得到的值都会与真实调度器的状态不一致——那比没有可观测量更糟（会给出假的"一切正常"）。
 */
 function containerClocks() {
-	return {
-		wake: wakeSchedulerState(),
-		autopilot: autopilotClockState()
-	};
+	return { wake: wakeSchedulerState() };
 }
 /** 唤醒注册表取数（文件 IO：每个渲染点自己决定是否要看它） */
 function containerWakes(root) {
@@ -14754,16 +14637,13 @@ function containerWakes(root) {
 		pending: entries.filter((e) => e.state === "pending").length
 	};
 }
-/** @returns CCC 根缺失（null）→ null */
-function containerAutopilot(root) {
-	return root ? getAutopilotStatus(root) : null;
-}
 /**
 * 核心段组装（`dashboard health` 的取数：身份 + 三原则 + 注册表两判据 + 配置 + 宿主契约）。
 *
-* 时间轴三段（时钟/唤醒注册表/autopilot 目标）**不在本组装内**：它们是各自独立消费方的需要
-* （`acc-diag` / `/serenity/trajectory`），硬塞进来会让只想看三原则的调用方付无谓的 IO。
-* 需要时按名字调 {@link containerClocks} / {@link containerWakes} / {@link containerAutopilot}。
+* 时间轴两段（时钟/唤醒注册表）**不在本组装内**：它们是各自独立消费方的需要
+* （`acc-diag` / 开发面诊断），硬塞进来会让只想看三原则的调用方付无谓的 IO。
+* 需要时按名字调 {@link containerClocks} / {@link containerWakes}。
+* （原第三段「autopilot 目标」及其取数函数 `containerAutopilot` 已随 ACC 侧 autopilot 退场删除。）
 */
 function containerStatus(opts = {}) {
 	const root = opts.root ?? null;
@@ -14788,7 +14668,7 @@ function containerStatus(opts = {}) {
 //#endregion
 //#region src/diag-ops.ts
 /**
-* diag-ops.ts — `acc-diag` 报告装配（v1.33，S142 §32.11）
+* diag-ops.ts — `acc-diag` 报告装配（v1.33，S142 §32.11；2026-09-15 段数收缩）
 *
 * 为什么单独成模块（R↓）：工具面（`tools/acc-diag.ts`）只做"取 CCC 根 + 渲染"，
 * 装配逻辑放这里 ⇒ 纯函数可单测、不依赖 DSH 工具注册。
@@ -14796,22 +14676,28 @@ function containerStatus(opts = {}) {
 * 为什么**无动作参数**：诊断是低频动作（§32.9 收敛取向），一次调用即出全报告，
 * 不需要子命令面；动作越多，模型选择成本越高。
 *
-* 四段内容（数据来源各自单一真相源，本模块只聚合不复制语义）：
-*   ① live 运行态 —— 插件进程内 `diagLive(ctx)`（live 会话清单 + 各 autopilot CCC 的
-*      目标命中 / agent 定位诊断）——**独立进程看不到运行时**，这正是本工具存在的理由
-*   ② 面板解析 —— `diagLive.panelResolved`（无参面板请求会落到哪个 CCC）
-*   ③ 唤醒注册表 —— `wake-registry.json` 全量条目（state / at / target / lastResult）+ 补跑窗口
-*   ④ 唤起条件链 —— **进程内** {@link buildWakeChain}（⑥ C6a）：逐条件值 + 阻断点 + 修复建议
-*      + 只有进程内能看到的三项事实（全局闸 / live 会话 / agent 可解析性）
-*
-* C5「观察面归一」（2026-09-15）：①/② 仍走 `diagLive`（那是**live 运行态**的独有取数，
-* 没有第二个来源），但 ①b 时钟与 ③ 注册表改经 `container-status.ts` 取（唯一取数出口）——
-* **投影仍在本文件**（诊断段不含 `message`，面板含；这是渲染差异，不是取数差异）。
-*
-* ⑥ C6a（2026-09-15）：④ 段由"spawn 包内脚本"改为**进程内计算**。旧实现是本报告里
-* 唯一一条**跨进程**取数：脚本看不到全局闸/live/agent ⇒ 与本工具 ① 段自相矛盾
-* （① 说"agent 未定位"，④ 却印"条件全部满足"）。现在 ④ 段与 ① 段读**同一份事实**
-* （`autopilotRuntimeFacts`），且条件链**只有一份实现**（开发面 `dsh-develop diag` import 同一个）。
+* 三段内容（数据来源各自单一真相源，本模块只聚合不复制语义）：
+*   ①  live 运行态 —— 插件进程内 `diagLive(ctx)`（进程 cwd/CCC + live 会话清单）
+*       ——**独立进程看不到运行时**，这正是本工具存在的理由
+*   ①b 唤醒时钟 —— `containerClocks().wake`（唤醒调度器进程内快照：武装态/计数/上次跳过原因）
+*   ③  唤醒注册表 —— `wake-registry.json` 全量条目（state / at / target / lastResult）+ 补跑窗口
+*
+* ── 2026-09-15：段数由四降为三（S142「ACC 侧 autopilot 退场」§1 二阶裁定）─────────────
+* ACC 侧 autopilot 整段退场后，报告里两段的**主语消失**，故删除（不是"暂时关掉"）：
+*   · 原 ② 面板解析 —— `diagLive.panelResolved` 的来源是"哪个 CCC 配了 autopilot"，
+*     面板区块同批删除 ⇒ 主语不存在。
+*   · 原 ④ 唤起条件链 —— 整段都是 ACC autopilot 的唤起条件（`buildWakeChain` +
+*     `autopilotRuntimeFacts`），实现模块已删 ⇒ 不留第二份条件链、也不留半死的手写版。
+*   · 原 ① 段的 autopilot CCC 渲染（逐 CCC 目标命中 / agent 定位）同批删除。
+*
+* 🔴 **已知缺口（登记，不静默丢弃）**：④「为什么这轮没唤起」的诊断在 **CCC 自管理链**上归零。
+* 新链的失败形态是"S151 漏了自排下一轮"或"调度器闸关/未 tick"，而删掉 ④ 后这两种病因都不可见。
+* 按所有者裁决本次**不补**（一句话可补，代价 = 一条新条件链：调度器 armed / 闸 / tick 在跑 /
+* 条目到期 / 补跑窗口 / 目标可解析 / CCC 闸）。**不得**以"顺手保留 ④"的方式把它偷偷带回。
+*
+* C5「观察面归一」（2026-09-15）：① 走 `diagLive`（那是**live 运行态**的独有取数，没有第二个
+* 来源）；①b 时钟与 ③ 注册表经 `container-status.ts` 取（唯一取数出口）——**投影仍在本文件**
+* （诊断段不含 `message`，面板含；这是渲染差异，不是取数差异）。
 */
 /** 人读渲染一行时钟状态（"为何没有 tick" 的第一手判据） */
 function renderClock(label, s) {
@@ -14829,21 +14715,17 @@ function renderClock(label, s) {
 /**
 * 装配报告（一次调用即全报告）。
 * @param ctx 插件上下文（进程内读 sessions/agents）
-* @param root 调用方 CCC 根（条件链诊断目标）
+* @param root 调用方 CCC 根（唤醒注册表取数目标）
 * @returns 结构化报告（渲染由 {@link renderAccDiag} 负责）
 */
 async function runAccDiag(ctx, root) {
 	const live = diagLive(ctx);
 	const clocks = containerClocks();
 	const wakes = containerWakes(root);
-	const chain = await buildWakeChain(root, autopilotRuntimeFacts(ctx, root));
 	return {
 		ccc: root,
 		live,
-		clocks: {
-			wake: clocks.wake,
-			autopilot: clocks.autopilot
-		},
+		clocks: { wake: clocks.wake },
 		wakes: {
 			error: wakes.error,
 			entries: wakes.entries.map((e) => ({
@@ -14856,12 +14738,10 @@ async function runAccDiag(ctx, root) {
 				lastResult: e.lastResult ?? null
 			})),
 			pending: wakes.pending
-		},
-		autopilotChain: renderWakeChain(chain),
-		autopilotVerdict: chain.verdict
+		}
 	};
 }
-/** 人读渲染（四段；空段也要显式说明"无"，避免"沉默 = 一切正常"的误读） */
+/** 人读渲染（三段；空段也要显式说明"无"，避免"沉默 = 一切正常"的误读） */
 function renderAccDiag(r) {
 	const lines = [];
 	lines.push(`═══ ACC 运行态诊断（acc-diag）═══`);
@@ -14872,20 +14752,8 @@ function renderAccDiag(r) {
 	lines.push(`进程 CCC: ${r.live.processCcc ?? "（无——进程 cwd 不在任何 CCC 内）"}`);
 	lines.push(`live 会话: ${r.live.liveSessions.length} 个`);
 	for (const s of r.live.liveSessions) lines.push(`  · ${s.id}${s.title ? `「${s.title}」` : ""} — ccc=${s.cccRoot ?? "(非 CCC)"} cwd=${s.cwd ?? "(无)"}`);
-	if (r.live.autopilotCccs.length === 0) lines.push("autopilot CCC: 无（没有 live 会话配置了 trajectory.autopilot）");
-	else {
-		lines.push(`autopilot CCC: ${r.live.autopilotCccs.length} 个`);
-		for (const c of r.live.autopilotCccs) {
-			lines.push(`  · ${c.root} enabled=${c.enabled} session=${c.session ?? "(未配置)"} 目标=${c.target?.dirName ?? "(未命中)"} wakeable=${c.target?.wakeable ?? false} agent=${c.agentResolved ? "已定位" : "未定位"}`);
-			if (c.agentDiagnosis) lines.push(`      诊断: ${c.agentDiagnosis}`);
-		}
-	}
 	lines.push("");
 	lines.push(renderClock("唤醒调度器（wake-registry tick）", r.clocks.wake));
-	lines.push(renderClock("autopilot 时钟（周期自唤醒 tick）", r.clocks.autopilot));
-	lines.push("");
-	lines.push(`── ② 面板解析（无参 /serenity/trajectory 落到哪个 CCC）──`);
-	lines.push(r.live.panelResolved ?? "（解析不到——本进程无 live+enabled 的 autopilot CCC）");
 	lines.push("");
 	lines.push(`── ③ 唤醒注册表（${r.ccc}/AGENT_SESSIONS/wake-registry.json）──`);
 	if (r.wakes.error) lines.push(`⚠ 注册表读取问题: ${r.wakes.error}`);
@@ -14895,9 +14763,6 @@ function renderAccDiag(r) {
 		lines.push(`  · ${w.id} [${w.state}] at=${w.at} → ${w.target} by=${w.createdBy} attempts=${w.attempts}`);
 		if (w.lastResult) lines.push(`      lastResult: ${w.lastResult}`);
 	}
-	lines.push("");
-	lines.push(`── ④ 唤起条件链（"为什么这轮没被唤起"）──`);
-	lines.push(r.autopilotChain);
 	return lines.join("\n");
 }
 //#endregion
@@ -14920,12 +14785,15 @@ function renderAccDiag(r) {
 */
 /**
 * 运行态诊断工具（`acc-diag`）。**无动作参数**：一次调用即全报告
-* （live 运行态 / 面板解析 / 唤醒注册表 / 唤起条件链）。
+* （① live 运行态 / ①b 唤醒时钟 / ③ 唤醒注册表）。
+*
+* ⚠️ 2026-09-15（ACC 侧 autopilot 退场，S142）：原四段降为三段——原 ②「面板解析」与
+* ④「唤起条件链」的主语随机制消失，已删（见 `../diag-ops.ts` 文件头；④ 的缺口已登记）。
 */
 function createAccDiagTool(ctx) {
 	return defineTool({
 		name: "acc-diag",
-		description: "ACC runtime diagnosis (ACC maintainers only — hidden unless this container declares \"acc-diag\" in .opencode/serenity.json exclusiveTools). One call returns the full report: (1) live runtime — live sessions with cwd/CCC + each autopilot CCC target resolution and agent-location diagnosis; (2) panel resolution — which CCC a parameterless panel request lands on; (3) wake registry — entries with state/at/target/lastResult plus the catch-up window; (4) wake condition chain — per-condition values, blocking points and fix suggestions (\"why did this round not wake\"). Read-only: it inspects process state and files, it changes nothing.",
+		description: "ACC runtime diagnosis (ACC maintainers only — hidden unless this container declares \"acc-diag\" in .opencode/serenity.json exclusiveTools). One call returns the full report (3 sections): (1) live runtime — live sessions with cwd/CCC; (1b) wake clock — the wake scheduler process snapshot (armed / gate / ticks / last tick / last skip reason); (3) wake registry — entries with state/at/target/lastResult plus the catch-up window. Read-only: it inspects process state and files, it changes nothing.",
 		parameters: {},
 		output: {
 			schema: { type: "json" },
@@ -15032,7 +14900,10 @@ function apply(ctx, config) {
 		configPaths: config.serenityConfigPaths,
 		entrySkillMaxChars: config.entrySkillMaxChars
 	});
-	if (config.api) registerStatusApi(ctx, { configPaths: config.serenityConfigPaths });
+	if (config.api) {
+		registerStatusApi(ctx, { configPaths: config.serenityConfigPaths });
+		registerVoyageApi(ctx);
+	}
 	registerSettingsSection(ctx, config);
 	registerGateway(ctx);
 	registerRebuildTurnHook(ctx);
@@ -15042,7 +14913,6 @@ function apply(ctx, config) {
 	registerBootstrap(ctx);
 	registerSkiff(ctx);
 	registerAcp(ctx);
-	registerAutopilot(ctx);
 	registerWakeScheduler(ctx);
 	registerWeixinBridge(ctx);
 	registerWeixinSendApi(ctx);