@chroxify/eunoe 1.2.1 → 1.2.2

package/README.md

@@ -407,9 +407,10 @@ Recall works out of the box, but it gets noticeably better with
 [Jev](https://typesafe.ai) reordering the candidates. To turn that on, put a
 Typesafe API key in `~/.eunoe/typesafe-key` or in the `TYPESAFE_API_KEY`
 environment variable, and `eunoe status` will show the reranker as active.
-It can't slow anything down, because if Jev errors or takes longer than four
-seconds the recall simply uses the plain keyword order instead. To switch it
-off, run `eunoe settings set rerank off`.
+The cost is time: the first request of each new message waits for Jev, about
+300 ms and at most four seconds, after which the recall falls back to the
+plain keyword order. Every other request is unaffected. To switch it off, run
+`eunoe settings set rerank off`.
 
 ### Logs
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chroxify/eunoe",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Context management for Claude Code that never forgets what matters.",
   "license": "MIT",
   "repository": {

package/src/cli/commands/serve.ts

@@ -1,5 +1,6 @@
 import { readConfig } from "../../config"
 import { serve as startProxy } from "../../proxy/server"
+import { warmRecentSessions } from "../../proxy/warm"
 import { VERSION } from "../../version"
 import type { Command } from "../command"
 import { proxyUrl } from "../proxy/claude-settings"
@@ -30,6 +31,7 @@ export const serve: Command = {
     process.on("uncaughtException", keepGoing)
     process.on("unhandledRejection", keepGoing)
     await bind(config.port)
+    if (config.mode !== "off") void warmRecentSessions(config).catch(keepGoing)
     line(`${c.bold("eunoe")} ${c.dim(VERSION)}  listening on ${c.cyan(proxyUrl(config.port))}  ${c.dim(`mode ${config.mode} · Ctrl-C to stop`)}`)
   },
 }

package/src/context/recall/index.ts

@@ -50,6 +50,50 @@ function windows(lines: string[], size: number): string[][] {
   return out
 }
 
+interface ChunkedText {
+  text: string
+  head: string
+  turn: number
+  chunks: RecallChunk[]
+}
+
+const CHUNK_CACHE_TERMS = 8_000_000
+
+const chunked = new Map<string, ChunkedText>()
+let chunkedTerms = 0
+
+const termCount = (chunks: RecallChunk[]) => chunks.reduce((sum, chunk) => sum + chunk.terms.length, 0)
+
+function forget(key: string) {
+  const known = chunked.get(key)
+  if (!known) return
+  chunked.delete(key)
+  chunkedTerms -= termCount(known.chunks)
+}
+
+function chunksOf(key: string | null, text: string, head: string, turn: number, build: () => RecallChunk[]): RecallChunk[] {
+  if (key === null) return build()
+  const known = chunked.get(key)
+  if (known && known.text === text && known.head === head) {
+    chunked.delete(key)
+    chunked.set(key, known)
+    if (known.turn !== turn) {
+      known.turn = turn
+      known.chunks = known.chunks.map((chunk) => ({ ...chunk, turn }))
+    }
+    return known.chunks
+  }
+  forget(key)
+  const chunks = build()
+  chunked.set(key, { text, head, turn, chunks })
+  chunkedTerms += termCount(chunks)
+  for (const oldest of chunked.keys()) {
+    if (chunkedTerms <= CHUNK_CACHE_TERMS || oldest === key) break
+    forget(oldest)
+  }
+  return chunks
+}
+
 export function recallChunks(messages: Message[], keptIds: Map<string, string>, options: RecallOptions = {}): RecallChunk[] {
   const size = options.windowLines ?? 6
   const weight = Math.max(1, options.callWeight ?? 1)
@@ -61,8 +105,12 @@ export function recallChunks(messages: Message[], keptIds: Map<string, string>,
         const text = resultText(result)
         if (keptIds.get(call.id) === text || !text.trim()) continue
         const head = describeToolCall(call)
-        const headTerms = Array.from({ length: weight }, () => terms(head)).flat()
-        for (const window of windows(text.split("\n"), size)) chunks.push({ turn: turnIndex + 1, call: head, lines: window, terms: [...headTerms, ...terms(window.join("\n"))] })
+        const key = typeof call.id === "string" && call.id ? `${size}|${weight}|${call.id}` : null
+        const built = chunksOf(key, text, head, turnIndex + 1, () => {
+          const headTerms = Array.from({ length: weight }, () => terms(head)).flat()
+          return windows(text.split("\n"), size).map((window) => ({ turn: turnIndex + 1, call: head, lines: window, terms: [...headTerms, ...terms(window.join("\n"))] }))
+        })
+        for (const chunk of built) chunks.push(chunk)
       }
       if (!(options.narrative ?? true)) return
       const said = turn
@@ -74,34 +122,215 @@ export function recallChunks(messages: Message[], keptIds: Map<string, string>,
             .map((b) => String(b.text ?? "").trim()),
         )
         .filter(Boolean)
-      for (const window of windows(said.join("\n").split("\n"), size)) chunks.push({ turn: turnIndex + 1, call: "agent", lines: window, terms: terms(window.join("\n")) })
+        .join("\n")
+      const built = chunksOf(said ? `${size}|said|${turnIndex}|${said}` : null, said, "agent", turnIndex + 1, () =>
+        windows(said.split("\n"), size).map((window) => ({ turn: turnIndex + 1, call: "agent", lines: window, terms: terms(window.join("\n")) })),
+      )
+      for (const chunk of built) chunks.push(chunk)
     })
   return chunks
 }
 
