@shgroup/dsh-serenity-hooks 1.50.0 → 1.50.1

package/dsh.plugin.json

@@ -1,10 +1,10 @@
 {
   "id": "dsh-serenity-hooks",
-  "version": "1.50.0",
+  "version": "1.50.1",
   "main": "lib/index.js",
-  "description": "宁静号 ACC harness（Native Cordis 插件）：给 DSH 装一个「AI 工作区」——11 个工具（container_fs/container_trajectory/dashboard/container_git/msm/praxis/handyman/localstore/container_admin/im-bridge/acc-diag；后两个按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫）+ 轨迹日志与原地重建 + 网页登录入口/微信桥/子角色/对外问答页/trajectory 唤醒注册表。适配 DSH 0.1.5-rc.2（deepseek-ai/deepseek-harness）。",
+  "description": "宁静号 ACC harness（Native Cordis 插件）：给 DSH 装一个「AI 工作区」——11 个工具（container_fs/container_trajectory/dashboard/container_git/msm/praxis/handyman/localstore/container_admin/im-bridge/acc-diag；后两个按配置条件出现）+ 机械约束（安全模式/工作区围墙/密钥守卫）+ 轨迹日志与原地重建 + 网页登录入口/微信桥/子角色/对外问答页/trajectory 唤醒注册表。适配 DSH 0.1.7-rc.1（deepseek-ai/deepseek-harness）。",
   "engines": {
-    "dsh": ">=0.1.5-rc.2"
+    "dsh": ">=0.1.7-rc.1"
   },
   "contributes": {
     "tools": [

package/lib/host/contract.d.ts

@@ -61,8 +61,40 @@ type HostEventName = (typeof HOST_EVENT_NAMES)[number];
  * dsp 订阅的宿主事件清单（与 HOST_EVENT_NAMES 同源；impact/site 供 health 报告与文档）。
  */
 export declare const HOST_EVENTS: readonly HostEventContract[];
-/** dsp 被验证过的宿主版本范围（与 package.json peerDependencies 同源，单一真相源） */
-export declare const REQUIRED_HOST_RANGE = "^0.1.7-rc.1";
+/**
+ * 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`。
+ */
+export declare const VERIFIED_HOST_BANDS: readonly {
+    floor: string;
+    ceiling: string;
+}[];
+/**
+ * 与 `package.json` 的 `peerDependencies` **逐字同串**的宿主版本范围（由 {@link VERIFIED_HOST_BANDS} 派生）。
+ *
+ * 🔴 这个字符串**就是**宿主门（`evaluatePluginCompatibility`）拿去跑 `semver.satisfies` 的那个串
+ * ⇒ 它与档表**必须一致**（"声明 union、判定单档"是一种自相矛盾）。
+ * 一致性由 `tests/host-contract.test.ts` 的**跨文件对账用例**钉住（读 package.json 逐字比对）。
+ */
+export declare const REQUIRED_HOST_RANGE: string;
 interface HostContractIssue {
     id: string;
     kind: 'service' | 'member' | 'version';
@@ -80,13 +112,14 @@ export interface HostContractReport {
 /** 最小 semver 比较（无依赖）：返回 -1 / 0 / 1；解析失败返回 null */
 export declare function compareSemver(a: string, b: string): number | null;
 /**
- * 宿主版本是否落在 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 语义**（本条只做"区间内/外"），这也是必须逐档判的原因。
  */
 export declare function checkHostVersion(version: string | null): {
     ok: boolean;

package/lib/human-channel.d.ts

@@ -18,9 +18,15 @@
  * `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`），可独立单测。
  */
+import type { HumanChannelSubscriptionSettings } from './settings-section.js';
 /** 一个"想为该账号起 poller"的请求（来自某 CCC） */
 export interface PollerRequest {
     /** 发起方 CCC 根（绝对路径） */
@@ -87,3 +93,126 @@ export declare function releasePollersOf(root: string): number;
 export declare function releaseAllPollers(): void;
 /** 测试专用：复位进程级归属表（生产零调用） */
 export declare function __resetPollersForTest(): void;
+/** 订阅表里**完好**的一行（四个字段全部非空） */
+export interface SubscriptionHit {
+    account: string;
+    user: string;
+    ccc: string;
+    role: string;
+}
+/**
+ * 订阅表里的**残缺行**（缺字段）。
+ * 🔴 它**不是**"未命中"（见上）；且**与是否命中无关** —— 表里只要有残缺行就要出声，
+ * 否则"命中了一条完好的"会让人以为整张表是干净的。
+ */
+export interface SubscriptionDefect {
+    /** 行序（0 基）—— 报错要指得出是**哪一行** */
+    index: number;
+    /** 缺哪些字段（`account` ／ `user` ／ `ccc` ／ `role`） */
+    missing: string[];
+    /** 行里**已有**的字段（残缺行的可见部分：让人认得出是哪一行） */
+    present: Record<string, string>;
+}
+export interface SubscriptionLookup {
+    /** 命中的行（未命中 ⇒ `null`） */
+    hit: SubscriptionHit | null;
+    /** 表里残缺的行（**与是否命中无关**，一律要出声） */
+    defects: SubscriptionDefect[];
+    /** 表里**完好**的行数（供调用方区分"表是空的"与"表里没有你"） */
+    usable: number;
+}
+/**
+ * 订阅表查询（**纯函数**）。
+ *
+ * 匹配两段式（**刻意对齐**旧 `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
+ */
+export declare function lookupSubscription(subscriptions: readonly HumanChannelSubscriptionSettings[], account: string, user: string): SubscriptionLookup;
+/** 入站投递目标**从哪来**（判据用；也是"这条消息为什么被投到这里"的可重建依据） */
+export type InboundRouteSource = 'machine' | 'ccc-fallback';
+/** 未投递的原因（两档，措辞刻意不同 —— 见 `planInboundRoute`） */
+export type InboundSkipReason = 'no-subscription' | 'no-match';
+export interface InboundRoutePlan {
+    /** 投递目标（`null` ⇒ **不投递**） */
+    target: {
+        ccc: string;
+        role: string;
+    } | null;
+    /** 目标出处（`null` ⇔ `target === null`） */
+    source: InboundRouteSource | null;
+    /** 未投递的原因（`target !== null` ⇒ `null`） */
+    skipReason: InboundSkipReason | null;
+    /** 订阅表里残缺的行（**与是否命中无关**，一律要出声） */
+    defects: SubscriptionDefect[];
+}
+/**
+ * 入站路由决策（**纯函数**）。
+ *
+ * 顺序：**机器级订阅表优先** → 未命中时用 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` ／ 省略
+ */
+export declare function planInboundRoute(input: {
+    subscriptions: readonly HumanChannelSubscriptionSettings[];
+    account: string;
+    user: string;
+    fallback?: {
+        ccc: string;
+        role: string;
+    } | null;
+}): InboundRoutePlan;
+/**
+ * 留痕落点：`$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` 同款推导）。
+ */
+export declare function humanChannelAuditPath(): string;
+/**
+ * 留痕事件。
+ * 🔴 **刻意不记消息正文**：方案 §3.1 要的是"**谁**发的、**为什么**没投" —— 正文既不必要，
+ * 又会把人说的话抄进一个机器级文件（本该只落在他自己 CCC 的日志里）。
+ */
+export type HumanChannelAuditEvent = {
+    kind: 'inbound-unrouted';
+    account: string;
+    user: string;
+    reason: InboundSkipReason;
+    detail: string;
+} | {
+    kind: 'inbound-target-missing';
+    account: string;
+    user: string;
+    ccc: string;
+    role: string;
+    detail: string;
+} | {
+    kind: 'subscription-defect';
+    account: string;
+    index: number;
+    missing: string[];
+    present: Record<string, string>;
+};
+/**
+ * 追加一条留痕。**永不抛** ——
+ * 留痕失败绝不能反过来打断投递（它是**旁路**，与 `invokeWeixinHook` 的"旁路容忍"同款）。
+ * 🔴 **不静默的是它记的那件事**，不是它自己：所以调用方仍要**另行 `console` 出声**。
+ */
+export declare function appendHumanChannelAudit(event: HumanChannelAuditEvent): void;

package/lib/index.js

@@ -9889,12 +9889,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"));
@@ -11017,12 +11069,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 +11130,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 +16023,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 +16123,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 +16540,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 +16548,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 +16616,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 +16631,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 +16675,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-Duk89a-h.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 +16791,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 +16831,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 +16990,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 +17076,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-Duk89a-h.js").then((n) => n.a);
+			for (const entry of await listCccs(ctx)) syncCccBridge(ctx, entry.root);
+		} catch {}
+	})();
+}
 /**
 * 解析该 CCC 的发送账号 + 凭据（v1.31.0：文本与文件发送的**单一账号选择真相源**）。
 * 顺序：桥启用 → 有启用账号 → 指定账号存在 → 凭据已绑定（扫码）。
@@ -16778,35 +17270,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

package/lib/status.d.ts

@@ -4,10 +4,37 @@
  * WebUI 停靠栏的数据源：ACC 版本 / CCC 根 / safe-mode 状态 / 黑名单 / keeper 阈值 / handyman 模型。
  * setSafeMode 直接读写 .serenity-safe-on 标记（守卫实时读取，写即生效）。
  */
+/**
+ * 🔴 **布局无关档**：从**正在跑的那个入口脚本**反推宿主包根，读它的 `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]`（单测直接注入，无需替身）
+ */
+export declare function dshVersionFromEntry(entry: string | undefined): string | 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**（单测、嵌入式、将来别的宿主进程）——
+ *     那时"本机装了哪个版本"仍需一个答案，只是证据等级更低。
  */
 export declare function readDshVersion(): string | null;
 interface SerenityStatus {

package/lib/weixin-bridge.d.ts

@@ -19,6 +19,7 @@
 import type { Context } from 'cordis';
 import { type WeixinAccountCredential } from './weixin-route.js';
 import { type WeixinMessage } from './weixin-api.js';
+import { type SkiffRoleConfig } from './skiff-role.js';
 /** 测试辅助：清空 typing_ticket 缓存（生产零调用） */
 export declare function resetWeixinTypingCache(): void;
 /**
@@ -36,6 +37,15 @@ export declare function manualOutputFallbackNeeded(input: {
     sentThisTurn: boolean;
     answer: string;
 }): boolean;
+/**
+ * 路由解析结果：目标根 ＋ 角色名 ＋ **角色配置**（三者一起给，避免调用方再读一次 skiff.roles）。
+ * `null` 从本函数出去 ⇒ **不投递**（未命中已留痕 ／ 目标不存在已响亮出声）。
+ */
+interface ResolvedInboundTarget {
+    root: string;
+    roleName: string;
+    role: SkiffRoleConfig;
+}
 /**
  * 处理单条微信消息：路由 → skiff 会话（固定 id 创建/延续）→ 提问 → 回复回写。
  *
@@ -53,8 +63,38 @@ export declare function manualOutputFallbackNeeded(input: {
  *   `_tmp/weixin-inbound/<userhash>/` → question 注入「存在性 + 路径」（ACC 层只保证
  *   可达性——"让会话知道文件的存在并可以拿到"；识别/解析归角色 LLM 决策，不编排）。
  *   降级不静默：下载失败 / 超 20MB → 注入说明进对话；typing 窗口覆盖下载（M7）。
+ *
+ * 🔴 **P0-3（2026-09-27）：路由改由机器级订阅表决定**（本函数的 `root` 入参退为
+ * **回退目标**）。两档语义刻意分开（方案 §3.1）：**未命中 ⇒ 不投递 ＋ 留痕**（静默档）；
+ * **目标不存在（CCC ／ 角色）⇒ 响亮报错**（`console.error` ＋ 机器级留痕）。两者都
+ * **不是**"投给默认角色"。
  */
-export declare function handleIncoming(ctx: Context, root: string, accountId: string, cred: WeixinAccountCredential, msg: Pick<WeixinMessage, 'from_user_id' | 'context_token' | 'item_list'>): Promise<void>;
+export declare function handleIncoming(ctx: Context, root: string, accountId: string, cred: WeixinAccountCredential, msg: Pick<WeixinMessage, 'from_user_id' | 'context_token' | 'item_list'>, 
+/**
+ * **机器级模式**（P0-3 A）：目标已由 `handleMachineIncoming` 解析好（`root` 入参即该目标根）。
+ * 给了它 ⇒ 本函数**不再自行路由**，且**不看本 CCC 的 `weixin.enabled`** ——
+ * 起 poller 与路由都已上移机器级（目标 CCC 没配 weixin 段也照样收得到）。
+ * ⚠️ **行为开关仍归目标 CCC**（`hook` ／ `autoReplyWithLastMessage` ／ `fallbackOnNoSend`）
+ * —— 机器级只管"**谁收**"与"**投到哪**"，不管"**怎么答**"。
+ */
+preset?: {
+    target: ResolvedInboundTarget;
+}): Promise<void>;
+/**
+ * **机器级 poller 的单条消息入口**（P0-3 A）。
+ *
+ * 与 `handleIncoming` 的唯一差别：**目标由机器级订阅表逐条解析，且没有 CCC 级回退**
+ * （方案 §3.1：机器级模式下**未命中 = 不投递**，不是"投给默认角色"）。
+ * 解析出来后把**目标根**当 `root` 交给 `handleIncoming`（并带上 `preset` ⇒ 它不再自行路由、
+ * 也不看目标 CCC 的 `weixin.enabled`）。
+ *
+ * 🔴 为什么"起 poller"与"路由"必须同批（本件即 P0-2 的后半）：机器级 poller 收到消息时
+ * **不知道它属于哪个 CCC** —— 那个答案是订阅表给的。没有订阅表 ⇒ **能收不能投**。
+ *
+ * 🔵 **导出供测试直接驱动**（与 `handleIncoming` 同款：它俩都是"单条消息的入口"，
+ * 生产路径 `runAccountLoop` 只是循环壳）。
+ */
+export declare function handleMachineIncoming(ctx: Context, accountId: string, cred: WeixinAccountCredential, msg: Pick<WeixinMessage, 'from_user_id' | 'context_token' | 'item_list'>): Promise<void>;
 /**
  * 启动/重建某 CCC 的桥：读配置 → 对每个 enabled + 有凭据的账号启动轮询循环。
  * 已存在（配置变化热重建）→ 先停旧循环再启动新的。
@@ -68,9 +108,19 @@ export declare function syncCccBridge(ctx: Context, root: string): void;
 /** 停止某 CCC 的桥（移除账号/禁用时）；同时释放它的账号归属 */
 export declare function stopCccBridge(root: string): void;
 /**
- * 停止全部桥（插件 dispose）
+ * 停止全部桥（插件 dispose）：CCC 级 ＋ 机器级
  */
 export declare function stopAllBridges(): void;
+/**
+ * 人机信道的**装配入口**（P0-3 A）—— 决定用哪种模式起 poller。
+ *
+ * 🔴 **模式由机器级账号表决定**（方案 §11.3 **Q5** 的过渡期语义）：
+ *  - 账号表**非空** ⇒ **机器级模式**：按账号起 poller；路由**只认订阅表**
+ *  - 账号表**为空** ⇒ **回退模式**（今天的形态）：按 CCC 起桥；路由**先查订阅表，未命中回退
+ *    到 CCC 级 routes** ⇒ **不打断在用的微信**
+ * ⚠️ 两种模式**互斥**（各自进入时先停掉另一种），否则同一个 bot 会被两处轮询。
+ */
+export declare function syncHumanChannel(ctx: Context): void;
 /** 主动发送失败原因（稳定 code——入口层翻译成 HTTP 状态 + 可行动提示） */
 type ProactiveSendErrorCode = 'BRIDGE_DISABLED' | 'NO_ACCOUNT' | 'ACCOUNT_NOT_FOUND' | 'ACCOUNT_NOT_BOUND' | 'SEND_FAILED';
 interface ProactiveSendInput {
@@ -129,7 +179,11 @@ type WeixinAccountResolution = {
  */
 export declare function resolveWeixinAccount(root: string, accountId?: string): WeixinAccountResolution;
 export declare function sendProactiveText(input: ProactiveSendInput): Promise<ProactiveSendResult>;
-/** 桥状态快照（面板数据源）：每 CCC → 每账号 → 轮询健康 */
+/**
+ * 桥状态快照（面板数据源）：每 CCC → 每账号 → 轮询健康。
+ * 🔴 **P0-3 A 起多一行**：机器级 poller 以 `ccc: '<machine>'`（`MACHINE_SCOPE`）出现 ——
+ * 它**不属于任何 CCC**，故**不伪装成某个 CCC 的行**（面板按原样显示这个哨兵值即可）。
+ */
 export declare function weixinBridgeStatus(): Array<{
     ccc: string;
     accounts: Array<{
@@ -139,8 +193,9 @@ export declare function weixinBridgeStatus(): Array<{
     }>;
 }>;
 /**
- * 装配（index.ts 调用）：扫描 live CCC 启动桥 + 监听会话变化。
- * 事件驱动（对齐 autotrajectory v1.26.15）：live 会话出现 → 同步该 CCC 桥。
+ * 装配（index.ts 调用）：**按机器级配置决定模式**（P0-3 A：`syncHumanChannel`），
+ * 并监听会话变化以重扫（新 CCC 出现即启动其桥；配置变化也可经此路径热重建）。
+ * 事件驱动（对齐 autotrajectory v1.26.15）。
  */
 export declare function registerWeixinBridge(ctx: Context): void;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shgroup/dsh-serenity-hooks",
-  "version": "1.50.0",
+  "version": "1.50.1",
   "description": "宁静号 ACC harness（Native Cordis 插件）——给 DeepSeek Harness 装一个「AI 工作区」：11 个工具（container_fs/container_trajectory/dashboard/container_git/msm/praxis/handyman/localstore/container_admin/im-bridge/acc-diag）+ 机械约束（安全模式/工作区围墙/密钥守卫/对外输出守卫）+ 工作日志与原地重建 + 网页登录入口/微信桥/子角色/对外问答页/trajectory 唤醒注册表。适配 DSH 0.1.7-rc.1。",
   "license": "MIT",
   "repository": {
@@ -54,21 +54,21 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-agent": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-agent-loop": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-agent-preset-registry": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-compaction": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-session-title": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-shell": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-shell-env": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-skill": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-web": "^0.1.7-rc.1",
-    "@deepseek-ai/dsh-web-fetch-http": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-agent": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-agent-loop": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-agent-preset-registry": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-compaction": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-session": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-session-title": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-shell": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-shell-env": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-skill": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-web": "^0.1.7-rc.1 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-web-fetch-http": "^0.1.7-rc.1 || ^0.2.0-rc.1",
     "@deepseek-ai/schemastery": "^3.18.4",
     "cordis": "^4.0.0-rc.7"
   },