@chroxify/eunoe 0.1.0 → 1.1.0

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

@@ -0,0 +1,40 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import type { Body } from "../context/content"
+
+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)) 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 {
+  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

@@ -1,75 +1,144 @@
-import { CLEARED_OUTPUT } from "../context/prompts"
-import { clearToolResults, compactMessages, countToolResults } from "../context/strategies"
-import { splitTurns, turnFingerprint } from "../context/turns"
-import { DEFAULT_RATIO, PROTECTED_OUTPUTS } from "./constants"
-import { estimator, targetSize } from "./estimate"
-import { resetCut } from "./state"
-import type { CompactInput, CompactResult } from "./types"
-
-export function compact({ body, config, state, window, guide, mayCompact, omittedBefore = 0 }: CompactInput): CompactResult {
-  const { turns } = splitTurns(body.messages)
-  let stateChanged = false
+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 { clearedOutput } from "../context/prompts"
+import { DEFAULT_RATIO, type Estimator, estimator, targetSize } from "./estimate"
+import { resetCut, type ThreadState } from "./state"
+
+export interface CompactInput {
+  body: Body
+  config: Config
+  state: ThreadState
+  window: number | null
+  guide: string | null
+  transcriptDir?: string | null
+  mayCompact: boolean
+  omittedBefore?: number
+  decorate?: (messages: Message[]) => Message[]
+  reduce?: CompactOptions["reduce"]
+}
+
+export interface CompactResult {
+  messages: Message[]
+  stateChanged: boolean
+  note: Record<string, unknown>
+}
+
+interface Rolling {
+  keep: number
+  budget: number
+}
 
+const PROTECTED_OUTPUTS = 5
+
+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
+}
+
+function resolveCut(turns: Message[][], state: ThreadState, config: Config, rollingKeep: number | undefined) {
   let cutIndex = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1
+  let stateChanged = false
   if (state.cut && cutIndex === -1) {
     resetCut(state)
     stateChanged = true
   }
   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
-    cutIndex = forced
-    state.cut = turnFingerprint(turns[forced])
+    cutIndex = settledCut(turns, Math.max(1, turns.length - 1 - (rollingKeep ?? 1)))
+    state.cut = turnFingerprint(turns[cutIndex])
     stateChanged = true
   }
+  return { cutIndex, stateChanged }
+}
+
+function shrinkOnce(state: ThreadState, cutIndex: number, configuredKeep: number, liveResults: () => number): string {
+  const keep = Math.min(state.keep ?? configuredKeep, cutIndex - 1)
+  if (cutIndex > 0 && keep > 0) {
+    state.keep = keep - 1
+    return `keep=${state.keep}`
+  }
+  const remaining = liveResults() - (state.cleared ?? 0) - PROTECTED_OUTPUTS
+  if (remaining <= 0) return "stuck"
+  state.cleared = (state.cleared ?? 0) + Math.ceil(remaining / 2)
+  return `cleared=${state.cleared}`
+}
+
+function dueRoll(turns: Message[][], cutIndex: number, rolling: Rolling, size: Estimator): number | null {
+  const next = settledCut(turns, turns.length - 1 - rolling.keep)
+  const backlog = size.of(turns.slice(Math.max(cutIndex, 0), Math.max(next, 0)).flat()) - size.fixed
+  return next >= 1 && next > cutIndex && backlog > rolling.budget ? next : null
+}
+
+function shrinkToTarget(over: () => boolean, step: () => string, actions: string[], rebuild: () => void) {
+  while (over()) {
+    const action = step()
+    actions.push(action)
+    if (action === "stuck") return
+    rebuild()
+  }
+}
+
+export function compact({ body, config, state, window, guide, transcriptDir, mayCompact, omittedBefore = 0, decorate = (m) => m, reduce }: CompactInput): CompactResult {
+  const { turns } = splitTurns(body.messages)
+  const rolling = config.eval?.rolling ?? (config.mode === "default" ? { keep: config.keep, budget: config.budget } : undefined)
+  const resolved = resolveCut(turns, state, config, rolling?.keep)
+  let cutIndex = resolved.cutIndex
+  let stateChanged = resolved.stateChanged
 
   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 })
-    : body.messages
+  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 liveStart = (list: Message[]) =>
+    list.length -
+    splitTurns(list)
+      .turns.slice(-(turns.length - Math.max(cutIndex, 0)))
+      .flat().length
+  const compacted = () => capTurns(cutIndex > 0 ? compactMessages(body.messages, cutIndex, { ...options, keepTurns: state.keep ?? configuredKeep }) : body.messages, { ...options, keepTurns: 0 })
   const build = () => {
     const messages = compacted()
-    return state.cleared ? clearToolResults(messages, messages.length - liveLength(), state.cleared, CLEARED_OUTPUT) : messages
+    return state.cleared ? clearToolResults(messages, liveStart(messages), state.cleared, clearedOutput(transcriptDir ?? null)) : messages
+  }
+  const liveResults = () => {
+    const uncleared = compacted()
+    return countToolResults(uncleared, liveStart(uncleared))
   }
 
