@davesheffer/hunch 0.19.1 → 0.20.0

package/dist/cli/index.js

@@ -30,6 +30,7 @@ import { parseTestReport } from "../extractors/testreport.js";
 import { selectProvider } from "../synthesis/provider.js";
 import { isGitRepo, headSha, logSince, lastChangeDate, stagedFiles, commitFiles, asOfDate, stagedDiff, commitDiff, rangeFiles, rangeDiff, revExists, commitAndPushHunch } from "../extractors/git.js";
 import { renderText, renderMarkdown, reportFailsStrict } from "../core/checkreport.js";
+import { partitionReview, READY_MIN_GROUNDED } from "../core/reviewqueue.js";
 import { installPostCommitHook, installPreCommitHook } from "../integrations/hooks.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
 import { ensureGitignore } from "../integrations/gitignore.js";
@@ -950,63 +951,101 @@ program
     }
 });
 // ---- review (curate loop) -------------------------------------------------
+/** Promote a draft to accepted/human-confirmed and CONFIRM its drafted tripwires —
+ *  this is how the Veto Guard goes advisory → blocking ("confirm rides hunch review";
+ *  dec_a466655539). Returns the new source tag and how many tripwires can now actually
+ *  block (non-empty forbids) so bulk enforcement is never silent. */
+function acceptDecision(store, d) {
+    const source = d.provenance.source.includes("llm_draft") ? "llm_draft+human_confirmed" : "human_confirmed";
+    const now = new Date().toISOString();
+    const confirmedTws = (d.rejected_tripwires ?? []).map((tw) => ({
+        ...tw,
+        provenance: {
+            ...tw.provenance,
+            source: tw.provenance.source.includes("human_confirmed")
+                ? tw.provenance.source
+                : tw.provenance.source.includes("llm_draft")
+                    ? "llm_draft+human_confirmed"
+                    : "human_confirmed",
+            last_verified: now,
+        },
+    }));
+    store.json.put("decisions", { ...d, status: "accepted", rejected_tripwires: confirmedTws, provenance: { ...d.provenance, source, confidence: 0.95, last_verified: now } });
+    const armed = confirmedTws.filter((tw) => tw.forbids.deps.length || tw.forbids.symbols.length || tw.forbids.patterns.length).length;
+    return { source, armed };
+}
+/** Print one draft for the review listing: id/status/source/confidence, the Critic's
+ *  prune count (its visible value), the title, a decision snippet, and the raw synth line. */
+function printReviewItem(it) {
+    const { d, synth } = it;
+    const pruneNote = synth.pruned ? `  · Critic pruned ${synth.pruned} unsupported` : "";
+    const synthLine = synth.raw ? `\n      ↳ ${synth.raw}` : "";
+    console.log(`  ${d.id} [${d.status}, ${d.provenance.source} ${d.provenance.confidence}]${pruneNote}\n      ${d.title}\n      ${d.decision.slice(0, 120)}${synthLine}`);
+}
 program
     .command("review")
-    .description("Triage low-confidence drafts: list, accept (promote), or reject.")
-    .option("--accept <id>", "promote a decision to accepted/human-confirmed")
+    .description("Triage drafts: segmented list, accept/reject one, or batch-accept Critic-verified drafts.")
+    .option("--accept <id>", "promote a decision to accepted/human-confirmed (confirms its tripwires)")
     .option("--reject <id>", "delete a draft decision")
