@chroxify/eunoe 1.2.2 → 1.3.0

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 { hasContent, isHarness, isStaleNote, type ReduceOptions, reduceTurn, splitTurns, turnFingerprint } from "./turns"
 
 export interface CompactOptions extends ReduceOptions {
   keepTurns: number
@@ -8,26 +8,70 @@ export interface CompactOptions extends ReduceOptions {
   guide: string | null
   omittedBefore?: number
   reduce?: (turn: Message[], options: ReduceOptions) => Message[]
+  pinned?: ReadonlySet<string>
 }
 
+const pinnedBy =
+  ({ pinned }: CompactOptions) =>
+  (turn: Message[]) =>
+    pinned !== undefined && pinned.size > 0 && pinned.has(turnFingerprint(turn))
+
+export const countPinned = (turns: Message[][], pinned: ReadonlySet<string>) => (pinned.size > 0 ? turns.filter((turn) => pinned.has(turnFingerprint(turn))).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 = pinnedBy(options)
   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 = isPinned(turns[0])
+  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 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))
+  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)),
+    ...turns.slice(keptFrom, cutIndex).flatMap(shown),
+    ...turns.slice(cutIndex).flat(),
+  ]
 }
 
 export function capTurns(messages: Message[], options: CompactOptions): Message[] {
@@ -36,7 +80,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 = pinnedBy(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")
 }
 
@@ -39,7 +48,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 +76,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

@@ -123,9 +123,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

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 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 { 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"
 
 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 {
@@ -50,13 +51,15 @@ 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: Config, rollingKeep: number | undefined) {
+function resolveCut(turns: Message[][], state: ThreadState, config: CoreConfig, rollingKeep: number | undefined) {
   let cutIndex = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === state.cut) : -1
   let stateChanged = false
   if (state.cut && cutIndex === -1) {
@@ -89,17 +92,47 @@ 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) {
+function shrinkToTarget(over: () => boolean, step: () => string, actions: string[], rebuild: () => void): boolean {
   while (over()) {
     const action = step()
     actions.push(action)
-    if (action === "stuck") return
+    if (action === "stuck") return true
     rebuild()
   }
+  return false
+}
+
+const holdsStuck = (state: ThreadState, estimate: number, window: number | null) => window !== null && state.stuck !== undefined && estimate <= state.stuck + STUCK_STEP * window
+
+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)
+
+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[]) {
+  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
+  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,
+    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)
   let cutIndex = resolved.cutIndex
@@ -107,7 +140,7 @@ export function compact({ body, config, state, window, guide, transcriptDir, may
 
   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)
@@ -151,12 +184,16 @@ 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,
-    )
+    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
+    }
     stateChanged = true
   }
 
@@ -164,13 +201,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, cutIndex, configuredKeep, actions),
+      stuck: state.stuck === undefined ? undefined : stuckSizes(messages, headLength(preamble, turns[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; 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,
+}

package/src/core/fold.ts

@@ -0,0 +1,69 @@
+import type { Message } from "../context/content"
+import { splitTurns, turnFingerprint } from "../context/fold/turns"
+import { threadKeyOf } from "./rewrite"
+import { resetCut, type ThreadState, type ThreadStore } from "./state"
+
+export interface FoldTarget {
+  store: ThreadStore
+  threadId: string
+  messages: Message[]
+}
+
+export interface FoldOptions {
+  at?: number | "latest"
+  pin?: number[]
+}
+
+export interface Folded {
+  threadKey: string
+  cutTurn: number | null
+  pinned: number[]
+}
+
+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) }
+}
+
+function checkedTurn(turn: number, turns: Message[][], from: number): number {
+  if (turns.length <= from) throw new RangeError(`this thread has ${turns.length} turn${turns.length === 1 ? "" : "s"}, so there is no turn ${turn} to fold at`)
+  if (!Number.isInteger(turn) || turn < from || turn >= turns.length) throw new RangeError(`turn ${turn} is outside turns ${from}..${turns.length - 1}`)
+  return turn
+}
+
+function folded(threadKey: string, turns: Message[][], state: ThreadState): Folded {
+  const cutTurn = state.cut ? turns.findIndex((turn) => turnFingerprint(turn) === 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] : [])) }
+}
+
+function withPins(state: ThreadState, turns: Message[][], 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)
+  }
+  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 cut = checkedTurn(at === "latest" ? turns.length - 1 : at, turns, 1)
+  withPins(state, turns, pin, true)
+  resetCut(state)
+  state.cut = turnFingerprint(turns[cut])
+  state.keep = cut - 1
+  state.host = true
+  target.store.save(threadKey, state)
+  return folded(threadKey, turns, state)
+}
+
+export function pinTurns(target: FoldTarget, indices: number[], pinned = true): Folded {
+  const { threadKey, turns, state } = located(target)
+  withPins(state, turns, indices, pinned)
+  target.store.save(threadKey, state)
+  return folded(threadKey, turns, state)
+}