@davesheffer/hunch 1.7.0 → 1.8.0

package/dist/core/dupdetect.js

@@ -68,6 +68,15 @@ export function commitCoveredBy(codeFiles, subject, existing, nowMs) {
     }
     return best;
 }
+/** Only a finalized, still-live human decision can justify deleting a draft as
+ *  redundant. Proposed records may resemble one another, but choosing which one
+ *  survives is review judgment—not deterministic hygiene. */
+export function isAcceptedDuplicateAnchor(d) {
+    return d.status === "accepted"
+        && d.provenance.source.includes("human_confirmed")
+        && !d.superseded_by
+        && !d.valid_to;
+}
 /** Is an existing DRAFT a near-duplicate of an accepted record? Review-time
  *  flag; threshold callers use 0.35 (batch-reject) — conservative on purpose. */
 export function draftDuplicateOf(draft, existing) {
@@ -77,9 +86,7 @@ export function draftDuplicateOf(draft, existing) {
     for (const d of existing) {
         if (d.id === draft.id)
             continue;
-        if (!d.provenance.source.includes("human_confirmed"))
-            continue;
-        if (d.status === "superseded" || d.status === "rejected" || d.superseded_by || d.valid_to)
+        if (!isAcceptedDuplicateAnchor(d))
             continue;
         const termSim = jaccard(draftTerms, dupTerms(`${d.title} ${d.decision}`));
         let fileBoost = 0;

package/dist/core/escalations.js

@@ -0,0 +1,65 @@
+import { topicCollisions } from "./topics.js";
+/** The decisions a human must make NOW, to be asked INLINE. Empty in a healthy graph. */
+export function pendingEscalations(decisions) {
+    const out = [];
+    for (const [topic, decs] of topicCollisions(decisions)) {
+        out.push({
+            kind: "topic-conflict",
+            topic,
+            decisionIds: decs.map((d) => d.id),
+            question: `Topic "${topic}" has ${decs.length} live decisions — which one is current?`,
+            detail: decs.map((d) => `${d.id} — "${d.title}"`).join("  ·  "),
+            resolution: `supersede the others: re-record the chosen one with supersedes:<other-id>, or split the topic.`,
+        });
+    }
+    return out;
+}
+/** The Constitution's genuine human moments (§59.5.3), framed as inline questions:
+ *  a candidate awaiting review, and a proposed policy whose next step (prove, or
+ *  accept/reject) is a human call. Machine conclusions never appear here as
+ *  approvals — every entry is a QUESTION with its explicit resolution verb. */
+export function policyEscalations(policies) {
+    const out = [];
+    const clip = (s) => (s.length > 90 ? s.slice(0, 89).trimEnd() + "…" : s);
+    for (const p of policies) {
+        // An auto-repaired policy asks FIRST (and only once): its bindings moved, so
+        // its proof is stale by construction — the human moment is "re-prove it".
+        if (p.last_action === "repaired" && (p.state === "proposed" || p.state === "active_advisory" || p.state === "active_blocking")) {
+            out.push({
+                kind: "policy-repaired",
+                topic: p.id,
+                decisionIds: [p.id],
+                question: `Rule "${clip(p.statement)}" (${p.id}) was auto-repaired after a rename — its proof is stale; re-prove it?`,
+                detail: `state ${p.state} · last action repaired · ${p.proof ? `proof ${p.proof} (stale)` : "no proof"}`,
+                resolution: `hunch policy prove ${p.id} — blocking stays fail-safe until the fresh proof lands`,
+            });
+            continue;
+        }
+        if (p.state === "compiled" || p.state === "validating") {
+            out.push({
+                kind: "policy-candidate",
+                topic: p.id,
+                decisionIds: [p.id],
+                question: `Candidate rule "${clip(p.statement)}" (${p.id}) awaits your review — keep it moving or reject it?`,
+                detail: `state ${p.state} · authority none · not yet proved`,
+                resolution: `hunch policy prove ${p.id} — then accept/reject; or hunch policy reject ${p.id} --reason "..."`,
+            });
+        }
+        else if (p.state === "proposed") {
+            out.push({
+                kind: "policy-proposal",
+                topic: p.id,
+                decisionIds: [p.id],
+                question: p.proof
+                    ? `Proposed rule "${clip(p.statement)}" (${p.id}) carries its proof — activate it (advisory/blocking) or reject it?`
+                    : `Proposed rule "${clip(p.statement)}" (${p.id}) has no current proof — prove it, then decide.`,
+                detail: `state proposed · ${p.proof ? `proof ${p.proof}` : "no proof"} · authority none`,
+                resolution: p.proof
+                    ? `inspect: hunch policy card ${p.id} — then hunch policy accept ${p.id} --advisory|--blocking --actor human:<you>, or reject`
+                    : `hunch policy prove ${p.id}`,
+            });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=escalations.js.map

package/dist/core/events.js

@@ -0,0 +1,61 @@
+/** The catch-log: an append-only, git-tracked JSONL trail of enforcement events
+ *  (`.hunch/events.log`). Every time the deterministic gate actually BLOCKS an
+ *  edit — a blocking invariant hit, or the Veto Guard reversing a rejected
+ *  approach — one line is appended here. Without this trail "the graph caught 37
+ *  violations" is an assertion; with it, it is a measurement (dec_6253f7e6d6).
+ *
+ *  WHY append-only (not temp-file+rename like the JSON index, con_902759b3dc):
+ *  the atomicity invariant exists so an interrupted write can never TRUNCATE the
+ *  index. A single-line append can never truncate what is already on disk — it
+ *  only ever extends it — so it honors that invariant's spirit without the O(n)
+ *  read-modify-write a rewrite would cost per event. The log is a derived audit
+ *  trail, never a source of truth: a lost or malformed line loses one catch's
+ *  provenance, never a decision.
+ *
+ *  HONESTY (dec_6253f7e6d6): a constraint/veto block carries NO subject/object/
+ *  assert — those are conformance-only predicates checked by a different gate
+ *  (`hunch conform`), not the edit hook. This schema records only what each gate
+ *  actually knows; it never fabricates the conformance shape for a plain block. */
+import { appendFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export function eventsLogPath(paths) {
+    return join(paths.hunch, "events.log");
+}
+/** Append one event as a JSONL line. Best-effort and never throws: the primary
+ *  call site is the edit hook, which MUST NEVER break an agent on failure
+ *  (con_03a0b94b2e). A dropped catch-log line is an acceptable loss. */
+export function appendEvent(paths, event) {
+    try {
+        appendFileSync(eventsLogPath(paths), `${JSON.stringify(event)}\n`);
+    }
+    catch {
+        /* best effort — a lost audit line must never surface to the agent */
+    }
+}
+/** Read + parse the catch-log. Malformed lines are skipped, not fatal (the log is
+ *  derived; one bad line never poisons the aggregation). Missing log → []. */
+export function readEvents(paths) {
+    let raw;
+    try {
+        raw = readFileSync(eventsLogPath(paths), "utf8");
+    }
+    catch {
+        return []; // no catches recorded yet
+    }
+    const out = [];
+    for (const line of raw.split("\n")) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        try {
+            const e = JSON.parse(s);
+            if (e && typeof e.at === "string" && typeof e.kind === "string")
+                out.push(e);
+        }
+        catch {
+            /* skip a corrupt line */
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=events.js.map

package/dist/core/externalImports.js

@@ -0,0 +1,24 @@
+import { shortHash } from "./ids.js";
+/** Canonical package identity for a static module specifier. Relative, absolute,
+ * package-import-map (#), and URL-like specifiers are repository/runtime-local
+ * and deliberately outside the external-dependency evaluator. */
+export function externalPackage(specifier) {
+    const value = specifier.trim();
+    if (!value || value.startsWith(".") || value.startsWith("/") || value.startsWith("#") || /^[a-z]+:\/\//i.test(value))
+        return null;
+    if (value.startsWith("node:"))
+        return /^node:[A-Za-z0-9_./-]+$/.test(value) ? value : null;
+    if (value.startsWith("@")) {
+        const [scope, name] = value.split("/");
+        return scope && name ? `${scope}/${name}` : null;
+    }
+    return value.split("/")[0] || null;
+}
+/** Virtual graph target for an external package. It is intentionally not a
+ * Component record: package facts stay a bounded evaluator layer and do not
+ * inflate the human-curated component graph. */
+export function externalImportNodeId(specifier) {
+    const dependency = externalPackage(specifier);
+    return dependency ? `ext_${shortHash(dependency)}` : null;
+}
+//# sourceMappingURL=externalImports.js.map

package/dist/core/hookpolicy.js

@@ -16,6 +16,7 @@ export function blockingInScope(store, file, proposedAddedLines = []) {
             continue;
         return {
             reason: `Hunch: editing ${file} would touch a BLOCKING invariant — "${c.statement}" (${c.id}). Do not proceed unless this change is meant to modify that invariant; otherwise preserve it.`,
+            event: { kind: "constraint", constraint: c.id },
         };
     }
     for (const b of store.blastRadiusFiles(file)) {
@@ -29,6 +30,7 @@ export function blockingInScope(store, file, proposedAddedLines = []) {
                 continue;
             return {
                 reason: `Hunch: ${file} is in the blast radius of a BLOCKING invariant — "${c.statement}" (${c.id}; via ${b.file}, ${b.via} depth ${b.depth}). Verify the invariant still holds before editing.`,
+                event: { kind: "constraint", constraint: c.id },
             };
         }
     }
@@ -53,6 +55,7 @@ export function vetoInScope(store, file, proposedAddedLines) {
         return null;
     return {
         reason: `Hunch: editing ${file} would REVERSE decision ${hit.decision} — you rejected "${hit.alternative}" and chose "${hit.chosen}". Do not re-introduce the rejected approach; preserve the chosen design.`,
+        event: { kind: "veto", decision: hit.decision },
     };
 }
 //# sourceMappingURL=hookpolicy.js.map

package/dist/core/memorylog.js

@@ -0,0 +1,69 @@
+/**
+ * The memory-move timeline — the data behind `hunch log` and the VS Code "Hunch
+ * Source Control" view. Every commit that touched `.hunch/` is one MOVE (a capture,
+ * adoption, supersession, or prune), classified deterministically from git's own
+ * name-status. Pure parsing — no LLM, no judgment — so the panel shows exactly what
+ * git recorded and each move maps back to a real, revertable commit.
+ *
+ * The parser is split from the git shell-out (extractors/git.gitMemoryLog) so it is
+ * unit-testable with canned `git log` output.
+ */
+/** The record-header separator we ask `git log --format` to emit, so header lines
+ *  are unambiguous against the name-status lines that follow each commit. */
+export const MEMLOG_HEADER = "@@@";
+/** The `--format` string that pairs with {@link parseMemoryLog}. */
+export const MEMLOG_FORMAT = `${MEMLOG_HEADER}%H\t%h\t%cI\t%s`;
+const ID_RE = /\/((?:dec|bug|con|cmp|pol)_[0-9a-f]+)\.json$/;
+/** Parse `git log <MEMLOG_FORMAT> --name-status -- .hunch/` output into classified
+ *  moves, newest first (git's order). */
+export function parseMemoryLog(raw) {
+    const moves = [];
+    let cur = null;
+    for (const line of raw.split("\n")) {
+        if (line.startsWith(MEMLOG_HEADER)) {
+            if (cur)
+                moves.push(classify(cur));
+            const f = line.slice(MEMLOG_HEADER.length).split("\t");
+            cur = {
+                sha: f[0] ?? "", shortSha: f[1] ?? "", date: f[2] ?? "", subject: f.slice(3).join("\t"),
+                kind: "edit", decisionIds: [], otherIds: [], added: 0, modified: 0, deleted: 0, files: [],
+            };
+            continue;
+        }
+        if (!cur || !line.trim())
+            continue;
+        // name-status: "A\tpath", "M\tpath", "D\tpath", or rename "R100\told\tnew".
+        const parts = line.split("\t");
+        const status = parts[0]?.[0];
+        const path = parts[parts.length - 1];
+        if (!path || !path.startsWith(".hunch/"))
+            continue;
+        cur.files.push(path);
+        if (status === "A")
+            cur.added++;
+        else if (status === "D")
+            cur.deleted++;
+        else
+            cur.modified++;
+        const id = ID_RE.exec(path)?.[1];
+        if (id)
+            (id.startsWith("dec_") ? cur.decisionIds : cur.otherIds).push(id);
+    }
+    if (cur)
+        moves.push(classify(cur));
+    return moves;
+}
+/** Deterministic move kind from the subject + the add/modify/delete shape. */
+function classify(m) {
+    const s = m.subject.toLowerCase();
+    m.kind =
+        /\brepair\b/.test(s) ? "repair"
+            : /\badopt/.test(s) ? "adopt"
+                : /supersed/.test(s) ? "supersede"
+                    : m.deleted > 0 && m.added === 0 && m.modified === 0 ? "prune"
+                        : m.added > 0 && m.modified === 0 && m.deleted === 0 ? "capture"
+                            : /\bcapture\b/.test(s) ? "capture"
+                                : "edit";
+    return m;
+}
+//# sourceMappingURL=memorylog.js.map

package/dist/core/relativeImports.js

@@ -0,0 +1,33 @@
+import { dirname, join, posix } from "node:path";
+function toPosix(path) {
+    return path.split(/[\\/]/).join(posix.sep);
+}
+/** Candidate source files for one static relative JS/TS import, in the same
+ * deterministic precedence order used by the indexer. Bare packages, URLs,
+ * absolute paths, and import-map aliases are deliberately unsupported. */
+export function relativeImportCandidates(fromFile, specifier) {
+    if (!specifier.startsWith(".") || specifier.includes("\0"))
+        return [];
+    const base = toPosix(join(dirname(fromFile), specifier));
+    return [...new Set([
+            base.replace(/\.js$/, ".ts"),
+            base.replace(/\.js$/, ".tsx"),
+            base.replace(/\.jsx$/, ".tsx"),
+            base + ".ts",
+            base + ".tsx",
+            base,
+            base + ".js",
+            toPosix(join(base, "index.ts")),
+            toPosix(join(base, "index.tsx")),
+            toPosix(join(base, "index.js")),
+        ])];
+}
+/** Resolve against an exact file set. The first candidate preserves existing
+ * indexer compatibility; callers that need ambiguity metadata can inspect the
+ * returned matches instead of guessing a different target. */
+export function resolveRelativeImport(fromFile, specifier, availableFiles) {
+    const available = new Set(availableFiles);
+    const matches = relativeImportCandidates(fromFile, specifier).filter((candidate) => available.has(candidate));
+    return { path: matches[0] ?? null, matches };
+}
+//# sourceMappingURL=relativeImports.js.map

package/dist/core/repair.js

@@ -0,0 +1,71 @@
+/** A scope entry is exact (rewritable) only when it contains no glob syntax. */
+function isExactPath(entry) {
+    return !/[*?[\]{}]/.test(entry);
+}
+/** Extract the rename pairs from a commit's change records (already 1:1 by git -M). */
+export function renamesOf(changes) {
+    return changes
+        .filter((c) => c.status === "renamed" && c.before && c.after && c.before !== c.after)
+        .map((c) => ({ before: c.before, after: c.after }));
+}
+/** Plan every safe rewrite. Only exact matches against a git-confirmed rename move;
+ *  live records only (a superseded/retired record's history stays as written). */
+export function planRepair(renames, decisions, constraints) {
+    const map = new Map(renames.map((r) => [r.before, r.after]));
+    const rewrites = [];
+    if (!map.size)
+        return { rewrites, records: [] };
+    for (const d of decisions) {
+        if (d.status === "superseded" || d.status === "rejected")
+            continue;
+        for (const f of d.related_files ?? []) {
+            const to = map.get(f);
+            if (to)
+                rewrites.push({ kind: "decisions", id: d.id, field: "related_files", from: f, to });
+        }
+        for (const tw of d.rejected_tripwires ?? []) {
+            for (const s of tw.scope ?? []) {
+                const to = isExactPath(s) ? map.get(s) : undefined;
+                if (to)
+                    rewrites.push({ kind: "decisions", id: d.id, field: "tripwire.scope", from: s, to });
+            }
+        }
+    }
+    for (const c of constraints) {
+        if (c.status && c.status !== "active")
+            continue;
+        for (const s of c.scope ?? []) {
+            const to = isExactPath(s) ? map.get(s) : undefined;
+            if (to)
+                rewrites.push({ kind: "constraints", id: c.id, field: "scope", from: s, to });
+        }
+    }
+    return { rewrites, records: [...new Set(rewrites.map((r) => `${r.kind}:${r.id}`))] };
+}
+/** Apply a plan's rewrites to one decision (pure — returns the healed copy, or the
+ *  original reference when nothing in the plan touches it). */
+export function repairDecision(d, plan) {
+    const mine = plan.rewrites.filter((r) => r.kind === "decisions" && r.id === d.id);
+    if (!mine.length)
+        return d;
+    const sub = (field, value) => mine.find((r) => r.field === field && r.from === value)?.to ?? value;
+    return {
+        ...d,
+        related_files: (d.related_files ?? []).map((f) => sub("related_files", f)),
+        rejected_tripwires: (d.rejected_tripwires ?? []).map((tw) => ({
+            ...tw,
+            scope: (tw.scope ?? []).map((s) => sub("tripwire.scope", s)),
+        })),
+    };
+}
+/** Apply a plan's rewrites to one constraint (pure). */
+export function repairConstraint(c, plan) {
+    const mine = plan.rewrites.filter((r) => r.kind === "constraints" && r.id === c.id);
+    if (!mine.length)
+        return c;
+    return {
+        ...c,
+        scope: (c.scope ?? []).map((s) => mine.find((r) => r.field === "scope" && r.from === s)?.to ?? s),
+    };
+}
+//# sourceMappingURL=repair.js.map

package/dist/core/reviewqueue.js

@@ -24,6 +24,17 @@ export function parseSynth(evidence) {
 }
 /** Grounded-ness at/above which a Critic-verified draft is a "quick yes". */
 export const READY_MIN_GROUNDED = 0.7;
+/** Whether a decision is an un-vouched draft still awaiting a human — the ONLY thing
+ *  the review path surfaces under the auto-trust model.
+ *
+ *  Low confidence NO LONGER makes a draft: captured memory is trusted-advisory the
+ *  moment it lands (status `accepted`, source `llm_draft`), so it grounds and ranks
+ *  but never nags. Only a DELIBERATE, not-yet-human-vouched `proposed` record — an
+ *  explicit roadmap/intent entry a human hasn't confirmed — counts as a review draft.
+ *  (Enforcement authority is granted INLINE, not by draining a background queue.) */
+export function isReviewDraft(d) {
+    return d.status === "proposed" && !d.provenance.source.includes("human_confirmed");
+}
 /** A draft is "ready to confirm" only when the Critic actually audited it (source
  *  includes "verified") AND judged it well-grounded. A high confidence number alone
  *  is NOT enough — an un-audited draft always needs human eyes. */

package/dist/core/stats.js

@@ -0,0 +1,115 @@
+/** A constraint that actually has teeth: active, blocking, and human-vouched — the
+ *  same "ARMED" definition `hunch status` uses. Draft/advisory rules don't count as
+ *  locked stock. */
+function isLocked(c) {
+    const src = c.provenance?.source;
+    const vouched = !!src && (src.includes("human_confirmed") || src === "derived");
+    return c.status === "active" && c.severity === "blocking" && vouched;
+}
+function eventMs(e) {
+    const t = Date.parse(e.at);
+    return Number.isNaN(t) ? 0 : t;
+}
+/** Tally the four return metrics over a set of events. `bugs_reprevented` is the
+ *  strict, deterministic claim: a blocked edit whose enforcing decision was caused
+ *  by a bug that has DEMONSTRABLY regressed (came back once already). No event ever
+ *  fabricates that shape — it's a real join over the graph. */
+function tallyReturn(events, decById, bugById) {
+    let caught = 0, drifts = 0, reprevented = 0, vetoes = 0;
+    for (const e of events) {
+        if (e.kind === "constraint" || e.kind === "veto" || e.kind === "conformance")
+            caught++;
+        if (e.kind === "veto")
+            vetoes++;
+        if (e.kind === "drift")
+            drifts++;
+        if (e.decision) {
+            const d = decById.get(e.decision);
+            const bug = d?.caused_by_bug ? bugById.get(d.caused_by_bug) : undefined;
+            if (bug && bug.status === "regressed")
+                reprevented++;
+        }
+    }
+    return { violations_caught: caught, drifts_flagged: drifts, bugs_reprevented: reprevented, vetoes_fired: vetoes };
+}
+export function computeStats(input) {
+    const { decisions, constraints, bugs, componentIds, events } = input;
+    const byStatus = (recs, s) => recs.filter((r) => r.status === s).length;
+    const activeConstraints = constraints.filter((c) => c.status === "active");
+    const locked = activeConstraints.filter(isLocked).length;
+    // Coverage: distinct components named by at least one decision, over total. Only
+    // component ids that actually EXIST count (a dangling ref isn't coverage).
+    const compSet = new Set(componentIds);
+    const touched = new Set();
+    for (const d of decisions)
+        for (const c of d.related_components)
+            if (compSet.has(c))
+                touched.add(c);
+    const componentsTotal = componentIds.length;
+    const pct = componentsTotal ? touched.size / componentsTotal : 0;
+    const decById = new Map(decisions.map((d) => [d.id, d]));
+    const bugById = new Map(bugs.map((b) => [b.id, b]));
+    const inWindow = events.filter((e) => eventMs(e) >= input.windowStart);
+    const lifetime = tallyReturn(events, decById, bugById);
+    const windowReturn = tallyReturn(inWindow, decById, bugById);
+    const rulesRecorded = locked;
+    const catchesLifetime = lifetime.violations_caught;
+    return {
+        schema: "hunch.stats/1",
+        generated_at: new Date(input.now).toISOString(),
+        window: { since: input.windowLabel, from: new Date(input.windowStart).toISOString(), to: new Date(input.now).toISOString() },
+        stock: {
+            decisions: {
+                total: decisions.length,
+                accepted: byStatus(decisions, "accepted"),
+                superseded: byStatus(decisions, "superseded"),
+                proposed: byStatus(decisions, "proposed"),
+                rejected: byStatus(decisions, "rejected"),
+            },
+            invariants: { total: activeConstraints.length, locked, advisory: activeConstraints.length - locked, stale: input.staleConstraints },
+            components: componentsTotal,
+            bugs: {
+                total: bugs.length,
+                open: byStatus(bugs, "open"),
+                investigating: byStatus(bugs, "investigating"),
+                fixed: byStatus(bugs, "fixed"),
+                regressed: byStatus(bugs, "regressed"),
+            },
+            runbooks: input.runbooksCount,
+            coverage: { components_with_decision: touched.size, components_total: componentsTotal, pct: Math.round(pct * 100) / 100 },
+        },
+        return: { window: windowReturn, lifetime },
+        compounding: {
+            rules_recorded: rulesRecorded,
+            catches_lifetime: catchesLifetime,
+            payback_ratio: rulesRecorded ? Math.round((catchesLifetime / rulesRecorded) * 10) / 10 : 0,
+        },
+    };
+}
+/** Human-readable receipt for the terminal (the CLI's default, non-`--json` output).
+ *  Same three blocks as the JSON: stock → return → compounding. Honest zeros are
+ *  shown plainly, never hidden — a young graph reads as young, not as broken. */
+export function formatStats(s) {
+    const L = [];
+    const pct = Math.round(s.stock.coverage.pct * 100);
+    L.push(`\n🧠 Hunch — engineering-memory stats\n`);
+    L.push(`  STOCK (accumulated)`);
+    L.push(`    decisions:  ${s.stock.decisions.total}  (${s.stock.decisions.accepted} accepted · ${s.stock.decisions.proposed} proposed · ${s.stock.decisions.superseded} superseded)`);
+    L.push(`    invariants: ${s.stock.invariants.total}  (${s.stock.invariants.locked} locked · ${s.stock.invariants.advisory} advisory${s.stock.invariants.stale ? ` · ${s.stock.invariants.stale} stale` : ""})`);
+    L.push(`    components: ${s.stock.components}   ·   bugs: ${s.stock.bugs.total}   ·   runbooks: ${s.stock.runbooks}`);
+    L.push(`    coverage:   ${pct}% of components explained by ≥1 decision  (${s.stock.coverage.components_with_decision}/${s.stock.coverage.components_total})`);
+    L.push(`\n  RETURN (what the stock caught)`);
+    const r = s.return.lifetime, w = s.return.window;
+    L.push(`    this ${s.window.since}:  ${w.violations_caught} caught · ${w.drifts_flagged} drift · ${w.bugs_reprevented} re-prevented`);
+    L.push(`    lifetime:    ${r.violations_caught} caught · ${r.bugs_reprevented} re-prevented`);
+    L.push(`\n  COMPOUNDING`);
+    if (s.compounding.rules_recorded && s.compounding.catches_lifetime) {
+        L.push(`    ${s.compounding.rules_recorded} locked rule(s) → ${s.compounding.catches_lifetime} catch(es)  ·  each rule pays back ${s.compounding.payback_ratio}×`);
+    }
+    else {
+        L.push(`    ${s.compounding.rules_recorded} locked rule(s), ${s.compounding.catches_lifetime} catch(es) so far — the catch-log grows as the gate fires (nothing to inflate).`);
+    }
+    L.push("");
+    return L.join("\n");
+}
+//# sourceMappingURL=stats.js.map