@chroxify/eunoe 1.0.0 → 1.2.0

package/src/proxy/usage.ts

@@ -1,41 +1,57 @@
-import { MAX_EVENT_BUFFER } from "./constants"
-import type { Usage } from "./types"
+type Usage = Record<string, number>
+
+function usageIn(line: string): Usage | null {
+  if (!line.startsWith("data:") || !line.includes("message_start")) return null
+  try {
+    return JSON.parse(line.slice(5)).message?.usage ?? null
+  } catch {
+    return null
+  }
+}
+
+function trailingUsage(buffer: string): Usage | null {
+  if (!buffer.trim().startsWith("{")) return null
+  try {
+    const json = JSON.parse(buffer)
+    if (json.usage) return json.usage
+    return typeof json.input_tokens === "number" ? { input_tokens: json.input_tokens } : null
+  } catch {
+    return null
+  }
+}
+
+function scanEvents(buffer: string): { usage: Usage | null; rest: string } {
+  let rest = buffer
+  for (let newline = rest.indexOf("\n"); newline !== -1; newline = rest.indexOf("\n")) {
+    const usage = usageIn(rest.slice(0, newline).trim())
+    rest = rest.slice(newline + 1)
+    if (usage) return { usage, rest }
+  }
+  return { usage: null, rest }
+}
+
+async function readUsage(stream: ReadableStream): Promise<Usage | null> {
+  const reader = stream.pipeThrough(new TextDecoderStream()).getReader()
+  let buffer = ""
+  let usage: Usage | null = null
+  while (true) {
+    const { value, done } = await reader.read()
+    if (done) return usage ?? trailingUsage(buffer)
+    if (usage) continue
+    const scanned = scanEvents(buffer + value)
+    usage = scanned.usage
+    buffer = scanned.rest.length > 4_000_000 ? "" : scanned.rest
+  }
+}
 
 export function watchUsage(response: Response, onUsage: (usage: Usage) => void): Response {
   if (!response.body) return response
   const [toClient, toUs] = response.body.tee()
-  void (async () => {
-    const reader = toUs.pipeThrough(new TextDecoderStream()).getReader()
-    let buffer = ""
-    let found = false
-    while (true) {
-      const { value, done } = await reader.read()
-      if (done) break
-      if (found) continue
-      buffer += value
-      let newline: number
-      while (!found && (newline = buffer.indexOf("\n")) !== -1) {
-        const line = buffer.slice(0, newline).trim()
-        buffer = buffer.slice(newline + 1)
-        if (!line.startsWith("data:") || !line.includes("message_start")) continue
-        try {
-          const event = JSON.parse(line.slice(5))
-          if (event.message?.usage) {
-            found = true
-            onUsage(event.message.usage)
-          }
-        } catch {}
-      }
-      if (!found && buffer.length > MAX_EVENT_BUFFER) buffer = ""
-    }
-    if (!found && buffer.trim().startsWith("{")) {
-      try {
-        const json = JSON.parse(buffer)
-        if (json.usage) onUsage(json.usage)
-        else if (typeof json.input_tokens === "number") onUsage({ input_tokens: json.input_tokens })
-      } catch {}
-    }
-  })().catch(() => undefined)
+  readUsage(toUs)
+    .then((usage) => {
+      if (usage) onUsage(usage)
+    })
+    .catch(() => undefined)
   return new Response(toClient, { status: response.status, statusText: response.statusText, headers: response.headers })
 }
 

package/src/proxy/window.ts

