opencode-jev-compaction 0.1.1 → 0.3.0

package/src/server.ts

@@ -1,97 +1,70 @@
-// jev-compaction — an opencode server plugin.
+// jev-compaction v0.3 — opencode server plugin, deterministic-first.
 //
-// Strategy adapted from https://github.com/tamaratran/fast-jev-compaction (MIT):
-// never summarize on compaction. Instead ask a fast model, per tool call, whether the
-// call and whether its full output still need to be in context. Drop the ones that
-// don't, truncate the ones where only the fact of the call matters, and leave every
-// user and assistant message verbatim. See NOTICE for the attribution.
+// HISTORY, because it explains the shape of this file:
+// v0.1 asked Jev a judgement per tool call ("should this stay? knowing it was made
+// still matters"). That produced mushy, drop-happy scores and once deleted a short file
+// of hard constraints. Two independent findings agreed on why: with a `noul` primitive
+// (calibrated P(true)), factual questions are reliable and judgement questions are not
+// — measured elsewhere at 0.996 on an explicit fact versus 0.003-0.28 on judgements.
 //
-// Adapted to opencode's model: a `tool` part carries both the call (state.input) and
-// its result (state.output) together, so there is no orphaned-result case to guard
-// against the way the original has to.
+// So v0.3 asks only facts, and computes what it can exactly:
 //
-// Safety: this runs before every model request. It never throws — any failure leaves
-// the messages exactly as they were.
+//   superseded       a later call reads/writes the same target  -> computed here
+//   errorResolved    this call errored, a later call succeeded  -> computed here
+//   referenced       a later message or tool input mentions the target string
+//                                                              -> computed here
+//   contentReferenced a later message quotes a value from the result body
+//                                                              -> the one question left
+//                                                                 for the model
 //
-//   TYPESAFE_API_KEY              API key (required unless the keychain is configured)
-//   JEV_KEYCHAIN_SERVICE          macOS keychain service to read the key from
-//   JEV_KEYCHAIN_ACCOUNT          macOS keychain account to read the key from
-//   JEV_COMPACTION=0              disable entirely
-//   JEV_COMPACTION_THRESHOLD      estimated tokens before it engages (default 60000)
-//   JEV_KEEP_THRESHOLD            minimum keep probability (default 0.35)
-//   JEV_PRESERVE_RECENT           newest messages never touched (default 6, minimum 1)
-//   JEV_MAX_STATE_TOKENS          ceiling for the state sent to Jev (default 25000)
-//   JEV_MAX_REQUEST_TOKENS        ceiling for state plus questions (default 30000)
-//   JEV_TRUNCATE_HEAD             chars of a dropped result retained (default 300)
-//   JEV_SMALL_RESULT_CHARS        results this size or smaller are shown to Jev in full (default 600)
-//   JEV_TIMEOUT_MS                per-request timeout (default 20000)
-//   JEV_DAILY_REQUEST_CAP         hard ceiling on Jev requests per day (default 200)
-//   JEV_MODEL                     model name (default "jev-latest")
-//   JEV_BASE_URL                  endpoint (default the System One endpoint)
-//   JEV_DEBUG=1                   append a trace to the debug log
-
-import { spawnSync } from "node:child_process"
+// Deletion requires DETERMINISTIC evidence (superseded or error-resolved). The model can
+// only ever justify a truncation, which keeps a head plus a "re-run if needed" note and
+// is therefore recoverable. Nothing is ever dropped on a probabilistic answer.
+//
+// Payload: the old design resent a 25k-token state on every request, which cost about
+// $1/day against a hosted model. A fact question needs only the target, a bounded
+// excerpt of the result, and the messages that came after — a few KB.
+
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
-import { join } from "node:path"
+import { basename, join } from "node:path"
 
-const ENDPOINT = process.env.JEV_BASE_URL ?? "https://api.typesafe.ai/v1/systemone"
-const MODEL = process.env.JEV_MODEL ?? "jev-latest"
+const ENDPOINT = process.env.LAYA_BASE_URL ?? process.env.JEV_BASE_URL ?? "http://127.0.0.1:8000/v1/systemone"
+const MODEL = process.env.LAYA_MODEL ?? process.env.JEV_MODEL ?? "laya"
+const API_KEY = process.env.LAYA_API_KEY ?? process.env.TYPESAFE_API_KEY ?? ""
 
-/** Parse a numeric setting, falling back rather than letting NaN disable a guard. */
 function num(value: string | undefined, fallback: number, min = 0): number {
   const parsed = Number(value)
   return Number.isFinite(parsed) && parsed >= min ? parsed : fallback
 }
 
