dsh-device-fleet 0.1.0-dev.6 → 0.1.0-dev.8

package/README.md

@@ -7,7 +7,8 @@ DeepSeek Harness 的设备联邦插件：把登录同一账号、且都安装本
 - ✅ **网络层 v1**：设备身份、邀请、端到端加密安全通道、直连（手动地址）、UDP 组播发现
 - ✅ **网络层 v2**：自建 Relay（fleetKey 鉴权的信令 + TCP 拼接数据面，不做 NAT 打洞）
 - ✅ **Host 插件 + 直调 MVP（代码完成、单测通过，待真实 DSH 安装联调）**：`fleet_list` / `fleet_tools` / `fleet_call` + `fleet_read` / `fleet_fetch` / `fleet_run`、Tool Policy、Execution Slot、审批 fail-closed
-- ⏳ Room / Room Board、委派、审批收件箱 UI、设备页/配对/房间 UI（下一步）
+- ✅ **审批收件箱逻辑层（dev.7）**：`fleet_approvals` / `fleet_approve` / `fleet_deny`，ask 档排队、超时 fail-closed、once/ttl 授权、`fleet_simulate_request` 本机演练；Client 审批面板待做
+- ⏳ Room / Room Board、委派升级 Room、审批面板/设备页 UI（下一步）
 
 ## 安装（开发版）
 

package/docs/notes/approval-inbox-phase.md

@@ -0,0 +1,31 @@
+# 审批收件箱（逻辑层，dev.7）
+
+## 实现
+
+- `src/host/approval-inbox.js`：`ApprovalInbox`
+  - `request()`：排队、60s（可配）超时 fail-closed、事件 `request/approved/denied/expired/closed`；
+  - `list()`：待审列表（来源设备、能力、工具、参数摘要、剩余时间）；
+  - `approve(id, {scope})`：`once` / `ttl`（TTL 由 Tool Policy 的 `approvalTtlMs` 控制）；
+  - `deny(id, reason)`；`close()` 时全部失败关闭。
+- `DirectCallHost` / `DelegationHost` 的 `ask` 档改为等待收件箱结果（不再一律拒绝），批准后按 scope 写入 Tool Policy 授权。
+- 新工具：`fleet_approvals` / `fleet_approve` / `fleet_deny`；`fleet_simulate_request`（仅 `approvals.simulation: true`）用于本机无第二台设备时演练。
+- 配置：`approvals: {ttlMs, maxPending, simulation}`。
+
+## 已验证
+
+单元测试（`node test/host.test.mjs`，10/10）：
+- 收件箱排队/批准/拒绝/超时/关闭/上限；
+- DirectCallHost 在 `run=ask` 时阻塞等待收件箱批准后才执行；
+- 工具 handler 的列表/批准/拒绝/模拟。
+
+当前 DSH 环境内模拟（dev.7，无需第二台设备）：
+1. `fleet_simulate_request` 创建一条 `run/pwsh` 请求，`fleet_approvals` 显示 `58328ms left`；
+2. `fleet_approve(id, scope="ttl")` → `approved … (ttl)`，再次 `fleet_approvals` 为 `(no pending approvals)`；
+3. 再模拟一条 `delegate` 请求，`fleet_deny` → `denied …`；
+4. 对不存在的 id 调 `fleet_approve` → `Error: [unknown-request]`。
+
+## 未完成
+
+- **Client UI 审批面板/通知**（需 Client bundle）：当前只能通过工具或后续 UI 应答；Host 侧已发出 `request/approved/denied/expired` 事件，面板可直接消费；
+- `room` 级授权 scope（需 Room 概念落地后再加）；
+- 审批结果持久化审计日志（后续与 Room 事件一起做）。

package/docs/notes/dev-release.md

@@ -38,4 +38,16 @@ dsh plugin --profile desktop add dsh-device-fleet@dev
 
 - 邀请里新增 `endpoints`（创建者的局域网/热点 IPv4 + direct 端口），加入方重启后自动向这些地址回连，绕开组播发现失败；
 - 新增 `fleet_status`（deviceId/直连端口/发现/连接/roster/hints）与 `fleet_connect(host, port)`（手动直连，成功后会从握手学到对端 deviceId）；
-- `fleet_list` 仍是本地视图；配对成功后双方 roster 会自动固定对端公钥。
+- `fleet_list` 仍是本地视图；配对成功后双方 roster 会自动固定对端公钥。
+## 0.1.0-dev.7（稳定化）
+
+- 直连端口可固定（profile `direct.port`），插件重载不再换端口；
+- 连接断开后自动重试已知地址（不再只在启动时试一次）；
+- `fleet_connect` 手动地址会持久化到 `peer-hints.json`，重启后继续回连；
+- 新增 `fleet_delegate`（dev.5）：目标设备用 `SubagentProvider` + `delivery:'caller'` 跑 agent 并返回最终结果。
+## 0.1.0-dev.7（审批收件箱，逻辑层）
+
+- 新增 `ApprovalInbox`：ask 档请求排队、超时 fail-closed、approve（once/ttl）/deny、关闭时全部失败关闭；
+- 直调与委派的 ask 档改为等待本机收件箱结果（不再一律拒绝）；
+- 新工具：`fleet_approvals` / `fleet_approve` / `fleet_deny`；`fleet_simulate_request`（仅 `approvals.simulation: true`）用于本机无第二台设备时演练流程；
+- 审批面板（Client UI）与通知尚未实现，当前通过工具/后续 UI 应答。

package/docs/notes/remote-tests-2026-11-09.md

