ds-bot 0.1.1 → 0.1.3

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
@@ -620,10 +653,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 +670,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 +712,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 +733,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,10 +764,11 @@ 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))
     const fresh = await rt.resolveAgent(freshId)
     fresh.followup(createUserMessage({ content: [{ type: 'text', text }], source: handoffSource(job, resume) }))
@@ -781,10 +817,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 +846,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 +873,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 +935,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,13 +5,16 @@ 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.',
+  '- 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.',
   '- 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.',
@@ -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/roster.js

@@ -4,6 +4,7 @@ import { mkdir } from 'node:fs/promises'
 import { join } from 'node:path'
 import { MAX_AVATAR_IMAGE, ROOM_MAX_MEMBERS, ROOM_MODES, ROOM_NAME_MAX, ROOM_NOTICE_MAX } from './constants.js'
 import { currentColor, isColor, unquote } from './text.js'
+import { nameProblem } from '../shared/mentions.js'
 
 export function install(rt) {
   const { ctx, config, home, defaults, state } = rt
@@ -56,52 +57,66 @@ export function install(rt) {
   // greeting waits until a model is chosen. So does a Bot made when no model is served.
   async function createBot({ name: botName, role = '', instructions = '', color, brief = '', createdBy, main = false, avatar, model, effort, copyOf, pickModel = false }) {
     const cleanName = String(botName ?? '').trim().slice(0, 40)
-    if (cleanName === '') throw new Error('A Bot needs a name')
+    const problem = nameProblem(cleanName)
+    if (problem !== undefined) throw new Error(problem)
     if (rt.findBot(cleanName)) throw new Error(`A Bot named ${cleanName} already exists`)
     const cleanAvatarValue = cleanAvatar(avatar)
     // The model is fixed at creation, so a later change of the DSH default leaves it alone.
     const modelRef = model ? await rt.resolveModel(model) : pickModel ? undefined : await rt.defaultModel()
     const effortId = modelRef !== undefined && effort !== undefined ? await rt.resolveEffort(modelRef, effort) : undefined
     const id = await createSession(cleanName)
-    state.bots[id] = {
-      id,
-      name: cleanName,
-      role: String(role).trim().slice(0, 24),
-      // A color is only stored when the user picks one; otherwise the id picks it.
-      ...(isColor(currentColor(color)) ? { color: currentColor(color) } : {}),
-      ...(cleanAvatarValue ? { avatar: cleanAvatarValue } : {}),
-      ...(modelRef ? { model: modelRef } : {}),
-      ...(effortId ? { effort: effortId } : {}),
-      instructions: String(instructions).trim(),
-      createdAt: Date.now(),
-      createdBy: createdBy ?? null,
-    }
-    if (main) state.mainBotIds.push(id)
-    const creator = rt.botOf(createdBy)
-    const original = rt.botOf(copyOf)
-    const language = rt.uiLanguage?.()
-    const kickoff = main
-      ? `You were just set up as the user's Main Bot. Greet the user in one or two short messages: say you will run their Bot team and that they can come to you for anything that needs a decision. Then use ask_user to ask what they want the team to help with first (3-4 short options). Write in ${language ?? 'the user\'s language if known; otherwise Chinese'}.`
-      : original
-        ? `The user just made you as a copy of ${original.name}: same job, fresh memory. Greet the user in one short message, then use ask_user to ask what this copy should focus on (3-4 short options).`
-        : creator
-          ? `${creator.name} just created you for the user.${brief ? ` Why you exist: ${brief}` : ''}\nGreet the user in one short message, then use ask_user to ask where to start (3-4 short options relevant to your role, with allowCustom). Keep it brief.`
-          : brief
-            ? `The user just created you and sent this first message:\n\n${brief}\n\nIntroduce yourself in one short line, then help with it.`
-            : 'The user just created you. Greet the user in one short message, then use ask_user to ask what you should focus on (3-4 short options, with allowCustom).'
-    const text = !main && language ? `${kickoff}\nWrite in ${language}.` : kickoff
-    const bot = state.bots[id]
-    if (modelRef === undefined) {
-      bot.kickoff = { text, from: createdBy ?? null, ...(main ? { main: true } : {}) }
+    try {
+      state.bots[id] = {
+        id,
+        name: cleanName,
+        role: String(role).trim().slice(0, 24),
+        // A color is only stored when the user picks one; otherwise the id picks it.
+        ...(isColor(currentColor(color)) ? { color: currentColor(color) } : {}),
+        ...(cleanAvatarValue ? { avatar: cleanAvatarValue } : {}),
+        ...(modelRef ? { model: modelRef } : {}),
+        ...(effortId ? { effort: effortId } : {}),
+        instructions: String(instructions).trim(),
+        createdAt: Date.now(),
+        createdBy: createdBy ?? null,
+      }
+      if (main) state.mainBotIds.push(id)
+      const creator = rt.botOf(createdBy)
+      const original = rt.botOf(copyOf)
+      const language = rt.uiLanguage?.()
+      const kickoff = main
+        ? `You were just set up as the user's Main Bot. Greet the user in one or two short messages: say you will run their Bot team and that they can come to you for anything that needs a decision. Then use ask_user to ask what they want the team to help with first (3-4 short options). Write in ${language ?? 'the user\'s language if known; otherwise Chinese'}.`
+        : original
+          ? `The user just made you as a copy of ${original.name}: same job, fresh memory. Greet the user in one short message, then use ask_user to ask what this copy should focus on (3-4 short options).`
+          : creator
+            ? `${creator.name} just created you for the user.${brief ? ` Why you exist: ${brief}` : ''}\nGreet the user in one short message, then use ask_user to ask where to start (3-4 short options relevant to your role, with allowCustom). Keep it brief.`
+            : brief
+              ? `The user just created you and sent this first message:\n\n${brief}\n\nIntroduce yourself in one short line, then help with it.`
+              : 'The user just created you. Greet the user in one short message, then use ask_user to ask what you should focus on (3-4 short options, with allowCustom).'
+      const text = !main && language ? `${kickoff}\nWrite in ${language}.` : kickoff
+      const bot = state.bots[id]
+      if (modelRef === undefined) {
+        bot.kickoff = { text, from: createdBy ?? null, ...(main ? { main: true } : {}) }
+        await rt.save()
+        return bot
+      }
       await rt.save()
+      // The greeting runs on the Bot's own model, once its provider is registered.
+      void rt.waitForModel(bot)
+        .then(() => rt.applyModel(bot).catch(error => rt.warn('ds-bot: model for %s not applied: %s', cleanName, error)))
+        .then(() => sendKickoff(bot, { text, from: createdBy }))
       return bot
+    } catch (error) {
+      // The Bot's Session was already made: archive it instead of leaving an orphan.
+      delete state.bots[id]
+      state.mainBotIds = state.mainBotIds.filter(other => other !== id)
+      rt.chatOwners.delete(id)
+      // A save that another change queued meanwhile still carries this Bot; a later
+      // one writes the team without it.
+      void rt.save().catch(() => {})
+      await ctx.workspaceRegistry.archiveSession(id)
+        .catch(archiveError => rt.warn('ds-bot: archiving the Session for %s failed: %s', cleanName, archiveError))
+      throw error
     }
-    await rt.save()
-    // The greeting runs on the Bot's own model, once its provider is registered.
-    void rt.waitForModel(bot)
-      .then(() => rt.applyModel(bot).catch(error => rt.warn('ds-bot: model for %s not applied: %s', cleanName, error)))
-      .then(() => sendKickoff(bot, { text, from: createdBy }))
-    return bot
   }
 
   function sendKickoff(bot, { text, from }) {
@@ -114,7 +129,7 @@ export function install(rt) {
     const bot = rt.botOf(botId)
     if (bot?.kickoff === undefined) return
     delete bot.kickoff
-    void rt.save()
+    void rt.save().catch(() => {})
   }
 
   async function duplicateBot(id) {
@@ -140,6 +155,9 @@ export function install(rt) {
       const next = String(patch.name).trim().slice(0, 40)
       const clash = rt.findBot(next)
       if (next === '' || (clash && clash.id !== id)) throw new Error(`Name ${next} is not available`)
+      // A name saved before the rule stays usable until it changes.
+      const problem = next === bot.name ? undefined : nameProblem(next)
+      if (problem !== undefined) throw new Error(problem)
       bot.name = next
       const agent = await rt.resolveAgent(rt.chatOf(id))
       await ctx.sessionTitle.rename(agent.session, next)
@@ -242,19 +260,28 @@ export function install(rt) {
     if (mode !== undefined && !ROOM_MODES.includes(mode)) throw new Error(`Reply mode must be one of ${ROOM_MODES.join(', ')}`)
     const title = custom || autoRoomName(members)
     const id = await createSession(title)
-    state.rooms[id] = {
-      id,
-      name: title,
-      ...(custom ? { named: true } : {}),
-      members,
-      admin: adminId,
-      mode: mode ?? 'admin',
-      notice: cleanNotice(notice),
-      createdAt: Date.now(),
-      createdBy: createdBy ?? null,
+    try {
+      state.rooms[id] = {
+        id,
+        name: title,
+        ...(custom ? { named: true } : {}),
+        members,
+        admin: adminId,
+        mode: mode ?? 'admin',
+        notice: cleanNotice(notice),
+        createdAt: Date.now(),
+        createdBy: createdBy ?? null,
+      }
+      await rt.save()
+      return state.rooms[id]
+    } catch (error) {
+      // The group's Session was already made: archive it instead of leaving an orphan.
+      delete state.rooms[id]
+      void rt.save().catch(() => {})
+      await ctx.workspaceRegistry.archiveSession(id)
+        .catch(archiveError => rt.warn('ds-bot: archiving the Session for %s failed: %s', title, archiveError))
+      throw error
     }
-    await rt.save()
-    return state.rooms[id]
   }
 
   // `actorId` is the Bot asking, or undefined for the user. Returns what changed, in words.
@@ -328,8 +355,12 @@ export function install(rt) {
     for (const botId of Object.keys(room.sessions ?? {})) rt.dropGroupSession(room, botId)
     delete state.rooms[id]
     rt.roomInbox.delete(id)
-    await rt.save()
-    await ctx.workspaceRegistry.archiveSession(id).catch(() => {})
+    const failed = await saveForDelete()
+    // Armed scheduled tasks refuse a plain archive and would keep delivering into
+    // the deleted group; the session-stop that stopActivity runs removes them.
+    await ctx.workspaceRegistry.archiveSession(id, { stopActivity: true })
+      .catch(error => rt.warn('ds-bot: group chat %s not archived: %s', room.name, error))
+    if (failed !== undefined) throw failed
   }
 
   // The first Main Bot is the sidebar tile. `replace` gives a Main Bot's place to
@@ -364,13 +395,14 @@ export function install(rt) {
   }
 
   async function deleteBot(id) {
-    if (rt.botOf(id) === undefined) throw new Error('Unknown Bot')
+    const bot = rt.botOf(id)
+    if (bot === undefined) throw new Error('Unknown Bot')
     if (rt.isMain(id)) throw new Error('A Main Bot cannot be deleted; remove its Main Bot role first')
     // Before the Bot and its group Sessions leave the state, which the archive reads.
     const archived = rt.archiveBotMemory(id)
     const current = rt.chatOf(id)
     // Questions and exchange turns are kept per Session, so every part of the chat is cleared.
-    const parts = new Set([id, current, ...(rt.botOf(id).segments ?? []).map(segment => segment.sessionId)])
+    const parts = new Set([id, current, ...(bot.segments ?? []).map(segment => segment.sessionId)])
     delete state.bots[id]
     for (const part of parts) {
       delete state.questions[part]
@@ -387,8 +419,29 @@ export function install(rt) {
     await followMemberNames(touched)
     await rt.forgetBotSecrets(id)
     await archived
-    await rt.save()
-    await ctx.workspaceRegistry.archiveSession(current).catch(() => {})
+    const failed = await saveForDelete()
+    // Same as deleteRoom: stopActivity removes the Session's armed scheduled tasks.
+    // Past parts are archived too: a part move can leave tasks on the old Session,
+    // which otherwise stays armed and invisible. Already-archived ids are a no-op.
+    for (const part of parts) {
+      await ctx.workspaceRegistry.archiveSession(part, { stopActivity: true })
+        .catch(error => rt.warn('ds-bot: Bot %s not archived: %s', bot.name, error))
+    }
+    if (failed !== undefined) throw failed
+  }
+
+  // A deletion whose save fails stays in memory, and the next save writes it, so its
+  // Sessions are stopped anyway: left armed, their scheduled tasks would keep running
+  // with nothing in the team to show or delete them. Only a host that lost the team
+  // to another dsh keeps them, since the other host's copy still has them.
+  async function saveForDelete() {
+    try {
+      await rt.save()
+      return undefined
+    } catch (error) {
+      if (error?.code === 'ELOCKLOST' || rt.readOnly() !== undefined) throw error
+      return error
+    }
   }
 
   async function bootstrap() {