@@ -1,12 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
-import { EUNOE_DIR, paths } from "../config/constants"
-import { ANTHROPIC_VERSION, MODEL_HEADERS, MODEL_LOOKUP_TIMEOUT_MS } from "./constants"
-
-const CACHE = paths.models
+import { EUNOE_DIR, paths } from "../config/paths"
 
 function readCache(): Map<string, number> {
   try {
-    return new Map(existsSync(CACHE) ? Object.entries(JSON.parse(readFileSync(CACHE, "utf8"))) : [])
+    return new Map(existsSync(paths.models) ? Object.entries(JSON.parse(readFileSync(paths.models, "utf8"))) : [])
   } catch {
     return new Map()
   }
@@ -15,36 +12,37 @@ function readCache(): Map<string, number> {
 const windows = readCache()
 const lookups = new Map<string, Promise<number | null>>()
 
-function modelId(model: unknown) {
-  return String(model ?? "").replace(/\[[^\]]*\]$/, "")
+function lookupHeaders(requestHeaders: Headers): Headers {
+  const headers = new Headers()
+  for (const name of ["authorization", "x-api-key", "anthropic-version", "anthropic-beta"]) {
+    const value = requestHeaders.get(name)
+    if (value) headers.set(name, value)
+  }
+  if (!headers.has("anthropic-version")) headers.set("anthropic-version", "2023-06-01")
+  return headers
 }
 
-export async function resolveWindow(model: unknown, requestHeaders: Headers, upstream: string): Promise<number | null> {
-  const id = modelId(model)
-  if (!id) return null
+async function lookup(id: string, requestHeaders: Headers, upstream: string): Promise<number | null> {
+  const response = await fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers: lookupHeaders(requestHeaders), signal: AbortSignal.timeout(5_000) })
+  if (!response.ok) return null
+  const info = (await response.json()) as { max_input_tokens?: number }
+  if (typeof info.max_input_tokens !== "number" || info.max_input_tokens <= 0) return null
+  windows.set(id, info.max_input_tokens)
+  mkdirSync(EUNOE_DIR, { recursive: true })
+  writeFileSync(paths.models, JSON.stringify(Object.fromEntries(windows), null, 2))
+  return info.max_input_tokens
+}
+
+export function resolveWindow(model: unknown, requestHeaders: Headers, upstream: string): Promise<number | null> {
+  const id = String(model ?? "").replace(/\[[^\]]*\]$/, "")
+  if (!id) return Promise.resolve(null)
   const known = windows.get(id)
-  if (known) return known
-  let lookup = lookups.get(id)
-  if (!lookup) {
-    const headers = new Headers()
-    for (const name of MODEL_HEADERS) {
-      const value = requestHeaders.get(name)
-      if (value) headers.set(name, value)
-    }
-    if (!headers.has("anthropic-version")) headers.set("anthropic-version", ANTHROPIC_VERSION)
-    lookup = fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers, signal: AbortSignal.timeout(MODEL_LOOKUP_TIMEOUT_MS) })
-      .then(async (response) => {
-        if (!response.ok) return null
-        const info = await response.json() as { max_input_tokens?: number }
-        if (typeof info.max_input_tokens !== "number" || info.max_input_tokens <= 0) return null
-        windows.set(id, info.max_input_tokens)
-        mkdirSync(EUNOE_DIR, { recursive: true })
-        writeFileSync(CACHE, JSON.stringify(Object.fromEntries(windows), null, 2))
-        return info.max_input_tokens
-      })
-      .catch(() => null)
-      .finally(() => lookups.delete(id))
-    lookups.set(id, lookup)
-  }
-  return lookup
+  if (known) return Promise.resolve(known)
+  const inFlight = lookups.get(id)
+  if (inFlight) return inFlight
+  const pending = lookup(id, requestHeaders, upstream)
+    .catch(() => null)
+    .finally(() => lookups.delete(id))
+  lookups.set(id, pending)
+  return pending
 }

package/src/transcript/format.ts

@@ -1,19 +1,43 @@
 import { clip } from "../context/content"
