ds-bot 0.0.0-stage → 0.1.0

package/src/host/channel.js

@@ -0,0 +1,313 @@
+// Client channel: the team view the browser renders, and the POST /api/bot endpoints.
+import { randomUUID } from 'node:crypto'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { questionReply } from './parts.js'
+import { COLORS, EXTRA_COLORS, ROUTE } from './constants.js'
+
+const LANGUAGES = { zh: 'Chinese (简体中文)', en: 'English' }
+
+const invalid = message => Object.assign(new Error(message), { code: 'bot/invalid' })
+// Programming and file system errors are DS Bot's own faults, logged with their stack;
+// any other error is a refusal whose message is meant for the user.
+const isInternal = error => error instanceof TypeError || error instanceof ReferenceError || error instanceof RangeError
+  || error instanceof SyntaxError || (typeof error?.code === 'string' && /^E[A-Z_]+$/.test(error.code))
+export function errorCode(error) {
+  if (typeof error?.code === 'string' && error.code.startsWith('bot/')) return error.code
+  return isInternal(error) ? 'bot/internal' : 'bot/refused'
+}
+
+export function install(rt) {
+  const { ctx, state } = rt
+
+  // The DSH interface language of the last browser that asked for the team.
+  let uiLocale
+  rt.uiLanguage = () => (uiLocale === undefined ? undefined : LANGUAGES[uiLocale.split('-')[0].toLowerCase()] ?? uiLocale)
+
+  const ok = value => ({ ok: true, value })
+  const fail = (message, code = 'bot/error') => ({ ok: false, error: { code, message, details: {} } })
+  // Models come from DSH, not state.json, so a provider added in Harness settings
+  // changes the view without a new revision.
+  const modelsKey = () => `${rt.cachedCatalog().map(entry => entry.ref).join(',')}|${rt.cachedDefault() ?? ''}`
+  const view = () => ({
+    revision: state.revision,
+    workspaceId: state.workspaceId ?? null,
+    // `mainBotId` is the first Main Bot, which the sidebar shows as its tile.
+    mainBotId: state.mainBotIds[0] ?? null,
+    mainBotIds: state.mainBotIds,
+    // `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.
+    bots: Object.values(state.bots).map(({ segments, kickoff, ...bot }) => ({
+      ...bot, sessionId: rt.chatOf(bot.id), parts: (segments ?? []).map(segment => segment.sessionId), ...(kickoff ? { waiting: true } : {}),
+    })),
+    // `parts`: the members' hidden group Sessions and their earlier segments, for usage.
+    rooms: Object.values(state.rooms).map(({ log, seen, botRounds, sessions, segments, ...room }) => {
+      const parts = [...Object.values(sessions ?? {}), ...Object.values(segments ?? {}).flat().map(segment => segment.sessionId)]
+      const last = (log ?? []).filter(line => line.kind === undefined).at(-1)
+      return { ...room, parts, ...(last ? { preview: last.who === 'User' ? last.text : `${last.who}：${last.text}` } : {}) }
+    }),
+    exchangeTurns: state.exchangeTurns,
+    questions: state.questions,
+    // The team's DSH Agent (at most one): plain dsh Sessions, not Bots.
+    agents: Object.values(state.agents),
+    // Key names and who may use them; values never leave the host.
+    secrets: rt.secretsView(),
+    secretRequests: state.secretRequests ?? {},
+    colors: [...COLORS, ...EXTRA_COLORS],
+    models: rt.cachedCatalog(),
+    defaultModel: rt.cachedDefault() ?? null,
+    modelsKey: modelsKey(),
+    prefs: state.prefs,
+    // Whether a Desktop window should serve Bot browser reads (see browser.js).
+    browser: rt.browserEnabled,
+    // False when config.memory turns memory off: no Memory row or panel.
+    memory: rt.memoryEnabled !== false,
+    // Set while another dsh host holds the team (store.js): why this one cannot change it.
+    readOnly: rt.readOnly() ?? null,
+  })
+  // What changes without a new revision, sent with every state answer. `memoryNews`:
+  // per Bot, its latest memory change; `memoryReviews`: memory reviews waiting or
+  // running.
+  const live = () => ({ activity: rt.activityView(), memoryNews: rt.memoryNews(), memoryReviews: rt.memoryReviews(), connectors: rt.connectorsView() })
+  // What a host that only reads the team may still answer.
+  // Updates change the dsh profile, not the team, so a reading host may run them too.
+  const READS = new Set(['state', 'models', 'earlier', 'room-progress', 'exchange', 'usage', 'schedules', 'memory-view', 'browser-wait', 'browser-result', 'diagnostics', 'diagnostics-log', 'diagnostics-clear', 'update-check', 'update-install'])
+
+  function setPrefs(body) {
+    if (body.theme !== undefined) {
+      if (typeof body.theme !== 'string' || !/^[a-z][\w-]{0,31}$/.test(body.theme)) throw invalid('Unknown theme')
+      state.prefs.theme = body.theme
+    }
+    if (body.accent !== undefined) {
+      if (body.accent === null || body.accent === '') delete state.prefs.accent
+      else if (/^#[0-9a-f]{6}$/i.test(body.accent)) state.prefs.accent = body.accent
+      else throw invalid('Accent must be a #rrggbb color')
+    }
+    if (body.motion !== undefined) {
+      if (body.motion === null || body.motion === 'normal') delete state.prefs.motion
+      else if (body.motion === 'quiet' || body.motion === 'lively') state.prefs.motion = body.motion
+      else throw invalid('Motion must be quiet, normal or lively')
+    }
+    return rt.save()
+  }
+
+  const handle = async (endpoint, payload) => {
+    try {
+      const body = payload ?? {}
+      await rt.refresh()
+      const readOnly = rt.readOnly()
+      if (readOnly !== undefined && !READS.has(endpoint)) return fail(readOnly, 'bot/read-only')
+      switch (endpoint) {
+        case 'state':
+          if (typeof body.locale === 'string' && /^[a-z]{2,3}(-[\w-]+)?$/i.test(body.locale)) uiLocale = body.locale
+          if (readOnly === undefined) await rt.bootstrap()
+          await rt.catalog()
+          await rt.loadSecrets()
+          if (body.since === state.revision && (body.models === undefined || body.models === modelsKey())) return ok({ revision: state.revision, unchanged: true, ...live() })
+          return ok({ ...view(), ...live() })
+        case 'models':
+          await rt.catalog({ fresh: true })
+          return ok({ modelsKey: modelsKey() })
+        case 'duplicate-bot':
+          await rt.load()
+          return ok(await rt.duplicateBot(body.id))
+        case 'set-prefs':
+          await rt.load()
+          await setPrefs(body)
+          return ok(state.prefs)
+        case 'exchange': {
+          await rt.load()
+          const pair = new Set([body.a, body.b])
+          return ok(state.exchanges.filter(entry => pair.has(entry.from) && pair.has(entry.to)))
+        }
+        case 'earlier':
+          await rt.load()
+          return ok(await rt.earlierPage(String(body.sessionId ?? ''), body.cursor ?? undefined))
+        case 'usage':
+          await rt.load()
+          return ok(await rt.usageView({ timeZone: typeof body.timeZone === 'string' ? body.timeZone.slice(0, 64) : undefined }))
+        case 'room-progress':
+          return ok([...rt.roomProgress.entries()].filter(([, entry]) => entry.roomId === body.roomId).map(([callId, entry]) => ({ callId, replies: entry.replies, speaking: entry.speaking ?? null })))
+        case 'create-bot': {
+          await rt.bootstrap()
+          const bot = await rt.createBot({ name: body.name, role: body.role, color: body.color, instructions: body.instructions, brief: body.brief, avatar: body.avatar, model: body.model })
+          return ok(bot)
+        }
+        case 'update-bot':
+          await rt.load()
+          return ok(await rt.updateBot(body.id, body))
+        case 'delete-bot':
+          await rt.load()
+          await rt.deleteBot(body.id)
+          return ok(view())
+        case 'set-main':
+          await rt.load()
+          await rt.setMain(body.id, body.main !== false, {
+            primary: body.primary === true,
+            replace: typeof body.replace === 'string' ? body.replace : undefined,
+          })
+          return ok(view())
+        case 'create-room': {
+          await rt.load()
+          const room = await rt.createRoom({ members: Array.isArray(body.members) ? body.members : [], name: body.name, ...(typeof body.admin === 'string' ? { admin: body.admin } : {}) })
+          if (body.greet === true) await rt.greetRoom(room.id).catch(error => rt.warn('ds-bot: greeting in %s failed: %s', room.name, error))
+          return ok(room)
+        }
+        case 'update-room': {
+          await rt.load()
+          const { room, changes } = await rt.updateRoom(body.id, {
+            name: body.name,
+            notice: body.notice,
+            mode: body.mode,
+            admin: body.admin,
+            members: Array.isArray(body.members) ? body.members : undefined,
+            add: Array.isArray(body.add) ? body.add : undefined,
+            remove: Array.isArray(body.remove) ? body.remove : undefined,
+          })
+          return ok({ room: view().rooms.find(entry => entry.id === room.id), changes })
+        }
+        case 'add-agent':
+          await rt.load()
+          return ok(await rt.addAgent())
+        case 'agent-session':
+          await rt.load()
+          return ok({ sessionId: await rt.createAgentSession(body.agentId, body.workspaceId) })
+        case 'agent-adopt':
+          await rt.load()
+          return ok({ sessionId: await rt.adoptAgentSession(body.agentId, body.sessionId) })
+        case 'agent-archive':
+          await rt.load()
+          await rt.archiveAgentSession(body.agentId, body.sessionId)
+          return ok(true)
+        case 'agent-rename':
+          await rt.load()
+          await rt.renameAgentSession(body.agentId, body.sessionId, body.title)
+          return ok(true)
+        case 'remove-agent':
+          await rt.load()
+          await rt.removeAgent(body.agentId)
+          return ok(view())
+        case 'set-flags':
+          await rt.load()
+          return ok(await rt.setFlags(body.id, body))
+        case 'delete-room':
+          await rt.load()
+          await rt.deleteRoom(body.id)
+          return ok(view())
+        case 'dismiss-question':
+          await rt.load()
+          if (state.questions[body.sessionId] !== undefined) {
+            delete state.questions[body.sessionId]
+            await rt.save()
+          }
+          return ok(true)
+        case 'secret-set':
+        case 'secret-allow':
+        case 'secret-cancel':
+        case 'secret-update':
+        case 'secret-delete':
+          await rt.load()
+          return ok(await rt.secretEndpoint(endpoint, body))
+        case 'connector-connect':
+        case 'connector-disconnect':
+        case 'connector-retry':
+          await rt.load()
+          return ok(await rt.connectorEndpoint(endpoint, body))
+        case 'schedules':
+        case 'schedule-create':
+        case 'schedule-delete':
+          await rt.load()
+          return ok(await rt.scheduleEndpoint(endpoint, body))
+        case 'memory-view':
+        case 'memory-ask':
+        case 'memory-forget':
+          await rt.load()
+          return ok(await rt.memoryEndpoint(endpoint, body))
+        case 'answer-question': {
+          if (typeof body.sessionId !== 'string') return fail('Nothing to send', 'bot/invalid')
+          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
+          const question = 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)
+          if (reply === undefined) return fail('Nothing to send', 'bot/invalid')
+          // Claim the question before queueing so a second answer is refused.
+          delete state.questions[sessionId]
+          try {
+            const agent = await rt.resolveAgent(sessionId)
+            agent.followup(createUserMessage({ content: [{ type: 'text', text: reply.text }], source: reply.source }))
+            await ctx.sessions.flush(agent.session)
+          } catch (error) {
+            state.questions[sessionId] ??= question
+            throw error
+          }
+          await rt.save()
+          return ok(true)
+        }
+        case 'send': {
+          const text = String(body.text ?? '').trim()
+          if (text === '' || typeof body.sessionId !== 'string') return fail('Nothing to send', 'bot/invalid')
+          await rt.load()
+          // A Bot id or an earlier part of its own chat means the current part.
+          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
+          await ctx.sessionController.prompt({
+            requestId: randomUUID(),
+            sessionId,
+            mode: 'queue',
+            content: [{ type: 'text', text }],
+          }, AbortSignal.timeout(30_000))
+          return ok(true)
+        }
+        case 'update-check':
+          return ok(await rt.updateCheck({ fresh: body.fresh === true }))
+        case 'update-install':
+          return ok(rt.updateStart())
+        // The Desktop window's long poll for read_browser, and its answers.
+        case 'browser-wait': {
+          if (rt.browserChannel === undefined) return fail('Bot browsers are off on this host', 'bot/browser-off')
+          const clientId = typeof body.clientId === 'string' ? body.clientId.slice(0, 100) : ''
+          if (clientId === '') return fail('A browser poll needs a clientId', 'bot/invalid')
+          await rt.load()
+          return ok(await rt.browserChannel.wait(clientId, rt.browserOpen(body.open)))
+        }
+        case 'browser-result':
+          if (rt.browserChannel === undefined) return fail('Bot browsers are off on this host', 'bot/browser-off')
+          return ok(rt.browserChannel.result(body))
+        case 'diagnostics':
+          await rt.load()
+          return ok(await rt.diagnostics.report(body))
+        case 'diagnostics-log':
+          return ok(await rt.diagnostics.logText())
+        case 'diagnostics-clear':
+          await rt.diagnostics.clear()
+          return ok(true)
+        default:
+          return fail(`Unknown endpoint ${endpoint}`, 'bot/not-found')
+      }
+    } catch (error) {
+      const code = errorCode(error)
+      const message = error?.message ?? String(error)
+      if (code === 'bot/internal') rt.noteFailure({ source: 'api', text: `${endpoint}: ${message}`, code: error?.code ?? error?.name, stack: error?.stack })
+      return fail(message, code)
+    }
+  }
+
+  // An exact Fetch route on the shared /api channel; the browser authenticates with its session cookie.
+  ctx.effect(() => ctx.connection.fetch.register({
+    path: ROUTE,
+    methods: ['POST'],
+    requestBody: 'buffered',
+    fetch: async (request) => {
+      let body
+      try { body = await request.json() } catch { body = {} }
+      const result = await handle(String(body?.endpoint ?? ''), body?.payload)
+      return new Response(JSON.stringify(result), { status: 200, headers: { 'content-type': 'application/json' } })
+    },
+  }), 'ds-bot: api route')
+
+  ctx.effect(() => {
+    void rt.load()
+    return () => {}
+  }, 'ds-bot: load state')
+}

