dsh-remote-agent 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -9,6 +9,104 @@
 
 ---
 
+## [0.8.0] - 2026-10-17
+
+### 功能：#27 完整版 —— 模型清单自述 + 面板下拉
+
+v0.7.0 只做了"自述 + 派发前拦截"，面板仍是自由文本 —— 当时的判断是
+"in-process 后端没有稳定的清单 API（DSH 内部的 `model/list` 走 app-server
+协议面，fiber 服务摸不到）"。**那个判断已经过时**：`ctx.llm` 现在直接暴露
+`listProviders()` 与 `listModels(provider)`，这就是稳定服务面。
+
+所以本版把最后一环补上，链路四段：
+
+1. **副机探测**（`readAvailableModels`）：`ctx.llm.listProviders()` →
+   逐个 `listModels(provider)`。单个 provider 失败 `continue`（不打断其它），
+   全部失败返回 `null`（面板退回自由文本）。上限：8 provider / 每 provider
+   24 模型 / 总 64 —— 不让 RESOURCE 帧膨胀。
+
+2. **RESOURCE 帧带缓存**：探测是 async 而 interval 回调是同步的，所以用
+   后台串行链刷新（启动探一次 + 每 10 分钟重探），帧里带**上一次的结果**。
+   用串行链而不是 `void refresh()` 是为了防探测堆积（探测慢时每 30s 一次帧
+   会越积越多）。探测失败保留旧值 —— 一次网络抖动不该让面板下拉消失。
+
+3. **hub 摄入**（`registry-ingest`）：字段级清洗 + **独立封顶**
+   （`MAX_NODE_MODELS`，不信任对端遵守了自己的上限）。
+   `models: null` **保留旧值**（与 `defaultModel` 的 null 清空语义刻意不同）。
+
+4. **视图 + 面板**：`registry.list()` → `nodeView()` 逐条投影（不 spread）
+   → 面板 `<select>`：
+   - 第一项"跟随副机默认（provider/model）"
+   - 中间是各模型，多节点时带 `· 节点名` 后缀
+   - 最后一项"自定义…"（展开回文本框）
+   - **没有清单时退回文本框**（向后兼容旧副机）
+
+**安全边界**：只上报 provider 键名 + model id + 显示名。
+绝不上报 apiKeyEnv 的值、baseURL、任何凭证。`listProviders()` 只返回
+已注册（有 adapter）的 route —— 天然满足"不泄露这台机器配了哪些渠道"，
+只有真能用的才会出现。
+
+测试：`test/model-list-dropdown.test.js` 13 条（四段链路逐段钉住 +
+"上报字段恰好是 provider/id/name"的硬断言 + 单个 provider 失败不打断 +
+null/[] 语义区分 + 面板有 select/自定义/多节点后缀）。
+doc-drift 新增 75（链路四段）、76（安全边界）两条锚点。
+
+### 修复：原子写 EPERM 立项修（第 5 次 CI 失败）
+
+`atomicWriteJson` 的 rename 在 Windows 上被 EPERM 拦（目标正被另一个句柄
+读着）。历次调整：6 次 × 10ms（总 210ms）→ 10 次封顶 200ms（总 ~1.3s），
+run 39012045381 **仍失败**。
+
+第 5 次失败时承认：这不是"抖动"，是"窗口太短"。失败用例是
+「原子写：并发写 + 并发读」—— 多个 rename 互相争抢同一个目标，而 CI
+runner 高峰期的磁盘延迟能到秒级。
+
+三层修法：
+
+- **总窗口拉到 ~6s**（16 次，封顶 500ms）—— 有界，正常路径第 1 次就成功
+- **最后一次尝试前做 unlink 兜底**（删目标再 rename，绕开"目标存在且被锁"
+  的 EPERM）
+- **兜底只在第 16 次触发** —— 它破坏"任何时刻读到完整文件"的严格原子性
+  （删除与 rename 之间读方看到 ENOENT），所以必须当最后手段而不是常规路径；
+  触发点用 `RENAME_RETRIES - 1` 计算，不写死数字
+
+安全性：读方（`readAll()` / `list()`）本来就容忍 ENOENT —— 首次写之前
+文件不存在是正常状态（`readAll` 的 ENOENT 分支返回空库且 `degraded: false`）。
+所以兜底造成的瞬时缺失落在既有容忍范围内，不会让读方看到半截 JSON。
+
+测试：`test/atomic-write-eperm.test.js` 6 条（窗口 ≥5s / 兜底存在 /
+触发点是最后一次 / readAll 容忍 ENOENT / 非 transient 立即抛 /
+目录占住时干净失败）。
+
+### 修复：队列残余风险的两处静默失效（#26-4 / #26-5）
+
+2026-10-17 实测：副机 `maxConcurrent=2` 被两条卡住的 exec 占满后，后续任务
+全部排队。排查时暴露两个让问题**不可见、不可控**的缺陷 —— 都是"没有报错、
+行为看起来正常"的静默失效型。
+
+- **#26-4 面板"运行中"分组**：此前面板只有一个数字（`running: 2`），
+  用户看不到**是哪两条、在跑什么、跑了多久**。现在任务列表按状态分组，
+  运行中（含 queued / pending_approval）置顶，每条显示 `已跑 N`
+  （由 `startedAt` 与当前时间算差）—— 这是判断"是不是卡住了"的唯一线索。
+  其余任务归入"已完成 / 已结束"，保持原顺序。
+
+- **#26-5 agent 取消真打断**：`InProcessRunner.run` 等 agent 停稳用的是
+  `Promise.race([agent.whenIdle(), timeoutPromise])` —— **取消信号不在里面**。
+  而 `cancel()` 做的是 `agent.cancel()` + `controller.abort()`：abort 只是
+  置了个标志，没有任何人在 await 它；DSH 的 agent 循环也不监听外部
+  AbortSignal。后果：hub 发 `task/cancel` → `remote_cancel` 返回
+  `requested: true` → 任务**一直 running 到 agent 自己跑完** → 最终落成
+  **completed**（不是 aborted）。用户以为取消成功，实际白跑一遍还烧了额度。
+
+  修法：把 abort 做成可 race 的 promise（触发即 resolve），并让返回值的
+  `ok` 排除 `aborted`（`ok: !timedOut && !aborted`）。两个语义细节同时钉住：
+  超时触发的 abort **不**改写成 aborted（超时 ≠ 用户取消，下游据此外报不同
+  错误码）；`finally` 里 `handle.dispose()` 收掉 agent，避免取消后泄漏。
+
+测试：`test/agent-cancel-abort.test.js` 8 条（race 含 abortPromise / ok 排除
+aborted / 超时不误标 / cancel 双动作 / finally dispose / engine 映射顺序）；
+doc-drift 新增 73、74 两条锚点。
+
 ## [0.7.0] - 2026-10-17
 
 ### 功能：模型自述 + headless 指定模型派发前拦截（提案 #27）