-  const size = estimator(body, state.ratio ?? DEFAULT_RATIO)
+  const size = estimator(body, ratio)
   const limit = window ? config.compactAt * window : Number.POSITIVE_INFINITY
   const target = window ? targetSize(size, window) : Number.POSITIVE_INFINITY
 
   let messages = build()
-  let estimate = size.of(messages)
+  let estimate = size.of(decorate(messages))
   const actions: string[] = []
-  const current = turns.length - 1
+  const rebuild = () => {
+    messages = build()
+    estimate = size.of(decorate(messages))
+  }
+  const moveCut = (index: number, action: string) => {
+    cutIndex = index
+    resetCut(state)
+    state.cut = turnFingerprint(turns[index])
+    actions.push(action)
+    rebuild()
+  }
+
+  const roll = mayCompact && rolling ? dueRoll(turns, cutIndex, rolling, size) : null
+  if (roll !== null) {
+    moveCut(roll, "roll")
+    stateChanged = true
+  }
 
   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)
-    }
-    while (estimate > target) {
-      const keep = Math.min(state.keep ?? configuredKeep, cutIndex - 1)
-      if (cutIndex > 0 && keep > 0) {
-        state.keep = keep - 1
-        actions.push(`keep=${state.keep}`)
-      } else {
-        const unclearedLive = compacted()
-        const total = countToolResults(unclearedLive, unclearedLive.length - liveLength())
-        const remaining = total - (state.cleared ?? 0) - PROTECTED_OUTPUTS
-        if (remaining <= 0) {
-          actions.push("stuck")
-          break
-        }
-        state.cleared = (state.cleared ?? 0) + Math.ceil(remaining / 2)
-        actions.push(`cleared=${state.cleared}`)
-      }
-      messages = build()
-      estimate = size.of(messages)
-    }
+    const current = turns.length - 1
+    if (current > 0 && current > cutIndex) moveCut(current, "cut")
+    shrinkToTarget(
+      () => estimate > target,
+      () => shrinkOnce(state, cutIndex, configuredKeep, liveResults),
+      actions,
+      rebuild,
+    )
     stateChanged = true
   }
 
