dsh-device-fleet 0.1.0-dev.3 → 0.1.0-dev.5

package/README.md

@@ -11,7 +11,7 @@ DeepSeek Harness 的设备联邦插件：把登录同一账号、且都安装本
 
 ## 安装（开发版）
 
-已发布到 npm：**`dsh-device-fleet@0.1.0-dev.2`**（dist-tag `dev`）。
+已发布到 npm：**`dsh-device-fleet@0.1.0-dev.3`**（dist-tag `dev`）。
 
 ```sh
 # CLI / web profile
@@ -21,7 +21,7 @@ dsh plugin --profile web add dsh-device-fleet@dev
 dsh plugin --profile desktop add dsh-device-fleet@dev
 
 # 离线安装包（拷到另一台设备）
-dsh plugin --profile desktop add C:/path/to/dsh-device-fleet-0.1.0-dev.2.tgz
+dsh plugin --profile desktop add C:/path/to/dsh-device-fleet-0.1.0-dev.3.tgz
 ```
 
 两台设备的 **DSH 版本与插件版本必须一致**（ADR-0024）；不一致会在握手时直接拒绝。

package/docs/notes/dev-release.md

@@ -1,11 +1,11 @@
 # 开发版发布记录
 
 - 包名：`dsh-device-fleet`
-- 版本：`0.1.0-dev.2`
+- 版本：`0.1.0-dev.3`
 - dist-tag：`dev`（同时也可用精确版本安装）
 - registry：<https://registry.npmjs.org/dsh-device-fleet>
-- tarball：<https://registry.npmjs.org/dsh-device-fleet/-/dsh-device-fleet-0.1.0-dev.2.tgz>
-- 本地离线包：`dsh-device-fleet-0.1.0-dev.2.tgz`（仓库根目录，可拷贝安装）
+- tarball：<https://registry.npmjs.org/dsh-device-fleet/-/dsh-device-fleet-0.1.0-dev.3.tgz>
+- 本地离线包：`dsh-device-fleet-0.1.0-dev.3.tgz`（仓库根目录，可拷贝安装）
 - 发布时间：2026-11-09（Asia/Shanghai）
 - 内容：网络层 v1/v2 + Host 插件 + 直调 MVP（`fleet_invite/join/list/tools/call/read/fetch/run`）；Room/Board/委派/审批 UI 未包含。
 
@@ -21,7 +21,7 @@ dsh plugin --profile desktop add dsh-device-fleet@dev
 
 ## 已知限制
 
-- 严格同版本：两台设备必须安装同一 `0.1.0-dev.2`，DSH 版本也要同一发布线；
+- 严格同版本：两台设备必须安装同一 `0.1.0-dev.3`，DSH 版本也要同一发布线；
 - `fleet_run` 的 `ask` 审批目前 fail-closed（审批收件箱未实现）；
 - `fleet_fetch` 仅返回文本；
 - 首次加载会在 `$DSH_HOME/device-fleet/` 自动创建身份与独立 Fleet；加入已有 Fleet 需要先 `fleet_join` 再重启；
@@ -33,4 +33,9 @@ dsh plugin --profile desktop add dsh-device-fleet@dev
 - 第一次 activate 失败：`@deepseek-ai/schemastery` 只有默认导出（`import Schema from ...`），改为默认导入；
 - 第二次 activate 失败：Cordis 直接访问未 inject 的服务会抛错 → 可选服务统一走 `ctx.get(name)`；
 - 最终 `set_plugin include:device-fleet enabled=true` → `application: applied`，8 个 `fleet_*` 工具出现在模型工具表，`fleet_list` 返回本机 device id，`taskui_probe` 仍为 v0.4.2 / tasks=247（与 task-list 无冲突）。
-- 已发布 `0.1.0-dev.2`（包含上述激活修复）；`0.1.0-dev.1` 会激活失败，不要使用。
+- 已发布 `0.1.0-dev.3`（包含上述激活修复）；`0.1.0-dev.1` 会激活失败，不要使用。
+## 0.1.0-dev.3（本次）
+
+- 邀请里新增 `endpoints`（创建者的局域网/热点 IPv4 + direct 端口），加入方重启后自动向这些地址回连，绕开组播发现失败；
+- 新增 `fleet_status`（deviceId/直连端口/发现/连接/roster/hints）与 `fleet_connect(host, port)`（手动直连，成功后会从握手学到对端 deviceId）；
+- `fleet_list` 仍是本地视图；配对成功后双方 roster 会自动固定对端公钥。

