@shgroup/dsh-serenity-hooks 1.56.10 → 1.57.0

package/lib/index.js

@@ -1,11 +1,11 @@
 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 { _ 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 { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-BC8mn8iM.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-BcCRsEOh.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 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 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 { 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 { 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";
@@ -1083,14 +1083,14 @@ 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）——面板「外部能力」组
   ⑤ 自主与接入        → 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 +1158,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 +1824,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 +1846,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 +1878,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 +1896,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
 /**
@@ -3446,7 +3326,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)",
@@ -4152,7 +4032,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";
 /**
@@ -4315,8 +4195,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];
@@ -4390,7 +4270,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 +9186,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 工具
+*
+* v1.24.0：loop（牛马）→ handyman（杂工）；2026-10-14：handyman → cheap-worker。
+* 🆕 2026-10-14（owner 令「删除后台运行能力」）：**background 模式整条退场** ——
+*    轮次循环 ／ stop-token 完成码 ／ 进度文件 ／ 重启计数 ／ maxRounds／maxParallel 全部删除。
+*    现存只有**前台委派**一种形态：宿主起子 agent、等它跑完、取回最终文本。
 *
-* 用户需求（S142 拍板）：
-*   - **同步**（用户明确：这个事一般不会异步——工具阻塞到完成）
-*   - **指定模型**（CCC 白名单内——handyman.models，未配置报错）
-*   - **自主循环到完成**（stop-token 唯一完成判据，对齐 osp loop）
-*   - **内部递归同样低能 subagent**（worker 工具面含 subagent，DSH 原生模型继承）
-*   - **workflow 能力**（jobs 编排：主 agent 一次并行多个杂工，maxParallel 默认 10）
-*   - **worker 不含 handyman 本身**（递归编排归主 agent，防无限嵌套）
-*   - **不兼容旧 loop 进度文件**（仅 handyman- 前缀）
+* 机制：走宿主**委派正门** `ctx.subagents.start('spawn', …)`（深度上限、子 agent 所有权、
+* `subagent/start|end` 事件、`dispose()` 收尾全部沿用宿主实现），模型经 `agentOptions` 注入。
+* 前置：`exec.agent` 必须存在（前台委派要有发起方）。
 *
-* 机制：ctx.agents.create()（带 setup 钩子）创建专用 agent（进程内），
-* 每轮 followup → agent/status idle → 读 session.events 响应 → 写进度 → stop token 检查 →
-* 未完成继续下一轮；followup/等待空闲抛错（非正常停止）→ dispose 并重新 create agent
-* （重启计数，≤100），同一轮重试。工厂模式：apply 时闭包捕获插件 ctx（工具 execute 无 ctx 参数）。
+* 🔴 **模型不可由调用方指定**（owner 令）：**没有 `model` 参数**，一律读 CCC 配置
+*    `cheap-worker.models` / `cheap-worker.defaultModel`（单一真相源）。
 *
-* preset 继承 + 工具收窄：setup 钩子里对子 agent 执行 agentPresets.composeFrom（对齐
-* subagent 先例）+ tools.restrict deny handyman（worker 内部看不到 handyman 工具）。
+* 递归防护：子 agent 的工具面 deny `cheap-worker` 本身（编排归主 agent，防无限嵌套）。
 */
 function renderText$4(value) {
 	return [{
@@ -9356,52 +9210,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 +9231,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 +9248,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 +9274,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 +9289,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 +9312,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 +9330,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 +9366,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 +11671,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 +12198,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 +12242,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 },  // 轨迹纪律子集（缺省全关 = 完全独立）
@@ -12647,7 +12286,7 @@ dsp 只提供机制（双白名单强制 + 基础提示词 + 调试问答页）
   会话追问（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 +12297,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 +12306,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 +12323,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 +12553,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 +12660,14 @@ function claimsUserNotification(text) {
 /**
 * **不许开**的会话（设计 §3 的"建议写死"，本版**确实写死**）：
 * `skiff-`（F4 问答 / **微信桥会话也是这个前缀** —— 桥那侧的"用户"是**家人**，
-* 代理替家人说话 = **冒充**）｜ `acp-`（对外程序化面）｜ `handyman-`（自主 worker，已有自己的完成码循环）。
+* 代理替家人说话 = **冒充**）｜ `acp-`（对外程序化面）｜ `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 +13777,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 +13881,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 +14422,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 +14450,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 +14458,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 +14619,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 +14704,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 +14714,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,7 +14729,6 @@ 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";
@@ -15245,31 +14883,6 @@ 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,
@@ -15483,11 +15096,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$4(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,
@@ -15519,7 +15132,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, {
@@ -15540,7 +15153,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$4(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);
@@ -15553,8 +15166,8 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$4(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)` });
@@ -15566,7 +15179,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				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) {
@@ -15610,7 +15223,7 @@ function registerStatusApi(ctx, opts = {}) {
 					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,
@@ -15625,7 +15238,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							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, {
@@ -15989,7 +15602,7 @@ const HOST_SERVICES = [
 			name: "get",
 			kind: "function"
 		}],
-		impact: "skiff/handyman 无法创建或复用 agent",
+		impact: "skiff/cheap-worker 无法创建或复用 agent",
 		required: true
 	},
 	{
@@ -16071,7 +15684,7 @@ const HOST_SERVICES = [
 		name: "agentLoop",
 		access: "injected",
 		members: [],
-		impact: "handyman worker agent 无法装配 preset",
+		impact: "cheap-worker worker agent 无法装配 preset",
 		required: false
 	},
 	{
@@ -16082,7 +15695,7 @@ const HOST_SERVICES = [
 			name: "start",
 			kind: "function"
 		}],
-		impact: "handyman foreground 模式不可用（响亮报错，不影响 background 模式）",
+		impact: "cheap-worker 委派不可用（前台委派的正门，响亮报错）",
 		required: false
 	},
 	{
@@ -19892,7 +19505,7 @@ async function handle$1(ctx, defaultRoot, webPort, req, res) {
 				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, {
@@ -20417,7 +20030,7 @@ var AcpServer = class {
 				continued: true
 			};
 		}
-		const hc = readHandymanConfig(ccc);
+		const hc = readCheapWorkerConfig(ccc);
 		return {
 			sessionId: (await createSkiffAgent(this.ctx, ccc, roleName, role, hc?.defaultModel)).sessionId,
 			role: roleName,
@@ -20762,7 +20375,7 @@ async function handleAskParsed(ctx, ccc, body, res, ip) {
 			continued = true;
 		}
 	}
-	if (!agent) agent = (await createSkiffAgent(ctx, root, effectiveRole, effectiveCfg, readHandymanConfig(root)?.defaultModel)).agent;
+	if (!agent) agent = (await createSkiffAgent(ctx, root, effectiveRole, effectiveCfg, readCheapWorkerConfig(root)?.defaultModel)).agent;
 	const result = await askSkiff(ctx, agent, question, void 0, { includeTrajectory: false });
 	sendJson$1(res, 200, {
 		answer: result.answer,
@@ -21781,7 +21394,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-BC8mn8iM.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 +21543,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 +21893,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-BC8mn8iM.js").then((n) => n.a);
 			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
 		} catch {}
 	})();
@@ -22516,7 +22129,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-BC8mn8iM.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -25407,7 +25020,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());