ds-bot 0.1.1 → 0.1.3

package/src/host/store.js

@@ -2,7 +2,7 @@
 // host on the same data from writing it, and the indexes that map a Session to the Bot
 // or group chat it belongs to.
 import { mkdirSync, statSync } from 'node:fs'
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { copyFile, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { LEGACY_THEMES, MAX_EXCHANGES, ROOM_MODES } from './constants.js'
 import { homeLock } from './home-lock.js'
@@ -22,7 +22,9 @@ export function install(rt) {
   // undefined while this host may write.
   let holder
   let lockBroken = false
+  let stuck
   let warnedReadOnly = false
+  let stopped = false
   // mtime and size of the state.json this host last read or wrote.
   let seen = ''
   const stamp = () => {
@@ -40,27 +42,56 @@ export function install(rt) {
       mkdirSync(home, { recursive: true })
       holder = lock.claim()
     } catch (error) {
-      // An unusable lock (a read-only or odd file system) must not stop the team.
+      // An unusable lock (a read-only or odd file system) must not stop the team; a
+      // save that then cannot write still rejects.
       lockBroken = true
       holder = undefined
       warn('ds-bot: cannot lock %s, so another dsh on the same data could undo changes: %s', home, error)
     }
   }
   const readOnly = () => {
+    if (stuck !== undefined) return `The Bot team file ${statePath} could not be read (${stuck}). DS Bot does not change it; fix or move the file and reload.`
     if (holder === undefined) return undefined
     const where = holder.pid ? `pid ${holder.pid}${holder.host ? ` on ${holder.host}` : ''}` : 'unknown process'
     return `The Bot team in ${home} is open in another dsh (Web or Desktop, ${where}). This window shows the team but cannot change it; close the other one and reload.`
   }
 
   const readFileState = async () => {
+    let contents
     try {
+      contents = await readFile(statePath, 'utf8')
+    } catch (error) {
       seen = stamp()
-      const parsed = JSON.parse(await readFile(statePath, 'utf8'))
-      return parsed?.version === 1 ? parsed : undefined
+      if (error?.code === 'ENOENT') {
+        stuck = undefined
+        return undefined
+      }
+      stuck = error?.code ?? error?.message ?? String(error)
+      warn('ds-bot: unreadable state %s: %s', statePath, error)
+      return undefined
+    }
+    seen = stamp()
+    let parsed
+    try {
+      parsed = JSON.parse(contents)
     } catch (error) {
-      if (error?.code !== 'ENOENT') warn('ds-bot: unreadable state %s: %s', statePath, error)
+      const backup = `${statePath}.broken-${Date.now()}`
+      try {
+        await copyFile(statePath, backup)
+        stuck = undefined
+        warn('ds-bot: unreadable state %s: %s; backed up as %s', statePath, error, backup)
+      } catch (copyError) {
+        stuck = copyError?.code ?? copyError?.message ?? error?.message ?? String(error)
+        warn('ds-bot: unreadable state %s: %s; backup failed: %s', statePath, error, copyError)
+      }
       return undefined
     }
+    if (parsed?.version === 1) {
+      stuck = undefined
+      return parsed
+    }
+    stuck = 'saved by a newer DS Bot; update DS Bot'
+    return undefined
   }
 
   // Fill `state` from the saved file and bring an older team up to date. Returns the
@@ -129,7 +160,15 @@ export function install(rt) {
     if (holder !== undefined) warn('ds-bot: %s', readOnly())
     const { migrated, stale } = adopt(await readFileState())
     if (holder !== undefined) return
-    if (migrated) await save()
+    if (migrated && stuck === undefined) {
+      // A failed write must not poison `loaded`: the migrated state stays in
+      // memory and the next save() writes it.
+      try {
+        await save()
+      } catch (error) {
+        warn('ds-bot: saving the migrated Bot team failed: %s', error)
+      }
+    }
     // Not awaited: renaming a session must not hold up the first roster read.
     for (const room of stale) void rt.retitleRoom(room)
   })()
@@ -137,18 +176,42 @@ export function install(rt) {
   // A reading host follows the file and takes over once the other host has gone.
   const refresh = async () => {
     await load()
-    if (holder === undefined) return
-    claimLock()
-    if (holder === undefined) {
-      warn('ds-bot: the other dsh has closed; this one now saves the Bot team')
-      warnedReadOnly = false
-      adopt(await readFileState())
-      return
+    const hadHolder = holder !== undefined
+    if (hadHolder) {
+      claimLock()
+      if (holder === undefined) {
+        warn('ds-bot: the other dsh has closed; this one now saves the Bot team')
+        warnedReadOnly = false
+        adopt(await readFileState())
+        return
+      }
+    } else if (!lockBroken && !lock.owns()) {
+      // A cached "writer" is stale once the lock file no longer names this host:
+      // another dsh may have taken it over, or the file may just be gone. Re-claim
+      // and re-check instead of trusting the flag.
+      claimLock()
+      if (lockBroken) return
+      if (holder === undefined) {
+        // The lock was free: still the writer, but the file may carry changes
+        // written while no host held it.
+        warnedReadOnly = false
+        adopt(await readFileState())
+        return
+      }
+      warn('ds-bot: %s', readOnly())
     }
-    if (stamp() !== seen) adopt(await readFileState())
+    if ((stuck !== undefined || holder !== undefined) && stamp() !== seen) adopt(await readFileState())
   }
 
+  const warnReadOnly = () => {
+    if (!warnedReadOnly) {
+      warnedReadOnly = true
+      warn('ds-bot: not saving the Bot team: %s', readOnly())
+    }
+    return false
+  }
   const writable = () => {
+    if (stuck !== undefined) return warnReadOnly()
     if (lockBroken) return true
     if (holder === undefined && lock.owns()) return true
     // Lost the lock: retake it when nobody else holds it (its file was deleted), else
@@ -157,31 +220,50 @@ export function install(rt) {
       claimLock()
       if (holder === undefined) return true
     }
-    if (!warnedReadOnly) {
-      warnedReadOnly = true
-      warn('ds-bot: not saving the Bot team: %s', readOnly())
-    }
-    return false
+    return warnReadOnly()
   }
 
   const save = () => {
+    if (stopped) return writing
     indexSessions()
     // A reading host keeps the file's revision, so its window does not skip the next change.
     if (!writable()) return writing
     state.revision += 1
     state.exchanges = state.exchanges.slice(-MAX_EXCHANGES)
     const snapshot = JSON.stringify(state, null, 2)
-    writing = writing.then(async () => {
-      await mkdir(home, { recursive: true })
+    const run = writing.then(async () => {
       const temp = `${statePath}.${process.pid}.tmp`
-      await writeFile(temp, snapshot, 'utf8')
-      await rename(temp, statePath)
-      seen = stamp()
-    }).catch(error => { warn('ds-bot: state write failed: %s', error) })
-    return writing
+      try {
+        await mkdir(home, { recursive: true })
+        const ensureLock = () => {
+          if (lockBroken) return
+          if (!lock.owns()) {
+            const error = new Error('ds-bot lost the state lock to another dsh')
+            error.code = 'ELOCKLOST'
+            throw error
+          }
+        }
+        ensureLock()
+        await writeFile(temp, snapshot, 'utf8')
+        ensureLock()
+        await rename(temp, statePath)
+        seen = stamp()
+      } catch (error) {
+        await unlink(temp).catch(() => {})
+        throw error
+      }
+    })
+    writing = run.catch(() => {})
+    return run.catch(error => {
+      warn('ds-bot: state write failed: %s', error)
+      throw error
+    })
   }
 
-  ctx.effect(() => () => lock.release(), 'ds-bot: state lock')
+  ctx.effect(() => () => {
+    stopped = true
+    return writing.finally(() => lock.release())
+  }, 'ds-bot: state lock')
 
   const botOf = id => (id === undefined ? undefined : state.bots[id])
   const roomOf = id => (id === undefined ? undefined : state.rooms[id])
@@ -233,7 +315,10 @@ export function install(rt) {
     delete room.sessions[botId]
     if (room.segments !== undefined) delete room.segments[botId]
     groupOwners.delete(sessionId)
-    void ctx.workspaceRegistry.archiveSession(sessionId).catch(() => {})
+    rt.cancelApprovals?.(sessionId)
+    // A plain archive refuses a running Session, which would go on working for a group
+    // that no longer has it.
+    void ctx.workspaceRegistry.archiveSession(sessionId, { stopActivity: true }).catch(() => {})
   }
   const findBot = (ref) => {
     if (ref === undefined) return undefined

package/src/host/time-context.js

@@ -0,0 +1,46 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+
+const SOURCE = 'ds-bot-time-context'
+const isClock = source => source?.kind === SOURCE || source?.kind === 'time-context'
+
+export function install(rt) {
+  const { ctx, config } = rt
+  const interval = config.timeRefreshIntervalMs ?? 600_000
+  if (!Number.isSafeInteger(interval) || interval < 0) throw new TypeError('timeRefreshIntervalMs must be a non-negative safe integer')
+  const formatter = new Intl.DateTimeFormat('en-CA', {
+    ...(config.timeZone ? { timeZone: config.timeZone } : {}),
+    year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
+    timeZoneName: 'longOffset',
+  })
+  const zone = formatter.resolvedOptions().timeZone
+
+  ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+    const decision = await next()
+    if (decision.kind === 'reject' || signal.aborted) return decision
+    await rt.load()
+    if (!rt.isBotSession(agent.id) || signal.aborted) return decision
+    // A loaded DSH clock covers every step itself. Its listener may run before or
+    // after this one (a reload reorders them), so its presence is read from its
+    // projection, not from the messages added so far.
+    if (ctx.get?.('sessionProjections')?.stateOf(agent.session, 'timeContext') !== undefined) return decision
+    if (decision.messages.some(message => isClock(message.source))) return decision
+    const now = Date.now()
+    for await (const event of rt.eventsBackwards(agent.id, signal, Infinity)) {
+      if (event.type === 'user/message' && isClock(event.data.source)) {
+        if (now >= event.time && now - event.time < interval) return decision
+        break
+      }
+      if (event.time <= now - interval) break
+    }
+    if (signal.aborted) return decision
+    const text = `Current time: ${formatter.format(now)} (${zone}).`
+    return {
+      ...decision,
+      messages: [...decision.messages, createUserMessage({
+        content: [{ type: 'text', text }],
+        source: { kind: SOURCE, form: 'snapshot', sections: [{ name: SOURCE, text }] },
+      })],
+    }
+  }, { prepend: true })
+}

package/src/host/tools.js

@@ -1,9 +1,8 @@
 // Team tools: the roster, bot-to-bot messages, group chat settings and posts, and the
 // question card. Group rounds and reading chats are in groups.js.
 import { randomUUID } from 'node:crypto'
-import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { defineTool } from '@deepseek-ai/dsh-tools'
-import { COLORS, EXTRA_COLORS, MAX_HOPS, ROOM_BOT_ROUNDS, ROOM_MODES, SOURCE_KIND } from './constants.js'
+import { COLORS, EXTRA_COLORS, MAX_HOPS, ROOM_BOT_ROUNDS, ROOM_MODES } from './constants.js'
 import { unquote } from './text.js'
 
 export const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: String(value) }] }