@@ -78,9 +147,10 @@ export function compact({ body, config, state, window, guide, mayCompact, omitte
     stateChanged,
     note: {
       action: cutIndex > 0 ? "compact" : "full",
-      compacted: actions.includes("cut"),
-      actions: actions.length ? actions : undefined,
+      compacted: actions.includes("cut") || actions.includes("roll"),
+      actions: actions.length > 0 ? actions : undefined,
       cutTurn: cutIndex > 0 ? cutIndex : null,
+      omitted: cutIndex > 0 ? Math.max(1, cutIndex - (state.keep ?? configuredKeep)) - 1 : 0,
       keep: state.keep,
       cleared: state.cleared,
       turns: turns.length,

package/src/proxy/estimate.ts

@@ -1,15 +1,20 @@
-import type { Body, Message } from "../context/types"
-import { MEDIA_CHARS, MEDIA_MIN_LENGTH, TARGET_SHARE } from "./constants"
-import type { Estimator } from "./types"
+import type { Body, Message } from "../context/content"
+
+export interface Estimator {
+  of: (messages: Message[]) => number
+  fixed: number
+}
+
+export const DEFAULT_RATIO = 1 / 3.6
+
+const MEDIA_CHARS = 5_800
 
 export function sizeOf(body: Pick<Body, "system" | "tools" | "messages">): number {
   let media = 0
   const json = JSON.stringify({ system: body.system, tools: body.tools, messages: body.messages }, (key, value) => {
-    if (key === "data" && typeof value === "string" && value.length > MEDIA_MIN_LENGTH) {
-      media += 1
-      return ""
-    }
-    return value
+    if (key !== "data" || typeof value !== "string" || value.length <= 2_000) return value
+    media += 1
+    return ""
   })
   return json.length + media * MEDIA_CHARS
 }
@@ -22,5 +27,5 @@ export function estimator(body: Body, ratio: number): Estimator {
 }
 
 export function targetSize(size: Estimator, window: number): number {
-  return size.fixed + TARGET_SHARE * Math.max(0, window - size.fixed)
+  return size.fixed + 0.3 * Math.max(0, window - size.fixed)
 }

package/src/proxy/fingerprint.ts

@@ -0,0 +1,29 @@
+import { type Body, blocks, type Message, shortHash, withoutCacheControl } from "../context/content"
+
+export interface ContextFingerprint {
+  system: string
+  tools: string
+  skills: string[]
+  given?: ContextFingerprint
+}
+
+export const isInjected = (text: unknown) => /^<(?:recalled-context|handoff)[\s>]/.test(String(text ?? ""))
+
+export function messageFingerprint(message: Message) {
+  const own = blocks(message)
+    .filter((b) => !(b.type === "text" && isInjected(b.text)))
+    .map(withoutCacheControl)
+  return shortHash(JSON.stringify(own), 24)
+}
+
+const hash = (value: unknown) =>
+  shortHash(
+    JSON.stringify(value ?? null, (key, inner) => (key === "cache_control" ? undefined : inner)),
+    12,
+  )
+
+export function contextFingerprint(body: Body): ContextFingerprint {
+  const skills = new Set<string>()
+  for (const match of JSON.stringify(body.messages ?? []).matchAll(/Base directory for this skill: ([^\s"\\]+)/g)) skills.add(match[1].split("/").at(-1) ?? match[1])
+  return { system: hash(body.system), tools: hash(body.tools), skills: [...skills].sort() }
+}

package/src/proxy/handoff.ts

@@ -0,0 +1,71 @@
+import { statSync } from "node:fs"
+import { type Config, claudeConfigDirs } from "../config"
+import { blocks, type Message } from "../context/content"
+import { FOLD_CAP_CHARS, foldedView, sourceChunks } from "../context/fold"
+import { isPrompt } from "../context/fold/turns"
+import { handoffBlock } from "../context/prompts"
+import type { RecallChunk } from "../context/recall"
+import { findSessionByPrefix } from "../transcript/locate"
+import { sessionMessages } from "../transcript/messages"
+import { isInjected, messageFingerprint } from "./fingerprint"
+import { titleOf } from "./sessions"
+import type { Handoff, ThreadState } from "./state"
+
+const sourceCache = new Map<string, { mtime: number; chunks: RecallChunk[] }>()
+
+export const continueToken = (id: string) => `{ee:continue:${id}}`
+
+export function continueIdOf(message: Message): string | null {
+  if (!isPrompt(message)) return null
+  const own = blocks(message)
+    .filter((b) => b.type === "text" && !isInjected(b.text))
+    .map((b) => String(b.text ?? ""))
+    .join("\n")
+  return own.match(/\{ee:continue:([A-Za-z0-9-]{8,})\}/)?.[1] ?? null
+}
+
+export function activeHandoffs(handoffs: Record<string, Handoff | null> = {}): Record<string, Handoff> {
+  return Object.fromEntries(Object.entries(handoffs).filter((entry): entry is [string, Handoff] => Boolean(entry[1])))
+}
+
+export function attachHandoffs(messages: Message[], config: Config, sessionId: string | null, state: ThreadState): boolean {
+  let changed = false
+  for (const message of messages) {
+    const id = continueIdOf(message)
+    if (!id) continue
+    const key = messageFingerprint(message)
+    if (state.handoffs && key in state.handoffs) continue
+    state.handoffs ??= {}
+    const file = findSessionByPrefix(id, claudeConfigDirs(config), sessionId ?? undefined)
+    const already = Object.values(state.handoffs).some((h) => h?.source === file)
+    state.handoffs[key] = file && !already ? { label: titleOf(file) ?? id, source: file, text: foldedView(sessionMessages(file), FOLD_CAP_CHARS) } : null
+    changed = true
+  }
+  return changed
+}
+
+export function withHandoffs(messages: Message[], handoffs: Record<string, Handoff>): Message[] {
+  if (Object.keys(handoffs).length === 0) return messages
+  return messages.map((message) => {
+    if (!isPrompt(message)) return message
+    const handoff = handoffs[messageFingerprint(message)]
+    return handoff ? { ...message, content: [{ type: "text", text: handoffBlock(handoff.label, handoff.text) }, ...blocks(message)] } : message
+  })
+}
+
+export function handoffChunks(handoffs: Record<string, Handoff>): RecallChunk[] {
+  const sources = new Map<string, string>()
+  for (const handoff of Object.values(handoffs)) if (!sources.has(handoff.source)) sources.set(handoff.source, handoff.label)
+  return [...sources].flatMap(([source, label]) => {
+    let mtime: number
+    try {
+      mtime = statSync(source).mtimeMs
+    } catch {
+      return []
+    }
+    const cached = sourceCache.get(source)
+    const chunks = cached?.mtime === mtime ? cached.chunks : sourceChunks(sessionMessages(source), label, true)
+    sourceCache.set(source, { mtime, chunks })
+    return chunks
+  })
+}