@@ -0,0 +1,33 @@
+# 跨设备调用实测（2026-11-09，dev.6）
+
+环境：A `desktop` / `50fdaf90-…`（端口固定 60580）；B `laptop` / `c2d42572-…`（dev.6，同一热点）。
+测试文件：A `E:\Dsh_test\hello-from-A.txt`；B `E:\Dsh_test\hello-from-B.txt`。
+
+## 结果
+
+| # | 调用 | 结果 | 耗时 |
+|---|---|---|---|
+| 1 | `fleet_read(B, E:/Dsh_test/hello-from-B.txt)` | ✅ 返回 `hello from device B` | 48ms |
+| 2 | `fleet_call(B, tool="read", {file_path:…hello-from-B.txt})` | ✅ 返回同一内容（原始工具直调） | 4ms |
+| 3 | `fleet_fetch(B, hello-from-B.txt)` | ✅ 返回文本 | 1ms |
+| 4 | `fleet_run(B, "echo hello-from-B")` | ⚠️ `approval_denied`（B 策略 run=ask，审批 UI 未实现，fail-closed 正确） | 即时 |
+| 5 | `fleet_delegate(B, "读取 hello-from-B.txt 并原样返回")` | ✅ B 的 agent（spawn 子会话 `1a768f89…`）读文件并回传最终文本 | 2.7s |
+| 6 | `fleet_delegate(B, "用 fleet_read 读 A 的 hello-from-A.txt 并原样返回")` | ✅ B 的 agent 反向调用 A 的 `read`，回传 `hello from device A (fleet test)`（子会话 `515f8c1b…`） | 2.5s |
+
+## 结论
+
+- v1 直连 + 端到端加密 + 配对/roster 固定公钥：**通过**；
+- 直调（typed 快捷工具 / `fleet_call` 原始工具 / fetch）：**通过**；
+- Tool Policy 与 fail-closed 审批：**按设计生效**；
+- 跨设备委派（B 的 agent 在本机执行并回传；B 的 agent 反向调 A 工具）：**通过**；
+- 遗留：审批收件箱 UI（`run`/`delegate` 的 `ask` 档目前只能拒绝或配置 auto）；Room/Room Board/设备页 UI 未开始；委派返回文本里 `[reasoning]` 是结果里的 reasoning block 展示，可后续过滤。
+
+## 复现命令（A 侧）
+
+```
+fleet_list()
+fleet_read(device="c2d42572-…", path="E:/Dsh_test/hello-from-B.txt")
+fleet_call(device="c2d42572-…", tool="read", parameters={file_path:"E:/Dsh_test/hello-from-B.txt"})
+fleet_delegate(device="c2d42572-…", task="读取 E:/Dsh_test/hello-from-B.txt 并原样返回")
+fleet_delegate(device="c2d42572-…", task="用 fleet_read 读设备 50fdaf90-… 的 E:/Dsh_test/hello-from-A.txt 并原样返回")
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-device-fleet",
-  "version": "0.1.0-dev.6",
+  "version": "0.1.0-dev.8",
   "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/approval-inbox.js

@@ -0,0 +1,135 @@
+// Local approval inbox (ADR-0020): a target device asks its own user before a
+// remote call/delegation with the `ask` policy can run. v1 has no client UI yet;
+// the inbox is exposed through `fleet_approvals` / `fleet_approve` /
+// `fleet_deny` and can be exercised with `fleet_simulate_request` while the
+// client panel is still missing.
+import { EventEmitter } from 'node:events'
+import { randomUUID } from 'node:crypto'
+
+export const APPROVAL_SCOPES = ['once', 'ttl']
+
+const SUMMARY_ARG_LENGTH = 160
+
+function summarizeArgs(args) {
+  try {
+    const text = JSON.stringify(args ?? {})
+    return text.length > SUMMARY_ARG_LENGTH ? `${text.slice(0, SUMMARY_ARG_LENGTH)}…` : text
+  } catch {
+    return '[unserializable arguments]'
+  }
+}
+
+export class ApprovalInbox extends EventEmitter {
+  constructor({ ttlMs = 60_000, maxPending = 50, now = Date.now } = {}) {
+    super()
+    this.ttlMs = ttlMs
+    this.maxPending = maxPending
+    this.now = now
+    this.closed = false
+    /** @type {Map<string, any>} */
+    this.pending = new Map()
+  }
+
+  /**
+   * Ask the local user. Resolves `{ approved, scope?, reason? }` when approved,
+   * denied, expired or closed.
+   */
+  request(request) {
+    if (this.closed) return Promise.resolve({ approved: false, reason: 'inbox-closed' })
+    if (this.pending.size >= this.maxPending) {
+      return Promise.resolve({ approved: false, reason: 'inbox-full' })
+    }
+    const id = randomUUID()
+    const createdAt = this.now()
+    const entry = {
+      id,
+      fromDeviceId: request.fromDeviceId ?? 'unknown',
+      capability: request.capability ?? 'tool',
+      tool: request.tool ?? null,
+      reason: request.reason ?? '',
+      argsSummary: summarizeArgs(request.args),
+      createdAt,
+      expiresAt: createdAt + this.ttlMs,
+      status: 'pending',
+    }
+    entry.promise = new Promise((resolve) => {
+      entry.resolve = resolve
+    })
+    entry.timer = setTimeout(() => this.expire(id), this.ttlMs)
+    entry.timer.unref?.()
+    this.pending.set(id, entry)
+    this.emit('request', this.summary(entry))
+    return entry.promise
+  }
+
+  summary(entry) {
+    return {
+      id: entry.id,
+      fromDeviceId: entry.fromDeviceId,
+      capability: entry.capability,
+      tool: entry.tool,
+      reason: entry.reason,
+      argsSummary: entry.argsSummary,
+      createdAt: entry.createdAt,
+      expiresAt: entry.expiresAt,
+      expiresInMs: Math.max(0, entry.expiresAt - this.now()),
+      status: entry.status,
+    }
+  }
+
+  list() {
+    return [...this.pending.values()]
+      .filter((entry) => entry.status === 'pending')
+      .sort((a, b) => a.createdAt - b.createdAt)
+      .map((entry) => this.summary(entry))
+  }
+
+  approve(id, { scope = 'once' } = {}) {
+    const entry = this.settle(id, 'approved')
+    if (!entry) throw Object.assign(new Error(`unknown approval request: ${String(id)}`), { code: 'unknown-request' })
+    const chosen = APPROVAL_SCOPES.includes(scope) ? scope : 'once'
+    entry.resolve({ approved: true, scope: chosen })
+    this.emit('approved', { ...this.summary(entry), scope: chosen })
+    return { ...this.summary(entry), scope: chosen }
+  }
+
+  deny(id, reason = 'denied by local user') {
+    const entry = this.settle(id, 'denied')
+    if (!entry) throw Object.assign(new Error(`unknown approval request: ${String(id)}`), { code: 'unknown-request' })
+    entry.resolve({ approved: false, reason })
+    this.emit('denied', { ...this.summary(entry), reason })
+    return { ...this.summary(entry), reason }
+  }
+
+  expire(id) {
+    const entry = this.pending.get(id)
+    if (!entry || entry.status !== 'pending') return
+    entry.status = 'expired'
+    this.pending.delete(id)
+    clearTimeout(entry.timer)
+    entry.resolve({ approved: false, reason: 'approval-timeout' })
+    this.emit('expired', this.summary(entry))
+  }
+
+  settle(id, status) {
+    const entry = this.pending.get(id)
+    if (!entry || entry.status !== 'pending') return undefined
+    entry.status = status
+    this.pending.delete(id)
+    clearTimeout(entry.timer)
+    return entry
+  }
+
+  /** Close the inbox: every pending request fails closed. */
+  close() {
+    if (this.closed) return
+    this.closed = true
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer)
+      entry.status = 'closed'
+      entry.resolve({ approved: false, reason: 'inbox-closed' })
+    }
+    this.pending.clear()
+    this.emit('closed')
+  }
+}

package/src/host/delegation.js

@@ -72,12 +72,15 @@ export class DelegationHost {
       throw Object.assign(new Error(decision.reason), { code: 'denied', data: { capability: 'delegate' } })
     }
     if (decision.decision === 'ask') {
-      const approved =
+      const outcome =
         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' })
+          : { approved: false, reason: 'no approval channel' }
+      const approved = outcome === true || outcome?.approved === true
+      if (!approved) {
+        throw Object.assign(new Error(outcome?.reason ?? 'local approval was not granted'), { code: 'approval_denied' })
+      }
+      this.policy.grant(decision.key, { scope: outcome?.scope === 'ttl' ? 'ttl' : 'once' })
     }
 
     const agent = await this.slot.ensureAgent()

package/src/host/direct-call.js

@@ -97,9 +97,11 @@ export class DirectCallHost {
       throw Object.assign(new Error(decision.reason), { code: 'denied', data: { capability, tool } })
     }
     if (decision.decision === 'ask') {
-      const approved = await this.askApproval({ fromDeviceId, capability, tool, args, reason: decision.reason })
-      if (!approved) throw Object.assign(new Error('local approval was not granted'), { code: 'approval_denied' })
-      this.policy.grant(decision.key, { scope: 'once' })
+      const outcome = await this.askApproval({ fromDeviceId, capability, tool, args, reason: decision.reason })
+      if (outcome.approved !== true) {
+        throw Object.assign(new Error(outcome.reason ?? 'local approval was not granted'), { code: 'approval_denied' })
+      }
+      this.policy.grant(decision.key, { scope: outcome.scope === 'ttl' ? 'ttl' : 'once' })
     }
     const startedAt = Date.now()
     const result = await this.execute({ capability, tool, args })
@@ -116,12 +118,16 @@ export class DirectCallHost {
   }
 
   async askApproval({ fromDeviceId, capability, tool, args, reason }) {
-    if (typeof this.requestApproval !== 'function') return false
+    if (typeof this.requestApproval !== 'function') return { approved: false, reason: 'no approval channel' }
     try {
-      const approved = await this.requestApproval({ fromDeviceId, capability, tool, args, reason })
-      return approved === true
-    } catch {
-      return false
+      const outcome = await this.requestApproval({ fromDeviceId, capability, tool, args, reason })
+      if (outcome === true) return { approved: true, scope: 'once' }
+      if (outcome && typeof outcome === 'object') {
+        return { approved: outcome.approved === true, scope: outcome.scope ?? 'once', reason: outcome.reason }
+      }
+      return { approved: false, reason: 'approval not granted' }
+    } catch (error) {
+      return { approved: false, reason: String(error?.message ?? error) }
     }
   }
 

package/src/host/index.js

@@ -4,4 +4,6 @@ export * from './tool-policy.js'
 export * from './execution-slot.js'
 export * from './direct-call.js'
 export * from './delegation.js'
+export * from './approval-inbox.js'
+export * from './room-service.js'
 export * from './tools.js'

package/src/host/room-service.js

@@ -0,0 +1,324 @@
+// Room logic layer (ADR-0002/0005/0006/0011/0021), with local participants for
+// simulation inside one DSH. The Host session log carries the authoritative
+// room events; participant agents are real local DSH sessions woken with an
+// addressed message, so addressing/wake/visibility and board handoff can be
+// exercised before the remote transport and the client UI exist.
+import { randomUUID } from 'node:crypto'
+
+const MAX_MESSAGE_CHARS = 20_000
+
+const DEFAULT_POLICY = Object.freeze({
+  invite: 'members',
+  join: 'auto',
+  maxMembers: 8,
+  boardWrite: 'members',
+  remove: 'members',
+})
+
+function hostMemberId(sessionId) {
+  return `host:${sessionId}`
+}
+
+function localMemberId(sessionId) {
+  return `local:${sessionId}`
+}
+
+export class RoomService {
+  /**
+   * @param {object} options
+   * @param {object} options.sessionController ctx.sessionController
+   * @param {(input: object) => object} [options.createUserMessage] dsh-llm helper
+   * @param {(now?: number) => number} [options.now]
+   */
+  constructor({ sessionController, createUserMessage = null, now = Date.now } = {}) {
+    this.sessionController = sessionController
+    this.createUserMessage = createUserMessage
+    this.now = now
+    /** @type {Map<string, any>} */
+    this.rooms = new Map()
+  }
+
+  async upgradeHost({ agent, policy = {} } = {}) {
+    if (!agent?.session?.id) throw Object.assign(new Error('room upgrade needs the calling agent session'), { code: 'bad-request' })
+    const sessionId = agent.session.id
+    const existing = this.rooms.get(sessionId)
+    if (existing) return this.summary(existing)
+    const memberId = hostMemberId(sessionId)
+    const room = {
+      roomId: sessionId,
+      createdAt: this.now(),
+      hostSessionId: sessionId,
+      policy: { ...DEFAULT_POLICY, ...policy },
+      members: new Map(),
+      messages: [],
+      tasks: new Map(),
+      closed: false,
+    }
+    room.members.set(memberId, {
+      memberId,
+      role: 'host',
+      kind: 'local',
+      sessionId,
+      name: agent.session.header?.title ?? 'host',
+      agent,
+    })
+    this.rooms.set(sessionId, room)
+    await this.append(room, 'room/created', { roomId: room.roomId, policy: room.policy, hostMemberId: memberId })
+    return this.summary(room)
+  }
+
+  async addLocalParticipant({ roomId, name = 'worker', agentPreset, cwd } = {}) {
+    const room = this.requireRoom(roomId)
+    if (room.members.size >= room.policy.maxMembers) {
+      throw Object.assign(new Error(`room member limit reached (${room.policy.maxMembers})`), { code: 'room-full' })
+    }
+    if (!this.sessionController?.create) {
+      throw Object.assign(new Error('participant sessions are unavailable'), { code: 'unsupported' })
+    }
+    const created = await this.sessionController.create({
+      ...(cwd ? { cwd } : {}),
+      ...(agentPreset ? { agentPreset } : {}),
+    })
+    const sessionId = created?.sessionId
+    if (!sessionId) throw Object.assign(new Error('could not create the participant session'), { code: 'room-participant-failed' })
+    const resolved = await this.sessionController.resolveAgent(sessionId)
+    if (!resolved?.agent) throw Object.assign(new Error('participant agent could not be resolved'), { code: 'room-participant-failed' })
+    const memberId = localMemberId(sessionId)
+    const member = { memberId, role: 'participant', kind: 'local', sessionId, name, agent: resolved.agent }
+    room.members.set(memberId, member)
+    await this.append(room, 'room/member', {
+      roomId: room.roomId,
+      action: 'added',
+      memberId,
+      role: 'participant',
+      name,
+      sessionId,
+    })
+    return this.memberSummary(member)
+  }
+
+  async removeMember({ roomId, memberId, reason = 'removed' } = {}) {
+    const room = this.requireRoom(roomId)
+    const member = room.members.get(memberId)
+    if (!member) throw Object.assign(new Error(`unknown member: ${String(memberId)}`), { code: 'unknown-member' })
+    if (member.role === 'host') throw Object.assign(new Error('the host cannot be removed; close the room instead'), { code: 'forbidden' })
+    room.members.delete(memberId)
+    await this.append(room, 'room/member', { roomId: room.roomId, action: 'removed', memberId, reason })
+    return { roomId: room.roomId, memberId }
+  }
+
+  /**
+   * Send one addressed message. The Host appends it to the canonical log and
+   * wakes only the addressed local members (never the sender).
+   */
+  async send({ roomId, from, to, text } = {}) {
+    const room = this.requireRoom(roomId)
+    const body = typeof text === 'string' ? text.trim() : ''
+    if (body === '') throw Object.assign(new Error('room message needs text'), { code: 'bad-request' })
+    if (body.length > MAX_MESSAGE_CHARS) throw Object.assign(new Error('room message is too long'), { code: 'bad-request' })
+    const recipients = Array.isArray(to) ? to.filter((id) => typeof id === 'string') : []
+    if (recipients.length === 0) throw Object.assign(new Error('room message needs at least one recipient'), { code: 'bad-request' })
+    for (const memberId of recipients) {
+      if (!room.members.has(memberId)) throw Object.assign(new Error(`unknown member: ${memberId}`), { code: 'unknown-member' })
+    }
+    const sender = this.resolveSender(room, from)
+    const message = {
+      id: randomUUID(),
+      roomId: room.roomId,
+      from: sender,
+      to: recipients,
+      text: body,
+      createdAt: this.now(),
+    }
+    room.messages.push(message)
+    await this.append(room, 'room/message', {
+      roomId: room.roomId,
+      messageId: message.id,
+      from: sender,
+      to: recipients,
+      text: body,
+    })
+    const woken = []
+    for (const memberId of recipients) {
+      if (sender.memberId === memberId) continue
+      const member = room.members.get(memberId)
+      if (await this.wake(room, member, message)) woken.push(memberId)
+    }
+    return { messageId: message.id, to: recipients, woken }
+  }
+
+  resolveSender(room, from) {
+    if (from && typeof from === 'object') {
+      if (typeof from.memberId === 'string') {
+        const member = room.members.get(from.memberId)
+        if (!member) throw Object.assign(new Error(`unknown sender member: ${from.memberId}`), { code: 'unknown-member' })
+        return { kind: 'agent', memberId: member.memberId, name: member.name ?? 'agent' }
+      }
+      if (typeof from.sessionId === 'string') {
+        for (const member of room.members.values()) {
+          if (member.sessionId === from.sessionId) {
+            return { kind: 'agent', memberId: member.memberId, name: member.name ?? 'agent' }
+          }
+        }
+        throw Object.assign(new Error(`sender session is not a room member: ${from.sessionId}`), { code: 'unknown-member' })
+      }
+      if (from.kind === 'user') return { kind: 'user', name: 'user' }
+    }
+    return { kind: 'user', name: 'user' }
+  }
+
+  /** Wake one local participant by injecting the addressed message. */
+  async wake(room, member, message) {
+    if (!member?.agent || typeof member.agent.followup !== 'function' || typeof this.createUserMessage !== 'function') return false
+    const senderLabel = message.from.kind === 'user' ? 'user' : (message.from.name ?? 'agent')
+    const text = [
+      `[Fleet Room ${room.roomId}] ${senderLabel} → you:`,
+      message.text,
+      '',
+      `Reply with room_send (roomId="${room.roomId}", to=["${message.from.memberId ?? 'host'}"]) when you have an answer.`,
+    ].join('\n')
+    const userMessage = this.createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } })
+    try {
+      member.agent.followup(userMessage)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async append(room, type, data) {
+    const host = room.members.get(hostMemberId(room.hostSessionId))
+    const session = host?.agent?.session
+    if (session?.append) await session.append(type, data)
+  }
+
+  // --------------------------------------------------------------- room tasks
+
+  async addTask({ roomId, title, owner, dependsOn = [], description = '' } = {}) {
+    const room = this.requireRoom(roomId)
+    if (typeof title !== 'string' || title.trim() === '') throw Object.assign(new Error('task needs a title'), { code: 'bad-request' })
+    const ownerMember = room.members.get(owner)
+    if (!ownerMember) throw Object.assign(new Error(`unknown task owner: ${String(owner)}`), { code: 'unknown-member' })
+    const id = randomUUID()
+    const task = {
+      id,
+      roomId: room.roomId,
+      title: title.trim(),
+      description,
+      owner,
+      status: 'pending',
+      dependsOn: Array.isArray(dependsOn) ? dependsOn : [],
+      readyNotified: false,
+      createdAt: this.now(),
+      updatedAt: this.now(),
+    }
+    room.tasks.set(id, task)
+    await this.append(room, 'room/task', { roomId: room.roomId, action: 'added', task })
+    return task
+  }
+
+  async updateTask({ roomId, id, status, note } = {}) {
+    const room = this.requireRoom(roomId)
+    const task = room.tasks.get(id)
+    if (!task) throw Object.assign(new Error(`unknown task: ${String(id)}`), { code: 'unknown-task' })
+    const allowed = ['pending', 'running', 'done', 'blocked']
+    if (status !== undefined && !allowed.includes(status)) {
+      throw Object.assign(new Error(`invalid task status: ${String(status)}`), { code: 'bad-request' })
+    }
+    if (status !== undefined) task.status = status
+    if (typeof note === 'string' && note !== '') task.note = note
+    task.updatedAt = this.now()
+    await this.append(room, 'room/task', { roomId: room.roomId, action: 'updated', task })
+    let handedOff = []
+    if (status === 'done') handedOff = await this.handOffReady(room)
+    return { task, handedOff }
+  }
+
+  /** Wake owners of pending tasks whose dependencies all completed. */
+  async handOffReady(room) {
+    const ready = []
+    for (const task of room.tasks.values()) {
+      if (task.status !== 'pending' || task.readyNotified) continue
+      if (task.dependsOn.length === 0) continue
+      const depsDone = task.dependsOn.every((dep) => room.tasks.get(dep)?.status === 'done')
+      if (!depsDone) continue
+      task.readyNotified = true
+      task.updatedAt = this.now()
+      const owner = room.members.get(task.owner)
+      const message = {
+        id: randomUUID(),
+        roomId: room.roomId,
+        from: { kind: 'user', name: 'room' },
+        to: [task.owner],
+        text: `任务 "${task.title}" 的前置任务已完成，现在可以开始。`,
+        createdAt: this.now(),
+      }
+      room.messages.push(message)
+      await this.append(room, 'room/message', { roomId: room.roomId, messageId: message.id, from: message.from, to: message.to, text: message.text })
+      const woken = owner ? await this.wake(room, owner, message) : false
+      ready.push({ taskId: task.id, owner: task.owner, woken })
+    }
+    return ready
+  }
+
+  listTasks(roomId) {
+    const room = this.requireRoom(roomId)
+    return [...room.tasks.values()].sort((a, b) => a.createdAt - b.createdAt)
+  }
+
+  // ------------------------------------------------------------------- reads
+
+  messages({ roomId, limit = 50 } = {}) {
+    const room = this.requireRoom(roomId)
+    const items = room.messages.slice(-Math.max(1, Math.min(limit, 200)))
+    return items.map((message) => ({
+      ...message,
+      fromLabel: message.from.kind === 'user' ? 'user' : `${message.from.name ?? 'agent'} (${message.from.memberId ?? '?'})`,
+    }))
+  }
+
+  summary(room) {
+    return {
+      roomId: room.roomId,
+      createdAt: room.createdAt,
+      closed: room.closed,
+      policy: { ...room.policy },
+      members: [...room.members.values()].map((member) => this.memberSummary(member)),
+      messageCount: room.messages.length,
+      tasks: this.listTasks(room.roomId).length,
+    }
+  }
+
+  memberSummary(member) {
+    return {
+      memberId: member.memberId,
+      role: member.role,
+      kind: member.kind,
+      sessionId: member.sessionId,
+      name: member.name,
+    }
+  }
+
+  status(roomId) {
+    return this.summary(this.requireRoom(roomId))
+  }
+
+  /** All open rooms (for cleanup and diagnostics). */
+  openRooms() {
+    return [...this.rooms.keys()]
+  }
+
+  async close({ roomId, reason = 'closed by host' } = {}) {
+    const room = this.requireRoom(roomId)
+    room.closed = true
+    await this.append(room, 'room/closed', { roomId: room.roomId, reason, closedAt: this.now() })
+    this.rooms.delete(room.roomId)
+    return { roomId: room.roomId, closed: true, reason }
+  }
+
+  requireRoom(roomId) {
+    const room = this.rooms.get(roomId)
+    if (!room) throw Object.assign(new Error(`unknown or closed room: ${String(roomId)}`), { code: 'unknown-room' })
+    return room
+  }
+}

package/src/host/tools.js

@@ -22,8 +22,54 @@ function fail(error) {
 }
 
 /** Pure handlers; wrapped into ToolDefinitions by `createFleetToolDefinitions`. */
-export function createFleetHandlers({ node, client = new DirectCallClient({ node }), pairing = null, onPeerHint = null }) {
+export function createFleetHandlers({
+  node,
+  client = new DirectCallClient({ node }),
+  pairing = null,
+  onPeerHint = null,
+  approvals = null,
+  rooms = null,
+}) {
   return {
+    async fleet_approvals() {
+      if (!approvals?.list) return { text: 'Error: [unsupported] the approval inbox is unavailable' }
+      const items = approvals.list()
+      if (items.length === 0) return { text: '(no pending approvals)' }
+      const lines = items.map(
+        (item) =>
+          `- ${item.id} · ${item.fromDeviceId} · ${item.capability}${item.tool ? `/${String(item.tool)}` : ''} · ${item.expiresInMs}ms left · ${item.argsSummary}`,
+      )
+      return { text: lines.join('\n') }
+    },
+
+    async fleet_approve({ id, scope }) {
+      if (!approvals?.approve) return { text: 'Error: [unsupported] the approval inbox is unavailable' }
+      try {
+        const result = approvals.approve(id, { scope: scope ?? 'once' })
+        return { text: `approved ${result.id} (${result.scope})` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async fleet_deny({ id, reason }) {
+      if (!approvals?.deny) return { text: 'Error: [unsupported] the approval inbox is unavailable' }
+      try {
+        const result = approvals.deny(id, reason ?? 'denied by local user')
+        return { text: `denied ${result.id}` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async fleet_simulate_request({ fromDeviceId, capability, tool, reason }) {
+      if (!approvals?.simulate) return { text: 'Error: [unsupported] approval simulation is disabled' }
+      try {
+        return { text: await approvals.simulate({ fromDeviceId, capability, tool, reason }) }
+      } catch (error) {
+        return fail(error)
+      }
+    },
     async fleet_status() {
       if (typeof node.status !== 'function') return { text: 'Error: [unsupported] status is unavailable' }
       return { text: JSON.stringify(node.status(), null, 2) }
@@ -69,6 +115,123 @@ export function createFleetHandlers({ node, client = new DirectCallClient({ node
       }
     },
 
+    async room_create(args, exec) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const room = await rooms.upgradeHost({ agent: exec?.agent, policy: args?.policy ?? {} })
+        return {
+          text: [
+            `room created: ${room.roomId}`,
+            `host: ${room.members.find((member) => member.role === 'host')?.memberId ?? '?'}`,
+            'Add participants with room_add_local (simulation) or the remote invite flow later, then room_send.',
+          ].join('\n'),
+        }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_add_local({ roomId, name, agentPreset, cwd }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const member = await rooms.addLocalParticipant({ roomId, name, agentPreset, cwd })
+        return { text: `participant added: ${member.memberId} (${member.name}) session=${member.sessionId}` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_remove_member({ roomId, memberId, reason }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const result = await rooms.removeMember({ roomId, memberId, reason })
+        return { text: `member removed: ${result.memberId}` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_send({ roomId, to, text }, exec) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const from = { sessionId: exec?.agent?.session?.id }
+        const result = await rooms.send({ roomId, from, to, text })
+        const woken = result.woken.length > 0 ? `, woke ${result.woken.join(', ')}` : ''
+        return { text: `message ${result.messageId} sent to ${result.to.join(', ')}${woken}` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_messages({ roomId, limit }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const items = rooms.messages({ roomId, limit })
+        if (items.length === 0) return { text: '(no messages)' }
+        const lines = items.map(
+          (message) => `- [${new Date(message.createdAt).toISOString()}] ${message.fromLabel} → ${message.to.join(', ')}: ${message.text}`,
+        )
+        return { text: lines.join('\n') }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_status({ roomId }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        return { text: JSON.stringify(rooms.status(roomId), null, 2) }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_task_add({ roomId, title, owner, dependsOn, description }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const task = await rooms.addTask({ roomId, title, owner, dependsOn: dependsOn ?? [], description: description ?? '' })
+        return { text: `task ${task.id} added for ${task.owner}: ${task.title}` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_task_update({ roomId, id, status, note }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const result = await rooms.updateTask({ roomId, id, status, note })
+        const handed = result.handedOff.length > 0 ? `; handed off to ${result.handedOff.map((item) => item.owner).join(', ')}` : ''
+        return { text: `task ${result.task.id} updated (${result.task.status})${handed}` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_task_list({ roomId }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        const tasks = rooms.listTasks(roomId)
+        if (tasks.length === 0) return { text: '(no tasks)' }
+        return {
+          text: tasks
+            .map((task) => `- [${task.status}] ${task.title} (${task.id}) owner=${task.owner}${task.dependsOn.length ? ` deps=${task.dependsOn.join(',')}` : ''}`)
+            .join('\n'),
+        }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
+    async room_close({ roomId, reason }) {
+      if (!rooms) return { text: 'Error: [unsupported] rooms are unavailable' }
+      try {
+        await rooms.close({ roomId, reason: reason ?? 'closed by host' })
+        return { text: `room closed: ${roomId}` }
+      } catch (error) {
+        return fail(error)
+      }
+    },
+
     async fleet_list() {
       const lines = []
       lines.push(`this device: ${node.identity.deviceId} (${node.name})`)
@@ -180,6 +343,155 @@ export function createFleetToolDefinitions({ defineTool, handlers }) {
       output,
       execute: (args) => handlers.fleet_connect(args),
     }),
+    defineTool({
+      name: 'fleet_approvals',
+      description:
+        'List pending approval requests waiting on this device (remote direct calls or delegations whose Tool Policy is `ask`). Approve or deny them with `fleet_approve` / `fleet_deny`. Approvals expire after the configured timeout and fail closed.',
+      parameters: {},
+      output,
+      execute: () => handlers.fleet_approvals(),
+    }),
+    defineTool({
+      name: 'fleet_approve',
+      description:
+        'Approve one pending approval request on this device. `scope: "once"` allows one call; `scope: "ttl"` allows that capability for the configured TTL (default 15 minutes). Permanent grants belong in the device settings, not here.',
+      parameters: {
+        id: { type: 'string', required: true, description: 'Approval request id from `fleet_approvals`.' },
+        scope: { type: 'string', enum: ['once', 'ttl'], description: 'Approval scope; defaults to once.' },
+      },
+      output,
+      execute: (args) => handlers.fleet_approve(args),
+    }),
+    defineTool({
+      name: 'fleet_deny',
+      description: 'Deny one pending approval request on this device.',
+      parameters: {
+        id: { type: 'string', required: true, description: 'Approval request id from `fleet_approvals`.' },
+        reason: { type: 'string', description: 'Optional reason returned to the caller.' },
+      },
+      output,
+      execute: (args) => handlers.fleet_deny(args),
+    }),
+    defineTool({
+      name: 'fleet_simulate_request',
+      description:
+        'Development helper (only when approval simulation is enabled): create a fake pending approval request so the inbox flow can be exercised without a second device. It does not execute anything.',
+      parameters: {
+        fromDeviceId: { type: 'string', description: 'Pretend caller device id.' },
+        capability: { type: 'string', description: 'Capability name, e.g. run.' },
+        tool: { type: 'string', description: 'Optional tool name.' },
+        reason: { type: 'string', description: 'Optional reason shown in the request.' },
+      },
+      output,
+      execute: (args) => handlers.fleet_simulate_request(args),
+    }),
+    defineTool({
+      name: 'room_create',
+      description:
+        'Upgrade the current session into a Room Host (local logic layer) so multiple agents can collaborate with shared messages and a shared task board. Add participants with `room_add_local` (simulation) or the future remote invite flow. Only do this when the user explicitly wants multi-agent collaboration, not for a one-off remote tool call.',
+      parameters: {
+        policy: { type: 'object', additionalProperties: true, description: 'Optional room policy overrides (invite/join/maxMembers/boardWrite/remove).' },
+      },
+      output,
+      execute: (args, exec) => handlers.room_create(args, exec),
+    }),
+    defineTool({
+      name: 'room_add_local',
+      description:
+        'Simulation helper: add a real local DSH agent as a Room participant (its own session). Use it to exercise addressing/wake/board logic in one DSH before the remote participant transport exists.',
+      parameters: {
+        roomId: { type: 'string', required: true, description: 'Room id returned by room_create.' },
+        name: { type: 'string', description: 'Participant display name.' },
+        agentPreset: { type: 'string', description: 'Optional agent preset id for the participant session.' },
+        cwd: { type: 'string', description: 'Optional working directory for the participant session.' },
+      },
+      output,
+      execute: (args) => handlers.room_add_local(args),
+    }),
+    defineTool({
+      name: 'room_remove_member',
+      description: 'Remove a participant from a Room (the host cannot be removed; close the room instead).',
+      parameters: {
+        roomId: { type: 'string', required: true, description: 'Room id.' },
+        memberId: { type: 'string', required: true, description: 'Member id from room_status.' },
+        reason: { type: 'string', description: 'Optional reason recorded in the room log.' },
+      },
+      output,
+      execute: (args) => handlers.room_remove_member(args),
+    }),
+    defineTool({
+      name: 'room_send',
+      description:
+        'Send one addressed Room message as the calling agent. The host appends it to the canonical room log and wakes only the addressed participants; unaddressed members do not run. To say different things to different members, send separate messages.',
+      parameters: {
+        roomId: { type: 'string', required: true, description: 'Room id.' },
+        to: { type: 'array', items: { type: 'string' }, required: true, description: 'Recipient member ids.' },
+        text: { type: 'string', required: true, description: 'Message body.' },
+      },
+      output,
+      execute: (args, exec) => handlers.room_send(args, exec),
+    }),
+    defineTool({
+      name: 'room_messages',
+      description: 'Read the Room transcript (the user-visible complete conversation, including agent-to-agent messages).',
+      parameters: {
+        roomId: { type: 'string', required: true, description: 'Room id.' },
+        limit: { type: 'number', description: 'Maximum recent messages to return (default 50).' },
+      },
+      output,
+      execute: (args) => handlers.room_messages(args),
+    }),
+    defineTool({
+      name: 'room_status',
+      description: 'Show one Room\'s members, policy, message count and task count.',
+      parameters: { roomId: { type: 'string', required: true, description: 'Room id.' } },
+      output,
+      execute: (args) => handlers.room_status(args),
+    }),
+    defineTool({
+      name: 'room_task_add',
+      description:
+        'Add one shared Room Board task. Use dependsOn to express serial handoff: when all dependencies are done, the owner is woken with a "ready" message. Parallel tasks have no dependencies and do not block each other.',
+      parameters: {
+        roomId: { type: 'string', required: true, description: 'Room id.' },
+        title: { type: 'string', required: true, description: 'Task title.' },
+        owner: { type: 'string', required: true, description: 'Owner member id.' },
+        dependsOn: { type: 'array', items: { type: 'string' }, description: 'Task ids that must complete first.' },
+        description: { type: 'string', description: 'Optional task detail.' },
+      },
+      output,
+      execute: (args) => handlers.room_task_add(args),
+    }),
+    defineTool({
+      name: 'room_task_update',
+      description:
+        'Update one Room Board task. Marking it done triggers serial handoff: owners of pending dependent tasks are woken. Keep status/steps current when starting and finishing your block.',
+      parameters: {
+        roomId: { type: 'string', required: true, description: 'Room id.' },
+        id: { type: 'string', required: true, description: 'Task id.' },
+        status: { type: 'string', enum: ['pending', 'running', 'done', 'blocked'], description: 'New status.' },
+        note: { type: 'string', description: 'Optional progress note.' },
+      },
+      output,
+      execute: (args) => handlers.room_task_update(args),
+    }),
+    defineTool({
+      name: 'room_task_list',
+      description: 'List the shared Room Board tasks with status, owner and dependencies.',
+      parameters: { roomId: { type: 'string', required: true, description: 'Room id.' } },
+      output,
+      execute: (args) => handlers.room_task_list(args),
+    }),
+    defineTool({
+      name: 'room_close',
+      description: 'Close a Room (archives its canonical log); participants are no longer woken afterwards.',
+      parameters: {
+        roomId: { type: 'string', required: true, description: 'Room id.' },
+        reason: { type: 'string', description: 'Optional close reason.' },
+      },
+      output,
+      execute: (args) => handlers.room_close(args),
+    }),
     defineTool({
       name: 'fleet_invite',
       description:

package/src/plugin/index.js

@@ -14,6 +14,8 @@ 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 { ApprovalInbox } from '../host/approval-inbox.js'
+import { RoomService } from '../host/room-service.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'
@@ -76,6 +78,13 @@ export const Config = Schema.object({
     .description('Direct-call Tool Policy owned by this device (ADR-0004/ADR-0019).'),
   promptSection: Schema.boolean().default(true).description('Render the one-sentence Fleet nudge when the Fleet has members.'),
   autoApproveAsk: Schema.boolean().default(false).description('Testing only: auto-approve every local approval request.'),
+  approvals: Schema.object({
+    ttlMs: Schema.number().default(60000),
+    maxPending: Schema.number().default(50),
+    simulation: Schema.boolean().default(false),
+  })
+    .default({ ttlMs: 60000, maxPending: 50, simulation: false })
+    .description('Local approval inbox (ADR-0020). `simulation` exposes fleet_simulate_request for local testing.'),
 })
 
 function packageVersion() {
@@ -157,6 +166,37 @@ export function apply(ctx, config) {
   const sessionController = service('sessionController')
   const fs = service('fs')
   const subagents = service('subagents')
+  const inbox = new ApprovalInbox({
+    ttlMs: config.approvals?.ttlMs ?? 60_000,
+    maxPending: config.approvals?.maxPending ?? 50,
+  })
+  inbox.on('request', (request) => logger.info?.(`[device-fleet] approval requested by ${request.fromDeviceId}: ${request.capability}/${String(request.tool ?? '')}`))
+  const approvalsApi = {
+    list: () => inbox.list(),
+    approve: (id, options) => inbox.approve(id, options),
+    deny: (id, reason) => inbox.deny(id, reason),
+    simulate: config.approvals?.simulation
+      ? async ({ fromDeviceId, capability, tool, reason }) => {
+          const promise = inbox.request({
+            fromDeviceId: fromDeviceId ?? 'simulated-device',
+            capability: capability ?? 'run',
+            tool: tool ?? null,
+            reason: reason ?? 'simulated approval request',
+            args: {},
+          })
+          const summary = inbox.list().at(-1)
+          // Keep the promise from becoming an unhandled rejection when the
+          // request expires without an answer; the demo only inspects the inbox.
+          promise.catch(() => {})
+          return `simulated approval request ${summary?.id ?? '?'} created; use fleet_approvals / fleet_approve / fleet_deny`
+        }
+      : null,
+  }
+  const requestApproval = config.autoApproveAsk
+    ? async () => ({ approved: true, scope: 'once' })
+    : async (request) => inbox.request(request)
+
+  const rooms = new RoomService({ sessionController, createUserMessage })
   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 })
@@ -173,12 +213,7 @@ export function apply(ctx, config) {
           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
-              },
+          requestApproval,
         })
       : null
 
@@ -195,12 +230,7 @@ export function apply(ctx, config) {
         shellTool: config.execution?.shellTool ?? DEFAULT_SHELL_TOOL,
         approvalTimeoutMs: config.execution?.approvalTimeoutMs ?? 60_000,
         delegation,
-        requestApproval: config.autoApproveAsk
-          ? async () => true
-          : async (request) => {
-              logger.info?.(`[device-fleet] approval required from ${request.fromDeviceId} for ${request.capability}/${String(request.tool)} (no approval UI yet)`)
-              return false
-            },
+        requestApproval,
       })
     : null
 
@@ -279,6 +309,8 @@ export function apply(ctx, config) {
         logger.warn?.(`[device-fleet] cannot persist peer hint: ${String(error?.message ?? error)}`)
       }
     },
+    approvals: approvalsApi,
+    rooms,
   })
   const definitions = createFleetToolDefinitions({ defineTool, handlers })
   const wrapped = withManual(definitions.map((definition) => ({ ...definition, execute: safe(definition.execute) })))
@@ -328,6 +360,10 @@ export function apply(ctx, config) {
   })
 
   ctx.effect(() => () => {
+    inbox.close()
+    for (const roomId of rooms.openRooms()) {
+      void rooms.close({ roomId, reason: 'plugin unloaded' }).catch(() => {})
+    }
     void node.close()
   })