@lienat/pi-jev-compaction 0.1.0

package/node_modules/fast-jev-compaction/README.md

@@ -0,0 +1,276 @@
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![npm](https://img.shields.io/npm/v/jev-compact?label=jev-compact)](https://www.npmjs.com/package/jev-compact)
+[![Fork of tamaratran/fast-jev-compaction](https://img.shields.io/badge/fork%20of-tamaratran%2Ffast--jev--compaction-blue)](https://github.com/tamaratran/fast-jev-compaction)
+[![no TypeSafe key](https://img.shields.io/badge/OpenRouter-no%20TypeSafe%20key-purple)](#fork-additions-openrouter-only-setup)
+
+# fast-jev-compaction
+
+Claude Code plugin that replaces the compaction summary with Jev decisions:
+every tool call and result is scored in one fast request, stale ones are
+dropped or truncated, everything kept stays verbatim. Also usable as an npm
+library.
+
+## Fork additions: jev-compact + jev-gate (OpenRouter, no TypeSafe key)
+
+This fork (github.com/aleksvega) adds two small CLI tools in `cli/` that run
+Jev through **OpenRouter's `/api/alpha/decisions`** (model `typesafe/jev-1.13`),
+so only an `OPENROUTER_API_KEY` is required — no TypeSafe API key. The upstream
+library and Claude Code plugin below are unchanged; to point them at
+OpenRouter instead, set `baseUrl` (library option) or `TYPESAFE_BASE_URL` +
+`TYPESAFE_MODEL=typesafe/jev-1.13`.
+
+**Setup**
+
+```bash
+npm install && npm run build
+export OPENROUTER_API_KEY="sk-or-..."   # your key; never commit it
+```
+
+**jev-compact — verbatim session compaction**
+
+```bash
+node cli/jev-compact.mjs transcript.json -o dump.md
+```
+
+Input: a JSON array of `{role, text, toolUses, toolResults}`. One batched Jev
+request decides, per tool call, whether the call and/or its result must stay
+verbatim; the rest is dropped. Typical run: 62→6 messages, 41K→4.6K chars,
+~$0.00002, output begins with a stats line.
+
+**jev-gate — confidence-gated pre-push guardrail**
+
+```bash
+python cli/jev-gate.py /path/to/repo              # exit 0 = ALLOW, 1 = BLOCK
+python cli/jev-gate.py /path/to/repo --threshold 0.9
+```
+
+One batched call (3 Noul + 1 Score over the last commit's diff): hardcoded
+secrets, syntax errors, breaking changes, test-failure risk. Blocks at
+probability ≥ threshold (default 0.85) or score ≥ 3; an API failure also
+blocks (fail-safe). ~400 ms, ~$0.00005. Verified: clean diff → ALLOW;
+diff containing an `sk-...` key → BLOCK at p=0.99.
+
+MIT, upstream credit: [tamaratran/fast-jev-compaction](https://github.com/tamaratran/fast-jev-compaction).
+
+## What and why
+
+Most context compaction asks an LLM to summarize old turns. A summary is
+lossy: a file path, exact error, constraint, or command can disappear even when
+it matters later. This library never rewrites anything. It only deletes tool
+calls and tool results Jev says are no longer needed, and it asks Jev while
+showing it the whole conversation. User and assistant text stays verbatim and
+in order.
+
+The repository is both an npm package (`src/`) and a Claude Code plugin
+(`hooks/`, `.claude-plugin/`) that uses the package to replace Claude Code's
+built-in compaction summary with the original messages.
+
+## How it works
+
+1. Every `tool_use` is paired with its `tool_result` by `tool_use_id`. Calls in
+   the first message or in the newest `preserveRecentMessages` messages are
+   pinned and never touched.
+2. The **state** sent to Jev is the whole conversation so far, oldest first,
+   with every tool result replaced by a short note (`ok, 4213 chars (omitted)`).
+   Tool inputs are included, texts are included, nothing is summarized.
+3. The state is fitted into `maxStateTokens` (25k by default) in stages, each
+   applied only if the previous one was not enough: tool inputs truncated to
+   1000, then 200, then 60 characters; long texts abridged to head + tail,
+   oldest non-pinned messages first; old non-pinned messages collapsed to a
+   `[… N chars omitted …]` note; old tool calls reduced to one line each
+   (`t12 Read file_path=src/a.ts → ok 480ch`); old call-less messages left
+   out; runs of old call-only messages folded into one entry. If it still
+   does not fit, compaction throws. Tokens are estimated without a tokenizer (a
+   word per six letters, half a token per digit, ~one per other symbol),
+   calibrated to land a little above the counts Jev reports.
+4. For every non-pinned call Jev gets two `noul` questions: should the **call**
+   stay (knowing it was made, with its input, still matters), and should the
+   **result** stay verbatim (its contents are still needed and re-running the
+   tool would not do).
+5. Questions are split into as many requests as needed so state plus questions
+   stays under `maxRequestTokens` (30k by default, under Jev's 32k request
+   limit). The same full state is resent with every request; requests run
+   concurrently and their answers are merged.
+6. Decisions per call, against `keepThreshold`:
+   - `keepResult ≥ threshold` → keep call and result;
+   - else `keepCall ≥ threshold` → keep the call, truncate the result to its
+     first `truncateHeadChars` characters plus a one-line note;
+   - else → remove the call together with its result.
+7. The message list is rebuilt: a message that loses all its content is
+   removed, untouched messages are returned as the same objects, and no result
+   is ever left without its call.
+
+Jev failures, malformed answers, a missing key, or a history that cannot be
+fitted throw; the caller (or the Claude Code hook) decides what to fall back to.
+
+
+### hermes-compact - OpenAI-chat transcripts (Hermes-compatible)
+
+    npm install -g jev-compact
+    OPENROUTER_API_KEY=... hermes-compact transcript.json -o compacted.json
+
+Input: JSON array / {"messages":[...]} / JSONL of OpenAI-chat messages
+(string or array content, nested or flat tool_calls). Output: compacted
+transcript JSON with verbatim kept messages and stats. Adapter semantics
+ported from [deadczarvc/hermes-jev-compaction](https://github.com/deadczarvc/hermes-jev-compaction) (MIT) - thanks! Difference: this build needs no
+TypeSafe key (OpenRouter backend).
+
+## Install and usage (upstream — TypeSafe endpoint)
+
+The upstream library targets the official TypeSafe API. **This fork does not need
+a TypeSafe key**: use the OpenRouter setup in the "Fork additions" section above
+(`OPENROUTER_API_KEY` only, model `typesafe/jev-1.13:latest` via
+`https://openrouter.ai/api/alpha/decisions`).
+
+```bash
+npm install fast-jev-compaction
+export TYPESAFE_API_KEY=...   # only needed for the upstream/official endpoint
+```
+
+```ts
+import { compactMessages, reductionRatio, type Message } from 'fast-jev-compaction';
+
+const transcript: Message[] = [
+  { role: 'user', text: 'Fix the failing test. Never edit src/generated.', toolUses: [] },
+  {
+    role: 'assistant',
+    text: '',
+    toolUses: [{ tool_use_id: 'toolu_1', tool: 'Read', input: { file_path: 'src/a.ts' } }],
+  },
+  { role: 'user', text: '', toolUses: [], toolResults: [{ tool_use_id: 'toolu_1', text: '…file…' }] },
+  // …
+];
+
+const result = await compactMessages(transcript, { preserveRecentMessages: 4 });
+console.log(result.messages, result.decisions, result.stats);
+if (reductionRatio(result) < 0.25) {
+  // not worth it: keep the original transcript, or summarize instead
+}
+```
+
+`Message` is a subset of Claude Code's `SessionMessage`, so a session transcript
+can be passed in as is.
+
+To bring your own transport, implement `JevAsker` (one `ask(state, questions)`
+method) and call `compact(messages, asker, options)`; `buildJevRequest` and
+`parseJevResponse` give you the HTTP request body and response validation.
+The building blocks (`collectToolCalls`, `fitState`, `batchCalls`,
+`decideCall`, `applyDecisions`) are exported too.
+
+`apiKey` defaults to `process.env.TYPESAFE_API_KEY`. Never commit the key or
+put it in a source file.
+
+## Options
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `apiKey` | `TYPESAFE_API_KEY` | TypeSafe API key (`compactMessages`/`JevClient`) |
+| `model` | `jev-latest` | Jev model name |
+| `baseUrl` | `https://api.typesafe.ai/v1/systemone` | System One endpoint |
+| `fetch` | native `fetch` | Injectable fetch implementation for tests |
+| `goal` | last 3 user prompts | Ongoing task description included in the state |
+| `keepThreshold` | `0.5` | Minimum keep probability for a call or result to stay |
+| `preserveRecentMessages` | `6` | Newest messages never touched (the first is always kept) |
+| `maxStateTokens` | `25000` | Estimated token ceiling for the state |
+| `maxRequestTokens` | `30000` | Estimated ceiling for state plus one batch of questions |
+| `truncateHeadChars` | `300` | Characters of a dropped tool result retained before its note |
+
+`result.stats` reports message and character counts before and after, the
+per-reason decision counts, the state size in estimated tokens, which fitting
+stage was needed, and the number of requests.
+
+## Limitations
+
+- Only tool calls and results are candidates; text messages are never removed
+  or shortened in the output (they are only abridged in the state Jev sees).
+- Token sizes are estimates from character counts, not a tokenizer.
+- Calibration is at the request level; a probability is not a proof that a
+  result is safe to delete. The assistant can always re-run the tool.
+- The full state is repeated with every request, so a history near the state
+  ceiling costs one request per handful of questions.
+
+## Claude Code plugin
+
+The repository root is a Claude Code function-hook plugin: `hooks/fast-jev.ts`
+is a thin adapter that feeds `session.compact` transcripts through `src/` and
+falls back to Claude Code's built-in summary on errors or insufficient
+reduction. See [`hooks/README.md`](hooks/README.md) for configuration and the
+Claude Code 2.1.274 type reference.
+
+### Install in Claude Code
+
+Function hooks are an early-access Claude Code feature (2.1.274+), so the
+opt-in flag must be set wherever Claude Code runs, e.g. in `~/.claude/settings.json`:
+
+```json
+{ "env": { "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS": "1", "TYPESAFE_API_KEY": "<your key>" } }
+```
+
+Then add this repository as a plugin marketplace and install the plugin,
+either from the shell or as slash commands inside a session:
+
+```sh
+claude plugin marketplace add tamaratran/fast-jev-compaction
+claude plugin install fast-jev-compaction@fast-jev-compaction
+```
+
+The install prompts for the plugin options (API key, thresholds, `truncateHeadChars`,
+…); leave them at their defaults to use `TYPESAFE_API_KEY` from the environment.
+Restart Claude Code or run `/reload-plugins`. From then on `/compact` (and
+auto-compaction) goes through Jev: the toast reads
+`fast-jev-compaction: kept N/M messages, no summary (…)` when the pruned history
+replaced the built-in summary, or `fallback to built-in summary (…)` when Jev
+could not remove enough (short sessions, or when it fails).
+
+To run from a checkout without installing: `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude --plugin-dir .`
+from the repository root. No publishing step is required; the marketplace is
+just the repo's `.claude-plugin/marketplace.json`.
+
+## Development
+
+```sh
+npm install
+npm run typecheck        # library + hook
+npm test
+npm run build
+npm run validate:plugin  # claude plugin validate
+TYPESAFE_API_KEY="$(cat ~/.typesafe_key)" npm run demo
+```
+
+The unit tests use a fake Jev and never contact TypeSafe. The demo is the live
+network check.
+
+## Animated demo (macOS)
+
+`demo/JevDemo` is a small native SwiftUI app that plays a scripted, dramatized
+version of the compaction flow inside a Claude Code-style terminal: the tool
+calls of a canned transcript are scored, results and calls Jev lets go turn red
+and collapse away, and the rest stays verbatim. It never calls the API; it
+exists to be screen recorded.
+
+```sh
+demo/JevDemo/build.sh   # builds demo/JevDemo/build/JevDemo.app and launches it
+```
+
+Press space in the app to replay from the start.
+
+
+## jev-qa — быстрый QA-скан репозитория
+
+Ищет ошибки кода за секунды: стадия 1 — бесплатные синтаксис-проверки (py_compile / node --check), стадия 2 — Jev-семантика по каждому файлу (баг, error-handling, security, logic — все вопросы одним пакетом, параллельно).
+
+```bash
+OPENROUTER_API_KEY=... jev-qa <repo> [--diff] [--out report.md] [--max N]
+```
+
+Замер (our measurements): 15 файлов за 5.4 с, ~$0.001; файл с подсаженным багом — has_bug 0.95 / logic 0.90 против 0.2–0.6 у чистых.
+
+### jev-find — natural-language file search
+
+Find code by meaning, not by name: a Jev walker ensemble walks the repo and reports where walkers landed.
+
+```
+jev-find "where is authentication handled?" ./src --walkers 20
+```
+
+Cheap (~$0.0005/search) and fast (~1-2 s on small repos). Pattern credit: ellipsis-dev/blink.

package/node_modules/fast-jev-compaction/cli/jev-find.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * jev-find — natural-language file search with a Jev walker ensemble (blink pattern).
+ *
+ *   OPENROUTER_API_KEY=... node cli/jev-find.mjs "where is authentication handled?" <dir> [--walkers 20] [--depth 10]
+ *
+ * N walkers start at <dir>. At every step Jev gets the query + the child list and
+ * returns a Choice over children (+ BACK). Walkers that reach a file stop there.
+ * Output: table of destination files with share of walkers.
+ */
+import { readdirSync, statSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+const args = process.argv.slice(2);
+const flag = (name, def) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? parseInt(args[i + 1], 10) || def : def;
+};
+const query = args[0];
+const root = args[1];
+if (!query || !root || !statSync(root, { throwIfNoEntry: false })?.isDirectory()) {
+  console.error('usage: node cli/jev-find.mjs "<query>" <dir> [--walkers 20] [--depth 10]');
+  process.exit(1);
+}
+const W = flag('--walkers', 20);
+const MAXD = flag('--depth', 10);
+const SKIP = new Set(['node_modules', '.git', 'dist', '.venv', 'venv', '__pycache__', '.next', 'build', 'coverage', '.vercel']);
+const MAX_CHILDREN = 28;
+
+const apiKey = process.env.OPENROUTER_API_KEY;
+if (!apiKey) { console.error('OPENROUTER_API_KEY not set'); process.exit(1); }
+
+async function jev(state, questions) {
+  const res = await fetch('https://openrouter.ai/api/alpha/decisions', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ model: process.env.JEV_MODEL || 'typesafe/jev-1.13', state: state.slice(0, 20_000), questions }),
+  });
+  if (!res.ok) throw new Error(`Jev HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  return (await res.json()).answers ?? (await res.json());
+}
+
+const childrenOf = (dir) =>
+  readdirSync(dir, { withFileTypes: true })
+    .filter((e) => !SKIP.has(e.name) && !e.name.startsWith('.'))
+    .map((e) => ({ name: e.name, path: join(dir, e.name), dir: e.isDirectory() }))
+    .slice(0, MAX_CHILDREN);
+
+const t0 = Date.now();
+let calls = 0;
+const dest = new Map(); // file -> walker count
+
+async function walk(dir, depth) {
+  if (depth > MAXD) return;
+  const kids = childrenOf(dir);
+  if (!kids.length) return;
+  const options = kids.map((k) => k.name).concat(['STOP_HERE']);
+  const criteria = {};
+  for (const k of kids) criteria[k.name] = k.dir ? `folder: ${k.name}/` : `file: ${k.name}`;
+  criteria.STOP_HERE = 'this folder already contains the answer as a whole';
+  calls++;
+  let choice;
+  try {
+    const a = await jev(
+      `Search query: "${query}"\nCurrent folder: ${relative(root, dir) || '.'}\nEntries:\n${kids.map((k) => {
+        if (!k.dir) {
+          let hint = '';
+          try { hint = readFileSync(k.path, 'utf8').slice(0, 400).split('\n').find((l) => l.trim()) || ''; } catch {}
+          return `- ${k.name} (file)${hint ? ` — ${hint.slice(0, 120)}` : ''}`;
+        }
+        let sub = '';
+        try { sub = readdirSync(k.path).filter((n) => !SKIP.has(n) && !n.startsWith('.')).slice(0, 12).join(', '); } catch {}
+        return `- ${k.name}/ (folder${sub ? `: ${sub}` : ''})`;
+      }).join('\n')}`,
+      { next: { type: 'choice', criteria, instructions: 'Which entry should the walker descend into next to find what the query asks about? Pick a file when it looks like the answer itself, a folder to go deeper, or STOP_HERE if this folder contains the answer as a whole.' } },
+    );
+    choice = a.next?.choice;
+    // Sample per walker from Jev probabilities so the ensemble actually explores
+    const probs = a.next?.probabilities || {};
+    const entries = Object.entries(probs).filter(([k, p]) => typeof p === 'number' && p > 0 && kids.some((k2) => k2.name === k));
+    if (entries.length) {
+      let r = Math.random() * entries.reduce((s, [, p]) => s + p, 0);
+      for (const [k, p] of entries) { r -= p; if (r <= 0) { choice = k; break; } }
+    }
+  } catch (e) {
+    return; // walker dies, fail-open
+  }
+  if (!choice || choice === 'STOP_HERE') return;
+  const kid = kids.find((k) => k.name === choice);
+  if (!kid) return;
+  if (!kid.dir) { dest.set(kid.path, (dest.get(kid.path) || 0) + 1); return; }
+  await walk(kid.path, depth + 1);
+}
+
+await Promise.all(Array.from({ length: W }, () => walk(root, 0)));
+
+const ms = Date.now() - t0;
+const rows = [...dest.entries()].sort((a, b) => b[1] - a[1]);
+console.log(`\njev-find "${query}" — ${W} walkers, ${calls} Jev calls, ${(ms / 1000).toFixed(1)} s\n`);
+if (!rows.length) { console.log('No walker reached a file. Try more walkers or a different query.'); process.exit(0); }
+for (const [path, n] of rows.slice(0, 10)) {
+  console.log(`  ${String(Math.round((n / W) * 100)).padStart(3)}%  ${relative(root, path)}`);
+}

package/node_modules/fast-jev-compaction/cli/jev-qa.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * jev-qa — fast code-error finder: free syntax stage + Jev semantic stage.
+ *
+ *   OPENROUTER_API_KEY=... node cli/jev-qa.mjs <repo> [--diff] [--out report.md] [--max N]
+ *
+ * Stage 1 (free, instant): node --check for js/mjs, python -m py_compile for py.
+ * Stage 2 (Jev, ~$0.0002/file): per file, one request with parallel questions:
+ *   has_bug (noul), severity (score low/medium/high), plus Noul for
+ *   error-handling gaps, security risk, logic bug.
+ * Report: markdown, sorted by risk = severity * confidence.
+ */
+import { execFileSync, spawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync, statSync, readdirSync } from 'node:fs';
+import { join, relative, extname } from 'node:path';
+
+const args = process.argv.slice(2);
+const repo = args[0];
+const diffOnly = args.includes('--diff');
+const outIdx = args.indexOf('--out');
+const outFile = outIdx !== -1 ? args[outIdx + 1] : null;
+const maxIdx = args.indexOf('--max');
+const maxFiles = maxIdx !== -1 ? Number(args[maxIdx + 1]) : 40;
+
+if (!repo || !existsSync(repo)) {
+  console.error('usage: node cli/jev-qa.mjs <repo> [--diff] [--out report.md] [--max N]');
+  process.exit(2);
+}
+const apiKey = process.env.OPENROUTER_API_KEY;
+if (!apiKey) {
+  console.error('OPENROUTER_API_KEY is not set');
+  process.exit(2);
+}
+const MODEL = process.env.JEV_MODEL || 'typesafe/jev-1.13';
+const BASE = (process.env.JEV_BASE_URL || 'https://openrouter.ai/api/alpha/decisions').replace(/\/$/, '');
+
+const walk = (dir, skip = ['node_modules', '.git', 'dist', '.venv', 'venv', '__pycache__', '.next', 'build', 'coverage']) => {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (skip.some((s) => name === s || name.endsWith(s))) continue;
+    const p = join(dir, name);
+    const st = statSync(p, { throwIfNoEntry: false });
+    if (!st) continue;
+    if (st.isDirectory()) out.push(...walk(p, skip));
+    else if (/\.(py|js|mjs|ts|tsx)$/.test(name)) out.push(p);
+  }
+  return out;
+};
+
+let files = walk(repo);
+if (diffOnly) {
+  const git = (a) => spawnSync('git', a, { cwd: repo, encoding: 'utf8' }).stdout.trim().split('\n').filter(Boolean);
+  const changed = new Set([...git(['diff', '--name-only', 'HEAD']), ...git(['diff', '--name-only'])].map((f) => f.replace(/\\/g, '/')));
+  files = files.filter((f) => changed.has(relative(repo, f).replace(/\\/g, '/')));
+  if (!files.length) { console.log('jev-qa: no changed code files'); process.exit(0); }
+}
+files = files.slice(0, maxFiles);
+
+// ---------- stage 1: free syntax checks ----------
+const stage1 = [];
+for (const f of files) {
+  const ext = extname(f);
+  let res = null;
+  try {
+    if (ext === '.py') {
+      const r = spawnSync('python', ['-m', 'py_compile', f], { encoding: 'utf8' });
+      res = r.status !== 0 ? r.stderr.split('\n').slice(-3).join(' ') : null;
+    } else if (['.js', '.mjs'].includes(ext)) {
+      const r = spawnSync('node', ['--check', f], { encoding: 'utf8' });
+      res = r.status !== 0 ? (r.stderr || r.stdout).split('\n').slice(0, 3).join(' ') : null;
+    } else if (['.ts', '.tsx'].includes(ext)) {
+      const tsc = spawnSync('npx', ['--no-install', 'tsc', '--noEmit', f], { encoding: 'utf8', cwd: repo });
+      res = tsc.status !== 0 && tsc.stdout ? tsc.stdout.split('\n').slice(0, 3).join(' ') : null;
+    }
+  } catch { /* checker missing — skip to stage 2 */ }
+  if (res) stage1.push({ file: relative(repo, f), error: res.trim() });
+}
+const stage1Files = new Set(stage1.map((s) => s.file));
+
+// ---------- stage 2: Jev semantic pass ----------
+async function jev(state, questions) {
+  const body = { model: MODEL, state, questions };
+  const res = await fetch(BASE, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(`Jev HTTP ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.json();
+}
+
+const semantic = [];
+const t0 = Date.now();
+let calls = 0;
+for (const f of files) {
+  if (stage1Files.has(relative(repo, f))) continue; // already failed syntax; no tokens wasted
+  let code = '';
+  try { code = readFileSync(f, 'utf8'); } catch { continue; }
+  if (!code.trim() || code.length > 100_000) continue;
+  const started = Date.now();
+  let data;
+  try {
+    data = await jev(code.slice(0, 60_000), {
+      has_bug: { type: 'noul', instructions: 'Does this file contain a real bug or broken logic (not style)?' },
+      severity: { type: 'score', instructions: 'How severe is the worst real issue in this file? 1 = harmless, 5 = data loss or security hole', criteria: ['harmless', 'minor', 'user-facing malfunction', 'serious', 'critical: data loss/security'] },
+      error_handling_gap: { type: 'noul', instructions: 'Are there unhandled error paths or missing catch/validation around fallible operations?' },
+      security_risk: { type: 'noul', instructions: 'Is there an injection, secret leak, or unsafe shell/file handling?' },
+      logic_bug: { type: 'noul', instructions: 'Is there a logic error: wrong operator, inverted condition, wrong variable, off-by-one?' },
+    });
+  } catch (e) {
+    console.error('Jev failed on', relative(repo, f), e.message);
+    continue;
+  }
+  calls++;
+  const a = data.answers || {};
+  const n = (k) => a[k]?.noul ?? a[k]?.probability ?? 0;
+  const sev = a.severity?.score ?? 0;
+  const conf = a.severity?.confidence ?? a.has_bug?.confidence ?? 0;
+  const risk = Number(sev) * Math.max(n('has_bug'), 0.5);
+  if (n('has_bug') > 0.5 || sev >= 1) {
+    semantic.push({
+      file: relative(repo, f),
+      has_bug: +n('has_bug').toFixed(2),
+      severity: sev,
+      confidence: +conf.toFixed(2),
+      risk: +risk.toFixed(2),
+      error_handling: +n('error_handling_gap').toFixed(2),
+      security: +n('security_risk').toFixed(2),
+      logic: +n('logic_bug').toFixed(2),
+      ms: Date.now() - started,
+    });
+  }
+}
+semantic.sort((x, y) => y.risk - x.risk);
+
+// ---------- report ----------
+const lines = [`# jev-qa report — ${new Date().toISOString()}`, ''];
+lines.push(`Scope: ${files.length} files · stage1 syntax errors: ${stage1.length} · stage2 flagged: ${semantic.length} · Jev calls: ${calls} in ${Date.now() - t0} ms`);
+lines.push('');
+if (stage1.length) {
+  lines.push('## Syntax errors (stage 1, free)');
+  for (const s of stage1) lines.push(`- **${s.file}** — \`${s.error}\``);
+  lines.push('');
+}
+if (semantic.length) {
+  lines.push('## Semantic flags (stage 2, Jev) — sorted by risk');
+  lines.push('');
+  lines.push('| file | bug | sev | risk | err-handling | security | logic | ms |');
+  lines.push('|---|---|---|---|---|---|---|---|');
+  for (const s of semantic) {
+    lines.push(`| ${s.file} | ${s.has_bug} | ${s.severity} | ${s.risk} | ${s.error_handling} | ${s.security} | ${s.logic} | ${s.ms} |`);
+  }
+} else if (!stage1.length) {
+  lines.push('No issues flagged.');
+}
+const report = lines.join('\n');
+if (outFile) writeFileSync(outFile, report + '\n', 'utf8');
+console.log(report);
+console.log(`\njev-qa done: ${calls} Jev calls, ${Date.now() - t0} ms total${outFile ? ` → ${outFile}` : ''}`);

package/node_modules/fast-jev-compaction/dist/client.d.ts

@@ -0,0 +1,21 @@
+import type { JevAsker, JevQuestions, JevResponse, JevState } from './types.js';
+export interface JevClientOptions {
+    /** Defaults to `process.env.TYPESAFE_API_KEY`. */
+    apiKey?: string;
+    /** Defaults to `jev-latest`. */
+    model?: string;
+    /** Defaults to the System One endpoint. */
+    baseUrl?: string;
+    /** Defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+}
+/** Asks Jev over HTTP with the global `fetch` (or an injected one). */
+export declare class JevClient implements JevAsker {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly fetcher;
+    constructor(options?: JevClientOptions);
+    ask(state: JevState, questions: JevQuestions): Promise<JevResponse>;
+}
+//# sourceMappingURL=client.d.ts.map

package/node_modules/fast-jev-compaction/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEhF,MAAM,WAAW,gBAAgB;IAC/B,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,uEAAuE;AACvE,qBAAa,SAAU,YAAW,QAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;gBAE3B,OAAO,GAAE,gBAAqB;IAOpC,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;CAc1E"}

package/node_modules/fast-jev-compaction/dist/client.js

@@ -0,0 +1,26 @@
+import { buildJevRequest, parseJevResponse } from './request.js';
+/** Asks Jev over HTTP with the global `fetch` (or an injected one). */
+export class JevClient {
+    apiKey;
+    model;
+    baseUrl;
+    fetcher;
+    constructor(options = {}) {
+        this.apiKey = options.apiKey ?? process.env.TYPESAFE_API_KEY ?? '';
+        this.model = options.model;
+        this.baseUrl = options.baseUrl;
+        this.fetcher = options.fetch ?? fetch;
+    }
+    async ask(state, questions) {
+        if (!this.apiKey)
+            throw new Error('TYPESAFE_API_KEY is not configured');
+        const request = buildJevRequest({ apiKey: this.apiKey, model: this.model, baseUrl: this.baseUrl }, state, questions);
+        const response = await this.fetcher(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+        });
+        return parseJevResponse(response.status, response.ok, await response.text());
+    }
+}
+//# sourceMappingURL=client.js.map

package/node_modules/fast-jev-compaction/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAcjE,uEAAuE;AACvE,MAAM,OAAO,SAAS;IACH,MAAM,CAAS;IACf,KAAK,CAAqB;IAC1B,OAAO,CAAqB;IAC5B,OAAO,CAAe;IAEvC,YAAY,UAA4B,EAAE;QACxC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,EAAE,CAAC;QACnE,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,KAAe,EAAE,SAAuB;QAChD,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxE,MAAM,OAAO,GAAG,eAAe,CAC7B,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,EACjE,KAAK,EACL,SAAS,CACV,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE;YAC/C,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,IAAI,EAAE,OAAO,CAAC,IAAI;SACnB,CAAC,CAAC;QACH,OAAO,gBAAgB,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IAC/E,CAAC;CACF"}

package/node_modules/fast-jev-compaction/dist/compact.d.ts

@@ -0,0 +1,30 @@
+import type { CallAnswer, CallDecision, CompactOptions, CompactResult, JevAsker, JevQuestions, Message, ResolvedCompactOptions, ToolCall } from './types.js';
+export declare const DEFAULT_OPTIONS: ResolvedCompactOptions;
+export declare function resolveOptions(options?: CompactOptions): ResolvedCompactOptions;
+/** The two `noul` questions asked about one call: keep the call, keep its result. */
+export declare function questionsFor(call: ToolCall): JevQuestions;
+/**
+ * Splits the candidate calls into batches whose questions, together with the
+ * (always complete) state, fit one request.
+ */
+export declare function batchCalls(calls: readonly ToolCall[], stateTokens: number, options: Pick<ResolvedCompactOptions, 'maxRequestTokens'>): ToolCall[][];
+export declare function decideCall(call: Pick<ToolCall, 'id' | 'tool' | 'pinned'>, answer: CallAnswer, options: Pick<ResolvedCompactOptions, 'keepThreshold'>): CallDecision;
+/**
+ * Rebuilds the conversation from the decisions. A dropped call disappears
+ * together with its result; a dropped result keeps a bounded head and note.
+ * Messages that lose all their content are removed; untouched messages are
+ * returned as the same objects they came in as.
+ */
+export declare function applyDecisions(messages: readonly Message[], decisions: readonly CallDecision[], calls: readonly ToolCall[], headChars: number): Message[];
+/** Characters of text, tool input and tool output a message holds. */
+export declare function messageChars(message: Message): number;
+export declare function reductionRatio(result: Pick<CompactResult, 'stats'>): number;
+/**
+ * Compacts a transcript by asking Jev, for every tool call outside the pinned
+ * first and newest messages, whether the call and whether its result must
+ * stay. The whole history (results omitted, fitted into `maxStateTokens`) is
+ * sent as state with every batch of questions. Throws when Jev fails or the
+ * history cannot be fitted; the caller decides whether to fall back.
+ */
+export declare function compact(messages: readonly Message[], asker: JevAsker, options?: CompactOptions): Promise<CompactResult>;
+//# sourceMappingURL=compact.d.ts.map

package/node_modules/fast-jev-compaction/dist/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../src/compact.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,cAAc,EACd,aAAa,EAEb,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,sBAAsB,EACtB,QAAQ,EAET,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,eAAe,EAAE,sBAO7B,CAAC;AASF,wBAAgB,cAAc,CAAC,OAAO,GAAE,cAAmB,GAAG,sBAAsB,CAoBnF;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,YAAY,CAWzD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,IAAI,CAAC,sBAAsB,EAAE,kBAAkB,CAAC,GACxD,QAAQ,EAAE,EAAE,CAsBd;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,QAAQ,CAAC,EAC9C,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,IAAI,CAAC,sBAAsB,EAAE,eAAe,CAAC,GACrD,YAAY,CAUd;AA4BD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,SAAS,EAAE,MAAM,GAChB,OAAO,EAAE,CAuEX;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAWrD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,MAAM,CAG3E;AAMD;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,KAAK,EAAE,QAAQ,EACf,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAgDxB"}