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

package/src/host/runtime-config.js

@@ -0,0 +1,192 @@
+// Runtime configuration (ADR-0025): the profile patch stays the base layer,
+// while `$DSH_HOME/device-fleet/config-overrides.json` holds UI edits. Applying
+// a patch merges it, persists it and runs the registered live-apply handlers so
+// no plugin/DSH restart is required.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+const READONLY_FIELDS = ['dataDir']
+const CAPABILITY_MODES = ['auto', 'ask', 'deny']
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+export function deepMerge(base, patch) {
+  if (!isPlainObject(patch)) return patch
+  const result = isPlainObject(base) ? { ...base } : {}
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === undefined) continue
+    if (Array.isArray(value)) result[key] = value.map((item) => (isPlainObject(item) ? deepMerge({}, item) : item))
+    else if (isPlainObject(value)) result[key] = deepMerge(result[key], value)
+    else result[key] = value
+  }
+  return result
+}
+
+function readJson(file) {
+  if (!file || !existsSync(file)) return null
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function requirePositiveInteger(value, name, { min = 1, max = Number.MAX_SAFE_INTEGER } = {}) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw Object.assign(new Error(`${name} must be an integer between ${min} and ${max}`), { code: 'bad-request' })
+  }
+  return value
+}
+
+function stringList(value, name) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+    throw Object.assign(new Error(`${name} must be an array of strings`), { code: 'bad-request' })
+  }
+  return value.map((item) => item.trim()).filter((item) => item !== '')
+}
+
+function optionalString(value, name) {
+  if (value === undefined || value === null) return ''
+  if (typeof value !== 'string') throw Object.assign(new Error(`${name} must be a string`), { code: 'bad-request' })
+  return value.trim()
+}
+
+/**
+ * Validate and clean a UI patch. Only known fields survive; unknown keys are
+ * dropped instead of leaking arbitrary objects into the effective config.
+ */
+export function sanitizeConfigPatch(patch) {
+  if (!isPlainObject(patch)) throw Object.assign(new Error('config patch must be an object'), { code: 'bad-request' })
+  const clean = {}
+  if (patch.deviceName !== undefined) {
+    const name = optionalString(patch.deviceName, 'deviceName')
+    if (name !== '') clean.deviceName = name.slice(0, 80)
+  }
+  if (patch.promptSection !== undefined) clean.promptSection = patch.promptSection === true
+  if (patch.autoApproveAsk !== undefined) clean.autoApproveAsk = patch.autoApproveAsk === true
+  if (patch.discovery !== undefined) clean.discovery = patch.discovery === true
+  if (patch.dataDir !== undefined) {
+    throw Object.assign(new Error('dataDir cannot be changed at runtime'), { code: 'readonly' })
+  }
+  if (patch.direct !== undefined) {
+    if (!isPlainObject(patch.direct)) throw Object.assign(new Error('direct must be an object'), { code: 'bad-request' })
+    clean.direct = {
+      host: optionalString(patch.direct.host, 'direct.host') || '0.0.0.0',
+      port: requirePositiveInteger(Number(patch.direct.port ?? 0), 'direct.port', { min: 0, max: 65535 }),
+    }
+  }
+  if (patch.relay !== undefined) {
+    if (patch.relay === null) clean.relay = null
+    else if (isPlainObject(patch.relay)) {
+      clean.relay = {
+        host: optionalString(patch.relay.host, 'relay.host'),
+        port: requirePositiveInteger(Number(patch.relay.port ?? 0), 'relay.port', { min: 0, max: 65535 }),
+        dataPort: requirePositiveInteger(Number(patch.relay.dataPort ?? 0), 'relay.dataPort', { min: 0, max: 65535 }),
+        reconnect: patch.relay.reconnect !== false,
+      }
+      if (clean.relay.host === '' || clean.relay.port === 0) clean.relay = null
+    } else {
+      throw Object.assign(new Error('relay must be an object or null'), { code: 'bad-request' })
+    }
+  }
+  if (patch.execution !== undefined) {
+    if (!isPlainObject(patch.execution)) throw Object.assign(new Error('execution must be an object'), { code: 'bad-request' })
+    const execution = {}
+    if (patch.execution.cwd !== undefined) execution.cwd = optionalString(patch.execution.cwd, 'execution.cwd')
+    if (patch.execution.agentPreset !== undefined) execution.agentPreset = optionalString(patch.execution.agentPreset, 'execution.agentPreset')
+    if (patch.execution.shellTool !== undefined) execution.shellTool = optionalString(patch.execution.shellTool, 'execution.shellTool')
+    if (patch.execution.subagentProvider !== undefined) execution.subagentProvider = optionalString(patch.execution.subagentProvider, 'execution.subagentProvider')
+    if (patch.execution.approvalTimeoutMs !== undefined) {
+      execution.approvalTimeoutMs = requirePositiveInteger(Number(patch.execution.approvalTimeoutMs), 'execution.approvalTimeoutMs', { min: 1000 })
+    }
+    if (patch.execution.delegateTimeoutMs !== undefined) {
+      execution.delegateTimeoutMs = requirePositiveInteger(Number(patch.execution.delegateTimeoutMs), 'execution.delegateTimeoutMs', { min: 1000 })
+    }
+    clean.execution = execution
+  }
+  if (patch.policy !== undefined) {
+    if (!isPlainObject(patch.policy)) throw Object.assign(new Error('policy must be an object'), { code: 'bad-request' })
+    const policy = {}
+    if (patch.policy.allowedRoots !== undefined) policy.allowedRoots = stringList(patch.policy.allowedRoots, 'policy.allowedRoots')
+    if (patch.policy.allowedTools !== undefined) policy.allowedTools = stringList(patch.policy.allowedTools, 'policy.allowedTools')
+    if (patch.policy.approvalTtlMs !== undefined) {
+      policy.approvalTtlMs = requirePositiveInteger(Number(patch.policy.approvalTtlMs), 'policy.approvalTtlMs', { min: 1000 })
+    }
+    if (patch.policy.capabilities !== undefined) {
+      if (!isPlainObject(patch.policy.capabilities)) throw Object.assign(new Error('policy.capabilities must be an object'), { code: 'bad-request' })
+      const capabilities = {}
+      for (const [key, value] of Object.entries(patch.policy.capabilities)) {
+        if (!CAPABILITY_MODES.includes(value)) {
+          throw Object.assign(new Error(`policy.capabilities.${key} must be auto|ask|deny`), { code: 'bad-request' })
+        }
+        capabilities[key] = value
+      }
+      policy.capabilities = capabilities
+    }
+    clean.policy = policy
+  }
+  if (patch.approvals !== undefined) {
+    if (!isPlainObject(patch.approvals)) throw Object.assign(new Error('approvals must be an object'), { code: 'bad-request' })
+    const approvals = {}
+    if (patch.approvals.ttlMs !== undefined) approvals.ttlMs = requirePositiveInteger(Number(patch.approvals.ttlMs), 'approvals.ttlMs', { min: 1000 })
+    if (patch.approvals.maxPending !== undefined) approvals.maxPending = requirePositiveInteger(Number(patch.approvals.maxPending), 'approvals.maxPending', { min: 1 })
+    if (patch.approvals.simulation !== undefined) approvals.simulation = patch.approvals.simulation === true
+    clean.approvals = approvals
+  }
+  return clean
+}
+
+export class RuntimeConfig {
+  /**
+   * @param {object} options
+   * @param {object} options.base profile (Cordis) config
+   * @param {string} [options.overridesFile] JSON file edited from the UI
+   */
+  constructor({ base = {}, overridesFile = null } = {}) {
+    this.base = base
+    this.overridesFile = overridesFile
+    this.overrides = readJson(overridesFile) ?? {}
+    this.current = deepMerge(this.base, this.overrides)
+    this.applyHandlers = []
+    this.updating = Promise.resolve()
+  }
+
+  onChange(handler) {
+    this.applyHandlers.push(handler)
+  }
+
+  persist() {
+    if (!this.overridesFile) return
+    try {
+      mkdirSync(dirname(this.overridesFile), { recursive: true })
+      const temporary = `${this.overridesFile}.tmp`
+      writeFileSync(temporary, JSON.stringify(this.overrides, null, 2), 'utf8')
+      renameSync(temporary, this.overridesFile)
+    } catch {
+      /* overrides are best effort; the in-memory config is still applied */
+    }
+  }
+
+  /** Merge, persist and live-apply one patch. Returns the effective config. */
+  update(patch) {
+    const clean = sanitizeConfigPatch(patch)
+    return this.updating.then(async () => {
+      const previous = this.current
+      this.overrides = deepMerge(this.overrides, clean)
+      this.current = deepMerge(this.base, this.overrides)
+      this.persist()
+      for (const handler of this.applyHandlers) await handler(this.current, previous)
+      return this.current
+    })
+  }
+
+  snapshot() {
+    return {
+      config: this.current,
+      overrides: this.overrides,
+      readonly: READONLY_FIELDS,
+    }
+  }
+}

