@ljwei-stak/dsh-model-route-bot 0.66.4 → 0.67.0

package/modules/bot-runtime/product-overlay/patches/src/client/details-drawer.js.patch

@@ -17,7 +17,39 @@
  
  const hostOf = (url) => { try { return new URL(url).hostname.replace(/^www\./, '') } catch { return '' } }
  const shortUrl = url => String(url ?? '').replace(/^https?:\/\//i, '').replace(/^www\./i, '').replace(/\/$/, '')
-@@ -268,7 +269,7 @@
+@@ -194,13 +195,20 @@
+ 
+ export function DetailsDrawer({ sessionId, startRenaming, startTab, hasStrip, roster, actions, useSessions, useSessionStatus, useActivity, useWork, useBrowserTabs, useBrowserPages }) {
+   const owner = roster.byId[sessionId]
+-  const part = owner ? currentPart(owner) : sessionId
++  // A thread Session is its own part: the drawer shows that thread's
++  // transcript, stats, questions and usage, while everything Bot-scoped
++  // (settings, model, folder, memory, computer) stays the Bot's — a thread has
++  // no authority of its own.
++  const thread = roster.threadsById?.[sessionId]
++  const threadName = typeof thread?.name === 'string' ? thread.name.trim() : ''
++  const part = thread ? (thread.sessionId ?? sessionId) : (owner ? currentPart(owner) : sessionId)
+   const isMainBot = isMainOf(roster, owner?.id)
+   const [tab, setTab] = useState('details')
+   const room = roster.roomsById[sessionId]
+   // The info pane swaps its overview for the Bot or group settings view in place.
+   const [view, setView] = useState(startTab === 'settings' && (owner || room) ? 'settings' : 'overview')
+-  const [editing, setEditing] = useState(Boolean(startRenaming && (roster.byId[sessionId] || roster.roomsById[sessionId])))
++  // A thread is named in the thread directory, never by renaming its Bot here.
++  const [editing, setEditing] = useState(Boolean(startRenaming && thread === undefined && (roster.byId[sessionId] || roster.roomsById[sessionId])))
+   const [draftName, setDraftName] = useState(roster.byId[sessionId]?.name ?? (roster.roomsById[sessionId]?.named ? roster.roomsById[sessionId].name : ''))
+   const [copied, setCopied] = useState(false)
+   const [error, setError] = useState('')
+@@ -218,7 +226,7 @@
+   const running = useSessionStatus(map => map.get(part)?.running === true)
+   const doing = useActivity(map => map[bot?.id ?? sessionId])
+   const transcript = useSessions(list => transcriptOf(list, part, bot?.name ?? room?.name ?? t('Bot'), roster.exchangeTurns[part]))
+-  const usage = useSessions(list => usageOf(list, [part, ...(bot?.parts ?? room?.parts ?? [])]))
++  const usage = useSessions(list => usageOf(list, [part, ...(thread === undefined ? (bot?.parts ?? room?.parts ?? []) : [])]))
+   const run = promise => Promise.resolve(promise)
+     .then(() => { setError(''); return true })
+     .catch(failure => { setError(failure?.message ?? String(failure)); return false })
+@@ -268,7 +276,7 @@
    }
    const subtitle = bot ? bot.role : roomSubtitle(room, roster)
    // Tab sets: a 1:1 Bot has Details and Browser; a group has only Details, so no tab row.
@@ -26,7 +58,21 @@
    return [h(Fragment, { key: 'top' }, top),
      h('div', { key: 'id', className: 'bt-drawer-id', 'data-move': side },
        bot ? h(BotAvatar, { bot, size: 64, state: botState(running, doing, roster.questions?.[part] !== undefined), main: isMainBot, badge: false, gaze: true, pokeable: true })
-@@ -306,6 +307,7 @@
+@@ -280,8 +288,11 @@
+             onChange: event => setDraftName(event.target.value), onBlur: saveName,
+             onKeyDown: (event) => { if (event.key === 'Enter') void saveName(); if (event.key === 'Escape') { event.stopPropagation(); setEditing(false) } },
+           })
+-        : h('button', { type: 'button', className: 'bt-drawer-name', 'aria-label': t('Rename {name}', { name: current }), title: t('Rename'), onClick: () => { setDraftName(room && !room.named ? '' : current); setEditing(true) } }, current),
+-      subtitle ? h('span', { className: 'bt-drawer-role' }, subtitle) : null),
++        : thread !== undefined
++          ? h('span', { className: 'bt-drawer-name', 'data-thread': '' }, current)
++          : h('button', { type: 'button', className: 'bt-drawer-name', 'aria-label': t('Rename {name}', { name: current }), title: t('Rename'), onClick: () => { setDraftName(room && !room.named ? '' : current); setEditing(true) } }, current),
++      subtitle ? h('span', { className: 'bt-drawer-role' }, subtitle) : null,
++      threadName ? h('span', { className: 'bt-drawer-role', 'data-thread': threadName }, threadName) : null),
+     tabs.length > 1 ? h('div', { key: 'tabs', ref: glide.box, className: 'bt-tabs', role: 'tablist', 'data-move': side },
+       h('span', { ref: glide.thumb, className: 'bt-thumb', 'aria-hidden': true }),
+       tabs.map(key => h('button', { key, type: 'button', role: 'tab', className: 'bt-tab', 'aria-selected': tab === key, onClick: () => setTab(key) }, t(TAB_LABELS[key])))) : null,
+@@ -306,6 +317,7 @@
            h('div', { className: 'bt-kv' }, h('span', null, bot.name), h('span', null, usage))) : null,
          h(ScheduleSummary, { key: 'routines', bot, actions }),
        ] : null,