package/docs/notes/pairing-session-2026-11-09.md

@@ -0,0 +1,30 @@
+# 首次配对实录（2026-11-09）
+
+## 环境
+
+- 设备 A：本机（Windows，DSH desktop profile，`device-fleet` 0.1.0-dev.3）
+  - deviceId：`50fdaf90-f0aa-440e-9fa6-c60ba5051001`，deviceName：`desktop`
+  - 直连：`0.0.0.0:60506`（热点网段 `192.168.137.1:60506`）
+  - allowedRoots：`E:/Dsh_test`
+- 设备 B：另一台设备（同一热点 `192.168.137.0/24`，plugin 0.1.0-dev.3）
+  - deviceId：`c2d42572-e5f0-4d7e-9fff-c28d9a668439`
+- 热点网段内网段：A `192.168.137.1/24`，B 为客户端之一。
+
+## 过程
+
+1. dev.3 邀请携带 `endpoints`（A 的 `210.73.18.88:60506` 与 `192.168.137.1:60506`）。
+2. B 安装 dev.3 → `fleet_join` 新邀请 → 重启；插件读取 enrollment endpoints，自动回连 A。
+3. 结果：双方握手成功，roster 互固定公钥；A 侧 `fleet_list` 显示 B `online`，`fleet_status.connected` 含 B。
+4. `fleet_tools(device=B)` 成功（说明 RPC/加密通道正常）。
+5. `fleet_read(device=B, path=E:/Dsh_test/hello-from-A.txt)` 返回 `denied: no allowed roots configured on this device` —— 策略按设计拦截，B 侧尚未配置 allowedRoots。
+
+## 结论
+
+- **网络层 v1 直连 + 配对流程打通**（组播发现在该热点下不可用，邀请 endpoints 自动回连解决了问题）。
+- **Tool Policy 生效**：目标设备未配置允许根时直调被拒。
+- 待配置 B 的 `policy.allowedRoots` / `execution.cwd` 后可双向直调；`fleet_run` 待审批收件箱 UI。
+
+## 复现要点
+
+- 邀请里的 endpoints 由 `networkInterfaces()` 的非回环 IPv4 + 当前 direct port 组成；direct 端口每次插件重载会变，重载后需重新生成邀请或手动 `fleet_connect`。
+- 同一账号指纹：邀请携带 `accountFingerprint`；B 登录不同账号会在加载时被标记 mismatch 并拒绝连接。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-device-fleet",
-  "version": "0.1.0-dev.3",
+  "version": "0.1.0-dev.5",
   "description": "DeepSeek Harness device fleet: enroll devices, direct-call remote tools, shared Rooms with lazy-woken agents, and delegated subagents across devices.",
   "type": "module",
   "main": "src/plugin/index.js",

package/src/host/delegation.js

