@shgroup/dsh-serenity-hooks 1.50.0 → 1.51.0

package/lib/index.js

@@ -1,13 +1,14 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+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 { a as findSerenityRoot, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, g as resolveInside, i as findGitRoot, l as pathInside, m as readTrajectorySkills, 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-DG4Oc7I1.js";
-import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-Duk89a-h.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-D72jte0u.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-CWMRa36W.js";
+import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-DtiMVRPo.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-LnJwIqLm.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-7BtOiy4X.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-KqQA6pkr.js";
-import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-EmaYsI-e.js";
-import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-CtFYm53S.js";
+import { 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-DQZ6eR51.js";
+import { a as FACE_PORTS, c as MECHANISM_PORTS, i as ACP_HTTP_PORT, l as SKIFF_DEBUG_PORT, n as registerSettingsSection, o as GATEWAY_PORT, s as MAIN_WEB_PORT, t as readSimpleSettings, u as WEIXIN_SEND_PORT } from "./settings-section-cq0eUSd-.js";
+import { a as markdownToPlainText, c as sendTyping, i as getUpdates, l as sniffImageExt, n as downloadMedia, o as sendFileMessage, r as getConfig, s as sendTextMessage, t as TypingStatus } from "./weixin-api-BrRcPiQs.js";
+import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
@@ -24,6 +25,7 @@ import * as zlib from "node:zlib";
 import { deriveEventMessage } from "@deepseek-ai/dsh-session";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
+import { Resvg, initWasm } from "@resvg/resvg-wasm";
 //#region src/fs-ops.ts
 /**
 * fs-ops.ts — container_fs 纯操作层（cc_fs → container_fs，v1.30；零 DSH 依赖，可独立单测）
@@ -1984,11 +1986,11 @@ const HANDYMAN_GUIDE = `# handyman — Scale-Up Usage Guide (guide)
 ## Two modes (v1.31.3; default = foreground)
 | | foreground (default) | background |
 |---|---|---|
-| What | child agent(s) run the task ONCE and return their final text (jobs=[...] ⇒ parallel, cap 5) | loop-validated worker: hard while-loop + random completion code |
+| 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 5 (fixed)** | yes (jobs=[...], handyman.maxParallel default 10) |
+| 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 |
 
@@ -2027,12 +2029,12 @@ Before calling handyman, load eap (acc-eap skill) and design the "scale-up handy
 
 ### 4. Parallel strategy (both modes)
 - Independent subtasks can run in parallel:
-  · **foreground** — handyman(jobs=[{task,label?,model?},...]) ⇒ fan-out of custom-model subagents, **cap 5**,
+  · **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 5 (fixed)** / background handyman.maxParallel (default 10 — cheap models are cheap)
+- 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
 
@@ -3133,7 +3135,7 @@ function toolsBlock() {
 		"  container_git— git operations (status/commit/push/log)",
 		"  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",
-		"  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 5, per-job model); mode=\"background\" = loop-validated worker (completion code + round cap + restart + progress file), jobs=[] orchestrates parallel work",
+		"  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",
 		"  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)",
 		"",
@@ -4459,16 +4461,18 @@ function parseJobs(raw) {
 	return jobs;
 }
 /**
-* 🔴 **foreground 并行上限 = 5**（owner 2026-09-27 具名令：「handyman foreground 能否允许并行，最大 5；
-* 就当是支持自定模型的 subagent 用了，急需」）。
+* 🔴 **foreground 并行上限 = 10**（owner 2026-09-29 具名令：「这个版本顺手帮我把 handyman 并行度从 5 调整成 10」；
+* 原值 5 出自 owner 2026-09-27 的具名令「最大 5；就当是支持自定模型的 subagent 用了，急需」）。
 *
-* 为什么是**硬编码**而不是又一个配置键：owner 的原话就是"最大 5"（同 `REBUILD-TODO` 那次的裁决口径
-* —— 设定项能不加就不加，见 S142 的「可砍设定项」）。若将来真要调，再按具名令改成配置。
+* 为什么是**硬编码**而不是又一个配置键：owner 两次都是**直接给数**（同 `REBUILD-TODO` 那次的裁决口径
+* —— 设定项能不加就不加，见 S142 的「可砍设定项」）。若将来还要调，仍按具名令改这个常量。
 *
-* 为什么 foreground 也要限流（而不是直接复用 `handyman.maxParallel` = 10）：**foreground 会占住主
-* agent 的这一轮**（调用方在等结果），并发越高越容易把宿主的并发面与用量推上去 ⇒ 前台给一个更紧的闸。
+* 为什么 foreground 仍与 background 分开（后台 = `handyman.maxParallel`，缺省 **10**）：**foreground 会占住
+* 主 agent 的这一轮**（调用方在等结果），并发越高越容易把宿主的并发面与用量推上去。
+* ⚠️ 现在两档**数值相等但语义不同**（前台 = 占住本轮 ／ 后台 = 不占）⇒ **刻意不合并成一个常量**：
+* 合并会让"哪天要给前台单独降档"变成一次语义手术。
 */
-const FOREGROUND_MAX_PARALLEL = 5;
+const FOREGROUND_MAX_PARALLEL = 10;
 /** foreground 的 jobs 解析（与 background 的差别：**label 可选** —— 前台 label 只是显示名，不命名进度文件） */
 function parseForegroundJobs(raw) {
 	if (!Array.isArray(raw) || raw.length === 0) return null;
@@ -4708,11 +4712,11 @@ async function runHandymanJob(ctx, opts) {
 function createHandymanTool(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 5).\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.",
+		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.",
 		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 5) or \"background\" (loop-validated worker with completion-code check, round cap, auto-restart, progress file, parallel jobs)"
+				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",
@@ -4732,7 +4736,7 @@ function createHandymanTool(ctx) {
 			},
 			jobs: {
 				type: "array",
-				description: "Multi-job orchestration (workflow capability): [{task, label?, model?}, ...] — runs jobs in parallel. Cap: foreground 5 (fixed) / background handyman.maxParallel (default 10). Results keep the order you passed them in.",
+				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.",
 				items: {
 					type: "object",
 					properties: {
@@ -9889,12 +9893,64 @@ function registerCompactRetention(ctx, opts = {}) {
 * WebUI 停靠栏的数据源：ACC 版本 / CCC 根 / safe-mode 状态 / 黑名单 / keeper 阈值 / handyman 模型。
 * setSafeMode 直接读写 .serenity-safe-on 标记（守卫实时读取，写即生效）。
 */
+/** 宿主包名 —— 从运行入口反推包根时的**身份核对**用（见 {@link dshVersionFromEntry}） */
+const HOST_PACKAGE_NAME = "@deepseek-ai/dsh";
+/** 上溯层数上限：入口脚本在包内的深度是 `lib/`（1 层）或 `lib/x/y/`（≤3 层）⇒ 6 层足够，且**保证有界** */
+const MAX_ENTRY_ASCENT = 6;
+/**
+* 🔴 **布局无关档**：从**正在跑的那个入口脚本**反推宿主包根，读它的 `version`。
+*
+* 为什么必须补这一档（R↓：一处**静默失效**的实际缺陷；2026-09-28 docker bench 实测）：
+* 下面那条静态候选链（{@link readDshVersion} 的 ②）是**猜安装位置**——`npm_config_prefix` /
+* `APPDATA\npm` / `~/.npm-global`。一旦宿主装在**别处**（典型 = 容器镜像里的
+* `/usr/local/lib/node_modules/@deepseek-ai/dsh`），**三个候选全不中** ⇒ 返回 `null`
+* ⇒ `checkHostVersion(null)` 只给一条 **`required: false`** 的 issue ⇒ 报告 `ok` 仍为 `true`
+* ⇒ **版本门完全静默**（bench 逐字：`host contract degraded (1 optional): host version unknown`）。
+* ⚠️ 这类坏法**比"偶尔报警"更危险**：一条**永远为假**的判据看起来像"没报警 = 没问题"。
+*
+* 而"我们正跑在哪个宿主里"**本来就有直接证据**：`process.argv[1]`（= 启动本进程的那个脚本）。
+* 三条判据要点（每条都对应一个实测过的坑）：
+*  ① **先 `realpath`** —— 全局安装的 `dsh` 是**符号链接**（`/usr/local/bin/dsh` → `…/@deepseek-ai/dsh/lib/bin.js`），
+*     而 Node 的 `argv[1]` **保留调用路径、不解析符号链接** ⇒ 不 realpath 就永远上溯不到包根。
+*  ② **核对包名**（`name === '@deepseek-ai/dsh'`）—— 否则在 vitest / npx 等入口下会误取**别人的**
+*     `package.json`（这是本档**唯一**的假阳性来源）。
+*  ③ **上溯有界**（{@link MAX_ENTRY_ASCENT}）—— 不设界的话，一个不在任何 dsh 包内的入口会一路爬到文件系统根。
+*
+* @param entry `process.argv[1]`（单测直接注入，无需替身）
+*/
+function dshVersionFromEntry(entry) {
+	if (typeof entry !== "string" || entry === "") return null;
+	let dir;
+	try {
+		const real = realpathSync(entry);
+		dir = statSync(real).isDirectory() ? real : dirname(real);
+	} catch {
+		return null;
+	}
+	for (let i = 0; i < MAX_ENTRY_ASCENT; i++) {
+		try {
+			const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+			if (pkg.name === HOST_PACKAGE_NAME && typeof pkg.version === "string") return pkg.version;
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
 /**
 * 读取已安装 DSH CLI 版本；读不到返回 null。
-* 跨平台（Windows 审计问题 13）：Windows npm 全局装在 %APPDATA%\npm（非 ~/.npm-global）——
-* 依次尝试 npm_config_prefix / APPDATA\npm / ~/.npm-global。
+*
+* **两档，顺序有理由**：
+*  ① 🔴 **布局无关档**（{@link dshVersionFromEntry}）= **正在跑的就是它** —— 直接证据优先于"猜安装位置"。
+*  ② **静态候选链**（跨平台历史档，保留）：`npm_config_prefix` ／ `APPDATA\npm` ／ `~/.npm-global`
+*     （Windows npm 全局装在 `%APPDATA%\npm`，见审计问题 13）。
+*     ⚠️ 保留它是因为**本进程不一定是 dsh CLI**（单测、嵌入式、将来别的宿主进程）——
+*     那时"本机装了哪个版本"仍需一个答案，只是证据等级更低。
 */
 function readDshVersion() {
+	const fromEntry = dshVersionFromEntry(process.argv[1]);
+	if (fromEntry !== null) return fromEntry;
 	const candidates = [];
 	if (process.env.npm_config_prefix) candidates.push(join(process.env.npm_config_prefix, "lib", "node_modules", "@deepseek-ai", "dsh"));
 	if (process.env.APPDATA) candidates.push(join(process.env.APPDATA, "npm", "node_modules", "@deepseek-ai", "dsh"));
@@ -10302,7 +10358,7 @@ function registerStatusApi(ctx, opts = {}) {
 					return;
 				}
 				const settings = readAdvancedSettings();
-				const { readSimpleSettings } = await import("./settings-section-EmaYsI-e.js").then((n) => n.r);
+				const { readSimpleSettings } = await import("./settings-section-cq0eUSd-.js").then((n) => n.r);
 				const simple = readSimpleSettings();
 				const allowed = settings.publicAsk.allowed;
 				const port = simple.acpHttpPort ?? ACP_HTTP_PORT;
@@ -10337,11 +10393,11 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$4(res, 400, { error: chk.error });
 						return;
 					}
-					const { readWeixinSettings } = await import("./weixin-route-CWMRa36W.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-7BtOiy4X.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-CWMRa36W.js").then((n) => n.u);
+					const { readWeixinCredential } = await import("./weixin-route-7BtOiy4X.js").then((n) => n.u);
 					const accounts = (settings.accounts ?? []).map((a) => ({
 						accountId: a.accountId,
 						name: a.name ?? void 0,
@@ -10370,10 +10426,10 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				const root = chk.root;
 				if (body.action === "login-start") {
-					const { fetchQRCode } = await import("./weixin-api-CtFYm53S.js").then((n) => n.u);
+					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-CWMRa36W.js").then((n) => n.u);
+					const { readWeixinSettings } = await import("./weixin-route-7BtOiy4X.js").then((n) => n.u);
 					const qr = await fetchQRCode({ botType: readWeixinSettings(root).botType ?? void 0 });
 					const loginKey = randomUUID();
 					weixinLogins.set(loginKey, {
@@ -10394,7 +10450,7 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$4(res, 400, { error: "missing accountId" });
 						return;
 					}
-					const { removeWeixinAccount } = await import("./weixin-route-CWMRa36W.js").then((n) => n.u);
+					const { removeWeixinAccount } = await import("./weixin-route-7BtOiy4X.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					removeWeixinAccount(root, body.accountId);
 					syncCccBridge(ctx, root);
@@ -10407,8 +10463,8 @@ function registerStatusApi(ctx, opts = {}) {
 						sendJson$4(res, 400, { error: "invalid routes (expected [{user, role}, ...])" });
 						return;
 					}
-					const { saveWeixinRoutes } = await import("./weixin-route-CWMRa36W.js").then((n) => n.u);
-					const { readSkiffRoles } = await import("./skiff-role-KqQA6pkr.js").then((n) => n.u);
+					const { saveWeixinRoutes } = await import("./weixin-route-7BtOiy4X.js").then((n) => n.u);
+					const { readSkiffRoles } = await import("./skiff-role-DQZ6eR51.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)` });
@@ -10420,7 +10476,7 @@ function registerStatusApi(ctx, opts = {}) {
 				}
 				if (body.action === "set-enabled") {
 					const enabled = body.enabled === true;
-					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-CWMRa36W.js").then((n) => n.u);
+					const { readWeixinSettings, setWeixinEnabled } = await import("./weixin-route-7BtOiy4X.js").then((n) => n.u);
 					const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 					const settings = readWeixinSettings(root);
 					if (enabled && (settings.accounts ?? []).length === 0) {
@@ -10463,8 +10519,8 @@ function registerStatusApi(ctx, opts = {}) {
 					sendJson$4(res, 200, { status: "expired" });
 					return;
 				}
-				const { pollQRStatus } = await import("./weixin-api-CtFYm53S.js").then((n) => n.u);
-				const { readWeixinSettings } = await import("./weixin-route-CWMRa36W.js").then((n) => n.u);
+				const { pollQRStatus } = await import("./weixin-api-BrRcPiQs.js").then((n) => n.u);
+				const { readWeixinSettings } = await import("./weixin-route-7BtOiy4X.js").then((n) => n.u);
 				const settings = readWeixinSettings(login.root);
 				const status = await pollQRStatus({
 					baseUrl: void 0,
@@ -10479,7 +10535,7 @@ function registerStatusApi(ctx, opts = {}) {
 							});
 							return;
 						}
-						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-CWMRa36W.js").then((n) => n.u);
+						const { upsertWeixinAccount, writeWeixinCredential, nextWeixinAccountId } = await import("./weixin-route-7BtOiy4X.js").then((n) => n.u);
 						const { syncCccBridge } = await Promise.resolve().then(() => weixin_bridge_exports);
 						const accountId = nextWeixinAccountId(settings);
 						upsertWeixinAccount(login.root, {
@@ -10594,12 +10650,12 @@ const VOYAGE_PATH = "/serenity/voyage";
 */
 const VOYAGE_ASSET = "assets/serenity-voyage.html";
 /** 包根 = 本模块所在目录的上一级（构建产物在 `lib/`，与 `assets/` 同级；同 constants.ts 定位法） */
-function packageRootPath() {
+function packageRootPath$1() {
 	return join(dirname(fileURLToPath(import.meta.url)), "..");
 }
 /** 资产绝对路径（导出以便测试与 pack-check 共用同一判据来源） */
 function voyageAssetPath() {
-	return join(packageRootPath(), VOYAGE_ASSET);
+	return join(packageRootPath$1(), VOYAGE_ASSET);
 }
 /** 缓存（830 KB，避免每次展开卡片都读盘；进程内只读一次） */
 let cachedHtml = null;
@@ -11017,12 +11073,43 @@ const HOST_SERVICES = [
 		required: false
 	}
 ];
-/** dsp 被验证过的宿主版本范围（与 package.json peerDependencies 同源，单一真相源） */
-const REQUIRED_HOST_RANGE = "^0.1.7-rc.1";
-/** 范围 floor：剥掉 caret/比较前缀（`^0.1.7-rc.1` → `0.1.7-rc.1`），供 {@link checkHostVersion} 使用 */
-const REQUIRED_HOST_FLOOR = REQUIRED_HOST_RANGE.replace(/^[\^~>=<\s]+/, "");
-/** 范围 ceiling：`^0.1.x` 的上界 = `<0.2.0`（显式常量，见 {@link checkHostVersion} 注释） */
-const REQUIRED_HOST_CEILING = "0.2.0";
+/**
+* dsp **被验证过的宿主版本档**（单一真相源）—— 每档 = 一个半开区间 `[floor, ceiling)`。
+*
+* 🔴 为什么是"档"而不是一条 caret 范围（R↓：2026-09-28 0.2.0-rc.1 适配轮实测得出）：
+*  - **宿主门的判据是真 semver**（`@deepseek-ai/dsh-app-boot:evaluatePluginCompatibility`
+*    = `semver.satisfies(runtime, range, { includePrerelease: true })`）⇒ **它支持 `||` 联合范围**；
+*  - 而 **dsp 这边是手写比较器**（{@link compareSemver}），**不实现 semver 的 range 语义**：
+*    旧写法"用正则从 `REQUIRED_HOST_RANGE` 剥前缀取 floor"在**联合范围上会取到垃圾**
+*    （`^0.1.7-rc.1 || ^0.2.0-rc.1` 的预发布捕获组 `(.*)` 会**吞掉 `||` 之后整段**）
+*    ⇒ 判定**变瞎**（既非"通过"也非"低于下限"，而是不可解释的值）。
+*  ⇒ 故**档表是唯一被验证的真相**：`REQUIRED_HOST_RANGE`（给宿主门看的串）与
+*    `checkHostVersion`（给自己的手写比较器）**都从它派生**，两者不可能互相漂移。
+*
+* 🔴 两档的由来（**实测，非推断**；判据表见插件仓 `docs/dsh-0.2.0-rc.1-adaptation-plan.md` §7.4）：
+*  - `^0.1.7-rc.1` 在 `0.2.0-rc.1` 上被宿主**整包拒绝 ＋ 回滚**
+*    （逐字 `installation rejected: … incompatible with dsh 0.2.0-rc.1` ＋ `restored package.json, …`）；
+*  - 单档 `^0.2.0-rc.1` 会**同样硬拒本机正在跑的 `0.1.7-rc.2`**
+*    ⇒ 发布后 deploy 必须先升宿主，**而升级会打断本容器**；
+*  - ⇒ 双档是**唯一不把本机宿主堵死的写法**（两档在真 semver 下均 PASS）。
+* 档上界取 `<0.2.0` / `<0.3.0`（即 `^0.2.0-rc.1` 的 caret 上界）：第二档同时覆盖
+* `0.2.0` 正式版与后续 `0.2.0-rc.N`。
+*/
+const VERIFIED_HOST_BANDS = [{
+	floor: "0.1.7-rc.1",
+	ceiling: "0.2.0"
+}, {
+	floor: "0.2.0-rc.1",
+	ceiling: "0.3.0"
+}];
+/**
+* 与 `package.json` 的 `peerDependencies` **逐字同串**的宿主版本范围（由 {@link VERIFIED_HOST_BANDS} 派生）。
+*
+* 🔴 这个字符串**就是**宿主门（`evaluatePluginCompatibility`）拿去跑 `semver.satisfies` 的那个串
+* ⇒ 它与档表**必须一致**（"声明 union、判定单档"是一种自相矛盾）。
+* 一致性由 `tests/host-contract.test.ts` 的**跨文件对账用例**钉住（读 package.json 逐字比对）。
+*/
+const REQUIRED_HOST_RANGE = VERIFIED_HOST_BANDS.map((b) => `^${b.floor}`).join(" || ");
 /** 最小 semver 比较（无依赖）：返回 -1 / 0 / 1；解析失败返回 null */
 function compareSemver(a, b) {
 	const parse = (v) => {
@@ -11047,37 +11134,54 @@ function compareSemver(a, b) {
 	return ra < rb ? -1 : 1;
 }
 /**
-* 宿主版本是否落在 dsp 被验证的范围（`REQUIRED_HOST_RANGE`）。
+* 宿主版本是否落在 dsp **被验证过的档**（{@link VERIFIED_HOST_BANDS}）之内。
 * 无版本信息 → 视为未知（ok=false，detail 说明），不猜测。
 *
-* floor/ceiling **从 `REQUIRED_HOST_RANGE` 派生**（v1.31.6，0.1.5-rc.1 适配轮）：
-* 此前 floor 是独立硬编码字面量——改 `REQUIRED_HOST_RANGE` 而忘改 floor 会造出
-* "常量说 0.1.5、判定用 0.1.2" 的双真相源。ceiling 无法从 caret 语义机械派生（手写比较器
-* 不实现 semver 的 caret 规则），故保留显式常量并在此声明其含义。
+* 🔴 **逐档判**（v1.50.x，0.2.0-rc.1 适配轮）：判据 = "∃ 档：`version >= floor ∧ version < ceiling`"。
+* 曾经的做法是"从 `REQUIRED_HOST_RANGE` 剥前缀取一个 floor ＋ 一个显式 ceiling"——
+* **单档假设一旦不成立（改联合范围），那个正则就会取到垃圾**（详见 {@link VERIFIED_HOST_BANDS}
+* 的注释）⇒ 故本函数**只读档表**，不再从范围串反推。
+* ⚠️ 手写比较器**不实现 semver 的 range 语义**（本条只做"区间内/外"），这也是必须逐档判的原因。
 */
 function checkHostVersion(version) {
 	if (version === null) return {
 		ok: false,
 		detail: `host version unknown (required ${REQUIRED_HOST_RANGE})`
 	};
-	const floor = compareSemver(version, REQUIRED_HOST_FLOOR);
-	const ceiling = compareSemver(version, REQUIRED_HOST_CEILING);
-	if (floor === null || ceiling === null) return {
+	let matched = false;
+	let belowEveryFloor = true;
+	let unparseable = false;
+	for (const band of VERIFIED_HOST_BANDS) {
+		const floor = compareSemver(version, band.floor);
+		const ceiling = compareSemver(version, band.ceiling);
+		if (floor === null || ceiling === null) {
+			unparseable = true;
+			break;
+		}
+		if (floor >= 0) {
+			belowEveryFloor = false;
+			if (ceiling < 0) {
+				matched = true;
+				break;
+			}
+		}
+	}
+	if (unparseable) return {
 		ok: false,
 		detail: `host version "${version}" not parseable (required ${REQUIRED_HOST_RANGE})`
 	};
-	if (floor < 0) return {
+	if (matched) return {
+		ok: true,
+		detail: `host ${version} within ${REQUIRED_HOST_RANGE}`
+	};
+	if (belowEveryFloor) return {
 		ok: false,
 		detail: `host ${version} is below the verified floor (required ${REQUIRED_HOST_RANGE})`
 	};
-	if (ceiling >= 0) return {
+	return {
 		ok: false,
 		detail: `host ${version} is outside the verified range (required ${REQUIRED_HOST_RANGE})`
 	};
-	return {
-		ok: true,
-		detail: `host ${version} within ${REQUIRED_HOST_RANGE}`
-	};
 }
 /** 结构化读取宿主服务（lazy → ctx.get；injected → 直接属性，属性缺失再试 ctx.get） */
 function readService(ctx, name, access) {
@@ -15923,8 +16027,13 @@ qInput.focus()
 * `ccc:<root>|<accountId>`（那时身份里带了 root ⇒ 跨 CCC 不可能撞车，也就不会误判成"同一账号"）。
 *
 * ## 边界
-* 本模块**只做归属判定**（谁能起、谁被谁占着），**不碰**：轮询循环、凭据解析、路由投递。
-* 那些留在 `weixin-bridge.ts`（渠道实现）—— 归属是机制，实现是渠道。
+* 本模块做三件事（**都属机制**，与"哪个渠道"无关）：
+*  ① **归属判定**（P0-2：谁能起 poller、谁被谁占着）—— 见下 §归属判定
+*  ② **订阅表查询 ＋ 入站路由决策**（P0-3：`(账号, 用户) → (CCC, 角色)`）—— 见 §订阅表
+*  ③ **机器级留痕**（P0-3：未投递 ／ 目标不存在 ／ 表残缺）—— 见 §留痕。
+*     🔴 为什么这些必须机器级：它们**没有目标 CCC** ⇒ 落进任何 CCC 都是"编一个"目标。
+* **不碰**：轮询循环、凭据解析、会话投递 —— 那些是**渠道实现**，留在 `weixin-bridge.ts`。
+* ⇒ 本模块**零 DSH 依赖**（只有 `node:crypto` ／ `node:fs`），可独立单测。
 */
 /**
 * 算账号的**机器级身份**。
@@ -16018,6 +16127,135 @@ function releasePollersOf(root) {
 function releaseAllPollers() {
 	owners.clear();
 }
+/** 订阅行的四个字段（顺序即报错里的字段顺序） */
+const SUBSCRIPTION_FIELDS = [
+	"account",
+	"user",
+	"ccc",
+	"role"
+];
+/**
+* 订阅表查询（**纯函数**）。
+*
+* 匹配两段式（**刻意对齐**旧 `matchWeixinRoute` 的 exact → `*` 兜底）：
+*  ① `account` **精确** ∧ `user` **精确**
+*  ② `account` **精确** ∧ `user === '*'`（通配兜底）
+* 🔴 `account` **不设通配**：它是机器级账号的**显式身份**（表里写的就是账号 id）；
+*   给账号也开 `*` 会让"这条订阅到底覆盖哪个 bot"变得不可读。
+* 🔴 `user` 保留 `*`：这是**有意的**——存量 CCC 级 `routes` 用的就是 `{user:'*'}`，
+*   迁移（P0-4）要能**逐字平移**它，否则"迁移"会悄悄改变行为。
+*
+* @param subscriptions 机器级订阅表（`readSimpleSettings().humanChannel.subscriptions`）
+* @param account 收到的**账号 id**（poller 身份；不是 token）
+* @param user 发信人 id
+*/
+function lookupSubscription(subscriptions, account, user) {
+	const defects = [];
+	const usable = [];
+	subscriptions.forEach((row, index) => {
+		const raw = {
+			account: row?.account,
+			user: row?.user,
+			ccc: row?.ccc,
+			role: row?.role
+		};
+		const present = {};
+		const missing = [];
+		for (const field of SUBSCRIPTION_FIELDS) {
+			const v = raw[field];
+			if (typeof v === "string" && v.trim() !== "") present[field] = v.trim();
+			else missing.push(field);
+		}
+		if (missing.length > 0) {
+			defects.push({
+				index,
+				missing,
+				present
+			});
+			return;
+		}
+		usable.push({
+			account: present.account,
+			user: present.user,
+			ccc: present.ccc,
+			role: present.role
+		});
+	});
+	return {
+		hit: usable.find((r) => r.account === account && r.user === user) ?? usable.find((r) => r.account === account && r.user === "*") ?? null,
+		defects,
+		usable: usable.length
+	};
+}
+/**
+* 入站路由决策（**纯函数**）。
+*
+* 顺序：**机器级订阅表优先** → 未命中时用 CCC 级回退。
+*
+* 🔴 **回退是过渡期的"不打断在用的微信"**（方案 §11.3 **Q5**）：机器级账号表为空时，
+* 桥仍按 CCC 起、路由也仍认 CCC 级 `routes`。机器级一旦配起来，回退传 `null`
+* ⇒ **未命中 = 不投递**（不是"投给默认角色"——那正是方案 §3.1 明令禁止的）。
+* @param input.subscriptions 机器级订阅表
+* @param input.account 收到的账号 id
+* @param input.user 发信人 id
+* @param input.fallback CCC 级回退目标（`{ccc, role}`）；无 ⇒ `null` ／ 省略
+*/
+function planInboundRoute(input) {
+	const { hit, defects } = lookupSubscription(input.subscriptions, input.account, input.user);
+	if (hit) return {
+		target: {
+			ccc: hit.ccc,
+			role: hit.role
+		},
+		source: "machine",
+		skipReason: null,
+		defects
+	};
+	if (input.fallback) return {
+		target: {
+			ccc: input.fallback.ccc,
+			role: input.fallback.role
+		},
+		source: "ccc-fallback",
+		skipReason: null,
+		defects
+	};
+	return {
+		target: null,
+		source: null,
+		skipReason: input.subscriptions.length === 0 ? "no-subscription" : "no-match",
+		defects
+	};
+}
+/**
+* 留痕落点：`$DSH_HOME/human-channel-audit.jsonl`（缺省 `~/.dsh/human-channel-audit.jsonl`）。
+*
+* 🔴 **为什么是机器级而不是某个 CCC 的 `_weixin-logs/`**：本文件记的事件（未投递 ／
+* 目标不存在 ／ 表残缺）**恰恰是"没有目标 CCC"的那些** —— 落进任何一个 CCC 都是**编一个**目标。
+* （投递成功的入站事件仍落**被路由到的那个 CCC** 的 `_weixin-logs/`，方案 §3.6 不变。）
+* env `SERENITY_HUMAN_CHANNEL_AUDIT` 覆盖（测试注入；与 `SERENITY_HOOKS_CONFIG` 同款推导）。
+*/
+function humanChannelAuditPath() {
+	const override = process.env.SERENITY_HUMAN_CHANNEL_AUDIT;
+	if (override && override !== "") return override;
+	const dshHome = process.env.DSH_HOME ?? join(process.env.HOME ?? "", ".dsh");
+	return join(dshHome, "human-channel-audit.jsonl");
+}
+/**
+* 追加一条留痕。**永不抛** ——
+* 留痕失败绝不能反过来打断投递（它是**旁路**，与 `invokeWeixinHook` 的"旁路容忍"同款）。
+* 🔴 **不静默的是它记的那件事**，不是它自己：所以调用方仍要**另行 `console` 出声**。
+*/
+function appendHumanChannelAudit(event) {
+	try {
+		const path = humanChannelAuditPath();
+		mkdirSync(dirname(path), { recursive: true });
+		appendFileSync(path, `${JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			...event
+		})}\n`, "utf-8");
+	} catch {}
+}
 const manualSessions = /* @__PURE__ */ new Map();
 /**
 * 本轮是否已成功发送（**由桥在每轮开始时清空** `clearSentThisTurn`；闸门只置位不清空——
@@ -16306,6 +16544,7 @@ function invokeWeixinHook(root, hookRel, event) {
 //#region src/weixin-bridge.ts
 var weixin_bridge_exports = /* @__PURE__ */ __exportAll({
 	handleIncoming: () => handleIncoming,
+	handleMachineIncoming: () => handleMachineIncoming,
 	manualOutputFallbackNeeded: () => manualOutputFallbackNeeded,
 	registerWeixinBridge: () => registerWeixinBridge,
 	resolveWeixinAccount: () => resolveWeixinAccount,
@@ -16313,9 +16552,21 @@ var weixin_bridge_exports = /* @__PURE__ */ __exportAll({
 	stopAllBridges: () => stopAllBridges,
 	stopCccBridge: () => stopCccBridge,
 	syncCccBridge: () => syncCccBridge,
+	syncHumanChannel: () => syncHumanChannel,
 	weixinBridgeStatus: () => weixinBridgeStatus
 });
 const bridges = /* @__PURE__ */ new Map();
+/**
+* 🔴 **机器级 poller 的"根"哨兵**（P0-3 A）—— 它**不是一个目录**。
+*
+* 机器级 poller **不属于任何 CCC**（这正是"上移 ACC 层"的含义：谁轮询不再由 CCC 数量决定）。
+* 用途有二：① `runAccountLoop` 的 `root` 形参在机器级模式下不被使用，传它以示"无根"；
+* ② 归属表（`human-channel.ts`）按 root 区分拥有者 ⇒ 机器级用这个哨兵值，
+*    与任何**真实** CCC 根都不会撞（真根一律是绝对路径）。
+*/
+const MACHINE_SCOPE = "<machine>";
+/** 机器级 poller（账号 id → 循环）。与 `bridges` **互斥**：同一时刻只有一种模式在跑。 */
+const machineLoops = /* @__PURE__ */ new Map();
 /** 轮询间隔（getupdates 失败后重试延迟；成功 = 立即续轮询） */
 const POLL_RETRY_MS = 3e3;
 /** 媒体大小上限（M6：20MB，对齐 vlm-describe；超限降级告知不落盘） */
@@ -16369,7 +16620,7 @@ async function sendTypingStop(cred, accountId, fromUserId) {
 	}
 }
 /** 单账号轮询循环：getupdates 长轮询 → 逐消息分发 → 回复回写 */
-async function runAccountLoop(ctx, root, accountId, cred, loop) {
+async function runAccountLoop(ctx, root, accountId, cred, loop, machine = false) {
 	let buf = "";
 	while (!loop.stopped) {
 		loop.lastPollAt = Date.now();
@@ -16384,7 +16635,8 @@ async function runAccountLoop(ctx, root, accountId, cred, loop) {
 			for (const msg of resp.msgs ?? []) {
 				if (loop.stopped) break;
 				if (msg.message_type !== 1) continue;
-				await handleIncoming(ctx, root, accountId, cred, msg);
+				if (machine) await handleMachineIncoming(ctx, accountId, cred, msg);
+				else await handleIncoming(ctx, root, accountId, cred, msg);
 			}
 		} catch (err) {
 			loop.lastError = err instanceof Error ? err.message : String(err);
@@ -16427,6 +16679,106 @@ function manualOutputFallbackNeeded(input) {
 	return input.fallbackOnNoSend === true && input.guardActive && !input.sentThisTurn && input.answer !== "";
 }
 /**
+* 订阅表里的 `ccc` **别名 → CCC 根**（P0-3）。
+*
+* 别名取值与面板下拉**同源**（方案 §2.3：`listCccs({withRoles:true})` 的下拉）⇒
+* 先按 **`CccEntry.name`**（= CCC 根目录名，`basename(root)`）匹配；再退一步接受**绝对路径**
+* （手写配置时人会直接粘路径）。两条都试 ⇒ 两种写法都可用，且**不引入第二张名字表**。
+* @returns 命中的 CCC 根；枚举里没有 ⇒ `null`（调用方**响亮报错**，不静默丢弃）
+*/
+async function resolveCccRootByAlias(ctx, alias) {
+	try {
+		const { listCccs } = await import("./ccc-roots-DtiMVRPo.js").then((n) => n.a);
+		const entries = await listCccs(ctx);
+		const byName = entries.find((e) => e.name === alias);
+		if (byName) return byName.root;
+		const byRoot = entries.find((e) => e.root === alias);
+		return byRoot ? byRoot.root : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* **入站路由的单一解析处**（P0-3）：机器级订阅表优先 → CCC 级回退；三档语义都在这里落地。
+*
+* 🔴 为什么抽成一个函数而不是写两遍：**两种模式（CCC 起桥 ／ 机器级起 poller）走的是同一套
+* 判据**，差别只有一格 —— **有没有 CCC 级回退**（`cccFallback`）。写两遍必然分叉。
+*
+* 三档（方案 §3.1，**刻意分档**）：
+*  - **未命中** ⇒ 不投递 ＋ **留痕**（`console.warn`，静默档：这是"表里没有你"，不是错误）
+*  - **表残缺** ⇒ **响亮出声**（`console.error`；且**独立于是否命中**）
+*  - **目标不存在**（CCC ／ 角色）⇒ **响亮报错**（`console.error`；不静默丢弃）
+*
+* @param input.cccFallback 过渡期回退（方案 Q5）；**机器级模式传 `null`** ⇒ 未命中即不投递
+*/
+async function resolveInboundTarget(ctx, input) {
+	const route = planInboundRoute({
+		subscriptions: readSimpleSettings().humanChannel.subscriptions,
+		account: input.account,
+		user: input.user,
+		fallback: input.cccFallback ? {
+			ccc: input.cccFallback.root,
+			role: input.cccFallback.role
+		} : null
+	});
+	for (const defect of route.defects) {
+		console.error(`[serenity-hooks] ✗ human-channel: 订阅表第 ${defect.index + 1} 行**残缺**（缺 ${defect.missing.join(" / ")}）｜已有字段 ${JSON.stringify(defect.present)}｜该行**不生效** —— 请补全或删掉（机器级 humanChannel.subscriptions）`);
+		appendHumanChannelAudit({
+			kind: "subscription-defect",
+			account: input.account,
+			index: defect.index,
+			missing: defect.missing,
+			present: defect.present
+		});
+	}
+	const target = route.target;
+	if (!target) {
+		const detail = route.skipReason === "no-subscription" ? "机器级订阅表为空（且无 CCC 级回退）" : "订阅表里没有匹配 (账号, 用户) 的行";
+		console.warn(`[serenity-hooks] ⚠ human-channel: 入站未命中订阅 ⇒ **不投递**（account=${input.account} user=${input.user}）：${detail}`);
+		appendHumanChannelAudit({
+			kind: "inbound-unrouted",
+			account: input.account,
+			user: input.user,
+			reason: route.skipReason ?? "no-match",
+			detail
+		});
+		return null;
+	}
+	const root = route.source === "ccc-fallback" ? target.ccc : await resolveCccRootByAlias(ctx, target.ccc);
+	if (root === null) {
+		const detail = `订阅表指向的 CCC "${target.ccc}" 在本机 CCC 枚举里不存在`;
+		console.error(`[serenity-hooks] ✗ human-channel: ${detail}（account=${input.account} user=${input.user}）—— 该消息**未投递**，请改订阅表`);
+		appendHumanChannelAudit({
+			kind: "inbound-target-missing",
+			account: input.account,
+			user: input.user,
+			ccc: target.ccc,
+			role: target.role,
+			detail
+		});
+		return null;
+	}
+	const role = readSkiffRoles(root).get(target.role);
+	if (!role) {
+		const detail = `目标 CCC "${target.ccc}" 未定义 skiff 角色 "${target.role}"`;
+		console.error(`[serenity-hooks] ✗ human-channel: ${detail}（account=${input.account} user=${input.user}）—— 该消息**未投递**，请改订阅表或该 CCC 的 skiff.roles`);
+		appendHumanChannelAudit({
+			kind: "inbound-target-missing",
+			account: input.account,
+			user: input.user,
+			ccc: target.ccc,
+			role: target.role,
+			detail
+		});
+		return null;
+	}
+	return {
+		root,
+		roleName: target.role,
+		role
+	};
+}
+/**
 * 处理单条微信消息：路由 → skiff 会话（固定 id 创建/延续）→ 提问 → 回复回写。
 *
 * 会话语义：`weixinSessionIdFor(fromUserId)` 固定可重建——同用户长期同一会话；
@@ -16443,16 +16795,35 @@ function manualOutputFallbackNeeded(input) {
 *   `_tmp/weixin-inbound/<userhash>/` → question 注入「存在性 + 路径」（ACC 层只保证
 *   可达性——"让会话知道文件的存在并可以拿到"；识别/解析归角色 LLM 决策，不编排）。
 *   降级不静默：下载失败 / 超 20MB → 注入说明进对话；typing 窗口覆盖下载（M7）。
+*
+* 🔴 **P0-3（2026-09-27）：路由改由机器级订阅表决定**（本函数的 `root` 入参退为
+* **回退目标**）。两档语义刻意分开（方案 §3.1）：**未命中 ⇒ 不投递 ＋ 留痕**（静默档）；
+* **目标不存在（CCC ／ 角色）⇒ 响亮报错**（`console.error` ＋ 机器级留痕）。两者都
+* **不是**"投给默认角色"。
 */
-async function handleIncoming(ctx, root, accountId, cred, msg) {
+async function handleIncoming(ctx, root, accountId, cred, msg, preset) {
 	const fromUserId = msg.from_user_id;
 	if (!fromUserId) return;
 	const text = extractWeixinText(msg);
 	const mediaRefs = extractWeixinMedia(msg);
 	const settings = readWeixinSettings(root);
-	if (!settings.enabled) return;
-	const roleName = matchWeixinRoute(settings.routes ?? [], fromUserId);
-	if (!roleName) return;
+	let resolved;
+	if (preset) resolved = preset.target;
+	else {
+		if (!settings.enabled) return;
+		const cccRole = matchWeixinRoute(settings.routes ?? [], fromUserId);
+		resolved = await resolveInboundTarget(ctx, {
+			account: accountId,
+			user: fromUserId,
+			cccFallback: cccRole ? {
+				root,
+				role: cccRole
+			} : null
+		});
+	}
+	if (!resolved) return;
+	const { roleName, role } = resolved;
+	root = resolved.root;
 	if (!text && mediaRefs.length === 0) {
 		if (hasVoiceItem(msg)) await sendTextMessage({
 			baseUrl: cred.baseUrl,
@@ -16464,11 +16835,6 @@ async function handleIncoming(ctx, root, accountId, cred, msg) {
 		return;
 	}
 	try {
-		const role = readSkiffRoles(root).get(roleName);
-		if (!role) {
-			console.log(`[serenity-hooks] weixin-bridge: 路由命中角色 "${roleName}" 但该 CCC 未定义（检查 skiff.roles）`);
-			return;
-		}
 		const sessionId = weixinSessionIdFor(fromUserId);
 		const existing = getSkiffAgent(sessionId);
 		const hc = readHandymanConfig(root);
@@ -16628,6 +16994,31 @@ async function handleIncoming(ctx, root, accountId, cred, msg) {
 	}
 }
 /**
+* **机器级 poller 的单条消息入口**（P0-3 A）。
+*
+* 与 `handleIncoming` 的唯一差别：**目标由机器级订阅表逐条解析，且没有 CCC 级回退**
+* （方案 §3.1：机器级模式下**未命中 = 不投递**，不是"投给默认角色"）。
+* 解析出来后把**目标根**当 `root` 交给 `handleIncoming`（并带上 `preset` ⇒ 它不再自行路由、
+* 也不看目标 CCC 的 `weixin.enabled`）。
+*
+* 🔴 为什么"起 poller"与"路由"必须同批（本件即 P0-2 的后半）：机器级 poller 收到消息时
+* **不知道它属于哪个 CCC** —— 那个答案是订阅表给的。没有订阅表 ⇒ **能收不能投**。
+*
+* 🔵 **导出供测试直接驱动**（与 `handleIncoming` 同款：它俩都是"单条消息的入口"，
+* 生产路径 `runAccountLoop` 只是循环壳）。
+*/
+async function handleMachineIncoming(ctx, accountId, cred, msg) {
+	const fromUserId = msg.from_user_id;
+	if (!fromUserId) return;
+	const target = await resolveInboundTarget(ctx, {
+		account: accountId,
+		user: fromUserId,
+		cccFallback: null
+	});
+	if (!target) return;
+	await handleIncoming(ctx, target.root, accountId, cred, msg, { target });
+}
+/**
 * 启动/重建某 CCC 的桥：读配置 → 对每个 enabled + 有凭据的账号启动轮询循环。
 * 已存在（配置变化热重建）→ 先停旧循环再启动新的。
 *
@@ -16689,13 +17080,118 @@ function stopCccBridge(root) {
 	bridges.delete(root);
 }
 /**
-* 停止全部桥（插件 dispose）
+* 停掉**全部 CCC 级桥**（不碰机器级 poller）＋ 释放它们各自的账号归属。
+* 🔴 模式切换时必须先调它：否则同一个 bot 会被**两处**轮询（方案 §2.6 要消灭的正是这个）。
+*/
+function stopCccBridges() {
+	for (const root of [...bridges.keys()]) stopCccBridge(root);
+}
+/** 停掉**机器级 poller**（不碰 CCC 级桥）＋ 释放机器级归属 */
+function stopMachineLoops() {
+	for (const loop of machineLoops.values()) loop.stopped = true;
+	machineLoops.clear();
+	releasePollersOf(MACHINE_SCOPE);
+}
+/**
+* 停止全部桥（插件 dispose）：CCC 级 ＋ 机器级
 */
 function stopAllBridges() {
-	for (const bridge of bridges.values()) for (const loop of bridge.loops.values()) loop.stopped = true;
-	bridges.clear();
+	stopCccBridges();
+	stopMachineLoops();
 	releaseAllPollers();
 }
+/** 已告警过的"未实现渠道"（避免每次 session/created 都刷一行） */
+const warnedChannels = /* @__PURE__ */ new Set();
+/**
+* **机器级模式**：按**账号**起 poller（方案 §2.6「一账号一 poller」的正面形态）。
+*
+* 与 CCC 模式的差别：poller **不属于任何 CCC** —— 消息投到哪由**订阅表逐条决定**
+* （见 `handleMachineIncoming`）。凭据来自机器级配置本身（方案 Q3：凭据落插件 Config）。
+*
+* 🔴 进入本函数即**先停掉全部 CCC 级桥**：两种模式**互斥**（同时跑 = 同一 bot 两处轮询）。
+*/
+function syncMachinePollers(ctx, hc) {
+	stopCccBridges();
+	const requests = [];
+	const creds = /* @__PURE__ */ new Map();
+	for (const account of hc.accounts) {
+		const id = account.id;
+		if (account.enabled === false) continue;
+		if (!id) {
+			console.warn("[serenity-hooks] ⚠ human-channel: 机器级账号表有一行**缺 `id`** ⇒ 跳过（该行无法被订阅表引用）");
+			continue;
+		}
+		if (account.channel !== "weixin") {
+			if (!warnedChannels.has(`${id}:${account.channel ?? ""}`)) {
+				warnedChannels.add(`${id}:${account.channel ?? ""}`);
+				console.warn(`[serenity-hooks] ⚠ human-channel: 账号 ${id} 的渠道 "${account.channel ?? "(未填)"}" **本机未实现** ⇒ 不起 poller（当前只有 weixin）`);
+			}
+			continue;
+		}
+		const token = (account.token ?? "").trim();
+		if (token === "") {
+			console.warn(`[serenity-hooks] ⚠ human-channel: 账号 ${id} **无 token**（未绑定）⇒ 不起 poller`);
+			continue;
+		}
+		creds.set(id, {
+			token,
+			baseUrl: "",
+			userId: account.userId
+		});
+		requests.push({
+			root: MACHINE_SCOPE,
+			accountId: id,
+			identity: accountIdentity(MACHINE_SCOPE, id, token)
+		});
+	}
+	const plan = planPollerClaims(requests, pollerOwners());
+	for (const { request, ownedBy } of plan.skipped) console.warn(`[serenity-hooks] ⚠ human-channel: 机器级账号 ${request.accountId} 与 ${ownedBy.accountId} **绑的是同一个 bot** ⇒ 本处不重复起循环（一账号一 poller；方案 §2.6）`);
+	stopMachineLoops();
+	for (const claim of plan.claims) {
+		const cred = creds.get(claim.accountId);
+		if (!cred) continue;
+		const loop = {
+			stopped: false,
+			lastPollAt: 0
+		};
+		machineLoops.set(claim.accountId, loop);
+		runAccountLoop(ctx, MACHINE_SCOPE, claim.accountId, cred, loop, true);
+	}
+	commitPollerClaims(plan);
+	if (machineLoops.size > 0) console.log(`[serenity-hooks] ✓ human-channel: 机器级 poller accounts=${[...machineLoops.keys()].join(",")}（与 CCC 无关）`);
+}
+/**
+* 人机信道的**装配入口**（P0-3 A）—— 决定用哪种模式起 poller。
+*
+* 🔴 **模式由机器级账号表决定**（方案 §11.3 **Q5** 的过渡期语义）：
+*  - 账号表**非空** ⇒ **机器级模式**：按账号起 poller；路由**只认订阅表**
+*  - 账号表**为空** ⇒ **回退模式**（今天的形态）：按 CCC 起桥；路由**先查订阅表，未命中回退
+*    到 CCC 级 routes** ⇒ **不打断在用的微信**
+* ⚠️ 两种模式**互斥**（各自进入时先停掉另一种），否则同一个 bot 会被两处轮询。
+*/
+function syncHumanChannel(ctx) {
+	let hc;
+	try {
+		hc = readSimpleSettings().humanChannel;
+	} catch (err) {
+		console.warn(`[serenity-hooks] ✗ human-channel: 机器级配置读取失败 ⇒ 按"未配置"处理（回退按 CCC 起桥）: ${String(err?.message ?? err)}`);
+	}
+	if (hc && hc.accounts.length > 0) {
+		try {
+			syncMachinePollers(ctx, hc);
+		} catch (err) {
+			console.warn(`[serenity-hooks] ✗ human-channel: 机器级 poller 装配失败: ${String(err?.message ?? err)}`);
+		}
+		return;
+	}
+	(async () => {
+		try {
+			stopMachineLoops();
+			const { listCccs } = await import("./ccc-roots-DtiMVRPo.js").then((n) => n.a);
+			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
+		} catch {}
+	})();
+}
 /**
 * 解析该 CCC 的发送账号 + 凭据（v1.31.0：文本与文件发送的**单一账号选择真相源**）。
 * 顺序：桥启用 → 有启用账号 → 指定账号存在 → 凭据已绑定（扫码）。
@@ -16778,35 +17274,37 @@ async function sendProactiveText(input) {
 		role
 	};
 }
-/** 桥状态快照（面板数据源）：每 CCC → 每账号 → 轮询健康 */
+/**
+* 桥状态快照（面板数据源）：每 CCC → 每账号 → 轮询健康。
+* 🔴 **P0-3 A 起多一行**：机器级 poller 以 `ccc: '<machine>'`（`MACHINE_SCOPE`）出现 ——
+* 它**不属于任何 CCC**，故**不伪装成某个 CCC 的行**（面板按原样显示这个哨兵值即可）。
+*/
 function weixinBridgeStatus() {
 	const out = [];
+	const toAccounts = (loops) => [...loops.entries()].map(([accountId, loop]) => ({
+		accountId,
+		lastPollAt: loop.lastPollAt,
+		...loop.lastError ? { lastError: loop.lastError } : {}
+	}));
 	for (const [root, bridge] of bridges) out.push({
 		ccc: root,
-		accounts: [...bridge.loops.entries()].map(([accountId, loop]) => ({
-			accountId,
-			lastPollAt: loop.lastPollAt,
-			...loop.lastError ? { lastError: loop.lastError } : {}
-		}))
+		accounts: toAccounts(bridge.loops)
+	});
+	if (machineLoops.size > 0) out.push({
+		ccc: MACHINE_SCOPE,
+		accounts: toAccounts(machineLoops)
 	});
 	return out;
 }
 /**
-* 装配（index.ts 调用）：扫描 live CCC 启动桥 + 监听会话变化。
-* 事件驱动（对齐 autotrajectory v1.26.15）：live 会话出现 → 同步该 CCC 桥。
+* 装配（index.ts 调用）：**按机器级配置决定模式**（P0-3 A：`syncHumanChannel`），
+* 并监听会话变化以重扫（新 CCC 出现即启动其桥；配置变化也可经此路径热重建）。
+* 事件驱动（对齐 autotrajectory v1.26.15）。
 */
 function registerWeixinBridge(ctx) {
-	const syncFromLive = () => {
-		(async () => {
-			try {
-				const { listCccs } = await import("./ccc-roots-Duk89a-h.js").then((n) => n.a);
-				for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
-			} catch {}
-		})();
-	};
-	syncFromLive();
+	syncHumanChannel(ctx);
 	try {
-		ctx.on("session/created", () => syncFromLive());
+		ctx.on("session/created", () => syncHumanChannel(ctx));
 	} catch {}
 }
 //#endregion
@@ -16925,7 +17423,7 @@ function matchCcc(input, candidates) {
 }
 /** 组装候选列表（`ccc-roots.listCccs` 投影 + `.serenity` 名；动态 import 保持本模块静态依赖轻量） */
 async function collectCandidates(ctx) {
-	const { listCccs } = await import("./ccc-roots-Duk89a-h.js").then((n) => n.a);
+	const { listCccs } = await import("./ccc-roots-DtiMVRPo.js").then((n) => n.a);
 	const entries = await listCccs(ctx, { defaultRoot: process.cwd() });
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
@@ -18776,6 +19274,843 @@ function createAccDiagTool(ctx) {
 	});
 }
 //#endregion
+//#region src/diagram/dsl.ts
+/** 文本形态的标签（其余标签自闭合、无文本内容） */
+const TEXT_TAGS = [
+	"title",
+	"subtitle",
+	"text"
+];
+/** 属性值 → 数字；缺失或非数字返回 undefined（不抛） */
+function num(v) {
+	if (v === void 0) return void 0;
+	const t = v.trim();
+	if (t === "") return void 0;
+	const n = Number(t);
+	return Number.isFinite(n) ? n : void 0;
+}
+/** 逗号分隔的 4 个数字；不合法返回 undefined */
+function quad(v) {
+	const parts = v.split(",");
+	if (parts.length !== 4) return void 0;
+	const [x0, y0, x1, y1] = parts.map(num);
+	if (x0 === void 0 || y0 === void 0 || x1 === void 0 || y1 === void 0) return void 0;
+	return {
+		x0,
+		y0,
+		x1,
+		y1
+	};
+}
+/** 剥离 <!-- ... -->（可跨行）；用空格占位以保住行号 */
+function stripComments(src) {
+	let out = "";
+	let i = 0;
+	while (i < src.length) {
+		const start = src.indexOf("<!--", i);
+		if (start < 0) {
+			out += src.slice(i);
+			break;
+		}
+		out += src.slice(i, start);
+		const end = src.indexOf("-->", start + 4);
+		const stop = end < 0 ? src.length : end + 3;
+		out += src.slice(start, stop).replace(/[^\n]/g, " ");
+		i = stop;
+	}
+	return out;
+}
+/** 索引处字符所在行（1-based） */
+function lineAt(src, idx) {
+	let ln = 1;
+	for (let i = 0; i < idx; i++) if (src[i] === "\n") ln++;
+	return ln;
+}
+/** 解析标签格式源码。**绝不抛异常**：看不懂的行记进 errors 并跳过，其余照收。 */
+function parseDsl(source) {
+	const src = stripComments(source);
+	const errors = [];
+	const model = {
+		W: 1e3,
+		H: 780,
+		x0: 0,
+		y0: -19,
+		x1: 100,
+		y1: 72,
+		pad: 10,
+		title: "",
+		subtitle: "",
+		colors: {},
+		rects: [],
+		segments: [],
+		texts: []
+	};
+	const ids = /* @__PURE__ */ new Set();
+	let rectOrdinal = 0;
+	let tagIndex = 0;
+	let i = 0;
+	const fail = (n, ln, msg) => {
+		errors.push(`第 ${n} 个标签（第 ${ln} 行）：${msg}`);
+	};
+	while (i < src.length) {
+		const lt = src.indexOf("<", i);
+		if (lt < 0) break;
+		let j = lt + 1;
+		let inQuote = false;
+		while (j < src.length) {
+			const c = src[j];
+			if (c === "\"") inQuote = !inQuote;
+			else if (c === ">" && !inQuote) break;
+			j++;
+		}
+		const ln = lineAt(src, lt);
+		if (j >= src.length) {
+			tagIndex++;
+			fail(tagIndex, ln, "标签未闭合（属性值引号未闭合）");
+			const gt = src.indexOf(">", lt + 1);
+			if (gt < 0) break;
+			i = gt + 1;
+			continue;
+		}
+		const raw = src.slice(lt + 1, j);
+		if (/^\s*\//.test(raw)) {
+			i = j + 1;
+			continue;
+		}
+		tagIndex++;
+		const selfClosing = /\/\s*$/.test(raw);
+		const body = raw.replace(/\/\s*$/, "");
+		const head = /^\s*([A-Za-z_][\w-]*)/.exec(body);
+		const tag = head ? head[1] : void 0;
+		if (tag === void 0) {
+			fail(tagIndex, ln, "标签名缺失或非法");
+			i = j + 1;
+			continue;
+		}
+		const attrs = {};
+		const attrRe = /([A-Za-z_][\w-]*)\s*=\s*"([^"]*)"/g;
+		let a;
+		while ((a = attrRe.exec(body)) !== null) {
+			const [k, val] = [a[1], a[2]];
+			if (k !== void 0 && val !== void 0) attrs[k] = val;
+		}
+		let content = "";
+		let next = j + 1;
+		if (!selfClosing && TEXT_TAGS.indexOf(tag) >= 0) {
+			const close = src.indexOf(`</${tag}`, next);
+			if (close < 0) {
+				fail(tagIndex, ln, `缺少 </${tag}> 闭合标签`);
+				i = next;
+				continue;
+			}
+			content = src.slice(next, close).trim();
+			const gt = src.indexOf(">", close);
+			next = gt < 0 ? src.length : gt + 1;
+		}
+		i = next;
+		if (tag === "diagram") {
+			const w = num(attrs.width);
+			const h = num(attrs.height);
+			if (w !== void 0) model.W = w;
+			if (h !== void 0) model.H = h;
+			if (attrs.domain !== void 0) {
+				const d = quad(attrs.domain);
+				if (d) {
+					model.x0 = d.x0;
+					model.y0 = d.y0;
+					model.x1 = d.x1;
+					model.y1 = d.y1;
+				} else fail(tagIndex, ln, `domain 不是 4 个数字：${attrs.domain}（已忽略）`);
+			}
+			continue;
+		}
+		if (tag === "title" || tag === "subtitle") {
+			if (tag === "title") model.title = content;
+			else model.subtitle = content;
+			continue;
+		}
+		if (tag === "color") {
+			const name = attrs.name;
+			const value = attrs.value;
+			if (!name || value === void 0) {
+				fail(tagIndex, ln, "color 缺 name 或 value");
+				continue;
+			}
+			model.colors[name] = value;
+			continue;
+		}
+		if (tag === "legend") {
+			model.legend = {
+				x: num(attrs.x) ?? 0,
+				y: num(attrs.y) ?? 0,
+				size: num(attrs.size) ?? 12
+			};
+			continue;
+		}
+		if (tag === "rect") {
+			rectOrdinal++;
+			if (attrs.box === void 0) {
+				fail(tagIndex, ln, "rect 缺 box");
+				continue;
+			}
+			const b = quad(attrs.box);
+			if (!b) {
+				fail(tagIndex, ln, `box 不是 4 个数字：${attrs.box}`);
+				continue;
+			}
+			const label = attrs.label;
+			const id = attrs.id || label || `rect${rectOrdinal}`;
+			if (ids.has(id)) {
+				fail(tagIndex, ln, `rect id 重复：${id}`);
+				continue;
+			}
+			ids.add(id);
+			const rect = {
+				id,
+				x0: Math.min(b.x0, b.x1),
+				y0: Math.min(b.y0, b.y1),
+				x1: Math.max(b.x0, b.x1),
+				y1: Math.max(b.y0, b.y1),
+				size: num(attrs.size) ?? 13,
+				fill: attrs.fill ?? ""
+			};
+			if (label !== void 0) rect.label = label;
+			model.rects.push(rect);
+			continue;
+		}
+		if (tag === "line" || tag === "arrow") {
+			const from = attrs.from;
+			const to = attrs.to;
+			if (!from || !to) {
+				fail(tagIndex, ln, `${tag} 缺 from 或 to`);
+				continue;
+			}
+			const seg = {
+				kind: tag,
+				from,
+				to,
+				free: attrs.free === "1",
+				ln
+			};
+			if (attrs.color !== void 0) seg.color = attrs.color;
+			const w = num(attrs.width);
+			if (w !== void 0) seg.width = w;
+			if (attrs.dash !== void 0) seg.dash = attrs.dash;
+			model.segments.push(seg);
+			continue;
+		}
+		if (tag === "text") {
+			const x = num(attrs.x);
+			const y = num(attrs.y);
+			if (x === void 0 || y === void 0) {
+				fail(tagIndex, ln, "text 缺 x 或 y");
+				continue;
+			}
+			const al = attrs.align;
+			const t = {
+				x,
+				y,
+				text: content,
+				align: al === "center" || al === "right" ? al : "left",
+				size: num(attrs.size) ?? 12.5,
+				ln
+			};
+			if (attrs.color !== void 0) t.color = attrs.color;
+			model.texts.push(t);
+			continue;
+		}
+		fail(tagIndex, ln, `未知标签：<${tag}>`);
+	}
+	return {
+		model,
+		errors
+	};
+}
+//#endregion
+//#region src/diagram/dsl-render.ts
+const TITLE_BAND = 68;
+const EPS = .35;
+const DEF_W = 960;
+const DEF_H = 540;
+const DEF_PAD = 24;
+const DEF_SIZE = 14;
+const DEF_FILL = "#cccccc";
+const DEF_INK = "#111111";
+const n = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+const r2 = (v) => Math.round(v * 100) / 100;
+const esc = (v) => String(v ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const textWidth = (s, size) => {
+	let w = 0;
+	for (const ch of s) w += (ch.codePointAt(0) ?? 0) > 11904 ? size : size * .55;
+	return w;
+};
+const lineNo = (s, i) => typeof s.line === "number" && Number.isFinite(s.line) ? s.line : i + 1;
+const ANCHOR_RE = /^(.+)\.(ne|nw|se|sw|n|s|e|w|c)(?:([+-]?\d+(?:\.\d+)?),([+-]?\d+(?:\.\d+)?))?$/;
+const NUM_PAIR_RE = /^(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)$/;
+/** 点是否在块内或贴块边（eps = EPS） */
+const inBox = (p, r) => p.x >= n(r.x0, 0) - EPS && p.x <= n(r.x1, 0) + EPS && p.y >= n(r.y0, 0) - EPS && p.y <= n(r.y1, 0) + EPS;
+/** Liang-Barsky：线段与轴对齐盒是否相交 */
+const segHitsBox = (ax, ay, bx, by, box) => {
+	const p = [
+		ax - bx,
+		bx - ax,
+		ay - by,
+		by - ay
+	];
+	const q = [
+		ax - box[0],
+		box[2] - ax,
+		ay - box[1],
+		box[3] - ay
+	];
+	let t0 = 0;
+	let t1 = 1;
+	for (let i = 0; i < 4; i++) {
+		const pi = p[i] ?? 0;
+		const qi = q[i] ?? 0;
+		if (pi === 0) {
+			if (qi < 0) return false;
+			continue;
+		}
+		const r = qi / pi;
+		if (pi < 0) {
+			if (r > t1) return false;
+			if (r > t0) t0 = r;
+		} else if (r < t0) return false;
+		else if (r < t1) t1 = r;
+	}
+	return true;
+};
+/** 把模型渲染成 SVG，并做四项体检。绝不抛异常：出错的图元跳过、记 errors、其余照画。 */
+/**
+* 🔴 **适配层（2026-09-29 加，修一处真缺陷）**
+*
+* 本文件此前用 `model as unknown as Model` 把 `DslModel` **硬 cast** 成自己的内部形状
+* ⇒ **编译器对字段名彻底变瞎**。而两侧字段名实际不同：
+* `W/H` vs `width/height` ／ `fill` vs `color` ／ `ln` vs `line` ／ `align` vs `anchor`
+* ⇒ 运行期整片取到 `undefined`，**而 `typecheck` 照样绿**（那个绿是假信号）。
+*
+* 现在改为**逐字段显式搬运**：类型系统会核对每一个名字 ⇒ 再对不上就**编译不过**。
+* 🆕 判据：**"typecheck 通过"≠"两侧接口一致"** —— 一个 cast 就足以让类型检查失效；
+* 这一层在，`typecheck` 才是证据。
+*/
+function adapt(model) {
+	return {
+		title: model.title,
+		subtitle: model.subtitle,
+		width: model.W,
+		height: model.H,
+		pad: model.pad,
+		x0: model.x0,
+		x1: model.x1,
+		y0: model.y0,
+		y1: model.y1,
+		colors: model.colors,
+		legend: model.legend,
+		rects: model.rects.map((r) => ({
+			id: r.id,
+			label: r.label,
+			x0: r.x0,
+			y0: r.y0,
+			x1: r.x1,
+			y1: r.y1,
+			color: r.fill,
+			size: r.size
+		})),
+		segs: model.segments.map((s) => ({
+			kind: s.kind,
+			from: s.from,
+			to: s.to,
+			color: s.color,
+			width: s.width,
+			dash: s.dash,
+			free: s.free,
+			line: s.ln
+		})),
+		texts: model.texts.map((t) => ({
+			x: t.x,
+			y: t.y,
+			text: t.text,
+			size: t.size,
+			color: t.color,
+			anchor: t.align
+		}))
+	};
+}
+function renderDsl(model) {
+	const m = adapt(model);
+	const lint = [];
+	const errors = [];
+	const rects = m.rects ?? [];
+	const segs = m.segs ?? [];
+	const texts = m.texts ?? [];
+	const colors = m.colors ?? {};
+	const ids = rects.map((r) => r.id);
+	const col = (v, d) => {
+		const s = typeof v === "string" ? v : "";
+		if (s === "") return d;
+		if (s.charAt(0) === "#") return s;
+		return colors[s] ?? s;
+	};
+	const W = n(m.width, DEF_W);
+	const H = n(m.height, DEF_H);
+	const pad = n(m.pad, DEF_PAD);
+	const gx = [];
+	const gy = [];
+	for (const r of rects) gx.push(n(r.x0, 0), n(r.x1, 0));
+	for (const r of rects) gy.push(n(r.y0, 0), n(r.y1, 0));
+	for (const t of texts) gx.push(n(t.x, 0));
+	for (const t of texts) gy.push(n(t.y, 0));
+	const hasBox = gx.length > 0 && gy.length > 0;
+	const x0 = n(m.x0, hasBox ? Math.min(...gx) : 0);
+	const x1 = n(m.x1, hasBox ? Math.max(...gx) : 100);
+	const y0 = n(m.y0, hasBox ? Math.min(...gy) : 0);
+	const y1 = n(m.y1, hasBox ? Math.max(...gy) : 100);
+	const scaleX = (W - 2 * pad) / (x1 - x0 || 1);
+	const scaleY = (H - TITLE_BAND - pad) / (y1 - y0 || 1);
+	const px = (x) => r2(pad + (x - x0) * scaleX);
+	const py = (y) => r2(TITLE_BAND + (y1 - y) * scaleY);
+	const resolve = (token) => {
+		const t = String(token ?? "").trim();
+		const np = NUM_PAIR_RE.exec(t);
+		if (np) return {
+			x: Number(np[1]),
+			y: Number(np[2]),
+			numeric: true
+		};
+		const mt = ANCHOR_RE.exec(t);
+		if (!mt) return null;
+		const ref = rects.find((r) => r.id === mt[1]);
+		if (!ref) return null;
+		const rx0 = n(ref.x0, 0);
+		const rx1 = n(ref.x1, 0);
+		const ry0 = n(ref.y0, 0);
+		const ry1 = n(ref.y1, 0);
+		const cx = (rx0 + rx1) / 2;
+		const cy = (ry0 + ry1) / 2;
+		const base = {
+			n: [cx, ry1],
+			s: [cx, ry0],
+			e: [rx1, cy],
+			w: [rx0, cy],
+			c: [cx, cy],
+			ne: [rx1, ry1],
+			nw: [rx0, ry1],
+			se: [rx1, ry0],
+			sw: [rx0, ry0]
+		}[mt[2] ?? ""];
+		if (!base) return null;
+		const dx = mt[3] === void 0 ? 0 : Number(mt[3]);
+		const dy = mt[4] === void 0 ? 0 : Number(mt[4]);
+		return {
+			x: base[0] + dx,
+			y: base[1] + dy,
+			numeric: false
+		};
+	};
+	for (let i = 0; i < rects.length; i++) for (let j = i + 1; j < rects.length; j++) {
+		const A = rects[i];
+		const B = rects[j];
+		const ix = Math.min(n(A.x1, 0), n(B.x1, 0)) - Math.max(n(A.x0, 0), n(B.x0, 0));
+		const iy = Math.min(n(A.y1, 0), n(B.y1, 0)) - Math.max(n(A.y0, 0), n(B.y0, 0));
+		if (ix > 0 && iy > 0) lint.push(`块重叠：${A.label ?? A.id} × ${B.label ?? B.id} ⇒ 相交 ${r2(ix)}×${r2(iy)}（面积 ${r2(ix * iy)} 平方数据单位）`);
+	}
+	for (const r of rects) {
+		if (!r.label) continue;
+		const need = textWidth(r.label, n(r.size, DEF_SIZE));
+		const boxPx = Math.abs(n(r.x1, 0) - n(r.x0, 0)) * scaleX;
+		if (need > boxPx - 6) lint.push(`标签溢出：${r.label}（需 ≈${r2(need)}px，块宽 ${r2(boxPx)}px）`);
+	}
+	const headEls = [], rectEls = [], segEls = [];
+	const textEls = [], legendEls = [], l3 = [], l4 = [];
+	let marks = 0;
+	headEls.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" font-family="-apple-system, 'Noto Sans CJK SC', 'Source Han Sans SC', 'Microsoft YaHei', sans-serif">`);
+	headEls.push(`<rect width="${W}" height="${H}" fill="#fbfaf7"/>`);
+	marks += 2;
+	if (m.title) headEls.push(`<text x="10" y="34" font-size="21" font-weight="bold" fill="#111">${esc(m.title)}</text>`);
+	if (m.title) marks += 1;
+	if (m.subtitle) headEls.push(`<text x="10" y="58" font-size="13" fill="#666">${esc(m.subtitle)}</text>`);
+	if (m.subtitle) marks += 1;
+	for (const r of rects) {
+		const X = px(n(r.x0, 0));
+		const Y = py(n(r.y1, 0));
+		const bw = r2(px(n(r.x1, 0)) - X);
+		const bh = r2(py(n(r.y0, 0)) - Y);
+		rectEls.push(`<rect x="${X}" y="${Y}" width="${bw}" height="${bh}" rx="2" fill="${esc(col(r.color, DEF_FILL))}" stroke="#ffffff" stroke-width="1.5"/>`);
+		marks += 1;
+		if (!r.label) continue;
+		const cx = px((n(r.x0, 0) + n(r.x1, 0)) / 2);
+		const cy = py((n(r.y0, 0) + n(r.y1, 0)) / 2);
+		rectEls.push(`<text x="${cx}" y="${cy}" font-size="${n(r.size, DEF_SIZE)}" font-weight="bold" fill="#1b1b1b" text-anchor="middle" dominant-baseline="middle">${esc(r.label)}</text>`);
+		marks += 1;
+	}
+	for (let i = 0; i < segs.length; i++) {
+		const s = segs[i];
+		const kind = s.kind === "arrow" ? "arrow" : "line";
+		const a = resolve(s.from);
+		const b = resolve(s.to);
+		if (!a || !b) {
+			const bad = !a ? s.from : s.to;
+			errors.push(`第 ${lineNo(s, i)} 行 ${kind}：锚点引用解析不了（${esc(bad)}）；已知 id = ${ids.join("、")} ⇒ 该图元已跳过`);
+			continue;
+		}
+		const X0 = px(a.x);
+		const Y0 = py(a.y);
+		const X1 = px(b.x);
+		const Y1 = py(b.y);
+		if (s.free !== true) {
+			if (a.numeric && !rects.some((r) => inBox(a, r))) l3.push(`端点悬空：${kind} 起点 (${r2(a.x)}, ${r2(a.y)}) 不在任何块内、也不贴任何块边`);
+			if (b.numeric && !rects.some((r) => inBox(b, r))) l3.push(`端点悬空：${kind} 终点 (${r2(b.x)}, ${r2(b.y)}) 不在任何块内、也不贴任何块边`);
+		}
+		for (const r of rects) {
+			if (!r.label) continue;
+			const size = n(r.size, DEF_SIZE);
+			const hw = textWidth(r.label, size) / 2 + 1;
+			const hh = size / 2 + 1;
+			const bx = px((n(r.x0, 0) + n(r.x1, 0)) / 2);
+			const by = py((n(r.y0, 0) + n(r.y1, 0)) / 2);
+			if (!segHitsBox(X0, Y0, X1, Y1, [
+				bx - hw,
+				by - hh,
+				bx + hw,
+				by + hh
+			])) continue;
+			l4.push(`线压标签：${kind}(${r2(a.x)},${r2(a.y)})→(${r2(b.x)},${r2(b.y)}) 穿过「${r.label}」⇒ 把该线挪开，或用锚点偏移（如 ${r.id}.n+3,0）`);
+		}
+		const stroke = esc(col(s.color, DEF_INK));
+		const dash = typeof s.dash === "string" && s.dash !== "" ? ` stroke-dasharray="${esc(s.dash)}"` : "";
+		if (kind === "arrow") {
+			const ang = Math.atan2(Y1 - Y0, X1 - X0);
+			const L = 13;
+			const Wd = 6.5;
+			const vx = X1 - Math.cos(ang) * L;
+			const vy = Y1 - Math.sin(ang) * L;
+			segEls.push(`<line x1="${X0}" y1="${Y0}" x2="${r2(vx)}" y2="${r2(vy)}" stroke="${stroke}" stroke-width="${n(s.width, 2.2)}"${dash}/>`);
+			segEls.push(`<polygon points="${X1},${Y1} ${r2(vx - Math.sin(ang) * Wd)},${r2(vy + Math.cos(ang) * Wd)} ${r2(vx + Math.sin(ang) * Wd)},${r2(vy - Math.cos(ang) * Wd)}" fill="${stroke}"/>`);
+			marks += 2;
+		} else {
+			segEls.push(`<line x1="${X0}" y1="${Y0}" x2="${X1}" y2="${Y1}" stroke="${stroke}" stroke-width="${n(s.width, 1.5)}"${dash}/>`);
+			marks += 1;
+		}
+	}
+	for (const t of texts) {
+		const anchor = t.anchor === "start" || t.anchor === "end" ? t.anchor : "middle";
+		textEls.push(`<text x="${px(n(t.x, 0))}" y="${py(n(t.y, 0))}" font-size="${n(t.size, DEF_SIZE)}" fill="${esc(col(t.color, "#4a4a4a"))}" text-anchor="${anchor}" dominant-baseline="middle">${esc(t.text)}</text>`);
+		marks += 1;
+	}
+	if (m.legend) {
+		const size = n(m.legend.size, DEF_SIZE);
+		const LX = r2(n(m.legend.x, 0));
+		const LY = r2(n(m.legend.y, 0));
+		legendEls.push(`<text x="${LX}" y="${LY}" font-size="${size + 1}" font-weight="bold" fill="#333">阵营</text>`);
+		marks += 1;
+		const entries = Object.entries(colors);
+		for (let i = 0; i < entries.length; i++) {
+			const row = LY + 20 + i * (size + 6);
+			legendEls.push(`<rect x="${LX}" y="${r2(row - 8)}" width="12" height="12" rx="2" fill="${esc(entries[i][1])}"/>`);
+			legendEls.push(`<text x="${r2(LX + 18)}" y="${r2(row)}" font-size="${size}" fill="#333" dominant-baseline="middle">${esc(entries[i][0])}</text>`);
+			marks += 2;
+		}
+	}
+	lint.push(...l3, ...l4);
+	return {
+		svg: [
+			...headEls,
+			...rectEls,
+			...segEls,
+			...textEls,
+			...legendEls,
+			"</svg>"
+		].join("\n") + "\n",
+		lint,
+		errors,
+		marks
+	};
+}
+//#endregion
+//#region src/diagram/rasterize.ts
+/**
+* diagram 光栅化 —— SVG → PNG（**纯进程内，不起浏览器、不截图**）
+*
+* 为什么是 `@resvg/resvg-wasm`（owner 2026-09-29 裁「内置」，判据 = 可行性调研 §7 的 docker 实测）：
+*   ① **纯 wasm**：无原生二进制、无平台/架构约束、无 postinstall 构建（公开包最怕那三样）；
+*   ② 实测渲染一张图尺寸画布 ≈60 ms ／ ~55 KB PNG。
+*
+* 🔴 **必须喂字体，且这是实测结论不是设计偏好**：docker 里给容器装好中文字体（`fc-list` 认它）
+*   后，resvg-wasm 渲染中文**仍得到空白画布**，且 `loadSystemFonts:true` 与 `false` **逐字节相同**
+*   ⇒ **wasm 对系统字体完全不可见**。只有 `fontBuffers` 才画得出字。
+*   ⇒ 顺带白拿一个好处：**输出与机器无关**（同一份内置字体 ⇒ 逐字节可复现，S↑ 稳定）。
+*
+* 字体资产随包分发：`assets/diagram/DroidSansFallbackFull.ttf`（3.8 MB，Apache-2.0，含许可证与出处）。
+*/
+/**
+* 包根 = **向上找到含 `package.json` 的那一级**。
+*
+* 🔴 为什么不能照抄 `voyage-page.ts` 的「`..` 一次」：那个文件在 `src/` 根下，一次 `..` 恰好是包根；
+* 本模块在 `src/diagram/` 里 ⇒ 开发态（vitest 直接跑 TS 源码）一次 `..` 只到 `src/`，
+* 于是去找 `src/assets/…` —— **实测 ENOENT**（测试全红，且现象是"字体不在"，与真因"路径层级算错"
+* 长得完全不同）。按 `package.json` 上溯对**开发态（src/diagram）与发布态（lib/diagram）都成立**。
+* @returns 包根绝对路径；四层内找不到 `package.json` 时回落"上一级"（不抛——定位失败由调用方响亮报错）
+*/
+function packageRootPath() {
+	const start = dirname(fileURLToPath(import.meta.url));
+	let dir = start;
+	for (let i = 0; i < 4; i++) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		dir = dirname(dir);
+	}
+	return join(start, "..");
+}
+/** 字体资产相对包根的路径（**必须同时出现在 package.json 的 files 白名单里**，pack-check 会核对） */
+const DIAGRAM_FONT_ASSET = "assets/diagram/DroidSansFallbackFull.ttf";
+/** 字体绝对路径（导出以便测试与 pack-check 共用同一判据来源） */
+function diagramFontPath() {
+	return join(packageRootPath(), DIAGRAM_FONT_ASSET);
+}
+/**
+* 内置字体的族名。SVG 里声明的 `Noto Sans CJK SC` ／ `Source Han Sans SC` ／ `Microsoft YaHei`
+* 在本机**一个都不存在**（本机 CJK 覆盖只有 AR PL UMing ＋ Droid Sans Fallback）
+* ⇒ 光栅化时必须由这里兜底，否则中文会退化成缺字方框。
+*/
+const DIAGRAM_FONT_FAMILY = "Droid Sans Fallback";
+let wasmReady = null;
+let fontBuf = null;
+/**
+* wasm 模块路径：**先解析 JS 入口再取同目录的 `.wasm`**。
+* 不直接 resolve `.wasm` 的原因：包的 `exports` 表未必暴露该子路径（解析失败会抛，
+* 而"抛"与"文件不在"在验收上长得一样 —— 故走这条更稳的路）。
+*/
+function wasmPath() {
+	const req = createRequire(import.meta.url);
+	return join(dirname(req.resolve("@resvg/resvg-wasm")), "index_bg.wasm");
+}
+function ensureReady() {
+	if (wasmReady === null) wasmReady = initWasm(readFileSync(wasmPath())).catch((err) => {
+		if (/already initialized/iu.test(String(err?.message ?? err))) return;
+		throw err;
+	});
+	return wasmReady;
+}
+/** 字体只读一次（3.8 MB，进程内缓存） */
+function fontBuffer() {
+	if (fontBuf === null) fontBuf = readFileSync(diagramFontPath());
+	return fontBuf;
+}
+/**
+* SVG → PNG。
+* @param width 输出像素宽（矢量无损放大；高度按 SVG 自身比例推出）
+*/
+async function rasterizeSvg(svg, width) {
+	await ensureReady();
+	const t0 = Date.now();
+	const img = new Resvg(svg, {
+		fitTo: {
+			mode: "width",
+			value: width
+		},
+		font: {
+			fontBuffers: [fontBuffer()],
+			loadSystemFonts: false,
+			defaultFontFamily: DIAGRAM_FONT_FAMILY
+		}
+	}).render();
+	return {
+		png: img.asPng(),
+		width: img.width,
+		height: img.height,
+		ms: Date.now() - t0
+	};
+}
+//#endregion
+//#region src/tools/diagram.ts
+/**
+* diagram.ts — `diagram` 工具：**agent 直接给一段标签格式源码，自动出图**
+*
+* owner 2026-09-29 具名令（D104）：「做成一个 tool，**ACC 级别**的，配合一个开关（demo 功能嘛，
+* 默认关，开了才可用）；Agent 调用这个 tool **直接给代码**就行，然后 dsh 可以**自动渲染成图片**
+* （注意**不借助浏览器生成截图**）」。权威设计 = 插件仓 `docs/diagram-tool-feasibility.md`。
+*
+* 链路（全部进程内，**不起浏览器**）：标签源码 → `parseDsl` → `renderDsl`（SVG ＋ 四项体检）
+* → `rasterizeSvg`（resvg-wasm ＋ **内置字体**）→ PNG → 落 CCC `_tmp/diagram/` ＋ 图片块进对话。
+*
+* 🔴 **为什么 PNG 是必需的**：宿主的对话内图片通路**白名单只有光栅格式**
+* （`image/png|jpeg|webp|gif`，见 `dsh-attachment/types.d.ts`）⇒ **SVG 进不去**，
+* "产出 SVG 就自动显示"确定不成立。右侧栏走 SVG 是二期方案。
+*
+* 🔴 **开关**：由 `index.ts` 在 registration 处门控（**关时不注册** ⇒ 工具根本不进模型工具清单，
+* 不占 token、不会被误调）—— 同 `skiff`／`acp` 的"未开启零资源占用"口径。
+*
+* ## 🔴 两条**宿主契约**（2026-09-29 现场取证；第 ① 条是本文件第一版写错的地方）
+*
+* ① **`output.render` 是「同步投影」，宿主不 await 它**：`@deepseek-ai/dsh-tools` 的
+*    `createSuccessResult()` 直接 `rendered = tool.output.render(args, value)`，紧接着
+*    `snapshotJsonValue(rendered)` —— 返回一个 Promise 会被判「**非 lossless JSON**」⇒
+*    **整条工具调用失败**（图片与文字回执**一起**丢掉）。⚠️ 第一版把 async 实现 cast 成同步，
+*    于是"拿不到图片块仍返回文字回执"那段自兜底**根本走不到**（它以为的失败模式不是真失败模式）。
+* ② **图片块带的 `attachment` 必须是附件服务的 durable 引用**（`ImageAttachmentRef`），
+*    而存字节是 async ⇒ **只能分两段**：`execute` 里 `saveImage`（async，把引用拼进**纯 JSON** 的返回值），
+*    `render` 里**同步**装配 `{ type: 'image', attachment: … }`。
+*    这正是平台自家 `read_image` 的形态（本机 live 安装 `dsh-tool-fs` 取证：`imageRefFromValue` ＋
+*    `render: (_args, value) => imageReadContent(value)`），本文件照该形态实现。
+*
+* ⚠️ 因此 render 里那个 `as unknown as ContentBlock` 是**必要的**（本包不引 `@deepseek-ai/dsh-attachment`，
+* 它不是 peerDep ⇒ 拿不到 `AttachmentId` 的 brand），而它**同时让类型检查对字段名变瞎**（判据 ㉜）⇒
+* 字段名由 `tests/diagram-tool.test.ts` 逐字钉住。
+*/
+/** 输出宽度缺省（矢量无损放大；高度按图自身比例推出） */
+const DEFAULT_WIDTH = 1200;
+/** 时间戳：ISO → `YYYYMMDD-HHMMSS`（本地时区不参与，仅用于文件名排序） */
+function stamp() {
+	return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+}
+/**
+* 当前模型路由是否**明确声明**收图像输入（正判据 —— 与 `read_image` 同一道门）。
+*
+* 🔴 为什么这道门必须过（而不是"先附上试试"）：图片块进的是**工具结果内容**，
+* 若路由不收图，最坏情形是**整轮请求**被装配层拒掉 —— 比"没图"坏得多。
+* ⚠️ 与 `read_image` 唯一的差别：**这里不抛错**（图已落盘，改用文字给路径）。
+*/
+async function routeDeclaresImage(ctx, exec) {
+	const agent = exec.agent;
+	const routed = agent?.session?.requestHeader?.()?.config;
+	const provider = routed?.provider ?? agent?.options?.provider;
+	const model = routed?.model ?? agent?.options?.model;
+	const llm = ctx.get?.("llm");
+	if (provider === void 0 || model === void 0 || llm?.resolveModelInfo === void 0) return false;
+	const signal = exec.signal;
+	const modes = (await llm.resolveModelInfo(provider, model, signal))?.inputModalities;
+	return Array.isArray(modes) && modes.includes("image");
+}
+/**
+* 落成**可进对话的图片块**所需的 durable 引用（async 段 —— 见文件头契约 ①）。
+*
+* 三条降级**都不抛错、只把原因带回**（图已落盘，文字回执里给路径：
+* 工具的价值不允许"附不上图"把整条回执一起带走）：
+*  ① 附件服务不在（未挂载） ② 部署不收 `image/png` ③ 当前路由未声明图像输入 ④ `saveImage` 自身报错。
+*/
+async function attachPng(ctx, exec, png, name) {
+	const attachments = ctx.get?.("attachments");
+	if (attachments === void 0 || typeof attachments.saveImage !== "function") return {
+		image: null,
+		imageSkip: "附件服务未挂载（ctx.attachments 不在）"
+	};
+	if (!attachments.imageLimits.mediaTypes.includes("image/png")) return {
+		image: null,
+		imageSkip: "本部署不收 image/png"
+	};
+	try {
+		if (!await routeDeclaresImage(ctx, exec)) return {
+			image: null,
+			imageSkip: "当前模型路由未声明图像输入（同 read_image 的门）"
+		};
+	} catch (err) {
+		return {
+			image: null,
+			imageSkip: `模型路由未能解析：${String(err?.message ?? err)}`
+		};
+	}
+	try {
+		const ref = await attachments.saveImage({
+			data: png,
+			mediaType: "image/png",
+			name: `${name}.png`
+		});
+		return {
+			image: {
+				attachmentId: ref.attachmentId,
+				mediaType: ref.mediaType,
+				bytes: ref.bytes,
+				width: ref.width,
+				height: ref.height,
+				name: ref.name ?? `${name}.png`
+			},
+			imageSkip: null
+		};
+	} catch (err) {
+		return {
+			image: null,
+			imageSkip: `附件服务拒收：${String(err?.message ?? err)}`
+		};
+	}
+}
+function createDiagramTool(ctx) {
+	return defineTool({
+		name: "diagram",
+		description: "Render a diagram from tag-format source into an image (in-process, no browser). Pass the source directly: a <diagram> root with <rect box=\"x0,y0,x1,y1\" label fill/>, <line>/<arrow from to> (endpoints may reference anchors like 德国.e or 波兰.n+3,0), <text x y align>, <color name value/>, <legend>. Returns the image in the conversation plus any authoring errors and four layout warnings (overlapping boxes / label overflow / dangling endpoints / a line crossing a label). A warning never blocks the image; an errored element is skipped and the rest still renders. Both the SVG and the PNG are written under _tmp/diagram/ in this container.",
+		parameters: {
+			source: {
+				type: "string",
+				required: true,
+				description: "Tag-format diagram source"
+			},
+			width: {
+				type: "integer",
+				description: `Output pixel width (default ${DEFAULT_WIDTH}; vector, so scaling is lossless)`
+			},
+			name: {
+				type: "string",
+				description: "Optional short name used in the output file name"
+			}
+		},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => {
+				const v = value;
+				const lines = [`图已生成（${v.marks} 个图元 ／ ${v.pxW}×${v.pxH} px ／ ${v.bytes} B PNG ／ 光栅化 ${v.ms} ms）`];
+				lines.push(`SVG: ${v.svgRel}`);
+				lines.push(`PNG: ${v.pngRel}`);
+				if (v.imageSkip !== null) lines.push(`⚠️ 未附图片块：${v.imageSkip}（PNG 已落盘，路径见上）`);
+				if (v.errors.length > 0) {
+					lines.push(`✗ 源码错误 ${v.errors.length} 条（图已尽力渲染；下列图元已跳过）`);
+					for (const e of v.errors) lines.push(`  [err] ${e}`);
+				}
+				if (v.lint.length === 0) lines.push("[lint] 体检干净（0 告警）");
+				else for (const w of v.lint) lines.push(`  [lint] ${w}`);
+				const blocks = [{
+					type: "text",
+					text: lines.join("\n")
+				}];
+				if (v.image !== null) blocks.push({
+					type: "image",
+					attachment: { ...v.image }
+				});
+				return blocks;
+			}
+		},
+		async execute(args, exec) {
+			const root = cccRootForExec(exec);
+			if (root === null) throw new Error("diagram: 找不到 CCC 根（本会话缺 header.cwd）—— 产物必须落在容器内");
+			const src = typeof args.source === "string" ? args.source : "";
+			const name = typeof args.name === "string" && args.name.trim() !== "" ? args.name.trim() : "diagram";
+			const width = typeof args.width === "number" && Number.isFinite(args.width) && args.width > 0 ? Math.round(args.width) : DEFAULT_WIDTH;
+			const parsed = parseDsl(src);
+			const rendered = renderDsl(parsed.model);
+			const { png, ms, width: pxW, height: pxH } = await rasterizeSvg(rendered.svg, width);
+			const rel = join("_tmp", "diagram");
+			const dir = join(root, rel);
+			mkdirSync(dir, { recursive: true });
+			const base = `${stamp()}-${name.replace(/[^\w\u4e00-\u9fa5-]/g, "_")}`;
+			writeFileSync(join(dir, `${base}.svg`), rendered.svg);
+			writeFileSync(join(dir, `${base}.png`), png);
+			const { image, imageSkip } = await attachPng(ctx, exec, png, base);
+			return {
+				name: base,
+				svgRel: join(rel, `${base}.svg`),
+				pngRel: join(rel, `${base}.png`),
+				lint: rendered.lint,
+				errors: [...parsed.errors, ...rendered.errors],
+				marks: rendered.marks,
+				ms,
+				bytes: png.length,
+				pxW,
+				pxH,
+				image,
+				imageSkip
+			};
+		}
+	});
+}
+//#endregion
 //#region src/host/storage-domain.ts
 /**
 * host/storage-domain.ts — 宿主存储域上的「会话 ↔ 轨迹」绑定表（§0L，S142 2026-09-19）
@@ -18988,6 +20323,7 @@ const Config = z.object({
 	webFetch: z.object({ enabled: z.boolean().default(true) }),
 	opencodeProvider: z.object({ autoConfigure: z.boolean().default(true) }),
 	visionPatch: z.object({ enabled: z.boolean().default(true) }),
+	diagram: z.object({ enabled: z.boolean().default(false) }),
 	humanChannel: z.object({
 		accounts: z.array(humanChannelAccountSchema).default([]),
 		subscriptions: z.array(humanChannelSubscriptionSchema).default([]),
@@ -19002,7 +20338,8 @@ const Config = z.object({
 	acpHttpPort: z.number().min(1024).max(65535).volatile(),
 	publicAskEnabled: z.boolean().volatile(),
 	croEnabled: z.boolean().volatile(),
-	unattendedEnabled: z.boolean().volatile()
+	unattendedEnabled: z.boolean().volatile(),
+	diagramEnabled: z.boolean().volatile()
 });
 function apply(ctx, config) {
 	try {
@@ -19051,6 +20388,7 @@ function apply(ctx, config) {
 		registerVoyageApi(ctx);
 	}
 	registerSettingsSection(ctx, config);
+	if (config.tools) registerDiagramTool(ctx);
 	registerGateway(ctx);
 	registerRebuildTurnHook(ctx);
 	registerOutputGuardHook(ctx);
@@ -19071,6 +20409,26 @@ function apply(ctx, config) {
 	if (config.visionPatch?.enabled !== false) registerDeepseekVisionPatch(ctx, true);
 }
 /**
+* diagram 工具装配（**D104**，2026-09-29 owner 具名令）：**默认关**的实验性工具 ⇒ 关时**不注册**。
+*
+* 归属与边界（E↑）：**机制归 ACC**（工具面 ＋ 开关 ＋ 光栅化），**图的语义归调用方**
+* （标签语法与四项体检在 `src/diagram/`，权威设计 = 插件仓 `docs/diagram-tool-feasibility.md`）。
+*
+* 🔴 **两条被实测钉住的接线前提**（改这里之前先读）：
+*  ① 必须**晚于** `registerSettingsSection`（开关值经 `readSimpleSettings()`，源在那里接上）；
+*  ② 注册失败**不得**成为启动单点（同 `hostContractReport` 的口径），但要**响亮**——
+*     静默失败会让"拨了开关没反应"看起来像开关坏了（判据：**失败必须可见**）。
+* @param ctx - 插件上下文
+*/
+function registerDiagramTool(ctx) {
+	if (!readSimpleSettings().diagramEnabled) return;
+	try {
+		ctx.tools.register(createDiagramTool(ctx));
+	} catch (err) {
+		console.error(`[serenity-hooks] ✗ diagram 工具注册失败: ${String(err?.message ?? err)}`);
+	}
+}
+/**
 * F4 Skiff 调试服务装配：启停 = 人工（设置面板 Skiff 区块开关，settings 持久化）。
 * settings-changed 事件触发同步（skiffEnabled 开 → 启动调试服务；关 → 停止）。
 * 角色配置（skiff.roles）从当前 CCC 根读取（含 skiff.roles 的 CCC 优先，进程 cwd 次之）。