+    .option("--accept-verified", "batch-accept every Critic-verified, well-grounded draft (>= --min-grounded)")
+    .option("--min-grounded <n>", "grounded-ness threshold for the ready group / --accept-verified", String(READY_MIN_GROUNDED))
     .action((opts) => {
     const { store, root } = storeFor();
+    const minGrounded = Number.isFinite(Number(opts.minGrounded)) ? Number(opts.minGrounded) : READY_MIN_GROUNDED;
     if (opts.accept) {
         const d = store.json.get("decisions", opts.accept);
-        if (!d)
+        if (!d) {
+            store.close();
             return fail(`decision ${opts.accept} not found`);
-        const source = d.provenance.source.includes("llm_draft") ? "llm_draft+human_confirmed" : "human_confirmed";
-        const now = new Date().toISOString();
-        // Accepting a decision also CONFIRMS its drafted tripwires — this is how the
-        // Veto Guard goes from advisory to blocking ("confirm rides hunch review").
-        const tws = d.rejected_tripwires ?? [];
-        const confirmedTws = tws.map((tw) => ({
-            ...tw,
-            provenance: {
-                ...tw.provenance,
-                source: tw.provenance.source.includes("human_confirmed")
-                    ? tw.provenance.source
-                    : tw.provenance.source.includes("llm_draft")
-                        ? "llm_draft+human_confirmed"
-                        : "human_confirmed",
-                last_verified: now,
-            },
-        }));
-        store.json.put("decisions", { ...d, status: "accepted", rejected_tripwires: confirmedTws, provenance: { ...d.provenance, source, confidence: 0.95, last_verified: now } });
+        }
+        const { source, armed } = acceptDecision(store, d);
         store.reindex();
         updateClaudeMd(root, store);
-        const twNote = confirmedTws.length ? `, ${confirmedTws.length} tripwire(s) now blocking` : "";
-        console.log(`✓ accepted ${opts.accept} (now ${source}, confidence 0.95${twNote})`);
+        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);
         store.reindex();
         console.log(ok2 ? `✓ rejected and removed ${opts.reject}` : `decision ${opts.reject} not found`);
     }
+    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 { 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)
+                armedTotal += acceptDecision(store, it.d).armed;
+            store.reindex();
+            updateClaudeMd(root, store);
+            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)
-            .sort((a, b) => a.provenance.confidence - b.provenance.confidence);
-        if (!drafts.length) {
+        const drafts = store.json.loadAll("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.");
         }
         else {
-            console.log(`${drafts.length} draft(s) awaiting review (lowest confidence first):\n`);
-            for (const d of drafts) {
-                // Surface synthesis telemetry (provider / reconciliation breadth / verifier
-                // grounding) parked in evidence, so the reviewer sees WHY the confidence is
-                // what it is and can confirm or reject at a glance.
-                const synth = (d.provenance.evidence ?? []).find((e) => e.startsWith("synth:"));
-                const synthLine = synth ? `\n      ↳ ${synth.slice("synth:".length).trim()}` : "";
-                console.log(`  ${d.id} [${d.status}, ${d.provenance.source} ${d.provenance.confidence}]\n      ${d.title}\n      ${d.decision.slice(0, 120)}${synthLine}`);
+            if (ready.length) {
+                console.log(`✓ ${ready.length} ready to confirm — Critic-verified, grounded ≥ ${minGrounded} (best first):\n`);
+                for (const it of ready)
+                    printReviewItem(it);
+                console.log(`\n   Batch-confirm all: hunch review --accept-verified\n`);
+            }
+            if (scrutiny.length) {
+                console.log(`⚠ ${scrutiny.length} need scrutiny — unverified / low-grounded (lowest confidence first):\n`);
+                for (const it of scrutiny)
+                    printReviewItem(it);
             }
-            console.log(`\nAccept:  hunch review --accept <id>\nReject:  hunch review --reject <id>`);
+            console.log(`\nAccept: hunch review --accept <id>   Reject: hunch review --reject <id>`);
         }
     }
     store.close();

package/dist/core/reviewqueue.js

