@chroxify/eunoe 1.2.2 → 1.3.1

package/src/cli/sessions/index.ts

@@ -2,8 +2,8 @@ import { spawnSync } from "node:child_process"
 import { claudeConfigDirs, readConfig } from "../../config"
 import { FOLD_CAP_CHARS, foldedView, sourceChunks } from "../../context/fold"
 import { recallFor } from "../../context/recall"
-import { DEFAULT_RATIO } from "../../proxy/estimate"
-import { continueToken } from "../../proxy/handoff"
+import { DEFAULT_RATIO } from "../../core/estimate"
+import { continueToken } from "../../core/handoff"
 import { seenSessions } from "../../proxy/sessions"
 import { isSessionId } from "../../transcript/locate"
 import { subagentChunks } from "../../transcript/subagents"

package/src/config/index.ts

@@ -1,29 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import path from "node:path"
+import { CORE_DEFAULTS, type CoreConfig, type Mode } from "../core/config"
 import { EUNOE_DIR, paths } from "./paths"
 
-export type Mode = "off" | "compact" | "default"
 export type SearchMode = "jsonl" | "markdown" | "xml" | "qmd"
 type Scope = "all" | "sessions"
 
-interface EvalConfig {
-  recallOptions?: { maxChars?: number; maxCharsMulti?: number; perQuery?: number }
-  strategy?: "tail" | "guide" | "trim"
-  rolling?: { keep: number; budget: number }
-  forceCut?: boolean
-  trustHeaders?: boolean
-  evidence?: boolean
-  recall?: boolean
-  rerank?: { model: string; candidates?: number; endpoint?: string }
-}
-
-export interface Tunables {
-  compactAt: number
-  keepTurns: number | "all"
-  keep: number
-  budget: number
-  turnCap: number | "off"
+export interface Tunables extends Pick<CoreConfig, "compactAt" | "keepTurns" | "keep" | "budget" | "turnCap"> {
   search: SearchMode
   rerank: string
 }
@@ -34,27 +18,20 @@ interface SessionSettings extends Partial<Tunables> {
   mode?: Mode
 }
 
-export interface Config extends Tunables {
-  mode: Mode
+export interface Config extends CoreConfig, Tunables {
   scope: Scope
   sessions: Record<string, SessionSettings>
   port: number
   upstream: string
   claudeConfigDirs: string[]
   window?: number
-  eval?: EvalConfig
 }
 
 export const DEFAULTS: Config = {
-  mode: "default",
+  ...CORE_DEFAULTS,
   scope: "all",
   sessions: {},
   port: 38663,
-  compactAt: 0.9,
-  keepTurns: "all",
-  keep: 3,
-  budget: 100_000,
-  turnCap: 100_000,
   search: "markdown",
   rerank: "jev-preview",
   upstream: "https://api.anthropic.com",

package/src/context/content.ts

@@ -45,8 +45,71 @@ export function clean(message: Message): Message {
   return { role: message.role, content: blocks(message).map(withoutCacheControl) }
 }
 
+const SHA256_ROUNDS = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6,
+  0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb,
+  0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee,
+  0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+])
+
+const utf8 = new TextEncoder()
+
+const rotate = (x: number, n: number) => (x >>> n) | (x << (32 - n))
+
+export function sha256(text: string): string {
+  const data = utf8.encode(text)
+  const size = ((data.length + 72) >> 6) << 6
+  const bytes = new Uint8Array(size)
+  bytes.set(data)
+  bytes[data.length] = 0x80
+  const view = new DataView(bytes.buffer)
+  view.setUint32(size - 8, Math.floor(data.length / 0x20000000))
+  view.setUint32(size - 4, (data.length << 3) >>> 0)
+  const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19])
+  const w = new Uint32Array(64)
+  for (let offset = 0; offset < size; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4)
+    for (let i = 16; i < 64; i += 1) w[i] = (w[i - 16] + (rotate(w[i - 15], 7) ^ rotate(w[i - 15], 18) ^ (w[i - 15] >>> 3)) + w[i - 7] + (rotate(w[i - 2], 17) ^ rotate(w[i - 2], 19) ^ (w[i - 2] >>> 10))) | 0
+    let [a, b, c, d, e, f, g, k] = h
+    for (let i = 0; i < 64; i += 1) {
+      const t1 = (k + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25)) + ((e & f) ^ (~e & g)) + SHA256_ROUNDS[i] + w[i]) | 0
+      const t2 = ((rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0
+      k = g
+      g = f
+      f = e
+      e = (d + t1) | 0
+      d = c
+      c = b
+      b = a
+      a = (t1 + t2) | 0
+    }
+    h[0] += a
+    h[1] += b
+    h[2] += c
+    h[3] += d
+    h[4] += e
+    h[5] += f
+    h[6] += g
+    h[7] += k
+  }
+  return Array.from(h, (x) => x.toString(16).padStart(8, "0")).join("")
+}
+
 export function shortHash(json: string, chars: number): string {
-  return new Bun.CryptoHasher("sha256").update(json).digest("hex").slice(0, chars)
+  return sha256(json).slice(0, chars)
+}
+
+export function quickHash(text: string): string {
+  let a = 0xdeadbeef ^ text.length
+  let b = 0x41c6ce57 ^ text.length
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i)
+    a = Math.imul(a ^ code, 2654435761)
+    b = Math.imul(b ^ code, 1597334677)
+  }
+  const high = Math.imul(a ^ (a >>> 16), 2246822507) ^ Math.imul(b ^ (b >>> 13), 3266489909)
+  const low = Math.imul(b ^ (b >>> 16), 2246822507) ^ Math.imul(high ^ (high >>> 13), 3266489909)
+  return `${(low >>> 0).toString(36)}${(high >>> 0).toString(36)}`
 }
 
 export function truncate(text: string, max: number): string {

package/src/context/fold/strategies.ts

@@ -1,6 +1,6 @@
-import { type Block, type Body, blocks, type Message, truncate, withoutCacheControl } from "../content"
+import { type Block, type Body, blocks, clean, type Message, truncate, withoutCacheControl } from "../content"
 import { clearedInput, compactionNotice, truncationNotice } from "../prompts"
-import { hasContent, isHarness, type ReduceOptions, reduceTurn, splitTurns } from "./turns"
+import { fingerprintOfKey, hasContent, isHarness, isStaleNote, type ReduceOptions, reduceTurn, splitTurns, turnFingerprint, turnKeys } from "./turns"
 
 export interface CompactOptions extends ReduceOptions {
   keepTurns: number
@@ -8,26 +8,78 @@ export interface CompactOptions extends ReduceOptions {
   guide: string | null
   omittedBefore?: number
   reduce?: (turn: Message[], options: ReduceOptions) => Message[]
+  pinned?: ReadonlySet<string>
 }
 
+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 = (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)
   if (turns.length < 2) return messages
   return [...preamble, ...turns.slice(0, -1).flatMap((turn) => reduceTurn(turn, options)), ...(turns.at(-1) ?? [])]
 }
 
+export const CARRIED_CHARS = 80_000
+
+function carriedHarness(removed: Message[]): Block[] {
+  const texts = removed
+    .filter((m) => isHarness(m) && hasContent(m))
+    .flatMap((m) => blocks(m).filter((b) => b.type === "text"))
+    .map((b) => String(b.text ?? ""))
+    .filter((text) => text.trim() && !isStaleNote(text))
+  const kept: string[] = []
+  const seen = new Set<string>()
+  let used = 0
+  for (const text of texts.toReversed()) {
+    if (seen.has(text) || used + text.length > CARRIED_CHARS) continue
+    seen.add(text)
+    kept.push(text)
+    used += text.length
+  }
+  return kept.toReversed().map((text) => ({ type: "text", text: `<system-reminder>\n${text}\n</system-reminder>` }))
+}
+
+export const foldsOpening = (opening: Message[], keptFrom: number) => keptFrom === 1 && opening.length > 1
+
 export function compactMessages(messages: Message[], cutIndex: number, options: CompactOptions): Message[] {
   const { preamble, turns } = splitTurns(messages)
   if (cutIndex <= 0 || cutIndex >= turns.length) return messages
   const reduce = options.reduce ?? reduceTurn
+  const isPinned = pinnedAt(turns, options)
+  const indexed = turns.map((turn, index) => ({ turn, pinned: isPinned(index) }))
   const keptFrom = Math.max(1, cutIndex - options.keepTurns)
-  const notice = compactionNotice({ omitted: keptFrom - 1 + (options.omittedBefore ?? 0), kept: cutIndex - keptFrom, guide: options.guide })
-  const removed = [...turns[0].slice(1), ...turns.slice(1, keptFrom).flat()]
-  const carried = removed
-    .filter((m) => isHarness(m) && hasContent(m))
-    .flatMap((m) => blocks(m).filter((b) => b.type === "text"))
-    .map((b) => ({ type: "text", text: `<system-reminder>\n${b.text}\n</system-reminder>` }))
-  return [...preamble, turns[0][0], { role: "user", content: [{ type: "text", text: notice }, ...carried] }, ...turns.slice(keptFrom, cutIndex).flatMap((turn) => reduce(turn, options)), ...turns.slice(cutIndex).flat()]
+  const [first, ...rest] = turns[0]
+  const openingPinned = indexed[0].pinned
+  const openingFolded = !openingPinned && foldsOpening(turns[0], keptFrom)
+  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((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,
+    ...(openingPinned ? rest.map(clean) : []),
+    { role: "user", content: [{ type: "text", text: notice }, ...carriedHarness(removed)] },
+    ...(openingFolded ? reduce(turns[0], options).slice(1) : []),
+    ...whole.flatMap((turn) => turn.map(clean)),
+    ...indexed.slice(keptFrom, cutIndex).flatMap(shown),
+    ...turns.slice(cutIndex).flat(),
+  ]
 }
 
 export function capTurns(messages: Message[], options: CompactOptions): Message[] {
@@ -36,7 +88,8 @@ 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 over = (turn: Message[], i: number) => i > 0 && i < live && JSON.stringify(turn).length > capChars
+  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
   return [...preamble, ...turns.flatMap((turn, i) => (over(turn, i) ? reduce(turn, options) : turn))]

package/src/context/fold/turns.ts

@@ -6,9 +6,18 @@ export interface ReduceOptions {
   evidence?: boolean
 }
 
+const IMAGE_NOTE = /^\s*\[Image: original \d+x\d+, displayed at \d+x\d+\.[^\]]*\]\s*$/
+
+const STALE_NOTE = /changed on disk since you last read it|was modified, either by the user or by a linter/
+
+export const isStaleNote = (text: unknown) => STALE_NOTE.test(String(text ?? ""))
+
+const isImageNote = (content: Block[]) => content.length > 0 && content.every((block) => block.type === "text" && IMAGE_NOTE.test(String(block.text ?? "")))
+
 export function isPrompt(message: Message) {
   if (message.role !== "user") return false
   const content = blocks(message)
+  if (isImageNote(content)) return false
   return !content.some((block) => block.type === "tool_result") && content.some((block) => block.type === "text" || block.type === "image" || block.type === "document")
 }
 
@@ -28,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"
 }
@@ -39,7 +60,18 @@ export function hasContent(message: Message) {
 const hasText = (block: Block) => block.type === "text" && String(block.text ?? "").trim() !== ""
 
 function mergedHarness(turn: Message[]): Message[] {
-  const content = turn.filter((m) => isHarness(m) && hasContent(m)).flatMap((m) => blocks(m).map(withoutCacheControl))
+  const seen = new Set<string>()
+  const fresh = (block: Block) => {
+    if (block.type !== "text") return true
+    const text = String(block.text ?? "")
+    if (isStaleNote(text) || seen.has(text)) return false
+    seen.add(text)
+    return true
+  }
+  const content = turn
+    .filter((m) => isHarness(m) && hasContent(m))
+    .flatMap((m) => blocks(m).map(withoutCacheControl))
+    .filter(fresh)
   return content.length > 0 ? [{ role: "system", content }] : []
 }
 
@@ -56,7 +88,7 @@ function interrupted(turn: Message[]): string {
 function carriedText(messages: Message[]): Block[] {
   return messages
     .filter((m) => m.role === "user")
-    .flatMap((m) => blocks(m).filter((b) => hasText(b) && !/^\s*(?:<system-reminder>[\s\S]*?<\/system-reminder>\s*)+$/.test(String(b.text))))
+    .flatMap((m) => blocks(m).filter((b) => hasText(b) && !IMAGE_NOTE.test(String(b.text)) && !/^\s*(?:<system-reminder>[\s\S]*?<\/system-reminder>\s*)+$/.test(String(b.text))))
     .map((b) => ({ type: "text", text: b.text }))
 }
 

package/src/context/prompts.ts

@@ -1,9 +1,9 @@
-import type { TranscriptRef } from "../transcript/search"
 import { truncate } from "./content"
 
 interface NoticeCounts {
   omitted: number
   kept: number
+  pinned?: number
   guide: string | null
 }
 
@@ -68,7 +68,7 @@ export function clearedInput(kept: string, cleared: number): string {
   return `${kept}… [${cleared} chars cleared; in the transcript]`
 }
 
-export function compactionNotice({ omitted, kept, guide }: NoticeCounts): string {
+export function compactionNotice({ omitted, kept, pinned = 0, guide }: NoticeCounts): string {
   return [
     "<context-compacted>",
     "Your context was compacted here, so tool calls and their output from before this point were removed.",
@@ -77,6 +77,7 @@ export function compactionNotice({ omitted, kept, guide }: NoticeCounts): string
       : kept > 0
         ? "Every earlier turn is shown below as the user's message and your final reply."
         : "",
+    pinned > 0 ? `${pinned === 1 ? "One earlier turn was" : `${pinned} earlier turns were`} kept whole, with their tool calls and output, because they matter to what comes next.` : "",
     "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.",
@@ -137,7 +138,7 @@ export function searchOnlyInstructions(guide: string): string {
   ].join("\n")
 }
 
-export function searchGuide(ref: TranscriptRef): string {
+export function searchGuide(ref: { mode: string; jsonl: string; dir: string }): string {
   if (ref.mode === "jsonl") {
     return [
       `The full transcript is Claude Code's session file: ${ref.jsonl}`,

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
@@ -123,9 +127,8 @@ export function recallChunks(messages: Message[], keptIds: Map<string, string>,
         )
         .filter(Boolean)
         .join("\n")
-      const built = chunksOf(said ? `${size}|said|${turnIndex}|${said}` : null, said, "agent", turnIndex + 1, () =>
-        windows(said.split("\n"), size).map((window) => ({ turn: turnIndex + 1, call: "agent", lines: window, terms: terms(window.join("\n")) })),
-      )
+      if (!said) return
+      const built = chunksOf(`${size}|said|${turnIndex}|${said}`, said, "agent", turnIndex + 1, () => windows(said.split("\n"), size).map((window) => ({ turn: turnIndex + 1, call: "agent", lines: window, terms: terms(window.join("\n")) })))
       for (const chunk of built) chunks.push(chunk)
     })
   return chunks
@@ -389,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/context/recall/rerank.ts

@@ -1,5 +1,3 @@
-import { existsSync, readFileSync } from "node:fs"
-import { paths } from "../../config/paths"
 import { rerankQuestion } from "../prompts"
 import type { RecallChunk, Reranker } from "."
 
@@ -9,12 +7,6 @@ interface RerankAnswer {
 
 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) => {

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

@@ -1,14 +1,15 @@
-import type { Config } from "../config"
-import type { Body, Message } from "../context/content"
-import { type CompactOptions, capTurns, clearToolResults, compactMessages, countToolResults } from "../context/fold/strategies"
-import { type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "../context/fold/turns"
+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, 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 { resetCut, type ThreadState } from "./state"
+import type { RewriteNote } from "./rewrite"
+import { resetCut, retireRecalls, type ThreadState } from "./state"
 
 export interface CompactInput {
   body: Body
-  config: Config
+  config: CoreConfig
   state: ThreadState
   window: number | null
   guide: string | null
@@ -24,7 +25,7 @@ const FOLDED_TURNS = 4096
 const folded = new Map<string, Message[]>()
 
 function reduceRemembered(turn: Message[], options: ReduceOptions): Message[] {
-  const key = `${options.evidence ? 1 : 0}:${Bun.hash(JSON.stringify(turn))}`
+  const key = `${options.evidence ? 1 : 0}:${quickHash(JSON.stringify(turn))}`
   const known = folded.get(key)
   if (known) {
     folded.delete(key)
@@ -40,7 +41,7 @@ function reduceRemembered(turn: Message[], options: ReduceOptions): Message[] {
 export interface CompactResult {
   messages: Message[]
   stateChanged: boolean
-  note: Record<string, unknown>
+  note: RewriteNote
 }
 
 interface Rolling {
@@ -56,8 +57,8 @@ function settledCut(turns: Message[][], index: number) {
   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
+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)
@@ -65,7 +66,8 @@ function resolveCut(turns: Message[][], state: ThreadState, config: Config, roll
   }
   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 }
@@ -98,16 +100,77 @@ function shrinkToTarget(over: () => boolean, step: () => string, actions: string
   }
 }
 
+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[], 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[][], 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(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(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,
+  }
+}
+
 export function compact({ body, config, state, window, guide, transcriptDir, mayCompact, omittedBefore = 0, decorate = (m) => m, reduce }: CompactInput): CompactResult {
-  const { turns } = splitTurns(body.messages)
+  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
 
   const configuredKeep = config.keepTurns === "all" ? Number.MAX_SAFE_INTEGER : config.keepTurns
   const ratio = state.ratio ?? DEFAULT_RATIO
-  const options = { guide, omittedBefore, evidence: config.eval?.evidence ?? true, reduce: reduce ?? reduceRemembered, capChars: config.turnCap === "off" ? undefined : config.turnCap / ratio }
+  const options = { guide, omittedBefore, evidence: config.eval?.evidence ?? true, reduce: reduce ?? reduceRemembered, capChars: config.turnCap === "off" ? undefined : config.turnCap / ratio, pinned: new Set(state.pins) }
   const liveStart = (list: Message[]) =>
     list.length -
     splitTurns(list)
@@ -137,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()
   }
@@ -151,12 +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")
-    shrinkToTarget(
-      () => estimate > target,
-      () => shrinkOnce(state, cutIndex, configuredKeep, liveResults),
-      actions,
-      rebuild,
-    )
+    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
   }
 
@@ -164,13 +226,8 @@ export function compact({ body, config, state, window, guide, transcriptDir, may
     messages,
     stateChanged,
     note: {
-      action: cutIndex > 0 ? "compact" : "full",
-      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,
+      ...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

@@ -0,0 +1,31 @@
+export type Mode = "off" | "compact" | "default"
+
+interface EvalConfig {
+  recallOptions?: { maxChars?: number; maxCharsMulti?: number; maxCharsTotal?: number; perQuery?: number }
+  strategy?: "tail" | "guide" | "trim"
+  rolling?: { keep: number; budget: number }
+  forceCut?: boolean
+  trustHeaders?: boolean
+  evidence?: boolean
+  recall?: boolean
+  rerank?: { model: string; candidates?: number; endpoint?: string }
+}
+
+export interface CoreConfig {
+  mode: Mode
+  compactAt: number
+  keepTurns: number | "all"
+  keep: number
+  budget: number
+  turnCap: number | "off"
+  eval?: EvalConfig
+}
+
+export const CORE_DEFAULTS: CoreConfig = {
+  mode: "default",
+  compactAt: 0.9,
+  keepTurns: "all",
+  keep: 3,
+  budget: 100_000,
+  turnCap: 100_000,
+}