ds-bot 0.1.2 → 0.1.4

package/src/host/memory.js

@@ -44,6 +44,9 @@ const QUERY_TERMS_MAX = 6
 const SOURCE_READ_MS = 5_000
 const MODEL_TIMEOUT_MS = 120_000
 const SUMMARY_MAX_TOKENS = 2_048
+// A reply cut off at the limit is tried once more with room for reasoning plus
+// the answer; a model that thinks can spend the smaller budget thinking alone.
+const SUMMARY_RETRY_MAX_TOKENS = 8_192
 const SUMMARY_TEXT_MAX = 8_000
 const ASK_TEXT_MAX = 2_000
 const ASK_CHANGES_MAX = 20
@@ -905,24 +908,32 @@ export function install(rt) {
   // the tag the meter would file them under "other".
   async function oneShot(route, system, text, tag) {
     const info = await ctx.llm.resolveModelInfo(route.provider, route.model).catch(() => undefined)
-    const off = info?.reasoning?.efforts?.some(effort => effort.id === 'off')
-    const assembler = new BlockAssembler()
+    const efforts = info?.reasoning?.efforts ?? []
+    // Thinking counts against the same output budget as the answer, so ask for
+    // the least the model offers: 'off' when it has one, else its lowest level.
+    const effort = efforts.some(entry => entry.id === 'off') ? 'off' : efforts.at(0)?.id
     const messages = [{ role: 'user', content: [{ type: 'text', text }] }]
     if (tag !== undefined) rt.tagUsage?.(messages, tag)
-    for await (const chunk of ctx.llm.stream({
-      provider: route.provider,
-      model: route.model,
-      ...(off ? { reasoningEffort: 'off' } : {}),
-      system,
-      messages,
-      maxTokens: SUMMARY_MAX_TOKENS,
-      signal: AbortSignal.timeout(MODEL_TIMEOUT_MS),
-    })) assembler.push(chunk)
-    const finish = assembler.finish
-    if (finish.kind === 'error' || finish.kind === 'aborted') throw new Error(finish.failure?.message ?? finish.kind)
-    const reply = assembler.blocks().filter(block => block.type === 'text').map(block => block.text).join('\n').trim()
-    if (reply === '') throw new Error('The model wrote nothing')
-    return reply
+    for (const maxTokens of [SUMMARY_MAX_TOKENS, SUMMARY_RETRY_MAX_TOKENS]) {
+      const assembler = new BlockAssembler()
+      for await (const chunk of ctx.llm.stream({
+        provider: route.provider,
+        model: route.model,
+        ...(effort === undefined ? {} : { reasoningEffort: effort }),
+        system,
+        messages,
+        maxTokens,
+        signal: AbortSignal.timeout(MODEL_TIMEOUT_MS),
+      })) assembler.push(chunk)
+      const finish = assembler.finish
+      if (finish.kind === 'error' || finish.kind === 'aborted') throw new Error(finish.failure?.message ?? finish.kind)
+      const reply = assembler.blocks().filter(block => block.type === 'text').map(block => block.text).join('\n').trim()
+      if (finish.kind !== 'max-tokens' && reply !== '') return reply
+      // A reply cut off at the limit — all of it thinking, or a half-written
+      // answer — is dropped, never used; the retry gives it room once.
+      if (finish.kind !== 'max-tokens' && maxTokens === SUMMARY_MAX_TOKENS) throw new Error('The model wrote nothing')
+    }
+    throw new Error(`The model's reasoning used up the output budget (${SUMMARY_MAX_TOKENS} and ${SUMMARY_RETRY_MAX_TOKENS} tokens); no complete answer was written`)
   }
 
   /** @type {Map<string, {hash:string, text:string, at:number}>} */

package/src/host/parts.js

@@ -18,7 +18,7 @@ import { randomUUID } from 'node:crypto'
 import { BlockAssembler, createUserMessage } from '@deepseek-ai/dsh-llm'
 import { HISTORY_TIMEOUT_MS, REPLY_KIND, SOURCE_KIND } from './constants.js'
 import { CHECKPOINT_PROMPT, STEWARD_SYSTEM, checkpointCount, checkpointTail, checkpointTailNote, checkpointText, linesFor, parseDecision, stewardRequest } from './steward.js'
-import { clip, createClock, escapeRegExp, estimateTokens, textOf } from './text.js'
+import { clip, createClock, escapeRegExp, estimateTokens, splitRef, textOf } from './text.js'
 
 // An ask_user card as the user saw it. The user's reply is often just an option label,
 // which means nothing without the card. Arguments the tool would refuse (no question,
@@ -136,13 +136,32 @@ export function install(rt) {
   const NOTE_COOLDOWN_MS = [60_000, 300_000, 900_000]
   const SWITCH_ATTEMPTS = 5
   const OVERFLOW = 'CONTEXT_WINDOW_EXCEEDED'
+  // A failed connection says nothing about the conversation, so it never moves a part on.
+  const STUCK_CODES = ['INVALID_REQUEST', 'IMAGE_OFFLOAD_REQUIRED']
   const ORIGINAL_COMPACT = Symbol.for('ds-bot/compaction')
   const HANDOFF_ACK = 'Noted. I have my handoff note and carry on from here.'
   const STEWARD_MAX_TOKENS = 4_096
   const STEWARD_TIMEOUT_MS = 120_000
   const STEWARD_LINES = 40
 
-  const tokensOf = session => ctx.get('tokenMeter')?.measure(session).totalTokens
+  // A broken provider adapter must not crash every turn; estimate from the
+  // derived messages instead, with one warning.
+  let measureWarned = false
+  const tokensOf = (session) => {
+    try {
+      return ctx.get('tokenMeter')?.measure(session).totalTokens
+    } catch (error) {
+      if (!measureWarned) {
+        measureWarned = true
+        rt.warn('ds-bot: token measure failed; context sizes are estimated: %s', error)
+      }
+    }
+    try {
+      return estimateTokens(session.deriveMessages().map(message => textOf(message.content)).join('\n'))
+    } catch {
+      return undefined
+    }
+  }
   const clock = createClock(config.timeZone)
 
   // Lines for the model the Session last routed to; undefined while it has not
@@ -528,18 +547,22 @@ export function install(rt) {
   // together without the model carries the last note the model wrote.
   function noteText(segment) {
     if (segment?.fallback === undefined) return segment?.note
-    const why = segment.fallback === 'overflow' ? 'the part overflowed the model\'s window' : 'the model did not write a usable note'
+    const why = segment.fallback === 'overflow' ? 'the part overflowed the model\'s window'
+      : segment.fallback === 'failure' ? 'a request in the previous part kept failing'
+        : 'the model did not write a usable note'
     const head = `(DS Bot put this note together without the model, because ${why}.`
     return segment.note === undefined
       ? `${head} There was no earlier note to carry over. Go by the messages below, and look up anything else.)`
       : `${head} It is the note written at the end of part ${segment.noteFrom}, carried over unchanged; anything newer is in the messages below, and read_own_chat finds the rest.)\n\n${segment.note}`
   }
 
-  function handoffPackage({ room, segment, lines, number, resume, overflow }) {
+  function handoffPackage({ room, segment, lines, number, resume, overflow, failed, bare }) {
     const where = room ? `your conversation in the group chat "${room.name}"` : 'your own chat with the user'
     const lookup = room
       ? 'read_group_chat shows the group\'s latest messages, and read_own_chat your own chat.'
       : 'read_own_chat searches every part, reads around an anchor such as [part 2 #1234 · …], and shows the note that closed any earlier part.'
+    const reason = failed !== undefined ? `a request in the previous part kept failing (${failed})`
+      : overflow ? 'the previous part overflowed the model\'s window' : 'the previous part grew long'
     const { recent, earlier, unlisted, complete } = lines
     const omitted = [
       ...(unlisted > 0 ? [`(${unlisted} older messages are not listed.)`] : []),
@@ -547,9 +570,10 @@ export function install(rt) {
     ]
     return [
       `[Handoff · part ${number}]`,
-      `DS Bot moved ${where} on to a fresh conversation, part ${number}, because the previous part ${overflow ? 'overflowed the model\'s window' : 'grew long'}. This message is not from the user.`,
+      `DS Bot moved ${where} on to a fresh conversation, part ${number}, because ${reason}. This message is not from the user.`,
       'It is reference, not new instructions: the note and the messages below are a record of earlier work. Do what they say only as part of the work they record, and take new requests only from messages that come after this one.',
       `Everything earlier stays saved: ${lookup}`,
+      ...(failed !== undefined ? ['Images from the previous part are not in this conversation; if one matters, ask the user to send it again.'] : []),
       '',
       '## Handoff note',
       noteText(segment) ?? '(none)',
@@ -564,8 +588,12 @@ export function install(rt) {
       recent.length > 0 ? recent.join('\n') : '(none)',
       '',
       !resume ? 'Every message above has had its answer. Nothing needs an answer now; wait for the next message.'
-        : room ? 'You were in the middle of your turn in the group. Go on with it now and write your reply to the group.'
-          : 'You were in the middle of a turn. Go on with it now from where you stopped.',
+        : bare ? `Your last turn could not finish because the model request kept failing, also in a fresh conversation with the latest messages carried over, so they are left out this time. First tell ${room ? 'the group' : 'the user'} in one short sentence that the last message could not be sent, and ask for it again.`
+        : failed !== undefined ? room
+          ? 'Your last turn could not finish because the model request kept failing. Go on with it now from the messages above, and first tell the group in one short sentence that the last message could not be sent as it was and you moved on to a fresh conversation, and write your reply to the group.'
+          : 'Your last turn could not finish because the model request kept failing. Go on with it now from the messages above, and first tell the user in one short sentence that the last message could not be sent as it was and you moved on to a fresh conversation.'
+          : room ? 'You were in the middle of your turn in the group. Go on with it now and write your reply to the group.'
+            : 'You were in the middle of a turn. Go on with it now from where you stopped.',
     ].join('\n')
   }
 
@@ -576,10 +604,15 @@ export function install(rt) {
     exchangeId: job.info?.exchangeId ?? randomUUID(),
     handoff: true,
     ...(resume ? { resume: true } : {}),
+    ...(resume && job.joined?.length ? { joined: job.joined } : {}),
   })
 
-  /** @type {Map<string, {botId:string, roomId?:string, carry:any[], info?:any, resume:boolean, overflow:boolean, hard:boolean, started?:boolean, moved?:boolean, noteFailed?:boolean}>} */
+  /** @type {Map<string, {botId:string, roomId?:string, carry:any[], info?:any, joined?:any[], resume:boolean, overflow:boolean, failed?:string, bare?:boolean, hard:boolean, started?:boolean, moved?:boolean, noteFailed?:boolean}>} */
   const switches = new Map()
+  // Parts opened because requests kept failing, until one of their turns ends well:
+  // 'carried' brought the latest messages along, 'bare' left them out.
+  /** @type {Map<string, 'carried'|'bare'>} */
+  const rescued = new Map()
   // Parts that have not started a turn yet, with their handoff package's size.
   const freshParts = new Map()
   // Context size where a part started, or where a checkpoint or a failed switch left
@@ -608,6 +641,7 @@ export function install(rt) {
   async function forward(owner, messages) {
     const target = currentOf(owner)
     if (target === undefined || messages.length === 0) return
+    await rt.ensureCapabilities(target)
     const agent = await rt.resolveAgent(target)
     for (const message of messages) {
       const copy = createUserMessage({ content: message.content, ...(message.source ? { source: message.source } : {}) })
@@ -620,10 +654,10 @@ export function install(rt) {
 
   // `hard`: past the hard line or the window, the part moves on even without a note
   // from the model.
-  function startSwitch(agent, { resume = false, carry = [], info, overflow = false, hard = overflow } = {}) {
+  function startSwitch(agent, { resume = false, carry = [], info, joined, overflow = false, failed, bare = false, hard = overflow } = {}) {
     const place = placeOf(agent.id)
     if (place === undefined || switches.has(agent.id) || readOnly()) return
-    const job = { ...place, carry: [...carry], info, resume, overflow, hard }
+    const job = { ...place, carry: [...carry], info, joined, resume, overflow, failed, bare, hard }
     switches.set(agent.id, job)
     void runSwitch(agent, job)
       .catch(error => rt.warn('ds-bot: %s did not move on to a fresh part: %s', rt.botOf(job.botId)?.name ?? agent.id, error))
@@ -637,9 +671,10 @@ export function install(rt) {
         // The stopped turn goes on where it was.
         const back = job.carry.splice(0)
         if (resume) {
+          const carried = job.joined?.length ? { joined: job.joined } : {}
           back.unshift(createUserMessage({
             content: [{ type: 'text', text: 'DS Bot paused your turn for a context check. Go on with it now from where you stopped.' }],
-            source: job.info ?? { kind: SOURCE_KIND, form: 'relay', role: 'resume', exchangeId: randomUUID(), senderName: 'DS Bot', hop: 0 },
+            source: job.info ? { ...job.info, ...carried } : { kind: SOURCE_KIND, form: 'relay', role: 'resume', exchangeId: randomUUID(), senderName: 'DS Bot', hop: 0, ...carried },
           }))
         }
         await forward(job, back).catch(error => rt.warn('ds-bot: input for %s was not handed on: %s', agent.id, error))
@@ -678,7 +713,7 @@ export function install(rt) {
     const number = parts.length
     let written
     let failure
-    if (!job.overflow) {
+    if (!job.overflow && job.failed === undefined) {
       try {
         written = await writeNote(agent, AbortSignal.any([signal, AbortSignal.timeout(NOTE_TIMEOUT_MS)]))
       } catch (error) {
@@ -699,15 +734,16 @@ export function install(rt) {
     if (failure !== undefined) rt.warn('ds-bot: handoff note for %s failed past the hard line; moving on with the earlier note: %s', bot.name, failure)
     const previous = parts.at(-2)
     const noted = written !== undefined ? { note: written.note }
-      : { fallback: job.overflow ? 'overflow' : 'failed', ...(previous?.note ? { note: previous.note, noteFrom: previous.noteFrom ?? previous.number } : {}) }
+      : { fallback: job.failed !== undefined ? 'failure' : job.overflow ? 'overflow' : 'failed', ...(previous?.note ? { note: previous.note, noteFrom: previous.noteFrom ?? previous.number } : {}) }
     const budget = Math.min(RECENT_TOKENS, Math.floor((lines?.check ?? 4 * RECENT_TOKENS) / 4))
-    const carried = await handoffLines(agent.id, { budget, group: room !== undefined, number })
+    const carried = job.bare ? { recent: [], earlier: [], unlisted: 0, complete: true } : await handoffLines(agent.id, { budget, group: room !== undefined, number })
     if (signal.aborted) throw signal.reason
     const freshId = await rt.createSession(room ? `${bot.name} · ${room.name}` : bot.name)
     const route = session.requestHeader()?.config
-    const model = route?.provider && route?.model ? `${route.provider}/${route.model}` : await rt.desiredModel(bot)
-    if (model !== undefined) {
-      await rt.selectSessionModel(freshId, model)
+    const ref = route?.provider && route?.model ? `${route.provider}/${route.model}` : await rt.desiredModel(bot)
+    if (ref !== undefined) {
+      const effort = route?.reasoningEffort ?? await rt.desiredEffort(bot, ref)
+      await rt.selectSessionModel(freshId, { ...splitRef(ref), ...(effort === undefined ? {} : { reasoningEffort: effort }) })
         .catch(error => rt.warn('ds-bot: model for the fresh part of %s not applied: %s', bot.name, error))
     }
     await rt.applyPermission(bot, freshId)
@@ -729,11 +765,13 @@ export function install(rt) {
       }
     }
     await rt.save()
+    if (job.failed !== undefined) rescued.set(freshId, job.bare ? 'bare' : 'carried')
     void rt.moveSchedules(agent.id, freshId)
     job.moved = true
     const resume = job.resume || job.overflow
-    const text = handoffPackage({ room, segment, lines: carried, number: number + 1, resume, overflow: job.overflow })
+    const text = handoffPackage({ room, segment, lines: carried, number: number + 1, resume, overflow: job.overflow, failed: job.failed, bare: job.bare })
     freshParts.set(freshId, estimateTokens(text))
+    await rt.ensureCapabilities(freshId)
     const fresh = await rt.resolveAgent(freshId)
     fresh.followup(createUserMessage({ content: [{ type: 'text', text }], source: handoffSource(job, resume) }))
     await ctx.sessions.flush(fresh.session)
@@ -781,10 +819,28 @@ export function install(rt) {
     // `messages` left the inbox for this step, so the switch carries them along.
     const entry = rt.liveOf(agent.id)
     entry.switched = true
-    startSwitch(agent, { resume: midTurn, carry: payload.messages, info: midTurn ? entry.info : undefined, hard: true })
+    startSwitch(agent, { resume: midTurn, carry: payload.messages, info: midTurn ? entry.info : undefined, joined: midTurn ? [...(entry.joined ?? [])] : undefined, hard: true })
     return { kind: 'reject' }
   }, { prepend: true })
 
+  ctx.on('agent/request-error', async (payload, next) => {
+    const failure = payload.failure
+    if (!STUCK_CODES.includes(failure?.code)) return next()
+    const decided = await next()
+    if (decided !== undefined || payload.signal?.aborted) return decided
+    await rt.load()
+    const { agent } = payload
+    if (!rt.isBotSession(agent.id) || switches.has(agent.id) || readOnly() || rescued.get(agent.id) === 'bare') return decided
+    // A provider may turn down one request for reasons of its own; a history that
+    // breaks every request fails the next turn as well.
+    if (failure.code === 'INVALID_REQUEST' && !STUCK_CODES.includes(lastTurnEnd(agent)?.data?.reason?.error?.code)) return decided
+    const entry = rt.liveOf(agent.id)
+    entry.switched = true
+    // The latest messages carried into a rescued part may be what breaks the request.
+    startSwitch(agent, { resume: true, info: entry.info, joined: [...(entry.joined ?? [])], overflow: true, failed: failure.code, bare: rescued.has(agent.id) })
+    return undefined
+  }, { prepend: true })
+
   ctx.on('agent/request-error', async (payload, next) => {
     if (payload.failure?.code !== OVERFLOW || payload.signal?.aborted) return next()
     await rt.load()
@@ -792,7 +848,7 @@ export function install(rt) {
     if (!rt.isBotSession(agent.id) || switches.has(agent.id) || readOnly()) return next()
     const entry = rt.liveOf(agent.id)
     entry.switched = true
-    startSwitch(agent, { resume: true, info: entry.info, overflow: true })
+    startSwitch(agent, { resume: true, info: entry.info, joined: [...(entry.joined ?? [])], overflow: true })
     return undefined
   }, { prepend: true })
 
@@ -819,8 +875,25 @@ export function install(rt) {
     }
   }
 
+  // The newest turn/end among the Session's last events in memory.
+  function lastTurnEnd(agent) {
+    const latest = agent.session.seq - 1
+    for (let seq = latest; seq >= Math.max(0, latest - 199); seq -= 1) {
+      const event = agent.session.eventAt?.(seq)
+      if (event?.type === 'turn/end') return event
+    }
+    return undefined
+  }
+
+  function releaseRescued(agent) {
+    if (!rescued.has(agent.id)) return
+    const end = lastTurnEnd(agent)
+    if (end !== undefined && end.data?.reason?.kind !== 'error') rescued.delete(agent.id)
+  }
+
   ctx.on('agent/status', ({ agent, status }) => {
     if (status === 'idle' && rt.isBotSession(agent.id)) {
+      releaseRescued(agent)
       void checkContext(agent).catch(error => rt.warn('ds-bot: context check for %s failed: %s', agent.id, error))
     }
   })
@@ -864,7 +937,7 @@ export function install(rt) {
       } else if (source?.kind === REPLY_KIND) {
         const reply = readReply(textOf(event.data.content))
         if (reply !== undefined) items.push({ kind: 'answer', questions: reply.questions, answers: reply.answers, time: event.time })
-      } else if (source?.kind === SOURCE_KIND && source.handoff !== true && ['request', 'reply', 'report'].includes(source.role)) {
+      } else if (source?.kind === SOURCE_KIND && source.handoff !== true && source.deferred !== true && ['request', 'reply', 'report', 'stopped'].includes(source.role)) {
         items.push({ kind: 'event', role: source.role, botId: source.senderSessionId ?? null, name: source.senderName ?? null, roomId: source.roomId ?? null, time: event.time })
       }
     }

package/src/host/prompt.js

@@ -5,14 +5,17 @@ const TEAM_RULES = [
   '## How your Bot team works',
   '- Every Bot is its own long-lived conversation with the user, with its own memory and computer.',
   '- The team changes over time. Call list_bots whenever you need to know who exists; do not rely on memory.',
-  '- message_bot sends an asynchronous message to another Bot. Its reply arrives later as a new "[Reply from …]" message. Never wait, poll, or resend.',
+  '- message_bot sends a message to another Bot. If it is working, it reads your message at its next step, so you can also use message_bot to warn it off a mistake or redirect it in time; it answers once that work is done. Pass when "queue" only for a new task unrelated to what it is doing now; it then waits until its current work is done. Its reply arrives later as a new "[Reply from …]" message. Never wait, poll, or resend.',
   '- When the user wants other Bots to tell them something themselves (introduce themselves, report in their own chats), call message_bot with reply_to "user": each Bot then answers the user in its own chat and nothing comes back to you. Do not relay those answers yourself.',
-  '- When a "[Message from …]" arrives, your final text in that turn is delivered back to that Bot automatically and the user does not see it. Answer it directly and briefly, as a list of facts. Never invent facts: say "not discussed yet" when you do not know.',
+  '- When a "[Message from …]" opens a turn, your final text in that turn is delivered back to that Bot automatically and the user does not see it. If one arrives while you are working on something else, take it into account in that work but do not answer it there: once the work is done, it comes back to you in a turn of its own to answer. Answer it directly and briefly, as a list of facts. Never invent facts: say "not discussed yet" when you do not know. If the message brings a request or a decision meant for the user, handle it in the same turn too — do the work, or ask the user with ask_user.',
   '- When a "[Message from … · the user sees your reply here]" arrives, your reply is shown to the user in your own chat and is not sent back. Talk to the user directly, as yourself.',
   '- When a "[Reply from …]" arrives, tell the user the outcome if it matters to them.',
   '- Chat like a teammate texting: short sentences, often two or three short messages instead of one long one, no headings. When the user asks for a deliverable (a plan, schedule, draft, or list), write it out in full in the chat; never claim you gave something you did not write. Mention other Bots by their exact name.',
+  '- Only for a direct user request in your own chat that needs several steps: write one short sentence of normal reply text before your first tool call, and make that tool call in the same response. Never start such a task with tools alone or end it with a promise. On long tasks, give brief factual updates only at meaningful milestones, then keep working.',
+  '- For "[Group chat …]", "[Message from …]", or "[Reply from …]" messages, do not write plans or progress updates: use tools silently, then reply with the answer. Simple answers do not need progress messages.',
   '- Offer choices with ask_user (a tap-to-answer card) instead of long option lists in text. Calling it ends your turn at once, so write everything you want to say before the call, in the same reply. The answer arrives as the user\'s next message. Never use ask_user_question: it blocks you, and messages from other Bots would queue behind it.',
-  '- You may be in group chats with the user and other Bots. You speak in each group from a separate conversation of yours, apart from your own chat with the user. There your turn arrives as a "[Group chat …]" message that shows the speaking order, and your reply is posted to the group. In a group, read_own_chat shows your own chat (the group sees that you looked; share only what the group needs). In your own chat, read_group_chat shows what was said in a group. A group may have an admin, who steers it: the admin can call members with @Name, change the group with update_group, and start a new discussion there with post_to_group.',
+  '- update_bot changes your own settings: name, role label, color, model, or instructions. Leave out bot to change yourself. Use it when the user asks you to change how you are set up. Only a Main Bot can change other Bots; when another Bot needs changing, ask a Main Bot.',
+  '- You may be in group chats with the user and other Bots. You speak in each group from a separate conversation of yours, apart from your own chat with the user. There your turn arrives as a "[Group chat …]" message that shows the speaking order, and your reply is posted to the group. When someone there asks you to do something, do the work in that turn: the group goes on without waiting, and your final reply is posted when you finish. Any member can hand work to another with @Name, and the one that asked answers the result. In a group, read_own_chat shows your own chat (the group sees that you looked; share only what the group needs). In your own chat, read_group_chat shows what was said in a group. A group may have an admin, who steers it: the admin can call members with @Name, change the group with update_group, and start a new discussion there with post_to_group.',
   '- When you need a key, token, or password, call request_secret: the user types it into a secure card and you never see it. Never ask the user to paste one into the chat. Use it through its environment variable ($DSH_SECRET_<NAME> in bash, $env:DSH_SECRET_<NAME> in PowerShell) and never print it. list_secrets shows which keys exist.',
   '- web_search results say which search backend answered. If web_search fails, never guess URLs or present pages you remember as search results: use a browser tool if you have one, otherwise tell the user that search is unavailable and the reason it gave.',
   '- Your conversations are long-lived. When one grows long, either its older messages are condensed in place into a summary you wrote (a "[Checkpoint N]" message), or it moves on to a fresh part that opens with a handoff note you wrote and your latest messages (a "[Handoff · part N]" message). What leaves your working context stays saved. When you need the exact earlier wording or a detail the summary or note does not show in full (a full path, a figure, every item of a complete list or a final summary), call read_own_chat with words to look for, or with part N to read the note that closed an earlier part; never fill such a detail in from memory. Each line it returns starts with an anchor such as [part 2 #1234 · 10-08 14:22]; pass the anchor as around to read what was said around it.',
@@ -25,6 +28,7 @@ const MAIN_RULES = [
   '- When the user wants something that deserves its own ongoing specialist, call create_bot (check list_bots first to avoid duplicates). Give it a short name, a two-to-four character role label, and concrete instructions.',
   '- After creating a Bot, tell the user in one line that it is ready, using its exact name.',
   '- Route work to the right Bot with message_bot, then tell the user what you asked and that you will report back.',
+  '- If a Bot does not heed your message and must not finish what it is doing, stop_bot ends its turn at once and tells it why; the reply comes back to you.',
   '- Every Bot runs on one model of its own (list_bots shows it). Pass model to create_bot or update_bot only when the user names one; list_models gives the provider/model refs.',
   '- Use update_bot to rename a Bot, change its role, color, model, or instructions when the user asks.',
   '- You run the group chats too. create_group makes a group (you join it as its admin unless you name another); update_group changes any group\'s name, notice, members, admin, or reply mode; post_to_group posts into any group as you, which starts a round of replies the user reads there; delete_group archives a group, only when the user asks. list_bots shows every group.',

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')
+}