@chroxify/eunoe 1.2.1 → 1.3.0

package/src/core/rewrite.ts

@@ -0,0 +1,189 @@
+import type { Body, Message } from "../context/content"
+import { appendSystem, tailMessages, trimMessages } from "../context/fold/strategies"
+import { splitTurns, turnFingerprint } from "../context/fold/turns"
+import { SYSTEM_PROMPT, searchOnlyInstructions, trimInstructions } from "../context/prompts"
+import { identityReranker, type RecallChunk, type Reranker, withRecall } from "../context/recall"
+import { compact, type StuckSizes } from "./compaction"
+import type { CoreConfig } from "./config"
+import { DEFAULT_RATIO, estimator, sizeOf, targetSize } from "./estimate"
+import { messageFingerprint } from "./fingerprint"
+import { activeHandoffs, attachHandoffs, withHandoffs } from "./handoff"
+import { activeRecalls, applyRecall, prefetchFor, wantsRecall } from "./recall"
+import type { ThreadStore } from "./state"
+
+export interface ThreadSources {
+  guide?: string | null
+  transcriptDir?: string | null
+  readHistory?: () => Message[]
+  listSubagentChunks?: () => RecallChunk[]
+  findHandoff?: (id: string) => { label: string; source: string } | null
+  readHandoff?: (source: string) => Message[]
+}
+
+export interface RewriteInput {
+  body: Body
+  threadId: string | null
+  config: CoreConfig
+  store: ThreadStore
+  sources?: ThreadSources
+  window: number | null
+  mayCompact: boolean
+  omittedBefore?: number
+}
+
+export type RewriteNote = {
+  action: "pass" | "full" | "compact" | "guide" | "trim" | "tail"
+  compacted?: boolean
+  actions?: string[]
+  cutTurn?: number | null
+  omitted?: number
+  folded?: number
+  pinned?: number
+  host?: boolean
+  keep?: number
+  cleared?: number
+  stuck?: StuckSizes
+  turns?: number
+  keptTurns?: number
+  messagesIn?: number
+  messagesOut?: number
+  estimate?: number
+  window?: number | null
+  fit?: "recut" | "bare" | "over"
+  fitEstimate?: number
+  recalled?: number
+  handoff?: number
+  handoffFrom?: string
+}
+
+export interface Rewrite {
+  body: Body
+  threadKey: string | null
+  note: RewriteNote
+}
+
+const pass = (body: Body): Rewrite => ({ body, threadKey: null, note: { action: "pass" } })
+
+const isAgentThread = (body: Body) => Array.isArray(body.tools) && body.tools.length > 0
+
+const withSystemPrompt = (system: Body["system"], extra?: string | null) => appendSystem(extra ? appendSystem(system, extra) : system, SYSTEM_PROMPT)
+
+const ratioOf = (input: RewriteInput, threadKey: string) => input.store.read(threadKey).ratio ?? DEFAULT_RATIO
+
+export function threadKeyOf(threadId: string, messages: Message[]): string | null {
+  const first = splitTurns(messages).turns[0]
+  return first ? `${threadId}-${turnFingerprint(first)}` : null
+}
+
+function evalStrategy(input: RewriteInput, turns: Message[][], threadKey: string, guide: string | null): Rewrite | null {
+  const { body, config } = input
+  const strategy = config.eval?.strategy
+  if (strategy !== "guide" && strategy !== "trim" && strategy !== "tail") return null
+  if (!isAgentThread(body)) return pass(body)
+  const counts = { turns: turns.length, messagesIn: body.messages.length }
+  if (strategy === "guide") {
+    return { body: { ...body, system: withSystemPrompt(body.system, guide ? searchOnlyInstructions(guide) : null) }, threadKey, note: { action: "guide", ...counts } }
+  }
+  if (strategy === "trim") {
+    const messages = trimMessages(body.messages, { evidence: config.eval?.evidence ?? true })
+    return { body: { ...body, system: withSystemPrompt(body.system, trimInstructions(guide)), messages }, threadKey, note: { action: "trim", ...counts, messagesOut: messages.length } }
+  }
+  const based = { ...body, system: withSystemPrompt(body.system) }
+  const size = estimator(based, ratioOf(input, threadKey))
+  let from = 1
+  if (input.window) {
+    const target = targetSize(size, input.window)
+    from = turns.length - 1
+    while (from > 1 && size.of(tailMessages(body.messages, from - 1, guide)) <= target) from -= 1
+  }
+  const messages = tailMessages(body.messages, from, guide)
+  return { body: { ...based, messages }, threadKey, note: { action: "tail", keptTurns: turns.length - from, ...counts, messagesOut: messages.length, estimate: size.of(messages) } }
+}
+
+function strategize(input: RewriteInput): Rewrite {
+  const { body, threadId, config, store } = input
+  const sources = input.sources ?? {}
+  if (!threadId || !Array.isArray(body.messages) || body.messages.length === 0) return pass(body)
+  const threadKey = threadKeyOf(threadId, body.messages)
+  if (!threadKey) return pass(body)
+  const off = config.mode === "off"
+  const state = store.read(threadKey)
+  if (off && !state.host) return pass(body)
+  const { turns } = splitTurns(body.messages)
+  const guide = sources.guide ?? null
+  if (!off && attachHandoffs(body.messages, sources, state)) store.save(threadKey, state)
+
+  const forced = off ? null : evalStrategy(input, turns, threadKey, guide)
+  if (forced) return forced
+
+  const based = isAgentThread(body) ? { ...body, system: withSystemPrompt(body.system) } : body
+  if (body.messages.length < 2) return { body: based, threadKey, note: { action: "full", turns: turns.length } }
+  const handoffs = activeHandoffs(state.handoffs)
+  const recalls = wantsRecall(input) ? activeRecalls(state.recalls) : {}
+  const result = compact({
+    body: based,
+    config,
+    state,
+    window: input.window,
+    guide,
+    transcriptDir: sources.transcriptDir ?? null,
+    mayCompact: input.mayCompact && !off,
+    omittedBefore: input.omittedBefore,
+    decorate: (messages) => withRecall(withHandoffs(messages, handoffs), messageFingerprint, recalls),
+  })
+  if (result.stateChanged) store.save(threadKey, state)
+  return { body: result.messages === body.messages ? based : { ...based, messages: result.messages }, threadKey, note: result.note }
+}
+
+function withAttachedHandoffs(input: RewriteInput, result: Rewrite): Rewrite {
+  if (!result.threadKey) return result
+  const handoffs = activeHandoffs(input.store.read(result.threadKey).handoffs)
+  const messages = withHandoffs(result.body.messages, handoffs)
+  if (messages === result.body.messages) return result
+  const attached = Object.values(handoffs)
+  const note = { ...result.note, handoff: attached.reduce((sum, h) => sum + h.text.length, 0), handoffFrom: attached.map((h) => h.label).join(", ") }
+  return { ...result, body: { ...result.body, messages }, note }
+}
+
+function once(input: RewriteInput): Rewrite {
+  const result = withAttachedHandoffs(input, strategize(input))
+  return wantsRecall(input) ? applyRecall(input, result) : result
+}
+
+function sentEstimate(input: RewriteInput, result: Rewrite): number {
+  return Math.round(sizeOf(result.body) * (result.threadKey ? ratioOf(input, result.threadKey) : DEFAULT_RATIO))
+}
+
+function overLimit(input: RewriteInput, result: Rewrite): boolean {
+  if (!input.window || !result.threadKey || input.mayCompact === false || result.note.action === "pass") return false
+  return sentEstimate(input, result) > input.config.compactAt * input.window
+}
+
+function carried(from: Rewrite, to: Rewrite): Rewrite {
+  const actions = [...(from.note.actions ?? []), ...(to.note.actions ?? [])]
+  if (!from.note.compacted && actions.length === 0) return to
+  return { ...to, note: { ...to.note, compacted: Boolean(to.note.compacted || from.note.compacted), actions } }
+}
+
+export function rewrite(input: RewriteInput, before?: Rewrite): Rewrite {
+  const result = before ? carried(before, once(input)) : once(input)
+  if (!overLimit(input, result)) return result
+  const recut = carried(result, once(input))
+  if (!overLimit(input, recut)) return { ...recut, note: { ...recut.note, fit: "recut" } }
+  const bare = carried(recut, once({ ...input, config: { ...input.config, eval: { ...input.config.eval, recall: false } } }))
+  return { ...bare, note: { ...bare.note, fit: overLimit(input, bare) ? "over" : "bare", fitEstimate: sentEstimate(input, bare) } }
+}
+
+export async function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<{ reranked: boolean; rerankError: null; recalled: number } | null> {
+  if (!wantsRecall(input)) return null
+  const recalled = await prefetchFor(input, strategize(input), rerank)
+  return recalled === null ? null : { reranked: rerank !== identityReranker, rerankError: null, recalled }
+}
+
+export async function rewriteAsync(input: RewriteInput, rerank: Reranker = identityReranker): Promise<Rewrite> {
+  if (!wantsRecall(input) || rerank === identityReranker) return rewrite(input)
+  const first = strategize(input)
+  const recalled = await prefetchFor(input, first, rerank)
+  const final = rewrite(input, first)
+  return recalled === null ? final : { ...final, note: { ...final.note, recalled } }
+}