package/src/host/store.js

@@ -50,6 +50,7 @@ export function loadState({ dshHome, dataDir, name = 'device' } = {}) {
 
   const roster = readJson(path.join(dir, 'roster.json'), [])
   const config = readJson(path.join(dir, 'config.json'), {})
+  const peerHints = readJson(path.join(dir, 'peer-hints.json'), [])
   let enrollment = readJson(path.join(dir, 'enrollment.json'), null)
   let pendingEnrollment = readJson(path.join(dir, 'enrollment.pending.json'), null)
 
@@ -75,7 +76,32 @@ export function loadState({ dshHome, dataDir, name = 'device' } = {}) {
     }
   }
 
-  return { dataDir: dir, identity, fleet, roster: Array.isArray(roster) ? roster : [], config, enrollment, pendingEnrollment, createdFleet }
+  return {
+    dataDir: dir,
+    identity,
+    fleet,
+    roster: Array.isArray(roster) ? roster : [],
+    config,
+    enrollment,
+    pendingEnrollment,
+    peerHints: Array.isArray(peerHints) ? peerHints : [],
+    createdFleet,
+  }
+}
+
+/** Persist one manually supplied peer address (from fleet_connect) for reconnects. */
+export function savePeerHint(state, hint) {
+  if (!hint || typeof hint.host !== 'string' || !Number.isInteger(hint.port) || hint.port <= 0) return
+  const entry = {
+    host: hint.host,
+    port: hint.port,
+    ...(typeof hint.deviceId === 'string' ? { deviceId: hint.deviceId } : {}),
+  }
+  const hints = Array.isArray(state.peerHints) ? state.peerHints : []
+  const exists = hints.some((item) => item.host === entry.host && item.port === entry.port && item.deviceId === entry.deviceId)
+  if (!exists) hints.push(entry)
+  state.peerHints = hints
+  writeJsonAtomic(path.join(state.dataDir, 'peer-hints.json'), hints)
 }
 
 /** Queue an invite for the next plugin load (the running node keeps its fleet). */

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: [],
@@ -13,7 +13,8 @@ export const DEFAULT_POLICY = Object.freeze({
     grep: 'auto',
     fetch: 'auto',
     run: 'ask',
-    tool: 'deny',
+    tool: 'auto',
+    delegate: 'ask',
   },
   allowedTools: [],
   approvalTtlMs: 15 * 60 * 1000,
@@ -76,15 +77,17 @@ export class ToolPolicy {
       return { decision: 'allow', reason: 'run is allowed by policy', key: grantKey, capability: capabilityName }
     }
     if (capabilityName === 'tool') {
-      if (!this.config.allowedTools.includes(String(tool))) {
-        return {
-          decision: 'deny',
-          reason: `tool ${String(tool)} is not in the allowed tools list`,
-          key: grantKey,
-          capability: capabilityName,
-        }
+      // Raw tools follow the normal DSH tool pipeline on this device: the
+      // target Session's tool pre-execute policy and approval seam decide
+      // whether a call runs, asks, or is rejected. `deny` disables raw tools
+      // entirely; `ask` adds the plugin-level approval in front of DSH.
+      if (mode === 'deny') {
+        return { decision: 'deny', reason: 'raw tool calls are disabled by policy', key: grantKey, capability: capabilityName }
+      }
+      if (mode === 'ask') {
+        return { decision: 'ask', reason: 'raw tool call requires local approval', key: grantKey, capability: capabilityName }
       }
-      return { decision: 'allow', reason: 'tool is allowlisted', key: grantKey, capability: capabilityName }
+      return { decision: 'allow', reason: 'raw tool call follows the DSH tool pipeline', key: grantKey, capability: capabilityName }
     }
     if (mode === 'allow') return { decision: 'allow', reason: 'capability is allowed by policy', key: grantKey, capability: capabilityName }
     if (mode === 'auto') return { decision: 'allow', reason: 'capability is auto-approved', key: grantKey, capability: capabilityName }

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 }) {
+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) }
@@ -34,6 +80,7 @@ export function createFleetHandlers({ node, client = new DirectCallClient({ node
       try {
         node.addPeerHint?.({ host, port })
         const peer = await node.connectAddress(host, port)
+        await onPeerHint?.({ host, port })
         return { text: `connected to ${peer.deviceId} (${peer.name ?? 'device'}) at ${host}:${port}` }
       } catch (error) {
         return fail(error)
@@ -68,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})`)
@@ -109,6 +273,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 }
@@ -165,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:
@@ -211,6 +538,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: