@chroxify/eunoe 1.2.0 → 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.0",
+  "version": "1.2.2",
   "description": "Context management for Claude Code that never forgets what matters.",
   "license": "MIT",
   "repository": {

package/src/cli/commands/replay.ts

@@ -200,24 +200,24 @@ export const replay: Command = {
         ["Cost", `${c.green(c.bold(`${fewer(sum.plainCost, sum.eunoeCost)} cheaper`))}  ${c.dim("cache reads at 0.1×, writes at 1.25×")}`],
         ["Folds", c.bold(sum.folds.toLocaleString())],
         ["Folds dropped", `${c.bold(sum.dropped.toLocaleString())} ${c.dim("folded turns removed entirely to fit the window")}`],
-        ["Peak context", `plain ${tokens(sum.peakPlain)}  ${c.dim("→")}  eunoe ${c.bold(tokens(sum.peakEunoe))}`],
+        ["Peak context", `plain ${c.green(c.bold(tokens(sum.peakPlain)))}  ${c.dim("→")}  eunoe ${c.bold(tokens(sum.peakEunoe))}  ${c.dim("· the longest conversation whole, every compaction undone, against the most eunoe sent")}`],
       ],
       4,
     )
     const saved = [...compared]
       .filter((r) => r.nativeCompactions > 0)
-      .sort((a, b) => b.discarded - a.discarded)
+      .sort((a, b) => b.peakPlain - a.peakPlain)
       .slice(0, TOP_SESSIONS)
     if (saved.length > 0) {
       line()
-      line(`  ${c.dim("Sessions Claude Code would have compacted, by history it would have lost")}`)
+      line(`  ${c.dim("Longest sessions Claude Code would have compacted, by their whole history")}`)
       table(
         saved.map((r) => [
           c.cyan(shortId(r.id)),
           (r.title ?? (r.cwd ? tilde(r.cwd) : "")).slice(0, 40),
-          c.bold(c.green(`${plural(r.nativeCompactions, "compaction")} avoided`)),
-          `${tokens(r.discarded)} tokens kept`,
-          c.dim(`${plural(r.folds, "fold")} · ${tokens(r.plainTokens)} → ${tokens(r.eunoeTokens)} tokens`),
+          `${c.green(c.bold(tokens(r.peakPlain)))} ${c.dim("of history")}`,
+          c.bold(`${plural(r.nativeCompactions, "compaction")} avoided`),
+          c.dim(`eunoe peak ${tokens(r.peakEunoe)} · ${plural(r.folds, "fold")}`),
         ]),
       )
     }

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/cli/commands/stats.ts

@@ -2,7 +2,9 @@ import { claudeConfigDirs, readConfig } from "../../config"
 import type { Command } from "../command"
 import { cleanupDays } from "../proxy/claude-settings"
 import { type RequestRecord, recentRequests } from "../proxy/inspect"
-import { savedTokens, totals } from "../proxy/stats"
+import { nativeCompactions, savedTokens, type ThreadPeak, threadPeaks, totals } from "../proxy/stats"
+import { REPLAY_NATIVE_COMPACT_AT } from "../replay"
+import { shortId } from "../sessions"
 import { c, fail, line, percent, plural, table, tokens, wrap } from "../terminal/ui"
 import { costOf, ratesOf, readUsage, type UsageEntry, usageFiles } from "../usage"
 
@@ -20,6 +22,7 @@ const MATCH_WITHIN = 10 * 60_000
 const NOTE_WIDTH = 110
 const DEFAULT_DAYS = 7
 const DEFAULT_WEEKS = 8
