@chroxify/eunoe 1.2.1 → 1.3.0

package/src/proxy/server.ts

@@ -1,17 +1,16 @@
 import path from "node:path"
 import { type Config, claudeConfigDirs, readConfig, settingsFor } from "../config"
-import { type Body, wellFormed } from "../context/content"
+import type { Body } from "../context/content"
+import { contextFingerprint } from "../core/fingerprint"
+import { claudeCodeSessionId, createForwarder, type Prepared } from "../core/forward"
 import { findSessionFile } from "../transcript/locate"
 import { prepareTranscript } from "../transcript/search"
 import { VERSION } from "../version"
 import { applyCanonical } from "./canonical"
-import { sizeOf } from "./estimate"
-import { type ContextFingerprint, contextFingerprint } from "./fingerprint"
 import { logRequest } from "./log"
 import { rewriteAsync } from "./rewrite"
 import { recordSession } from "./sessions"
-import { readState, saveState } from "./state"
-import { inputTokens, watchUsage } from "./usage"
+import { fileStore } from "./state"
 import { resolveWindow } from "./window"
 
 export interface Health {
@@ -22,48 +21,14 @@ export interface Health {
   startedAt?: number
 }
 
-interface Outgoing {
-  note: Record<string, unknown>
-  threadKey: string | null
-  bodyText: string | undefined
-  sentSize: number
-  givenSize: number
-  fixedSize: number
-  sent: (ContextFingerprint & { session: string | null }) | null
-}
-
 export const HEALTH_PATH = "/_eunoe/health"
 
 const startedAt = Date.now()
 
 const trustedHeader = (request: Request, config: Config, name: string) => (config.eval?.trustHeaders === true ? request.headers.get(`x-eunoe-${name}`) : null)
 
-const clipped = (error: string) => error.slice(0, 500)
-
-function sessionIdOf(headers: Headers, body: Body): string | null {
-  const header = headers.get("x-claude-code-session-id")
-  if (header) return header
-  try {
-    return JSON.parse(body.metadata?.user_id ?? "{}").session_id ?? null
-  } catch {
-    return null
-  }
-}
-
-function forwardableHeaders(headers: Headers) {
-  const out = new Headers(headers)
-  out.delete("content-encoding")
-  out.delete("content-length")
-  return out
-}
-
-function overflowTokens(errorText: string): number | null {
-  const tokens = Number(errorText.match(/prompt is too long[^0-9]*(\d+)\s*tokens?\s*>\s*(\d+)/i)?.[1])
-  return Number.isFinite(tokens) && tokens > 0 ? tokens : null
-}
-
-async function prepare(request: Request, body: Body, base: Config, isCountTokens: boolean) {
-  const sessionId = sessionIdOf(request.headers, body)
+async function prepareSession(request: Request, body: Body, base: Config, isCountTokens: boolean) {
+  const sessionId = claudeCodeSessionId(request.headers, body)
   const config = settingsFor(base, sessionId)
   const trusted = config.eval?.trustHeaders === true
   const transcriptOverride = trustedHeader(request, config, "transcript")
@@ -87,109 +52,31 @@ async function prepare(request: Request, body: Body, base: Config, isCountTokens
   })
 }
 
-function saveRatio(threadKey: string, ratio: (previous: number | undefined) => number) {
-  const state = readState(threadKey)
-  state.ratio = ratio(state.ratio)
-  saveState(threadKey, state)
+async function prepare(request: Request, given: Body, config: Config, mayCompact: boolean): Promise<Prepared> {
+  const canonicalFile = trustedHeader(request, config, "canonical")
+  const canonical = canonicalFile ? applyCanonical(given, canonicalFile) : null
+  const result = await prepareSession(request, canonical?.body ?? given, config, !mayCompact)
+  const context = config.eval ? { context: { session: claudeCodeSessionId(request.headers, given), ...contextFingerprint(result.body), given: contextFingerprint(given) } } : {}
+  return { ...result, note: { ...result.note, ...(canonical && { canonical: canonical.status }), ...context } }
 }
 
-export async function handle(request: Request): Promise<Response> {
-  try {
-    return await route(request)
-  } catch (error) {
-    logRequest({ path: new URL(request.url).pathname, status: 502, action: "upstream-unreachable", error: clipped(String(error)) })
-    return Response.json({ type: "error", error: { type: "api_error", message: `eunoe could not reach the API: ${String(error)}` } }, { status: 502 })
-  }
+interface Timing {
+  countTokensTimeoutMs: number
 }
 
-async function route(request: Request): Promise<Response> {
+export function handle(request: Request, timing: Timing = { countTokensTimeoutMs: 10_000 }): Promise<Response> {
   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)
-  const headers = new Headers(request.headers)
-  for (const name of ["host", "content-length", "accept-encoding"]) headers.delete(name)
-
-  let givenText: string | undefined
-  if (request.method !== "GET" && request.method !== "HEAD") givenText = await request.text()
-  const isMessages = request.method === "POST" && url.pathname.startsWith("/v1/messages")
-  const isCountTokens = url.pathname.includes("count_tokens")
-
-  const build = async (): Promise<Outgoing> => {
-    const passthrough: Outgoing = { note: { action: "pass" }, threadKey: null, bodyText: givenText, sentSize: 0, givenSize: 0, fixedSize: 0, sent: null }
-    if (!givenText || !isMessages) return passthrough
-    try {
-      const given = JSON.parse(givenText) as Body
-      const canonicalFile = trustedHeader(request, config, "canonical")
-      const canonical = canonicalFile ? applyCanonical(given, canonicalFile) : null
-      const result = await prepare(request, canonical?.body ?? given, config, isCountTokens)
-      const sentSize = sizeOf(result.body)
-      return {
-        note: canonical ? { ...result.note, canonical: canonical.status } : result.note,
-        threadKey: result.threadKey,
-        bodyText: result.body !== given ? JSON.stringify(result.body, wellFormed) : givenText,
-        sentSize,
-        givenSize: result.body === given ? sentSize : sizeOf(given),
-        fixedSize: sizeOf({ ...result.body, messages: [] }),
-        sent: config.eval ? { session: sessionIdOf(request.headers, given), ...contextFingerprint(result.body), given: contextFingerprint(given) } : null,
-      }
-    } catch (error) {
-      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 })
-
-  let out = await build()
-  let upstream = await send(out.bodyText)
-  const errorResponse = (text: string) => new Response(text, { status: upstream.status, statusText: upstream.statusText, headers: forwardableHeaders(upstream.headers) })
-
-  if (upstream.status >= 400 && out.note.action !== "pass") {
-    const errorText = await upstream.text()
-    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) })
-      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) })
-    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) })
-      return errorResponse(retryError)
-    }
-  }
-
-  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 }) })
-    return response
-  }
-
-  return watchUsage(response, (usage) => {
-    const input = inputTokens(usage)
-    logRequest({
-      path: url.pathname,
-      status: upstream.status,
-      thread: threadKey,
-      ...note,
-      input,
-      cacheRead: usage.cache_read_input_tokens ?? 0,
-      cacheWrite: usage.cache_creation_input_tokens ?? 0,
-      uncached: usage.input_tokens ?? 0,
-      charsIn: givenSize,
-      charsOut: sentSize,
-      charsFixed: fixedSize,
-      ...(sent && { context: sent }),
-    })
-    if (threadKey && input > 0 && sentSize > 0) saveRatio(threadKey, () => input / sentSize)
+  if (new URL(request.url).pathname === HEALTH_PATH) return Promise.resolve(Response.json({ ok: true, version: VERSION, mode: config.mode, pid: process.pid, startedAt } satisfies Health))
+  const forward = createForwarder({
+    store: fileStore,
+    upstream: config.upstream,
+    prepare: (incoming, body, mayCompact) => prepare(incoming, body, config, mayCompact),
+    record: logRequest,
+    countTokensTimeoutMs: timing.countTokensTimeoutMs,
   })
+  return forward(request)
 }
 
 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/sessions.ts

@@ -1,6 +1,6 @@
 import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs"
-import type { Mode } from "../config"
 import { EUNOE_DIR, paths } from "../config/paths"
+import type { Mode } from "../core/config"
 
 interface SeenSession {
   lastSeen: string

package/src/proxy/sources.ts

@@ -0,0 +1,35 @@
+import { type Config, claudeConfigDirs } from "../config"
+import type { Message } from "../context/content"
+import { searchGuide } from "../context/prompts"
+import type { ThreadSources } from "../core/rewrite"
+import { findSessionByPrefix } from "../transcript/locate"
+import { sessionMessages } from "../transcript/messages"
+import type { TranscriptRef } from "../transcript/search"
+import { subagentChunks } from "../transcript/subagents"
+import { titleOf } from "./sessions"
+
+function readSession(file: string): Message[] {
+  try {
+    return sessionMessages(file)
+  } catch {
+    return []
+  }
+}
+
+export function sessionSources(transcript: TranscriptRef | null, config: Config, sessionId: string | null): ThreadSources {
+  const handoffs = {
+    findHandoff: (id: string) => {
+      const file = findSessionByPrefix(id, claudeConfigDirs(config), sessionId ?? undefined)
+      return file ? { label: titleOf(file) ?? id, source: file } : null
+    },
+    readHandoff: readSession,
+  }
+  if (!transcript) return handoffs
+  return {
+    ...handoffs,
+    guide: searchGuide(transcript),
+    transcriptDir: transcript.mode !== "jsonl" ? transcript.dir : null,
+    readHistory: () => sessionMessages(transcript.jsonl),
+    listSubagentChunks: () => subagentChunks(transcript.jsonl),
+  }
+}

package/src/proxy/state.ts

@@ -1,29 +1,41 @@
-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"
+import type { ThreadState, ThreadStore } from "../core/state"
 
-export interface Handoff {
-  label: string
-  source: string
-  text: string
+function stateFile(key: string) {
+  return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
 }
 
-export interface ThreadState {
-  handoffs?: Record<string, Handoff | null>
-  cut?: string
-  keep?: number
-  cleared?: number
-  ratio?: number
-  recalls?: Record<string, string>
+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 stateFile(key: string) {
-  return path.join(paths.threads, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`)
+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,11 +43,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) {
-  delete state.cut
-  delete state.keep
-  delete state.cleared
-}
+export const fileStore: ThreadStore = { read: readState, save: saveState }

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/proxy/window.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { EUNOE_DIR, paths } from "../config/paths"
+import { createWindowLookup } from "../core/window"
 
 function readCache(): Map<string, number> {
   try {
@@ -9,40 +10,9 @@ function readCache(): Map<string, number> {
   }
 }
 
-const windows = readCache()
-const lookups = new Map<string, Promise<number | null>>()
-
-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
-}
-
-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)
+function saveCache(windows: Map<string, number>) {
   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 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
-}
+export const resolveWindow = createWindowLookup({ known: readCache(), onLearn: saveCache })

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/format.ts

@@ -1,9 +1,8 @@
 import { clip } from "../context/content"
 import type { ToolPart, TranscriptFormat, Turn } from "./parse"
-import type { SubagentRun } from "./subagents"
 
 export interface SubagentRecord {
-  run: SubagentRun
+  run: { description: string }
   turns: Turn[]
   parentTurn: number
   file: string

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))