package/src/core/state.ts

@@ -0,0 +1,40 @@
+export interface Handoff {
+  label: string
+  source: string
+  text: string
+}
+
+export interface ThreadState {
+  handoffs?: Record<string, Handoff | null>
+  cut?: string
+  keep?: number
+  cleared?: number
+  stuck?: number
+  host?: boolean
+  pins?: string[]
+  ratio?: number
+  recalls?: Record<string, string>
+}
+
+export interface ThreadStore {
+  read: (key: string) => ThreadState
+  save: (key: string, state: ThreadState) => void
+}
+
+export function memoryStore(initial: Record<string, ThreadState> = {}): ThreadStore {
+  const threads = new Map(Object.entries(initial).map(([key, state]) => [key, structuredClone(state)]))
+  return {
+    read: (key) => structuredClone(threads.get(key) ?? {}),
+    save: (key, state) => {
+      threads.set(key, structuredClone(state))
+    },
+  }
+}
+
+export function resetCut(state: ThreadState) {
+  delete state.cut
+  delete state.keep
+  delete state.cleared
+  delete state.stuck
+  delete state.host
+}

package/src/core/subagents.ts

@@ -0,0 +1,28 @@
+import { blocks, type Message } from "../context/content"
+import { splitTurns } from "../context/fold/turns"
+import { type RecallChunk, recallChunks } from "../context/recall"
+
+export interface Subagent {
+  description: string
+  messages: Message[]
+  toolUseId?: string
+}
+
+const closingTurn: Message = { role: "user", content: "" }
+
+export function launchTurnOf(parentMessages: Message[], toolUseId: string | undefined): number {
+  if (!toolUseId) return 0
+  const index = splitTurns(parentMessages).turns.findIndex((turn) => turn.some((message) => message.role === "assistant" && blocks(message).some((b) => b.type === "tool_use" && b.id === toolUseId)))
+  return index + 1
+}
+
+const subagentLabel = (description: string) => `subagent "${description}"`
+
+export function subagentRecall(messages: Message[], description: string, parentTurn: number): RecallChunk[] {
+  const from = subagentLabel(description)
+  return recallChunks([...messages, closingTurn], new Map()).map((chunk) => ({ ...chunk, from, turn: parentTurn }))
+}
+
+export function listSubagentRecall(parentMessages: Message[], subagents: Subagent[]): RecallChunk[] {
+  return subagents.flatMap((subagent) => subagentRecall(subagent.messages, subagent.description, launchTurnOf(parentMessages, subagent.toolUseId)))
+}

