@chroxify/eunoe 1.3.0 → 1.3.1

package/dist/types/context/fold/strategies.d.ts

@@ -8,7 +8,7 @@ export interface CompactOptions extends ReduceOptions {
     reduce?: (turn: Message[], options: ReduceOptions) => Message[];
     pinned?: ReadonlySet<string>;
 }
-export declare const countPinned: (turns: Message[][], pinned: ReadonlySet<string>) => number;
+export declare const countPinned: (keys: string[], pinned: ReadonlySet<string>) => number;
 export declare function trimMessages(messages: Message[], options?: ReduceOptions): Message[];
 export declare const CARRIED_CHARS = 80000;
 export declare const foldsOpening: (opening: Message[], keptFrom: number) => boolean;

package/dist/types/context/fold/turns.d.ts

@@ -9,6 +9,8 @@ export declare function splitTurns(messages: Message[]): {
     turns: Message[][];
 };
 export declare function turnFingerprint(turn: Message[]): string;
+export declare function turnKeys(turns: Message[][]): string[];
+export declare const fingerprintOfKey: (key: string) => string;
 export declare function isHarness(message: Message): boolean;
 export declare function hasContent(message: Message): boolean;
 export declare function reduceTurn(turn: Message[], options?: ReduceOptions): Message[];

package/dist/types/context/recall/index.d.ts

