@threadcrumbs/common 0.0.0-stage → 0.1.1

package/lib/claude-desktop.mjs

@@ -0,0 +1,208 @@
+import fsp from 'node:fs/promises'
+import { existsSync, readdirSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { listDirs, listFiles } from './fsutil.mjs'
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const isCliId = (v) => typeof v === 'string' && UUID.test(v)
+
+/**
+ * Where Electron puts `userData` on each OS. The Claude desktop app's own folder is one level
+ * below, named after the app — see `claudeDesktopStores` for why that name is not a constant.
+ *
+ * On Windows there are two answers, because the app ships two ways. The classic installer writes
+ * to `%APPDATA%`, which is what Electron's `userData` means everywhere else. Installed from the
+ * Microsoft Store the app is an MSIX package, and MSIX *redirects* what a packaged app believes is
+ * `%APPDATA%` into its own private `…\Packages\<family>\LocalCache\Roaming`. The app is installed,
+ * running and writing session records — and `%APPDATA%\Claude` does not exist at all.
+ *
+ * The package folder is matched by prefix rather than named: its suffix is a hash of the
+ * publisher. A hard-coded suffix would work until the publisher's hash changed, and then it would
+ * look exactly like the app having been uninstalled.
+ */
+function userDataRoots() {
+  const home = os.homedir()
+  switch (process.platform) {
+    case 'win32': {
+      const roots = [process.env.APPDATA || path.join(home, 'AppData', 'Roaming')]
+      const packages = path.join(process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), 'Packages')
+      for (const name of dirNames(packages)) {
+        if (name.startsWith('Claude_')) roots.push(path.join(packages, name, 'LocalCache', 'Roaming'))
+      }
+      return roots
+    }
+    case 'linux':
+      return [process.env.XDG_CONFIG_HOME || path.join(home, '.config')]
+    default:
+      return [path.join(home, 'Library', 'Application Support')]
+  }
+}
+
+function dirNames(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Every session store the desktop app has written, as a list.
+ *
+ * The app's folder is not always called `Claude`. macOS ships it as `Claude-3p` too, and a second
+ * desktop profile gets a folder of its own, `Claude-<profile>`, beside the first. Two can be live
+ * at once, and an older install leaves a `Claude` behind that still holds a handful of records and
+ * its deletion markers. Picking the first folder that had records meant reading that leftover and
+ * missing the one in use: on one Windows machine that was 4 records of 103, so nearly every thread
+ * lost its title and `Open` fell back to `claude://resume`, which imports a copy of the thread
+ * rather than navigating to it.
+ *
+ * So every `Claude*` folder holding a `claude-code-sessions` store is read, and the readers merge
+ * them the way they already merge two records for one transcript.
+ *
+ * Callers resolve this once, when they are created. Installing the app while a reader is running
+ * therefore needs a restart to be noticed, a deliberate trade against listing these folders on
+ * every scan to catch something that happens once. When nothing is found, the classic path stands
+ * in so every caller still works against a real path, which `detect()` reads as "no app".
+ */
+export function claudeDesktopStores() {
+  if (process.env.THREADCRUMBS_CLAUDE_DESKTOP_DIR) return [process.env.THREADCRUMBS_CLAUDE_DESKTOP_DIR]
+  const roots = userDataRoots()
+  const appFolders = roots.flatMap((root) =>
+    dirNames(root)
+      .filter((name) => /^Claude(?:$|[-_ ])/.test(name))
+      .map((name) => path.join(root, name))
+  )
+  if (process.platform === 'win32') {
+    const relocated = path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'Claude-Data')
+    appFolders.push(...dirNames(relocated).map((name) => path.join(relocated, name)))
+  }
+  const found = appFolders.map((folder) => path.join(folder, 'claude-code-sessions')).filter((store) => existsSync(store))
+  return found.length ? found : [path.join(roots[0], 'Claude', 'claude-code-sessions')]
+}
+
+/**
+ * `/repo/.claude/worktrees/feature-abc` -> project `/repo`, worktree `feature-abc`.
+ * Either separator: on Windows the same cwd arrives as `C:\repo\.claude\worktrees\…`.
+ */
+const WORKTREE = /[\\/]\.claude[\\/]worktrees[\\/]([^\\/]+)/
+function splitWorktree(cwd) {
+  const m = WORKTREE.exec(cwd)
+  if (!m) return { root: cwd, worktree: '' }
+  return { root: cwd.slice(0, m.index), worktree: m[1] }
+}
+
+/**
+ * The desktop app's throwaway sessions each get a fresh folder of their own,
+ * `<userData>/scratch-workspaces/<account>/<org>/scratch-2026-09-22-a1b2c3`. Read as projects,
+ * every one of them claimed a hex zone for a single bot — twenty-one zones on one machine — so
+ * they share one plot, the way a repo's worktrees share its plot, and the folder rides along as
+ * the worktree tag.
+ */
+const SCRATCH = /^(.*[\\/]scratch-workspaces)[\\/](?:[^\\/]+[\\/]){2}(scratch-[^\\/]+)[\\/]?$/
+
+/** The folder that plot stands on: the app's own, so nothing is started in it. */
+export const SCRATCH_ROOT = /[\\/]scratch-workspaces[\\/]?$/
+
+export function projectOf(cwd, originCwd) {
+  const scratch = SCRATCH.exec(originCwd || cwd || '')
+  if (scratch) return { projectPath: scratch[1], project: 'Scratch', worktree: scratch[2] }
+  const { root, worktree } = splitWorktree(cwd || '')
+  const projectPath = originCwd || root || cwd || ''
+  return { projectPath, project: path.basename(projectPath) || projectPath || 'unknown', worktree }
+}
+
+/**
+ * What deleting a thread in the desktop app leaves behind, in the folder its record was in:
+ * `deleted_<cliSessionId>`, holding the deletion time in epoch ms. The record goes; the CLI
+ * transcript does not. Without the marker that transcript is indistinguishable from a thread
+ * started in a terminal, so a thread you had deleted came back as one.
+ */
+const DELETED_MARKER = /^deleted_(.+)$/
+const isRecord = (name) => name.startsWith('local_') && name.endsWith('.json')
+
+/**
+ * The fields of a desktop record the readers actually use. A record is not small: the app
+ * writes its whole MCP connector configuration into each one (`remoteMcpServersConfig`, close
+ * to a megabyte on a machine with a dozen connectors), and on one machine the store came to
+ * 148 MB over 204 records — read and parsed in full on every 15-second poll, for perhaps
+ * 60 KB of fields anyone looks at. Half of every scan, and most of the process's memory.
+ * Keeping only these means the cache below holds kilobytes, not the store.
+ */
+function pickRecord(r) {
+  return {
+    sessionId: r.sessionId,
+    cliSessionId: r.cliSessionId,
+    cwd: r.cwd,
+    originCwd: r.originCwd,
+    title: r.title,
+    bridgeSessionIds: r.bridgeSessionIds,
+    model: r.model,
+    effort: r.effort,
+    createdAt: r.createdAt,
+    lastActivityAt: r.lastActivityAt,
+    lastFocusedAt: r.lastFocusedAt,
+    error: r.error,
+    turnOutcome:
+      r.postTurnSummary && r.postTurnSummaryFor && r.postTurnSummaryFor === r.lastAssistantUuid
+        ? String(r.postTurnSummary.status_category || '')
+        : '',
+    isStarred: r.isStarred,
+    scheduledTaskId: r.scheduledTaskId,
+    prState: r.prState,
+    isArchived: r.isArchived,
+  }
+}
+
+/**
+ * Every thread the desktop app has a record for, and the ids of the ones it has deleted.
+ *
+ * Parsed records are kept by file and pinned to the mtime they were read at, so a steady-state
+ * scan is one stat per record and no reads.
+ */
+export function desktopRecordReader() {
+  const recordCache = new Map()
+  return async function readDesktopRecords(stores) {
+    const records = []
+    const deleted = new Set()
+    const seen = new Set()
+    const accounts = (await Promise.all(stores.map((store) => listDirs(store)))).flat()
+    for (const account of accounts) {
+      for (const org of await listDirs(account)) {
+        for (const file of await listFiles(org, (n) => isRecord(n) || DELETED_MARKER.test(n))) {
+          const marker = DELETED_MARKER.exec(path.basename(file))
+          if (marker) {
+            if (isCliId(marker[1])) deleted.add(marker[1])
+            continue
+          }
+          seen.add(file)
+          let stat
+          try {
+            stat = await fsp.stat(file)
+          } catch {
+            continue
+          }
+          const cached = recordCache.get(file)
+          if (cached && cached.mtime === stat.mtimeMs) {
+            records.push(cached.record)
+            continue
+          }
+          try {
+            const record = pickRecord(JSON.parse(await fsp.readFile(file, 'utf8')))
+            recordCache.set(file, { mtime: stat.mtimeMs, record })
+            records.push(record)
+          } catch {
+            // The app is partway through writing the record. The previous read is the latest
+            // complete copy; without it the thread would drop out for one scan each time the app saves.
+            if (cached) records.push(cached.record)
+          }
+        }
+      }
+    }
+    for (const file of recordCache.keys()) if (!seen.has(file)) recordCache.delete(file)
+    return { records, deleted }
+  }
+}

