@chroxify/eunoe 1.0.0 → 1.1.0

package/src/cli/{ui.ts → terminal/ui.ts}

@@ -1,12 +1,14 @@
 import { homedir } from "node:os"
-import { TYPO_DISTANCE } from "./constants"
 
 const colorFor = (stream: NodeJS.WriteStream) => Boolean(stream.isTTY) && !process.env.NO_COLOR && process.env.TERM !== "dumb"
 export const useColor = colorFor(process.stdout)
 export const trueColor = /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? "")
 const useColorErr = colorFor(process.stderr)
 
-const paint = (open: number, close: number, enabled = useColor) => (text: string) => (enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text)
+const paint =
+  (open: number, close: number, enabled = useColor) =>
+  (text: string) =>
+    enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text
 
 export const c = {
   bold: paint(1, 22),
@@ -27,15 +29,15 @@ export function line(text = "") {
 }
 
 export function ok(text: string) {
-  console.log(`${c.green("✓")} ${text}`)
+  line(`${c.green("✓")} ${text}`)
 }
 
 export function note(text: string) {
-  console.log(`${c.dim("·")} ${text}`)
+  line(`${c.dim("·")} ${text}`)
 }
 
 export function warn(text: string) {
-  console.log(`${c.yellow("!")} ${text}`)
+  line(`${c.yellow("!")} ${text}`)
 }
 
 export function fail(text: string, hint?: string): never {
@@ -50,18 +52,38 @@ export function listFiles(files: string[]) {
 
 export function rows(entries: Array<[string, string]>, indent = 2) {
   const width = Math.max(...entries.map(([label]) => label.length))
-  for (const [label, value] of entries) console.log(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
+  for (const [label, value] of entries) line(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
 }
 
-const visible = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "")
+const ESC = "\x1b"
+const ANSI_STYLE = new RegExp(`${ESC}\\[[0-9;]*m`, "g")
+
+const visible = (text: string) => text.replace(ANSI_STYLE, "")
 
 export function table(entries: string[][], indent = 4, gap = 2) {
   const columns = Math.max(...entries.map((row) => row.length))
   const widths = Array.from({ length: columns }, (_, column) => Math.max(...entries.map((row) => visible(row[column] ?? "").length)))
   for (const row of entries) {
     const cells = widths.map((width, column) => (row[column] ?? "") + " ".repeat(Math.max(0, width - visible(row[column] ?? "").length)))
-    console.log(`${" ".repeat(indent)}${cells.join(" ".repeat(gap)).trimEnd()}`)
+    line(`${" ".repeat(indent)}${cells.join(" ".repeat(gap)).trimEnd()}`)
+  }
+}
+
+export function wrap(text: string, width: number): string[] {
+  const out: string[] = []
+  let current = ""
+  for (const word of text.split(" ")) {
+    if (current && current.length + 1 + word.length > width) {
+      out.push(current)
+      current = word
+    } else current = current ? `${current} ${word}` : word
   }
+  if (current) out.push(current)
+  return out
+}
+
+export function plural(count: number, word: string) {
+  return `${count} ${word}${count === 1 ? "" : "s"}`
 }
 
 export function percent(share: number) {
@@ -74,8 +96,16 @@ export function tilde(file: string) {
 }
 
 export function tokens(count: number) {
-  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(count >= 10_000_000 ? 0 : 1)}M`
-  if (count >= 1_000) return `${(count / 1_000).toFixed(count >= 10_000 ? 0 : 1)}k`
+  for (const [scale, suffix] of [
+    [1e12, "T"],
+    [1e9, "B"],
+    [1e6, "M"],
+    [1e3, "k"],
+  ] as const) {
+    const scaled = count / scale
+    const shown = scaled.toFixed(scaled >= 10 ? 0 : 1)
+    if (Number(shown) >= 1) return `${shown}${suffix}`
+  }
   return String(count)
 }
 
@@ -87,20 +117,21 @@ export function ago(iso: string) {
   return `${Math.round(seconds / 86_400)}d ago`
 }
 
-export function closest(input: string, options: string[]) {
-  const distance = (a: string, b: string) => {
-    const row = Array.from({ length: b.length + 1 }, (_, i) => i)
-    for (let i = 1; i <= a.length; i += 1) {
-      let previous = row[0]
-      row[0] = i
-      for (let j = 1; j <= b.length; j += 1) {
-        const current = row[j]
-        row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1))
-        previous = current
-      }
+function editDistance(a: string, b: string) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i)
+  for (let i = 1; i <= a.length; i += 1) {
+    let previous = row[0]
+    row[0] = i
+    for (let j = 1; j <= b.length; j += 1) {
+      const current = row[j]
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1))
+      previous = current
     }
-    return row[b.length]
   }
-  const [best] = options.map((option) => [option, distance(input, option)] as const).sort((x, y) => x[1] - y[1])
-  return best && best[1] <= TYPO_DISTANCE ? best[0] : null
+  return row[b.length]
+}
+
+export function closest(input: string, options: string[]) {
+  const [best] = options.map((option) => [option, editDistance(input, option)] as const).sort((x, y) => x[1] - y[1])
+  return best && best[1] <= 2 ? best[0] : null
 }

package/src/config/index.ts

@@ -1,47 +1,114 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import path from "node:path"
-import { DEFAULTS, EUNOE_DIR, MODES, paths, SCOPES, SEARCH_MODES, TUNABLES } from "./constants"
-import type { Config, Mode, SessionSettings, Tunable, Tunables } from "./types"
+import { EUNOE_DIR, paths } from "./paths"
 
-const VALID: { [K in Tunable]: (value: unknown) => value is Tunables[K] } = {
-  compactAt: (value): value is number => typeof value === "number" && value > 0 && value <= 1,
-  keepTurns: (value): value is number | "all" => value === "all" || (Number.isInteger(value) && (value as number) >= 0),
-  keep: (value): value is number => Number.isInteger(value) && (value as number) >= 1,
-  budget: (value): value is number => Number.isInteger(value) && (value as number) >= 1_000,
-  search: (value): value is Tunables["search"] => SEARCH_MODES.includes(value as Tunables["search"]),
-  rerank: (value): value is string => typeof value === "string" && /^[\w.-]+$/.test(value),
+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"
+  search: SearchMode
+  rerank: string
+}
+
+export type Tunable = keyof Tunables
+
+interface SessionSettings extends Partial<Tunables> {
+  mode?: Mode
+}
+
+export interface Config extends Tunables {
+  mode: Mode
+  scope: Scope
+  sessions: Record<string, SessionSettings>
+  port: number
+  upstream: string
+  claudeConfigDirs: string[]
+  window?: number
+  eval?: EvalConfig
 }
 
+export const DEFAULTS: Config = {
+  mode: "default",
+  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",
+  claudeConfigDirs: [],
+}
+
+export const MODES: Mode[] = ["default", "compact", "off"]
+export const TUNABLES: Tunable[] = ["keep", "budget", "turnCap", "compactAt", "keepTurns", "search", "rerank"]
+
+const SEARCH_MODES: SearchMode[] = ["jsonl", "markdown", "xml", "qmd"]
 const TEXT_TUNABLES: Tunable[] = ["search", "rerank"]
 
+const isWhole = (value: unknown, min: number): value is number => Number.isInteger(value) && (value as number) >= min
+
+const validators: { [K in Tunable]: (value: unknown) => value is Tunables[K] } = {
+  compactAt: (value): value is number => typeof value === "number" && value > 0 && value <= 1,
+  keepTurns: (value): value is number | "all" => value === "all" || isWhole(value, 0),
+  keep: (value): value is number => isWhole(value, 1),
+  budget: (value): value is number => isWhole(value, 1_000),
+  turnCap: (value): value is number | "off" => value === "off" || isWhole(value, 1_000),
+  search: (value): value is SearchMode => SEARCH_MODES.includes(value as SearchMode),
+  rerank: (value): value is string => typeof value === "string" && /^[\w.-]+$/.test(value),
+}
+
 const isMode = (value: unknown): value is Mode => MODES.includes(value as Mode)
 
+const isRecord = (value: unknown): value is Record<string, unknown> => Boolean(value) && typeof value === "object" && !Array.isArray(value)
+
 export function parseTunable<K extends Tunable>(key: K, raw: string): Tunables[K] | null {
-  const value = TEXT_TUNABLES.includes(key) || raw === "all" ? raw : Number(raw.replace(/[_,]/g, ""))
-  return VALID[key](value) ? value as Tunables[K] : null
+  const value = TEXT_TUNABLES.includes(key) || raw === "all" || raw === "off" ? raw : Number(raw.replace(/[_,]/g, ""))
+  return validators[key](value) ? (value as Tunables[K]) : null
 }
 
 function normalizeSession(value: unknown): SessionSettings | null {
   if (value === null) return {}
   if (isMode(value)) return { mode: value }
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null
-  const raw = value as Record<string, unknown>
-  const settings: SessionSettings = isMode(raw.mode) ? { mode: raw.mode } : {}
-  for (const key of TUNABLES) if (VALID[key](raw[key])) Object.assign(settings, { [key]: raw[key] })
+  if (!isRecord(value)) return null
+  const settings: SessionSettings = isMode(value.mode) ? { mode: value.mode } : {}
+  for (const key of TUNABLES) if (validators[key](value[key])) Object.assign(settings, { [key]: value[key] })
   return settings
 }
 
-export function normalizeConfig(raw: Record<string, any>): Config {
-  const config: Config = { ...DEFAULTS, ...raw }
+export function normalizeConfig(raw: Record<string, unknown>): Config {
+  const config = { ...DEFAULTS, ...raw } as Config
   if (!isMode(config.mode)) config.mode = DEFAULTS.mode
-  if (!SCOPES.includes(config.scope)) config.scope = DEFAULTS.scope
-  for (const key of TUNABLES) if (!VALID[key](config[key])) Object.assign(config, { [key]: DEFAULTS[key] })
-  const sessions = config.sessions && typeof config.sessions === "object" && !Array.isArray(config.sessions) ? config.sessions : {}
-  config.sessions = Object.fromEntries(Object.entries(sessions).flatMap(([id, value]) => {
-    const settings = normalizeSession(value)
-    return settings ? [[id, settings]] : []
-  }))
+  if (config.scope !== "all" && config.scope !== "sessions") config.scope = DEFAULTS.scope
+  for (const key of TUNABLES) if (!validators[key](config[key])) Object.assign(config, { [key]: DEFAULTS[key] })
+  const sessions = isRecord(config.sessions) ? config.sessions : {}
+  config.sessions = Object.fromEntries(
+    Object.entries(sessions).flatMap(([id, value]) => {
+      const settings = normalizeSession(value)
+      return settings ? [[id, settings]] : []
+    }),
+  )
   if (!Number.isInteger(config.port)) config.port = DEFAULTS.port
   if (!Array.isArray(config.claudeConfigDirs)) config.claudeConfigDirs = []
   return config
@@ -49,7 +116,7 @@ export function normalizeConfig(raw: Record<string, any>): Config {
 
 let cached: { mtimeMs: number; config: Config } | null = null
 
-export function loadConfig(): Config {
+export function readConfig(): Config {
   let mtimeMs: number
   try {
     mtimeMs = statSync(paths.config).mtimeMs
@@ -60,9 +127,7 @@ export function loadConfig(): Config {
   let config = DEFAULTS
   try {
     config = normalizeConfig(JSON.parse(readFileSync(paths.config, "utf8")))
-  } catch (error) {
-    console.error(`[eunoe] ${paths.config} is not valid JSON; using defaults`, error)
-  }
+  } catch {}
   cached = { mtimeMs, config }
   return config
 }
@@ -70,7 +135,7 @@ export function loadConfig(): Config {
 export function saveConfig(patch: Partial<Config>) {
   mkdirSync(EUNOE_DIR, { recursive: true })
   const current = existsSync(paths.config) ? JSON.parse(readFileSync(paths.config, "utf8")) : {}
-  writeFileSync(paths.config, JSON.stringify({ ...current, ...patch }, null, 2) + "\n")
+  writeFileSync(paths.config, `${JSON.stringify({ ...current, ...patch }, null, 2)}\n`)
 }
 
 export function claudeConfigDirs(config: Config): string[] {
@@ -85,14 +150,14 @@ export function modeFor(config: Config, sessionId: string | null): Mode {
   return config.scope === "all" ? config.mode : "off"
 }
 
+export function compactionOwner(config: Config): Mode {
+  return modeFor(config, null)
+}
+
 export function overrides(settings: SessionSettings | undefined): Partial<Tunables> {
-  return Object.fromEntries(TUNABLES.filter((key) => settings?.[key] !== undefined).map((key) => [key, settings![key]]))
+  return Object.fromEntries(TUNABLES.filter((key) => settings?.[key] !== undefined).map((key) => [key, settings?.[key]]))
 }
 
 export function settingsFor(config: Config, sessionId: string | null): Config {
   return { ...config, ...overrides(sessionId ? config.sessions[sessionId] : undefined), mode: modeFor(config, sessionId) }
 }
-
-export function compactionOwner(config: Config): Mode {
-  return config.scope === "all" ? config.mode : "off"
-}

package/src/config/paths.ts

@@ -0,0 +1,17 @@
+import { homedir } from "node:os"
+import path from "node:path"
+
+export const EUNOE_DIR = process.env.EUNOE_DIR ?? path.join(homedir(), ".eunoe")
+
+export const paths = {
+  config: path.join(EUNOE_DIR, "config.json"),
+  requests: path.join(EUNOE_DIR, "requests.jsonl"),
+  threads: path.join(EUNOE_DIR, "threads"),
+  transcripts: path.join(EUNOE_DIR, "transcripts"),
+  models: path.join(EUNOE_DIR, "models.json"),
+  sessions: path.join(EUNOE_DIR, "sessions.json"),
+  proxyLog: path.join(EUNOE_DIR, "proxy.log"),
+  typesafeKey: path.join(EUNOE_DIR, "typesafe-key"),
+  loaded: path.join(EUNOE_DIR, "loaded"),
+  watch: path.join(EUNOE_DIR, "watch.json"),
+}

package/src/context/content.ts

@@ -1,14 +1,40 @@
-import { SUMMARY_ARGUMENT_CHARS, SUMMARY_COMMAND_CHARS } from "./constants"
-import type { Block, Message } from "./types"
+export type Block = { type: string; [key: string]: any }
+
+export type Message = { role: string; content: string | Block[] }
+
+export type Body = {
+  model?: string
+  system?: string | Block[]
+  messages: Message[]
+  tools?: unknown[]
+  metadata?: { user_id?: string }
+  [key: string]: any
+}
 
 export function contentBlocks(content: unknown): Block[] {
-  return typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : []
+  if (typeof content === "string") return [{ type: "text", text: content }]
+  return Array.isArray(content) ? content : []
 }
 
 export function blocks(message: Message): Block[] {
   return contentBlocks(message.content)
 }
 
+function joinedText(list: Block[]): string {
+  return list
+    .filter((b) => b.type === "text")
+    .map((b) => String(b.text ?? ""))
+    .join("\n")
+}
+
+export function textOf(message: Message): string {
+  return joinedText(blocks(message))
+}
+
+export function resultText(block: Block): string {
+  return typeof block.content === "string" ? block.content : joinedText(contentBlocks(block.content))
+}
+
 export function withoutCacheControl(block: Block): Block {
   if (!("cache_control" in block)) return block
   const { cache_control: _, ...rest } = block
@@ -19,28 +45,28 @@ export function clean(message: Message): Message {
   return { role: message.role, content: blocks(message).map(withoutCacheControl) }
 }
 
+export function shortHash(json: string, chars: number): string {
+  return new Bun.CryptoHasher("sha256").update(json).digest("hex").slice(0, chars)
+}
+
 export function truncate(text: string, max: number): string {
   const cut = text.slice(0, max)
   return /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut
 }
 
-export function wellFormed(_key: string, value: unknown): unknown {
-  return typeof value === "string" ? value.toWellFormed() : value
-}
-
 export function clip(value: unknown, max: number): string {
   const text = String(value).replace(/\s+/g, " ").trim()
   return text.length > max ? `${truncate(text, max)}…` : text
 }
 
+export function wellFormed(_key: string, value: unknown): unknown {
+  return typeof value === "string" ? value.toWellFormed() : value
+}
+
 export function describeToolCall(block: Block): string {
   const input = block.input ?? {}
-  if (typeof input.command === "string") return `${block.name} \`${clip(input.command, SUMMARY_COMMAND_CHARS)}\``
+  if (typeof input.command === "string") return `${block.name} \`${clip(input.command, 100)}\``
   if (typeof input.file_path === "string") return `${block.name} ${input.file_path}`
-  if (typeof input.pattern === "string") return `${block.name} "${clip(input.pattern, SUMMARY_ARGUMENT_CHARS)}"`
-  return `${block.name} ${clip(JSON.stringify(input), SUMMARY_ARGUMENT_CHARS)}`
-}
-
-export function resultText(block: Block): string {
-  return typeof block.content === "string" ? block.content : contentBlocks(block.content).filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n")
+  if (typeof input.pattern === "string") return `${block.name} "${clip(input.pattern, 60)}"`
+  return `${block.name} ${clip(JSON.stringify(input), 60)}`
 }

package/src/context/fold/evidence.ts

@@ -0,0 +1,145 @@
+import { type Block, blocks, clip, describeToolCall, type Message, resultText } from "../content"
+import { toolEvidence } from "../prompts"
+
+export interface EvidenceOptions {
+  linesPerCall?: number
+  lineChars?: number
+  turnChars?: number
+  scanLines?: number
+  minScore?: number
+  allTools?: boolean
+  ranked?: boolean
+  labels?: boolean
+  callFloor?: number
+}
+
+interface Scored {
+  index: number
+  line: string
+  score: number
+}
+
+interface Entry {
+  head: string
+  lines: string[]
+}
+
+export const REREADABLE_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "NotebookRead", "WebFetch", "WebSearch", "TodoWrite", "Edit", "Write", "MultiEdit", "NotebookEdit"])
+
+const ERROR_LINE = /\b(?:error|errors|fail|fails|failed|failure|fatal|exception|panic|denied|refused|timed? ?out|traceback|cannot|unable to)\b/i
+
+const ERROR_CODE =
+  /\b[A-Z][A-Z0-9]*_[A-Z0-9_]{2,}\b|\bSIG[A-Z]{2,}\d*\b|\b[A-Z]{2,}\d{2,}\b|\bE(?:NOENT|ACCES|PERM|EXIST|CONN(?:REFUSED|RESET|ABORTED)|PIPE|ADDRINUSE|TIMEDOUT|NOTFOUND|INVAL|BUSY|MFILE|AGAIN|HOSTUNREACH|NOTDIR|ISDIR|BADF|NOSPC|AI_[A-Z]+)\b/
+
+const VALUE_TOKEN =
+  /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{4,}\b|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\b\d+(?:\.\d+)?\s?(?:ms|s|[KMGT]i?B|kB|%)(?![a-z])|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+|\b\d+ (?:pass(?:ed|ing)?|fail(?:ed|ing)?|tests?|files? changed|insertions?|deletions?|rows?|errors?|warnings?)\b|[$€£]\d+(?:[.,]\d+)?|\b(?:status|HTTP\/\d(?:\.\d)?)\s*[:=]?\s*[45]\d{2}\b|\bexit(?: code| status)?\s*[:=]?\s*(?!0\b)\d{1,3}\b/i
+
+const ID_TOKEN = /\b[a-z]{2,}[_-](?=[a-z0-9]*\d)[a-z0-9]{6,}\b|\b(?=[0-9a-f]*\d)(?=[0-9a-f]*[a-f])[0-9a-f]{7,}\b|https?:\/\/[^\s)"']+|\b\d{6,}_[a-z0-9_]{3,}\b|\bv?\d+\.\d+\.\d+\b|\bsha\d*:[0-9a-f]+|@[a-z][\w-]+|--[a-z][\w-]*=\S+/i
+
+const KEY_VALUE = /^[\w .\-/()]{2,48}[:=]\s*\S/
+
+const VALUE_LABEL = /\b(?:ids?|hash|sha(?:256)?|checksum|trace|deploy(?:ment)?|preview|url|version|rows|p9[59]|exit(?: code)?|signal|request[_-]?id|job|migration|applied|bundle|build|status|took|updated|created)\b/i
+
+function resolved(options: EvidenceOptions) {
+  return {
+    linesPerCall: options.linesPerCall ?? 12,
+    lineChars: options.lineChars ?? 220,
+    turnChars: options.turnChars ?? 4_000,
+    scanLines: options.scanLines ?? 1_000_000,
+    minScore: options.minScore ?? 2,
+    ranked: options.ranked ?? true,
+    labels: options.labels ?? true,
+    callFloor: options.callFloor ?? 2,
+  }
+}
+
+const isError = (line: string) => ERROR_LINE.test(line) || ERROR_CODE.test(line)
+
+export function isSalient(line: string): boolean {
+  return isError(line) || VALUE_TOKEN.test(line)
+}
+
+function scoreLines(text: string, options: EvidenceOptions): Scored[] {
+  const { scanLines, lineChars, minScore, labels } = resolved(options)
+  const scored = text
+    .split("\n")
+    .slice(0, scanLines)
+    .flatMap((raw, index) => {
+      const line = raw.trim()
+      if (line.length < 4) return []
+      const error = isError(line)
+      const value = VALUE_TOKEN.test(line)
+      if (!error && !value) return []
+      const score = (error ? 3 : 0) + (value ? (ID_TOKEN.test(line) ? 3 : 2) : 0) + (KEY_VALUE.test(line) ? 1 : 0) + (line.length < 120 ? 1 : 0) + (labels && VALUE_LABEL.test(line) ? 1 : 0)
+      return score >= minScore ? [{ index, line: clip(line, lineChars), score }] : []
+    })
+  const seen = new Set<string>()
+  return scored.sort((a, b) => b.score - a.score || a.index - b.index).filter((s) => !seen.has(s.line) && seen.add(s.line))
+}
+
+export function salientLines(text: string, options: EvidenceOptions = {}): string[] {
+  return scoreLines(text, options)
+    .slice(0, resolved(options).linesPerCall)
+    .sort((a, b) => a.index - b.index)
+    .map((s) => s.line)
+}
+
+export function toolPairs(turn: Message[]): Array<{ call: Block; result: Block }> {
+  const results = new Map<string, Block>()
+  for (const message of turn) {
+    if (message.role !== "user") continue
+    for (const block of blocks(message)) if (block.type === "tool_result") results.set(block.tool_use_id, block)
+  }
+  return turn
+    .filter((m) => m.role === "assistant")
+    .flatMap((m) => blocks(m).filter((b) => b.type === "tool_use"))
+    .flatMap((call) => {
+      const result = results.get(call.id)
+      return result ? [{ call, result }] : []
+    })
+}
+
+function render(entries: Entry[]): string | null {
+  const shown = entries.filter((e) => e.lines.length > 0).map((e) => `- ${e.head}:\n${e.lines.map((l) => `    ${l}`).join("\n")}`)
+  return shown.length > 0 ? toolEvidence(shown) : null
+}
+
+function inCallOrder(heads: string[], pairs: Array<{ result: Block }>, options: EvidenceOptions): Entry[] {
+  const { turnChars } = resolved(options)
+  const entries: Entry[] = []
+  let used = 0
+  pairs.forEach(({ result }, i) => {
+    const lines = salientLines(resultText(result), options)
+    if (lines.length === 0) return
+    const size = heads[i].length + 4 + lines.reduce((s, l) => s + l.length + 5, 0)
+    if (used + size > turnChars) return
+    entries.push({ head: heads[i], lines })
+    used += size
+  })
+  return entries
+}
+
+function byScore(heads: string[], pairs: Array<{ result: Block }>, options: EvidenceOptions): Entry[] {
+  const { turnChars, linesPerCall, callFloor } = resolved(options)
+  const perCall = pairs.map(({ result }) => scoreLines(resultText(result), options))
+  const chosen = new Map<number, Scored[]>()
+  let used = 0
+  const take = (call: number, line: Scored) => {
+    const bucket = chosen.get(call) ?? []
+    const cost = line.line.length + 5 + (bucket.length > 0 ? 0 : heads[call].length + 4)
+    if (bucket.length >= linesPerCall || used + cost > turnChars) return
+    bucket.push(line)
+    chosen.set(call, bucket)
+    used += cost
+  }
+  for (const [call, lines] of perCall.entries()) for (const line of lines.slice(0, callFloor)) take(call, line)
+  const rest = perCall.flatMap((lines, call) => lines.slice(callFloor).map((line) => ({ line, call }))).sort((a, b) => b.line.score - a.line.score || a.call - b.call || a.line.index - b.line.index)
+  for (const { line, call } of rest) take(call, line)
+  return heads.map((head, i) => ({ head, lines: (chosen.get(i) ?? []).sort((a, b) => a.index - b.index).map((s) => s.line) }))
+}
+
+export function turnEvidence(turn: Message[], options: EvidenceOptions = {}): string | null {
+  const pairs = toolPairs(turn).filter(({ call }) => options.allTools || !REREADABLE_TOOLS.has(call.name))
+  const heads = pairs.map(({ call, result }) => `${describeToolCall(call)}${result.is_error ? " (failed)" : ""}`)
+  return render(resolved(options).ranked ? byScore(heads, pairs, options) : inCallOrder(heads, pairs, options))
+}

package/src/context/fold/index.ts

@@ -0,0 +1,65 @@
+import { type Message, textOf } from "../content"
+import { type RecallChunk, recallChunks, terms } from "../recall"
+import { isPrompt, reduceTurn, splitTurns } from "./turns"
+
+export interface FoldedTurn {
+  user: string
+  evidence: string
+  reply: string
+}
+
+export const FOLD_CAP_CHARS = 400_000
+
+const spoken = (message: Message) =>
+  textOf(message)
+    .replace(/<(system-reminder|system-message|recalled-context|handoff)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, "")
+    .trim()
+
+const isEvidence = (text: string) => text.startsWith("<tool-evidence>")
+
+export function foldedTurns(messages: Message[]): FoldedTurn[] {
+  return splitTurns(messages)
+    .turns.filter((turn) => isPrompt(turn[0]))
+    .map((turn) => {
+      const reduced = reduceTurn(turn, { evidence: true })
+      const users = reduced.filter((m) => m.role === "user").map(spoken)
+      return {
+        user: users.filter((t) => t && !isEvidence(t)).join("\n\n"),
+        evidence: users.filter(isEvidence).join("\n"),
+        reply: reduced
+          .filter((m) => m.role === "assistant")
+          .map(spoken)
+          .join("\n"),
+      }
+    })
+}
+
+function renderTurn(turn: FoldedTurn, index: number, full: boolean): string {
+  const parts = [`### Turn ${index + 1}`, `**You:** ${turn.user}`]
+  if (full && turn.evidence) parts.push(turn.evidence)
+  if (full && turn.reply) parts.push(`**Agent:** ${turn.reply}`)
+  return parts.join("\n\n")
+}
+
+export function foldedView(messages: Message[], cap = Number.POSITIVE_INFINITY): string {
+  const turns = foldedTurns(messages)
+  const full = new Set<number>()
+  let used = 0
+  for (let i = turns.length - 1; i >= 0; i -= 1) {
+    const size = renderTurn(turns[i], i, true).length
+    if (used + size > cap) break
+    full.add(i)
+    used += size
+  }
+  return turns.map((turn, i) => renderTurn(turn, i, full.has(i))).join("\n\n")
+}
+
+export function sourceChunks(messages: Message[], from: string, users = false): RecallChunk[] {
+  const chunks = recallChunks([...messages, { role: "user", content: "" }], new Map()).map((chunk) => ({ ...chunk, from }))
+  if (!users) return chunks
+  const said = splitTurns(messages)
+    .turns.filter((turn) => isPrompt(turn[0]))
+    .map((turn, i) => ({ turn: i + 1, text: spoken(turn[0]) }))
+    .filter((t) => t.text)
+  return [...said.map((t) => ({ turn: t.turn, from, call: "you", lines: t.text.split("\n"), terms: terms(t.text) })), ...chunks]
+}