package/src/host/chat-index.js

@@ -0,0 +1,293 @@
+// Reading a Bot's own chat: Session history pages, the SQLite FTS5 index, and the
+// search, latest, and around reads behind read_own_chat.
+//
+// Chat index. read_own_chat searches a SQLite FTS5 table of every part of a Bot's own
+// chat, ranked by BM25. The trigram tokenizer matches any run of three or more
+// characters, so Chinese needs no word splitting; shorter words fall back to LIKE.
+// The index is derived from the Session logs: a part catches up when it is read, an
+// ended part is sealed once it is complete, and deleting the file only costs a
+// rebuild. Without SQLite, read_own_chat scans the logs as before.
+import { mkdir, unlink } from 'node:fs/promises'
+import { join } from 'node:path'
+import { ANCHOR_LINE_MAX, HISTORY_PAGE, HISTORY_PAGES_MAX, HISTORY_TIMEOUT_MS, OWN_CHAT_BRIEF, OWN_CHAT_LINE_MAX, OWN_CHAT_READ, OWN_CHAT_SEARCH } from './constants.js'
+import { excerpt } from './text.js'
+
+const INDEX_VERSION = 3
+const AROUND_LINES = 6
+const SEARCH_TERMS_MAX = 6
+const ANY_TERM_HITS = 50
+const INDEX_TIMEOUT_MS = 120_000
+// A part still gets a few events (a title, a late reply) just after it ends.
+const SEAL_AFTER_MS = 60_000
+
+const likeOf = term => `%${term.replace(/[\\%_]/g, char => `\\${char}`)}%`
+// Each term is a quoted FTS5 phrase when trigrams can match it, else a LIKE filter.
+export function termQuery(terms, sessions, limit, hidden) {
+  const long = terms.filter(term => [...term].length >= 3)
+  const short = terms.filter(term => [...term].length < 3)
+  const where = ['session IN (SELECT value FROM json_each(?))']
+  const args = [JSON.stringify(sessions)]
+  if (hidden !== undefined) {
+    where.push('NOT (session = ? AND seq >= ?)')
+    args.push(hidden.session, hidden.from)
+  }
+  if (long.length > 0) {
+    where.unshift('lines MATCH ?')
+    args.unshift(long.map(term => `"${term.replace(/"/g, '""')}"`).join(' '))
+  }
+  for (const term of short) {
+    where.push("text LIKE ? ESCAPE '\\'")
+    args.push(likeOf(term))
+  }
+  return { sql: `SELECT text, session, seq, time, who FROM lines WHERE ${where.join(' AND ')} ORDER BY ${long.length > 0 ? 'rank' : 'time DESC'} LIMIT ${limit}`, args }
+}
+
+export function install(rt) {
+  const { ctx, home } = rt
+
+  const indexPath = join(home, 'chat-index.sqlite')
+  let chatIndex
+  let indexOpening
+
+  // A Session's events from newest to oldest, also for an archived part.
+  async function* eventsBackwards(sessionId, signal, maxPages = HISTORY_PAGES_MAX) {
+    const agent = await rt.resolveAgent(sessionId)
+    const throughSeq = Number(agent.session.seq) - 1
+    let beforeSeq
+    for (let pages = 0; throughSeq >= 0 && pages < maxPages; pages += 1) {
+      const page = await ctx.sessionController.page({
+        address: { kind: 'session', sessionId },
+        throughSeq,
+        ...(beforeSeq === undefined ? {} : { beforeSeq }),
+        maxMessages: HISTORY_PAGE,
+      }, signal)
+      const events = page.records.map(record => record.event)
+      for (let index = events.length - 1; index >= 0; index -= 1) yield events[index]
+      if (!page.hasMore || events.length === 0) return
+      beforeSeq = events[0].seq
+    }
+  }
+
+  function openIndex() {
+    if (chatIndex !== undefined) return Promise.resolve(chatIndex)
+    const opening = indexOpening ??= (async () => {
+      let DatabaseSync
+      try {
+        ({ DatabaseSync } = await import('node:sqlite'))
+        await mkdir(home, { recursive: true })
+      } catch (error) {
+        rt.warn('ds-bot: no chat index, read_own_chat scans the logs: %s', error)
+        return null
+      }
+      // A damaged file is rebuilt from the logs once.
+      for (const fresh of [false, true]) {
+        try {
+          if (fresh) await unlink(indexPath).catch(() => {})
+          return createIndex(new DatabaseSync(indexPath))
+        } catch (error) {
+          if (fresh) rt.warn('ds-bot: no chat index, read_own_chat scans the logs: %s', error)
+        }
+      }
+      return null
+    })().then((index) => {
+      // The plugin may have been disposed while the file opened.
+      if (indexOpening !== opening) {
+        index?.db.close()
+        return null
+      }
+      return chatIndex = index
+    })
+    return opening
+  }
+
+  function createIndex(db) {
+    try {
+      db.exec('PRAGMA journal_mode = WAL')
+      if (db.prepare('PRAGMA user_version').get().user_version !== INDEX_VERSION) {
+        db.exec(`
+          DROP TABLE IF EXISTS lines;
+          DROP TABLE IF EXISTS marks;
+          CREATE VIRTUAL TABLE lines USING fts5(text, session UNINDEXED, seq UNINDEXED, time UNINDEXED, who UNINDEXED, tokenize = 'trigram');
+          CREATE TABLE marks (session TEXT PRIMARY KEY, through INTEGER NOT NULL, keep INTEGER NOT NULL, sealed INTEGER NOT NULL, turn INTEGER NOT NULL);
+          PRAGMA user_version = ${INDEX_VERSION};`)
+      }
+      return {
+        db,
+        mark: db.prepare('SELECT through, keep, sealed, turn FROM marks WHERE session = ?'),
+        setMark: db.prepare('INSERT OR REPLACE INTO marks (session, through, keep, sealed, turn) VALUES (?, ?, ?, ?, ?)'),
+        insert: db.prepare('INSERT INTO lines (text, session, seq, time, who) VALUES (?, ?, ?, ?, ?)'),
+        before: db.prepare('SELECT text, session, seq, time, who FROM lines WHERE session = ? AND seq < ? ORDER BY seq DESC LIMIT ?'),
+        from: db.prepare('SELECT text, session, seq, time, who FROM lines WHERE session = ? AND seq >= ? ORDER BY seq LIMIT ?'),
+      }
+    } catch (error) {
+      db.close()
+      throw error
+    }
+  }
+  ctx.effect(() => () => {
+    chatIndex?.db.close()
+    chatIndex = undefined
+    indexOpening = undefined
+  }, 'ds-bot: chat index')
+
+  // Adds what a part said since its mark. Reads of one part wait for each other, so no
+  // line is added twice.
+  const catchingUp = new Map()
+  function catchUp(index, part) {
+    const running = catchingUp.get(part.sessionId)
+    if (running) return running
+    const job = (async () => {
+      const mark = index.mark.get(part.sessionId)
+      if (mark?.sealed) return
+      const through = mark?.through ?? -1
+      const events = []
+      for await (const event of eventsBackwards(part.sessionId, AbortSignal.timeout(INDEX_TIMEOUT_MS), Infinity)) {
+        if (event.seq <= through) break
+        events.push(event)
+      }
+      if (events.length > 0 && events.at(-1).seq !== through + 1) throw new Error(`the history of ${part.sessionId} came back with a gap`)
+      events.reverse()
+      if (index !== chatIndex) return
+      let keep = mark ? mark.keep === 1 : false
+      let turn = mark?.turn ?? -1
+      const seal = part.endedAt !== undefined && Date.now() - part.endedAt > SEAL_AFTER_MS
+      index.db.exec('BEGIN')
+      try {
+        let last = through
+        for (const event of events) {
+          last = event.seq
+          if (event.type === 'turn/start') turn = event.seq
+          const entry = rt.historyEntry(event, false)
+          if (entry === undefined) continue
+          if (entry.answer) {
+            if (keep) index.insert.run(entry.text, part.sessionId, event.seq, event.time ?? 0, 'you')
+            continue
+          }
+          keep = entry.keepAnswers
+          if (entry.text !== '') index.insert.run(entry.text, part.sessionId, event.seq, event.time ?? 0, entry.who)
+        }
+        index.setMark.run(part.sessionId, last, keep ? 1 : 0, seal ? 1 : 0, turn)
+        index.db.exec('COMMIT')
+      } catch (error) {
+        index.db.exec('ROLLBACK')
+        throw error
+      }
+    })().finally(() => catchingUp.delete(part.sessionId))
+    catchingUp.set(part.sessionId, job)
+    return job
+  }
+
+  // A message's anchor: its part (once there are several) and its seq in that part.
+  const anchorOf = (parts, row) => {
+    const part = parts.find(item => item.sessionId === row.session)
+    return `${parts.length > 1 ? `part ${part?.number ?? '?'} ` : ''}#${row.seq}`
+  }
+  const rowLine = (parts, row, terms = [], max = OWN_CHAT_LINE_MAX) => {
+    const lower = row.text.toLowerCase()
+    const wanted = terms.find(term => lower.includes(term)) ?? ''
+    const text = row.who === 'user' ? `User: ${row.text}` : row.who === 'you' ? `You: ${row.text}` : row.text
+    return `[${anchorOf(parts, row)} · ${rt.clock(row.time)}] ${excerpt(text, wanted, max)}`
+  }
+
+  // Every part, caught up. Asked from the current part, the turn that asks is left out
+  // (`hidden`): it is in context, and its own question would match.
+  async function indexedParts(botId, askingId) {
+    const index = await openIndex()
+    if (index === null) return { index }
+    const parts = rt.partsOf(botId)
+    // A part that cannot be read now is searched as far as it was indexed.
+    for (const part of parts) await catchUp(index, part).catch(error => rt.warn('ds-bot: indexing %s failed: %s', part.sessionId, error))
+    const turn = askingId !== undefined && askingId === parts.at(-1)?.sessionId ? index.mark.get(askingId)?.turn : undefined
+    return { index, parts, hidden: turn === undefined || turn < 0 ? undefined : { session: askingId, from: turn } }
+  }
+
+  // Messages with all the words, best first; with none of them having all, those with
+  // the most of them. Shown oldest first.
+  async function searchOwnChat(botId, query, { askingId, limit = OWN_CHAT_SEARCH } = {}) {
+    const terms = [...new Set(query.toLowerCase().split(/\s+/).filter(Boolean))].slice(0, SEARCH_TERMS_MAX)
+    const { index, parts, hidden } = await indexedParts(botId, askingId)
+    if (index === null) return { lines: await scanOwnChat(botId, query, limit), every: true }
+    const sessions = parts.map(part => part.sessionId)
+    const run = (wanted, max) => {
+      const { sql, args } = termQuery(wanted, sessions, max, hidden)
+      return index.db.prepare(sql).all(...args)
+    }
+    const byTime = (a, b) => (a.time - b.time) || (sessions.indexOf(a.session) - sessions.indexOf(b.session)) || (a.seq - b.seq)
+    let rows = run(terms, limit)
+    let every = true
+    if (rows.length === 0 && terms.length > 1) {
+      every = false
+      const found = new Map()
+      for (const term of terms) {
+        for (const row of run([term], ANY_TERM_HITS)) {
+          const key = `${row.session}#${row.seq}`
+          const hit = found.get(key) ?? { row, count: 0 }
+          hit.count += 1
+          found.set(key, hit)
+        }
+      }
+      rows = [...found.values()].sort((a, b) => (b.count - a.count) || (b.row.time - a.row.time)).slice(0, limit).map(hit => hit.row)
+    }
+    return { lines: rows.sort(byTime).map(row => rowLine(parts, row, terms)), every }
+  }
+
+  // The latest messages across all parts, oldest first.
+  async function latestOwnChat(botId, { askingId, limit = OWN_CHAT_READ } = {}) {
+    const { index, parts, hidden } = await indexedParts(botId, askingId)
+    if (index === null) return scanOwnChat(botId, '', limit)
+    const rows = []
+    for (const part of [...parts].reverse()) {
+      const below = hidden?.session === part.sessionId ? hidden.from : Number.MAX_SAFE_INTEGER
+      rows.push(...index.before.all(part.sessionId, below, limit - rows.length))
+      if (rows.length >= limit) break
+    }
+    return rows.reverse().map(row => rowLine(parts, row))
+  }
+
+  // The messages around an anchor, in its part.
+  async function aroundOwnChat(botId, anchor) {
+    const { index, parts } = await indexedParts(botId)
+    if (index === null) return { error: 'Anchors need the chat index, which is unavailable here. Search with words instead.' }
+    const found = /(?:part\s*)?(\d+)?\s*#\s*(\d+)/i.exec(anchor)
+    if (found === null) return { error: `"${anchor}" is not an anchor. Anchors look like "part 2 #1234", or "#1234" in the current part.` }
+    const number = found[1] === undefined ? parts.length : Number(found[1])
+    const part = parts[number - 1]
+    if (part === undefined) return { error: `Your own chat has no part ${number}.` }
+    const seq = Number(found[2])
+    const rows = [...index.before.all(part.sessionId, seq, AROUND_LINES).reverse(), ...index.from.all(part.sessionId, seq, AROUND_LINES + 1)]
+    return { part, exact: rows.some(row => row.seq === seq), lines: rows.map(row => rowLine(parts, row, [], row.seq === seq ? ANCHOR_LINE_MAX : OWN_CHAT_LINE_MAX)) }
+  }
+
+  // Without the index: what the user, other Bots, and the Bot itself said, across all
+  // parts, oldest first, by reading the logs.
+  async function scanOwnChat(botId, query, limit) {
+    const wanted = query.toLowerCase()
+    const parts = rt.partsOf(botId)
+    const signal = AbortSignal.timeout(HISTORY_TIMEOUT_MS)
+    const lines = []
+    for (const part of [...parts].reverse()) {
+      for await (const line of rt.partLines(part.sessionId, signal)) {
+        if (wanted !== '' && !line.text.toLowerCase().includes(wanted)) continue
+        lines.push(`[${parts.length > 1 ? `part ${part.number} · ` : ''}${rt.clock(line.time)}] ${excerpt(line.text, wanted)}`)
+        if (lines.length >= limit) break
+      }
+      if (lines.length >= limit) break
+    }
+    return lines.reverse()
+  }
+
+  // The parts of a Bot's own chat, for the model: when each ran.
+  const partIndex = parts => parts.map(part => `part ${part.number} (${rt.clock(part.startedAt)} – ${part.endedAt === undefined ? 'now' : rt.clock(part.endedAt)})`).join(', ')
+
+  async function ownChatBrief(member) {
+    let lines = []
+    try { lines = await latestOwnChat(member.id, { limit: OWN_CHAT_BRIEF }) } catch (error) { rt.warn('ds-bot: brief for %s failed: %s', member.name, error) }
+    return [
+      'Your own chat with the user so far (latest messages, oldest first; private, so share only what the group needs):',
+      lines.length > 0 ? lines.join('\n') : 'Nothing yet.',
+      'This brief does not change. Call read_own_chat when you need something newer or older from your own chat.',
+    ].join('\n')
+  }
+
+  Object.assign(rt, { eventsBackwards, searchOwnChat, latestOwnChat, aroundOwnChat, partIndex, ownChatBrief })
+}