package/src/core/transcript.ts

@@ -0,0 +1,44 @@
+import { blocks, type Message } from "../context/content"
+import { isPrompt } from "../context/fold/turns"
+import { searchGuide } from "../context/prompts"
+import { renderIndex, renderMarkdown, renderSubagentMarkdown, renderSubagentXml, renderXml, type SubagentRecord, subagentFile, turnFile } from "../transcript/format"
+import { parseTurns, type SessionEntry, type TranscriptFormat, type Turn } from "../transcript/parse"
+import { launchTurnOf, type Subagent } from "./subagents"
+
+export interface TranscriptOptions {
+  format?: TranscriptFormat
+  subagents?: Subagent[]
+}
+
+const isNote = (message: Message) => message.role === "user" && !isPrompt(message) && !blocks(message).some((b) => b.type === "tool_result")
+
+const turnsOf = (messages: Message[], sidechain: boolean | "any" = false): Turn[] =>
+  parseTurns(
+    messages.map((message): SessionEntry => ({ type: message.role, isMeta: isNote(message), message })),
+    sidechain,
+  )
+
+function subagentRecords(messages: Message[], turns: Turn[], subagents: Subagent[], format: TranscriptFormat): SubagentRecord[] {
+  const perTurn = new Map<number, number>()
+  return subagents.map((subagent) => {
+    const parentTurn = launchTurnOf(messages, subagent.toolUseId)
+    const k = (perTurn.get(parentTurn) ?? 0) + 1
+    perTurn.set(parentTurn, k)
+    const file = subagentFile(parentTurn, k, format)
+    const launcher = turns[parentTurn - 1]?.parts.find((part) => part.kind === "tool" && part.id === subagent.toolUseId)
+    if (launcher?.kind === "tool") launcher.record = file
+    return { run: { description: subagent.description }, turns: turnsOf(subagent.messages, "any"), parentTurn, file }
+  })
+}
+
+export function renderTranscriptFiles(messages: Message[], { format = "markdown", subagents = [] }: TranscriptOptions = {}): Record<string, string> {
+  const turns = turnsOf(messages)
+  const records = subagentRecords(messages, turns, subagents, format)
+  const files: Record<string, string> = {}
+  for (const turn of turns) files[turnFile(turn, format)] = format === "xml" ? renderXml(turn) : renderMarkdown(turn)
+  for (const record of records) files[record.file] = format === "xml" ? renderSubagentXml(record) : renderSubagentMarkdown(record)
+  files["index.md"] = renderIndex(turns, format, records)
+  return files
+}
+
+export const transcriptGuide = (dir: string, format: TranscriptFormat = "markdown") => searchGuide({ mode: format, dir, jsonl: "" })