package/lib/client.js

@@ -74,6 +74,10 @@ window.__ModuleLoader__.load({
       '.dra-card-l{font-size:11px;color:var(--dsw-alias-label-secondary)}',
       '.dra-sec{margin:14px 0 6px;font-size:11px;letter-spacing:.04em;',
       'text-transform:uppercase;color:var(--dsw-alias-label-secondary)}',
+      // #26-4：任务列表的分组小标题（"运行中（2）" / "已完成 / 已结束"）。
+      // 比 .dra-sec 轻一档 —— 它是二级标题，不该和区块标题抢视觉重量。
+      '.dra-sub{margin:10px 0 4px;font-size:11px;font-weight:600;',
+      'color:var(--dsw-alias-label-secondary);opacity:.85}',
       '.dra-row{display:flex;align-items:center;gap:8px;padding:7px 9px;border-radius:6px;',
       'border:1px solid transparent}',
       '.dra-row:hover{background:var(--dsw-alias-bg-layer-1)}',
@@ -1423,12 +1427,98 @@ window.__ModuleLoader__.load({
             value: fv.workspace,
             onChange: function (e) { setForm(function (f) { const n = Object.assign({}, f); n.workspace = e.target.value; return n }) },
           }),
-          h('input', {
-            className: 'dra-in',
-            placeholder: '模型（可选，如 deepseek-reasoner 或 provider/model）',
-            value: fv.model,
-            onChange: function (e) { setForm(function (f) { const n = Object.assign({}, f); n.model = e.target.value; return n }) },
-          }),
+          // ── 模型选择（提案 #27）─────────────────────────────────────────
+          //
+          // 此前是**自由文本**：用户必须自己记住副机的 provider 名和 model 名，
+          // 填错了要等任务跑到副机才失败（浪费一轮往返 + 烧一个 taskId）。
+          //
+          // 现在副机随 RESOURCE 帧上报可用模型清单（只报 provider 键名 +
+          // model id + 显示名，不碰凭证），面板据此渲染下拉：
+          //
+          //   · 有清单 → <select>，第一项是"跟随副机默认（xxx）"，
+          //     最后一项是"自定义…"（展开回文本框）
+          //   · 没清单（旧副机 / 探测未完成 / null）→ 保持原样：文本框
+          //   · 清单是 []（副机明确说一个都没有）→ 显示提示，仍是文本框
+          //
+          // 目标节点 = 显式选的 node，或（自动路由时）第一个在线节点的并集。
+          // 多节点时取**并集**并带节点名后缀，避免同名 model 混淆。
+          (function () {
+            const chosen = fv.node.trim()
+            const targets = chosen !== ''
+              ? state.nodes.filter(function (n) { return n.nodeId === chosen || n.hostname === chosen })
+              : state.nodes.filter(function (n) { return n.online })
+            // 收集并集（同一 provider/model 只留一条，name 取第一个非空）
+            const seen = {}
+            const opts = []
+            targets.forEach(function (n) {
+              (Array.isArray(n.models) ? n.models : []).forEach(function (m) {
+                const key = m.provider + '\u0000' + m.id
+                if (seen[key]) return
+                seen[key] = true
+                opts.push({ provider: m.provider, id: m.id, name: m.name || m.id, nodeId: n.nodeId })
+              })
+            })
+            const hasList = targets.some(function (n) { return Array.isArray(n.models) })
+            // 副机默认（仅单节点目标时有意义；多节点时用第一台的）
+            const def = targets.length > 0 ? targets[0].defaultModel : null
+            const defLabel = def && def.model
+              ? '跟随副机默认（' + (def.provider ? def.provider + '/' : '') + def.model + '）'
+              : '跟随副机默认'
+
+            if (!hasList || opts.length === 0) {
+              // 没有清单：保持文本框（向后兼容旧副机）
+              return h('div', null,
+                h('input', {
+                  className: 'dra-in',
+                  placeholder: '模型（可选，如 deepseek-reasoner 或 provider/model）',
+                  value: fv.model,
+                  onChange: function (e) { setForm(function (f) { const n = Object.assign({}, f); n.model = e.target.value; return n }) },
+                }),
+                hasList
+                  ? h('div', { className: 'dra-dim', style: { marginTop: '2px' } },
+                    '副机上报的模型清单为空 —— 需手动填写，或先在副机配置模型。')
+                  : null,
+              )
+            }
+
+            // 有清单：下拉。值是 `provider/model` 或空串（跟随默认）或 `__custom__`
+            const isCustom = fv.model !== '' && !opts.some(function (o) {
+              return (o.provider ? o.provider + '/' : '') + o.id === fv.model
+            })
+            const multi = targets.length > 1
+            return h('div', null,
+              h('select', {
+                className: 'dra-in',
+                value: isCustom ? '__custom__' : fv.model,
+                onChange: function (e) {
+                  const v = e.target.value
+                  setForm(function (f) {
+                    const n = Object.assign({}, f)
+                    n.model = v === '__custom__' ? (n.model === '__custom__' ? '' : n.model) : v
+                    return n
+                  })
+                },
+              },
+                h('option', { value: '' }, defLabel),
+                opts.map(function (o) {
+                  const val = (o.provider ? o.provider + '/' : '') + o.id
+                  const label = (o.name || o.id) + (o.provider ? '（' + o.provider + '）' : '')
+                    + (multi ? ' · ' + o.nodeId : '')
+                  return h('option', { key: val + o.nodeId, value: val }, label)
+                }),
+                h('option', { value: '__custom__' }, '自定义…'),
+              ),
+              isCustom
+                ? h('input', {
+                  className: 'dra-in',
+                  style: { marginTop: '4px' },
+                  placeholder: '自定义模型（provider/model）',
+                  value: fv.model,
+                  onChange: function (e) { setForm(function (f) { const n = Object.assign({}, f); n.model = e.target.value; return n }) },
+                })
+                : null,
+            )
+          })(),
           h('input', {
             className: 'dra-in',
             placeholder: '期望产出 glob，逗号分隔（可选）',
@@ -1456,27 +1546,71 @@ window.__ModuleLoader__.load({
       )
 
       // ── 任务列表 ──
+      //
+      // ═══════════════════════════════════════════════════════════════════
+      // #26-4：按状态分组，**运行中置顶且显示已跑多久**
+      // ═══════════════════════════════════════════════════════════════════
+      //
+      // 事故（2026-10-17 实测）：副机的 `maxConcurrent=2` 被两条卡住的
+      // exec 占满，后续任务全部排队。但面板只显示**一个数字**
+      // （`running: 2`），用户看不到是哪两条、在跑什么、跑了多久 ——
+      // 只知道"卡了"，没有任何可操作的东西。
+      //
+      // 那次的代价：排查花了很久，因为"卡住的任务"在面板上完全不可见。
+      //
+      // 所以这里把任务列表改成三段：
+      //   · 运行中 —— 置顶，显示**已跑时长**（`startedAt` 与现在的时间差）
+      //   · 待审批 —— 次之（等用户动作的也要显眼）
+      //   · 其它 —— 按 updatedAt 倒序
+      //
+      // 只在有运行中任务时才显示"运行中"小标题，避免空分组占位。
+      const ACTIVE_STATUSES = ['running', 'queued', 'pending_approval']
+      const activeTasks = state.tasks.filter(function (t) { return ACTIVE_STATUSES.indexOf(t.status) >= 0 })
+      const restTasks = state.tasks.filter(function (t) { return ACTIVE_STATUSES.indexOf(t.status) < 0 })
+
+      /** 单条任务的行（分组内复用）。 */
+      const renderTaskRow = function (t) {
+        const isSel = t.taskId === selected
+        // 运行中的任务显示"已跑 N 秒"—— 这是判断"是不是卡住了"的唯一线索。
+        const liveSec = t.status === 'running' && t.startedAt
+          ? Math.max(0, Math.round((Date.now() - t.startedAt) / 1000))
+          : 0
+        return h('div', { key: t.taskId },
+          h('div', {
+            className: 'dra-row' + (isSel ? ' sel' : ''),
+            onClick: function () { setSelected(isSel ? null : t.taskId) },
+            style: { cursor: 'pointer' },
+          },
+            h(StatusBadge, { status: t.status }),
+            h('span', { className: 'dra-ell', style: { flex: '1' }, title: t.goal }, t.goal || t.taskId),
+            h('span', { className: 'dra-dim' }, t.nodeId),
+            liveSec > 0
+              ? h('span', { className: 'dra-dim', title: '已运行时长' }, '已跑 ' + fmtDur(liveSec * 1000))
+              : (t.durationMs ? h('span', { className: 'dra-dim' }, fmtDur(t.durationMs)) : null),
+          ),
+          isSel ? h(TaskDetail, {
+            task: t, detail: detail, caps: caps, onCancel: cancel, onPull: pull,
+            onApprove: approve, onReject: reject,
+          }) : null,
+        )
+      }
+
       const taskRows = state.tasks.length === 0
         ? h('div', { className: 'dra-empty' }, '还没有任务。')
-        : state.tasks.map(function (t) {
-          const isSel = t.taskId === selected
-          return h('div', { key: t.taskId },
-            h('div', {
-              className: 'dra-row' + (isSel ? ' sel' : ''),
-              onClick: function () { setSelected(isSel ? null : t.taskId) },
-              style: { cursor: 'pointer' },
-            },
-              h(StatusBadge, { status: t.status }),
-              h('span', { className: 'dra-ell', style: { flex: '1' }, title: t.goal }, t.goal || t.taskId),
-              h('span', { className: 'dra-dim' }, t.nodeId),
-              t.durationMs ? h('span', { className: 'dra-dim' }, fmtDur(t.durationMs)) : null,
-            ),
-            isSel ? h(TaskDetail, {
-              task: t, detail: detail, caps: caps, onCancel: cancel, onPull: pull,
-              onApprove: approve, onReject: reject,
-            }) : null,
-          )
-        })
+        : h('div', null,
+          activeTasks.length > 0
+            ? h('div', null,
+              h('div', { className: 'dra-sub' }, '运行中（' + activeTasks.length + '）'),
+              activeTasks.map(renderTaskRow),
+            )
+            : null,
+          restTasks.length > 0
+            ? h('div', null,
+              activeTasks.length > 0 ? h('div', { className: 'dra-sub' }, '已完成 / 已结束') : null,
+              restTasks.map(renderTaskRow),
+            )
+            : null,
+        )
 
       const taskSection = h('div', null,
         h('div', { className: 'dra-sec' }, '任务'),

package/lib/hub/node-registry.js

@@ -869,6 +869,10 @@ class NodeRegistryCore {
       // null = 副机未上报或未配置默认模型。
       runnerKind: typeof r.runnerKind === 'string' ? r.runnerKind : null,
       defaultModel: r.defaultModel && typeof r.defaultModel === 'object' ? r.defaultModel : null,
+      // 可用模型清单（提案 #27 面板下拉的数据源）。null = 副机未上报
+      // （旧版本 / 探测还没完成 / 全部失败）—— 消费方据此退回自由文本。
+      // 空数组是**权威事实**（"确实一个都没有"），与 null 语义不同。
+      models: Array.isArray(r.models) ? r.models : null,
       // 仓库清单（提案 #13）：路由提示。remote_nodes 给名字列表供选型，
       // repo 路由细节在 pickNodeByRepo。
       repos: Array.isArray(r.repos) ? r.repos.map((x) => x.name) : [],

package/lib/hub/registry-ingest.js

@@ -14,6 +14,15 @@ import { ERROR_CODE, HUB_TO_NODE, NODE_TO_HUB, TASK_STATUS, TERMINAL_STATUS } fr
 import { E2E_MARKER } from '../e2e.js'
 import { errText, numOr } from './hub-util.js'
 
+/**
+ * 单个节点可上报的模型数量上限（提案 #27）。
+ *
+ * 与副机侧的 MAX_MODELS 同量级 —— hub 侧必须**独立封顶**：不能信任对端
+ * 遵守了自己的上限（旧版副机、或刻意构造的帧都可能更大）。这是"单帧
+ * 故障隔离"不变式的一部分：畸形帧不能把注册表撑爆。
+ */
+const MAX_NODE_MODELS = 64
+
 export function withIngest(Base) {
   return class extends Base {
     // ─────────────────────────── 上行帧处理 ───────────────────────────
@@ -188,6 +197,33 @@ export function withIngest(Base) {
             // 显式 null 是合法上报（副机没配默认模型）—— 清掉旧值避免误导
             if (d.defaultModel === null) rec.defaultModel = null
           }
+
+          // 可用模型清单（提案 #27 面板下拉的数据源）。
+          //
+          // 与 defaultModel 一样是"副机自述"，但**整帧替换**的语义要更小心：
+          //   · 副机上报 `models: null`（探测失败 / 还没探完）→ **保留旧值**，
+          //     不要清空。否则一次网络抖动会让面板下拉退回自由文本，
+          //     用户刚记住的选项突然消失。
+          //   · 副机上报 `models: {models: [...]}` → 替换（含空数组：那是
+          //     "确实一个都没有"的权威事实）。
+          //
+          // 字段级清洗 + 上限：一个畸形帧不能伤害注册表（单帧故障隔离不变式）。
+          const rawModels = d.models && typeof d.models === 'object' && !Array.isArray(d.models) ? d.models : null
+          if (rawModels) {
+            const list = Array.isArray(rawModels.models) ? rawModels.models : []
+            const cleaned = []
+            for (const m of list.slice(0, MAX_NODE_MODELS)) {
+              if (!m || typeof m !== 'object') continue
+              const id = typeof m.id === 'string' ? m.id.trim() : ''
+              if (id === '') continue
+              cleaned.push({
+                provider: typeof m.provider === 'string' ? m.provider.slice(0, 64) : '',
+                id: id.slice(0, 128),
+                name: typeof m.name === 'string' && m.name !== '' ? m.name.slice(0, 128) : id.slice(0, 128),
+              })
+            }
+            rec.models = cleaned
+          }
           return
         }
 

package/lib/hub/templates.js

@@ -108,10 +108,28 @@ export const MAX_TIMEOUT_MS = 24 * 60 * 60 * 1000
  * （run 38894088627 实录）。生产读者的读窗口同样是几毫秒级，加宽到
  * ~1.3s 只影响"目标文件被别人持续锁死"这种异常场景，正常路径仍然
  * 前两次短退避就成功。仍是有界的：超时即抛，让上层报错而不是无限转圈。
+ *
+ * ── 2026-10-17 第二次加宽（run 39012045381，第 5 次 EPERM）──────────────
+ *
+ * 1.3s 仍不够。那个 run 的失败形态是：**测试自身在并发写同一个文件**
+ * （`原子写：并发写 + 并发读` 用例），多个 rename 互相争抢目标 ——
+ * 而 Windows 的 rename 覆盖"正被另一个 rename 短暂锁住"的目标时给 EPERM。
+ * CI runner 的磁盘在高峰期延迟抖动可以到秒级。
+ *
+ * 所以：
+ *   · 总窗口拉到 **~6s**（16 次，封顶 500ms）—— 仍是有界的，且只在
+ *     "目标被持续锁死"的异常路径上才会走满；正常路径第 1 次就成功。
+ *   · 最后一次尝试前做一次 **unlink 兜底**：Windows 上"删掉目标再 rename"
+ *     能绕开"目标存在且被锁"的 EPERM（POSIX 上 rename 本来就覆盖，
+ *     这一步只在 Windows 且前面的重试全失败时才走，不影响原子性语义 ——
+ *     删除与 rename 之间读方会看到 ENOENT，所以**只在前 15 次全失败后**
+ *     才做，把它当最后手段而不是常规路径）。
  */
-const RENAME_RETRIES = 10
+const RENAME_RETRIES = 16
 const RENAME_BACKOFF_MS = 10
-const RENAME_BACKOFF_MAX_MS = 200
+const RENAME_BACKOFF_MAX_MS = 500
+/** 第几次尝试开始走 unlink 兜底（0 基；= RENAME_RETRIES - 1 即最后一次）。 */
+const RENAME_UNLINK_FALLBACK_AT = RENAME_RETRIES - 1
 
 /**
  * 可写字段白名单。
@@ -446,6 +464,16 @@ export async function atomicWriteJson(file, value) {
       } catch (err) {
         const transient = err?.code === 'EPERM' || err?.code === 'EBUSY' || err?.code === 'EACCES'
         if (!transient || attempt >= RENAME_RETRIES) throw err
+        // 最后一次尝试前走 unlink 兜底（见 RENAME_UNLINK_FALLBACK_AT 的说明）。
+        // 只在"前面所有退避都失败"时执行 —— 那个时点目标文件本来就被
+        // 别人长期锁着，删掉它换来一次成功的 rename 比继续等更划算。
+        if (attempt === RENAME_UNLINK_FALLBACK_AT) {
+          try {
+            await fs.promises.rm(file, { force: true })
+          } catch {
+            /* 删不掉就继续等下一轮 —— 失败会由最后的 throw 反映 */
+          }
+        }
         await new Promise((r) => setTimeout(r, Math.min(RENAME_BACKOFF_MAX_MS, RENAME_BACKOFF_MS * 2 ** attempt)))
       }
     }

package/lib/hub/tools.js

@@ -443,6 +443,21 @@ export function registerRemoteTools({ ctx, registry, pulls, log: _log, defaults
                     model: { type: 'string' },
                   },
                 },
+                // 可用模型清单（提案 #27 面板下拉的数据源）。
+                // null = 副机未上报（旧版 / 探测未完成），由 dropNullForSchema
+                // 剥掉；[] = 副机明确说"一个都没有"（保留，语义不同）。
+                models: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      provider: { type: 'string' },
+                      id: { type: 'string' },
+                      name: { type: 'string' },
+                    },
+                    required: ['id'],
+                  },
+                },
               },
               required: ['nodeId', 'online'],
             },