package/modules/bot-runtime/product-overlay/patches/src/client/header.js.patch

@@ -0,0 +1,41 @@
+--- a/src/client/header.js
++++ b/src/client/header.js
+@@ -72,6 +72,11 @@
+   const doing = useActivity(map => map[owner])
+   const bot = roster.byId[sessionId]
+   const room = roster.roomsById[sessionId]
++  // A thread is another own chat of this Bot: the header keeps naming the Bot,
++  // because that is who is speaking, and adds the thread so the owner can tell
++  // two contexts of the same Bot apart at a glance.
++  const thread = roster.threadsById?.[sessionId]
++  const threadName = typeof thread?.name === 'string' ? thread.name.trim() : ''
+   const goal = room?.goal
+   const goalCompose = useUi(state => state.goalCompose === sessionId)
+   const goalOpen = useUi(state => state.goalOpen === sessionId)
+@@ -116,7 +121,7 @@
+   }, [showGoal])
+   const pill = h('button', {
+     type: 'button', className: 'bt-pill', 'aria-expanded': away ? undefined : detailsOpen, 'data-memory': memoryNotice ? 'updated' : undefined,
+-    'aria-label': away ? t('Back to chat') : memoryNotice ? t('Memory updated. Open {name}\'s memory', { name: roster.byId[changed]?.name ?? name }) : t('View conversation details'),
++    'aria-label': away ? t('Back to chat') : memoryNotice ? t('Memory updated. Open {name}\'s memory', { name: roster.byId[changed]?.name ?? name }) : threadName ? `${t('View conversation details')} · ${threadName}` : t('View conversation details'),
+     title: away ? name : undefined,
+     onClick: () => (away ? selectView('chat') : memoryNotice ? actions.openMemory(changed) : actions.toggleDetails(sessionId)),
+   },
+@@ -127,6 +132,7 @@
+         h('span', { className: 'bt-pill-goal' }, h('span', { className: 'bt-pill-ico', 'aria-hidden': true }, h(GoalIcon)), h('span', { className: 'bt-pill-title' }, view.title)),
+         h('span', { className: 'bt-pill-name' }, name))
+       : h('span', { className: 'bt-pill-name' }, away ? t('Back to chat') : bot?.name ?? room?.name ?? (title || t('New chat'))),
++    threadName ? h('span', { className: 'bt-swap' }, threadName) : null,
+     goalShown && view?.number !== undefined ? h('span', { className: 'bt-pill-count' }, `${view.number}/${view.count}`) : null,
+     h(MemoryNotice, { shown: memoryNotice }),
+     h('span', { className: 'bt-pill-go', 'aria-hidden': true }, h(GoArrow)))
+@@ -134,7 +140,8 @@
+     showGoal ? h(GoalIsland, { room, goal, view, open: goalOpen, composing: goalCompose, roomWork, roster, actions, pill }) : pill,
+     h('span', { className: 'bt-sr', role: 'status' }, memoryNotice ? t('Memory updated') : ''),
+     h(NewMessagePills, { key: sessionId, sessionId, useSessions, useUi, useTurnClock }),
+-    h(ActivityIndicator, { key: `activity:${sessionId}`, sessionId, useRoster, useSessionStatus, useSession, useLive, useWork, actions }))
++    h(ActivityIndicator, { key: `activity:${sessionId}`, sessionId, useRoster, useSessionStatus, useSession, useLive, useWork, actions }),
++    typeof actions.conversationAddon === 'function' ? h(actions.conversationAddon, { sessionId, bot, room, roster, actions, running }) : null)
+ }
+ 
+ // New-message pills. "N new messages ↓" takes Back to bottom's place when

package/modules/bot-runtime/product-overlay/patches/src/client/index.js.patch

@@ -1,6 +1,38 @@
 --- a/src/client/index.js
 +++ b/src/client/index.js
