@chroxify/eunoe 1.0.0 → 1.2.0

package/src/context/prompts.ts

@@ -1,33 +1,105 @@
-import type { NoticeCounts } from "./types"
+import type { TranscriptRef } from "../transcript/search"
+import { truncate } from "./content"
 
-export function compactionNotice(args: NoticeCounts) {
+interface NoticeCounts {
+  omitted: number
+  kept: number
+  guide: string | null
+}
+
+const plural = (count: number, word: string) => `${count} ${word}${count === 1 ? "" : "s"}`
+
+export const SYSTEM_PROMPT = [
+  "# Earlier sessions in this project",
+  "",
+  "eunoe keeps the full record of this project's earlier Claude Code sessions, and the user expects you to use it the way a colleague who was there would. When they point you at one, skipping it is the failure to avoid: you will redo finished work, break rules the user already set, and ask for things they already told you.",
+  "",
+  "## When",
+  "",
+  'A message carrying `{ee:continue:<id>}` already has that session attached to it as a `<handoff>` block: read it as part of the message, nothing to run. Use the commands below when the user names a session without the marker (`eunoe load <id>`), or when they refer to earlier work you have no context for: a plan, a todo, "the thing we talked about", "where we left off". `eunoe sessions <key words>` lists the closest earlier sessions, newest first, each with its first and last request; if one clearly continues into this message, load it, otherwise ask which they mean. Do not go looking for work that is clearly new and unrelated.',
+  "",
+  "## How",
+  "",
+  "1. `eunoe load <id>` writes that whole session to a file and prints its path. Read the file with the Read tool from the first line to the last, in as many Read calls as its length needs, before you act. Do not grep, head, tail or sed it, and do not stop partway: the rules, values and open todos you need are spread across all of it.",
+  "2. Only then start the work. Follow what the record establishes: the user's rules and preferences, decisions made, what was finished and what was left for later. Its values (ids, versions, names, commands) are exact.",
+  "",
+  "`eunoe peek <id> <words>` returns just the excerpts of a session that match, for a single fact such as an error message or a value. It is not a substitute for loading when the message continues that session's work.",
+  "",
+  "Loading or peeking needs no permission and no announcement: run it and carry on with the request.",
+].join("\n")
+
+const HANDOFF_PREAMBLE =
+  "What follows is carried over from an earlier session on this project so you can pick the work up without being told again: the user's messages, the key output lines and the agent's replies, in order. Treat the rules and preferences in it as still in force, and the values in it (ids, versions, names, commands) as exact. Its full tool output is not here but stays reachable two ways: when a later message touches it, the matching excerpts are attached to that message as recalled context, labelled with this session's title; and for a specific value you can run `eunoe peek <id> <words>` yourself."
+
+export function handoffBlock(label: string, text: string): string {
+  return `<handoff from="${label}">\n${HANDOFF_PREAMBLE}\n\n${text}\n</handoff>`
+}
+
+export function recalledContext(entries: string[], fromEarlierSessions: boolean): string {
+  const where = fromEarlierSessions ? "earlier in this session or in an earlier session on this project" : "earlier in this session"
+  return `<recalled-context>\nExcerpts from ${where} 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>`
+}
+
+export function rerankQuestion(query: string): string {
+  return `Which excerpt contains the exact answer to the developer's question about this coding session: "${query}"?`
+}
+
+export function toolEvidence(entries: string[]): string {
+  return `<tool-evidence>\nKey lines of command output from this turn, kept verbatim (the full output is in the transcript):\n${entries.join("\n")}\n</tool-evidence>`
+}
+
+export function interruptedReply(lastWords: string | undefined, calls: string[]): string {
+  const shown = calls.slice(-20)
+  return [
+    "[This turn was interrupted before a final reply.]",
+    lastWords ? `Last thing you said: ${lastWords.length > 600 ? `${truncate(lastWords, 600)}…` : 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 clearedOutput(dir: string | null): string {
+  return `[Output cleared to keep the context within its limit. It is in the full transcript${dir ? ` at ${dir}` : ""}: search there for this call.]`
+}
+
+export function clearedInput(kept: string, cleared: number): string {
+  return `${kept}… [${cleared} chars cleared; in the transcript]`
+}
+
+export function compactionNotice({ omitted, kept, guide }: NoticeCounts): string {
   return [
     "<context-compacted>",
     "Your context was compacted here, so tool calls and their output from before this point were removed.",
-    args.omitted > 0
-      ? `${args.omitted} of the oldest turns didn't fit and were removed entirely. The ${args.kept} turn${args.kept === 1 ? "" : "s"} after them are shown as the user's message and your final reply.`
-      : args.kept > 0
+    omitted > 0
+      ? `${omitted} of the oldest turns didn't fit and were removed entirely. The ${plural(kept, "turn")} after them are shown as the user's message and your final reply.`
+      : kept > 0
         ? "Every earlier turn is shown below as the user's message and your final reply."
         : "",
     "The turn that was in progress when the context filled up follows in full. Continue from it.",
     "Instructions and preferences the user gave in earlier turns still apply: how they want things done, and what to do or not do on your own. Look back over their messages before you act.",
     "For an exact detail from before this point (an ID, a path, a command, an error, a value, what a tool printed), look it up instead of going from memory. A lookup is cheap; a wrong detail is not. Never say you don't know about something earlier in this session without searching for it first, and if what you remember contradicts what the user says, search before telling them they are wrong.",
-    args.guide ?? "",
+    guide ?? "",
     "</context-compacted>",
-  ].filter(Boolean).join("\n\n")
+  ]
+    .filter(Boolean)
+    .join("\n\n")
 }
 
-export function truncationNotice(args: NoticeCounts) {
+export function truncationNotice({ omitted, kept, guide }: NoticeCounts): string {
   return [
     "<context-truncated>",
-    `${args.omitted} earlier turn${args.omitted === 1 ? " was" : "s were"} dropped to fit the context window. What follows is the most recent ${args.kept} turn${args.kept === 1 ? "" : "s"}, unchanged.`,
+    `${omitted} earlier turn${omitted === 1 ? " was" : "s were"} dropped to fit the context window. What follows is the most recent ${plural(kept, "turn")}, unchanged.`,
     "Instructions and preferences the user gave in earlier turns still apply.",
-    args.guide ?? "",
+    guide ?? "",
     "</context-truncated>",
-  ].filter(Boolean).join("\n\n")
+  ]
+    .filter(Boolean)
+    .join("\n\n")
 }
 
-export function trimInstructions(guide: string): string {
+export function trimInstructions(guide: string | null): string {
   return [
     "# Context between turns",
     "",
@@ -39,15 +111,19 @@ export function trimInstructions(guide: string): string {
     "- Decisions and their reasons, including approaches you tried and ruled out.",
     "- Where things stand: what is done, what is not, what you verified and how, and what is waiting on the user.",
     "",
-    "It is still your reply to the user, so write it for them, but leave out nothing you will need. State things outright instead of pointing back at tool output: \"as shown above\" means nothing next turn. One exact line (a path, a command, a value) beats a paragraph describing it. A turn that ends on a question still needs the state written down. A trivial turn (a quick answer, small talk) needs no state.",
+    'It is still your reply to the user, so write it for them, but leave out nothing you will need. State things outright instead of pointing back at tool output: "as shown above" means nothing next turn. One exact line (a path, a command, a value) beats a paragraph describing it. A turn that ends on a question still needs the state written down. A trivial turn (a quick answer, small talk) needs no state.',
     "",
     "Instructions and preferences the user gave in earlier turns still apply: how they want things done, and what to do or not do on your own.",
-    "",
-    "Nothing is lost. What you see of earlier turns is only their outcome. For an exact detail from an earlier turn (an ID, a path, a command you ran, what it printed, a file's earlier content, an error), look it up in the full transcript instead of going from memory or redoing the work. A lookup is cheap; a wrong detail is not.",
-    "",
-    guide,
-    "",
-    "What you read from it stays in context for this turn only. If you will need it again later, put it in your final message.",
+    ...(guide
+      ? [
+          "",
+          "Nothing is lost. What you see of earlier turns is only their outcome. For an exact detail from an earlier turn (an ID, a path, a command you ran, what it printed, a file's earlier content, an error), look it up in the full transcript instead of going from memory or redoing the work. A lookup is cheap; a wrong detail is not.",
+          "",
+          guide,
+          "",
+          "What you read from it stays in context for this turn only. If you will need it again later, put it in your final message.",
+        ]
+      : []),
   ].join("\n")
 }
 
@@ -61,6 +137,49 @@ export function searchOnlyInstructions(guide: string): string {
   ].join("\n")
 }
 
-export const CLEARED_OUTPUT = "[Output cleared to keep the context within its limit. It is in the full transcript: search there for this call.]"
-
-export const TRANSCRIPT_FALLBACK = "The full transcript is your Claude Code session file under ~/.claude/projects."
+export function searchGuide(ref: TranscriptRef): string {
+  if (ref.mode === "jsonl") {
+    return [
+      `The full transcript is Claude Code's session file: ${ref.jsonl}`,
+      "It is JSONL, one entry per line. Your tool calls are `tool_use` blocks in `assistant` entries; their output is in the `tool_result` blocks of the `user` entries that follow. It is large: search it narrowly and never read it whole. For example:",
+      `  grep -n 'distinctive text' ${ref.jsonl} | cut -c1-400`,
+      `  jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | "\\(.name) \\(.input | tostring | .[0:200])"' ${ref.jsonl}`,
+    ].join("\n")
+  }
+  const layout =
+    ref.mode === "xml"
+      ? [
+          `The full transcript is a folder with one XML file per turn: ${ref.dir}`,
+          "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
+          "- `turn-0001.xml`, …: one turn each, `<turn n>` with `<user>` (the message), `<said>` (what you wrote while working), `<tool n name>` holding `<call>`, `<input>` and `<output>`, and `<final_reply>`.",
+          "- `turn-0001-subagent-1.xml`, …: the whole run of a subagent launched in that turn, same layout. The turn itself only has the subagent's report; what the subagent saw and ran is here.",
+        ]
+      : [
+          `The full transcript is a folder of markdown files: ${ref.dir}`,
+          "- `index.md`: one line per turn, what the user asked and how the turn ended. Skim it to find the turn you need.",
+          "- `turn-0001.md`, …: one turn each. `## User` (the message), `### [tool 3/12] Bash: …` for every tool call with `[output of tool 3]` below it, and `## Final reply`.",
+          "- `turn-0001-subagent-1.md`, …: the whole run of a subagent launched in that turn, same layout. The turn itself only has the subagent's report; what the subagent saw and ran is here.",
+        ]
+  const habits =
+    "Search for more than one phrasing (the exact term, a synonym, a file or function name, an error string) before you conclude something isn't there. Read the whole turn file around a hit: the answer is often a few calls before or after it."
+  if (ref.mode === "qmd") {
+    return [
+      ...layout,
+      "It is indexed with qmd. Run qmd from inside that folder:",
+      `  cd ${ref.dir} && qmd query "a natural-language question"   # semantic + keyword, best when you don't know the exact words (5–20s)`,
+      `  cd ${ref.dir} && qmd search "exact words"                 # keyword only, instant`,
+      `  then Read ${ref.dir}/turn-NNNN.md (or qmd get turn-NNNN.md)`,
+      "If qmd isn't ready yet (the index builds in the background), grep the folder instead.",
+      habits,
+    ].join("\n")
+  }
+  const ext = ref.mode === "xml" ? "xml" : "md"
+  return [
+    ...layout,
+    "To find something:",
+    `  grep -ril 'distinctive words' ${ref.dir}        # which turns mention it`,
+    `  grep -n -i 'distinctive words' ${ref.dir}/*.${ext} | cut -c1-300`,
+    `  then Read ${ref.dir}/turn-NNNN.${ext}`,
+    habits,
+  ].join("\n")
+}