+const LONGEST = 5
 
 const midnight = (ms: number) => new Date(new Date(ms).toDateString()).getTime()
 const addDays = (ms: number, days: number) => {
@@ -123,7 +126,13 @@ function notSentCell(logged: RequestRecord[]) {
   const sum = totals(logged)
   if (sum.requests === 0) return c.dim("–")
   if (sum.saved <= 0) return c.dim("±0")
-  return `${tokens(sum.saved)} ${c.dim(plural(sum.folds, "fold"))}`
+  return `${c.green(c.bold(tokens(sum.saved)))} ${c.dim(plural(sum.folds, "fold"))}`
+}
+
+function avoidedCell(logged: RequestRecord[], avoided: Set<RequestRecord>) {
+  if (!logged.some((record) => record.input)) return c.dim("–")
+  const count = logged.filter((record) => avoided.has(record)).length
+  return count > 0 ? c.green(c.bold(count.toLocaleString())) : c.dim("0")
 }
 
 function costSavedCell(logged: RequestRecord[], matched: Matched) {
@@ -131,13 +140,13 @@ function costSavedCell(logged: RequestRecord[], matched: Matched) {
   if (sum.priced === 0) return c.dim("–")
   if (Math.abs(sum.saved) < 0.005) return c.dim("±0")
   const share = c.dim(percent(sum.saved / (sum.actual + sum.saved)))
-  return sum.saved > 0 ? `${c.green(c.bold(dollars(sum.saved)))} ${share}` : `${c.yellow(`−${dollars(-sum.saved)}`)} ${share}`
+  return sum.saved > 0 ? `${dollars(sum.saved)} ${share}` : `${c.yellow(`−${dollars(-sum.saved)}`)} ${share}`
 }
 
-function row(label: string, usage: UsageEntry[], logged: RequestRecord[], matched: Matched, bold = false) {
+function row(label: string, usage: UsageEntry[], logged: RequestRecord[], matched: Matched, avoided: Set<RequestRecord>, bold = false) {
   const sum = summarize(usage)
   const strong = (text: string) => (bold ? c.bold(text) : text)
-  const eunoe = [notSentCell(logged), costSavedCell(logged, matched)]
+  const eunoe = [avoidedCell(logged, avoided), notSentCell(logged), costSavedCell(logged, matched)]
   if (sum.requests === 0) return [strong(label), c.dim("–"), "", "", "", "", "", ...eunoe]
   return [strong(label), strong(sum.requests.toLocaleString()), tokens(sum.input), tokens(sum.output), tokens(sum.cacheWrite), tokens(sum.cacheRead), strong(`${dollars(sum.cost)}${sum.unpriced ? c.dim("*") : ""}`), ...eunoe]
 }
@@ -161,6 +170,15 @@ function byModel(usage: UsageEntry[]) {
     ])
 }
 
+function longestRow(peak: ThreadPeak) {
+  return [
+    c.cyan(shortId(peak.session)),
+    `${c.green(c.bold(tokens(peak.plain)))} ${c.dim("of history")}`,
+    peak.compactions > 0 ? `${c.bold(plural(peak.compactions, "compaction"))} avoided` : c.dim("no compaction needed"),
+    c.dim(`eunoe sent ${tokens(peak.sent)}${peak.turns ? ` · ${plural(peak.turns, "turn")}` : ""} · ${dayLabel(Date.parse(peak.lastSeen))}`),
+  ]
+}
+
 const countArg = (args: string[], flag: string, fallback: number) => {
   const at = args.indexOf(flag)
   if (at === -1) return fallback
@@ -175,9 +193,10 @@ export const stats: Command = {
   details: [
     "Reads the usage the API returned for every request in your Claude Code",
     "sessions, subagents included, counting each response once. Cost is at",
-    "API list prices. The eunoe columns come from its request log: the input",
-    "tokens it kept out of the requests it handled, and what that saved at",
-    "cache-read prices once the cache writes its folds caused are paid for.",
+    "API list prices. The eunoe columns come from its request log: the",
+    "compactions Claude Code would have run on the conversations it handled,",
+    "the input tokens it kept out, and what that saved at cache-read prices",
+    "once the cache writes its folds caused are paid for.",
   ],
   options: [
     ["--days <n>", `Days to show (default ${DEFAULT_DAYS})`],
@@ -192,7 +211,9 @@ export const stats: Command = {
     const since = list[0].start
     const configDirs = claudeConfigDirs(readConfig())
     const usage = readUsage(usageFiles(configDirs, since), since)
-    const logged = recentRequests(Number.POSITIVE_INFINITY).filter((record) => Date.parse(record.ts) >= since)
+    const all = recentRequests(Number.POSITIVE_INFINITY)
+    const avoided = nativeCompactions(all)
+    const logged = all.filter((record) => Date.parse(record.ts) >= since)
     for (const entry of usage) place(list, entry.at, (bucket) => bucket.usage.push(entry))
     const matched = matchLogged(usage, logged)
     for (const record of logged) place(list, Date.parse(record.ts), (bucket) => bucket.logged.push(record))
@@ -201,11 +222,20 @@ export const stats: Command = {
     line(`  ${c.bold("eunoe stats")}  ${c.dim(`the last ${count} ${weekly ? "weeks" : "days"} of Claude Code, from your session files`)}`)
     line()
     table([
-      [weekly ? "Week" : "Day", "Requests", "Input", "Output", "Cache write", "Cache read", "API cost", "Not sent by eunoe", "Cost saved"].map((title) => c.dim(title)),
-      ...list.map((bucket) => row(bucket.label, bucket.usage, bucket.logged, matched)),
-      row("Total", usage, logged, matched, true),
+      [weekly ? "Week" : "Day", "Requests", "Input", "Output", "Cache write", "Cache read", "API cost", "Compactions avoided", "Tokens saved", "Cost saved"].map((title) => c.dim(title)),
+      ...list.map((bucket) => row(bucket.label, bucket.usage, bucket.logged, matched, avoided)),
+      row("Total", usage, logged, matched, avoided, true),
     ])
 
+    const longest = threadPeaks(all, avoided)
+      .filter((peak) => Date.parse(peak.lastSeen) >= since)
+      .slice(0, LONGEST)
+    if (longest.length > 0) {
+      line()
+      line(`  ${c.dim("Longest conversations, by the history Claude Code would have had to carry")}`)
+      table(longest.map(longestRow))
+    }
+
     const models = byModel(usage)
     if (models.length > 0) {
       line()
@@ -216,7 +246,8 @@ export const stats: Command = {
     const handled = savings(logged, matched)
     const notes: Array<[label: string, text: string]> = [
       ["API cost", "At list prices, including cache writes and fast mode."],
-      ["Not sent", "Input eunoe kept out, mostly history Claude Code would have read from cache."],
+      ["Compactions", `Times Claude Code would have compacted a conversation eunoe handled, at ${Math.round(REPLAY_NATIVE_COMPACT_AT * 100)}% of its window. eunoe kept every turn instead.`],
+      ["Tokens saved", "Input eunoe kept out, mostly history Claude Code would have read from cache."],
       ["Cost saved", "Those tokens at cache-read prices, minus what each fold cost to rewrite."],
       ...(handled.priced < handled.handled ? [["Not priced", `${(handled.handled - handled.priced).toLocaleString()} of ${handled.handled.toLocaleString()} eunoe requests: ${leftOut(handled)}.`] as [string, string]] : []),
       ...(summarize(usage).unpriced ? [["* No price", "Some models have no known price, so their tokens count but their cost doesn't."] as [string, string]] : []),

package/src/cli/proxy/stats.ts

@@ -1,3 +1,5 @@
+import { DEFAULT_RATIO } from "../../proxy/estimate"
+import { NATIVE_SUMMARY_CHARS, REPLAY_NATIVE_COMPACT_AT } from "../replay"
 import type { RequestRecord } from "./inspect"
 
 export interface SessionStats {
@@ -84,3 +86,49 @@ export function savedShare(context: number, plain: number | null): number | null
   if (!plain) return null
   return plain > context ? 1 - context / plain : 0
 }
+
+export function nativeCompactions(records: RequestRecord[]): Set<RequestRecord> {
+  const summary = Math.round(NATIVE_SUMMARY_CHARS * DEFAULT_RATIO)
+  const offsets = new Map<string, number>()
+  const compacted = new Set<RequestRecord>()
+  for (const record of records) {
+    const plain = scaled(record, record.charsIn)
+    const window = typeof record.window === "number" ? record.window : 0
+    if (typeof record.thread !== "string" || plain === null || window <= 0) continue
+    if (plain - (offsets.get(record.thread) ?? 0) <= REPLAY_NATIVE_COMPACT_AT * window) continue
+    compacted.add(record)
+    offsets.set(record.thread, plain - (scaled(record, record.charsFixed) ?? 0) - summary)
+  }
+  return compacted
+}
+
+export interface ThreadPeak {
+  thread: string
+  session: string
+  plain: number
+  sent: number
+  turns: number | null
+  compactions: number
+  lastSeen: string
+}
+
+export function threadPeaks(records: RequestRecord[], compacted: Set<RequestRecord>): ThreadPeak[] {
+  const peaks = new Map<string, ThreadPeak>()
+  for (const record of records) {
+    const plain = scaled(record, record.charsIn)
+    const session = sessionOf(record)
+    if (typeof record.thread !== "string" || !session || plain === null) continue
+    const previous = peaks.get(record.thread)
+    const higher = !previous || plain >= previous.plain
+    peaks.set(record.thread, {
+      thread: record.thread,
+      session,
+      plain: higher ? plain : previous.plain,
+      sent: higher ? inputOf(record) : previous.sent,
+      turns: record.turns ?? previous?.turns ?? null,
+      compactions: (previous?.compactions ?? 0) + (compacted.has(record) ? 1 : 0),
+      lastSeen: record.ts,
+    })
+  }
+  return [...peaks.values()].sort((a, b) => b.plain - a.plain)
+}

package/src/cli/replay/index.ts

@@ -43,7 +43,7 @@ export interface ReplayFailure {
 
 export const REPLAY_NATIVE_COMPACT_AT = 0.92
 
-const NATIVE_SUMMARY_CHARS = 30_000
+export const NATIVE_SUMMARY_CHARS = 30_000
 const CACHE_READ_WEIGHT = 0.1
 const CACHE_WRITE_WEIGHT = 1.25
 
@@ -85,7 +85,7 @@ export function replaySession(messages: Message[], { config, window, fixedTokens
 
   const state: ThreadState = {}
   const eunoe = { sent: [] as Message[], sum: 0, count: 0, upTo: 0, recall: 0, compactedTurn: -2, previous: 0 }
-  const plain = { sum: 0, count: 0, since: 0, previous: 0 }
+  const plain = { sum: 0, count: 0, since: 0, previous: 0, whole: 0, wholeCount: 0 }
 
   const sendEunoe = (i: number) => {
     const turn = turnAt[i - 1]
@@ -119,10 +119,12 @@ export function replaySession(messages: Message[], { config, window, fixedTokens
     for (; plain.since < i; plain.since += 1) {
       plain.sum += sizes[plain.since]
       plain.count += 1
+      plain.whole += sizes[plain.since]
+      plain.wholeCount += 1
     }
+    out.peakPlain = Math.max(out.peakPlain, tokens(fixedChars + listChars(plain.whole, plain.wholeCount)))
     let chars = fixedChars + listChars(plain.sum, plain.count)
     let cacheable = plain.previous
-    out.peakPlain = Math.max(out.peakPlain, tokens(chars))
     if (tokens(chars) > REPLAY_NATIVE_COMPACT_AT * window) {
       out.nativeCompactions += 1
       out.discarded += tokens(chars - fixedChars)

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)