@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/proxy/shell-compression-log.js

@@ -1,93 +0,0 @@
-/**
- * Compression-specific event log — per-command rows written to
- * `.unerr/metrics.db` (`compression_events` and `file_read_events`).
- *
- * Previously this was JSONL (`logs/compression.jsonl`, `logs/file-reads.jsonl`);
- * migrated to SQLite for indexed lookups, monotonic poll-by-id semantics
- * (used by the log-tailer), and cheap aggregations in the dashboard.
- *
- * The wire types (CompressionLogEntry / FileReadLogEntry) are unchanged so
- * callers don't need to know about the storage backend.
- */
-import { join } from "node:path";
-import { openMetricsStore } from "../tracking/metrics-store.js";
-function parseTs(ts) {
-    const n = Date.parse(ts);
-    return Number.isNaN(n) ? Date.now() : n;
-}
-export function appendCompressionLog(cwd, entry) {
-    try {
-        const store = openMetricsStore(join(cwd, ".unerr"));
-        store.insertCompression({
-            ts: parseTs(entry.ts),
-            ts_iso: entry.ts,
-            command: entry.command,
-            category: entry.category,
-            confidence: entry.confidence,
-            raw_bytes: entry.rawBytes,
-            compressed_bytes: entry.compressedBytes,
-            saved_pct: entry.savedPct,
-            omni_fallback: entry.omniFallback ? 1 : 0,
-            tee_file: entry.teeFile ?? null,
-        });
-    }
-    catch {
-        /* best effort */
-    }
-}
-export function appendFileReadLog(cwd, entry) {
-    try {
-        const store = openMetricsStore(join(cwd, ".unerr"));
-        store.insertFileRead({
-            ts: parseTs(entry.ts),
-            ts_iso: entry.ts,
-            file: entry.file,
-            mode: entry.mode,
-            total_lines: entry.totalLines,
-            returned_lines: entry.returnedLines,
-            saved_pct: entry.savedPct,
-            entity: entry.entity ?? null,
-            token_estimate: entry.tokenEstimate ?? null,
-        });
-    }
-    catch {
-        /* best effort */
-    }
-}
-export function readRecentFileReadLogs(cwd, limit = 10) {
-    try {
-        const store = openMetricsStore(join(cwd, ".unerr"));
-        return store.recentFileReads(limit).map((r) => ({
-            ts: r.ts_iso,
-            file: r.file,
-            mode: r.mode,
-            totalLines: r.total_lines,
-            returnedLines: r.returned_lines,
-            savedPct: r.saved_pct,
-            entity: r.entity ?? undefined,
-            tokenEstimate: r.token_estimate ?? undefined,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-export function readRecentCompressionLogs(cwd, limit = 10) {
-    try {
-        const store = openMetricsStore(join(cwd, ".unerr"));
-        return store.recentCompression(limit).map((r) => ({
-            ts: r.ts_iso,
-            command: r.command,
-            category: r.category,
-            confidence: r.confidence,
-            rawBytes: r.raw_bytes,
-            compressedBytes: r.compressed_bytes,
-            savedPct: r.saved_pct,
-            omniFallback: r.omni_fallback === 1,
-            teeFile: r.tee_file ?? undefined,
-        }));
-    }
-    catch {
-        return [];
-    }
-}

package/dist/proxy/shell-compressor.js

@@ -1,390 +0,0 @@
-/**
- * Layer 6 Sprint FE-D / FE-F — ANSI strip + classifier dispatch + strategy compression + optional graph boost.
- */
-import { readFileSync } from "node:fs";
-import { TokenFlowWriter } from "../tracking/token-flow.js";
-import { classifyShellOutput, } from "./shell-classifier.js";
-import { appendCompressionLog } from "./shell-compression-log.js";
-import { buildShellDiffRiskMap, buildShellFileRiskMap, categoryWantsFileRiskBoost, tryLoadGraphForShellBoost, } from "./shell-graph-boost.js";
-import { shellCategoryToContentType } from "./shell-monitor-map.js";
-import { estimateRoughTokens, recordShellCompressionEvent, } from "./shell-stats.js";
-import { tryCompressCloud } from "./shell-strategies/cloud.js";
-import { compressDiff } from "./shell-strategies/diff.js";
-import { compressErrorDiagnostic } from "./shell-strategies/error-diagnostic.js";
-import { applyUserFilter } from "./shell-strategies/filter-dsl.js";
-import { compressGitStatus } from "./shell-strategies/git-status.js";
-import { compressKeyValue } from "./shell-strategies/key-value.js";
-import { compressLogText } from "./shell-strategies/log-text.js";
-import { compressOmni } from "./shell-strategies/omni.js";
-import { compressProgress } from "./shell-strategies/progress.js";
-import { redactOutput } from "./shell-strategies/redact.js";
-import { compressStructured } from "./shell-strategies/structured.js";
-import { compressTabular } from "./shell-strategies/tabular.js";
-import { compressTestResults } from "./shell-strategies/test-results.js";
-import { compressTreePaths } from "./shell-strategies/tree-paths.js";
-import { compressYaml } from "./shell-strategies/yaml.js";
-import { teeShellOutput } from "./shell-tee.js";
-const CONFIDENCE_GATE = 0.7;
-/**
- * R8 — commands whose primary signal lives on stderr. When the caller passes
- * options.stderr alongside stdout, we merge stderr into the stream that goes
- * through ANSI strip → redact → classify → compress. De-duplicated within the
- * strategies (log_text / error_diagnostic already pattern-dedup).
- */
-const STDERR_SIGNAL_COMMANDS = /\b(tsc|tsx|cargo|rustc|go (?:build|vet|test)|eslint|biome|ruff|mypy|pyright|npm (?:install|i|ci)|pnpm (?:install|i)|yarn (?:install)?|mvn|gradle|gradlew|make|cmake|webpack|vite build|esbuild|swc|rollup|next build|nuxi build|scalac|clang|gcc|shellcheck|hadolint|terraform (?:plan|apply|validate))\b/;
-function shouldMergeStderr(command) {
-    return STDERR_SIGNAL_COMMANDS.test(command);
-}
-function mergeStderrIntoStdout(stdout, stderr) {
-    // Drop lines that already appear in stdout to avoid double-counting noise
-    if (!stderr.trim())
-        return stdout;
-    const stdoutLines = new Set(stdout.split("\n"));
-    const uniqueErr = stderr
-        .split("\n")
-        .filter((l) => l.trim() && !stdoutLines.has(l))
-        .join("\n");
-    if (!uniqueErr)
-        return stdout;
-    return stdout ? `${stdout}\n${uniqueErr}` : uniqueErr;
-}
-/** Strip common ANSI escape sequences (no extra dependency). */
-export function stripAnsiCodes(text) {
-    const esc = String.fromCharCode(27);
-    const bel = String.fromCharCode(7);
-    const csi = new RegExp(`${esc}\\[[0-9;?]*[\\w~]`, "g");
-    const osc = new RegExp(`${esc}\\][^${bel}]*${bel}`, "g");
-    return text.replace(csi, "").replace(osc, "");
-}
-/** Apply a specific strategy compressor by category. */
-function applyStrategy(category, stripped, command, options) {
-    switch (category) {
-        case "tabular":
-            return compressTabular(stripped, command);
-        case "log_text":
-            return compressLogText(stripped, command);
-        case "test_results":
-            return compressTestResults(stripped, command, options?.exitCode);
-        case "progress_streaming":
-            return compressProgress(stripped, command);
-        case "structured":
-            return compressStructured(stripped, command);
-        case "diff":
-            return compressDiff(stripped, undefined, command);
-        case "tree_paths":
-            return compressTreePaths(stripped, undefined, command);
-        case "key_value":
-            return compressKeyValue(stripped, command);
-        case "error_diagnostic":
-            return compressErrorDiagnostic(stripped, command);
-        case "yaml":
-            return compressYaml(stripped, command);
-        default:
-            return stripped;
-    }
-}
-export async function compressShellOutput(command, stdout, options) {
-    const cwd = options?.cwd ?? process.cwd();
-    const persist = options?.persistStats !== false;
-    // R8 — fold stderr into the stream for commands whose signal lives there
-    const streamIn = options?.stderr && shouldMergeStderr(command)
-        ? mergeStderrIntoStdout(stdout, options.stderr)
-        : stdout;
-    if (streamIn.includes("\u0000")) {
-        const classification = {
-            category: "structured",
-            confidence: 1,
-            hint_source: "content_heuristic",
-        };
-        if (options?.qualityMonitor) {
-            options.qualityMonitor.recordCompression(`shell-binary-${Date.now()}`, shellCategoryToContentType("structured"), 1);
-        }
-        return {
-            text: streamIn,
-            classification,
-        };
-    }
-    const ansiStripped = stripAnsiCodes(streamIn);
-    const stripped = options?.skipRedact
-        ? ansiStripped
-        : redactOutput(ansiStripped, options?.redactRules);
-    // N8 — tee-passthrough for small files. When the agent runs cat/head/tail/less
-    // on a file under 4 KB AND that file lives in a transient location
-    // (/tmp/*, .unerr/tee/*, or current cwd /tmp scratch), pass through verbatim.
-    // The existing .unerr/tee/*.txt bypass in exec.ts covers that one path; this
-    // covers the broader "agent reading its own scratch output" case.
-    const SMALL_PASSTHROUGH_BYTES = 4096;
-    if (stripped.length < SMALL_PASSTHROUGH_BYTES &&
-        /^(?:\s*)(?:cat|head|tail|less|more)\s+/.test(command) &&
-        /(?:^|\s)(?:\/tmp\/|\.unerr\/tee\/)\S+/.test(command)) {
-        const classification = {
-            category: "structured",
-            confidence: 1,
-            hint_source: "command_name",
-        };
-        return { text: stripped, classification };
-    }
-    // F2 — dedicated `git status` parser runs before classification.
-    // Generic key_value/log_text classifiers produced 0% compression on
-    // git status; this parser groups + de-boilerplates for ~70-85% wins.
-    if (/^\s*git\s+status\b/.test(command)) {
-        let gitStatusOut = compressGitStatus(stripped);
-        if (gitStatusOut) {
-            // R9 — also apply file-risk boost when the daemon graph is available,
-            // since git status is exactly the surface a coding agent uses to
-            // pick what to edit next.
-            let graphForBoost = options?.graph ?? null;
-            if (!graphForBoost && process.env.UNERR_SHELL_GRAPH_BOOST === "1") {
-                graphForBoost = await tryLoadGraphForShellBoost(cwd);
-            }
-            if (graphForBoost) {
-                const fileRisk = await buildShellFileRiskMap(graphForBoost, stripped);
-                if (fileRisk.size > 0) {
-                    const header = `_shell_boost:file_risk\n${[...fileRisk.values()]
-                        .slice(0, 10)
-                        .map((h) => `${h.file} — risk:${h.risk_level} fan_in=${h.fan_in} top=${h.topEntity}`)
-                        .join("\n")}\n`;
-                    gitStatusOut = `${header}${gitStatusOut}`;
-                }
-            }
-            const classification = {
-                category: "key_value",
-                confidence: 1,
-                hint_source: "command_name",
-            };
-            appendCompressionLog(cwd, {
-                ts: new Date().toISOString(),
-                command,
-                category: "git_status",
-                confidence: 1,
-                rawBytes: stripped.length,
-                compressedBytes: gitStatusOut.length,
-                savedPct: Math.max(0, Math.round(((stripped.length - gitStatusOut.length) /
-                    Math.max(1, stripped.length)) *
-                    100)),
-                omniFallback: false,
-            });
-            if (persist)
-                recordShellCompressionEvent(cwd, classification.category, stdout, gitStatusOut);
-            recordShellTokenFlow(cwd, command, classification.category, stripped, gitStatusOut, "git_status");
-            return { text: gitStatusOut, classification };
-        }
-    }
-    // R4 — cloud-specific deep parser runs before classification
-    const cloudOut = tryCompressCloud(stripped, command);
-    if (cloudOut) {
-        const classification = {
-            category: "structured",
-            confidence: 1,
-            hint_source: "command_name",
-        };
-        appendCompressionLog(cwd, {
-            ts: new Date().toISOString(),
-            command,
-            category: "cloud",
-            confidence: 1,
-            rawBytes: stripped.length,
-            compressedBytes: cloudOut.length,
-            savedPct: Math.max(0, Math.round(((stripped.length - cloudOut.length) / Math.max(1, stripped.length)) *
-                100)),
-            omniFallback: false,
-        });
-        if (persist)
-            recordShellCompressionEvent(cwd, classification.category, stdout, cloudOut);
-        recordShellTokenFlow(cwd, command, classification.category, stripped, cloudOut, "cloud");
-        return { text: cloudOut, classification };
-    }
-    // R3 — user filter takes precedence over built-in classifier
-    const userFiltered = applyUserFilter(command, stripped, cwd);
-    if (userFiltered) {
-        const text = userFiltered.text;
-        const classification = {
-            category: "log_text",
-            confidence: 1,
-            hint_source: "command_name",
-        };
-        appendCompressionLog(cwd, {
-            ts: new Date().toISOString(),
-            command,
-            category: `user_filter[${userFiltered.name}]`,
-            confidence: 1,
-            rawBytes: stripped.length,
-            compressedBytes: text.length,
-            savedPct: Math.max(0, Math.round(((stripped.length - text.length) / Math.max(1, stripped.length)) * 100)),
-            omniFallback: false,
-        });
-        if (persist)
-            recordShellCompressionEvent(cwd, classification.category, stdout, text);
-        recordShellTokenFlow(cwd, command, classification.category, stripped, text, "user_filter");
-        return { text, classification };
-    }
-    const classification = classifyShellOutput(command, stripped);
-    let graph = options?.graph ?? null;
-    const wantsFileBoost = categoryWantsFileRiskBoost(classification.category, command);
-    if (!graph &&
-        (classification.category === "diff" || wantsFileBoost) &&
-        process.env.UNERR_SHELL_GRAPH_BOOST === "1") {
-        graph = await tryLoadGraphForShellBoost(cwd);
-    }
-    const riskMap = graph && classification.category === "diff"
-        ? await buildShellDiffRiskMap(graph, stripped)
-        : undefined;
-    // R9 — file-level risk overlay for git status / git log --stat / lint output
-    const fileRiskMap = graph && wantsFileBoost
-        ? await buildShellFileRiskMap(graph, stripped)
-        : undefined;
-    const fileRiskHeader = fileRiskMap && fileRiskMap.size > 0
-        ? `_shell_boost:file_risk\n${[...fileRiskMap.values()]
-            .slice(0, 10)
-            .map((h) => `${h.file} — risk:${h.risk_level} fan_in=${h.fan_in} top=${h.topEntity}`)
-            .join("\n")}\n`
-        : "";
-    if (classification.confidence < CONFIDENCE_GATE) {
-        // Smart omni: try both the best-guess strategy AND omni, pick whichever compresses more
-        const omniResult = compressOmni(stripped);
-        let strategyResult = null;
-        try {
-            strategyResult = applyStrategy(classification.category, stripped, command, options);
-        }
-        catch {
-            // Strategy failed — fall back to omni
-        }
-        // Use strategy if it achieved >20% compression AND beat omni (or is within 10%)
-        let text;
-        if (strategyResult && strategyResult.length < stripped.length * 0.8) {
-            const strategyRatio = strategyResult.length / stripped.length;
-            const omniRatio = omniResult.length / stripped.length;
-            text = strategyRatio <= omniRatio * 1.1 ? strategyResult : omniResult;
-        }
-        else {
-            text = omniResult;
-        }
-        const usedOmni = text !== strategyResult;
-        const savedPct = stripped.length > 0
-            ? Math.round(((stripped.length - text.length) / stripped.length) * 100)
-            : 0;
-        appendCompressionLog(cwd, {
-            ts: new Date().toISOString(),
-            command,
-            category: classification.category,
-            confidence: classification.confidence,
-            rawBytes: stripped.length,
-            compressedBytes: text.length,
-            savedPct: Math.max(0, savedPct),
-            omniFallback: usedOmni,
-        });
-        if (persist)
-            recordShellCompressionEvent(cwd, classification.category, stdout, text);
-        if (options?.qualityMonitor) {
-            const before = estimateRoughTokens(stripped);
-            const after = estimateRoughTokens(text);
-            options.qualityMonitor.recordCompression(`shell-omni-${Date.now()}`, shellCategoryToContentType(classification.category), after / Math.max(1, before));
-        }
-        recordShellTokenFlow(cwd, command, classification.category, stripped, text, usedOmni ? "omni" : classification.category);
-        return { text, classification };
-    }
-    let text = stripped;
-    switch (classification.category) {
-        case "tabular":
-            text = compressTabular(stripped, command);
-            break;
-        case "log_text":
-            text = compressLogText(stripped, command);
-            break;
-        case "test_results":
-            text = compressTestResults(stripped, command, options?.exitCode);
-            break;
-        case "progress_streaming":
-            text = compressProgress(stripped, command);
-            break;
-        case "structured":
-            text = compressStructured(stripped, command);
-            break;
-        case "diff":
-            text = compressDiff(stripped, riskMap, command);
-            break;
-        case "tree_paths":
-            text = compressTreePaths(stripped, undefined, command);
-            break;
-        case "key_value":
-            text = compressKeyValue(stripped, command);
-            break;
-        case "error_diagnostic":
-            text = compressErrorDiagnostic(stripped, command);
-            break;
-        case "yaml":
-            text = compressYaml(stripped, command);
-            break;
-    }
-    // R9 — prepend file-risk overlay when the boost ran
-    if (fileRiskHeader)
-        text = `${fileRiskHeader}${text}`;
-    // Tee: save full output to disk when compression is significant
-    const tee = teeShellOutput(cwd, command, stripped, text);
-    if (tee) {
-        text += `\n[full output: ${tee.filePath} (${(tee.sizeBytes / 1024).toFixed(1)}KB)]`;
-    }
-    const savedPctHi = stripped.length > 0
-        ? Math.round(((stripped.length - text.length) / stripped.length) * 100)
-        : 0;
-    appendCompressionLog(cwd, {
-        ts: new Date().toISOString(),
-        command,
-        category: classification.category,
-        confidence: classification.confidence,
-        rawBytes: stripped.length,
-        compressedBytes: text.length,
-        savedPct: Math.max(0, savedPctHi),
-        omniFallback: false,
-        teeFile: tee?.filePath,
-    });
-    if (persist)
-        recordShellCompressionEvent(cwd, classification.category, stdout, text);
-    if (options?.qualityMonitor) {
-        const before = estimateRoughTokens(stripped);
-        const after = estimateRoughTokens(text);
-        options.qualityMonitor.recordCompression(`shell-${classification.category}-${Date.now()}`, shellCategoryToContentType(classification.category), after / Math.max(1, before));
-    }
-    recordShellTokenFlow(cwd, command, classification.category, stripped, text, classification.category);
-    return { text, classification };
-}
-/**
- * Layer 10: Record shell compression savings to token-flow.jsonl.
- * Uses UNERR_SESSION_ID from env (set by parent proxy/MCP process).
- * Exec processes have turn=0 since they lack turn context.
- */
-function recordShellTokenFlow(cwd, command, category, raw, compressed, strategy) {
-    const rawTokens = Math.ceil(raw.length / 4);
-    const compressedTokens = Math.ceil(compressed.length / 4);
-    const shellSaved = rawTokens - compressedTokens;
-    if (shellSaved <= 0)
-        return;
-    try {
-        let sessionId = process.env.UNERR_SESSION_ID ?? "";
-        const unerrDir = `${cwd}/.unerr`;
-        // RC3 fix: Read session ID from file if env var not set (exec processes
-        // are launched by the agent shell, not child of --mcp)
-        if (!sessionId) {
-            try {
-                sessionId = readFileSync(`${unerrDir}/state/session.id`, "utf-8").trim();
-            }
-            catch {
-                sessionId = "unknown";
-            }
-        }
-        const writer = new TokenFlowWriter(unerrDir, sessionId);
-        writer.record({
-            session_id: sessionId,
-            turn: 0,
-            mechanism: "shell_compression",
-            tool: null,
-            tokens_without: rawTokens,
-            tokens_with: compressedTokens,
-            tokens_saved: shellSaved,
-            detail: { command: command.slice(0, 80), category, strategy },
-        });
-    }
-    catch {
-        /* best effort — never block compression */
-    }
-}

package/dist/proxy/shell-graph-boost.js

@@ -1,202 +0,0 @@
-/**
- * Layer 6 Sprint FE-F — optional Layer 2 lookups for shell stdout (diff risk hints).
- */
-/** Identifier-like tokens worth resolving against the graph (bounded). */
-export function extractRiskLookupCandidates(text) {
-    const out = new Set();
-    for (const m of text.matchAll(/\b([A-Za-z_][\w$]{2,63})\b/g)) {
-        const name = m[1];
-        if (name)
-            out.add(name);
-    }
-    for (const m of text.matchAll(/function\s+([A-Za-z_][\w$]*)/g)) {
-        const name = m[1];
-        if (name)
-            out.add(name);
-    }
-    return [...out].slice(0, 48);
-}
-/** Resolve symbols that are high-risk or high fan-in for diff annotation. */
-export async function buildShellDiffRiskMap(graph, stdout) {
-    const candidates = extractRiskLookupCandidates(stdout);
-    const map = new Map();
-    for (const name of candidates) {
-        const e = await graph.findEntityByName(name);
-        if (!e)
-            continue;
-        if (e.risk_level === "high" ||
-            e.risk_level === "critical" ||
-            e.fan_in > 5) {
-            map.set(name, {
-                name: e.name,
-                risk_level: e.risk_level,
-                fan_in: e.fan_in,
-            });
-        }
-    }
-    return map;
-}
-/**
- * R9 — Extend graph boost beyond diff.
- *
- * Extracts likely file paths from `git status`, `git log --stat`, lint output,
- * etc., then resolves each path's max-risk entity from the graph. Returns
- * `path → "risk:high (fan_in=24)"` annotations so the strategy can inline
- * them next to the file row without reading the file.
- */
-const PATH_RE = /\b([A-Za-z0-9_./-]+\.[A-Za-z0-9]{1,6})\b/g;
-export function extractFilePathCandidates(text) {
-    const out = new Set();
-    for (const m of text.matchAll(PATH_RE)) {
-        const p = m[1];
-        if (!p)
-            continue;
-        // Must contain a / OR look like a code file at the root
-        if (p.includes("/") ||
-            /\.(ts|tsx|js|jsx|py|go|rs|rb|cs|java|kt|swift|scala|cpp|c|h|hpp)$/i.test(p)) {
-            out.add(p);
-        }
-    }
-    return [...out].slice(0, 64);
-}
-/**
- * Build `file_path → risk hint` map by scanning paths in the output and
- * resolving the highest-fan-in entity owned by each file via the graph.
- */
-export async function buildShellFileRiskMap(graph, stdout) {
-    const paths = extractFilePathCandidates(stdout);
-    const map = new Map();
-    for (const path of paths) {
-        try {
-            const entities = await graph.getEntitiesByFile(path);
-            if (!entities || entities.length === 0)
-                continue;
-            const first = entities[0];
-            if (!first)
-                continue;
-            // Pick the highest fan_in entity to summarize file-level risk
-            let top = first;
-            for (const e of entities) {
-                if ((e.fan_in ?? 0) > (top.fan_in ?? 0))
-                    top = e;
-            }
-            const fanIn = top.fan_in ?? 0;
-            if (top.risk_level === "high" ||
-                top.risk_level === "critical" ||
-                fanIn > 5) {
-                map.set(path, {
-                    file: path,
-                    topEntity: top.name,
-                    risk_level: top.risk_level,
-                    fan_in: fanIn,
-                });
-            }
-        }
-        catch {
-            // Per-file lookup failures are non-fatal — keep building the map
-        }
-    }
-    return map;
-}
-/**
- * Categories whose strategies can benefit from a file-level risk overlay.
- * Used by the dispatcher to decide whether to invoke buildShellFileRiskMap.
- */
-export function categoryWantsFileRiskBoost(category, command) {
-    if (!command)
-        return false;
-    if (category === "diff")
-        return false; // handled by buildShellDiffRiskMap
-    // git status / git log --stat / lint outputs benefit
-    if (/^\s*git\s+(status|log)\b/.test(command))
-        return true;
-    if (/^\s*(eslint|biome|tsc|ruff|mypy|golangci|cargo clippy|shellcheck)\b/.test(command))
-        return true;
-    return false;
-}
-const BOOST_TTL_MS = 30_000;
-const boostCache = new Map();
-async function logBoostFailure(reason) {
-    try {
-        const { startupLog } = await import("../utils/startup-log.js");
-        startupLog.fileOnly("warn", `shell graph boost: ${reason}`);
-    }
-    catch {
-        /* logging failure is non-fatal */
-    }
-}
-/** Load snapshot graph for hook/exec boost (same snapshot layout as proxy). */
-export async function tryLoadGraphForShellBoost(cwd) {
-    const cached = boostCache.get(cwd);
-    if (cached && Date.now() - cached.loadedAt < BOOST_TTL_MS) {
-        return cached.kind === "ok" ? cached.graph : null;
-    }
-    const { existsSync, readFileSync } = await import("node:fs");
-    const { join } = await import("node:path");
-    const snapshotsDir = join(cwd, ".unerr", "snapshots");
-    let snapshotPath = join(snapshotsDir, "graph.msgpack.gz");
-    if (!existsSync(snapshotPath)) {
-        snapshotPath = join(snapshotsDir, "graph.msgpack");
-    }
-    if (!existsSync(snapshotPath)) {
-        const reason = `snapshot missing at ${snapshotsDir}`;
-        await logBoostFailure(reason);
-        boostCache.set(cwd, { kind: "miss", reason, loadedAt: Date.now() });
-        return null;
-    }
-    let CozoDbConstructor;
-    let CozoGraphStoreCtor;
-    try {
-        const cozoMod = (await import("cozo-node"));
-        CozoDbConstructor = cozoMod.default
-            ? cozoMod.default.CozoDb
-            : cozoMod.CozoDb;
-        if (typeof CozoDbConstructor !== "function") {
-            throw new Error("cozo-node CozoDb export is not a constructor");
-        }
-        const localGraph = await import("../intelligence/local-graph.js");
-        CozoGraphStoreCtor = localGraph.CozoGraphStore;
-    }
-    catch (err) {
-        const reason = `module load failed: ${err instanceof Error ? err.message : String(err)}`;
-        await logBoostFailure(reason);
-        boostCache.set(cwd, { kind: "miss", reason, loadedAt: Date.now() });
-        return null;
-    }
-    let buffer;
-    try {
-        const { gunzipSync } = await import("node:zlib");
-        const raw = readFileSync(snapshotPath);
-        try {
-            buffer = gunzipSync(raw);
-        }
-        catch {
-            buffer = raw; // legacy uncompressed snapshot
-        }
-    }
-    catch (err) {
-        const reason = `snapshot read failed: ${err instanceof Error ? err.message : String(err)}`;
-        await logBoostFailure(reason);
-        boostCache.set(cwd, { kind: "miss", reason, loadedAt: Date.now() });
-        return null;
-    }
-    try {
-        const db = new CozoDbConstructor();
-        const graph = await CozoGraphStoreCtor.create(db);
-        const { unpack } = await import("msgpackr");
-        const envelope = unpack(buffer);
-        await graph.loadSnapshot(envelope);
-        boostCache.set(cwd, { kind: "ok", graph, loadedAt: Date.now() });
-        return graph;
-    }
-    catch (err) {
-        const reason = `graph instantiation failed: ${err instanceof Error ? err.message : String(err)}`;
-        await logBoostFailure(reason);
-        boostCache.set(cwd, { kind: "miss", reason, loadedAt: Date.now() });
-        return null;
-    }
-}
-/** Test-only — clear the boost cache so unit tests don't share state. */
-export function _clearShellBoostCache() {
-    boostCache.clear();
-}