@@ -0,0 +1,124 @@
+// Cross-device delegation (ADR-0015): the caller asks the target device's
+// agent to do a one-shot task and gets the final assistant output back.
+//
+// On the target device this runs through the official SubagentProvider
+// contract with `delivery: 'caller'`, so the child agent's own model turn and
+// tools run on that device, and the `result` promise resolves with the final
+// content blocks. No Room, no shared history: delegation is a one-shot task.
+const DEFAULT_DELEGATE_TIMEOUT_MS = 180_000
+const DEFAULT_PROVIDER = 'spawn'
+const DEFAULT_LABEL = 'fleet delegation'
+
+function textOf(result) {
+  const blocks = Array.isArray(result?.output) ? result.output : []
+  return blocks
+    .map((block) => (block?.type === 'text' ? block.text : `[${String(block?.type ?? 'block')}]`))
+    .join('\n')
+    .trim()
+}
+
+function withTimeout(promise, timeoutMs, onTimeout) {
+  let timer
+  return Promise.race([
+    promise.finally(() => clearTimeout(timer)),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(onTimeout()), timeoutMs)
+      timer.unref?.()
+    }),
+  ])
+}
+
+export class DelegationHost {
+  /**
+   * @param {object} options
+   * @param {object} options.subagents ctx.subagents service
+   * @param {object} options.slot ExecutionSlot
+   * @param {import('./tool-policy.js').ToolPolicy} options.policy
+   * @param {(request: object) => Promise<boolean>} [options.requestApproval]
+   * @param {string} [options.deviceId]
+   * @param {string} [options.defaultCwd]
+   * @param {string} [options.defaultAgentPreset]
+   * @param {string} [options.provider]
+   * @param {number} [options.timeoutMs]
+   */
+  constructor({
+    subagents,
+    slot,
+    policy,
+    requestApproval,
+    deviceId,
+    defaultCwd,
+    defaultAgentPreset,
+    provider = DEFAULT_PROVIDER,
+    timeoutMs = DEFAULT_DELEGATE_TIMEOUT_MS,
+  }) {
+    this.subagents = subagents
+    this.slot = slot
+    this.policy = policy
+    this.requestApproval = requestApproval
+    this.deviceId = deviceId
+    this.defaultCwd = defaultCwd
+    this.defaultAgentPreset = defaultAgentPreset
+    this.provider = provider
+    this.timeoutMs = timeoutMs
+  }
+
+  async delegate({ fromDeviceId, request = {} }) {
+    const task = typeof request.task === 'string' ? request.task.trim() : ''
+    if (task === '') throw Object.assign(new Error('delegate needs a non-empty task'), { code: 'bad-request' })
+
+    const decision = this.policy.decide({ capability: 'delegate', args: {} })
+    if (decision.decision === 'deny') {
+      throw Object.assign(new Error(decision.reason), { code: 'denied', data: { capability: 'delegate' } })
+    }
+    if (decision.decision === 'ask') {
+      const approved =
+        typeof this.requestApproval === 'function'
+          ? await this.requestApproval({ fromDeviceId, capability: 'delegate', tool: 'delegate', args: { task }, reason: decision.reason })
+          : false
+      if (approved !== true) throw Object.assign(new Error('local approval was not granted'), { code: 'approval_denied' })
+      this.policy.grant(decision.key, { scope: 'once' })
+    }
+
+    const agent = await this.slot.ensureAgent()
+    const controller = new AbortController()
+    const startedAt = Date.now()
+    let activation
+    try {
+      activation = await this.subagents.startActivation({
+        provider: request.provider ?? this.provider,
+        label: typeof request.label === 'string' && request.label !== '' ? request.label : DEFAULT_LABEL,
+        request: {
+          prompt: [{ type: 'text', text: task }],
+          parent: agent,
+          ...(request.cwd ?? this.defaultCwd ? { cwd: request.cwd ?? this.defaultCwd } : {}),
+          ...(request.agentPreset ?? this.defaultAgentPreset
+            ? { agentPreset: request.agentPreset ?? this.defaultAgentPreset }
+            : {}),
+        },
+        signal: controller.signal,
+        delivery: 'caller',
+      })
+      const result = await withTimeout(
+        activation.result,
+        Number.isFinite(request.timeoutMs) ? request.timeoutMs : this.timeoutMs,
+        () => {
+          controller.abort()
+          return Object.assign(new Error('delegation timed out; the child agent was asked to stop'), { code: 'delegate-timeout' })
+        },
+      )
+      return {
+        text: textOf(result) || '(delegated agent returned no text)',
+        stopReason: result?.stopReason ?? null,
+        childId: activation.childId,
+        durationMs: Date.now() - startedAt,
+      }
+    } finally {
+      try {
+        await activation?.dispose?.()
+      } catch {
+        /* best effort */
+      }
+    }
+  }
+}

package/src/host/direct-call.js

