ds-bot 0.1.3 → 0.1.4

package/src/host/resume.js

@@ -0,0 +1,247 @@
+// Resume: Bot work that DeepSeek Harness dropped when it closed or restarted. DSH closes
+// a turn it never finished as interrupted when the Session next opens, and a clean
+// shutdown also cancels the messages still waiting in a Session's inbox; nothing would
+// ever run either again, and whoever waited for them was not told. DS Bot notes each
+// running Bot turn and each message it delivers until a turn takes it up, in
+// inflight.json; what is still noted at the next start is picked up once.
+import { randomUUID } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { SOURCE_KIND } from './constants.js'
+
+// Long enough for DSH to finish opening its workspaces after a start.
+const RESUME_DELAY_MS = 3000
+// A delivery waiting longer than this was not lost to a restart.
+const QUEUED_KEPT_MS = 24 * 60 * 60 * 1000
+const QUEUED_MAX = 50
+
+export const resumeText = record => [
+  'DeepSeek Harness restarted while you were working on this, so your last turn stopped before it finished.',
+  record.approval ? `You were waiting for the user's approval to run ${record.approval.tool || 'a tool'}${record.approval.reason ? ` (${record.approval.reason})` : ''}; that request is gone, so ask again if you still need it.` : '',
+  'Check what is already done (files, commands, messages) before you repeat anything, then finish the task and give your reply.',
+].filter(Boolean).join(' ')
+
+// The trigger fields a resumed turn needs to answer the same sender.
+const triggerOf = info => ({
+  role: info.role,
+  ...(info.exchangeId ? { exchangeId: info.exchangeId } : {}),
+  ...(info.senderSessionId ? { senderSessionId: info.senderSessionId } : {}),
+  ...(info.roomId ? { roomId: info.roomId } : {}),
+  ...(typeof info.hop === 'number' ? { hop: info.hop } : {}),
+  ...(info.audience ? { audience: info.audience } : {}),
+  ...(info.askedBy ? { askedBy: info.askedBy } : {}),
+  ...(info.senderRoomId ? { senderRoomId: info.senderRoomId } : {}),
+})
+
+const readNotes = (file) => {
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    const object = value => (value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {})
+    return { turns: object(parsed?.turns), queued: object(parsed?.queued) }
+  } catch {
+    return { turns: {}, queued: {} }
+  }
+}
+
+export function install(rt) {
+  const { ctx, home } = rt
+  const file = join(home, 'inflight.json')
+
+  // What the last run left; read before this run notes anything.
+  let interrupted = readNotes(file)
+
+  /** @type {Record<string, {botId:string, roomId?:string, since:number, trigger?:any, approval?:{tool:string, reason:string}, resumed?:boolean}>} */
+  let turns = {}
+  /** @type {Record<string, {at:number, args:any}[]>} deliveries no turn has taken up, by Session */
+  let queued = {}
+  let writing = Promise.resolve()
+  let stopped = false
+  let latest
+  let due = false
+  const persist = () => {
+    // Only the host that saves the team runs its work again.
+    if (stopped || rt.readOnly() !== undefined) return
+    latest = JSON.stringify({ turns, queued })
+    // One write waits at a time and takes the latest notes, so a busy round does not
+    // write the file once per change.
+    if (due) return
+    due = true
+    // Written in place: a rename over the file fails on Windows while anything reads
+    // it, and a torn write only loses what one restart would pick up.
+    writing = writing.then(async () => {
+      due = false
+      const snapshot = latest
+      await mkdir(home, { recursive: true })
+      await writeFile(file, snapshot, 'utf8')
+    }).catch(error => rt.warn('ds-bot: noting running turns failed: %s', error))
+  }
+  const update = (id, change) => {
+    const next = change(turns[id])
+    if (next === turns[id]) return
+    turns = { ...turns }
+    if (next === undefined) delete turns[id]
+    else turns[id] = next
+    persist()
+  }
+  const forgetQueued = (exchangeId) => {
+    for (const [sessionId, list] of Object.entries(queued)) {
+      const at = list.findIndex(item => item.args.exchangeId === exchangeId)
+      if (at === -1) continue
+      const rest = list.toSpliced(at, 1)
+      queued = { ...queued }
+      if (rest.length === 0) delete queued[sessionId]
+      else queued[sessionId] = rest
+      persist()
+      return
+    }
+  }
+
+  const deliver = rt.deliver
+  rt.deliver = async (args) => {
+    const noted = { ...args, exchangeId: args.exchangeId ?? randomUUID() }
+    const sessionId = noted.sessionId ?? rt.chatOf(noted.toId)
+    // Noted before it is sent: a turn may take it up before the send returns.
+    queued = { ...queued, [sessionId]: [...(queued[sessionId] ?? []), { at: Date.now(), args: noted }].slice(-QUEUED_MAX) }
+    persist()
+    try {
+      return await deliver(noted)
+    } catch (error) {
+      forgetQueued(noted.exchangeId)
+      throw error
+    }
+  }
+
+  // A message is done with once a turn takes it up, or once it leaves the inbox untaken
+  // while DS Bot runs: the user stopped the Bot, or DS Bot moved or withdrew it.
+  ctx.on('agent/inbox/discarded', ({ message } = {}) => {
+    if (message?.source?.kind === SOURCE_KIND && message.source.exchangeId) forgetQueued(message.source.exchangeId)
+  })
+  // Exchanges a turn took up since this start, until the resends are done, so a resend
+  // never repeats one.
+  let taken = Object.keys(interrupted.queued).length > 0 ? new Set() : undefined
+  // The first turn event of each Session since this start, until the noted turns are
+  // picked up. A turn that ends, or still runs, before one starts here outlived the
+  // last run: only DS Bot restarted (the plugin reloaded) and DSH went on.
+  let firstTurn = Object.keys(interrupted.turns).length > 0 ? new Map() : undefined
+  ctx.on('session/event', (session, event) => {
+    const id = session?.id
+    if (id === undefined) return
+    if ((event.type === 'turn/start' || event.type === 'turn/end') && firstTurn?.has(id) === false) firstTurn.set(id, event.type)
+    if (event.type === 'user/message' && event.data?.source?.kind === SOURCE_KIND && event.data.source.exchangeId) {
+      taken?.add(event.data.source.exchangeId)
+      forgetQueued(event.data.source.exchangeId)
+    }
+    if (!rt.isBotSession(id)) return
+    switch (event.type) {
+      case 'turn/start': {
+        const owner = rt.groupOwners.get(id)
+        const botId = owner?.botId ?? rt.chatOwners.get(id)
+        update(id, () => ({ botId, ...(owner ? { roomId: owner.roomId } : {}), since: event.time ?? Date.now() }))
+        break
+      }
+      case 'user/message': {
+        if (event.data?.source?.kind !== SOURCE_KIND) break
+        // turns.js, installed earlier, has already claimed the turn's trigger.
+        const info = rt.live.get(id)?.info
+        update(id, record => (record === undefined || record.trigger !== undefined || info === undefined ? record
+          : { ...record, trigger: triggerOf(info), ...(info.resumed ? { resumed: true } : {}) }))
+        break
+      }
+      case 'turn/end': {
+        // DSH stops every turn as it shuts down; that one is picked up at the next start.
+        const reason = event.data?.reason
+        if (reason?.kind === 'aborted' && reason.reason?.kind === 'disposed') break
+        update(id, () => undefined)
+        break
+      }
+    }
+  })
+
+  // An approval the restart drops is named when the turn is picked up.
+  rt.noteApproval = (sessionId, approval) => update(sessionId, record => (record === undefined ? record
+    : approval === undefined ? (({ approval: _, ...rest }) => rest)(record) : { ...record, approval }))
+
+  async function resumeTurn(sessionId, record) {
+    const bot = rt.botOf(record.botId)
+    if (bot === undefined) return
+    const text = resumeText(record)
+    if (record.roomId !== undefined) {
+      const room = rt.roomOf(record.roomId)
+      if (room === undefined || !room.members.includes(bot.id)) return
+      await rt.postToRoom(room, bot, '', { resumed: true, quiet: true, ...(record.resumed ? { again: true } : {}) })
+      // A turn already picked up once and cut off again stays stopped: a restart loop
+      // must not run it forever.
+      if (record.resumed) return
+      await rt.deliver({ toId: bot.id, sessionId: room.sessions?.[bot.id] ?? sessionId, role: 'room', roomId: room.id, note: 'picking up after a restart', resumed: true, text, ...(record.trigger?.askedBy ? { askedBy: record.trigger.askedBy } : {}) })
+      return
+    }
+    if (record.resumed) return
+    const trigger = record.trigger
+    if ((trigger?.role === 'request' || trigger?.role === 'stopped') && trigger.senderSessionId && trigger.audience !== 'user' && rt.botOf(trigger.senderSessionId)) {
+      // The sender still waits for this turn's answer, so it goes on under the same exchange.
+      await rt.deliver({ fromId: trigger.senderSessionId, toId: bot.id, role: trigger.role, hop: trigger.hop ?? 0, ...(trigger.exchangeId ? { exchangeId: trigger.exchangeId } : {}), ...(trigger.senderRoomId ? { fromRoomId: trigger.senderRoomId } : {}), resumed: true, text })
+      return
+    }
+    await rt.deliver({ toId: bot.id, role: 'resume', resumed: true, text })
+  }
+
+  // A hard stop keeps the inbox, which the Session runs once it wakes; only what DSH
+  // cancelled is sent again.
+  async function resendQueued(sessionId, list) {
+    // A Session that moved on to a new part since is reached at its current one.
+    const current = (args) => {
+      if (rt.isBotSession(sessionId)) return sessionId
+      return args.roomId === undefined ? rt.chatOf(args.toId) : rt.roomOf(args.roomId)?.sessions?.[args.toId]
+    }
+    const fresh = list.filter(item => Date.now() - item.at < QUEUED_KEPT_MS && rt.botOf(item.args?.toId) !== undefined
+      && current(item.args) !== undefined && taken?.has(item.args.exchangeId) !== true)
+    if (fresh.length === 0) return
+    const target = current(fresh[0].args)
+    const agent = await rt.resolveAgent(target)
+    const waiting = new Set([...(agent.inbox?.nextStep ?? []), ...(agent.inbox?.nextTurn ?? [])].map(message => message.source?.exchangeId))
+    for (const { args } of fresh) {
+      if (waiting.has(args.exchangeId) || taken?.has(args.exchangeId) === true) continue
+      await rt.deliver({ ...args, sessionId: current(args), steer: false, resent: true })
+    }
+  }
+
+  async function resumeAll() {
+    await rt.load()
+    if (rt.readOnly() !== undefined) return
+    const { turns: noted, queued: dropped } = interrupted
+    interrupted = { turns: {}, queued: {} }
+    // Taken up now, so another restart does not pick them up twice.
+    persist()
+    // Agents and inboxes are read before anything wakes their Sessions.
+    const cut = []
+    for (const [sessionId, record] of Object.entries(noted)) {
+      const first = firstTurn.get(sessionId)
+      if (first === 'turn/end') continue
+      // Still running: noted again, as if it had started here.
+      if (first === undefined && (await rt.resolveAgent(sessionId).catch(() => undefined))?.status === 'running') update(sessionId, () => record)
+      else cut.push([sessionId, record])
+    }
+    firstTurn = undefined
+    for (const [sessionId, list] of Object.entries(dropped)) {
+      if (!Array.isArray(list)) continue
+      await resendQueued(sessionId, list).catch(error => rt.warn('ds-bot: sending again what %s was sent failed: %s', sessionId, error))
+    }
+    taken = undefined
+    for (const [sessionId, record] of cut) {
+      await resumeTurn(sessionId, record).catch(error => rt.warn('ds-bot: picking up the turn of %s failed: %s', sessionId, error))
+    }
+  }
+
+  ctx.effect(() => {
+    const pending = Object.keys(interrupted.turns).length > 0 || Object.keys(interrupted.queued).length > 0
+    const timer = pending ? setTimeout(() => void resumeAll().catch(error => rt.warn('ds-bot: picking up interrupted work failed: %s', error)), RESUME_DELAY_MS) : undefined
+    timer?.unref?.()
+    // What the turns stopped by this shutdown left stays as last noted.
+    return () => {
+      stopped = true
+      clearTimeout(timer)
+      return writing
+    }
+  }, 'ds-bot: resume interrupted turns')
+}

