@davesheffer/hunch 0.1.1 → 0.5.0

package/README.md

@@ -98,7 +98,8 @@ normally and Claude consults Hunch, or invoke the slash commands:
 | `/hunch-fragile` | a fragility report (the riskiest code, with evidence) |
 
 The MCP tools Claude calls under the hood: `hunch_why`, `hunch_query`,
-`hunch_check_constraints`, `hunch_get_dependents` (blast radius), `hunch_bug_lineage`,
+`hunch_check_constraints`, `hunch_get_dependents` (blast radius), `hunch_blast_radius`
+(dependent files + near-violations a change could break indirectly), `hunch_bug_lineage`,
 `hunch_context` (surgical minimal slice for a task), `hunch_record_decision` (write-back).
 
 **Through the CLI** — the same graph, from your terminal:
@@ -110,13 +111,14 @@ The MCP tools Claude calls under the hood: `hunch_why`, `hunch_query`,
 | `hunch backfill --since 90d` | replay git history → seed decisions |
 | `hunch sync [sha]` | turn a commit into a Decision (run automatically by the hook) |
 | `hunch record-bug --test <id> --message <m>` | capture a Bug from a failing test |
+| `hunch test [cmd…]` | run the suite (default `npm test`); auto-capture failures as Bugs (suspects + recurrence→Constraints), mark passing tests' bugs fixed |
 | `hunch why <path\|symbol>` | decisions / bugs / constraints explaining a target (flags `⚠STALE`) |
 | `hunch query "<q>" [--semantic]` | full-text + graph search (`--semantic` blends in local embeddings) |
 | `hunch embed` | generate local embeddings for semantic recall (opt-in; needs `@huggingface/transformers`) |
 | `hunch context <path\|symbol>` | minimal relevant slice for a task: invariants → decisions → bugs → blast radius |
 | `hunch fragile` | ranked fragility report with evidence |
-| `hunch check [--staged\|--commit <sha>] [--strict]` | guardrail: flag changes touching a do-not-break invariant |
-| `hunch stale` | drift: records whose files changed after they were last verified |
+| `hunch check [--staged\|--commit <sha>] [--strict] [--blast]` | guardrail: flag changes touching a do-not-break invariant **directly or via blast radius** (a guarded file that depends on what you changed); `--blast` prints the dependency fan-out |
+| `hunch stale [--resync]` | drift: records whose files changed after last verification (`--resync` regenerates stale decisions from their commits) |
 | `hunch review [--accept <id>\|--reject <id>]` | curate: triage / promote / drop low-confidence drafts |
 | `hunch migrate` | upgrade `.hunch/` records to the current schema version |
 | `hunch compact [--apply]` | prune low-value drafts to bound growth (dry-run by default) |
