ds-bot 0.1.3 → 0.1.5

package/src/host/parts.js

@@ -90,8 +90,9 @@ export function historyEntry(event, group) {
     const text = textOf(event.data?.message?.content)
     return text === '' ? undefined : { answer: true, text }
   }
-  // Cards only show in an own chat.
-  if (event.type === 'tool/call' && event.data?.name === 'ask_user' && !group) {
+  // Cards only show in an own chat. A PTC program's sub-call asks too.
+  const asks = (event.type === 'tool/call' || event.type === 'tool/ptc-dispatch-start') && event.data?.name === 'ask_user'
+  if (asks && !group) {
     const text = cardText(event.data.arguments)
     return text === '' ? undefined : { answer: true, text }
   }
@@ -143,6 +144,7 @@ export function install(rt) {
   const STEWARD_MAX_TOKENS = 4_096
   const STEWARD_TIMEOUT_MS = 120_000
   const STEWARD_LINES = 40
+  const FOLDER_RETRY_MS = 300_000
 
   // A broken provider adapter must not crash every turn; estimate from the
   // derived messages instead, with one warning.
@@ -312,7 +314,8 @@ export function install(rt) {
       complete = false
       rt.warn('ds-bot: reading %s for its handoff stopped early: %s', sessionId, error)
     }
-    return { recent: recent.reverse(), earlier: earlier.reverse(), unlisted, complete }
+    // `whole`: every message of the part is in `recent`.
+    return { recent: recent.reverse(), earlier: earlier.reverse(), unlisted, complete, whole: complete && !full }
   }
 
   // The note's sections, in order. A note without all of them is not used.
@@ -326,8 +329,8 @@ export function install(rt) {
     ['Next step', 'the single next action, with the words of the request it follows quoted exactly; "(none)" when nothing is pending'],
     ['Where to look', 'details this note leaves out that you may need again, each with a few words copied exactly from the message that holds it, for read_own_chat to search'],
   ]
-  const HANDOFF_PROMPT = [
-    'You are now writing a handoff note to yourself. This request comes from DS Bot, not from the user: do not answer or continue the messages above. Your conversation is long, so it moves on to a fresh conversation now. The fresh one starts with this note and your latest messages word for word; everything else leaves your working context. The full record stays saved, and you can search it later with read_own_chat. Write the note that lets you carry on as the same Bot without losing anything that matters.',
+  const handoffPrompt = why => [
+    `You are now writing a handoff note to yourself. This request comes from DS Bot, not from the user: do not answer or continue the messages above. ${why}, so it moves on to a fresh conversation now. The fresh one starts with this note and your latest messages word for word; everything else leaves your working context. The full record stays saved, and you can search it later with read_own_chat. Write the note that lets you carry on as the same Bot without losing anything that matters.`,
     '',
     'Output EXACTLY the Markdown structure below: every heading as written, in English and in this order. Write the content in the language the user writes in, as terse bullets. Write "(none)" under a heading with nothing to say.',
     '',
@@ -341,6 +344,8 @@ export function install(rt) {
     '- Do NOT mention this request or the move to a fresh conversation.',
     '- Output only the note, in at most about 2,000 words: no preface, and no tool calls.',
   ].join('\n')
+  const HANDOFF_PROMPT = handoffPrompt('Your conversation is long')
+  const FOLDER_PROMPT = handoffPrompt('Your working folder changed')
   const NOTE_RETRY_SHORTER = 'Your last note was cut off at the output limit, so it was not used. Write the whole note again, shorter: at most about 1,000 words. Keep every heading; drop detail before you drop facts.'
   const noteRetryMissing = missing => `Your last note lacked these headings, so it was not used: ${missing.map(name => `"## ${name}"`).join(', ')}. Write the whole note again with every heading exactly as given, in English.`
   const missingSections = note => NOTE_SECTIONS.map(([name]) => name)
@@ -349,16 +354,17 @@ export function install(rt) {
   // The same system prompt, tools, and messages as the conversation's own requests,
   // plus the note prompt; nothing is written into the Session. A cut-off note, or one
   // without every section, is asked for again once; then the note fails.
-  async function writeNote(agent, signal) {
+  async function writeNote(agent, signal, { folder = false } = {}) {
     const session = agent.session
     const header = session.requestHeader()
     const route = header?.config
     if (!route?.provider || !route?.model) throw new Error('the Session has not called a model yet')
     const messages = session.deriveMessages()
+    const base = folder ? FOLDER_PROMPT : HANDOFF_PROMPT
     let retry
     let problem
     for (let attempt = 1; attempt <= NOTE_ATTEMPTS; attempt += 1) {
-      const prompt = retry === undefined ? HANDOFF_PROMPT : `${HANDOFF_PROMPT}\n\n${retry}`
+      const prompt = retry === undefined ? base : `${base}\n\n${retry}`
       const assembler = new BlockAssembler()
       for await (const chunk of ctx.llm.stream({
         provider: route.provider,
@@ -489,6 +495,7 @@ export function install(rt) {
       system: STEWARD_SYSTEM,
       messages: rt.tagUsage([{ role: 'user', content: [{ type: 'text', text: stewardRequest({ lines, midTurn, checkpoints: checkpointCount(session.deriveMessages()), group }) }] }], { sessionId: agent.id, kind: 'compaction' }),
       maxTokens: STEWARD_MAX_TOKENS,
+      sessionId: session.id,
       purpose: 'compaction',
       signal: AbortSignal.timeout(STEWARD_TIMEOUT_MS),
     })) assembler.push(chunk)
@@ -547,6 +554,10 @@ 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
+    if (segment.fallback === 'whole') {
+      const head = '(No new note: every message of the part was carried over word for word.'
+      return segment.note === undefined ? `${head})` : `${head} Below is the note written at the end of part ${segment.noteFrom}, carried over unchanged.)\n\n${segment.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'
@@ -556,13 +567,14 @@ export function install(rt) {
       : `${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, failed, bare }) {
+  function handoffPackage({ room, segment, lines, number, resume, overflow, failed, bare, folder }) {
     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'
+      : overflow ? 'the previous part overflowed the model\'s window'
+        : folder !== undefined ? `your working folder changed to ${folder}` : 'the previous part grew long'
     const { recent, earlier, unlisted, complete } = lines
     const omitted = [
       ...(unlisted > 0 ? [`(${unlisted} older messages are not listed.)`] : []),
@@ -573,6 +585,7 @@ export function install(rt) {
       `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}`,
+      ...(folder !== undefined ? [`You now work in ${folder}: commands and file tools start there. Relative paths in the messages below meant the previous folder.`] : []),
       ...(failed !== undefined ? ['Images from the previous part are not in this conversation; if one matters, ask the user to send it again.'] : []),
       '',
       '## Handoff note',
@@ -607,8 +620,11 @@ export function install(rt) {
     ...(resume && job.joined?.length ? { joined: job.joined } : {}),
   })
 
-  /** @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}>} */
+  /** @type {Map<string, {botId:string, roomId?:string, carry:any[], info?:any, joined?:any[], resume:boolean, overflow:boolean, failed?:string, bare?:boolean, folder?:boolean, hard:boolean, started?:boolean, moved?:boolean, noteFailed?:boolean}>} */
   const switches = new Map()
+  // Parts whose move to their working folder failed, and the time before which it is
+  // not tried again.
+  const folderRetry = 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'>} */
@@ -641,6 +657,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 } : {}) })
@@ -652,11 +669,11 @@ 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, joined, overflow = false, failed, bare = false, hard = overflow } = {}) {
+  // from the model. `folder`: the part moves on because its working folder changed.
+  function startSwitch(agent, { resume = false, carry = [], info, joined, overflow = false, failed, bare = false, folder = false, hard = overflow || folder } = {}) {
     const place = placeOf(agent.id)
     if (place === undefined || switches.has(agent.id) || readOnly()) return
-    const job = { ...place, carry: [...carry], info, joined, resume, overflow, failed, bare, hard }
+    const job = { ...place, carry: [...carry], info, joined, resume, overflow, failed, bare, folder, 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))
@@ -664,8 +681,12 @@ export function install(rt) {
         switches.delete(agent.id)
         if (job.moved) {
           noteFailures.delete(agent.id)
+          folderRetry.delete(agent.id)
+          // The folder may have changed again while the switch ran.
+          if (job.roomId === undefined) void followFolder(job.botId)
           return
         }
+        if (folder) folderRetry.set(agent.id, Date.now() + FOLDER_RETRY_MS)
         if (!job.noteFailed) partBase.set(agent.id, tokensOf(agent.session) ?? 0)
         // The stopped turn goes on where it was.
         const back = job.carry.splice(0)
@@ -710,11 +731,16 @@ export function install(rt) {
     const lines = await contextLines(session).catch(() => undefined)
     const parts = partsOf(bot.id, room?.id)
     const number = parts.length
+    const budget = Math.min(RECENT_TOKENS, Math.floor((lines?.check ?? 4 * RECENT_TOKENS) / 4))
+    const readLines = () => (job.bare ? { recent: [], earlier: [], unlisted: 0, complete: true } : handoffLines(agent.id, { budget, group: room !== undefined, number }))
+    let carried = job.folder ? await readLines() : undefined
+    // A short part with no tool work goes over word for word, so it needs no note.
+    const whole = carried?.whole === true && !session.deriveMessages().some(message => message.role === 'tool')
     let written
     let failure
-    if (!job.overflow && job.failed === undefined) {
+    if (!job.overflow && job.failed === undefined && !whole) {
       try {
-        written = await writeNote(agent, AbortSignal.any([signal, AbortSignal.timeout(NOTE_TIMEOUT_MS)]))
+        written = await writeNote(agent, AbortSignal.any([signal, AbortSignal.timeout(NOTE_TIMEOUT_MS)]), { folder: job.folder })
       } catch (error) {
         if (signal.aborted) throw error
         failure = error
@@ -733,11 +759,12 @@ 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.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 = job.bare ? { recent: [], earlier: [], unlisted: 0, complete: true } : await handoffLines(agent.id, { budget, group: room !== undefined, number })
+      : { fallback: whole ? 'whole' : job.failed !== undefined ? 'failure' : job.overflow ? 'overflow' : 'failed', ...(previous?.note ? { note: previous.note, noteFrom: previous.noteFrom ?? previous.number } : {}) }
+    carried ??= await readLines()
     if (signal.aborted) throw signal.reason
-    const freshId = await rt.createSession(room ? `${bot.name} · ${room.name}` : bot.name)
+    const dir = rt.workDirOf(job)
+    const intended = dir !== undefined && await rt.isFolder(dir) ? dir : rt.teamFolder()
+    const freshId = await rt.createSession(room ? `${bot.name} · ${room.name}` : bot.name, { dir })
     const route = session.requestHeader()?.config
     const ref = route?.provider && route?.model ? `${route.provider}/${route.model}` : await rt.desiredModel(bot)
     if (ref !== undefined) {
@@ -768,18 +795,26 @@ export function install(rt) {
     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, failed: job.failed, bare: job.bare })
-    freshParts.set(freshId, estimateTokens(text))
+    await rt.ensureCapabilities(freshId)
     const fresh = await rt.resolveAgent(freshId)
+    const cwd = fresh.session.header?.cwd
+    const folder = cwd !== undefined && cwd !== session.header?.cwd ? cwd : undefined
+    // A fresh part that is not where it was made for would move on at every step.
+    if (intended !== undefined && cwd !== undefined && cwd !== intended) {
+      folderRetry.set(freshId, Date.now() + FOLDER_RETRY_MS)
+      rt.warn('ds-bot: the fresh part of %s did not start in %s; it works in %s', bot.name, intended, cwd)
+    }
+    const text = handoffPackage({ room, segment, lines: carried, number: number + 1, resume, overflow: job.overflow, failed: job.failed, bare: job.bare, folder })
+    freshParts.set(freshId, estimateTokens(text))
     fresh.followup(createUserMessage({ content: [{ type: 'text', text }], source: handoffSource(job, resume) }))
     await ctx.sessions.flush(fresh.session)
     // Then what the old part held: the stopped turn's input, then whatever waited.
     const held = [...agent.inbox.nextStep, ...agent.inbox.nextTurn]
     for (const message of held) agent.inbox.remove(message.id)
     await forward(job, [...job.carry.splice(0), ...held])
-    ctx.logger.info('ds-bot: %s%s moved on to part %d at %d tokens (check line %d, hard line %d); %s; %d latest and %d earlier messages carried', bot.name, room ? ` in ${room.name}` : '', number + 1, tokens ?? -1, lines?.check ?? -1, lines?.hard ?? -1,
+    ctx.logger.info('ds-bot: %s%s moved on to part %d at %d tokens (check line %d, hard line %d); %s; %d latest and %d earlier messages carried%s', bot.name, room ? ` in ${room.name}` : '', number + 1, tokens ?? -1, lines?.check ?? -1, lines?.hard ?? -1,
       written !== undefined ? `note written in ${written.attempts} attempt(s)` : `note put together by DS Bot (${noted.fallback}${noted.note ? `, carries part ${noted.noteFrom}'s` : ', nothing to carry'})`,
-      carried.recent.length, carried.earlier.length)
+      carried.recent.length, carried.earlier.length, folder === undefined ? '' : `; now works in ${folder}`)
   }
 
   // Runs first: an earlier part hands its input on, a part past the hard line makes
@@ -805,21 +840,54 @@ export function install(rt) {
       freshParts.delete(agent.id)
       partBase.set(agent.id, (tokensOf(agent.session) ?? 0) + fresh)
     }
+    if (!readOnly() && await folderMove(agent, { midTurn: payload.step > 1 }) !== undefined) return switchBeforeStep(agent, payload, { folder: true })
     const lines = await contextLines(agent.session).catch(() => undefined)
     const tokens = tokensOf(agent.session)
     if (lines === undefined || tokens === undefined || tokens < lines.hard || !grown(agent.id, tokens, lines) || readOnly()) return next()
-    const midTurn = payload.step > 1
-    if (await decide(agent, { midTurn }) === 'compact' && await condense(agent, lines, { inTurn: true, signal: payload.signal })) return next()
-    if (switches.has(agent.id)) {
-      switches.get(agent.id).carry.push(...payload.messages)
+    if (await decide(agent, { midTurn: payload.step > 1 }) === 'compact' && await condense(agent, lines, { inTurn: true, signal: payload.signal })) return next()
+    return switchBeforeStep(agent, payload, { hard: true })
+  }, { prepend: true })
+
+  // `messages` left the inbox for this step, so the switch carries them along.
+  function switchBeforeStep(agent, payload, options) {
+    // A switch may have started while the checks above awaited.
+    const running = switches.get(agent.id)
+    if (running !== undefined) {
+      running.carry.push(...payload.messages)
       return { kind: 'reject' }
     }
-    // `messages` left the inbox for this step, so the switch carries them along.
+    const midTurn = payload.step > 1
     const entry = rt.liveOf(agent.id)
     entry.switched = true
-    startSwitch(agent, { resume: midTurn, carry: payload.messages, info: midTurn ? entry.info : undefined, joined: midTurn ? [...(entry.joined ?? [])] : undefined, hard: true })
+    startSwitch(agent, { resume: midTurn, carry: payload.messages, info: midTurn ? entry.info : undefined, joined: midTurn ? [...(entry.joined ?? [])] : undefined, ...options })
     return { kind: 'reject' }
-  }, { prepend: true })
+  }
+
+  // The folder a part should move to, when it is not the one the part was made in. A
+  // working folder that is gone counts as the team workspace, where a fresh part would
+  // start. A group reply ends where it began; the group conversation moves at its next
+  // turn there.
+  async function folderMove(agent, { midTurn = false } = {}) {
+    const place = placeOf(agent.id)
+    const cwd = agent.session.header?.cwd
+    if (place === undefined || cwd === undefined || (midTurn && place.roomId !== undefined) || Date.now() < (folderRetry.get(agent.id) ?? 0)) return undefined
+    const wanted = rt.workDirOf(place)
+    const target = wanted !== undefined && await rt.isFolder(wanted) ? wanted : rt.teamFolder()
+    return target === undefined || target === cwd ? undefined : target
+  }
+
+  // A Bot's own chat moves to its new folder now when it is idle; a running turn
+  // moves at its next step, and each group conversation at its next turn there.
+  async function followFolder(botId) {
+    const sessionId = rt.chatOf(botId)
+    if (sessionId === undefined || switches.has(sessionId) || readOnly()) return
+    try {
+      const agent = await rt.resolveAgent(sessionId)
+      if (agent.status === 'idle' && await folderMove(agent) !== undefined) startSwitch(agent, { folder: true })
+    } catch (error) {
+      rt.warn('ds-bot: %s did not move to its working folder: %s', rt.botOf(botId)?.name ?? botId, error)
+    }
+  }
 
   ctx.on('agent/request-error', async (payload, next) => {
     const failure = payload.failure
@@ -900,7 +968,7 @@ export function install(rt) {
   // in the part's history. When nothing is left to do, that turn's reply is a fixed
   // line instead of a model call.
   ctx.on('llm/stream', (options, next) => {
-    if (options.sessionId === undefined || options.purpose !== undefined) return next()
+    if (options.sessionId === undefined || options.purpose !== undefined || rt.ownRequest(options)) return next()
     const messages = options.messages ?? []
     const since = messages.findLastIndex(message => message.role === 'assistant' || message.role === 'tool') + 1
     const opened = messages.slice(since).filter(message => message.role === 'user' && (message.source?.kind === 'user' || message.source?.kind === SOURCE_KIND))
@@ -969,5 +1037,5 @@ export function install(rt) {
     }
   }
 
-  Object.assign(rt, { clock, partsOf, historyEntry, partLines, noteText, earlierPage, switchJobs: () => switches.values() })
+  Object.assign(rt, { clock, partsOf, historyEntry, partLines, noteText, earlierPage, followFolder, switchJobs: () => switches.values() })
 }

package/src/host/prompt.js

@@ -13,9 +13,9 @@ const TEAM_RULES = [
   '- 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.',
-  '- 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. 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.',
+  '- 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.',
+  '- update_bot changes your own settings: name, role label, color, model, working folder, or instructions. Leave out bot to change yourself. Use it when the user asks you to change how you are set up, for example to work in a project folder (work_dir, a full path). 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.',
@@ -30,8 +30,8 @@ const MAIN_RULES = [
   '- 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.',
+  '- Use update_bot to rename a Bot, change its role, color, model, working folder, 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, reply mode, or the folder every member works in there; 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.',
   '- The team can have more than one Main Bot; list_bots marks them. They share these powers, so coordinate with them through message_bot.',
 ].join('\n')
 

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