package/src/host/roster.js

@@ -78,6 +78,7 @@ export function install(rt) {
         instructions: String(instructions).trim(),
         createdAt: Date.now(),
         createdBy: createdBy ?? null,
+        capabilities: [],
       }
       if (main) state.mainBotIds.push(id)
       const creator = rt.botOf(createdBy)

package/src/host/secrets.js

@@ -526,5 +526,13 @@ export function install(rt) {
     return () => { if (usedTimer !== null) clearTimeout(usedTimer) }
   }, 'ds-bot: load secrets')
 
-  Object.assign(rt, { secretsView, secretValue: name => secrets.get(name)?.value, secretEndpoint, forgetBotSecrets, loadSecrets, redactSecrets: text => redact(text) })
+  Object.assign(rt, {
+    secretsView,
+    secretValue: name => secrets.get(name)?.value,
+    canUseSecret: (name, botId) => canUse(secrets.get(name), botId),
+    secretEndpoint,
+    forgetBotSecrets,
+    loadSecrets,
+    redactSecrets: text => redact(text),
+  })
 }

package/src/host/store.js

@@ -11,8 +11,8 @@ import { currentColor, normalize, unquote } from './text.js'
 export function install(rt) {
   const { ctx, home, statePath } = rt
 
-  /** @type {{version:1, workspaceId?:string, mainBotIds:string[], bots:Record<string,any>, rooms:Record<string,any>, agents:Record<string,any>, exchanges:any[], exchangeTurns:Record<string,number[]>, revision:number}} */
-  const state = { version: 1, mainBotIds: [], bots: {}, rooms: {}, agents: {}, exchanges: [], exchangeTurns: {}, questions: {}, prefs: {}, revision: 0 }
+  /** @type {{version:1, workspaceId?:string, mainBotIds:string[], bots:Record<string,any>, rooms:Record<string,any>, agents:Record<string,any>, capabilities:{items:Record<string,any>}, exchanges:any[], exchangeTurns:Record<string,number[]>, revision:number}} */
+  const state = { version: 1, mainBotIds: [], bots: {}, rooms: {}, agents: {}, capabilities: { items: {} }, exchanges: [], exchangeTurns: {}, questions: {}, prefs: {}, revision: 0 }
   let loaded = null
   let writing = Promise.resolve()
   const { warn } = rt
@@ -97,13 +97,25 @@ export function install(rt) {
   // Fill `state` from the saved file and bring an older team up to date. Returns the
   // groups whose Session titles still need the new name.
   const adopt = (parsed) => {
+    const hadCapabilities = parsed !== null && parsed !== undefined && Object.hasOwn(parsed, 'capabilities')
     for (const key of Object.keys(state)) delete state[key]
     Object.assign(state, JSON.parse(EMPTY), parsed ?? {})
     state.prefs ??= {}
     // Teams saved before the DSH Agent existed carry no `agents`; corrupt values reset.
     if (state.agents === null || typeof state.agents !== 'object' || Array.isArray(state.agents)) state.agents = {}
-    let migrated = false
+    let migrated = !hadCapabilities
+    if (state.capabilities === null || typeof state.capabilities !== 'object' || Array.isArray(state.capabilities)) {
+      state.capabilities = { items: {} }
+      migrated = true
+    } else if (state.capabilities.items === null || typeof state.capabilities.items !== 'object' || Array.isArray(state.capabilities.items)) {
+      state.capabilities.items = {}
+      migrated = true
+    }
     for (const bot of Object.values(state.bots)) {
+      if (!Array.isArray(bot.capabilities)) {
+        bot.capabilities = []
+        migrated = true
+      }
       if (bot.color !== currentColor(bot.color)) {
         bot.color = currentColor(bot.color)
         migrated = true
@@ -248,6 +260,7 @@ export function install(rt) {
         ensureLock()
         await rename(temp, statePath)
         seen = stamp()
+        rt.capabilitiesStateSaved?.()
       } catch (error) {
         await unlink(temp).catch(() => {})
         throw error

package/src/host/tools.js

@@ -17,6 +17,10 @@ export function install(rt) {
   const { ctx, state } = rt
 
   const callerBot = (exec) => rt.botOf(rt.selfOf(exec.agent?.id))
+  const callerRoom = (exec) => {
+    const roomId = rt.groupOwners.get(exec.agent?.id)?.roomId
+    return roomId ? { fromRoomId: roomId } : {}
+  }
 
   const roomLine = (room, self) => {
     const members = room.members.map(rt.botOf).filter(Boolean)
@@ -100,7 +104,7 @@ export function install(rt) {
       const toUser = args.reply_to === 'user'
       const working = rt.live.get(rt.chatOf(target.id))?.turn !== undefined
       const steer = args.when !== 'queue' && !toUser
-      await rt.deliver({ fromId: sender.id, toId: target.id, text: args.message, role: 'request', hop, steer, ...(toUser ? { audience: 'user' } : {}) })
+      await rt.deliver({ fromId: sender.id, toId: target.id, text: args.message, role: 'request', hop, steer, ...(toUser ? { audience: 'user' } : callerRoom(exec)) })
       const sent = toUser
         ? `Delivered to ${target.name}. It will answer the user in its own chat; nothing comes back to you, so point the user to ${target.name}'s chat instead of relaying.`
         : working && steer
@@ -142,7 +146,7 @@ export function install(rt) {
         agent.cancel({ kind: 'hook', reason: 'ds-bot/stopped' })
       }
       const why = String(args.reason ?? '').trim() || 'Stop what you are doing; the previous turn was ended on purpose. Acknowledge briefly.'
-      await rt.deliver({ fromId: sender.id, toId: target.id, text: why, role: 'stopped' })
+      await rt.deliver({ fromId: sender.id, toId: target.id, text: why, role: 'stopped', ...callerRoom(exec) })
       return `Stopped ${target.name} in ${running.map(whereOf).join(' and ')}. It is told why in a new turn, whose reply comes back to you.`
     },
   }))
@@ -334,7 +338,7 @@ export function install(rt) {
     description: 'Post a message into a group chat as yourself. It starts a round: members reply in the group, where the user reads them. Main Bots may post into any group; an admin into its own group.',
     parameters: {
       group: GROUP_REF,
-      message: { type: 'string', required: true, description: 'What to say; write "@Name" to choose who answers' },
+      message: { type: 'string', required: true, description: 'What to say; write "@Name" to choose who answers, and a name without "@" to only mention a member' },
       report_back: { type: 'boolean', description: 'Also send the members\' replies back to you as a new message when the round ends' },
     },
     output,
@@ -421,5 +425,103 @@ export function install(rt) {
     },
   }))
 
+  ctx.tools.register(defineTool({
+    name: 'list_capabilities',
+    description: 'List shared MCP servers, skills, and packs, plus the capabilities attached to you.',
+    parameters: {},
+    output,
+    async execute(_args, exec) {
+      await rt.load()
+      const self = rt.selfOf(exec.agent?.id)
+      const bot = rt.botOf(self)
+      if (!bot) return 'Only Bots on the team can use list_capabilities.'
+      const items = Object.values(state.capabilities?.items ?? {})
+      if (items.length === 0) return 'No shared capabilities are saved yet.'
+      const statuses = rt.capabilityStatusesView()[bot.id] ?? {}
+      const lines = items.map(item => {
+        const extra = item.kind === 'pack' ? `; includes ${(item.items ?? []).join(', ') || 'nothing'}`
+          : item.kind === 'mcp' && item.transport === 'stdio' ? `; ${item.approved ? 'allowed' : 'needs user approval'}` : ''
+        const itemStatus = statuses[item.name]
+        const state = itemStatus ? ` (${itemStatus.state}${itemStatus.error ? `: ${itemStatus.error}` : ''})` : ''
+        const status = bot.capabilities?.includes(item.name) ? `; attached to you${state}` : ''
+        return `- ${item.name} (${item.kind})${item.description ? ` — ${item.description}` : ''}${extra}${status}`
+      })
+      return ['Shared capabilities:', ...lines].join('\n')
+    },
+  }))
+  ctx.tools.register(defineTool({
+    name: 'save_capability',
+    description: 'Create or update a shared MCP server, skill, or pack. Changes apply from your next message.',
+    parameters: {
+      name: { type: 'string', required: true, description: 'Lowercase letters, digits, and single hyphens, up to 32 characters; "github" is reserved' },
+      kind: { type: 'string', required: true, enum: ['mcp', 'skill', 'pack'] },
+      description: { type: 'string', description: 'What this capability provides' },
+      transport: { type: 'string', enum: ['stdio', 'streamable-http'], description: 'How to reach an MCP server: a local command or an HTTP URL' },
+      command: { type: 'string', description: 'Program that starts a local MCP server' },
+      args: { type: 'array', items: { type: 'string' }, description: 'Arguments for command' },
+      env: { type: 'object', additionalProperties: true, description: 'Environment variables for command; write $DSH_SECRET_<NAME> to insert a saved secret instead of the value' },
+      url: { type: 'string', description: 'MCP server URL' },
+      headers: { type: 'object', additionalProperties: true, description: 'HTTP headers; write $DSH_SECRET_<NAME> to insert a saved secret instead of the value' },
+      content: { type: 'string', description: 'Skill instructions' },
+      items: { type: 'array', items: { type: 'string' }, description: 'MCP server and skill names in the pack' },
+    },
+    output,
+    async execute(args, exec) {
+      await rt.load()
+      const self = rt.selfOf(exec.agent?.id)
+      if (!rt.botOf(self)) return 'Only Bots on the team can use save_capability.'
+      try {
+        const item = await rt.capabilitySave(args, { botId: self })
+        const approval = item.kind === 'mcp' && item.transport === 'stdio' && !item.approved
+          ? ' The user must allow this MCP server in DS Bot settings before it can work.'
+          : ''
+        return `Saved ${item.name}. Bots with it attached use the change from their next message.${approval}`
+      } catch (error) { return error.message }
+    },
+  }))
+  ctx.tools.register(defineTool({
+    name: 'delete_capability',
+    description: 'Remove a shared capability and detach it from every Bot and pack.',
+    parameters: { name: { type: 'string', required: true } },
+    output,
+    async execute(args, exec) {
+      await rt.load()
+      const self = rt.selfOf(exec.agent?.id)
+      if (!rt.botOf(self)) return 'Only Bots on the team can use delete_capability.'
+      try {
+        await rt.capabilityDelete(args.name, { botId: self })
+        return `Deleted ${args.name}; it was removed from every Bot and pack. The change applies from their next message.`
+      } catch (error) { return error.message }
+    },
+  }))
+  for (const [name, endpoint, verb] of [['attach_capability', 'attach', 'Attached'], ['detach_capability', 'detach', 'Detached']]) {
+    ctx.tools.register(defineTool({
+      name,
+      description: `${verb} a shared capability to yourself, or to another Bot if you are a Main Bot.`,
+      parameters: {
+        name: { type: 'string', required: true, description: 'Capability name from list_capabilities' },
+        bot: { type: 'string', description: 'Optional Bot name; only a Main Bot may change another Bot' },
+      },
+      output,
+      async execute(args, exec) {
+        await rt.load()
+        const self = rt.selfOf(exec.agent?.id)
+        if (!rt.botOf(self)) return `Only Bots on the team can use ${name}.`
+        try {
+          const result = await rt.changeCapabilityAttachment(endpoint, args, self)
+          const attached = state.capabilities.items[args.name]
+          const members = attached?.kind === 'pack'
+            ? (attached.items ?? []).map(child => state.capabilities.items[child]).filter(Boolean)
+            : attached ? [attached] : []
+          const approvals = members
+            .filter(item => item.kind === 'mcp' && item.transport === 'stdio' && item.approved !== true)
+            .map(item => ` The user must allow ${item.name} in DS Bot settings before it can work.`)
+            .join('')
+          return `${verb} ${args.name} ${args.bot ? `to ${result.bot}` : 'to yourself'}. Changes apply from ${result.bot}'s next message.${endpoint === 'attach' ? approvals : ''}`
+        } catch (error) { return error.message }
+      },
+    }))
+  }
+
   Object.assign(rt, { pickRoom })
 }

package/src/host/turns.js

@@ -31,9 +31,41 @@ export function attachReference(queued, source, text) {
   post.references = [...(post.references ?? []), { labels, text }]
 }
 
+// A tool call some models write into their text instead of making it (the XML-like
+// form of their own chat template).
+const WRITTEN_CALL = /<tool_call>\s*<function=|<function=[\w.-]+>\s*<parameter=/
+export const writesToolCall = text => typeof text === 'string' && WRITTEN_CALL.test(text)
+export const stripWrittenCalls = text => text
+  .replace(/<tool_call>[\s\S]*?(?:<\/tool_call>|$)/g, '')
+  .replace(/<function=[\w.-]+>[\s\S]*?(?:<\/function>|$)/g, '')
+  .trim()
+
+const RETRY_TEXT = 'Your last reply wrote a tool call as plain text (<tool_call>…), so it did not run and nothing happened. Call the tool through the tool interface now, then reply as you meant to.'
+
 export function install(rt) {
   const { ctx, state } = rt
 
+  // The retry goes where the turn's trigger came from: a group round's waiter or a
+  // Bot's request keeps its exchange; anything else is a nudge in the Bot's own chat.
+  const retryWrittenCall = (id, info) => {
+    const keeps = info !== undefined && (info.role === 'room' || expectsReply(info))
+    return rt.deliver({
+      ...(keeps && info.senderSessionId ? { fromId: info.senderSessionId } : {}),
+      toId: rt.selfOf(id),
+      sessionId: id,
+      role: keeps ? info.role : 'retry',
+      ...(keeps && info.roomId ? { roomId: info.roomId } : {}),
+      hop: keeps ? info.hop ?? 0 : 0,
+      ...(keeps && info.exchangeId ? { exchangeId: info.exchangeId } : {}),
+      ...(keeps && info.audience ? { audience: info.audience } : {}),
+      ...(keeps && info.askedBy ? { askedBy: info.askedBy } : {}),
+      ...(keeps && info.senderRoomId ? { fromRoomId: info.senderRoomId } : {}),
+      note: 'your tool call did not run',
+      retried: true,
+      text: RETRY_TEXT,
+    })
+  }
+
   /** @type {Map<string, {turn?:number, pending?:any, info?:any, texts:string[], opened?:boolean, joined?:{info:any, from:number}[]}>} */
   const live = new Map()
   /** @type {Map<string, {sessionId:string, resolve:(text:string|null)=>void, fail:(failure:any)=>void, touch:()=>void, approval:()=>void}>} member turn waiters keyed by exchange id */
@@ -157,6 +189,24 @@ export function install(rt) {
     return bots
   }
 
+  // Per group, the members whose turn there is running; the round's current speaker is
+  // marked, since its round shows it.
+  const roomWorkView = () => {
+    const speaking = new Set([...roomProgress.values()].map(round => `${round.roomId}:${round.speaking}`))
+    const rooms = {}
+    for (const [id, entry] of live) {
+      const owner = rt.groupOwners.get(id)
+      if (entry.turn === undefined || owner === undefined) continue
+      rooms[owner.roomId] = [...(rooms[owner.roomId] ?? []), {
+        botId: owner.botId,
+        since: entry.since,
+        ...(entry.tool ? { tool: entry.tool } : {}),
+        ...(speaking.has(`${owner.roomId}:${owner.botId}`) ? { speaking: true } : {}),
+      }]
+    }
+    return rooms
+  }
+
   // What a running tool call is about, for an approval card: its own description and
   // the command, path or address it acts on.
   const callDetail = (sessionId, callId) => {
@@ -197,6 +247,7 @@ export function install(rt) {
         const name = String(event.data?.name ?? '')
         setActivity(id, name === 'ask_user' ? undefined : activityOf(name))
         entry.tool = name
+        if (rt.groupOwners.has(id)) rt.workRoomTurn?.(id, name)
         if (typeof event.data?.callId === 'string') (entry.calls ??= new Map()).set(event.data.callId, String(event.data.arguments ?? ''))
         break
       }
@@ -255,6 +306,10 @@ export function install(rt) {
             ...(source.late ? { late: true } : {}),
             ...(source.quiet ? { quiet: true } : {}),
             ...(source.failed ? { failed: source.failed } : {}),
+            ...(source.resumed ? { resumed: true } : {}),
+            ...(source.again ? { again: true } : {}),
+            ...(source.stopped ? { stopped: true } : {}),
+            ...(source.askedBy ? { askedBy: source.askedBy } : {}),
           })
         } else if (source?.kind === SOURCE_KIND && source.role === 'kickoff' && rt.roomOf(id)) {
           queueRoomMessage(id, { text: '', kickoff: true })
@@ -295,8 +350,11 @@ export function install(rt) {
         break
       }
       case 'assistant/message': {
-        const text = textOf(event.data?.message?.content)
+        const content = event.data?.message?.content
+        const text = textOf(content)
         if (text !== '') entry.texts.push(text)
+        entry.lastText = text
+        entry.lastCalled = Array.isArray(content) && content.some(block => block?.type === 'tool-call')
         break
       }
       case 'turn/end': {
@@ -304,6 +362,7 @@ export function install(rt) {
         const info = entry.info
         const joined = entry.joined ?? []
         const texts = entry.texts
+        const { lastText, lastCalled } = entry
         // A turn stopped for a switch goes on in the next part, which answers instead.
         const switched = entry.switched === true
         entry.turn = undefined
@@ -314,20 +373,37 @@ export function install(rt) {
         entry.since = undefined
         entry.tool = undefined
         entry.calls = undefined
+        entry.lastText = undefined
+        entry.lastCalled = undefined
         const reason = event.data?.reason
         const failure = reason?.kind === 'error' && !switched ? turnFailure(reason.error) : undefined
         if (failure !== undefined) noteTurnFailure(id, failure)
         if (switched) break
+        // A model that writes its tool call as text ends the turn as if it were done,
+        // though nothing ran. It gets one more turn on the same trigger, so a waiting
+        // round or sender gets the real answer; a second time, the text goes on without
+        // the call.
+        const wroteCall = failure === undefined && reason?.kind === 'completed' && lastCalled !== true && writesToolCall(lastText)
+        const retry = wroteCall && info?.retried !== true && !(info?.role === 'room' && stoppedRoomTurns.has(info.exchangeId))
+        if (retry) void retryWrittenCall(id, info).catch(error => rt.warn('ds-bot: asking %s to run its written tool call failed: %s', id, error))
+        const replyText = () => {
+          const reply = (wroteCall ? texts.map(stripWrittenCalls) : texts).join('\n\n').trim()
+          return wroteCall && reply === '' ? 'Tried to run a tool but wrote the call as text, so it did not run.' : reply
+        }
         // Whoever the turn answers gets the same three-way rule: a failure notice,
         // the turn's text (or a stopped-before-answer line), or nothing.
         const answer = (source, reply) => {
           if (!expectsReply(source) || answersUser(source)) return
           const name = rt.botOf(rt.selfOf(id))?.name ?? 'The other Bot'
+          // A sender that wrote from a group gets the reply in its Session there, while
+          // it is still a member.
+          const back = rt.roomOf(source.senderRoomId)?.sessions?.[source.senderSessionId]
           if (failure !== undefined) {
             // The sender was told a reply comes later; without this it would wait forever.
             void rt.deliver({
               fromId: rt.selfOf(id),
               toId: source.senderSessionId,
+              ...(back ? { sessionId: back } : {}),
               text: `${name} could not answer your message: its model call failed (${failureLine(failure)}). Tell the user if it matters; do not retry right away.`,
               role: 'reply',
               hop: (source.hop ?? 0) + 1,
@@ -339,6 +415,7 @@ export function install(rt) {
             void rt.deliver({
               fromId: rt.selfOf(id),
               toId: source.senderSessionId,
+              ...(back ? { sessionId: back } : {}),
               text: reply !== '' ? reply : `${name} was stopped before it could answer your message.`,
               role: 'reply',
               hop: (source.hop ?? 0) + 1,
@@ -346,20 +423,28 @@ export function install(rt) {
             }).catch(error => rt.warn('ds-bot: reply delivery failed: %s', error))
           }
         }
-        if (info?.role === 'room') {
+        // A retried turn answers the same waiter or sender, so this one passes nothing on.
+        if (!retry && info?.role === 'room') {
           const waiter = roomWaiters.get(info.exchangeId)
           roomWaiters.delete(info.exchangeId)
           const stopped = stoppedRoomTurns.delete(info.exchangeId)
           if (waiter !== undefined) {
             if (failure !== undefined) waiter.fail(failure)
-            else waiter.resolve(reason?.kind === 'aborted' ? null : texts.join('\n\n').trim())
+            else waiter.resolve(reason?.kind === 'aborted' ? null : replyText())
           } else if (!stopped && reason?.kind !== 'aborted') {
             // The round moved on without this member; how its turn ends still reaches the group.
             if (failure !== undefined) void rt.lateRoomFailure?.(id, info, failure)
-            else void rt.lateRoomReply?.(id, info, texts.join('\n\n').trim())
+            else void rt.lateRoomReply?.(id, info, replyText())
+          }
+        } else if (!retry && info !== undefined) {
+          // A group Session speaks only in its group: the turn that takes a reply to a
+          // message it sent from there posts what it ends with.
+          if (rt.groupOwners.has(id) && (info.role === 'reply' || info.role === 'retry')) {
+            if (failure !== undefined) void rt.lateRoomFailure?.(id, info, failure)
+            else if (reason?.kind !== 'aborted') void rt.lateRoomReply?.(id, info, replyText())
+          } else {
+            answer(info, replyText())
           }
-        } else if (info !== undefined) {
-          answer(info, texts.join('\n\n').trim())
         }
         for (const request of joined) {
           // A failed or stopped turn closes the request like any other; a finished
@@ -376,6 +461,7 @@ export function install(rt) {
             role: 'request',
             hop: request.info.hop ?? 0,
             exchangeId: request.info.exchangeId,
+            ...(request.info.senderRoomId ? { fromRoomId: request.info.senderRoomId } : {}),
             deferred: true,
           }).catch(error => rt.warn('ds-bot: deferred request delivery failed: %s', error))
         }
@@ -384,5 +470,5 @@ export function install(rt) {
     }
   })
 
-  Object.assign(rt, { live, liveOf, roomWaiters, roomProgress, roomInbox, activityView, workView, callDetail, stopRoomTurn })
+  Object.assign(rt, { live, liveOf, roomWaiters, roomProgress, roomInbox, activityView, workView, roomWorkView, callDetail, stopRoomTurn })
 }