package/src/context/recall/index.ts

@@ -0,0 +1,214 @@
+import { blocks, clip, describeToolCall, type Message, resultText, textOf } from "../content"
+import { isSalient, toolPairs } from "../fold/evidence"
+import { isPrompt, splitTurns } from "../fold/turns"
+import { recalledContext } from "../prompts"
+
+export interface RecallChunk {
+  turn: number
+  from?: string
+  call: string
+  lines: string[]
+  terms: string[]
+}
+
+export interface RecallOptions {
+  windowLines?: number
+  perQuery?: number
+  minTerms?: number
+  maxChars?: number
+  maxCharsMulti?: number
+  narrative?: boolean
+  callWeight?: number
+  salientExcerpt?: boolean
+  candidates?: number
+}
+
+export interface RecallPick {
+  index: number
+  query: Set<string>
+}
+
+export type Reranker = (query: string, chunks: RecallChunk[], candidates: number[]) => Promise<number[]>
+
+const SHOWN_LINES = 8
+const BM25_K1 = 1.2
+const BM25_B = 0.75
+
+const STOPWORDS = new Set(
+  "the and for with that this what which when where who how was were did does done from into onto have has had you your our out not but are can could would should will just then than them they there their its it's about after before again also any each other some such only own same very more most over under while because been being into".split(
+    " ",
+  ),
+)
+
+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 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 size = options.windowLines ?? 6
+  const weight = Math.max(1, options.callWeight ?? 1)
+  const chunks: RecallChunk[] = []
+  splitTurns(messages)
+    .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 ?? true)) 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 = 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)
+      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
+        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))
+      }
+      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 limit = salient ? SHOWN_LINES + 2 : SHOWN_LINES
+  const shown = new Set<number>()
+  chunk.lines.forEach((line, i) => {
+    if (!terms(line).some((t) => query.has(t))) return
+    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 < limit; i += 1) if (isSalient(chunk.lines[i])) shown.add(i)
+  const ordered = [...shown].sort((a, b) => a - b).slice(0, limit)
+  return (ordered.length > 0 ? ordered : [0]).map((i) => clip(chunk.lines[i], 240)).filter(Boolean)
+}
+
+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]
+}
+
+function merged(hits: Array<{ query: string[]; indices: number[] }>): RecallPick[] {
+  const picked = new Map<number, Set<string>>()
+  for (const { query, indices } of hits) {
+    for (const index of indices) {
+      const matched = picked.get(index) ?? new Set()
+      for (const term of query) matched.add(term)
+      picked.set(index, matched)
+    }
+  }
+  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 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) }
+    }),
+  )
+}
+
+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))
+    hits.push({ query, indices: reordered.slice(0, options.perQuery ?? 12) })
+  }
+  return merged(hits)
+}
+
+export function renderRecall(prompt: string, chunks: RecallChunk[], picks: RecallPick[], options: RecallOptions = {}): string | null {
+  if (picks.length === 0) return null
+  const budget = queriesOf(prompt).length > 1 ? (options.maxCharsMulti ?? 30_000) : (options.maxChars ?? 18_000)
+  const entries: string[] = []
+  let used = 0
+  for (const { index, query } of [...picks].sort((a, b) => chunks[a.index].turn - chunks[b.index].turn || a.index - b.index)) {
+    const chunk = chunks[index]
+    const where = chunk.from ? `${chunk.from}, turn ${chunk.turn}` : `turn ${chunk.turn}`
+    const lines = excerpt(chunk, query, options.salientExcerpt ?? true).map((l) => `    ${l}`)
+    const entry = `[${where}] ${chunk.call}:\n${lines.join("\n")}`
+    if (used + entry.length > budget) continue
+    entries.push(entry)
+    used += entry.length
+  }
+  if (entries.length === 0) return null
+  return recalledContext(
+    entries,
+    picks.some((p) => Boolean(chunks[p.index].from)),
+  )
+}
+
+export function recallFor(prompt: string, chunks: RecallChunk[], options: RecallOptions = {}): string | null {
+  if (chunks.length === 0) 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 === 0) 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)
+  const live = turns.at(-1)
+  if (!live || !isPrompt(live[0])) return null
+  const index = preamble.length + turns.slice(0, -1).reduce((s, t) => s + t.length, 0)
+  const text = textOf(live[0])
+    .replace(/<(system-reminder|system-message|recalled-context|tool-evidence|handoff)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, "")
+    .trim()
+  return { index, text }
+}
+
+export function withRecall(messages: Message[], fingerprint: (message: Message) => string, recalls: Record<string, string>): Message[] {
+  if (Object.keys(recalls).length === 0) 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/recall/rerank.ts

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync } from "node:fs"
+import { paths } from "../../config/paths"
+import { rerankQuestion } from "../prompts"
+import type { RecallChunk, Reranker } from "."
+
+interface RerankAnswer {
+  answers?: { where?: { probabilities?: Record<string, number> } }
+}
+
+const TIMEOUT_MS = 4_000
+
+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
+}
+
+function rerankState(chunks: RecallChunk[], candidates: number[]): string {
+  return candidates
+    .map((index, n) => {
+      const chunk = chunks[index]
+      return `### ${n}\n[turn ${chunk.turn}] ${chunk.call}\n${chunk.lines.map((l) => l.slice(0, 240)).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])
+}
+
+function failureReason(error: unknown): string {
+  if (!(error instanceof Error)) return String(error)
+  return error.name === "TimeoutError" ? `timeout after ${TIMEOUT_MS}ms` : error.message
+}
+
+export function jevReranker(model: string, key: string, endpoint = "https://api.typesafe.ai/v1/systemone", onError?: (reason: string) => void): 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(TIMEOUT_MS),
+        body: JSON.stringify({
+          model,
+          state: rerankState(chunks, candidates),
+          questions: {
+            where: {
+              type: "choice",
+              instructions: rerankQuestion(query),
+              criteria: Object.fromEntries(candidates.map((_, n) => [String(n), null])),
+            },
+          },
+        }),
+      })
+      if (!response.ok) {
+        const body = await response.text().catch(() => "")
+        onError?.(`${response.status} ${/error_type"\s*:\s*"([^"]+)/.exec(body)?.[1] ?? body.slice(0, 60)}`.trim())
+        return candidates
+      }
+      const probabilities = ((await response.json()) as RerankAnswer).answers?.where?.probabilities
+      return probabilities && typeof probabilities === "object" ? orderByProbability(candidates, probabilities) : candidates
+    } catch (error) {
+      onError?.(failureReason(error))
+      return candidates
+    }
+  }
+}

package/src/proxy/canonical.ts

@@ -1,21 +1,29 @@
 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"
+import type { Body } from "../context/content"
 
-const billingLine = (system: Body["system"]) => {
+interface Canonical {
+  system: Body["system"]
+  tools: Body["tools"]
+}
+
+export interface CanonicalResult {
+  body: Body
+  status: "applied" | "captured" | "skipped"
+}
+
+const BILLING_LINE = /^x-anthropic-billing-header:[^\n]*/
+
+function billingLine(system: Body["system"]): string | null {
   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)
+  if (!Array.isArray(system)) return String(system ?? "").replace(BILLING_LINE, line)
+  const [first, ...rest] = system
+  return [{ ...first, text: String(first?.text ?? "").replace(BILLING_LINE, line) }, ...rest]
 }
 
 export function applyCanonical(body: Body, file: string): CanonicalResult {