package/lib/hub/views.js

@@ -164,6 +164,29 @@ export function nodeView(n) {
         at: Number.isFinite(n.resource.at) ? n.resource.at : null,
       }
       : null,
+    // 执行后端 + 默认模型（提案 #27）：面板节点行显示 + 派发前校验依据。
+    runnerKind: typeof n.runnerKind === 'string' ? n.runnerKind : null,
+    defaultModel: (n.defaultModel && typeof n.defaultModel === 'object')
+      ? {
+        provider: typeof n.defaultModel.provider === 'string' ? n.defaultModel.provider : '',
+        model: typeof n.defaultModel.model === 'string' ? n.defaultModel.model : '',
+      }
+      : null,
+    // 可用模型清单（提案 #27 面板下拉的数据源）。
+    //
+    // **逐条投影**，绝不 spread —— 帧里的对象可能被构造，多带字段就等于让
+    // 副机决定面板渲染什么。`null` 与 `[]` 语义不同：
+    //   · null = 副机没上报（旧版 / 探测未完成）→ 面板退回自由文本
+    //   · []   = 副机明确说"一个都没有"       → 面板显示空下拉 + 提示
+    models: Array.isArray(n.models)
+      ? n.models
+        .map((m) => ({
+          provider: typeof m?.provider === 'string' ? m.provider : '',
+          id: typeof m?.id === 'string' ? m.id : '',
+          name: typeof m?.name === 'string' && m.name !== '' ? m.name : (typeof m?.id === 'string' ? m.id : ''),
+        }))
+        .filter((m) => m.id !== '')
+      : null,
   }
 }
 