-const ENABLED = process.env.JEV_COMPACTION !== "0"
-const THRESHOLD_TOKENS = num(process.env.JEV_COMPACTION_THRESHOLD, 60_000, 1)
-const MAX_STATE_TOKENS = num(process.env.JEV_MAX_STATE_TOKENS, 25_000, 1)
-const MAX_REQUEST_TOKENS = num(process.env.JEV_MAX_REQUEST_TOKENS, 30_000, 1)
-const KEEP_THRESHOLD = num(process.env.JEV_KEEP_THRESHOLD, 0.35)
-const PRESERVE_RECENT = Math.max(1, Math.floor(num(process.env.JEV_PRESERVE_RECENT, 6, 1)))
-const TRUNCATE_HEAD = Math.floor(num(process.env.JEV_TRUNCATE_HEAD, 300))
-const SMALL_RESULT_CHARS = Math.floor(num(process.env.JEV_SMALL_RESULT_CHARS, 600))
-const TIMEOUT_MS = num(process.env.JEV_TIMEOUT_MS, 20_000, 1)
-const DAILY_REQUEST_CAP = Math.floor(num(process.env.JEV_DAILY_REQUEST_CAP, 200))
+const ENABLED = process.env.LAYA_COMPACTION !== "0" && process.env.JEV_COMPACTION !== "0"
+const THRESHOLD_TOKENS = num(process.env.LAYA_COMPACTION_THRESHOLD, 60_000, 1)
+const PRESERVE_RECENT = Math.max(1, Math.floor(num(process.env.LAYA_PRESERVE_RECENT, 6, 1)))
+const SMALL_RESULT_CHARS = Math.floor(num(process.env.LAYA_SMALL_RESULT_CHARS, 600))
+const TRUNCATE_HEAD = Math.floor(num(process.env.LAYA_TRUNCATE_HEAD, 300))
+const EXCERPT_CHARS = Math.floor(num(process.env.LAYA_EXCERPT_CHARS, 400))
+/** Laya's sequence budget is 512 tokens; the model sees only this much of what came after. */
+const AFTER_CHARS = Math.floor(num(process.env.LAYA_AFTER_CHARS, 1000))
+const REFERENCED_HIGH = num(process.env.LAYA_REFERENCED_HIGH, 0.7)
+const REFERENCED_LOW = num(process.env.LAYA_REFERENCED_LOW, 0.3)
+const TIMEOUT_MS = num(process.env.LAYA_TIMEOUT_MS, 8_000, 1)
+const DAILY_REQUEST_CAP = Math.floor(num(process.env.LAYA_DAILY_REQUEST_CAP, 400))
+const MAX_QUESTIONS = Math.floor(num(process.env.LAYA_MAX_QUESTIONS, 40))
+const CONCURRENCY = Math.floor(num(process.env.LAYA_CONCURRENCY, 4, 1))
 
 const STATE_DIR = join(homedir(), ".local", "share", "opencode")
-const STATS_FILE = join(STATE_DIR, "jev-compaction.json")
-const CAP_FILE = join(STATE_DIR, "jev-compaction-usage.json")
-const DEBUG_FILE = join(STATE_DIR, "jev-compaction.log")
-
-const STATE_CONTEXT =
-  "A coding assistant conversation is being compacted to free context. `history` is the whole " +
-  "conversation so far, oldest first; tool outputs are replaced by a short `result` note and long " +
-  "texts may be abridged. Each question asks whether one tool call, or the full output of that " +
-  "call, still needs to stay in the history verbatim. Whatever is not kept is deleted permanently, " +
-  "but the assistant can always re-run a tool or re-read a file."
-
-// Plugin modules are loaded once per server process, so this state persists across
-// the many transform calls a single session makes. Decisions are monotonic per call:
-// once dropped, always dropped.
-const decided = new Map<string, Action>()
-let cachedKey: string | undefined
-let counted: { day: string; requests: number } | undefined
-
-function trace(line: string, extra?: unknown) {
-  if (process.env.JEV_DEBUG !== "1") return
-  try {
-    mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 })
-    appendFileSync(
-      DEBUG_FILE,
-      `${new Date().toISOString()} ${line}${extra === undefined ? "" : " " + JSON.stringify(extra)}\n`,
-      { mode: 0o600 },
-    )
-  } catch {}
-}
+const STATS_FILE = join(STATE_DIR, "laya-compaction.json")
+const LEDGER_FILE = join(STATE_DIR, "laya-compaction-ledger.jsonl")
+const CAP_FILE = join(STATE_DIR, "laya-compaction-usage.json")
+const DEBUG_FILE = join(STATE_DIR, "laya-compaction.log")
 
-// --- token estimate -----------------------------------------------------------
-// A word costs ~1 token per 6 letters, a digit half a token, any other symbol 0.9.
-// Lands slightly above the counts Jev reports, which is the safe direction.
+const DECISION_FACT =
+  "Coding agent context pruning. `target` is what a tool call touched, `result_head` is the " +
+  "beginning of its output, and `after` is everything that came later in the conversation. " +
+  "Questions are answerable by inspection of `after`; answer only from what is present there."
 
 const TOKEN_PIECES = /[A-Za-z]+|\d+|[^\sA-Za-z\d]/g
