@davesheffer/hunch 1.4.2 → 1.6.0

package/dist/cli/index.js

@@ -29,7 +29,7 @@ import { indexRepo } from "../extractors/indexer.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, asOfDate, stagedDiff, commitDiff, rangeFiles, rangeDiff, rangeSubjects, revExists, commitAndPushHunch, pullHunch, gitUntrackCached, gitCommonDir, isLinkedWorktree, mainWorktreeRoot } from "../extractors/git.js";
+import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, workingFiles, commitFiles, asOfDate, stagedDiff, workingDiff, commitDiff, rangeFiles, rangeDiff, rangeSubjects, revExists, commitAndPushHunch, pullHunch, gitUntrackCached, gitCommonDir, isLinkedWorktree, mainWorktreeRoot } from "../extractors/git.js";
 import { writeTeamConfig, ensureTeamOverlay, readTeamConfig } from "../integrations/team.js";
 import { runbookId, decisionId } from "../core/ids.js";
 import { deriveForbids, effectiveForbids } from "../core/constraintmatch.js";
@@ -50,8 +50,10 @@ import { formatContext, formatStructure } from "../core/format.js";
 import { readConfig, writeConfig, FIRMNESS_LEVELS, isFirmness } from "../core/config.js";
 import { blockingInScope, vetoInScope, proposedEditLines } from "../core/hookpolicy.js";
 import { injectionMode } from "../core/hookcache.js";
+import { contextHookOutput, denyHookOutput, hookProvider, normalizeHookEvent, stopHookOutput } from "../core/agenthook.js";
 import { PIPELINE_LOOP, UNVERIFIED_NAG, loadPipelineState, onCommand, onEdit, onPrompt, onSkill, pipelineEnabled, savePipelineState, stopVerdict, } from "../core/pipeline.js";
 import { draftDuplicateOf } from "../core/dupdetect.js";
+import { planAutoReview, planMutations } from "../core/autoreview.js";
 import { loadGoldenSet, evaluateGraphLift } from "../eval/harness.js";
 import { loadGuardCases, evalGuards, generateGuardCases } from "../eval/guards.js";
 import { computeDrift } from "../core/drift.js";
@@ -68,6 +70,7 @@ import { mergeHunchJson } from "../store/merge.js";
 import { movePublicMemoryToPrivate } from "../store/privateMigrate.js";
 import { ENTITY_KINDS } from "../core/types.js";
 import { planCompaction } from "../store/compact.js";
+import { repairDecisionReference } from "../core/refrepair.js";
 import { resolveInvocation } from "./invocation.js";
 const program = new Command();
 program.name("hunch").description("Hunch — an Engineering Memory OS: a git-native reasoning graph for your codebase.").version(HUNCH_VERSION);
@@ -81,12 +84,12 @@ function storeFor() {
 // ---- init -----------------------------------------------------------------
 program
     .command("init")
-    .description("Scaffold .hunch/, index the repo, install the git hook, and wire up your coding assistants (Claude Code, Cursor, VS Code, Windsurf, Codex).")
+    .description("Scaffold .hunch/, index the repo, install the git hook, and wire up your coding assistants (Claude Code, Cursor, VS Code, Windsurf, Antigravity, Codex).")
     .option("--no-index", "skip the initial repo index")
     .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 direct, high-confidence, non-stale blocking invariant")
-    .option("--no-providers", "skip scaffolding non-Claude assistant configs (Cursor / VS Code / Codex / AGENTS.md)")
-    .option("--no-agent-hooks", "skip installing the Claude Code agent hooks (.claude/settings.json)")
+    .option("--no-providers", "skip scaffolding non-Claude assistant configs (Cursor / VS Code / Windsurf / Antigravity / Codex / AGENTS.md)")
+    .option("--no-agent-hooks", "skip installing all assistant lifecycle hooks (MCP + grounding are still configured)")
     .option("--firmness <level>", "agent-hook firmness: off | advisory | firm | strict")
     .option("--private-sync", "post-commit synthesis writes captured decisions into the overlay repo (HUNCH_PRIVATE_DIR), never the public store")
     .option("--shared-sync", "alias of --private-sync (for teams using one shared overlay repo for any code repo)")
@@ -138,7 +141,7 @@ program
     }
     if (isGitRepo(root)) {
         const syncToOverlay = !!(opts.privateSync || opts.sharedSync);
-        const h = installPostCommitHook(root, inv.shell, { private: syncToOverlay, commit: opts.autoCommit });
+        const h = installPostCommitHook(root, inv.shell, { private: syncToOverlay, commit: opts.autoCommit, localOnly: syncToOverlay });
         console.log(`  ✓ post-commit hook ${h.action} (learning loop)${syncToOverlay ? " — syncs to the shared overlay" : ""}${opts.autoCommit ? " — auto-commit on" : ""}`);
         const m = installMergeDriver(root, inv.shell);
         console.log(`  ✓ team merge driver ${m.action}`);
@@ -172,16 +175,16 @@ program
     // Firmness: stamp .hunch/config.json (default advisory) so `hunch hook` reads a
     // level even before the user runs `hunch firmness` (--firmness validated above).
     const firmness = writeConfig(paths, opts.firmness ? { firmness: opts.firmness } : {}).firmness;
-    // Agent hooks: ground the assistant in Hunch automatically (PreToolUse injects
-    // context before edits; UserPromptSubmit reminds). Reads firmness at run time.
+    // Claude's native hooks run alongside provider-specific hooks below. Every
+    // adapter reads firmness at run time, so changing it needs no config rewrite.
     if (opts.agentHooks !== false) {
         const a = installClaudeHooks(root, `${inv.shell} hook`);
         console.log(`  ✓ Claude Code agent hooks ${a.action} (firmness: ${firmness} — change with \`hunch firmness <level>\`)`);
     }
-    // Multi-assistant compatibility: the MCP server is client-agnostic, so wire up
-    // Cursor / VS Code (Copilot) / Codex / AGENTS.md to the same .hunch/ graph.
+    // Multi-assistant compatibility: MCP + grounding + lifecycle adapters share
+    // the same .hunch/ graph across Cursor / VS Code / Windsurf / Antigravity.
     if (opts.providers !== false) {
-        const ps = scaffoldProviders(root, inv.mcp, store);
+        const ps = scaffoldProviders(root, inv.mcp, store, { agentHooks: opts.agentHooks !== false });
         const ok = ps.filter((p) => !p.error);
         const total = ok.reduce((a, p) => a + p.files.length, 0);
         console.log(`  ✓ wrote ${total} multi-assistant config file(s) → ${ok.map((p) => p.assistant).join(", ")}`);
@@ -320,7 +323,16 @@ program
         return opts.quiet ? undefined : fail("--private/--overlay needs HUNCH_PRIVATE_DIR set to an overlay store");
     }
     store.json.ensureDirs();
-    const r = await syncCommit(store, root, sha ?? headSha(root), { force: opts.force, private: toOverlay, deep: opts.deep, verify: opts.verify, samples: parseSamples(opts.samples) });
+    const r = await syncCommit(store, root, sha ?? headSha(root), {
+        force: opts.force,
+        private: toOverlay,
+        // A split-private overlay is sensitive/local by definition. A shared store
+        // is an explicit team policy and may keep its configured synthesis provider.
+        localOnly: toOverlay && store.mode === "private",
+        deep: opts.deep,
+        verify: opts.verify,
+        samples: parseSamples(opts.samples),
+    });
     if (r.status === "written") {
         store.reindex();
         // Don't rewrite grounding from the hook — it would dirty the working tree on
@@ -455,7 +467,7 @@ function configureOverlay(dir, opts, mode) {
     // 4) route post-commit synthesis to the overlay (local hook, never committed)
     let hookNote = "";
     if (opts.hook && isGitRepo(root)) {
-        const h = installPostCommitHook(root, inv.shell, { private: true, commit: opts.autoCommit });
+        const h = installPostCommitHook(root, inv.shell, { private: true, commit: opts.autoCommit, localOnly: mode === "private" });
         hookNote = `  ✓ post-commit hook ${h.action} — captured decisions route here${opts.autoCommit ? " (auto-commit+push on)" : ""}\n`;
     }
     // 5) one-time migration: MOVE existing public memory INTO the overlay, then make
@@ -1047,16 +1059,24 @@ program
     .description("Capture a Bug from a failing test (symptom + suspect ranking).")
     .requiredOption("--test <id>", "failing test id/name")
     .requiredOption("--message <msg>", "failure message / stack")
+    .option("--private", "keep the bug and its failure text in the private overlay; uses deterministic local synthesis")
     .action(async (opts) => {
     const { store, root } = storeFor();
+    if (opts.private && !store.hasPrivate) {
+        store.close();
+        return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
+    }
     store.json.ensureDirs();
-    const r = await recordFailure(store, root, { test: opts.test, message: opts.message });
+    const r = await recordFailure(store, root, { test: opts.test, message: opts.message }, { private: opts.private });
     store.reindex();
-    console.log(`✓ recorded bug ${r.bug.id} via ${r.provider}: "${r.bug.title}"`);
+    const flush = flushCapture(store, hunchPaths(root).hunch, !!opts.private, `hunch: capture ${r.bug.id}`);
+    console.log(`✓ recorded bug ${r.bug.id} via ${r.provider}: "${r.bug.title}"${opts.private ? " [private overlay; local-only synthesis]" : ""}`);
     if (r.bug.lineage.recurrence_of)
         console.log(`  ↳ recurrence of ${r.bug.lineage.recurrence_of}`);
     if (r.constraint)
         console.log(`  ↳ promoted constraint ${r.constraint.id} [${r.constraint.severity}]: ${r.constraint.statement}`);
+    if (flush === "pushed")
+        console.log("  ↳ private memory committed + pushed");
     store.close();
 });
 // ---- record-constraint (human-authored invariant) -------------------------
@@ -1073,11 +1093,16 @@ program
     .option("--forbid-dep <names>", "comma-sep imports that BREAK the rule (parsed-import precise; e.g. lodash) — blocks the real violation, immune to staleness")
     .option("--forbid-symbol <names>", "comma-sep identifier names that break the rule")
     .option("--match <regex>", "textual line regex (lint-grade last resort; prefer --forbid-dep/--forbid-symbol)")
+    .option("--private", "write the invariant into the private overlay (local enforcement only; never included in public CI output)")
     .action((statement, opts) => {
     const SEV = ["advisory", "warning", "blocking"];
     if (!SEV.includes(opts.severity))
         return fail(`--severity must be one of: ${SEV.join(", ")}`);
     const { store, root } = storeFor();
+    if (opts.private && !store.hasPrivate) {
+        store.close();
+        return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
+    }
     store.json.ensureDirs();
     const scope = opts.scope.split(",").map((s) => toPosixTarget(s.trim())).filter(Boolean);
     const csv = (s) => (s ? s.split(",").map((x) => x.trim()).filter(Boolean) : []);
@@ -1107,10 +1132,14 @@ program
         valid_from: new Date().toISOString(),
         valid_to: null,
         provenance: { source: "human_confirmed", confidence: 1, evidence: [], last_verified: new Date().toISOString() },
-    });
+    }, opts.private);
     store.reindex();
-    refreshExistingGrounding(root, store); // keep EVERY assistant's grounding current, not just CLAUDE.md
-    console.log(`✓ recorded ${c.severity} constraint ${c.id}: "${c.statement}" (scope: ${scope.join(", ") || "repo"})`);
+    // Public grounding is a publishable artifact. Private rules stay local and
+    // are surfaced by local checks/MCP, never copied into committed agent docs.
+    if (store.captureHome(!!opts.private) === "public")
+        refreshExistingGrounding(root, store);
+    const flush = flushCapture(store, hunchPaths(root).hunch, !!opts.private, `hunch: capture ${c.id}`);
+    console.log(`✓ recorded ${c.severity} constraint ${c.id}: "${c.statement}" (scope: ${scope.join(", ") || "repo"})${opts.private ? " [private overlay]" : ""}`);
     if (derived && c.forbids?.deps.length)
         console.log(`  ↳ matcher: forbids import of ${c.forbids.deps.join(", ")} (precise, immune to staleness)`);
     if (c.severity === "blocking" && !effectiveForbids(c)) {
@@ -1119,6 +1148,8 @@ program
         console.log(`  ⚠ scope-only — this will downgrade to advisory once a file in scope is changed after today.`);
         console.log(`    To block the actual violation across the file's life, add  --forbid-dep <pkg>  (or --forbid-symbol / --match).`);
     }
+    if (flush === "pushed")
+        console.log("  ↳ private memory committed + pushed");
     store.close();
 });
 // ---- test (failure-learning loop) -----------------------------------------
