@threadcrumbs/common 0.1.2 → 0.1.4

package/lib/opencode-store.mjs

@@ -6,21 +6,30 @@ import {
   RECENT_MS,
   activityDetail,
   addFileChange,
+  askOf,
   clip,
   clipBlock,
   emptyActivity,
+  emptySample,
   endCall,
   fileList,
+  joinedText,
   keepNewest,
+  keepText,
   number,
+  openTool,
   planItems,
   planSummary,
+  sampleList,
+  samplePoint,
   settleCalls,
   startCall,
   text,
+  textList,
   titleFromPrompt,
   toolFile,
   toolInput,
+  toolNow,
   toolTarget,
 } from './telemetry-fields.mjs'
 
@@ -185,12 +194,12 @@ function childList(rows, turnOf) {
       const turn = turnOf(r)
       return {
         id: r.id,
-        name: text(r.title).trim() || (turn.firstPrompt ? titleFromPrompt(turn.firstPrompt) : '') || 'Subagent',
+        name: childName(r, turn),
         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,
+        tool: turn.open && turn.tool ? toolNow(turn.tool) : null,
         startedAt: number(r.time_created),
         lastActivityAt: number(r.time_updated),
       }
@@ -215,6 +224,7 @@ function legacyDetail(db, tables, row, context) {
       .map((r) => r.message_id),
   )
   const modelOf = new Map()
+  const messageAt = 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)
@@ -232,6 +242,7 @@ function legacyDetail(db, tables, row, context) {
     if (data.role !== 'assistant') continue
     const model = text(data.modelID)
     modelOf.set(message.id, model)
+    messageAt.set(message.id, at)
     messageUsage.push([model, data.tokens, data.cost])
     if (number(data.tokens?.output) > 0) {
       const output = number(data.tokens.output) + number(data.tokens.reasoning)
@@ -266,6 +277,17 @@ function legacyDetail(db, tables, row, context) {
       endCall(activity, callId, number(state.time?.end), failed, text(state.error) || text(state.output))
     }
   }
+  const thoughts = []
+  const replies = []
+  const said = db.prepare(`SELECT message_id, data FROM part WHERE session_id = ? AND (data LIKE '%"type":"text"%' OR data LIKE '%"type":"reasoning"%') ORDER BY rowid`)
+  for (const part of said.all(row.id)) {
+    if (!messageAt.has(part.message_id)) continue
+    const data = parse(part.data)
+    if (data.synthetic || data.ignored) continue
+    const at = number(data.time?.end) || number(data.time?.start) || messageAt.get(part.message_id)
+    if (data.type === 'reasoning') keepText(thoughts, 'thoughts', { id: part.message_id, at, text: text(data.text) })
+    else if (data.type === 'text') keepText(replies, 'replies', { id: part.message_id, at, text: text(data.text) })
+  }
   const turnOf = (r) => cached(context, `v1:${r.id}`, number(r.time_updated), () => legacyTurn(db, r, context))
   if (!turnOf(row).open) settleCalls(activity)
 
@@ -284,6 +306,9 @@ function legacyDetail(db, tables, row, context) {
     subagents: childList(sessionRows(db, 'session', 'parent_id', row.id), turnOf),
     files: files.size || !context.liveSummary ? fileList(files, directory) : null,
     prompts,
+    thoughts: textList(thoughts),
+    replies: textList(replies),
+    contextBreakdown: null,
     errors,
   }
 }
@@ -296,13 +321,15 @@ function currentDetail(db, tables, row, context) {
   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 replied = []
+  for (const message of db.prepare('SELECT id, 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') {
+      replied.push({ id: message.id, at, content: list(data.content) })
       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)
@@ -314,21 +341,34 @@ function currentDetail(db, tables, row, context) {
   }
 
   const parts = tables.has('session_part') && ['session_id', 'message_id', 'type', 'data'].every((c) => columnsOf(db, 'session_part').has(c))
-  let plan = []
+  const rows = new Map()
   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)) {
+    for (const part of db.prepare(`SELECT id, message_id, type, data FROM session_part WHERE session_id = ? AND type IN ('tool', 'reasoning', 'text') ORDER BY rowid`).all(row.id)) {
       const data = parse(part.data)
+      if (!rows.has(part.message_id)) rows.set(part.message_id, [])
+      rows.get(part.message_id).push({ ...data, type: text(data.type) || part.type, rowId: part.id })
+    }
+  }
+  let plan = []
+  const thoughts = []
+  const replies = []
+  for (const message of replied) {
+    const content = rows.get(message.id) || message.content
+    content.forEach((data, i) => {
+      if (data?.type !== 'tool') return
       const state = data.state || {}
-      const callId = text(data.callID) || text(data.id) || part.id
+      const callId = text(data.callID) || text(data.id) || data.rowId || `${message.id}:${i}`
       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 (!startCall(activity, { ...call, startedAt: number(data.time?.ran) || number(data.time?.created) || message.at })) return
       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) }))
       }