-import { INDEX_PROMPT_CHARS, INDEX_REPLY_CHARS } from "./constants"
-import type { TranscriptFormat, Turn } from "./types"
+import type { ToolPart, TranscriptFormat, Turn } from "./parse"
+import type { SubagentRun } from "./subagents"
+
+export interface SubagentRecord {
+  run: SubagentRun
+  turns: Turn[]
+  parentTurn: number
+  file: string
+}
+
+const extension = (format: TranscriptFormat) => (format === "xml" ? "xml" : "md")
+const padded = (n: number) => String(n).padStart(4, "0")
+const calls = (count: number) => `${count} tool call${count === 1 ? "" : "s"}`
 
 export function turnFile(turn: Turn, format: TranscriptFormat) {
-  return `turn-${String(turn.number).padStart(4, "0")}.${format === "xml" ? "xml" : "md"}`
+  return `turn-${padded(turn.number)}.${extension(format)}`
+}
+
+export function subagentFile(parentTurn: number, k: number, format: TranscriptFormat) {
+  return `turn-${padded(parentTurn)}-subagent-${k}.${extension(format)}`
+}
+
+function toolMarkdown(part: ToolPart, total: number) {
+  return [
+    `### [tool ${part.n}/${total}] ${part.name}: ${part.call}`,
+    part.record ? `Full record of this subagent run: ${part.record}` : "",
+    part.body,
+    part.output ? `[output of tool ${part.n}${part.error ? ", error" : ""}]\n\`\`\`\n${part.output}\n\`\`\`` : `[tool ${part.n}: no output]`,
+  ]
+    .filter(Boolean)
+    .join("\n\n")
+}
+
+function workOf(turn: Turn) {
+  const work = turn.parts.map((part) => (part.kind === "say" ? `> ${part.text.replace(/\n/g, "\n> ")}` : toolMarkdown(part, turn.calls)))
+  return work.join("\n\n") || "_No tool calls._"
 }
 
 export function renderMarkdown(turn: Turn) {
-  const work = turn.parts.map((part) => part.kind === "say"
-    ? `> ${part.text.replace(/\n/g, "\n> ")}`
-    : [
-        `### [tool ${part.n}/${turn.calls}] ${part.name}: ${part.call}`,
-        part.body,
-        part.output ? `[output of tool ${part.n}${part.error ? ", error" : ""}]\n\`\`\`\n${part.output}\n\`\`\`` : `[tool ${part.n}: no output]`,
-      ].filter(Boolean).join("\n\n"))
   return [
     `# Turn ${turn.number}${turn.time ? ` · ${turn.time}` : ""}`,
     "",
@@ -21,9 +45,9 @@ export function renderMarkdown(turn: Turn) {
     "",
     turn.prompt,
     "",
-    `## Work (${turn.calls} tool call${turn.calls === 1 ? "" : "s"})`,
+    `## Work (${calls(turn.calls)})`,
     "",
-    work.join("\n\n") || "_No tool calls._",
+    workOf(turn),
     "",
     "## Final reply",
     "",
@@ -36,33 +60,72 @@ function attr(value: string) {
   return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/\n/g, " ")
 }
 
+function toolXml(part: ToolPart, total: number) {
+  return [
+    `<tool n="${part.n}" of="${total}" name="${attr(part.name)}">`,
+    `<call>${part.call.replace(/^`|`$/g, "")}</call>`,
+    part.record ? `<record>${part.record}</record>` : "",
+    part.body ? `<input>\n${part.body}\n</input>` : "",
+    part.output ? `<output${part.error ? ' error="true"' : ""}>\n${part.output}\n</output>` : "<output/>",
+    "</tool>",
+  ]
+    .filter(Boolean)
+    .join("\n")
+}
+
 export function renderXml(turn: Turn) {
-  const work = turn.parts.map((part) => part.kind === "say"
-    ? `<said>\n${part.text}\n</said>`
-    : [
-        `<tool n="${part.n}" of="${turn.calls}" name="${attr(part.name)}">`,
-        `<call>${part.call.replace(/^`|`$/g, "")}</call>`,
-        part.body ? `<input>\n${part.body}\n</input>` : "",
-        part.output ? `<output${part.error ? ' error="true"' : ""}>\n${part.output}\n</output>` : "<output/>",
-        "</tool>",
-      ].filter(Boolean).join("\n"))
   return [
     `<turn n="${turn.number}"${turn.time ? ` time="${turn.time}"` : ""} tool_calls="${turn.calls}">`,
     `<user>\n${turn.prompt}\n</user>`,
-    ...work,
+    ...turn.parts.map((part) => (part.kind === "say" ? `<said>\n${part.text}\n</said>` : toolXml(part, turn.calls))),
     turn.final ? `<final_reply>\n${turn.final}\n</final_reply>` : `<final_reply interrupted="true"/>`,
     "</turn>",
     "",
   ].join("\n")
 }
 
-export function renderIndex(turns: Turn[], format: TranscriptFormat) {
+const finalOf = (final: string | undefined) => (final ? clip(final, 160) : "_(no final reply)_")
+
+const turnLine = (turn: Turn, format: TranscriptFormat) => `- **${turnFile(turn, format)}** (${turn.time}, ${turn.calls} calls): ${clip(turn.prompt, 140)} → ${finalOf(turn.final)}`
+
+const recordLine = (record: SubagentRecord) => {
+  const total = record.turns.reduce((sum, turn) => sum + turn.calls, 0)
+  return `  - **${record.file}**: subagent "${clip(record.run.description, 140)}" (${total} calls) → ${finalOf(record.turns.at(-1)?.final)}`
+}
+
+export function renderIndex(turns: Turn[], format: TranscriptFormat, records: SubagentRecord[] = []) {
+  const ext = extension(format)
+  const subagentNote = records.length > 0 ? ` Indented lines are subagents the agent launched in that turn; turn-NNNN-subagent-K.${ext} holds the subagent's whole run, which the turn itself only has the report of.` : ""
   return [
     "# Session index",
     "",
-    `One line per turn: what the user asked → how the turn ended. Open turn-NNNN.${format === "xml" ? "xml" : "md"} for everything that happened in it.`,
+    `One line per turn: what the user asked → how the turn ended. Open turn-NNNN.${ext} for everything that happened in it.${subagentNote}`,
     "",
-    ...turns.map((turn) => `- **${turnFile(turn, format)}** (${turn.time}, ${turn.calls} calls): ${clip(turn.prompt, INDEX_PROMPT_CHARS)} → ${turn.final ? clip(turn.final, INDEX_REPLY_CHARS) : "_(no final reply)_"}`),
+    ...turns.flatMap((turn) => [turnLine(turn, format), ...records.filter((record) => record.parentTurn === turn.number).map(recordLine)]),
+    ...records.filter((record) => record.parentTurn === 0).map(recordLine),
     "",
   ].join("\n")
 }
+
+export function renderSubagentMarkdown(record: SubagentRecord) {
+  const parent = record.parentTurn || "?"
+  const body = record.turns.flatMap((turn, i) => [
+    record.turns.length > 1 ? `## Message ${i + 1}` : "## Task",
+    "",
+    turn.prompt,
+    "",
+    `## Work (${calls(turn.calls)})`,
+    "",
+    workOf(turn),
+    "",
+    "## Final reply",
+    "",
+    turn.final || "_No final reply: the run was interrupted or is still going._",
+    "",
+  ])
+  return [`# Subagent of turn ${parent} · "${record.run.description}"`, `This is the full record of a subagent launched from turn ${parent}; that turn only holds its final report.`, "", ...body].join("\n")
+}
+
+export function renderSubagentXml(record: SubagentRecord) {
+  return [`<subagent parent_turn="${record.parentTurn}" description="${attr(record.run.description)}">`, ...record.turns.map(renderXml), "</subagent>", ""].join("\n")
+}

package/src/transcript/locate.ts

@@ -1,28 +1,49 @@
 import { existsSync, readdirSync } from "node:fs"
 import path from "node:path"
-import { SESSION_ID_PATTERN } from "../config/constants"
 
 const found = new Map<string, string>()
 
+export const isSessionId = (value: string) => /^[a-zA-Z0-9-]+$/.test(value)
+
+export const projectFolderName = (cwd: string) => cwd.replace(/[^a-zA-Z0-9]/g, "-")
+
+export function listEntries(dir: string): string[] {
+  try {
+    return readdirSync(dir)
+  } catch {
+    return []
+  }
+}
+
+export function projectFolders(configDirs: string[]): string[] {
+  return configDirs.flatMap((configDir) => {
+    const projects = path.join(configDir, "projects")
+    return listEntries(projects).map((name) => path.join(projects, name))
+  })
+}
+
+export function findSessionByPrefix(prefix: string, configDirs: string[], exclude?: string): string | null {
+  if (!isSessionId(prefix)) return null
+  const hits = new Map<string, string>()
+  for (const folder of projectFolders(configDirs)) {
+    for (const name of listEntries(folder)) {
+      if (!name.endsWith(".jsonl") || !name.startsWith(prefix)) continue
+      const id = name.slice(0, -".jsonl".length)
+      if (id !== exclude && !hits.has(id)) hits.set(id, path.join(folder, name))
+    }
+  }
+  return hits.size === 1 ? [...hits.values()][0] : null
+}
+
 export function findSessionFile(sessionId: string, configDirs: string[]): string | null {
   const hit = found.get(sessionId)
   if (hit && existsSync(hit)) return hit
-  if (!SESSION_ID_PATTERN.test(sessionId)) return null
-  for (const configDir of configDirs) {
-    const projects = path.join(configDir, "projects")
-    let dirs: string[]
-    try {
-      dirs = readdirSync(projects)
-    } catch {
-      continue
-    }
-    for (const dir of dirs) {
-      const file = path.join(projects, dir, `${sessionId}.jsonl`)
-      if (existsSync(file)) {
-        found.set(sessionId, file)
-        return file
-      }
-    }
+  if (!isSessionId(sessionId)) return null
+  for (const folder of projectFolders(configDirs)) {
+    const file = path.join(folder, `${sessionId}.jsonl`)
+    if (!existsSync(file)) continue
+    found.set(sessionId, file)
+    return file
   }
   return null
 }

package/src/transcript/messages.ts

@@ -1,6 +1,6 @@
 import { readFileSync, statSync } from "node:fs"
-import type { Message } from "../context/types"
-import type { SessionEntry } from "./types"
+import type { Message } from "../context/content"
+import { entryMessages, parseJsonl } from "./parse"
 
 let cached: { file: string; mtimeMs: number; messages: Message[] } | null = null
 
@@ -12,18 +12,7 @@ export function sessionMessages(file: string): Message[] {
     return []
   }
   if (cached?.file === file && cached.mtimeMs === mtimeMs) return cached.messages
-  const messages: Message[] = []
-  for (const line of readFileSync(file, "utf8").split("\n")) {
-    if (!line) continue
-    let entry: SessionEntry
-    try {
-      entry = JSON.parse(line)
-    } catch {
-      continue
-    }
-    if (entry.isSidechain || entry.isCompactSummary || (entry.type !== "user" && entry.type !== "assistant") || !entry.message) continue
-    messages.push({ role: entry.message.role, content: entry.message.content })
-  }
+  const messages = entryMessages(parseJsonl(readFileSync(file, "utf8")).filter((entry) => !entry.isSidechain))
   cached = { file, mtimeMs, messages }
   return messages
 }

package/src/transcript/parse.ts

@@ -1,31 +1,89 @@
-import { contentBlocks } from "../context/content"
-import type { Block } from "../context/types"
-import { CALL_COMMAND_CHARS, CALL_DESCRIPTION_CHARS, CALL_INPUT_CHARS, CALL_PATTERN_CHARS, OUTPUT_CAP } from "./constants"
-import type { SessionEntry, ToolPart, Turn } from "./types"
+import { type Block, contentBlocks, type Message } from "../context/content"
 
-function stripReminders(text: string) {
-  return text
+export interface SessionEntry {
+  type?: string
+  subtype?: string
+  isSidechain?: boolean
+  isMeta?: boolean
+  isCompactSummary?: boolean
+  agentId?: string
+  timestamp?: string
+  cwd?: string
+  aiTitle?: string
+  message?: { role: string; content: string | Block[] }
+}
+
+export type TranscriptFormat = "markdown" | "xml"
+
+export interface ToolPart {
+  kind: "tool"
+  n: number
+  id: string
+  name: string
+  prompt?: string
+  record?: string
+  call: string
+  body: string
+  output: string
+  error: boolean
+}
+
+type TurnPart = { kind: "say"; text: string } | ToolPart
+
+export interface Turn {
+  number: number
+  time: string
+  prompt: string
+  parts: TurnPart[]
+  final: string
+  calls: number
+}
+
+const OUTPUT_CAP = 40_000
+
+export function parseJsonl<T = SessionEntry>(text: string): T[] {
+  return text.split("\n").flatMap((line) => {
+    if (!line) return []
+    try {
+      return [JSON.parse(line) as T]
+    } catch {
+      return []
+    }
+  })
+}
+
+export function entryMessages(entries: SessionEntry[]): Message[] {
+  return entries.flatMap((entry): Message[] => {
+    if (entry.isCompactSummary || (entry.type !== "user" && entry.type !== "assistant") || !entry.message) return []
+    return [{ role: entry.message.role, content: entry.message.content }]
+  })
+}
+
+function promptText(content: Block[]) {
+  return content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text ?? "")
+    .join("\n")
     .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
     .replace(/<system-message>[\s\S]*?<\/system-message>/g, "")
     .trim()
 }
 
 function isPrompt(entry: SessionEntry) {
-  if (entry.type !== "user" || entry.isMeta || entry.isCompactSummary || entry.isSidechain) return false
+  if (entry.type !== "user" || entry.isMeta || entry.isCompactSummary) return false
   const content = contentBlocks(entry.message?.content)
   if (content.some((block) => block.type === "tool_result")) return false
-  const text = stripReminders(content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n"))
-  return Boolean(text) || content.some((block) => block.type === "image")
+  return Boolean(promptText(content)) || content.some((block) => block.type === "image")
 }
 
 function describeCall(block: Block): string {
   const input = block.input ?? {}
-  if (typeof input.command === "string") return `${block.name}: \`${input.command.replace(/\s+/g, " ").slice(0, CALL_COMMAND_CHARS)}\``
-  if (typeof input.file_path === "string") return `${block.name}: ${input.file_path}`
-  if (typeof input.pattern === "string") return `${block.name}: "${input.pattern.slice(0, CALL_PATTERN_CHARS)}"${input.path ? ` in ${input.path}` : ""}`
-  if (typeof input.url === "string") return `${block.name}: ${input.url}`
-  if (typeof input.description === "string") return `${block.name}: ${input.description.slice(0, CALL_DESCRIPTION_CHARS)}`
-  return `${block.name}: ${JSON.stringify(input).slice(0, CALL_INPUT_CHARS)}`
+  if (typeof input.command === "string") return `\`${input.command.replace(/\s+/g, " ").slice(0, 300)}\``
+  if (typeof input.file_path === "string") return input.file_path
+  if (typeof input.pattern === "string") return `"${input.pattern.slice(0, 120)}"${input.path ? ` in ${input.path}` : ""}`
+  if (typeof input.url === "string") return input.url
+  if (typeof input.description === "string") return input.description.slice(0, 160)
+  return JSON.stringify(input).slice(0, 200)
 }
 
 function callBody(block: Block): string {
@@ -35,59 +93,82 @@ function callBody(block: Block): string {
   return ""
 }
 
-function resultText(block: Block): string {
-  const content = typeof block.content === "string"
-    ? block.content
-    : contentBlocks(block.content).map((part) => (part.type === "text" ? part.text : `[${part.type}]`)).join("\n")
+function outputOf(block: Block): string {
+  const content =
+    typeof block.content === "string"
+      ? block.content
+      : contentBlocks(block.content)
+          .map((part) => (part.type === "text" ? part.text : `[${part.type}]`))
+          .join("\n")
   return content.length > OUTPUT_CAP ? `${content.slice(0, OUTPUT_CAP)}\n… [${content.length - OUTPUT_CAP} more characters]` : content
 }
 
-export function parseTurns(entries: SessionEntry[]): Turn[] {
+function promptTurn(entry: SessionEntry, number: number): Turn {
+  const text = promptText(contentBlocks(entry.message?.content))
+  const time = String(entry.timestamp ?? "")
+    .slice(0, 16)
+    .replace("T", " ")
+  return { number, time, prompt: text || "[image]", parts: [], final: "", calls: 0 }
+}
+
+function recordAssistant(turn: Turn, content: Block[], pending: Map<string, ToolPart>, narration: string): string {
+  let said = narration
+  for (const block of content) {
+    if (block.type === "text" && String(block.text).trim()) {
+      said = String(block.text).trim()
+      turn.final = said
+    }
+    if (block.type !== "tool_use") continue
+    turn.calls += 1
+    if (said) {
+      turn.parts.push({ kind: "say", text: said })
+      said = ""
+    }
+    turn.final = ""
+    const call: ToolPart = {
+      kind: "tool",
+      n: turn.calls,
+      id: String(block.id ?? ""),
+      name: block.name,
+      prompt: typeof block.input?.prompt === "string" ? block.input.prompt : undefined,
+      call: describeCall(block),
+      body: callBody(block),
+      output: "",
+      error: false,
+    }
+    pending.set(block.id, call)
+    turn.parts.push(call)
+  }
+  return said
+}
+
+function recordResults(content: Block[], pending: Map<string, ToolPart>) {
+  for (const block of content) {
+    if (block.type !== "tool_result") continue
+    const call = pending.get(block.tool_use_id)
+    if (!call) continue
+    pending.delete(block.tool_use_id)
+    call.output = outputOf(block).trim()
+    call.error = Boolean(block.is_error)
+  }
+}
+
+export function parseTurns(entries: SessionEntry[], sidechain: boolean | "any" = false): Turn[] {
   const turns: Turn[] = []
   const pending = new Map<string, ToolPart>()
   let narration = ""
   for (const entry of entries) {
-    if (entry.isSidechain) continue
+    if (sidechain !== "any" && Boolean(entry.isSidechain) !== sidechain) continue
     if (isPrompt(entry)) {
-      const text = stripReminders(contentBlocks(entry.message.content).filter((block) => block.type === "text").map((block) => block.text).join("\n"))
-      turns.push({ number: turns.length + 1, time: String(entry.timestamp ?? "").slice(0, 16).replace("T", " "), prompt: text || "[image]", parts: [], final: "", calls: 0 })
+      turns.push(promptTurn(entry, turns.length + 1))
       continue
     }
     const turn = turns.at(-1)
     if (!turn) continue
-    if (entry.type === "system" && entry.subtype === "compact_boundary") {
-      turn.parts.push({ kind: "say", text: "(Claude Code compacted the context here.)" })
-      continue
-    }
-    if (entry.type === "assistant") {
-      for (const block of contentBlocks(entry.message?.content)) {
-        if (block.type === "text" && String(block.text).trim()) {
-          narration = String(block.text).trim()
-          turn.final = narration
-        }
-        if (block.type === "tool_use") {
-          turn.calls += 1
-          if (narration) {
-            turn.parts.push({ kind: "say", text: narration })
-            narration = ""
-          }
-          turn.final = ""
-          const call: ToolPart = { kind: "tool", n: turn.calls, name: block.name, call: describeCall(block).slice(block.name.length + 2), body: callBody(block), output: "", error: false }
-          pending.set(block.id, call)
-          turn.parts.push(call)
-        }
-      }
-    }
-    if (entry.type === "user") {
-      for (const block of contentBlocks(entry.message?.content)) {
-        if (block.type !== "tool_result") continue
-        const call = pending.get(block.tool_use_id)
-        if (!call) continue
-        pending.delete(block.tool_use_id)
-        call.output = resultText(block).trim()
-        call.error = Boolean(block.is_error)
-      }
-    }
+    const content = contentBlocks(entry.message?.content)
+    if (entry.type === "system" && entry.subtype === "compact_boundary") turn.parts.push({ kind: "say", text: "(Claude Code compacted the context here.)" })
+    else if (entry.type === "assistant") narration = recordAssistant(turn, content, pending, narration)
+    else if (entry.type === "user") recordResults(content, pending)
   }
   return turns
 }