ds-bot 0.1.3 → 0.1.5

package/index.js

@@ -1,7 +1,6 @@
 // DS Bot: a team of long-lived Bots on top of ordinary dsh root Sessions.
 // Every Bot is one root Session; the roster, rooms, and the bot-to-bot exchange log live
 // in one JSON file under DSH_HOME so they survive restarts without new Session event types.
-import { homedir } from 'node:os'
 import { join } from 'node:path'
 import * as diagnostics from './src/host/diagnostics.js'
 import * as store from './src/host/store.js'
@@ -10,6 +9,7 @@ import * as permissions from './src/host/permissions.js'
 import * as turns from './src/host/turns.js'
 import * as delivery from './src/host/delivery.js'
 import * as roster from './src/host/roster.js'
+import * as folders from './src/host/folders.js'
 import * as agents from './src/host/agents.js'
 import * as prompt from './src/host/prompt.js'
 import * as timeContext from './src/host/time-context.js'
@@ -17,12 +17,14 @@ import * as tools from './src/host/tools.js'
 import * as chatIndex from './src/host/chat-index.js'
 import * as groups from './src/host/groups.js'
 import * as approvals from './src/host/approvals.js'
+import * as resume from './src/host/resume.js'
 import * as memory from './src/host/memory.js'
 import * as parts from './src/host/parts.js'
 import * as images from './src/host/images.js'
 import * as browser from './src/host/browser.js'
 import * as secrets from './src/host/secrets.js'
 import * as connectors from './src/host/connectors.js'
+import * as capabilities from './src/host/capabilities.js'
 import * as schedules from './src/host/schedules.js'
 import * as usage from './src/host/usage.js'
 import * as update from './src/host/update.js'