-    }
+    })
+    keepText(thoughts, 'thoughts', { at: message.at, text: joinedText(content, 'reasoning', 'text') })
+    keepText(replies, 'replies', { at: message.at, text: joinedText(content, 'text') })
   }
   const turnOf = (r) => cached(context, `v2:${r.id}`, number(r.time_updated), () => currentTurn(db, r, parts, context))
   if (!turnOf(row).open) settleCalls(activity)
@@ -343,6 +383,9 @@ function currentDetail(db, tables, row, context) {
     subagents: childList(sessionRows(db, 'session_v2', 'parent_id', row.id), turnOf),
     files: null,
     prompts,
+    thoughts: textList(thoughts),
+    replies: textList(replies),
+    contextBreakdown: null,
     errors,
   }
 }
@@ -373,14 +416,23 @@ function cached(context, key, updated, compute) {
 
 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'
+    if (tool?.name === QUESTION_TOOL) return ['asking', 'question']
+    if (errands && (!tool || SUBAGENT_TOOLS.has(tool.name))) return ['delegating', 'subagents']
+    return ['working', 'turn-open']
+  }
+  if (errands) return ['delegating', 'subagents']
+  if (failed) return ['error', 'turn-failed']
+  if (read) return read.unread ? ['done', 'unread'] : ['idle', 'read']
+  return at - lastActivityAt < ACTIVE_WINDOW_MS ? ['done', 'recent'] : ['idle', 'quiet']
+}
+
+const childName = (row, turn) => text(row.title).trim() || (turn.firstPrompt ? titleFromPrompt(turn.firstPrompt) : '') || 'Subagent'
+
+function workingChildren(rows, parent, turnOf, context) {
+  return rows
+    .filter((r) => r.parent_id === parent.id && context.at - number(r.time_updated) < SUBAGENT_WINDOW_MS && turnOf(r).open)
+    .sort((a, b) => number(a.time_created) - number(b.time_created))
+    .map((r) => ({ id: r.id, name: childName(r, turnOf(r)) }))
 }
 
 function session(context, row, turn, extra) {
@@ -389,7 +441,8 @@ function session(context, row, turn, extra) {
   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 })
