jevprune 0.1.0 → 0.1.1

package/dist/cli.js

@@ -1092,7 +1092,7 @@ var DEFAULT_CONFIG = {
   concurrency: 4,
   maxPruneBytes: 16777216,
   retention: { maxRuns: 200, maxBytes: 268435456 },
-  autoWrap: true,
+  autoWrap: false,
   allowlist: DEFAULT_ALLOWLIST
 };
 function resolveHome(env = process.env) {
@@ -1216,1098 +1216,1011 @@ function describeValue(value) {
 // src/footer.ts
 import { homedir as homedir2 } from "os";
 import { sep } from "path";
-var LF = 10;
-function formatFooter(input) {
-  if (input.mode === "fast-path") return "";
-  const parts = [];
-  if (input.mode === "passthrough") {
-    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
-    const note = input.passthroughNote === void 0 ? "" : ` (${input.passthroughNote})`;
-    parts.push(`${formatCount(input.linesIn)} lines passed through${note}`);
-  } else {
-    if (input.mode === "fallback") parts.push(`fallback (no Jev: ${input.fallbackReason ?? "unknown"})`);
-    parts.push(`${formatCount(input.linesIn)} \u2192 ${formatCount(input.linesOut)} lines`);
-    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
+
+// src/keeps.ts
+var SIGNATURE_CASE_SENSITIVE = /(^|\s)(FAIL|FAILED|ERROR|PANIC|FATAL)(\s|:|$)|\b[A-Z][A-Za-z]*(Error|Exception|Panic)\b|^\s*E\s{2,}\S|^npm ERR!|^\s*(Test Files|Tests|Test Suites)\s/;
+var SIGNATURE_CASE_INSENSITIVE = /^\s*(✗|✘|×|⨯|❌|❯)|^\s*(error|fatal)(\[E\d+\])?:|^traceback \(most recent call last\)|^\s*File ".*", line \d+|^\s+at .*:\d+:\d+\)?$|^\s*-->\s.*:\d+:\d+|^thread '.*' panicked|\b(exit code|exit status|exited with|command not found|no such file or directory|ENOENT|EACCES|ECONNREFUSED|segmentation fault|core dumped|killed)\b|\blevel[=:"\s]+"?(error|fatal|panic)\b|\[(error|fatal|panic)\]|^=+ .*(passed|failed|error).* =+$/i;
+function isSignatureLine(text) {
+  return SIGNATURE_CASE_SENSITIVE.test(text) || SIGNATURE_CASE_INSENSITIVE.test(text);
+}
+function computeKeeps(lines, options) {
+  const keeps = /* @__PURE__ */ new Map();
+  const tailLines = Math.max(0, Math.trunc(options.tailLines));
+  const contextLines = Math.max(0, Math.trunc(options.contextLines));
+  const tailStart = lines.length - tailLines + 1;
+  for (const line of lines) {
+    if (line.n >= tailStart) keeps.set(line.n, "tail");
   }
-  if (input.storeFailureCode !== void 0) {
-    parts.push(`run store unavailable (${input.storeFailureCode})`);
-  } else if (input.logPath !== void 0) {
-    parts.push(`full output ${displayPath(input.logPath, input.home)}`);
+  const seen = /* @__PURE__ */ new Set();
+  const signatures = [];
+  for (const line of lines) {
+    if (!isSignatureLine(line.text)) continue;
+    const key = line.text.trim();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    signatures.push(line.n);
   }
-  return `jevprune: ${parts.join(", ")}`;
-}
-function footerAfter(lastByte, footer) {
-  if (footer.length === 0) return "";
-  const separator = lastByte === void 0 || lastByte === LF ? "" : "\n";
-  return `${separator}${footer}
-`;
-}
-function withFooter(kept, footer) {
-  if (footer.length === 0) return kept;
-  const separator = kept.length === 0 || kept.endsWith("\n") ? "" : "\n";
-  return `${kept}${separator}${footer}
-`;
-}
-function formatCount(value) {
-  const digits = Math.trunc(Math.abs(value)).toString();
-  const grouped = digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-  return value < 0 ? `-${grouped}` : grouped;
-}
-function displayPath(path, home = homedir2()) {
-  if (path === home) return "~";
-  if (home.length > 0 && path.startsWith(home + sep)) return `~${path.slice(home.length)}`;
-  return path;
+  for (const n of signatures) keeps.set(n, "signature");
+  for (const n of signatures) {
+    for (let offset = 1; offset <= contextLines; offset += 1) {
+      for (const candidate of [n - offset, n + offset]) {
+        if (candidate < 1 || candidate > lines.length) continue;
+        if (!keeps.has(candidate)) keeps.set(candidate, "context");
+      }
+    }
+  }
+  return keeps;
 }
 
-// src/store.ts
-import { randomBytes } from "crypto";
-import { createReadStream } from "fs";
-import { appendFile, mkdir, open, readFile as readFile2, readdir, stat, unlink, writeFile } from "fs/promises";
-import { join as join2 } from "path";
-import { finished } from "stream/promises";
-
-// src/bytes.ts
-var LF2 = 10;
-var CR = 13;
-function isValidUtf8(bytes) {
-  try {
-    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    return true;
-  } catch {
-    return false;
+// src/lines.ts
+function splitLines(text) {
+  const lines = [];
+  const pattern = /\r\n|\n|\r/g;
+  let start = 0;
+  let match = pattern.exec(text);
+  while (match !== null) {
+    const raw = match[0];
+    const terminator = raw === "\r\n" ? "\r\n" : raw === "\r" ? "\r" : "\n";
+    lines.push({ n: lines.length + 1, text: text.slice(start, match.index), terminator });
+    start = match.index + raw.length;
+    match = pattern.exec(text);
   }
-}
-function byteLineStarts(bytes) {
-  const starts = [0];
-  for (let index = 0; index < bytes.length; index += 1) {
-    const byte = bytes[index];
-    if (byte === CR && bytes[index + 1] === LF2) index += 1;
-    else if (byte !== CR && byte !== LF2) continue;
-    starts.push(index + 1);
+  if (start < text.length) {
+    lines.push({ n: lines.length + 1, text: text.slice(start), terminator: "" });
   }
-  if (starts[starts.length - 1] !== bytes.length) starts.push(bytes.length);
-  return starts;
-}
-function countByteLines(bytes) {
-  return byteLineStarts(bytes).length - 1;
+  return lines;
 }
 
-// src/store.ts
-var RUN_ID_PATTERN = /^[a-z0-9]+-[a-f0-9]{4}$/;
-var RUNS_DIR = "runs";
-var GAIN_FILE = "gain.jsonl";
-var DIR_MODE = 448;
-var FILE_MODE = 384;
-function newRunId() {
-  return `${Date.now().toString(36)}-${randomBytes(2).toString("hex")}`;
+// src/merge.ts
+function collapseMarker(range2, runId) {
+  return `[jevprune: ${String(range2.count)} lines dropped, run ${runId}, lines ${String(range2.from)}-${String(range2.to)}]
+`;
 }
-var FileRunWriter = class {
-  path;
-  #handle;
-  #stream;
-  #waiting = [];
-  #failure;
-  #closed = false;
-  constructor(path, handle, stream) {
-    this.path = path;
-    this.#handle = handle;
-    this.#stream = stream;
-    this.#stream.on("error", (error) => {
-      this.#fail(error);
-      this.#release();
-    });
-    this.#stream.on("drain", () => {
-      this.#release();
-    });
-  }
-  get failure() {
-    return this.#failure;
-  }
-  write(chunk) {
-    if (this.#closed || this.#failure !== void 0) return true;
-    try {
-      return this.#stream.write(chunk);
-    } catch (error) {
-      this.#fail(error);
-      return true;
+function mergeDecisions(lines, decisions, options) {
+  const minCollapseLines = Math.max(1, Math.trunc(options.minCollapseLines));
+  const dropped = [];
+  let kept = "";
+  let run = null;
+  let expected = 1;
+  const flush = () => {
+    if (run === null) return;
+    const count = run.to - run.from + 1;
+    if (!run.missing && count < minCollapseLines) {
+      for (const line of run.lines) {
+        decisions.set(line.n, { keep: true, reason: "collapse-min" });
+        kept += line.text + line.terminator;
+      }
+    } else {
+      const range2 = { from: run.from, to: run.to, count };
+      dropped.push(range2);
+      kept += collapseMarker(range2, options.runId);
     }
-  }
-  onDrain(listener) {
-    if (this.#closed || this.#failure !== void 0) {
-      queueMicrotask(listener);
-      return;
+    run = null;
+  };
+  const dropLine = (line) => {
+    if (run === null) run = { from: line.n, to: line.n, lines: [line], missing: false };
+    else {
+      run.to = line.n;
+      run.lines.push(line);
     }
-    this.#waiting.push(listener);
-  }
-  async close() {
-    if (this.#closed) return;
-    this.#closed = true;
-    try {
-      this.#stream.end();
-      await finished(this.#stream);
-    } catch (error) {
-      this.#fail(error);
-      await this.#handle.close().catch(() => void 0);
+  };
+  const dropMissing = (from, to) => {
+    if (to < from) return;
+    if (run === null) run = { from, to, lines: [], missing: true };
+    else {
+      run.to = to;
+      run.missing = true;
     }
-    this.#release();
+  };
+  for (const line of lines) {
+    dropMissing(expected, line.n - 1);
+    expected = line.n + 1;
+    if (decisions.get(line.n)?.keep === false) {
+      dropLine(line);
+      continue;
+    }
+    flush();
+    kept += line.text + line.terminator;
   }
-  #fail(error) {
-    this.#failure ??= storeError(`run log ${this.path} could not be written`, error);
+  if (options.totalLines !== void 0) dropMissing(expected, options.totalLines);
+  flush();
+  return { kept, dropped };
+}
+
+// src/select.ts
+var UNAUTHORIZED_REASON = "unauthorized (401)";
+var NOT_UTF8_REASON = "not valid UTF-8";
+var NOT_UTF8_NOTE = "output is not valid UTF-8";
+var RUBRIC = "A line is needed when a developer acting on the task would want to read it: errors, failures, assertions, stack frames, diagnostics, timings or statuses that bear on the task, and the lines that give them meaning. Progress bars, download counters, repeated banners, unchanged status lines and routine success noise are not needed.";
+var ITEM_OVERHEAD_TOKENS = 12;
+function passthroughSelection(input) {
+  return {
+    mode: "passthrough",
+    kept: "",
+    dropped: [],
+    linesIn: input.lines,
+    linesOut: input.lines,
+    bytesIn: input.bytes,
+    bytesOut: input.bytes,
+    windows: 0,
+    jevRequests: 0,
+    jevInputTokens: 0,
+    ...input.reason !== void 0 ? { fallbackReason: input.reason } : {},
+    decisions: /* @__PURE__ */ new Map()
+  };
+}
+function questionFor(n) {
+  return `Is line ${String(n)} needed for the task?`;
+}
+async function selectLines(input) {
+  const lines = splitLines(input.text);
+  const bytesIn = Buffer.byteLength(input.text);
+  if (input.oversize !== void 0) {
+    return oversizeSelection(input, input.oversize, lines, bytesIn);
   }
-  #release() {
-    const waiting = this.#waiting;
-    this.#waiting = [];
-    for (const listener of waiting) listener();
+  if (input.exitCode !== void 0 && input.exitCode !== null && input.exitCode !== 0 || input.interrupted === true) {
+    return everyLine(lines, "passthrough", input.text, bytesIn);
   }
-};
-var RunStore = class {
-  home;
-  #retention;
-  constructor(options) {
-    this.home = options.home;
-    this.#retention = options.retention ?? DEFAULT_CONFIG.retention;
-  }
-  get runsDir() {
-    return join2(this.home, RUNS_DIR);
-  }
-  get gainPath() {
-    return join2(this.home, GAIN_FILE);
-  }
-  logPath(id) {
-    return join2(this.runsDir, `${requireRunId(id)}.log`);
-  }
-  metaPath(id) {
-    return join2(this.runsDir, `${requireRunId(id)}.json`);
-  }
-  async openRun(run) {
-    const path = this.logPath(run.id);
-    await this.#ensureDir(this.runsDir);
-    let handle;
-    try {
-      handle = await open(path, "wx", FILE_MODE);
-    } catch (error) {
-      throw storeError(`run log ${path} could not be created`, error);
-    }
-    return new FileRunWriter(path, handle, handle.createWriteStream());
-  }
-  async finalizeRun(id, meta) {
-    const path = this.metaPath(id);
-    await this.#ensureDir(this.runsDir);
-    try {
-      await writeFile(path, `${JSON.stringify(meta)}
-`, { mode: FILE_MODE });
-    } catch (error) {
-      throw storeError(`run meta ${path} could not be written`, error);
-    }
-  }
-  async readRunBytes(id) {
-    const path = this.logPath(id);
-    try {
-      return await readFile2(path);
-    } catch (error) {
-      if (errorCode(error) === "ENOENT") throw new RunNotFoundError(id, { cause: error });
-      throw storeError(`run log ${path} could not be read`, error);
-    }
-  }
-  async *readRunChunks(id) {
-    const path = this.logPath(id);
-    try {
-      for await (const chunk of createReadStream(path)) {
-        yield typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
-      }
-    } catch (error) {
-      if (errorCode(error) === "ENOENT") throw new RunNotFoundError(id, { cause: error });
-      throw storeError(`run log ${path} could not be read`, error);
-    }
-  }
-  async readRun(id) {
-    const bytes = await this.readRunBytes(id);
-    return { id, path: this.logPath(id), text: bytes.toString("utf8"), meta: await this.#readMeta(id) };
+  if (lines.length <= input.config.fastPathLines) {
+    return everyLine(lines, "fast-path", input.text, bytesIn);
   }
-  async readRunLineBytes(id, from = 1, to) {
-    const bytes = await this.readRunBytes(id);
-    const starts = byteLineStarts(bytes);
-    const lines = starts.length - 1;
-    const last = to ?? lines;
-    if (!Number.isInteger(from) || !Number.isInteger(last) || from < 1 || last < from) {
-      throw new LineRangeError(`line range ${String(from)}-${String(last)} is not a range`);
-    }
-    if (last > lines) {
-      throw new LineRangeError(
-        `line range ${String(from)}-${String(last)} is outside run ${id} (${String(lines)} lines)`
-      );
+  const keeps = keepsOf(lines, input.config);
+  const decisions = /* @__PURE__ */ new Map();
+  const candidates = [];
+  for (const line of lines) {
+    const keep = keeps.get(line.n);
+    if (keep !== void 0) {
+      decisions.set(line.n, { keep: true, reason: keep });
+      continue;
     }
-    return bytes.subarray(starts[from - 1] ?? 0, starts[last] ?? bytes.length);
-  }
-  async readRunLines(id, from = 1, to) {
-    return (await this.readRunLineBytes(id, from, to)).toString("utf8");
-  }
-  async appendGain(entry2) {
-    await this.#ensureDir(this.home);
-    try {
-      await appendFile(this.gainPath, `${JSON.stringify(entry2)}
-`, { mode: FILE_MODE });
-    } catch (error) {
-      throw storeError(`gain ledger ${this.gainPath} could not be written`, error);
+    if (line.text.trim().length === 0) {
+      decisions.set(line.n, { keep: false, reason: "blank" });
+      continue;
     }
+    candidates.push({ id: `l${String(line.n)}`, n: line.n, text: line.text });
   }
-  async readGain() {
-    let raw;
-    try {
-      raw = await readFile2(this.gainPath, "utf8");
-    } catch (error) {
-      if (errorCode(error) === "ENOENT") return { runs: 0, linesIn: 0, linesOut: 0, bytesIn: 0, bytesOut: 0 };
-      throw storeError(`gain ledger ${this.gainPath} could not be read`, error);
-    }
-    let runs = 0;
-    let linesIn = 0;
-    let linesOut = 0;
-    let bytesIn = 0;
-    let bytesOut = 0;
-    for (const line of raw.split("\n")) {
-      if (line.trim().length === 0) continue;
-      const entry2 = parseGainEntry(line);
-      if (entry2 === null) continue;
-      runs += 1;
-      linesIn += entry2.linesIn;
-      linesOut += entry2.linesOut;
-      bytesIn += entry2.bytesIn;
-      bytesOut += entry2.bytesOut;
-    }
-    return { runs, linesIn, linesOut, bytesIn, bytesOut };
+  if (input.client === null) {
+    return fallbackSelection({
+      lines,
+      keeps,
+      input,
+      reason: { kind: "unavailable", detail: "API key not set" },
+      bytesIn,
+      linesIn: lines.length
+    });
   }
-  async enforceRetention() {
-    let names;
-    try {
-      names = await readdir(this.runsDir);
-    } catch (error) {
-      if (errorCode(error) === "ENOENT") return;
-      throw storeError(`run directory ${this.runsDir} could not be read`, error);
-    }
-    const ids = [...new Set(names.filter((name) => name.endsWith(".log")).map((name) => name.slice(0, -4)))].filter((id) => RUN_ID_PATTERN.test(id)).sort();
-    const sizes = /* @__PURE__ */ new Map();
-    let total = 0;
-    for (const id of ids) {
-      const bytes = await this.#sizeOf(this.logPath(id)) + await this.#sizeOf(this.metaPath(id));
-      sizes.set(id, bytes);
-      total += bytes;
-    }
-    let count = ids.length;
-    for (const id of ids) {
-      if (count <= this.#retention.maxRuns && total <= this.#retention.maxBytes) break;
-      await this.discardRun(id);
-      total -= sizes.get(id) ?? 0;
-      count -= 1;
-    }
+  let verdicts;
+  try {
+    verdicts = await askJev(candidates, input, input.client);
+  } catch (error) {
+    return fallbackSelection({
+      lines,
+      keeps,
+      input,
+      reason: unavailableReason(error),
+      bytesIn,
+      linesIn: lines.length
+    });
   }
-  async discardRun(id) {
-    for (const path of [this.logPath(id), this.metaPath(id)]) {
-      try {
-        await unlink(path);
-      } catch (error) {
-        if (errorCode(error) === "ENOENT") continue;
-        throw storeError(`run file ${path} could not be deleted`, error);
-      }
-    }
+  for (const n of verdicts.oversize) decisions.set(n, { keep: true, reason: "oversize" });
+  for (const item of candidates) {
+    if (decisions.has(item.n)) continue;
+    const noul2 = verdicts.answers.get(item.n) ?? 0;
+    decisions.set(item.n, { keep: noul2 >= input.config.threshold, reason: "jev", noul: noul2 });
   }
-  async #sizeOf(path) {
-    try {
-      return (await stat(path)).size;
-    } catch (error) {
-      if (errorCode(error) === "ENOENT") return 0;
-      throw storeError(`run file ${path} could not be inspected`, error);
-    }
+  const { kept, dropped } = mergeDecisions(lines, decisions, {
+    minCollapseLines: input.config.minCollapseLines,
+    runId: input.runId
+  });
+  return {
+    mode: "jev",
+    kept,
+    dropped,
+    linesIn: lines.length,
+    linesOut: splitLines(kept).length,
+    bytesIn,
+    bytesOut: Buffer.byteLength(kept),
+    windows: verdicts.windows,
+    jevRequests: verdicts.jevRequests,
+    jevInputTokens: verdicts.jevInputTokens,
+    decisions
+  };
+}
+async function askJev(candidates, input, client) {
+  const answers = /* @__PURE__ */ new Map();
+  if (candidates.length === 0) {
+    return { windows: 0, jevRequests: 0, jevInputTokens: 0, answers, oversize: [] };
   }
-  async #readMeta(id) {
-    const path = this.metaPath(id);
-    let raw;
-    try {
-      raw = await readFile2(path, "utf8");
-    } catch (error) {
-      if (errorCode(error) === "ENOENT") return null;
-      throw storeError(`run meta ${path} could not be read`, error);
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch (error) {
-      throw storeError(`run meta ${path} is not valid JSON`, error);
+  const lastLine = candidates[candidates.length - 1]?.n ?? 0;
+  const plan = planWindows(candidates, {
+    budgetTokens: input.config.windowTokens,
+    overheadTokens: estimateJsonTokens(stateOf(input, [])),
+    itemOverheadTokens: estimateTokens(questionFor(lastLine)) + ITEM_OVERHEAD_TOKENS,
+    costTokens: (item) => estimateJsonTokens({ n: item.n, text: item.text })
+  });
+  const results = await runWindows(
+    plan.windows,
+    async (window, _index, options) => {
+      const questions = {};
+      for (const item of window) questions[item.id] = questionFor(item.n);
+      return await client.noul({ state: stateOf(input, window), questions }, options);
+    },
+    {
+      concurrency: input.config.concurrency,
+      timeoutMs: input.config.windowTimeoutMs,
+      ...input.signal !== void 0 ? { signal: input.signal } : {}
     }
-    return isRecord4(parsed) ? parsed : null;
-  }
-  async #ensureDir(path) {
-    try {
-      await mkdir(path, { recursive: true, mode: DIR_MODE });
-    } catch (error) {
-      throw storeError(`directory ${path} could not be created`, error);
+  );
+  let jevInputTokens = 0;
+  for (const [index, result] of results.entries()) {
+    jevInputTokens += result.usage.inputTokens;
+    for (const item of plan.windows[index] ?? []) {
+      const noul2 = result.answers[item.id];
+      if (noul2 !== void 0) answers.set(item.n, noul2);
     }
   }
-};
-function requireRunId(id) {
-  if (!RUN_ID_PATTERN.test(id)) throw new RunStoreError(`"${id}" is not a run id`);
-  return id;
+  return {
+    windows: plan.windows.length,
+    jevRequests: results.length,
+    jevInputTokens,
+    answers,
+    oversize: plan.oversize.map((item) => item.n)
+  };
 }
-function parseGainEntry(line) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return null;
-  }
-  if (!isRecord4(parsed)) return null;
-  const linesIn = parsed["linesIn"];
-  const linesOut = parsed["linesOut"];
-  const bytesIn = parsed["bytesIn"];
-  const bytesOut = parsed["bytesOut"];
-  if (typeof linesIn !== "number" || typeof linesOut !== "number" || typeof bytesIn !== "number" || typeof bytesOut !== "number") {
-    return null;
+function stateOf(input, window) {
+  return {
+    command: input.command,
+    task: input.task,
+    rubric: RUBRIC,
+    lines: window.map((item) => ({ n: item.n, text: item.text }))
+  };
+}
+function keepsOf(lines, config) {
+  return computeKeeps(lines, { tailLines: config.tailLines, contextLines: config.contextLines });
+}
+function fallbackSelection(fallback) {
+  const { lines, keeps, input } = fallback;
+  return fallbackResult({
+    lines,
+    decisions: fallbackDecisions(lines, keeps, input.config.headLines),
+    input,
+    reason: fallback.reason,
+    bytesIn: fallback.bytesIn,
+    linesIn: fallback.linesIn
+  });
+}
+function oversizeSelection(input, oversize, captured, bytesIn) {
+  const headCount = Math.min(Math.max(0, Math.trunc(oversize.headSegmentLines)), captured.length);
+  const totalLines = Math.max(Math.trunc(oversize.lines), captured.length);
+  const tailFirst = totalLines - captured.length + headCount + 1;
+  const head = captured.slice(0, headCount);
+  const tail = renumber(captured.slice(headCount), tailFirst);
+  const contextLines = input.config.contextLines;
+  const keeps = computeKeeps(head, { tailLines: 0, contextLines });
+  const tailKeeps = computeKeeps(renumber(tail, 1), { tailLines: input.config.tailLines, contextLines });
+  for (const [n, reason] of tailKeeps) keeps.set(n + tailFirst - 1, reason);
+  const lines = [...head, ...tail];
+  return fallbackResult({
+    lines,
+    decisions: fallbackDecisions(lines, keeps, input.config.headLines),
+    input,
+    reason: { kind: "size-limit", maxBytes: input.config.maxPruneBytes },
+    bytesIn,
+    linesIn: totalLines,
+    totalLines
+  });
+}
+function fallbackDecisions(lines, keeps, headLines) {
+  const head = Math.max(0, Math.trunc(headLines));
+  const decisions = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const keep = keeps.get(line.n);
+    if (keep !== void 0) decisions.set(line.n, { keep: true, reason: keep });
+    else if (line.n <= head) decisions.set(line.n, { keep: true, reason: "head" });
+    else decisions.set(line.n, { keep: false, reason: "fallback" });
   }
-  return parsed;
+  return decisions;
 }
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function renumber(lines, from) {
+  return lines.map((line, index) => ({ ...line, n: from + index }));
 }
-function storeError(message, error) {
-  const code = errorCode(error);
-  return new RunStoreError(`${message}: ${errorMessage(error)}`, {
-    ...code !== void 0 ? { code } : {},
-    cause: error
+function fallbackResult(fallback) {
+  const { kept, dropped } = mergeDecisions(fallback.lines, fallback.decisions, {
+    minCollapseLines: fallback.input.config.minCollapseLines,
+    runId: fallback.input.runId,
+    ...fallback.totalLines !== void 0 ? { totalLines: fallback.totalLines } : {}
   });
+  return {
+    mode: "fallback",
+    kept,
+    dropped,
+    linesIn: fallback.linesIn,
+    linesOut: splitLines(kept).length,
+    bytesIn: fallback.bytesIn,
+    bytesOut: Buffer.byteLength(kept),
+    windows: 0,
+    jevRequests: 0,
+    jevInputTokens: 0,
+    fallbackReason: fallback.reason,
+    decisions: fallback.decisions
+  };
 }
-
-// src/commands/gain.ts
-async function runGain(io) {
-  const config = await loadConfig(io.env);
-  const store = new RunStore({ home: config.home, retention: config.retention });
-  const totals = await store.readGain();
-  const tokens = Math.max(0, Math.floor((totals.bytesIn - totals.bytesOut) / CHARS_PER_TOKEN));
-  await io.write(
-    `jevprune: ${formatCount(totals.runs)} runs, ${formatCount(totals.linesIn)} \u2192 ${formatCount(totals.linesOut)} lines, ~${formatCount(tokens)} tokens saved (estimated at ${String(CHARS_PER_TOKEN)} chars per token)
-`
-  );
-  return 0;
+function fallbackReasonText(reason) {
+  switch (reason.kind) {
+    case "size-limit":
+      return `output over ${String(reason.maxBytes)} bytes`;
+    case "not-utf8":
+      return NOT_UTF8_REASON;
+    case "unavailable":
+      return reason.detail;
+  }
 }
-
-// src/hook.ts
-var STATE_CHANGING_TOKENS = [
-  "cd",
-  "export",
-  "source",
-  ".",
-  "unset",
-  "alias",
-  "set",
-  "eval",
-  "exec",
-  "pushd",
-  "popd"
-];
-var ALWAYS_INTERACTIVE_COMMANDS = [
-  "vim",
-  "vi",
-  "nvim",
-  "nano",
-  "emacs",
-  "less",
-  "more",
-  "man",
-  "top",
-  "htop",
-  "ssh",
-  "telnet",
-  "tmux",
-  "screen",
-  "sudo",
-  "su",
-  "passwd",
-  "claude",
-  "watch"
-];
-var INTERACTIVE_WHEN_BARE_COMMANDS = [
-  "python",
-  "python3",
-  "node",
-  "irb",
-  "psql",
-  "mysql",
-  "sqlite3",
-  "bash",
-  "sh",
-  "zsh",
-  "fish",
-  "gh"
-];
-var SHELL_COMMANDS = ["bash", "sh", "zsh", "fish"];
-var DOCKER_TTY_FLAG = /^-(?:i|t|it|ti)$|^--interactive$|^--tty$/;
-var STATE_CHANGE_PATTERN = new RegExp(
-  `(?:^|;|\\||\\(|&&|\\n)\\s*(?:${STATE_CHANGING_TOKENS.map(escapeRegExp).join("|")})(?=\\s|$|[;|)&])`
-);
-var ENV_ASSIGNMENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*=/;
-function quoteForShell(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
+function unavailableReason(error) {
+  return { kind: "unavailable", detail: unavailableDetail(error) };
+}
+function unavailableDetail(error) {
+  if (error instanceof JevTimeoutError) return "timeout";
+  if (error instanceof JevResponseError) return "invalid response";
+  if (error instanceof JevRequestError) {
+    switch (error.status) {
+      case 429:
+        return "rate limited (429)";
+      case 529:
+        return "overloaded (529)";
+      case 401:
+        return UNAUTHORIZED_REASON;
+      case 400:
+        return "bad request (400)";
+      case void 0:
+        return "network";
+      default:
+        return error.name;
+    }
+  }
+  if (error instanceof Error) return error.name;
+  return "unknown";
 }
-function hasStateChange(command) {
-  return STATE_CHANGE_PATTERN.test(command);
+function everyLine(lines, mode, text, bytesIn) {
+  const decisions = /* @__PURE__ */ new Map();
+  for (const line of lines) decisions.set(line.n, { keep: true, reason: mode });
+  return {
+    mode,
+    kept: text,
+    dropped: [],
+    linesIn: lines.length,
+    linesOut: lines.length,
+    bytesIn,
+    bytesOut: bytesIn,
+    windows: 0,
+    jevRequests: 0,
+    jevInputTokens: 0,
+    decisions
+  };
 }
-function isInteractiveCommand(command) {
-  const words = command.split(/\s+/).filter((word2) => word2.length > 0);
-  let index = 0;
-  while (index < words.length && ENV_ASSIGNMENT_PATTERN.test(words[index] ?? "")) index += 1;
-  const word = words[index];
-  if (word === void 0) return true;
-  const rest = words.slice(index + 1);
-  if (ALWAYS_INTERACTIVE_COMMANDS.includes(word)) return true;
-  if (INTERACTIVE_WHEN_BARE_COMMANDS.includes(word)) {
-    if (rest.length === 0) return true;
-    if (SHELL_COMMANDS.includes(word) && rest.includes("-i")) return true;
-    return word === "gh" && rest[0] === "auth";
+
+// src/footer.ts
+var LF = 10;
+function formatFooter(input) {
+  if (input.mode === "fast-path") return "";
+  const parts = [];
+  if (input.mode === "passthrough") {
+    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
+    const note = input.passthroughNote === void 0 ? "" : ` (${input.passthroughNote})`;
+    parts.push(`${formatCount(input.linesIn)} lines passed through${note}`);
+  } else {
+    if (input.mode === "fallback") parts.push(`fallback (${fallbackNote(input.fallbackReason)})`);
+    parts.push(`${formatCount(input.linesIn)} \u2192 ${formatCount(input.linesOut)} lines`);
+    if (input.exitCode !== void 0 && input.exitCode !== null) parts.push(`exit ${String(input.exitCode)}`);
   }
-  if (word === "tail") return rest[0] === "-f";
-  if (word === "docker" && (rest[0] === "exec" || rest[0] === "run")) {
-    return rest.some((flag) => DOCKER_TTY_FLAG.test(flag));
+  if (input.storeFailureCode !== void 0) {
+    parts.push(`full output was not saved (${input.storeFailureCode})`);
+  } else if (input.logPath !== void 0) {
+    parts.push(`full output ${displayPath(input.logPath, input.home)}`);
   }
-  return false;
+  return `jevprune: ${parts.join(", ")}`;
 }
-function isAllowlisted(command, allowlist) {
-  for (const prefix of allowlist) {
-    if (prefix.length === 0) continue;
-    if (command === prefix) return true;
-    const next = command.startsWith(prefix) ? command[prefix.length] : void 0;
-    if (next !== void 0 && /\s/.test(next)) return true;
+function fallbackNote(reason) {
+  if (reason === void 0) return "Jev unavailable: unknown";
+  switch (reason.kind) {
+    case "size-limit":
+      return `output over ${String(reason.maxBytes)} bytes`;
+    case "not-utf8":
+      return NOT_UTF8_NOTE;
+    case "unavailable":
+      return `Jev unavailable: ${reason.detail}`;
   }
-  return false;
 }
-function planRewrite(input, config) {
-  if (input.tool_name !== "Bash") return null;
-  if (!config.autoWrap) return null;
-  const toolInput = input.tool_input;
-  if (toolInput === void 0) return null;
-  if (toolInput.run_in_background === true) return null;
-  const command = typeof toolInput.command === "string" ? toolInput.command.trim() : "";
-  if (command.length === 0) return null;
-  if (/\bjevprune\b/.test(command)) return null;
-  if (hasStateChange(command)) return null;
-  if (isInteractiveCommand(command)) return null;
-  if (command.endsWith("&") && !command.endsWith("&&")) return null;
-  if (isAllowlisted(command, config.allowlist)) return null;
-  const transcript = typeof input.transcript_path === "string" && input.transcript_path.length > 0 ? ` --transcript ${quoteForShell(input.transcript_path)}` : "";
-  return { command: `jevprune run --hook${transcript} -- bash -c ${quoteForShell(command)}` };
+function footerAfter(lastByte, footer) {
+  if (footer.length === 0) return "";
+  const separator = lastByte === void 0 || lastByte === LF ? "" : "\n";
+  return `${separator}${footer}
+`;
 }
-function parsePreToolUse(raw) {
-  let parsed;
+function withFooter(kept, footer) {
+  if (footer.length === 0) return kept;
+  const separator = kept.length === 0 || kept.endsWith("\n") ? "" : "\n";
+  return `${kept}${separator}${footer}
+`;
+}
+function formatCount(value) {
+  const digits = Math.trunc(Math.abs(value)).toString();
+  const grouped = digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return value < 0 ? `-${grouped}` : grouped;
+}
+function displayPath(path, home = homedir2()) {
+  if (path === home) return "~";
+  if (home.length > 0 && path.startsWith(home + sep)) return `~${path.slice(home.length)}`;
+  return path;
+}
+
+// src/store.ts
+import { randomBytes } from "crypto";
+import { createReadStream } from "fs";
+import { appendFile, mkdir, open, readFile as readFile2, readdir, stat, unlink, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import { finished } from "stream/promises";
+
+// src/bytes.ts
+var LF2 = 10;
+var CR = 13;
+function isValidUtf8(bytes) {
   try {
-    parsed = JSON.parse(raw);
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return true;
   } catch {
-    return null;
+    return false;
   }
-  if (!isRecord5(parsed)) return null;
-  const toolName = parsed["tool_name"];
-  const transcriptPath = parsed["transcript_path"];
-  const toolInput = parsed["tool_input"];
-  return {
-    ...typeof toolName === "string" ? { tool_name: toolName } : {},
-    ...typeof transcriptPath === "string" ? { transcript_path: transcriptPath } : {},
-    ...isRecord5(toolInput) ? { tool_input: readToolInput(toolInput) } : {}
-  };
-}
-function formatHookOutput(plan) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      updatedInput: { command: plan.command }
-    }
-  });
-}
-function readToolInput(source) {
-  const command = source["command"];
-  const background = source["run_in_background"];
-  return {
-    ...typeof command === "string" ? { command } : {},
-    ...typeof background === "boolean" ? { run_in_background: background } : {}
-  };
 }
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function byteLineStarts(bytes) {
+  const starts = [0];
+  for (let index = 0; index < bytes.length; index += 1) {
+    const byte = bytes[index];
+    if (byte === CR && bytes[index + 1] === LF2) index += 1;
+    else if (byte !== CR && byte !== LF2) continue;
+    starts.push(index + 1);
+  }
+  if (starts[starts.length - 1] !== bytes.length) starts.push(bytes.length);
+  return starts;
 }
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function countByteLines(bytes) {
+  return byteLineStarts(bytes).length - 1;
 }
 
-// src/io.ts
-var CLOSED_PIPE_CODES = /* @__PURE__ */ new Set([
-  "EPIPE",
-  "EOF",
-  "ERR_STREAM_DESTROYED",
-  "ERR_STREAM_WRITE_AFTER_END"
-]);
-function processIo() {
-  const write = openWriter(process.stdout);
-  return {
-    env: process.env,
-    cwd: process.cwd(),
-    stdin: process.stdin,
-    write: (text) => write(text),
-    writeBytes: (bytes) => write(bytes),
-    writeError: openWriter(process.stderr)
-  };
+// src/store.ts
+var RUN_ID_PATTERN = /^[a-z0-9]+-[a-f0-9]{4}$/;
+var RUNS_DIR = "runs";
+var GAIN_FILE = "gain.jsonl";
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+function newRunId() {
+  return `${Date.now().toString(36)}-${randomBytes(2).toString("hex")}`;
 }
-async function readStreamBytes(stream) {
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+var FileRunWriter = class {
+  path;
+  #handle;
+  #stream;
+  #waiting = [];
+  #failure;
+  #closed = false;
+  constructor(path, handle, stream) {
+    this.path = path;
+    this.#handle = handle;
+    this.#stream = stream;
+    this.#stream.on("error", (error) => {
+      this.#fail(error);
+      this.#release();
+    });
+    this.#stream.on("drain", () => {
+      this.#release();
+    });
+  }
+  get failure() {
+    return this.#failure;
+  }
+  write(chunk) {
+    if (this.#closed || this.#failure !== void 0) return true;
+    try {
+      return this.#stream.write(chunk);
+    } catch (error) {
+      this.#fail(error);
+      return true;
+    }
+  }
+  onDrain(listener) {
+    if (this.#closed || this.#failure !== void 0) {
+      queueMicrotask(listener);
+      return;
+    }
+    this.#waiting.push(listener);
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    try {
+      this.#stream.end();
+      await finished(this.#stream);
+    } catch (error) {
+      this.#fail(error);
+      await this.#handle.close().catch(() => void 0);
+    }
+    this.#release();
+  }
+  #fail(error) {
+    this.#failure ??= storeError(`run log ${this.path} could not be written`, error);
+  }
+  #release() {
+    const waiting = this.#waiting;
+    this.#waiting = [];
+    for (const listener of waiting) listener();
+  }
+};
+var RunStore = class {
+  home;
+  #retention;
+  constructor(options) {
+    this.home = options.home;
+    this.#retention = options.retention ?? DEFAULT_CONFIG.retention;
+  }
+  get runsDir() {
+    return join2(this.home, RUNS_DIR);
+  }
+  get gainPath() {
+    return join2(this.home, GAIN_FILE);
+  }
+  logPath(id) {
+    return join2(this.runsDir, `${requireRunId(id)}.log`);
   }
-  return Buffer.concat(chunks);
-}
-async function readStream(stream) {
-  return (await readStreamBytes(stream)).toString("utf8");
-}
-function isClosedPipe(error) {
-  const code = errorCode(error);
-  return code !== void 0 && CLOSED_PIPE_CODES.has(code);
-}
-function openWriter(stream) {
-  let closed = false;
-  stream.on("error", (error) => {
-    if (isClosedPipe(error)) closed = true;
-  });
-  return (chunk) => new Promise((resolve2, reject) => {
-    if (closed || chunk.length === 0) {
-      resolve2();
-      return;
+  metaPath(id) {
+    return join2(this.runsDir, `${requireRunId(id)}.json`);
+  }
+  async openRun(run) {
+    const path = this.logPath(run.id);
+    await this.#ensureDir(this.runsDir);
+    let handle;
+    try {
+      handle = await open(path, "wx", FILE_MODE);
+    } catch (error) {
+      throw storeError(`run log ${path} could not be created`, error);
     }
+    return new FileRunWriter(path, handle, handle.createWriteStream());
+  }
+  async finalizeRun(id, meta) {
+    const path = this.metaPath(id);
+    await this.#ensureDir(this.runsDir);
     try {
-      stream.write(chunk, (error) => {
-        if (error === void 0 || error === null) resolve2();
-        else if (isClosedPipe(error)) {
-          closed = true;
-          resolve2();
-        } else reject(error);
-      });
+      await writeFile(path, `${JSON.stringify(meta)}
+`, { mode: FILE_MODE });
     } catch (error) {
-      if (!isClosedPipe(error)) {
-        reject(error instanceof Error ? error : new Error(String(error)));
-        return;
-      }
-      closed = true;
-      resolve2();
+      throw storeError(`run meta ${path} could not be written`, error);
     }
-  });
-}
-
-// src/commands/hook.ts
-async function runHook(io) {
-  try {
-    const input = parsePreToolUse(await readStream(io.stdin));
-    if (input === null) return 0;
-    const plan = planRewrite(input, await loadConfig(io.env));
-    if (plan === null) return 0;
-    await io.write(`${formatHookOutput(plan)}
-`);
-  } catch (error) {
-    await io.writeError(`jevprune: hook skipped: ${errorMessage(error)}
-`).catch(() => void 0);
   }
-  return 0;
-}
-
-// src/notices.ts
-import { mkdir as mkdir2, open as open2 } from "fs/promises";
-import { join as join3 } from "path";
-var MISSING_KEY_MARKER = "missing-key-notice";
-async function shouldAnnounceMissingKey(home) {
-  const path = join3(home, MISSING_KEY_MARKER);
-  try {
-    await mkdir2(home, { recursive: true, mode: 448 });
-    const handle = await open2(path, "wx", 384);
-    await handle.close();
-    return true;
-  } catch (error) {
-    return errorCode(error) !== "EEXIST";
+  async readRunBytes(id) {
+    const path = this.logPath(id);
+    try {
+      return await readFile2(path);
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") throw new RunNotFoundError(id, { cause: error });
+      throw storeError(`run log ${path} could not be read`, error);
+    }
   }
-}
-
-// src/keeps.ts
-var SIGNATURE_CASE_SENSITIVE = /(^|\s)(FAIL|FAILED|ERROR|PANIC|FATAL)(\s|:|$)|\b[A-Z][A-Za-z]*(Error|Exception|Panic)\b|^\s*E\s{2,}\S|^npm ERR!|^\s*(Test Files|Tests|Test Suites)\s/;
-var SIGNATURE_CASE_INSENSITIVE = /^\s*(✗|✘|×|⨯|❌|❯)|^\s*(error|fatal)(\[E\d+\])?:|^traceback \(most recent call last\)|^\s*File ".*", line \d+|^\s+at .*:\d+:\d+\)?$|^\s*-->\s.*:\d+:\d+|^thread '.*' panicked|\b(exit code|exit status|exited with|command not found|no such file or directory|ENOENT|EACCES|ECONNREFUSED|segmentation fault|core dumped|killed)\b|\blevel[=:"\s]+"?(error|fatal|panic)\b|\[(error|fatal|panic)\]|^=+ .*(passed|failed|error).* =+$/i;
-function isSignatureLine(text) {
-  return SIGNATURE_CASE_SENSITIVE.test(text) || SIGNATURE_CASE_INSENSITIVE.test(text);
-}
-function computeKeeps(lines, options) {
-  const keeps = /* @__PURE__ */ new Map();
-  const tailLines = Math.max(0, Math.trunc(options.tailLines));
-  const contextLines = Math.max(0, Math.trunc(options.contextLines));
-  const tailStart = lines.length - tailLines + 1;
-  for (const line of lines) {
-    if (line.n >= tailStart) keeps.set(line.n, "tail");
+  async *readRunChunks(id) {
+    const path = this.logPath(id);
+    try {
+      for await (const chunk of createReadStream(path)) {
+        yield typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+      }
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") throw new RunNotFoundError(id, { cause: error });
+      throw storeError(`run log ${path} could not be read`, error);
+    }
   }
-  const seen = /* @__PURE__ */ new Set();
-  const signatures = [];
-  for (const line of lines) {
-    if (!isSignatureLine(line.text)) continue;
-    const key = line.text.trim();
-    if (seen.has(key)) continue;
-    seen.add(key);
-    signatures.push(line.n);
+  async readRun(id) {
+    const bytes = await this.readRunBytes(id);
+    return { id, path: this.logPath(id), text: bytes.toString("utf8"), meta: await this.#readMeta(id) };
   }
-  for (const n of signatures) keeps.set(n, "signature");
-  for (const n of signatures) {
-    for (let offset = 1; offset <= contextLines; offset += 1) {
-      for (const candidate of [n - offset, n + offset]) {
-        if (candidate < 1 || candidate > lines.length) continue;
-        if (!keeps.has(candidate)) keeps.set(candidate, "context");
-      }
+  async readRunLineBytes(id, from = 1, to) {
+    const bytes = await this.readRunBytes(id);
+    const starts = byteLineStarts(bytes);
+    const lines = starts.length - 1;
+    const last = to ?? lines;
+    if (!Number.isInteger(from) || !Number.isInteger(last) || from < 1 || last < from) {
+      throw new LineRangeError(`line range ${String(from)}-${String(last)} is not a range`);
+    }
+    if (last > lines) {
+      throw new LineRangeError(
+        `line range ${String(from)}-${String(last)} is outside run ${id} (${String(lines)} lines)`
+      );
     }
+    return bytes.subarray(starts[from - 1] ?? 0, starts[last] ?? bytes.length);
   }
-  return keeps;
-}
-
-// src/lines.ts
-function splitLines(text) {
-  const lines = [];
-  const pattern = /\r\n|\n|\r/g;
-  let start = 0;
-  let match = pattern.exec(text);
-  while (match !== null) {
-    const raw = match[0];
-    const terminator = raw === "\r\n" ? "\r\n" : raw === "\r" ? "\r" : "\n";
-    lines.push({ n: lines.length + 1, text: text.slice(start, match.index), terminator });
-    start = match.index + raw.length;
-    match = pattern.exec(text);
+  async readRunLines(id, from = 1, to) {
+    return (await this.readRunLineBytes(id, from, to)).toString("utf8");
   }
-  if (start < text.length) {
-    lines.push({ n: lines.length + 1, text: text.slice(start), terminator: "" });
+  async appendGain(entry2) {
+    await this.#ensureDir(this.home);
+    try {
+      await appendFile(this.gainPath, `${JSON.stringify(entry2)}
+`, { mode: FILE_MODE });
+    } catch (error) {
+      throw storeError(`gain ledger ${this.gainPath} could not be written`, error);
+    }
   }
-  return lines;
-}
-
-// src/merge.ts
-function collapseMarker(range2, runId) {
-  return `[jevprune: ${String(range2.count)} lines dropped, run ${runId}, lines ${String(range2.from)}-${String(range2.to)}]
-`;
-}
-function mergeDecisions(lines, decisions, options) {
-  const minCollapseLines = Math.max(1, Math.trunc(options.minCollapseLines));
-  const dropped = [];
-  let kept = "";
-  let run = null;
-  let expected = 1;
-  const flush = () => {
-    if (run === null) return;
-    const count = run.to - run.from + 1;
-    if (!run.missing && count < minCollapseLines) {
-      for (const line of run.lines) {
-        decisions.set(line.n, { keep: true, reason: "collapse-min" });
-        kept += line.text + line.terminator;
-      }
-    } else {
-      const range2 = { from: run.from, to: run.to, count };
-      dropped.push(range2);
-      kept += collapseMarker(range2, options.runId);
+  async readGain() {
+    let raw;
+    try {
+      raw = await readFile2(this.gainPath, "utf8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return { runs: 0, linesIn: 0, linesOut: 0, bytesIn: 0, bytesOut: 0 };
+      throw storeError(`gain ledger ${this.gainPath} could not be read`, error);
     }
-    run = null;
-  };
-  const dropLine = (line) => {
-    if (run === null) run = { from: line.n, to: line.n, lines: [line], missing: false };
-    else {
-      run.to = line.n;
-      run.lines.push(line);
+    let runs = 0;
+    let linesIn = 0;
+    let linesOut = 0;
+    let bytesIn = 0;
+    let bytesOut = 0;
+    for (const line of raw.split("\n")) {
+      if (line.trim().length === 0) continue;
+      const entry2 = parseGainEntry(line);
+      if (entry2 === null) continue;
+      runs += 1;
+      linesIn += entry2.linesIn;
+      linesOut += entry2.linesOut;
+      bytesIn += entry2.bytesIn;
+      bytesOut += entry2.bytesOut;
     }
-  };
-  const dropMissing = (from, to) => {
-    if (to < from) return;
-    if (run === null) run = { from, to, lines: [], missing: true };
-    else {
-      run.to = to;
-      run.missing = true;
+    return { runs, linesIn, linesOut, bytesIn, bytesOut };
+  }
+  async enforceRetention() {
+    let names;
+    try {
+      names = await readdir(this.runsDir);
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return;
+      throw storeError(`run directory ${this.runsDir} could not be read`, error);
     }
-  };
-  for (const line of lines) {
-    dropMissing(expected, line.n - 1);
-    expected = line.n + 1;
-    if (decisions.get(line.n)?.keep === false) {
-      dropLine(line);
-      continue;
+    const ids = [...new Set(names.filter((name) => name.endsWith(".log")).map((name) => name.slice(0, -4)))].filter((id) => RUN_ID_PATTERN.test(id)).sort();
+    const sizes = /* @__PURE__ */ new Map();
+    let total = 0;
+    for (const id of ids) {
+      const bytes = await this.#sizeOf(this.logPath(id)) + await this.#sizeOf(this.metaPath(id));
+      sizes.set(id, bytes);
+      total += bytes;
+    }
+    let count = ids.length;
+    for (const id of ids) {
+      if (count <= this.#retention.maxRuns && total <= this.#retention.maxBytes) break;
+      await this.discardRun(id);
+      total -= sizes.get(id) ?? 0;
+      count -= 1;
     }
-    flush();
-    kept += line.text + line.terminator;
-  }
-  if (options.totalLines !== void 0) dropMissing(expected, options.totalLines);
-  flush();
-  return { kept, dropped };
-}
-
-// src/select.ts
-var UNAUTHORIZED_REASON = "unauthorized (401)";
-var NOT_UTF8_REASON = "not valid UTF-8";
-var NOT_UTF8_NOTE = "output is not valid UTF-8";
-var RUBRIC = "A line is needed when a developer acting on the task would want to read it: errors, failures, assertions, stack frames, diagnostics, timings or statuses that bear on the task, and the lines that give them meaning. Progress bars, download counters, repeated banners, unchanged status lines and routine success noise are not needed.";
-var ITEM_OVERHEAD_TOKENS = 12;
-function passthroughSelection(input) {
-  return {
-    mode: "passthrough",
-    kept: "",
-    dropped: [],
-    linesIn: input.lines,
-    linesOut: input.lines,
-    bytesIn: input.bytes,
-    bytesOut: input.bytes,
-    windows: 0,
-    jevRequests: 0,
-    jevInputTokens: 0,
-    ...input.reason !== void 0 ? { fallbackReason: input.reason } : {},
-    decisions: /* @__PURE__ */ new Map()
-  };
-}
-function questionFor(n) {
-  return `Is line ${String(n)} needed for the task?`;
-}
-async function selectLines(input) {
-  const lines = splitLines(input.text);
-  const bytesIn = Buffer.byteLength(input.text);
-  if (input.oversize !== void 0) {
-    return oversizeSelection(input, input.oversize, lines, bytesIn);
   }
-  if (input.exitCode !== void 0 && input.exitCode !== null && input.exitCode !== 0 || input.interrupted === true) {
-    return everyLine(lines, "passthrough", input.text, bytesIn);
+  async discardRun(id) {
+    for (const path of [this.logPath(id), this.metaPath(id)]) {
+      try {
+        await unlink(path);
+      } catch (error) {
+        if (errorCode(error) === "ENOENT") continue;
+        throw storeError(`run file ${path} could not be deleted`, error);
+      }
+    }
   }
-  if (lines.length <= input.config.fastPathLines) {
-    return everyLine(lines, "fast-path", input.text, bytesIn);
+  async #sizeOf(path) {
+    try {
+      return (await stat(path)).size;
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return 0;
+      throw storeError(`run file ${path} could not be inspected`, error);
+    }
   }
-  const keeps = keepsOf(lines, input.config);
-  const decisions = /* @__PURE__ */ new Map();
-  const candidates = [];
-  for (const line of lines) {
-    const keep = keeps.get(line.n);
-    if (keep !== void 0) {
-      decisions.set(line.n, { keep: true, reason: keep });
-      continue;
+  async #readMeta(id) {
+    const path = this.metaPath(id);
+    let raw;
+    try {
+      raw = await readFile2(path, "utf8");
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return null;
+      throw storeError(`run meta ${path} could not be read`, error);
     }
-    if (line.text.trim().length === 0) {
-      decisions.set(line.n, { keep: false, reason: "blank" });
-      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw storeError(`run meta ${path} is not valid JSON`, error);
     }
-    candidates.push({ id: `l${String(line.n)}`, n: line.n, text: line.text });
+    return isRecord4(parsed) ? parsed : null;
   }
-  if (input.client === null) {
-    return fallbackSelection({ lines, keeps, input, reason: "no api key", bytesIn, linesIn: lines.length });
+  async #ensureDir(path) {
+    try {
+      await mkdir(path, { recursive: true, mode: DIR_MODE });
+    } catch (error) {
+      throw storeError(`directory ${path} could not be created`, error);
+    }
   }
-  let verdicts;
+};
+function requireRunId(id) {
+  if (!RUN_ID_PATTERN.test(id)) throw new RunStoreError(`"${id}" is not a run id`);
+  return id;
+}
+function parseGainEntry(line) {
+  let parsed;
   try {
-    verdicts = await askJev(candidates, input, input.client);
-  } catch (error) {
-    return fallbackSelection({
-      lines,
-      keeps,
-      input,
-      reason: fallbackReason(error),
-      bytesIn,
-      linesIn: lines.length
-    });
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
   }
-  for (const n of verdicts.oversize) decisions.set(n, { keep: true, reason: "oversize" });
-  for (const item of candidates) {
-    if (decisions.has(item.n)) continue;
-    const noul2 = verdicts.answers.get(item.n) ?? 0;
-    decisions.set(item.n, { keep: noul2 >= input.config.threshold, reason: "jev", noul: noul2 });
+  if (!isRecord4(parsed)) return null;
+  const linesIn = parsed["linesIn"];
+  const linesOut = parsed["linesOut"];
+  const bytesIn = parsed["bytesIn"];
+  const bytesOut = parsed["bytesOut"];
+  if (typeof linesIn !== "number" || typeof linesOut !== "number" || typeof bytesIn !== "number" || typeof bytesOut !== "number") {
+    return null;
   }
-  const { kept, dropped } = mergeDecisions(lines, decisions, {
-    minCollapseLines: input.config.minCollapseLines,
-    runId: input.runId
-  });
-  return {
-    mode: "jev",
-    kept,
-    dropped,
-    linesIn: lines.length,
-    linesOut: splitLines(kept).length,
-    bytesIn,
-    bytesOut: Buffer.byteLength(kept),
-    windows: verdicts.windows,
-    jevRequests: verdicts.jevRequests,
-    jevInputTokens: verdicts.jevInputTokens,
-    decisions
-  };
+  return parsed;
 }
-async function askJev(candidates, input, client) {
-  const answers = /* @__PURE__ */ new Map();
-  if (candidates.length === 0) {
-    return { windows: 0, jevRequests: 0, jevInputTokens: 0, answers, oversize: [] };
-  }
-  const lastLine = candidates[candidates.length - 1]?.n ?? 0;
-  const plan = planWindows(candidates, {
-    budgetTokens: input.config.windowTokens,
-    overheadTokens: estimateJsonTokens(stateOf(input, [])),
-    itemOverheadTokens: estimateTokens(questionFor(lastLine)) + ITEM_OVERHEAD_TOKENS,
-    costTokens: (item) => estimateJsonTokens({ n: item.n, text: item.text })
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function storeError(message, error) {
+  const code = errorCode(error);
+  return new RunStoreError(`${message}: ${errorMessage(error)}`, {
+    ...code !== void 0 ? { code } : {},
+    cause: error
   });
-  const results = await runWindows(
-    plan.windows,
-    async (window, _index, options) => {
-      const questions = {};
-      for (const item of window) questions[item.id] = questionFor(item.n);
-      return await client.noul({ state: stateOf(input, window), questions }, options);
-    },
-    {
-      concurrency: input.config.concurrency,
-      timeoutMs: input.config.windowTimeoutMs,
-      ...input.signal !== void 0 ? { signal: input.signal } : {}
-    }
-  );
-  let jevInputTokens = 0;
-  for (const [index, result] of results.entries()) {
-    jevInputTokens += result.usage.inputTokens;
-    for (const item of plan.windows[index] ?? []) {
-      const noul2 = result.answers[item.id];
-      if (noul2 !== void 0) answers.set(item.n, noul2);
-    }
-  }
-  return {
-    windows: plan.windows.length,
-    jevRequests: results.length,
-    jevInputTokens,
-    answers,
-    oversize: plan.oversize.map((item) => item.n)
-  };
 }
-function stateOf(input, window) {
-  return {
-    command: input.command,
-    task: input.task,
-    rubric: RUBRIC,
-    lines: window.map((item) => ({ n: item.n, text: item.text }))
-  };
+
+// src/commands/gain.ts
+async function runGain(io) {
+  const config = await loadConfig(io.env);
+  const store = new RunStore({ home: config.home, retention: config.retention });
+  const totals = await store.readGain();
+  const tokens = Math.max(0, Math.floor((totals.bytesIn - totals.bytesOut) / CHARS_PER_TOKEN));
+  await io.write(
+    `jevprune: ${formatCount(totals.runs)} runs, ${formatCount(totals.linesIn)} \u2192 ${formatCount(totals.linesOut)} lines, ~${formatCount(tokens)} output tokens removed (estimate: ${String(CHARS_PER_TOKEN)} bytes per token)
+`
+  );
+  return 0;
 }
-function keepsOf(lines, config) {
-  return computeKeeps(lines, { tailLines: config.tailLines, contextLines: config.contextLines });
+
+// src/hook.ts
+var STATE_CHANGING_TOKENS = [
+  "cd",
+  "export",
+  "source",
+  ".",
+  "unset",
+  "alias",
+  "set",
+  "eval",
+  "exec",
+  "pushd",
+  "popd"
+];
+var ALWAYS_INTERACTIVE_COMMANDS = [
+  "vim",
+  "vi",
+  "nvim",
+  "nano",
+  "emacs",
+  "less",
+  "more",
+  "man",
+  "top",
+  "htop",
+  "ssh",
+  "telnet",
+  "tmux",
+  "screen",
+  "sudo",
+  "su",
+  "passwd",
+  "claude",
+  "watch"
+];
+var INTERACTIVE_WHEN_BARE_COMMANDS = [
+  "python",
+  "python3",
+  "node",
+  "irb",
+  "psql",
+  "mysql",
+  "sqlite3",
+  "bash",
+  "sh",
+  "zsh",
+  "fish",
+  "gh"
+];
+var SHELL_COMMANDS = ["bash", "sh", "zsh", "fish"];
+var DOCKER_TTY_FLAG = /^-(?:i|t|it|ti)$|^--interactive$|^--tty$/;
+var STATE_CHANGE_PATTERN = new RegExp(
+  `(?:^|;|\\||\\(|&&|\\n)\\s*(?:${STATE_CHANGING_TOKENS.map(escapeRegExp).join("|")})(?=\\s|$|[;|)&])`
+);
+var ENV_ASSIGNMENT_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*=/;
+function quoteForShell(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
 }
-function fallbackSelection(fallback) {
-  const { lines, keeps, input } = fallback;
-  return fallbackResult({
-    lines,
-    decisions: fallbackDecisions(lines, keeps, input.config.headLines),
-    input,
-    reason: fallback.reason,
-    bytesIn: fallback.bytesIn,
-    linesIn: fallback.linesIn
-  });
+function hasStateChange(command) {
+  return STATE_CHANGE_PATTERN.test(command);
 }
-function oversizeSelection(input, oversize, captured, bytesIn) {
-  const headCount = Math.min(Math.max(0, Math.trunc(oversize.headSegmentLines)), captured.length);
-  const totalLines = Math.max(Math.trunc(oversize.lines), captured.length);
-  const tailFirst = totalLines - captured.length + headCount + 1;
-  const head = captured.slice(0, headCount);
-  const tail = renumber(captured.slice(headCount), tailFirst);
-  const contextLines = input.config.contextLines;
-  const keeps = computeKeeps(head, { tailLines: 0, contextLines });
-  const tailKeeps = computeKeeps(renumber(tail, 1), { tailLines: input.config.tailLines, contextLines });
-  for (const [n, reason] of tailKeeps) keeps.set(n + tailFirst - 1, reason);
-  const lines = [...head, ...tail];
-  return fallbackResult({
-    lines,
-    decisions: fallbackDecisions(lines, keeps, input.config.headLines),
-    input,
-    reason: `output over ${String(input.config.maxPruneBytes)} bytes`,
-    bytesIn,
-    linesIn: totalLines,
-    totalLines
-  });
+function isInteractiveCommand(command) {
+  const words = command.split(/\s+/).filter((word2) => word2.length > 0);
+  let index = 0;
+  while (index < words.length && ENV_ASSIGNMENT_PATTERN.test(words[index] ?? "")) index += 1;
+  const word = words[index];
+  if (word === void 0) return true;
+  const rest = words.slice(index + 1);
+  if (ALWAYS_INTERACTIVE_COMMANDS.includes(word)) return true;
+  if (INTERACTIVE_WHEN_BARE_COMMANDS.includes(word)) {
+    if (rest.length === 0) return true;
+    if (SHELL_COMMANDS.includes(word) && rest.includes("-i")) return true;
+    return word === "gh" && rest[0] === "auth";
+  }
+  if (word === "tail") return rest[0] === "-f";
+  if (word === "docker" && (rest[0] === "exec" || rest[0] === "run")) {
+    return rest.some((flag) => DOCKER_TTY_FLAG.test(flag));
+  }
+  return false;
 }
-function fallbackDecisions(lines, keeps, headLines) {
-  const head = Math.max(0, Math.trunc(headLines));
-  const decisions = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    const keep = keeps.get(line.n);
-    if (keep !== void 0) decisions.set(line.n, { keep: true, reason: keep });
-    else if (line.n <= head) decisions.set(line.n, { keep: true, reason: "head" });
-    else decisions.set(line.n, { keep: false, reason: "fallback" });
+function isAllowlisted(command, allowlist) {
+  for (const prefix of allowlist) {
+    if (prefix.length === 0) continue;
+    if (command === prefix) return true;
+    const next = command.startsWith(prefix) ? command[prefix.length] : void 0;
+    if (next !== void 0 && /\s/.test(next)) return true;
   }
-  return decisions;
+  return false;
 }
-function renumber(lines, from) {
-  return lines.map((line, index) => ({ ...line, n: from + index }));
+function planRewrite(input, config) {
+  if (input.tool_name !== "Bash") return null;
+  if (!config.autoWrap) return null;
+  const toolInput = input.tool_input;
+  if (toolInput === void 0) return null;
+  if (toolInput.run_in_background === true) return null;
+  const command = typeof toolInput.command === "string" ? toolInput.command.trim() : "";
+  if (command.length === 0) return null;
+  if (/\bjevprune\b/.test(command)) return null;
+  if (hasStateChange(command)) return null;
+  if (isInteractiveCommand(command)) return null;
+  if (command.endsWith("&") && !command.endsWith("&&")) return null;
+  if (isAllowlisted(command, config.allowlist)) return null;
+  const transcript = typeof input.transcript_path === "string" && input.transcript_path.length > 0 ? ` --transcript ${quoteForShell(input.transcript_path)}` : "";
+  return { command: `jevprune run --hook${transcript} -- bash -c ${quoteForShell(command)}` };
 }
-function fallbackResult(fallback) {
-  const { kept, dropped } = mergeDecisions(fallback.lines, fallback.decisions, {
-    minCollapseLines: fallback.input.config.minCollapseLines,
-    runId: fallback.input.runId,
-    ...fallback.totalLines !== void 0 ? { totalLines: fallback.totalLines } : {}
-  });
+function parsePreToolUse(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord5(parsed)) return null;
+  const toolName = parsed["tool_name"];
+  const transcriptPath = parsed["transcript_path"];
+  const toolInput = parsed["tool_input"];
   return {
-    mode: "fallback",
-    kept,
-    dropped,
-    linesIn: fallback.linesIn,
-    linesOut: splitLines(kept).length,
-    bytesIn: fallback.bytesIn,
-    bytesOut: Buffer.byteLength(kept),
-    windows: 0,
-    jevRequests: 0,
-    jevInputTokens: 0,
-    fallbackReason: fallback.reason,
-    decisions: fallback.decisions
+    ...typeof toolName === "string" ? { tool_name: toolName } : {},
+    ...typeof transcriptPath === "string" ? { transcript_path: transcriptPath } : {},
+    ...isRecord5(toolInput) ? { tool_input: readToolInput(toolInput) } : {}
   };
 }
-function fallbackReason(error) {
-  if (error instanceof JevTimeoutError) return "timeout";
-  if (error instanceof JevResponseError) return "invalid response";
-  if (error instanceof JevRequestError) {
-    switch (error.status) {
-      case 429:
-        return "rate limited (429)";
-      case 529:
-        return "overloaded (529)";
-      case 401:
-        return UNAUTHORIZED_REASON;
-      case 400:
-        return "bad request (400)";
-      case void 0:
-        return "network";
-      default:
-        return error.name;
+function formatHookOutput(plan) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      updatedInput: { command: plan.command }
     }
-  }
-  if (error instanceof Error) return error.name;
-  return "unknown";
+  });
 }
-function everyLine(lines, mode, text, bytesIn) {
-  const decisions = /* @__PURE__ */ new Map();
-  for (const line of lines) decisions.set(line.n, { keep: true, reason: mode });
+function readToolInput(source) {
+  const command = source["command"];
+  const background = source["run_in_background"];
   return {
-    mode,
-    kept: text,
-    dropped: [],
-    linesIn: lines.length,
-    linesOut: lines.length,
-    bytesIn,
-    bytesOut: bytesIn,
-    windows: 0,
-    jevRequests: 0,
-    jevInputTokens: 0,
-    decisions
+    ...typeof command === "string" ? { command } : {},
+    ...typeof background === "boolean" ? { run_in_background: background } : {}
   };
 }
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
-// src/prune.ts
-async function pruneOutput(input) {
-  const env = input.env ?? process.env;
-  const config = mergeConfig(await loadConfig(env), input.config);
-  const client = input.client !== void 0 ? input.client : clientFromEnv(env);
-  const runId = newRunId();
-  const command = input.command ?? "";
-  const store = input.save === false ? null : new RunStore({ home: config.home, retention: config.retention });
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const selection = await selectLines({
-    text: input.text,
-    task: input.task,
-    command,
-    exitCode: input.exitCode ?? null,
-    client,
-    config,
-    runId
-  });
-  const recorded = await recordRun({
-    store,
-    selection,
-    logText: input.text,
-    meta: {
-      id: runId,
-      command,
-      argv: [],
-      startedAt,
-      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      exitCode: input.exitCode ?? null,
-      signal: null,
-      bytes: selection.bytesIn,
-      lines: selection.linesIn,
-      task: input.task
-    }
-  });
+// src/io.ts
+var CLOSED_PIPE_CODES = /* @__PURE__ */ new Set([
+  "EPIPE",
+  "EOF",
+  "ERR_STREAM_DESTROYED",
+  "ERR_STREAM_WRITE_AFTER_END"
+]);
+function processIo() {
+  const write = openWriter(process.stdout);
   return {
-    kept: selection.kept,
-    dropped: selection.dropped,
-    runId,
-    mode: selection.mode,
-    linesIn: selection.linesIn,
-    linesOut: selection.linesOut,
-    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
-    ...recorded.logPath !== void 0 ? { logPath: recorded.logPath } : {},
-    footer: recorded.footer
+    env: process.env,
+    cwd: process.cwd(),
+    stdin: process.stdin,
+    write: (text) => write(text),
+    writeBytes: (bytes) => write(bytes),
+    writeError: openWriter(process.stderr)
   };
 }
-async function recordRun(input) {
-  const { store, selection, meta } = input;
-  const fastPath = selection.mode === "fast-path";
-  const log = input.logBytes ?? (input.logText !== void 0 ? Buffer.from(input.logText, "utf8") : void 0);
-  let failureCode = input.storeFailureCode;
-  if (store !== null && failureCode === void 0) {
+async function readStreamBytes(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+  }
+  return Buffer.concat(chunks);
+}
+async function readStream(stream) {
+  return (await readStreamBytes(stream)).toString("utf8");
+}
+function isClosedPipe(error) {
+  const code = errorCode(error);
+  return code !== void 0 && CLOSED_PIPE_CODES.has(code);
+}
+function openWriter(stream) {
+  let closed = false;
+  stream.on("error", (error) => {
+    if (isClosedPipe(error)) closed = true;
+  });
+  return (chunk) => new Promise((resolve2, reject) => {
+    if (closed || chunk.length === 0) {
+      resolve2();
+      return;
+    }
     try {
-      if (fastPath) {
-        if (log === void 0) await store.discardRun(meta.id);
-      } else {
-        if (log !== void 0) await writeLog(store, meta.id, log);
-        await store.finalizeRun(meta.id, {
-          ...meta,
-          mode: selection.mode,
-          linesOut: selection.linesOut,
-          ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {}
-        });
-      }
-      await store.appendGain({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        id: meta.id,
-        mode: selection.mode,
-        linesIn: selection.linesIn,
-        linesOut: selection.linesOut,
-        bytesIn: selection.bytesIn,
-        bytesOut: selection.bytesOut,
-        ...selection.fallbackReason !== void 0 ? { reason: selection.fallbackReason } : {}
+      stream.write(chunk, (error) => {
+        if (error === void 0 || error === null) resolve2();
+        else if (isClosedPipe(error)) {
+          closed = true;
+          resolve2();
+        } else reject(error);
       });
-      await store.enforceRetention();
     } catch (error) {
-      if (!(error instanceof RunStoreError)) throw error;
-      failureCode = error.code ?? "failed";
+      if (!isClosedPipe(error)) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      closed = true;
+      resolve2();
     }
-  }
-  const logPath = store !== null && !fastPath && failureCode === void 0 ? store.logPath(meta.id) : void 0;
-  const footer = formatFooter({
-    mode: selection.mode,
-    linesIn: selection.linesIn,
-    linesOut: selection.linesOut,
-    exitCode: meta.exitCode,
-    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
-    ...input.passthroughNote !== void 0 ? { passthroughNote: input.passthroughNote } : {},
-    ...failureCode !== void 0 ? { storeFailureCode: failureCode } : {},
-    ...logPath !== void 0 ? { logPath } : {}
   });
-  return { footer, ...logPath !== void 0 ? { logPath } : {} };
 }
-function clientFromEnv(env) {
+
+// src/commands/hook.ts
+async function runHook(io) {
   try {
-    return createJevClientFromEnv(env);
+    const input = parsePreToolUse(await readStream(io.stdin));
+    if (input === null) return 0;
+    const plan = planRewrite(input, await loadConfig(io.env));
+    if (plan === null) return 0;
+    await io.write(`${formatHookOutput(plan)}
+`);
   } catch (error) {
-    if (error instanceof JevConfigError) return null;
-    throw error;
+    await io.writeError(`jevprune: hook skipped: ${errorMessage(error)}
+`).catch(() => void 0);
   }
+  return 0;
 }
-function mergeConfig(base, overrides) {
-  if (overrides === void 0) return base;
-  const defined = {};
-  for (const key of Object.keys(overrides)) {
-    if (overrides[key] !== void 0) Object.assign(defined, { [key]: overrides[key] });
+
+// src/notices.ts
+import { mkdir as mkdir2, open as open2 } from "fs/promises";
+import { join as join3 } from "path";
+var MISSING_KEY_MARKER = "missing-key-notice";
+async function shouldAnnounceMissingKey(home) {
+  const path = join3(home, MISSING_KEY_MARKER);
+  try {
+    await mkdir2(home, { recursive: true, mode: 448 });
+    const handle = await open2(path, "wx", 384);
+    await handle.close();
+    return true;
+  } catch (error) {
+    return errorCode(error) !== "EEXIST";
   }
-  return { ...base, ...defined };
-}
-async function writeLog(store, id, bytes) {
-  const writer = await store.openRun({ id });
-  writer.write(bytes);
-  await writer.close();
-  if (writer.failure !== void 0) throw writer.failure;
 }
 
-// src/runner.ts
-import { spawn } from "child_process";
-import { constants } from "os";
-var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+// src/capture.ts
 var TAIL_RING_BYTES = 256 * 1024;
 var LF3 = 10;
 var CR2 = 13;
@@ -2384,7 +2297,10 @@ var CaptureBuffer = class {
     this.#trimRing();
   }
   bytes() {
-    if (!this.#oversize) return Buffer.concat(this.#head);
+    if (!this.#oversize) {
+      const single = this.#head.length === 1 ? this.#head[0] : void 0;
+      return single ?? Buffer.concat(this.#head);
+    }
     const head = trimToLastTerminator(Buffer.concat(this.#head));
     const tail = trimToFirstLine(Buffer.concat(this.#ring));
     return Buffer.concat([head, tail]);
@@ -2404,15 +2320,202 @@ var CaptureBuffer = class {
     }
   }
 };
+var OutputCapture = class {
+  #buffer;
+  #counter = new LineCounter();
+  #bytes = 0;
+  constructor(maxBytes) {
+    this.#buffer = new CaptureBuffer(maxBytes);
+  }
+  push(chunk) {
+    this.#bytes += chunk.length;
+    this.#counter.push(chunk);
+    this.#buffer.push(chunk);
+  }
+  result() {
+    return {
+      captured: this.#buffer.bytes(),
+      bytes: this.#bytes,
+      lines: this.#counter.lines,
+      headSegmentLines: this.#buffer.headSegmentLines,
+      oversize: this.#buffer.oversize
+    };
+  }
+};
+function captureBytes(bytes, maxBytes) {
+  const capture = new OutputCapture(maxBytes);
+  capture.push(bytes);
+  return capture.result();
+}
+function trimToLastTerminator(buffer) {
+  for (let index = buffer.length - 1; index >= 0; index -= 1) {
+    const byte = buffer[index];
+    if (byte === LF3 || byte === CR2) return buffer.subarray(0, index + 1);
+  }
+  return buffer.subarray(0, 0);
+}
+function trimToFirstLine(buffer) {
+  for (let index = 0; index < buffer.length; index += 1) {
+    const byte = buffer[index];
+    if (byte === LF3) return buffer.subarray(index + 1);
+    if (byte === CR2) {
+      const next = buffer[index + 1];
+      return buffer.subarray(next === LF3 ? index + 2 : index + 1);
+    }
+  }
+  return Buffer.alloc(0);
+}
+
+// src/prune.ts
+async function pruneOutput(input) {
+  const prepared = await prepare(input);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const bytes = Buffer.from(input.text, "utf8");
+  const capture = captureBytes(bytes, prepared.config.maxPruneBytes);
+  return await selectAndRecord({
+    prepared,
+    capture,
+    text: capture.oversize ? capture.captured.toString("utf8") : input.text,
+    task: input.task,
+    exitCode: input.exitCode ?? null,
+    startedAt,
+    logBytes: bytes
+  });
+}
+async function recordRun(input) {
+  const { store, selection, meta } = input;
+  const fastPath = selection.mode === "fast-path";
+  const log = input.logBytes ?? (input.logText !== void 0 ? Buffer.from(input.logText, "utf8") : void 0);
+  let failureCode = input.storeFailureCode;
+  if (store !== null && failureCode === void 0) {
+    try {
+      if (fastPath) {
+        if (log === void 0) await store.discardRun(meta.id);
+      } else {
+        if (log !== void 0) await writeLog(store, meta.id, log);
+        await store.finalizeRun(meta.id, {
+          ...meta,
+          mode: selection.mode,
+          linesOut: selection.linesOut,
+          ...selection.fallbackReason !== void 0 ? { fallbackReason: fallbackReasonText(selection.fallbackReason) } : {}
+        });
+      }
+      await store.appendGain({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        id: meta.id,
+        mode: selection.mode,
+        linesIn: selection.linesIn,
+        linesOut: selection.linesOut,
+        bytesIn: selection.bytesIn,
+        bytesOut: selection.bytesOut,
+        ...selection.fallbackReason !== void 0 ? { reason: fallbackReasonText(selection.fallbackReason) } : {}
+      });
+      await store.enforceRetention();
+    } catch (error) {
+      if (!(error instanceof RunStoreError)) throw error;
+      failureCode = error.code ?? "failed";
+    }
+  }
+  const logPath = store !== null && !fastPath && failureCode === void 0 ? store.logPath(meta.id) : void 0;
+  const footer = formatFooter({
+    mode: selection.mode,
+    linesIn: selection.linesIn,
+    linesOut: selection.linesOut,
+    exitCode: meta.exitCode,
+    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
+    ...input.passthroughNote !== void 0 ? { passthroughNote: input.passthroughNote } : {},
+    ...failureCode !== void 0 ? { storeFailureCode: failureCode } : {},
+    ...logPath !== void 0 ? { logPath } : {}
+  });
+  return { footer, ...logPath !== void 0 ? { logPath } : {} };
+}
+function clientFromEnv(env) {
+  try {
+    return createJevClientFromEnv(env);
+  } catch (error) {
+    if (error instanceof JevConfigError) return null;
+    throw error;
+  }
+}
+function mergeConfig(base, overrides) {
+  if (overrides === void 0) return base;
+  const defined = {};
+  for (const key of Object.keys(overrides)) {
+    if (overrides[key] !== void 0) Object.assign(defined, { [key]: overrides[key] });
+  }
+  return { ...base, ...defined };
+}
+async function prepare(input) {
+  const env = input.env ?? process.env;
+  const config = mergeConfig(await loadConfig(env), input.config);
+  return {
+    config,
+    client: input.client !== void 0 ? input.client : clientFromEnv(env),
+    store: input.save === false ? null : new RunStore({ home: config.home, retention: config.retention }),
+    runId: newRunId(),
+    command: input.command ?? ""
+  };
+}
+async function selectAndRecord(input) {
+  const { prepared, capture } = input;
+  const selection = await selectLines({
+    text: input.text,
+    task: input.task,
+    command: prepared.command,
+    exitCode: input.exitCode,
+    ...capture.oversize ? { oversize: { lines: capture.lines, headSegmentLines: capture.headSegmentLines } } : {},
+    client: prepared.client,
+    config: prepared.config,
+    runId: prepared.runId
+  });
+  const recorded = await recordRun({
+    store: prepared.store,
+    selection,
+    ...input.logBytes !== void 0 ? { logBytes: input.logBytes } : {},
+    ...input.storeFailureCode !== void 0 ? { storeFailureCode: input.storeFailureCode } : {},
+    meta: {
+      id: prepared.runId,
+      command: prepared.command,
+      argv: [],
+      startedAt: input.startedAt,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exitCode: input.exitCode,
+      signal: null,
+      bytes: capture.bytes,
+      lines: selection.linesIn,
+      task: input.task
+    }
+  });
+  return {
+    kept: selection.kept,
+    dropped: selection.dropped,
+    runId: prepared.runId,
+    mode: selection.mode,
+    linesIn: selection.linesIn,
+    linesOut: selection.linesOut,
+    ...selection.fallbackReason !== void 0 ? { fallbackReason: selection.fallbackReason } : {},
+    ...recorded.logPath !== void 0 ? { logPath: recorded.logPath } : {},
+    footer: recorded.footer
+  };
+}
+async function writeLog(store, id, bytes) {
+  const writer = await store.openRun({ id });
+  writer.write(bytes);
+  await writer.close();
+  if (writer.failure !== void 0) throw writer.failure;
+}
+
+// src/runner.ts
+import { spawn } from "child_process";
+import { constants } from "os";
+var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 async function runCommand(input) {
   const executable = input.argv[0];
   if (executable === void 0 || executable.length === 0) {
     throw new UsageError("run needs a command to execute");
   }
   const writer = await openWriter2(input);
-  const buffer = new CaptureBuffer(input.maxPruneBytes);
-  const counter = new LineCounter();
-  let bytes = 0;
+  const capture = new OutputCapture(input.maxPruneBytes);
   let storeFailure = writer.failure;
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const child = spawn(executable, input.argv.slice(1), {
@@ -2423,9 +2526,7 @@ async function runCommand(input) {
   });
   let paused = false;
   const onChunk = (chunk) => {
-    bytes += chunk.length;
-    counter.push(chunk);
-    buffer.push(chunk);
+    capture.push(chunk);
     const ready = writer.write(chunk);
     if (ready || paused) return;
     paused = true;
@@ -2452,17 +2553,13 @@ async function runCommand(input) {
     await writer.close();
   }
   storeFailure = writer.failure ?? storeFailure;
-  const captured = buffer.bytes();
+  const output = capture.result();
   return {
-    captured,
-    validUtf8: isValidUtf8(captured),
-    bytes,
-    lines: counter.lines,
-    headSegmentLines: buffer.headSegmentLines,
+    ...output,
+    validUtf8: isValidUtf8(output.captured),
     exitCode: exitCodeOf(exit),
     signal: exit.signal,
     interrupted: receivedSignal || exit.signal !== null,
-    oversize: buffer.oversize,
     startedAt,
     endedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...storeFailure !== void 0 ? { storeFailure } : {}
@@ -2525,24 +2622,6 @@ function exitCodeOf(exit) {
   if (exit.signal !== null) return 128 + (constants.signals[exit.signal] ?? 0);
   return 0;
 }
-function trimToLastTerminator(buffer) {
-  for (let index = buffer.length - 1; index >= 0; index -= 1) {
-    const byte = buffer[index];
-    if (byte === LF3 || byte === CR2) return buffer.subarray(0, index + 1);
-  }
-  return buffer.subarray(0, 0);
-}
-function trimToFirstLine(buffer) {
-  for (let index = 0; index < buffer.length; index += 1) {
-    const byte = buffer[index];
-    if (byte === LF3) return buffer.subarray(index + 1);
-    if (byte === CR2) {
-      const next = buffer[index + 1];
-      return buffer.subarray(next === LF3 ? index + 2 : index + 1);
-    }
-  }
-  return Buffer.alloc(0);
-}
 
 // src/task.ts
 import { readFile as readFile3 } from "fs/promises";
@@ -2665,7 +2744,8 @@ async function runRun(options, io) {
       config,
       runId
     });
-    if (options.hook === true && selection.fallbackReason === UNAUTHORIZED_REASON) {
+    const reason = selection.fallbackReason;
+    if (options.hook === true && reason?.kind === "unavailable" && reason.detail === UNAUTHORIZED_REASON) {
       await io.writeError(`jevprune: ${TYPESAFE_API_KEY_ENV} rejected (401), using fallback
 `).catch(() => void 0);
     }
@@ -2707,9 +2787,9 @@ async function passThrough(input, io) {
     lastByte = capture.captured.at(-1);
     complete = !capture.oversize;
   }
-  const oversizeReason = `output over ${String(input.maxPruneBytes)} bytes`;
-  const reason = capture.validUtf8 ? complete ? void 0 : oversizeReason : NOT_UTF8_REASON;
-  const note = capture.validUtf8 ? reason : NOT_UTF8_NOTE;
+  const oversizeReason = { kind: "size-limit", maxBytes: input.maxPruneBytes };
+  const reason = capture.validUtf8 ? complete ? void 0 : oversizeReason : { kind: "not-utf8" };
+  const note = capture.validUtf8 ? reason === void 0 ? void 0 : fallbackReasonText(reason) : NOT_UTF8_NOTE;
   try {
     const { footer } = await recordRun({
       store: input.store,
@@ -2768,7 +2848,7 @@ async function passThrough2(input, io) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const { footer } = await recordRun({
     store,
-    selection: passthroughSelection({ bytes: input.bytes.length, lines, reason: NOT_UTF8_REASON }),
+    selection: passthroughSelection({ bytes: input.bytes.length, lines, reason: { kind: "not-utf8" } }),
     logBytes: input.bytes,
     passthroughNote: NOT_UTF8_NOTE,
     meta: {
@@ -2815,19 +2895,26 @@ async function runShow(options, io) {
 }
 
 // src/version.ts
-var VERSION2 = "0.1.0";
+var VERSION2 = "0.1.1";
 
 // src/cli.ts
 var HELP = `usage: jevprune <command> [options]
 
 commands:
   run [--task <text>] [--threshold <n>] [--hook] [--transcript <path>] -- <command> [args...]
+      runs the command, prints the kept lines and exits with the command's exit code
   select [--task <text>] [--threshold <n>] [--file <path>] [--command <text>]
+      prunes a local file or stdin and reports only its own exit status
   show <id> [--lines A-B]
+      prints a saved run, or one line range of it, exactly as it was captured
   gain
+      totals the locally recorded runs and estimates the output tokens removed
   hook
+      reads a plugin PreToolUse event on stdin and answers it
 
 options:
+  --task <text>     the task the kept lines have to serve
+  --threshold <n>   minimum Jev score to keep a line, 0 to 1
   --help
   --version
 `;