@@ -135,6 +137,12 @@ hunch embed                                     # embed your records (first run
 hunch query --semantic "auth token expiry"      # hybrid keyword + semantic recall
 ```
 
+> **Install it where `hunch` runs.** The runtime is resolved from `hunch`'s own
+> `node_modules`, so match the install scope: a globally-installed `hunch` needs the
+> global (`-g`) install above; running from a source checkout needs it in the repo
+> (`npm i @huggingface/transformers` there). If `hunch embed` reports the model "present
+> but failed to load," the scopes don't match. `hunch doctor` shows the active mode.
+
 Embeddings are **local and free** (no API — consistent with the subscription-only synthesis
 rule) and **opt-in** (the base install stays lean). The long-lived MCP server picks them up
 automatically once present. Vectors live in the derived SQLite index and are reconciled by
@@ -160,6 +168,33 @@ concurrent edits to the graph merge **by record id** instead of throwing conflic
 committed `.gitattributes`; the per-clone driver definition is set up by each teammate's
 `hunch init`.
 
+## Continuous learning (CI)
+
+The decision half of the loop is automatic (the post-commit hook). Light up the **bug /
+constraint half** by wrapping your test run with `hunch test`:
+
+```bash
+hunch test                       # runs `npm test`; capture failures → Bugs, resolve fixed ones
+hunch test -- pytest -q          # any runner: pass the command after `--`
+```
+
+It parses TAP and the `node:test` spec reporter, captures each failing test as a **Bug**
+(ranked suspects; a recurrence or substantiated high-severity failure auto-promotes a
+do-not-break **Constraint**), and marks a previously-open bug **fixed** once its test passes
+again. It preserves the runner's exit code, so it's a drop-in CI step:
+
+```yaml
+# .github/workflows/ci.yml
+- run: npm ci
+- run: npx hunch test            # exits non-zero on failure, just like the suite
+- run: |                         # persist what was learned (optional)
+    git add .hunch && git commit -m "chore(hunch): capture test run" || true
+    git push || true
+```
+
+Repair drift after refactors with **`hunch stale --resync`** (re-synthesizes stale decisions
+from their commits via the LLM).
+
 ## Maintenance
 
 - **`hunch doctor`** — is git healthy? are you on the subscription path or the offline

package/dist/cli/index.js

@@ -9,17 +9,19 @@
  *   why       decisions/bugs/constraints explaining a file/symbol
  *   fragile   ranked fragility report with evidence
  *   record-bug  capture a Bug from a (failing) test
+ *   test      run the suite, auto-capture failures as Bugs, resolve fixed ones
  *   mcp       start the MCP server (Claude Code connects here)
  *   doctor    environment diagnostics
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { Command } from "commander";
 import { hunchPaths, findRoot } from "../core/paths.js";
 import { HunchStore } from "../store/hunchStore.js";
 import { selectEmbedder } from "../store/embedder.js";
 import { indexRepo } from "../extractors/indexer.js";
-import { syncCommit, recordFailure } from "../synthesis/synthesize.js";
+import { syncCommit, recordFailure, captureTestRun } from "../synthesis/synthesize.js";
+import { parseTestReport } from "../extractors/testreport.js";
 import { selectProvider } from "../synthesis/provider.js";
 import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles } from "../extractors/git.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
@@ -45,8 +47,8 @@ program
     .command("init")
     .description("Scaffold .hunch/, index the repo, install the git hook, and wire up Claude Code.")
     .option("--no-index", "skip the initial repo index")
-    .option("--enforce", "install an advisory pre-commit constraint guard")
-    .option("--enforce-strict", "install a pre-commit guard that FAILS the commit on a blocking invariant")
+    .option("--no-enforce", "do not install the advisory pre-commit constraint guard")
+    .option("--enforce-strict", "make the pre-commit guard FAIL the commit on a blocking invariant (direct or near)")
     .action((opts) => {
     const root = findRoot();
     const paths = hunchPaths(root);
@@ -68,9 +70,13 @@ program
         console.log(`  ✓ post-commit hook ${h.action} (learning loop)`);
         const m = installMergeDriver(root, inv.shell);
         console.log(`  ✓ team merge driver ${m.action}`);
-        if (opts.enforce || opts.enforceStrict) {
-            const p = installPreCommitHook(root, inv.shell, !!opts.enforceStrict);
-            console.log(`  ✓ pre-commit constraint guard ${p.action} (${opts.enforceStrict ? "strict — blocks on blocking invariants" : "advisory"})`);
+        // Auto-install the pre-commit guard by default (advisory: flags invariants
+        // touched directly OR via blast radius, never blocks). Opt out with
+        // --no-enforce; --enforce-strict makes blocking near/direct hits fail the commit.
+        if (opts.enforce !== false || opts.enforceStrict) {
+            const strict = !!opts.enforceStrict;
+            const p = installPreCommitHook(root, inv.shell, strict);
+            console.log(`  ✓ pre-commit constraint guard ${p.action} (${strict ? "strict — blocks on blocking invariants, direct or near" : "advisory — flags invariants in scope or blast radius"})`);
         }
     }
     else {
@@ -228,13 +234,25 @@ program
         return;
     }
     process.stdout.write(`Embedding ${todo} doc(s) with ${embedder.id} (first run downloads the model ~90MB, one time)…\n`);
-    const res = await store.embedAll(embedder, {
-        batch: Number(opts.batch),
-        onProgress: (done, total) => process.stdout.write(`\r  ${done}/${total} embedded   `),
-    });
-    process.stdout.write("\n");
-    console.log(`✓ embedded ${res.embedded} doc(s) (${res.skipped} already current). Model: ${embedder.id}.`);
-    console.log(`  Try:  hunch query --semantic "<question>"   — the MCP server uses it automatically.`);
+    try {
+        const res = await store.embedAll(embedder, {
+            batch: Number(opts.batch),
+            onProgress: (done, total) => process.stdout.write(`\r  ${done}/${total} embedded   `),
+        });
+        process.stdout.write("\n");
+        console.log(`✓ embedded ${res.embedded} doc(s) (${res.skipped} already current). Model: ${embedder.id}.`);
+        console.log(`  Try:  hunch query --semantic "<question>"   — the MCP server uses it automatically.`);
+    }
+    catch (e) {
+        // The availability probe (createRequire.resolve) can succeed while the
+        // runtime ESM import/model load fails — e.g. the package is only
+        // resolvable via NODE_PATH, or a native backend is missing. Degrade with
+        // an actionable hint instead of a stack trace; queries stay on keyword search.
+        process.stdout.write("\n");
+        console.log("Semantic model is present but failed to load — staying on keyword (FTS) search.");
+        console.log(`  reason: ${e.message.split("\n")[0]}`);
+        console.log("  Install @huggingface/transformers where hunch actually runs (a global `hunch` needs a global install; running from source needs it in the repo's node_modules).");
+    }
     store.close();
 });
 // ---- why ------------------------------------------------------------------
@@ -306,24 +324,108 @@ program
         console.log(`  ↳ promoted constraint ${r.constraint.id} [${r.constraint.severity}]: ${r.constraint.statement}`);
     store.close();
 });
+// ---- test (failure-learning loop) -----------------------------------------
+program
+    .command("test")
+    .description("Run the test suite; capture failures as Bugs (suspects + recurrence → Constraints), mark passing tests' bugs fixed.")
+    .argument("[cmd...]", "test command to run (default: `npm test`)")
+    .option("--dry-run", "show what would be captured without writing")
+    .action(async (cmd, opts) => {
+    const { store, root } = storeFor();
+    store.json.ensureDirs();
+    // Run as a shell string (not argv) so the npm/test-runner shim resolves on
+    // Windows and avoids Node's DEP0190 args+shell warning — same lesson as the
+    // claude CLI fix. The command is operator-supplied, so a shell is expected.
+    const cmdStr = cmd.length ? cmd.join(" ") : "npm test";
+    console.log(`▶ running: ${cmdStr}\n`);
+    const run = spawnSync(cmdStr, {
+        cwd: root,
+        shell: true,
+        encoding: "utf8",
+        maxBuffer: 64 * 1024 * 1024,
+        windowsHide: true,
+    });
+    const output = `${run.stdout ?? ""}\n${run.stderr ?? ""}`;
+    const report = parseTestReport(output);
+    if (opts.dryRun) {
+        const willFallback = !report.recognized && run.status !== 0;
+        const n = willFallback ? 1 : report.failures.length;
+        console.log(`DRY RUN — exit ${run.status}, ${report.passed.length} passed, ${n} failure(s)${willFallback ? " (fallback: output not TAP/spec)" : ""}:`);
+        for (const f of report.failures)
+            console.log(`  ✗ ${f.test}`);
+        if (willFallback)
+            console.log(`  ✗ ${cmdStr} (whole-suite)`);
+        store.close();
+        return;
+    }
+    const cap = await captureTestRun(store, root, { report, status: run.status, cmd: cmdStr, output });
+    for (const { bug, constraint } of cap.results) {
+        if (constraint)
+            console.log(`  ⚠ ${bug.id} "${bug.title}" → promoted constraint ${constraint.id} [${constraint.severity}]`);
+        else
+            console.log(`  ✗ ${bug.id} "${bug.title}" [${bug.severity}]${bug.lineage.recurrence_of ? ` ↳ recurrence of ${bug.lineage.recurrence_of}` : ""}`);
+    }
+    for (const b of cap.fixed)
+        console.log(`  ✓ ${b.id} "${b.title}" → fixed (test passing)`);
+    store.reindex();
+    store.close();
+    const recurrences = cap.results.filter((r) => r.bug.lineage.recurrence_of).length;
+    const promoted = cap.results.filter((r) => r.constraint).length;
+    console.log(`\n${run.status === 0 ? "✓ suite passed" : "✗ suite failed"} — ` +
+        `${cap.results.length} bug(s) captured (${recurrences} recurrence, ${promoted} constraint), ${cap.fixed.length} resolved.`);
+    if (run.status !== 0)
+        process.exitCode = 1; // preserve CI semantics
+});
 // ---- stale (drift detection) ----------------------------------------------
 program
     .command("stale")
     .description("List decisions/constraints whose files changed after they were last verified (drift).")
-    .action(() => {
+    .option("--resync", "re-synthesize stale decisions from their commit via the LLM (drift repair)")
+    .action(async (opts) => {
     const { store, root } = storeFor();
     const stale = store.staleness((f) => lastChangeDate(f, root));
     if (!stale.length) {
         console.log("✓ No drift detected — every verified decision/constraint is current.");
+        store.close();
+        return;
     }
-    else {
+    if (!opts.resync) {
         console.log(`⚠ ${stale.length} record(s) may be stale (a file in scope changed after last verification):\n`);
         for (const s of stale) {
             console.log(`  ${s.kind} ${s.id}\n      verified ${s.last_verified.slice(0, 10)} · changed ${s.changed_at.slice(0, 10)} · ${s.files.join(", ")}`);
         }
-        console.log(`\nRe-validate with: hunch review --accept <id>  (or edit the record).`);
+        console.log(`\nRepair: hunch stale --resync  (re-synthesize from commits)  ·  or  hunch review --accept <id>`);
+        store.close();
+        return;
+    }
+    // --resync: regenerate each stale DECISION from its commit. Constraints have no
+    // commit to replay, so they're reported as needing manual review instead.
+    let resynced = 0, skipped = 0;
+    for (const s of stale) {
+        if (!s.kind.startsWith("decision")) {
+            skipped++;
+            console.log(`  · ${s.kind} ${s.id} — manual (no commit to replay)`);
+            continue;
+        }
+        const d = store.json.get("decisions", s.id);
+        if (!d?.commit) {
+            skipped++;
+            console.log(`  · ${s.id} — skipped (no source commit)`);
+            continue;
+        }
+        const r = await syncCommit(store, root, d.commit, { force: true });
+        if (r.status === "written") {
+            resynced++;
+            console.log(`  ↻ ${s.id} ← ${d.commit.slice(0, 8)} (${r.provider})`);
+        }
+        else {
+            skipped++;
+            console.log(`  · ${s.id} — skipped: ${r.reason}`);
+        }
     }
+    store.reindex();
     store.close();
+    console.log(`\n✓ re-synthesized ${resynced} stale decision(s), ${skipped} left for manual review.`);
 });
 // ---- check (constraint enforcement) ---------------------------------------
 program
@@ -331,40 +433,76 @@ program
     .description("Flag changes that touch a do-not-break invariant's scope (guardrail).")
     .option("--staged", "check git staged files (default)")
     .option("--commit <sha>", "check a specific commit's files")
-    .option("--strict", "exit non-zero if a blocking constraint is in scope")
+    .option("--strict", "exit non-zero if a blocking constraint is in scope (direct OR near)")
+    .option("--blast", "also print the dependency blast radius of the changed files")
     .action((opts) => {
     if (opts.commit && opts.staged)
         return fail("--staged and --commit are mutually exclusive");
     const { store, root } = storeFor();
+    store.reindex(); // blast radius walks the edge graph — make the index current
     const files = opts.commit ? commitFiles(opts.commit, root) : stagedFiles(root);
     if (!files.length) {
         console.log("No changed files to check.");
         store.close();
         return;
     }
-    const hits = new Map();
+    const mark = (s) => (s === "blocking" ? "⛔" : s === "warning" ? "⚠" : "·");
+    // 1) DIRECT — a changed file matches a constraint's scope.
+    const direct = new Map();
     for (const f of files) {
         for (const c of store.checkConstraints(f)) {
-            const e = hits.get(c.id) ?? { constraint: c, files: [] };
+            const e = direct.get(c.id) ?? { c, files: [] };
             e.files.push(f);
-            hits.set(c.id, e);
+            direct.set(c.id, e);
+        }
+    }
+    // 2) NEAR — a changed file's blast radius reaches a file an invariant guards:
+    //    you didn't touch the invariant, but you touched something it depends on.
+    const near = new Map();
+    for (const f of files) {
+        for (const b of store.blastRadiusFiles(f)) {
+            for (const c of store.checkConstraints(b.file)) {
+                if (direct.has(c.id))
+                    continue; // already reported as a direct hit
+                const e = near.get(c.id) ?? { c, via: [] };
+                e.via.push(`${f} → ${b.file} (${b.via}, depth ${b.depth})`);
+                near.set(c.id, e);
+            }
         }
     }
-    if (!hits.size) {
-        console.log(`✓ ${files.length} changed file(s) touch no recorded invariants.`);
+    if (opts.blast) {
+        console.log(`Blast radius of ${files.length} changed file(s):`);
+        for (const f of files) {
+            const b = store.blastRadiusFiles(f);
+            const list = b.length ? `: ${b.slice(0, 8).map((x) => x.file).join(", ")}${b.length > 8 ? " …" : ""}` : "";
+            console.log(`  ${f} → ${b.length} dependent file(s)${list}`);
+        }
+        console.log("");
+    }
+    if (!direct.size && !near.size) {
+        console.log(`✓ ${files.length} changed file(s) touch no recorded invariants (directly or via blast radius).`);
         store.close();
         return;
     }
     let blocking = 0;
-    console.log(`Changes touch ${hits.size} invariant(s):\n`);
-    for (const { constraint: c, files: fs } of hits.values()) {
-        if (c.severity === "blocking")
-            blocking++;
-        const mark = c.severity === "blocking" ? "⛔" : c.severity === "warning" ? "⚠" : "·";
-        console.log(`  ${mark} [${c.severity}] ${c.statement}\n      ${c.id} · in: ${fs.join(", ")}\n      rationale: ${c.rationale || "—"}`);
+    if (direct.size) {
+        console.log(`Directly touches ${direct.size} invariant(s):\n`);
+        for (const { c, files: fs } of direct.values()) {
+            if (c.severity === "blocking")
+                blocking++;
+            console.log(`  ${mark(c.severity)} [${c.severity}] ${c.statement}\n      ${c.id} · in: ${fs.join(", ")}\n      rationale: ${c.rationale || "—"}`);
+        }
+    }
+    if (near.size) {
+        console.log(`${direct.size ? "\n" : ""}Near ${near.size} invariant(s) via blast radius (a guarded dependency changed — review):\n`);
+        for (const { c, via } of near.values()) {
+            if (c.severity === "blocking")
+                blocking++;
+            console.log(`  ${mark(c.severity)} [${c.severity}] ${c.statement}\n      ${c.id}\n      ${via.slice(0, 4).join("\n      ")}${via.length > 4 ? `\n      …+${via.length - 4} more path(s)` : ""}`);
+        }
     }
     if (opts.strict && blocking) {
-        console.log(`\n✗ ${blocking} blocking invariant(s) in scope — review before committing.`);
+        console.log(`\n✗ ${blocking} blocking invariant(s) in scope (direct or near) — review before committing.`);
         process.exitCode = 1;
     }
     else {

package/dist/extractors/testreport.js

@@ -0,0 +1,87 @@
+/**
+ * Parse a test run's output into pass/fail signals for the failure-learning loop
+ * (`hunch test`). Test-framework-agnostic: it recognizes both common shapes that
+ * `node:test` (this repo), mocha, ava, vitest, jest, and `prove` emit:
+ *
+ *  - TAP:  `ok 12 - name` / `not ok 3 - name`, with an optional indented YAML
+ *          diagnostic block (error + stack) under a failure.
+ *  - spec: node:test's default non-TTY reporter — `✔ name (1.2ms)` /
+ *          `✖ name (1.2ms)`, failures followed by an indented error block.
+ *          (Also accepts ✓/✗.)
+ *
+ * Design choices:
+ *  - A failure's `message` is the test name plus its indented diagnostic block —
+ *    exactly the context recordFailure() feeds the synthesizer for root-cause and
+ *    suspect ranking.
+ *  - If NEITHER shape is recognized, we return empty lists + recognized=false so
+ *    the caller falls back to a coarse "the suite failed" bug from the raw tail —
+ *    never silently reports success.
+ *  - Results are deduped by name (a spec reporter can echo a failing test in its
+ *    end-of-run recap).
+ */
+// TAP: `ok 12 - desc` / `not ok 3 - desc` (the "- " separator is optional).
+const TAP = /^(not ok|ok)\s+\d+\s*-?\s*(.*)$/;
+// spec: `✔ desc (1.2ms)` (pass) or `✖ desc (1.2ms)` (fail). ✓/✗ accepted too.
+const SPEC = /^([✔✓✖✗])\s+(.*)$/;
+const DURATION = /\s+\(\d+(?:\.\d+)?ms\)\s*$/; // trailing " (1.2ms)" spec suffix
+const DIRECTIVE = /#\s*(SKIP|TODO)\b/i;
+/** Parse TAP-or-spec text. Pure + synchronous so it's trivially unit-testable. */
+export function parseTestReport(output) {
+    const lines = output.split(/\r?\n/);
+    const failMap = new Map();
+    const passSet = new Set();
+    let recognized = false;
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const trimmed = raw.trim();
+        const tap = TAP.exec(trimmed);
+        const spec = tap ? null : SPEC.exec(trimmed);
+        if (!tap && !spec)
+            continue;
+        recognized = true;
+        const isFail = tap ? tap[1] === "not ok" : (spec[1] === "✖" || spec[1] === "✗");
+        let name = (tap ? tap[2] : spec[2]) ?? "";
+        name = name.replace(DURATION, "").trim();
+        if (!name)
+            name = `test #${i + 1}`;
+        if (DIRECTIVE.test(name))
+            continue; // skipped/todo — neither pass nor fail
+        name = stripDirective(name);
+        if (!isFail) {
+            passSet.add(name);
+            continue;
+        }
+        if (failMap.has(name))
+            continue; // dedupe recap echoes
+        // Collect the following more-indented diagnostic block as the message.
+        const baseIndent = leadingSpaces(raw);
+        const block = [];
+        for (let j = i + 1; j < lines.length; j++) {
+            const ln = lines[j];
+            if (ln.trim() === "") {
+                block.push("");
+                continue;
+            }
+            if (leadingSpaces(ln) <= baseIndent)
+                break;
+            block.push(ln.slice(baseIndent + 1));
+        }
+        const diag = block.join("\n").trim();
+        failMap.set(name, { test: name, message: diag ? `${name}\n${diag}` : name });
+    }
+    // A test can legitimately appear as both (flaky retry) — trust the failure.
+    for (const name of failMap.keys())
+        passSet.delete(name);
+    return { failures: [...failMap.values()], passed: [...passSet], recognized };
+}
+function leadingSpaces(s) {
+    let n = 0;
+    while (n < s.length && s[n] === " ")
+        n++;
+    return n;
+}
+function stripDirective(name) {
+    const hash = name.indexOf("#");
+    return (hash === -1 ? name : name.slice(0, hash)).trim();
+}
+//# sourceMappingURL=testreport.js.map

package/dist/mcp/server.js

@@ -38,6 +38,12 @@ function resolveSymbols(store, target) {
         return byName;
     return syms.filter((s) => s.file === target || s.file.endsWith(target));
 }
+/** Resolve a target to canonical indexed file path(s) (for file-granular blast
+ *  radius). Falls back to the literal target so direct-scope checks still run. */
+function resolveFiles(store, target) {
+    const files = new Set(resolveSymbols(store, target).map((s) => s.file));
+    return files.size ? [...files] : [target];
+}
 export function buildServer(root) {
     const store = new HunchStore(hunchPaths(root));
     // Ensure the SQLite index reflects the JSON source of truth on startup.
@@ -143,6 +149,35 @@ export function buildServer(root) {
         const lines = deps.slice(0, DEP_CAP).map((d) => `  • [depth ${d.depth}] ${d.via} (${d.id})`);
         return ok(`Blast radius of "${symbol}" — ${deps.length} dependent(s):\n${lines.join("\n")}${more(deps.length, DEP_CAP, "closest shown first")}`);
     });
+    // -- hunch_blast_radius (dependents + near-violations) --------------------
+    server.registerTool("hunch_blast_radius", {
+        title: "Blast radius + near-violations for a file",
+        description: "Given a file you're about to change, return its dependency blast radius (files whose code depends on it) AND any invariants reached THROUGH that radius — 'near-violations' you could break indirectly without touching their own scope. Call before editing a widely-depended-on file. Mirrors `hunch check --blast`.",
+        inputSchema: { target: z.string().describe("A file path (e.g. src/auth/jwt.ts) or symbol.") },
+    }, async ({ target }) => {
+        const parts = [];
+        for (const file of resolveFiles(store, target)) {
+            const blast = store.blastRadiusFiles(file);
+            const directIds = new Set(store.checkConstraints(file).map((c) => c.id));
+            const near = new Map();
+            for (const b of blast) {
+                for (const c of store.checkConstraints(b.file)) {
+                    if (directIds.has(c.id) || near.has(c.id))
+                        continue;
+                    near.set(c.id, { c, via: `${b.file} (${b.via}, depth ${b.depth})` });
+                }
+            }
+            const blastBody = blast.length
+                ? `:\n${blast.slice(0, DEP_CAP).map((b) => `  • [depth ${b.depth}] ${b.file} (via ${b.via})`).join("\n")}${more(blast.length, DEP_CAP, "closest first")}`
+                : "";
+            const nearArr = [...near.values()];
+            const nearBody = nearArr.length
+                ? `\n  NEAR-VIOLATIONS (invariants reachable via this radius — review before editing):\n${nearArr.map((n) => `    ⚠ ${n.c.id} [${n.c.severity}] ${n.c.statement}\n        via ${n.via}`).join("\n")}`
+                : "\n  No invariants in the blast radius.";
+            parts.push(`${file} → ${blast.length} dependent file(s)${blastBody}${nearBody}`);
+        }
+        return ok(`Blast radius for "${target}":\n\n${parts.join("\n\n")}`);
+    });
     // -- hunch_context (surgical retrieval) -----------------------------------
     server.registerTool("hunch_context", {
         title: "Assemble the minimal relevant Hunch slice for a task",

package/dist/store/embedder.js

@@ -48,7 +48,12 @@ export class TransformersEmbedder {
                 // pass) and onnxruntime warns to stderr, so the model load never writes to
                 // stdout — safe for the MCP JSON-RPC stdio channel without redirecting it.
                 const mod = (await import(pkg));
-                return (await mod.pipeline("feature-extraction", HF_MODEL));
+                // Pin dtype to fp32 (the lib's default for this model): silences the
+                // "dtype not specified … using the default dtype (fp32)" line the lib
+                // prints to stderr on every load (it leaked into `hunch query` output),
+                // and guarantees the numbers stay consistent with vectors already
+                // persisted under this model id — changing dtype would shift them.
+                return (await mod.pipeline("feature-extraction", HF_MODEL, { dtype: "fp32" }));
             })();
             this.extractor = p;
             // Never cache a REJECTED load: a transient failure (network blip during the

package/dist/store/hunchStore.js

@@ -337,6 +337,26 @@ export class HunchStore {
         }
         return id;
     }