+  const errands = extra.working.length
+  const [status, statusReason] = statusOf({ ...turn, errands, lastActivityAt, read, at: context.at })
   return {
     id: `${context.id}:${row.id}`,
     harness: context.id,
@@ -405,14 +458,20 @@ function session(context, row, turn, extra) {
     live: turn.open,
     startedAt: number(row.time_created),
     lastActivityAt,
-    tool: turn.open && turn.tool ? { ...turn.tool } : null,
+    tool: turn.open && turn.tool ? toolNow(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,
+    contextHistory: sampleList(turn.contextSample, turn.context),
     costUsd: turn.cost,
     lines: extra.lines,
     plan: planSummary(extra.plan),
-    subagents: extra.errands,
+    subagents: errands,
+    workingSubagents: extra.working,
     prompts: turn.prompts,
+    turnStartedAt: turn.open ? turn.turnStartedAt || null : null,
+    statusReason,
+    ask: askOf(status, { calls: turn.open && turn.tool ? [turn.tool] : [], errorText: turn.errorText }),
+    usageLimits: null,
   }
 }
 
@@ -431,7 +490,7 @@ function legacySessions(db, tables, context) {
   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 working = workingChildren(rows, row, turnOf, context)
     const lines = context.liveSummary
       ? row.summary_additions == null && row.summary_deletions == null
         ? null
@@ -443,13 +502,13 @@ function legacySessions(db, tables, context) {
           .all(row.id)
           .map((t) => ({ content: text(t.content), status: text(t.status) }))
       : null
-    out.push(session(context, row, turn, { errands, lines, plan }))
+    out.push(session(context, row, turn, { working, 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 turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, contextSample: emptySample(), lines: null, tool: null, turnStartedAt: 0 }
   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%'`)
@@ -458,10 +517,11 @@ function legacyTurn(db, row, context) {
   )
   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)) {
+  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)
     last = data
     if (data.role === 'user') {
+      turn.turnStartedAt = number(data.time?.created) || number(message.time_created)
       if (typed.has(message.id)) {
         turn.prompts++
         if (!turn.firstPrompt) turn.firstPrompt = firstText(db, message.id)
@@ -481,7 +541,10 @@ function legacyTurn(db, row, context) {
     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)
+    if (number(data.tokens?.output) > 0) {
+      turn.context = windowOf(data.tokens)
+      samplePoint(turn.contextSample, turn.context)
+    }
   }
   const usage = usageFromColumns(row)
   if (usage) {
@@ -496,8 +559,10 @@ function legacyTurn(db, row, context) {
   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)
+  const failedTool = last?.role === 'assistant' && !error && ended ? toolFailure(db, lastAssistant) : ''
+  turn.failed = last?.role === 'assistant' && (error ? !ABORTED.test(error) : Boolean(failedTool))
+  turn.errorText = turn.failed ? text(last?.error?.data?.message) || error || failedTool : ''
+  if (turn.busy) turn.tool = runningTool(db, lastAssistant, text(row.directory))
   return turn
 }
 
@@ -509,21 +574,21 @@ function firstText(db, messageId) {
   return ''
 }
 
-function toolFailed(db, messageId) {
+function toolFailure(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
+    if (!STOPPED.test(`${text(state.error)}\n${text(state.output)}`)) return text(state.error) || text(state.output) || 'A tool failed'
   }
-  return false
+  return ''
 }
 
-function runningTool(db, messageId) {
+function runningTool(db, messageId, cwd) {
   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) }
+    tool = openTool(text(data.tool), number(data.state?.time?.start), data.state?.input, cwd)
   }
   return tool
 }
@@ -542,15 +607,36 @@ function currentSessions(db, tables, context) {
   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 }))
+    out.push(session(context, row, turn, { working: workingChildren(rows, row, turnOf, context), lines: null, plan: turn.plan }))
   }
   return out
 }
 
+function currentSample(db, sessionId, before) {
+  let { contextSample: sample, contextSeq: seq = -1, contextCount: count = 0 } = before || {}
+  const kept = sample && db.prepare(`SELECT COUNT(*) AS n, MAX(seq) AS top FROM session_message WHERE session_id = ? AND type = 'assistant' AND seq <= ?`).get(sessionId, seq)
+  if (!kept || number(kept.n) !== count || (count && number(kept.top) !== seq)) {
+    sample = emptySample()
+    seq = -1
+    count = 0
+  }
+  const newer = db.prepare(`SELECT seq, data FROM session_message WHERE session_id = ? AND type = 'assistant' AND seq > ? ORDER BY seq`).all(sessionId, seq)
+  for (const [i, message] of newer.entries()) {
+    const data = parse(message.data)
+    if (i === newer.length - 1 && !data.time?.completed) break
+    if (number(data.tokens?.output) > 0) samplePoint(sample, windowOf(data.tokens))
+    seq = number(message.seq)
+    count++
+  }
+  return { contextSample: sample, contextSeq: seq, contextCount: count }
+}
+
 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 }
+  const before = context.facts.get(`v2:${row.id}`)?.value
+  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, tool: null, plan: null, turnStartedAt: 0, ...currentSample(db, row.id, before) }
   turn.prompts = number(db.prepare(`SELECT COUNT(*) AS n FROM session_message WHERE session_id = ? AND type = 'user'`).get(row.id)?.n)
+  const lastUser = db.prepare(`SELECT time_created FROM session_message WHERE session_id = ? AND type = 'user' ORDER BY seq DESC LIMIT 1`).get(row.id)
+  turn.turnStartedAt = number(row.time_busy) || number(lastUser?.time_created)
   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)
