@chroxify/eunoe 0.1.0 → 1.0.0

package/src/context/recall.ts

@@ -0,0 +1,155 @@
+import { BM25_B, BM25_K1, RECALL_LINE_CHARS, RECALL_MAX_CHARS, RECALL_MAX_CHARS_MULTI, RECALL_MIN_TERMS, RECALL_NARRATIVE, RECALL_PER_QUERY, RECALL_RERANK_CANDIDATES, RECALL_SALIENT_EXCERPT, RECALL_SHOWN_LINES, RECALL_WINDOW_LINES, STOPWORDS } from "./constants"
+import { blocks, clip, describeToolCall, resultText } from "./content"
+import { isSalient, toolPairs } from "./evidence"
+import { isPrompt, splitTurns } from "./turns"
+import type { Message, RecallChunk, RecallOptions, RecallPick, Reranker } from "./types"
+
+const REMINDERS = /<(system-reminder|system-message|recalled-context|tool-evidence)>[\s\S]*?<\/\1>/g
+
+export function terms(text: string): string[] {
+  return (text.toLowerCase().match(/[a-z0-9_@$][a-z0-9_.:/@$-]*[a-z0-9_]|[a-z0-9]/g) ?? [])
+    .flatMap((term) => (/[._:/-]/.test(term) ? [term, ...term.split(/[._:/-]+/)] : [term]))
+    .filter((term) => term.length >= 3 && !STOPWORDS.has(term))
+}
+
+function promptText(message: Message): string {
+  return blocks(message).filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n").replace(REMINDERS, "").trim()
+}
+
+function windows(lines: string[], size: number): string[][] {
+  const out: string[][] = []
+  for (let start = 0; start < lines.length; start += size) out.push(lines.slice(start, start + size))
+  return out
+}
+
+export function recallChunks(messages: Message[], keptIds: Map<string, string>, options: RecallOptions = {}): RecallChunk[] {
+  const { turns } = splitTurns(messages)
+  const size = options.windowLines ?? RECALL_WINDOW_LINES
+  const weight = Math.max(1, options.callWeight ?? 1)
+  const chunks: RecallChunk[] = []
+  turns.slice(0, -1).forEach((turn, turnIndex) => {
+    for (const { call, result } of toolPairs(turn)) {
+      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"))] })
+      }
+    }
+    if (!(options.narrative ?? RECALL_NARRATIVE)) return
+    const said = turn.slice(1, -1).filter((m) => m.role === "assistant").flatMap((m) => blocks(m).filter((b) => b.type === "text").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")) })
+    }
+  })
+  return chunks
+}
+
+export function rank(query: string[], chunks: RecallChunk[], minTerms = RECALL_MIN_TERMS) {
+  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)
+    let score = 0
+    let matched = 0
+    for (const term of wanted) {
+      const f = tf.get(term) ?? 0
+      if (!f) continue
+      matched += 1
+      const idf = Math.log(1 + (chunks.length - df.get(term)! + 0.5) / (df.get(term)! + 0.5))
+      score += idf * (f * (BM25_K1 + 1)) / (f + BM25_K1 * (1 - BM25_B + BM25_B * chunk.terms.length / average))
+    }
+    return { index, score, matched }
+  }).filter((r) => r.matched >= Math.min(minTerms, wanted.length) && r.score > 0).sort((a, b) => b.score - a.score)
+}
+
+function excerpt(chunk: RecallChunk, query: Set<string>, salient: boolean): string[] {
+  const hits = chunk.lines.map((line, i) => (terms(line).some((t) => query.has(t)) ? i : -1)).filter((i) => i >= 0)
+  const shown = new Set<number>()
+  for (const i of hits) for (const j of [i - 1, i, i + 1]) if (j >= 0 && j < chunk.lines.length) shown.add(j)
+  if (salient) for (let i = 0; i < chunk.lines.length && shown.size < RECALL_SHOWN_LINES + 2; i += 1) if (isSalient(chunk.lines[i])) shown.add(i)
+  const ordered = [...shown].sort((a, b) => a - b).slice(0, salient ? RECALL_SHOWN_LINES + 2 : RECALL_SHOWN_LINES)
+  return (ordered.length ? ordered : [0]).map((i) => clip(chunk.lines[i], RECALL_LINE_CHARS)).filter(Boolean)
+}
+
+export function queriesOf(prompt: string): string[] {
+  const lines = prompt.split("\n").map((l) => l.trim()).filter((l) => terms(l).length >= 2)
+  return lines.length > 1 ? lines : [prompt]
+}
+
+export function pickRecall(prompt: string, chunks: RecallChunk[], options: RecallOptions = {}): RecallPick[] {
+  const perQuery = options.perQuery ?? RECALL_PER_QUERY
+  const picked = new Map<number, Set<string>>()
+  for (const query of queriesOf(prompt)) {
+    const q = terms(query)
+    for (const hit of rank(q, chunks, options.minTerms).slice(0, perQuery)) {
+      if (!picked.has(hit.index)) picked.set(hit.index, new Set())
+      for (const t of q) picked.get(hit.index)!.add(t)
+    }
+  }
+  return [...picked.entries()].map(([index, query]) => ({ index, query }))
+}
+
+export async function pickRecallWith(prompt: string, chunks: RecallChunk[], rerank: Reranker, options: RecallOptions = {}): Promise<RecallPick[]> {
+  const perQuery = options.perQuery ?? RECALL_PER_QUERY
+  const width = options.candidates ?? RECALL_RERANK_CANDIDATES
+  const picked = new Map<number, Set<string>>()
+  for (const query of queriesOf(prompt)) {
+    const q = terms(query)
+    const candidates = rank(q, chunks, options.minTerms).slice(0, width).map((hit) => hit.index)
+    for (const index of (await rerank(query, chunks, candidates)).slice(0, perQuery)) {
+      if (!picked.has(index)) picked.set(index, new Set())
+      for (const t of q) picked.get(index)!.add(t)
+    }
+  }
+  return [...picked.entries()].map(([index, query]) => ({ index, query }))
+}
+
+export function renderRecall(prompt: string, chunks: RecallChunk[], picks: RecallPick[], options: RecallOptions = {}): string | null {
+  if (!picks.length) return null
+  const budget = queriesOf(prompt).length > 1 ? options.maxCharsMulti ?? RECALL_MAX_CHARS_MULTI : options.maxChars ?? RECALL_MAX_CHARS
+  const entries: string[] = []
+  let used = 0
+  for (const pick of [...picks].sort((a, b) => chunks[a.index].turn - chunks[b.index].turn || a.index - b.index)) {
+    const chunk = chunks[pick.index]
+    const entry = `[turn ${chunk.turn}] ${chunk.call}:\n${excerpt(chunk, pick.query, options.salientExcerpt ?? RECALL_SALIENT_EXCERPT).map((l) => `    ${l}`).join("\n")}`
+    if (used + entry.length > budget) continue
+    entries.push(entry)
+    used += entry.length
+  }
+  return entries.length
+    ? `<recalled-context>\nExcerpts from earlier in this session that match this message: tool output that is no longer in your context, quoted exactly, oldest first. Where the same thing appears twice, the later turn is current. Use them if they answer what was asked; ignore them otherwise.\n\n${entries.join("\n")}\n</recalled-context>`
+    : null
+}
+
+export function recallFor(prompt: string, chunks: RecallChunk[], options: RecallOptions = {}): string | null {
+  if (!chunks.length) return null
+  return renderRecall(prompt, chunks, pickRecall(prompt, chunks, options), options)
+}
+
+export async function recallForWith(prompt: string, chunks: RecallChunk[], rerank: Reranker, options: RecallOptions = {}): Promise<string | null> {
+  if (!chunks.length) return null
+  return renderRecall(prompt, chunks, await pickRecallWith(prompt, chunks, rerank, options), options)
+}
+
+export function livePrompt(messages: Message[]): { index: number; text: string } | null {
+  const { preamble, turns } = splitTurns(messages)
+  if (turns.length < 2) return null
+  const first = turns.at(-1)![0]
+  if (!isPrompt(first)) return null
+  const index = preamble.length + turns.slice(0, -1).reduce((s, t) => s + t.length, 0)
+  return { index, text: promptText(first) }
+}
+
+export function withRecall(messages: Message[], fingerprint: (message: Message) => string, recalls: Record<string, string>): Message[] {
+  if (!Object.keys(recalls).length) return messages
+  return messages.map((message) => {
+    if (!isPrompt(message)) return message
+    const text = recalls[fingerprint(message)]
+    return text ? { ...message, content: [...blocks(message), { type: "text", text }] } : message
+  })
+}