@@ -38,13 +40,19 @@ export const inject = ['llm', 'tools', 'systemPrompt', 'sessionController', 'ses
 // the functions other modules call; they call them through `rt` at run time, never during
 // install. Listeners run and tools are listed in registration order, so this order holds:
 // usage meters model requests after every listener that rewrites them.
-const MODULES = [diagnostics, store, models, permissions, turns, delivery, roster, agents, prompt, timeContext, tools, chatIndex, groups, approvals, memory, parts, images, secrets, connectors, schedules, browser, usage, update, dshUpdate, channel]
+const MODULES = [diagnostics, store, models, permissions, turns, delivery, roster, folders, agents, prompt, timeContext, tools, chatIndex, groups, approvals, resume, memory, parts, images, secrets, connectors, capabilities, schedules, browser, usage, update, dshUpdate, channel]
 
 export function apply(ctx, config = {}) {
-  const home = config.home ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'bot')
+  createRuntime(ctx, config)
+}
+
+export function createRuntime(ctx, config = {}) {
+  const dshHome = folders.dshHomeOf(process.env.DSH_HOME)
+  const home = config.home ?? join(dshHome, 'bot')
   const rt = {
     ctx,
     config,
+    dshHome,
     home,
     statePath: join(home, 'state.json'),
     defaults: {
@@ -53,4 +61,5 @@ export function apply(ctx, config = {}) {
     },
   }
   for (const module of MODULES) module.install(rt)
+  return rt
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ds-bot",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "DS Bot: a team of long-lived Bots for DeepSeek Harness, with Main Bots, Bot-to-Bot messages and group chats",
   "keywords": [
     "dsh-plugin",

package/src/host/approvals.js

@@ -29,11 +29,17 @@ export function install(rt) {
       at: Date.now(),
     }
     pending.set(id, entry)
-    if (owner === undefined) return Promise.resolve(next()).finally(() => pending.delete(id))
+    rt.noteApproval?.(sessionId, { tool: entry.tool, reason: entry.reason.slice(0, 200) })
+    const settled = () => {
+      pending.delete(id)
+      rt.noteApproval?.(sessionId, undefined)
+    }
+    if (owner === undefined) return Promise.resolve(next()).finally(settled)
     rt.yieldRoomTurn?.(sessionId)
     return new Promise((resolve) => {
       entry.answer = (outcome) => {
-        if (!pending.delete(id)) return
+        if (!pending.has(id)) return
+        settled()
         resolve(outcome)
       }
       if (request.signal?.aborted) entry.answer('cancelled')

package/src/host/capabilities.js

@@ -0,0 +1,521 @@
+import { createHash } from 'node:crypto'
+
+const MCP_CLIENT = '@deepseek-ai/dsh-mcp-client'
+const NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/
+const SECRET_REFERENCE = /\$DSH_SECRET_([A-Z][A-Z0-9_]*)/g
+const ENSURE_TIMEOUT_MS = 15_000
+
+export function validateCapabilityName(value) {
+  const name = String(value ?? '').trim()
+  if (name.length > 32 || !NAME.test(name) || name === 'github') {
+    throw new Error('Use a capability name with lowercase letters, digits, and single hyphens; "github" is reserved.')
+  }
+  return name
+}
+
+export function expandCapabilityNames(capabilities, library) {
+  const expanded = new Set()
+  for (const name of capabilities ?? []) {
+    const item = library[name]
+    if (!item) throw new Error(`No capability named ${name}.`)
+    if (item.kind === 'pack') {
+      for (const childName of item.items ?? []) {
+        const child = library[childName]
+        if (!child || !['mcp', 'skill'].includes(child.kind)) throw new Error(`Pack ${name} refers to an unavailable capability ${childName}.`)
+        expanded.add(childName)
+      }
+    } else if (item.kind === 'mcp' || item.kind === 'skill') {
+      expanded.add(name)
+    } else {
+      throw new Error(`Capability ${name} has an unknown kind.`)
+    }
+  }
+  return expanded
+}
+
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b)
+const strings = value => {
+  if (value === undefined) return []
+  if (!Array.isArray(value) || value.some(item => typeof item !== 'string')) throw new Error('Arguments must be a list of text values.')
+  return [...value]
+}
+const stringMap = (value, label) => {
+  if (value === undefined) return {}
+  if (value === null || typeof value !== 'object' || Array.isArray(value)
+    || Object.values(value).some(item => typeof item !== 'string')) throw new Error(`${label} must contain text values.`)
+  return Object.fromEntries(Object.entries(value))
+}
+
+export function install(rt) {
+  const { ctx, state } = rt
+  const agents = new Map()
+  // Mounted fibers live in each Agent's own context, so they outlive this plugin unless
+  // its cleanup disposes them; a strong map keeps them reachable for that.
+  const mounts = new Map()
+  // One reconcile chain per Agent: a slow MCP server holds up only its own Agent.
+  const chains = new WeakMap()
+  const queued = new WeakSet()
+  const sessionStatuses = new Map()
+  let pluginPromise
+  let scheduled = null
+  let loadingSecrets = 0
+  let stopped = false
+
+  const library = () => state.capabilities.items
+  const ensureLibrary = () => {
+    state.capabilities ??= { items: {} }
+    state.capabilities.items ??= {}
+    return library()
+  }
+  const writeCheck = () => {
+    const readOnly = rt.readOnly()
+    if (readOnly !== undefined) throw new Error(readOnly)
+  }
+  const allowedToEdit = (item, botId) => rt.isMain(botId) || item.createdBy === botId
+  const usedByOthers = (name, botId) => Object.values(state.bots).some(bot => bot.id !== botId
+    && (bot.capabilities ?? []).some(attached => attached === name
+      || (library()[attached]?.kind === 'pack' && (library()[attached].items ?? []).includes(name))))
+  // A creator that is not a Main Bot could otherwise rewrite what a Main Bot runs.
+  const editCheck = (item, botId, verb) => {
+    if (!allowedToEdit(item, botId)) throw new Error(`Only ${item.createdBy ? 'its creator or a Main Bot' : 'a Main Bot'} can ${verb} ${item.name}.`)
+    if (!rt.isMain(botId) && usedByOthers(item.name, botId)) throw new Error(`Another Bot uses ${item.name}, so only a Main Bot can ${verb} it.`)
+  }
+  const itemInput = (body, { botId, ui }) => {
+    const name = validateCapabilityName(body.name)
+    const kind = body.kind
+    if (!['mcp', 'skill', 'pack'].includes(kind)) throw new Error('Choose an MCP server, skill, or pack.')
+    const items = ensureLibrary()
+    const previous = items[name]
+    if (previous && !ui) editCheck(previous, botId, 'change')
+    if (previous && previous.kind !== kind) throw new Error('A capability cannot change its kind. Delete it and save a new one.')
+    const now = Date.now()
+    const item = {
+      name,
+      kind,
+      description: String(body.description ?? '').trim().slice(0, 2000),
+      createdBy: previous?.createdBy ?? (ui ? null : botId),
+      createdAt: previous?.createdAt ?? now,
+      updatedAt: now,
+    }
+    if (kind === 'mcp') {
+      const transport = body.transport === 'streamable-http' ? 'streamable-http' : 'stdio'
+      if (transport === 'stdio') {
+        const command = String(body.command ?? '').trim()
+        if (command === '') throw new Error('Enter a command for the MCP server.')
+        const args = strings(body.args)
+        const env = stringMap(body.env, 'Environment variables')
+        const changed = !previous || previous.kind !== 'mcp' || previous.transport !== 'stdio'
+          || previous.command !== command || !same(previous.args ?? [], args) || !same(previous.env ?? {}, env)
+        Object.assign(item, { transport, command, args, env, approved: ui ? true : changed ? false : previous.approved === true })
+      } else {
+        const url = String(body.url ?? '').trim()
+        try {
+          const parsed = new URL(url)
+          if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') throw new Error()
+        } catch { throw new Error('Enter a valid HTTP or HTTPS URL.') }
+        Object.assign(item, { transport, url, headers: stringMap(body.headers, 'Headers'), approved: true })
+      }
+    } else if (kind === 'skill') {
+      item.content = String(body.content ?? '').trim()
+    } else {
+      const names = [...new Set(strings(body.items))]
+      for (const childName of names) {
+        const child = items[childName]
+        if (!child || !['mcp', 'skill'].includes(child.kind)) throw new Error(`Packs can include only saved MCP servers and skills. ${childName} is not one.`)
+      }
+      item.items = names
+    }
+    items[name] = item
+    return item
+  }
+  const capabilitySave = async (body, options = {}) => {
+    await rt.load()
+    writeCheck()
+    const item = itemInput(body ?? {}, options)
+    await rt.save()
+    return item
+  }
+  const capabilityDelete = async (name, { botId, ui } = {}) => {
+    await rt.load()
+    writeCheck()
+    const items = ensureLibrary()
+    const item = items[String(name ?? '')]
+    if (!item) throw new Error(`No capability named ${name}.`)
+    if (!ui) editCheck(item, botId, 'delete')
+    delete items[item.name]
+    for (const pack of Object.values(items)) if (pack.kind === 'pack') pack.items = (pack.items ?? []).filter(child => child !== item.name)
+    for (const bot of Object.values(state.bots)) bot.capabilities = (bot.capabilities ?? []).filter(attached => attached !== item.name)
+    await rt.save()
+    return true
+  }
+  const changeAttachment = async (endpoint, { name, bot: targetRef }, callerId) => {
+    await rt.load()
+    writeCheck()
+    const caller = rt.botOf(callerId)
+    if (!caller) throw new Error('Only Bots on the team can change capabilities.')
+    const target = targetRef ? rt.findBot(targetRef) : caller
+    if (!target) throw new Error(`No Bot named ${targetRef}.`)
+    if (target.id !== caller.id && !rt.isMain(callerId)) throw new Error('Only a Main Bot can change another Bot’s capabilities.')
+    const item = ensureLibrary()[String(name ?? '')]
+    if (!item) throw new Error(`No capability named ${name}.`)
+    await setAttached(target, item.name, endpoint === 'attach')
+    return { bot: target.name, attached: endpoint === 'attach' }
+  }
+  // Changes one name against the saved list, so two quick changes both land.
+  const setAttached = async (bot, name, attached) => {
+    bot.capabilities ??= []
+    const wasEmpty = bot.capabilities.length === 0
+    if (attached && !bot.capabilities.includes(name)) bot.capabilities.push(name)
+    if (!attached) bot.capabilities = bot.capabilities.filter(entry => entry !== name)
+    await rt.save()
+    if (wasEmpty && bot.capabilities.length > 0) {
+      await trackBotAgents(bot)
+      void scheduleReconcile()
+    }
+    return bot.capabilities
+  }
+
+  const statusSet = (botId, itemName, sessionId, status) => {
+    let byItem = sessionStatuses.get(botId)
+    if (!byItem) sessionStatuses.set(botId, byItem = new Map())
+    let bySession = byItem.get(itemName)
+    if (!bySession) byItem.set(itemName, bySession = new Map())
+    bySession.set(sessionId, status)
+  }
+  const clearStatus = (botId, itemName, sessionId) => {
+    const byItem = sessionStatuses.get(botId)
+    const bySession = byItem?.get(itemName)
+    bySession?.delete(sessionId)
+    if (bySession?.size === 0) byItem.delete(itemName)
+    if (byItem?.size === 0) sessionStatuses.delete(botId)
+  }
+  const clearSession = sessionId => {
+    for (const [botId, byItem] of sessionStatuses) {
+      for (const [name, bySession] of byItem) {
+        bySession.delete(sessionId)
+        if (bySession.size === 0) byItem.delete(name)
+      }
+      if (byItem.size === 0) sessionStatuses.delete(botId)
+    }
+  }
+  const statusFor = (botId, name) => {
+    const values = [...(sessionStatuses.get(botId)?.get(name)?.values() ?? [])]
+    if (values.some(status => status.state === 'error')) return values.find(status => status.state === 'error')
+    if (values.some(status => status.state === 'needs-approval')) return { state: 'needs-approval' }
+    if (values.some(status => status.state === 'connecting')) return { state: 'connecting' }
+    return values.length > 0 ? { state: 'ready' } : undefined
+  }
+  const capabilityStatusesView = () => {
+    const result = {}
+    for (const bot of Object.values(state.bots)) {
+      const statuses = {}
+      for (const name of bot.capabilities ?? []) {
+        const item = library()[name]
+        if (!item) continue
+        if (item.kind !== 'pack') {
+          const status = statusFor(bot.id, name)
+          if (status) statuses[name] = status
+          continue
+        }
+        const children = (item.items ?? []).map(child => statusFor(bot.id, child)).filter(Boolean)
+        const status = children.find(status => status.state === 'error')
+          ?? children.find(status => status.state === 'needs-approval')
+          ?? children.find(status => status.state === 'connecting')
+          ?? children[0]
+        if (status) statuses[name] = status
+      }
+      result[bot.id] = statuses
+    }
+    return result
+  }
+  const libraryView = () => Object.values(library()).map(item => ({
+    ...item,
+    ...(item.env ? { env: { ...item.env } } : {}),
+    ...(item.headers ? { headers: { ...item.headers } } : {}),
+    ...(item.items ? { items: [...item.items] } : {}),
+  }))
+
+  async function loadMcpPlugin() {
+    if (!pluginPromise) {
+      pluginPromise = (async () => {
+        const loader = ctx.get?.('loader')
+        if (typeof loader?.import !== 'function') throw new Error('This DSH cannot load MCP servers.')
+        const exports = await loader.import(MCP_CLIENT)
+        return loader.unwrapExports?.(exports) ?? exports?.default ?? exports
+      })()
+    }
+    return pluginPromise
+  }
+  function resolveValues(values, botId) {
+    const resolved = {}
+    for (const [key, raw] of Object.entries(values ?? {})) {
+      resolved[key] = String(raw).replace(SECRET_REFERENCE, (_match, name) => {
+        if (!rt.canUseSecret(name, botId)) throw new Error(`Secret ${name} is missing or unavailable for this Bot.`)
+        const value = rt.secretValue(name)
+        if (value === undefined) throw new Error(`Secret ${name} is missing or unavailable for this Bot.`)
+        return value
+      })
+    }
+    return resolved
+  }
+  const configFor = (item, botId) => {
+    if (item.kind === 'skill') return { name: item.name, description: item.description, content: item.content }
+    if (item.transport === 'stdio') return { transport: 'stdio', serverName: item.name, command: item.command, args: item.args ?? [], env: resolveValues(item.env, botId), failOnStartupError: true }
+    return { transport: 'streamable-http', serverName: item.name, url: item.url, headers: resolveValues(item.headers, botId), failOnStartupError: true }
+  }
+  const disposeMount = async mount => {
+    if (mount?.fiber) await Promise.resolve().then(() => mount.fiber.dispose()).catch(() => {})
+  }
+  const mountOne = async (agent, bot, agentMounts, name) => {
+    const sessionId = agent.session.id
+    const item = library()[name]
+    const drop = async () => {
+      await disposeMount(agentMounts.get(name))
+      agentMounts.delete(name)
+    }
+    if (item.kind === 'mcp' && item.transport === 'stdio' && item.approved !== true) {
+      await drop()
+      statusSet(bot.id, name, sessionId, { state: 'needs-approval' })
+      return
+    }
+    let config
+    try {
+      config = configFor(item, bot.id)
+    } catch (error) {
+      await drop()
+      statusSet(bot.id, name, sessionId, { state: 'error', error: rt.redactSecrets(error.message).slice(0, 300) })
+      return
+    }
+    const key = `${name}:${createHash('sha256').update(JSON.stringify(config)).digest('hex')}`
+    if (agentMounts.get(name)?.key === key) return
+    await drop()
+    statusSet(bot.id, name, sessionId, { state: 'connecting' })
+    try {
+      const plugin = item.kind === 'skill'
+        ? {
+          name: `ds-bot-capability-skill-${name}`,
+          inject: ['skills'],
+          apply(c) {
+            c.effect(() => c.skills.register({ name: config.name, description: config.description, source: 'runtime', content: config.content }))
+          },
+        }
+        : await loadMcpPlugin()
+      if (stopped) return
+      const fiber = item.kind === 'skill' ? agent.ctx.plugin(plugin) : agent.ctx.plugin(plugin, config)
+      agentMounts.set(name, { key, fiber })
+      await fiber.await()
+      if (stopped || agents.get(sessionId)?.deref() !== agent) return
+      statusSet(bot.id, name, sessionId, { state: 'ready' })
+    } catch (error) {
+      await drop()
+      const message = rt.redactSecrets([error, error?.cause].filter(Boolean).map(part => String(part?.message ?? part)).join(': ') || 'Connection failed').slice(0, 300)
+      statusSet(bot.id, name, sessionId, { state: 'error', error: message })
+    }
+  }
+  const reconcileAgent = async (agent, bot) => {
+    const sessionId = agent.session.id
+    const desired = bot ? expandCapabilityNames(bot.capabilities, library()) : new Set()
+    const agentMounts = mounts.get(agent) ?? new Map()
+    if (desired.size > 0) mounts.set(agent, agentMounts)
+    if (bot) {
+      for (const name of sessionStatuses.get(bot.id)?.keys() ?? []) {
+        if (!desired.has(name)) clearStatus(bot.id, name, sessionId)
+      }
+    } else {
+      clearSession(sessionId)
+    }
+    for (const [name, mount] of agentMounts) {
+      if (desired.has(name)) continue
+      await disposeMount(mount)
+      agentMounts.delete(name)
+    }
+    await Promise.all([...desired].map(name => mountOne(agent, bot, agentMounts, name)))
+    if (agentMounts.size === 0 && mounts.get(agent) === agentMounts) mounts.delete(agent)
+  }
+  const botOfSession = sessionId => (rt.isBotSession(sessionId) ? rt.botOf(rt.selfOf(sessionId)) : undefined)
+  // At most one run waits behind the running one; it reads the latest state when it starts.
+  const reconcileOne = agent => {
+    if (queued.has(agent)) return chains.get(agent)
+    queued.add(agent)
+    const run = (chains.get(agent) ?? Promise.resolve()).then(async () => {
+      queued.delete(agent)
+      const sessionId = agent.session.id
+      if (stopped || agents.get(sessionId)?.deref() !== agent) return
+      await reconcileAgent(agent, botOfSession(sessionId))
+    }).catch(error => rt.warn('ds-bot: capability reconcile for %s failed: %s', agent.session?.id, error))
+    chains.set(agent, run)
+    return run
+  }
+  const loadInputs = async () => {
+    await rt.load()
+    loadingSecrets += 1
+    try {
+      await rt.loadSecrets()
+    } finally {
+      loadingSecrets -= 1
+    }
+  }
+  async function reconcile() {
+    if (stopped) return
+    await loadInputs()
+    const runs = []
+    for (const [sessionId, reference] of agents) {
+      const agent = reference.deref()
+      if (agent) {
+        runs.push(reconcileOne(agent))
+        continue
+      }
+      agents.delete(sessionId)
+      clearSession(sessionId)
+    }
+    await Promise.all(runs)
+  }
+  const scheduleReconcile = () => {
+    if (!scheduled) {
+      scheduled = new Promise(resolve => queueMicrotask(() => {
+        scheduled = null
+        resolve(reconcile().catch(error => rt.warn('ds-bot: capability reconcile failed: %s', error)))
+      }))
+    }
+    return scheduled
+  }
+  // A run that outlasts the limit goes on in the background, and later requests for the
+  // same Agent do not wait for it again.
+  const stalled = new WeakSet()
+  const prepare = async (agent, sessionId) => {
+    const run = loadInputs().then(() => reconcileOne(agent)).then(() => true, error => {
+      rt.warn('ds-bot: capability mount for %s failed: %s', sessionId, error)
+      return true
+    })
+    if (stalled.has(agent)) return
+    const timeoutMs = rt.capabilityEnsureTimeoutMs ?? ENSURE_TIMEOUT_MS
+    let timer
+    const completed = await Promise.race([run, new Promise(resolve => { timer = setTimeout(resolve, timeoutMs, false) })])
+    clearTimeout(timer)
+    if (completed) return
+    stalled.add(agent)
+    void run.then(() => stalled.delete(agent))
+    rt.warn('ds-bot: capability mount for %s did not finish within %dms; continuing', sessionId, timeoutMs)
+  }
+  async function ensureCapabilities(sessionId) {
+    await rt.load()
+    const bot = botOfSession(sessionId)
+    if (!bot) return
+    if ((bot.capabilities ?? []).length === 0 && !mounts.get(agents.get(sessionId)?.deref())?.size) return
+    let agent
+    try {
+      agent = await rt.resolveAgent(sessionId)
+    } catch (error) {
+      rt.warn('ds-bot: capability Agent for %s could not be resolved: %s', sessionId, rt.redactSecrets(String(error)))
+      return
+    }
+    trackAgent(agent)
+    await prepare(agent, sessionId)
+  }
+  const trackAgent = agent => {
+    const sessionId = agent?.session?.id
+    if (typeof sessionId !== 'string' || !agent.ctx) return
+    if (agents.get(sessionId)?.deref() === agent) return
+    agents.set(sessionId, new WeakRef(agent))
+    agent.ctx.effect(() => () => {
+      if (agents.get(sessionId)?.deref() === agent) agents.delete(sessionId)
+      clearSession(sessionId)
+      for (const mount of mounts.get(agent)?.values() ?? []) void disposeMount(mount)
+      mounts.delete(agent)
+    }, `ds-bot: capabilities ${sessionId}`)
+  }
+  const trackBotAgents = async bot => {
+    const sessionIds = new Set()
+    try {
+      const sessionId = rt.chatOf(bot.id)
+      if (typeof sessionId === 'string') sessionIds.add(sessionId)
+    } catch (error) {
+      rt.warn('ds-bot: capability chat session for %s could not be read: %s', bot.id, error)
+    }
+    try {
+      for (const sessionId of rt.groupSessionsOf(bot.id) ?? []) {
+        if (typeof sessionId === 'string') sessionIds.add(sessionId)
+      }
+    } catch (error) {
+      rt.warn('ds-bot: capability group sessions for %s could not be read: %s', bot.id, error)
+    }
+    for (const sessionId of sessionIds) {
+      try {
+        trackAgent(await rt.resolveAgent(sessionId))
+      } catch (error) {
+        rt.warn('ds-bot: capability Agent for %s could not be resolved: %s', sessionId, error)
+      }
+    }
+  }
+
+  async function capabilityEndpoint(endpoint, body = {}) {
+    if (endpoint === 'capability-save') return capabilitySave(body, { ui: true })
+    if (endpoint === 'capability-delete') return capabilityDelete(body.name, { ui: true })
+    if (endpoint === 'capability-approve') {
+      await rt.load()
+      writeCheck()
+      const item = library()[String(body.name ?? '')]
+      if (!item || item.kind !== 'mcp' || item.transport !== 'stdio') throw new Error(`No unapproved stdio MCP named ${body.name}.`)
+      item.approved = true
+      item.updatedAt = Date.now()
+      await rt.save()
+      return item
+    }
+    if (endpoint === 'bot-capability') {
+      await rt.load()
+      writeCheck()
+      const bot = rt.botOf(String(body.botId ?? ''))
+      if (!bot) throw new Error('Unknown Bot')
+      const name = String(body.name ?? '')
+      if (!library()[name]) throw new Error(`No capability named ${name}.`)
+      return setAttached(bot, name, body.attached === true)
+    }
+    throw new Error('Unknown capability operation.')
+  }
+  const secretsChanged = rt.secretsChanged
+  rt.secretsChanged = () => {
+    secretsChanged?.()
+    if (loadingSecrets === 0) void scheduleReconcile()
+  }
+  rt.capabilitiesStateSaved = () => { void scheduleReconcile() }
+  // Creation waits for these listeners, so a new Agent's first request already has its
+  // tools and skill catalog. agent/pre-step is too late: a step assembles its tools first.
+  ctx.on('agent/created', async function prepareCapabilities({ agent }) {
+    trackAgent(agent)
+    try {
+      await rt.load()
+      const bot = botOfSession(agent.session.id)
+      if ((bot?.capabilities ?? []).length > 0) await prepare(agent, agent.session.id)
+    } catch (error) {
+      rt.warn('ds-bot: capability load failed: %s', error)
+    }
+  })
+  ctx.effect(() => {
+    void rt.load().then(async () => {
+      for (const bot of Object.values(state.bots)) {
+        if ((bot.capabilities ?? []).length > 0) await trackBotAgents(bot)
+      }
+      await scheduleReconcile()
+    }).catch(error => rt.warn('ds-bot: capability startup failed: %s', error))
+    return async () => {
+      stopped = true
+      const live = [...mounts.values()]
+      mounts.clear()
+      agents.clear()
+      sessionStatuses.clear()
+      await Promise.all(live.flatMap(agentMounts => [...agentMounts.values()].map(disposeMount)))
+    }
+  }, 'ds-bot: capabilities')
+  Object.assign(rt, {
+    capabilitySave,
+    capabilityDelete,
+    capabilityEndpoint,
+    capabilityLibraryView: libraryView,
+    capabilityStatusesView,
+    reconcileCapabilities: reconcile,
+    scheduleCapabilitiesReconcile: scheduleReconcile,
+    ensureCapabilities,
+    expandCapabilities: names => expandCapabilityNames(names, library()),
+    changeCapabilityAttachment: changeAttachment,
+  })
+}