package/lib/node/index.js

@@ -308,10 +308,6 @@ export function resolveToken(config, stateDir = '') {
  * 的 provider/model/reasoning 选择）。**只报 provider 键名与 model id，
  * 不碰任何凭证**。取不到（服务缺失 / 抛错 / 字段形态不对）一律 null ——
  * 上报是尽力而为的遥测，绝不能影响资源帧本身。
- *
- * 完整的"可用模型清单"第一版不做：in-process 后端没有稳定的清单 API
- * （DSH 内部的 model/list 走 app-server 协议面，fiber 服务摸不到），
- * 探测 llm-pi-ai 内部结构太脆弱。等 DSH 把清单暴露成稳定 API 再补。
  */
 export function readDefaultModel(ctx) {
   try {
@@ -327,6 +323,92 @@ export function readDefaultModel(ctx) {
   }
 }
 
+/** 模型清单上限：够面板下拉用，又不让 RESOURCE 帧膨胀。 */
+const MAX_MODELS = 64
+/** 单个 provider 的模型上限（防止某个聚合 provider 一次吐几百个）。 */
+const MAX_MODELS_PER_PROVIDER = 24
+/** provider 数量上限。 */
+const MAX_MODEL_PROVIDERS = 8
+
+/**
+ * 收集副机**可用的模型清单**（提案 #27 的面板下拉数据源）。
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * 为什么现在能做（2026-10-17 更新）
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * v0.7.0 的注释曾写"in-process 后端没有稳定的清单 API（DSH 内部的
+ * `model/list` 走 app-server 协议面，fiber 服务摸不到）" —— **那个判断
+ * 已经过时**。`ctx.llm` 服务现在直接暴露：
+ *
+ *     listProviders(): LlmProviderInfo[]                     // {id, name}
+ *     async listModels(provider): Promise<LlmModelInfo[]>    // {provider, id, name, ...}
+ *
+ * 所以面板可以真的渲染下拉，而不是让用户猜 provider/model 名、填错了等
+ * 任务跑到副机才失败。
+ *
+ * ── 安全边界（硬要求）──────────────────────────────────────────────────
+ *
+ * **只上报 provider 键名 + model id + 显示名**。
+ * 绝不上报：apiKeyEnv 的值、baseURL、任何凭证、未注册的 provider。
+ * `listProviders()` 只返回**已注册（有 adapter）** 的 route —— 天然满足
+ * "不泄露这台机器配了哪些渠道"，只有真能用的才会出现。
+ *
+ * ── 尽力而为 ────────────────────────────────────────────────────────────
+ *
+ * 每个 provider 的 `listModels` 都可能抛（网络探测、鉴权失败、adapter 不
+ * 支持）。单个 provider 失败**不影响其它**；全部失败则返回 null（面板退回
+ * 自由文本）。整段包在 try/catch 里：遥测帧绝不能因为模型探测而丢。
+ *
+ * @returns {Promise<{models: Array<{provider:string,id:string,name:string}>, defaultModel: object|null}|null>}
+ */
+export async function readAvailableModels(ctx) {
+  let llm
+  try {
+    llm = typeof ctx?.get === 'function' ? ctx.get('llm') : undefined
+  } catch {
+    return null
+  }
+  if (!llm || typeof llm.listProviders !== 'function' || typeof llm.listModels !== 'function') {
+    return null
+  }
+
+  let providers
+  try {
+    providers = llm.listProviders()
+  } catch {
+    return null
+  }
+  if (!Array.isArray(providers) || providers.length === 0) return null
+
+  const models = []
+  // 逐个 provider 探测；单个失败静默跳过（不打断其它）。
+  for (const p of providers.slice(0, MAX_MODEL_PROVIDERS)) {
+    const providerId = p && typeof p.id === 'string' ? p.id.trim() : ''
+    if (providerId === '') continue
+    let list
+    try {
+      // 逐个探测是刻意的：并发打满会把副机的出站连接占住，
+      // 而这里只是低频遥测（RESOURCE 帧 30s 一次）。
+      list = await llm.listModels(providerId)
+    } catch {
+      continue
+    }
+    if (!Array.isArray(list)) continue
+    for (const m of list.slice(0, MAX_MODELS_PER_PROVIDER)) {
+      if (!m || typeof m.id !== 'string' || m.id === '') continue
+      const id = m.id.slice(0, 128)
+      const name = typeof m.name === 'string' && m.name !== '' ? m.name.slice(0, 128) : id
+      models.push({ provider: providerId.slice(0, 64), id, name })
+      if (models.length >= MAX_MODELS) break
+    }
+    if (models.length >= MAX_MODELS) break
+  }
+
+  if (models.length === 0) return null
+  return { models, defaultModel: readDefaultModel(ctx) }
+}
+
 /** 组 hello：hub 与 relay 都靠它认这台机器。 */
 export function buildNodeHello(config, { roots, nodeId } = {}) {  const c = asConfig(config)
   // 不变式：产出的 hello **必须**能过 protocol.validateHello。所以显式 override 也
@@ -584,6 +666,44 @@ function startWorker(ctx, config) {
   const resourceIntervalMs = Number.isFinite(cfg.resourceIntervalMs)
     ? Math.max(0, cfg.resourceIntervalMs)
     : RESOURCE_INTERVAL_MS
+
+  /**
+   * 模型清单缓存（提案 #27）。
+   *
+   * `readAvailableModels` 是 async（`llm.listModels()` 可能走网络探测），
+   * 而 RESOURCE 帧的 `setInterval` 回调是**同步**的 —— 不能在回调里 await。
+   *
+   * 所以用一个后台刷新循环：启动时探一次，之后每 `MODELS_REFRESH_MS` 重探。
+   * 帧里带的是**上一次的结果**（可能为 null = 还没探完/全部失败）。
+   *
+   * 为什么不用 `void refresh()` 直接塞进 interval：那会在探测慢时堆积
+   * 并发探测（每 30s 一次帧 × 探测要 3s = 越积越多）。用串行链保证
+   * 任何时刻最多一个探测在跑（与 repos 上报同款手法）。
+   */
+  const MODELS_REFRESH_MS = 10 * 60 * 1000
+  let cachedModels = null
+  let modelsTail = Promise.resolve()
+  let modelsQueued = false
+  const refreshModels = () => {
+    if (modelsQueued) return
+    modelsQueued = true
+    modelsTail = modelsTail.then(async () => {
+      modelsQueued = false
+      try {
+        const r = await readAvailableModels(ctx)
+        if (r) cachedModels = r
+      } catch {
+        /* 探测失败保留上一次的结果 —— 面板不该因为一次网络抖动退回空列表 */
+      }
+    })
+  }
+  // 启动后立刻探一次（不阻塞装配：fire-and-forget，结果进了缓存下一帧就带出去）
+  refreshModels()
+  const modelsTimer = resourceIntervalMs > 0
+    ? setInterval(refreshModels, MODELS_REFRESH_MS)
+    : undefined
+  if (modelsTimer?.unref) modelsTimer.unref()
+
   const resourceTimer = resourceIntervalMs > 0
     ? setInterval(() => {
       // 队列健康快照（提案 #26-3）随资源帧搭车：engine 在下方第 7 节才
@@ -593,12 +713,17 @@ function startWorker(ctx, config) {
       // 提案 #27：执行后端与默认模型随帧自述 —— hub 派发前要知道
       // "这台副机用哪个后端、默认模型是什么"（面板显示 + 派发前校验）。
       // currentSelection 每帧重算（用户可在副机改默认），取不到就 null。
+      //
+      // `models` 是**可用模型清单**（面板下拉的数据源），来自缓存 ——
+      // 探测是 async 的，不能在同步 interval 里 await（见 refreshModels）。
+      // 只报 provider 键名 + model id + 显示名，不碰任何凭证。
       send(NODE_TO_HUB.RESOURCE, {
         nodeId,
         ...sampler.sample(),
         queue,
         runnerKind: runner.kind,
         defaultModel: readDefaultModel(ctx),
+        models: cachedModels,
       })
     }, resourceIntervalMs)
     : undefined

package/lib/node/runner.js

@@ -477,6 +477,7 @@ export class InProcessRunner {
 
     let timer
     let timedOut = false
+    let aborted = false
     const timeoutPromise = new Promise((resolve) => {
       if (!(timeoutMs > 0)) return
       timer = setTimeout(() => {
@@ -487,6 +488,61 @@ export class InProcessRunner {
       if (timer.unref) timer.unref()
     })
 
+    /**
+     * 取消信号也必须参与 `Promise.race`（提案 #26-5）。
+     *
+     * ═══════════════════════════════════════════════════════════════════════
+     * 原实现：cancel 不真打断
+     * ═══════════════════════════════════════════════════════════════════════
+     *
+     * `race` 里只有两个竞争者 —— `agent.whenIdle()` 与 `timeoutPromise`：
+     *
+     *     const raced = await Promise.race([
+     *       agent.whenIdle().then(() => ({ timedOut: false })),
+     *       timeoutPromise,
+     *     ])
+     *
+     * 而 `InProcessRunner.cancel()` 做的是：
+     *   `agent.cancel({ kind: 'user' })` + `controller.abort()`
+     *
+     * **`controller.abort()` 只是置了个信号，没有任何人在 await 它** ——
+     * `whenIdle()` 不因 signal 而停（DSH 的 agent 循环不监听外部 AbortSignal），
+     * 于是：
+     *
+     *   用户 cancel → race 还在等 whenIdle → agent 继续跑到自然结束 →
+     *   按 `ok: !timedOut` 落成 **completed**（不是 aborted）。
+     *
+     * 实测症状：hub 发 `task/cancel`，`remote_cancel` 返回 `requested: true`，
+     * 但任务**一直 running 到 agent 自己跑完**，最终状态 completed ——
+     * 用户以为取消成功，实际白跑一遍还烧了额度。
+     *
+     * ── 修法 ──────────────────────────────────────────────────────────────
+     *
+     * 把 abort 也做成可 race 的 promise：一旦触发立即 resolve，race 立刻返回，
+     * `finally` 里 `handle.dispose()` 收掉 agent。
+     *
+     * ⚠ 两个语义细节：
+     *   1. `timedOut` 为真时 abort 是**超时的副作用**，不该把状态改写成
+     *      aborted（超时 ≠ 用户取消，下游据此外报不同的错误码）。
+     *   2. resolve 之后 agent 可能还跑一小会儿（dispose 是异步的），所以
+     *      状态判定必须用 `aborted` 而不是 `!timedOut`。
+     */
+    const abortPromise = new Promise((resolve) => {
+      if (controller.signal.aborted) {
+        aborted = true
+        resolve({ aborted: true })
+        return
+      }
+      controller.signal.addEventListener(
+        'abort',
+        () => {
+          if (!timedOut) aborted = true
+          resolve({ aborted: !timedOut })
+        },
+        { once: true },
+      )
+    })
+
     const sessionIdFor = `session-remote-${String(taskId).replace(/[^A-Za-z0-9-]/g, '').slice(0, 48)}`
     let handle
     let disposeListener
@@ -699,9 +755,18 @@ export class InProcessRunner {
       const raced = await Promise.race([
         agent.whenIdle().then(() => ({ timedOut: false })),
         timeoutPromise,
+        // #26-5：取消必须能赢 race。少了这一项，cancel 只会置 signal，
+        // agent 继续跑到自然结束，状态落成 completed。
+        abortPromise,
       ])
       if (raced.timedOut === true) timedOut = true
-      dlog('whenIdle resolved', { timedOut, liveTextLen: liveText.join('').length, elapsedMs: Date.now() - startedAt })
+      if (raced.aborted === true) aborted = true
+      dlog('whenIdle resolved', {
+        timedOut,
+        aborted,
+        liveTextLen: liveText.join('').length,
+        elapsedMs: Date.now() - startedAt,
+      })
 
       // 会话日志优先；日志取不到就用实时累积
       const fromLog = readSessionOutcome(session)
@@ -714,9 +779,13 @@ export class InProcessRunner {
       })
 
       return {
-        ok: !timedOut,
-        exitCode: timedOut ? null : 0,
+        // #26-5：取消不是成功。`ok` 必须把 aborted 排除掉，否则 engine 会把
+        // 取消落成 completed（engine 的映射是 `result.aborted ? ABORTED : ...`，
+        // 但那是 exec 侧；agent 侧靠这里的 ok 判定）。
+        ok: !timedOut && !aborted,
+        exitCode: timedOut || aborted ? null : 0,
         timedOut,
+        aborted,
         final: finalText,
         stderr: '',
         toolCalls: fromLog.toolCalls,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-agent",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "把另一台电脑变成你 DSH 的远程 Agent 同事：副机本地持久跑任务、独立 Agent 循环，只回传 handoff 摘要与产物清单，成品按需拉取。",
   "license": "MIT",

package/scripts/check-doc-drift.mjs

@@ -799,6 +799,93 @@ check('65', 'eslint 严格档：lint script + 配置文件 + CI job 三件套齐
     'scripts/check-doc-drift.mjs 断言 65（`\\s` 必须带反斜杠，否则脚本崩）')
 }
 
+/* ── 73~74. 队列残余风险的两条防线（#26-4 / #26-5，2026-10-17）──
+ *
+ * 背景：副机的 `maxConcurrent=2` 被两条卡住的 exec 占满后，后续任务全部排队。
+ * 排查时发现两个让问题"不可见/不可控"的缺陷：
+ *
+ *   #26-4 面板只显示 `running: 2` 这个数字 —— 看不到是哪两条、在跑什么、
+ *         跑了多久。用户只知道"卡了"，没有任何可操作的东西。
+ *   #26-5 `cancel` 只置 AbortSignal，没进 `Promise.race` —— agent 循环
+ *         不监听它，任务继续跑到自然结束，最终落成 **completed**（不是
+ *         aborted）。用户以为取消成功，实际白跑一遍还烧了额度。
+ *
+ * 这两条都是"静默失效"型：没有报错、没有日志、行为看起来"正常"。
+ * 所以用断言把修复钉住。
+ */
+{
+  const panelClient = read('lib/client.js')
+  check('73', '#26-4 面板任务列表按状态分组，运行中置顶且显示已跑时长',
+    /ACTIVE_STATUSES/.test(panelClient)
+    && /activeTasks/.test(panelClient)
+    && /运行中（/.test(panelClient)
+    && /已跑 /.test(panelClient),
+    'lib/client.js（ACTIVE_STATUSES + 运行中分组 + 已跑时长）')
+
+  const runnerSrc = read('lib/node/runner.js')
+  check('74', '#26-5 agent 取消真打断：abortPromise 参与 race，ok 排除 aborted',
+    /const abortPromise/.test(runnerSrc)
+    && /abortPromise,/.test(runnerSrc)
+    && /ok:\s*!timedOut\s*&&\s*!aborted/.test(runnerSrc)
+    && /if\s*\(!timedOut\)\s*aborted\s*=\s*true/.test(runnerSrc),
+    'lib/node/runner.js（abortPromise 进 race + ok 排除 aborted + 超时不误标）')
+}
+
+/* ── 75. #27 完整链路：模型清单自述 → 面板下拉（2026-10-17）──
+ *
+ * v0.7.0 只做了"自述 + 派发前拦截"，面板仍是自由文本 —— 当时的判断是
+ * "DSH 没有稳定的清单 API"。**那个判断已过时**：`ctx.llm.listProviders()`
+ * 与 `listModels(provider)` 现在就是稳定服务面。
+ *
+ * 链路四段，任一断掉面板就退回自由文本：
+ *   1. 副机 readAvailableModels（探测 + 缓存 + 上限）
+ *   2. RESOURCE 帧带缓存值（interval 回调是同步的，不能 await）
+ *   3. hub 字段级清洗 + 独立封顶
+ *   4. registry.list → nodeView → 面板 <select>
+ *
+ * 安全边界：只报 provider/id/name，绝不带 apiKeyEnv / baseURL / 凭证。
+ */
+{
+  const nodeIdx = read('lib/node/index.js')
+  const ingestSrc = read('lib/hub/registry-ingest.js')
+  const viewsSrc = read('lib/hub/views.js')
+  const clientSrc = read('lib/client.js')
+
+  check('75', '#27 模型清单链路：副机探测 + 帧自述 + hub 清洗 + 视图投影 + 面板下拉都在',
+    /export async function readAvailableModels/.test(nodeIdx)
+    && /llm\.listProviders\(\)/.test(nodeIdx)
+    && /llm\.listModels\(/.test(nodeIdx)
+    && /models:\s*cachedModels/.test(nodeIdx)
+    && /MAX_NODE_MODELS/.test(ingestSrc)
+    && /models: Array\.isArray\(r\.models\)/.test(read('lib/hub/node-registry.js'))
+    && /models: Array\.isArray\(n\.models\)/.test(viewsSrc)
+    && /跟随副机默认/.test(clientSrc)
+    && /__custom__/.test(clientSrc),
+    'lib/node/index.js + registry-ingest.js + node-registry.js + views.js + client.js')
+
+  check('76', '#27 安全：模型自述只含 provider/id/name，不碰凭证',
+    (() => {
+      const code = nodeIdx.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/[^\n]*/g, '$1')
+      const i = code.indexOf('export async function readAvailableModels')
+      if (i < 0) return false
+      const seg = code.slice(i, i + 2600)
+      // 上报对象里不得出现凭证相关字段
+      if (/apiKeyEnv/.test(seg) || /baseURL/.test(seg)) return false
+      const push = seg.match(/models\.push\(\{([^}]*)\}\)/)
+      if (!push) return false
+      const inner = push[1]
+      const keys = new Set()
+      for (const m of inner.matchAll(/(\w+)\s*:/g)) keys.add(m[1])
+      for (const part of inner.split(',')) {
+        const t = part.trim()
+        if (/^[A-Za-z_$][\w$]*$/.test(t)) keys.add(t)
+      }
+      const got = [...keys].sort().join(',')
+      return got === 'id,name,provider'
+    })(),
+    'lib/node/index.js readAvailableModels（上报字段恰好 provider/id/name）')
+}
+
 /* ── 输出 ── */
 const failed = results.filter((r) => !r.ok)
 if (process.argv.includes('--json')) {