package/src/context/rerank.ts

@@ -0,0 +1,44 @@
+import { existsSync, readFileSync } from "node:fs"
+import { paths } from "../config/constants"
+import { RERANK_ENDPOINT, RERANK_LINE_CHARS, RERANK_TIMEOUT_MS } from "./constants"
+import type { RecallChunk, Reranker } from "./types"
+
+export function rerankKey(): string | null {
+  const env = process.env.TYPESAFE_API_KEY?.trim()
+  if (env) return env
+  return existsSync(paths.typesafeKey) ? readFileSync(paths.typesafeKey, "utf8").trim() : null
+}
+
+export function rerankState(chunks: RecallChunk[], candidates: number[]): string {
+  return candidates.map((index, n) => `### ${n}\n[turn ${chunks[index].turn}] ${chunks[index].call}\n${chunks[index].lines.map((l) => l.slice(0, RERANK_LINE_CHARS)).join("\n")}`).join("\n\n")
+}
+
+export function orderByProbability(candidates: number[], probabilities: Record<string, number>): number[] {
+  return candidates.map((_, n) => n).sort((a, b) => (probabilities[String(b)] ?? 0) - (probabilities[String(a)] ?? 0) || a - b).map((n) => candidates[n])
+}
+
+export function jevReranker(model: string, key: string, endpoint = RERANK_ENDPOINT): Reranker {
+  return async (query, chunks, candidates) => {
+    if (candidates.length < 2) return candidates
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+        signal: AbortSignal.timeout(RERANK_TIMEOUT_MS),
+        body: JSON.stringify({
+          model,
+          state: rerankState(chunks, candidates),
+          questions: {
+            where: { type: "choice", instructions: `Which excerpt contains the exact answer to the developer's question about this coding session: "${query}"?`, criteria: Object.fromEntries(candidates.map((_, n) => [String(n), null])) },
+          },
+        }),
+      })
+      if (!response.ok) return candidates
+      const json: any = await response.json()
+      const probabilities = json?.answers?.where?.probabilities
+      return probabilities && typeof probabilities === "object" ? orderByProbability(candidates, probabilities) : candidates
+    } catch {
+      return candidates
+    }
+  }
+}

package/src/context/strategies.ts

@@ -1,13 +1,13 @@
 import { CLEARED_INPUT_KEPT, CLEARED_INPUT_THRESHOLD } from "./constants"
-import { blocks, withoutCacheControl } from "./content"
+import { blocks, truncate, withoutCacheControl } from "./content"
 import { compactionNotice, truncationNotice } from "./prompts"
 import { hasContent, isHarness, reduceTurn, splitTurns } from "./turns"
-import type { Block, Body, CompactOptions, Message } from "./types"
+import type { Block, Body, CompactOptions, Message, ReduceOptions } from "./types"
 
-export function trimMessages(messages: Message[]): Message[] {
+export function trimMessages(messages: Message[], options: ReduceOptions = {}): Message[] {
   const { preamble, turns } = splitTurns(messages)
   if (turns.length < 2) return messages
-  return [...preamble, ...turns.slice(0, -1).flatMap(reduceTurn), ...turns.at(-1)!]
+  return [...preamble, ...turns.slice(0, -1).flatMap((turn) => reduceTurn(turn, options)), ...turns.at(-1)!]
 }
 
 export function compactMessages(
@@ -28,7 +28,7 @@ export function compactMessages(
     ...preamble,
     turns[0][0],
     { role: "user", content: [{ type: "text", text: notice }, ...carried] },
-    ...turns.slice(keptFrom, cutIndex).flatMap(reduceTurn),
+    ...turns.slice(keptFrom, cutIndex).flatMap((turn) => reduceTurn(turn, options)),
     ...turns.slice(cutIndex).flat(),
   ]
 }
@@ -73,7 +73,7 @@ export function clearToolResults(messages: Message[], from: number, count: numbe
 }
 
 function shortenInput(input: unknown): unknown {
-  if (typeof input === "string") return input.length > CLEARED_INPUT_THRESHOLD ? `${input.slice(0, CLEARED_INPUT_KEPT)}… [${input.length - CLEARED_INPUT_KEPT} chars cleared; in the transcript]` : input
+  if (typeof input === "string") return input.length > CLEARED_INPUT_THRESHOLD ? `${truncate(input, CLEARED_INPUT_KEPT)}… [${input.length - CLEARED_INPUT_KEPT} chars cleared; in the transcript]` : input
   if (Array.isArray(input)) return input.map(shortenInput)
   if (input && typeof input === "object") return Object.fromEntries(Object.entries(input).map(([k, v]) => [k, shortenInput(v)]))
   return input

package/src/context/turns.ts

@@ -1,6 +1,7 @@
-import { SUMMARY_ARGUMENT_CHARS, SUMMARY_CALLS_SHOWN, SUMMARY_COMMAND_CHARS, SUMMARY_LAST_WORDS_CHARS } from "./constants"
-import { blocks, clean, clip, withoutCacheControl } from "./content"
-import type { Block, Message } from "./types"
+import { REMINDER_ONLY, SUMMARY_CALLS_SHOWN, SUMMARY_LAST_WORDS_CHARS } from "./constants"
+import { blocks, clean, describeToolCall, truncate, withoutCacheControl } from "./content"
+import { turnEvidence } from "./evidence"
+import type { Block, Message, ReduceOptions } from "./types"
 
 export function isPrompt(message: Message) {
   if (message.role !== "user") return false
@@ -43,14 +44,6 @@ function mergedHarness(turn: Message[]): Message[] {
   return content.length > 0 ? [{ role: "system", content }] : []
 }
 
-function describeToolCall(block: Block): string {
-  const input = block.input ?? {}
-  if (typeof input.command === "string") return `${block.name} \`${clip(input.command, SUMMARY_COMMAND_CHARS)}\``
-  if (typeof input.file_path === "string") return `${block.name} ${input.file_path}`
-  if (typeof input.pattern === "string") return `${block.name} "${clip(input.pattern, SUMMARY_ARGUMENT_CHARS)}"`
-  return `${block.name} ${clip(JSON.stringify(input), SUMMARY_ARGUMENT_CHARS)}`
-}
-
 function interruptedSummary(turn: Message[]): string {
   const assistant = turn.filter((m) => m.role === "assistant")
   const lastWords = [...assistant].reverse()
@@ -60,17 +53,29 @@ function interruptedSummary(turn: Message[]): string {
   const shown = calls.slice(-SUMMARY_CALLS_SHOWN)
   return [
     "[This turn was interrupted before a final reply.]",
-    lastWords ? `Last thing you said: ${lastWords.length > SUMMARY_LAST_WORDS_CHARS ? `${lastWords.slice(0, SUMMARY_LAST_WORDS_CHARS)}…` : lastWords}` : "",
+    lastWords ? `Last thing you said: ${lastWords.length > SUMMARY_LAST_WORDS_CHARS ? `${truncate(lastWords, SUMMARY_LAST_WORDS_CHARS)}…` : lastWords}` : "",
     calls.length > 0 ? `Tool calls (${calls.length}${calls.length > shown.length ? `, last ${shown.length} shown` : ""}): ${shown.join("; ")}` : "",
     "Their output is in the full transcript.",
   ].filter(Boolean).join("\n")
 }
 
-export function reduceTurn(turn: Message[]): Message[] {
+function carriedText(messages: Message[]): Block[] {
+  return messages
+    .filter((m) => m.role === "user")
+    .flatMap((m) => blocks(m).filter((b) => b.type === "text" && String(b.text ?? "").trim() && !REMINDER_ONLY.test(String(b.text))))
+    .map((b) => ({ type: "text", text: b.text }))
+}
+
+export function reduceTurn(turn: Message[], options: ReduceOptions = {}): Message[] {
   const opening: Message[] = []
-  for (let i = 0; i < turn.length && turn[i].role !== "assistant"; i += 1) {
+  let i = 0
+  for (; i < turn.length && turn[i].role !== "assistant"; i += 1) {
     if (turn[i].role === "user") opening.push(clean(turn[i]))
   }
+  const carried = carriedText(turn.slice(i))
+  if (carried.length > 0) opening.push({ role: "user", content: carried })
+  const evidence = options.evidence ? turnEvidence(turn) : null
+  if (evidence) opening.push({ role: "user", content: [{ type: "text", text: evidence }] })
   opening.push(...mergedHarness(turn))
   const last = [...turn].reverse().find((m) => m.role !== "system")!
   const content = last.role === "assistant" ? blocks(last) : []

package/src/context/types.ts

@@ -11,7 +11,11 @@ export type Body = {
   [key: string]: any
 }
 
-export interface CompactOptions {
+export interface ReduceOptions {
+  evidence?: boolean
+}
+
+export interface CompactOptions extends ReduceOptions {
   keepTurns: number
   guide: string | null
   omittedBefore?: number
@@ -22,3 +26,41 @@ export interface NoticeCounts {
   kept: number
   guide: string | null
 }
+
+export interface RecallChunk {
+  turn: number
+  call: string
+  lines: string[]
+  terms: string[]
+}
+
+export interface EvidenceOptions {
+  linesPerCall?: number
+  lineChars?: number
+  turnChars?: number
+  scanLines?: number
+  minScore?: number
+  allTools?: boolean
+  ranked?: boolean
+  labels?: boolean
+  callFloor?: number
+}
+
+export interface RecallOptions {
+  windowLines?: number
+  perQuery?: number
+  minTerms?: number
+  maxChars?: number
+  maxCharsMulti?: number
+  narrative?: boolean
+  callWeight?: number
+  salientExcerpt?: boolean
+  candidates?: number
+}
+
+export type Reranker = (query: string, chunks: RecallChunk[], candidates: number[]) => Promise<number[]>
+
+export interface RecallPick {
+  index: number
+  query: Set<string>
+}

package/src/proxy/canonical.ts

@@ -0,0 +1,32 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import type { Body } from "../context/types"
+import { BILLING_LINE } from "./constants"
+import type { Canonical, CanonicalResult } from "./types"
+
+const billingLine = (system: Body["system"]) => {
+  const first = Array.isArray(system) ? String(system[0]?.text ?? "") : String(system ?? "")
+  return first.match(BILLING_LINE)?.[0] ?? null
+}
+
+function withBilling(system: Body["system"], line: string | null): Body["system"] {
+  if (!line) return system
+  if (Array.isArray(system)) {
+    const [first, ...rest] = system
+    return [{ ...first, text: String(first?.text ?? "").replace(BILLING_LINE, line) }, ...rest]
+  }
+  return String(system ?? "").replace(BILLING_LINE, line)
+}
+
+export function applyCanonical(body: Body, file: string): CanonicalResult {
+  if (!Array.isArray(body.tools) || body.tools.length === 0) return { body, status: "skipped" }
+  if (existsSync(file)) {
+    const canonical = JSON.parse(readFileSync(file, "utf8")) as Canonical
+    return { body: { ...body, system: withBilling(canonical.system, billingLine(body.system)), tools: canonical.tools }, status: "applied" }
+  }
+  mkdirSync(path.dirname(file), { recursive: true })
+  const partial = `${file}.${process.pid}.${Date.now()}`
+  writeFileSync(partial, JSON.stringify({ system: body.system, tools: body.tools } satisfies Canonical))
+  renameSync(partial, file)
+  return { body, status: "captured" }
+}

package/src/proxy/compaction.ts

@@ -4,8 +4,15 @@ import { splitTurns, turnFingerprint } from "../context/turns"
 import { DEFAULT_RATIO, PROTECTED_OUTPUTS } from "./constants"
 import { estimator, targetSize } from "./estimate"
 import { resetCut } from "./state"
+import type { Message } from "../context/types"
 import type { CompactInput, CompactResult } from "./types"
 
+function settledCut(turns: Message[][], index: number) {
+  let cut = index
+  while (cut > 1 && JSON.stringify(turns[cut][0].content).includes("[Request interrupted")) cut -= 1
+  return cut
+}
+
 export function compact({ body, config, state, window, guide, mayCompact, omittedBefore = 0 }: CompactInput): CompactResult {
   const { turns } = splitTurns(body.messages)
   let stateChanged = false
@@ -15,9 +22,9 @@ export function compact({ body, config, state, window, guide, mayCompact, omitte
     resetCut(state)
     stateChanged = true
   }
+  const rolling = config.eval?.rolling ?? (config.mode === "default" ? { keep: config.keep, budget: config.budget } : undefined)
   if (cutIndex <= 0 && config.eval?.forceCut && turns.length >= 3) {
-    let forced = turns.length - 2
-    while (forced > 1 && JSON.stringify(turns[forced][0].content).includes("[Request interrupted")) forced -= 1
+    const forced = settledCut(turns, Math.max(1, turns.length - 1 - (rolling?.keep ?? 1)))
     cutIndex = forced
     state.cut = turnFingerprint(turns[forced])
     stateChanged = true
@@ -26,7 +33,7 @@ export function compact({ body, config, state, window, guide, mayCompact, omitte
   const configuredKeep = config.keepTurns === "all" ? Number.MAX_SAFE_INTEGER : config.keepTurns
   const liveLength = () => turns.slice(Math.max(cutIndex, 0)).flat().length
   const compacted = () => cutIndex > 0
-    ? compactMessages(body.messages, cutIndex, { keepTurns: state.keep ?? configuredKeep, guide, omittedBefore })
+    ? compactMessages(body.messages, cutIndex, { keepTurns: state.keep ?? configuredKeep, guide, omittedBefore, evidence: config.eval?.evidence ?? true })
     : body.messages
   const build = () => {
     const messages = compacted()
@@ -41,16 +48,26 @@ export function compact({ body, config, state, window, guide, mayCompact, omitte
   let estimate = size.of(messages)
   const actions: string[] = []
   const current = turns.length - 1
+  const moveCut = (index: number, action: string) => {
+    cutIndex = index
+    resetCut(state)
+    state.cut = turnFingerprint(turns[index])
+    actions.push(action)
+    messages = build()
+    estimate = size.of(messages)
+  }
 
-  if (mayCompact && estimate > limit) {
-    if (current > 0 && current > cutIndex) {
-      cutIndex = current
-      resetCut(state)
-      state.cut = turnFingerprint(turns[current])
-      actions.push("cut")
-      messages = build()
-      estimate = size.of(messages)
+  if (mayCompact && rolling) {
+    const next = settledCut(turns, current - rolling.keep)
+    const backlog = size.of(turns.slice(Math.max(cutIndex, 0), Math.max(next, 0)).flat()) - size.fixed
+    if (next >= 1 && next > cutIndex && backlog > rolling.budget) {
+      moveCut(next, "roll")
+      stateChanged = true
     }
+  }
+
+  if (mayCompact && estimate > limit) {
+    if (current > 0 && current > cutIndex) moveCut(current, "cut")
     while (estimate > target) {
       const keep = Math.min(state.keep ?? configuredKeep, cutIndex - 1)
       if (cutIndex > 0 && keep > 0) {
@@ -78,7 +95,7 @@ export function compact({ body, config, state, window, guide, mayCompact, omitte
     stateChanged,
     note: {
       action: cutIndex > 0 ? "compact" : "full",
-      compacted: actions.includes("cut"),
+      compacted: actions.includes("cut") || actions.includes("roll"),
       actions: actions.length ? actions : undefined,
       cutTurn: cutIndex > 0 ? cutIndex : null,
       keep: state.keep,

package/src/proxy/constants.ts

@@ -2,6 +2,9 @@ export const HEALTH_PATH = "/_eunoe/health"
 export const SESSION_HEADER = "x-claude-code-session-id"
 export const TRANSCRIPT_HEADER = "x-eunoe-transcript"
 export const OMITTED_BEFORE_HEADER = "x-eunoe-omitted-before"
+export const CANONICAL_HEADER = "x-eunoe-canonical"
+export const WINDOW_HEADER = "x-eunoe-window"
+export const BILLING_LINE = /^x-anthropic-billing-header:[^\n]*/
 
 export const TARGET_SHARE = 0.3
 export const PROTECTED_OUTPUTS = 5
@@ -17,3 +20,10 @@ export const MODEL_LOOKUP_TIMEOUT_MS = 5_000
 export const MAX_EVENT_BUFFER = 4_000_000
 export const LOGGED_ERROR_CHARS = 500
 export const IDLE_TIMEOUT_SECONDS = 255
+
+export const SESSION_SEEN_INTERVAL_MS = 30_000
+export const SESSION_HEAD_BYTES = 65_536
+export const SESSIONS_KEPT = 200
+
+export const FINGERPRINT_LENGTH = 12
+export const SKILL_MARKER = /Base directory for this skill: ([^\s"\\]+)/g

package/src/proxy/fingerprint.ts

@@ -0,0 +1,15 @@
+import type { Body } from "../context/types"
+import { FINGERPRINT_LENGTH, SKILL_MARKER } from "./constants"
+import type { ContextFingerprint } from "./types"
+
+const hash = (value: unknown) => {
+  const hasher = new Bun.CryptoHasher("sha256")
+  hasher.update(JSON.stringify(value ?? null, (key, inner) => (key === "cache_control" ? undefined : inner)))
+  return hasher.digest("hex").slice(0, FINGERPRINT_LENGTH)
+}
+
+export function contextFingerprint(body: Body): ContextFingerprint {
+  const skills = new Set<string>()
+  for (const match of JSON.stringify(body.messages ?? []).matchAll(SKILL_MARKER)) skills.add(match[1].split("/").at(-1)!)
+  return { system: hash(body.system), tools: hash(body.tools), skills: [...skills].sort() }
+}

package/src/proxy/rewrite.ts

@@ -1,8 +1,14 @@
 import { searchOnlyInstructions, trimInstructions, TRANSCRIPT_FALLBACK } from "../context/prompts"
+import { recallChunks, recallFor, recallForWith, livePrompt, withRecall } from "../context/recall"
+import { jevReranker, rerankKey } from "../context/rerank"
 import { appendSystem, tailMessages, trimMessages } from "../context/strategies"
+import { blocks, resultText, withoutCacheControl } from "../context/content"
 import { splitTurns, turnFingerprint } from "../context/turns"
-import type { Body } from "../context/types"
+import type { Body, Message, Reranker } from "../context/types"
+import { sessionMessages } from "../transcript/messages"
 import { searchGuide } from "../transcript/search"
+import { RERANK_OFF } from "../config/constants"
+import type { Config } from "../config/types"
 import { compact } from "./compaction"
 import { DEFAULT_RATIO } from "./constants"
 import { estimator, targetSize } from "./estimate"
@@ -13,7 +19,76 @@ const pass = (body: Body): Rewrite => ({ body, threadKey: null, note: { action:
 
 const isAgentThread = (body: Body) => Array.isArray(body.tools) && body.tools.length > 0
 
+function messageFingerprint(message: Message) {
+  const hasher = new Bun.CryptoHasher("sha256")
+  hasher.update(JSON.stringify(blocks(message).filter((b) => !(b.type === "text" && String(b.text ?? "").startsWith("<recalled-context>"))).map(withoutCacheControl)))
+  return hasher.digest("hex").slice(0, 24)
+}
+
+const wantsRecall = (input: RewriteInput) => (input.config.eval?.recall ?? true) && input.config.mode !== "off"
+
+function rerankModel(config: Config): string | null {
+  const model = config.eval?.rerank?.model ?? config.rerank
+  return model && model !== RERANK_OFF ? model : null
+}
+
+function droppedChunks(original: Body, result: Rewrite, transcript: string | null) {
+  const kept = new Map<string, string>()
+  for (const message of result.body.messages) for (const b of blocks(message)) if (b.type === "tool_result") kept.set(b.tool_use_id, resultText(b))
+  const chunks = recallChunks(original.messages, kept)
+  return chunks.length || !transcript ? chunks : recallChunks([...sessionMessages(transcript), { role: "user", content: "" }], kept)
+}
+
+function recallTarget(original: Body, result: Rewrite): { key: string; text: string } | null {
+  if (!result.threadKey || result.body === original && result.note.action === "pass") return null
+  const live = livePrompt(original.messages)
+  return live ? { key: messageFingerprint(original.messages[live.index]), text: live.text } : null
+}
+
+function recalled(original: Body, result: Rewrite, transcript: string | null): Rewrite {
+  if (!result.threadKey || result.body === original && result.note.action === "pass") return result
+  const state = loadState(result.threadKey)
+  state.recalls ??= {}
+  const target = recallTarget(original, result)
+  let note = result.note
+  if (target && !(target.key in state.recalls)) {
+    state.recalls[target.key] = recallFor(target.text, droppedChunks(original, result, transcript)) ?? ""
+    saveState(result.threadKey, state)
+    note = { ...note, recalled: state.recalls[target.key].length }
+  }
+  const recalls = Object.fromEntries(Object.entries(state.recalls).filter(([, text]) => text))
+  const messages = withRecall(result.body.messages, messageFingerprint, recalls)
+  return messages === result.body.messages ? { ...result, note } : { ...result, body: { ...result.body, messages }, note }
+}
+
+export async function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<boolean> {
+  if (!wantsRecall(input)) return false
+  const result = strategize(input)
+  const target = recallTarget(input.body, result)
+  if (!target) return false
+  const state = loadState(result.threadKey!)
+  state.recalls ??= {}
+  if (target.key in state.recalls) return false
+  const chunks = droppedChunks(input.body, result, input.transcript?.jsonl ?? null)
+  state.recalls[target.key] = (await recallForWith(target.text, chunks, rerank, { candidates: input.config.eval?.rerank?.candidates })) ?? ""
+  saveState(result.threadKey!, state)
+  return true
+}
+
 export function rewrite(input: RewriteInput): Rewrite {
+  const result = strategize(input)
+  return wantsRecall(input) ? recalled(input.body, result, input.transcript?.jsonl ?? null) : result
+}
+
+export async function rewriteAsync(input: RewriteInput): Promise<Rewrite> {
+  const model = rerankModel(input.config)
+  const key = model ? rerankKey() : null
+  const reranked = model && key ? await prefetchRecall(input, jevReranker(model, key)) : false
+  const result = rewrite(input)
+  return reranked ? { ...result, note: { ...result.note, reranked: model } } : result
+}
+
+function strategize(input: RewriteInput): Rewrite {
   const { body, sessionId, config, transcript } = input
   if (config.mode === "off" || !sessionId || !Array.isArray(body.messages) || body.messages.length === 0) return pass(body)
   const { turns } = splitTurns(body.messages)
@@ -48,15 +123,14 @@ export function rewrite(input: RewriteInput): Rewrite {
         note: { action: "tail", keptTurns: turns.length - from, turns: turns.length, messagesIn: body.messages.length, messagesOut: messages.length, estimate: size.of(messages) },
       }
     }
-  }
-
-  if (config.mode === "trim") {
-    if (!isAgentThread(body)) return pass(body)
-    const messages = trimMessages(body.messages)
-    return {
-      body: { ...body, system: appendSystem(body.system, trimInstructions(guide ?? TRANSCRIPT_FALLBACK)), messages },
-      threadKey,
-      note: { action: "trim", turns: turns.length, messagesIn: body.messages.length, messagesOut: messages.length },
+    case "trim": {
+      if (!isAgentThread(body)) return pass(body)
+      const messages = trimMessages(body.messages, { evidence: config.eval?.evidence ?? true })
+      return {
+        body: { ...body, system: appendSystem(body.system, trimInstructions(guide ?? TRANSCRIPT_FALLBACK)), messages },
+        threadKey,
+        note: { action: "trim", turns: turns.length, messagesIn: body.messages.length, messagesOut: messages.length },
+      }
     }
   }