package/src/{proxy → core}/usage.ts

@@ -1,4 +1,8 @@
-type Usage = Record<string, number>
+import type { Body } from "../context/content"
+import { sizeOf } from "./estimate"
+import type { ThreadStore } from "./state"
+
+export type Usage = Record<string, number>
 
 function usageIn(line: string): Usage | null {
   if (!line.startsWith("data:") || !line.includes("message_start")) return null
@@ -58,3 +62,32 @@ export function watchUsage(response: Response, onUsage: (usage: Usage) => void):
 export function inputTokens(usage: Usage) {
   return (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0)
 }
+
+const OVERFLOW_MARGIN = 1.1
+
+const charsOf = (sent: Body | number) => (typeof sent === "number" ? sent : sizeOf(sent))
+
+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
+}
+
+export function recordUsage(store: ThreadStore, threadKey: string, sent: Body | number, usage: Usage): boolean {
+  const input = inputTokens(usage)
+  const chars = charsOf(sent)
+  if (input <= 0 || chars <= 0) return false
+  const state = store.read(threadKey)
+  state.ratio = input / chars
+  store.save(threadKey, state)
+  return true
+}
+
+export function recordOverflow(store: ThreadStore, threadKey: string, sent: Body | number, errorText: string): number | null {
+  const tokens = overflowTokens(errorText)
+  const chars = charsOf(sent)
+  if (!tokens || chars <= 0) return null
+  const state = store.read(threadKey)
+  state.ratio = Math.max(state.ratio ?? 0, tokens / chars) * OVERFLOW_MARGIN
+  store.save(threadKey, state)
+  return tokens
+}

