@chroxify/eunoe 0.1.0 → 1.0.0

package/src/cli/prompt.ts

@@ -0,0 +1,91 @@
+import { c, useColor } from "./ui"
+
+export interface Choice<T extends string = string> {
+  value: T
+  label?: string
+  hint?: string
+}
+
+export const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+
+function keys(onKey: (key: string) => boolean | void): Promise<void> {
+  return new Promise((resolve) => {
+    const stdin = process.stdin
+    stdin.setRawMode(true)
+    stdin.resume()
+    stdin.setEncoding("utf8")
+    const handler = (chunk: string) => {
+      if (onKey(chunk) === true) {
+        stdin.off("data", handler)
+        stdin.setRawMode(false)
+        stdin.pause()
+        resolve()
+      }
+    }
+    stdin.on("data", handler)
+  })
+}
+
+function render(title: string, choices: Choice[], index: number, width: number) {
+  const lines = [`  ${c.bold(title)}`, ""]
+  for (const [i, choice] of choices.entries()) {
+    const label = (choice.label ?? choice.value).padEnd(width)
+    const marker = i === index ? c.green("●") : c.dim("○")
+    lines.push(`  ${marker} ${i === index ? c.bold(label) : label}${choice.hint ? `  ${c.dim(choice.hint)}` : ""}`)
+  }
+  lines.push("", `  ${c.dim("↑↓ move · enter choose · esc cancel")}`)
+  return lines
+}
+
+export async function select<T extends string>(title: string, choices: Choice<T>[], current?: T): Promise<T | null> {
+  let index = Math.max(0, choices.findIndex((choice) => choice.value === current))
+  const width = Math.max(...choices.map((choice) => (choice.label ?? choice.value).length))
+  let drawn = 0
+  const draw = () => {
+    const lines = render(title, choices, index, width)
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+    process.stdout.write(lines.join("\n") + "\n")
+    drawn = lines.length
+  }
+  let chosen: T | null = null
+  process.stdout.write(useColor ? "\x1b[?25l" : "")
+  draw()
+  await keys((key) => {
+    if (key === "\x1b[A" || key === "k") index = (index + choices.length - 1) % choices.length
+    else if (key === "\x1b[B" || key === "j") index = (index + 1) % choices.length
+    else if (key === "\r" || key === "\n") {
+      chosen = choices[index].value
+      return true
+    } else if (key === "\x1b" || key === "q" || key === "\x03") return true
+    draw()
+  })
+  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+  process.stdout.write(useColor ? "\x1b[?25h" : "")
+  return chosen
+}
+
+export async function input(title: string, placeholder: string, initial = ""): Promise<string | null> {
+  let value = initial
+  let drawn = 0
+  const draw = () => {
+    const shown = value ? value : c.dim(placeholder)
+    const lines = [`  ${c.bold(title)}`, `  ${c.cyan("›")} ${shown}`, "", `  ${c.dim("enter save · esc cancel")}`]
+    if (drawn) process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+    process.stdout.write(lines.join("\n") + "\n")
+    drawn = lines.length
+  }
+  let result: string | null = null
+  draw()
+  await keys((key) => {
+    if (key === "\r" || key === "\n") {
+      result = value
+      return true
+    }
+    if (key === "\x1b" || key === "\x03") return true
+    if (key === "\x7f" || key === "\b") value = value.slice(0, -1)
+    else if (key >= " " && !key.startsWith("\x1b")) value += key
+    draw()
+  })
+  process.stdout.write(`\x1b[${drawn}A\x1b[J`)
+  return result
+}

package/src/cli/service.ts

