@shgroup/dsh-serenity-hooks 1.56.10 → 1.57.1

package/lib/index.js

@@ -1,12 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as hostSessions, c as hostWeb, i as hostService, l as hostWebServer, n as hostInjected, o as hostSettings, r as hostLlm, s as hostSubagents, t as hostAgents } from "./access-CNccNtgf.js";
-import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readHandymanConfig, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-DXky9UZu.js";
-import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-CDW2dO0n.js";
-import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-CQNfQaTx.js";
-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-CxCciqQl.js";
-import { a as unregisterSkiffSession$1, i as skiffSessionSnapshot$1, n as skiffRoleFor$1, o as ACC_VERSION, r as skiffSessionInfo$1, t as registerSkiffSession$1 } from "./skiff-registry-BjIX_KD1.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-Det66X16.js";
-import { a as ACP_HTTP_PORT, c as MAIN_WEB_PORT, d as WEIXIN_SEND_PORT, l as MECHANISM_PORTS, n as readSimpleSettings, o as FACE_PORTS, r as registerSettingsSection, s as GATEWAY_PORT, u as SKIFF_DEBUG_PORT } from "./settings-section-xHABl8nk.js";
+import { c as hostInjected, d as hostSessions, f as hostSettings, h as hostWebServer, i as cccRootForExec, l as hostLlm, m as hostWeb, n as agentCwdFor, o as listCccs, p as hostSubagents, r as cccRootForCwd, s as hostAgents, t as NO_CCC_FROM_AGENT_CWD, u as hostService } from "./ccc-roots-GIJ3A_tw.js";
+import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readCheapWorkerConfig, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readExclusiveTools, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-B0ZGL9lx.js";
+import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-B4P3Uw6D.js";
+import { a as 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-B9gU1YXz.js";
+import { a as GATEWAY_PORT, c as SKIFF_DEBUG_PORT, d as skiffRoleFor$1, f as skiffSessionInfo$1, i as FACE_PORTS, l as WEIXIN_SEND_PORT, m as ACC_VERSION, n as readSimpleSettings, o as MAIN_WEB_PORT, p as unregisterSkiffSession$1, r as registerSettingsSection, s as MECHANISM_PORTS, u as registerSkiffSession$1 } from "./settings-section-DQIVsTqE.js";
+import { a as readSkiffRoles, c as roleMsmWhitelist, d as systemPromptSource, f as trajectorySubset, i as isSkiffSessionId, l as roleToolWhitelist, n as buildSkiffBasePrompt, o as resolveRoleSystemPrompt, r as createRolePromptReader, s as resolveSkiffKind } from "./skiff-role-B615L9MV.js";
 import { REGISTERED_TOOLS } from "./invariant.js";
 import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-BrRcPiQs.js";
 import { createRequire } from "node:module";
@@ -1083,14 +1081,15 @@ Directory of ACC capabilities — each area lists where to go for details (guide
                           与 praxis ontology 的分工 = 那个是**方法文本**、这个是**能跑的那个**）
   ③ 工具与执行        → container_fs（容器文件系统 15 子命令）/ container_git（git）/ dashboard（health 含注册表检查/time/wait）
                          acc_msm 已并入 msm（执行+发现）与 container_admin（管理）——msm("<name>", ["<args>"])；inspect=true 查用法
-                         handyman（杂工 agent 编排——guide 子命令：handyman guide）
+                         cheap-worker（杂工 agent 编排——guide 子命令：cheap-worker guide）
                          专属工具（**默认对所有 CCC 隐藏**，只有在自己 exclusiveTools 里点名的 CCC 可见）→ acc-diag（运行态诊断）
   ④ 角色与对外面      → container_admin role（Skiff 认知子集角色：guide/validate/apply/list——skiff_admin 已并入）
-                         ACP（程序化 JSON-RPC 3100）/ Skiff 问答页（公网 ask）——面板「外部能力」组
+                         3099 Skiff 调试问答页（人工调试面）。🔴 2026-10-15：自造 ACP 面已退役
+                         ⇒ 外部程序化接入改走官方 dsh --profile acp ＋ 现成 ACP 客户端
   ⑤ 自主与接入        → container_trajectory send-now（跨轨迹的**即时**递送，**不排队**：live 目标在跑就当场注入当前轮、空闲则立即起轮；非 live 冷载入——等效于直接 wake；**有同步回执**）
                          container_trajectory send-later（跨轨迹的"未来时刻 + 一条 message"；fire-and-forget，无回执无回收）
                          weixin 微信桥（配置/扫码/路由/消息 hook——CCC 侧 weixin-doctor MSM：msm("weixin-doctor", ["guide"])）
-  ⑥ CCC 配置总览      → container_admin msm ccc-config（9 段：handyman/sessionKeeper/localstore/hooks/safeMode/skiff/trajectory/weixin/**exclusiveTools**）
+  ⑥ CCC 配置总览      → container_admin msm ccc-config（9 段：cheap-worker/sessionKeeper/localstore/hooks/safeMode/skiff/trajectory/weixin/**exclusiveTools**）
   ⑦ 注册表与安全      → mech-registry.json 由 container_admin msm register/deregister 管理（写保护——不可直接编辑）
                          dashboard health 输出 registry 完整性检查；损坏恢复指引见 health registry.issues
                          CCC 级开关：exclusiveTools（声明专属工具）/ safeMode.blacklist（写路径黑名单）
@@ -1158,24 +1157,27 @@ const CCC_CONFIG_REFERENCE = `═══ CCC Configuration Reference ═══
 CCC-level features are configured in .opencode/serenity.json.
 Below are all available configuration sections.
 
-── 1. handyman.models ──
-handyman（杂工）工具可用模型白名单（provider/model 列表）；未配置时 handyman 报错要求配置。
-缺省模型 = models[0]（可用 handyman.defaultModel 指定，必须 ∈ models）。
-**CCC 应把该白名单指向低成本模型**——handyman 是批量执行通道（v1.31.3 双模式共用同一白名单）。
+── 1. cheap-worker.models ──
+cheap-worker（杂工）工具可用模型白名单（provider/model 列表）；未配置时 cheap-worker 报错要求配置。
+缺省模型 = models[0]（可用 cheap-worker.defaultModel 指定，必须 ∈ models）。
+**CCC 应把该白名单指向低成本模型**——cheap-worker 是批量执行通道。
+🔴 模型**不可由调用方指定**（工具无 model 参数）⇒ 本白名单是模型选择的唯一来源。
 
-  Modes（v1.31.3，缺省 foreground）:
-    mode="foreground"（缺省）：一次前台串行委派（宿主委派服务 ctx.subagents.start("spawn") +
+  Behaviour（2026-10-14：background 模式已删除，只剩前台委派）:
+    cheap-worker(task, [label])：一次前台委派（宿主委派服务 ctx.subagents.start("spawn") +
       agentOptions 注入模型）——不循环、不校验完成码、不写进度文件；返回子 agent 最终文本。
-      适合"一次调用一次结果"（逐用例回归、单次转换）。
-    mode="background"：既有循环校验实现（内部 while 硬循环 + 随机完成码唯一判据 + 轮次上限
-      默认 100 可续跑 + 异常自动重启 ≤100 + 进度文件 AGENT_SESSIONS/handyman-<label>.md/.json +
-      jobs 并行 maxParallel 默认 10）。适合长任务/无人值守/需抗提前收工。
+    cheap-worker(jobs=[{task,label?},...])：并行扇出，上限 10（硬编码），结果保持传入顺序。
+    ⇒ **无 background 模式、无进度文件、无续跑**（owner 2026-10-14 令「删除后台运行能力」）。
+
+  Old key（兼容）:
+    读不到 "cheap-worker" 时**回落到旧键 "handyman"**（同形状：models / defaultModel）。
+    旧键里的 "maxRounds"／"maxParallel" 已随 background 退场，留着无害但不再生效。
 
   Config:
-    { "handyman": { "models": ["provider/model-name"] } }
+    { "cheap-worker": { "models": ["provider/model-name"] } }
 
   Example:
-    { "handyman": { "models": ["minimax-cn-coding-plan/MiniMax-M3"], "defaultModel": "minimax-cn-coding-plan/MiniMax-M3", "maxRounds": 100, "maxParallel": 10 } }
+    { "cheap-worker": { "models": ["minimax-cn-coding-plan/MiniMax-M3"], "defaultModel": "minimax-cn-coding-plan/MiniMax-M3" } }
 
 ── 2. sessionKeeper.threshold / sessionKeeper.sessionMdMaxKB ──
 trajectory-assistant（TRAJECTORY-ASSISTANT · CHECKPOINT）提醒机制的积分阈值（非 headless 主 agent）。
@@ -1821,77 +1823,14 @@ async function runMsmAsync(root, args) {
 	}
 }
 //#endregion
-//#region src/handyman-ops.ts
+//#region src/cheap-worker-ops.ts
 /**
-* handyman-ops.ts — handyman（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
+* cheap-worker-ops.ts — cheap-worker（杂工）纯逻辑层（零 DSH 依赖，可独立单测）
 *
-* v1.24.0：loop（牛马）→ handyman（杂工）重命名。语义对齐 osp loop：
-* 进度文件（handyman-<label>.md/.json）、续跑、轮次 prompt 结构、stop token。
-* 不兼容旧 loop- 进度文件（用户拍板：仅新 handyman- 前缀）。
+* 🆕 2026-10-14（owner 令「删除后台运行能力」）：**进度文件 / stop token / 轮次循环**整族已退场 ——
+* 它们**只**服务于 background 模式。本模块现存 = 前台委派真正需要的三件：
+* 模型串解析 ／ 白名单校验 ／ provider 可用性判读（＋ 使用指引文本）。
 */
-/** label 脱敏（Windows 审计问题 17）：非法字符 → '-'，去尾点/空格，限长（按码点截断，修复代理对切散 U+FFFD） */
-function sanitizeLabel(label) {
-	return [...label.replace(/[<>:"/\\|?*\u0000-\u001f]/g, "-").replace(/[ .]+$/g, "")].slice(0, 50).join("");
-}
-function handymanProgressPaths(root, label) {
-	const dir = join(root, "AGENT_SESSIONS");
-	const safe = sanitizeLabel(label);
-	return {
-		md: join(dir, `handyman-${safe}.md`),
-		json: join(dir, `handyman-${safe}.json`)
-	};
-}
-/** 读取进度（续跑）；无文件返回 round 0 */
-function readProgress(root, label) {
-	const { json } = handymanProgressPaths(root, label);
-	if (!existsSync(json)) return null;
-	try {
-		return JSON.parse(readFileSync(json, "utf-8"));
-	} catch {
-		return null;
-	}
-}
-function writeProgress(root, label, p) {
-	const { md, json } = handymanProgressPaths(root, label);
-	mkdirSync(join(root, "AGENT_SESSIONS"), { recursive: true });
-	writeFileSync(json, JSON.stringify({
-		...p,
-		status: p.status ?? "running",
-		updated: isoLocal()
-	}, null, 2) + "\n", "utf-8");
-	const lines = [
-		`# handyman: ${label}`,
-		`- Model: ${p.model}`,
-		`- Round: ${p.round}`,
-		`- Done: ${p.done}`,
-		"",
-		`## Latest response`,
-		"",
-		p.lastResponse,
-		""
-	];
-	writeFileSync(md, lines.join("\n"), "utf-8");
-}
-/** 失败状态落盘（对齐 osp writeFailedStatus：done=true / status=failed / errorCode） */
-function writeFailedStatus(root, label, info) {
-	const { json } = handymanProgressPaths(root, label);
-	mkdirSync(join(root, "AGENT_SESSIONS"), { recursive: true });
-	const prev = readProgress(root, label);
-	writeFileSync(json, JSON.stringify({
-		round: prev?.round ?? 0,
-		done: true,
-		label,
-		model: prev?.model ?? "",
-		status: "failed",
-		errorCode: info.errorCode,
-		errorMessage: info.errorMessage,
-		updated: isoLocal(),
-		lastResponse: prev?.lastResponse ?? ""
-	}, null, 2) + "\n", "utf-8");
-}
-function newStopToken() {
-	return `SERENITY_HANDYMAN_DONE_${randomBytes(8).toString("hex")}`;
-}
 /** 解析 model 字符串（provider/model）→ {provider, model}；无 / 视为 model-only */
 function splitModel(model) {
 	const idx = model.indexOf("/");
@@ -1906,13 +1845,13 @@ function splitModel(model) {
 }
 /** 校验模型在白名单内；不在 → 抛错（用户拍板：只能使用 CCC 配置的模型） */
 function requireWhitelistedModel(model, models) {
-	if (!models.includes(model)) throw new Error(`handyman: model "${model}" is not in the CCC whitelist. Configure .opencode/serenity.json "handyman.models" with one of: ${models.join(", ")}`);
+	if (!models.includes(model)) throw new Error(`cheap-worker: model "${model}" is not in the CCC whitelist. Configure .opencode/serenity.json "cheap-worker.models" with one of: ${models.join(", ")}`);
 }
 /**
 * providerAvailabilityError — 判定「**本机有没有该 provider 的 adapter**」，并产出**可执行**的错误文本。
 * 返回 `null` = 全部可用（调用方照常继续）。
 *
-* 🔴 为什么需要它（S142 2026-09-25，owner 在 **Mac** 上实测）：`handyman` 的模型白名单写在
+* 🔴 为什么需要它（S142 2026-09-25，owner 在 **Mac** 上实测）：`cheap-worker` 的模型白名单写在
 *   **CCC**（`.opencode/serenity.json`，**随 git 走**），而 provider adapter 由**每台机器的宿主**
 *   注册（profile 配置 / settings 命名空间）⇒ 同一份白名单在一台机器可用、在另一台必失败。
 *   实测症状：宿主抛 `no adapter registered for provider "<p>"`（`dsh-llm`，code `NO_ADAPTER`），
@@ -1938,11 +1877,11 @@ function providerAvailabilityError(models, facts) {
 	const configPath = facts.configPath ?? "<ccc>/.opencode/serenity.json";
 	const missingList = missing.map((p) => `"${p}"`).join(", ");
 	return [
-		`handyman: provider ${missingList} has no adapter registered on this machine.`,
+		`cheap-worker: provider ${missingList} has no adapter registered on this machine.`,
 		"",
 		"  Requested model(s) :",
 		...requested.map((e) => `    ${e.raw}`),
-		`  Configured in      : ${configPath} → "handyman.models" / "handyman.defaultModel"`,
+		`  Configured in      : ${configPath} → "cheap-worker.models" / "cheap-worker.defaultModel"`,
 		"",
 		"  Why this happens   : the whitelist lives in the CCC (it travels with the repository), while",
 		"                       provider adapters are registered per machine by the host. An entry that",
@@ -1956,135 +1895,75 @@ function providerAvailabilityError(models, facts) {
 		"",
 		"  Fix (pick one, then retry):",
 		`    1. Point the whitelist at a provider that IS registered here — edit ${configPath}`,
-		"       (\"handyman.models\", and \"handyman.defaultModel\" if that is what you relied on).",
+		"       (\"cheap-worker.models\", and \"cheap-worker.defaultModel\" if that is what you relied on).",
 		`    2. Register/activate provider ${missingList} on this machine (host profile config,`,
 		"       or the settings namespace listed above).",
 		"",
 		"  Do not retry unchanged — the same call fails identically."
 	].join("\n");
 }
-/** 轮次 prompt（对齐老 loop 结构：回顾进度 → 自由工作 → 汇报；S134 EAP 化：固定详尽） */
-function buildRoundPrompt(opts) {
-	const { root, session, label, round, stopToken, progress, task } = opts;
-	const resumeNote = progress && progress.round > 0 ? `Previous round (round ${progress.round}) completed: ${progress.lastResponse.slice(0, 300)}\nAlways continue from where you left off; never redo completed work.` : "This is the first round.";
-	return `# ${label} — handyman round ${round}
-
-CCC root: ${root}
-${session ? `Work session: ${session} (progress recorded in AGENT_SESSIONS/${session}/SESSION.md)` : ""}
-${task ? `Task: ${task}` : `Task: follow the work corresponding to label "${label}" (if a work session exists, read SESSION.md first to clarify the goal)`}
-${resumeNote}
-
-## Work rules (fixed every round, must follow)
-1. Work freely within this round: read files, modify code, execute commands — use every means to advance the task.
-2. If this task is **reading/curating or text-writing work** (extracting from files, summarizing, writing docs, generating text, etc.),
-   first load eap (acc-eap skill) and organize output per the EAP standard:
-   - E↑ Explicit: entities/variables clearly defined, relationships with direction and cardinality, boundaries drawn, no ambiguous words
-   - R↓ Reconstructable: key conclusions record sources and reasoning, rebuildable by later agents
-   - S↑ Stable: output structure regenerates repeatably, no reliance on implicit context
-3. Reports must be concrete and verifiable — no filler.
-
-## Per-round report (fixed format, answer each item)
-1. What was done this round (concrete)
-2. Next-step plan
-3. Whether the task is complete (if complete, output only ${stopToken})
-
-If the task is complete, output only ${stopToken}.`;
-}
 /**
-* handyman 规模化使用指引（guide 子命令输出；S134 继承 + v1.24.0 更新）：
-* 使用 handyman 前必须先加载 eap 设计方案；并行策略（jobs 编排）；提示词规范（详尽固定 EAP）；
-* 阅读/文字编写类 handyman 内部也加载 eap。
+* cheap-worker 规模化使用指引（guide 子命令输出）。
+*
+* 🆕 2026-10-14：**双模式段已整段退场**（owner 令「删除后台运行能力」）。本指引只描述现行机制：
+* 前台委派（单任务）／前台并行扇出（jobs）／白名单与 provider 预检。
 */
-const HANDYMAN_GUIDE = `# handyman — Scale-Up Usage Guide (guide)
+const CHEAP_WORKER_GUIDE = `# cheap-worker — Scale-Up Usage Guide (guide)
 
-## Two modes (v1.31.3; default = foreground)
-| | foreground (default) | background |
+## What it is
+One delegation primitive: **foreground spawn**. The host starts child agent(s) through its delegation
+service, awaits them, and returns their final text. There is no loop, no completion code, no progress
+file, and no unattended/background run.
+
+| | single | parallel (jobs) |
 |---|---|---|
-| What | child agent(s) run the task ONCE and return their final text (jobs=[...] ⇒ parallel, cap 10) | loop-validated worker: hard while-loop + random completion code |
-| Use when | you need result(s) back now (per-case testers, single conversions, parallel fan-out) | long/unattended work needing anti-early-finish, resumability, or parallel jobs |
-| Loop / validation | none | stop-token is the ONLY completion condition; round cap (default 100); auto-restart (≤100) |
-| Progress file | none | AGENT_SESSIONS/handyman-<label>.md/.json (same label resumes) |
-| Parallel jobs | **yes** — jobs=[{task,label?,model?},...], **cap 10 (fixed)** | yes (jobs=[...], handyman.maxParallel default 10) |
-| Mechanism | host delegation service ctx.subagents.start("spawn") + agentOptions | ctx.agents.create + internal while-loop |
-| Model source | CCC handyman.models whitelist (same for both) | same |
+| Call | cheap-worker(task, [label]) | cheap-worker(jobs=[{task, label?}, ...]) |
+| Behaviour | one child runs the task once | all children start at once, results keep your order |
+| Cap | — | **10 (fixed, hardcoded)** |
+| Model | CCC config (single source) | same |
 
 ## ⚠️ Before using: load eap and design the plan
-Before calling handyman, load eap (acc-eap skill) and design the "scale-up handyman plan" based on the EAP framework.
+Before calling cheap-worker, load eap (acc-eap skill) and design the "scale-up cheap-worker plan" based on the EAP framework.
 
 ### 1. Task decomposition (E↑ Explicit)
 - Split large tasks into explicit subtasks: each subtask defines goal / input / boundaries (what to do, what not to do) / acceptance criteria
-- Make dependencies explicit: dependent tasks run serially, independent ones can run in parallel (both modes)
+- Make dependencies explicit: dependent tasks run serially, independent ones can run in parallel via \`jobs\`
 
-### 2. Prompt design (handyman's task parameter)
+### 2. Prompt design (cheap-worker's task parameter)
 - task must be detailed, fixed, and EAP-compliant: clear goal, drawn boundaries, decidable acceptance criteria
-- foreground mode: the child does NOT share your conversation — restate everything it needs in task
+- the child does NOT share your conversation — restate everything it needs in task
 - Anti-example "handle this file" — ambiguous; good example "read <path>, extract all rows of the「关键决策」table,
   output a JSON array (fields id/conclusion/evidence), do not modify the original file"
 - Reading/curating or text-writing work (extracting from files, summarizing, writing docs, generating text, etc.):
-  the handyman-internal agent is also required to load eap and organize output per the EAP standard
+  the cheap-worker-internal agent is also required to load eap and organize output per the EAP standard
 
-### 3. Model whitelist (CCC-configured, mandatory)
-- handyman only uses models listed in .opencode/serenity.json "handyman.models" — never arbitrary models
-- The CCC is expected to point this whitelist at LOW-COST models: handyman is the bulk-execution channel
-- background mode: recursive subagents inside a worker inherit the worker's model automatically (DSH native)
-- foreground mode: the child is started through the host delegation service with the resolved model
+### 3. Model (CCC-configured, not selectable per call)
+- The model is read from .opencode/serenity.json "cheap-worker.models" — **the caller cannot pass one**
+  (there is no "model" parameter). "cheap-worker.defaultModel" names which entry is used; it falls back to models[0].
+- The CCC is expected to point this whitelist at LOW-COST models: cheap-worker is the bulk-execution channel
+- A child's own recursive subagents inherit the child's model automatically (DSH native)
 
 ### 3b. 🔴 Provider availability (per-machine — the whitelist is NOT enough)
 - The whitelist lives in the **CCC** ("serenity.json", it **travels with the repository**), but provider
   **adapters are registered per machine by the host** (profile config / settings namespace). An entry that
   works on one machine can fail on another with: "no adapter registered for provider <p>".
-- Before spawning, handyman verifies the provider of the resolved model against the adapters registered
+- Before spawning, cheap-worker verifies the provider of the resolved model against the adapters registered
   **on this machine**; if it is missing it reports the requested model, where it is configured, **the
   providers that ARE available here**, any declared-but-dormant route (with its settings namespace), and the
-  exact fix — foreground puts this in "diagnostic", background throws it.
-- ⇒ If you see "has no adapter registered on this machine": edit ".opencode/serenity.json" "handyman.models"
-  (and "handyman.defaultModel") to a provider listed as available, or activate/register the provider on this
+  exact fix — delivered in the result's "diagnostic" field (never an opaque failure, never a created child).
+- ⇒ If you see "has no adapter registered on this machine": edit ".opencode/serenity.json" "cheap-worker.models"
+  (and "cheap-worker.defaultModel") to a provider listed as available, or activate/register the provider on this
   machine. **Do not retry the same call unchanged** — it fails identically.
 
-### 4. Parallel strategy (both modes)
-- Independent subtasks can run in parallel:
-  · **foreground** — handyman(jobs=[{task,label?,model?},...]) ⇒ fan-out of custom-model subagents, **cap 10**,
-    results come back **in the order you passed them** (label is only a display name here; per-job "model" allowed)
-  · **background** — handyman(mode="background", jobs=[...]): each job gets its own label + task + stop token + progress file
-- Concurrency safety guaranteed: unique sessionId (handyman-<label>-<uuid>), progress files isolated per label
-  (AGENT_SESSIONS/handyman-<label>.json) — same label resumes, different labels never interfere
-- Parallel cap: **foreground 10 (fixed)** / background handyman.maxParallel (default 10 — cheap models are cheap)
-- Aggregation: foreground returns all outputs in one result; background: after each parallel job produces progress, the main agent merges (or spawns one aggregation handyman)
-- For programmable pipeline/phase orchestration at scale, use the platform's workflow tool instead
+### 4. Parallel strategy
+- Independent subtasks: cheap-worker(jobs=[{task,label?},...]) ⇒ fan-out, **cap 10**, results come back
+  **in the order you passed them** (label is only a display name).
+- For programmable pipeline/phase orchestration at scale, use the platform's workflow tool instead.
 
 ## Completion criteria
-- foreground: the child's run settles; done=true only when stopReason="completed" (otherwise read diagnostic)
-- background (osp loop standard): the only completion condition = the worker echoes this round's random verification
-  code (stop token); dialogue round cap (default 100, osp fail-safe, forced stop beyond the cap, resumable);
-  automatic restart on abnormal agent stop (≤100 restarts, anti-infinite-loop)
-
-## Waiting UI
-- The WebUI session-header Serenity detail card shows running background handymen's progress
-  (label / round / last response), one line per parallel job, ~3s refresh (foreground mode writes no progress)
+- The child's run settles; done=true only when stopReason="completed" — otherwise read "diagnostic"
+  (and "output" for whatever partial text was produced).
 `;
-/** 列出 AGENT_SESSIONS/handyman-*.json 的全部进度（按 updated 倒序；坏文件跳过） */
-function listActiveHandymen(root) {
-	const dir = join(root, "AGENT_SESSIONS");
-	if (!existsSync(dir)) return [];
-	const out = [];
-	for (const entry of readdirSync(dir)) {
-		if (!entry.startsWith("handyman-") || !entry.endsWith(".json")) continue;
-		try {
-			const data = JSON.parse(readFileSync(join(dir, entry), "utf-8"));
-			if (typeof data.label !== "string" || typeof data.round !== "number") continue;
-			out.push({
-				label: data.label,
-				round: data.round,
-				done: data.done === true,
-				model: typeof data.model === "string" ? data.model : "",
-				updated: typeof data.updated === "string" ? data.updated : "",
-				lastResponse: typeof data.lastResponse === "string" ? data.lastResponse : ""
-			});
-		} catch {}
-	}
-	out.sort((a, b) => Date.parse(b.updated) - Date.parse(a.updated));
-	return out;
-}
 //#endregion
 //#region src/agent-idle.ts
 /**
@@ -3063,10 +2942,6 @@ function defaultAdvancedSettings() {
 			mode: "",
 			overrideText: ""
 		},
-		publicAsk: {
-			key: "",
-			allowed: []
-		},
 		weixinApi: {
 			enabled: true,
 			port: WEIXIN_SEND_PORT
@@ -3119,7 +2994,6 @@ function mergeWithDefaults(raw) {
 	const o = raw;
 	const gateway = o.gateway ?? {};
 	const persona = o.persona ?? {};
-	const publicAsk = o.publicAsk ?? {};
 	const weixinApi = o.weixinApi ?? {};
 	return {
 		gateway: {
@@ -3136,10 +3010,6 @@ function mergeWithDefaults(raw) {
 			mode: typeof persona.mode === "string" ? persona.mode : def.persona.mode,
 			overrideText: typeof persona.overrideText === "string" ? persona.overrideText : def.persona.overrideText
 		},
-		publicAsk: {
-			key: typeof publicAsk.key === "string" ? publicAsk.key : def.publicAsk.key,
-			allowed: Array.isArray(publicAsk.allowed) ? publicAsk.allowed.filter((n) => typeof n === "string" && n !== "") : def.publicAsk.allowed
-		},
 		weixinApi: {
 			enabled: typeof weixinApi.enabled === "boolean" ? weixinApi.enabled : def.weixinApi.enabled,
 			port: typeof weixinApi.port === "number" && Number.isInteger(weixinApi.port) && weixinApi.port >= 0 ? weixinApi.port : def.weixinApi.port
@@ -3177,10 +3047,6 @@ function updateAdvancedSettings(patch) {
 			mode: typeof ps.mode === "string" ? ps.mode : current.persona.mode,
 			overrideText: typeof ps.overrideText === "string" ? ps.overrideText : current.persona.overrideText
 		} : current.persona,
-		publicAsk: patch.publicAsk !== void 0 ? {
-			key: typeof patch.publicAsk.key === "string" ? patch.publicAsk.key : current.publicAsk.key,
-			allowed: Array.isArray(patch.publicAsk.allowed) ? patch.publicAsk.allowed.filter((n) => typeof n === "string" && n !== "") : current.publicAsk.allowed
-		} : current.publicAsk,
 		weixinApi: patch.weixinApi !== void 0 ? {
 			enabled: typeof patch.weixinApi.enabled === "boolean" ? patch.weixinApi.enabled : current.weixinApi.enabled,
 			port: typeof patch.weixinApi.port === "number" && Number.isInteger(patch.weixinApi.port) && patch.weixinApi.port >= 0 ? patch.weixinApi.port : current.weixinApi.port
@@ -3190,87 +3056,6 @@ function updateAdvancedSettings(patch) {
 	return next;
 }
 /**
-* 确保问答页访问 key 存在（首次启用自动生成 + 写回固定，用户拍板"配置时生成"）：
-* 读取全局配置 publicAsk.key；为空 → 生成 32 字节随机 hex（64 字符）→ 写回持久化。
-* @returns 当前固定 key（已生成则返回既有值——**幂等**，不会覆盖用户手改的 key）
-*/
-function ensurePublicAskKey() {
-	const current = readAdvancedSettings();
-	if (current.publicAsk.key !== "") return current.publicAsk.key;
-	const key = randomBytes(32).toString("hex");
-	updateAdvancedSettings({ publicAsk: {
-		key,
-		allowed: current.publicAsk.allowed
-	} });
-	return key;
-}
-/** 校验问答页访问 key（timing-safe；key 未生成 → 恒 false——没有 key 不工作） */
-function verifyPublicAskKey(provided) {
-	const expected = readAdvancedSettings().publicAsk.key;
-	if (!expected || typeof provided !== "string" || provided === "") return false;
-	const a = Buffer.from(provided);
-	const b = Buffer.from(expected);
-	return a.length === b.length && timingSafeEqual(a, b);
-}
-/**
-* 轮换问答页访问 key（v1.26.5，S142 用户：公网开放 + 不好说要换 key 呢）：
-* 生成新 32 字节随机 hex（64 字符）→ 覆盖写回（**强制替换**——旧 key 立即失效）。
-* @returns 新 key（面板展示给管理员，重新分享给使用者）
-*/
-function rotatePublicAskKey() {
-	const current = readAdvancedSettings();
-	const key = randomBytes(32).toString("hex");
-	updateAdvancedSettings({ publicAsk: {
-		key,
-		allowed: current.publicAsk.allowed
-	} });
-	return key;
-}
-/** 失败锁定阈值（连续失败次数） */
-const PUBLIC_ASK_FAIL_THRESHOLD = 5;
-/** 首次锁定基础时长（指数退避底数） */
-const PUBLIC_ASK_LOCK_BASE_MS = 9e5;
-/** 锁定上限 */
-const PUBLIC_ASK_LOCK_MAX_MS = 144e5;
-const ipFailStates = /* @__PURE__ */ new Map();
-/** 重置 IP 失败状态（测试/管理员解封） */
-function resetPublicAskIpFail(ip) {
-	ipFailStates.delete(ip);
-}
-/** IP 当前是否锁定（到期自动解锁） */
-function isPublicAskIpLocked(ip) {
-	const st = ipFailStates.get(ip);
-	if (!st || st.lockedUntil === 0) return false;
-	if (Date.now() >= st.lockedUntil) {
-		st.lockedUntil = 0;
-		st.count = 0;
-		return false;
-	}
-	return true;
-}
-/** 记录一次 key 校验失败；达到阈值 → 锁定（指数退避）。返回锁定剩余毫秒（0 = 未锁定） */
-function recordPublicAskFail(ip) {
-	let st = ipFailStates.get(ip);
-	if (!st) {
-		st = {
-			count: 0,
-			lockedUntil: 0,
-			lockRound: 0
-		};
-		ipFailStates.set(ip, st);
-	}
-	if (st.lockedUntil > 0 && Date.now() < st.lockedUntil) return st.lockedUntil - Date.now();
-	st.count += 1;
-	if (st.count >= PUBLIC_ASK_FAIL_THRESHOLD) {
-		const base = PUBLIC_ASK_LOCK_BASE_MS * 2 ** st.lockRound;
-		st.lockedUntil = Date.now() + Math.min(base, PUBLIC_ASK_LOCK_MAX_MS);
-		st.lockRound += 1;
-		st.count = 0;
-		return st.lockedUntil - Date.now();
-	}
-	return 0;
-}
-/**
 * 一次性迁移（v1.21.x → v1.22）：旧版把 `serenityAdvanced` 存在 CCC localstore.json；
 * 新版归 plugin 全局文件。全局文件已存在 → 跳过（幂等）；localstore 无旧节 → 跳过。
 * @param root - CCC 根（localstore.json 所在目录）
@@ -3303,8 +3088,7 @@ function toWire(settings) {
 			allowWorkspaceCreate: settings.gateway.allowWorkspaceCreate,
 			totpEnabled: settings.gateway.totpEnabled
 		},
-		persona: settings.persona,
-		publicAsk: { allowed: [...settings.publicAsk.allowed] }
+		persona: settings.persona
 	};
 }
 /**
@@ -3373,11 +3157,6 @@ function applyWirePatch(wire) {
 		if (typeof wire.persona.overrideText === "string") psPatch.overrideText = wire.persona.overrideText;
 		patch.persona = psPatch;
 	}
-	if (wire.publicAsk !== void 0 && Array.isArray(wire.publicAsk.allowed)) {
-		const paPatch = { ...current.publicAsk };
-		paPatch.allowed = wire.publicAsk.allowed.filter((n) => typeof n === "string" && n !== "");
-		patch.publicAsk = paPatch;
-	}
 	return updateAdvancedSettings(patch);
 }
 //#endregion
@@ -3446,7 +3225,7 @@ function toolsBlock() {
 		"  msm          — execute a registered CCC MSM: msm(name, args); partial name returns candidates; inspect=true shows usage",
 		"  praxis       — actionable theory injection: praxis (index) / praxis eap / praxis neat / praxis cce / praxis ontology",
 		"  ontology     — ontology engineering ENGINE (executable): init (write template) / check (M1-M10 structural; level=strict adds L1-L5 hints) / explain (summary) / verify (V1-V4 runtime compliance) / review (semantic-review prompt) / compliance (axiom-vs-skill checklist). Sibling of `praxis ontology` — that one is the METHOD TEXT, this one RUNS it. path must stay inside the container; the receipt carries the engine exit code (0/1/2/4) and the engine text verbatim, so read it rather than assuming success",
-		"  handyman     — delegate work to a worker agent on a CCC-whitelisted model; mode=\"foreground\" (default) = child agent(s) run once and return their final text (jobs=[...] fans out in parallel, cap 10, per-job model); mode=\"background\" = loop-validated worker (completion code + round cap + restart + progress file), jobs=[] orchestrates parallel work",
+		"  cheap-worker     — delegate work to a worker agent on the CCC-configured model; one serial child per task, returns its final text. `jobs=[...]` fans out in parallel (cap 10, results keep your order). No loop, no completion code, no progress file. The model is NOT selectable per call (read from the CCC config); a worker's tool set excludes cheap-worker itself",
 		"  serenity-skill-creator — creator for serenity-skills (this container's enhanced skill standard): guide (authoring/optimization method — read first) / create <name> (scaffold SKILL.md + skill.ttl + references/, base-chain import path computed) / check <name> (A1 structural + A2 base-chain; three states: modeled-ok / plain-skill / modeled-but-check-could-not-run) / review <name> (C tier: axiom-vs-text compliance question list, half-mechanical) / index <name> (preview the second-layer resource list the model will see) / status (which skills are modeled). A skill is \"modeled\" iff it has a file named exactly skill.ttl next to SKILL.md; a plain skill is NOT an anomaly. Only `create` writes, and it refuses an existing directory",
 		"  localstore   — ACC local credential/config storage (CCC-root localstore.json; git policy localstore.gitTrack default deny)",
 		"  container_admin — container administration (the maintenance bay): role (Skiff roles: guide/validate/apply/list) / msm (register/deregister/check/guide/catalog/ccc-config) / config (view)",
@@ -3997,15 +3776,6 @@ function unregisterSkiffSession(sessionId) {
 	skiffAgents.delete(sessionId);
 	unregisterSkiffSession$1(sessionId);
 }
-/** 测试/调试：注册表快照（sessionId → {role} 兼容展示） */
-function skiffSessionSnapshot() {
-	const out = /* @__PURE__ */ new Map();
-	for (const [id, b] of skiffSessionSnapshot$1()) out.set(id, {
-		role: b.role,
-		ccc: b.ccc
-	});
-	return out;
-}
 /** 自动创建的 bound 标记（readLastBound 恢复判定——只恢复本机制建的；手工 use 的旧 bound 不认） */
 const AUTO_BOUND_NOTE_PREFIX = "auto-created for skiff role";
 /**
@@ -4094,7 +3864,7 @@ function ensureWorkspacePromptSection(agent, scope) {
 *
 * 判定链：
 * ⓪ **临时身份不建工作台**（v1.30.9，S142 用户报"SESSION 爆炸"根治）：`persistent=false`
-*    （ACP/调试页/问答页等**无固定会话 id**的临时 agent）→ null。理由（R↓）：这些 agent 每次
+*    （调试页等**无固定会话 id**的临时 agent）→ null。理由（R↓）：这些 agent 每次
 *    调用都是新 id、无身份延续，为其建 SESSION = 每次问答留一个永久空目录（无界熵增）；
 *    用户模型「skiff 本质是临时会话机制」——工作台属于**持久身份**，不属于单次调用。
 * ① 角色未启用 session 能力（trajectory.session !== true）→ null（现状零变化）
@@ -4152,7 +3922,7 @@ function ensureSkiffSession(root, agent, roleName, role, persistent = true) {
 	return mdPath;
 }
 /** Skiff agent 挂载的 DSH preset（v1.25.3 修复：read/grep/glob 等平台工具由 preset 决定工具面；
-*  handyman 经 composeFrom 继承父、skiff 无父上下文——直接挂 DSH 默认 standard preset；
+*  cheap-worker 经 composeFrom 继承父、skiff 无父上下文——直接挂 DSH 默认 standard preset；
 *  guard 角色白名单再按角色过滤可见/可用面——白名单外工具仍 deny） */
 const SKIFF_PRESET = "standard";
 /**
@@ -4163,10 +3933,10 @@ const SKIFF_PRESET = "standard";
 * 指定 sessionId 且磁盘已有持久化 log → `ctx.agents.resume`（DSH 持久化语义：
 * sessionId 即身份，已持久化会话必须 resume——历史 + turn 续号延续，同用户长期记忆保留）；
 * 无 log（首次）/持久化未配置 → `ctx.agents.create`（新建）。不指定 sessionId →
-* 随机 id 恒 create（ACP/调试页默认路径）。
+* 随机 id 恒 create（调试页默认路径）。
 *
 * @param sessionId 指定会话 id（可选；微信桥等外部面用固定 id 实现用户↔会话长期映射——
-*   不传则随机生成 skiff-<role>-<uuid>，ACP/调试页默认路径）
+*   不传则随机生成 skiff-<role>-<uuid>，调试页默认路径）
 */
 async function createSkiffAgent(ctx, root, roleName, role, defaultModel, sessionId) {
 	if (!ctx.agents) throw new Error("skiff: ctx.agents unavailable");
@@ -4315,8 +4085,8 @@ function sessionEvents(session) {
 	if (typeof s.snapshotEvents === "function") return s.snapshotEvents();
 	return s.events ?? [];
 }
-/** 读会话最后一个 assistant/message 文本（handyman 同款） */
-function lastAssistantText$2(agent) {
+/** 读会话最后一个 assistant/message 文本（cheap-worker 同款） */
+function lastAssistantText$1(agent) {
 	const events = sessionEvents(agent.session);
 	for (let i = events.length - 1; i >= 0; i--) {
 		const e = events[i];
@@ -4377,8 +4147,9 @@ function truncate(s, n) {
 * 提问一轮：followup → 等 idle → 读答案 + 轨迹。
 * @param eventsStart 轨迹起点：显式传 0 = 全量轨迹（会话追问时页面重绘完整时间线，
 *   v1.25.10 用户拍板）；不传（undefined）= 本轮增量（followup 前 events 之后）
-* @param options.includeTrajectory 是否计算轨迹（v1.26.10：**3100 对外只提供问答**——
-*   公开问答页 / ACP JSON-RPC 不返回 trajectory，传 false 跳过计算；3099 调试页默认 true 保留）
+* @param options.includeTrajectory 是否计算轨迹（v1.26.10 起供**对外面**传 false 跳过计算——
+*   原消费方 = 3100 公开问答页 / ACP JSON-RPC，**该面已于 2026-10-15 退役** ⇒ 现无生产调用方传 false；
+*   3099 调试页默认 true 保留）
 */
 async function askSkiff(ctx, agent, question, eventsStart, options) {
 	const before = eventsStart === void 0 ? sessionEvents(agent.session).length : eventsStart;
@@ -4390,7 +4161,7 @@ async function askSkiff(ctx, agent, question, eventsStart, options) {
 		source: PLUGIN_SOURCE
 	}));
 	await waitAgentIdle(ctx, agent);
-	const answer = lastAssistantText$2(agent);
+	const answer = lastAssistantText$1(agent);
 	const trajectory = options?.includeTrajectory === false ? [] : eventsToTrajectory(sessionEvents(agent.session).slice(before));
 	return {
 		answer,
@@ -9306,49 +9077,23 @@ function createSkillCreatorTool() {
 	});
 }
 //#endregion
-//#region src/handyman-preset-inherit.ts
+//#region src/tools/cheap-worker.ts
 /**
-* 解析 handyman worker 从父 agent 继承的 preset，并组装创建 setup 钩子。
-* @param parentCtx - 发起 handyman 的 agent 的 scope ctx；无（headless/非 agent 上下文）时为 undefined。
-* @returns 继承结果：meta 用的 agentPreset 与创建 setup 钩子。
-*/
-function handymanPresetInheritance(parentCtx) {
-	if (parentCtx === void 0) return { setup: (childCtx) => {
-		childCtx.tools.restrict({ deny: ["handyman"] });
-	} };
-	const agentPreset = parentCtx.get("agentPresets")?.composedPreset(parentCtx);
-	if (agentPreset === void 0) return { setup: (childCtx) => {
-		childCtx.tools.restrict({ deny: ["handyman"] });
-	} };
-	return {
-		agentPreset,
-		setup: (childCtx) => {
-			childCtx.get("agentPresets")?.composeFrom(childCtx, parentCtx);
-			childCtx.tools.restrict({ deny: ["handyman"] });
-		}
-	};
-}
-//#endregion
-//#region src/tools/handyman.ts
-/**
-* handyman.ts — handyman（杂工）真实 DSH 工具（v1.24.0：loop 牛马 → handyman 杂工）
+* cheap-worker.ts — cheap-worker（杂工）真实 DSH 工具
 *
-* 用户需求（S142 拍板）：
-*   - **同步**（用户明确：这个事一般不会异步——工具阻塞到完成）
-*   - **指定模型**（CCC 白名单内——handyman.models，未配置报错）
-*   - **自主循环到完成**（stop-token 唯一完成判据，对齐 osp loop）
-*   - **内部递归同样低能 subagent**（worker 工具面含 subagent，DSH 原生模型继承）
-*   - **workflow 能力**（jobs 编排：主 agent 一次并行多个杂工，maxParallel 默认 10）
-*   - **worker 不含 handyman 本身**（递归编排归主 agent，防无限嵌套）
-*   - **不兼容旧 loop 进度文件**（仅 handyman- 前缀）
+* v1.24.0：loop（牛马）→ handyman（杂工）；2026-10-14：handyman → cheap-worker。
+* 🆕 2026-10-14（owner 令「删除后台运行能力」）：**background 模式整条退场** ——
+*    轮次循环 ／ stop-token 完成码 ／ 进度文件 ／ 重启计数 ／ maxRounds／maxParallel 全部删除。
+*    现存只有**前台委派**一种形态：宿主起子 agent、等它跑完、取回最终文本。
 *
-* 机制：ctx.agents.create()（带 setup 钩子）创建专用 agent（进程内），
-* 每轮 followup → agent/status idle → 读 session.events 响应 → 写进度 → stop token 检查 →
-* 未完成继续下一轮；followup/等待空闲抛错（非正常停止）→ dispose 并重新 create agent
-* （重启计数，≤100），同一轮重试。工厂模式：apply 时闭包捕获插件 ctx（工具 execute 无 ctx 参数）。
+* 机制：走宿主**委派正门** `ctx.subagents.start('spawn', …)`（深度上限、子 agent 所有权、
+* `subagent/start|end` 事件、`dispose()` 收尾全部沿用宿主实现），模型经 `agentOptions` 注入。
+* 前置：`exec.agent` 必须存在（前台委派要有发起方）。
 *
-* preset 继承 + 工具收窄：setup 钩子里对子 agent 执行 agentPresets.composeFrom（对齐
-* subagent 先例）+ tools.restrict deny handyman（worker 内部看不到 handyman 工具）。
+* 🔴 **模型不可由调用方指定**（owner 令）：**没有 `model` 参数**，一律读 CCC 配置
+*    `cheap-worker.models` / `cheap-worker.defaultModel`（单一真相源）。
+*
+* 递归防护：子 agent 的工具面 deny `cheap-worker` 本身（编排归主 agent，防无限嵌套）。
 */
 function renderText$4(value) {
 	return [{
@@ -9356,52 +9101,18 @@ function renderText$4(value) {
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
 	}];
 }
-/** 读取会话最后一个 assistant/message 文本 */
-function lastAssistantText$1(agent) {
-	const s = agent.session;
-	const events = typeof s.snapshotEvents === "function" ? s.snapshotEvents() : s.events ?? [];
-	for (let i = events.length - 1; i >= 0; i--) {
-		const e = events[i];
-		if (e && e.type === "assistant/message") {
-			const data = e.data;
-			const text = (data?.message?.content ?? data?.content ?? []).filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
-			if (text) return text;
-		}
-	}
-	return "";
-}
-/** 非正常停止时重启 agent 的次数上限（防死循环保险阀）：对话轮次有上限，重启有上限 */
-const HANDYMAN_MAX_RESTARTS = 100;
-/** 运行时解析 jobs 参数（DSH schema 不支持 object items 的 required/校验 → 手工校验类型） */
-function parseJobs(raw) {
-	if (!Array.isArray(raw) || raw.length === 0) return null;
-	const jobs = [];
-	for (const item of raw) {
-		if (typeof item !== "object" || item === null) return null;
-		const rec = item;
-		if (typeof rec.task !== "string" || typeof rec.label !== "string") return null;
-		jobs.push({
-			task: rec.task,
-			label: rec.label,
-			model: typeof rec.model === "string" ? rec.model : void 0
-		});
-	}
-	return jobs;
-}
 /**
-* 🔴 **foreground 并行上限 = 10**（owner 2026-09-29 具名令：「这个版本顺手帮我把 handyman 并行度从 5 调整成 10」；
+* 🔴 **前台并行上限 = 10**（owner 2026-09-29 具名令：「这个版本顺手帮我把 handyman 并行度从 5 调整成 10」；
 * 原值 5 出自 owner 2026-09-27 的具名令「最大 5；就当是支持自定模型的 subagent 用了，急需」）。
 *
 * 为什么是**硬编码**而不是又一个配置键：owner 两次都是**直接给数**（同 `REBUILD-TODO` 那次的裁决口径
 * —— 设定项能不加就不加，见 S142 的「可砍设定项」）。若将来还要调，仍按具名令改这个常量。
 *
-* 为什么 foreground 仍与 background 分开（后台 = `handyman.maxParallel`，缺省 **10**）：**foreground 会占住
-* 主 agent 的这一轮**（调用方在等结果），并发越高越容易把宿主的并发面与用量推上去。
-* ⚠️ 现在两档**数值相等但语义不同**（前台 = 占住本轮 ／ 后台 = 不占）⇒ **刻意不合并成一个常量**：
-* 合并会让"哪天要给前台单独降档"变成一次语义手术。
+* 为什么是 10 而不是更高：**前台委派会占住主 agent 的这一轮**（调用方在等结果），
+* 并发越高越容易把宿主的并发面与用量推上去。
 */
 const FOREGROUND_MAX_PARALLEL = 10;
-/** foreground 的 jobs 解析（与 background 的差别：**label 可选** —— 前台 label 只是显示名，不命名进度文件） */
+/** foreground 的 jobs 解析（label 可选 —— 前台 label 只是显示名，不命名任何文件） */
 function parseForegroundJobs(raw) {
 	if (!Array.isArray(raw) || raw.length === 0) return null;
 	const jobs = [];
@@ -9411,8 +9122,7 @@ function parseForegroundJobs(raw) {
 		if (typeof rec.task !== "string" || rec.task.trim() === "") return null;
 		jobs.push({
 			task: rec.task,
-			...typeof rec.label === "string" && rec.label !== "" ? { label: rec.label } : {},
-			...typeof rec.model === "string" && rec.model !== "" ? { model: rec.model } : {}
+			...typeof rec.label === "string" && rec.label !== "" ? { label: rec.label } : {}
 		});
 	}
 	return jobs;
@@ -9429,8 +9139,8 @@ function subagentOutputText(output) {
 * ⇒ 一律**不阻断**，保持旧行为 —— 增强不得变成新的失败源）。
 *
 * 为什么必须放在"创建之前"：宿主对未知 provider 抛 `no adapter registered for provider "…"`
-* （`dsh-llm`，code `NO_ADAPTER`）。若照常创建：前台只拿回 `stopReason:"error"` ＋ **空
-* `diagnostic`**（实测），后台整条失败且**不带原因** ⇒ 调用方（LLM）无法自我修正配置。
+* （`dsh-llm`，code `NO_ADAPTER`）。若照常创建：只拿回 `stopReason:"error"` ＋ **空
+* `diagnostic`**（实测）⇒ 调用方（LLM）无法自我修正配置。
 */
 function providerPreflight(ctx, model) {
 	const llm = hostLlm(ctx);
@@ -9455,14 +9165,13 @@ function providerPreflight(ctx, model) {
 	});
 }
 /**
-* foreground 模式：单次前台串行委派（用户裁决"本次所需的简单实现"）。
+* 单次前台串行委派。
 *
-* 与 background 的差别（R↓）：
 *  - 走宿主**委派正门** `ctx.subagents.start('spawn', …)`——深度上限、子 agent 所有权、
 *    `subagent/start|end` 生命周期事件、`dispose()` 收尾全部沿用宿主实现（不重写 agent 创建）；
 *  - 模型经 `agentOptions` 注入（spawn 后端能力位 `agentOptions: true`），因此**不依赖**
 *    宿主未放开的 `subagent-model-selection` 设置；
-*  - 不循环、不写进度文件、不做完成码校验——"一次调用一次结果"。
+*  - 不循环、不写文件、不做完成码校验——"一次调用一次结果"。
 *
 * 前置条件：`opts.parent` 必须是发起 agent（由调用方 `execute` 在解析 CCC 之前校验；
 * 本函数不再重复检查——单一真相源）。
@@ -9471,7 +9180,7 @@ async function runForegroundJob(ctx, opts) {
 	const { task, label, model, models, parent, signal } = opts;
 	requireWhitelistedModel(model, models);
 	const subagents = hostSubagents(ctx);
-	if (!subagents?.start) throw new Error("handyman foreground: host subagents service unavailable — neither ctx.subagents nor ctx.get(\"subagents\") yielded a start() function. Check `dashboard health` (host-contract section, service \"subagents\"); mode=\"background\" does not need this service and still works.");
+	if (!subagents?.start) throw new Error("cheap-worker: host subagents service unavailable — neither ctx.subagents nor ctx.get(\"subagents\") yielded a start() function. Check `dashboard health` (host-contract section, service \"subagents\").");
 	const preflight = providerPreflight(ctx, model);
 	if (preflight !== null) return {
 		mode: "foreground",
@@ -9494,7 +9203,7 @@ async function runForegroundJob(ctx, opts) {
 			...provider === void 0 ? {} : { provider },
 			model: modelName
 		},
-		toolFilter: { deny: ["handyman"] }
+		toolFilter: { deny: ["cheap-worker"] }
 	});
 	try {
 		const result = run.result === void 0 ? {} : await run.result;
@@ -9512,165 +9221,28 @@ async function runForegroundJob(ctx, opts) {
 		if (run.dispose) await run.dispose().catch(() => {});
 	}
 }
-/**
-* 驱动单个 handyman worker：创建 agent → while 循环（stop-token 完成判据）→ dispose。
-* 同步阻塞直到完成/保险阀。jobs 编排时多个 worker 并行（Promise.all）。
-*/
-async function runHandymanJob(ctx, opts) {
-	const { root, job, defaultModel, models, maxRounds, parentSession, parentCtx, session } = opts;
-	const label = job.label;
-	const model = job.model ?? defaultModel;
-	requireWhitelistedModel(model, models);
-	const preflightError = providerPreflight(ctx, model);
-	if (preflightError !== null) throw new Error(preflightError);
-	const { provider, model: modelName } = splitModel(model);
-	const stopToken = newStopToken();
-	let progress = readProgress(root, label);
-	const startRound = progress ? progress.round + 1 : 1;
-	const inherited = handymanPresetInheritance(parentCtx);
-	if (!ctx.agents) throw new Error("handyman: ctx.agents unavailable");
-	let handle;
-	let workerAgent;
-	const spawnAgent = async () => {
-		const sessionId = `handyman-${label}-${randomUUID()}`;
-		handle = await ctx.agents.create({
-			sessionId,
-			meta: {
-				cwd: root,
-				origin: "subagent",
-				...parentSession === void 0 ? {} : { parentSession },
-				...inherited.agentPreset === void 0 ? {} : { agentPreset: inherited.agentPreset }
-			},
-			agentOptions: {
-				provider,
-				model: modelName
-			},
-			...inherited.setup === void 0 ? {} : { setup: inherited.setup }
-		});
-		workerAgent = handle.agent;
-	};
-	await spawnAgent();
-	let done = false;
-	let lastResponse = progress?.lastResponse ?? "";
-	let finalRound = startRound - 1;
-	let restarts = 0;
-	let finishReason = "done";
-	try {
-		let round = startRound;
-		while (true) {
-			if (round > maxRounds) {
-				finishReason = "max_rounds";
-				break;
-			}
-			finalRound = round;
-			const prompt = buildRoundPrompt({
-				root,
-				session,
-				label,
-				round,
-				stopToken,
-				progress,
-				task: job.task
-			});
-			try {
-				workerAgent.followup(createUserMessage({
-					content: [{
-						type: "text",
-						text: prompt
-					}],
-					source: PLUGIN_SOURCE
-				}));
-				await waitAgentIdle(ctx, workerAgent);
-				lastResponse = lastAssistantText$1(workerAgent);
-			} catch {
-				restarts++;
-				if (restarts > HANDYMAN_MAX_RESTARTS) {
-					finishReason = "restart_exceeded";
-					break;
-				}
-				await handle.dispose().catch(() => {});
-				await spawnAgent();
-				continue;
-			}
-			progress = {
-				round,
-				done: false,
-				label,
-				model,
-				updated: isoLocal(),
-				lastResponse
-			};
-			writeProgress(root, label, progress);
-			if (lastResponse.includes(stopToken)) {
-				done = true;
-				finishReason = "done";
-				break;
-			}
-			round++;
-		}
-		writeProgress(root, label, {
-			round: finalRound,
-			done,
-			label,
-			model,
-			updated: isoLocal(),
-			lastResponse,
-			status: done ? "done" : "running"
-		});
-		if (finishReason !== "done") writeFailedStatus(root, label, {
-			errorCode: finishReason,
-			errorMessage: finishReason === "max_rounds" ? `Reached ${maxRounds} rounds without completion — resume with same label to continue.` : `Agent restarted ${HANDYMAN_MAX_RESTARTS} times without progress — resume with same label to continue.`
-		});
-	} finally {
-		await handle.dispose().catch(() => {});
-	}
-	const { json } = handymanProgressPaths(root, label);
-	return {
-		label,
-		done,
-		rounds: finalRound,
-		finishReason,
-		restarts,
-		model,
-		lastResponse: lastResponse.slice(0, 2e3),
-		progressFile: json
-	};
-}
-/** 创建 handyman 工具（闭包捕获插件 ctx → 可访问 ctx.agents） */
-function createHandymanTool(ctx) {
+/** 创建 cheap-worker 工具（闭包捕获插件 ctx → 可访问 ctx.subagents） */
+function createCheapWorkerTool(ctx) {
 	return defineTool({
-		name: "handyman",
-		description: "The handyman (杂工): delegate work to a worker agent on a CCC-configured model. Two modes (v1.31.3).\nMode \"foreground\" (DEFAULT): one serial child agent runs the task once and returns its final text — no loop, no completion-code validation, no progress file; use it for one-shot serial delegation (e.g. per-case testers that just gather evidence). Usage: handyman(task, [label], [model]).\nMode \"background\": the loop-validated worker — internal hard while-loop whose ONLY completion condition is the worker echoing this round's random completion code (stop token, prevents low-intelligence models from finishing early), round cap (default 100, resumable), automatic restart on abnormal stop (≤100), progress file AGENT_SESSIONS/handyman-<label>.md/.json (same label resumes), and parallel jobs (handyman.maxParallel, default 10). Usage: handyman(mode=\"background\", task, label, [model]) or handyman(mode=\"background\", jobs=[{task,label,model?},...]).\nChoosing: need exactly one result back now → foreground; need anti-early-finish guarantees or resumability → background; need N results back now (parallel, per-job model) → foreground with jobs (cap 10).\nModel: only models whitelisted in .opencode/serenity.json \"handyman.models\" (missing config = error); default reads handyman.defaultModel. Both modes share the same whitelist and default.\nProvider check: the whitelist lives in the CCC (it travels with the repo) while provider adapters are registered per machine by the host — so before spawning, the provider of the resolved model is verified against the adapters present on THIS machine. If it is missing you get the available providers plus the exact fix (foreground: in `diagnostic`; background: thrown), never an opaque failure.\nRecursion: a worker's tool set excludes handyman itself (orchestration belongs to the main agent).\nGuide: handyman(guide=true) prints the scale-up usage guide.",
+		name: "cheap-worker",
+		description: "The cheap-worker (杂工): delegate work to a worker agent on the CCC-configured model, and return its final text. One serial child per task; `jobs` fans out in parallel.\nUsage: cheap-worker(task, [label]) for a single delegation; cheap-worker(jobs=[{task,label?},...]) for parallel fan-out (cap 10, results keep your order).\nThe child does NOT share this conversation — the task must be self-contained.\nNo loop, no completion-code validation, no progress file, no unattended/background run.\nModel: NOT selectable per call — it is read from .opencode/serenity.json \"cheap-worker.models\" (missing config = error); \"cheap-worker.defaultModel\" names the one used, falling back to models[0].\nProvider check: the whitelist lives in the CCC (it travels with the repo) while provider adapters are registered per machine by the host — so before spawning, the provider of the resolved model is verified against the adapters present on THIS machine. If it is missing you get the available providers plus the exact fix in `diagnostic`, and no child is created.\nRecursion: a worker's tool set excludes cheap-worker itself (orchestration belongs to the main agent).\nGuide: cheap-worker(guide=true) prints the scale-up usage guide.",
 		parameters: {
-			mode: {
-				type: "string",
-				description: "Delegation mode: \"foreground\" (default — child agent(s) run once and return their final text; accepts `jobs` for parallel fan-out, cap 10) or \"background\" (loop-validated worker with completion-code check, round cap, auto-restart, progress file, parallel jobs)"
-			},
 			task: {
 				type: "string",
-				description: "The task goal to complete (required in both modes; foreground needs a self-contained prompt — the child does not share this conversation)"
+				description: "The task goal to complete (must be self-contained — the child does not share this conversation)"
 			},
 			label: {
 				type: "string",
-				description: "Task label (background: 1-50 chars, names the progress file; foreground: optional child display name)"
-			},
-			session: {
-				type: "string",
-				description: "Work session S### (context hint, progress reference)"
-			},
-			model: {
-				type: "string",
-				description: "provider/model — must be in the CCC whitelist handyman.models; default reads handyman.defaultModel"
+				description: "Optional child display name"
 			},
 			jobs: {
 				type: "array",
-				description: "Multi-job orchestration (workflow capability): [{task, label?, model?}, ...] — runs jobs in parallel. Cap: foreground 10 (fixed) / background handyman.maxParallel (default 10). Results keep the order you passed them in.",
+				description: "Multi-job orchestration (workflow capability): [{task, label?}, ...] — runs jobs in parallel, cap 10 (fixed). Results keep the order you passed them in.",
 				items: {
 					type: "object",
 					properties: {
 						task: { type: "string" },
-						label: { type: "string" },
-						model: { type: "string" }
+						label: { type: "string" }
 					},
 					additionalProperties: false
 				}
@@ -9685,93 +9257,51 @@ function createHandymanTool(ctx) {
 			render: (_args, value) => renderText$4(value)
 		},
 		async execute(args, exec) {
-			if (args.guide) return { guide: HANDYMAN_GUIDE };
-			if ((args.mode ?? "foreground") === "foreground" && !exec.agent) throw new Error("handyman foreground: requires a calling agent (exec.agent was undefined)");
+			if (args.guide) return { guide: CHEAP_WORKER_GUIDE };
+			if (!exec.agent) throw new Error("cheap-worker: requires a calling agent (exec.agent was undefined)");
 			const root = cccRootForExec(exec);
 			if (!root) throw new Error(NO_CCC_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\"}})");
-			const mode = args.mode === "background" ? "background" : "foreground";
-			if (args.mode !== void 0 && args.mode !== "background" && args.mode !== "foreground") throw new Error("handyman: mode must be \"foreground\" (default) or \"background\"");
-			if (mode === "foreground") {
-				if (args.jobs !== void 0) {
-					const jobs = parseForegroundJobs(args.jobs);
-					if (jobs === null) throw new Error("handyman foreground: jobs must be [{task, label?, model?}, ...] (every job requires a non-empty task)");
-					if (jobs.length > FOREGROUND_MAX_PARALLEL) throw new Error(`handyman foreground: ${jobs.length} jobs exceed the foreground parallel cap ${FOREGROUND_MAX_PARALLEL} (split into batches, or use mode="background" whose cap is handyman.maxParallel)`);
-					const results = await Promise.all(jobs.map((job) => runForegroundJob(ctx, {
-						task: job.task,
-						...job.label === void 0 ? {} : { label: job.label },
-						model: job.model ?? (typeof args.model === "string" && args.model !== "" ? args.model : hc.defaultModel),
-						models: hc.models,
-						parent: exec.agent,
-						signal: exec.signal
-					})));
-					const done = results.every((r) => r.done);
-					return {
-						mode: "foreground",
-						done,
-						jobs: results,
-						usage: {
-							how: `foreground parallel mode starts ${results.length} child agents at once through the host delegation service (ctx.subagents.start "spawn"), awaits all of them, and returns each child's final text. No loop, no completion-code validation, no progress file. Cap = ${FOREGROUND_MAX_PARALLEL}.`,
-							model: "restricted to the CCC whitelist handyman.models; per-job model overrides the call-level model; default reads handyman.defaultModel",
-							next: done ? "All children completed; use each job's output directly (results are in the same order as the jobs you passed)" : "Some children did not complete — inspect each job's diagnostic/output (results keep the order you passed); for anti-early-finish guarantees use mode=\"background\""
-						}
-					};
-				}
-				if (typeof args.task !== "string" || args.task.trim() === "") throw new Error("handyman foreground: task is required (and must be self-contained — the child does not share this conversation)");
-				const model = typeof args.model === "string" && args.model !== "" ? args.model : hc.defaultModel;
-				const res = await runForegroundJob(ctx, {
-					task: args.task,
-					...typeof args.label === "string" && args.label !== "" ? { label: args.label } : {},
-					model,
+			const hc = readCheapWorkerConfig(root, DEFAULT_SERENITY_CONFIG_PATHS);
+			if (hc === null) throw new Error("cheap-worker requires a model whitelist: configure .opencode/serenity.json \"cheap-worker.models\" (e.g. {\"cheap-worker\": {\"models\": [\"minimax-cn-coding-plan/MiniMax-M3\"], \"defaultModel\": \"minimax-cn-coding-plan/MiniMax-M3\"}})");
+			if (args.jobs !== void 0) {
+				const jobs = parseForegroundJobs(args.jobs);
+				if (jobs === null) throw new Error("cheap-worker: jobs must be [{task, label?}, ...] (every job requires a non-empty task)");
+				if (jobs.length > FOREGROUND_MAX_PARALLEL) throw new Error(`cheap-worker: ${jobs.length} jobs exceed the parallel cap ${FOREGROUND_MAX_PARALLEL} (split into batches)`);
+				const results = await Promise.all(jobs.map((job) => runForegroundJob(ctx, {
+					task: job.task,
+					...job.label === void 0 ? {} : { label: job.label },
+					model: hc.defaultModel,
 					models: hc.models,
 					parent: exec.agent,
 					signal: exec.signal
-				});
+				})));
+				const done = results.every((r) => r.done);
 				return {
-					...res,
+					mode: "foreground",
+					done,
+					jobs: results,
 					usage: {
-						how: "foreground mode starts ONE serial child agent through the host delegation service (ctx.subagents.start \"spawn\") with the CCC-configured model; it awaits the run and returns the child's final text. No loop, no completion-code validation, no progress file.",
-						model: "restricted to the CCC whitelist handyman.models; default reads handyman.defaultModel",
-						next: res.done ? "Child completed; use its output directly" : `Child did not complete (stopReason=${res.stopReason}); inspect diagnostic/output and decide whether to retry, switch model, or use mode="background"`
+						how: `foreground parallel mode starts ${results.length} child agents at once through the host delegation service (ctx.subagents.start "spawn"), awaits all of them, and returns each child's final text. No loop, no completion-code validation, no progress file. Cap = ${FOREGROUND_MAX_PARALLEL}.`,
+						model: "NOT selectable per call — resolved from the CCC config cheap-worker.models (cheap-worker.defaultModel, else models[0])",
+						next: done ? "All children completed; use each job's output directly (results are in the same order as the jobs you passed)" : "Some children did not complete — inspect each job's diagnostic/output (results keep the order you passed)"
 					}
 				};
 			}
-			const jobs = args.jobs !== void 0 ? (() => {
-				const parsed = parseJobs(args.jobs);
-				if (parsed === null) throw new Error("handyman: jobs must be [{task, label, model?}, ...] (every job requires task and label)");
-				return parsed;
-			})() : (() => {
-				if (typeof args.task !== "string" || typeof args.label !== "string") throw new Error("handyman: task and label are required (single-job mode)");
-				return [{
-					task: args.task,
-					label: args.label,
-					...typeof args.model === "string" && args.model !== "" ? { model: args.model } : {}
-				}];
-			})();
-			if (jobs.length === 0) throw new Error("handyman: no jobs provided");
-			if (jobs.length > hc.maxParallel) throw new Error(`handyman: ${jobs.length} jobs exceed maxParallel ${hc.maxParallel} (configure handyman.maxParallel to raise)`);
-			if (jobs.some((j) => !j.task || !j.label)) throw new Error("handyman: every job requires task and label");
-			const parentCtx = exec.agent?.ctx;
-			const parentSession = (exec.agent?.session)?.id;
-			const results = await Promise.all(jobs.map((job) => runHandymanJob(ctx, {
-				root,
-				job,
-				defaultModel: hc.defaultModel,
+			if (typeof args.task !== "string" || args.task.trim() === "") throw new Error("cheap-worker: task is required (and must be self-contained — the child does not share this conversation)");
+			const res = await runForegroundJob(ctx, {
+				task: args.task,
+				...typeof args.label === "string" && args.label !== "" ? { label: args.label } : {},
+				model: hc.defaultModel,
 				models: hc.models,
-				maxRounds: hc.maxRounds,
-				parentSession,
-				parentCtx,
-				session: typeof args.session === "string" ? args.session : void 0
-			})));
+				parent: exec.agent,
+				signal: exec.signal
+			});
 			return {
-				done: results.every((r) => r.done),
-				jobs: results.map((r) => ({ ...r })),
+				...res,
 				usage: {
-					how: "handyman drives each worker agent round by round via an internal hard while-loop; the worker terminates by echoing the random completion code; round cap (default 100, osp fail-safe), automatic restart on abnormal stop (≤100 times); model restricted to the CCC whitelist handyman.models",
-					progress: "Progress in AGENT_SESSIONS/handyman-<label>.md and .json; calling handyman again with the same label resumes from the next round (no redo)",
-					constraints: "handyman workers carry full Serenity constraints (ACC identity / entry-skill system prompt / guards / trajectory-steward); workers include the subagent tool (same-model inheritance) but NOT handyman itself",
-					next: results.every((r) => r.done) ? "All jobs completed; check the progress files to wrap up" : "Some jobs incomplete (max_rounds / restart_exceeded fail-safe); resume with the same labels"
+					how: "foreground mode starts ONE serial child agent through the host delegation service (ctx.subagents.start \"spawn\") with the CCC-configured model; it awaits the run and returns the child's final text. No loop, no completion-code validation, no progress file.",
+					model: "NOT selectable per call — resolved from the CCC config cheap-worker.models (cheap-worker.defaultModel, else models[0])",
+					next: res.done ? "Child completed; use its output directly" : `Child did not complete (stopReason=${res.stopReason}); inspect diagnostic/output and decide whether to retry`
 				}
 			};
 		}
@@ -12032,7 +11562,7 @@ function renderCroSampleSnapshot() {
 /**
 * CRO 编写指南正文（ACC 内置手册；由工具的 guide 动作输出）。
 *
-* 结构照既有 guide 惯例（`MSM_GUIDE` / `handyman(guide=true)`）：
+* 结构照既有 guide 惯例（`MSM_GUIDE` / `cheap-worker(guide=true)`）：
 * 用途 → 位置 → 我给什么 → 你给我什么 → 骨架 → 常见模式 → 坑 → **自测**。
 */
 const CRO_GUIDE = `CRO（Continuous Re-Occurrence · 持续再发生）编写指南
@@ -12559,7 +12089,7 @@ function renderText$2(value) {
 }
 const localstoreTool = defineTool({
 	name: "localstore",
-	description: "ACC standard local credential/config storage: one tool manages two namespaces — credential (credentials) and config (local preferences). Stored in localstore.json at the CCC root (JSON format, directly readable by MSMs). Git policy: .opencode/serenity.json localstore.gitTrack (allow commits / deny commits, default deny; .dsh fallback) — when deny, writes ensure .gitignore contains this file (physical guarantee), container_git commit checks and refuses. Subcommands: list (list keys, credentials never return values) / get <name> (read value) / set <name> <value> (write) / unset <name> (delete) / show <name> (metadata, credentials never print values) / doc (output the storage spec — path/format/key conventions/git policy; agents may operate the file directly with read/write per the spec). Default scope=credential; config requires --scope config (path is section.key, e.g. handyman.models).",
+	description: "ACC standard local credential/config storage: one tool manages two namespaces — credential (credentials) and config (local preferences). Stored in localstore.json at the CCC root (JSON format, directly readable by MSMs). Git policy: .opencode/serenity.json localstore.gitTrack (allow commits / deny commits, default deny; .dsh fallback) — when deny, writes ensure .gitignore contains this file (physical guarantee), container_git commit checks and refuses. Subcommands: list (list keys, credentials never return values) / get <name> (read value) / set <name> <value> (write) / unset <name> (delete) / show <name> (metadata, credentials never print values) / doc (output the storage spec — path/format/key conventions/git policy; agents may operate the file directly with read/write per the spec). Default scope=credential; config requires --scope config (path is section.key, e.g. cheap-worker.models).",
 	parameters: {
 		action: {
 			type: "string",
@@ -12603,7 +12133,7 @@ dsp 只提供机制（双白名单强制 + 基础提示词 + 调试问答页）
 ── 角色配置 schema ──
   { "skiff": { "roles": {
       "<role-name>": {
-        "model": "provider/model",             // 角色模型（CCC 直接指定，无白名单校验；缺省回退 handyman.defaultModel）
+        "model": "provider/model",             // 角色模型（CCC 直接指定，无白名单校验；缺省回退 cheap-worker.defaultModel）
         "msms": ["msm-a", "msm-b"],            // MSM 白名单（独立）：msm 工具只能执行这些；register/deregister 必拒
         "tools": ["read","grep","glob",...],   // 非 MSM 工具白名单（独立）：白名单外工具一律不可用（guard 强制）
         "trajectory": { "session": false, "keeper": false, "rebuild": false },  // 轨迹纪律子集（缺省全关 = 完全独立）
@@ -12636,18 +12166,17 @@ dsp 只提供机制（双白名单强制 + 基础提示词 + 调试问答页）
 
 ── 运行 ──
   调试：设置面板「Serenity」页 Skiff 区块开启 → http://127.0.0.1:<debugPort> 问答页实测
-  ACP 程序化面（v1.26.0）：设置面板「ACP」区块开启 → HTTP JSON-RPC 端点（默认 3100）——
-    POST /  {jsonrpc, id, method, params}
-    session/new {ccc, role, sessionId?}  → 创建/延续会话（sessionId 可选=进程内追问）
-    session/prompt {sessionId, question} → {answer, trajectory}
-    session/cancel / session/close / session/list / request_permission（恒 allow）
+  🔴 外部程序化接入（2026-10-15 起改走官方）：本插件自造的 ACP 面（HTTP JSON-RPC 3100 ／
+    建议问答页）**已整体退役**（owner 裁「砍掉外部问答」）。现在要程序化/远程接入，走宿主
+    自带的官方 ACP server：dsh --profile acp（纯 stdio、零认证）＋ 任一 ACP 客户端
+    （手机端如 Agmente / ACP UI）经隧道接入。详见 S142 的接入指南文档。
   启停 = 人工（设置面板开关，不随插件加载自动启动）；未开启零资源占用
   生效机制：角色配置**实时读取**（改 .opencode/serenity.json → 刷新调试页即生效）；
   改配置后用 container_admin role apply 做显式校验 + 应用确认（绑定 CCC + 角色清单）
   会话追问（v1.25.10）：调试页持有当前会话，追问自动续接（同会话上下文延续）；
   「新对话」按钮开新会话；进程重启后旧会话不可续（WebUI 仍可见历史）
   注意：skill 加载对 skiff **恒可用**（不设白名单——读知识面，无写能力）`;
-/** 校验当前 CCC 的 skiff 配置：roles schema 合法 / msms 均已注册 / model ∈ handyman.models / systemPrompt 非空 */
+/** 校验当前 CCC 的 skiff 配置：roles schema 合法 / msms 均已注册 / model ∈ cheap-worker.models / systemPrompt 非空 */
 function validateSkiffConfig(root) {
 	const roles = readSkiffRoles(root);
 	const issues = [];
@@ -12658,7 +12187,7 @@ function validateSkiffConfig(root) {
 		note: "no skiff roles defined (skiff disabled — zero impact)"
 	};
 	const registered = new Set(loadMsmEntries(root).map((e) => e.name));
-	const hc = readHandymanConfig(root);
+	const hc = readCheapWorkerConfig(root);
 	const allowedModels = hc ? new Set(hc.models) : null;
 	for (const [name, role] of roles) {
 		try {
@@ -12667,7 +12196,7 @@ function validateSkiffConfig(root) {
 			issues.push(`role "${name}": ${String(err?.message ?? err)}`);
 		}
 		for (const m of role.msms ?? []) if (!registered.has(m)) issues.push(`role "${name}": msms "${m}" is not registered in mech-registry.json`);
-		if (role.model && allowedModels && !allowedModels.has(role.model)) issues.push(`role "${name}": model "${role.model}" not in handyman.models (${[...allowedModels].join(", ") || "(none)"})`);
+		if (role.model && allowedModels && !allowedModels.has(role.model)) issues.push(`role "${name}": model "${role.model}" not in cheap-worker.models (${[...allowedModels].join(", ") || "(none)"})`);
 	}
 	return {
 		ok: issues.length === 0,
@@ -12684,7 +12213,7 @@ function listSkiffRoles(root) {
 	};
 	const items = [...roles.entries()].map(([name, role]) => ({
 		name,
-		model: role.model ?? "(handyman default)",
+		model: role.model ?? "(cheap-worker default)",
 		msms: role.msms ?? [],
 		tools: role.tools ?? [],
 		trajectory: {
@@ -12914,7 +12443,7 @@ function createContainerAdminTool(ctx) {
 * 注入文本**自带**"请回复 ABCD" ⇒ 模型**复述指令**即**假完成**（高概率，不是小概率）
 * ⇒ 用**每轮新生成**的 nonce ＋ **包装 ＋ 独占一行**（`[[UNATTENDED-DONE:<hex>]]`），
 * 明写「**旧码作废**」，校验**只认当前轮**（防上下文里的旧码复活）。
-* 先例 = `handyman` background 的 `SERENITY_HANDYMAN_DONE_<16hex>`（同族实现）。
+* 先例 = `cheap-worker` background 的 `SERENITY_CHEAP_WORKER_DONE_<16hex>`（同族实现）。
 */
 /** 完成码包装前缀（**独占一行**才有意义；见文件头"禁用 4 位字母码"） */
 const UNATTENDED_DONE_PREFIX = "[[UNATTENDED-DONE:";
@@ -13021,14 +12550,16 @@ function claimsUserNotification(text) {
 /**
 * **不许开**的会话（设计 §3 的"建议写死"，本版**确实写死**）：
 * `skiff-`（F4 问答 / **微信桥会话也是这个前缀** —— 桥那侧的"用户"是**家人**，
-* 代理替家人说话 = **冒充**）｜ `acp-`（对外程序化面）｜ `handyman-`（自主 worker，已有自己的完成码循环）。
+* 代理替家人说话 = **冒充**）｜ `acp-`（对外程序化面 —— ⚠️ **2026-10-15 起已成死判据**：
+* 该前缀从无生产者且面 E 已退役；理由与"为何保留"见 `output-guard-seam.ts` 文件头）｜
+* `cheap-worker-`（自主 worker，已有自己的完成码循环）。
 *
 * ⚠️ **`rebuild-` 不在排除面**（与 `output-guard-seam.ts` 的取向**刻意不同**）：重建会话是
 * **同一轨迹的载体**（内部维护面），不是对外面；把它排除会让"重建后就没人推了"。
 */
 function isProxyExcludedSessionId(sessionId) {
 	if (typeof sessionId !== "string" || sessionId === "") return true;
-	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("handyman-");
+	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("cheap-worker-");
 }
 /**
 * 一次判定的**唯一入口**（纯函数）。
@@ -14138,7 +13669,7 @@ function createEpochPromotion(promoteEvents, requiredSignals = 1, maxRoundsFallb
 				promoted: true
 			};
 			const loopSid = session.id;
-			if (typeof loopSid === "string" && (loopSid.startsWith("handyman-") || isSkiffSessionId(loopSid))) return {
+			if (typeof loopSid === "string" && (loopSid.startsWith("cheap-worker-") || isSkiffSessionId(loopSid))) return {
 				boundary: -1,
 				promoted: true
 			};
@@ -14242,7 +13773,7 @@ function registerBootstrap(ctx) {
 			const session = agent.session;
 			const depth = session?.header?.delegationDepth ?? 0;
 			const sid = typeof session?.id === "string" ? session.id : void 0;
-			if (sid !== void 0 && (sid.startsWith("handyman-") || isSkiffSessionId(sid))) return;
+			if (sid !== void 0 && (sid.startsWith("cheap-worker-") || isSkiffSessionId(sid))) return;
 			if (depth === 0) {
 				if (hasUserMessageHistory(session)) return;
 			} else if (sid !== void 0 && anchoredSessions.has(sid)) return;
@@ -14783,7 +14314,7 @@ function accIdentityText(root, configPaths = DEFAULT_SERENITY_CONFIG_PATHS, entr
 }
 /**
 * ACC 注入消息（S134 去重）：**只含简短身份锚点**（[ACC] 已激活 + CCC 根 + 约束 + Phase 2）。
-* ⚠️ 原文案含「+ handyman 模型」，该注入已于 2026-09-16 删除（§0e-G）⇒ 此处同步订正（散文级残留）。
+* ⚠️ 原文案含「+ cheap-worker 模型」，该注入已于 2026-09-16 删除（§0e-G）⇒ 此处同步订正（散文级残留）。
 * 完整身份（ACC 5 块 + CCE + Constraints + EAP + SKILL 全文 + Session 块）由**系统提示词层**
 * （systemPrompt.section，每轮 prompt 装配自动注入，含 subagent）承担——对话消息流/压缩重注入
 * 不再重复注入同一内容（token 双倍浪费，见 S134 注入方案梳理）。
@@ -14811,7 +14342,7 @@ function agentScope(agent) {
 * 只有"conversation 根会话"才自动恢复最近激活的宁静号会话——
 * - subagent：session header `origin === 'subagent'`（DSH 路由语义，agent-lookup.ts）
 * - 派生会话：`parentSession` 存在（任何子会话）
-* - handyman 杂工：sessionId 固定 `handyman-` 前缀（tools/handyman.ts 生成）
+* - cheap-worker 杂工：sessionId 固定 `cheap-worker-` 前缀（tools/cheap-worker.ts 生成）
 * 三者都不恢复（避免把主会话激活注入子上下文，违背 v1.16.2 scope 隔离）。
 */
 function shouldAutoRestore(agent) {
@@ -14819,7 +14350,7 @@ function shouldAutoRestore(agent) {
 	if (!session) return false;
 	if (session.header?.origin === "subagent") return false;
 	if (session.header?.parentSession) return false;
-	if (session.id?.startsWith("handyman-")) return false;
+	if (session.id?.startsWith("cheap-worker-")) return false;
 	if (isSkiffSessionId(session.id)) return false;
 	return true;
 }
@@ -14980,7 +14511,7 @@ function registerCompactRetention(ctx, opts = {}) {
 /**
 * status.ts — 状态与安全模式操作（纯逻辑，零 DSH 依赖，可独立单测）
 *
-* WebUI 停靠栏的数据源：ACC 版本 / CCC 根 / safe-mode 状态 / 黑名单 / keeper 阈值 / handyman 模型。
+* WebUI 停靠栏的数据源：ACC 版本 / CCC 根 / safe-mode 状态 / 黑名单 / keeper 阈值 / cheap-worker 模型。
 * setSafeMode 直接读写 .serenity-safe-on 标记（守卫实时读取，写即生效）。
 */
 /** 宿主包名 —— 从运行入口反推包根时的**身份核对**用（见 {@link dshVersionFromEntry}） */
@@ -15065,7 +14596,7 @@ function getStatus(cwd, configPaths = DEFAULT_SERENITY_CONFIG_PATHS) {
 		safeModeOn: false,
 		blacklist: [],
 		threshold: null,
-		handymanModel: null,
+		cheapWorkerModel: null,
 		restrict
 	};
 	const cfg = loadSerenityConfig(root, configPaths);
@@ -15075,7 +14606,7 @@ function getStatus(cwd, configPaths = DEFAULT_SERENITY_CONFIG_PATHS) {
 		safeModeOn: isSafeModeOn(root),
 		blacklist: readBlacklist(root, configPaths),
 		threshold: cfg.sessionKeeper?.threshold ?? null,
-		handymanModel: readHandymanConfig(root, configPaths)?.defaultModel ?? null,
+		cheapWorkerModel: readCheapWorkerConfig(root, configPaths)?.defaultModel ?? null,
 		restrict
 	};
 }
@@ -15090,12 +14621,10 @@ function setSafeMode(root, on) {
 //#endregion
 //#region src/api.ts
 const ROUTE_PATH = "/serenity/status";
-const HANDYMEN_PATH = "/serenity/handymen";
 const UPLOAD_PATH = "/serenity/image-upload";
 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 WEIXIN_PATH = "/serenity/weixin";
 /** 图片落盘目录（CCC 根相对；S142 图片自动识别基础设施——粘贴图片落盘供 agent 经 CCC vlm MSM 自主处理） */
 const IMAGE_UPLOAD_DIR = "_tmp/images_from_user";
@@ -15179,7 +14708,7 @@ function saveFileToTmp(root, fileName, data) {
 	writeFileSync(join(dir, filename), bytes);
 	return `${FILE_UPLOAD_DIR}/${filename}`;
 }
-function readBody$4(req, maxBytes) {
+function readBody$3(req, maxBytes) {
 	return new Promise((resolve, reject) => {
 		let data = "";
 		req.on("data", (chunk) => {
@@ -15193,7 +14722,7 @@ function readBody$4(req, maxBytes) {
 		req.on("error", reject);
 	});
 }
-function sendJson$4(res, code, body) {
+function sendJson$3(res, code, body) {
 	const payload = JSON.stringify(body);
 	res.writeHead(code, {
 		"content-type": "application/json; charset=utf-8",
@@ -15218,7 +14747,7 @@ function senderIsWebUi(req) {
 */
 function requireWebUi(req, res, message) {
 	if (senderIsWebUi(req)) return true;
-	sendJson$4(res, 403, { error: message });
+	sendJson$3(res, 403, { error: message });
 	return false;
 }
 /**
@@ -15245,42 +14774,17 @@ function resolveWorkspace(ctx, params) {
 }
 function registerStatusApi(ctx, opts = {}) {
 	const configPaths = opts.configPaths ?? DEFAULT_SERENITY_CONFIG_PATHS;
-	ctx.webServer.register({
-		kind: "exact",
-		path: HANDYMEN_PATH,
-		handler: async (req, res) => {
-			try {
-				if (req.method !== "GET") {
-					sendJson$4(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);
-				if (!root) {
-					sendJson$4(res, 200, { handymen: [] });
-					return;
-				}
-				sendJson$4(res, 200, { handymen: listActiveHandymen(root) });
-			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
-			}
-		}
-	});
 	ctx.webServer.register({
 		kind: "exact",
 		path: UPLOAD_PATH,
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "POST") {
-					sendJson$4(res, 405, { error: "method not allowed" });
+					sendJson$3(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "图片落盘仅限 WebUI（client 专用）")) return;
-				const raw = await readBody$4(req, 20971520);
+				const raw = await readBody$3(req, 20971520);
 				const body = JSON.parse(raw);
 				const workspace = resolveWorkspace(ctx, {
 					sessionId: body.sessionId,
@@ -15288,12 +14792,12 @@ function registerStatusApi(ctx, opts = {}) {
 				});
 				const root = cccRootForCwd(workspace);
 				if (!root) {
-					sendJson$4(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+					sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 					return;
 				}
-				sendJson$4(res, 200, { path: saveImageToTmp(root, body.mediaType ?? "", body.data ?? "") });
+				sendJson$3(res, 200, { path: saveImageToTmp(root, body.mediaType ?? "", body.data ?? "") });
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15303,11 +14807,11 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "POST") {
-					sendJson$4(res, 405, { error: "method not allowed" });
+					sendJson$3(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "文件落盘仅限 WebUI（client 专用）")) return;
-				const raw = await readBody$4(req, 20971520);
+				const raw = await readBody$3(req, 20971520);
 				const body = JSON.parse(raw);
 				const workspace = resolveWorkspace(ctx, {
 					sessionId: body.sessionId,
@@ -15315,12 +14819,12 @@ function registerStatusApi(ctx, opts = {}) {
 				});
 				const root = cccRootForCwd(workspace);
 				if (!root) {
-					sendJson$4(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+					sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 					return;
 				}
-				sendJson$4(res, 200, { path: saveFileToTmp(root, body.name ?? "", body.data ?? "") });
+				sendJson$3(res, 200, { path: saveFileToTmp(root, body.name ?? "", body.data ?? "") });
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15336,7 +14840,7 @@ function registerStatusApi(ctx, opts = {}) {
 						workspace: url.searchParams.get("workspace") ?? void 0
 					}), configPaths);
 					const runtime = ctx.get("codeRuntime");
-					sendJson$4(res, 200, {
+					sendJson$3(res, 200, {
 						...status,
 						...runtime === void 0 ? { codeRuntime: null } : { codeRuntime: {
 							language: runtime.language,
@@ -15347,7 +14851,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (req.method === "POST") {
 					if (!requireWebUi(req, res, "safe-mode 切换仅限 WebUI（agent 不可自行开关）")) return;
-					const raw = await readBody$4(req, 65536);
+					const raw = await readBody$3(req, 65536);
 					const body = JSON.parse(raw);
 					const workspace = resolveWorkspace(ctx, {
 						sessionId: body.sessionId,
@@ -15355,19 +14859,19 @@ function registerStatusApi(ctx, opts = {}) {
 					});
 					const root = cccRootForCwd(workspace);
 					if (!root) {
-						sendJson$4(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+						sendJson$3(res, 404, { error: `no CCC found from workspace: ${workspace}` });
 						return;
 					}
 					const result = setSafeMode(root, body.on === true);
-					sendJson$4(res, 200, {
+					sendJson$3(res, 200, {
 						...getStatus(workspace, configPaths),
 						...result
 					});
 					return;
 				}
-				sendJson$4(res, 405, { error: "method not allowed" });
+				sendJson$3(res, 405, { error: "method not allowed" });
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15383,24 +14887,24 @@ function registerStatusApi(ctx, opts = {}) {
 					try {
 						known = projectKnownWorkspaces(hostService(ctx, "workspaceRegistry")?.list?.() ?? [], settings.gateway.workspaces);
 					} catch {}
-					sendJson$4(res, 200, {
+					sendJson$3(res, 200, {
 						config: toWire(settings),
 						knownWorkspaces: known
 					});
 					return;
 				}
 				if (req.method === "PUT") {
-					const raw = await readBody$4(req, 131072);
+					const raw = await readBody$3(req, 131072);
 					const saved = applyWirePatch(JSON.parse(raw).config ?? {});
 					try {
 						ctx.emit?.("serenity/config-updated");
 					} catch {}
-					sendJson$4(res, 200, { config: toWire(saved) });
+					sendJson$3(res, 200, { config: toWire(saved) });
 					return;
 				}
-				sendJson$4(res, 405, { error: "method not allowed" });
+				sendJson$3(res, 405, { error: "method not allowed" });
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15410,7 +14914,7 @@ function registerStatusApi(ctx, opts = {}) {
 		handler: async (req, res) => {
 			try {
 				if (req.method !== "GET") {
-					sendJson$4(res, 405, { error: "method not allowed" });
+					sendJson$3(res, 405, { error: "method not allowed" });
 					return;
 				}
 				const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -15419,54 +14923,12 @@ function registerStatusApi(ctx, opts = {}) {
 					workspace: url.searchParams.get("workspace") ?? void 0
 				});
 				const root = cccRootForCwd(workspace) ?? "";
-				sendJson$4(res, 200, { cccs: await listCccs(ctx, {
+				sendJson$3(res, 200, { cccs: await listCccs(ctx, {
 					defaultRoot: root,
 					withRoles: true
 				}) });
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
-			}
-		}
-	});
-	ctx.webServer.register({
-		kind: "exact",
-		path: PUBLIC_ASK_PATH,
-		handler: async (req, res) => {
-			try {
-				if (!requireWebUi(req, res, "仅限 WebUI（key 属敏感凭据）")) return;
-				if (req.method === "PUT") {
-					const raw = await readBody$4(req, 16384);
-					if (JSON.parse(raw).action !== "rotate") {
-						sendJson$4(res, 400, { error: "unsupported action (expected \"rotate\")" });
-						return;
-					}
-					sendJson$4(res, 200, { key: rotatePublicAskKey() });
-					return;
-				}
-				if (req.method !== "GET") {
-					sendJson$4(res, 405, { error: "method not allowed" });
-					return;
-				}
-				const settings = readAdvancedSettings();
-				const { readSimpleSettings } = await import("./settings-section-xHABl8nk.js").then((n) => n.i);
-				const simple = readSimpleSettings();
-				const allowed = settings.publicAsk.allowed;
-				const port = simple.acpHttpPort ?? ACP_HTTP_PORT;
-				const base = `http://127.0.0.1:${port}`;
-				const containerUrls = allowed.map((name) => ({
-					name,
-					url: `${base}/c/${encodeURIComponent(name)}`
-				}));
-				sendJson$4(res, 200, {
-					enabled: simple.publicAskEnabled ?? false,
-					port,
-					key: ensurePublicAskKey(),
-					allowed,
-					urls: containerUrls,
-					listUrl: `${base}/`
-				});
-			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15480,21 +14942,21 @@ function registerStatusApi(ctx, opts = {}) {
 				if (req.method === "GET") {
 					const chk = requireCcc(url.searchParams.get("ccc") ?? void 0);
 					if (!chk.ok) {
-						sendJson$4(res, 400, { error: chk.error });
+						sendJson$3(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
 					const { weixinBridgeStatus } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(chk.root);
 					const bridge = weixinBridgeStatus().find((b) => b.ccc === chk.root);
-					const { readWeixinCredential } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
+					const { readWeixinCredential } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
 					const accounts = (settings.accounts ?? []).map((a) => ({
 						accountId: a.accountId,
 						name: a.name ?? void 0,
 						enabled: a.enabled !== false,
 						bound: readWeixinCredential(chk.root, a.accountId) !== null
 					}));
-					sendJson$4(res, 200, {
+					sendJson$3(res, 200, {
 						enabled: settings.enabled === true,
 						botType: settings.botType ?? void 0,
 						accounts,
@@ -15504,14 +14966,14 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				if (req.method !== "POST") {
-					sendJson$4(res, 405, { error: "method not allowed" });
+					sendJson$3(res, 405, { error: "method not allowed" });
 					return;
 				}
-				const raw = await readBody$4(req, 131072);
+				const raw = await readBody$3(req, 131072);
 				const body = JSON.parse(raw);
 				const chk = requireCcc(body.ccc);
 				if (!chk.ok) {
-					sendJson$4(res, 400, { error: chk.error });
+					sendJson$3(res, 400, { error: chk.error });
 					return;
 				}
 				const root = chk.root;
@@ -15519,7 +14981,7 @@ function registerStatusApi(ctx, opts = {}) {
 					const { fetchQRCode } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
 					const { randomUUID } = await import("node:crypto");
 					for (const [key, v] of weixinLogins) if (Date.now() - v.startedAt > WEIXIN_LOGIN_TTL_MS) weixinLogins.delete(key);
-					const { readWeixinSettings } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -15528,7 +14990,7 @@ function registerStatusApi(ctx, opts = {}) {
 						startedAt: Date.now(),
 						polling: false
 					});
-					sendJson$4(res, 200, {
+					sendJson$3(res, 200, {
 						qrcode: qr.qrcode,
 						qrcode_img_content: qr.qrcode_img_content,
 						loginKey
@@ -15537,40 +14999,40 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "remove-account") {
 					if (!body.accountId) {
-						sendJson$4(res, 400, { error: "missing accountId" });
+						sendJson$3(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
+					const { removeWeixinAccount } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
-					sendJson$4(res, 200, { removed: body.accountId });
+					sendJson$3(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$4(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
+						sendJson$3(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
 						return;
 					}
-					const { saveWeixinRoutes } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
-					const { readSkiffRoles } = await import("./skiff-role-Det66X16.js").then((n) => n.u);
+					const { saveWeixinRoutes } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
+					const { readSkiffRoles } = await import("./skiff-role-B615L9MV.js").then((n) => n.u);
 					const roles = readSkiffRoles(root);
 					for (const r of routes) if (!roles.has(r.role)) {
-						sendJson$4(res, 400, { error: `unknown role: ${r.role} (not in ${root} skiff.roles)` });
+						sendJson$3(res, 400, { error: `unknown role: ${r.role} (not in ${root} skiff.roles)` });
 						return;
 					}
 					saveWeixinRoutes(root, routes);
-					sendJson$4(res, 200, { saved: routes.length });
+					sendJson$3(res, 200, { saved: routes.length });
 					return;
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
-						sendJson$4(res, 400, { error: "启用前请先扫码绑定至少一个账号" });
+						sendJson$3(res, 400, { error: "启用前请先扫码绑定至少一个账号" });
 						return;
 					}
 					setWeixinEnabled(root, enabled);
@@ -15579,12 +15041,12 @@ function registerStatusApi(ctx, opts = {}) {
 						const { stopCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						stopCccBridge(root);
 					}
-					sendJson$4(res, 200, { enabled });
+					sendJson$3(res, 200, { enabled });
 					return;
 				}
-				sendJson$4(res, 400, { error: `unsupported action: ${body.action ?? ""}` });
+				sendJson$3(res, 400, { error: `unsupported action: ${body.action ?? ""}` });
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15595,22 +15057,22 @@ function registerStatusApi(ctx, opts = {}) {
 			try {
 				if (!requireWebUi(req, res, "微信桥配置仅限 WebUI（client 专用）")) return;
 				if (req.method !== "GET") {
-					sendJson$4(res, 405, { error: "method not allowed" });
+					sendJson$3(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$4(res, 404, { error: "login not found or expired" });
+					sendJson$3(res, 404, { error: "login not found or expired" });
 					return;
 				}
 				if (Date.now() - login.startedAt > WEIXIN_LOGIN_TTL_MS) {
 					weixinLogins.delete(key);
-					sendJson$4(res, 200, { status: "expired" });
+					sendJson$3(res, 200, { status: "expired" });
 					return;
 				}
 				const { pollQRStatus } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
-				const { readWeixinSettings } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
+				const { readWeixinSettings } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -15619,13 +15081,13 @@ function registerStatusApi(ctx, opts = {}) {
 				switch (status.status) {
 					case "confirmed": {
 						if (!status.bot_token) {
-							sendJson$4(res, 200, {
+							sendJson$3(res, 200, {
 								status: "error",
 								error: "confirmed but no bot_token"
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-CxCciqQl.js").then((n) => n.u);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-B9gU1YXz.js").then((n) => n.u);
 						const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -15640,7 +15102,7 @@ function registerStatusApi(ctx, opts = {}) {
 						});
 						syncCccBridge(ctx, login.root);
 						weixinLogins.delete(key);
-						sendJson$4(res, 200, {
+						sendJson$3(res, 200, {
 							status: "confirmed",
 							accountId,
 							tokenSaved: true
@@ -15649,14 +15111,14 @@ function registerStatusApi(ctx, opts = {}) {
 					}
 					case "expired":
 						weixinLogins.delete(key);
-						sendJson$4(res, 200, { status: "expired" });
+						sendJson$3(res, 200, { status: "expired" });
 						return;
 					default:
-						sendJson$4(res, 200, { status: status.status ?? "wait" });
+						sendJson$3(res, 200, { status: status.status ?? "wait" });
 						return;
 				}
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15678,7 +15140,7 @@ function registerStatusApi(ctx, opts = {}) {
 				const root = sessionsRootDir();
 				if (req.method === "GET") {
 					const { candidates } = performCleanup(root, cutoffDaysAgo(days), liveIds, { dryRun: true });
-					sendJson$4(res, 200, {
+					sendJson$3(res, 200, {
 						root,
 						olderThanDays: days,
 						dryRun: true,
@@ -15692,12 +15154,12 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				if (req.method !== "POST") {
-					sendJson$4(res, 405, { error: "method not allowed" });
+					sendJson$3(res, 405, { error: "method not allowed" });
 					return;
 				}
 				if (!requireWebUi(req, res, "会话清理仅限 WebUI（client 专用）")) return;
 				const { result } = performCleanup(root, cutoffDaysAgo(days), liveIds);
-				sendJson$4(res, 200, {
+				sendJson$3(res, 200, {
 					root,
 					olderThanDays: days,
 					dryRun: false,
@@ -15705,7 +15167,7 @@ function registerStatusApi(ctx, opts = {}) {
 					errors: result.errors
 				});
 			} catch (err) {
-				sendJson$4(res, 400, { error: err.message ?? String(err) });
+				sendJson$3(res, 400, { error: err.message ?? String(err) });
 			}
 		}
 	});
@@ -15758,7 +15220,7 @@ function loadVoyageHtml(assetPath = voyageAssetPath()) {
 	return readFileSync(assetPath, "utf-8");
 }
 /** 发 JSON（错误分支用；与 api.ts 的 sendJson 同形，但本模块不依赖它，保持零耦合） */
-function sendJson$3(res, status, body) {
+function sendJson$2(res, status, body) {
 	res.statusCode = status;
 	res.setHeader("content-type", "application/json; charset=utf-8");
 	res.end(JSON.stringify(body));
@@ -15773,14 +15235,14 @@ function registerVoyageApi(ctx, opts = {}) {
 		path: VOYAGE_PATH,
 		handler: (req, res) => {
 			if (req.method !== "GET") {
-				sendJson$3(res, 405, { error: "method not allowed" });
+				sendJson$2(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)}` });
+				sendJson$2(res, 500, { error: `voyage asset unavailable: ${err?.message ?? String(err)}` });
 				return;
 			}
 			res.statusCode = 200;
@@ -15989,7 +15451,7 @@ const HOST_SERVICES = [
 			name: "get",
 			kind: "function"
 		}],
-		impact: "skiff/handyman 无法创建或复用 agent",
+		impact: "skiff/cheap-worker 无法创建或复用 agent",
 		required: true
 	},
 	{
@@ -16071,7 +15533,7 @@ const HOST_SERVICES = [
 		name: "agentLoop",
 		access: "injected",
 		members: [],
-		impact: "handyman worker agent 无法装配 preset",
+		impact: "cheap-worker worker agent 无法装配 preset",
 		required: false
 	},
 	{
@@ -16082,7 +15544,7 @@ const HOST_SERVICES = [
 			name: "start",
 			kind: "function"
 		}],
-		impact: "handyman foreground 模式不可用（响亮报错，不影响 background 模式）",
+		impact: "cheap-worker 委派不可用（前台委派的正门，响亮报错）",
 		required: false
 	},
 	{
@@ -16375,14 +15837,16 @@ function summarizeHostContract(report) {
 *
 * ## 现状 → 本模块要收掉什么（取证：`…/acc-c4c5-current-state.md` §①/§③ 3.1）
 *
-* 插件自己 spawn 了**四个** node:http 监听器（B 3081 网关 / C 3082 微信发送 / D 3099 Skiff 调试
-* / E 3100 ACP+问答）。此前四处各写一份同款样板：`createServer` + `server.once('error')` +
+* 插件自己 spawn 了**三个** node:http 监听器（B 3081 网关 / C 3082 微信发送 / D 3099 Skiff 调试）。
+* ⚠️ **2026-10-15 变更**：原为四个（含 **E 3100 ACP+问答**），E 已随 owner「砍掉外部问答」令**整面退役**
+* ⇒ 仍保有面 B/C/D 三个；本段保留"当年是四个"的记述，因为下方"两套拆卸"的病史由它解释。
+* 此前四处各写一份同款样板：`createServer` + `server.once('error')` +
 * `listen(port, host)` + 模块级 `active` 变量 + `close()`；拆卸也分裂成**两套**——
 * `seams/lifecycle.ts` 有一个聚合 disposer，而 `gateway.ts` 与 `weixin-send-api.ts`
 * **各自另注册**一个（D/E 干脆没有自己的 disposer）。
 *
 * 本模块把"listener 生命周期"收成一处：**active 表 + 统一 listen/close + 统一错误与端口占用
-* 处理**。四个面各自只提供 `{ name, port, host, enabled, handler }`。
+* 处理**。各面各自只提供 `{ name, port, host, enabled, handler }`。
 *
 * ## 🔴 共享的是「生命周期与样板」，**绝不是**「路由 / 监听器 / 鉴权」
 *
@@ -16390,12 +15854,12 @@ function summarizeHostContract(report) {
 *   · **A ↔ C 解耦**（`weixin-send-api.ts:4-7`）：3080 会被 3081 原样反代（连请求头），
 *     把 3082 的端点挂到 3080 上 = 已登录的外部家庭账号即可冒充 bot 发消息
 *     ⇒ 本模块**不提供**"把面挂到别的面"的能力，也不共享路由表；
-*   · **E ↔ D** 共用会话核心（acp-core → skiff-core）但各自独立 listener + 独立路由/HTML；
+*   · （原 **E ↔ D** 共用会话核心但各自独立 listener 一条，**随 E 退役删除**）；
 *   · **B 是 A 的代理宿主**（把请求打到 `127.0.0.1:<主端口>`），不是另一个路由面。
 *
 * ## 面 A（3080）不在本模块之列
 * 它是**宿主 DSH 主 WebUI**，插件只往上挂 `/serenity/*` 路由（`ctx.webServer.register`），
-* **插件不起这个 listener** ⇒ 面宿主只持有 B/C/D/E 四个自起面。
+* **插件不起这个 listener** ⇒ 面宿主只持有 B/C/D 三个自起面。
 *
 * ## 两个入口的分工（这是本模块唯一的"抽象决策"，别混）
 *   · {@link startFace} —— **机械启动**：把一个 handler 绑到 `host:port` 上。同名面若已在监听，
@@ -17020,7 +16484,7 @@ function createDshCookieProvider(connection, authority) {
 /** 面名（C4 块 A：listener 生命周期归 `face-host`） */
 const FACE_GATEWAY = "gateway";
 /** 读取请求体（≤ maxBytes；超限 reject） */
-function readBody$3(req, maxBytes) {
+function readBody$2(req, maxBytes) {
 	return new Promise((resolve, reject) => {
 		let data = "";
 		req.on("data", (chunk) => {
@@ -17147,7 +16611,7 @@ async function startGateway(config, getAccounts, getDshCookie) {
 		const session = authed(req);
 		if (session !== void 0) {
 			if (req.method === "POST" && isWorkspaceCreatePath(url.pathname)) {
-				readBody$3(req, 131072).then((body) => {
+				readBody$2(req, 131072).then((body) => {
 					const { rpcId, path } = parseWorkspaceCreateBody(body);
 					if (!allowWorkspaceCreate) {
 						res.writeHead(403, { "content-type": "application/json" });
@@ -19477,7 +18941,7 @@ const SKIFF_DEBUG_HOST = FACE_PORTS.skiffDebug.host ?? "127.0.0.1";
 function skiffDebugActive() {
 	return faceActive(FACE_SKIFF_DEBUG);
 }
-function readBody$2(req) {
+function readBody$1(req) {
 	return new Promise((resolve, reject) => {
 		const chunks = [];
 		req.on("data", (c) => chunks.push(c));
@@ -19485,7 +18949,7 @@ function readBody$2(req) {
 		req.on("error", reject);
 	});
 }
-function sendJson$2(res, status, payload) {
+function sendJson$1(res, status, payload) {
 	const body = JSON.stringify(payload);
 	res.writeHead(status, {
 		"Content-Type": "application/json; charset=utf-8",
@@ -19493,7 +18957,7 @@ function sendJson$2(res, status, payload) {
 	});
 	res.end(body);
 }
-function sendHtml$1(res, html) {
+function sendHtml(res, html) {
 	res.writeHead(200, {
 		"Content-Type": "text/html; charset=utf-8",
 		"Cache-Control": "no-store"
@@ -19690,8 +19154,8 @@ function escapeHtml(s) {
 * 在 JSON **文本层**把它们替换为 `\uXXXX` 转义序列：JSON.parse 后语义完全一致（还原原字符），
 * 且 JSC 正则看到的是常规 ASCII 转义（与 JSON.stringify 对控制字符的输出同形态，安全）。
 *
-* 3100 问答页客户端 `await res.json()`（acp-http.ts）与页面内嵌 JSON（skiff-debug/acp-http）
-* 均需此兼容层——iOS Safari 用户实测"复杂回答"触发。
+* 3099 调试页客户端 `await res.json()` 与页面内嵌 JSON 均需此兼容层
+* ——iOS Safari 用户实测"复杂回答"触发。（原同批还列了 3100 问答页，该面已退役，2026-10-15）
 *
 * @param jsonText JSON.stringify 的输出文本；原地等价替换，返回 JSC 安全文本
 */
@@ -19819,7 +19283,7 @@ function skiffDebugSpec(ctx, root, port, webPort) {
 		port,
 		host: SKIFF_DEBUG_HOST,
 		enabled: () => readSimpleSettings().skiffEnabled,
-		handler: (req, res) => handle$1(ctx, root, webPort, req, res)
+		handler: (req, res) => handle(ctx, root, webPort, req, res)
 	};
 }
 /**
@@ -19843,11 +19307,11 @@ async function startSkiffDebugServer(ctx, root, port, webPort) {
 function stopSkiffDebugServer() {
 	stopFace(FACE_SKIFF_DEBUG);
 }
-async function handle$1(ctx, defaultRoot, webPort, req, res) {
+async function handle(ctx, defaultRoot, webPort, req, res) {
 	try {
 		const url = (req.url ?? "/").split("?")[0] ?? "/";
 		if (req.method === "GET" && url === "/") {
-			sendHtml$1(res, skiffDebugPage(await listCccs(ctx, {
+			sendHtml(res, skiffDebugPage(await listCccs(ctx, {
 				defaultRoot,
 				withRoles: true
 			}), defaultRoot, webPort));
@@ -19856,11 +19320,11 @@ async function handle$1(ctx, defaultRoot, webPort, req, res) {
 		if (req.method === "POST" && url === "/ask") {
 			let body;
 			try {
-				const parsed = JSON.parse(await readBody$2(req));
+				const parsed = JSON.parse(await readBody$1(req));
 				if (parsed === null || typeof parsed !== "object") throw new Error("not an object");
 				body = parsed;
 			} catch {
-				sendJson$2(res, 400, { error: "invalid JSON body" });
+				sendJson$1(res, 400, { error: "invalid JSON body" });
 				return;
 			}
 			const ccc = typeof body.ccc === "string" && body.ccc !== "" ? body.ccc : defaultRoot;
@@ -19869,11 +19333,11 @@ async function handle$1(ctx, defaultRoot, webPort, req, res) {
 			const sessionId = typeof body.sessionId === "string" && body.sessionId !== "" ? body.sessionId : void 0;
 			const role = readSkiffRoles(ccc).get(roleName);
 			if (!roleName || !role) {
-				sendJson$2(res, 400, { error: `unknown role: ${roleName} (ccc: ${ccc})` });
+				sendJson$1(res, 400, { error: `unknown role: ${roleName} (ccc: ${ccc})` });
 				return;
 			}
 			if (!question.trim()) {
-				sendJson$2(res, 400, { error: "empty question" });
+				sendJson$1(res, 400, { error: "empty question" });
 				return;
 			}
 			let agent;
@@ -19882,20 +19346,20 @@ async function handle$1(ctx, defaultRoot, webPort, req, res) {
 				const info = skiffSessionInfo(sessionId);
 				const live = getSkiffAgent(sessionId);
 				if (!info || !live) {
-					sendJson$2(res, 400, { error: "session is not recoverable (process restarted or session unknown) — start a new conversation" });
+					sendJson$1(res, 400, { error: "session is not recoverable (process restarted or session unknown) — start a new conversation" });
 					return;
 				}
 				if (info.role !== roleName || info.ccc !== ccc) {
-					sendJson$2(res, 400, { error: `session "${sessionId}" belongs to role "${info.role}" in another CCC — start a new conversation` });
+					sendJson$1(res, 400, { error: `session "${sessionId}" belongs to role "${info.role}" in another CCC — start a new conversation` });
 					return;
 				}
 				agent = live;
 				continued = true;
 			}
-			const hc = readHandymanConfig(ccc);
+			const hc = readCheapWorkerConfig(ccc);
 			if (!agent) agent = (await createSkiffAgent(ctx, ccc, roleName, role, hc?.defaultModel)).agent;
 			const result = await askSkiff(ctx, agent, question, 0);
-			sendJson$2(res, 200, {
+			sendJson$1(res, 200, {
 				answer: result.answer,
 				answer_html: renderSkiffMarkdown(result.answer),
 				sessionId: result.sessionId,
@@ -19904,9 +19368,9 @@ async function handle$1(ctx, defaultRoot, webPort, req, res) {
 			});
 			return;
 		}
-		sendJson$2(res, 404, { error: "not found" });
+		sendJson$1(res, 404, { error: "not found" });
 	} catch (err) {
-		sendJson$2(res, 500, { error: err?.message ?? String(err) });
+		sendJson$1(res, 500, { error: err?.message ?? String(err) });
 	}
 }
 //#endregion
@@ -20050,7 +19514,9 @@ const rebukeStates = /* @__PURE__ */ new Map();
 //#endregion
 //#region src/output-guard-seam.ts
 /** 外部面会话判定（v1.26.3 用户拍板：仅外部面检测，本地维护会话豁免）：
-*  skiff-（F4 问答）/ acp-（F4c 程序化）/ rebuild-（v1.22.4 重建会话）前缀 */
+*  skiff-（F4 问答）/ rebuild-（v1.22.4 重建会话）前缀。
+*  🔴 `acp-` 分支保留但**已是死判据**（无生产者；面 E 已于 2026-10-15 退役）——
+*  理由与"为何不擅自删"见文件头注释。 */
 function isExternalFaceSession(sessionId) {
 	if (!sessionId) return false;
 	return isSkiffSessionId(sessionId) || sessionId.startsWith("acp-") || sessionId.startsWith("rebuild-");
@@ -20345,760 +19811,6 @@ function registerUnattendedSeam(ctx) {
 	});
 }
 //#endregion
-//#region src/acp-core.ts
-/** JSON-RPC 错误码（对齐标准） */
-const RPC_ERROR = {
-	PARSE: -32700,
-	INVALID_REQUEST: -32600,
-	METHOD_NOT_FOUND: -32601,
-	INVALID_PARAMS: -32602,
-	INTERNAL: -32603
-};
-/**
-* ACP 会话管理器：持有 skiff agent 会话（与 skiff-core 注册表同源——
-* 创建走 createSkiffAgent（自动注册），关闭走 unregisterSkiffSession）。
-* 传输无关：HTTP 端点/企业微信桥/未来 stdio 都调 handle(method, params)。
-*/
-var AcpServer = class {
-	ctx;
-	constructor(ctx) {
-		this.ctx = ctx;
-	}
-	/** 实现级方法调度（返回 result 或抛 JSON-RPC 语义错误） */
-	async handle(method, params) {
-		switch (method) {
-			case "initialize": return this.initialize();
-			case "authenticate": return {};
-			case "session/new": return this.newSession(params);
-			case "session/list": return this.listSessions();
-			case "session/prompt": return this.prompt(params);
-			case "session/cancel": return this.cancel(params);
-			case "session/close": return this.closeSession(params);
-			case "session/request_permission": return { allow: true };
-			default: throw new RpcMethodError(`method not found: ${method}`);
-		}
-	}
-	initialize() {
-		return {
-			protocolVersion: 1,
-			capabilities: {
-				sessionId: true,
-				ccc: true,
-				role: true
-			},
-			serverInfo: {
-				name: "dsh-serenity-hooks-acp",
-				version: "1.26.0"
-			}
-		};
-	}
-	/**
-	* session/new：{ ccc, role, sessionId? } → 创建或延续 skiff 会话。
-	* 无 sessionId → createSkiffAgent（新会话，continued:false）；
-	* 有 → 进程内延续（getSkiffAgent 命中 + role/ccc 绑定校验；未命中 → 错误）。
-	*/
-	async newSession(params) {
-		const ccc = typeof params?.ccc === "string" && params.ccc !== "" ? params.ccc : void 0;
-		const roleName = typeof params?.role === "string" ? params.role : void 0;
-		const sessionId = typeof params?.sessionId === "string" && params.sessionId !== "" ? params.sessionId : void 0;
-		if (!ccc) throw new RpcInvalidParams("session/new requires ccc (CCC root path)");
-		if (!roleName) throw new RpcInvalidParams("session/new requires role");
-		const role = readSkiffRoles(ccc).get(roleName);
-		if (!role) throw new RpcInvalidParams(`unknown role: ${roleName} (ccc: ${ccc})`);
-		if (sessionId) {
-			const info = skiffSessionInfo(sessionId);
-			const live = getSkiffAgent(sessionId);
-			if (!info || !live) throw new RpcInvalidParams("session is not recoverable (process restarted or session unknown) — start a new conversation");
-			if (info.role !== roleName || info.ccc !== ccc) throw new RpcInvalidParams(`session "${sessionId}" belongs to role "${info.role}" in another CCC`);
-			return {
-				sessionId,
-				role: roleName,
-				ccc,
-				continued: true
-			};
-		}
-		const hc = readHandymanConfig(ccc);
-		return {
-			sessionId: (await createSkiffAgent(this.ctx, ccc, roleName, role, hc?.defaultModel)).sessionId,
-			role: roleName,
-			ccc,
-			continued: false
-		};
-	}
-	listSessions() {
-		const sessions = [];
-		for (const [id, b] of skiffSessionSnapshot()) sessions.push({
-			sessionId: id,
-			role: b.role,
-			ccc: b.ccc
-		});
-		return { sessions };
-	}
-	/**
-	* session/prompt：{ sessionId, question } → 答案（**v1.26.10：不返回 trajectory**——
-	* 3100 对外只提供问答，轨迹含工具结果等内部信息；3099 调试页另走 /ask 保留）
-	*/
-	async prompt(params) {
-		const sessionId = typeof params?.sessionId === "string" ? params.sessionId : void 0;
-		const question = typeof params?.question === "string" ? params.question : void 0;
-		if (!sessionId) throw new RpcInvalidParams("session/prompt requires sessionId");
-		if (!question?.trim()) throw new RpcInvalidParams("session/prompt requires question");
-		const agent = getSkiffAgent(sessionId);
-		if (!agent) throw new RpcInvalidParams(`unknown session: ${sessionId} (not recoverable — process restarted?)`);
-		const result = await askSkiff(this.ctx, agent, question, void 0, { includeTrajectory: false });
-		return {
-			answer: result.answer,
-			sessionId: result.sessionId
-		};
-	}
-	/** session/cancel：{ sessionId } → 取消该会话的当前活动（Agent.cancel，宿主 rc.1 契约） */
-	cancel(params) {
-		const sessionId = typeof params?.sessionId === "string" ? params.sessionId : void 0;
-		if (!sessionId) return { cancelled: false };
-		const agent = getSkiffAgent(sessionId);
-		if (!agent) return { cancelled: false };
-		try {
-			agent.cancel({ kind: "user" });
-		} catch {}
-		return { cancelled: true };
-	}
-	/** session/close：{ sessionId } → 释放 agent + 注册表清理（进程内） */
-	closeSession(params) {
-		const sessionId = typeof params?.sessionId === "string" ? params.sessionId : void 0;
-		if (!sessionId) return { closed: false };
-		if (!getSkiffAgent(sessionId)) return { closed: false };
-		unregisterSkiffSession(sessionId);
-		return { closed: true };
-	}
-};
-/** 方法不存在错误（JSON-RPC -32601） */
-var RpcMethodError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "RpcMethodError";
-	}
-};
-/** 参数错误（JSON-RPC -32602） */
-var RpcInvalidParams = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "RpcInvalidParams";
-	}
-};
-/**
-* JSON-RPC 2.0 批处理（单帧）：解析请求/通知 → 调 AcpServer.handle → 响应。
-* 传输无关：acp-http 端点 / 未来 stdio 共用。
-* @returns 响应帧数组（请求有响应；通知无；解析失败 → 单错误响应）
-*/
-async function dispatchRpc(server, frame) {
-	if (frame === null || typeof frame !== "object") return [rpcError(null, RPC_ERROR.INVALID_REQUEST, "invalid request")];
-	const req = frame;
-	if (req.jsonrpc !== "2.0" || typeof req.method !== "string") return [rpcError(req.id ?? null, RPC_ERROR.INVALID_REQUEST, "invalid request")];
-	if (req.id === void 0) {
-		try {
-			await server.handle(req.method, req.params);
-		} catch {}
-		return [];
-	}
-	try {
-		const result = await server.handle(req.method, req.params);
-		return [{
-			jsonrpc: "2.0",
-			id: req.id,
-			result
-		}];
-	} catch (error) {
-		return [rpcError(req.id, rpcCodeOf(error), error instanceof Error ? error.message : String(error))];
-	}
-}
-function rpcCodeOf(error) {
-	if (error instanceof RpcMethodError) return RPC_ERROR.METHOD_NOT_FOUND;
-	if (error instanceof RpcInvalidParams) return RPC_ERROR.INVALID_PARAMS;
-	return RPC_ERROR.INTERNAL;
-}
-function rpcError(id, code, message) {
-	return {
-		jsonrpc: "2.0",
-		id,
-		error: {
-			code,
-			message
-		}
-	};
-}
-//#endregion
-//#region src/acp-http.ts
-/** 面名（C4 块 A） */
-const FACE_ACP_HTTP = "acp-http";
-/** 监听地址：**只绑 loopback**（JSON-RPC 子面无认证——仅靠 loopback；问答页另有 key 认证） */
-const ACP_HTTP_HOST = FACE_PORTS.acpHttp.host ?? "127.0.0.1";
-function acpHttpActive() {
-	return faceActive(FACE_ACP_HTTP);
-}
-function readBody$1(req) {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		req.on("data", (c) => chunks.push(c));
-		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-		req.on("error", reject);
-	});
-}
-function sendJson$1(res, status, payload) {
-	const body = jscSafeJsonText(JSON.stringify(payload));
-	res.writeHead(status, {
-		"Content-Type": "application/json; charset=utf-8",
-		"Cache-Control": "no-store"
-	});
-	res.end(body);
-}
-function sendHtml(res, html) {
-	res.writeHead(200, {
-		"Content-Type": "text/html; charset=utf-8",
-		"Cache-Control": "no-store"
-	});
-	res.end(html);
-}
-/**
-* 本面的规格（C4 块 A/④：**只提供** name/port/host/enabled/handler）。
-* 两个子面（ACP JSON-RPC / 对外问答页）的路由与鉴权仍全部归 {@link handle}——
-* 面宿主不介入面语义，也**不合并** D/E 两面（两者共用会话核心但各有独立 listener/路由/HTML）。
-*/
-function acpHttpSpec(ctx, port, defaultRoot) {
-	return {
-		name: FACE_ACP_HTTP,
-		port,
-		host: ACP_HTTP_HOST,
-		enabled: () => {
-			const s = readSimpleSettings();
-			return s.acpEnabled || s.publicAskEnabled;
-		},
-		handler: (req, res) => handle(ctx, defaultRoot ?? "", req, res)
-	};
-}
-/**
-* 启动 ACP HTTP JSON-RPC + 建议问答页服务（单实例；重复启动幂等返回既有实例）。
-* C4 块 A：listener 的创建/监听/错误/端口占用/关闭归 `face-host`。
-* @param ctx 插件上下文（AcpServer 内部经 skiff-core 创建 agent）
-* @param port 监听端口（仅 127.0.0.1）
-* @param defaultRoot 默认 CCC 根（问答页候选发现兜底；resolveSkiffRoot 传入）
-*/
-async function startAcpHttpServer(ctx, port, defaultRoot) {
-	if (acpHttpActive()) return;
-	const handle = await startFace(acpHttpSpec(ctx, port, defaultRoot));
-	const s = readSimpleSettings();
-	const faces = [];
-	if (s.acpEnabled) faces.push("JSON-RPC");
-	if (s.publicAskEnabled) faces.push("问答页(key 认证)");
-	console.log(`[serenity-hooks] ✓ ACP HTTP: http://127.0.0.1:${handle.port}（${faces.join(" + ") || "未开启任何面"}；session/new 支持 {ccc, role, sessionId?}）`);
-}
-function stopAcpHttpServer() {
-	stopFace(FACE_ACP_HTTP);
-}
-async function handle(ctx, defaultRoot, req, res) {
-	try {
-		const url = (req.url ?? "/").split("?")[0] ?? "/";
-		const s = readSimpleSettings();
-		const ip = req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.socket.remoteAddress || "unknown";
-		if (req.method === "POST" && url === "/") {
-			if (!s.acpEnabled) {
-				sendJson$1(res, 403, { error: "ACP JSON-RPC disabled (enable in Serenity settings)" });
-				return;
-			}
-			let body;
-			try {
-				body = JSON.parse(await readBody$1(req));
-			} catch {
-				sendJson$1(res, 400, [{
-					jsonrpc: "2.0",
-					id: null,
-					error: {
-						code: -32700,
-						message: "parse error"
-					}
-				}]);
-				return;
-			}
-			sendJson$1(res, 200, await dispatchRpc(new AcpServer(ctx), body));
-			return;
-		}
-		if (!s.publicAskEnabled) {
-			if (req.method === "GET" && (url === "/" || url.startsWith("/c/"))) {
-				sendHtml(res, publicAskDisabledHtml());
-				return;
-			}
-			if (req.method === "POST" && (url === "/ask" || url.startsWith("/c/"))) {
-				sendJson$1(res, 403, { error: "public ask disabled (enable in Serenity settings)" });
-				return;
-			}
-			sendJson$1(res, 404, { error: "not found" });
-			return;
-		}
-		const containerAllowed = (name) => {
-			const allowed = readAdvancedSettings().publicAsk.allowed;
-			return allowed.length === 0 || allowed.includes(name);
-		};
-		let cccsCache = null;
-		const cccsOf = async () => {
-			if (cccsCache === null) cccsCache = await listCccs(ctx, {
-				defaultRoot: defaultRoot || (cccRootForCwd(process.cwd()) ?? ""),
-				withRoles: true
-			});
-			return cccsCache;
-		};
-		const cMatch = /^\/c\/([^/]+)$/.exec(url);
-		if (req.method === "GET" && cMatch) {
-			const name = decodeURIComponent(cMatch[1] ?? "");
-			const ccc = (await cccsOf()).find((c) => c.name === name);
-			if (!ccc) {
-				sendHtml(res, publicAskContainerUnknownHtml(name));
-				return;
-			}
-			if (!containerAllowed(name)) {
-				sendHtml(res, publicAskContainerClosedHtml(name));
-				return;
-			}
-			sendHtml(res, publicAskContainerPage(ccc));
-			return;
-		}
-		if (req.method === "GET" && url === "/") {
-			sendHtml(res, publicAskListPage((await cccsOf()).filter((c) => containerAllowed(c.name))));
-			return;
-		}
-		const aMatch = /^\/c\/([^/]+)\/ask$/.exec(url);
-		if (req.method === "POST" && aMatch) {
-			const name = decodeURIComponent(aMatch[1] ?? "");
-			const ccc = (await cccsOf()).find((c) => c.name === name);
-			if (!ccc || !containerAllowed(name)) {
-				sendJson$1(res, 403, { error: `container "${name}" is not open for public ask` });
-				return;
-			}
-			let body;
-			try {
-				const parsed = JSON.parse(await readBody$1(req));
-				if (parsed === null || typeof parsed !== "object") throw new Error("not an object");
-				body = parsed;
-			} catch {
-				sendJson$1(res, 400, { error: "invalid JSON body" });
-				return;
-			}
-			await handleAskParsed(ctx, ccc, body, res, ip);
-			return;
-		}
-		if (req.method === "POST" && url === "/ask") {
-			let body;
-			try {
-				const parsed = JSON.parse(await readBody$1(req));
-				if (parsed === null || typeof parsed !== "object") throw new Error("not an object");
-				body = parsed;
-			} catch {
-				sendJson$1(res, 400, { error: "invalid JSON body" });
-				return;
-			}
-			const cccValue = typeof body.ccc === "string" && body.ccc !== "" ? body.ccc : void 0;
-			const nameValue = typeof body.name === "string" && body.name !== "" ? body.name : void 0;
-			let ccc;
-			if (nameValue) ccc = (await cccsOf()).find((c) => c.name === nameValue);
-			else if (cccValue) {
-				ccc = (await cccsOf()).find((c) => c.root === cccValue);
-				if (!ccc && cccValue !== "") ccc = {
-					root: cccValue,
-					name: cccValue.split("/").filter(Boolean).pop() ?? cccValue,
-					roles: [...readSkiffRoles(cccValue).keys()]
-				};
-			}
-			if (!ccc || !containerAllowed(ccc.name)) {
-				sendJson$1(res, 403, { error: "container is not open for public ask" });
-				return;
-			}
-			await handleAskParsed(ctx, ccc, body, res, ip);
-			return;
-		}
-		sendJson$1(res, 404, { error: "not found" });
-	} catch (err) {
-		sendJson$1(res, 500, { error: err?.message ?? String(err) });
-	}
-}
-/**
-* 单容器问答核心（/c/<name>/ask 与 /ask 共用）：
-* body { key, role?, question, sessionId? } → key 校验（401 + IP 失败锁定）→ 角色缺省取 CCC 第一个
-* → 会话延续（v1.25.10 语义，静默新建）→ askSkiff(0 全量轨迹) → { answer, answer_html, sessionId, continued, trajectory }
-* @param ip 请求来源 IP（v1.26.5 公网 key 失败锁定：X-Forwarded-For 优先——公网反代，回退 remoteAddress）
-*/
-async function handleAskParsed(ctx, ccc, body, res, ip) {
-	const key = typeof body.key === "string" ? body.key : void 0;
-	if (isPublicAskIpLocked(ip)) {
-		sendJson$1(res, 429, { error: "too many failed attempts — temporarily locked (retry later)" });
-		return;
-	}
-	if (!verifyPublicAskKey(key)) {
-		const remaining = recordPublicAskFail(ip);
-		sendJson$1(res, remaining > 0 ? 429 : 401, { error: remaining > 0 ? `too many failed attempts — locked for ${Math.ceil(remaining / 6e4)} min` : "invalid or missing key" });
-		return;
-	}
-	resetPublicAskIpFail(ip);
-	const root = ccc.root;
-	const roleName = typeof body.role === "string" && body.role !== "" ? body.role : void 0;
-	const question = typeof body.question === "string" ? body.question : "";
-	const sessionId = typeof body.sessionId === "string" && body.sessionId !== "" ? body.sessionId : void 0;
-	if (!question.trim()) {
-		sendJson$1(res, 400, { error: "empty question" });
-		return;
-	}
-	const roles = readSkiffRoles(root);
-	const explicit = roleName ? roles.get(roleName) : void 0;
-	const effectiveRole = roleName && explicit ? roleName : roles.keys().next().value;
-	const effectiveCfg = (roleName && explicit ? explicit : effectiveRole ? roles.get(effectiveRole) : void 0) ?? void 0;
-	if (!effectiveRole || !effectiveCfg) {
-		sendJson$1(res, 400, { error: `no skiff role available in ccc: ${root}` });
-		return;
-	}
-	let agent;
-	let continued = false;
-	if (sessionId) {
-		const info = skiffSessionInfo(sessionId);
-		const live = getSkiffAgent(sessionId);
-		if (info && live && info.role === effectiveRole && info.ccc === root) {
-			agent = live;
-			continued = true;
-		}
-	}
-	if (!agent) agent = (await createSkiffAgent(ctx, root, effectiveRole, effectiveCfg, readHandymanConfig(root)?.defaultModel)).agent;
-	const result = await askSkiff(ctx, agent, question, void 0, { includeTrajectory: false });
-	sendJson$1(res, 200, {
-		answer: result.answer,
-		answer_html: renderSkiffMarkdown(result.answer, true),
-		sessionId: result.sessionId,
-		continued
-	});
-}
-/** 问答页未启用提示页 */
-function publicAskDisabledHtml() {
-	return `<!DOCTYPE html>
-<html lang="zh"><head><meta charset="utf-8"><title>Serenity Public Ask</title></head>
-<body style="font-family:system-ui;padding:48px;text-align:center;color:#57606a">
-<h2>Serenity Public Ask</h2>
-<p>问答页未启用（请在 dsh 设置面板「Serenity」页开启「建议问答」）。</p>
-</body></html>`;
-}
-/** 容器不存在提示页（URL 容器名不在已发现 CCC 中） */
-function publicAskContainerUnknownHtml(name) {
-	return `<!DOCTYPE html>
-<html lang="zh"><head><meta charset="utf-8"><title>Serenity Public Ask</title></head>
-<body style="font-family:system-ui;padding:48px;text-align:center;color:#57606a">
-<h2>Serenity Public Ask</h2>
-<p>认知容器「${name}」不存在。</p>
-<p style="font-size:13px"><a href="/" style="color:#0ba875">返回容器列表</a></p>
-</body></html>`;
-}
-/** 容器未开放提示页（白名单外） */
-function publicAskContainerClosedHtml(name) {
-	return `<!DOCTYPE html>
-<html lang="zh"><head><meta charset="utf-8"><title>Serenity Public Ask</title></head>
-<body style="font-family:system-ui;padding:48px;text-align:center;color:#57606a">
-<h2>Serenity Public Ask</h2>
-<p>认知容器「${name}」当前未开放问答（管理员在设置面板「开放容器」中配置）。</p>
-<p style="font-size:13px"><a href="/" style="color:#0ba875">返回容器列表</a></p>
-</body></html>`;
-}
-/** 页面基础样式（列表页 + 单容器页共用；v1.26.4 聊天 UI） */
-const ASK_CSS = `
-  :root { color-scheme: light dark; --sp-green: #0ba875; --sp-green-dim: #059669; }
-  * { box-sizing: border-box; }
-  html, body { height: 100%; }
-  body { font-family: system-ui, -apple-system, sans-serif; margin: 0; background: #f6f7f9; color: #1f2328; }
-  @media (prefers-color-scheme: dark) { body { background: #16181c; color: #e6e6e6; } }
-  main { max-width: 720px; margin: 0 auto; }
-  h1 { font-size: 18px; margin: 0 0 4px; }
-  .sub { opacity: .65; font-size: 13px; margin-bottom: 16px; }
-  .card { background: #fff; border: 1px solid #d0d7de; border-radius: 10px; padding: 14px 16px; margin-bottom: 10px; display: block; text-decoration: none; color: inherit; }
-  @media (prefers-color-scheme: dark) { .card { background: #26282c; border-color: #3a3d42; } }
-  .card:hover { border-color: var(--sp-green); }
-  .card .cname { font-weight: 600; font-size: 15px; }
-  .card .cmeta { opacity: .6; font-size: 12px; margin-top: 2px; }
-  .empty { text-align: center; opacity: .7; padding: 24px 0; }
-  .ccname { font-weight: 600; color: var(--sp-green); }
-  /* key 门（v1.26.6：选容器前必填） */
-  .keyGate { display: flex; align-items: center; gap: 8px; margin-bottom: 14px; background: rgba(127,127,127,.06); border: 1px solid rgba(127,127,127,.18); border-radius: 10px; padding: 10px 14px; }
-  .keyGate label { font-size: 12px; opacity: .7; white-space: nowrap; }
-  .keyGate input { flex: 1; border: 1px solid rgba(127,127,127,.25); border-radius: 8px; background: transparent; color: inherit; padding: 8px 12px; font-size: 14px; }
-  .keyGate input:focus { outline: none; border-color: var(--sp-green); }
-
-  /* ── 聊天布局（v1.26.4 体验升级：参考 ChatGPT/Claude 会话形态）── */
-  .chat { display: flex; flex-direction: column; height: 100vh; max-width: 720px; margin: 0 auto; }
-  .chatHead { display: flex; align-items: center; gap: 10px; padding: 10px 16px; border-bottom: 1px solid rgba(127,127,127,.18); background: rgba(127,127,127,.04); position: sticky; top: 0; z-index: 5; }
-  .chatHead .back { color: var(--sp-green); text-decoration: none; font-size: 13px; white-space: nowrap; }
-  .chatHead .title { font-weight: 600; font-size: 14px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-  .chatHead .spacer { flex: 1; }
-  .chatHead select { border: 1px solid rgba(127,127,127,.25); border-radius: 8px; background: transparent; color: inherit; padding: 4px 8px; font-size: 12px; }
-  .chatHead .newBtn { border: 1px solid rgba(127,127,127,.25); border-radius: 8px; background: transparent; color: inherit; padding: 4px 10px; font-size: 12px; cursor: pointer; white-space: nowrap; }
-  .chatHead .newBtn:hover { border-color: var(--sp-green); color: var(--sp-green); }
-  /* 消息流 */
-  .msgList { flex: 1; overflow-y: auto; padding: 18px 16px; display: flex; flex-direction: column; gap: 16px; }
-  .msg { display: flex; flex-direction: column; max-width: 88%; }
-  .msg.user { align-self: flex-end; align-items: flex-end; }
-  .msg.assistant { align-self: flex-start; align-items: flex-start; }
-  .msg .who { font-size: 11px; opacity: .55; margin-bottom: 4px; padding: 0 4px; }
-  .msg .bubble { padding: 10px 14px; border-radius: 14px; font-size: 14px; line-height: 1.65; word-break: break-word; white-space: normal; }
-  .msg.user .bubble { background: var(--sp-green); color: #fff; border-bottom-right-radius: 4px; }
-  .msg.assistant .bubble { background: #fff; border: 1px solid #d0d7de; border-bottom-left-radius: 4px; }
-  @media (prefers-color-scheme: dark) { .msg.assistant .bubble { background: #26282c; border-color: #3a3d42; } }
-  .bubble p { margin: 6px 0; }
-  .bubble p:first-child { margin-top: 0; }
-  .bubble p:last-child { margin-bottom: 0; }
-  .bubble h1, .bubble h2, .bubble h3, .bubble h4 { margin: 12px 0 6px; font-size: 15px; line-height: 1.4; }
-  .bubble ul, .bubble ol { margin: 6px 0; padding-left: 22px; }
-  .bubble code { background: rgba(127,127,127,.14); border-radius: 4px; padding: 1px 5px; font-size: 13px; font-family: ui-monospace, monospace; }
-  .bubble pre { background: rgba(127,127,127,.1); border-radius: 8px; padding: 10px 12px; overflow-x: auto; margin: 8px 0; }
-  .bubble pre code { background: none; padding: 0; }
-  .bubble blockquote { margin: 6px 0; padding: 2px 12px; border-left: 3px solid rgba(127,127,127,.3); opacity: .85; }
-  .bubble a { color: var(--sp-green); }
-  .bubble table { border-collapse: collapse; margin: 8px 0; }
-  .bubble th, .bubble td { border: 1px solid rgba(127,127,127,.25); padding: 4px 10px; font-size: 13px; }
-  .bubble img { max-width: 100%; border-radius: 8px; }
-  .bubble hr { border: 0; border-top: 1px solid rgba(127,127,127,.2); margin: 10px 0; }
-  .typing { display: inline-flex; align-items: center; gap: 4px; padding: 4px 2px; }
-  .typing i { width: 6px; height: 6px; border-radius: 50%; background: rgba(127,127,127,.5); animation: blink 1.2s infinite; }
-  .typing i:nth-child(2) { animation-delay: .2s; }
-  .typing i:nth-child(3) { animation-delay: .4s; }
-  @keyframes blink { 0%, 80%, 100% { opacity: .3 } 40% { opacity: 1 } }
-  .err { color: #cf222e; white-space: pre-wrap; font-size: 13px; }
-  .msg .err { padding: 0 4px; }
-  /* 输入区 */
-  .chatInput { border-top: 1px solid rgba(127,127,127,.18); padding: 10px 16px calc(12px + env(safe-area-inset-bottom)); background: rgba(127,127,127,.04); }
-  .inputRow { display: flex; align-items: flex-end; gap: 8px; }
-  .inputRow textarea { flex: 1; border: 1px solid rgba(127,127,127,.25); border-radius: 12px; background: #fff; color: inherit; padding: 10px 12px; font-size: 14px; resize: none; min-height: 44px; max-height: 140px; line-height: 1.5; }
-  @media (prefers-color-scheme: dark) { .inputRow textarea { background: #26282c; border-color: #3a3d42; } }
-  .inputRow textarea:focus { outline: none; border-color: var(--sp-green); }
-  .inputRow .sendBtn { border: 0; border-radius: 12px; background: var(--sp-green); color: #fff; padding: 10px 18px; font-size: 14px; font-weight: 600; cursor: pointer; white-space: nowrap; }
-  .inputRow .sendBtn:disabled { opacity: .5; cursor: wait; }
-  .inputRow .sendBtn:hover:not(:disabled) { background: var(--sp-green-dim); }
-  .hint { text-align: center; font-size: 12px; opacity: .55; padding: 20px 0; }
-
-  /* ── 移动端适配（v1.26.6：手机/平板——iOS 防放大 16px / 触控 ≥44px / 100dvh / safe-area）── */
-  @media (max-width: 640px) {
-    main { padding: 20px 16px calc(28px + env(safe-area-inset-bottom)); }
-    .sub { font-size: 14px; margin-bottom: 14px; }
-    .keyGate { flex-wrap: wrap; gap: 6px; }
-    .keyGate input { flex: 1 1 100%; font-size: 16px; padding: 12px 14px; min-height: 48px; } /* 16px 防 iOS 聚焦放大 + 触控 ≥44px */
-    .card { padding: 16px; border-radius: 12px; }
-    .card .cname { font-size: 16px; }
-    .card .cmeta { font-size: 13px; }
-    .chat { height: 100vh; height: 100dvh; } /* dvh：iOS 地址栏收起/展开不跳动 */
-    .chatHead { gap: 8px; padding: 8px 12px calc(8px + env(safe-area-inset-top)); }
-    .chatHead .back { font-size: 14px; padding: 10px 4px; } /* 触控目标 ≥44px */
-    .chatHead .title { font-size: 14px; }
-    .chatHead select { font-size: 16px; padding: 8px 6px; min-height: 44px; } /* 16px 防放大 + 触控 */
-    .chatHead .newBtn { font-size: 14px; padding: 10px 12px; min-height: 44px; }
-    .msgList { padding: 14px 12px calc(20px + env(safe-area-inset-bottom)); gap: 14px; }
-    .msg { max-width: 94%; }
-    .msg .bubble { font-size: 15px; padding: 12px 14px; }
-    .msg .who { font-size: 12px; }
-    .chatInput { padding: 8px 12px calc(10px + env(safe-area-inset-bottom)); }
-    .inputRow textarea { font-size: 16px; padding: 12px 14px; min-height: 48px; } /* 16px 防放大 + 触控 */
-    .inputRow .sendBtn { font-size: 16px; padding: 12px 20px; min-height: 48px; }
-  }
-`;
-/** 容器列表页（v1.26.2 → v1.26.6）：key 在选容器前填写（v1.26.6 用户拍板：不填 key 不让选容器） */
-function publicAskListPage(cccs) {
-	const cards = cccs.map((c) => `
-    <a class="card" data-name="${c.name}" href="/c/${encodeURIComponent(c.name)}">
-      <div class="cname">${c.name}</div>
-      <div class="cmeta">${c.roles.length} 个问答角色 · 点击进入</div>
-    </a>`).join("") || "<div class=\"empty\">暂无可问答的认知容器（管理员尚未开放）</div>";
-	return `<!DOCTYPE html>
-<html lang="zh">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
-<title>Serenity Public Ask</title>
-<style>${ASK_CSS}</style>
-</head>
-<body>
-<main>
-  <h1>Serenity Public Ask</h1>
-  <div class="sub">先填写访问 key，再选择认知容器开始提问</div>
-  <div class="keyGate">
-    <label for="gateKey">访问 Key</label>
-    <input id="gateKey" type="password" placeholder="请输入访问 key（仅本次浏览器记忆）" autocomplete="off" autocapitalize="none" enterkeyhint="done">
-  </div>
-  <div id="cards">${cards}</div>
-</main>
-<script>
-const KEY_STORE = 'serenity-public-ask-key'
-const gateKey = document.getElementById('gateKey')
-const cardList = document.getElementById('cards')
-// 容器卡片（key 未填时禁用——v1.26.6 用户拍板：key 在选容器前填写）
-function applyGate() {
-  const ok = gateKey.value.trim().length > 0
-  for (const card of cardList.querySelectorAll('a.card')) {
-    card.classList.toggle('locked', !ok)
-    card.setAttribute('aria-disabled', ok ? 'false' : 'true')
-    if (!ok) { card.removeAttribute('href'); card.style.pointerEvents = 'none'; card.style.opacity = '.4' }
-    else { card.setAttribute('href', '/c/' + encodeURIComponent(card.dataset.name)); card.style.pointerEvents = ''; card.style.opacity = '' }
-  }
-}
-gateKey.addEventListener('input', () => {
-  // 即存 localStorage（v1.26.7 修复：v1.26.6 漏掉保存——填一次就记录，对话页读取）
-  try { localStorage.setItem(KEY_STORE, gateKey.value.trim()) } catch {}
-  applyGate()
-})
-// key 自动从 localStorage 恢复
-let hasSavedKey = false
-try { const saved = localStorage.getItem(KEY_STORE); if (saved) { gateKey.value = saved; hasSavedKey = true } } catch {}
-if (hasSavedKey) gateKey.placeholder = '访问 Key（已记忆，可修改）'
-applyGate()
-gateKey.focus()
-<\/script>
-</body>
-</html>`;
-}
-/** 单容器问答页（v1.26.2→v1.26.6）：URL 锁定容器；聊天 UI——消息流 + 连续对话 + key 从列表页记忆（v1.26.6 用户拍板：对话页不再填 key） */
-function publicAskContainerPage(ccc) {
-	const data = jscSafeJsonText(JSON.stringify({
-		name: ccc.name,
-		root: ccc.root,
-		roles: ccc.roles
-	}).replace(/</g, "\\u003c"));
-	return `<!DOCTYPE html>
-<html lang="zh">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
-<title>Serenity · ${ccc.name}</title>
-<style>${ASK_CSS}</style>
-</head>
-<body>
-<div class="chat">
-  <div class="chatHead">
-    <a class="back" href="/">← 容器</a>
-    <span class="title">Serenity · <span class="ccname">${ccc.name}</span></span>
-    <span class="spacer"></span>
-    <select id="role" title="问答角色"></select>
-    <button id="newChat" class="newBtn" title="清空当前对话（不存储，刷新即失）">新对话</button>
-  </div>
-
-  <div id="msgs" class="msgList"></div>
-
-  <div class="chatInput">
-    <div class="inputRow">
-      <textarea id="q" placeholder="向 ${ccc.name} 提问…（Enter 发送，Shift+Enter 换行）" rows="1" enterkeyhint="send" autocapitalize="sentences"></textarea>
-      <button id="ask" class="sendBtn">发送</button>
-    </div>
-  </div>
-</div>
-<script id="ask-data" type="application/json">${data}<\/script>
-<script>
-const CCC = JSON.parse(document.getElementById('ask-data').textContent)
-const KEY_STORE = 'serenity-public-ask-key'
-const roleSel = document.getElementById('role')
-const btn = document.getElementById('ask')
-const msgs = document.getElementById('msgs')
-const qInput = document.getElementById('q')
-let sessionId = ''
-let busy = false
-
-// 角色下拉
-roleSel.innerHTML = (CCC.roles || []).map((r) => '<option value="' + r + '">' + r + '</option>').join('') || '<option value="">(无角色)</option>'
-// key 从 localStorage 读取（列表页填写时记忆；对话页不填——v1.26.6 用户拍板）
-function getStoredKey() {
-  try { return (localStorage.getItem(KEY_STORE) || '').trim() } catch { return '' }
-}
-
-/** 追加一条消息气泡（role: user|assistant） */
-function addMsg(role, htmlOrText, isHtml) {
-  const m = document.createElement('div')
-  m.className = 'msg ' + role
-  const who = document.createElement('div')
-  who.className = 'who'
-  who.textContent = role === 'user' ? '你' : CCC.name
-  const bubble = document.createElement('div')
-  bubble.className = 'bubble'
-  if (isHtml) bubble.innerHTML = htmlOrText
-  else bubble.textContent = htmlOrText
-  m.appendChild(who)
-  m.appendChild(bubble)
-  msgs.appendChild(m)
-  msgs.scrollTop = msgs.scrollHeight
-  return bubble
-}
-
-/** 打字指示器（等待回答时显示） */
-function addTyping() {
-  const m = document.createElement('div')
-  m.className = 'msg assistant'
-  const who = document.createElement('div')
-  who.className = 'who'
-  who.textContent = CCC.name
-  const bubble = document.createElement('div')
-  bubble.className = 'bubble'
-  bubble.innerHTML = '<span class="typing"><i></i><i></i><i></i></span>'
-  m.appendChild(who)
-  m.appendChild(bubble)
-  msgs.appendChild(m)
-  msgs.scrollTop = msgs.scrollHeight
-  return bubble
-}
-
-async function ask() {
-  const q = qInput.value.trim()
-  const key = getStoredKey()
-  const role = roleSel.value || undefined
-  if (!q) return
-  if (!key) { addMsg('assistant', '⚠️ 未找到访问 key，请先回到 <a href="/">容器列表页</a> 填写 key。', true); return }
-  if (busy) return
-  // 追加用户消息 + 打字指示
-  addMsg('user', q, false)
-  qInput.value = ''
-  autoGrow()
-  const typing = addTyping()
-  busy = true
-  btn.disabled = true
-  try {
-    const res = await fetch('/c/' + encodeURIComponent(CCC.name) + '/ask', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key, role, question: q, sessionId: sessionId || undefined }) })
-    const data = await res.json()
-    typing.remove() // 移除打字指示，替换为真实回答
-    if (!res.ok) {
-      sessionId = ''
-      addMsg('assistant', '⚠️ ' + (data.error || ('HTTP ' + res.status)), true)
-      return
-    }
-    addMsg('assistant', data.answer_html || data.answer || '（空回答）', true)
-    sessionId = data.sessionId || ''
-  } catch (err) {
-    typing.remove()
-    addMsg('assistant', '⚠️ ' + String(err.message || err), true)
-  } finally {
-    busy = false
-    btn.disabled = false
-    qInput.focus()
-  }
-}
-
-function autoGrow() {
-  qInput.style.height = 'auto'
-  qInput.style.height = Math.min(qInput.scrollHeight, 140) + 'px'
-}
-
-btn.addEventListener('click', () => void ask())
-qInput.addEventListener('keydown', (e) => {
-  if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); void ask() }
-})
-qInput.addEventListener('input', autoGrow)
-// 新对话：重置 sessionId + 清空消息流（前端内存，不存储——刷新即失）
-document.getElementById('newChat').addEventListener('click', () => {
-  sessionId = ''
-  msgs.innerHTML = ''
-  qInput.focus()
-})
-
-// 初始欢迎消息（外层模板求值注入容器名；textContent 渲染防注入）
-addMsg('assistant', '你好，我是「${ccc.name}」的认知助手。有什么可以帮你的？（本对话仅当前页面有效，刷新即失）', false)
-qInput.focus()
-<\/script>
-</body>
-</html>`;
-}
-//#endregion
 //#region src/human-channel.ts
 /**
 * human-channel.ts — 人机信道的**机制层**（机器级；2026-09-26 owner 定案 ⇒ 方案 §2.6）
@@ -21420,7 +20132,7 @@ function buildManualOutputRebuke(session) {
 }
 /**
 * 装配闸门（index.ts apply 调用）。
-* 只对**已登记的手动模式会话**生效——其他会话（主舱/其他 skiff/ACP 临时会话）零干预。
+* 只对**已登记的手动模式会话**生效——其他会话（主舱/其他 skiff 会话）零干预。
 */
 function registerWeixinOutputGuard(ctx) {
 	try {
@@ -21781,7 +20493,7 @@ function manualOutputFallbackNeeded(input) {
 */
 async function resolveCccRootByAlias(ctx, alias) {
 	try {
-		const { listCccs } = await import("./ccc-roots-CDW2dO0n.js").then((n) => n.a);
+		const { listCccs } = await import("./ccc-roots-GIJ3A_tw.js").then((n) => n.a);
 		const entries = await listCccs(ctx);
 		const byName = entries.find((e) => e.name === alias);
 		if (byName) return byName.root;
@@ -21930,7 +20642,7 @@ async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 	try {
 		const sessionId = weixinSessionIdFor(fromUserId);
 		const existing = getSkiffAgent(sessionId);
-		const hc = readHandymanConfig(root);
+		const hc = readCheapWorkerConfig(root);
 		if (existing) try {
 			ensureSkiffSession(root, existing, roleName, role, true);
 		} catch (err) {
@@ -22280,7 +20992,7 @@ function syncHumanChannel(ctx) {
 	(async () => {
 		try {
 			stopMachineLoops();
-			const { listCccs } = await import("./ccc-roots-CDW2dO0n.js").then((n) => n.a);
+			const { listCccs } = await import("./ccc-roots-GIJ3A_tw.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -22516,7 +21228,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-CDW2dO0n.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-GIJ3A_tw.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -22782,7 +21494,7 @@ function registerLifecycle(ctx) {
 			stopAllBridges();
 		} catch {}
 	};
-	registerDisposer(ctx, "self-started resources (gateway/weixin/skiff-debug/acp faces + weixin bridges)", disposeAll);
+	registerDisposer(ctx, "self-started resources (gateway/weixin/skiff-debug faces + weixin bridges)", disposeAll);
 }
 //#endregion
 //#region src/web-fetch-provider.ts
@@ -24984,7 +23696,7 @@ function renderDsl(model) {
 * 🔴 **为什么 PNG 是必需的**：宿主的对话内图片通路**白名单只有光栅格式**
 * （`image/png|jpeg|webp|gif`，见 `dsh-attachment/types.d.ts`）⇒ **SVG 进不去**。
 *
-* 🔴 **开关**：由 `index.ts` 门控（**关时不注册** ⇒ 工具根本不进模型工具清单），同 skiff／acp 口径。
+* 🔴 **开关**：由 `index.ts` 门控（**关时不注册** ⇒ 工具根本不进模型工具清单），同 skiff 口径。
 *
 * ## 🔴 两条**宿主契约**（2026-09-29 现场取证；第 ① 条是本文件第一版写错的地方）
 *
@@ -25358,10 +24070,6 @@ const Config = z.object({
 		enabled: z.boolean().default(false),
 		debugPort: z.number().min(1024).max(65535).default(SKIFF_DEBUG_PORT)
 	}),
-	acp: z.object({
-		enabled: z.boolean().default(false),
-		httpPort: z.number().min(1024).max(65535).default(ACP_HTTP_PORT)
-	}),
 	webFetch: z.object({ enabled: z.boolean().default(true) }),
 	opencodeProvider: z.object({ autoConfigure: z.boolean().default(true) }),
 	visionPatch: z.object({ enabled: z.boolean().default(true) }),
@@ -25376,9 +24084,6 @@ const Config = z.object({
 	rebuildThresholdK: z.number().min(50).max(4e3).volatile(),
 	skiffEnabled: z.boolean().volatile(),
 	skiffDebugPort: z.number().min(1024).max(65535).volatile(),
-	acpEnabled: z.boolean().volatile(),
-	acpHttpPort: z.number().min(1024).max(65535).volatile(),
-	publicAskEnabled: z.boolean().volatile(),
 	croEnabled: z.boolean().volatile(),
 	unattendedEnabled: z.boolean().volatile(),
 	diagramEnabled: z.boolean().volatile()
@@ -25407,7 +24112,7 @@ function apply(ctx, config) {
 		ctx.tools.register(praxisTool);
 		ctx.tools.register(createOntologyTool());
 		ctx.tools.register(createSkillCreatorTool());
-		ctx.tools.register(createHandymanTool(ctx));
+		ctx.tools.register(createCheapWorkerTool(ctx));
 		ctx.tools.register(localstoreTool);
 		ctx.tools.register(createContainerAdminTool(ctx));
 		ctx.tools.register(createImBridgeTool());
@@ -25441,7 +24146,6 @@ function apply(ctx, config) {
 	if (config.opencodeSkills) registerOpencodeSkills(ctx);
 	registerBootstrap(ctx);
 	registerSkiff(ctx);
-	registerAcp(ctx);
 	registerCroTurnTracking(ctx);
 	registerWakeScheduler(ctx);
 	registerWeixinBridge(ctx);
@@ -25465,7 +24169,7 @@ function apply(ctx, config) {
 *   ① 听宿主的**真事件** `settings/document-updated`（ns = 我们那张设置页）——顺带说明为什么不用
 *      我们自己的 `serenity/settings-changed`：那个事件**全仓没有任何 `emit` 点**（只有 `ctx.on` 侧
 *      在用）＝**死通道**，照着它接线等于接了个永远不响的铃；
-*   ② 兜底再挂 `agent/created` ／ `session/created`（与 skiff／acp 同款做法，那两条在实测里确实会 fire）
+*   ② 兜底再挂 `agent/created` ／ `session/created`（与 skiff 同款做法，那两条在实测里确实会 fire）
 *      —— 宿主事件面若换名，至少还有这一条能自愈；
 *   ③ 启动时同步一次（apply 时按当前配置定初始态）。
 * 🔴 **关的时候要注销**（不是"留着但不响应"）：与"关时不注册"同一口径 —— 工具不出现在模型清单里。
@@ -25512,7 +24216,8 @@ function registerDiagramTool(ctx) {
 * 同步一次——此刻通常还没有 live 会话，进程 cwd（服务启动目录）也不在 CCC 内 →
 * `resolveSkiffRoot` 返回 null → 打印一行警告后**永不重试**（实证：重启日志
 * `✗ Skiff 调试服务未启动：无法定位 CCC root`，`ss -ltn` 无 3099；同批 ACP 因容忍
-* `root ?? undefined` 而正常启动）。
+* `root ?? undefined` 而正常启动 —— ⚠️ **该对照已随面 E 退役而失效**（2026-10-15），
+* 但本条记录的**病因与修法不受影响**（Skiff 侧仍是"首次未定位 → 曾永不重试"）。
 *
 * v1.30.14（重启日志实证后的收敛）：**并发启动守卫** + 首次未定位降级为信息级日志。
 *  - 实证（v1.30.13 重启日志）：定时触发与"会话就绪"事件几乎同时到达 → 两次 sync 都
@@ -25636,29 +24341,5 @@ function readWebPort(ctx) {
 		return MAIN_WEB_PORT;
 	}
 }
-/**
-* F4c ACP HTTP + F4d 建议问答页装配（v1.26.x 实验性）：启停 = 人工（设置面板
-* 「Serenity」页 ACP / 问答页开关，settings 持久化）。任一面开启即启动服务
-* （同一端口：POST / = JSON-RPC 需 acpEnabled；GET / + /ask = 问答页需 publicAskEnabled）。
-* 会话创建/延续走 acp-core → skiff-core；仅监听 127.0.0.1；未开启零资源占用。
-*/
-function registerAcp(ctx) {
-	const sync = async () => {
-		const s = readSimpleSettings();
-		const anyFace = s.acpEnabled || s.publicAskEnabled;
-		if (anyFace && !acpHttpActive()) {
-			const root = await resolveSkiffRoot(ctx);
-			return startAcpHttpServer(ctx, s.acpHttpPort, root ?? void 0).catch((err) => {
-				console.error(`[serenity-hooks] ✗ ACP HTTP 服务启动失败: ${String(err?.message ?? err)}`);
-			});
-		} else if (!anyFace && acpHttpActive()) stopAcpHttpServer();
-	};
-	try {
-		ctx.on("serenity/settings-changed", () => {
-			sync();
-		});
-	} catch {}
-	sync();
-}
 //#endregion
 export { Config, apply, humanChannelAccountSchema, humanChannelSubscriptionSchema, inject, name };