package/src/core/window.ts

@@ -0,0 +1,39 @@
+export type WindowLookup = (model: unknown, requestHeaders: Headers, upstream?: string) => Promise<number | null>
+
+const LOOKUP_TIMEOUT_MS = 5_000
+
+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
+}
+
+export function createWindowLookup({ known = new Map<string, number>(), onLearn }: { known?: Map<string, number>; onLearn?: (windows: Map<string, number>) => void } = {}): WindowLookup {
+  const lookups = new Map<string, Promise<number | null>>()
+  const lookup = async (id: string, requestHeaders: Headers, upstream: string): Promise<number | null> => {
+    const response = await fetch(`${upstream}/v1/models/${encodeURIComponent(id)}`, { headers: lookupHeaders(requestHeaders), signal: AbortSignal.timeout(LOOKUP_TIMEOUT_MS) })
+    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
+    known.set(id, info.max_input_tokens)
+    onLearn?.(known)
+    return info.max_input_tokens
+  }
+  return (model, requestHeaders, upstream = "https://api.anthropic.com") => {
+    const id = String(model ?? "").replace(/\[[^\]]*\]$/, "")
+    if (!id) return Promise.resolve(null)
+    const window = known.get(id)
+    if (window) return Promise.resolve(window)
+    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
+  }
+}

package/src/proxy/rewrite.ts

@@ -1,20 +1,15 @@
+import { existsSync, readFileSync } from "node:fs"
 import type { Config } from "../config"
-import type { Body, Message } from "../context/content"
-import { appendSystem, tailMessages, trimMessages } from "../context/fold/strategies"
-import { splitTurns, turnFingerprint } from "../context/fold/turns"
-import { SYSTEM_PROMPT, searchGuide, searchOnlyInstructions, trimInstructions } from "../context/prompts"
-import { identityReranker, type Reranker, withRecall } from "../context/recall"
-import { jevReranker, rerankKey } from "../context/recall/rerank"
+import { paths } from "../config/paths"
+import type { Reranker } from "../context/recall"
+import { jevReranker } from "../context/recall/rerank"
+import { type RewriteInput as CoreInput, prefetchRecall as prefetchCore, type Rewrite, rewrite as rewriteCore, rewriteAsync as rewriteCoreAsync } from "../core/rewrite"
 import type { TranscriptRef } from "../transcript/search"