+    /** Files whose symbols (in)directly DEPEND ON a symbol defined in `file` — the
+     *  blast radius of editing `file`, collapsed to file granularity (nearest depth
+     *  wins per file). Powers `hunch check` near-violation detection and `--blast`. */
+    blastRadiusFiles(file, maxDepth = 4) {
+        const syms = this.db.prepare(`SELECT id FROM symbols WHERE file = ?`).all(file);
+        const out = new Map();
+        for (const s of syms) {
+            for (const dep of this.getDependents(s.id, maxDepth)) {
+                if (!dep.id.startsWith("sym_"))
+                    continue;
+                const r = this.db.prepare(`SELECT name, file FROM symbols WHERE id=?`).get(dep.id);
+                if (!r || r.file === file)
+                    continue; // ignore self-file dependents
+                const prev = out.get(r.file);
+                if (!prev || dep.depth < prev.depth)
+                    out.set(r.file, { file: r.file, via: r.name, depth: dep.depth });
+            }
+        }
+        return [...out.values()].sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
+    }
     /** Constraints whose scope glob matches a path/glob (hunch_check_constraints). */
     checkConstraints(scope) {
         const all = this.json.loadAll("constraints");

package/dist/synthesis/synthesize.js

@@ -165,6 +165,43 @@ export async function recordFailure(store, root, failure) {
     raiseFragility(store, affectedFiles);
     return { status: "written", bug, constraint, provider: provider.name };
 }
+/** Orchestrate one `hunch test` run into graph writes: capture each failing test
+ *  as a Bug (recordFailure → suspects / recurrence / Constraint promotion), and
+ *  resolve any open Bug whose test now passes. Kept free of console I/O so the
+ *  whole capture→resolve→promote loop is unit-testable. Does NOT reindex — the
+ *  caller does, once. `status` is the runner's exit code (null if unknown). */
+export async function captureTestRun(store, root, input) {
+    const { report, status } = input;
+    // Unrecognized output that still failed → one coarse bug from the tail, rather
+    // than silently reporting success (the worst failure mode for a learning loop).
+    let failures = report.failures;
+    let fallback = false;
+    if (!report.recognized && status !== 0) {
+        const tail = input.output.trim().split(/\r?\n/).slice(-40).join("\n");
+        failures = [{ test: input.cmd, message: `Test run failed (exit ${status}); output not TAP/spec.\n${tail}` }];
+        fallback = true;
+    }
+    const results = [];
+    for (const f of failures) {
+        const r = await recordFailure(store, root, f);
+        results.push({ bug: r.bug, constraint: r.constraint });
+    }
+    let sha = null;
+    try {
+        sha = headSha(root);
+    }
+    catch { /* not a git repo / no HEAD — leave null */ }
+    const fixed = [];
+    for (const name of report.passed) {
+        const b = store.json.get("bugs", bugId(name));
+        if (b && b.status === "open") {
+            const resolved = { ...b, status: "fixed", lineage: { ...b.lineage, fixed_commit: sha } };
+            store.json.put("bugs", resolved);
+            fixed.push(resolved);
+        }
+    }
+    return { results, fixed, fallback };
+}
 /** Whether a bug should auto-promote a regression Constraint (a do-not-break
  *  invariant). A recurrence always does. Otherwise it must be high/critical AND
  *  substantiated by a real root cause — a bare severity label with no analysis

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.1.1",
+  "version": "0.5.0",
   "license": "MIT",
   "author": "Dave Sheffer <dave.sheffer1@gmail.com>",
   "description": "Hunch — an Engineering Memory OS: a persistent, git-native reasoning graph over a codebase, exposed to Claude Code via MCP.",