-
 function estimateTokens(text: string): number {
   let tokens = 0
   for (const [piece] of text.matchAll(TOKEN_PIECES)) {
@@ -103,40 +76,23 @@ function estimateTokens(text: string): number {
   return Math.ceil(tokens)
 }
 
-// --- key ----------------------------------------------------------------------
-
-function apiKey(): string {
-  if (cachedKey !== undefined) return cachedKey
-  const env = process.env.TYPESAFE_API_KEY
-  if (env && env.trim()) {
-    cachedKey = env.trim()
-    return cachedKey
-  }
-  const service = process.env.JEV_KEYCHAIN_SERVICE
-  const account = process.env.JEV_KEYCHAIN_ACCOUNT
-  if (service && account) {
-    // Array args, no shell: env-derived values cannot be interpolated into a command.
-    // Timeout so a locked keychain cannot block the pre-request path indefinitely.
-    const result = spawnSync(
-      "security",
-      ["find-generic-password", "-s", service, "-a", account, "-w"],
-      { encoding: "utf8", timeout: 3000, stdio: ["ignore", "pipe", "ignore"] },
-    )
-    cachedKey = result.status === 0 ? (result.stdout ?? "").trim() : ""
-    trace("key resolved", { source: "keychain", found: cachedKey.length > 0 })
-    return cachedKey
-  }
-  cachedKey = ""
-  return cachedKey
+function trace(line: string, extra?: unknown) {
+  if (process.env.LAYA_DEBUG !== "1" && process.env.JEV_DEBUG !== "1") return
+  try {
+    mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 })
+    appendFileSync(DEBUG_FILE, `${new Date().toISOString()} ${line}${extra === undefined ? "" : " " + JSON.stringify(extra)}\n`, { mode: 0o600 })
+  } catch {}
 }
 
 // --- spend ceiling -------------------------------------------------------------
 
-function today(): string {
-  return new Date().toISOString().slice(0, 10)
-}
+const counters = { transformCalls: 0, engaged: 0, belowThreshold: 0, capReached: 0, noBackend: 0 }
+let lastFlush = 0
+let counted: { day: string; requests: number } | undefined
+
+const today = () => new Date().toISOString().slice(0, 10)
 
-function readUsage(): { day: string; requests: number } {
+function readUsage() {
   try {
     const raw = JSON.parse(readFileSync(CAP_FILE, "utf8"))
     if (raw && raw.day === today()) return { day: raw.day, requests: Number(raw.requests) || 0 }
@@ -144,8 +100,7 @@ function readUsage(): { day: string; requests: number } {
   return { day: today(), requests: 0 }
 }
 
-/** Process-local counter so concurrent batches cannot lose increments. */
-function dayUsage(): { day: string; requests: number } {
+function dayUsage() {
   if (!counted || counted.day !== today()) counted = readUsage()
   return counted
 }
@@ -157,64 +112,96 @@ function writeUsage(current: { day: string; requests: number }) {
   } catch {}
 }
 
-// --- asking -------------------------------------------------------------------
+function updateStats(mutate: (stats: any) => void) {
+  try {
+    mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 })
+    let stats: any = {}
+    try {
+      stats = JSON.parse(readFileSync(STATS_FILE, "utf8"))
+    } catch {}
+    mutate(stats)
+    stats.updated = new Date().toISOString()
+    writeFileSync(STATS_FILE, JSON.stringify(stats, null, 2), { mode: 0o600 })
+  } catch {}
+}
 
-type Question = { type: "noul"; instructions: string }
-type Answers = Record<string, { noul?: unknown }>
+function flushCounters(force = false) {
+  const now = Date.now()
+  if (!force && now - lastFlush < 60_000) return
+  if (counters.transformCalls === 0 && counters.engaged === 0) return
+  lastFlush = now
+  const snapshot = { ...counters }
+  for (const key of Object.keys(counters) as Array<keyof typeof counters>) counters[key] = 0
+  updateStats((stats) => {
+    for (const [key, value] of Object.entries(snapshot)) stats[key] = (Number(stats[key]) || 0) + value
+  })
+}
 
-async function ask(state: object, questions: Record<string, Question>): Promise<Answers> {
-  const key = apiKey()
-  if (!key) throw new Error("no Jev key configured (TYPESAFE_API_KEY or JEV_KEYCHAIN_SERVICE/JEV_KEYCHAIN_ACCOUNT)")
+function appendLedger(entry: Record<string, unknown>) {
+  try {
+    mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 })
+    appendFileSync(LEDGER_FILE, JSON.stringify(entry) + "\n", { mode: 0o600 })
+  } catch {}
+}
 
+// --- backend -------------------------------------------------------------------
+
+/**
+ * One residual question: does anything after this call depend on its output?
+ *
+ * Deliberately a `choice` rather than a `noul`. Measured against this same local model:
+ * a `noul` statement and its own negation both scored ~0.95, so it agreed with the shape
+ * of the question rather than reading it. As a two-option choice with explicit criteria
+ * the same cases separate cleanly (quotes 0.75-0.99 on a real quote, does-not 0.80-0.91
+ * on unrelated text). Do not "simplify" this back to a boolean statement.
+ */
+async function askChoice(
+  state: object,
+  name: string,
+  instructions: string,
+  criteria: Record<string, string>,
+): Promise<{ choice?: string; probabilities?: Record<string, number> }> {
   const controller = new AbortController()
   const timer = setTimeout(() => controller.abort(), TIMEOUT_MS)
   try {
+    const headers: Record<string, string> = { "content-type": "application/json" }
+    if (API_KEY) headers.authorization = `Bearer ${API_KEY}`
     const response = await fetch(ENDPOINT, {
       method: "POST",
-      headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
-      body: JSON.stringify({ model: MODEL, state, questions }),
+      headers,
+      body: JSON.stringify({ model: MODEL, state, questions: { [name]: { type: "choice", instructions, criteria } } }),
       signal: controller.signal,
     })
-    if (!response.ok) throw new Error(`jev request failed (${response.status})`)
+    if (!response.ok) throw new Error(`backend ${response.status}`)
     const parsed = JSON.parse(await response.text())
-    if (!parsed || typeof parsed !== "object" || !("answers" in parsed) || !parsed.answers) {
-      throw new Error("jev response missing answers")
-    }
-    trace("jev usage", {
-      input: parsed.usage?.input_tokens,
-      output: parsed.usage?.output_tokens,
-      answers: Object.keys(parsed.answers ?? {}).length,
-    })
-    return parsed.answers as Answers
+    const answer = parsed?.answers?.[name]
+    if (!answer || typeof answer !== "object") throw new Error("no answer in response")
+    return { choice: answer.choice, probabilities: answer.probabilities }
   } finally {
     clearTimeout(timer)
   }
 }
 
-function noul(answers: Answers, name: string): number {
-  const value = answers?.[name]?.noul
-  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`invalid jev answer for ${name}`)
-  return value
-}
-
-// --- opencode part handling ---------------------------------------------------
+// --- opencode parts ------------------------------------------------------------
 
 type Part = { id?: string; type?: string; tool?: string; callID?: string; state?: any; text?: string; [key: string]: any }
 type Message = { info?: any; parts?: Part[]; [key: string]: any }