package/lib/claude-transcript.mjs

@@ -0,0 +1,462 @@
+import fsp from 'node:fs/promises'
+import { requestCost } from './anthropic-prices.mjs'
+import { listFiles, parseJsonLine, readNewLines } from './fsutil.mjs'
+import {
+  DETAIL_LIMITS,
+  activityDetail,
+  addFileChange,
+  clip,
+  clipBlock,
+  diffHunk,
+  emptyActivity,
+  endCall,
+  fileList,
+  firstChange,
+  keepNewest,
+  nextPlan,
+  patchLines,
+  planItems,
+  settleCalls,
+  startCall,
+  toolFile,
+  toolInput,
+  toolTarget,
+} from './telemetry-fields.mjs'
+
+const HEAD_BYTES = 192 * 1024
+const TAIL_BYTES = 64 * 1024
+const TAIL_LIMIT = 4 * 1024 * 1024
+const NOISE = /<([a-z][\w-]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g
+
+const AGENT_TOOLS = new Set(['Agent', 'Task'])
+const IDLE_NOTICE = /^\[Cross-session idle notice\] "([^"]+)"/
+const AWAIT_LIMIT = 20
+const PEER_BUSY = new Set(['busy', 'waiting'])
+
+const MID_TURN = Object.freeze({ handedBack: false, failed: false })
+
+const number = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0)
+const text = (v) => (typeof v === 'string' ? v : '')
+
+export const stripNoise = (value) => String(value).replace(NOISE, ' ')
+
+const pidAlive = (pid) => {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (err) {
+    return err.code === 'EPERM'
+  }
+}
+
+export async function readLiveSessions(dir, isAlive = pidAlive) {
+  const live = new Map()
+  for (const file of await listFiles(dir, (n) => n.endsWith('.json'))) {
+    let record
+    try {
+      record = JSON.parse(await fsp.readFile(file, 'utf8'))
+    } catch {
+      continue
+    }
+    if (!record?.sessionId || !record.pid || !isAlive(record.pid)) continue
+    live.set(record.sessionId, { pid: record.pid, status: text(record.status), name: text(record.name), socket: text(record.messagingSocketPath) })
+  }
+  return live
+}
+
+export function transcriptReader({ skim = false, detail = false } = {}) {
+  const files = new Map()
+
+  async function advance(entry, file, size) {
+    if (!entry.state || size < entry.state.offset) entry.state = emptyState(entry.sidechain, detail)
+    const state = entry.state
+    if (size === state.offset) return state
+    try {
+      if (skim && state.offset === 0 && size > HEAD_BYTES + TAIL_BYTES) {
+        await skimInto(state, file, size)
+      } else {
+        const { lines, carry } = await readNewLines(file, state.offset, size, state.carry)
+        state.offset = size
+        state.carry = carry
+        for (const line of lines) applyLine(state, line)
+      }
+    } catch (err) {
+      entry.state = null
+      throw err
+    }
+    return state
+  }
+
+  function read(file, stat, { sidechain = false } = {}) {
+    let entry = files.get(file)
+    if (!entry || entry.sidechain !== sidechain) {
+      entry = { sidechain, state: null, queue: Promise.resolve(), seen: true }
+      files.set(file, entry)
+    }
+    entry.seen = true
+    const next = entry.queue.then(() => advance(entry, file, stat.size))
+    entry.queue = next.catch(() => {})
+    return next
+  }
+
+  function sweep() {
+    for (const [file, entry] of files) {
+      if (entry.seen) entry.seen = false
+      else files.delete(file)
+    }
+  }
+
+  return { read, sweep }
+}
+
+async function skimInto(state, file, size) {
+  const head = await readNewLines(file, 0, HEAD_BYTES)
+  const headEnd = HEAD_BYTES - head.carry.length
+  for (const line of head.lines) applyLine(state, line)
+  for (let bytes = TAIL_BYTES; ; bytes *= 4) {
+    const from = Math.max(headEnd, size - bytes)
+    const tail = await readNewLines(file, from, size)
+    const gap = from > headEnd
+    const records = (gap ? tail.lines.slice(1) : tail.lines).map(parseJsonLine).filter(Boolean)
+    if (gap && bytes < TAIL_LIMIT && !records.some((r) => isTurn(state, r))) continue
+    if (gap) {
+      state.open.clear()
+      state.ending = null
+      state.partial = true
+    }
+    const headAt = state.lastAt
+    for (const record of records) applyRecord(state, record)
+    if (gap && state.lastAt === headAt) state.lastAt = 0
+    state.offset = size
+    state.carry = tail.carry
+    return
+  }
+}
+
+function emptyState(sidechain, detail) {
+  return {
+    detail: detail ? emptyDetail() : null,
+    offset: 0,
+    carry: Buffer.alloc(0),
+    sidechain,
+    partial: false,
+    startedAt: 0,
+    lastAt: 0,
+    customTitle: '',
+    aiTitle: '',
+    summary: '',
+    firstPrompt: '',
+    cwd: '',
+    firstCwd: '',
+    gitBranch: '',
+    firstBranch: '',
+    model: '',
+    effort: '',
+    usageById: new Map(),
+    costById: new Map(),
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    spend: 0,
+    unpriced: false,
+    lines: { added: 0, removed: 0 },
+    context: 0,
+    open: new Map(),
+    ending: null,
+    handedBackAt: 0,
+    awaiting: new Map(),
+    cost: null,
+    plan: null,
+    prompts: 0,
+  }
+}
+
+function emptyDetail() {
+  return {
+    history: [],
+    compactions: [],
+    activity: emptyActivity(),
+    files: new Map(),
+    prompts: [],
+    errors: [],
+    models: new Map(),
+    contextParts: null,
+  }
+}
+
+const ownRecord = (state, record) => state.sidechain || !record.isSidechain
+
+const isTurn = (state, record) => (record.type === 'user' || record.type === 'assistant') && ownRecord(state, record)
+
+function applyLine(state, line) {
+  const record = parseJsonLine(line)
+  if (record) applyRecord(state, record)
+}
+
+function applyRecord(state, record) {
+  const at = Date.parse(record.timestamp)
+  if (at) {
+    if (!state.startedAt) state.startedAt = at
+    if (at > state.lastAt) state.lastAt = at
+  }
+  if (record.customTitle) state.customTitle = text(record.customTitle)
+  if (record.aiTitle) state.aiTitle = text(record.aiTitle)
+  if (record.type === 'summary' && record.summary && !state.summary) state.summary = text(record.summary)
+  if (record.type === 'cost-state') {
+    state.cost = {
+      usd: number(record.totalCostUSD),
+      linesAdded: number(record.totalLinesAdded),
+      linesRemoved: number(record.totalLinesRemoved),
+    }
+    return
+  }
+  if (record.cwd) {
+    state.cwd = text(record.cwd)
+    state.firstCwd ||= state.cwd
+  }
+  if (record.gitBranch && record.gitBranch !== 'HEAD') {
+    state.gitBranch = text(record.gitBranch)
+    state.firstBranch ||= state.gitBranch
+  }
+  if (state.detail && record.type === 'system' && ownRecord(state, record)) applySystem(state.detail, record, at || state.lastAt)
+  if (!isTurn(state, record)) return
+  if (record.type === 'user') applyUser(state, record, at || state.lastAt)
+  else applyAssistant(state, record, at || state.lastAt)
+}
+
+function applySystem(detail, record, at) {
+  if (record.subtype === 'compact_boundary') {
+    const meta = record.compactMetadata || {}
+    keepNewest(detail.compactions, { at, before: number(meta.preTokens), after: number(meta.postTokens) }, DETAIL_LIMITS.compactions)
+  } else if (record.subtype === 'api_error') {
+    const message = text(record.error?.message) || text(record.content) || 'API error'
+    const retry = record.retryAttempt ? ` (retry ${number(record.retryAttempt)} of ${number(record.maxRetries)})` : ''
+    keepNewest(detail.errors, { at, message: clip(`${message}${retry}`, DETAIL_LIMITS.errorText) }, DETAIL_LIMITS.errors)
+  }
+}
+
+function applyUser(state, record, at) {
+  const content = record.message?.content
+  let answered = false
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block?.type !== 'tool_result') continue
+      state.open.delete(block.tool_use_id)
+      answered = true
+      const result = record.toolUseResult
+      const failed = block.is_error === true || (typeof result === 'string' && /^error/i.test(result.trim()))
+      if (failed || result?.success === false) unsubscribe(state, block.tool_use_id)
+      const call = state.detail ? endCall(state.detail.activity, block.tool_use_id, at, failed, failed ? errorTextOf(block, result) : null) : null
+      if (!failed) countEdits(state, result, call)
+    }
+  }
+  state.ending = MID_TURN
+  const notice = record.isMeta ? IDLE_NOTICE.exec(firstText(content)) : null
+  if (notice) state.awaiting.delete(notice[1])
+  if (answered || record.isMeta || record.isCompactSummary || record.toolUseResult !== undefined) return
+  const prompt = stripNoise(firstText(content)).trim()
+  if (!prompt || prompt.startsWith('<')) return
+  state.open.clear()
+  state.prompts++
+  if (!state.firstPrompt) state.firstPrompt = prompt
+  if (state.detail) {
+    settleCalls(state.detail.activity)
+    keepNewest(state.detail.prompts, { at, text: clipBlock(prompt, DETAIL_LIMITS.promptText) }, DETAIL_LIMITS.prompts)
+  }
+}
+
+function hunkLines(hunks) {
+  let added = 0
+  let removed = 0
+  for (const hunk of Array.isArray(hunks) ? hunks : []) {
+    const counted = patchLines(hunk?.lines)
+    added += counted.added
+    removed += counted.removed
+  }
+  return { added, removed }
+}
+
+function editsOf(result) {
+  if (!result || typeof result !== 'object') return []
+  const edits = []
+  const file = text(result.filePath)
+  if (file && result.type === 'create' && typeof result.content === 'string') {
+    const added = result.content ? result.content.split('\n').length - (result.content.endsWith('\n') ? 1 : 0) : 0
+    edits.push({ file, added, removed: 0, created: result.content })
+  } else if (file && Array.isArray(result.structuredPatch)) {
+    edits.push({ file, ...hunkLines(result.structuredPatch), patch: result.structuredPatch })
+  }
+  for (const changed of Array.isArray(result.bashEditDiff?.files) ? result.bashEditDiff.files : []) {
+    if (text(changed?.filePath)) edits.push({ file: text(changed.filePath), ...hunkLines(changed.hunks), patch: changed.hunks })
+  }
+  return edits
+}
+
+function hunksOf(edit) {
+  if (typeof edit.created === 'string') {
+    const lines = edit.created.split('\n')
+    if (edit.created.endsWith('\n')) lines.pop()
+    const kept = lines.slice(0, DETAIL_LIMITS.hunkLines).map((l) => `+${l}`)
+    return kept.length ? [diffHunk({ line: 1, lines: kept, more: lines.length - kept.length })] : []
+  }
+  return (Array.isArray(edit.patch) ? edit.patch : []).map((h) => diffHunk({ line: h?.newStart, oldLine: h?.oldStart, lines: h?.lines }))
+}
+
+function countEdits(state, result, call = null) {
+  for (const edit of editsOf(result)) {
+    state.lines.added += edit.added
+    state.lines.removed += edit.removed
+    if (!state.detail) continue
+    const hunks = hunksOf(edit)
+    addFileChange(state.detail.files, edit.file, edit.added, edit.removed, hunks)
+    if (call && call.line == null && hunks.length) call.line = firstChange(hunks[0])
+  }
+}
+
+function errorTextOf(block, result) {
+  return firstText(block.content) || (typeof result === 'string' ? result : '')
+}
+
+function subscribe(state, block, at) {
+  const to = text(block.input?.to)
+  if (!to || block.input.notify_when_idle !== true) return
+  state.awaiting.delete(to)
+  state.awaiting.set(to, { since: at, call: text(block.id) })
+  if (state.awaiting.size > AWAIT_LIMIT) state.awaiting.delete(state.awaiting.keys().next().value)
+}
+
+function unsubscribe(state, callId) {
+  for (const [to, subscription] of state.awaiting) {
+    if (subscription.call === callId) state.awaiting.delete(to)
+  }
+}
+
+function applyAssistant(state, record, at) {
+  const message = record.message
+  if (!message) return
+  const usage = message.usage
+  if (message.id && usage) {
+    const next = {
+      input: number(usage.input_tokens),
+      output: number(usage.output_tokens),
+      cacheRead: number(usage.cache_read_input_tokens),
+      cacheWrite: number(usage.cache_creation_input_tokens),
+    }
+    const previous = state.usageById.get(message.id)
+    for (const key of Object.keys(next)) state.tokens[key] += next[key] - (previous?.[key] || 0)
+    state.usageById.set(message.id, next)
+    state.context = next.input + next.cacheRead + next.cacheWrite + next.output
+    const cost = requestCost(message.model, usage)
+    let added = null
+    if (cost != null) {
+      added = cost - (state.costById.get(message.id) || 0)
+      state.costById.set(message.id, cost)
+      state.spend += added
+    } else if (next.input + next.output + next.cacheRead + next.cacheWrite > 0) {
+      state.unpriced = true
+    }
+    if (state.detail) recordUsage(state.detail, message, next, previous, state.context, at, added)
+  }
+  if (message.model && message.model !== '<synthetic>') state.model = text(message.model)
+  if (record.effort) state.effort = text(record.effort)
+  const content = Array.isArray(message.content) ? message.content : []
+  let calling = false
+  for (const block of content) {
+    if (block?.type !== 'tool_use') continue
+    calling = true
+    if (!state.open.has(block.id)) {
+      state.open.set(block.id, { name: text(block.name), startedAt: at })
+      if (state.detail) {
+        startCall(state.detail.activity, {
+          id: text(block.id),
+          name: text(block.name),
+          target: toolTarget(block.input, state.cwd),
+          input: toolInput(block.input),
+          ...toolFile(block.input, state.cwd),
+          startedAt: at,
+        })
+      }
+    }
+    state.plan = nextPlan(state.plan, text(block.name), block.input)
+    if (block.name === 'SendMessage') subscribe(state, block, at)
+  }
+  const handedBack = !calling && message.stop_reason !== 'tool_use'
+  state.ending = { handedBack, failed: handedBack && record.isApiErrorMessage === true }
+  if (handedBack) {
+    state.open.clear()
+    state.handedBackAt = at
+  }
+  if (!state.detail) return
+  if (handedBack) settleCalls(state.detail.activity)
+  if (record.isApiErrorMessage === true) {
+    keepNewest(state.detail.errors, { at, message: clip(firstText(content) || 'API error', DETAIL_LIMITS.errorText) }, DETAIL_LIMITS.errors)
+  }
+}
+
+function recordUsage(detail, message, next, previous, context, at, cost) {
+  const last = detail.history.at(-1)
+  if (last?.id === message.id) {
+    last.context = context
+    last.output = next.output
+  } else {
+    keepNewest(detail.history, { id: message.id, at, context, output: next.output }, DETAIL_LIMITS.history)
+  }
+  if (context) detail.contextParts = { input: next.input, cacheRead: next.cacheRead, cacheWrite: next.cacheWrite, output: next.output }
+  const model = text(message.model)
+  if (!model || model === '<synthetic>') return
+  const totals = detail.models.get(model) || { tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, usd: 0, unpriced: false }
+  for (const key of Object.keys(next)) totals.tokens[key] += next[key] - (previous?.[key] || 0)
+  if (cost == null) totals.unpriced = true
+  else totals.usd += cost
+  detail.models.set(model, totals)
+}
+
+export function transcriptDetail(state) {
+  const detail = state.detail
+  if (!detail) return null
+  const models = [...detail.models].map(([model, m]) => ({ model, tokens: { ...m.tokens }, costUsd: m.unpriced ? null : m.usd }))
+  return {
+    models,
+    contextParts: detail.contextParts ? { ...detail.contextParts } : null,
+    history: detail.history.map(({ at, context, output }) => ({ at, context, output })),
+    compactions: detail.compactions.map((c) => ({ ...c })),
+    ...activityDetail(detail.activity),
+    plan: planItems(state.plan),
+    files: fileList(detail.files, state.cwd),
+    prompts: detail.prompts.map((p) => ({ ...p })),
+    errors: detail.errors.map((e) => ({ ...e })),
+  }
+}
+
+function firstText(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  for (const part of content) {
+    if (typeof part === 'string') return part
+    if (part?.type === 'text' && typeof part.text === 'string') return part.text
+  }
+  return ''
+}
+
+export function turnEnding(state) {
+  const ending = state?.ending || MID_TURN
+  const open = state?.open || new Map()
+  const onAgents = !ending.handedBack && open.size > 0 && [...open.values()].every((c) => AGENT_TOOLS.has(c.name))
+  return { handedBack: ending.handedBack, failed: ending.failed, onAgents }
+}
+
+export function awaitedPeers(state, live, handedBackAt = () => 0) {
+  if (!state?.awaiting?.size) return []
+  const sockets = new Map()
+  const names = new Map()
+  for (const [sessionId, session] of live) {
+    if (session.socket) sockets.set(session.socket, sessionId)
+    if (session.name) names.set(session.name, names.has(session.name) ? null : sessionId)
+  }
+  const peers = new Map()
+  for (const [to, { since }] of state.awaiting) {
+    const sessionId = sockets.get(to.replace(/^uds:/, '')) ?? names.get(to)
+    const peer = sessionId ? live.get(sessionId) : null
+    if (!peer || !PEER_BUSY.has(peer.status) || handedBackAt(sessionId) > since) continue
+    peers.set(sessionId, { sessionId, name: peer.name, since })
+  }
+  return [...peers.values()]
+}