@@ -1127,8 +1158,13 @@ program
     .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")
+    .option("--private", "keep captured test failures in the private overlay and use deterministic local synthesis")
     .action(async (cmd, opts) => {
     const { store, root } = storeFor();
+    if (opts.private && !store.hasPrivate) {
+        store.close();
+        return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
+    }
     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
@@ -1155,7 +1191,7 @@ program
         store.close();
         return;
     }
-    const cap = await captureTestRun(store, root, { report, status: run.status, cmd: cmdStr, output });
+    const cap = await captureTestRun(store, root, { report, status: run.status, cmd: cmdStr, output, private: opts.private });
     for (const { bug, constraint } of cap.results) {
         if (constraint)
             console.log(`  ⚠ ${bug.id} "${bug.title}" → promoted constraint ${constraint.id} [${constraint.severity}]`);
@@ -1165,6 +1201,8 @@ program
     for (const b of cap.fixed)
         console.log(`  ✓ ${b.id} "${b.title}" → fixed (test passing)`);
     store.reindex();
+    if (cap.results.length || cap.fixed.length)
+        flushCapture(store, hunchPaths(root).hunch, !!opts.private, `hunch: capture test results`);
     store.close();
     const recurrences = cap.results.filter((r) => r.bug.lineage.recurrence_of).length;
     const promoted = cap.results.filter((r) => r.constraint).length;
@@ -1229,6 +1267,7 @@ program
     .command("check")
     .description("Flag changes that touch a do-not-break invariant — the local guardrail AND the CI/PR Constraint Guard. Also flags (advisory) symbols you add that already exist elsewhere — possible re-implementation/sprawl.")
     .option("--staged", "check git staged files (default)")
+    .option("--working", "check all working-tree edits vs HEAD (staged, unstaged, and untracked files)")
     .option("--commit <sha>", "check a specific commit's files")
     .option("--base <ref>", "check a PR/branch: files changed vs <ref> (e.g. origin/main) — for CI")
     .option("--strict", "exit non-zero ONLY on a direct, high-confidence, non-stale blocking invariant (near/stale/low-confidence stay advisory)")
@@ -1236,9 +1275,9 @@ program
     .option("--blast", "also print the dependency blast radius of the changed files")
     .option("--public-only", "exclude the private overlay (HUNCH_PRIVATE_DIR) from the report — use for any output that may be posted publicly (the CI PR comment passes this)")
     .action((opts) => {
-    const sources = [opts.commit && "--commit", opts.base && "--base", opts.staged && "--staged"].filter(Boolean);
+    const sources = [opts.commit && "--commit", opts.base && "--base", opts.staged && "--staged", opts.working && "--working"].filter(Boolean);
     if (sources.length > 1)
-        return fail(`pick one of --staged / --commit / --base (got ${sources.join(", ")})`);
+        return fail(`pick one of --staged / --working / --commit / --base (got ${sources.join(", ")})`);
     const markdown = opts.format === "markdown";
     const emptyReport = { fileCount: 0, strict: !!opts.strict, direct: [], near: [], regressions: [], vetoes: [], redundant: [], strictBlockers: 0, regBlocking: 0, vetoBlocking: 0 };
     const { store, root } = storeFor();
@@ -1251,7 +1290,8 @@ program
     store.reindex(); // blast radius walks the edge graph — make the index current
     const files = opts.commit ? commitFiles(opts.commit, root)
         : opts.base ? rangeFiles(opts.base, root)
-            : stagedFiles(root);
+            : opts.working ? workingFiles(root)
+                : stagedFiles(root);
     if (!files.length) {
         console.log(markdown ? renderMarkdown(emptyReport) : "No changed files to check.");
         store.close();
@@ -1261,7 +1301,7 @@ program
     // code) + REDUNDANT (adds a symbol already defined elsewhere — advisory) + the
     // hardened strict gate + causal `why` citations — all assembled by the shared
     // store.buildCheckReport (also used by the hunch_merge_verdict tool).
-    const diff = opts.commit ? commitDiff(opts.commit, root) : opts.base ? rangeDiff(opts.base, root) : stagedDiff(root);
+    const diff = opts.commit ? commitDiff(opts.commit, root) : opts.base ? rangeDiff(opts.base, root) : opts.working ? workingDiff(root) : stagedDiff(root);
     const report = store.buildCheckReport(files, diff, {
         strict: !!opts.strict,
         lastChange: (f) => lastChangeDate(f, root),
@@ -1488,7 +1528,7 @@ program
 // ---- firmness (agent-hook enforcement level) ------------------------------
 program
     .command("firmness")
-    .description("Get or set how firmly the Claude Code agent hook enforces Hunch before edits.")
+    .description("Get or set how firmly agent lifecycle hooks enforce Hunch before edits.")
     .argument("[level]", "off | advisory | firm | strict (omit to print the current level)")
     .action((level) => {
     const paths = hunchPaths(findRoot());
@@ -1501,7 +1541,7 @@ program
         return fail(`firmness must be one of: ${FIRMNESS_LEVELS.join(", ")}`);
     }
     const next = writeConfig(paths, { firmness: level }).firmness;
-    console.log(`✓ firmness set to ${next} (takes effect on the next edit — no Claude Code restart needed).`);
+    console.log(`✓ firmness set to ${next} (takes effect on the next agent edit — no restart needed).`);
 });
 // ---- status (enforcement readiness at a glance) ---------------------------
 program
@@ -1542,16 +1582,22 @@ program
     console.log("");
     store.close();
 });
-// ---- hook (Claude Code agent-hook handler) --------------------------------
+// ---- hook (multi-agent lifecycle hook handler) ----------------------------
 program
     .command("hook")
-    .description("Claude Code hook handler: inject relevant Hunch context before edits (and, at strict firmness, deny edits that hit a blocking invariant). Reads the hook event JSON on stdin.")
-    .action(async () => {
+    .description("Agent-agnostic hook handler: normalizes Claude, VS Code, Cursor, Windsurf, and Antigravity events into Hunch context and strict policy checks. Reads hook JSON on stdin.")
+    .option("--provider <provider>", "hook event dialect: claude | vscode | cursor | windsurf | antigravity", "claude")
+    .action(async (opts) => {
     // A hook MUST NEVER break the agent: on ANY error or unrecognized input we
     // emit nothing and exit 0 (the action defers to Claude Code's normal flow).
     let store = null;
     try {
-        const evt = JSON.parse(await readStdin());
+        const provider = hookProvider(opts.provider);
+        if (!provider)
+            return;
+        const evt = normalizeHookEvent(JSON.parse(await readStdin()), provider);
+        if (!evt)
+            return;
         const root = findRoot();
         const paths = hunchPaths(root);
         const firmness = readConfig(paths).firmness;
@@ -1581,7 +1627,7 @@ program
             const verdict = stopVerdict(st, firmness);
             if (verdict.block) {
                 savePipelineState(evt.session_id, verdict.state);
-                process.stdout.write(JSON.stringify({ decision: "block", reason: verdict.reason }));
+                emitStop(provider, verdict.reason);
             }
             return;
         }
@@ -1603,7 +1649,7 @@ program
             // different content, so it always comes through (dec_244397d920).
             if (injectionMode(evt.session_id, "prompt-reminder", text) === "delta")
                 return;
-            emitContext("UserPromptSubmit", text);
+            emitContext(provider, "UserPromptSubmit", text);
             return;
         }
         if (evt.hook_event_name === "SessionStart") {
@@ -1619,7 +1665,7 @@ program
                 if (!decisions.length) {
                     // Fresh graph: nothing to orient on, but the operating loop still ships.
                     if (pipelineEnabled())
-                        emitContext("SessionStart", PIPELINE_LOOP);
+                        emitContext(provider, "SessionStart", PIPELINE_LOOP);
                     return;
                 }
                 const L = [];
@@ -1639,7 +1685,13 @@ program
                 // (the zod bench showed ambient skills are read in ~0% of sessions).
                 if (pipelineEnabled())
                     L.push("", PIPELINE_LOOP);
-                emitContext("SessionStart", L.join("\n"));
+                const orientation = L.join("\n");
+                // Antigravity's nearest equivalent is PreInvocation, which can fire
+                // repeatedly in one conversation. Deduplicate it just like edit
+                // grounding so it remains an orientation, not a context flood.
+                if (provider === "antigravity" && injectionMode(evt.session_id, "orientation", orientation) === "delta")
+                    return;
+                emitContext(provider, "SessionStart", orientation);
             }
             finally {
                 s.close();
@@ -1671,7 +1723,7 @@ program
             const proposedLines = proposedEditLines(evt.tool_input);
             const deny = blockingInScope(store, target, proposedLines);
             if (deny) {
-                emitDeny(deny.reason);
+                emitDeny(provider, deny.reason);
                 return;
             }
             // Veto Guard (live): the proposed edit text re-introduces an approach an
@@ -1679,7 +1731,7 @@ program
             // only human-confirmed tripwires deny.
             const vetoDeny = proposedLines.length ? vetoInScope(store, target, proposedLines) : null;
             if (vetoDeny) {
-                emitDeny(vetoDeny.reason);
+                emitDeny(provider, vetoDeny.reason);
                 return;
             }
         }
@@ -1722,10 +1774,10 @@ program
         // the full 10-16KB block. Any record change re-sends the full text; the
         // strict-gate deny path above never routes through this (dec_244397d920).
         if (injectionMode(evt.session_id, `pre:${target}`, text) === "delta") {
-            emitContext("PreToolUse", `Hunch grounding for ${target}: unchanged this session (${ctx.decisions.length} decision(s), ${ctx.constraints.length} invariant(s) shown earlier — still current; hunch_why("${target}") to re-expand).`);
+            emitContext(provider, "PreToolUse", `Hunch grounding for ${target}: unchanged this session (${ctx.decisions.length} decision(s), ${ctx.constraints.length} invariant(s) shown earlier — still current; hunch_why("${target}") to re-expand).`);
             return;
         }
-        emitContext("PreToolUse", text);
+        emitContext(provider, "PreToolUse", text);
     }
     catch {
         // swallow — never block an edit on a hook failure
@@ -1774,29 +1826,40 @@ program
     .option("--accept-verified", "batch-accept every Critic-verified, well-grounded draft (>= --min-grounded)")
     .option("--reject-duplicates", "batch-reject drafts that near-duplicate an accepted record (deterministic term+file similarity — hygiene, not judgment)")
     .option("--min-grounded <n>", "grounded-ness threshold for the ready group / --accept-verified", String(READY_MIN_GROUNDED))
+    .option("--private", "include local private/shared-overlay drafts; terminal output may contain private memory")
     .action((opts) => {
     const { store, root } = storeFor();
     const minGrounded = Number.isFinite(Number(opts.minGrounded)) ? Number(opts.minGrounded) : READY_MIN_GROUNDED;
+    if (opts.private && !store.hasPrivate) {
+        store.close();
+        return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
+    }
+    const decisions = () => opts.private ? store.recs("decisions") : store.json.loadAll("decisions");
+    let publicGroundingChanged = false;
     if (opts.accept) {
-        const d = store.json.get("decisions", opts.accept);
+        const d = opts.private ? store.getRec("decisions", opts.accept) : store.json.get("decisions", opts.accept);
         if (!d) {
             store.close();
             return fail(`decision ${opts.accept} not found`);
         }
+        const inPrivate = !!store.getPrivateRec("decisions", d.id);
         const { source, armed } = acceptDecision(store, d);
         store.reindex();
-        refreshExistingGrounding(root, store); // confirming a rule must reach EVERY assistant's grounding
+        if (!inPrivate) {
+            refreshExistingGrounding(root, store);
+            publicGroundingChanged = true;
+        }
         console.log(`✓ accepted ${opts.accept} (now ${source}, confidence 0.95${armed ? `, ${armed} tripwire(s) now blocking` : ""})`);
     }
     else if (opts.reject) {
-        const ok2 = store.json.delete("decisions", opts.reject);
+        const ok2 = opts.private ? store.deleteWhereItLives("decisions", opts.reject) : store.json.delete("decisions", opts.reject);
         store.reindex();
         console.log(ok2 ? `✓ rejected and removed ${opts.reject}` : `decision ${opts.reject} not found`);
     }
     else if (opts.rejectDuplicates) {
         // Deterministic hygiene, not a trust decision (dec_a466655539 stays intact):
         // only drafts, only against ACCEPTED records, conservative threshold.
-        const all = store.json.loadAll("decisions");
+        const all = decisions();
         const drafts = all.filter((d) => d.status === "proposed" && !d.provenance.source.includes("human_confirmed"));
         const dupes = drafts
             .map((d) => ({ d, m: draftDuplicateOf(d, all) }))
@@ -1807,7 +1870,7 @@ program
         else {
             let removed = 0;
             for (const { d, m } of dupes) {
-                if (store.json.delete("decisions", d.id))
+                if ((opts.private ? store.deleteWhereItLives("decisions", d.id) : store.json.delete("decisions", d.id)))
                     removed++;
                 console.log(`  ✗ ${d.id} — "${d.title}"\n      duplicate of ${m.of.id} — "${m.of.title}" (${Math.round(m.score * 100)}%)`);
             }
@@ -1818,24 +1881,28 @@ program
     else if (opts.acceptVerified) {
         // Batch path: only Critic-verified, well-grounded drafts qualify — still the
         // human-driven accept gate (the operator runs this), just over a safe subset.
-        const proposed = store.json.loadAll("decisions").filter((d) => d.status === "proposed");
+        const proposed = decisions().filter((d) => d.status === "proposed");
         const { ready } = partitionReview(proposed, minGrounded);
         if (!ready.length) {
             console.log(`✓ No Critic-verified drafts at grounded ≥ ${minGrounded} to batch-accept.`);
         }
         else {
             let armedTotal = 0;
-            for (const it of ready)
+            for (const it of ready) {
+                if (!store.getPrivateRec("decisions", it.d.id))
+                    publicGroundingChanged = true;
                 armedTotal += acceptDecision(store, it.d).armed;
+            }
             store.reindex();
-            refreshExistingGrounding(root, store); // batch-confirm must reach EVERY assistant's grounding
+            if (publicGroundingChanged)
+                refreshExistingGrounding(root, store); // committed grounding stays public-only
             console.log(`✓ accepted ${ready.length} verified draft(s); ${armedTotal} tripwire(s) now blocking.`);
             for (const it of ready)
                 console.log(`   ${it.d.id}  grounded=${it.synth.grounded ?? "?"}  ${it.d.title}`);
         }
     }
     else {
-        const drafts = store.json.loadAll("decisions").filter((d) => d.status === "proposed" || d.provenance.confidence < 0.6);
+        const drafts = decisions().filter((d) => d.status === "proposed" || d.provenance.confidence < 0.6);
         const { ready, scrutiny } = partitionReview(drafts, minGrounded);
         if (!ready.length && !scrutiny.length) {
             console.log("✓ No low-confidence drafts to review.");
@@ -1849,7 +1916,7 @@ program
             }
             if (scrutiny.length) {
                 console.log(`⚠ ${scrutiny.length} need scrutiny — unverified / low-grounded (lowest confidence first):\n`);
-                const all = store.json.loadAll("decisions");
+                const all = decisions();
                 let dupCount = 0;
                 for (const it of scrutiny) {
                     printReviewItem(it);
@@ -1867,6 +1934,109 @@ program
     }
     store.close();
 });
+// ---- auto-review (harness-driven triage) ----------------------------------
+/** One line per plan entry. */
+function printAutoEntry(e) {
+    console.log(`  ${e.d.id}  ${e.d.title.slice(0, 66)}\n      ${dim(e.reason)}`);
+}
+program
+    .command("auto-review")
+    .description("Harness-driven draft triage: delegate relevance to the coding-assistant CLI, then dedup, auto-confirm the verified+relevant, and delete duplicates/irrelevant. Dry-run unless --apply.")
+    .option("--apply", "execute the plan (accept/delete). Without it, print the plan and change nothing.")
+    .option("--min-grounded <n>", "grounded-ness threshold for the auto-accept gate", String(READY_MIN_GROUNDED))
+    .option("--min-reject-confidence <n>", "minimum harness confidence to DELETE an irrelevant draft (else kept for a human)", "0.7")
+    .option("--no-llm", "skip the harness judgment (dedup + grounding only — no relevance deletion)")
+    .option("--private", "include local private/shared-overlay drafts; private drafts are never sent to an LLM judge")
+    .action(async (opts) => {
+    const { store, root } = storeFor();
+    try {
+        if (opts.private && !store.hasPrivate)
+            return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
+        const minGrounded = Number.isFinite(Number(opts.minGrounded)) ? Number(opts.minGrounded) : READY_MIN_GROUNDED;
+        const minRejectConfidence = Number.isFinite(Number(opts.minRejectConfidence)) ? Number(opts.minRejectConfidence) : 0.7;
+        const all = opts.private ? store.recs("decisions") : store.json.loadAll("decisions");
+        // Same draft set `hunch review` / `hunch status` triage.
+        const drafts = all.filter((d) => d.status === "proposed" || d.provenance.confidence < 0.6);
+        if (!drafts.length) {
+            console.log("✓ No drafts to auto-review.");
+            return;
+        }
+        // Delegate relevance to the harness (subscription CLI) — feature-detected,
+        // and any per-draft failure degrades to "not judged" (kept for a human).
+        const verdicts = new Map();
+        if (opts.llm !== false && !opts.private) {
+            const provider = await selectProvider();
+            if (provider.judgeDraft) {
+                // The candidate pool for duplicate_of / restatement: the LIVE, vouched records.
+                const existing = all
+                    .filter((d) => d.provenance.source.includes("human_confirmed") && d.status !== "superseded" && d.status !== "rejected")
+                    .map((d) => ({ id: d.id, title: d.title, decision: d.decision }));
+                console.log(`Judging ${drafts.length} draft(s) via ${provider.name} (subscription)…`);
+                for (const d of drafts) {
+                    try {
+                        verdicts.set(d.id, await provider.judgeDraft(d, existing.filter((e) => e.id !== d.id)));
+                    }
+                    catch {
+                        /* transient / unparseable — leave unjudged, planner keeps it for a human */
+                    }
+                }
+            }
+            else {
+                console.log(dim("No subscription CLI available — relevance judgment skipped (dedup + grounding only)."));
+            }
+        }
+        else if (opts.private && opts.llm !== false) {
+            console.log(dim("Private review stays local — harness judgment skipped (dedup + grounding only)."));
+        }
+        const plan = planAutoReview(drafts, all, verdicts, { minGrounded, minRejectConfidence });
+        printAutoReviewPlan(plan);
+        if (!opts.apply) {
+            const n = planMutations(plan);
+            console.log(`\n${dim(`Dry run — nothing changed. Re-run with --apply to ${n ? `apply ${n} change(s)` : "confirm (no changes)"}.`)}`);
+            return;
+        }
+        // Apply: accept the verified+relevant, delete duplicates + irrelevant.
+        let accepted = 0, deleted = 0, armedTotal = 0, publicAccepted = false;
+        for (const e of plan.accept) {
+            if (!store.getPrivateRec("decisions", e.d.id))
+                publicAccepted = true;
+            armedTotal += acceptDecision(store, e.d).armed;
+            accepted++;
+        }
+        for (const e of [...plan.rejectDuplicate, ...plan.rejectIrrelevant]) {
+            if ((opts.private ? store.deleteWhereItLives("decisions", e.d.id) : store.json.delete("decisions", e.d.id)))
+                deleted++;
+        }
+        if (accepted || deleted) {
+            store.reindex();
+            if (publicAccepted)
+                refreshExistingGrounding(root, store); // committed grounding stays public-only
+        }
+        console.log(`\n✓ auto-review applied: ${accepted} accepted${armedTotal ? ` (${armedTotal} tripwire(s) now blocking)` : ""}, ${deleted} deleted, ${plan.keep.length} kept for review.`);
+    }
+    finally {
+        store.close();
+    }
+});
+/** Print the four buckets of an auto-review plan (skipping empty ones). */
+function printAutoReviewPlan(plan) {
+    if (plan.accept.length) {
+        console.log(`\n✓ ACCEPT — verified, grounded, harness-relevant (${plan.accept.length}):`);
+        plan.accept.forEach(printAutoEntry);
+    }
+    if (plan.rejectDuplicate.length) {
+        console.log(`\n✗ DELETE (duplicate) — restates an accepted record (${plan.rejectDuplicate.length}):`);
+        plan.rejectDuplicate.forEach(printAutoEntry);
+    }
+    if (plan.rejectIrrelevant.length) {
+        console.log(`\n✗ DELETE (irrelevant) — harness judged not worth keeping (${plan.rejectIrrelevant.length}):`);
+        plan.rejectIrrelevant.forEach(printAutoEntry);
+    }
+    if (plan.keep.length) {
+        console.log(`\n⏳ KEEP for human review (${plan.keep.length}):`);
+        plan.keep.forEach(printAutoEntry);
+    }
+}
 // ---- mcp ------------------------------------------------------------------
 program
     .command("mcp")
@@ -2014,23 +2184,24 @@ program
     .description("PR impact: the dependency + memory surface of a change — dependent files reached, invariants direct/near, and the decisions concerned. Read-only, advisory (gating is `hunch check`). Omit base and --commit to inspect staged changes.")
     .argument("[base]", "diff against this base ref (e.g. origin/main) for a branch/PR")
     .option("--commit <sha>", "impact of a single commit")
+    .option("--working", "impact all working-tree edits vs HEAD (staged, unstaged, and untracked files)")
     .action((base, opts) => {
     const { store, root } = storeFor();
     try {
-        if (base && opts.commit)
-            return fail("Pass at most one of [base] / --commit.");
+        if ((base && opts.commit) || (opts.working && (base || opts.commit)))
+            return fail("Pass exactly one of [base] / --commit / --working (or omit all for staged changes).");
         if (base && !revExists(base, root))
             return fail(`base ref "${base}" does not resolve.`);
         if (opts.commit && !revExists(opts.commit, root))
             return fail(`commit "${opts.commit}" does not resolve.`);
         store.reindex(); // reflect out-of-band JSON edits before reading the graph
-        const files = opts.commit ? commitFiles(opts.commit, root) : base ? rangeFiles(base, root) : stagedFiles(root);
-        const scope = opts.commit ? `commit ${opts.commit}` : base ? `${base}..HEAD` : "staged changes";
+        const files = opts.commit ? commitFiles(opts.commit, root) : base ? rangeFiles(base, root) : opts.working ? workingFiles(root) : stagedFiles(root);
+        const scope = opts.commit ? `commit ${opts.commit}` : base ? `${base}..HEAD` : opts.working ? "working changes" : "staged changes";
         if (!files.length) {
             console.log(`No changed files in ${scope}.`);
             return;
         }
-        const diff = opts.commit ? commitDiff(opts.commit, root) : base ? rangeDiff(base, root) : stagedDiff(root);
+        const diff = opts.commit ? commitDiff(opts.commit, root) : base ? rangeDiff(base, root) : opts.working ? workingDiff(root) : stagedDiff(root);
         console.log(renderImpact(store.prImpact(files, diff), scope));
     }
     finally {
@@ -2238,6 +2409,38 @@ program
         store.close();
     }
 });
+// ---- repair-ref (atomic decision reference correction) --------------------
+program
+    .command("repair-ref")
+    .description("Atomically repair one exact file reference in a decision's scope and provenance evidence (never changes the decision itself).")
+    .argument("<decision>", "decision id containing the stale reference")
+    .requiredOption("--from <path>", "exact stale path to replace")
+    .requiredOption("--to <path>", "exact current path (use private:<path> for a private-overlay file)")
+    .option("--private", "require the decision to be in the configured private overlay")
+    .action((id, opts) => {
+    const { store } = storeFor();
+    try {
+        if (opts.from === opts.to)
+            return fail("--from and --to must be different paths");
+        if (opts.private && !store.hasPrivate)
+            return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
+        // `getRec` is deliberately overlay-first. An explicit --private prevents a
+        // same-id public record from being silently amended instead of private memory.
+        const d = opts.private ? store.getPrivateRec("decisions", id) : store.getRec("decisions", id);
+        if (!d)
+            return fail(`decision "${id}" not found${opts.private ? " in the private overlay" : ""}`);
+        const repaired = repairDecisionReference(d, opts.from, opts.to);
+        if (!repaired)
+            return fail(`decision "${id}" does not contain the exact reference "${opts.from}"`);
+        store.putWhereItLives("decisions", repaired.decision);
+        store.reindex();
+        console.log(`✓ repaired ${id}: ${repaired.relatedFiles} related file reference(s) + ${repaired.evidence} provenance evidence reference(s).`);
+        console.log(`  ${opts.from} → ${opts.to}`);
+    }
+    finally {
+        store.close();
+    }
+});
 // ---- compact (bound Hunch growth) -----------------------------------------
 program
     .command("compact")
@@ -2467,13 +2670,22 @@ function realpathNorm(p) {
 function toRepoRel(root, abs) {
     return relative(realpathNorm(root), realpathNorm(abs)).split("\\").join("/");
 }
-function emitContext(event, text) {
-    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: text } }));
+function emitContext(provider, event, text) {
+    const output = contextHookOutput(provider, event, text);
+    if (output)
+        process.stdout.write(JSON.stringify(output));
 }
-function emitDeny(reason) {
-    process.stdout.write(JSON.stringify({
-        hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason },
-    }));
+function emitDeny(provider, reason) {
+    const result = denyHookOutput(provider, reason);
+    if (result.output)
+        process.stdout.write(JSON.stringify(result.output));
+    if (result.stderr)
+        process.stderr.write(`${result.stderr}\n`);
+    if (result.exitCode !== undefined)
+        process.exitCode = result.exitCode;
+}
+function emitStop(provider, reason) {
+    process.stdout.write(JSON.stringify(stopHookOutput(provider, reason)));
 }
 program.parseAsync().catch((e) => {
     try {