@threadcrumbs/common 0.0.0-stage → 0.1.1

package/lib/opencode-store.mjs

@@ -0,0 +1,602 @@
+import fsp from 'node:fs/promises'
+import path from 'node:path'
+import { columnsOf, tablesOf, withReadOnly } from './sqlite.mjs'
+import {
+  DETAIL_LIMITS,
+  RECENT_MS,
+  activityDetail,
+  addFileChange,
+  clip,
+  clipBlock,
+  emptyActivity,
+  endCall,
+  fileList,
+  keepNewest,
+  number,
+  planItems,
+  planSummary,
+  settleCalls,
+  startCall,
+  text,
+  titleFromPrompt,
+  toolFile,
+  toolInput,
+  toolTarget,
+} from './telemetry-fields.mjs'
+
+const ACTIVE_WINDOW_MS = 30 * 60 * 1000
+const SUBAGENT_WINDOW_MS = 10 * 60 * 1000
+const OPEN_TOOL = new Set(['pending', 'streaming', 'running'])
+const ABORTED = /abort/i
+const STOPPED = /user rejected permission|permission.{0,20}denied|denied.{0,20}permission|aborted|cancelled/i
+const QUESTION_TOOL = 'question'
+const SUBAGENT_TOOLS = new Set(['task', 'subagent'])
+const TODO_TOOL = 'todowrite'
+const CATALOG_KEY = 'models-dev:v2:catalog'
+const TURN_MESSAGES = ['user', 'assistant', 'shell', 'synthetic', 'compaction', 'idle']
+const USAGE_COLUMNS = ['cost', 'tokens_input', 'tokens_output', 'tokens_reasoning', 'tokens_cache_read', 'tokens_cache_write']
+
+function parse(raw) {
+  try {
+    const value = typeof raw === 'string' ? JSON.parse(raw) : raw
+    return value && typeof value === 'object' ? value : {}
+  } catch {
+    return {}
+  }
+}
+
+const list = (value) => (Array.isArray(value) ? value : Object.values(value || {}))
+
+function addTokens(total, t) {
+  if (!t) return total
+  const next = total || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+  next.input += number(t.input)
+  next.output += number(t.output) + number(t.reasoning)
+  next.cacheRead += number(t.cache?.read)
+  next.cacheWrite += number(t.cache?.write)
+  return next
+}
+
+const windowOf = (t) => number(t?.input) + number(t?.output) + number(t?.reasoning) + number(t?.cache?.read) + number(t?.cache?.write)
+
+function usageFromColumns(row) {
+  if (row.tokens_input == null && row.cost == null) return null
+  return {
+    tokens: {
+      input: number(row.tokens_input),
+      output: number(row.tokens_output) + number(row.tokens_reasoning),
+      cacheRead: number(row.tokens_cache_read),
+      cacheWrite: number(row.tokens_cache_write),
+    },
+    cost: row.cost == null ? null : number(row.cost),
+  }
+}
+
+const pickColumns = (cols, names) => names.map((c) => (cols.has(c) ? c : `NULL AS ${c}`)).join(', ')
+
+export function opencodeStore({ id, name, dbPath, watchDirs, limitsFile, continuing = ['tool-calls'], liveSummary = false, now = Date.now }) {
+  const facts = new Map()
+  const options = { id, continuing: new Set(continuing), liveSummary }
+  let limits = { file: '', mtime: -1, byModel: new Map() }
+
+  async function fileLimits() {
+    const file = await limitsFile()
+    const stat = file ? await fsp.stat(file).catch(() => null) : null
+    if (!stat) return new Map()
+    if (limits.file === file && limits.mtime === stat.mtimeMs) return limits.byModel
+    const byModel = new Map()
+    for (const [providerId, provider] of Object.entries(parse(await fsp.readFile(file, 'utf8').catch(() => '{}')))) {
+      for (const [modelId, model] of Object.entries(provider?.models || {})) {
+        const limit = number(model?.limit?.context)
+        if (limit) byModel.set(`${providerId}/${modelId}`, limit)
+      }
+    }
+    limits = { file, mtime: stat.mtimeMs, byModel }
+    return byModel
+  }
+
+  async function scanSessions() {
+    const file = await dbPath()
+    if (!file) return []
+    const context = { ...options, facts, seen: new Set(), byModel: new Map(await fileLimits()), at: now() }
+    const sessions = await withReadOnly(
+      file,
+      (db) => {
+        const tables = tablesOf(db)
+        const byId = new Map()
+        const keep = (s) => {
+          const existing = byId.get(s.id)
+          if (!existing || s.lastActivityAt >= existing.lastActivityAt) byId.set(s.id, s)
+        }
+        if (['session', 'message', 'part'].every((t) => tables.has(t))) legacySessions(db, tables, context).forEach(keep)
+        if (tables.has('session_v2') && tables.has('session_message')) {
+          if (tables.has('kv')) catalogLimits(db, context.byModel)
+          currentSessions(db, tables, context).forEach(keep)
+        }
+        return [...byId.values()]
+      },
+      [],
+    )
+    for (const key of facts.keys()) if (!context.seen.has(key)) facts.delete(key)
+    return sessions
+  }
+
+  async function sessionDetail(key) {
+    const prefix = `${id}:`
+    const sessionId = String(key).startsWith(prefix) ? String(key).slice(prefix.length) : ''
+    const file = sessionId ? await dbPath() : ''
+    if (!file) return null
+    const context = { ...options, facts, seen: new Set(), byModel: new Map(), at: now() }
+    return withReadOnly(
+      file,
+      (db) => {
+        const tables = tablesOf(db)
+        const legacy = ['session', 'message', 'part'].every((t) => tables.has(t)) ? sessionRow(db, 'session', sessionId) : null
+        const current = tables.has('session_v2') && tables.has('session_message') ? sessionRow(db, 'session_v2', sessionId) : null
+        if (!legacy && !current) return null
+        const useCurrent = current && (!legacy || number(current.time_updated) >= number(legacy.time_updated))
+        const detail = useCurrent ? currentDetail(db, tables, current, context) : legacyDetail(db, tables, legacy, context)
+        return { id: `${id}:${sessionId}`, sessionId, source: file, ...detail }
+      },
+      null,
+    )
+  }
+
+  return {
+    id,
+    name,
+    detect: async () => Boolean(await dbPath()),
+    watchRoots: () => watchDirs,
+    scanSessions,
+    sessionDetail,
+  }
+}
+
+const ROW_COLUMNS = ['title', 'parent_id', 'model', 'time_archived', 'time_idle', 'time_busy', 'idle_outcome', ...USAGE_COLUMNS]
+
+function sessionRows(db, table, where, value) {
+  const cols = columnsOf(db, table)
+  if (!['id', 'directory', 'time_created', 'time_updated'].every((c) => cols.has(c))) return []
+  if (where === 'parent_id' && !cols.has('parent_id')) return []
+  return db.prepare(`SELECT id, directory, time_created, time_updated, ${pickColumns(cols, ROW_COLUMNS)} FROM ${table} WHERE ${where} = ?`).all(value)
+}
+
+function sessionRow(db, table, sessionId) {
+  const row = sessionRows(db, table, 'id', sessionId)[0]
+  return row && !row.parent_id && row.time_archived == null ? row : null
+}
+
+function addModelUsage(models, model, tokens, cost) {
+  if (!model) return
+  const entry = models.get(model) || { model, tokens: null, costUsd: null }
+  entry.tokens = addTokens(entry.tokens, tokens)
+  if (cost != null) entry.costUsd = (entry.costUsd || 0) + number(cost)
+  models.set(model, entry)
+}
+
+function modelList(models) {
+  return [...models.values()].map((m) => ({ model: m.model, tokens: m.tokens || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, costUsd: m.costUsd }))
+}
+
+function childList(rows, turnOf) {
+  return rows
+    .filter((r) => r.time_archived == null)
+    .map((r) => {
+      const turn = turnOf(r)
+      return {
+        id: r.id,
+        name: text(r.title).trim() || (turn.firstPrompt ? titleFromPrompt(turn.firstPrompt) : '') || 'Subagent',
+        type: '',
+        status: turn.open ? 'working' : turn.failed ? 'error' : 'done',
+        model: turn.model,
+        tokens: turn.tokens ? { ...turn.tokens } : null,
+        tool: turn.open && turn.tool ? { ...turn.tool } : null,
+        startedAt: number(r.time_created),
+        lastActivityAt: number(r.time_updated),
+      }
+    })
+    .sort((a, b) => a.startedAt - b.startedAt)
+    .slice(-DETAIL_LIMITS.subagents)
+}
+
+function legacyDetail(db, tables, row, context) {
+  const directory = text(row.directory)
+  const activity = emptyActivity()
+  const history = []
+  const prompts = []
+  const errors = []
+  const files = new Map()
+  const models = new Map()
+  let contextParts = null
+  const typed = new Set(
+    db
+      .prepare(`SELECT message_id FROM part WHERE session_id = ? AND data LIKE '%"type":"text"%' AND data NOT LIKE '%"synthetic":true%'`)
+      .all(row.id)
+      .map((r) => r.message_id),
+  )
+  const modelOf = new Map()
+  const messageUsage = []
+  for (const message of db.prepare('SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, rowid').all(row.id)) {
+    const data = parse(message.data)
+    const at = number(data.time?.created) || number(message.time_created)
+    if (data.role === 'user') {
+      if (typed.has(message.id)) {
+        const prompt = firstText(db, message.id)
+        if (prompt) keepNewest(prompts, { at, text: clipBlock(prompt, DETAIL_LIMITS.promptText) }, DETAIL_LIMITS.prompts)
+      }
+      for (const diff of Array.isArray(data.summary?.diffs) ? data.summary.diffs : []) {
+        if (text(diff?.file)) addFileChange(files, text(diff.file), number(diff.additions), number(diff.deletions))
+      }
+      continue
+    }
+    if (data.role !== 'assistant') continue
+    const model = text(data.modelID)
+    modelOf.set(message.id, model)
+    messageUsage.push([model, data.tokens, data.cost])
+    if (number(data.tokens?.output) > 0) {
+      const output = number(data.tokens.output) + number(data.tokens.reasoning)
+      keepNewest(history, { at: number(data.time?.completed) || at, context: windowOf(data.tokens), output }, DETAIL_LIMITS.history)
+      contextParts = { input: number(data.tokens.input), cacheRead: number(data.tokens.cache?.read), cacheWrite: number(data.tokens.cache?.write), output: number(data.tokens.output) + number(data.tokens.reasoning) }
+    }
+    const error = text(data.error?.name)
+    if (error && !ABORTED.test(error)) {
+      keepNewest(errors, { at, message: clip(text(data.error?.data?.message) || error, DETAIL_LIMITS.errorText) }, DETAIL_LIMITS.errors)
+    }
+  }
+
+  const steps = db.prepare(`SELECT message_id, data FROM part WHERE session_id = ? AND data LIKE '%"type":"step-finish"%' ORDER BY rowid`).all(row.id)
+  if (steps.length) {
+    for (const step of steps) {
+      const data = parse(step.data)
+      addModelUsage(models, modelOf.get(step.message_id), data.tokens, data.cost)
+    }
+  } else {
+    for (const [model, tokens, cost] of messageUsage) addModelUsage(models, model, tokens, cost)
+  }
+
+  for (const part of db.prepare(`SELECT id, data FROM part WHERE session_id = ? AND data LIKE '%"type":"tool"%' ORDER BY rowid`).all(row.id)) {
+    const data = parse(part.data)
+    if (data.type !== 'tool') continue
+    const state = data.state || {}
+    const callId = text(data.callID) || part.id
+    const call = { id: callId, name: text(data.tool), target: toolTarget(state.input, directory), input: toolInput(state.input), ...toolFile(state.input, directory) }
+    if (!startCall(activity, { ...call, startedAt: number(state.time?.start) })) continue
+    if (state.status === 'completed' || state.status === 'error') {
+      const failed = state.status === 'error' && !STOPPED.test(`${text(state.error)}\n${text(state.output)}`)
+      endCall(activity, callId, number(state.time?.end), failed, text(state.error) || text(state.output))
+    }
+  }
+  const turnOf = (r) => cached(context, `v1:${r.id}`, number(r.time_updated), () => legacyTurn(db, r, context))
+  if (!turnOf(row).open) settleCalls(activity)
+
+  const todoCols = tables.has('todo') ? columnsOf(db, 'todo') : new Set()
+  const plan = ['session_id', 'content', 'status'].every((c) => todoCols.has(c))
+    ? db.prepare(`SELECT content, status FROM todo WHERE session_id = ? ORDER BY ${todoCols.has('position') ? 'position' : 'rowid'}`).all(row.id)
+    : []
+
+  return {
+    models: modelList(models),
+    history,
+    compactions: null,
+    contextParts,
+    ...activityDetail(activity),
+    plan: planItems(plan.map((t) => ({ content: text(t.content), status: text(t.status) }))),
+    subagents: childList(sessionRows(db, 'session', 'parent_id', row.id), turnOf),
+    files: files.size || !context.liveSummary ? fileList(files, directory) : null,
+    prompts,
+    errors,
+  }
+}
+
+function currentDetail(db, tables, row, context) {
+  const directory = text(row.directory)
+  const activity = emptyActivity()
+  const history = []
+  const prompts = []
+  const errors = []
+  const models = new Map()
+  let contextParts = null
+  for (const message of db.prepare('SELECT type, time_created, data FROM session_message WHERE session_id = ? ORDER BY seq').all(row.id)) {
+    const data = parse(message.data)
+    const at = number(message.time_created)
+    if (message.type === 'user') {
+      const prompt = text(data.text).trim()
+      if (prompt) keepNewest(prompts, { at, text: clipBlock(prompt, DETAIL_LIMITS.promptText) }, DETAIL_LIMITS.prompts)
+    } else if (message.type === 'assistant') {
+      addModelUsage(models, text(data.model?.id), data.tokens, data.cost)
+      if (number(data.tokens?.output) > 0) {
+        keepNewest(history, { at, context: windowOf(data.tokens), output: number(data.tokens.output) + number(data.tokens.reasoning) }, DETAIL_LIMITS.history)
+        contextParts = { input: number(data.tokens.input), cacheRead: number(data.tokens.cache?.read), cacheWrite: number(data.tokens.cache?.write), output: number(data.tokens.output) + number(data.tokens.reasoning) }
+      }
+    } else if (message.type === 'idle' && text(data.outcome) === 'failed') {
+      keepNewest(errors, { at, message: clip(text(data.error?.message) || 'The turn failed', DETAIL_LIMITS.errorText) }, DETAIL_LIMITS.errors)
+    }
+  }
+
+  const parts = tables.has('session_part') && ['session_id', 'message_id', 'type', 'data'].every((c) => columnsOf(db, 'session_part').has(c))
+  let plan = []
+  if (parts) {
+    for (const part of db.prepare(`SELECT id, data FROM session_part WHERE session_id = ? AND type = 'tool' ORDER BY rowid`).all(row.id)) {
+      const data = parse(part.data)
+      const state = data.state || {}
+      const callId = text(data.callID) || text(data.id) || part.id
+      const call = { id: callId, name: text(data.name), target: toolTarget(state.input, directory), input: toolInput(state.input), ...toolFile(state.input, directory) }
+      if (!startCall(activity, { ...call, startedAt: number(data.time?.ran) || number(data.time?.created) })) continue
+      if (state.status === 'completed' || state.status === 'error') {
+        endCall(activity, callId, number(state.time?.end) || number(data.time?.completed), state.status === 'error', text(state.error) || text(state.output))
+      }
+      if (data.name === TODO_TOOL && state.status === 'completed' && Array.isArray(state.input?.todos)) {
+        plan = state.input.todos.map((t) => ({ content: text(t?.content), status: text(t?.status) }))
+      }
+    }
+  }
+  const turnOf = (r) => cached(context, `v2:${r.id}`, number(r.time_updated), () => currentTurn(db, r, parts, context))
+  if (!turnOf(row).open) settleCalls(activity)
+
+  return {
+    models: modelList(models),
+    history,
+    compactions: null,
+    contextParts,
+    ...activityDetail(activity),
+    plan: planItems(plan),
+    subagents: childList(sessionRows(db, 'session_v2', 'parent_id', row.id), turnOf),
+    files: null,
+    prompts,
+    errors,
+  }
+}
+
+function catalogLimits(db, byModel) {
+  const row = db.prepare('SELECT value FROM kv WHERE key = ?').get(CATALOG_KEY)
+  if (!row) return
+  const body = parse(parse(row.value).body)
+  for (const provider of list(body.providers ?? body)) {
+    for (const model of list(provider?.models)) {
+      const limit = number(model?.limit?.context)
+      if (provider?.id && model?.id && limit) byModel.set(`${provider.id}/${model.id}`, limit)
+    }
+  }
+}
+
+function cached(context, key, updated, compute) {
+  context.seen.add(key)
+  const hit = context.facts.get(key)
+  let turn = hit?.value
+  if (!hit || hit.updated !== updated) {
+    turn = compute()
+    context.facts.set(key, { updated, value: turn })
+  }
+  const open = turn.busy && context.at - updated < ACTIVE_WINDOW_MS
+  return { ...turn, open, tool: open ? turn.tool : null }
+}
+
+function statusOf({ open, failed, errands, tool, lastActivityAt, read, at }) {
+  if (open) {
+    if (tool?.name === QUESTION_TOOL) return 'asking'
+    if (errands && (!tool || SUBAGENT_TOOLS.has(tool.name))) return 'delegating'
+    return 'working'
+  }
+  if (errands) return 'delegating'
+  if (failed) return 'error'
+  if (read) return read.unread ? 'done' : 'idle'
+  return at - lastActivityAt < ACTIVE_WINDOW_MS ? 'done' : 'idle'
+}
+
+function session(context, row, turn, extra) {
+  const directory = text(row.directory)
+  const sessionModel = parse(row.model)
+  const lastActivityAt = number(row.time_updated)
+  const viewed = number(row.time_viewed)
+  const read = viewed > 0 ? { unread: number(row.time_idle) > viewed } : null
+  const status = statusOf({ ...turn, errands: extra.errands, lastActivityAt, read, at: context.at })
+  return {
+    id: `${context.id}:${row.id}`,
+    harness: context.id,
+    title: text(row.title).trim() || (turn.firstPrompt ? titleFromPrompt(turn.firstPrompt) : '') || 'Untitled session',
+    project: path.basename(directory.replace(/\\/g, '/')) || 'unknown',
+    projectPath: directory,
+    worktree: '',
+    cwd: directory,
+    gitBranch: '',
+    model: turn.model || text(sessionModel.id),
+    effort: turn.effort || text(sessionModel.variant),
+    status,
+    live: turn.open,
+    startedAt: number(row.time_created),
+    lastActivityAt,
+    tool: turn.open && turn.tool ? { ...turn.tool } : null,
+    tokens: turn.tokens ? { ...turn.tokens } : null,
+    context: turn.context ? { used: turn.context, limit: context.byModel.get(`${turn.provider}/${turn.model}`) || 0 } : null,
+    costUsd: turn.cost,
+    lines: extra.lines,
+    plan: planSummary(extra.plan),
+    subagents: extra.errands,
+    prompts: turn.prompts,
+  }
+}
+
+function legacySessions(db, tables, context) {
+  const cols = columnsOf(db, 'session')
+  if (!['id', 'directory', 'time_created', 'time_updated'].every((c) => cols.has(c))) return []
+  const rows = db
+    .prepare(
+      `SELECT id, directory, time_created, time_updated, ${pickColumns(cols, ['title', 'parent_id', 'model', 'time_archived', 'summary_additions', 'summary_deletions', ...USAGE_COLUMNS])} FROM session WHERE time_updated > ?`,
+    )
+    .all(context.at - RECENT_MS)
+  const todoCols = tables.has('todo') ? columnsOf(db, 'todo') : new Set()
+  const todos = ['session_id', 'content', 'status'].every((c) => todoCols.has(c))
+  const turnOf = (row) => cached(context, `v1:${row.id}`, number(row.time_updated), () => legacyTurn(db, row, context))
+  const out = []
+  for (const row of rows) {
+    if (row.parent_id || row.time_archived != null) continue
+    const turn = turnOf(row)
+    const errands = rows.filter((r) => r.parent_id === row.id && context.at - number(r.time_updated) < SUBAGENT_WINDOW_MS && turnOf(r).open).length
+    const lines = context.liveSummary
+      ? row.summary_additions == null && row.summary_deletions == null
+        ? null
+        : { added: number(row.summary_additions), removed: number(row.summary_deletions) }
+      : turn.lines
+    const plan = todos
+      ? db
+          .prepare(`SELECT content, status FROM todo WHERE session_id = ? ORDER BY ${todoCols.has('position') ? 'position' : 'rowid'}`)
+          .all(row.id)
+          .map((t) => ({ content: text(t.content), status: text(t.status) }))
+      : null
+    out.push(session(context, row, turn, { errands, lines, plan }))
+  }
+  return out
+}
+
+function legacyTurn(db, row, context) {
+  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, lines: null, tool: null }
+  const typed = new Set(
+    db
+      .prepare(`SELECT message_id FROM part WHERE session_id = ? AND data LIKE '%"type":"text"%' AND data NOT LIKE '%"synthetic":true%'`)
+      .all(row.id)
+      .map((r) => r.message_id),
+  )
+  let last = null
+  let lastAssistant = ''
+  for (const message of db.prepare('SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created, rowid').all(row.id)) {
+    const data = parse(message.data)
+    last = data
+    if (data.role === 'user') {
+      if (typed.has(message.id)) {
+        turn.prompts++
+        if (!turn.firstPrompt) turn.firstPrompt = firstText(db, message.id)
+      }
+      if (Array.isArray(data.summary?.diffs)) {
+        turn.lines ||= { added: 0, removed: 0 }
+        for (const diff of data.summary.diffs) {
+          turn.lines.added += number(diff?.additions)
+          turn.lines.removed += number(diff?.deletions)
+        }
+      }
+      continue
+    }
+    if (data.role !== 'assistant') continue
+    lastAssistant = message.id
+    if (data.modelID) turn.model = text(data.modelID)
+    if (data.providerID) turn.provider = text(data.providerID)
+    if (data.variant) turn.effort = text(data.variant)
+    if (data.cost != null) turn.cost = (turn.cost || 0) + number(data.cost)
+    if (number(data.tokens?.output) > 0) turn.context = windowOf(data.tokens)
+  }
+  const usage = usageFromColumns(row)
+  if (usage) {
+    turn.tokens = usage.tokens
+    if (usage.cost != null) turn.cost = usage.cost
+  } else {
+    for (const part of db.prepare(`SELECT data FROM part WHERE session_id = ? AND data LIKE '%"type":"step-finish"%'`).all(row.id)) {
+      turn.tokens = addTokens(turn.tokens, parse(part.data).tokens)
+    }
+  }
+  const error = text(last?.error?.name)
+  const finish = text(last?.finish)
+  const ended = Boolean(last?.time?.completed) || Boolean(finish)
+  turn.busy = last?.role === 'user' || (last?.role === 'assistant' && !error && (!ended || context.continuing.has(finish)))
+  turn.failed = last?.role === 'assistant' && (error ? !ABORTED.test(error) : ended && toolFailed(db, lastAssistant))
+  if (turn.busy) turn.tool = runningTool(db, lastAssistant)
+  return turn
+}
+
+function firstText(db, messageId) {
+  for (const part of db.prepare('SELECT data FROM part WHERE message_id = ? ORDER BY rowid LIMIT 8').all(messageId)) {
+    const data = parse(part.data)
+    if (data.type === 'text' && !data.synthetic && text(data.text).trim()) return text(data.text).trim()
+  }
+  return ''
+}
+
+function toolFailed(db, messageId) {
+  for (const part of db.prepare(`SELECT data FROM part WHERE message_id = ? AND data LIKE '%"status":"error"%'`).all(messageId)) {
+    const state = parse(part.data).state || {}
+    if (!STOPPED.test(`${text(state.error)}\n${text(state.output)}`)) return true
+  }
+  return false
+}
+
+function runningTool(db, messageId) {
+  if (!messageId) return null
+  let tool = null
+  for (const part of db.prepare('SELECT data FROM part WHERE message_id = ? ORDER BY rowid').all(messageId)) {
+    const data = parse(part.data)
+    if (data.type !== 'tool' || !OPEN_TOOL.has(data.state?.status)) continue
+    tool = { name: text(data.tool), startedAt: number(data.state?.time?.start) }
+  }
+  return tool
+}
+
+function currentSessions(db, tables, context) {
+  const cols = columnsOf(db, 'session_v2')
+  if (!['id', 'directory', 'time_created', 'time_updated'].every((c) => cols.has(c))) return []
+  const rows = db
+    .prepare(
+      `SELECT id, directory, time_created, time_updated, ${pickColumns(cols, ['title', 'parent_id', 'model', 'time_archived', 'time_idle', 'time_viewed', 'time_busy', 'idle_outcome', ...USAGE_COLUMNS])} FROM session_v2 WHERE time_updated > ?`,
+    )
+    .all(context.at - RECENT_MS)
+  const parts = tables.has('session_part') && ['session_id', 'message_id', 'type', 'data'].every((c) => columnsOf(db, 'session_part').has(c))
+  const turnOf = (row) => cached(context, `v2:${row.id}`, number(row.time_updated), () => currentTurn(db, row, parts, context))
+  const out = []
+  for (const row of rows) {
+    if (row.parent_id || row.time_archived != null) continue
+    const turn = turnOf(row)
+    const errands = rows.filter((r) => r.parent_id === row.id && context.at - number(r.time_updated) < SUBAGENT_WINDOW_MS && turnOf(r).open).length
+    out.push(session(context, row, turn, { errands, lines: null, plan: turn.plan }))
+  }
+  return out
+}
+
+function currentTurn(db, row, parts, context) {
+  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, tool: null, plan: null }
+  turn.prompts = number(db.prepare(`SELECT COUNT(*) AS n FROM session_message WHERE session_id = ? AND type = 'user'`).get(row.id)?.n)
+  turn.firstPrompt = text(parse(db.prepare(`SELECT data FROM session_message WHERE session_id = ? AND type = 'user' ORDER BY seq ASC LIMIT 1`).get(row.id)?.data).text).trim()
+  const assistant = db.prepare(`SELECT id, data FROM session_message WHERE session_id = ? AND type = 'assistant' ORDER BY seq DESC LIMIT 1`).get(row.id)
+  const latest = parse(assistant?.data)
+  turn.model = text(latest.model?.id)
+  turn.provider = text(latest.model?.providerID)
+  turn.effort = text(latest.model?.variant)
+  const withTokens = db
+    .prepare(`SELECT data FROM session_message WHERE session_id = ? AND type = 'assistant' AND data LIKE '%"tokens"%' ORDER BY seq DESC LIMIT 1`)
+    .get(row.id)
+  turn.context = windowOf(parse(withTokens?.data).tokens)
+  const usage = usageFromColumns(row)
+  if (usage) {
+    turn.tokens = usage.tokens
+    turn.cost = usage.cost
+  }
+  const last = db
+    .prepare(`SELECT type, data FROM session_message WHERE session_id = ? AND type IN (${TURN_MESSAGES.map(() => '?').join(', ')}) ORDER BY seq DESC LIMIT 1`)
+    .get(row.id, ...TURN_MESSAGES)
+  const busy = row.time_busy != null ? number(row.time_busy) > number(row.time_idle) : Boolean(last) && last.type !== 'idle'
+  turn.busy = busy
+  const outcome = text(row.idle_outcome) || (last?.type === 'idle' ? text(parse(last.data).outcome) : '')
+  turn.failed = !busy && outcome === 'failed'
+  const tools = currentTools(db, row.id, assistant, parts)
+  if (busy) turn.tool = tools.running
+  turn.plan = tools.todos
+  return turn
+}
+
+function currentTools(db, sessionId, assistant, parts) {
+  const result = { running: null, todos: null }
+  let latest = []
+  let recent = []
+  if (parts && assistant) {
+    latest = db.prepare(`SELECT data FROM session_part WHERE session_id = ? AND message_id = ? AND type = 'tool'`).all(sessionId, assistant.id).map((p) => parse(p.data))
+  }
+  if (parts) {
+    recent = db
+      .prepare(`SELECT data FROM session_part WHERE session_id = ? AND type = 'tool' AND data LIKE ? ORDER BY rowid DESC LIMIT 20`)
+      .all(sessionId, `%"${TODO_TOOL}"%`)
+      .map((p) => parse(p.data))
+  }
+  if (!latest.length && assistant) latest = list(parse(assistant.data).content).filter((c) => c?.type === 'tool')
+  for (const part of latest) {
+    if (OPEN_TOOL.has(part.state?.status)) result.running = { name: text(part.name), startedAt: number(part.time?.ran) || number(part.time?.created) }
+  }
+  const todos = recent.find((p) => p.name === TODO_TOOL && p.state?.status === 'completed' && Array.isArray(p.state?.input?.todos))
+  if (todos) result.todos = todos.state.input.todos.map((t) => ({ content: text(t?.content), status: text(t?.status) }))
+  return result
+}

package/lib/sqlite.mjs

@@ -0,0 +1,29 @@
+let sqlitePromise
+export const sqliteApi = () => (sqlitePromise ??= import('node:sqlite').catch(() => null))
+
+export async function openReadOnly(file) {
+  const sqlite = await sqliteApi()
+  if (!file || !sqlite?.DatabaseSync) return null
+  try {
+    return new sqlite.DatabaseSync(file, { readOnly: true })
+  } catch {
+    return null
+  }
+}
+
+export async function withReadOnly(file, run, fallback) {
+  const db = await openReadOnly(file)
+  if (!db) return fallback
+  try {
+    return await run(db)
+  } finally {
+    try {
+      db.close()
+    } catch {}
+  }
+}
+
+export const tablesOf = (db) =>
+  new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((r) => r.name))
+
+export const columnsOf = (db, table) => new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((r) => r.name))