@@ -58,9 +57,21 @@ export function install(rt) {
     },
   }))
 
+  // Sessions a Bot is running in right now: its own chat plus each group Session
+  // with a live turn. An idle Bot reports just its own chat.
+  const activeSessions = (botId) => {
+    const running = [...new Set([rt.chatOf(botId), ...rt.groupSessionsOf(botId)])]
+      .filter(sessionId => rt.live.get(sessionId)?.turn !== undefined)
+    return { running, idle: running.length === 0 }
+  }
+  const whereOf = (sessionId) => {
+    const room = rt.roomOf(rt.groupOwners.get(sessionId)?.roomId)
+    return room ? `group "${room.name}"` : 'its own chat'
+  }
+
   ctx.tools.register(defineTool({
     name: 'message_bot',
-    description: 'Send an asynchronous message to another Bot on the team. By default its reply arrives later as a new message to you; with reply_to "user" it answers the user in its own chat instead.',
+    description: 'Send a message to another Bot on the team. If that Bot is working, it reads your message at its next step and can change course, then answers once that work is done; if it is idle, it starts on it right away. Its reply arrives later as a new message to you; with reply_to "user" it answers the user in its own chat instead.',
     parameters: {
       to: { type: 'string', required: true, description: 'Exact Bot name from list_bots' },
       message: { type: 'string', required: true, description: 'Self-contained message; the other Bot cannot see this conversation' },
@@ -69,6 +80,11 @@ export function install(rt) {
         enum: ['me', 'user'],
         description: '"me" (default): the reply comes back to you and the user does not see it. "user": the Bot answers the user in its own chat, where the user reads it, and nothing comes back to you. Use "user" whenever the user wants to hear from that Bot directly or asks Bots to say something in their own chats.',
       },
+      when: {
+        type: 'string',
+        enum: ['now', 'queue'],
+        description: '"now" (default): a working Bot reads your message at its next step, between its current actions, and answers once its current work is done; use it for questions, information it needs, corrections and warnings. "queue": it reads your message only after its current work is done, as a separate task; use it only for a new task unrelated to what it is doing now. With reply_to "user" the message always queues.',
+      },
     },
     output,
     async execute(args, exec) {
@@ -78,13 +94,56 @@ export function install(rt) {
       const target = rt.findBot(args.to)
       if (target === undefined) return `No Bot named ${args.to}. Team: ${Object.values(state.bots).map(bot => bot.name).join(', ')}`
       if (target.id === sender.id) return 'You cannot message yourself.'
-      const hop = (rt.live.get(exec.agent?.id)?.info?.hop ?? 0)
+      const turn = rt.live.get(exec.agent?.id)
+      const hop = Math.max(turn?.info?.hop ?? 0, ...(turn?.joined ?? []).map(joined => joined.info?.hop ?? 0))
       if (hop >= MAX_HOPS) return 'This chain of Bot messages is already long. Stop here and report to the user instead.'
       const toUser = args.reply_to === 'user'
-      await rt.deliver({ fromId: sender.id, toId: target.id, text: args.message, role: 'request', hop, ...(toUser ? { audience: 'user' } : {}) })
-      return toUser
+      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' } : {}) })
+      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.`
-        : `Delivered to ${target.name}. Its reply will arrive later as a new message; do not wait for it.`
+        : working && steer
+          ? `Delivered to ${target.name} while it is working: it reads your message at its next step and answers once that work is done. Its reply will arrive later as a new message; do not wait for it.`
+          : working
+            ? `Queued for ${target.name}: it reads your message after its current work. Its reply will arrive later as a new message; do not wait for it.`
+            : `Delivered to ${target.name}. Its reply will arrive later as a new message; do not wait for it.`
+      // Messages reach a Bot's own chat only; work in a group goes on without them.
+      const groups = activeSessions(target.id).running.filter(sessionId => sessionId !== rt.chatOf(target.id))
+      if (groups.length === 0) return sent
+      const stop = rt.isMain(sender.id) ? ' If it must not go on there, use stop_bot.' : ''
+      return `${sent} ${target.name} is also working in ${groups.map(whereOf).join(' and ')}; your message does not reach that work.${stop}`
+    },
+  }))
+
+  // stop_bot throws when it does nothing, so the chat shows the call as failed
+  // instead of "Stopped".
+  const refuse = (message) => { throw new Error(message) }
+
+  ctx.tools.register(defineTool({
+    name: 'stop_bot',
+    description: 'Main Bot only. Stop another Bot\'s running turn immediately — when it must not finish a dangerous action and a message_bot warning is not enough. Its queued messages are dropped with the turn. It is then told why in a new turn, whose reply comes back to you.',
+    parameters: {
+      bot: { type: 'string', required: true, description: 'Exact Bot name from list_bots' },
+      reason: { type: 'string', description: 'Why it was stopped; it reads this afterwards' },
+    },
+    output,
+    async execute(args, exec) {
+      await rt.load()
+      const sender = callerBot(exec)
+      if (sender === undefined || !rt.isMain(sender.id)) refuse('Only a Main Bot can stop other Bots.')
+      const target = rt.findBot(args.bot)
+      if (target === undefined) refuse(`No Bot named ${args.bot}. Team: ${Object.values(state.bots).map(bot => bot.name).join(', ')}`)
+      if (target.id === sender.id) refuse('You cannot stop yourself.')
+      const { running } = activeSessions(target.id)
+      if (running.length === 0) refuse(`${target.name} is not running right now, so there is nothing to stop. Use message_bot to reach it.`)
+      for (const sessionId of running) {
+        const agent = await rt.resolveAgent(sessionId)
+        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' })
+      return `Stopped ${target.name} in ${running.map(whereOf).join(' and ')}. It is told why in a new turn, whose reply comes back to you.`
     },
   }))
 
@@ -113,9 +172,9 @@ export function install(rt) {
 
   ctx.tools.register(defineTool({
     name: 'update_bot',
-    description: 'Main Bot only. Rename a Bot or change its role, color, model, or instructions.',
+    description: 'Change a Bot\'s name, role, color, model, or instructions. Every Bot may change itself; only a Main Bot may change another Bot.',
     parameters: {
-      bot: { type: 'string', required: true, description: 'Current Bot name' },
+      bot: { type: 'string', description: 'Current name of the Bot to change; leave out to change yourself' },
       name: { type: 'string', description: 'New name' },
       role: { type: 'string', description: 'New role label' },
       instructions: { type: 'string', description: 'Replacement instructions' },
@@ -125,9 +184,12 @@ export function install(rt) {
     output,
     async execute(args, exec) {
       await rt.load()
-      if (!rt.isMain(rt.selfOf(exec.agent?.id))) return 'Only the Main Bot can update Bots.'
-      const bot = rt.findBot(args.bot)
+      const self = rt.selfOf(exec.agent?.id)
+      const caller = rt.botOf(self)
+      if (caller === undefined) return 'Only Bots on the team can use update_bot.'
+      const bot = args.bot ? rt.findBot(args.bot) : caller
       if (bot === undefined) return `No Bot named ${args.bot}.`
+      if (bot.id !== caller.id && !rt.isMain(self)) return 'Only a Main Bot can change another Bot. Leave out bot to change yourself, or ask a Main Bot with message_bot.'
       try {
         const { name: newName, role, instructions, color, model } = args
         const next = await rt.updateBot(bot.id, { name: newName, role, instructions, color, ...(model ? { model } : {}) })
@@ -294,22 +356,7 @@ export function install(rt) {
       await rt.save()
       const reportBack = args.report_back === true
       try {
-        const agent = await rt.resolveAgent(room.id)
-        agent.followup(createUserMessage({
-          content: [{ type: 'text', text: `[Group post from ${sender.name}]\n${text}` }],
-          source: {
-            kind: SOURCE_KIND,
-            form: 'relay',
-            role: 'post',
-            exchangeId: randomUUID(),
-            senderName: sender.name,
-            senderSessionId: sender.id,
-            roomId: room.id,
-            hop: info?.hop ?? 0,
-            ...(reportBack ? { reportBack: true } : {}),
-          },
-        }))
-        await ctx.sessions.flush(agent.session)
+        await rt.postToRoom(room, sender, text, { hop: info?.hop ?? 0, ...(reportBack ? { reportBack: true } : {}) })
       } catch (failure) {
         return `Could not post in "${room.name}": ${failure.message}`
       }
@@ -354,9 +401,13 @@ export function install(rt) {
         .filter(option => option.label !== '')
         .slice(0, 6)
       if (options.length === 0) return 'Give at least one option.'
+      // A hidden Bot-to-Bot turn shows none of its calls, so its card goes to the
+      // composer dock, which takes questions without a call.
+      const turn = rt.live.get(id)?.turn
+      const hidden = turn !== undefined && (state.exchangeTurns[id] ?? []).includes(turn)
       state.questions[id] = {
         id: randomUUID(),
-        ...(exec.callId ? { callId: exec.callId } : {}),
+        ...(exec.callId && !hidden ? { callId: exec.callId } : {}),
         question: String(args.question ?? '').trim(),
         ...(args.detail ? { detail: String(args.detail).trim() } : {}),
         options,