@@ -12,6 +12,8 @@ export interface RecallOptions {
     minTerms?: number;
     maxChars?: number;
     maxCharsMulti?: number;
+    maxCharsTotal?: number;
+    charsInUse?: number;
     narrative?: boolean;
     callWeight?: number;
     salientExcerpt?: boolean;
@@ -22,6 +24,7 @@ export interface RecallPick {
     query: Set<string>;
 }
 export type Reranker = (query: string, chunks: RecallChunk[], candidates: number[]) => Promise<number[]>;
+export declare const RECALL_CHARS_TOTAL = 30000;
 export declare function terms(text: string): string[];
 export declare function recallChunks(messages: Message[], keptIds: Map<string, string>, options?: RecallOptions): RecallChunk[];
 interface RankedChunk {

package/dist/types/core/config.d.ts

@@ -3,6 +3,7 @@ interface EvalConfig {
     recallOptions?: {
         maxChars?: number;
         maxCharsMulti?: number;
+        maxCharsTotal?: number;
         perQuery?: number;
     };
     strategy?: "tail" | "guide" | "trim";

package/dist/types/core/recall.d.ts

@@ -4,5 +4,6 @@ export declare const wantsRecall: (input: RewriteInput) => boolean;
 export declare const activeRecalls: (recalls?: Record<string, string>) => {
     [k: string]: string;
 };
+export declare function dropLiveRecall(input: RewriteInput, threadKey: string): void;
 export declare function applyRecall(input: RewriteInput, result: Rewrite): Rewrite;
 export declare function prefetchFor(input: RewriteInput, result: Rewrite, rerank: Reranker): Promise<number | null>;

package/dist/types/core/rewrite.d.ts

@@ -54,10 +54,10 @@ export interface Rewrite {
     note: RewriteNote;
 }
 export declare function threadKeyOf(threadId: string, messages: Message[]): string | null;
-export declare function rewrite(input: RewriteInput, before?: Rewrite): Rewrite;
-export declare function prefetchRecall(input: RewriteInput, rerank: Reranker): Promise<{
+export declare function rewrite(given: RewriteInput, before?: Rewrite): Rewrite;
+export declare function prefetchRecall(given: RewriteInput, rerank: Reranker): Promise<{
     reranked: boolean;
     rerankError: null;
     recalled: number;
 } | null>;
-export declare function rewriteAsync(input: RewriteInput, rerank?: Reranker): Promise<Rewrite>;
+export declare function rewriteAsync(given: RewriteInput, rerank?: Reranker): Promise<Rewrite>;

package/dist/types/core/state.d.ts

@@ -1,3 +1,4 @@
+import type { Message } from "../context/content.js";
 export interface Handoff {
     label: string;
     source: string;
@@ -12,6 +13,7 @@ export interface ThreadState {
     host?: boolean;
     pins?: string[];
     ratio?: number;
+    limits?: Record<string, number>;
     recalls?: Record<string, string>;
 }
 export interface ThreadStore {
@@ -19,4 +21,5 @@ export interface ThreadStore {
     save: (key: string, state: ThreadState) => void;
 }
 export declare function memoryStore(initial?: Record<string, ThreadState>): ThreadStore;
+export declare function retireRecalls(state: ThreadState, folded: Message[][]): void;
 export declare function resetCut(state: ThreadState): void;

package/dist/types/core/usage.d.ts

@@ -4,4 +4,5 @@ export type Usage = Record<string, number>;
 export declare function watchUsage(response: Response, onUsage: (usage: Usage) => void): Response;
 export declare function inputTokens(usage: Usage): number;
 export declare function recordUsage(store: ThreadStore, threadKey: string, sent: Body | number, usage: Usage): boolean;
-export declare function recordOverflow(store: ThreadStore, threadKey: string, sent: Body | number, errorText: string): number | null;
+export declare const limitKey: (model: unknown) => string;
+export declare function recordOverflow(store: ThreadStore, threadKey: string, sent: Body | number, errorText: string, model?: unknown): number | null;

package/dist/types/core/window.d.ts

@@ -1,5 +1,8 @@
 export type WindowLookup = (model: unknown, requestHeaders: Headers, upstream?: string) => Promise<number | null>;
-export declare function createWindowLookup({ known, onLearn }?: {
+export interface WindowLookupOptions {
     known?: Map<string, number>;
     onLearn?: (windows: Map<string, number>) => void;
-}): WindowLookup;
+    timeoutMs?: number;
+    retryAfterMs?: number;
+}
+export declare function createWindowLookup({ known, onLearn, timeoutMs, retryAfterMs }?: WindowLookupOptions): WindowLookup;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chroxify/eunoe",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Context management for Claude Code that never forgets what matters.",
   "license": "MIT",
   "repository": {

package/src/context/fold/strategies.ts

@@ -1,6 +1,6 @@
 import { type Block, type Body, blocks, clean, type Message, truncate, withoutCacheControl } from "../content"
 import { clearedInput, compactionNotice, truncationNotice } from "../prompts"
-import { hasContent, isHarness, isStaleNote, type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "./turns"
+import { fingerprintOfKey, hasContent, isHarness, isStaleNote, type ReduceOptions, reduceTurn, splitTurns, turnFingerprint, turnKeys } from "./turns"
 
 export interface CompactOptions extends ReduceOptions {
   keepTurns: number
@@ -11,12 +11,19 @@ export interface CompactOptions extends ReduceOptions {
   pinned?: ReadonlySet<string>
 }
 
-const pinnedBy =
-  ({ pinned }: CompactOptions) =>
-  (turn: Message[]) =>
-    pinned !== undefined && pinned.size > 0 && pinned.has(turnFingerprint(turn))
+function pinnedAt(turns: Message[][], { pinned }: CompactOptions): (index: number) => boolean {
+  if (pinned === undefined || pinned.size === 0) return () => false
+  const keys = turnKeys(turns)
+  return (index) => pinned.has(keys[index])
+}
+
+function pinnedPrompt({ pinned }: CompactOptions): (turn: Message[]) => boolean {
+  if (pinned === undefined || pinned.size === 0) return () => false
+  const fingerprints = new Set([...pinned].map(fingerprintOfKey))
+  return (turn) => fingerprints.has(turnFingerprint(turn))
+}
 
-export const countPinned = (turns: Message[][], pinned: ReadonlySet<string>) => (pinned.size > 0 ? turns.filter((turn) => pinned.has(turnFingerprint(turn))).length : 0)
+export const countPinned = (keys: string[], pinned: ReadonlySet<string>) => (pinned.size > 0 ? keys.filter((key) => pinned.has(key)).length : 0)
 
 export function trimMessages(messages: Message[], options: ReduceOptions = {}): Message[] {
   const { preamble, turns } = splitTurns(messages)
@@ -50,18 +57,19 @@ export function compactMessages(messages: Message[], cutIndex: number, options:
   const { preamble, turns } = splitTurns(messages)
   if (cutIndex <= 0 || cutIndex >= turns.length) return messages
   const reduce = options.reduce ?? reduceTurn
-  const isPinned = pinnedBy(options)
+  const isPinned = pinnedAt(turns, options)
+  const indexed = turns.map((turn, index) => ({ turn, pinned: isPinned(index) }))
   const keptFrom = Math.max(1, cutIndex - options.keepTurns)
   const [first, ...rest] = turns[0]
-  const openingPinned = isPinned(turns[0])
+  const openingPinned = indexed[0].pinned
   const openingFolded = !openingPinned && foldsOpening(turns[0], keptFrom)
-  const dropped = turns.slice(1, keptFrom)
-  const whole = dropped.filter(isPinned)
-  const pinned = whole.length + turns.slice(keptFrom, cutIndex).filter(isPinned).length + (openingPinned ? 1 : 0)
+  const dropped = indexed.slice(1, keptFrom)
+  const whole = dropped.filter((t) => t.pinned).map((t) => t.turn)
+  const pinned = whole.length + indexed.slice(keptFrom, cutIndex).filter((t) => t.pinned).length + (openingPinned ? 1 : 0)
   const kept = cutIndex - keptFrom + (openingFolded ? 1 : 0)
   const notice = compactionNotice({ omitted: dropped.length - whole.length + (options.omittedBefore ?? 0), kept, pinned, guide: options.guide })
-  const removed = [...(openingPinned || openingFolded ? [] : rest), ...dropped.filter((turn) => !isPinned(turn)).flat()]
-  const shown = (turn: Message[]) => (isPinned(turn) ? turn.map(clean) : reduce(turn, options))
+  const removed = [...(openingPinned || openingFolded ? [] : rest), ...dropped.filter((t) => !t.pinned).flatMap((t) => t.turn)]
+  const shown = (t: { turn: Message[]; pinned: boolean }) => (t.pinned ? t.turn.map(clean) : reduce(t.turn, options))
   return [
     ...preamble,
     first,
@@ -69,7 +77,7 @@ export function compactMessages(messages: Message[], cutIndex: number, options:
     { role: "user", content: [{ type: "text", text: notice }, ...carriedHarness(removed)] },
     ...(openingFolded ? reduce(turns[0], options).slice(1) : []),
     ...whole.flatMap((turn) => turn.map(clean)),
-    ...turns.slice(keptFrom, cutIndex).flatMap(shown),
+    ...indexed.slice(keptFrom, cutIndex).flatMap(shown),
     ...turns.slice(cutIndex).flat(),
   ]
 }
@@ -80,7 +88,7 @@ export function capTurns(messages: Message[], options: CompactOptions): Message[
   const { preamble, turns } = splitTurns(messages)
   if (turns.length < 3) return messages
   const live = turns.length - 1
-  const isPinned = pinnedBy(options)
+  const isPinned = pinnedPrompt(options)
   const over = (turn: Message[], i: number) => i > 0 && i < live && !isPinned(turn) && JSON.stringify(turn).length > capChars
   if (!turns.some(over)) return messages
   const reduce = options.reduce ?? reduceTurn

package/src/context/fold/turns.ts

@@ -37,6 +37,18 @@ export function turnFingerprint(turn: Message[]): string {
   return shortHash(JSON.stringify(blocks(turn[0]).map(withoutCacheControl)), 24)
 }
 
+export function turnKeys(turns: Message[][]): string[] {
+  const copies = new Map<string, number>()
+  return turns.map((turn) => {
+    const fingerprint = turnFingerprint(turn)
+    const earlier = copies.get(fingerprint) ?? 0
+    copies.set(fingerprint, earlier + 1)
+    return earlier === 0 ? fingerprint : `${fingerprint}~${earlier}`
+  })
+}
+
+export const fingerprintOfKey = (key: string) => key.split("~")[0]
+
 export function isHarness(message: Message) {
   return message.role === "system"
 }

package/src/context/recall/index.ts

@@ -17,6 +17,8 @@ export interface RecallOptions {
   minTerms?: number
   maxChars?: number
   maxCharsMulti?: number
+  maxCharsTotal?: number
+  charsInUse?: number
   narrative?: boolean
   callWeight?: number
   salientExcerpt?: boolean
@@ -30,6 +32,8 @@ export interface RecallPick {
 
 export type Reranker = (query: string, chunks: RecallChunk[], candidates: number[]) => Promise<number[]>
 
+export const RECALL_CHARS_TOTAL = 30_000
+
 const SHOWN_LINES = 8
 const BM25_K1 = 1.2
 const BM25_B = 0.75
@@ -388,7 +392,8 @@ export async function pickRecallWith(prompt: string, chunks: RecallChunk[], rera
 
 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 own = queriesOf(prompt).length > 1 ? (options.maxCharsMulti ?? 30_000) : (options.maxChars ?? 18_000)
+  const budget = Math.min(own, (options.maxCharsTotal ?? RECALL_CHARS_TOTAL) - (options.charsInUse ?? 0))
   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)) {

package/src/core/compaction.ts

@@ -1,11 +1,11 @@
 import { type Body, type Message, quickHash } from "../context/content"
 import { type CompactOptions, capTurns, clearToolResults, compactMessages, countPinned, countToolResults, foldsOpening } from "../context/fold/strategies"
-import { type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "../context/fold/turns"
+import { type ReduceOptions, reduceTurn, splitTurns, turnKeys } from "../context/fold/turns"
 import { clearedOutput } from "../context/prompts"
 import type { CoreConfig } from "./config"
 import { DEFAULT_RATIO, type Estimator, estimator, targetSize } from "./estimate"
 import type { RewriteNote } from "./rewrite"
-import { resetCut, type ThreadState } from "./state"
+import { resetCut, retireRecalls, type ThreadState } from "./state"
 
 export interface CompactInput {
   body: Body
@@ -51,16 +51,14 @@ interface Rolling {
 
 const PROTECTED_OUTPUTS = 5
 
-const STUCK_STEP = 0.1
-
 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: CoreConfig, rollingKeep: number | undefined) {
-  let cutIndex = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1
+function resolveCut(turns: Message[][], keys: string[], state: ThreadState, config: CoreConfig, rollingKeep: number | undefined) {
+  let cutIndex = state.cut ? keys.indexOf(state.cut) : -1
   let stateChanged = false
   if (state.cut && cutIndex === -1) {
     resetCut(state)
@@ -68,7 +66,8 @@ function resolveCut(turns: Message[][], state: ThreadState, config: CoreConfig,
   }
   if (cutIndex <= 0 && config.eval?.forceCut && turns.length >= 3) {
     cutIndex = settledCut(turns, Math.max(1, turns.length - 1 - (rollingKeep ?? 1)))
-    state.cut = turnFingerprint(turns[cutIndex])
+    state.cut = keys[cutIndex]
+    retireRecalls(state, turns.slice(0, cutIndex))
     stateChanged = true
   }
   return { cutIndex, stateChanged }
@@ -92,39 +91,69 @@ function dueRoll(turns: Message[][], cutIndex: number, rolling: Rolling, size: E
   return next >= 1 && next > cutIndex && backlog > rolling.budget ? next : null
 }
 
-function shrinkToTarget(over: () => boolean, step: () => string, actions: string[], rebuild: () => void): boolean {
+function shrinkToTarget(over: () => boolean, step: () => string, actions: string[], rebuild: () => void) {
   while (over()) {
     const action = step()
     actions.push(action)
-    if (action === "stuck") return true
+    if (action === "stuck") return
     rebuild()
   }
-  return false
 }
 
-const holdsStuck = (state: ThreadState, estimate: number, window: number | null) => window !== null && state.stuck !== undefined && estimate <= state.stuck + STUCK_STEP * window
+interface Shrink {
+  estimate: () => number
+  step: () => string
+  rebuild: () => void
+  target: number
+  limit: number
+  window: number | null
+}
+
+function shrinkOrHold(state: ThreadState, actions: string[], shrink: Shrink) {
+  const overWindow = (tokens: number) => shrink.window !== null && tokens > shrink.window
+  const held = state.stuck === undefined ? null : { keep: state.keep, cleared: state.cleared, actions: actions.length, overWindow: overWindow(shrink.estimate()) }
+  shrinkToTarget(() => shrink.estimate() > shrink.target, shrink.step, actions, shrink.rebuild)
+  const helped = (estimate: number) => estimate <= shrink.limit || (held?.overWindow === true && !overWindow(estimate))
+  if (held && !helped(shrink.estimate())) {
+    restoreShrink(state, held)
+    actions.length = held.actions
+    shrink.rebuild()
+  }
+  if (shrink.estimate() > shrink.limit) state.stuck = shrink.estimate()
+  else {
+    delete state.stuck
+    if (actions.at(-1) === "stuck") actions.pop()
+  }
+}
+
+function restoreShrink(state: ThreadState, held: Pick<ThreadState, "keep" | "cleared">) {
+  if (held.keep === undefined) delete state.keep
+  else state.keep = held.keep
+  if (held.cleared === undefined) delete state.cleared
+  else state.cleared = held.cleared
+}
 
 export type StuckSizes = ReturnType<typeof stuckSizes>
 
-const headLength = (preamble: Message[], first: Message[], state: ThreadState) => preamble.length + 1 + (countPinned([first], new Set(state.pins)) > 0 ? first.length : 1)
+const headLength = (preamble: Message[], first: Message[], firstKey: string, state: ThreadState) => preamble.length + 1 + (countPinned([firstKey], new Set(state.pins)) > 0 ? first.length : 1)
 
 function stuckSizes(messages: Message[], headEnd: number, liveFrom: number, size: Estimator) {
   const of = (list: Message[]) => size.of(list) - size.fixed
   return { fixed: size.fixed, head: of(messages.slice(0, headEnd)), folded: of(messages.slice(headEnd, liveFrom)), live: of(messages.slice(liveFrom)) }
 }
 
-function cutNote(state: ThreadState, turns: Message[][], cutIndex: number, configuredKeep: number, actions: string[]) {
+function cutNote(state: ThreadState, turns: Message[][], keys: string[], cutIndex: number, configuredKeep: number, actions: string[]) {
   const pins = new Set(state.pins)
   const keptFrom = cutIndex > 0 ? Math.max(1, cutIndex - (state.keep ?? configuredKeep)) : 0
-  const omitted = cutIndex > 0 ? keptFrom - 1 - countPinned(turns.slice(1, keptFrom), pins) : 0
+  const omitted = cutIndex > 0 ? keptFrom - 1 - countPinned(keys.slice(1, keptFrom), pins) : 0
   return {
     action: cutIndex > 0 ? ("compact" as const) : ("full" as const),
     compacted: actions.includes("cut") || actions.includes("roll"),
     actions: actions.length > 0 ? actions : undefined,
     cutTurn: cutIndex > 0 ? cutIndex : null,
     omitted,
-    folded: cutIndex > 0 ? cutIndex - keptFrom - countPinned(turns.slice(keptFrom, cutIndex), pins) + (foldsOpening(turns[0], keptFrom) && countPinned([turns[0]], pins) === 0 ? 1 : 0) : 0,
-    pinned: cutIndex > 0 ? countPinned(turns.slice(0, cutIndex), pins) : 0,
+    folded: cutIndex > 0 ? cutIndex - keptFrom - countPinned(keys.slice(keptFrom, cutIndex), pins) + (foldsOpening(turns[0], keptFrom) && countPinned([keys[0]], pins) === 0 ? 1 : 0) : 0,
+    pinned: cutIndex > 0 ? countPinned(keys.slice(0, cutIndex), pins) : 0,
     host: state.host,
     keep: state.keep,
     cleared: state.cleared,
@@ -134,7 +163,8 @@ function cutNote(state: ThreadState, turns: Message[][], cutIndex: number, confi
 export function compact({ body, config, state, window, guide, transcriptDir, mayCompact, omittedBefore = 0, decorate = (m) => m, reduce }: CompactInput): CompactResult {
   const { preamble, 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)
+  const keys = turnKeys(turns)
+  const resolved = resolveCut(turns, keys, state, config, rolling?.keep)
   let cutIndex = resolved.cutIndex
   let stateChanged = resolved.stateChanged
 
@@ -170,7 +200,8 @@ export function compact({ body, config, state, window, guide, transcriptDir, may
   const moveCut = (index: number, action: string) => {
     cutIndex = index
     resetCut(state)
-    state.cut = turnFingerprint(turns[index])
+    state.cut = keys[index]
+    retireRecalls(state, turns.slice(0, index))
     actions.push(action)
     rebuild()
   }
@@ -184,16 +215,10 @@ export function compact({ body, config, state, window, guide, transcriptDir, may
   if (mayCompact && estimate > limit) {
     const current = turns.length - 1
     if (current > 0 && current > cutIndex) moveCut(current, "cut")
-    if (!holdsStuck(state, estimate, window)) {
-      const stuck = shrinkToTarget(
-        () => estimate > target,
-        () => shrinkOnce(state, cutIndex, configuredKeep, liveResults),
-        actions,
-        rebuild,
-      )
-      if (stuck) state.stuck = estimate
-      else delete state.stuck
-    }
+    shrinkOrHold(state, actions, { estimate: () => estimate, step: () => shrinkOnce(state, cutIndex, configuredKeep, liveResults), rebuild, target, limit, window })
+    stateChanged = true
+  } else if (state.stuck !== undefined) {
+    delete state.stuck
     stateChanged = true
   }
 
@@ -201,8 +226,8 @@ export function compact({ body, config, state, window, guide, transcriptDir, may
     messages,
     stateChanged,
     note: {
-      ...cutNote(state, turns, cutIndex, configuredKeep, actions),
-      stuck: state.stuck === undefined ? undefined : stuckSizes(messages, headLength(preamble, turns[0], state), liveStart(messages), size),
+      ...cutNote(state, turns, keys, cutIndex, configuredKeep, actions),
+      stuck: state.stuck === undefined ? undefined : stuckSizes(messages, headLength(preamble, turns[0], keys[0], state), liveStart(messages), size),
       turns: turns.length,
       messagesIn: body.messages.length,
       messagesOut: messages.length,

package/src/core/config.ts

@@ -1,7 +1,7 @@
 export type Mode = "off" | "compact" | "default"
 
 interface EvalConfig {
-  recallOptions?: { maxChars?: number; maxCharsMulti?: number; perQuery?: number }
+  recallOptions?: { maxChars?: number; maxCharsMulti?: number; maxCharsTotal?: number; perQuery?: number }
   strategy?: "tail" | "guide" | "trim"
   rolling?: { keep: number; budget: number }
   forceCut?: boolean

package/src/core/fold.ts

@@ -1,7 +1,7 @@
 import type { Message } from "../context/content"
-import { splitTurns, turnFingerprint } from "../context/fold/turns"
+import { splitTurns, turnKeys } from "../context/fold/turns"
 import { threadKeyOf } from "./rewrite"
-import { resetCut, type ThreadState, type ThreadStore } from "./state"
+import { resetCut, retireRecalls, type ThreadState, type ThreadStore } from "./state"
 
 export interface FoldTarget {
   store: ThreadStore
@@ -23,7 +23,8 @@ export interface Folded {
 function located({ store, threadId, messages }: FoldTarget) {
   const threadKey = threadKeyOf(threadId, messages)
   if (!threadKey) throw new RangeError("eunoe can only fold a thread that has at least one user turn")
-  return { threadKey, turns: splitTurns(messages).turns, state: store.read(threadKey) }
+  const turns = splitTurns(messages).turns
+  return { threadKey, turns, keys: turnKeys(turns), state: store.read(threadKey) }
 }
 
 function checkedTurn(turn: number, turns: Message[][], from: number): number {
@@ -32,38 +33,39 @@ function checkedTurn(turn: number, turns: Message[][], from: number): number {
   return turn
 }
 
-function folded(threadKey: string, turns: Message[][], state: ThreadState): Folded {
-  const cutTurn = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1
+function folded(threadKey: string, keys: string[], state: ThreadState): Folded {
+  const cutTurn = state.cut ? keys.indexOf(state.cut) : -1
   const pins = new Set(state.pins)
-  return { threadKey, cutTurn: cutTurn > 0 ? cutTurn : null, pinned: turns.flatMap((turn, i) => (pins.has(turnFingerprint(turn)) ? [i] : [])) }
+  return { threadKey, cutTurn: cutTurn > 0 ? cutTurn : null, pinned: keys.flatMap((key, i) => (pins.has(key) ? [i] : [])) }
 }
 
-function withPins(state: ThreadState, turns: Message[][], indices: number[], pinned: boolean) {
+function withPins(state: ThreadState, turns: Message[][], keys: string[], indices: number[], pinned: boolean) {
   const pins = new Set(state.pins)
   for (const index of indices) {
-    const fingerprint = turnFingerprint(turns[checkedTurn(index, turns, 0)])
-    if (pinned) pins.add(fingerprint)
-    else pins.delete(fingerprint)
+    const key = keys[checkedTurn(index, turns, 0)]
+    if (pinned) pins.add(key)
+    else pins.delete(key)
   }
   if (pins.size > 0) state.pins = [...pins].sort()
   else delete state.pins
 }
 
 export function foldThread(target: FoldTarget, { at = "latest", pin = [] }: FoldOptions = {}): Folded {
-  const { threadKey, turns, state } = located(target)
+  const { threadKey, turns, keys, state } = located(target)
   const cut = checkedTurn(at === "latest" ? turns.length - 1 : at, turns, 1)
-  withPins(state, turns, pin, true)
+  withPins(state, turns, keys, pin, true)
   resetCut(state)
-  state.cut = turnFingerprint(turns[cut])
+  state.cut = keys[cut]
+  retireRecalls(state, turns.slice(0, cut))
   state.keep = cut - 1
   state.host = true
   target.store.save(threadKey, state)
-  return folded(threadKey, turns, state)
+  return folded(threadKey, keys, state)
 }
 
 export function pinTurns(target: FoldTarget, indices: number[], pinned = true): Folded {
-  const { threadKey, turns, state } = located(target)
-  withPins(state, turns, indices, pinned)
+  const { threadKey, turns, keys, state } = located(target)
+  withPins(state, turns, keys, indices, pinned)
   target.store.save(threadKey, state)
-  return folded(threadKey, turns, state)
+  return folded(threadKey, keys, state)
 }

package/src/core/forward.ts

@@ -26,6 +26,7 @@ export interface ForwarderOptions {
 
 interface Outgoing {
   note: ForwardNote
+  model: unknown
   threadKey: string | null
   bodyText: string | undefined
   sentSize: number
@@ -71,7 +72,7 @@ function defaultPrepare(options: ForwarderOptions, upstream: string): NonNullabl
   }
 }
 
-const passthrough = (bodyText: string | undefined): Outgoing => ({ note: { action: "pass" }, threadKey: null, bodyText, sentSize: 0, givenSize: 0, fixedSize: 0 })
+const passthrough = (bodyText: string | undefined): Outgoing => ({ note: { action: "pass" }, model: undefined, threadKey: null, bodyText, sentSize: 0, givenSize: 0, fixedSize: 0 })
 
 async function outgoing(prepare: NonNullable<ForwarderOptions["prepare"]>, request: Request, givenText: string, mayCompact: boolean): Promise<Outgoing> {
   try {
@@ -80,6 +81,7 @@ async function outgoing(prepare: NonNullable<ForwarderOptions["prepare"]>, reque
     const sentSize = sizeOf(result.body)
     return {
       note: result.note,
+      model: given.model,
       threadKey: result.threadKey,
       bodyText: result.body !== given ? JSON.stringify(result.body, wellFormed) : givenText,
       sentSize,
@@ -161,7 +163,7 @@ export function createForwarder(options: ForwarderOptions): (request: Request) =
     if (answer.status >= 400 && out.note.action !== "pass") {
       const errorText = await answer.text()
       const logged = { path: url.pathname, status: answer.status, thread: out.threadKey, ...out.note }
-      const overflow = out.threadKey && !isCountTokens ? recordOverflow(options.store, out.threadKey, out.sentSize, errorText) : null
+      const overflow = out.threadKey && !isCountTokens ? recordOverflow(options.store, out.threadKey, out.sentSize, errorText, out.model) : null
       if (!overflow) {
         log({ ...logged, error: clipped(errorText) })
         return errorResponse(errorText)

package/src/core/recall.ts

@@ -1,5 +1,6 @@
 import { type Body, blocks, type Message, resultText } from "../context/content"
-import { livePrompt, type RecallChunk, type Reranker, recallChunks, recallFor, recallForWith, withRecall } from "../context/recall"
+import { isPrompt } from "../context/fold/turns"
+import { livePrompt, RECALL_CHARS_TOTAL, type RecallChunk, type RecallOptions, type Reranker, recallChunks, recallFor, recallForWith, withRecall } from "../context/recall"
 import { messageFingerprint } from "./fingerprint"
 import { activeHandoffs, handoffChunks } from "./handoff"
 import type { Rewrite, RewriteInput } from "./rewrite"
@@ -27,6 +28,29 @@ function recallTarget(original: Body): { key: string; text: string } | null {
   return live ? { key: messageFingerprint(original.messages[live.index]), text: live.text } : null
 }
 
+function charsInUse(messages: Message[], recalls: Record<string, string>): number {
+  return messages.reduce((sum, message) => sum + (isPrompt(message) ? (recalls[messageFingerprint(message)]?.length ?? 0) : 0), 0)
+}
+
+const RECALL_SHARE = 0.25
+
+const RECALL_FLOOR = 6_000
+
+function withinTotal(input: RewriteInput, result: Rewrite, recalls: Record<string, string>): RecallOptions {
+  const options = input.config.eval?.recallOptions
+  const share = Math.max(RECALL_FLOOR, RECALL_SHARE * JSON.stringify(result.body.messages).length)
+  return { ...options, maxCharsTotal: Math.min(options?.maxCharsTotal ?? RECALL_CHARS_TOTAL, share), charsInUse: charsInUse(result.body.messages, recalls) }
+}
+
+export function dropLiveRecall(input: RewriteInput, threadKey: string) {
+  const target = recallTarget(input.body)
+  if (!target) return
+  const state = input.store.read(threadKey)
+  if (state.recalls?.[target.key] === "") return
+  state.recalls = { ...state.recalls, [target.key]: "" }
+  input.store.save(threadKey, state)
+}
+
 export function applyRecall(input: RewriteInput, result: Rewrite): Rewrite {
   if (!touched(input, result) || !result.threadKey) return result
   const state = input.store.read(result.threadKey)
@@ -34,7 +58,7 @@ export function applyRecall(input: RewriteInput, result: Rewrite): Rewrite {
   const target = recallTarget(input.body)
   let note = result.note
   if (target && !(target.key in state.recalls)) {
-    state.recalls[target.key] = recallFor(target.text, droppedChunks(input, result, result.threadKey), input.config.eval?.recallOptions) ?? ""
+    state.recalls[target.key] = recallFor(target.text, droppedChunks(input, result, result.threadKey), withinTotal(input, result, state.recalls)) ?? ""
     input.store.save(result.threadKey, state)
     note = { ...note, recalled: state.recalls[target.key].length }
   }
@@ -49,7 +73,7 @@ export async function prefetchFor(input: RewriteInput, result: Rewrite, rerank:
   const state = input.store.read(result.threadKey)
   state.recalls ??= {}
   if (target.key in state.recalls) return null
-  const options = { candidates: input.config.eval?.rerank?.candidates, ...input.config.eval?.recallOptions }
+  const options = { candidates: input.config.eval?.rerank?.candidates, ...withinTotal(input, result, state.recalls) }
   state.recalls[target.key] = (await recallForWith(target.text, droppedChunks(input, result, result.threadKey), rerank, options)) ?? ""
   input.store.save(result.threadKey, state)
   return state.recalls[target.key].length