@@ -27,6 +27,7 @@ export class DirectCallHost {
    * @param {string} [options.dshVersion]
    * @param {string[]} [options.capabilities]
    * @param {string} [options.shellTool]
+   * @param {object} [options.delegation] DelegationHost for `fleet.delegate`
    */
   constructor({
     slot,
@@ -40,6 +41,7 @@ export class DirectCallHost {
     capabilities = [],
     shellTool = DEFAULT_SHELL_TOOL,
     approvalTimeoutMs = DEFAULT_POLICY_TIMEOUT_MS,
+    delegation = null,
   }) {
     this.slot = slot
     this.policy = policy
@@ -52,6 +54,7 @@ export class DirectCallHost {
     this.capabilities = capabilities
     this.shellTool = shellTool
     this.approvalTimeoutMs = approvalTimeoutMs
+    this.delegation = delegation
   }
 
   info() {
@@ -75,6 +78,11 @@ export class DirectCallHost {
         return { deviceId: this.deviceId, tools: await this.slot.listTools(), policy: this.policy.summarize() }
       case 'fleet.call':
         return this.handleCall({ fromDeviceId: deviceId, request: params ?? {} })
+      case 'fleet.delegate':
+        if (!this.delegation) {
+          throw Object.assign(new Error('delegation is unavailable on this device'), { code: 'unsupported' })
+        }
+        return this.delegation.delegate({ fromDeviceId: deviceId, request: params ?? {} })
       default:
         throw Object.assign(new Error(`unknown fleet method: ${String(method)}`), { code: 'unknown-method' })
     }
@@ -178,6 +186,11 @@ export class DirectCallClient {
     return this.node.request(deviceId, 'fleet.call', { capability, tool, args }, options)
   }
 
+  /** Ask the target device's agent to do a one-shot task and return its final text. */
+  async delegate(deviceId, request, options = {}) {
+    return this.node.request(deviceId, 'fleet.delegate', request, options)
+  }
+
   /** Format a remote result for a model-facing text tool. */
   render(result) {
     if (result?.isError) return `Error: ${result.text || 'remote tool failed'}`

package/src/host/execution-slot.js

@@ -55,11 +55,25 @@ export class ExecutionSlot {
    */
   async executeTool({ name, args = {}, signal }) {
     const agent = await this.ensureAgent()
-    const batch = await this.tools.execute({
-      calls: [{ id: randomUUID(), name, arguments: JSON.stringify(args ?? {}) }],
-      agent,
-      signal,
-    })
+    // execToolBatch requires a real AbortSignal: without one the pipeline
+    // throws before dispatch, which surfaces as "Tool batch execution failed".
+    const effectiveSignal = signal ?? new AbortController().signal
+    let batch
+    try {
+      batch = await this.tools.execute({
+        calls: [{ id: randomUUID(), name, arguments: JSON.stringify(args ?? {}) }],
+        agent,
+        signal: effectiveSignal,
+      })
+    } catch (error) {
+      const cause = error?.cause
+      const detail = cause?.message ?? error?.message ?? String(error)
+      throw Object.assign(new Error(`tool ${name} failed: ${String(detail)}`), {
+        code: 'tool-failed',
+        cause,
+        data: { causeCode: cause?.code ?? null, causeMessage: cause?.message ?? null },
+      })
+    }
     const first = batch?.results?.[0]?.result
     if (!first) throw Object.assign(new Error(`tool ${name} returned no result`), { code: 'tool-no-result' })
     const text = (first.content ?? [])

package/src/host/index.js

@@ -3,4 +3,5 @@ export * from './store.js'
 export * from './tool-policy.js'
 export * from './execution-slot.js'
 export * from './direct-call.js'
+export * from './delegation.js'
 export * from './tools.js'

package/src/host/tool-policy.js

@@ -3,7 +3,7 @@
 // the raw-tool allowlist, and short-lived grants created by approvals.
 import path from 'node:path'
 
-export const CAPABILITIES = ['read', 'list', 'grep', 'fetch', 'run', 'tool']
+export const CAPABILITIES = ['read', 'list', 'grep', 'fetch', 'run', 'tool', 'delegate']
 
 export const DEFAULT_POLICY = Object.freeze({
   allowedRoots: [],
@@ -14,6 +14,7 @@ export const DEFAULT_POLICY = Object.freeze({
     fetch: 'auto',
     run: 'ask',
     tool: 'deny',
+    delegate: 'ask',
   },
   allowedTools: [],
   approvalTtlMs: 15 * 60 * 1000,

package/src/host/tools.js

@@ -109,6 +109,20 @@ export function createFleetHandlers({ node, client = new DirectCallClient({ node
       }
     },
 
+    async fleet_delegate({ device, task, label, cwd }) {
+      try {
+        const result = await client.delegate(
+          device,
+          { task, ...(label ? { label } : {}), ...(cwd ? { cwd } : {}) },
+          { timeoutMs: 200_000 },
+        )
+        const meta = result?.childId ? `\n[delegated on ${device} · ${String(result.durationMs ?? 0)}ms · child ${String(result.childId)}]` : ''
+        return { text: `${String(result?.text ?? '')}${meta}`.trim() }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
     async fleet_read({ device, path, offset, limit }) {
       try {
         const args = { file_path: path }
@@ -211,6 +225,19 @@ export function createFleetToolDefinitions({ defineTool, handlers }) {
       output,
       execute: (args) => handlers.fleet_call(args),
     }),
+    defineTool({
+      name: 'fleet_delegate',
+      description:
+        'Delegate a one-shot task to another device\'s agent and wait for its final answer. Use it when the work needs that device\'s model and tools ("let B build/check this"), not just one tool call. The delegated agent runs on the target device; it does not join a Room and its history is not shared. The target device decides whether delegation is allowed or needs local approval.',
+      parameters: {
+        device: commonDevice,
+        task: { type: 'string', required: true, description: 'Self-contained task instructions for the target agent.' },
+        label: { type: 'string', description: 'Short label shown in the target device\'s subagent list.' },
+        cwd: { type: 'string', description: 'Optional working directory on the target device.' },
+      },
+      output,
+      execute: (args) => handlers.fleet_delegate(args),
+    }),
     defineTool({
       name: 'fleet_read',
       description:

package/src/plugin/index.js

@@ -13,6 +13,7 @@ import Schema from '@deepseek-ai/schemastery'
 import { FleetNode } from '../net/fleet-node.js'
 import { accountFingerprint } from '../net/identity.js'
 import { DirectCallClient, DirectCallHost } from '../host/direct-call.js'
+import { DelegationHost } from '../host/delegation.js'
 import { ExecutionSlot, DEFAULT_SHELL_TOOL } from '../host/execution-slot.js'
 import { ToolPolicy } from '../host/tool-policy.js'
 import { createFleetHandlers, createFleetToolDefinitions } from '../host/tools.js'
@@ -60,9 +61,11 @@ export const Config = Schema.object({
     agentPreset: Schema.string(),
     shellTool: Schema.string().default(DEFAULT_SHELL_TOOL),
     approvalTimeoutMs: Schema.number().default(60000),
+    delegateTimeoutMs: Schema.number().default(180000),
+    subagentProvider: Schema.string().default('spawn'),
   })
-    .default({ shellTool: DEFAULT_SHELL_TOOL, approvalTimeoutMs: 60000 })
-    .description('Execution Slot: the hidden DSH session used to execute remote tool calls.'),
+    .default({ shellTool: DEFAULT_SHELL_TOOL, approvalTimeoutMs: 60000, delegateTimeoutMs: 180000, subagentProvider: 'spawn' })
+    .description('Execution Slot and delegation settings for direct calls and one-shot delegation.'),
   policy: Schema.object({
     allowedRoots: Schema.array(Schema.string()).default([]),
     capabilities: Schema.any().default({}),
@@ -153,11 +156,32 @@ export function apply(ctx, config) {
   const policy = new ToolPolicy(config.policy)
   const sessionController = service('sessionController')
   const fs = service('fs')
+  const subagents = service('subagents')
   if (!sessionController) logger.warn?.('[device-fleet] sessionController unavailable: direct calls to stateful tools will fail')
   const slot = sessionController
     ? new ExecutionSlot({ sessionController, tools: ctx.tools, config: config.execution })
     : null
 
+  const delegation =
+    slot && subagents
+      ? new DelegationHost({
+          subagents,
+          slot,
+          policy,
+          deviceId: state.identity.deviceId,
+          defaultCwd: config.execution?.cwd,
+          defaultAgentPreset: config.execution?.agentPreset,
+          provider: config.execution?.subagentProvider ?? 'spawn',
+          timeoutMs: config.execution?.delegateTimeoutMs ?? 180_000,
+          requestApproval: config.autoApproveAsk
+            ? async () => true
+            : async (request) => {
+                logger.info?.(`[device-fleet] delegation approval required from ${request.fromDeviceId} (no approval UI yet)`)
+                return false
+              },
+        })
+      : null
+
   const host = slot
     ? new DirectCallHost({
         slot,
@@ -170,6 +194,7 @@ export function apply(ctx, config) {
         capabilities: CAPABILITIES,
         shellTool: config.execution?.shellTool ?? DEFAULT_SHELL_TOOL,
         approvalTimeoutMs: config.execution?.approvalTimeoutMs ?? 60_000,
+        delegation,
         requestApproval: config.autoApproveAsk
           ? async () => true
           : async (request) => {