@chroxify/eunoe 1.2.0 → 1.2.2

package/src/proxy/server.ts

@@ -93,16 +93,27 @@ function saveRatio(threadKey: string, ratio: (previous: number | undefined) => n
   saveState(threadKey, state)
 }
 
-export async function handle(request: Request): Promise<Response> {
+interface Timing {
+  countTokensTimeoutMs: number
+}
+
+const COUNT_TOKENS_ATTEMPTS = 3
+
+export async function handle(request: Request, timing: Timing = { countTokensTimeoutMs: 10_000 }): Promise<Response> {
+  const began = Date.now()
   try {
-    return await route(request)
+    return await route(request, began, timing)
   } catch (error) {
-    logRequest({ path: new URL(request.url).pathname, status: 502, action: "upstream-unreachable", error: clipped(String(error)) })
+    logRequest({ path: new URL(request.url).pathname, status: 502, action: "upstream-unreachable", error: clipped(String(error)), ms: Date.now() - began })
     return Response.json({ type: "error", error: { type: "api_error", message: `eunoe could not reach the API: ${String(error)}` } }, { status: 502 })
   }
 }
 
-async function route(request: Request): Promise<Response> {
+async function route(request: Request, began: number, timing: Timing): Promise<Response> {
+  let stalled = 0
+  let prep = 0
+  let upload = 0
+  const log = (record: Record<string, unknown>) => logRequest({ ...record, ms: Date.now() - began, prep, upload, ...(stalled > 0 && { stalled }) })
   const config = readConfig()
   const url = new URL(request.url)
   if (url.pathname === HEALTH_PATH) return Response.json({ ok: true, version: VERSION, mode: config.mode, pid: process.pid, startedAt } satisfies Health)
@@ -111,6 +122,7 @@ async function route(request: Request): Promise<Response> {
 
   let givenText: string | undefined
   if (request.method !== "GET" && request.method !== "HEAD") givenText = await request.text()
+  upload = Date.now() - began
   const isMessages = request.method === "POST" && url.pathname.startsWith("/v1/messages")
   const isCountTokens = url.pathname.includes("count_tokens")
 
@@ -136,9 +148,22 @@ async function route(request: Request): Promise<Response> {
       return { ...passthrough, note: { action: "error-passthrough", error: String(error) } }
     }
   }
-  const send = (body: string | undefined) => fetch(config.upstream + url.pathname + url.search, { method: request.method, headers, body })
+  const target = config.upstream + url.pathname + url.search
+  const send = async (body: string | undefined): Promise<Response> => {
+    if (!isCountTokens) return fetch(target, { method: request.method, headers, body })
+    for (;;) {
+      try {
+        return await fetch(target, { method: request.method, headers, body, signal: AbortSignal.timeout(timing.countTokensTimeoutMs) })
+      } catch (error) {
+        const timedOut = error instanceof Error && error.name === "TimeoutError"
+        if (!timedOut || stalled + 1 >= COUNT_TOKENS_ATTEMPTS) throw error
+        stalled += 1
+      }
+    }
+  }
 
   let out = await build()
+  prep = Date.now() - began - upload
   let upstream = await send(out.bodyText)
   const errorResponse = (text: string) => new Response(text, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
 
@@ -147,18 +172,18 @@ async function route(request: Request): Promise<Response> {
     const overflow = overflowTokens(errorText)
     const logged = { path: url.pathname, status: upstream.status, thread: out.threadKey, ...out.note }
     if (!overflow || !out.threadKey || out.sentSize === 0 || isCountTokens) {
-      logRequest({ ...logged, error: clipped(errorText) })
+      log({ ...logged, error: clipped(errorText) })
       return errorResponse(errorText)
     }
     const sentSize = out.sentSize
     saveRatio(out.threadKey, (previous) => Math.max(previous ?? 0, overflow / sentSize) * 1.1)
-    logRequest({ ...logged, overflow, error: clipped(errorText) })
+    log({ ...logged, overflow, error: clipped(errorText) })
     out = await build()
     out = { ...out, note: { ...out.note, healed: overflow } }
     upstream = await send(out.bodyText)
     if (upstream.status >= 400) {
       const retryError = await upstream.text()
-      logRequest({ path: url.pathname, status: upstream.status, thread: out.threadKey, ...out.note, error: clipped(retryError) })
+      log({ path: url.pathname, status: upstream.status, thread: out.threadKey, ...out.note, error: clipped(retryError) })
       return errorResponse(retryError)
     }
   }
@@ -166,13 +191,13 @@ async function route(request: Request): Promise<Response> {
   const { note, threadKey, sentSize, givenSize, fixedSize, sent } = out
   const response = new Response(upstream.body, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
   if (note.action === "pass" || !isMessages || isCountTokens) {
-    if (note.action !== "pass" || sent) logRequest({ path: url.pathname, status: upstream.status, ...note, ...(sent && { context: sent }) })
+    if (note.action !== "pass" || sent) log({ path: url.pathname, status: upstream.status, ...note, ...(sent && { context: sent }) })
     return response
   }
 
   return watchUsage(response, (usage) => {
     const input = inputTokens(usage)
-    logRequest({
+    log({
       path: url.pathname,
       status: upstream.status,
       thread: threadKey,
@@ -191,5 +216,5 @@ async function route(request: Request): Promise<Response> {
 }
 
 export function serve(port: number) {
-  return Bun.serve({ port, hostname: "127.0.0.1", idleTimeout: 255, fetch: handle })
+  return Bun.serve({ port, hostname: "127.0.0.1", idleTimeout: 255, fetch: (request) => handle(request) })
 }

package/src/proxy/state.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import path from "node:path"
 import { paths } from "../config/paths"
 
@@ -21,9 +21,35 @@ function stateFile(key: string) {
   return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
 }
 
+const KEPT_THREADS = 64
+
+const known = new Map<string, { version: string; state: ThreadState }>()
+
+function versionOf(file: string): string | null {
+  try {
+    const { mtimeMs, size } = statSync(file)
+    return `${mtimeMs}:${size}`
+  } catch {
+    return null
+  }
+}
+
+function remember(file: string, version: string, state: ThreadState) {
+  known.delete(file)
+  known.set(file, { version, state })
+  if (known.size > KEPT_THREADS) known.delete(known.keys().next().value as string)
+}
+
 export function readState(key: string): ThreadState {
+  const file = stateFile(key)
+  const version = versionOf(file)
+  if (version === null) return {}
+  const hit = known.get(file)
+  if (hit?.version === version) return structuredClone(hit.state)
   try {
-    return JSON.parse(readFileSync(stateFile(key), "utf8"))
+    const state = JSON.parse(readFileSync(file, "utf8")) as ThreadState
+    remember(file, version, state)
+    return structuredClone(state)
   } catch {
     return {}
   }
@@ -31,7 +57,10 @@ export function readState(key: string): ThreadState {
 
 export function saveState(key: string, state: ThreadState) {
   mkdirSync(paths.threads, { recursive: true })
-  writeFileSync(stateFile(key), JSON.stringify(state))
+  const file = stateFile(key)
+  writeFileSync(file, JSON.stringify(state))
+  const version = versionOf(file)
+  if (version !== null) remember(file, version, structuredClone(state))
 }
 
 export function resetCut(state: ThreadState) {

package/src/proxy/warm.ts

@@ -0,0 +1,68 @@
+import path from "node:path"
+import { type Config, claudeConfigDirs } from "../config"
+import type { Message } from "../context/content"
+import { splitTurns } from "../context/fold/turns"
+import { recallChunks, warmIndex } from "../context/recall"
+import { readSessionSlice } from "../transcript/entries"
+import { findSessionFile, listEntries } from "../transcript/locate"
+import { sessionMessages } from "../transcript/messages"
+import { subagentChunks, subagentMessages, subagentRuns, subagentsDir } from "../transcript/subagents"
+import { seenSessions } from "./sessions"
+
+const SLICE_MS = 8
+const SLICE_BYTES = 2 * 1024 * 1024
+const RECENT_MS = 24 * 60 * 60 * 1000
+const MAX_SESSIONS = 16
+const TURNS_PER_SLICE = 40
+
+let deadline = 0
+
+async function breathe() {
+  if (performance.now() < deadline) return
+  await new Promise((resolve) => setTimeout(resolve, 1))
+  deadline = performance.now() + SLICE_MS
+}
+
+const closingTurn: Message = { role: "user", content: "" }
+
+async function warmSession(file: string) {
+  while (!readSessionSlice(file, SLICE_BYTES)) await breathe()
+  await breathe()
+  for (const name of listEntries(subagentsDir(file))) {
+    if (!name.endsWith(".jsonl")) continue
+    while (!readSessionSlice(path.join(subagentsDir(file), name), SLICE_BYTES)) await breathe()
+    await breathe()
+  }
+  const messages = sessionMessages(file)
+  await breathe()
+  const { preamble, turns } = splitTurns(messages)
+  let end = preamble.length
+  for (let i = 0; i < turns.length; i += 1) {
+    end += turns[i].length
+    if ((i + 1) % TURNS_PER_SLICE !== 0 && i !== turns.length - 1) continue
+    recallChunks([...messages.slice(0, end), closingTurn], new Map())
+    await breathe()
+  }
+  for (const run of subagentRuns(file)) {
+    recallChunks([...subagentMessages(run), closingTurn], new Map())
+    await breathe()
+  }
+  const corpus = [...recallChunks([...messages, closingTurn], new Map()), ...subagentChunks(file)]
+  await breathe()
+  while (!warmIndex(corpus, performance.now() + SLICE_MS)) await breathe()
+}
+
+export async function warmRecentSessions(config: Config, now = Date.now()) {
+  deadline = performance.now() + SLICE_MS
+  const recent = seenSessions()
+    .filter(([, seen]) => seen.mode !== "off" && now - Date.parse(seen.lastSeen) < RECENT_MS)
+    .slice(0, MAX_SESSIONS)
+  for (const [id] of recent) {
+    const file = findSessionFile(id, claudeConfigDirs(config))
+    if (!file) continue
+    try {
+      await warmSession(file)
+    } catch {}
+    await breathe()
+  }
+}

package/src/transcript/entries.ts

@@ -0,0 +1,114 @@
+import { closeSync, openSync, readSync, statSync } from "node:fs"
+import type { SessionEntry } from "./parse"
+
+interface Parsed {
+  size: number
+  mtimeMs: number
+  offset: number
+  seam: Buffer
+  committed: SessionEntry[]
+  entries: SessionEntry[]
+}
+
+const BUDGET_BYTES = 768 * 1024 * 1024
+const NEWLINE = 0x0a
+const SEAM_BYTES = 64
+
+const parsed = new Map<string, Parsed>()
+let heldBytes = 0
+
+function parseLines(text: string): SessionEntry[] {
+  const out: SessionEntry[] = []
+  for (const line of text.split("\n")) {
+    if (!line) continue
+    try {
+      out.push(JSON.parse(line) as SessionEntry)
+    } catch {}
+  }
+  return out
+}
+
+function readRange(file: string, from: number, to: number): Buffer {
+  const buffer = Buffer.allocUnsafe(Math.max(0, to - from))
+  const fd = openSync(file, "r")
+  try {
+    let read = 0
+    while (read < buffer.length) {
+      const n = readSync(fd, buffer, read, buffer.length - read, from + read)
+      if (n === 0) break
+      read += n
+    }
+    return buffer.subarray(0, read)
+  } finally {
+    closeSync(fd)
+  }
+}
+
+function remember(file: string, next: Parsed) {
+  heldBytes += next.size - (parsed.get(file)?.size ?? 0)
+  parsed.delete(file)
+  parsed.set(file, next)
+  for (const [key, value] of parsed) {
+    if (heldBytes <= BUDGET_BYTES || key === file) break
+    parsed.delete(key)
+    heldBytes -= value.size
+  }
+}
+
+function appendable(file: string, known: Parsed | undefined, size: number): known is Parsed {
+  if (!known || size < known.size || known.offset === 0) return false
+  return readRange(file, known.offset - known.seam.length, known.offset).equals(known.seam)
+}
+
+export function readSessionSlice(file: string, maxBytes: number): boolean {
+  let size: number
+  let mtimeMs: number
+  try {
+    ;({ size, mtimeMs } = statSync(file))
+  } catch {
+    return true
+  }
+  const known = parsed.get(file)
+  if (known && known.size === size && known.mtimeMs === mtimeMs) return true
+  const appended = appendable(file, known, size)
+  const from = appended ? known.offset : 0
+  const bytes = from + maxBytes < size ? readRange(file, from, from + maxBytes) : null
+  const complete = bytes ? bytes.lastIndexOf(NEWLINE) + 1 : 0
+  if (!bytes || complete === 0) {
+    readSessionEntries(file)
+    return true
+  }
+  const added = parseLines(bytes.subarray(0, complete).toString("utf8"))
+  const committed = appended ? known.committed.concat(added) : added
+  const offset = from + complete
+  remember(file, { size: offset, mtimeMs: 0, offset, seam: readRange(file, Math.max(0, offset - SEAM_BYTES), offset), committed, entries: committed })
+  return false
+}
+
+export function readSessionEntries(file: string): SessionEntry[] {
+  let size: number
+  let mtimeMs: number
+  try {
+    ;({ size, mtimeMs } = statSync(file))
+  } catch {
+    return []
+  }
+  const known = parsed.get(file)
+  if (known && known.size === size && known.mtimeMs === mtimeMs) {
+    parsed.delete(file)
+    parsed.set(file, known)
+    return known.entries
+  }
+  const appended = appendable(file, known, size)
+  const from = appended ? known.offset : 0
+  const bytes = readRange(file, from, size)
+  const complete = bytes.lastIndexOf(NEWLINE) + 1
+  const added = parseLines(bytes.subarray(0, complete).toString("utf8"))
+  const committed = appended ? (added.length > 0 ? known.committed.concat(added) : known.committed) : added
+  const tail = parseLines(bytes.subarray(complete).toString("utf8"))
+  const entries = tail.length > 0 ? committed.concat(tail) : committed
+  const offset = from + complete
+  const seam = readRange(file, Math.max(0, offset - SEAM_BYTES), offset)
+  remember(file, { size, mtimeMs, offset, seam, committed, entries })
+  return entries
+}

package/src/transcript/messages.ts

@@ -1,18 +1,21 @@
-import { readFileSync, statSync } from "node:fs"
 import type { Message } from "../context/content"
-import { entryMessages, parseJsonl } from "./parse"
+import { readSessionEntries } from "./entries"
+import { entryMessages, type SessionEntry } from "./parse"
 
-let cached: { file: string; mtimeMs: number; messages: Message[] } | null = null
+const KEPT_SESSIONS = 32
+
+const cached = new Map<string, { entries: SessionEntry[]; messages: Message[] }>()
 
 export function sessionMessages(file: string): Message[] {
-  let mtimeMs: number
-  try {
-    mtimeMs = statSync(file).mtimeMs
-  } catch {
-    return []
+  const entries = readSessionEntries(file)
+  const known = cached.get(file)
+  cached.delete(file)
+  if (known?.entries === entries) {
+    cached.set(file, known)
+    return known.messages
   }
-  if (cached?.file === file && cached.mtimeMs === mtimeMs) return cached.messages
-  const messages = entryMessages(parseJsonl(readFileSync(file, "utf8")).filter((entry) => !entry.isSidechain))
-  cached = { file, mtimeMs, messages }
+  const messages = entryMessages(entries.filter((entry) => !entry.isSidechain))
+  cached.set(file, { entries, messages })
+  if (cached.size > KEPT_SESSIONS) cached.delete(cached.keys().next().value as string)
   return messages
 }

package/src/transcript/render-worker.ts

@@ -0,0 +1,24 @@
+import path from "node:path"
+import type { TranscriptFormat } from "./parse"
+import { renderTranscript } from "./render"
+
+declare const self: Worker
+
+export interface RenderJob {
+  dir: string
+  sessionFile: string
+  format: TranscriptFormat
+}
+
+export interface RenderDone {
+  dir: string
+  changed: boolean
+}
+
+self.onmessage = ({ data }: MessageEvent<RenderJob>) => {
+  let changed = false
+  try {
+    changed = renderTranscript(data.sessionFile, path.basename(data.dir), data.dir, data.format).changed
+  } catch {}
+  self.postMessage({ dir: data.dir, changed } satisfies RenderDone)
+}

package/src/transcript/render.ts

@@ -1,8 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import path from "node:path"
 import { paths } from "../config/paths"
+import { readSessionEntries } from "./entries"
 import { renderIndex, renderMarkdown, renderSubagentMarkdown, renderSubagentXml, renderXml, type SubagentRecord, subagentFile, turnFile } from "./format"
-import { parseJsonl, parseTurns, type ToolPart, type TranscriptFormat, type Turn } from "./parse"
+import { parseTurns, type ToolPart, type TranscriptFormat, type Turn } from "./parse"
 import { type SubagentRun, subagentEntries, subagentRuns } from "./subagents"
 
 interface RenderResult {
@@ -11,6 +12,8 @@ interface RenderResult {
   turns: number
 }
 
+const written = new Map<string, number | bigint>()
+
 export function transcriptDir(sessionId: string) {
   return path.join(paths.transcripts, sessionId)
 }
@@ -45,13 +48,19 @@ export function renderTranscript(sessionFile: string, sessionId: string, outDir
   const stamp = [statSync(sessionFile).mtimeMs, ...runs.map((run) => `${run.id}:${run.mtimeMs}`)].join("|")
   if (existsSync(stampFile) && readFileSync(stampFile, "utf8") === stamp) return { dir: outDir, changed: false, turns: Number(readFileSync(countFile, "utf8") || 0) }
 
-  const turns = parseTurns(parseJsonl(readFileSync(sessionFile, "utf8")))
+  const turns = parseTurns(readSessionEntries(sessionFile))
   const records = subagentRecords(turns, runs, format)
   let changed = false
   const write = (file: string, content: string) => {
     const target = path.join(outDir, file)
-    if (existsSync(target) && readFileSync(target, "utf8") === content) return
+    const hash = Bun.hash(content)
+    if (written.get(target) === hash && existsSync(target)) return
+    if (!written.has(target) && existsSync(target) && readFileSync(target, "utf8") === content) {
+      written.set(target, hash)
+      return
+    }
     writeFileSync(target, content)
+    written.set(target, hash)
     changed = true
   }
   for (const turn of turns) write(turnFile(turn, format), format === "xml" ? renderXml(turn) : renderMarkdown(turn))

package/src/transcript/search.ts

@@ -1,7 +1,8 @@
 import { existsSync } from "node:fs"
 import path from "node:path"
 import type { SearchMode } from "../config"
-import { renderTranscript, transcriptDir } from "./render"
+import { transcriptDir } from "./render"
+import type { RenderDone, RenderJob } from "./render-worker"
 
 export interface TranscriptRef {
   mode: SearchMode
@@ -32,13 +33,53 @@ function indexWithQmd(dir: string) {
   return next
 }
 
+const queued = new Map<string, { mode: SearchMode; sessionFile: string }>()
+let renderer: Worker | null = null
+let rendering: { dir: string; mode: SearchMode } | null = null
+let drained: Array<() => void> = []
+
+function finished(changed: boolean) {
+  if (rendering?.mode === "qmd" && (changed || !isIndexed(rendering.dir))) void indexWithQmd(rendering.dir)
+  rendering = null
+  renderNext()
+}
+
+function startRenderer(): Worker {
+  const worker = new Worker(new URL("./render-worker.ts", import.meta.url))
+  worker.onmessage = ({ data }: MessageEvent<RenderDone>) => finished(data.changed)
+  worker.onerror = () => {
+    renderer = null
+    finished(false)
+  }
+  ;(worker as Worker & { unref(): void }).unref()
+  return worker
+}
+
+function renderNext() {
+  const next = queued.entries().next()
+  if (next.done) {
+    const waiting = drained
+    drained = []
+    for (const resolve of waiting) resolve()
+    return
+  }
+  const [dir, { mode, sessionFile }] = next.value
+  queued.delete(dir)
+  rendering = { dir, mode }
+  renderer ??= startRenderer()
+  renderer.postMessage({ dir, sessionFile, format: mode === "xml" ? "xml" : "markdown" } satisfies RenderJob)
+}
+
+export function flushTranscripts(): Promise<void> {
+  if (!rendering && queued.size === 0) return Promise.resolve()
+  return new Promise((resolve) => drained.push(resolve))
+}
+
 export function prepareTranscript(mode: SearchMode, sessionFile: string, key: string): TranscriptRef {
   const dir = transcriptDir(key)
   if (mode !== "jsonl") {
-    try {
-      const { changed } = renderTranscript(sessionFile, key, dir, mode === "xml" ? "xml" : "markdown")
-      if (mode === "qmd" && (changed || !isIndexed(dir))) void indexWithQmd(dir)
-    } catch {}
+    queued.set(dir, { mode, sessionFile })
+    if (!rendering) renderNext()
   }
   return { mode, jsonl: sessionFile, dir }
 }

package/src/transcript/subagents.ts

@@ -3,9 +3,10 @@ import path from "node:path"
 import { blocks, clip, contentBlocks, type Message } from "../context/content"
 import { splitTurns } from "../context/fold/turns"
 import { type RecallChunk, recallChunks } from "../context/recall"
+import { readSessionEntries } from "./entries"
 import { listEntries } from "./locate"
 import { sessionMessages } from "./messages"
-import { entryMessages, parseJsonl, type SessionEntry } from "./parse"
+import { entryMessages, type SessionEntry } from "./parse"
 
 export interface SubagentRun {
   id: string
@@ -20,7 +21,7 @@ export interface SubagentRun {
 
 const INLINE_ID = "sidechain"
 
-const entryCache = new Map<string, { mtimeMs: number; entries: SessionEntry[] }>()
+const runCache = new Map<string, SubagentRun>()
 const chunkCache = new Map<string, { mtimeMs: number; parentTurn: number; chunks: RecallChunk[] }>()
 
 function mtimeOf(file: string): number | null {
@@ -31,16 +32,6 @@ function mtimeOf(file: string): number | null {
   }
 }
 
-function readEntries(file: string): SessionEntry[] {
-  const mtimeMs = mtimeOf(file)
-  if (mtimeMs === null) return []
-  const hit = entryCache.get(file)
-  if (hit?.mtimeMs === mtimeMs) return hit.entries
-  const entries = parseJsonl(readFileSync(file, "utf8"))
-  entryCache.set(file, { mtimeMs, entries })
-  return entries
-}
-
 function firstPrompt(entries: SessionEntry[]): string {
   for (const entry of entries) {
     if (entry.type !== "user" || !entry.message) continue
@@ -72,10 +63,13 @@ function fileRuns(sessionFile: string): SubagentRun[] {
     .filter((name) => name.startsWith("agent-") && name.endsWith(".jsonl"))
     .map((name) => {
       const file = path.join(dir, name)
-      const entries = readEntries(file)
+      const mtimeMs = mtimeOf(file) ?? 0
+      const known = runCache.get(file)
+      if (known?.mtimeMs === mtimeMs) return known
+      const entries = readSessionEntries(file)
       const meta = readMeta(file)
       const prompt = firstPrompt(entries)
-      return {
+      const run: SubagentRun = {
         id: name.slice("agent-".length, -".jsonl".length),
         file,
         inline: false,
@@ -83,17 +77,21 @@ function fileRuns(sessionFile: string): SubagentRun[] {
         toolUseId: meta.toolUseId ? String(meta.toolUseId) : null,
         prompt,
         started: String(entries[0]?.timestamp ?? ""),
-        mtimeMs: mtimeOf(file) ?? 0,
+        mtimeMs,
       }
+      runCache.set(file, run)
+      return run
     })
 }
 
 function inlineRuns(sessionFile: string, known: Set<string>): SubagentRun[] {
   const byAgent = new Map<string, SessionEntry[]>()
-  for (const entry of readEntries(sessionFile)) {
+  for (const entry of readSessionEntries(sessionFile)) {
     if (!entry.isSidechain) continue
     const id = entry.agentId ?? INLINE_ID
-    byAgent.set(id, [...(byAgent.get(id) ?? []), entry])
+    const group = byAgent.get(id)
+    if (group) group.push(entry)
+    else byAgent.set(id, [entry])
   }
   return [...byAgent]
     .filter(([id]) => !known.has(id))
@@ -110,7 +108,7 @@ export function subagentRuns(sessionFile: string): SubagentRun[] {
 }
 
 export function subagentEntries(run: SubagentRun): SessionEntry[] {
-  const entries = readEntries(run.file)
+  const entries = readSessionEntries(run.file)
   if (!run.inline) return entries
   return entries.filter((entry) => entry.isSidechain && (entry.agentId ?? INLINE_ID) === run.id)
 }
@@ -119,27 +117,50 @@ export function subagentMessages(run: SubagentRun): Message[] {
   return entryMessages(subagentEntries(run))
 }
 
-function launchedBy(run: SubagentRun, call: { id?: unknown; name?: unknown; prompt?: unknown }): boolean {
-  if (run.toolUseId) return call.id === run.toolUseId
-  return (call.name === "Agent" || call.name === "Task") && String(call.prompt ?? "") === run.prompt
+interface Launches {
+  byId: Map<unknown, number>
+  byPrompt: Map<string, number>
+}
+
+function launchesIn(parentMessages: Message[]): Launches {
+  const launches: Launches = { byId: new Map(), byPrompt: new Map() }
+  splitTurns(parentMessages).turns.forEach((turn, index) => {
+    for (const message of turn) {
+      if (message.role !== "assistant") continue
+      for (const block of blocks(message)) {
+        if (block.type !== "tool_use") continue
+        if (!launches.byId.has(block.id)) launches.byId.set(block.id, index + 1)
+        const prompt = String(block.input?.prompt ?? "")
+        if ((block.name === "Agent" || block.name === "Task") && !launches.byPrompt.has(prompt)) launches.byPrompt.set(prompt, index + 1)
+      }
+    }
+  })
+  return launches
 }
 
+const launchTurn = (run: SubagentRun, launches: Launches) => (run.toolUseId ? launches.byId.get(run.toolUseId) : launches.byPrompt.get(run.prompt)) ?? 0
+
 export function parentTurnOf(run: SubagentRun, parentMessages: Message[]): number {
-  const { turns } = splitTurns(parentMessages)
-  const index = turns.findIndex((turn) =>
-    turn
-      .filter((message) => message.role === "assistant")
-      .flatMap(blocks)
-      .some((block) => block.type === "tool_use" && launchedBy(run, { id: block.id, name: block.name, prompt: block.input?.prompt })),
-  )
-  return index + 1
+  return launchTurn(run, launchesIn(parentMessages))
+}
+
+const KEPT_LAUNCHES = 8
+const launchCache = new Map<Message[], Launches>()
+
+function cachedLaunches(parentMessages: Message[]): Launches {
+  const known = launchCache.get(parentMessages)
+  if (known) return known
+  const launches = launchesIn(parentMessages)
+  launchCache.set(parentMessages, launches)
+  if (launchCache.size > KEPT_LAUNCHES) launchCache.delete(launchCache.keys().next().value as Message[])
+  return launches
 }
 
 export function subagentChunks(sessionFile: string): RecallChunk[] {
-  const parent = sessionMessages(sessionFile)
+  const launches = cachedLaunches(sessionMessages(sessionFile))
   return subagentRuns(sessionFile).flatMap((run) => {
     const key = `${run.file}#${run.id}`
-    const parentTurn = parentTurnOf(run, parent)
+    const parentTurn = launchTurn(run, launches)
     const hit = chunkCache.get(key)
     if (hit && hit.mtimeMs === run.mtimeMs && hit.parentTurn === parentTurn) return hit.chunks
     const from = `subagent "${run.description}"`