@@ -573,13 +659,14 @@ function currentTurn(db, row, parts, context) {
   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)
+  turn.errorText = turn.failed && last?.type === 'idle' ? text(parse(last.data).error?.message) : ''
+  const tools = currentTools(db, row.id, assistant, parts, text(row.directory))
   if (busy) turn.tool = tools.running
   turn.plan = tools.todos
   return turn
 }
 
-function currentTools(db, sessionId, assistant, parts) {
+function currentTools(db, sessionId, assistant, parts, cwd) {
   const result = { running: null, todos: null }
   let latest = []
   let recent = []
@@ -593,8 +680,14 @@ function currentTools(db, sessionId, assistant, parts) {
       .map((p) => parse(p.data))
   }
   if (!latest.length && assistant) latest = list(parse(assistant.data).content).filter((c) => c?.type === 'tool')
+  if (!recent.length) {
+    recent = db
+      .prepare(`SELECT data FROM session_message WHERE session_id = ? AND type = 'assistant' AND data LIKE ? ORDER BY seq DESC LIMIT 20`)
+      .all(sessionId, `%"${TODO_TOOL}"%`)
+      .flatMap((m) => list(parse(m.data).content).filter((c) => c?.type === 'tool').reverse())
+  }
   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) }
+    if (OPEN_TOOL.has(part.state?.status)) result.running = openTool(text(part.name), number(part.time?.ran) || number(part.time?.created), part.state?.input, cwd)
   }
   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) }))

package/lib/telemetry-fields.mjs