-type Call = {
-  id: string
+
+type Candidate = {
   callID: string
   tool: string
   input: Record<string, unknown>
   output: string
   isError: boolean
   messageIndex: number
-  /** The part itself, held by reference: dropping one part must not shift the others. */
   part: Part
-  pinned: boolean
+  targets: string[]
+  key: string
 }
 
-function isFinishedToolPart(part: Part): boolean {
+const TARGET_KEYS = /^(file_?path|filepath|path|file|filename|dir|directory|command|cmd|pattern|url|uri|query|name|target)$/i
+
+function isFinished(part: Part): boolean {
   if (part?.type !== "tool") return false
   return part.state?.status === "completed" || part.state?.status === "error"
 }
@@ -232,244 +219,137 @@ function textOf(message: Message): string {
     .trim()
 }
 
+/** Strings that identify what a call touched, for later-mention checks. */
+function targetsOf(input: Record<string, unknown>): string[] {
+  const found = new Set<string>()
+  for (const [key, value] of Object.entries(input ?? {})) {
+    if (typeof value !== "string") continue
+    if (!TARGET_KEYS.test(key)) continue
+    const raw = value.trim()
+    if (raw.length < 3) continue
+    found.add(raw)
+    if (raw.includes("/")) {
+      const base = basename(raw)
+      if (base.length >= 3) found.add(base)
+    }
+  }
+  return [...found].slice(0, 4)
+}
+
+/** Comparable identity for supersession: same tool, same target. */
+function identityOf(tool: string, targets: string[]): string {
+  const normalized = targets.map((t) => t.toLowerCase().replace(/\s+/g, " ").trim()).sort().join("|")
+  return `${tool}::${normalized}`
+}
+
 function isPinned(index: number, total: number): boolean {
   return index === 0 || index >= total - PRESERVE_RECENT
 }
 
-function collectCalls(messages: Message[]): Call[] {
-  const calls: Call[] = []
+function candidatesOf(messages: Message[]): Candidate[] {
+  const list: Candidate[] = []
   messages.forEach((message, messageIndex) => {
     for (const part of message.parts ?? []) {
-      if (!isFinishedToolPart(part)) continue
+      if (!isFinished(part)) continue
       const { text, isError } = outputOf(part)
-      calls.push({
-        id: `t${calls.length + 1}`,
-        callID: String(part.callID ?? part.id ?? `p${calls.length + 1}`),
+      const input = (part.state?.input as Record<string, unknown>) ?? {}
+      const targets = targetsOf(input)
+      list.push({
+        callID: String(part.callID ?? part.id ?? `p${list.length + 1}`),
         tool: String(part.tool ?? "tool"),
-        input: (part.state?.input as Record<string, unknown>) ?? {},
+        input,
         output: text,
         isError,
         messageIndex,
         part,
-        pinned: isPinned(messageIndex, messages.length),
+        targets,
+        key: identityOf(String(part.tool ?? "tool"), targets.length ? targets : [JSON.stringify(input)]),
       })
     }
   })
-  return calls
-}
-
-// --- state fitting ------------------------------------------------------------
-
-const INPUT_CHARS = [1000, 200, 60] as const
-const TEXT_HEAD = 400
-const TEXT_TAIL = 150
-
-function truncate(text: string, limit: number): string {
-  return text.length <= limit ? text : `${text.slice(0, Math.max(0, limit - 1))}…`
-}
-
-function abridge(text: string, head: number, tail: number): string {
-  if (text.length <= head + tail + 40) return text
-  return `${text.slice(0, head)}\n[… ${text.length - head - tail} chars omitted …]\n${text.slice(-tail)}`
-}
-
-function inputText(input: Record<string, unknown>, limit: number): string {
-  try {
-    return truncate(JSON.stringify(input), limit)
-  } catch {
-    return "[unserializable input]"
-  }
+  return list
 }
 
-function resultNote(call: Call): string {
-  // Small results are sent in full. Replacing every result with a note hides the
-  // evidence Jev needs: it cannot tell a throwaway file listing from a short file
-  // of hard constraints, so it reasonably guesses "cheap to re-read" and drops
-  // both. Showing what a small result actually says is what lets it tell them apart.
-  if (call.output.length <= SMALL_RESULT_CHARS) return call.output
-  return `${call.isError ? "error" : "ok"}, ${call.output.length} chars (omitted)`
-}
-
-function compactCall(call: Call): string {
-  const input = Object.entries(call.input)
-    .map(([key, value]) => {
-      const text = typeof value === "string" ? value : inputText({ [key]: value }, 200)
-      return `${key}=${text.replace(/\s+/g, " ")}`
-    })
-    .join(" ")
-  return `${call.id} ${call.tool} ${truncate(input, INPUT_CHARS[2])} → ${call.isError ? "error" : "ok"} ${call.output.length}ch`
-}
-
-type Entry = { i: number; role: string; text: string; tool_calls?: Array<Record<string, string>> | string[] }
-
-function buildHistory(messages: Message[], calls: Call[], inputChars: number): Entry[] {
-  const byMessage = new Map<number, Call[]>()
-  for (const call of calls) {
-    const list = byMessage.get(call.messageIndex) ?? []
-    list.push(call)
-    byMessage.set(call.messageIndex, list)
+/**
+ * Everything after a position. `prose` is message text only: that is what the deterministic
+ * mention check uses, because a later call to the same target is supersession, not a
+ * reference, and counting its input as a mention would mask exactly that. `full` adds the
+ * later tool calls and is what the model sees.
+ */
+function contextAfter(messages: Message[], index: number): { prose: string; full: string } {
+  const prose: string[] = []
+  const toolLines: string[] = []
+  for (let i = index + 1; i < messages.length && prose.length + toolLines.length < 40; i++) {
+    const text = textOf(messages[i]!)
+    if (text) prose.push(text.slice(0, 600))
+    for (const part of messages[i]?.parts ?? []) {
+      if (part?.type !== "tool") continue
+      toolLines.push(`called ${part.tool} with ${JSON.stringify(part.state?.input ?? {}).slice(0, 200)}`)
+    }
   }
-  const entries: Entry[] = []
-  messages.forEach((message, index) => {
-    const toolCalls = (byMessage.get(index) ?? []).map((call) => ({
-      id: call.id,
-      tool: call.tool,
-      input: inputText(call.input, inputChars),
-      result: resultNote(call),
-    }))
-    const text = textOf(message)
-    if (text.length === 0 && toolCalls.length === 0) return
-    const entry: Entry = { i: index, role: String(message.info?.role ?? "user"), text }
-    if (toolCalls.length > 0) entry.tool_calls = toolCalls
-    entries.push(entry)
-  })
-  return entries
+  return { prose: prose.join("\n"), full: [...prose, ...toolLines].join("\n") }
 }
 
-function goalFrom(messages: Message[]): string {
-  return messages
-    .filter((message) => message.info?.role === "user" && textOf(message).length > 0)
-    .slice(-3)
-    .map((message) => truncate(textOf(message), 500))
-    .join("\n")
+// --- policy --------------------------------------------------------------------
+
+type Action = "keep" | "truncate" | "drop"
+type Reason =
+  | "referenced"
+  | "superseded"
+  | "error-resolved"
+  | "small-result"
+  | "model-referenced"
+  | "model-unreferenced"
+  | "inconclusive"
+
+function truncatedOutput(text: string, isError: boolean): string {
+  if (text.length <= TRUNCATE_HEAD + 120) return text
+  const head = TRUNCATE_HEAD > 0 ? `${text.slice(0, TRUNCATE_HEAD)}\n` : ""
+  return `${head}[laya-compaction truncated ${text.length - TRUNCATE_HEAD} chars of this tool result${isError ? " (error)" : ""}; re-run the tool if needed]`
 }
 
-function fitState(messages: Message[], calls: Call[]): { state: object; tokens: number; stage: string } {
-  const goal = goalFrom(messages)
-  const stateOf = (history: Entry[]) => ({ context: STATE_CONTEXT, goal, history })
-  const tokensOf = (history: Entry[]) =>
-    estimateTokens(JSON.stringify(stateOf([]))) +
-    history.reduce((sum, entry) => sum + estimateTokens(JSON.stringify(entry)) + 1, 0)
-
-  for (const limit of INPUT_CHARS) {
-    const history = buildHistory(messages, calls, limit)
-    const tokens = tokensOf(history)
-    if (tokens <= MAX_STATE_TOKENS) return { state: stateOf(history), tokens, stage: `inputs<=${limit}` }
+function decide(candidate: Candidate, later: Candidate[], prose: string): { action: Action; reason: Reason } {
+  // 1. Something later names the target. Kept, no model needed.
+  const mentioned = candidate.targets.some((target) => prose.toLowerCase().includes(target.toLowerCase()))
+  if (mentioned) return { action: "keep", reason: "referenced" }
+
+  // 2. A later call with the same identity: this one is stale, and the answer is deterministic.
+  const sameKey = later.filter((other) => other.key === candidate.key)
+  if (sameKey.length > 0) {
+    return candidate.isError && sameKey.some((other) => !other.isError)
+      ? { action: "drop", reason: "error-resolved" }
+      : { action: "drop", reason: "superseded" }
   }
 
-  const history = buildHistory(messages, calls, INPUT_CHARS[2])
-  let tokens = tokensOf(history)
-  const pinnedAt = (entry: Entry) => isPinned(entry.i, messages.length)
-  const order = [
-    ...history.map((_, i) => i).filter((i) => !pinnedAt(history[i]!)),
-    ...history.map((_, i) => i).filter((i) => pinnedAt(history[i]!)),
-  ]
-
-  for (const index of order) {
-    const entry = history[index]
-    if (!entry || entry.text.length <= TEXT_HEAD + TEXT_TAIL + 40) continue
-    entry.text = abridge(entry.text, TEXT_HEAD, TEXT_TAIL)
-    tokens = tokensOf(history)
-    if (tokens <= MAX_STATE_TOKENS) return { state: stateOf(history), tokens, stage: "texts abridged" }
-  }
+  // 3. Short results are not worth touching, and this is the class v0.1 wrongly deleted.
+  if (candidate.output.length <= SMALL_RESULT_CHARS) return { action: "keep", reason: "small-result" }
 
-  for (const index of order) {
-    const entry = history[index]
-    if (!entry || pinnedAt(entry) || entry.text.length === 0) continue
-    const original = textOf(messages[entry.i] ?? {}).length || entry.text.length
-    entry.text = `[… ${original} chars omitted …]`
-    tokens = tokensOf(history)
-    if (tokens <= MAX_STATE_TOKENS) return { state: stateOf(history), tokens, stage: "old messages collapsed" }
-  }
-
-  const byMessage = new Map<number, Call[]>()
-  for (const call of calls) {
-    const list = byMessage.get(call.messageIndex) ?? []
-    list.push(call)
-    byMessage.set(call.messageIndex, list)
-  }
-  for (const index of order) {
-    const entry = history[index]
-    const own = entry ? byMessage.get(entry.i) : undefined
-    if (!entry || pinnedAt(entry) || !own) continue
-    entry.tool_calls = own.map(compactCall)
-    tokens = tokensOf(history)
-    if (tokens <= MAX_STATE_TOKENS) return { state: stateOf(history), tokens, stage: "old calls compacted" }
-  }
-
-  return { state: stateOf(history), tokens, stage: "overflow" }
+  // 4. Nothing deterministic either way. The model may only justify a truncation.
+  return { action: "truncate", reason: "inconclusive" }
 }
 
-// --- decisions -----------------------------------------------------------------
+// --- telemetry -----------------------------------------------------------------
 
-type Action = "keep" | "drop_result" | "drop_call"
+const sessions = new Map<string, { dropped: Map<string, string>; truncated: Map<string, string> }>()
 
-function questionsFor(call: Call): Record<string, Question> {
-  return {
-    [`call_${call.id}`]: {
-      type: "noul",
-      instructions: `Tool call ${call.id} (${call.tool}) should stay in the history: knowing this call was made, with its input, still matters for what the assistant does next`,
-    },
-    [`result_${call.id}`]: {
-      type: "noul",
-      instructions: `The full output of tool call ${call.id} (${call.tool}, ${call.output.length} chars) should stay in the history verbatim: the assistant still needs its contents and re-running the tool would not do`,
-    },
+function memoryFor(sessionID: string) {
+  let entry = sessions.get(sessionID)
+  if (!entry) {
+    if (sessions.size > 200) sessions.clear()
+    entry = { dropped: new Map(), truncated: new Map() }
+    sessions.set(sessionID, entry)
   }
+  return entry
 }
 
-const REQUEST_OVERHEAD_TOKENS = 20
-
-function batch(calls: Call[], stateTokens: number): Call[][] {
-  const budget = MAX_REQUEST_TOKENS - stateTokens - REQUEST_OVERHEAD_TOKENS
-  const batches: Call[][] = []
-  let current: Call[] = []
-  let currentTokens = 0
-  for (const call of calls) {
-    const tokens = estimateTokens(JSON.stringify(questionsFor(call)))
-    if (current.length > 0 && currentTokens + tokens > budget) {
-      batches.push(current)
-      current = []
-      currentTokens = 0
-    }
-    if (current.length === 0 && tokens > budget) throw new Error(`state leaves no room for questions (~${stateTokens} tokens)`)
-    current.push(call)
-    currentTokens += tokens
-  }
-  if (current.length > 0) batches.push(current)
-  return batches
-}
-
-function decide(call: Call, keepCall: number, keepResult: number): Action {
-  if (call.pinned) return "keep"
-  if (keepResult >= KEEP_THRESHOLD) return "keep"
-  if (keepCall >= KEEP_THRESHOLD) return "drop_result"
-  return "drop_call"
-}
-
-function truncatedOutput(call: Call): string {
-  if (call.output.length <= TRUNCATE_HEAD + 120) return call.output
-  const head = TRUNCATE_HEAD > 0 ? `${call.output.slice(0, TRUNCATE_HEAD)}\n` : ""
-  return `${head}[jev-compaction truncated ${call.output.length - TRUNCATE_HEAD} chars of this tool result${call.isError ? " (error)" : ""}; re-run the tool if needed]`
-}
-
-// --- stats ---------------------------------------------------------------------
-
-function writeStats(delta: {
-  savedChars: number
-  calls: number
-  dropped: number
-  truncated: number
-  requests: number
-  ms: number
-  stage: string
-}) {
+function signatureOf(candidate: Candidate): string {
+  let input = ""
   try {
-    mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 })
-    let previous: any = {}
-    try {
-      previous = JSON.parse(readFileSync(STATS_FILE, "utf8"))
-    } catch {}
-    const next = {
-      updated: new Date().toISOString(),
-      runs: (Number(previous.runs) || 0) + 1,
-      tokensSaved: (Number(previous.tokensSaved) || 0) + Math.round(delta.savedChars / 4),
-      callsSeen: (Number(previous.callsSeen) || 0) + delta.calls,
-      dropped: (Number(previous.dropped) || 0) + delta.dropped,
-      truncated: (Number(previous.truncated) || 0) + delta.truncated,
-      last: delta,
-    }
-    writeFileSync(STATS_FILE, JSON.stringify(next, null, 2), { mode: 0o600 })
-  } catch {}
+    input = JSON.stringify(candidate.input)
+  } catch {
+    input = "[unserializable]"
+  }
+  return `${candidate.tool}\u0000${input}`
 }
 
 // --- the pruner ----------------------------------------------------------------
@@ -477,96 +357,129 @@ function writeStats(delta: {
 async function prune(messages: Message[], reason: string): Promise<void> {
   if (!ENABLED) return
   try {
+    counters.transformCalls += 1
     if (!Array.isArray(messages) || messages.length === 0) return
 
-    const calls = collectCalls(messages)
-    if (calls.length === 0) return
-
-    const estimated = estimateTokens(JSON.stringify(messages))
-    if (estimated < THRESHOLD_TOKENS) {
-      trace("below threshold", { estimated, threshold: THRESHOLD_TOKENS })
+    const all = candidatesOf(messages)
+    if (all.length === 0) {
+      flushCounters()
       return
     }
 
-    const allowed = Math.max(0, DAILY_REQUEST_CAP - dayUsage().requests)
-    if (allowed === 0) {
-      trace("daily cap reached, skipping", { used: dayUsage().requests, cap: DAILY_REQUEST_CAP })
-      return
-    }
-    if (!apiKey()) {
-      trace("no key, skipping")
+    const estimated = estimateTokens(JSON.stringify(messages))
+    if (estimated < THRESHOLD_TOKENS) {
+      counters.belowThreshold += 1
+      flushCounters()
       return
     }
 
     const started = Date.now()
-    const candidates = calls.filter((call) => !call.pinned && !decided.has(call.callID))
-    const totalBefore = messages.reduce((sum, message) => sum + JSON.stringify(message).length, 0)
-
-    let requests = 0
-    let stage = "cache"
-    if (candidates.length > 0) {
-      const fitted = fitState(messages, calls)
-      stage = fitted.stage
-      if (fitted.stage === "overflow") {
-        trace("state overflow, skipping", { tokens: fitted.tokens })
-        return
+    const sessionID = String(messages[0]?.info?.sessionID ?? "unknown")
+    const memory = memoryFor(sessionID)
+    const tokensBefore = messages.reduce((total, message) => total + estimateTokens(JSON.stringify(message)), 0)
+
+    const candidates = all.filter((candidate) => !isPinned(candidate.messageIndex, messages.length))
+    const before = candidates.map((candidate) => {
+      const later = all.filter((other) => other.messageIndex > candidate.messageIndex)
+      const context = contextAfter(messages, candidate.messageIndex)
+      return { candidate, later, prose: context.prose, full: context.full }
+    })
+
+    // Count a call re-issued under a new id after we removed or shortened the original.
+    let rerunAfterDrop = 0
+    let rerunAfterTruncate = 0
+    for (const candidate of all) {
+      const sig = signatureOf(candidate)
+      const dropped = memory.dropped.get(sig)
+      if (dropped && dropped !== candidate.callID) {
+        rerunAfterDrop += 1
+        memory.dropped.delete(sig)
       }
-      // Reserve against the cap before firing: every request is already in flight by
-      // the time the first answer returns, so checking only the total afterwards
-      // would let a single run overshoot the ceiling.
-      const send = batch(candidates, fitted.tokens).slice(0, allowed)
-      if (send.length === 0) {
-        trace("no request budget left for a batch", { stateTokens: fitted.tokens })
-        return
+      const truncated = memory.truncated.get(sig)
+      if (truncated && truncated !== candidate.callID) {
+        rerunAfterTruncate += 1
+        memory.truncated.delete(sig)
       }
-      dayUsage().requests += send.length
-      writeUsage(dayUsage())
-
-      const answered = await Promise.all(
-        send.map(async (group) => {
-          const questions = Object.assign({}, ...group.map(questionsFor))
-          const answers = await ask(fitted.state, questions)
-          requests += 1
-          return group.map((call) => ({
-            call,
-            keepCall: noul(answers, `call_${call.id}`),
-            keepResult: noul(answers, `result_${call.id}`),
-          }))
-        }),
-      )
-      if (decided.size > 5000) decided.clear()
-      for (const group of answered) {
-        for (const item of group) {
-          const action = decide(item.call, item.keepCall, item.keepResult)
-          trace("decision", {
-            id: item.call.id,
-            tool: item.call.tool,
-            keepCall: item.keepCall,
-            keepResult: item.keepResult,
-            action,
-          })
-          decided.set(item.call.callID, action)
-        }
+    }
+
+    const decisions = before.map(({ candidate, later, prose, full }) => ({
+      candidate,
+      full,
+      ...decide(candidate, later, prose),
+    }))
+
+    // Only the inconclusive, large-result cases go to the model, one small request each.
+    const uncertain = decisions.filter((entry) => entry.reason === "inconclusive").slice(0, MAX_QUESTIONS)
+    let asked = 0
+    let backendReachable = true
+
+    if (uncertain.length > 0) {
+      const allowed = Math.max(0, DAILY_REQUEST_CAP - dayUsage().requests)
+      const batch = uncertain.slice(0, allowed)
+      if (batch.length > 0) {
+        dayUsage().requests += batch.length
+        writeUsage(dayUsage())
+        const queue = [...batch]
+        const workers = Array.from({ length: Math.min(CONCURRENCY, queue.length) }, async () => {
+          while (queue.length > 0) {
+            const entry = queue.shift()
+            if (!entry) break
+            const name = `content_${entry.candidate.callID}`
+            try {
+              const answer = await askChoice(
+                {
+                  context: DECISION_FACT,
+                  target: entry.candidate.targets[0] ?? "",
+                  result_head: entry.candidate.output.slice(0, EXCERPT_CHARS),
+                  after: entry.full.slice(0, AFTER_CHARS),
+                },
+                name,
+                "Do the later messages quote or use any value that came from the earlier tool output?",
+                {
+                  quotes: "a later message states a value that came from the earlier output",
+                  "does-not": "no later message uses any value from the earlier output",
+                },
+              )
+              asked += 1
+              const quoted = Number(answer.probabilities?.quotes ?? 0)
+              entry.reason = quoted >= REFERENCED_HIGH ? "model-referenced" : "model-unreferenced"
+              entry.action = quoted >= REFERENCED_HIGH ? "keep" : "truncate"
+              entry.model = { choice: answer.choice, quotes: quoted }
+            } catch (error) {
+              backendReachable = false
+              trace("fact question failed", { id: entry.candidate.callID, error: String((error as Error)?.message ?? error) })
+            }
+          }
+        })
+        await Promise.all(workers)
+      } else {
+        counters.capReached += 1
       }
     }
 
-    // Apply by part reference. Parts are held directly, so removing one cannot shift
-    // the position of another in the same message.
+    if (!backendReachable && asked === 0 && uncertain.length > 0) counters.noBackend += 1
+
+    // Apply. Deletion only ever came from a deterministic reason; the model cannot cause one.
     const drop = new Set<Part>()
+    const reasonCounts: Record<string, number> = {}
     let dropped = 0
     let truncated = 0
-    for (const call of calls) {
-      const action = decided.get(call.callID)
-      if (!action || action === "keep" || call.pinned) continue
-      if (action === "drop_call") {
-        drop.add(call.part)
+
+    for (const entry of decisions) {
+      const { candidate, action, reason: why } = entry
+      reasonCounts[why] = (reasonCounts[why] ?? 0) + 1
+      if (action === "keep") continue
+      if (action === "drop") {
+        drop.add(candidate.part)
+        memory.dropped.set(signatureOf(candidate), candidate.callID)
         dropped += 1
         continue
       }
-      const next = truncatedOutput(call)
-      if (next === call.output) continue
-      if (call.part.state?.status === "completed") call.part.state.output = next
-      else if (call.part.state?.status === "error") call.part.state.error = next
+      const next = truncatedOutput(candidate.output, candidate.isError)
+      if (next === candidate.output) continue
+      if (candidate.part.state?.status === "completed") candidate.part.state.output = next
+      else if (candidate.part.state?.status === "error") candidate.part.state.error = next
+      memory.truncated.set(signatureOf(candidate), candidate.callID)
       truncated += 1
     }
 
@@ -581,37 +494,61 @@ async function prune(messages: Message[], reason: string): Promise<void> {
     messages.length = 0
     messages.push(...kept)
 
-    const totalAfter = messages.reduce((sum, message) => sum + JSON.stringify(message).length, 0)
-    writeStats({
-      savedChars: Math.max(0, totalBefore - totalAfter),
-      calls: calls.length,
-      dropped,
-      truncated,
-      requests,
-      ms: Date.now() - started,
-      stage,
+    const tokensAfter = messages.reduce((total, message) => total + estimateTokens(JSON.stringify(message)), 0)
+    const tokensSaved = Math.max(0, tokensBefore - tokensAfter)
+    const ms = Date.now() - started
+
+    counters.engaged += 1
+    updateStats((stats) => {
+      stats.runs = (Number(stats.runs) || 0) + 1
+      stats.tokensSaved = (Number(stats.tokensSaved) || 0) + tokensSaved
+      stats.callsSeen = (Number(stats.callsSeen) || 0) + all.length
+      stats.dropped = (Number(stats.dropped) || 0) + dropped
+      stats.truncated = (Number(stats.truncated) || 0) + truncated
+      stats.asked = (Number(stats.asked) || 0) + asked
+      stats.rerunAfterDrop = (Number(stats.rerunAfterDrop) || 0) + rerunAfterDrop
+      stats.rerunAfterTruncate = (Number(stats.rerunAfterTruncate) || 0) + rerunAfterTruncate
+      for (const [key, value] of Object.entries(reasonCounts)) stats[`reason_${key}`] = (Number(stats[`reason_${key}`]) || 0) + value
+      stats.last = { tokensBefore, tokensAfter, tokensSaved, calls: all.length, dropped, truncated, asked, ms, rerunAfterDrop, rerunAfterTruncate, reasons: reasonCounts }
     })
-    trace("pruned", { reason, estimated, stage, requests, dropped, truncated, savedChars: totalBefore - totalAfter })
+    flushCounters(counters.engaged > 0)
+
+    if (dropped > 0 || truncated > 0 || rerunAfterDrop > 0 || rerunAfterTruncate > 0) {
+      appendLedger({
+        at: new Date().toISOString(),
+        session: sessionID,
+        reason,
+        tokensBefore,
+        tokensAfter,
+        tokensSaved,
+        calls: all.length,
+        dropped,
+        truncated,
+        asked,
+        rerunAfterDrop,
+        rerunAfterTruncate,
+        reasons: reasonCounts,
+        ms,
+      })
+    }
+    trace("pruned", { reason, session: sessionID, dropped, truncated, asked, tokensSaved, rerunAfterDrop, rerunAfterTruncate, reasons: reasonCounts })
   } catch (error) {
-    trace("prune failed", { error: String((error as Error)?.message ?? error) })
+    trace("prune failed (messages untouched)", { error: String((error as Error)?.message ?? error) })
   }
 }
 
-// --- plugin --------------------------------------------------------------------
-
 async function server() {
   return {
     "experimental.chat.messages.transform": async (_input: unknown, output: { messages: Message[] }) => {
       await prune(output.messages, "step")
     },
-
     "experimental.session.compacting": async (_input: unknown, output: { context: string[]; prompt?: string }) => {
       output.context.push(
-        "Tool results marked `[jev-compaction truncated …]` were shortened deliberately: the call is still " +
+        "Tool results marked `[laya-compaction truncated …]` were shortened deliberately: the call is still " +
           "historically accurate but the body was dropped as no longer needed. Do not treat them as tool failures.",
       )
     },
   }
 }
 
-export default { id: "jev-compaction", server }
+export default { id: "laya-compaction", server }