@@ -0,0 +1,33 @@
+import path from "node:path"
+import { paths } from "../config/constants"
+import type { Config } from "../config/types"
+import { proxyUrl } from "./claude-settings"
+import { START_POLL_MS, START_TIMEOUT_MS } from "./constants"
+import { probe } from "./inspect"
+import * as launchd from "./launchd"
+import { c, line, ok, warn } from "./ui"
+
+async function waitForProxy(port: number) {
+  const deadline = Date.now() + START_TIMEOUT_MS
+  while (Date.now() < deadline) {
+    if (await probe(port)) return true
+    await Bun.sleep(START_POLL_MS)
+  }
+  return false
+}
+
+export async function startService(config: Config) {
+  if (!launchd.supported) {
+    if (await probe(config.port)) return true
+    warn("No launchd here, so keep the proxy running yourself:")
+    line(`    ${c.cyan("eunoe serve")}`)
+    return false
+  }
+  launchd.installAgent([process.execPath, path.join(import.meta.dir, "main.ts"), "serve"], paths.proxyLog)
+  if (await waitForProxy(config.port)) {
+    ok(`Proxy running in the background on ${c.cyan(proxyUrl(config.port))}`)
+    return true
+  }
+  warn(`The proxy didn't answer on ${proxyUrl(config.port)} yet. Check ${paths.proxyLog}.`)
+  return false
+}

package/src/cli/sessions.ts

@@ -0,0 +1,25 @@
+import { SESSION_ID_PATTERN } from "../config/constants"
+import { seenSessions } from "../proxy/sessions"
+import { flagValues } from "./args"
+import { SHORT_ID_LENGTH } from "./constants"
+import { fail } from "./ui"
+
+export const shortId = (sessionId: string) => sessionId.slice(0, SHORT_ID_LENGTH)
+
+function resolve(input: string): string {
+  if (!SESSION_ID_PATTERN.test(input)) fail(`Not a session id: ${input}`)
+  const seen = seenSessions().map(([id]) => id)
+  if (seen.includes(input)) return input
+  const matches = seen.filter((id) => id.startsWith(input))
+  if (matches.length === 1) return matches[0]
+  if (matches.length > 1) fail(`${input} matches ${matches.length} sessions`, "Use more of the id.")
+  return input
+}
+
+export function sessionArgs(args: string[]): string[] {
+  return [...new Set(flagValues(args, "--session").map(resolve))]
+}
+
+export function isKnown(sessionId: string) {
+  return seenSessions().some(([id]) => id === sessionId)
+}

package/src/cli/stats.ts

@@ -0,0 +1,73 @@
+import { STATUS_WINDOW_MS } from "./constants"
+import type { RequestRecord } from "./types"
+
+export interface SessionStats {
+  context: number
+  plain: number | null
+  turns: number | null
+  requests: number
+  folds: number
+  lastSeen: string
+}
+
+export interface Totals {
+  requests: number
+  cacheRead: number
+  cacheWrite: number
+  uncached: number
+  folds: number
+  lastFold: string | null
+  sent: number
+  saved: number
+}
+
+const THREAD_SUFFIX = /-[0-9a-f]{24}$/
+
+export const sessionOf = (record: RequestRecord): string | null => (typeof record.thread === "string" ? record.thread.replace(THREAD_SUFFIX, "") : null)
+
+const plainTokens = (record: RequestRecord): number | null => (record.charsIn > 0 && record.charsOut > 0 && record.input > 0 ? Math.round(record.input * record.charsIn / record.charsOut) : null)
+
+export function withinWindow(records: RequestRecord[], now = Date.now(), window = STATUS_WINDOW_MS): RequestRecord[] {
+  return records.filter((record) => now - Date.parse(record.ts) <= window)
+}
+
+export function perSession(records: RequestRecord[]): Map<string, SessionStats> {
+  const stats = new Map<string, SessionStats>()
+  for (const record of records) {
+    const id = sessionOf(record)
+    if (!id || !(record.input > 0)) continue
+    const previous = stats.get(id)
+    stats.set(id, {
+      context: record.input,
+      plain: plainTokens(record),
+      turns: typeof record.turns === "number" ? record.turns : previous?.turns ?? null,
+      requests: (previous?.requests ?? 0) + 1,
+      folds: (previous?.folds ?? 0) + (record.compacted ? 1 : 0),
+      lastSeen: record.ts,
+    })
+  }
+  return stats
+}
+
+export function totals(records: RequestRecord[]): Totals {
+  const out: Totals = { requests: 0, cacheRead: 0, cacheWrite: 0, uncached: 0, folds: 0, lastFold: null, sent: 0, saved: 0 }
+  for (const record of records) {
+    if (!(record.input > 0)) continue
+    out.requests += 1
+    out.cacheRead += record.cacheRead ?? 0
+    out.cacheWrite += record.cacheWrite ?? 0
+    out.uncached += record.uncached ?? 0
+    if (record.compacted) {
+      out.folds += 1
+      out.lastFold = record.ts
+    }
+    const plain = plainTokens(record)
+    if (plain !== null) {
+      out.sent += record.input
+      out.saved += plain - record.input
+    }
+  }
+  return out
+}
+
+export const savedShare = (context: number, plain: number | null): number | null => (plain && plain > context ? 1 - context / plain : plain ? 0 : null)