@@ -1,3 +1,5 @@
+import { nameKind, toolKind } from './tool-kinds.mjs'
+
 export const RECENT_MS = 24 * 60 * 60 * 1000
 
 export const DETAIL_LIMITS = Object.freeze({
@@ -5,6 +7,10 @@ export const DETAIL_LIMITS = Object.freeze({
   activity: 100,
   prompts: 50,
   promptText: 2000,
+  thoughts: 20,
+  thoughtText: 2000,
+  replies: 50,
+  replyText: 2000,
   errors: 20,
   errorText: 500,
   input: 2000,
@@ -73,6 +79,8 @@ export function toolTarget(input, cwd = '', max = TARGET_MAX) {
   return ''
 }
 
+export const inputKind = (name, input) => toolKind(name, typeof input === 'string' && input.endsWith('…') ? '' : input)
+
 export function toolInput(input) {
   if (typeof input === 'string') return clipBlock(input, DETAIL_LIMITS.input) || null
   if (!input || typeof input !== 'object') return null
@@ -92,12 +100,76 @@ export function toolFile(input, cwd = '') {
   return { path: null, line: null }
 }
 
+const ASK_QUESTIONS = 4
+const ASK_OPTIONS = 8
+const askText = (value) => clipBlock(text(value), DETAIL_LIMITS.errorText)
+
+export function askQuestions(input) {
+  if (!Array.isArray(input?.questions) || !input.questions.length) return null
+  return input.questions.slice(0, ASK_QUESTIONS).map((q) => ({
+    header: clip(q?.header),
+    text: askText(q?.question ?? q?.text),
+    options: (Array.isArray(q?.options) ? q.options : []).slice(0, ASK_OPTIONS).map((o) => ({
+      label: clip(typeof o === 'string' ? o : o?.label),
+      description: askText(o?.description),
+    })),
+    multiple: q?.multiSelect === true || q?.multiple === true,
+  }))
+}
+
+export function openTool(name, startedAt, input = null, cwd = '') {
+  const command = typeof input === 'string' ? input : commandText(input?.command ?? input?.cmd)
+  const tool = { name, startedAt, target: toolTarget(input, cwd), kind: toolKind(name, command || toolInput(input)).kind }
+  const questions = tool.kind === 'communicate' ? askQuestions(input) : null
+  if (questions) tool.questions = questions
+  return tool
+}
+
+export function askOf(status, { calls = [], errorText = '' } = {}) {
+  if (status === 'error') return { type: 'error', text: askText(errorText) }
+  if (status !== 'asking') return null
+  const asked = calls.findLast((c) => c?.questions)
+  if (asked) return { type: 'question', questions: asked.questions.map((q) => ({ ...q, options: q.options.map((o) => ({ ...o })) })) }
+  const call = calls.findLast((c) => (c.kind ?? nameKind(c.name)) !== 'agent')
+  if (call) return { type: 'approval', tool: call.name, target: call.target ?? '', kind: call.kind ?? nameKind(call.name) }
+  return { type: 'unknown' }
+}
+
+export const toolNow = (tool) => (tool ? { name: tool.name, startedAt: tool.startedAt, target: tool.target ?? '', kind: tool.kind ?? nameKind(tool.name) } : null)
+
 export function keepNewest(list, item, max) {
   list.push(item)
   if (list.length > max) list.splice(0, list.length - max)
   return item
 }
 
+const TEXT_LISTS = {
+  thoughts: [DETAIL_LIMITS.thoughts, DETAIL_LIMITS.thoughtText],
+  replies: [DETAIL_LIMITS.replies, DETAIL_LIMITS.replyText],
+}
+
+export function keepText(list, kind, { id = null, at, text: value }) {
+  const [max, maxText] = TEXT_LISTS[kind]
+  const body = clipBlock(value, maxText)
+  if (!body) return null
+  const last = list.at(-1)
+  if (id != null && last?.id === id) {
+    if (last.text.length < maxText) last.text = clipBlock(`${last.text}\n\n${body}`, maxText)
+    return last
+  }
+  return keepNewest(list, { id, at, text: body }, max)
+}
+
+export const textList = (list) => (list ? list.map(({ at, text: value }) => ({ at, text: value })) : null)
+
+export function joinedText(blocks, type, field = type) {
+  if (!Array.isArray(blocks)) return ''
+  return blocks
+    .filter((block) => block?.type === type && typeof block[field] === 'string' && block[field].trim())
+    .map((block) => block[field].trim())
+    .join('\n\n')
+}
+
 export function patchLines(lines) {
   let added = 0
   let removed = 0
@@ -151,12 +223,13 @@ export const emptyActivity = () => ({ calls: [], tools: new Map() })
 
 export function startCall(activity, { id = '', name, target = '', input = null, path = null, line = null, startedAt, running = true }) {
   if (id && activity.calls.some((c) => c.id === id)) return null
+  const { kind, server } = inputKind(name, input)
   const call = keepNewest(
     activity.calls,
-    { id, name, target, input, path, line, startedAt, endedAt: null, running, error: null, errorText: null },
+    { id, name, kind, server, target, input, path, line, startedAt, endedAt: null, running, error: null, errorText: null },
     DETAIL_LIMITS.activity,
   )
-  const tool = activity.tools.get(name) || { name, calls: 0, errors: 0, ms: 0 }
+  const tool = activity.tools.get(name) || { name, kind: nameKind(name), server, calls: 0, errors: 0, ms: 0 }
   tool.calls++
   activity.tools.set(name, tool)
   return call
@@ -243,3 +316,37 @@ export function nextPlan(plan, tool, input) {
   }
   return next
 }
+
+export const CONTEXT_POINTS = 24
+
+export const emptySample = () => ({ stride: 1, seen: 0, points: [], newest: null, newestKept: false })
+
+export function samplePoint(sample, value, { update = false } = {}) {
+  const point = Math.round(number(value))
+  if (point <= 0) return
+  if (update && sample.newest != null) {
+    if (sample.newestKept) sample.points[sample.points.length - 1] = point
+    sample.newest = point
+    return
+  }
+  sample.newestKept = sample.seen % sample.stride === 0
+  if (sample.newestKept) {
+    sample.points.push(point)
+    if (sample.points.length >= CONTEXT_POINTS * 2) {
+      sample.points = sample.points.filter((_, i) => i % 2 === 0)
+      sample.stride *= 2
+      sample.newestKept = false
+    }
+  }
+  sample.seen++
+  sample.newest = point
+}
+
+export function sampleList(sample, current) {
+  if (!sample || !(current > 0)) return null
+  const now = Math.round(current)
+  const older = sample.newestKept && sample.newest === now ? sample.points.slice(0, -1) : sample.points
+  const room = CONTEXT_POINTS - 1
+  const picked = older.length <= room ? older : Array.from({ length: room }, (_, i) => older[Math.round((i * (older.length - 1)) / (room - 1))])
+  return [...picked, now]
+}