-import { compact } from "./compaction"
-import { DEFAULT_RATIO, estimator, sizeOf, targetSize } from "./estimate"
-import { messageFingerprint } from "./fingerprint"
-import { activeHandoffs, attachHandoffs, withHandoffs } from "./handoff"
-import { activeRecalls, applyRecall, prefetchFor, wantsRecall } from "./recall"
-import { readState, saveState } from "./state"
+import { sessionSources } from "./sources"
+import { fileStore } from "./state"
 
 export interface RewriteInput {
-  body: Body
+  body: CoreInput["body"]
   sessionId: string | null
   config: Config
   transcript: TranscriptRef | null
@@ -23,146 +18,34 @@ export interface RewriteInput {
   omittedBefore?: number
 }
 
-export interface Rewrite {
-  body: Body
-  threadKey: string | null
-  note: Record<string, unknown>
+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
 }
 
-interface Prefetched {
-  reranked: boolean
-  rerankError: string | null
-  recalled: number
-}
-
-const pass = (body: Body): Rewrite => ({ body, threadKey: null, note: { action: "pass" } })
-
-const isAgentThread = (body: Body) => Array.isArray(body.tools) && body.tools.length > 0
-
-const withSystemPrompt = (system: Body["system"], extra?: string | null) => appendSystem(extra ? appendSystem(system, extra) : system, SYSTEM_PROMPT)
-
-const ratioOf = (threadKey: string) => readState(threadKey).ratio ?? DEFAULT_RATIO
-
 function rerankModel(config: Config): string | null {
   const model = config.eval?.rerank?.model ?? config.rerank
   return model && model !== "off" ? model : null
 }
 
-function evalStrategy(input: RewriteInput, turns: Message[][], threadKey: string, guide: string | null): Rewrite | null {
-  const { body, config } = input
-  const strategy = config.eval?.strategy
-  if (strategy !== "guide" && strategy !== "trim" && strategy !== "tail") return null
-  if (!isAgentThread(body)) return pass(body)
-  const counts = { turns: turns.length, messagesIn: body.messages.length }
-  if (strategy === "guide") {
-    return { body: { ...body, system: withSystemPrompt(body.system, guide ? searchOnlyInstructions(guide) : null) }, threadKey, note: { action: "guide", ...counts } }
-  }
-  if (strategy === "trim") {
-    const messages = trimMessages(body.messages, { evidence: config.eval?.evidence ?? true })
-    return { body: { ...body, system: withSystemPrompt(body.system, trimInstructions(guide)), messages }, threadKey, note: { action: "trim", ...counts, messagesOut: messages.length } }
-  }
-  const based = { ...body, system: withSystemPrompt(body.system) }
-  const size = estimator(based, ratioOf(threadKey))
-  let from = 1
-  if (input.window) {
-    const target = targetSize(size, input.window)
-    from = turns.length - 1
-    while (from > 1 && size.of(tailMessages(body.messages, from - 1, guide)) <= target) from -= 1
-  }
-  const messages = tailMessages(body.messages, from, guide)
-  return { body: { ...based, messages }, threadKey, note: { action: "tail", keptTurns: turns.length - from, ...counts, messagesOut: messages.length, estimate: size.of(messages) } }
-}
-
-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)
-  if (turns.length === 0) return pass(body)
-  const threadKey = `${sessionId}-${turnFingerprint(turns[0])}`
-  const guide = transcript ? searchGuide(transcript) : null
-  const state = readState(threadKey)
-  if (attachHandoffs(body.messages, config, sessionId, state)) saveState(threadKey, state)
-
-  const forced = evalStrategy(input, turns, threadKey, guide)
-  if (forced) return forced
-
-  const based = isAgentThread(body) ? { ...body, system: withSystemPrompt(body.system) } : body
-  if (body.messages.length < 2) return { body: based, threadKey, note: { action: "full", turns: turns.length } }
-  const handoffs = activeHandoffs(state.handoffs)
-  const recalls = wantsRecall(input) ? activeRecalls(state.recalls) : {}
-  const result = compact({
-    body: based,
-    config,
-    state,
-    window: input.window,
-    guide,
-    transcriptDir: transcript && transcript.mode !== "jsonl" ? transcript.dir : null,
-    mayCompact: input.mayCompact,
-    omittedBefore: input.omittedBefore,
-    decorate: (messages) => withRecall(withHandoffs(messages, handoffs), messageFingerprint, recalls),
-  })
-  if (result.stateChanged) saveState(threadKey, state)
-  return { body: result.messages === body.messages ? based : { ...based, messages: result.messages }, threadKey, note: result.note }
-}
-
-function withAttachedHandoffs(result: Rewrite): Rewrite {
-  if (!result.threadKey) return result
-  const handoffs = activeHandoffs(readState(result.threadKey).handoffs)
-  const messages = withHandoffs(result.body.messages, handoffs)
-  if (messages === result.body.messages) return result
-  const attached = Object.values(handoffs)
-  const note = { ...result.note, handoff: attached.reduce((sum, h) => sum + h.text.length, 0), handoffFrom: attached.map((h) => h.label).join(", ") }
-  return { ...result, body: { ...result.body, messages }, note }
-}
-
-function once(input: RewriteInput): Rewrite {
-  const result = withAttachedHandoffs(strategize(input))
-  return wantsRecall(input) ? applyRecall(input, result) : result
-}
-
-function sentEstimate(result: Rewrite): number {
-  return Math.round(sizeOf(result.body) * (result.threadKey ? ratioOf(result.threadKey) : DEFAULT_RATIO))
-}
-
-function overLimit(input: RewriteInput, result: Rewrite): boolean {
-  if (!input.window || !result.threadKey || input.mayCompact === false || result.note.action === "pass") return false
-  return sentEstimate(result) > input.config.compactAt * input.window
-}
-
-function carried(from: Rewrite, to: Rewrite): Rewrite {
-  const actionsOf = ({ note }: Rewrite) => (note.actions as string[] | undefined) ?? []
-  const actions = [...actionsOf(from), ...actionsOf(to)]
-  if (!from.note.compacted && actions.length === 0) return to
-  return { ...to, note: { ...to.note, compacted: Boolean(to.note.compacted || from.note.compacted), actions } }
-}
+const toCore = ({ sessionId, transcript, ...input }: RewriteInput): CoreInput => ({ ...input, threadId: sessionId, store: fileStore, sources: sessionSources(transcript, input.config, sessionId) })
 
