@dsh-sup/dsh-core-linux-x64 0.1.6-BETA.1 → 0.1.6-BETA.2

package/core.cjs

@@ -15,10 +15,10 @@ var require_exec = __commonJS({
     function options(opts) {
       const o = opts || {};
       return {
-        // timeout 是历史别名：service.js 曾传 { timeout } 而被静默忽略，所有超时回落默认值（N1）。
+        // timeout 是历史别名（兼容旧调用点拼写，若不与 timeoutMs 归一会被静默忽略）：
         // 两种拼写都收，timeoutMs 优先；新调用一律用 timeoutMs。
         timeout: o.timeoutMs || o.timeout || DEFAULT_TIMEOUT_MS,
-        // 必须 SIGKILL：SIGTERM 对挂起或被停住的进程可能无效，否则有超时等于没超时。
+        // 必须 SIGKILL：SIGTERM 对挂起或被停住的进程可能无效。
         killSignal: o.killSignal || "SIGKILL",
         maxBuffer: o.maxBuffer || DEFAULT_MAX_BUFFER,
         stdio: o.stdio || ["ignore", "pipe", "pipe"],
@@ -195,9 +195,8 @@ var require_config = __commonJS({
     }
     var BASE_DEFAULTS = {
       probeIntervalMs: 5e3,
-      // 健康探测（三层）：L0 进程存活 + L1 端口监听 + L2 HTTP GET healthUrl。probeTimeoutMs = 单次
-      // HTTP 探测超时；failThreshold = 连续失败次数判故障（防抖动）；httpProbeEnabled=false 时
-      // 退化为端口在线即健康。
+      // 健康探测三层：L0 进程存活 + L1 端口监听 + L2 HTTP GET healthUrl。probeTimeoutMs = 单次探测超时；
+      // failThreshold = 连续失败判故障（防抖动）；httpProbeEnabled=false 退化为端口在线即健康。
       probeTimeoutMs: 3e3,
       failThreshold: 2,
       httpProbeEnabled: true,
@@ -208,18 +207,14 @@ var require_config = __commonJS({
       crashBurst: 5,
       backoff: [3e4, 6e4, 12e4, 3e5, 6e5],
       apiHost: "127.0.0.1",
-      // API 端口：高位不常用段起始（3100 常用端口易冲突）。守卫启动被占则自动顺延并持久化。
+      // API 端口：高位不常用段起始（常用端口段易冲突）；守卫启动被占则自动顺延并持久化。
       apiPort: 36360,
-      // 注意：daemon 控制通道端口（43107/43108）属业务域知识，已反转至 app/settings/domain-config.js，
-      // 经 normalize/buildDefaults 的第二参注入；原键名与值逐字保留，消费方零改动。
-      // 动态端口池（范围是配置项，非编译期常量）。默认避开 OS 动态端口范围
-      // （Linux ip_local_port_range=32768-60999），落在 IANA User 段低位供监听池使用。
-      // managed = relay/proxyInstance/oauthCallback 共享池；providerApi = 智能路由供应商独立端点池。
-      // null = 内置默认池。
+      // 注意：daemon 控制通道端口属业务域知识，经注入声明提供（同上），原键名与值逐字保留。
+      // 动态端口池（范围是配置项，非编译期常量）：null = 内置默认池，默认避开 OS 动态端口范围
+      // （Linux ip_local_port_range=32768-60999），落在 IANA User 段低位。额外池由域装配期申报（DS-G4）。
       portPools: null,
       stateFile: path2.join(SUP, "state.json"),
-      // 日志目录布局：log/ 与 events/ 分目录；守卫事件在 events/guard.events.log、分级日志在 log/guard.log。
-      // 显式配置（既有 config.json / 测试）仍尊重用户给定路径，不强行改写。
+      // 日志目录布局：事件在 events/guard.events.log，分级日志在 log/；显式配置的路径尊重用户给定值，不强改。
       logFile: path2.join(SUP, "events", "guard.events.log"),
       eventsMaxBytes: 5 * 1024 * 1024,
       supervisorLogFile: path2.join(SUP, "log", "guard.log"),
@@ -228,22 +223,17 @@ var require_config = __commonJS({
       logLevel: "info",
       logMaxBytes: 5 * 1024 * 1024,
       notifyEnabled: true,
-      // 注意：routerAutostart（智能路由启动开关）同属业务域知识，经注入声明提供。
-      // 内核更新单写入者 = 桌面壳：corePackageName 为内核自身 npm 子包名，守卫只读它查询版本状态，
-      // 安装/升级由桌面壳执行（见 RELEASE-AND-UPDATE-MECHANISM.md）。
+      // 内核更新单写入者 = 桌面壳：corePackageName 仅为内核自身 npm 子包名，守卫只读它查版本状态，
+      // 安装/升级由壳执行。不得再引入 manifest 更新通道（残留键已删，config.json 中未知键加载时忽略）。
       corePackageName: null,
-      // 旧 manifest 模式的残留键 selfUpdateManifestUrl / selfUpdateDir 已删除（全仓无赋值点）。
-      // 既有用户 config.json 若仍含这两键，加载时忽略即可（未知键不报错）；新代码不得再引入 manifest 更新通道。
       pluginsProfileName: "web",
       packageName: "@deepseek-ai/dsh",
-      // 灰度名单（RELEASE-CHANNEL-CONTRACT）：本机配置 canary:true 即视为灰度机，仅对我们的内核包生效，
-      // 对第三方包（packageName）无效；名单否定优先：未置真即非灰度。
+      // 灰度名单（RELEASE-CHANNEL-CONTRACT）：本机 canary:true 即灰度机，仅对内核包生效，对第三方包
+      // （packageName）无效；未置真即非灰度。
       canary: false,
-      // 最小兜底镜像源。完整目录与探测规格是壳的产物：用户在装壳那刻机器上
-      // 没有内核，壳必须先完成镜像选择才能装内核，故镜像源管理所有权在壳，经
-      // <产品状态根>/supervisor/registry.json 投放，内核由 platform/distribution 读取
-      // （见 platform/contract/registry.js）。此处仅保留官方源（能上网）+ npmmirror（中国网络）两条，
-      // 覆盖契约不可用时也能跑这一底线（不变量 C2）。
+      // 最小兜底镜像源（不变量 C2）：完整目录归壳管理，经 <产品状态根>/supervisor/registry.json 投放，
+      // 内核由 platform/distribution 读取（契约见 platform/contract/registry.js）；
+      // 此处官方源 + npmmirror 两条兜底，保证契约不可用时仍可安装。
       registries: [
         "https://registry.npmjs.org",
         "https://registry.npmmirror.com"
@@ -253,12 +243,11 @@ var require_config = __commonJS({
       initialCheckDelayMs: 2e4,
       upgradeTimeoutMs: 6e5,
       installCommandTemplate: ["npm", "install", "-g", "{pkg}@{version}"],
-      // apiAccessKey（可选）：出回环访问密钥。仅当配置了该键时，0.0.0.0（局域网）与 FRP 公网通道
-      // 的 API 请求必须携带 Authorization: Bearer <key> 或 ?access_key=<key>，否则 401；
-      // 本地回环豁免。不配置 = 维持现状（LAN 受 RFC1918 白名单约束，FRP 暴露仍强制 remoteToken）。
+      // apiAccessKey（可选）出回环访问密钥：配置后，0.0.0.0（局域网）与 FRP 公网通道的 API 请求必须携带
+      // Authorization: Bearer <key> 或 ?access_key=<key>，否则 401；回环豁免。
+      // 不配置 = LAN 受 RFC1918 白名单约束，FRP 暴露仍强制 remoteToken。
       apiAccessKey: null,
-      // 关闭窗口行为（系统级）：'hide' = 隐藏至系统托盘（默认，服务继续常驻）；
-      // 'exit' = 退出管家，结束壳并停止全部服务链。
+      // 关闭窗口行为（系统级）：'hide' = 隐藏至托盘、服务常驻（默认）；'exit' = 退出管家并停全部服务链。
       closeAction: "hide"
     };
     function buildDefaults2(ext) {
@@ -337,7 +326,7 @@ var require_domain_config = __commonJS({
     var defaults = [
       {
         at: "portPools",
-        // daemon 控制通道端口（router/lan 独立进程 ctl）：集中定义，杜绝散落硬编码。
+        // daemon 控制通道端口：集中定义，杜绝散落硬编码。
         // 这两个值同时是 app/ctl/client.js 与两个 daemon 的兜底端口，不得单独改动
         //   （改动即需同步 8 处 43107/43108 兜底常量）。
         values: {
@@ -347,7 +336,7 @@ var require_domain_config = __commonJS({
       },
       {
         at: "corePackageName",
-        // 智能路由启动开关（别名见下方 aliases）。
+        // 智能路由启动开关。
         values: {
           routerAutostart: false
         }
@@ -373,7 +362,7 @@ var require_version = __commonJS({
     var fs2 = require("node:fs");
     var path2 = require("node:path");
     function guardVersion() {
-      if (true) return String("0.1.6-BETA.1");
+      if (true) return String("0.1.6-BETA.2");
       try {
         return JSON.parse(fs2.readFileSync(path2.join(__dirname, "..", "..", "package.json"), "utf8")).version || "unknown";
       } catch {
@@ -2248,7 +2237,7 @@ var require_events = __commonJS({
         }
         return max;
       }
-      // 条 13)：文件实际最大 seq —— 只读尾部（append-only + seq 单调 => 末行即最大）。
+      // 文件实际最大 seq —— 只读尾部（append-only + seq 单调，末行即最大）。
       // 末行不可解析（截断起点落在行中 / 崩溃残留半行）时从后往前找首条完整记录；
       // 整段都解析不出（文件为空/刚轮转走）才回退 _maxSeq() 全扫描，含 .1 防与旧代重号。
       _fileMaxSeq() {
@@ -2708,8 +2697,8 @@ var require_hub = __commonJS({
     var { loadWatermark, saveWatermark } = require_watermark();
     var EventHub = class {
       // opts: stateDir 守卫状态目录（聚合流/水位落此）；guardEvents 守卫 Events 实例（源之一）；
-      // guardLogFile / dshLogFile / upgradeLogFile 守卫侧运行日志（/logs/tail 用）；
-      // daemonLogs / ctlPorts 按装配短键索引的 daemon 日志与 ctl 端口；logger 可选。
+      // guardLogFile/dshLogFile/upgradeLogFile 守卫侧运行日志（/logs/tail 用）；
+      // daemonLogs/ctlPorts 按装配短键索引；logger 可选。
       constructor(opts) {
         this.stateDir = opts.stateDir;
         this.aggBase = opts.aggBase || "state";
@@ -2738,7 +2727,7 @@ var require_hub = __commonJS({
         if (this.watermark[this._localSource] == null && this.guardEvents) this.watermark[this._localSource] = this.guardEvents.seq;
         this._tickSeq = 0;
       }
-      // 内部告警出口：可选 logger + 绝不抛（失败路径上的最后一环）。
+      // 内部告警出口：经可选 logger，绝不抛（失败路径上的最后一环）。
       _log(level, msg) {
         try {
           const lg = this.logger;
@@ -2787,7 +2776,7 @@ var require_hub = __commonJS({
         }
         return lastOkSeq;
       }
-      // 守卫事件推模式：守卫 Events.append 已同步调此，守卫事件零延迟入聚合流。
+      // 推模式：守卫 Events.append 已同步调此，守卫事件零延迟入聚合流。
       pushGuard(rec) {
         if (!rec || typeof rec.seq !== "number") return;
         if (rec.source === "guard-hub") return;
@@ -2878,7 +2867,7 @@ var require_hub = __commonJS({
       get seq() {
         return this.writer.seq;
       }
-      // /logs/tail：读各运行日志尾部。
+      // /logs/tail：dsh/upgrade 为预设流；守卫与业务流按注册源装配短键解析。
       tailLog(stream, n) {
         const fixed = { dsh: this.dshLogFile, upgrade: this.upgradeLogFile };
         if (stream in fixed) return tailFile(fixed[stream], n);
@@ -3466,9 +3455,9 @@ var require_alloc = __commonJS({
           }
         }
       }
-      /** 跨进程分配锁（best-effort，B14）。返回释放函数；获取超时返回 null 并**继续**
-       *  （fail-open 有界：登记后的「二次确认、被抢即撤销」复检是第二层防线，且 ports.json
-       *  读路径 reload 使外部分配可见 —— 宁可退化到复检层，也不让锁 IO 故障冻结分配）。 */
+      /** 跨进程分配锁（best-effort）。返回释放函数；获取超时返回 null 并继续（fail-open 有界：
+       *  登记后的「二次确认、被抢即撤销」复检是第二层防线，且 ports.json 读路径 reload 使外部
+       *  分配可见 —— 宁可退化到复检层，也不让锁 IO 故障冻结分配）。 */
       async _acquireXLock() {
         const f = String(this._registry._file || "") + ".alloc.lock";
         const deadline = Date.now() + XLOCK_TIMEOUT_MS;
@@ -3511,7 +3500,7 @@ var require_alloc = __commonJS({
           }
         }
       }
-      /** 登记 + 有界复检（B14 TOCTOU）：登记后端口若立刻被外部占用（bind 探测与登记间隙被抢），
+      /** 登记 + 有界复检（TOCTOU）：登记后端口若立刻被外部占用（bind 探测与登记间隙被抢），
        *  撤销登记并返回 false —— 宁可让调用方换下一个端口，也不留下必然失败的占用登记。
        *  self-listening 等「自己就在监听」的登记走 _register，不经本复检。 */
       async _confirmRegister(port, rangeKey, owner) {
@@ -3684,7 +3673,7 @@ var require_pool = __commonJS({
         if (pools && typeof pools === "object") this._pools = Object.assign({}, core.DEFAULT_POOLS, pools);
         return this._pools;
       }
-      /** 实例侧注册接口（委托模块级函数；段名/池名同样是域知识）。 */
+      /** 实例侧注册接口（委托 core 模块级函数）；段名/池名是域知识，不在本平台模块硬编码（DS-G4）。 */
       registerSegment(role, pool) {
         core.registerSegment(role, pool);
         return this;
@@ -3759,8 +3748,7 @@ var require_pool = __commonJS({
         }
         if (removed) this._save();
       }
-      /** 释放端口：不传 ownerId 按端口号；传了则仅当登记 owner 匹配才释放。
-       *  注意空值检查必须在 owner 比较之前（旧实现顺序反了会抛 TypeError）。
+      /** 释放端口：不传 ownerId 按端口号；传了则仅当登记 owner 匹配才释放。空值检查必须先于 owner 比较。
        *  @returns {boolean} 是否真的释放了一条记录 */
       release(port, ownerId) {
         const p = Number(port);
@@ -3787,8 +3775,8 @@ var require_pool = __commonJS({
         for (const r of this._records.values()) if (r.owner === owner) return r.port;
         return null;
       }
-      /** 端口是否被占用：已登记 交 本机实际监听；excludeOwner 仅豁免 registry 登记。
-       *  监听探测为**双栈回环**（127.0.0.1 并::1），不再漏 IPv6-only 监听者。 */
+      /** 端口是否被占用：已登记 或 本机实际监听；excludeOwner 仅豁免 registry 登记。
+       *  监听探测为双栈回环（127.0.0.1 并 ::1），不漏 IPv6-only 监听者。 */
       async isTaken(port, excludeOwner) {
         const rec = this._records.get(Number(port));
         if (rec && (!excludeOwner || rec.owner !== excludeOwner)) return true;
@@ -4548,7 +4536,7 @@ var require_watchdog = __commonJS({
           const r = await shell.restartShell({
             exePath: exe,
             procPattern,
-            // 在飞复判（K4）：杀旧壳与 spawn 之间有 ~8s 窗口，退出请求可能在窗口内到达。
+            // 在飞复判：杀旧壳与 spawn 之间有 ~8s 窗口，退出请求可能在窗口内到达。
             shouldAbort: typeof o.halted === "function" ? () => o.halted() : void 0
           });
           if (r && r.ok) {
@@ -4599,10 +4587,9 @@ var require_capability_profile = __commonJS({
   "src/platform/os/capability-profile.js"(exports2, module2) {
     "use strict";
     var linux = {
-      // 沙箱舱拆两字段（multiInstance 一字段混装「能否跑舱」与「有无 cgroup」，掩盖降级形状）：
-      // sandboxLaunch=能否运行实例舱；sandboxEnforcement=限额由谁执行（cgroup|supervise|none）。
+      // 两维拆分声明：sandboxLaunch = 能否运行实例舱；sandboxEnforcement = 限额由谁执行（cgroup|supervise|none）。
       sandboxLaunch: true,
-      // W3 起恒可跑舱：有 systemd-run 走 cgroup 硬档，无则落 portable 软档（容器/WSL1 解锁）
+      // W3：恒可跑舱；有 systemd-run 走 cgroup 硬档，无则落 portable 软档（容器/WSL1）
       sandboxEnforcement: "cgroup",
       // 期望 cgroup 硬限额；无 systemd-run 实测降 'supervise'（采样式，无内核强制）
       pidAdoption: true,
@@ -4640,8 +4627,8 @@ var require_capability_profile = __commonJS({
       // LaunchAgent RunAtLoad + KeepAlive
       guardSelfHeal: true,
       // KeepAlive
-      // 独立 LaunchAgent com.dsh.supervisor.gui（RunAtLoad）；守卫 plist 归桌面壳建立，
-      // 内核只 enable/disable（见 autostart.js 头注的所有权矩阵）。
+      // 壳自启 = 独立 LaunchAgent com.dsh.supervisor.gui（RunAtLoad），内核创建/删除；
+      // 守卫 plist 归桌面壳建立，内核只 enable/disable + bootstrap/bootout。
       shellAutostart: true,
       shellSelfHeal: true
       // 守卫看护（三平台一套机制）
@@ -4653,9 +4640,8 @@ var require_capability_profile = __commonJS({
       // 采样式限额；Job Object 硬档一期不做不预留（届时以真机数据另立项）
       pidAdoption: true,
       // netstat
-      // processTreeKill 已接入 _killTree（supervisor 的 SIGKILL 升级路径 + 接管实例路径），
       processTreeKill: true,
-      // taskkill /PID /T /F（由 hasTool 覆写；使用点见 main-process._killTree）
+      // taskkill /PID /T /F（hasTool 覆写；使用点见 app/main/signals.js 的 _killTree）
       desktopNotify: true,
       // 期望 powershell（实测覆写）
       autostart: true,
@@ -4663,13 +4649,12 @@ var require_capability_profile = __commonJS({
       frpExpose: true,
       hostService: "windows-service",
       guardAutostart: true,
-      // schtasks DSH-Supervisor（ONLOGON）
+      // schtasks DSH-Supervisor（ONLOGON，由壳建立）
       guardSelfHeal: true,
-      // schtasks DSH-Supervisor-Watchdog 每 5 分钟
+      // schtasks DSH-Supervisor-Watchdog 每 5 分钟（同样归壳，内核只查询存在性）
       shellAutostart: true,
-      // schtasks DSH-Supervisor-GUI（ONLOGON，由 setAutostart 建立）
-      // watchdog 的壳检查不再限定在守卫也挂的块内 —— 壳崩而守卫活正是唯一需要它的场景。
-      // 前置条件：登录自启已启用（watchdog 任务由 setAutostart 建立），与 guardSelfHeal 同前提。
+      // schtasks DSH-Supervisor-GUI（ONLOGON，内核 setAutostart 创建）
+      // 壳的自愈依赖那条 watchdog 任务，故与 guardSelfHeal 同前提：登录自启未启用时无从检查。
       shellSelfHeal: true
     };
     var unknown = {
@@ -5003,8 +4988,8 @@ var require_portable = __commonJS({
         return true;
       },
       /** 拉起：spawn(detached)——POSIX 自成进程组（kill(-pid) 语义的前提）、win32 windowsHide +
-       *  CREATE_NEW_PROCESS_GROUP（统一经 platform/os/spawn.js，NO-CONSOLE-WINDOW 纪律收口在那）。
-       *  props（cgroup 语义）在此被如实忽略——无内核强制可施加，处置归 governor 采样违规链。
+       *  CREATE_NEW_PROCESS_GROUP（NO-CONSOLE-WINDOW 纪律收口在 platform/os/spawn.js）。
+       *  调用方传来的 props（cgroup 语义）在此如实忽略：本档无内核强制可施加。
        *  @param {{cmd:string[], env?:object, workingDir?:string, pidFile?:string, port?:number, anchors?:string[]}} o */
       startTransient(o) {
         const opts = o || {};
@@ -5069,12 +5054,10 @@ var require_portable = __commonJS({
         }
         return false;
       },
-      /** 活跃判定（三态）：见文件头契约。无任何锚点（port 与 pidFile 都缺）= 无从查询 -> null，
-       *  绝不被删除保护路径当成「已停止」。
-       *  anchors 为空时降级为与 monitor.probeInstance 同一口径「端口有监听即活跃」（该调用方本就以此
-       *  判在线，如 waitPortHealthy）；杀进程（stopUnit）仍要求锚点命中，二者宽严不同是有意的：
-       *  判定可宽，动手必严。存活 pid 的 cmdline 读取失败 = 无法区分「他人复用」与「查询失败」
-       *  -> null（与 FIX-5 同一保守方向）。 */
+      /** 活跃判定（三态）：port 与 pidFile 都缺 = 无从查询 -> null，删除保护路径不得把它当「已停止」。
+       *  anchors 为空时降级为「端口有监听即活跃」（monitor.probeInstance 同口径，该调用方本就以此判在线）；
+       *  杀进程（stopUnit）仍要求锚点命中 —— 判定可宽，动手必严。
+       *  存活 pid 的 cmdline 读不到 = 分不清「他人复用」与「查询失败」-> null。 */
       isUnitActive(unit, o) {
         const opts = o || {};
         if (findOurs(opts)) return true;
@@ -5101,8 +5084,7 @@ var require_portable = __commonJS({
       transientUnitFile() {
         return null;
       },
-      /** 清理同名残留：先停掉仍活着的旧进程（重启自愈路径：旧进程未监听端口时端口探测拦不住），
-       *  再清 run.pid。返回形态与 systemd 档一致（{ok, errors}），调用方无需分支。 */
+      /** 清理同名残留：先停掉仍活着的旧进程（重启自愈路径：旧进程未监听端口时端口探测拦不住），再清 run.pid。 */
       cleanTransient(unit, o) {
         const opts = o || {};
         const errors = [];
@@ -5110,8 +5092,7 @@ var require_portable = __commonJS({
         removePidFile(opts);
         return { ok: errors.length === 0, errors };
       },
-      /** 运行期限额下发：portable 档恒 false（档位声明）。true/false 只表示「是否改动了内核强制」，
-       *  governor 不因 false 走任何降级分支——违规处置链本就平台无关。 */
+      /** 返回值只表示「是否改动了内核强制」；governor 不因 false 走降级分支 —— 违规处置链本就平台无关。 */
       setLimits() {
         return false;
       }
@@ -5166,15 +5147,14 @@ var require_service = __commonJS({
           return false;
         }
       },
-      // run() 失败返回 null 而不抛，故原 try/catch 是死代码、恒返回 true（N5）。如实回传成败。
+      // run() 失败返回 null 而不抛，try/catch 包裹会恒返回 true；如实回传成败。
       resetFailed(unit) {
         if (unitNameViolation(unit)) return false;
         return run("systemctl", ["--user", "reset-failed", unit], { timeoutMs: 1e4 }) !== null;
       },
       /** 单元活跃判定（三态）：确认 active -> true；确认不活跃 -> false；查询未完成 -> null（未知）。
-       *  旧实现把「查询未完成」折成 false，而 run() 失败只返回 null，于是
-       *  instance/ops.js 删除数据目录前的 null 保护成了不可达死分支，is-active 超时时仍会 rmSync
-       *  沙箱数据（FIX-5 A 的根因）。调用方按「!== false 才放行删除」消费本函数。 */
+       *  run() 失败只返回 null，「查询未完成」不可折成 false：instance/ops.js 删除数据目录前
+       *  按「!== false 才放行删除」消费本函数，折假即超时窗口内误删沙箱数据。 */
       isUnitActive(unit) {
         if (!unit) return true;
         if (unitNameViolation(unit)) return false;
@@ -5201,9 +5181,8 @@ var require_service = __commonJS({
       },
       /** 清理 stale transient 单元：stop/reset-failed/删单元文件/daemon-reload。
        *  必须 reload：删除文件后 systemd 仍缓存该单元为 loaded，否则 systemd-run 拒绝重建同名单元。
-       *  返回 {ok, errors}：原实现四步全由 try/catch 包裹，而 run() 失败只返回 null 不抛 —— 四步
-       *  全部静默，调用方无条件记「cleaned」日志（N5）。stop/reset-failed 对「从未加载的单元」非零
-       *  退出属正常，不计入 ok；真正的硬失败只有删单元文件与 daemon-reload。 */
+       *  返回 {ok, errors}：stop/reset-failed 对「从未加载的单元」非零退出属正常，不计入 ok；
+       *  硬失败只有删单元文件与 daemon-reload（run() 失败返回 null 不抛，成败须如实回传）。 */
       cleanTransient(unit) {
         const errors = [];
         const bad = unitNameViolation(unit);
@@ -5239,8 +5218,7 @@ var require_service = __commonJS({
         return true;
       },
       /** 运行期改限额（W3 动态化）：systemctl --user set-property 立即生效，无需重启单元。
-       *  必带 --runtime：transient 单元本不落盘，不带它会把 drop-in 写进用户配置目录，
-       *  与「每次启动按当时拓扑重算」的 governor 语义失同步（陈旧下限永久黏住）。
+       *  必带 --runtime：transient 单元本不落盘，不带它会把 drop-in 写进用户配置目录，陈旧下限永久黏住。
        *  值只来自 sandbox.unitProps 同源的 alloc（平台层翻译语义、不决定数额）。 */
       setLimits(unit, alloc) {
         if (unitNameViolation(unit)) return false;
@@ -5277,7 +5255,7 @@ var require_service = __commonJS({
         transientUnitFile() {
           return null;
         },
-        // 无 transient 单元可清 = 成功；返回形态与 systemd 一致，调用方无需分支（N5）。
+        // 无 transient 单元可清 = 成功；返回形态与 systemd 一致，调用方无需分支。
         cleanTransient() {
           return { ok: true, errors: [] };
         },
@@ -6108,17 +6086,17 @@ var require_os = __commonJS({
       processControl: require_process(),
       pidlookup: require_pidlookup(),
       execPath,
-      // 跨平台可执行解析（扩展名/PATHEXT/标准目录；hasTool 亦复用）
+      // 跨平台可执行解析
       fileProtect: require_file_protect(),
       // 跨平台文件保护（Unix chmod / Windows icacls）
       service: require_service(),
       // 服务管理器抽象（Provider 分派）
-      // notify 必须是直接可调函数：supervisor 按 platform.notify(title, body, onError) 调用，
-      // 导出模块对象会报 platform.notify is not a function，升级终态被误判为失败。
+      // notify 必须是直接可调函数：调用方按 platform.notify(title, body, onError) 用，
+      // 导出模块对象会抛 platform.notify is not a function，把升级终态误判成失败。
       notify: require_notify().notify,
       browser: require_browser(),
       desktop: require_desktop(),
-      // 图形会话可用性（Linux 需真判定，见 desktop.js）
+      // 图形会话可用性（Linux 需实测 socket）
       autostart: require_autostart()
     };
   }
@@ -6274,14 +6252,12 @@ var require_bootstrap = __commonJS({
           logger: host2.logger,
           events: host2.events,
           config: host2.config,
-          // 门**下沉到看护域**：tick() 的一切调用者都受同一门约束。
-          //   合取式收敛为单源谓词 host._shellExitIntended()
-          //   （通用退出 或 持久 _shellHalted）。壳看护是**桌面壳域**自愈，须含 shellHalted
-          //   （9-18：退出管家后守卫重启不得把壳拉回）；主 DSH 收敛用不含 shellHalted 的 _exitIntended。
+          // 退出门下沉到看护域：tick() 的一切调用者受同一门约束，合取式收敛为单源谓词
+          //   host._shellExitIntended()（通用退出 或 持久 _shellHalted）。壳看护属桌面壳域，
+          //   须含 shellHalted（退出管家后守卫重启不得把壳拉回）；主 DSH 收敛用 _exitIntended。
           halted: () => host2._shellExitIntended(),
           // 壳已在线 = 用户重新打开了壳 -> 清除持久退出标记（否则自愈被永久抑制）。
-          //    只在**非退出中**才清：退出握手期间壳还会存活数百 ms，若此时误清，
-          //   持久标记被写成 false，守卫重启后看护又把壳拉回（本修的核心场景）。
+          //   只在非退出中清：退出握手期间壳还会存活数百 ms，此时误清会让守卫重启后又把壳拉回。
           onShellAlive: () => {
             if (!host2._shellHalted) return;
             if (host2._stopping) return;
@@ -7118,7 +7094,7 @@ var require_runtime = __commonJS({
         npmPath: j.npmPath || npm.path || null,
         // 外壳可只提供包内 JS（npmPath=node，npmArgs=[npm-cli.js]），消费者必须带上 args。
         npmArgs: Array.isArray(j.npmArgs) ? j.npmArgs : Array.isArray(npm.args) ? npm.args : [],
-        // npm 版本由壳**真实执行** npm --version 得到；旧壳没有这个键时为 null（未知就是未知）。
+        // npm 版本由壳真实执行 npm --version 得到；旧壳无此键时为 null（未知就是未知）。
         npmVersion: typeof npm.version === "string" && npm.version || null,
         minNode: j.minNode || null,
         writtenBy: j.writtenBy || null,
@@ -7483,15 +7459,14 @@ var require_distribution = __commonJS({
       DistributionManager,
       semverCompare,
       VERSION_RE,
-      // 选版算法（release.js 唯一实现）+ 包归属判定 + rollback 防降级下限常量（RC-7 / A3-b）
+      // 选版算法（release.js 唯一实现）+ 包归属判定 + rollback 防降级下限常量（RC-7）
       pickReleaseVersion: release.pickReleaseVersion,
       isOurReleasePackage: release.isOurReleasePackage,
       OUR_RELEASE_SCOPE: release.OUR_RELEASE_SCOPE,
       ROLLBACK_FLOOR_VERSION: release.ROLLBACK_FLOOR_VERSION,
       ROLLBACK_MAX_AGE_DAYS: release.ROLLBACK_MAX_AGE_DAYS,
-      // 在途 npm 中止出口（D-10）：句柄登记在 install.js 的模块级集合（跨实例，覆盖全部调用路径），
-      // 故门面按**静态**导出，不挂 DistributionManager 实例方法——挂实例会漏掉直接 require('./install')
-      // 的调用方（app/native/installer.js 经 host.dist 走门面，但测试与未来 daemon 可直用）。
+      // 在途 npm 中止出口（D-10）：句柄登记在 install.js 的模块级集合（跨实例、覆盖全部调用路径），
+      // 故门面按静态导出而非实例方法——挂实例会漏掉直接 require('./install') 的调用方。
       killInflightNpm: install.killInflightNpm,
       inflightNpmCount: install.inflightNpmCount
     };
@@ -7728,9 +7703,9 @@ var require_scheduler = __commonJS({
     }
     module2.exports = {
       methods: {
-        /** tick 保留为 _dshConverge 别名（C3-3b G3）：外部收敛触发点（start 首拍 / setDesired /
-         *  requestRestart / _exitUpgradeHold）调用；shadow 模式下定时器也驱动此别名。
-         *  on 模式下 main 每拍收敛由 heartbeat 的 dsh supervise 调用 _dshConverge（无独立 tick 定时器）。 */
+        /** tick 保留为 _dshConverge 别名：外部收敛触发点（start 首拍 / setDesired / requestRestart /
+         *  _exitUpgradeHold）调用；shadow 模式的定时器也驱动此别名。on 模式下 main 每拍收敛由
+         *  heartbeat 的 dsh supervise 直接调 _dshConverge（无独立 tick 定时器）。 */
         async tick() {
           const d = depsOf(this);
           return d.main().converge();
@@ -7791,7 +7766,7 @@ var require_instance_adapter = __commonJS({
           logger: () => host2.logger,
           control: () => host2.control,
           managedObjects: () => host2.managedObjects,
-          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用）。
+          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用）
           syncSandboxRegistryEntry: (entry) => host2._syncSandboxRegistryEntry(entry)
         };
         DEPS.set(host2, d);
@@ -7800,11 +7775,10 @@ var require_instance_adapter = __commonJS({
     }
     module2.exports = {
       methods: {
-        /** 沙箱实例监督单拍（v3 R3 C3-4a observe -> C3-4b supervise 接管）：heartbeat 经 adapter
-         *  对每个沙箱实例执行监督收敛（InstanceManager.supervise 单实例状态机，语义=旧 tick per-instance），
-         *  并把目录项与实例域状态对齐（desired/phase/guardian——目录=真实视图，防 ghost/死登记）。
-         *  域业务 CRUD/安装/装配/systemd/持久化保留 InstanceManager；本方法只做心跳驱动 + 目录同步。
-         *  @returns {ok:boolean} 实例当前在线（heartbeat 统一写目录 lastObserved） */
+        /** 沙箱实例监督单拍：heartbeat 经 adapter 对每个沙箱实例跑 InstanceManager.supervise
+         *  （单实例状态机）并把目录项与实例域状态对齐（目录=真实视图，防 ghost/死登记）。
+         *  域业务 CRUD/安装/装配/systemd/持久化保留在 InstanceManager，本方法只做心跳驱动+目录同步；
+         *  返回 ok=实例当前在线（heartbeat 统一写目录 lastObserved）。 */
         async _sandboxSuperviseOnce(entry) {
           const d = depsOf(this);
           if (d.stopping()) return { ok: false, error: "guard stopping" };
@@ -7832,10 +7806,9 @@ var require_instance_adapter = __commonJS({
           }
           return { ok: running, error: running ? null : "\u6C99\u7BB1\u5B9E\u4F8B\u672A\u8FD0\u884C" };
         },
-        /** 目录项 <- 实例域状态对齐（heartbeat 监督拍后调用）：实例已删 -> 注销（防死登记）；
-         *  实例存在 -> name/guardian/ownership 经 _managedSandboxSpec 申报，phase 落目录唯一词表。
-         *   **desired 不同步**（D-8/铁律 1）：观测推导的应然写回目录会让「崩溃进 BACKOFF」被
-         *    误判成「用户想停它」。意图只由 entry 的 start()/stop() 与动作路径改。 */
+        /** 目录项 <- 实例域状态对齐（监督拍后调用）：实例已删 -> 注销（防死登记）；存在 -> 经
+         *  sandboxSpec 同步 name/guardian/ownership + phase 落目录词表。desired 不同步（keepDesired，
+         *  契约 M-1：观测推导不得写回应然，崩溃进 BACKOFF 不等于「用户想停」）。 */
         _syncSandboxRegistryEntry(entry) {
           const d = depsOf(this);
           if (!entry || !d.managedObjects() || !d.instances()) return;
@@ -7888,7 +7861,7 @@ var require_decide = __commonJS({
           crashHalted() {
             return host2._crashHalted;
           },
-          // 字段 helper 与状态读取经 host 上的既有安装转发（等价于原经 this 的调用）。
+          // 字段 helper 与状态读取经 host 既有安装转发。
           mLastProbeOk() {
             return host2._mLastProbeOk();
           },
@@ -8169,7 +8142,7 @@ var require_controller = __commonJS({
           sessionState() {
             return host2._sessionState;
           },
-          // 字段 helper 经 host 上的既有安装转发（等价于原经 this 的调用）。
+          // 字段 helper 经 host 既有安装转发。
           mChild() {
             return host2._mChild();
           },
@@ -8225,8 +8198,8 @@ var require_controller = __commonJS({
     }
     module2.exports = {
       methods: {
-        // 主循环收敛段（唯一心跳驱动；外部操作仍可即时触发）。单一状态机：
-        // STOPPED/STARTING/RUNNING/RESTARTING/BACKOFF。systemd 托管已废弃，main 由守卫 spawn/观测统一管理。
+        // 唯一心跳驱动的收敛段（外部操作仍可即时触发）；单一状态机 STOPPED/STARTING/RUNNING/RESTARTING/BACKOFF。
+        // main 由守卫统一 spawn/观测管理（不经 systemd 托管）。
         async _dshConverge() {
           const d = depsOf(this);
           if (d.readTicking() || d.stopping()) return;
@@ -8444,7 +8417,7 @@ var require_shadow = __commonJS({
           stopping() {
             return host2._stopping;
           },
-          // 兄弟方法/字段 helper 经 host 上的既有安装转发（等价于原经 this 的调用）。
+          // 兄弟方法/字段 helper 经 host 既有安装转发。
           mAdopted() {
             return host2._mAdopted();
           },
@@ -8673,7 +8646,7 @@ var require_log = __commonJS({
           return 0;
         }
       }
-      // 读取日志尾部至多 n 行（空行省略；供测试/调试读已落盘内容）。文件不存在返回空数组。
+      // 读取日志尾部至多 n 行（空行省略；文件不存在返回空数组）。
       tail(n) {
         if (!this.file) return [];
         try {
@@ -9157,7 +9130,7 @@ var require_signals = __commonJS({
           logger() {
             return host2.logger;
           },
-          // 兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用）。
+          // 兄弟方法经 host 既有安装转发。
           mainOwnerFile() {
             return host2._mainOwnerFile();
           },
@@ -9195,10 +9168,8 @@ var require_signals = __commonJS({
     }
     module2.exports = {
       methods: {
-        /** 主 DSH 的**归属凭据**文件：与 lan/router daemon 的
-         *  `*-daemon.identity.json` 同范式、同址（stateFile 所在目录）。此前接管只凭 cmdline 子串
-         *  相似（`_isManagedProcess`），于是**两个守卫会认领同一个 DSH**——彼此 stop/kill 对方刚
-         *  接管的进程（审计原述「疑似双管家互杀」）。 */
+        /** 主 DSH 归属凭据文件：与 lan/router daemon 的 *-daemon.identity.json 同范式、同址（stateFile 目录）。
+         *  接管只凭 cmdline 子串相似会让两个守卫认领同一个 DSH、互 stop/kill 对方刚接管的进程，故落凭据声明归属。 */
         _mainOwnerFile() {
           const d = depsOf(this);
           try {
@@ -9207,7 +9178,7 @@ var require_signals = __commonJS({
             return null;
           }
         },
-        /** 读归属凭据；缺失/损坏一律 null（**绝不**因读失败而接管或否决——判定回落 cmdline）。 */
+        /** 读归属凭据；缺失/损坏一律 null（绝不因读失败而接管或否决，判定回落 cmdline）。 */
         _readMainOwner() {
           const d = depsOf(this);
           try {
@@ -9219,10 +9190,8 @@ var require_signals = __commonJS({
             return null;
           }
         },
-        /** 落归属凭据：声明「pid=<dshPid> 的主 DSH 由本守卫（guardPid）负责」。
-         *  spawn 与 adopt 两条取得所有权的路线都要写。落盘走 E-1 原子写单源（platform/util/fs 的
-         *  writeAtomic：tmp 名含 pid+时间戳，多实例并发不互相覆盖，rename 原子替换）+ 0600
-         *  ——与 daemon 身份文件同法。 */
+        /** 落归属凭据：声明 pid=<dshPid> 的主 DSH 由本守卫（guardPid）负责；spawn 与 adopt 两条取得所有权的路线都要写。
+         *  落盘走 writeAtomic 单源（tmp 名含 pid+时间戳，多实例并发不互相覆盖）+ 0600，与 daemon 身份文件同法。 */
         _writeMainOwner(dshPid, port) {
           const d = depsOf(this);
           try {
@@ -9238,12 +9207,9 @@ var require_signals = __commonJS({
             d.logger() && d.logger().warn && d.logger().warn("writeMainOwner: " + (e && e.message || e));
           }
         },
-        /** 校验 pid 进程是否属于本守卫管理：cmdline 含配置的启动 bin，或符合 DSH 特征（兼容外部手动起的标准 DSH）。
-         *  精确匹配避免"路径碰巧含 dsh 就误接管"与"安装路径不含 dsh 就漏接管"。
-         *
-         *  先看**归属凭据**——但凭据只做**否决**（别的守卫活着且明确拥有这个 pid 时不接管），
-         *  不单独放行：放行权威仍是 cmdline 特征。理由——陈旧凭据（pid 已被内核复用）若可单独放行，
-         *  会把无关进程接管进来，那是比原缺陷更糟的失败方向。 */
+        /** 校验 pid 是否属本守卫：cmdline 含配置启动 bin 或符合 DSH 特征（兼容外部手动起的标准 DSH）；
+         *  精确匹配避免"路径碰巧含 dsh 误接管"与"安装路径不含 dsh 漏接管"。
+         *  归属凭据只做否决（别的存活守卫拥有此 pid 时不接管），不单独放行：陈旧凭据的 pid 可能已被内核复用，单独放行会误接管无关进程。 */
         _isManagedProcess(pid) {
           const d = depsOf(this);
           const own = d.readMainOwner();
@@ -9259,22 +9225,14 @@ var require_signals = __commonJS({
           if (typeof bin === "string" && bin && cmd2.includes(bin)) return true;
           return pidlook.isDshCmdline(pid);
         },
-        /** 向进程组发信号（detached spawn 的子进程是组长）；组信号失败退回单进程（平台层封装：
-         *  POSIX 组信号；Windows 无组语义则单进程信号，树语义由 `killTree` 提供）。 */
+        /** 向进程组发信号（detached spawn 的子进程是组长）；组信号失败退回单进程。平台层封装：
+         *  POSIX 组信号；Windows 无组语义则单进程信号，树语义由 killTree 提供。 */
         _signalChild(child, sig) {
           platform.processControl.signalProcess(child.pid, sig);
         },
-        /** 整树终止。
-         *
-         *  为什么必须单独有这个方法：
-         *   平台层提供 `killTree`（Windows = `taskkill /PID <pid> /T /F`，POSIX = 进程组信号），
-         *   实际停止路径若只用 `signalProcess`，它在 Windows 上只 `process.kill(pid, sig)`（单进程语义由平台层注释自己写明）。
-         *   于是 Windows 上停止 DSH 只杀父进程：其派生的子进程（node / 浏览器 / 子命令）成为**孤儿**，
-         *   继续占端口、持文件锁；守卫重启后 adopt 复用即被楔死。
-         *
-         *   POSIX 上 `killTree` 退化为组信号，与 `_signalChild` 等价（幂等，无害）。
-         *   child 一律是本守卫 detached 拉起（组长），显式 ownGroup:true 保留组信号。
-         */
+        /** 整树终止：必须单独存在。平台层 killTree（Windows taskkill /PID <pid> /T /F，POSIX 进程组信号）
+         *  与 signalProcess 不同，后者在 Windows 只杀单进程——停止 DSH 会遗留子进程成孤儿、继续占端口与文件锁，守卫重启 adopt 即被楔死。
+         *  child 恒为本守卫 detached 拉起的组长，故显式 ownGroup:true 走组信号（POSIX 退化为组信号，幂等无害）。 */
         _killTree(child, sig) {
           const d = depsOf(this);
           const pc = platform.processControl;
@@ -9297,16 +9255,10 @@ var require_signals = __commonJS({
             }
           }, d.config().stopGraceMs));
         },
-        /** 杀无句柄的接管实例（仅知 pid）。
-         *
-         *  失败不再静默（D12）：SIGKILL 投递后另给一次复核窗口，仍存活才判定「停止落空」，
-         *  发 stop_failed + warn —— 原实现只 append sigkill_sent 就算完，kill 失败与成功无法区分。
-         *
-         *  代际（gen）：本文件只有一个 _adoptKillTimer 槽位，后一次 kill 会覆盖前一次的句柄。
-         *  故每次调用自增 _adoptKillGen，定时器只在「本代仍是当前代」时才把槽位置回 null，
-         *  防止旧 timer 清掉新一次操作的句柄（清掉后 shutdown 就漏清它）。
-         *  注意代际只保护共享槽位：每个 timer 仍按自己的 pid 完成升级与复核，
-         *  不因换代而跳过，否则前一个 pid 的 SIGKILL 升级会被吞掉。 */
+        /** 杀无句柄的接管实例（仅知 pid）。失败不再静默：SIGKILL 后另给复核窗口，仍存活才判「停止落空」发 stop_failed + warn。
+         *  代际 gen：本文件只有一个 _adoptKillTimer 槽位，后一次 kill 会覆盖前一次句柄；故每次自增 _adoptKillGen，
+         *  定时器只在「本代仍是当前代」时置空槽位，防旧 timer 清掉新句柄。
+         *  代际只保护共享槽位：每个 timer 仍按自己的 pid 完成升级与复核，不因换代跳过（否则前一个 pid 的 SIGKILL 升级被吞）。 */
         _killAdopted(pid) {
           const d = depsOf(this);
           const gen = (d.readAdoptKillGen() || 0) + 1;
@@ -9409,7 +9361,7 @@ var require_health_gate = __commonJS({
           ui() {
             return host2.ui;
           },
-          // 字段 helper 经 host 上的既有安装转发（等价于原经 this 的调用）。
+          // 字段 helper 经 host 既有安装转发。
           mCrashWindowStart() {
             return host2._mCrashWindowStart();
           },
@@ -9466,13 +9418,9 @@ var require_health_gate = __commonJS({
             d.ui().notify("DSH \u53CD\u590D\u5D29\u6E83", "\u5DF2\u8FDB\u5165\u7B2C " + dec.backoffLevel + " \u7EA7\u9000\u907F\uFF08" + Math.round(d.config().backoff[dec.backoffLevel] / 1e3) + "s\uFF09\uFF0C\u8BF7\u67E5\u770B dsh-supervisor \u9762\u677F");
           }
         },
-        /** 假死识别（健康维度判定）：进程/端口在但 HTTP 不健康时连续 failThreshold 次判故障重启。
-         *  单次抖动不清零（failStreak 单调累积直到达到阈值或恢复健康），达到阈值即触发。
+        /** 假死识别（健康维度）：进程/端口在但 HTTP 连续 failThreshold 次不健康才判故障重启；单次抖动不清零（failStreak 单调累积至阈值或恢复）。
          *  httpProbeEnabled=false 时 healthOk 恒为 true（monitor.probe 已退化），此处天然不触发。
-         *
-         *  本方法只记账 + 返回决策，不直接调 main.beginRestart()（否则造成
-         *  health-gate -> process 反向边）；执行由收敛器（main/controller.js）承担。
-         *  依赖单向：controller/process -> health-gate。 */
+         *  只记账 + 返回决策，不直接调 main.beginRestart（避免 health-gate -> process 反向边）；执行由收敛器 controller 承担。 */
         _applyHealthCheck(healthOk) {
           const d = depsOf(this);
           if (healthOk) {
@@ -9521,12 +9469,10 @@ var require_supervise = __commonJS({
     }
     module2.exports = {
       methods: {
-        /** 唯一心跳驱动的 daemon 保活单拍：
-         *  router/lan-daemon 的「业务需要它 + 失联即拉起」，由 ManagedRegistry.heartbeat 经 adapter 调用
-         *  （节流约 30s）。守卫重启不影响 daemon（进程独立）。
-         *  契约 域 B：这两个 daemon 是基础设施（能力自愈），本方法是保活，不是「用户意图被守护触发」，
-         *  故两分支均不写 guardian_action / restartCount（G-1/G-2）。
-         *  @returns {ok:boolean} daemon 当前在线（heartbeat 统一写入目录实然）。 */
+        /** 唯一心跳驱动的 daemon 保活单拍：router/lan-daemon「业务需要它 + 失联即拉起」，由 ManagedRegistry.heartbeat
+         *  经 adapter 调用（节流约 30s）；守卫重启不影响 daemon（进程独立）。
+         *  契约 域 B：两 daemon 是基础设施（能力自愈），本方法是保活而非守护触发用户意图，两分支均不写
+         *  guardian_action / restartCount（G-1/G-2）。@returns {ok:boolean} daemon 当前在线（heartbeat 统一写入目录实然）。 */
         async _daemonSuperviseOnce(kind) {
           const d = depsOf(this);
           if (d.stopping()) return { ok: false };
@@ -9685,16 +9631,9 @@ var require_process3 = __commonJS({
     var { waitProcessExit, waitPortFree } = require_process_wait();
     var { deriveCmdMarks } = require_process_marks();
     var DaemonLifecycle = class {
-      /**
-       * @param {object} o
-       *  - name: 标识（'router' | 'lan'）
-       *  - script / args: spawn 命令
-       *  - ctlPort: 就绪/换代仲裁端口
-       *  - cmdMark: cmdline 识别子串（防误接管异主）
-       *  - identityFile: JSON {guardPid, daemonPid, startedAt}
-       *  - spawnEnv(extra) / logger / events
-       *  - readyTimeoutMs / stopGraceMs / portReleaseTimeoutMs / spawnWindowMs
-       */
+      /** @param o 配置：name（'router' | 'lan'）、script/args（spawn 命令）、ctlPort（就绪/换代仲裁端口）、
+       *  cmdMark（cmdline 识别子串，防误接管异主）、identityFile（JSON {guardPid, daemonPid, startedAt}）、
+       *  spawnEnv(extra) / logger / events、readyTimeoutMs / stopGraceMs / portReleaseTimeoutMs / spawnWindowMs。 */
       constructor(o) {
         this.name = o.name;
         this.script = o.script;
@@ -9768,9 +9707,9 @@ var require_process3 = __commonJS({
         const id = this._readIdentity();
         return id && id.daemonPid ? id.daemonPid : null;
       }
-      /** 回收非当前受管代际的旧代进程：YAMA 下 /proc fd 对非祖先不可读，socket 到 pid 无法映射，
-       *  故改用 pgrep -af 读 cmdline（跨平台/YAMA 免疫）。凡 cmdline 命中本 daemon（script+configPath 特征）
-       *  且 pid 非当前身份 pid/自己/ctl 属主，一律视为旧代残留 TERM 回收。@returns 回收数 */
+      /** 回收非当前受管代际的旧代进程：YAMA 下 /proc fd 对非祖先不可读、socket 到 pid 无法映射，
+       *  故用 pgrep -af 读 cmdline（跨平台/YAMA 免疫）。命中本 daemon 特征且 pid 非当前身份 pid/自己/
+       *  ctl 属主者一律视为旧代残留，TERM 回收。@returns 回收数 */
       reclaimOrphans() {
         const args = this.args || [];
         let cfg = "";
@@ -9820,11 +9759,8 @@ var require_process3 = __commonJS({
         }
         return killed;
       }
-      /** 换代/启动仲裁总入口：
-       *  - 期望 pid 活且 ctl 就绪 -> {mode:'adopted', pid}
-       *  - 无进程 -> spawn（latch）-> {mode:'started', pid}
-       *  - 期望 pid 死或失联 -> reclaiming（停残留，短 latch 后下一轮 spawn）
-       *  - spawn latch 窗口内 -> {mode:'barrier'} */
+      /** 换代/启动仲裁总入口：期望 pid 活 -> {mode:'adopted', pid}；无进程 -> spawn（latch）-> {mode:'started', pid}；
+       *  期望 pid 死或失联 -> reclaiming（停残留，短 latch 后下一轮 spawn）；spawn latch 窗口内 -> {mode:'barrier'}。 */
       ensureRunning() {
         if (this._stopping) return { mode: "stopping" };
         try {
@@ -9880,16 +9816,9 @@ var require_process3 = __commonJS({
         if (this.logger && this.logger.info) this.logger.info("[" + this.name + "] \u5DF2\u62C9\u8D77\u72EC\u7ACB daemon pid=" + child.pid + "\uFF08spawn \u7A97\u53E3\u81F3 " + new Date(this._spawnWindowUntil).toISOString() + "\uFF09");
         return { mode: "started", pid: child.pid };
       }
-      /** 无副作用分类（供监督/审计共用）：当前受管代际与 ctl 属主的真实状态。**绝不 spawn/stop**。
-       *  @returns {{mode:'running'|'external'|'reclaiming'|'barrier'|'absent'|'stopping', pid?, owner?, stale?}}
-       *   - running: 期望代际存活（ctl 属主=期望 pid，或 ctl 尚未起）
-       *   - external: ctl 被「异 cmdMark/异代际」进程占用（外部抢占，绝不接管）
-       *   - reclaiming: 期望代际已死但同 cmdMark 残留仍占 ctl（需换代）
-       *   - barrier: spawn latch 窗口内（等旧代退出）
-       *   - absent: 无进程、无残留（可 spawn）
-       *   - stopping: 已进入停止流程
-       *  这是生产监督路径（_orphanAudit / _daemonSuperviseOnce）识别「异主 daemon」的唯一判据——
-       *  ensureRunning 只按 cmdline 判 active，无法区分「本守卫的 daemon」与「外部同名 daemon」。 */
+      /** 无副作用分类（供监督/审计共用，绝不 spawn/stop）：running 期望代际存活 / external ctl 被异 cmdMark 进程
+       *  占用（绝不接管）/ reclaiming 期望已死且同 cmdMark 残留占 ctl / barrier latch 窗口内 / absent 可 spawn /
+       *  stopping 停止中。监督与停止路径据此识别「异主 daemon」——ensureRunning 只按 cmdline 判 active，分不清两者。 */
       classify() {
         if (this._stopping) return { mode: "stopping" };
         const exp = this.expectedPid();
@@ -9903,8 +9832,8 @@ var require_process3 = __commonJS({
         if (stale) return { mode: "reclaiming", stale };
         return { mode: "absent" };
       }
-      /** 周期监督：期望进程失联则先验证死透再 replace（死透由 ensureRunning 的 stale/死pid 分支处理）。
-       *  基于 classify() 分类后施加副作用（reclaim/spawn）；分类能力本身无副作用、供审计复用。 */
+      /** 周期监督：classify() 分类（无副作用）后再施加副作用（reclaim/spawn）；期望进程失联则先验证
+       *  死透再 replace（死透由 ensureRunning 的 stale/死 pid 分支处理）。 */
       async superviseOnce() {
         if (!this.expectedPid()) {
           try {
@@ -10021,7 +9950,7 @@ var require_runtime2 = __commonJS({
           router() {
             return host2.router;
           },
-          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用；外部覆写 host 方法仍生效）。
+          // 同模块兄弟方法经 host 上的既有安装转发（外部覆写 host 方法仍生效）。
           dshMainView() {
             return host2.dshMainView();
           },
@@ -10061,7 +9990,7 @@ var require_runtime2 = __commonJS({
     module2.exports = {
       methods: {
         /** 统一受管进程生命周期实例（懒加载单例；lan/router 共用 DaemonLifecycle 核心）。
-         *  身份文件（owner 连续：守卫重启=接管既有 daemon）+ spawn latch + 换代停旧/等死/等端口释放 全在核心内。 */
+         *  身份文件（owner 连续：守卫重启=接管既有 daemon）、spawn latch、换代停旧/等死/等端口释放都在核心内。 */
         _daemonLifecycle(kind) {
           const d = depsOf(this);
           if (!d.configPath()) return null;
@@ -10331,7 +10260,7 @@ var require_identity = __commonJS({
           config() {
             return host2.config;
           },
-          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用）。
+          // 同模块兄弟方法经 host 上的既有安装转发。
           lanLockPath() {
             return host2._lanLockPath();
           },
@@ -10344,7 +10273,7 @@ var require_identity = __commonJS({
       return d;
     }
     module2.exports = {
-      // D-12 测试缝：锁的取/放/读主是纯 fs + kill(0) 语义，直接导出给回归用（不改行为）。
+      // 测试缝：锁的取/放/读主是纯 fs + kill(0) 语义，直接导出给回归用。
       _lockPrimitives: { acquireLock: acquireLock2, releaseLock: releaseLock2, lockPid, pidAlive },
       methods: {
         _lanLockPath() {
@@ -10434,9 +10363,7 @@ var require_probe4 = __commonJS({
     }
     module2.exports = {
       methods: {
-        /** 独立 router-daemon 是否在运行（探测 ctl 端口监听者 cmdline 是否 router-daemon）。
-         *  守卫探测到 daemon 在跑就不再内嵌启动 router（避免双占 ctl 口），只做监督
-         *  （lifecycleManager 周期探活 ctl 口，异常时拉起 daemon）。 */
+        /** 独立 router-daemon 是否在运行（探测 ctl 端口监听者 cmdline）。 */
         _routerDaemonActive() {
           const d = depsOf(this);
           try {
@@ -10448,9 +10375,8 @@ var require_probe4 = __commonJS({
             return false;
           }
         },
-        /** lan-daemon 模式是否启用（结构性部署选择，非用户意图开关）。
-         *  config.lanDaemon === true 时 lan 由独立 daemon 承载（ctl 通道），
-         *  否则内嵌 LanManager。这是部署形态选择（壳写配置），不对用户暴露。 */
+        /** lan-daemon 模式是否启用：config.lanDaemon 是结构性部署选择（壳写配置，无面板入口、不对用户
+         *  暴露）——true 时 lan 由独立 daemon 承载（ctl 通道），否则内嵌 LanManager。 */
         lanDaemonEnabled() {
           const d = depsOf(this);
           const cfg = d.config();
@@ -10499,7 +10425,7 @@ var require_router = __commonJS({
           ctl() {
             return host2.ctl;
           },
-          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用；外部覆写 host 方法仍生效）。
+          // 同模块兄弟方法经 host 上的既有安装转发（外部覆写 host 方法仍生效）。
           routerDaemonActive() {
             return host2.routerDaemonActive();
           },
@@ -10584,12 +10510,10 @@ var require_router = __commonJS({
           return { ok: false, source: "embedded", error: e2 && e2.message || String(e2) };
         }
       },
-      // L3 监督模式：router 控制通道（daemon 唯一事实源）。
-      // 本方法上移至此以打断 facade/router 与 ctl/facades 的 this 调用环：ctl/facades 不再
-      // 调用本文件的 routerDaemonActive；本文件对 ctl 的依赖单向（经 this._makeRouterFacade）。
-      // 守卫 API/视图统一从 routerApi() 取 router 门面：daemon 在跑则转发 ctl
-      // （POST /ctl {method,args}，见 src/platform/ctl/server.js）——写即 daemon 生效、读即
-      // daemon 最新；daemon 未跑则走守卫本地实例（内嵌回退路径）。
+      // router 控制通道门面：守卫 API/视图统一从这里取。
+      // 本方法在此文件以保证对 ctl 的依赖单向（ctl/facades 不调本文件的 routerDaemonActive）。
+      // daemon 在跑则转发 ctl（POST /ctl {method,args}）——写即 daemon 生效、读即 daemon 最新；
+      // daemon 未跑则走守卫本地实例（内嵌回退路径）。
       routerApi() {
         const d = depsOf(this);
         if (d.routerDaemonActive()) {
@@ -10616,12 +10540,9 @@ var require_lan = __commonJS({
       return d;
     }
     module2.exports = { methods: {
-      // 远程控制委托：全部转发给 LanManager。
-      // daemon 监督模式经 43108 ctl 委托（异步）；本地模式走 LanManager（同步）。
-      // 令牌收敛：listLan 输出剔除 token/dshToken——/lan-access 允许 LAN/私网 Host 访问，
-      // 直出 dshToken 会把 DSH 会话令牌泄漏给局域网；权威仍在 DshTokenService（relay 经
-      // tokenOf 内部读取，无需经此透传）。remote（projectRemoteView 产物）为后端单一推导
-      // 视图 {mode,ready,accessUrl,reasons}，不含机密，整段放行给 UI 消费。返回形如 {items,addresses}。
+      // 远程控制委托：全部转发给 LanManager；daemon 监督模式经 43108 ctl 委托（异步），本地模式走 LanManager（同步）。
+      // 令牌收敛：listLan 输出必须剔除 token/dshToken —— /lan-access 允许 LAN/私网 Host 访问，直出会把 DSH 会话令牌泄漏给局域网，权威仍在 DshTokenService。
+      // remote（projectRemoteView 产物）为后端单一推导视图 {mode,ready,accessUrl,reasons}，不含机密，整段放行给 UI。返回形如 {items,addresses}。
       listLan() {
         const d = depsOf(this);
         const sanitize = (r) => {
@@ -10680,7 +10601,6 @@ var require_ports2 = __commonJS({
           logger() {
             return host2.logger;
           },
-          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用）。
           portActives(list) {
             return host2._portActives(list);
           },
@@ -10696,8 +10616,8 @@ var require_ports2 = __commonJS({
       return d;
     }
     module2.exports = { methods: {
-      // 端口管理门面：统一端口 registry 清单经 sup 接口暴露（presentation 不直连 infra）。
-      // 每条记录必须补 active（端口当前真实监听中），否则前端「状态」列全部显示停用。
+      // 端口清单经 sup 接口暴露（presentation 不直连 infra）。每条记录必须补 active
+      // （端口当前真实监听中），否则前端「状态」列全部显示停用。
       // 探测按端口集合整批缓存 3s TTL，避免前端 2s 心跳每次触发全量同步扫 /proc 挤占事件循环。
       async listPorts() {
         const d = depsOf(this);
@@ -10736,11 +10656,9 @@ var require_ports2 = __commonJS({
         }
         return { records: out, snapshot: snap, capacity };
       },
-      /** 端口集合激活探测。active=true 表示该端口当前有进程在监听。
-       *  用纯 TCP connect（probe.portListening）判定：findListeningPid 需读 /proc/<pid>/fd 反查
-       *  socket->pid，对守卫管理树外的孙进程（router-daemon 的反代子进程）常因读取权限返回 null，
-       *  导致端口在监听却恒报 inactive。TCP connect 与端口是否被监听直接等价（同 isTaken 判占用
-       *  语义），无需 /proc 权限，三平台一致。 */
+      /** 端口集合激活探测，active=true 表示该端口当前有进程在监听。判定用纯 TCP connect（probe.portListening）：
+       *  findListeningPid 要读 /proc/<pid>/fd 反查 socket->pid，对守卫管理树外的孙进程（router-daemon 的反代子进程）
+       *  常因读取权限返回 null，端口在监听却恒报 inactive；TCP connect 无需 /proc 权限、三平台一致。 */
       async _portActives(portsList) {
         const d = depsOf(this);
         const now = Date.now();
@@ -10893,7 +10811,7 @@ var require_status = __commonJS({
       return {
         desired: host2._mDesired(),
         phase: host2._mPhase(),
-        // 会话生命周期（契约 ，INV-S4）：与 phase 正交——phase 是 main 状态机相位，
+        // 会话生命周期（INV-S4）：与 phase 正交——phase 是 main 状态机相位，
         // sessionState 是整个服务链的运行相位（前端/壳据此表达「退出中/已退出」）。
         sessionState: host2._sessionState,
         // 数据目录保护状态（Windows 无 icacls 时可观测降级）。
@@ -10938,7 +10856,6 @@ var require_router2 = __commonJS({
     function createRouterActions(deps) {
       const g = deps || {};
       return {
-        // 智能路由开关管理
         async setRouterRunning(on) {
           const lifecycleManager = g.getLifecycleManager();
           const daemons = g.getDaemons();
@@ -11094,7 +11011,7 @@ var require_core4 = __commonJS({
         return {
           ok: false,
           redirect: url.pathname,
-          // 令牌条 5：种的是派生会话值，绝不是门卫令牌原文。
+          // 令牌条 5：种派生会话值，绝不是门卫令牌原文。
           cookie: "dsh_lan_token=" + lanGateCookieValue(token, salt) + "; Path=/; HttpOnly; SameSite=Lax"
         };
       }
@@ -11436,10 +11353,9 @@ var require_env_catalog = __commonJS({
       constructor(config) {
         this.config = config || {};
       }
-      /** 系统二进制条目探测：{ id: { label, required, state, detail } }。
-       *  state 三态：ok = 存在且满足门槛（Node 需 >= 壳投放的 minNode）；outdated = 存在但低于门槛
-       *  （旧实现会误报 ok，面板谎报环境就绪）；missing = 不存在。
-       *  兼容：detail 保持字符串，新增字段放 detail 之外（version/min/meets），不破坏既有契约。 */
+      /** 系统二进制条目探测：{ id: { label, required, state, detail } }。state 三态：
+       *  ok = 存在且满足门槛（Node 需 >= 壳投放的 minNode）；outdated = 存在但低于门槛；missing = 不存在。
+       *  兼容：detail 保持字符串，新增字段（version/min/meets）放 detail 之外，不破坏既有契约。 */
       probe() {
         const out = {};
         for (const [id, e] of Object.entries(SYSTEM_ENTRIES)) {
@@ -11460,9 +11376,8 @@ var require_env_catalog = __commonJS({
         }
         return out;
       }
-      /** 内核更新依赖条目（单写入者契约：安装/重启归桌面壳）。守卫不再自更新，corePackageName 只用于
-       *  查询内核版本状态，本条目只报告壳执行内核更新所需的包名是否就位。id 仍为 selfUpdate 以兼容
-       *  既有 /env/status 消费方。 */
+      /** 内核更新依赖条目（单写入者契约：安装/重启归桌面壳，守卫只读 corePackageName 查版本状态）。
+       *  id 仍为 selfUpdate 以兼容既有 /env/status 消费方。 */
       selfUpdateEntry() {
         const pkg = this.config.corePackageName;
         if (!pkg) {
@@ -11484,8 +11399,7 @@ var require_env_catalog = __commonJS({
           detail: binOk ? installed || "\u5DF2\u88C5" : "bin \u4E0D\u5B58\u5728: " + (bin || "?")
         };
       }
-      /** 汇总：全部必填项状态（供面板/守卫快速判定环境就绪）。
-       *  无 sys 时探测一次（有 10s TTL 缓存）。 */
+      /** 汇总：全部必填项状态（供面板/守卫快速判定环境就绪）；无 sys 时探测一次（有 10s TTL 缓存）。 */
       summary(extra, sys) {
         const s = sys || this.probe();
         const items = { ...s, ...extra || {} };
@@ -11587,7 +11501,7 @@ var require_node_lts = __commonJS({
     var path2 = require("node:path");
     module2.exports = {
       methods: {
-        /** 6h 缓存 + 失败降级：不做远端查询（避免守卫启动依赖网络），本地判定 + 可刷新缓存；
+        /** Node LTS 状态：本地判定 + 6h 可刷新缓存，不做远端查询（避免守卫启动依赖网络）。
          *  失败返回 { ok:false, error } 由前端降级展示，绝不抛异常。 */
         async nodeLtsStatus() {
           try {
@@ -11713,7 +11627,6 @@ var require_versions = __commonJS({
           dist: () => host2.dist,
           events: () => host2.events,
           guardVersion: () => host2.guardVersion,
-          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用）。
           guardCorePkg: () => host2.guardCorePkg(),
           readBinarySelfVersion: () => host2._readBinarySelfVersion(),
           vcsRoot: () => host2._vcsRoot(),
@@ -11725,20 +11638,18 @@ var require_versions = __commonJS({
     }
     module2.exports = {
       methods: {
-        // ---- 内核更新（单写入者契约：安装/重启归桌面壳）----
-        // 内核 npm 包的唯一写入者是桌面壳（见 RELEASE-AND-UPDATE-MECHANISM.md）；
+        // ---- 内核更新（单写入者契约）：内核 npm 包的唯一写入者是桌面壳；
         // 守卫只保留只读的 guardSelfUpdateStatus，接口 /self-update/apply|restart-guard 返回 410。
-        /** 内核 npm 子包名（按当前平台/架构）。corePackageName 可为显式常量或含 {os}/{arch} 占位的模板。 */
+        /** 内核 npm 子包名：corePackageName 可为显式常量或含 {os}/{arch} 占位的模板。 */
         guardCorePkg() {
           const d = depsOf(this);
           const raw = d.config().corePackageName;
           if (!raw) return null;
           return String(raw).replace(/{os}/g, matrix.osTag()).replace(/{arch}/g, matrix.current().arch) || null;
         },
-        /** 内核更新状态（只读；安装/重启归桌面壳，单写入者契约）。
-         *  查 @dsh-sup/dsh-core-<os>-<arch> 的通道版本（RELEASE-CHANNEL-CONTRACT：
-         *  rollback -> canary -> latest；latest 缺失才回落最高），与本机 guardVersion 比较。
-         *  本方法不写任何东西：面板据此显示可更新，实际安装由桌面壳 kernel_update_apply 执行。 */
+        /** 内核更新状态（只读，本方法不写任何东西；实际安装由桌面壳 kernel_update_apply 执行）。
+         *  查内核子包在发布通道（RELEASE-CHANNEL-CONTRACT：rollback -> canary -> latest，
+         *  latest 缺失才回落最高）的版本，与本机 guardVersion 比较。 */
         async guardSelfUpdateStatus() {
           const d = depsOf(this);
           const pkg = d.guardCorePkg();
@@ -11759,14 +11670,10 @@ var require_versions = __commonJS({
             return { ok: false, error: e.message };
           }
         },
-        /** 读磁盘上运行位的自报版本（A1 校验用）：spawn --version，解析 guardVersion= 行。
-         *
-         *  条件为「可更新的标准形态」（updatable === true，即 sea-binary 或 launcher）：
-         *    发布形态已弃 SEA 改为文本 launcher，launcher 的 <pkg>/bin/dsh-supervisor 同样是可执行入口
-         *    （require('../../core.cjs')），spawn 它能得到同样的 --version 输出。若只认 sea-binary，
-         *    真实用户永远读不到磁盘实况版本，updatePending 恒 false（「已装好待重启」永不显示）。
-         *  source-shell（源码形态）不支持：其 --version 报的是开发目录版本，与 npm 安装无关。
-         */
+        /** 读磁盘上运行位的自报版本：spawn --version，解析版本行。
+         *  条件是 updatable（sea-binary 或 launcher）：launcher 的 bin 入口同样可执行，
+         *  若只认 sea-binary 则发布态永远读不到磁盘实况，updatePending 恒 false。
+         *  source-shell 不支持：其 --version 报的是开发目录版本，与 npm 安装无关。 */
         _readBinarySelfVersion() {
           const dep = deploy.detect();
           if (!dep.updatable || !dep.runningTarget) return null;
@@ -11779,9 +11686,9 @@ var require_versions = __commonJS({
           }
         },
         // 管家自身版本检查（与 DSH 更新解耦）：本地仓库 git 视角，配了远程才 fetch 比对。
-        /** VCS 根解析：从包根上溯找最近的外层 .git（排除自身嵌套仓）。
-         *  命中嵌套仓会使其 HEAD 与真实外层仓脱节，导致 UI 版本/commit 失真；找不到外层仓时回退包根。
-         *  包根用 srcpath.resolvePackageRoot()（按 package.json 上溯），不能靠 __dirname 相对路径。 */
+        /** VCS 根：从包根上溯找最近的外层 .git（排除自身嵌套仓——嵌套仓 HEAD 与外层仓脱节，
+         *  会导致 UI 版本/commit 失真）；找不到时回退包根。
+         *  包根必须用 srcpath.resolvePackageRoot()（按 package.json 上溯），不能靠 __dirname 相对层数。 */
         _vcsRoot() {
           const dir = srcpath.resolvePackageRoot() || path2.resolve(__dirname, "..");
           const innerGit = path2.join(dir, ".git");
@@ -11807,11 +11714,9 @@ var require_versions = __commonJS({
           }
           return { version: d.guardVersion(), runningVersion: d.guardVersion(), commit, updateAvailable: false, upstream, latest: d.guardVersion() };
         },
-        /**
-         * 完整版本检查（async）：本地 commit + 远端 fetch 比对。
-         * 关键架构约束：git fetch 是网络 I/O，绝不能同步执行（会冻结整个事件循环，守卫假死且无法自愈）。
-         * 这里用 exec.runOutAsync（异步）+ 10s 超时；fetch 失败/超时只降级为「本地视图」，不抛错。
-         */
+        /** 完整版本检查（async）：本地 commit + 远端 fetch 比对。
+         *  git fetch 是网络 I/O，绝不能同步执行（会冻结事件循环，守卫假死且无法自愈）；
+         *  fetch 失败/超时只降级为「本地视图」，不抛错。 */
         async guardVersionCheck() {
           const d = depsOf(this);
           const base = d.guardVersionLocal();
@@ -11861,10 +11766,10 @@ var require_access = __commonJS({
           const cfg = this.config || {};
           return { configured: !!cfg.apiAccessKey, host: cfg.apiHost || void 0 };
         },
-        /** 设置/清除出回环访问密钥（空串=清除）。原子持久化到守卫 config。
-         *  清空密钥必须**同时回关 LAN**（apiHost -> 127.0.0.1 并持久化）：lan-panel 的开 LAN 前置条件是
-         *  「已有 apiAccessKey」，若只清 key 不动 apiHost，就会留下「绑定 0.0.0.0 且零认证」的暴露窗口。
-         *  监听 socket 的即时生效由 api 层的 fail-closed 兜底（本层只负责让配置事实自洽，不在此重绑）。 */
+        /** 设置/清除出回环访问密钥（空串=清除）。
+         *  清空密钥必须同时回关 LAN（apiHost -> 127.0.0.1 并持久化）：lan-panel 的开 LAN
+         *  前置条件是「已有 apiAccessKey」，只清 key 不动 apiHost 会留下「绑定 0.0.0.0 且零认证」
+         *  的暴露窗口。监听 socket 的即时生效由 api 层 fail-closed 兜底，本层只保证配置自洽。 */
         setAccessKey(key) {
           try {
             const cfg = this.config || {};
@@ -12031,7 +11936,6 @@ var require_lan_panel = __commonJS({
           events: () => host2.events,
           configPath: () => host2.configPath,
           api: () => host2.api,
-          // 同模块兄弟方法经 host 上的既有安装转发（等价于原经 this 的调用）。
           lanPanelStatus: () => host2.lanPanelStatus(),
           apiRebind: () => host2._apiRebind()
         };
@@ -12104,9 +12008,7 @@ var require_facets = __commonJS({
     var FACETS = [
       { name: "assembly/bootstrap", mod: require_bootstrap(), hostFirst: true },
       { name: "assembly/api-rebind", mod: require_api_rebind(), apiRebind: true },
-      // 级 2：session/machine + state/{store,fields,desired,upgrade-hold,main-store}
-      //   + control/{projection,specs} 已改为**真 ctor 工厂**，经 assembly/collaborators.js 装配，
-      //   不再在此以 { methods }/{ hostFirst } 形态安装（见 collaborators.js）。
+      // session/state/control 不在本清单：它们是真 ctor 工厂，由 assembly/collaborators.js 装配。
       { name: "session/shutdown", mod: require_shutdown(), hostFirst: true },
       { name: "self/notify", mod: require_notify2(), hostFirst: true },
       { name: "control/scheduler", mod: require_scheduler() },
@@ -12115,7 +12017,6 @@ var require_facets = __commonJS({
       { name: "main/controller", mod: require_controller() },
       { name: "main/shadow", mod: require_shadow() },
       { name: "main/process", mod: require_process2() },
-      // R3 严值 DF-2：端口运行时再推导从 main/process.js 拆为独立切面（_findManagedDshPort/_applyMainPort）。
       { name: "main/port-rederive", mod: require_port_rederive() },
       { name: "main/signals", mod: require_signals() },
       { name: "main/health-gate", mod: require_health_gate() },
@@ -12130,10 +12031,9 @@ var require_facets = __commonJS({
       { name: "facade/ports", mod: require_ports2() },
       { name: "facade/main", mod: require_main() },
       { name: "facade/status", mod: require_status(), hostFirst: true },
-      // 域写动作下沉 app/domain-actions/（facade 只读），同一装配契约。
-      //    P6-B：三者已改为**真 ctor 工厂**（实现体经显式 deps 取事实，不再直连 this），
-      //   故不再走 `f.mod.methods` 分支 —— 用 factory 名在装配期构造，并把产物**平铺安装**到 host，
-      //   保证 api 消费面（sup.setRouterRunning / patchDshMain / setRemoteMode …）名字逐个不变。
+      // 域写动作在 app/domain-actions/（facade 侧只读）：三者是真 ctor 工厂，实现体经显式 deps
+      //   取事实、不直连 this；按 factory 名在装配期构造后把产物平铺安装到 host，
+      //   平铺名必须与 api 消费面（setRouterRunning / patchDshMain / setRemoteMode 等）逐个一致。
       { name: "domain-actions/router", mod: require_router2(), factory: "createRouterActions" },
       { name: "domain-actions/lan", mod: require_lan2(), factory: "createLanActions" },
       { name: "domain-actions/main", mod: require_main2(), factory: "createMainActions" },
@@ -12706,9 +12606,8 @@ var require_pool2 = __commonJS({
         this._loaded = false;
       }
       /* 来源登记 */
-      /** 登记或更新目标的令牌来源，同一目标重复 attach 幂等并保留已推送的 stdout 行。
-       *  id 为目标标识（'main' 或实例 id）；src 形如 { kind?, unit?, file? }，kind 缺省时按源形态强推断。
-       *  返回是否完成登记；kind 完全无法判定时返回 false。 */
+      /** 登记或更新目标的令牌来源，重复 attach 幂等并保留已推送的 stdout 行；kind 缺省时按源形态推断（infer.js）。
+       *  kind 必须在 kinds.js 登记（契约1），完全无法判定时返回 false，避免幽灵令牌入池。 */
       attach(id, src) {
         if (!id) return false;
         const s = src || {};
@@ -12739,9 +12638,8 @@ var require_pool2 = __commonJS({
         this.clear(id);
       }
       /* 统一捕获（源无关） */
-      /** 主动捕捉一次：按源顺序取“最新一条”URL 行的令牌，有变化则入库并广播。
-       *：stdout/文件档同步返回；journal 档**非阻塞**发射（resolve 后照常 _commit+广播），
-       *  因为同步 journalctl 在守卫生命周期 tick 里会冻结事件循环最长 5s（心跳停摆）。 */
+      /** 主动捕捉一次：按源优先级取“最新一条”URL 行的令牌，有变化则入库并广播。
+       *  stdout/文件档同步返回；journal 档非阻塞发射：同步 journalctl 在生命周期 tick 里会冻结事件循环（见 capture.js）。 */
       capture(id) {
         const src = this._sources.get(id);
         if (!src) return null;
@@ -12813,9 +12711,9 @@ var require_pool2 = __commonJS({
         this.capture(id);
       }
       /* 生命周期 */
-      /** 清空某目标的令牌与调度；TK-8：必须广播 null（消费方据此立刻丢弃旧代令牌）。
-       *  stdout 行缓冲同属旧代状态——不清则 ensureCaptured 下一拍从残留行再“捕获”已死令牌，
-       *  以新 gen 追加进恢复文件（回灌死令牌，relay 恒 401）。 */
+      /** 清空某目标的令牌与调度；TK-8：必须广播 null（消费方立刻丢弃旧代令牌）。
+       *  stdout 行缓冲同属旧代状态必须一并清：残留行会被 ensureCaptured 再“捕获”，
+       *  以新 gen 把已死令牌回灌进恢复文件。 */
       clear(id) {
         this._cancelSchedule(id);
         this._backfillAt.delete(id);
@@ -12882,7 +12780,6 @@ var require_pool2 = __commonJS({
         const rec = {
           value,
           gen: (prev ? prev.gen : 0) + 1,
-          // 每次值变化加一，代号解决无版本问题
           source: source || "unknown",
           at: Date.now(),
           kind: src && src.kind || prev && prev.kind || null
@@ -12899,7 +12796,7 @@ var require_pool2 = __commonJS({
         this._bus.emit(id, rec.value, { value: rec.value, gen: rec.gen, source: rec.source, at: rec.at });
         return value;
       }
-      /** 把命中令牌的原文行持久化到恢复文件（统一经 persist：脱敏 + 0600 + 超限轮转）。 */
+      /** 把命中令牌的原文行写入恢复文件（统一经 persist：脱敏 + 0600 + 轮转）。 */
       _persistLine(id, file, line) {
         const r = persist.appendByRotation(file, line, { maxBytes: persist.PERSIST_LIMITS.MAX_BYTES });
         if (!r.ok) this.logger.warn && this.logger.warn("[token] persist file(" + id + ") failed: " + (r.reason || "unknown"));
@@ -12938,7 +12835,6 @@ var require_pool2 = __commonJS({
           this._records.set(e.id, { value: e.value, gen: e.gen, source: e.source, at: e.at, kind: e.kind });
         }
       }
-      // 兼容层已移除：TK-4 要求令牌池是唯一事实源，任何指向内部 Map 的旧访问器都会让消费方绕开 get/getRecord，成为各自缓存令牌的温床。
     };
     module2.exports = {
       TokenPool,
@@ -12962,7 +12858,6 @@ var require_token = __commonJS({
         this.events = o.events || null;
         this.pool = new TokenPool({ logger: this.logger, events: this.events, poolFile: o.poolFile || null });
       }
-      /* 来源登记 */
       /** 登记源。kind 必填（契约1）；缺省时按源形态强推断（见 pool.inferKind）。 */
       attach(id, src) {
         return this.pool.attach(id, src);
@@ -12971,7 +12866,6 @@ var require_token = __commonJS({
       detach(id) {
         return this.pool.detach(id);
       }
-      /* 捕捉 */
       /** 主动捕捉一次（journal 源）。返回当前令牌或 null。 */
       capture(id) {
         return this.pool.capture(id);
@@ -12988,7 +12882,6 @@ var require_token = __commonJS({
       ensureCaptured(id) {
         return this.pool.ensureCaptured(id);
       }
-      /* 变更 */
       /** 清令牌，广播 null（TK-8）。 */
       clear(id) {
         return this.pool.clear(id);
@@ -13377,11 +13270,8 @@ var require_tasks = __commonJS({
         this._log("info", "task " + task.id + " created (" + kind + "/" + action + " " + task.target.id + ")");
         return task;
       }
-      /**
-       * 统一作业执行器：提供 begin->start->fn->succeed/fail 的封装（作业体异常自动落 failed）。
-       *  内建契约：finally 清 _current 索引；fn 内的任何异常都不再逃逸为 unhandledRejection /
-       *  任务永久 running。
-       */
+      /** 统一作业执行器：begin->start->fn->succeed/fail 封装，作业体异常一律落 failed；
+       *  finally 清 _current 索引，任务绝不永久占用。 */
       async run(kind, targetId, action, opts, fn) {
         if (this.isBusy(kind, targetId)) {
           const cur = this.current(kind, targetId);
@@ -13421,7 +13311,6 @@ var require_tasks = __commonJS({
         const t = this.tasks.find((x) => x.id === id);
         return t && (t.state === "running" || t.state === "pending") ? t : null;
       }
-      /** 按 id 查任务。 */
       get(taskId2) {
         return this.tasks.find((t) => t.id === taskId2) || null;
       }
@@ -13435,7 +13324,6 @@ var require_tasks = __commonJS({
         return this.tasks.filter((t) => t.state === "running" || t.state === "pending");
       }
       /* 任务推进 */
-      /** 标记任务运行中（从 pending 进入 running；首个 step 前调用）。 */
       start(taskId2) {
         const t = this.get(taskId2);
         if (!t || t.state !== "pending") return null;
@@ -13444,7 +13332,6 @@ var require_tasks = __commonJS({
         this._emit("task_state", { id: taskId2, state: "running" });
         return t;
       }
-      /** 添加一个 step（追加到 steps 尾部）。 */
       step(taskId2, name) {
         const t = this.get(taskId2);
         if (!t) return null;
@@ -13453,7 +13340,6 @@ var require_tasks = __commonJS({
         this._save();
         return s;
       }
-      /** 推进某 step 状态。 */
       stepState(taskId2, index, state, extra) {
         const t = this.get(taskId2);
         if (!t || !t.steps[index]) return null;
@@ -13468,7 +13354,6 @@ var require_tasks = __commonJS({
         this._emit("task_step", { id: taskId2, index, name: s.name, state });
         return s;
       }
-      /** 记录任务日志（有界尾部）。 */
       log(taskId2, line) {
         const t = this.get(taskId2);
         if (!t) return;
@@ -13477,11 +13362,9 @@ var require_tasks = __commonJS({
         if (t.log.length > MAX_LOG_LINES) t.log.splice(0, t.log.length - MAX_LOG_LINES);
         this._save();
       }
-      /** 任务成功。 */
       succeed(taskId2, extra) {
         return this._finish(taskId2, "succeeded", null, extra);
       }
-      /** 任务失败。 */
       fail(taskId2, error, extra) {
         return this._finish(taskId2, "failed", error, extra);
       }
@@ -13588,7 +13471,7 @@ var require_token_kinds = __commonJS({
     var kinds = require_kinds();
     var pool = require_pool2();
     var KINDS = {
-      // 1) 原生 main 会话令牌：DSH 进程自己生成，我方只能捕捉；每次 DSH 重启轮换。
+      // 原生令牌：DSH 进程生成、我方只能捕捉；每次 DSH 重启轮换。main 与实例同策略、仅源不同。
       "dsh-main": {
         side: "dsh",
         strategy: "capture+persist",
@@ -13598,7 +13481,7 @@ var require_token_kinds = __commonJS({
         unitBacked: false,
         desc: "\u539F\u751F main \u4F1A\u8BDD\u4EE4\u724C\uFF08DSH \u8FDB\u7A0B\u751F\u6210\uFF1B\u6355\u6349+\u6301\u4E45\u5316+\u8DDF\u968F\uFF09"
       },
-      // 2) 沙箱实例会话令牌：与 main 同策略、只是源不同（systemd 单元 journald）。
+      // 沙箱实例会话令牌：源为 systemd 单元 journald。
       "dsh-instance": {
         side: "dsh",
         strategy: "capture+persist",
@@ -13608,8 +13491,8 @@ var require_token_kinds = __commonJS({
         unitBacked: true,
         desc: "\u6C99\u7BB1\u5B9E\u4F8B\u4F1A\u8BDD\u4EE4\u724C\uFF08DSH \u8FDB\u7A0B\u751F\u6210\uFF1B\u6E90\u4E3A dsh-web@<id> \u5355\u5143\uFF09"
       },
-      // 3) 浏览器会话 cookie：由 1/2 经 HTTP 303 换取，随 dshToken 轮换重换。
-      //    刻意为 persistent:false —— cookie 是**派生缓存**，落盘等于多一份会话凭据副本。
+      // 浏览器会话 cookie：由上面两种经 HTTP 303 换取，随 dshToken 轮换重换。
+      // 刻意为 persistent:false —— cookie 是派生缓存，落盘等于多一份会话凭据副本。
       "dsh-auth": {
         side: "dsh-derived",
         strategy: "exchange",
@@ -13619,7 +13502,7 @@ var require_token_kinds = __commonJS({
         unitBacked: false,
         desc: "\u6D4F\u89C8\u5668\u4F1A\u8BDD cookie\uFF08dsh-auth-*\uFF0C\u7531 dsh-main/dsh-instance \u6362\u53D6\uFF1B\u53EA\u5B58\u8FDB\u7A0B\u5185\u5B58\uFF09"
       },
-      // 4-6) 用户配置类：不是 DSH 令牌。不捕捉、不进令牌池展示、不随 DSH 轮换。
+      // 用户配置类：不是 DSH 令牌。不捕捉、不进令牌池展示、不随 DSH 轮换。
       "remote-token": {
         side: "user",
         strategy: "config",
@@ -13647,7 +13530,7 @@ var require_token_kinds = __commonJS({
         unitBacked: false,
         desc: "FRP \u8BA4\u8BC1\u4EE4\u724C\uFF08\u7528\u6237\u5728 UI \u586B\u5199\uFF0C\u900F\u4F20\u7ED9 frpc\uFF09"
       },
-      // 7) 我方签发的门卫会话 cookie。
+      // 我方签发的门卫会话 cookie。
       "lan-gate": {
         side: "self",
         strategy: "issue+verify",
@@ -13819,7 +13702,7 @@ var require_core5 = __commonJS({
         registryFile: path2.join(swDir, "registry.json"),
         events: host2.events,
         logger: host2.logger,
-        // 灰度名单事实：本机配置 canary:true。仅对 @dsh-sup/* 生效。
+        // 灰度事实由本机配置注入（canary:true）；仅 @dsh-sup/* 包消费该开关。
         canary: host2.config.canary === true
       });
       host2.shellDomain = shellDomain;
@@ -13840,7 +13723,7 @@ var require_port_segments = __commonJS({
     var ports = require_ports();
     var POOLS = {
       providerApi: { base: 24e3, count: 2e3 }
-      // 智能路由每供应商独立 API 端点（24000-25999，可容 2000 供应商）
+      // 每供应商独立 API 端点段（24000-25999）
     };
     var SEGMENTS = {
       proxyInstance: { pool: "managed", anchor: 1e3 },
@@ -13966,7 +13849,6 @@ var require_store3 = __commonJS({
       canPersist() {
         return this._canPersist ? this._canPersist() !== false : true;
       }
-      /** 触发一次落盘（经统一写权闸）。 */
       persist() {
         if (!this._persistFn) return;
         if (!this.canPersist()) return;
@@ -14399,12 +14281,9 @@ var require_base = __commonJS({
       async detectAccount(acc) {
         throw new Error("detectAccount must be implemented by subclass");
       }
-      // 能力契约声明（PG-1）。process-pool 能力面（startInstance/stopInstance/restartInstance/
-      // _waitHealthy/instanceOf/ensureServable/reclaimAccount/markRequestOk/markInstanceNetFail/
-      // _retryPendingStop/flushRestartPending/reconcileInstances 及其 this 图所需的
-      // accountOf/markInstanceProblem/_doStart）
-      // 由 providers/process-pool.js 的 mixin 实现并并入 supports 词表——契约在能力方声明，
-      // 基座不再携带实现不了的抛错占位；调用方一律以 supports(cap) 守卫。
+      // 能力契约声明（PG-1）：process-pool 能力面由 providers/process-pool.js 的 mixin 实现并
+      // 并入 supports 词表——契约在能力方声明，基座不携带实现不了的抛错占位；
+      // 调用方一律以 supports(cap) 守卫。
       /** 本 provider 是否具备某项能力；缺省为无 process 能力（最保守）。 */
       supports(_cap) {
         return false;
@@ -14460,7 +14339,7 @@ var require_base = __commonJS({
       classifyResponse(status, headers, bodyText) {
         return quota.classifyUpstreamLimited(status, bodyText);
       }
-      /** 账号处置副作用（M3 契约）：router 只发 signal，具体冻结/停实例/封号由 provider 执行。 */
+      /** 账号处置副作用契约：router 只发 signal，具体冻结/停实例/封号由 provider 执行。 */
       effect(signal, acc, ctx) {
         const c = ctx || {};
         if (signal === "credits") {
@@ -14477,7 +14356,7 @@ var require_base = __commonJS({
         }
         return false;
       }
-      /** 唯一「时间窗额度用尽」判定（M4）。 */
+      /** 唯一「时间窗额度用尽」判定。 */
       _windowExhausted(acc) {
         return quota.windowExhausted(acc);
       }
@@ -14487,7 +14366,7 @@ var require_base = __commonJS({
       _creditsRefilled(acc) {
         return quota.creditsRefilled(acc);
       }
-      /** 账号可用性判定（唯一事实，M4）：ready 且未「预付余额不足」且窗口未满。 */
+      /** 账号可用性判定（唯一事实）：ready 且未「预付余额不足」且窗口未满。 */
       isAccountUsable(acc, opts) {
         if (!acc || acc.status !== "ready") return false;
         if (this._isCreditsLow(acc)) return false;
@@ -14501,7 +14380,7 @@ var require_base = __commonJS({
       _ensureLimit(acc) {
         return freeze.ensureLimit(acc);
       }
-      /** limit 纯只读预览（#20；不赋值、不写盘）：只读视图唯一入口。写版 _ensureLimit 保留（门禁/测试消费）。 */
+      /** limit 纯只读预览（不赋值、不写盘）：只读视图唯一入口。写版 _ensureLimit 保留（门禁/测试消费）。 */
       _previewLimit(acc) {
         return freeze.previewLimit(acc);
       }
@@ -14520,7 +14399,7 @@ var require_base = __commonJS({
       markBanned(acc, error) {
         return freeze.markBanned(acc, error, this);
       }
-      // 状态投影完成处补齐 limit（写版 ensureLimit 从只读视图移到此）。唯一投影入口，覆盖全部 applyDetection 调用方。
+      // applyDetection 是唯一状态投影入口（覆盖全部调用方）：投影完成后补齐 limit（写版 ensureLimit）。
       applyDetection(acc, det) {
         const r = freeze.applyDetection(acc, det, this);
         freeze.ensureLimit(acc);
@@ -14715,7 +14594,7 @@ var require_direct = __commonJS({
         this.presetId = opts.presetId || null;
         this.officialPricing = {};
       }
-      /** 能力声明：key-pool 无实例能力。显式声明「不支持」，使转发层不再靠 typeof 猜测，差异可静态校验。 */
+      /** 能力声明：key-pool 无实例能力，显式声明「不支持」供调用方 supports() 守卫，差异可静态校验。 */
       supports(_cap) {
         return false;
       }
@@ -14798,15 +14677,13 @@ var require_model2 = __commonJS({
       toJSON() {
         return serializeInstance(this);
       }
-      /** 实例是否可立即服务（切换策略唯一需要问的问题，见双预算切换）。 */
+      /** 实例是否可立即服务（切换策略唯一需要问的问题）。 */
       isServable() {
         return isServable(this);
       }
-      /** 实例是否占用资源（WARM/HOT/DEAD 都有进程）。 */
       occupiesSlot() {
         return occupiesSlot(this);
       }
-      /** 反序列化：进程态(pid)不落盘 -> 一律回到 COLD，由 reconcile 按期望集重新拉起。 */
       static fromJSON(o) {
         return deserializeInstance(o);
       }
@@ -15727,11 +15604,10 @@ var require_process_pool = __commonJS({
             }
           };
         }
-        /** 能力声明 = 基座能力与 process-pool 能力的并集。 */
         supports(cap) {
           return POOL_CAPS.includes(cap) || super.supports(cap);
         }
-        /** 使用状态在基座（in-use/idle）上派生 warming：实例在场是池能力，覆写归 mixin。 */
+        /** 实例在场是池能力：在基座使用状态（in-use/idle）上覆写派生 warming。 */
         usageOf(acc) {
           const r = super.usageOf(acc);
           if (r !== "idle") return r;
@@ -15741,7 +15617,7 @@ var require_process_pool = __commonJS({
         accountOf(inst) {
           return this.accounts.find((a) => a.key === inst.key) || null;
         }
-        /** 账号 -> 实例映射（一账号一实例）：usageOf 派生 warming 的依据。 */
+        /** 账号 -> 实例映射（一账号一实例硬规则）。 */
         instanceOf(acc) {
           if (!acc) return null;
           return (this.instances || []).find((i) => i.keyId === acc.keyId) || acc.instance || null;
@@ -15769,19 +15645,17 @@ var require_process_pool = __commonJS({
           })();
           return inst.startingPromise;
         }
-        /** 启动实例底层治理（spawn/探活在 probe.js）。方法在能力面上保持原型可覆写，
-         *  测试以 _doStart 打桩替换 spawn；留在 mixin 侧是为了 this 图单向（mixin 不回调消费方方法）。 */
+        /** 启动实例底层治理（spawn/探活在 probe.js）。测试以 _doStart 打桩替换 spawn；留在 mixin 侧是为 this 图单向。 */
         async _doStart(inst) {
           return probe.spawnInstance(this, inst);
         }
-        /** 请求成功后清零失败计数（时机是熔断可达的全部要害）。不触碰健康监测的 _monitorFails。 */
+        /** 请求级熔断计数清零；独立于健康监测的 _monitorFails。 */
         markRequestOk(inst) {
           if (!inst) return;
           inst._unhealthyCount = 0;
         }
-        /** 统一可服务化门面（LC 核心-1：请求路径/显式切换经此驱动进程，不裸调 start/kill）：
-         *  幂等启动（startingPromise 去重）+ 预算内同步等待。opts.budgetMs=null 表示等满探活周期
-         *  （显式切换的启动预算，裁决 1：超时诚实报错，绝不静默换号）。 */
+        /** 统一可服务化门面（LC 核心-1）：幂等启动 + 预算内同步等待，外部不裸调 start/kill。
+         *  budgetMs=null 表示等满探活周期（显式切换预算）；超时诚实报错，绝不静默换号。 */
         async ensureServable(acc, opts) {
           const inst = this.instanceOf(acc);
           if (!inst) return { ok: false, error: "\u5B9E\u4F8B\u4E0D\u5B58\u5728" };
@@ -15795,12 +15669,12 @@ var require_process_pool = __commonJS({
           return { ok: false, warming: !!inst.pid, error: "\u5B9E\u4F8B\u672A\u5728\u7B49\u5F85\u671F\u5185\u5C31\u7EEA" };
         }
         /** 等待区回收唯一入口（LC 核心-3）：force 终止 + 释放端口，账号进程层面同一轮零存在。
-         *  丢弃在途属预期语义——发不出请求的账号不该继续占进程（裁决：冻结零宽限）。幂等。 */
+         *  冻结零宽限：发不出请求的账号不该继续占进程；丢弃在途属预期语义。幂等。 */
         reclaimAccount(acc) {
           return life.reclaimAccount(this, acc);
         }
-        /** 状态迁移事件表接线（freeze.js setStatus 回调）：进入等待区（frozen/banned/discarded）
-         *  立即回收；恢复回可用池（status 回到 ready）立即重算期望集补缺口（LC 核心-5，不等周期对账的运气）。 */
+        /** 状态迁移事件表的进程侧接线（freeze.js setStatus 调用）：进等待区立即回收；
+         *  回 ready 立即重算期望集补缺口（LC 核心-5），不等周期对账。 */
         _onStatusTransition(acc, prev, status) {
           if (status === "frozen" || status === "banned" || status === "discarded") {
             try {
@@ -15811,11 +15685,10 @@ var require_process_pool = __commonJS({
             this.reconcileNow();
           }
         }
-        /** 实例停止（幂等）：在途/在用 -> 标记待停；force 跳过仲裁（委托 instance-lifecycle.js）。 */
+        /** 实例停止仲裁（在途/在用延后、force 跳过的语义在 instance-lifecycle.js）。 */
         stopInstance(inst, force) {
           return life.arbitrateStop(this, inst, force);
         }
-        /** 请求结束补刀（委托 instance-lifecycle.js）。 */
         _retryPendingStop(acc) {
           return life.retryPendingStop(this, acc);
         }
@@ -15874,11 +15747,11 @@ var require_process_pool = __commonJS({
           } catch {
           }
         }
-        /** 兼容旧名（保持对外调用不破）。 */
+        /** 兼容旧名别名。 */
         markInstanceNetFail(instOrAcc) {
           this.markInstanceProblem(instOrAcc, "net-error");
         }
-        /** 实例空闲后补做「被延后的重启」（_restartPending 的消费点，不再只写不读）。 */
+        /** 实例空闲后补做被延后的重启（_restartPending 的唯一消费点）。 */
         flushRestartPending(inst) {
           if (!inst || !inst._restartPending) return;
           const acc = this.accountOf(inst);
@@ -15976,7 +15849,6 @@ var require_proxy = __commonJS({
         this._stopping = false;
         this._terminatingPids = /* @__PURE__ */ new Set();
       }
-      /** 能力声明：基座与 process-pool 的并集在 withProcessPool mixin 完成（process-pool.js）。 */
       async ensureInstance(key) {
         let inst = this.instances.find((i) => i.key === key);
         if (inst) return inst;
@@ -15984,7 +15856,7 @@ var require_proxy = __commonJS({
         this.instances.push(inst);
         return inst;
       }
-      /** 解析启动命令（缓存优先 + fallback npx）：纯拼装委托 command.js，凭证剔除留在本层（纪律）。 */
+      /** 解析启动命令（缓存优先 + fallback npx）：拼装委托 command.js；凭证剔除留在本层（纪律）。 */
       async _resolveLaunchCommand(app, port, key) {
         const registry = this.dist ? await this.dist.selectRegistry(false).catch(() => null) : null;
         const cachedBin = this._cachedPkgBin(app.pkg);
@@ -16008,23 +15880,18 @@ var require_proxy = __commonJS({
       _ensurePkgCached(app) {
         return probe.ensurePkgCached(this, app);
       }
-      /** 实例停止仲裁（委托 instance-lifecycle.js）。 */
       _canStopInstance(acc) {
         return life.canStopInstance(this, acc);
       }
-      /** 等待全部 SIGTERM 在途子进程真正退出（实现与 zombie 判定在 probe.js）。 */
       async waitAllStopped(timeoutMs) {
         return probe.waitAllStopped(this, timeoutMs);
       }
-      /** 实例探活（探活实现与计数分层在 probe.js，计数各归其主）。 */
       async healthInstance(inst) {
         return probe.healthInstance(this, inst);
       }
-      /** 实例生命周期监控（进程/端口/HTTP 卡死检测）。 */
       async monitorLifecycle() {
         return probe.monitorLifecycle(this);
       }
-      /** 模式级配额检测（策略注册与解析在 probe.js + quota-strategies.js）。 */
       async detectInstanceQuota(inst) {
         return probe.detectInstanceQuota(this, inst);
       }
@@ -16034,14 +15901,14 @@ var require_proxy = __commonJS({
       isAccountUsable(acc, opts) {
         return life.isAccountUsable(this, acc, opts);
       }
-      /** 429/403 配额触发冻结：立即回收进等待区（force + 释放端口，零宽限），再状态机，再对账补槽。 */
+      /** 429/403 配额冻结：先立即回收进等待区（force + 释放端口，零宽限），再状态机，再对账补槽。 */
       markQuotaExhausted(acc, cooldownMs) {
         this.reclaimAccount(acc);
         super.markQuotaExhausted(acc, cooldownMs);
         this.reconcileNow();
         this._probeAfterResponseFreeze(acc);
       }
-      /** credits 余额不足：与窗口同一处置（立即回收 + 冻结 + 对账补槽）。 */
+      /** credits 余额不足：与窗口同一处置（回收 + 冻结 + 补槽）。 */
       markCreditsExhausted(acc) {
         this.reclaimAccount(acc);
         super.markCreditsExhausted(acc);
@@ -16072,7 +15939,7 @@ var require_proxy = __commonJS({
       reconcileNow() {
         return restart.reconcileNow(this);
       }
-      /** 封号：立即回收进等待区，再更新状态机。 */
+      /** 封号：与配额冻结同一处置（先回收再走状态机）。 */
       markBanned(acc, error) {
         this.reclaimAccount(acc);
         super.markBanned(acc, error);
@@ -16185,8 +16052,7 @@ var require_switch2 = __commonJS({
         this.events = opts.events || null;
         this.onPersist = opts.onPersist || null;
       }
-      /** 在指定供应商的账号池内选择（供应商独立端点语义）：绝不跨供应商 failover，本池无可用返回 null。
-       *  opts.excludeKeys=Set 时把本请求内瞬时故障（5xx/net-error）账号直接排除，强制轮换不粘滞。 */
+      /** 在指定供应商池内选号（不跨池，见文件头）。opts.excludeKeys=Set 时排除本请求内瞬时故障账号，强制轮换不粘滞。 */
       pickFor(provider, opts) {
         if (!provider) return null;
         return this._pickIn(provider, opts);
@@ -16223,11 +16089,8 @@ var require_switch2 = __commonJS({
         if (this.events) this.events.append("router_pick", { provider: p.name, key: picked.maskedKey });
         return picked;
       }
-      /** 上游失败反应（唯一编排点）。ctx = { status, headers, body, attempt, attempts, error? }：
-       *  1) provider.classifyResponse 给出 signal；
-       *  2) provider.effect 执行账号副作用（credits/window 冻结，proxy 会停实例并预热；banned 封号）；
-       *  3) 返回 action：'retry'（credits/window/transient，带 transient 标记供调用方定退避）或
-       *     'passthrough'（banned/none/unknown 原样回状态/头/体，绝不误切）。 */
+      /** 上游失败反应（唯一编排点）。ctx = { status, headers, body, attempt, attempts, error? }；
+       *  action/retry 语义见 policies/failure.js decideFailure 契约。 */
       reactToFailure(provider, acc, ctx) {
         const c = ctx || {};
         const status = c.status;
@@ -16296,7 +16159,7 @@ var require_store4 = __commonJS({
       canPersist() {
         return this._writable !== false && this.loadedOk === true;
       }
-      /** L3：设置状态文件写开关（true=本实例写；false=只读，由外部 router-daemon 独占写）。 */
+      /** 设置状态文件写开关（true=本实例写；false=只读，由外部 router-daemon 独占写）。 */
       setPersistEnabled(v) {
         this._writable = v !== false;
       }
@@ -16361,8 +16224,7 @@ var require_store4 = __commonJS({
           key: a.key || null,
           keyId: a.keyId,
           maskedKey: a.maskedKey,
-          // 单事实源：只读 status；
-          //   usage 不反序列化（纯派生，由 usageOf 从 activeAccount/实例实况算）。
+          // 单事实源：只读 status；usage 不反序列化（纯派生，由 usageOf 计算）。
           status: a.status || a.validity || "registered",
           quota: a.quota || null,
           registeredAt: a.registeredAt || Date.now(),
@@ -16398,32 +16260,27 @@ var require_proxy_apps = __commonJS({
         id: "commandcode",
         name: "Command Code Proxy",
         pkg: "commandcode-api-proxy",
-        // 官方运行方式（npx 一键）—— 完整独立发行版
         command: ["npx", "--yes", "commandcode-api-proxy", "--host", "127.0.0.1", "--port", "{{port}}", "--api-key", "{{key}}"],
         healthPath: "/health",
         modelPath: "/v1/models",
         upstream: "https://api.commandcode.ai",
-        // 实例环境契约：keyEnv=账号密钥注入的 env 名（只经 env 传递，绝不进 cmdline）；app.env/超时等
-        // 一律不注入，commandcode-api-proxy 跑完全默认配置（idle 120s / upstream 600s，作者设计值）——
-        // 加 CC_IDLE_TIMEOUT_MS=0 等自我干预曾导致回归，故保持纯净注入。
+        // 实例环境契约：keyEnv 是密钥注入的唯一 env 名（绝不进 cmdline）；app.env/超时等一律不注入，
+        // 跑上游完全默认配置（作者设计值）——自我干预（如 CC_IDLE_TIMEOUT_MS=0）曾导致回归，保持纯净注入。
         keyEnv: "CC_API_KEY",
         repo: "thaolaptrinh/commandcode-api-proxy",
         // 自动更新：最新版本从 npm registry 查（同一 package 名）。空则跳过版本检查。
         registry: "commandcode-api-proxy",
         versionRefreshMs: 6 * 3600 * 1e3,
-        // 默认 6h 查一次 npm
-        // 每账号配额来源：Command Code 官方 /alpha/billing/credits（Bearer 各账号 key；窗口 5h/weekly +
-        // credits 池，无 period 字段），以及 /alpha/billing/subscriptions 的 currentPeriodEnd（月额度随订阅
-        // 续期重置的精确时刻；仅 credits-limited 账号按 6h 缓存低频取，防风控）。
-        // windowMap: rolling=5h、weekly=周；monthly 由订阅面推导（见 quota-strategies 的 monthlyCapUsd）。
+        // 每账号配额来源：官方 billing 面（解析逻辑见 quota-strategies.js detectCommandCodeBilling）。
+        // windowMap 指 rolling/weekly 字段；monthly 由订阅面推导。
         quota: {
           type: "commandcode-billing",
           apiBase: "https://api.commandcode.ai",
           creditsPath: "/alpha/billing/credits",
           subscriptionsPath: "/alpha/billing/subscriptions",
           windowMap: { rolling: "fiveHour", weekly: "weekly", monthly: null },
-          // 月度配额上限（$/月）：Command 订阅含 $10/月总配额池，周窗口从池内扣（weekly.used +
-          // monthlyCredits.remaining = 10），解析层据此推导 monthly.percent，前端每月格子显示真实百分比。
+          // 月度配额上限（$/月）：订阅含 $10/月总池，周窗口从池内扣（weekly.used + monthlyRemaining = 10），
+          // 解析层据此推导 monthly.percent。
           monthlyCapUsd: 10
         },
         real: true
@@ -17053,11 +16910,8 @@ var require_usage = __commonJS({
         this._timer = null;
         this._dirty = false;
       }
-      /** 归一 model 键：E-4 单源字符集闸（platform/util/input.ledgerKey）。
-       *  旧实现只做「字符串化 + 截断」，于是客户端 body 里的 model 名可以就是
-       *  `__proto__` / `constructor` —— `t.byModel[key] = {...}` 走的是原型赋值，
-       *  账本静默失真且污染面在 Object.prototype 上（空白/控制符键同理，面板也没法看）。
-       *  违规值**折进 (other) 桶**而不是丢弃：B19 的上限语义与「不丢计数」都保持不变。 */
+      /** model 键归一走 platform/util/input.ledgerKey（外部输入字符集单源闸）：
+       *  __proto__/constructor/空白/控制符等违规值折进 (other) 桶——不丢计数，也不做对象键（防原型污染）。 */
       _modelKey(model) {
         return input.ledgerKey(model, { max: 128, empty: "unknown", unsafe: "(other)" });
       }
@@ -17074,7 +16928,6 @@ var require_usage = __commonJS({
         }
         return bm;
       }
-      /** 记账：累计总量 + byModel + byKey，按快照单价估算费用，节流落盘。 */
       recordUsage(entry) {
         const t = this.load();
         t.requests += 1;
@@ -17104,14 +16957,13 @@ var require_usage = __commonJS({
         if (this.events) this.events.append("router_usage", { model: entry.model, tokens: entry.totalTokens });
         return t;
       }
-      /** 错误计数（持久化）。 */
       recordError() {
         const t = this.load();
         t.errors = (t.errors || 0) + 1;
         this._scheduleWrite();
         return t.errors;
       }
-      /** 脏标记 + 尾部定时器合并落盘（delay=0 时保持每调用同步写，兼容既有测试语义）。 */
+      /** 脏标记 + 尾部定时器合并落盘；delay=0 时每调用同步写（兼容既有测试语义）。 */
       _scheduleWrite() {
         this._dirty = true;
         if (this._writeDelayMs <= 0) return this._writeTotals();
@@ -17131,9 +16983,8 @@ var require_usage = __commonJS({
         if (!this._dirty) return;
         this._writeTotals();
       }
-      /** 读盘。读源纪律：写者以内存为准（节流窗口内盘落后于内存，重读会丢在途账）；
-       *  只读实例（守卫/内嵌，无写权）从不记账，盘上是别人的活账，必须每次新鲜读盘——
-       *  永久缓存会让面板冻结在进程启动时的旧快照。兼容旧格式补默认字段，防 undefined 崩溃。 */
+      /** 读源纪律：写者以内存为准（节流窗口内盘落后于内存，重读丢在途账）；
+       *  只读实例（无写权）从不记账、盘上是别人的活账，必须每次新鲜读盘——永久缓存会冻结面板。 */
       load() {
         if (this.totals && this._canPersist()) return this.totals;
         let t;
@@ -17145,13 +16996,12 @@ var require_usage = __commonJS({
         this.totals = defaults(t);
         return this.totals;
       }
-      /** 汇总视图（byModel 取 token 前 12）。 */
       getUsage() {
         const t = this.load();
         const byModel = Object.entries(t.byModel || {}).map(([model, v]) => ({ model, ...v })).sort((a, b) => b.totalTokens - a.totalTokens).slice(0, 12);
         return { requests: t.requests, promptTokens: t.promptTokens, completionTokens: t.completionTokens, totalTokens: t.totalTokens, costUsd: t.costUsd, errors: t.errors || 0, byModel, byKey: t.byKey || {} };
       }
-      /** 原子落盘（tmp+rename 防崩溃/断电损坏高频用量文件）；写权单闸。 */
+      /** 原子落盘：tmp+rename 防崩溃/断电损坏高频用量文件；写权单闸。 */
       _writeTotals() {
         try {
           if (typeof this._canPersist === "function" && !this._canPersist()) return;
@@ -17183,13 +17033,10 @@ var require_inflight = __commonJS({
           acc.inflight = (acc.inflight || 0) + 1;
           return acc.inflight;
         },
-        /**
-         * 唯一在途递减入口。
-         * @param {object} acc 账号（在途计数挂在账号对象上）
-         * @param {{prov?:object, inst?:object, lifecycle?:boolean}} [ctx]
-         * @returns {{ zero:boolean, effects:Array<{kind:string,acc:object,prov:object,inst:object}> }}
-         *   effects 仅为**描述**，由调用方执行——两条结束路径共用此结果。
-         */
+        /** 唯一在途递减入口。@param {object} acc 账号（在途计数挂在账号对象上）
+         *  @param {{prov?:object, inst?:object, lifecycle?:boolean}} [ctx]
+         *  @returns {{ zero:boolean, effects:Array<{kind:string,acc:object,prov:object,inst:object}> }}
+         *    effects 仅为描述，由调用方在所有结束路径统一执行。 */
         end(acc, ctx) {
           if (!acc) return { zero: false, effects: [] };
           ended += 1;
@@ -18090,7 +17937,7 @@ var require_views = __commonJS({
       });
       return {
         running: state.running === true,
-        // 中转服务逻辑开关（无公用入口；启用即提供已激活供应商的独立端点）
+        // 服务运行标志（由 RouterService start/stop 翻转，不在 ctl 方法白名单内）
         activatedProviders: (state.providers || []).filter((x) => x.activated).length,
         // 已激活供应商数（独立端点在线数）
         providers: provs,
@@ -18142,14 +17989,13 @@ var require_views = __commonJS({
             keyId: a.keyId,
             maskedKey: a.maskedKey,
             status: a.status,
-            // 单事实源
             validity: a.status,
             // 兼容字段（=status，避免旧前端读 undefined）
             usage: usageOf,
             // 纯派生（activeAccount/实例实况）
             quota: a.quota || null,
             limit: (p._previewLimit ? p._previewLimit(a) : a.limit) || null,
-            // limitKind+recovery（#20 纯只读预览，无写副作用）
+            // limitKind+recovery（只读预览，无写副作用）
             nextResetAt: a.nextResetAt || null,
             registeredAt: a.registeredAt,
             detectError: a.detectError || null,
@@ -18964,7 +18810,6 @@ var require_router3 = __commonJS({
       _startActivatedProviders() {
         return this._endpoint.startActivatedProviders();
       }
-      /* Q9 转发 */
       proxyFor(prov, req, res) {
         return this._forward.proxyFor(prov, req, res);
       }
@@ -18977,7 +18822,7 @@ var require_router3 = __commonJS({
       recordError() {
         return this._forward.recordError();
       }
-      /* Q7 注册表 + Q12 生命周期 */
+      /* 注册表 + 生命周期 */
       addDirectProvider(o) {
         return this._ops.addDirectProvider(o);
       }
@@ -18999,7 +18844,7 @@ var require_router3 = __commonJS({
       stopAllInstances() {
         return this._ops.stopAllInstances();
       }
-      /* Q10/Q11 调度 */
+      /* 调度 */
       _startMaintenance() {
         return this._scheduler.start();
       }
@@ -19400,7 +19245,6 @@ var require_model3 = __commonJS({
         id,
         name: String(payload.name || "\u5B9E\u4F8B:" + port).slice(0, 40),
         port,
-        // 新增实例：默认沙箱域（绝对隔离、与原生/彼此互不干扰）
         domain: "sandbox",
         kind: "sandbox",
         autoRegistered: false,
@@ -19415,7 +19259,7 @@ var require_model3 = __commonJS({
           privateTmp: true,
           // node/dsh 位于 /home（nvm），ProtectHome=yes 会使其 exec 失败(203/EXEC)；默认关闭，可用 payload.protectHome 覆盖
           protectHome: payload.protectHome === void 0 ? false : !!payload.protectHome
-          // 资源配额不接收户输入：启动时由 governor 按机器预算与活跃实例数推导（见 ARCHITECTURE-PLAN-instance-sandbox-governor）。
+          // 资源配额不接收户输入：启动时由 governor 按机器预算与活跃实例数推导。
         },
         state: { phase: "STOPPED", restartCount: 0, backoffLevel: 0, lastProbeOk: null },
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -19509,16 +19353,13 @@ var require_store5 = __commonJS({
         this.syncPorts();
         return this.instances;
       }
-      /** 清历史遗留的未声明 state 字段。**只在内存删、本方法不写盘**；下次 save（5s tick 或任意内容变化）
-       *  由 save() 全量序列化内存数组而自然落地，故幂等：文件既已无该键，再 load 即无键可删。
-       *  state.version：阶段五已停止写入（upgrade.js 的两处赋值删除），且内核/测试/壳仓**零消费者**、
-       *  createRecord 声明的 state 形状不含它（version 显示走 readInstalledVersion 实时读盘）。
-       *  同型先例：model.normalizeInstance 同样在加载期删遗留键 dshToken（有测试断言该行为）。 */
+      /** 清历史遗留的未声明 state 字段。只在内存删、本方法不写盘；下次 save() 全量序列化自然落地，故幂等。
+       *  state.version：内核/测试/壳仓零消费者，版本显示走 readInstalledVersion 实时读盘，已从记录形状声明中移除。 */
       _stripLegacyStateKeys(inst) {
         if (inst.state && Object.prototype.hasOwnProperty.call(inst.state, "version")) delete inst.state.version;
       }
-      /** 损坏现场隔离：先告警，再把损坏文件改名为 .corrupt-<ts> 保留现场，最后清空内存。
-       *  rename 先于清空（后续 save 会覆盖原文件）；rename 后原文件不再被覆盖。 */
+      /** 损坏现场隔离：先告警，再把损坏文件改名为 .corrupt-<ts> 保留现场，最后清空内存——
+       *  rename 必须先于清空，后续 save 才不会覆盖原损坏文件。 */
       _quarantineCorrupt(err) {
         const bak = this.instancesFile + ".corrupt-" + Date.now();
         this.logger && this.logger.warn && this.logger.warn("instances.json \u8BFB\u53D6/\u89E3\u6790\u5931\u8D25\uFF0C\u5907\u4EFD\u540E\u6E05\u7A7A: " + (err && err.message) + " -> " + bak);
@@ -19529,7 +19370,7 @@ var require_store5 = __commonJS({
         }
         this._replace([]);
       }
-      /** 原地替换数组内容（**保持数组对象身份**，外部引用不失效）。 */
+      /** 原地替换数组内容（保持数组对象身份，外部引用不失效）。 */
       _replace(list) {
         if (list === this.instances) return;
         this.instances.length = 0;
@@ -19549,11 +19390,10 @@ var require_store5 = __commonJS({
           this.logger && this.logger.error && this.logger.error("instances.json \u6301\u4E45\u5316\u5931\u8D25: " + (e && e.message));
         }
       }
-      /** 实例端口注册表派生同步：端口真源是 instances.json（内存数组，用户配置值）；registry 的 inst:*
-       *  记录是派生投影，把配置端口纳入全局冲突视图（防动态分配段撞实例端口），非记忆绑定。
-       *  全量对账：内存有而 registry 缺则 registerUser；registry 有 inst:* 而内存无对应实例则 unregister。
-       *  同 owner 已登记端口与当前配置端口不一致（端口已变）时，先 unregister 旧登记再按新端口
-       *  registerUser——否则旧 inst:* 记录因「该 id 仍存在」而永久泄漏。 */
+      /** 端口登记派生同步：真源是 instances.json 内存数组（用户配置值），registry 的 inst:* 记录只是派生投影，
+       *  把配置端口纳入全局冲突视图（防动态分配段撞实例端口）。全量对账：内存有而 registry 缺则 registerUser，
+       *  registry 有 inst:* 而内存无该实例则 unregister；端口变更时先卸旧登记再按新端口注册，
+       *  否则旧 inst:* 记录因「该 id 仍存在」永久泄漏。 */
       syncPorts() {
         for (const inst of this.instances) {
           const id = String(inst.id || "");
@@ -19582,7 +19422,7 @@ var require_store5 = __commonJS({
         }
       }
       /** 为沙箱实例建独立目录（根 + 数据 + 依赖 + 临时）。实例根一次性收紧权限：
-       *  同机他用户的跨舱互读是隔离清单里唯一没被目录布局本身挡住的一格。 */
+       *  同机他用户的跨舱互读是隔离清单里唯一未被目录布局本身挡住的一格。 */
       ensureDirs(inst) {
         const r = fileProtect.ensurePrivateDir(sandbox.root(this.instancesRoot, inst));
         if (r && r.ok === false) this.logger && this.logger.warn && this.logger.warn("\u5B9E\u4F8B\u6839\u6743\u9650\u6536\u7D27\u5931\u8D25 " + r.mode + ": " + r.reason);
@@ -21275,14 +21115,10 @@ var require_market = __commonJS({
         if (this._inFlight) return this._inFlight;
         return this._startBuild();
       }
-      /** 启动一次构建并登记为并发去重引用，返回**原始** promise。
-       *  两条不变量必须同时成立：
-       *    (a) 无消费者的后台刷新失败不得成为进程级 unhandledRejection —— 靠给 raw **挂一个
-       *        no-op handler「标记已处理」**实现，而不是把 promise 消化掉；
-       *    (b) 被消费者取走时仍须如实失败 —— raw 的 reject 语义不变（api/domains/plugins.js 的
-       *        GET /plugins/market 分支据此回答 500）。
-       *  若改成「消化后存回 _inFlight」，则并发的 force 请求会取到这个已消化的 promise，
-       *  失败时 resolve 成 undefined -> 200 + 空体，正是本仓最忌讳的「假成功」。 */
+      /** 启动一次构建并登记为并发去重引用，返回原始 promise。两条不变量必须同时成立：
+       *  (a) 无消费者的后台刷新失败不得成为进程级 unhandledRejection —— 靠给 raw 挂 no-op handler「标记已处理」实现，而不是把 promise 消化掉；
+       *  (b) 被消费者取走时仍须如实失败 —— raw 的 reject 语义不变（api/domains/plugins.js 的 GET /plugins/market 据此回答 500）。
+       *  若改成「消化后存回 _inFlight」，force 请求会取到它并在失败时 resolve 成 undefined -> 200 + 空体。 */
       _startBuild() {
         const raw = this.buildIndex();
         raw.catch(() => {
@@ -21425,7 +21261,7 @@ var require_market = __commonJS({
         }
         return (origin || REGISTRY).replace(/\/+$/, "");
       }
-      /** npm 最新版元数据查询：走 dist 统一镜像源（国内可达性/手动固定与全系统一致）。 */
+      /** npm 最新版元数据查询（镜像源选择见 _npmOrigin）。 */
       async safeFetchLatest(name) {
         return fetchLatest(await this._npmOrigin(), name);
       }
@@ -22718,27 +22554,20 @@ var require_managed_object = __commonJS({
         kind: o.kind,
         id: o.id,
         name: String(o.name || o.id),
-        // 应然（业务申报 / 用户操作；唯一持久意图）
-        //   desired：两域共用同一字段名，但语义不同——
-        //     域 A = 用户意图；域 B = 「当前业务是否需要它」的条件。
+        // desired 两域共用字段名但语义不同：域 A=用户意图；域 B=「当前业务是否需要它」的条件
         desired: o.desired === "stopped" ? "stopped" : "running",
-        // guardian：域 A 专有字段（契约 G-1）。域 B 基础设施不物化它——
-        //   不是「置 false」，是「不存在」，这样旧残留才清得掉。
+        // guardian 域 A 专有（见上）；域 B 不物化，旧残留才清得掉
         ...isDomainA(o.kind) ? { guardian: o.guardian === true } : {},
-        // 所有权（注册时申报；持久）
         ownership: normalizeOwnership(o.ownership),
-        // phase（调谐循环 R3 驱动；初始 stopped。业务不得直接改）
+        // 初始 stopped；业务不得直接改，由 heartbeat 调谐循环写入
         phase: "stopped",
-        // 观测缓存（实然；不持久化，由 heartbeat/adapter 写入）
         lastObserved: null,
-        // { ok, error, at }
-        // 进程句柄/运行期引用（C3-3b G2：main 状态机句柄挂目录，不持久化——
-        // 形如 { child?, adoptedPid?, adopted, observedOnly, startDeadline?, spawnBlockedUntil? }）
+        // 实然缓存 { ok, error, at }；不持久化，由 heartbeat/adapter 写入
+        // 运行期引用（不持久化）：main 状态机句柄，形如 { child?, adoptedPid?, adopted, observedOnly, startDeadline?, spawnBlockedUntil? }
         process: null,
-        // 域摘要引用（R4：daemon 类黑盒经 ctl 向目录呈报的紧凑摘要，只存引用/只读缓存，不持久化；
-        // 形如 { runState, providers, accounts, proxyInstances, resourcePorts, fetchedAt }）
+        // daemon 类黑盒经 ctl 呈报的紧凑摘要，只读缓存不持久化（形如 { runState, providers, accounts, proxyInstances, resourcePorts, fetchedAt }）
         domainSummary: null,
-        // 退避（调谐用；崩溃窗口）随目录持久化（见 _load/_save）。
+        // 退避与崩溃窗口计数随目录持久化（见 registry _load/_save）
         backoffLevel: 0,
         backoffUntil: null,
         crashWindowStart: null,
@@ -22940,8 +22769,8 @@ var require_registry3 = __commonJS({
           this._log("warn", "managed-objects \u6301\u4E45\u5316\u5931\u8D25: " + (e && e.message));
         }
       }
-      /** 崩溃/退避字段变化时的持久化入口：防抖 50ms 合并同拍多次变更，避免写放大。
-       *  仅落盘目录文件；由 supervisor._persistCrashField 在字段变更后调用。 */
+      /** 崩溃/退避字段变化的持久化入口：防抖 50ms 合并同拍多次变更避免写放大；
+       *  由 supervisor._persistCrashField 在字段变更后调用。 */
       persistCrashState() {
         if (this._crashSaveTimer) return;
         this._crashSaveTimer = setTimeout(() => {
@@ -22971,7 +22800,7 @@ var require_registry3 = __commonJS({
         const i = this._objects.indexOf(e);
         if (i >= 0) this._objects.splice(i, 1);
       }
-      /** 注册新类型能力（未来扩展；显式声明，非 CRD）。委托纯模型 managed-object。 */
+      /** 注册新类型能力（显式声明，非通用 CRD；实现与判据见 managed-object.js）。 */
       registerKind(kind, meta) {
         registerManagedKind(kind, meta);
         return this;
@@ -22995,8 +22824,8 @@ var require_registry3 = __commonJS({
         this._event("managed_object_registered", { kind: e.kind, id: e.id, name: e.name });
         return e;
       }
-      /** 对象变更申报（desired/guardian/ownership/name）。
-       *  `guardian` 是域 A 专有：域 B 基础设施忽略它并清除历史残留。 */
+      /** 对象变更申报（desired/guardian/ownership/name）。guardian 是域 A 专有：
+       *  域 B 基础设施既不写入，还主动删键清除早期版本残留（下一次 update 即归一）。 */
       update(id, patch) {
         const e = this.get(id);
         if (!e) return { ok: false, error: "\u672A\u6CE8\u518C: " + id };
@@ -23043,10 +22872,8 @@ var require_registry3 = __commonJS({
         this._event("managed_object_removed", { kind: e.kind, id: e.id });
         return { ok: true };
       }
-      /** 释放本对象持有的端口（按 owner）。
-       *  `PortRegistry.release(port, ownerId)` 的 owner 校验不可绕过：这里绝不回退成无 owner 的释放
-       *    （那会误删他人端口登记）。返回值仅用于日志——不匹配即 no-op 是期望行为，不是错误。
-       */
+      /** 释放本对象持有的端口（按 owner）。绝不回退成无 owner 的释放——那会误删他人登记；
+       *  owner 不匹配时 release 返回失败是期望行为，不视为错误，仅日志。 */
       _releasePort(port, ownerId) {
         if (!this.ports || typeof this.ports.release !== "function") return;
         try {
@@ -23077,11 +22904,8 @@ var require_registry3 = __commonJS({
       count() {
         return this._objects.length;
       }
-      /** 唯一心跳：薄委托 runHeartbeat（单拍调度、节流、单对象超时隔离在 control/heartbeat.js）。
-       *  观测写入口仍是本实例的 applyObservation/setPhase。
-       *  @param {number} [intervalMs] 心跳拍宽（默认 5000）
-       *  @returns {Promise<{ observed: string[], errors: string[] }>}
-       */
+      /** 唯一心跳：薄委托 runHeartbeat（单拍调度、节流、单对象超时隔离在 control/heartbeat.js）；
+       *  观测写入口仍是本实例的 applyObservation/setPhase。 */
       heartbeat(intervalMs) {
         return runHeartbeat(this, intervalMs);
       }
@@ -24157,16 +23981,6 @@ var require_entry = __commonJS({
     "use strict";
     var { PHASES } = require_registry3();
     var ManagedLifecycle = class {
-      /**
-       * @param {object} opts
-       *   - id: 模块唯一标识（如 'dsh' / 'router' / 'router.proxy.<keyId>' / 'inst.<id>' / 'lan'）
-       *   - kind: 模块类别（'dsh' | 'router' | 'proxy-instance' | 'instance' | 'lan' | 'plugin'）
-       *   - name: 显示名
-       *   - logger / events：可选（日志与事件总线）
-       *   - start(ctx)：async —— 启动该模块（由生命周期管理器调用）
-       *   - stop(ctx)：async —— 停止该模块（守卫 shutdown 或用户启停时调用）
-       *   - status()：返回模块自身细节状态（供面板展示，可选）
-       */
       constructor(opts) {
         this.id = opts.id || "lc-" + Math.random().toString(36).slice(2, 8);
         this.kind = opts.kind || "module";
@@ -24202,19 +24016,16 @@ var require_entry = __commonJS({
           lastProbeAt: this.lastProbeAt,
           lastTransitionAt: this.lastTransitionAt,
           error: this.error,
-          // 无 restartCount（域 A 计数不在本对象上）
           guardian: this.guardian === true,
           startable: this.startable,
-          // 能力声明可视化（UI 据此灰化启停入口）
+          // UI 据此灰化启停入口
           guardable: this.guardable,
           monitoring: this._monitoring,
           detail: this._status ? this._status() || null : null
         };
       }
-      /* 内部状态迁移（由 LifecycleManager 驱动，模块不直接改 phase） */
-      /** 状态迁移。非白名单值静默丢弃（是执法，不是 bug）：
-       *  phase 只能取 canonical 词表内的值，防止写入手写字符串造成新的分叉；
-       *  代价是写错值时不报错，故词表必须引用唯一源，否则合法值会被无声拒绝。 */
+      /** 状态迁移。非白名单值静默丢弃是执法不是 bug：phase 只取 canonical 词表，
+       *  防止手写字符串造成分叉；代价是写错不报错，故词表必须引用唯一源。 */
       _setPhase(p) {
         if (!PHASES.includes(p)) return;
         if (this.phase !== p) {
@@ -24223,23 +24034,16 @@ var require_entry = __commonJS({
         }
       }
       /* 供 LifecycleManager 调用的统一操作 */
-      /** 期望保持运行。 */
       wantRunning() {
         this.desired = "running";
         this.error = null;
       }
-      /** 期望停止。 */
       wantStopped() {
         this.desired = "stopped";
       }
-      /** 启动模块（幂等：已在运行则 no-op）。
-       *
-       *  必须尊重回调的显式失败：适配器的 start 可能返回 `{ok:false, error}`
-       *  （如 daemon 拉不起来时）。若不看 `r.ok` 就置 running/healthy，
-       *  会让 `/lifecycle/status` 谎报成功，而模块实际没起来。
-       *
-       *  兼容性：`r.ok !== false` 视为成功，保留「回调只返回 undefined / 无 ok 字段」的既有语义。
-       */
+      /** 启动（幂等：已在运行则 no-op）。必须尊重回调的显式失败：适配器 start 可能返回
+       *  {ok:false}（如 daemon 拉不起来），不看 r.ok 就置 running/healthy 会让
+       *  /lifecycle/status 谎报成功。r.ok !== false 视为成功（允许回调返回 undefined）。 */
       async start() {
         if (this.phase === "running" || this.phase === "starting") return { ok: true, already: true };
         this.error = null;
@@ -24266,12 +24070,8 @@ var require_entry = __commonJS({
           return { ok: false, error: this.error };
         }
       }
-      /** 停止模块（守卫 shutdown 或用户显式停）。
-       *
-       *  同样必须尊重回调的显式失败：stop 回调返回 `{ok:false}` 时不得置
-       *  phase=stopped/desired=stopped，否则面板显示「已停止」而进程可能还在跑；
-       *  显式失败时保持运行态（与异常分支同一语义）并如实上报错误。
-       */
+      /** 停止（守卫 shutdown 或用户显式停）。同样必须尊重回调显式失败：ok:false 时
+       *  不得置 stopped，否则面板显示「已停止」而进程可能还在跑。 */
       async stop(reason) {
         if (this.phase === "stopped") {
           this.desired = "stopped";
@@ -24298,12 +24098,8 @@ var require_entry = __commonJS({
           return { ok: false, error: this.error };
         }
       }
-      /** 重启（无 _restart 回调时退化为 stop -> start）。
-       *
-       *  回退路径必须尊重 stop/start 的显式失败：两个返回值都不可丢弃，
-       *  否则「停不掉」或「起不来」时仍报成功，面板显示「已重启」而模块实际是死的。
-       *  语义：stop 失败则模块仍在跑，重启未发生；start 失败则已停但未起。
-       */
+      /** 重启（无 _restart 回调时退化为 stop -> start）。两步返回值都不得丢弃显式失败：
+       *  stop 失败=模块仍在跑、重启未发生；start 失败=已停但未起。 */
       async restart() {
         if (this._restart) {
           const r = await this._restart();
@@ -24380,7 +24176,9 @@ var require_manager = __commonJS({
         this._emit("lifecycle_stopped", { id: lc.id, kind: lc.kind, ok: r.ok, reason });
         return { ok: r.ok !== false, error: r.error, already: r.already, ...lc.snapshot() };
       }
-      /** 重启模块（保持 desired 语义）。 */
+      /** 重启（保持 desired 语义）。委托 lc.restart()：_restart 回调优先（如 dsh 经 requestRestart
+       *  停旧拉新），无回调才退化为 stop -> start；该回退逻辑由 ManagedLifecycle.restart() 唯一承担
+       *  （契约测试锁定），此处不留副本。 */
       async restart(id) {
         const lc = this.registrations.get(id);
         if (!lc) return { ok: false, error: "\u672A\u6CE8\u518C\u6A21\u5757: " + id };
@@ -24392,12 +24190,9 @@ var require_manager = __commonJS({
       statusAll() {
         return this.all().map((l) => lc_status(l));
       }
-      /**
-       * 守卫 shutdown：停全部 monitoring 的模块。
-       * 契约（RC2）：本管理器不内置 dsh 特例——stopAll 会停掉所有纳管/期望运行项。
-       * 「守卫退出不动 DSH」由调用方以 exclude:['dsh'] 保证（见 supervisor.js 的 stopAll 调用）。
-       * @param {object} opts { exclude?: string[] } 额外豁免的模块 id（如独立 daemon 型 router）
-       */
+      /** 守卫 shutdown：停全部 monitoring 的模块。契约 RC2：本管理器不内置 dsh 特例——
+       *  stopAll 会停掉所有纳管/期望运行项，「守卫退出不动 DSH」由调用方以 exclude:['dsh'] 保证
+       *  （见 supervisor.js 的调用）。exclude = 额外豁免的模块 id（如独立 daemon 型 router）。 */
       async stopAll(reason, opts) {
         const exclude = new Set(opts && opts.exclude || []);
         for (const lc of this.all()) {
@@ -24581,13 +24376,12 @@ var require_adapters = __commonJS({
           name: "\u667A\u80FD\u8DEF\u7531",
           logger,
           start: async () => sup && typeof sup.setRouterRunning === "function" ? sup.setRouterRunning(true) : router.start(),
-          // 守卫自身 shutdown（_stopping=true）时 stopAll 不得停独立 router-daemon：
-          // 守卫退出不影响被管模块（daemon 独立生命周期继续服务）；仅显式用户停止才停 daemon。
+          // 守卫自身 shutdown（_stopping=true）不得停独立 daemon：守卫退出不影响被管模块，仅显式用户停止才停。
           stop: async () => {
             if (sup && sup._stopping) return { ok: true, already: true, reason: "guard-shutdown \u4E0D\u505C daemon" };
             return sup && typeof sup.setRouterRunning === "function" ? sup.setRouterRunning(false) : router.stop();
           },
-          // detail 走守卫真实 router 状态视图（daemon 模式经 ctl 取 daemon 实时态）。
+          // detail 走守卫真实 router 状态视图（daemon 模式经 ctl 取实时态）
           status: () => sup && typeof sup.routerStatus === "function" ? sup.routerStatus() : router.status ? router.status() : null
         });
         mgr.register(rlc);
@@ -24609,7 +24403,7 @@ var require_adapters = __commonJS({
               return { ok: false, error: e.message };
             }
           },
-          // 守卫 shutdown 时同样不停 LAN（L3b：relay 由独立 lan-daemon 承载；守卫内 LanManager 为 dry/门面）
+          // 守卫 shutdown 同样不停 lan（relay 由独立 lan-daemon 承载；守卫内 LanManager 为门面）
           stop: async () => {
             if (deps && deps.supervisor && deps.supervisor._stopping) return { ok: true, already: true, reason: "guard-shutdown \u4E0D\u505C lan" };
             try {
@@ -24628,16 +24422,14 @@ var require_adapters = __commonJS({
           id: "instances",
           kind: "instances",
           name: "\u5B9E\u4F8B\u7BA1\u7406",
-          // 聚合单元：无全局进程（start/stop 为 no-op）——声明不可启停，避免「返回 ok 但无动作」的假成功。
-          // 单个实例的启停走 /instances/{start|stop}（各自独立生命周期）。
+          // 聚合单元无全局进程：声明不可启停，避免「返回 ok 但无动作」的假成功；
+          // 单个实例的启停走 /instances/{start|stop}。
           startable: false,
           guardable: false,
           logger,
           start: async () => ({ ok: true }),
-          // 实例无全局进程；单个实例由各自启停
           stop: async () => ({ ok: true }),
-          // detail 用实例集真实统计（曾引用不存在的 instances.summary——死回调恒 null）；
-          // phase/healthy 视图由守卫 _syncInstancesLifecycleView 每心跳真实刷新。
+          // detail 用实例集真实统计；phase/healthy 视图由守卫 _syncInstancesLifecycleView 每心跳刷新。
           status: () => {
             try {
               const arr = instances && typeof instances.all === "function" && instances.all() || [];
@@ -25780,8 +25572,7 @@ var require_instances = __commonJS({
       return bootstrapDshCookie("127.0.0.1", it.port, tok).then((cookie) => {
         if (!cookie) return deny(400, "\u4EE4\u724C\u6362\u53D6\u5931\u8D25");
         res.writeHead(303, {
-          // SameSite=Strict——cookie 跨端口共享是本设计意图（回环同源，
-          // 端口不参与 site 判定），但必须杜绝跨站导航/子资源携带（旧值缺省=Lax）。
+          // 跨端口共享 cookie 是设计意图（回环同源，端口不参与 site 判定），故须 Strict 杜绝跨站携带。
           "Set-Cookie": cookie + "; Path=/; HttpOnly; SameSite=Strict",
           "Location": "http://127.0.0.1:" + it.port + "/"
         });
@@ -26095,7 +25886,7 @@ var require_router_table = __commonJS({
       require_instances(),
       require_relay(),
       require_shell2()
-      // 桌面壳更新安全网（/shell/*）——内核仅做安全网，非更新源
+      // 桌面壳更新安全网（/shell/*）
     ];
     module2.exports = { API_DOMAINS };
   }
@@ -26995,8 +26786,8 @@ var require_ports3 = __commonJS({
         bindingPreferred: !!o.bindingPreferred,
         onBindingLost: o.onBindingLost,
         reclaimCmdMark: "lan-daemon.js",
-        // configPath 为空时 reclaimCfg=''，probe.reclaimByCmdMark 按
-        // fail-closed 不回收（宁可留占用走冲突分支，也不按 cmdMark 全量误杀同名进程）。
+        // configPath 为空时 reclaimCfg=''，probe.reclaimByCmdMark 按 fail-closed 不回收：
+        // 宁可留占用走冲突分支，也不按 cmdMark 全量误杀同名进程。
         reclaimCfg: o.configPath || "",
         waitMs: 8e3
       });
@@ -27217,8 +27008,8 @@ var require_frp = __commonJS({
         this._sumCache = null;
         this._hardenPermissions();
       }
-      /** 敏感文件权限加固：frpc.toml 含 auth.token 明文、frp.json 同含 token；
-       *  新写入已用 0600，但历史遗留文件可能是早期版本以默认 umask 写出的 0644/0664。 */
+      /** frpc.toml 含 auth.token 明文、frp.json 同含 token：新写入已用 0600，
+       *  但历史遗留文件可能是早期以默认 umask 写出的 0644/0664，故启动时补加固。 */
       _hardenPermissions() {
         try {
           const fp = platform.fileProtect;
@@ -27254,19 +27045,18 @@ var require_frp = __commonJS({
           installed: fs2.existsSync(this.binPath),
           running: !!(this.child && this.child.pid),
           pid: this.child ? this.child.pid : null,
-          // API 面绝不回显 authToken 明文（与 access.js「只报 configured」同规）。
-          // UI 需要改动令牌时显式提交新值；normalizeFrpSettings 是 patch 归并——
-          // **字段缺省（undefined）= 保留现值**，显式提交 '' = 清除（UI 留空时必须省略字段）。
+          // API 面绝不回显 authToken 明文，只报 authTokenSet（与 access.js「只报 configured」同规）。
+          // normalizeFrpSettings 是 patch 归并：字段缺省（undefined）= 保留现值，显式 '' = 清除；
+          // 故 UI 想保留现值必须省略字段而不是留空。
           settings: { serverAddr: s.serverAddr, serverPort: s.serverPort, user: s.user, authTokenSet: !!s.authToken },
           logTail: this.logTail.slice(-20)
         };
       }
-      /** instances 里 remoteMode==='wan' 的映射到远程端口（纯文本生成委托 core.buildFrpcToml）。 */
+      /** wan 实例映射为远程端口；文本生成委托纯函数 core.buildFrpcToml。 */
       buildConfig(settings, instances) {
         return buildFrpcToml(settings, instances);
       }
-      /** 由受管清单变化时调用：重写配置并在运行中时平滑重启。
-       *  frpc 生命周期单一条件 = 是否存在 wan 隧道（count>0）；无全局总闸。 */
+      /** 受管清单变化时调用：重写配置，运行中则平滑重启（生命周期条件见类头：是否存在 wan 隧道）。 */
       syncFromInstances(instances) {
         const settings = this.loadSettings();
         const { text, count } = this.buildConfig(settings, instances);
@@ -27335,7 +27125,6 @@ var require_frp = __commonJS({
         this.logger.info && this.logger.info("frpc started pid=" + child.pid);
         return { ok: true, pid: child.pid };
       }
-      /** 非预期退出后的有界退避重启。 */
       _scheduleRestart() {
         if (this._restartTimer) return;
         if (!this._lastCount) return;
@@ -27419,7 +27208,6 @@ var require_frp = __commonJS({
       _download(url, report) {
         return download(url, report);
       }
-      /** 安装 frpc（下载 + 完整性校验 + 解压）。 */
       async install(onProgress) {
         const cache = this._sumCache || (this._sumCache = {});
         return installFrpc({
@@ -27682,7 +27470,7 @@ var require_ops5 = __commonJS({
       localAddresses() {
         return managed.localAddresses();
       }
-      /** 持久化：优先注入的路由(persist)，否则回退沙箱实例 save。 */
+      /** 持久化：优先注入的 persist 路由，否则回退沙箱 instances.save()。 */
       _saveAll() {
         if (typeof this.persist === "function") {
           try {
@@ -27699,15 +27487,15 @@ var require_ops5 = __commonJS({
           }
         }
       }
-      /** 受管 DSH 合成清单：沙箱实例 + 原生主干 main。 */
+      /** 受管 DSH 合成清单（沙箱 + 原生主干 main）。 */
       _allManaged() {
         return managed.allManaged({ instances: this.instances, mainOf: this.mainOf });
       }
-      /** 合成查找：按 id 取首个匹配（清单无同 id 项，见 managed.js#allManaged）。 */
+      /** 合成查找：按 id 取首个匹配。 */
       _findManaged(id) {
         return managed.findManaged(this._allManaged(), id);
       }
-      /** frpc 子进程句柄只读访问器（daemon 优雅停机等待其退出；不暴露内部 frp 私有对象）。 */
+      /** frpc 子进程句柄只读访问器：不暴露 frp 私有对象，供 daemon 优雅停机等待其退出。 */
       frpChild() {
         return this.frp && this.frp.child || null;
       }
@@ -27751,7 +27539,7 @@ var require_ops5 = __commonJS({
             wanPort: proxy ? proxy.wanPort : null,
             token: inst.remoteToken || "",
             dshToken: this.tokenOf(inst.id) || "",
-            // 令牌一律按需从令牌池读取
+            // 令牌按需从令牌池读取
             running: !!this._lanServers && !!this._lanServers[inst.id],
             inject,
             remote
@@ -27768,7 +27556,7 @@ var require_ops5 = __commonJS({
         });
         return st;
       }
-      /** frpc 操作门面（settings/install 统一入口；总闸已随三态模型废止）。 */
+      /** frpc 操作门面（settings/install 统一入口）。 */
       async frpAction(action, body) {
         const j = body || {};
         if (action === "settings") {
@@ -27792,14 +27580,13 @@ var require_ops5 = __commonJS({
         }
         return { ok: false, error: "\u672A\u77E5 frp \u64CD\u4F5C: " + action };
       }
-      /** 受管清单是否存在 wan 意图（配置闸用：含尚未建立代理的实例，磁盘态即算）。 */
+      /** 受管清单是否有 wan 意图：含尚未建立代理的实例（磁盘态即算）。 */
       _hasWanIntent() {
         return this._allManaged().some((x) => normalizeRemoteMode(x.remoteMode) === "wan");
       }
       /** 实例变化后同步 frpc 配置与进程（尽力而为，不抛异常影响主流程）。
-       *  执行边界复校 wan 闸：写入口（setRemoteMode 动作）已过 core.validateWanAccess，但冷启动
-       *  是直接按磁盘态组装隧道 —— 历史遗留的「wan 态但远程令牌为空」会绕开写侧闸，在网络
-       *  边界重现公网零认证暴露。故建隧道前对每个 wan 项复用同一事实源复校，不过闸即跳过该隧道。 */
+       *  建隧道前复校 wan 闸（core.validateWanAccess，与写入口同一实现）：冷启动直接按磁盘态组装隧道，
+       *  历史遗留「wan 态但令牌为空」会绕开写侧闸，在网络边界重现公网零认证暴露——不过闸即跳过该隧道。 */
       syncFrpc() {
         if (!this.frp) return;
         try {
@@ -27821,9 +27608,8 @@ var require_ops5 = __commonJS({
         }
       }
       /** 远程代理对账：注册只与「remoteMode!=off」绑定；relay 运行 = 目标存活；孤儿注册移除。
-       *  单飞：对账内含逐实例串行 await targetReachable（每个最多 600ms），而被 2 秒级节拍多次触发；
-       *  同刻只允许一轮在跑，后续调用复用同一在途 Promise。
-       *  刻意不加 async：async 会把返回值包一层新 Promise，单飞身份丢失。 */
+       *  单飞：内部逐实例串行 await targetReachable（每个最多 600ms）而被 2s 节拍反复触发，
+       *  同刻只允许一轮在跑，后续调用复用同一在途 Promise。刻意不加 async——包一层 Promise 会丢单飞身份。 */
       reconcile() {
         if (this._reconcileInFlight) return this._reconcileInFlight;
         this._reconcileInFlight = this._reconcileOnce().catch((e) => {
@@ -27833,25 +27619,23 @@ var require_ops5 = __commonJS({
         });
         return this._reconcileInFlight;
       }
-      /** 对账主体（委托 ops/reconcile.js；具名保留：单飞包装与门禁按此名调用）。 */
+      /** 对账主体（委托 ops/reconcile.js）；方法名不可改：单飞包装与门禁按此名调用。 */
       async _reconcileOnce() {
         return reconcile.reconcileOnce(this);
       }
-      /** 目标实例是否可达（委托 ops/reconcile.js）。 */
       targetReachable(inst) {
         return reconcile.targetReachable(inst);
       }
-      /** 串行执行 syncProxy（队列）。 */
       _syncProxyQueued(inst) {
         return reconcile.syncProxyQueued(this, inst);
       }
-      /** 删除某实例关联的局域网代理（实例被删除时调用）。 */
+      /** 实例被删除时移除其局域网代理。 */
       async removeProxyForInstance(instId) {
         return reconcile.removeProxyForInstance(this, instId);
       }
       /** 同步某实例的远程访问代理：remoteMode!=off 且目标在监听时创建 relay，off 拆除。
-       *  wan 不引入第二监听/第二端口：隧道口与 relay 口恒同号（core.buildFrpcToml）。
-       *  端口绑定唯一权威是 relay 槽位注册表（byOwner 复用）；实例记录不存 wanPort 镜像。 */
+       *  wan 不引入第二监听/第二端口（隧道口与 relay 口恒同号，见 core.buildFrpcToml）；
+       *  端口绑定唯一权威是 relay 槽位注册表，实例记录不存 wanPort 镜像。 */
       async syncProxy(inst) {
         if (!inst) return;
         const mode = normalizeRemoteMode(inst.remoteMode);
@@ -27915,11 +27699,10 @@ var require_ops5 = __commonJS({
           }
         }
       }
-      /** 实例启动时联动远程代理（委托 ops/reconcile.js）。 */
+      /** 实例启动/停止时联动远程代理（委托 ops/reconcile.js：停止只停 relay，保留注册）。 */
       async instanceStart(inst) {
         return reconcile.instanceStart(this, inst);
       }
-      /** 实例停止时联动远程代理（委托 ops/reconcile.js）。 */
       instanceStop(inst) {
         return reconcile.instanceStop(this, inst);
       }
@@ -27929,11 +27712,11 @@ var require_ops5 = __commonJS({
       _stopLanServer(id) {
         return lanServers.stopLanServer(this, id);
       }
-      /** 守卫优雅退出时调用（委托 ops/lan-servers.js）。 */
+      /** 守卫优雅退出：停全部 relay 与 frpc。 */
       shutdown() {
         return lanServers.shutdown(this);
       }
-      /** 令牌变化经 onChange 下发（委托 ops/lan-servers.js）。 */
+      /** 令牌变化下发到既有 relay（热换 DSH 会话 cookie）；本域不持久化令牌。 */
       applyToken(instId) {
         return lanServers.applyToken(this, instId);
       }