@@ -0,0 +1,49 @@
+/** Extract the `synth:` line out of a decision's evidence and parse its `k=v` fields. */
+export function parseSynth(evidence) {
+    const line = (evidence ?? []).find((e) => e.startsWith("synth:"));
+    if (!line)
+        return {};
+    const body = line.slice("synth:".length).trim();
+    const num = (k) => {
+        const m = new RegExp(`\\b${k}=(-?[0-9]*\\.?[0-9]+)`).exec(body);
+        return m ? Number(m[1]) : undefined;
+    };
+    const str = (k) => {
+        const m = new RegExp(`\\b${k}=([A-Za-z0-9_.\\-]+)`).exec(body);
+        return m ? m[1] : undefined;
+    };
+    return {
+        raw: body,
+        provider: str("provider"),
+        grounded: num("grounded"),
+        samples: num("samples"),
+        agreement: num("agreement"),
+        pruned: num("pruned"),
+        verify: str("verify"),
+    };
+}
+/** Grounded-ness at/above which a Critic-verified draft is a "quick yes". */
+export const READY_MIN_GROUNDED = 0.7;
+/** 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. */
+export function isReady(d, synth, minGrounded = READY_MIN_GROUNDED) {
+    return d.provenance.source.includes("verified") && (synth.grounded ?? 0) >= minGrounded;
+}
+/** Split review drafts into ready-to-confirm (best-grounded first) and needs-scrutiny
+ *  (lowest-confidence first). A draft is never in both groups. */
+export function partitionReview(drafts, minGrounded = READY_MIN_GROUNDED) {
+    const items = drafts.map((d) => ({
+        d,
+        synth: parseSynth(d.provenance.evidence),
+        verified: d.provenance.source.includes("verified"),
+    }));
+    const ready = items
+        .filter((it) => isReady(it.d, it.synth, minGrounded))
+        .sort((a, b) => (b.synth.grounded ?? 0) - (a.synth.grounded ?? 0));
+    const scrutiny = items
+        .filter((it) => !isReady(it.d, it.synth, minGrounded))
+        .sort((a, b) => a.d.provenance.confidence - b.d.provenance.confidence);
+    return { ready, scrutiny };
+}
+//# sourceMappingURL=reviewqueue.js.map

package/dist/synthesis/provider.js

@@ -636,11 +636,14 @@ function flaggedMatches(entry, flagged) {
 export function applyVerdict(draft, v) {
     const alternatives_rejected = draft.alternatives_rejected.filter((a) => !flaggedMatches(a, v.unsupported_alternatives));
     const consequences = draft.consequences.filter((c) => !flaggedMatches(c, v.unsupported_claims));
+    // The Critic's visible value: how many unsupported items it removed (alternatives
+    // never become tripwires; consequences never mislead). Surfaced in `hunch review`.
+    const pruned = (draft.alternatives_rejected.length - alternatives_rejected.length) + (draft.consequences.length - consequences.length);
     const grounded = clamp01(v.grounded);
     // Penalize weak grounding; (0.5 + 0.5*grounded) ∈ [0.5,1], so this only lowers.
     const confidence = Math.min(draft.confidence, Math.round(draft.confidence * (0.5 + 0.5 * grounded) * 100) / 100);
     const source = draft.source.includes("verified") ? draft.source : `${draft.source}+verified`;
-    return { ...draft, alternatives_rejected, consequences, confidence, grounded, source, verifyOutcome: "applied" };
+    return { ...draft, alternatives_rejected, consequences, confidence, grounded, source, verifyOutcome: "applied", pruned };
 }
 /** Run the Critic pass and apply it, degrading to the un-audited draft when the
  *  provider can't verify (deterministic / no CLI) or the call keeps failing. Never

package/dist/synthesis/synthesize.js

@@ -98,6 +98,8 @@ export async function syncCommit(store, root, sha, opts = {}) {
     // (unavailable / failed) so a skipped audit is never mistaken for a clean one.
     else if (draft.verifyOutcome && draft.verifyOutcome !== "applied")
         synthBits.push(`verify=${draft.verifyOutcome}`);
+    if (draft.pruned)
+        synthBits.push(`pruned=${draft.pruned}`); // the Critic's visible value
     const synthEvidence = `synth:${synthBits.join(" ")}`;
     const components = store.json.loadAll("components");
     const relatedComponents = components

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davesheffer/hunch",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "license": "Apache-2.0",
   "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.",