package/src/cli/types.ts

@@ -7,6 +7,7 @@ export interface Command {
   usage: string
   details?: string[]
   options?: OptionRow[]
+  hidden?: boolean
   run: (args: string[]) => void | Promise<void>
 }
 

package/src/cli/ui.ts

@@ -53,6 +53,21 @@ export function rows(entries: Array<[string, string]>, indent = 2) {
   for (const [label, value] of entries) console.log(`${" ".repeat(indent)}${c.dim(label.padEnd(width))}  ${value}`)
 }
 
+const visible = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "")
+
+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()}`)
+  }
+}
+
+export function percent(share: number) {
+  return `${Math.round(share * 100)}%`
+}
+
 export function tilde(file: string) {
   const home = homedir()
   return file.startsWith(home) ? `~${file.slice(home.length)}` : file

package/src/config/constants.ts

@@ -1,6 +1,6 @@
 import { homedir } from "node:os"
 import path from "node:path"
-import type { Config, Mode, SearchMode } from "./types"
+import type { Config, Mode, Scope, SearchMode, Tunable } from "./types"
 
 export const EUNOE_DIR = process.env.EUNOE_DIR ?? path.join(homedir(), ".eunoe")
 
@@ -10,18 +10,30 @@ export const paths = {
   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"),
 }
 
+export const RERANK_OFF = "off"
+
 export const DEFAULTS: Config = {
-  mode: "compact",
+  mode: "default",
+  scope: "all",
+  sessions: {},
   port: 8788,
   compactAt: 0.9,
   keepTurns: "all",
+  keep: 3,
+  budget: 100_000,
   search: "markdown",
+  rerank: "jev-preview",
   upstream: "https://api.anthropic.com",
   claudeConfigDirs: [],
 }
 
-export const MODES: Mode[] = ["off", "trim", "compact"]
+export const MODES: Mode[] = ["default", "compact", "off"]
 export const SEARCH_MODES: SearchMode[] = ["jsonl", "markdown", "xml", "qmd"]
+export const TUNABLES: Tunable[] = ["keep", "budget", "compactAt", "keepTurns", "search", "rerank"]
+export const SCOPES: Scope[] = ["all", "sessions"]
+export const SESSION_ID_PATTERN = /^[a-zA-Z0-9-]+$/

package/src/config/index.ts

@@ -1,15 +1,47 @@
 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, SEARCH_MODES } from "./constants"
-import type { Config } from "./types"
+import { DEFAULTS, EUNOE_DIR, MODES, paths, SCOPES, SEARCH_MODES, TUNABLES } from "./constants"
+import type { Config, Mode, SessionSettings, Tunable, Tunables } from "./types"
+
+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),
+}
+
+const TEXT_TUNABLES: Tunable[] = ["search", "rerank"]
+
+const isMode = (value: unknown): value is Mode => MODES.includes(value as Mode)
+
+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
+}
+
+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] })
+  return settings
+}
 
 export function normalizeConfig(raw: Record<string, any>): Config {
   const config: Config = { ...DEFAULTS, ...raw }
-  if (!MODES.includes(config.mode)) config.mode = DEFAULTS.mode
-  if (!SEARCH_MODES.includes(config.search)) config.search = DEFAULTS.search
-  if (typeof config.compactAt !== "number" || config.compactAt <= 0 || config.compactAt > 1) config.compactAt = DEFAULTS.compactAt
-  if (config.keepTurns !== "all" && (typeof config.keepTurns !== "number" || config.keepTurns < 0)) config.keepTurns = DEFAULTS.keepTurns
+  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 (!Number.isInteger(config.port)) config.port = DEFAULTS.port
   if (!Array.isArray(config.claudeConfigDirs)) config.claudeConfigDirs = []
   return config
@@ -47,3 +79,20 @@ export function claudeConfigDirs(config: Config): string[] {
   for (const dir of config.claudeConfigDirs) dirs.add(dir.replace(/^~(?=$|\/)/, homedir()))
   return [...dirs]
 }
+
+export function modeFor(config: Config, sessionId: string | null): Mode {
+  if (sessionId && sessionId in config.sessions) return config.sessions[sessionId].mode ?? config.mode
+  return config.scope === "all" ? config.mode : "off"
+}
+
+export function overrides(settings: SessionSettings | undefined): Partial<Tunables> {
+  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/types.ts

@@ -1,19 +1,48 @@
-export type Mode = "off" | "trim" | "compact"
+export type Mode = "off" | "compact" | "default"
 export type SearchMode = "jsonl" | "markdown" | "xml" | "qmd"
+export type Scope = "all" | "sessions"
+
+export interface RollingConfig {
+  keep: number
+  budget: number
+}
+
+export interface RerankConfig {
+  model: string
+  candidates?: number
+}
 
 export interface EvalConfig {
-  strategy?: "tail" | "guide"
+  strategy?: "tail" | "guide" | "trim"
+  rolling?: RollingConfig
   tailTurns?: number
   forceCut?: boolean
   trustHeaders?: boolean
+  evidence?: boolean
+  recall?: boolean
+  rerank?: RerankConfig
 }
 
-export interface Config {
-  mode: Mode
-  port: number
+export interface Tunables {
   compactAt: number
   keepTurns: number | "all"
+  keep: number
+  budget: number
   search: SearchMode
+  rerank: string
+}
+
+export type Tunable = keyof Tunables
+
+export 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

package/src/context/constants.ts

@@ -5,3 +5,38 @@ export const SUMMARY_CALLS_SHOWN = 20
 
 export const CLEARED_INPUT_THRESHOLD = 2_000
 export const CLEARED_INPUT_KEPT = 500
+
+export const REMINDER_ONLY = /^\s*(?:<system-reminder>[\s\S]*?<\/system-reminder>\s*)+$/
+
+export const REREADABLE_TOOLS = new Set(["Read", "Grep", "Glob", "LS", "NotebookRead", "WebFetch", "WebSearch", "TodoWrite", "Edit", "Write", "MultiEdit", "NotebookEdit"])
+export const EVIDENCE_LINES_PER_CALL = 12
+export const EVIDENCE_LINE_CHARS = 220
+export const EVIDENCE_TURN_CHARS = 4_000
+export const EVIDENCE_SCAN_LINES = 1_000_000
+export const EVIDENCE_MIN_SCORE = 2
+export const EVIDENCE_RANKED = true
+export const EVIDENCE_LABELS = true
+export const EVIDENCE_CALL_FLOOR = 2
+export const ERROR_LINE = /\b(?:error|errors|fail|fails|failed|failure|fatal|exception|panic|denied|refused|timed? ?out|traceback|cannot|unable to)\b/i
+export 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/
+export 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
+export 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
+export const KEY_VALUE =/^[\w .\-/()]{2,48}[:=]\s*\S/
+export 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
+
+export const RECALL_WINDOW_LINES = 6
+export const RECALL_SHOWN_LINES = 8
+export const RECALL_PER_QUERY = 12
+export const RECALL_MAX_CHARS = 18_000
+export const RECALL_MAX_CHARS_MULTI = 30_000
+export const RECALL_MIN_TERMS = 2
+export const RECALL_SALIENT_EXCERPT = true
+export const RECALL_NARRATIVE = true
+export const RECALL_LINE_CHARS = 240
+export const RECALL_RERANK_CANDIDATES = 30
+export const RERANK_ENDPOINT = "https://api.typesafe.ai/v1/systemone"
+export const RERANK_TIMEOUT_MS = 4_000
+export const RERANK_LINE_CHARS = 240
+export const BM25_K1 = 1.2
+export const BM25_B = 0.75
+export const STOPWORDS = new Set("the and for with that this what which when where who how was were did does done from into onto have has had you your our out not but are can could would should will just then than them they there their its it's about after before again also any each other some such only own same very more most over under while because been being into".split(" "))

package/src/context/content.ts

@@ -1,3 +1,4 @@
+import { SUMMARY_ARGUMENT_CHARS, SUMMARY_COMMAND_CHARS } from "./constants"
 import type { Block, Message } from "./types"
 
 export function contentBlocks(content: unknown): Block[] {
@@ -18,7 +19,28 @@ export function clean(message: Message): Message {
   return { role: message.role, content: blocks(message).map(withoutCacheControl) }
 }
 
+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 ? `${text.slice(0, max)}…` : text
+  return text.length > max ? `${truncate(text, max)}…` : text
+}
+
+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.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")
 }

package/src/context/evidence.ts

@@ -0,0 +1,92 @@
+import { ERROR_CODE, ERROR_LINE, EVIDENCE_CALL_FLOOR, EVIDENCE_LABELS, EVIDENCE_LINE_CHARS, EVIDENCE_LINES_PER_CALL, EVIDENCE_MIN_SCORE, EVIDENCE_RANKED, EVIDENCE_SCAN_LINES, EVIDENCE_TURN_CHARS, ID_TOKEN, KEY_VALUE, REREADABLE_TOOLS, VALUE_LABEL, VALUE_TOKEN } from "./constants"
+import { blocks, clip, describeToolCall, resultText } from "./content"
+import type { Block, EvidenceOptions, Message } from "./types"
+
+interface Scored {
+  index: number
+  line: string
+  score: number
+}
+
+export function isSalient(line: string): boolean {
+  return ERROR_LINE.test(line) || ERROR_CODE.test(line) || VALUE_TOKEN.test(line)
+}
+
+function scoreLines(text: string, options: EvidenceOptions): Scored[] {
+  const scan = options.scanLines ?? EVIDENCE_SCAN_LINES
+  const lineChars = options.lineChars ?? EVIDENCE_LINE_CHARS
+  const minScore = options.minScore ?? EVIDENCE_MIN_SCORE
+  const scored = text.split("\n").slice(0, scan).flatMap((raw, index) => {
+    const line = raw.trim()
+    if (line.length < 4) return []
+    const error = ERROR_LINE.test(line) || ERROR_CODE.test(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) + ((options.labels ?? EVIDENCE_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, options.linesPerCall ?? EVIDENCE_LINES_PER_CALL)
+    .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) => (results.has(call.id) ? [{ call, result: results.get(call.id)! }] : []))
+}
+
+function render(entries: Array<{ head: string; lines: string[] }>): string | null {
+  const body = entries.filter((e) => e.lines.length).map((e) => `- ${e.head}:\n${e.lines.map((l) => `    ${l}`).join("\n")}`)
+  return body.length ? `<tool-evidence>\nKey lines of command output from this turn, kept verbatim (the full output is in the transcript):\n${body.join("\n")}\n</tool-evidence>` : null
+}
+
+export function turnEvidence(turn: Message[], options: EvidenceOptions = {}): string | null {
+  const turnChars = options.turnChars ?? EVIDENCE_TURN_CHARS
+  const perCall = options.linesPerCall ?? EVIDENCE_LINES_PER_CALL
+  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)" : ""}`)
+  if (!(options.ranked ?? EVIDENCE_RANKED)) {
+    const entries: Array<{ head: string; lines: string[] }> = []
+    let used = 0
+    pairs.forEach(({ result }, i) => {
+      const lines = salientLines(resultText(result), options)
+      if (!lines.length) 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 render(entries)
+  }
+  const floor = options.callFloor ?? EVIDENCE_CALL_FLOOR
+  const perCallLines = 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 : heads[call].length + 4)
+    if (bucket.length >= perCall || used + cost > turnChars) return
+    bucket.push(line)
+    chosen.set(call, bucket)
+    used += cost
+  }
+  perCallLines.forEach((lines, call) => lines.slice(0, floor).forEach((line) => take(call, line)))
+  perCallLines
+    .flatMap((lines, call) => lines.slice(floor).map((line) => ({ line, call })))
+    .sort((a, b) => b.line.score - a.line.score || a.call - b.call || a.line.index - b.line.index)
+    .forEach(({ line, call }) => take(call, line))
+  return render(heads.map((head, i) => ({ head, lines: (chosen.get(i) ?? []).sort((a, b) => a.index - b.index).map((s) => s.line) })))
+}