-export function rank(query: string[], chunks: RecallChunk[], minTerms = 2) {
-  const df = new Map<string, number>()
-  for (const chunk of chunks) for (const term of new Set(chunk.terms)) df.set(term, (df.get(term) ?? 0) + 1)
-  const average = chunks.reduce((s, c) => s + c.terms.length, 0) / Math.max(1, chunks.length)
-  const wanted = [...new Set(query)].filter((t) => df.has(t))
-  return chunks
-    .map((chunk, index) => {
-      const tf = new Map<string, number>()
-      for (const term of chunk.terms) tf.set(term, (tf.get(term) ?? 0) + 1)
+interface RankedChunk {
+  index: number
+  score: number
+  matched: number
+}
+
+interface Postings {
+  chunks: RecallChunk[]
+  counts: number[]
+}
+
+interface CorpusIndex {
+  members: Set<RecallChunk>
+  postings: Map<string, Postings>
+}
+
+const INDEXED_FROM = 2_000
+const KEPT_INDEXES = 6
+const SAMPLED = 32
+
+const indexes: CorpusIndex[] = []
+
+function addToIndex(index: CorpusIndex, chunk: RecallChunk) {
+  index.members.add(chunk)
+  const counts = new Map<string, number>()
+  for (const term of chunk.terms) counts.set(term, (counts.get(term) ?? 0) + 1)
+  for (const [term, count] of counts) {
+    const postings = index.postings.get(term)
+    if (postings) {
+      postings.chunks.push(chunk)
+      postings.counts.push(count)
+    } else index.postings.set(term, { chunks: [chunk], counts: [count] })
+  }
+}
+
+function overlap(index: CorpusIndex, chunks: RecallChunk[]): number {
+  const step = Math.max(1, Math.floor(chunks.length / SAMPLED))
+  let found = 0
+  let sampled = 0
+  for (let i = 0; i < chunks.length; i += step) {
+    sampled += 1
+    if (index.members.has(chunks[i])) found += 1
+  }
+  return found / Math.max(1, sampled)
+}
+
+function indexFor(chunks: RecallChunk[]): CorpusIndex {
+  let best: CorpusIndex | null = null
+  let bestOverlap = 0.5
+  for (const index of indexes) {
+    const shared = overlap(index, chunks)
+    if (shared >= bestOverlap) {
+      best = index
+      bestOverlap = shared
+    }
+  }
+  let present = 0
+  if (best) for (const chunk of chunks) if (best.members.has(chunk)) present += 1
+  if (!best || best.members.size - present > chunks.length / 2) {
+    if (best) indexes.splice(indexes.indexOf(best), 1)
+    best = { members: new Set(), postings: new Map() }
+    present = 0
+  } else indexes.splice(indexes.indexOf(best), 1)
+  indexes.push(best)
+  if (indexes.length > KEPT_INDEXES) indexes.shift()
+  if (present < chunks.length) for (const chunk of chunks) if (!best.members.has(chunk)) addToIndex(best, chunk)
+  return best
+}
+
+let warming: { chunks: RecallChunk[]; index: CorpusIndex; next: number } | null = null
+
+export function warmIndex(chunks: RecallChunk[], until: number): boolean {
+  if (chunks.length < INDEXED_FROM) return true
+  if (warming?.chunks !== chunks) {
+    const index: CorpusIndex = { members: new Set(), postings: new Map() }
+    indexes.push(index)
+    if (indexes.length > KEPT_INDEXES) indexes.shift()
+    warming = { chunks, index, next: 0 }
+  }
+  const { index } = warming
+  while (warming.next < chunks.length) {
+    const chunk = chunks[warming.next]
+    warming.next += 1
+    if (!index.members.has(chunk)) addToIndex(index, chunk)
+    if (warming.next < chunks.length && performance.now() > until) return false
+  }
+  warming = null
+  return true
+}
+
+function indexedAll(queries: string[][], chunks: RecallChunk[], minTerms: number): RankedChunk[][] | null {
+  const position = new Map<RecallChunk, number>()
+  let total = 0
+  chunks.forEach((chunk, i) => {
+    position.set(chunk, i)
+    total += chunk.terms.length
+  })
+  if (position.size !== chunks.length) return null
+  const index = indexFor(chunks)
+  const average = total / Math.max(1, chunks.length)
+  const hitsByTerm = new Map<string, Array<[number, number]>>()
+  const hitsOf = (term: string) => {
+    const known = hitsByTerm.get(term)
+    if (known) return known
+    const hits: Array<[number, number]> = []
+    const postings = index.postings.get(term)
+    if (postings)
+      postings.chunks.forEach((chunk, k) => {
+        const at = position.get(chunk)
+        if (at !== undefined) hits.push([at, postings.counts[k]])
+      })
+    hitsByTerm.set(term, hits)
+    return hits
+  }
+  return queries.map((query) => {
+    const lists = [...new Set(query)].map(hitsOf)
+    const needed = Math.max(1, Math.min(minTerms, lists.filter((hits) => hits.length > 0).length))
+    const found = new Map<number, Array<[number, number]>>()
+    lists.forEach((hits, k) => {
+      for (const [at, f] of hits) {
+        const mine = found.get(at)
+        if (mine) mine.push([k, f])
+        else found.set(at, [[k, f]])
+      }
+    })
+    const scored: RankedChunk[] = []
+    for (const at of [...found.keys()].sort((a, b) => a - b)) {
+      const mine = found.get(at) as Array<[number, number]>
+      if (mine.length < needed) continue
+      const length = chunks[at].terms.length
       let score = 0
-      let matched = 0
-      for (const term of wanted) {
-        const f = tf.get(term) ?? 0
-        if (!f) continue
-        matched += 1
-        const n = df.get(term) ?? 0
+      for (const [k, f] of mine) {
+        const n = lists[k].length
         const idf = Math.log(1 + (chunks.length - n + 0.5) / (n + 0.5))
-        score += (idf * (f * (BM25_K1 + 1))) / (f + BM25_K1 * (1 - BM25_B + (BM25_B * chunk.terms.length) / average))
+        score += (idf * (f * (BM25_K1 + 1))) / (f + BM25_K1 * (1 - BM25_B + (BM25_B * length) / average))
       }
-      return { index, score, matched }
+      if (score > 0) scored.push({ index: at, score, matched: mine.length })
+    }
+    return scored.sort((a, b) => b.score - a.score)
+  })
+}
+
+function rankAll(queries: string[][], chunks: RecallChunk[], minTerms = 2): RankedChunk[][] {
+  return (chunks.length >= INDEXED_FROM && indexedAll(queries, chunks, minTerms)) || scanAll(queries, chunks, minTerms)
+}
+
+function scanAll(queries: string[][], chunks: RecallChunk[], minTerms: number): RankedChunk[][] {
+  const ids = new Map<string, number>()
+  for (const query of queries) for (const term of query) if (!ids.has(term)) ids.set(term, ids.size)
+  const df = new Int32Array(ids.size)
+  const counts = new Int32Array(ids.size)
+  const touched: number[] = []
+  const hits: Array<{ index: number; found: Array<[number, number]> }> = []
+  let total = 0
+  chunks.forEach((chunk, index) => {
+    total += chunk.terms.length
+    touched.length = 0
+    for (const term of chunk.terms) {
+      const id = ids.get(term)
+      if (id === undefined) continue
+      if (counts[id] === 0) touched.push(id)
+      counts[id] += 1
+    }
+    if (touched.length === 0) return
+    const found = touched.map((id): [number, number] => {
+      const f = counts[id]
+      counts[id] = 0
+      df[id] += 1
+      return [id, f]
     })
-    .filter((r) => r.matched >= Math.min(minTerms, wanted.length) && r.score > 0)
-    .sort((a, b) => b.score - a.score)
+    hits.push({ index, found })
+  })
+  const average = total / Math.max(1, chunks.length)
+  return queries.map((query) => {
+    const asked = [...new Set(query)].map((term) => ids.get(term) ?? -1)
+    const position = new Int32Array(ids.size).fill(-1)
+    asked.forEach((id, i) => {
+      position[id] = i
+    })
+    const needed = Math.max(1, Math.min(minTerms, asked.filter((id) => df[id] > 0).length))
+    const scored: RankedChunk[] = []
+    for (const { index, found } of hits) {
+      const mine = found.filter(([id]) => position[id] >= 0)
+      if (mine.length < needed) continue
+      if (mine.length > 1) mine.sort((a, b) => position[a[0]] - position[b[0]])
+      const length = chunks[index].terms.length
+      let score = 0
+      for (const [id, f] of mine) {
+        const n = df[id]
+        const idf = Math.log(1 + (chunks.length - n + 0.5) / (n + 0.5))
+        score += (idf * (f * (BM25_K1 + 1))) / (f + BM25_K1 * (1 - BM25_B + (BM25_B * length) / average))
+      }
+      if (score > 0) scored.push({ index, score, matched: mine.length })
+    }
+    return scored.sort((a, b) => b.score - a.score)
+  })
+}
+
+export function rank(query: string[], chunks: RecallChunk[], minTerms = 2): RankedChunk[] {
+  return rankAll([query], chunks, minTerms)[0]
 }
 
 function excerpt(chunk: RecallChunk, query: Set<string>, salient: boolean): string[] {
@@ -136,27 +365,23 @@ function merged(hits: Array<{ query: string[]; indices: number[] }>): RecallPick
   return [...picked.entries()].map(([index, query]) => ({ index, query }))
 }
 
-const ranked = (query: string[], chunks: RecallChunk[], options: RecallOptions, width: number) =>
-  rank(query, chunks, options.minTerms)
-    .slice(0, width)
-    .map((hit) => hit.index)
+function rankedLines(prompt: string, chunks: RecallChunk[], options: RecallOptions, width: number) {
+  const lines = queriesOf(prompt)
+  const queries = lines.map(terms)
+  const results = rankAll(queries, chunks, options.minTerms)
+  return lines.map((line, i) => ({ line, query: queries[i], indices: results[i].slice(0, width).map((hit) => hit.index) }))
+}
 
 function pickRecall(prompt: string, chunks: RecallChunk[], options: RecallOptions): RecallPick[] {
-  return merged(
-    queriesOf(prompt).map((line) => {
-      const query = terms(line)
-      return { query, indices: ranked(query, chunks, options, options.perQuery ?? 12) }
-    }),
-  )
+  return merged(rankedLines(prompt, chunks, options, options.perQuery ?? 12))
 }
 
 export const identityReranker: Reranker = async (_query, _chunks, candidates) => candidates
 
 export async function pickRecallWith(prompt: string, chunks: RecallChunk[], rerank: Reranker, options: RecallOptions = {}): Promise<RecallPick[]> {
   const hits: Array<{ query: string[]; indices: number[] }> = []
-  for (const line of queriesOf(prompt)) {
-    const query = terms(line)
-    const reordered = await rerank(line, chunks, ranked(query, chunks, options, options.candidates ?? 30))
+  for (const { line, query, indices } of rankedLines(prompt, chunks, options, options.candidates ?? 30)) {
+    const reordered = await rerank(line, chunks, indices)
     hits.push({ query, indices: reordered.slice(0, options.perQuery ?? 12) })
   }
   return merged(hits)

package/src/proxy/compaction.ts

@@ -1,7 +1,7 @@
 import type { Config } from "../config"
 import type { Body, Message } from "../context/content"
 import { type CompactOptions, capTurns, clearToolResults, compactMessages, countToolResults } from "../context/fold/strategies"
-import { splitTurns, turnFingerprint } from "../context/fold/turns"
+import { type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "../context/fold/turns"
 import { clearedOutput } from "../context/prompts"
 import { DEFAULT_RATIO, type Estimator, estimator, targetSize } from "./estimate"
 import { resetCut, type ThreadState } from "./state"
@@ -19,6 +19,24 @@ export interface CompactInput {
   reduce?: CompactOptions["reduce"]
 }
 
+const FOLDED_TURNS = 4096
+
+const folded = new Map<string, Message[]>()
+
+function reduceRemembered(turn: Message[], options: ReduceOptions): Message[] {
+  const key = `${options.evidence ? 1 : 0}:${Bun.hash(JSON.stringify(turn))}`
+  const known = folded.get(key)
+  if (known) {
+    folded.delete(key)
+    folded.set(key, known)
+    return known
+  }
+  const reduced = reduceTurn(turn, options)
+  folded.set(key, reduced)
+  if (folded.size > FOLDED_TURNS) folded.delete(folded.keys().next().value as string)
+  return reduced
+}
+
 export interface CompactResult {
   messages: Message[]
   stateChanged: boolean
@@ -89,7 +107,7 @@ export function compact({ body, config, state, window, guide, transcriptDir, may
 
   const configuredKeep = config.keepTurns === "all" ? Number.MAX_SAFE_INTEGER : config.keepTurns
   const ratio = state.ratio ?? DEFAULT_RATIO
-  const options = { guide, omittedBefore, evidence: config.eval?.evidence ?? true, reduce, capChars: config.turnCap === "off" ? undefined : config.turnCap / ratio }
+  const options = { guide, omittedBefore, evidence: config.eval?.evidence ?? true, reduce: reduce ?? reduceRemembered, capChars: config.turnCap === "off" ? undefined : config.turnCap / ratio }
   const liveStart = (list: Message[]) =>
     list.length -
     splitTurns(list)

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}"`