-@@ -1082,7 +1082,7 @@
+@@ -199,7 +199,7 @@
+     for (const id of pendingAdopt.keys()) {
+       if (roster.getSnapshot().agentOf[id] !== undefined || listed[id] === undefined) pendingAdopt.delete(id)
+     }
+-    for (const id of [...value.bots.map(currentPart), ...value.rooms.map(room => room.sessionId ?? room.id)]) {
++    for (const id of [...value.bots.map(currentPart), ...value.rooms.map(room => room.sessionId ?? room.id), ...(value.bots ?? []).flatMap(bot => (bot.threads ?? []).map(thread => thread.sessionId))]) {
+       if (refreshed.has(id)) continue
+       refreshed.add(id)
+       void Promise.resolve(ctx.sessions.refreshProjections?.(id)).catch(quietly('refresh projections'))
+@@ -407,6 +407,13 @@
+   // A Bot id or a group chat id, or any part of either's chat, opens the current part.
+   const partFor = (id) => {
+     const snapshot = roster.getSnapshot()
++    // A thread Session, or a thread id, opens its own Session: it is not the
++    // Bot's default chat, and opening it is never redirected there. The thread
++    // is resolved before the Bot, because a thread Session also resolves to its
++    // Bot in `byId` — every other Bot surface needs that, and this one line
++    // keeps the two from being confused.
++    const thread = snapshot.threadsById?.[id]
++    if (thread !== undefined) return thread.sessionId ?? id
+     const bot = snapshot.byId[id]
+     if (bot !== undefined) return currentPart(bot)
+     const room = snapshot.roomsById[id]
+@@ -437,7 +444,7 @@
+     const snapshot = roster.getSnapshot()
+     if (!snapshot.ready || !snapshot.mainBotId) return
+     const main = mainView()
+-    if (main !== undefined && snapshot.byId[main] === undefined && snapshot.roomsById[main] === undefined) {
++    if (main !== undefined && snapshot.byId[main] === undefined && snapshot.roomsById[main] === undefined && snapshot.threadsById?.[main] === undefined) {
+       actions.openSession(snapshot.mainBotId)
+     }
+   }
+@@ -1082,7 +1089,7 @@
        let landed = false
        let declared = true
        try {

package/modules/bot-runtime/product-overlay/patches/src/client/learning-card.js.patch

@@ -0,0 +1,20 @@
+--- a/src/client/learning-card.js
++++ b/src/client/learning-card.js
+@@ -1,7 +1,7 @@
+ import { createElement as h, useId, useMemo, useRef, useState } from 'react'
+ import { useTurnFacts } from './btw.js'
+ import { editLines, lineDiff, proposalPlacement } from './learning-card-model.js'
+-import { currentPart } from './text.js'
++import { isOwnChatOf } from './sources.js'
+ import { t } from './i18n.js'
+ import { CheckIcon, MemoryIcon, PencilIcon } from './icons.js'
+ import { spring, SPRING_TAP } from './motion.js'
+@@ -106,7 +106,7 @@
+   const facts = useTurnFacts(sessionId, actions)
+   const [failed, setFailed] = useState({})
+   const bot = roster.byId?.[sessionId]
+-  if (!bot || currentPart(bot) !== sessionId) return null
++  if (!bot || !isOwnChatOf(bot, sessionId)) return null
+   const proposals = roster.learning?.[bot.id] ?? []
+   const visible = [...proposals]
+   for (const entry of Object.values(failed)) {

package/modules/bot-runtime/product-overlay/patches/src/client/model-menu.js.patch

@@ -0,0 +1,24 @@
+--- a/src/client/model-menu.js
++++ b/src/client/model-menu.js
+@@ -1,6 +1,6 @@
+ import { createElement as h, Fragment, useEffect, useLayoutEffect, useRef, useState, useSyncExternalStore } from 'react'
+ import { createPortal } from 'react-dom'
+-import { currentPart } from './text.js'
++import { isOwnChatOf } from './sources.js'
+ import { CheckIcon, SlidersIcon } from './icons.js'
+ import { BotMark } from './mark.js'
+ import { KeyIcon, MaskedInput } from './secret-card.js'
+@@ -202,9 +202,11 @@
+   const bot = roster.byId[sessionId]
+   const [busy, setBusy] = useState('')
+   const [error, setError] = useState('')
+-  const shown = Boolean(bot) && currentPart(bot) === sessionId && roster.ready
++  // A thread is another own chat of the same Bot, so the Bot's model choice
++  // belongs to it exactly as it belongs to the default chat.
++  const shown = Boolean(bot) && isOwnChatOf(bot, sessionId) && roster.ready
+   useEffect(() => { if (shown) void actions.refreshModels?.() }, [shown, sessionId])
+-  if (!bot || currentPart(bot) !== sessionId || !roster.ready) return null
++  if (!bot || !isOwnChatOf(bot, sessionId) || !roster.ready) return null
+   const models = roster.models ?? []
+   // A model whose provider has no API key fails every turn, so it is no choice.
+   const usable = models.filter(model => !model.needsKey)

package/modules/bot-runtime/product-overlay/patches/src/client/secret-card.js.patch

@@ -0,0 +1,25 @@
+--- a/src/client/secret-card.js
++++ b/src/client/secret-card.js
+@@ -5,11 +5,11 @@
+ import { createElement as h, useEffect, useId, useRef, useState } from 'react'
+ import { CheckIcon, CloseIcon, TrashIcon } from './icons.js'
+ import { BotAvatar, BotMark } from './mark.js'
+-import { contentText, currentPart } from './text.js'
++import { contentText } from './text.js'
+ import { dateLocale, t } from './i18n.js'
+ import { SPRING_POP, SPRING_SHAPE, spring } from './motion.js'
+ import { useDockHold } from './card-hold.js'
+-import { heldCardKey } from './sources.js'
++import { heldCardKey, isOwnChatOf } from './sources.js'
+ import { CellEmpty } from './cell-empty.js'
+ 
+ const MIN_VALUE = 4
+@@ -178,7 +178,7 @@
+   const shown = useCards?.(state => state[sessionId]) ?? NONE
+   const held = useHeldCards?.(state => state[sessionId]) ?? NONE
+   const bot = roster.byId[sessionId]
+-  if (!bot || currentPart(bot) !== sessionId) return null
++  if (!bot || !isOwnChatOf(bot, sessionId)) return null
+   const drawn = entry => entry.callId && entry.sessionId === sessionId && shown[entry.callId] > 0 && !(held[heldCardKey('secret', entry.id)] > 0)
+   const waiting = (roster.secretRequests?.[bot.id] ?? []).filter(entry => entry.status === 'pending' && !drawn(entry))
+   if (waiting.length === 0) return null

package/modules/bot-runtime/product-overlay/patches/src/client/sources.js.patch

@@ -0,0 +1,52 @@
+--- a/src/client/sources.js
++++ b/src/client/sources.js
+@@ -16,7 +16,7 @@
+   }
+ }
+ 
+-export const EMPTY_ROSTER = { revision: -1, mainBotId: null, mainBotIds: [], bots: [], rooms: [], agents: [], exchangeTurns: {}, questions: {}, btwCards: {}, sideChats: {}, learning: {}, secrets: [], capabilities: [], capabilityStatuses: {}, secretRequests: {}, models: [], defaultModel: null, modelsKey: null, prefs: {}, byId: {}, roomsById: {}, agentsById: {}, agentOf: {}, ready: false }
++export const EMPTY_ROSTER = { revision: -1, mainBotId: null, mainBotIds: [], bots: [], rooms: [], agents: [], exchangeTurns: {}, questions: {}, btwCards: {}, sideChats: {}, learning: {}, secrets: [], capabilities: [], capabilityStatuses: {}, secretRequests: {}, models: [], defaultModel: null, modelsKey: null, prefs: {}, byId: {}, roomsById: {}, agentsById: {}, agentOf: {}, threadsById: {}, ready: false }
+ // Any Main Bot holds the Main Bot powers; `mainBotId`, the first one, is the sidebar tile.
+ export const isMainOf = (roster, id) => id !== undefined && (roster.mainBotIds ?? []).includes(id)
+ 
+@@ -28,6 +28,21 @@
+   for (const bot of value.bots) {
+     for (const id of [...(bot.parts ?? []), bot.sessionId ?? bot.id, bot.id]) byId[id] = bot
+   }
++  // A thread is another own chat of its Bot, and it is indexed twice on
++  // purpose. `threadsById` holds the thread itself — its own Session, its name,
++  // its archive — so opening one opens the thread and never the Bot's default
++  // chat. Its Session also resolves to its Bot in `byId`, so every surface that
++  // asks "whose chat is this?" (the header, the composer's extra menu, the
++  // details drawer, and with it the model, memory, computer, voice and
++  // attachment controls) keeps the Bot instead of going blank inside a thread.
++  // A thread never takes a Bot's own chat identity: a Session the Bot already
++  // owns stays the Bot's.
++  const threadsById = {}
++  for (const bot of value.bots) for (const thread of bot.threads ?? []) {
++    if (thread.sessionId !== undefined) threadsById[thread.sessionId] = { botId: bot.id, ...thread }
++    if (thread.threadId !== undefined) threadsById[thread.threadId] = { botId: bot.id, ...thread }
++    if (thread.sessionId !== undefined && byId[thread.sessionId] === undefined) byId[thread.sessionId] = bot
++  }
+   const roomsById = {}
+   // A group's own Session is a chain of parts like a Bot's chat: `room.id` is its
+   // first part's id and `sessionId` its current one; every part id finds the room.
+@@ -41,9 +56,17 @@
+     agentsById[agent.id] = agent
+     for (const sessionId of agent.sessions ?? []) agentOf[sessionId] = agent.id
+   }
+-  return { ...value, agents: value.agents ?? [], byId, roomsById, agentsById, agentOf, ready: true }
++  return { ...value, agents: value.agents ?? [], byId, roomsById, agentsById, agentOf, threadsById, ready: true }
+ }
+ 
++// Whether a Session is one of this Bot's own chats: its current part, or one of
++// its threads' Sessions. A thread is another own chat of the same Bot, so the
++// Bot-scoped surfaces (model choice, memory learning, secret requests, turn
++// errors) belong to it exactly as they belong to the default chat. Earlier
++// parts are deliberately not included: they keep the behaviour they had.
++export const isOwnChatOf = (bot, sessionId) => bot !== undefined && bot !== null && typeof sessionId === 'string'
++  && ((bot.sessionId ?? bot.id) === sessionId || (bot.threads ?? []).some(thread => thread.sessionId === sessionId))
++
+ // Whether a main-view Session id belongs to the team's DSH Agent: the conversation
+ // group then stays withdrawn while the shell keeps the sidebar. Before the roster
+ // arrives, the ids cached from the last pull answer.

package/modules/bot-runtime/product-overlay/patches/src/client/turn-error.js.patch

@@ -0,0 +1,23 @@
+--- a/src/client/turn-error.js
++++ b/src/client/turn-error.js
+@@ -1,9 +1,10 @@
+ import { createElement as h, useEffect, useMemo, useState, useSyncExternalStore } from 'react'
+-import { currentPart, isHiddenTurn } from './text.js'
++import { isHiddenTurn } from './text.js'
+ import { CheckIcon, CopyIcon } from './icons.js'
+ import { ModelKeyCard, manageModels } from './model-menu.js'
+ import { knownFailure } from './diagnostics.js'
+ import { hostText, t } from './i18n.js'
++import { isOwnChatOf } from './sources.js'
+ 
+ // -------------------------------------------------------------------------
+ // A failed turn in a Bot's chat: what went wrong and what the user can do about it,
+@@ -157,7 +158,7 @@
+   const provider = blocked?.provider ?? providerOf(bot, roster)
+   const text = failureText(data.code, { name: bot?.name ?? t('This Bot'), provider: providerName(roster, provider), status: blocked?.status })
+   const facts = failureFacts(data, blocked)
+-  const current = bot !== undefined && currentPart(bot) === sessionId && !later
++  const current = bot !== undefined && isOwnChatOf(bot, sessionId) && !later
+   // The key route never takes the account's credential, so a sign-in alone leaves the Bot
+   // failing; it moves onto the account route. With no account model listed yet, the
+   // user picks one.

package/modules/bot-runtime/product-overlay/patches/src/host/channel.js.patch

@@ -0,0 +1,46 @@
+--- a/src/host/channel.js
++++ b/src/host/channel.js
+@@ -43,8 +43,16 @@
+     // `sessionId` is the Bot's current own-chat part; `parts` its earlier ones.
+     // `waiting`: the Bot holds its greeting until the user picks its model or fixes
+     // what failed it. `blocked`: the facts of a failure only the user can fix (turns.js).
+-    bots: Object.values(state.bots).map(({ segments, kickoff, ...bot }) => ({
+-      ...bot, sessionId: rt.chatOf(bot.id), parts: (segments ?? []).map(segment => segment.sessionId), ...(kickoff ? { waiting: true } : {}),
++    bots: Object.values(state.bots).map(({ segments, threads, kickoff, ...bot }) => ({
++      ...bot, sessionId: rt.chatOf(bot.id), parts: (segments ?? []).map(segment => segment.sessionId),
++      // `sessionId` stays the default chat; `threads` are the Bot's other own
++      // chats, each with its own Session. An archived thread keeps its id and
++      // its history and opens read-only.
++      threads: (threads ?? []).map(thread => ({ threadId: thread.threadId, sessionId: thread.sessionId,
++        ...(thread.name === undefined ? {} : { name: thread.name }),
++        ...(thread.createdAt === undefined ? {} : { createdAt: thread.createdAt }),
++        ...(thread.archivedAt === undefined || thread.archivedAt === null ? {} : { archivedAt: thread.archivedAt }) })),
++      ...(kickoff ? { waiting: true } : {}),
+     })),
+     // `sessionId` is the group's own Session's current part, `ownParts` its earlier
+     // ones; `parts` the members' hidden group Sessions and their earlier segments,
+@@ -435,6 +443,7 @@
+           await rt.load()
+           const past = rt.pastOwners.get(body.sessionId)
+           const sessionId = rt.botOf(body.sessionId) ? rt.chatOf(body.sessionId) : past && past.roomId === undefined ? rt.chatOf(past.botId) : body.sessionId
++          if (past?.threadId !== undefined) return fail('This thread is archived; open it again to write in it', 'bot/archived')
+           const question = rt.own(state.questions, sessionId)
+           if (question === undefined || question.id !== body.questionId) return fail('This question is no longer open', 'bot/stale')
+           const reply = questionReply(question, body.answer)
+@@ -458,6 +467,7 @@
+           await rt.load()
+           const past = rt.pastOwners.get(body.sessionId)
+           const sessionId = rt.botOf(body.sessionId) ? rt.chatOf(body.sessionId) : past && past.roomId === undefined ? rt.chatOf(past.botId) : body.sessionId
++          if (past?.threadId !== undefined) return fail('This thread is archived; open it again to write in it', 'bot/archived')
+           const pending = rt.own(state.views, sessionId)
+           if (pending === undefined || pending.id !== body.viewId) return fail('This view is no longer open', 'bot/stale')
+           const checked = validateViewAnswer(pending.view, body.action, body.values)
+@@ -485,6 +495,8 @@
+           // A Bot id, a group chat's id, or an earlier part of either means the
+           // current part.
+           const past = rt.pastOwners.get(body.sessionId)
++          // An archived thread keeps its history but takes no new input.
++          if (past?.threadId !== undefined) return fail('This thread is archived; open it again to write in it', 'bot/archived')
+           const room = rt.roomOf(body.sessionId)
+           const sessionId = rt.botOf(body.sessionId) ? rt.chatOf(body.sessionId)
+             : room !== undefined ? rt.sessionOfRoom(room)

package/modules/bot-runtime/product-overlay/patches/src/host/memory.js.patch

@@ -0,0 +1,11 @@
+--- a/src/host/memory.js
++++ b/src/host/memory.js
+@@ -866,7 +866,7 @@
+   // A deleted Bot's memory moves to the archive, whole.
+   function archiveBotMemory(botId) {
+     const bot = rt.botOf(botId)
+-    for (const sessionId of [botId, rt.chatOf(botId), ...(bot?.segments ?? []).map(segment => segment.sessionId), ...rt.groupSessionsOf(botId)]) renewMemory(sessionId)
++    for (const sessionId of rt.sessionsOfBot(botId)) renewMemory(sessionId)
+     summaries.delete(botId)
+     news.delete(botId)
+     return queued(async () => {

package/modules/bot-runtime/product-overlay/patches/src/host/models.js.patch

@@ -0,0 +1,16 @@
+--- a/src/host/models.js
++++ b/src/host/models.js
+@@ -244,6 +244,13 @@
+       await selectSessionModel(sessionId, route)
+         .catch(error => rt.warn('ds-bot: model for %s in a group not applied: %s', bot.name, error))
+     }
++    // A thread follows its Bot's model, as a group Session does.
++    for (const sessionId of rt.threadsOf(bot.id).map(thread => thread.sessionId)) {
++      const applied = sessionSelections.get(sessionId)
++      if (!force && applied !== undefined && sameSelection(applied, route)) continue
++      await selectSessionModel(sessionId, route)
++        .catch(error => rt.warn('ds-bot: model for a thread of %s not applied: %s', bot.name, error))
++    }
+     if (!ownChanged) return ref
+     bot.appliedModel = ref
+     if (effort === undefined) delete bot.appliedEffort

package/modules/bot-runtime/product-overlay/patches/src/host/parts.js.patch

@@ -0,0 +1,95 @@
+--- a/src/host/parts.js
++++ b/src/host/parts.js
+@@ -446,6 +446,11 @@
+     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')
++    // The Host's prepared auxiliary stream binds one adapter generation for this note and
++    // admits the money against that same generation. A Host that has not wired it refuses
++    // the note here, rather than re-resolving the route at dispatch the way a bare stream
++    // does.
++    const auxiliary = ctx.get('botAuxiliaryModelStream')
++    if (typeof auxiliary !== 'function') throw new Error('the Host has no prepared auxiliary model stream')
+     const messages = session.deriveMessages()
+     const base = folder ? FOLDER_PROMPT : HANDOFF_PROMPT
+     let retry
+@@ -453,7 +458,7 @@
+     for (let attempt = 1; attempt <= NOTE_ATTEMPTS; attempt += 1) {
+       const prompt = retry === undefined ? base : `${base}\n\n${retry}`
+       const assembler = new BlockAssembler()
+-      for await (const chunk of ctx.llm.stream({
++      for await (const chunk of auxiliary.stream({
+         provider: route.provider,
+         model: route.model,
+         ...(route.reasoningEffort ? { reasoningEffort: route.reasoningEffort } : {}),
+@@ -515,6 +520,12 @@
+   async function writeCheckpoint(input, agent, signal) {
+     const session = agent.session
+     const route = session.requestHeader()?.config
+     if (!route?.provider || !route?.model) throw new Error('the Session has not called a model yet')
++    // The Host's prepared auxiliary stream binds one adapter generation for this checkpoint,
++    // so the summary is written by the generation the accounting admitted. A Host that has
++    // not wired it refuses the checkpoint instead of pricing one generation and streaming
++    // another.
++    const auxiliary = ctx.get('botAuxiliaryModelStream')
++    if (typeof auxiliary !== 'function') throw new Error('the Host has no prepared auxiliary model stream')
+     // The results list grows with the work, so the checkpoint may write as much as one
+     // of the Bot's own replies.
+     const maxTokens = route.maxTokens
+@@ -522,7 +531,7 @@
+     const tail = checkpointTail(head, session.deriveMessages())
+     const prompt = tail.length === 0 ? CHECKPOINT_PROMPT : `${CHECKPOINT_PROMPT}\n\n${checkpointTailNote(tail)}`
+     const assembler = new BlockAssembler()
+-    for await (const chunk of ctx.llm.stream({
++    for await (const chunk of auxiliary.stream({
+       provider: route.provider,
+       model: route.model,
+       ...(route.reasoningEffort ? { reasoningEffort: route.reasoningEffort } : {}),
+@@ -571,18 +582,19 @@
+     const lines = []
+     for await (const line of partLines(agent.id, AbortSignal.timeout(HANDOFF_READ_MS), { group })) {
+       lines.push({ who: line.who, text: line.who === 'you' || line.who === 'user' ? line.text.replace(/^(?:You|User): /, '') : line.text })
+       if (lines.length >= STEWARD_LINES) break
+     }
+-    const info = await ctx.llm.resolveModelInfo(route.provider, route.model).catch(() => undefined)
+-    // The decision needs no long thinking.
+-    const off = info?.reasoning?.efforts?.some(effort => effort.id === 'off')
++    // The decision needs no long thinking. Whether this model can be asked to think less
++    // is decided from the generation this very call prepares, not from a read of whatever
++    // registration happens to be current now.
++    const auxiliary = ctx.get('botAuxiliaryModelStream')
++    if (typeof auxiliary !== 'function') throw new Error('the Host has no prepared auxiliary model stream')
+     const assembler = new BlockAssembler()
+-    for await (const chunk of ctx.llm.stream({
++    for await (const chunk of auxiliary.stream({
+       provider: route.provider,
+       model: route.model,
+-      ...(off ? { reasoningEffort: 'off' } : {}),
+       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)
++    }, { controls: auxiliary.reasoningOff })) assembler.push(chunk)
+@@ -732,7 +743,10 @@
+ 
+   const placeOf = (sessionId) => {
+     const botId = rt.chatOwners.get(sessionId)
+-    if (botId !== undefined) return { botId }
++    // A thread is not a part chain: it keeps its own Session for as long as it
++    // lives, so the steward neither condenses it nor hands its input on to the
++    // Bot's default chat.
++    if (botId !== undefined) return rt.threadOf(sessionId) === undefined ? { botId } : undefined
+     const owner = rt.groupOwners.get(sessionId)
+     if (owner !== undefined) return { botId: owner.botId, roomId: owner.roomId }
+@@ -1234,6 +1245,7 @@
+   // past it.
+   async function checkContext(agent) {
+     if (switches.has(agent.id) || freshParts.has(agent.id) || checking.has(agent.id) || readOnly()) return
++    if (placeOf(agent.id) === undefined) return
+     if (lastTurnEnd(agent)?.data?.reason?.kind === 'error') return
+     const lines = await contextLines(agent.session)
+     const tokens = tokensOf(agent.session)

package/modules/bot-runtime/product-overlay/patches/src/host/privacy.js.patch

@@ -0,0 +1,11 @@
+--- a/src/host/privacy.js
++++ b/src/host/privacy.js
+@@ -30,7 +30,7 @@
+   const privateBots = () => Object.values(state.bots).filter(bot => bot.private === true)
+   // Deleting a private Bot does not make the files and memory it leaves behind public.
+   const protectedBots = () => [...new Map([...(state.privateArchives ?? []), ...privateBots()].map(bot => [bot.id, bot])).values()]
+-  const sessionsOf = bot => [...new Set([bot.id, ...(bot.sessionIds ?? [rt.chatOf(bot.id), ...(bot.segments ?? []).map(segment => segment.sessionId), ...rt.groupSessionsOf(bot.id)])])]
++  const sessionsOf = bot => [...new Set([bot.id, ...(bot.sessionIds ?? [rt.sessionsOfBot(bot.id)])])]
+   const dataRoots = () => [rt.dshHome, rt.home, process.env.DS_BOT_USER_DSH_HOME?.trim()].filter(Boolean)
+ 
+   // A path as it is and as the file system resolves it, folded for comparing. realBeyond

package/modules/bot-runtime/product-overlay/patches/src/host/roster.js.patch

@@ -0,0 +1,145 @@
+--- a/src/host/roster.js
++++ b/src/host/roster.js
+@@ -2,7 +2,7 @@
+ // the first Main Bot of a new team.
+ import { mkdir } from 'node:fs/promises'
+ import { MAX_AVATAR_IMAGE, ROOM_MAX_MEMBERS, ROOM_MODES, ROOM_NAME_MAX, ROOM_NOTICE_MAX } from './constants.js'
+-import { currentColor, isColor, normalize, unquote } from './text.js'
++import { currentColor, isColor, normalize, splitRef, unquote } from './text.js'
+ import { nameProblem } from '../shared/mentions.js'
+ 
+ const BROWSER_GRANT_KINDS = new Set(['post', 'upload', 'download', 'delete', '*'])
+@@ -420,6 +420,114 @@
+     return bot
+   }
+ 
++  // Trusted product-only profile edit. No notice is delivered, no model is selected,
++  // and no kickoff is released. The owner service supplies the final synchronous
++  // committed-state check; the live base is compared at the same mutation boundary.
++  async function updateBotProfile(id, patch, { base, check } = {}) {
++    const fail = (code, message) => { throw Object.assign(new Error(message), { code }) }
++    const fields = { name: 40, role: 24, instructions: 4000 }
++    const plain = value => value && typeof value === 'object' && !Array.isArray(value)
++    if (!plain(patch) || !Object.keys(patch).length || Object.keys(patch).some(key => !Object.hasOwn(fields, key))
++      || !plain(base) || typeof check !== 'function') fail('BOT_PROFILE_INVALID', 'Invalid profile mutation')
++    const bot = rt.botOf(id)
++    if (!bot || state.bots[id] !== bot) fail('BOT_PROFILE_UNKNOWN_BOT', 'Unknown Bot')
++    if (rt.readOnly() !== undefined) fail('PRODUCT_READ_ONLY', rt.readOnly())
++    const next = {}
++    for (const field of Object.keys(patch)) {
++      if (typeof patch[field] !== 'string' || patch[field].trim().length > fields[field]) fail('BOT_PROFILE_INVALID', 'Invalid profile field')
++      if (typeof base[field] !== 'string' || (bot[field] ?? '') !== base[field]) fail('BOT_PROFILE_CONFLICT', 'Bot profile changed before commit')
++      next[field] = patch[field].trim()
++    }
++    if (next.name !== undefined) {
++      const clash = rt.findBot(next.name)
++      const pending = isHeld('bot', next.name) && normalize(next.name) !== normalize(bot.name)
++      const problem = next.name === bot.name ? undefined : nameProblem(next.name)
++      if (!next.name || (clash && clash.id !== id) || pending || problem !== undefined) fail('BOT_PROFILE_NAME_INVALID', 'Bot name is not available')
++    }
++    const checked = check(bot)
++    if (checked && typeof checked.then === 'function') fail('BOT_PROFILE_INVALID', 'Profile commit check must be synchronous')
++    // No await between the check and all three field assignments.
++    const renamed = next.name !== undefined && next.name !== bot.name
++    Object.assign(bot, next)
++    const rooms = renamed ? Object.values(state.rooms).filter(room => !room.named && room.members.includes(id)) : []
++    for (const room of rooms) room.name = autoRoomName(room.members)
++    await rt.save()
++    // Session titles are presentation. A failure cannot undo an already persisted
++    // profile or turn the successful save into a request the UI might retry.
++    if (renamed) {
++      try {
++        const agent = await rt.resolveAgent(rt.chatOf(id))
++        const current = rt.botOf(id)
++        if (current) await ctx.sessionTitle.rename(agent.session, current.name)
++      } catch (error) { rt.warn('ds-bot: profile session title not updated: %s', error?.message ?? error) }
++      for (const room of rooms) await retitleRoom(room)
++    }
++    return bot
++  }
++
++  // Trusted product-only thread records. A thread Session is made by the caller
++  // through rt.createSession — the same factory every own chat uses — and
++  // recorded here in one save, so the committed state the Host lifecycle
++  // compiles and the directory the product keeps can never disagree about who
++  // owns a Session. Nothing here delivers a notice, picks a model beyond the
++  // Bot's own, or starts a turn.
++  const THREAD_LIMIT = 64
++  const THREAD_ID = /^[A-Za-z0-9_-]{1,128}$/
++  const threadFail = (code, message) => { throw Object.assign(new Error(message), { code }) }
++  async function addThreadSession(botId, threadId, sessionId, { name } = {}) {
++    const readOnly = rt.readOnly()
++    if (readOnly !== undefined) threadFail('PRODUCT_READ_ONLY', readOnly)
++    const bot = rt.botOf(botId)
++    if (!bot || state.bots[botId] !== bot) threadFail('BOT_THREAD_UNKNOWN_BOT', 'Unknown Bot')
++    if (!THREAD_ID.test(threadId ?? '') || !THREAD_ID.test(sessionId ?? '')) threadFail('BOT_THREAD_INVALID', 'Invalid thread identity')
++    const threads = bot.threads ?? []
++    if (threads.length >= THREAD_LIMIT) threadFail('BOT_THREAD_LIMIT', 'Too many threads on one Bot')
++    if (threads.some(thread => thread.threadId === threadId)) threadFail('BOT_THREAD_KNOWN', 'That thread already has a Session')
++    for (const other of Object.values(state.bots)) {
++      for (const thread of other.threads ?? []) if (thread.sessionId === sessionId) threadFail('BOT_THREAD_SESSION_TAKEN', 'That Session already belongs to a thread')
++    }
++    const record = { threadId, sessionId, createdAt: Date.now(), ...(typeof name === 'string' && name.trim() ? { name: name.trim().slice(0, 80) } : {}) }
++    ;(bot.threads ??= []).push(record)
++    await rt.save()
++    // A thread runs on its Bot's model and permission preset, as a fresh part does.
++    const ref = await rt.desiredModel(bot)
++    if (ref !== undefined) {
++      const effort = await rt.desiredEffort(bot, ref)
++      await rt.selectSessionModel(sessionId, { ...splitRef(ref), ...(effort === undefined ? {} : { reasoningEffort: effort }) })
++        .catch(error => rt.warn('ds-bot: model for a thread of %s not applied: %s', bot.name, error))
++    }
++    await rt.applyPermission(bot, sessionId)
++      .catch(error => rt.warn('ds-bot: permission for a thread of %s not applied: %s', bot.name, error))
++    return { ...record }
++  }
++
++  async function renameThread(botId, threadId, name) {
++    const readOnly = rt.readOnly()
++    if (readOnly !== undefined) threadFail('PRODUCT_READ_ONLY', readOnly)
++    const bot = rt.botOf(botId)
++    const thread = bot?.threads?.find(entry => entry.threadId === threadId)
++    if (!bot || !thread) threadFail('BOT_THREAD_UNKNOWN', 'Unknown thread')
++    if (typeof name !== 'string' || name.trim().length > 80) threadFail('BOT_THREAD_INVALID', 'Invalid thread name')
++    thread.name = name.trim()
++    await rt.save()
++    return { ...thread }
++  }
++
++  // Archive hides a thread and drops its authority in the same save: the
++  // Session and its history stay, and only an explicit restore brings it back.
++  async function setThreadArchived(botId, threadId, archivedAt) {
++    const readOnly = rt.readOnly()
++    if (readOnly !== undefined) threadFail('PRODUCT_READ_ONLY', readOnly)
++    const bot = rt.botOf(botId)
++    const thread = bot?.threads?.find(entry => entry.threadId === threadId)
++    if (!bot || !thread) threadFail('BOT_THREAD_UNKNOWN', 'Unknown thread')
++    if (archivedAt === undefined || archivedAt === null) delete thread.archivedAt
++    else if (Number.isFinite(archivedAt) && archivedAt >= 0) thread.archivedAt = archivedAt
++    else threadFail('BOT_THREAD_INVALID', 'Invalid archive stamp')
++    await rt.save()
++    return { ...thread }
++  }
++
+   async function setFlags(id, { pinned, hidden }) {
+     const entry = rt.botOf(id) ?? rt.roomOf(id) ?? rt.own(state.agents, id)
+     if (entry === undefined) throw new Error('Unknown conversation')
+@@ -694,7 +802,7 @@
+     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, ...(bot.segments ?? []).map(segment => segment.sessionId)])
++    const parts = new Set([id, current, ...(bot.segments ?? []).map(segment => segment.sessionId), ...(bot.threads ?? []).map(thread => thread.sessionId)])
+     // `archiving` stands until the archive's path is known: the memory may already be
+     // there, and no region of its own closes it yet.
+     const closedArchive = bot.private === true ? {
+@@ -769,7 +877,8 @@
+   }
+ 
+   Object.assign(rt, {
+-    ensureWorkspace, keepTeamFolder, createSession, createBot, duplicateBot, updateBot, setFlags,
++    ensureWorkspace, keepTeamFolder, createSession, createBot, duplicateBot, updateBot, updateBotProfile,
++    addThreadSession, renameThread, setThreadArchived, setFlags,
+     roomBusy, autoRoomName, retitleRoom, createRoom, updateRoom, deleteRoom,
+     setMain, deleteBot, bootstrap, releaseKickoff, greetingOut, holdKickoffAgain, userWrote, userAnswered,
+   })