-export function rewrite(input: RewriteInput, before?: Rewrite): Rewrite {
-  const result = before ? carried(before, once(input)) : once(input)
-  if (!overLimit(input, result)) return result
-  const recut = carried(result, once(input))
-  if (!overLimit(input, recut)) return { ...recut, note: { ...recut.note, fit: "recut" } }
-  const bare = carried(recut, once({ ...input, config: { ...input.config, eval: { ...input.config.eval, recall: false } } }))
-  return { ...bare, note: { ...bare.note, fit: overLimit(input, bare) ? "over" : "bare", fitEstimate: sentEstimate(bare) } }
-}
+export const rewrite = (input: RewriteInput): Rewrite => rewriteCore(toCore(input))
 
-export async function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<Prefetched | null> {
-  if (!wantsRecall(input)) return null
-  const recalled = await prefetchFor(input, strategize(input), rerank)
-  return recalled === null ? null : { reranked: rerank !== identityReranker, rerankError: null, recalled }
-}
+export const prefetchRecall = (input: RewriteInput, rerank: Reranker) => prefetchCore(toCore(input), rerank)
 
-export async function rewriteAsync(input: RewriteInput): Promise<Rewrite> {
-  const model = wantsRecall(input) ? rerankModel(input.config) : null
+export async function rewriteAsync(input: RewriteInput): Promise<Rewrite & { note: { reranked?: string; rerankError?: string } }> {
+  const core = toCore(input)
+  const model = core.config.mode !== "off" && (core.config.eval?.recall ?? true) ? rerankModel(input.config) : null
   const key = model ? rerankKey() : null
-  if (!model || !key) return rewrite(input)
+  if (!model || !key) return rewriteCore(core)
   const failure = { reason: null as string | null }
   const reranker = jevReranker(model, key, input.config.eval?.rerank?.endpoint, (reason) => {
     failure.reason = reason
   })
-  const first = strategize(input)
-  const recalled = await prefetchFor(input, first, reranker)
-  const final = rewrite(input, first)
-  if (recalled === null) return final
+  const result = await rewriteCoreAsync(core, reranker)
+  if (result.note.recalled === undefined) return result
   const outcome = failure.reason ? { rerankError: `${model}: ${failure.reason}` } : { reranked: model }
-  return { ...final, note: { ...final.note, recalled, ...outcome } }
+  return { ...result, note: { ...result.note, ...outcome } }
 }