@davesheffer/hunch 1.39.0 → 1.39.2

package/dist/cli/index.js

@@ -40,7 +40,7 @@ import { assertCompleteRepoScan, indexRepo, scanRepo } from "../extractors/index
 import { syncCommit, recordFailure, captureTestRun } from "../synthesis/synthesize.js";
 import { parseTestReport } from "../extractors/testreport.js";
 import { readSynthesisPreference, resolveSynthesisProvider, selectProvider, SYNTH_PREFERENCES, writeSynthesisPreference, normalizeProviderName, } from "../synthesis/provider.js";
-import { isGitRepo, isGitRepoRoot, sameGitPublication, sameRemoteUrl, canonicalRemoteUrl, repositoryUsesRemote, headSha, isolatedHeadSha, logSince, lastChangeDate, firstCommitForFile, stagedFiles, workingFiles, commitFiles, asOfDate, stagedDiff, workingDiff, commitDiff, rangeFiles, rangeDiff, rangeSubjects, revExists, revParse, commitAndPushHunch, pullHunchStatus, syncExistingHunch, gitUntrackCached, gitCommonDir, hooksDir, isLinkedWorktree, mainWorktreeRoot, gitMemoryLog, memoryMoveDiff, revertMemoryMove, pushCurrentBranch, commitChanges, commitRepairStatus, mergeRangeChanges, commitsExist } from "../extractors/git.js";
+import { isGitRepo, isGitRepoRoot, sameGitPublication, sameRemoteUrl, canonicalRemoteUrl, repositoryUsesRemote, headSha, isolatedHeadSha, logSince, lastChangeDate, firstCommitForFile, stagedFiles, workingFiles, commitFiles, asOfDate, stagedGateDiff, workingGateDiff, commitGateDiff, rangeFiles, rangeGateDiff, rangeSubjects, revExists, revParse, commitAndPushHunch, pullHunchStatus, syncExistingHunch, gitUntrackCached, gitCommonDir, hooksDir, isLinkedWorktree, mainWorktreeRoot, gitMemoryLog, memoryMoveDiff, revertMemoryMove, pushCurrentBranch, commitChanges, commitRepairStatus, mergeRangeChanges, commitsExist } from "../extractors/git.js";
 import { parseMemoryLog } from "../core/memorylog.js";
 import { renamesOf, planRepair, repairDecision, repairConstraint } from "../core/repair.js";
 import { orphanedCommitDecisions, planCommitRepair, repairDecisionCommit, pickRewrite, commitRepairReviewHash, mergeRewrites, firstFor, deadRewrites, resolvedRewriteIds, withoutDropped, addDropped, withheldForUnresolvableTo } from "../core/commitrepair.js";
@@ -52,11 +52,11 @@ import { deriveForbids, effectiveForbids } from "../core/constraintmatch.js";
 import { extractInlineIntent } from "../extractors/comments.js";
 import { renderText, renderMarkdown, renderSarif, renderImpact, reportFailsStrict } from "../core/checkreport.js";
 import { partitionReview, isReviewDraft, READY_MIN_GROUNDED } from "../core/reviewqueue.js";
-import { installPostCommitHook, installPreCommitHook, installPostMergeHook, installPostCheckoutHook, hookStatus } from "../integrations/hooks.js";
+import { installPostCommitHook, installPreCommitHook, installPostMergeHook, installPostCheckoutHook, hookStatus, hookReport, formatHookInstall } from "../integrations/hooks.js";
 import { ensureSharedOverlayPointer } from "../integrations/worktree.js";
 import { flushCapture, flushMemoryHome, flushMemoryHomes, pinSharedRemote, sharedRemoteFor } from "../integrations/sync.js";
 import { installMergeDriver } from "../integrations/mergeDriver.js";
-import { ensureGitignore, ignoreHunchMemory, HUNCH_MEMORY_DIRS } from "../integrations/gitignore.js";
+import { ensureGitignore, ignoreHunchMemory, HUNCH_MEMORY_DIRS, upgradeManagedGitignore, describeGitignoreUpgrade } from "../integrations/gitignore.js";
 import { writeCiWorkflow } from "../integrations/ciAction.js";
 import { updateClaudeMd, renderHunchSection } from "../integrations/claudemd.js";
 import { classifyGroundingBlock, describeGroundingFreshness } from "../core/groundingLag.js";
@@ -81,7 +81,7 @@ import { projectDnaDeliverySupplement } from "../core/projectDnaDelivery.js";
 import { readConfig, writeConfig, FIRMNESS_LEVELS, isFirmness, workspacesConfig } from "../core/config.js";
 import { loadOrCreateMachine, setMachineLabel, machineFile, labelLeaksIdentity } from "../core/machine.js";
 import { worktreeRows, branchRows } from "../core/workspace.js";
-import { workspaceLedgerView, recordWorkspaceSnapshot, renderWorktreeTable, renderBranchTable, workspaceSummaryLine, prunePlanFor, renderPrunePlan, applyPrune, confirmPrune } from "../integrations/workspaceLedger.js";
+import { workspaceLedgerView, recordWorkspaceSnapshot, renderWorktreeTable, renderBranchTable, workspaceSummaryLine, prunePlanFor, renderPrunePlan, applyPrune, confirmPrune, pruneConfirmQuestion } from "../integrations/workspaceLedger.js";
 import { blockingInScope, vetoInScope, proposedEditLines } from "../core/hookpolicy.js";
 import { isHumanConfirmed } from "../core/strictgate.js";
 import { appendEvent, readEvents } from "../core/events.js";
@@ -102,10 +102,11 @@ import { loadGoldenSet, evaluateRetrieval, evaluateTraversalLift } from "../eval
 import { loadGuardCases, evalGuards, generateGuardCases } from "../eval/guards.js";
 import { DRIFT_KINDS, computeDrift } from "../core/drift.js";
 import { renderCompilerScorecard, scoreCompilerCaseBank } from "../constitution/scorecard.js";
-import { generateWiki, wikiStatus, wikiPrompt, publicHome, privateHome, readWikiManifestAt, nowData } from "../wiki/wiki.js";
+import { generateWiki, wikiStatus, wikiPrompt, publicHome, privateHome, readWikiManifestAt, nowData, unconfirmedRoadmapMarker } from "../wiki/wiki.js";
 import { adoptProsePrompt } from "../wiki/adopt.js";
 import { topicCollisions, isInForce, liveForTopic } from "../core/topics.js";
 import { ADR_DIR_CANDIDATES, ADR_FILE_RE, mapAdrCorpus } from "../extractors/adrImport.js";
+import { countersignConstraint, countersignDecision } from "../core/countersign.js";
 import { applyImportedAdrReview, carryImportedAdrReview, importedAdrReviewHash, importedAdrSourceHash, isImportedAdrDecision, pendingImportedAdrReviews } from "../core/importReview.js";
 import { exportMadrCorpus, isRegenerableMadr } from "../integrations/madrExport.js";
 import { buildMadrManifest, writeMadrManifest, refreshMadrCorpus } from "../integrations/madrManifest.js";
@@ -341,6 +342,10 @@ program
     const gi = ensureGitignore(root);
     if (gi.action !== "unchanged")
         console.log(`  ✓ .gitignore ${gi.action} (Hunch runtime index excluded)`);
+    // A repo migrated to a private overlay by an older release: bring its private-only
+    // block up to date (and stop publishing newly ignored memory dirs).
+    for (const line of describeGitignoreUpgrade(upgradeManagedGitignore(root)))
+        console.log(`  ✓ ${line}`);
     if (opts.index !== false) {
         if (isGitRepo(root) && revExists("HEAD", root)) {
             const res = indexRepo(store, root, { source: { kind: "commit", ref: "HEAD" } });
@@ -393,11 +398,14 @@ program
     if (isGitRepo(root)) {
         const syncToOverlay = !!(opts.privateSync || opts.sharedSync);
         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" : ""}`);
+        for (const line of formatHookInstall(root, "post-commit hook", h, ` (learning loop)${syncToOverlay ? " — syncs to the shared overlay" : ""}${opts.autoCommit ? " — auto-commit on" : ""}`))
+            console.log(line);
         const pm = installPostMergeHook(root, inv.shell);
-        console.log(`  ✓ post-merge hook ${pm.action} (squash-merge provenance repair + re-syncs grounding docs after a merge that brought memory in)`);
+        for (const line of formatHookInstall(root, "post-merge hook", pm, " (squash-merge provenance repair + re-syncs grounding docs after a merge that brought memory in)"))
+            console.log(line);
         const pc = installPostCheckoutHook(root, inv.shell);
-        console.log(`  ✓ post-checkout hook ${pc.action} (workspace ledger: records this machine's branches + worktrees on checkout)`);
+        for (const line of formatHookInstall(root, "post-checkout hook", pc, " (workspace ledger: records this machine's branches + worktrees on checkout)"))
+            console.log(line);
         const m = installMergeDriver(root, inv.shell);
         console.log(`  ✓ team merge driver ${m.action}`);
         // Auto-install the pre-commit guard by default (advisory: flags invariants
@@ -406,7 +414,8 @@ program
         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 — fails only on direct, high-confidence, non-stale blocking invariants" : "advisory — flags invariants in scope or blast radius"})`);
+            for (const line of formatHookInstall(root, "pre-commit constraint guard", p, ` (${strict ? "strict — fails only on direct, high-confidence, non-stale blocking invariants" : "advisory — flags invariants in scope or blast radius"})`))
+                console.log(line);
         }
     }
     else {
@@ -478,7 +487,10 @@ program
     .action((opts) => {
     const { store, root } = storeFor();
     store.json.ensureDirs();
-    ensureGitignore(root); // keep the derived SQLite index out of git (idempotent)
+    // Keep the derived SQLite index out of git (idempotent). Adds a missing block but
+    // never rewrites an existing one: `index` runs in CI/release gates on a clean
+    // checkout. Older blocks are upgraded by `hunch update` / init / private setup.
+    ensureGitignore(root, { upgradeExisting: false });
     // The post-merge hook only ever got installed by `hunch init`/`hunch
     // private`/`hunch shared` — a repo that already ran init before this hook
     // existed never receives it. `hunch index` already self-heals gitignore
@@ -1250,11 +1262,12 @@ function configureOverlay(dir, opts, mode) {
         if (opts.hook && isGitRepo(root)) {
             freshSetup?.markHookWrite();
             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`;
+            const note = (lines) => lines.map((l) => `${l}\n`).join("");
+            hookNote = note(formatHookInstall(root, "post-commit hook", h, ` — captured decisions route here${opts.autoCommit ? " (auto-commit+push on)" : ""}`));
             const pm = installPostMergeHook(root, inv.shell);
-            hookNote += `  ✓ post-merge hook ${pm.action} (squash-merge provenance repair + re-syncs grounding docs after a merge that brought memory in)\n`;
+            hookNote += note(formatHookInstall(root, "post-merge hook", pm, " (squash-merge provenance repair + re-syncs grounding docs after a merge that brought memory in)"));
             const pc = installPostCheckoutHook(root, inv.shell);
-            hookNote += `  ✓ post-checkout hook ${pc.action} (workspace ledger: this machine's branches + worktrees sync through the overlay)\n`;
+            hookNote += note(formatHookInstall(root, "post-checkout hook", pc, " (workspace ledger: this machine's branches + worktrees sync through the overlay)"));
         }
         // 5) one-time migration: MOVE existing public memory INTO the overlay, then make
         //    THIS repo code-only. Records are absorbed (union by id) BEFORE the public
@@ -1314,6 +1327,13 @@ function configureOverlay(dir, opts, mode) {
                     `  next: review, then commit the PUBLIC repo:\n` +
                     `      git add -A && git commit -m "chore: move engineering memory to a private overlay" && git push\n`;
         }
+        else {
+            // Re-running setup on a repo migrated by an older release upgrades its private-only
+            // block in place and stops publishing memory dirs that block did not yet list.
+            const upgraded = describeGitignoreUpgrade(upgradeManagedGitignore(root));
+            if (upgraded.length)
+                migrateNote = upgraded.map((line) => `  ✓ ${line}\n`).join("");
+        }
         const lead = mode === "private"
             ? `✓ private overlay enabled → ${hunchDir}\n`
             : `✓ shared overlay enabled → ${hunchDir}\n`;
@@ -1520,7 +1540,7 @@ workspacesCmd
         if (!isGitRepo(root))
             return fail("`hunch workspaces prune` needs a git repo");
         const view = workspaceLedgerView(store, root, { fetch: opts.fetch });
-        const plan = prunePlanFor(view);
+        const plan = prunePlanFor(view, root);
         if (!opts.apply) {
             if (opts.json)
                 return console.log(JSON.stringify({ machine: view.machine.label, plan }, null, 2));
@@ -1536,8 +1556,7 @@ workspacesCmd
         if (!opts.json)
             console.log(renderPrunePlan(view, plan));
         if (!opts.yes) {
-            const worktrees = plan.local.filter((s) => s.worktree).length;
-            const ok = await confirmPrune(`Delete ${plan.local.length} branch(es)${worktrees ? ` and remove ${worktrees} worktree(s)` : ""} on ${view.machine.label}?`);
+            const ok = await confirmPrune(pruneConfirmQuestion(view, plan));
             if (!ok)
                 return fail(process.stdin.isTTY ? "not confirmed — nothing was deleted" : "refusing to apply without confirmation: stdin is not a terminal; pass --yes to confirm explicitly");
         }
@@ -1555,11 +1574,12 @@ workspacesCmd
             return console.log(JSON.stringify({ machine: view.machine.label, plan, results, recorded }, null, 2));
         console.log("");
         for (const r of results)
-            console.log(`  ${r.outcome === "deleted" ? "✓" : "✗"} ${r.step.branch}: ${r.detail}`);
+            console.log(`  ${r.outcome === "deleted" ? "✓" : r.outcome === "skipped" ? "–" : "✗"} ${r.step.branch}: ${r.detail}`);
         const failed = results.filter((r) => r.outcome === "failed").length;
+        const skipped = results.filter((r) => r.outcome === "skipped").length;
         const ledger = recorded === "written" ? " · ledger updated" : recorded === "unchanged" || recorded === "no-home" || recorded === "off" ? "" : ` · ledger not updated (${recorded})`;
-        console.log(`\n${results.length - failed} deleted, ${failed} refused by git${ledger}`);
-        if (failed)
+        console.log(`\n${results.length - failed - skipped} deleted, ${skipped ? `${skipped} skipped (nothing changed), ` : ""}${failed} refused by git${ledger}`);
+        if (failed || skipped)
             process.exitCode = 1;
     }
     finally {
@@ -4025,14 +4045,17 @@ program
     // vacuous green (deletions are excluded by the enumerators' --diff-filter=ACMR, so
     // such a PR enumerates zero files) — including a deletion of the very symbol a
     // blocking conformance predicate or an active policy guards.
-    const diff = files.length
-        ? (exactCommit ? commitDiff(exactCommit, root) : opts.base ? rangeDiff(opts.base, root) : opts.working ? workingDiff(root) : stagedDiff(root))
-        : "";
+    // The COMPLETE diff (no synthesis byte budget); an incomplete one is flagged so
+    // content-matched blocking invariants fail closed instead of passing unseen.
+    const gate = files.length
+        ? (exactCommit ? commitGateDiff(exactCommit, root) : opts.base ? rangeGateDiff(opts.base, root) : opts.working ? workingGateDiff(root) : stagedGateDiff(root))
+        : { diff: "" };
     const report = files.length
-        ? store.buildCheckReport(files, diff, {
+        ? store.buildCheckReport(files, gate.diff, {
             strict: !!opts.strict,
             lastChange: (f) => lastChangeDate(f, root),
             publicOnly: !!opts.publicOnly,
+            diffStatus: gate,
         })
         : emptyReport;
     if (opts.blast && !markdown && !sarif && files.length) {
@@ -4170,8 +4193,8 @@ const vetoCmd = program
         store.close();
         return;
     }
-    const diff = opts.commit ? commitDiff(opts.commit, root) : opts.base ? rangeDiff(opts.base, root) : stagedDiff(root);
-    const full = store.buildCheckReport(files, diff, { strict: !!opts.strict, lastChange: (f) => lastChangeDate(f, root) });
+    const gate = opts.commit ? commitGateDiff(opts.commit, root) : opts.base ? rangeGateDiff(opts.base, root) : stagedGateDiff(root);
+    const full = store.buildCheckReport(files, gate.diff, { strict: !!opts.strict, lastChange: (f) => lastChangeDate(f, root), diffStatus: gate });
     if (!full.vetoes.length) {
         console.log(`✓ ${files.length} changed file(s) reverse no decision you rejected.`);
         store.close();
@@ -4732,11 +4755,14 @@ program
             const before = st;
             let activity = null;
             if (/^(Edit|Write|MultiEdit)$/.test(evt.tool_name ?? "")) {
-                const p = evt.tool_input?.file_path;
-                if (p) {
+                // A Codex apply_patch touches every file it lists (and each Move-to
+                // destination); the Stop gate must see all of them, not only the first.
+                const patchPaths = evt.tool_input?.patch_files?.flatMap((f) => f.moved_to ? [f.path, f.moved_to] : [f.path]);
+                const edited = patchPaths?.length ? patchPaths : evt.tool_input?.file_path ? [evt.tool_input.file_path] : [];
+                for (const p of edited)
                     st = onEdit(st, toRepoRel(root, p));
+                if (edited.length)
                     activity = { kind: "edit" };
-                }
             }
             else if (evt.tool_name === "Bash" || evt.tool_name === "PowerShell") {
                 const command = String(evt.tool_input?.command ?? "");
@@ -5017,7 +5043,10 @@ program
                         L.push(`  ${r.date} [${r.status}] ${r.title} (${r.id})`);
                 }
                 if (roadmap.length) {
-                    L.push(`Roadmap (${roadmap.length} live proposed): ${roadmap.slice(0, 3).map((r) => r.title).join(" · ")}${roadmap.length > 3 ? " · …" : ""}`);
+                    L.push(`Roadmap (${roadmap.length} live proposed): ${roadmap.slice(0, 3).map((r) => (r.unconfirmed ? `${r.title} [unconfirmed, ${r.id}]` : r.title)).join(" · ")}${roadmap.length > 3 ? " · …" : ""}`);
+                    const unconfirmed = roadmap.filter((r) => r.unconfirmed).length;
+                    if (unconfirmed)
+                        L.push(`${unconfirmed} roadmap item(s) are unconfirmed agent testimony — the human confirms each with \`hunch review --confirm <id>${s.unified ? " --private" : ""}\`.`);
                 }
                 if (pendingReview > 0)
                     L.push(`${pendingReview} legacy un-vouched draft(s) — adopt as advisory memory with \`hunch adopt-drafts\` (new captures auto-trust).`);
@@ -5046,18 +5075,16 @@ program
         }
         if (evt.hook_event_name !== "PreToolUse")
             return;
-        const abs = evt.tool_input?.file_path;
-        if (!abs)
-            return;
-        const target = toRepoRel(root, abs);
-        // Outside the repo (".." prefix) or on another drive (absolute, e.g. "D:/…")
-        // → nothing for Hunch to say.
-        if (!target || target.startsWith("..") || /^[a-zA-Z]:/.test(target))
+        const targets = editTargets(root, evt.tool_input);
+        // Nothing inside the repo → nothing for Hunch to say.
+        if (!targets.length)
             return;
+        // Grounding below stays about the first in-repo file; the strict gate checks every target.
+        const { abs, target } = targets[0];
         // A compiled red→green probe is only meaningful if its red receipt exists
         // before implementation. Firm/strict may deny two edits per prompt, then
         // fail open so a malformed or unavailable probe can never deadlock work.
-        if ((firmness === "firm" || firmness === "strict") && evt.session_id && pipelineEnabled() && isProductPath(target)) {
+        if ((firmness === "firm" || firmness === "strict") && evt.session_id && pipelineEnabled() && targets.some((t) => isProductPath(t.target))) {
             const baseline = beforeEditProbeVerdict(loadPipelineState(evt.session_id));
             if (baseline.block) {
                 savePipelineState(evt.session_id, baseline.state);
@@ -5089,23 +5116,28 @@ program
             store.reindex();
             // The lines this edit would ADD — so a content-matched invariant denies only
             // when the edit actually trips it (not on every edit in scope), and the Veto
-            // Guard can test the proposed text. Covers Edit/Write/MultiEdit.
-            const proposedLines = proposedEditLines(evt.tool_input);
-            const deny = blockingInScope(store, target, proposedLines);
-            if (deny) {
-                appendEvent(paths, { at: new Date().toISOString(), file: target, ...deny.event });
-                emitDeny(provider, deny.reason);
-                observeHookDenial(root, provider, evt, target, deny);
-                return;
+            // Guard can test the proposed text. Covers Edit/Write/MultiEdit, and each
+            // file of a Codex apply_patch with that file's own added lines.
+            const denials = [];
+            for (const t of targets) {
+                // Veto Guard (live): the proposed edit text re-introduces an approach an
+                // in-force decision REJECTED. The agent self-corrects before staging;
+                // only human-confirmed tripwires deny.
+                const hit = blockingInScope(store, t.target, t.lines) ?? (t.lines.length ? vetoInScope(store, t.target, t.lines) : null);
+                if (hit)
+                    denials.push({ target: t.target, hit });
             }
-            // Veto Guard (live): the proposed edit text re-introduces an approach an
-            // in-force decision REJECTED. The agent self-corrects before staging;
-            // only human-confirmed tripwires deny.
-            const vetoDeny = proposedLines.length ? vetoInScope(store, target, proposedLines) : null;
-            if (vetoDeny) {
-                appendEvent(paths, { at: new Date().toISOString(), file: target, ...vetoDeny.event });
-                emitDeny(provider, vetoDeny.reason);
-                observeHookDenial(root, provider, evt, target, vetoDeny);
+            if (denials.length) {
+                for (const d of denials)
+                    appendEvent(paths, { at: new Date().toISOString(), file: d.target, ...d.hit.event });
+                // One denied file keeps the single-file reason verbatim; several are
+                // listed so the agent knows every file it must reconsider.
+                const reason = denials.length === 1
+                    ? denials[0].hit.reason
+                    : `Hunch: this patch is denied for ${denials.length} files (${denials.map((d) => d.target).join(", ")}).\n${denials.map((d) => d.hit.reason).join("\n")}`;
+                emitDeny(provider, reason);
+                for (const d of denials)
+                    observeHookDenial(root, provider, evt, d.target, d.hit);
                 return;
             }
         }
@@ -5330,6 +5362,8 @@ program
     .description("Answer hash-bound imported-ADR questions, or triage deliberate proposed drafts.")
     .option("--accept <id>", "promote a decision to accepted/human-confirmed (confirms its tripwires)")
     .option("--reject <id>", "reject a draft decision with a durable lifecycle tombstone")
+    .option("--confirm <id>", "countersign an agent-recorded decision (dec_…) or correction (con_…) as human-confirmed WITHOUT changing its status or content — the human act a capture token alone cannot stand in for")
+    .option("--severity <s>", "with --confirm on a correction: the severity you grant (advisory | warning | blocking); default keeps its current severity")
     .option("--approve-import <id>", "approve one exact imported ADR as human-confirmed authority")
     .option("--decline-import <id>", "record that one exact imported ADR was reviewed and must stay advisory")
     .option("--expected-source-hash <hash>", "exact sha256 source hash printed with the imported-ADR question")
@@ -5346,11 +5380,15 @@ program
         store.close();
         return fail("--private needs HUNCH_PRIVATE_DIR set to a private store");
     }
-    const actionCount = [opts.accept, opts.reject, opts.approveImport, opts.declineImport, opts.acceptVerified, opts.rejectDuplicates].filter(Boolean).length;
+    const actionCount = [opts.accept, opts.reject, opts.confirm, opts.approveImport, opts.declineImport, opts.acceptVerified, opts.rejectDuplicates].filter(Boolean).length;
     if (actionCount > 1) {
         store.close();
         return fail("choose exactly one review action at a time");
     }
+    if (opts.severity && !opts.confirm) {
+        store.close();
+        return fail("--severity applies only with --confirm on a correction");
+    }
     const decisions = () => opts.private ? store.recs("decisions") : store.json.loadAll("decisions");
     let publicGroundingChanged = false;
     const touchedHomes = new Set();
@@ -5390,6 +5428,58 @@ program
             return fail(error instanceof Error ? error.message : String(error));
         }
     }
+    else if (opts.confirm) {
+        // Human countersign of agent testimony. A capture token proves only that the
+        // interview tool was called (inside the agent's channel), so agent-written records
+        // land as agent_recorded; this is the out-of-channel human act that signs them.
+        // Content and status are untouched: confirming a proposed decision is not shipping it.
+        const id = opts.confirm;
+        const SEV = ["advisory", "warning", "blocking"];
+        if (opts.severity && !SEV.includes(opts.severity)) {
+            store.close();
+            return fail(`--severity must be one of: ${SEV.join(", ")}`);
+        }
+        const now = new Date().toISOString();
+        const d = opts.private ? store.getRec("decisions", id) : store.json.get("decisions", id);
+        const c = d ? undefined : opts.private ? store.getRec("constraints", id) : store.json.get("constraints", id);
+        if (!d && !c) {
+            store.close();
+            return fail(`no decision or constraint ${id} found${opts.private ? "" : " in the public home (add --private for overlay records)"}`);
+        }
+        let home;
+        if (d) {
+            if (opts.severity) {
+                store.close();
+                return fail("--severity applies only when confirming a correction (con_…), not a decision");
+            }
+            if (isImportedAdrDecision(d)) {
+                store.close();
+                return fail(`imported ADR ${d.id} requires the hash-bound --approve-import flow shown by hunch review`);
+            }
+            home = opts.private ? decisionMemoryHome(store, d.id) : "public";
+            putDecisionInHome(store, countersignDecision(d, now), home);
+            console.log(`✓ confirmed decision ${id} as human_confirmed (status ${d.status} unchanged)`);
+        }
+        else {
+            home = opts.private && store.getPrivateRec("constraints", id) ? "private" : "public";
+            const next = countersignConstraint(c, now, opts.severity);
+            if (home === "private")
+                store.putPrivate("constraints", next);
+            else
+                store.json.put("constraints", next);
+            const repoWide = next.scope.length === 1 && next.scope[0] === "**";
+            console.log(`✓ confirmed ${next.severity} constraint ${id} as human_confirmed (scope: ${next.scope.join(", ")})`);
+            if (next.severity === "blocking" && repoWide)
+                console.log("  ⚠ repo-wide blocking rule: it can deny any edit at strict firmness and fail hunch check --strict.");
+        }
+        touchedHomes.add(home);
+        store.reindex();
+        if (home === "public") {
+            publicGroundingChanged = true;
+            if (!store.autoCommit)
+                refreshExistingGrounding(root, store);
+        }
+    }
     else if (opts.accept) {
         const d = opts.private ? store.getRec("decisions", opts.accept) : store.json.get("decisions", opts.accept);
         if (!d) {
@@ -5513,7 +5603,7 @@ program
                 if (dupCount)
                     console.log(`\n   Batch-reject the ${dupCount} duplicate(s): hunch review --reject-duplicates`);
             }
-            console.log(`\nAccept: hunch review --accept <id>   Reject: hunch review --reject <id>`);
+            console.log(`\nAccept: hunch review --accept <id>   Reject: hunch review --reject <id>   Confirm (sign, keep status): hunch review --confirm <id>`);
         }
     }
     if (touchedHomes.size)
@@ -6562,8 +6652,8 @@ program
             console.log(`No changed files in ${scope}.`);
             return;
         }
-        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));
+        const gate = opts.commit ? commitGateDiff(opts.commit, root) : base ? rangeGateDiff(base, root) : opts.working ? workingGateDiff(root) : stagedGateDiff(root);
+        console.log(renderImpact(store.prImpact(files, gate.diff, gate), scope));
     }
     finally {
         store.close();
@@ -6713,7 +6803,7 @@ program
         if (!roadmap.length)
             console.log("  (empty — record what's next as a PROPOSED decision via /capture and it appears here)");
         for (const r of roadmap)
-            console.log(`  • ${r.title}  (${r.id}${r.topic ? `, ${r.topic}` : ""}, since ${r.date})\n      ${r.note}`);
+            console.log(`  • ${r.title}  (${r.id}${r.topic ? `, ${r.topic}` : ""}, since ${r.date})${r.unconfirmed ? `\n      ${unconfirmedRoadmapMarker(r, { private: !!opts.private })}` : ""}\n      ${r.note}`);
         if (pendingReview > 0)
             console.log(`\n  (${pendingReview} legacy un-vouched draft(s) — \`hunch adopt-drafts\` to auto-trust them as advisory)`);
         // Task-record ranking: evaluated automatically on every task write; the kill rule applies itself.
@@ -6983,16 +7073,32 @@ program
     // squash-merge went unrepaired. pre-commit is opt-out (`--no-enforce`),
     // so its absence is informational only, never a warning.
     if (isGitRepo(root)) {
+        const report = hookReport(root);
         const hooks = hookStatus(root);
-        const missing = [!hooks.postCommit && "post-commit", !hooks.postMerge && "post-merge"].filter((h) => !!h);
+        const missing = [report.postCommit.state === "missing" && "post-commit", report.postMerge.state === "missing" && "post-merge"].filter((h) => !!h);
+        // A block that is present but never runs (after an exec/exit, or inside a
+        // hook manager's regenerated file — issue #311) is NOT installed.
+        const unreachable = [["post-commit", report.postCommit], ["post-merge", report.postMerge], ["pre-commit", report.preCommit], ["post-checkout", report.postCheckout]]
+            .filter(([, e]) => e.state === "unreachable");
         // `hunch index` only ever installs post-merge onto an existing
         // post-commit install (it never hooks an un-hooked repo — see
-        // isGitRepo(root) && hookStatus(root).postCommit above) — so the fix
-        // hint must not point there when post-commit itself is missing.
-        const fix = !hooks.postCommit ? "run `hunch init` for the full setup" : "run `hunch index` to install it";
-        console.log(`hooks:      ${missing.length
-            ? `⚠ missing ${missing.join(", ")} — ${fix}`
+        // isGitRepo(root) && hookStatus(root).postCommit above) and never writes
+        // into a manager-owned hook — so the fix hint must not point there when
+        // post-commit itself is missing or a hook manager is in play.
+        const managedMissing = [report.postCommit, report.postMerge].find((e) => e.state === "missing" && e.manager !== "none");
+        const fix = managedMissing
+            ? `${managedMissing.manager === "exec-exit" ? "the existing hook exits before an appended block would run" : `a hook manager (${managedMissing.manager}) owns these hooks`}; run \`hunch init\` to print the snippet to add to ${rel(root, managedMissing.path)}`
+            : !hooks.postCommit ? "run `hunch init` for the full setup" : "run `hunch index` to install it";
+        const problems = [
+            missing.length ? `⚠ missing ${missing.join(", ")} — ${fix}` : "",
+            unreachable.length ? `⚠ installed but unreachable: ${unreachable.map(([n]) => n).join(", ")} — never runs; run \`hunch init\` to print the snippet for your hook manager` : "",
+        ].filter(Boolean);
+        console.log(`hooks:      ${problems.length
+            ? problems.join("\n            ")
             : `post-commit, post-merge installed${hooks.preCommit ? " (+ pre-commit)" : ""}`}`);
+        for (const [name, e] of unreachable) {
+            console.log(dim(`            ↳ ${name}: ${e.reason ?? "the block sits where git never reaches it"} (${rel(root, e.path)})`));
+        }
         // Workspace ledger: what this machine is called, whether its record is in memory,
         // and whether the checkout hook that keeps it fresh is installed.
         try {
@@ -7001,7 +7107,7 @@ program
             const others = store.recs("workspaces").filter((r) => r.machine.id !== machine.id).length;
             const leak = labelLeaksIdentity(machine.label);
             console.log(`workspaces: this machine is ${machine.label}${leak ? ` (⚠ label equals the ${leak})` : ""} · record in memory: ${stored ? `yes (${stored.observed_at})` : "no"} · ${others} other machine(s)` +
-                `${hooks.postCheckout ? " · post-checkout hook installed" : hooks.postCommit ? " · post-checkout hook not installed (`hunch index` adds it)" : ""}`);
+                `${hooks.postCheckout ? " · post-checkout hook installed" : report.postCheckout.state === "unreachable" ? " · ⚠ post-checkout hook unreachable" : hooks.postCommit ? " · post-checkout hook not installed (`hunch index` adds it)" : ""}`);
         }
         catch { /* no machine file writable: nothing to report */ }
     }
@@ -7169,6 +7275,28 @@ function realpathNorm(p) {
 function toRepoRel(root, abs) {
     return relative(realpathNorm(root), realpathNorm(abs)).split("\\").join("/");
 }
+/** The in-repo files a pre-edit event would change, each with the lines the edit
+ *  ADDS to that file. A Codex apply_patch yields one entry per touched path (a
+ *  Move-to destination is its own entry, carrying the section's added lines);
+ *  every other edit tool yields its single `file_path`. Paths outside the repo
+ *  ("..") or on another drive ("D:/…") are skipped. */
+function editTargets(root, input) {
+    const raw = input?.patch_files?.length
+        ? input.patch_files.flatMap((f) => (f.moved_to ? [f.path, f.moved_to] : [f.path]).map((abs) => ({ abs, lines: f.added_lines })))
+        : input?.file_path ? [{ abs: input.file_path, lines: proposedEditLines(input) }] : [];
+    const byTarget = new Map();
+    for (const { abs, lines } of raw) {
+        const target = toRepoRel(root, abs);
+        if (!target || target.startsWith("..") || /^[a-zA-Z]:/.test(target))
+            continue;
+        const seen = byTarget.get(target);
+        if (seen)
+            seen.lines = [...seen.lines, ...lines];
+        else
+            byTarget.set(target, { abs, target, lines });
+    }
+    return [...byTarget.values()];
+}
 function emitContext(provider, event, text, 
 /** One user-facing line where the host shows hook messages (Claude Code's
  * `systemMessage`); never a block, never a second model turn. */

package/dist/cli/integrations.js

@@ -1,6 +1,7 @@
 import { findRoot } from "../core/paths.js";
 import { CAPABILITIES, HARNESSES, inspectIntegrations, integrationHealthFails, formatIntegrationHealth, repairIntegrationPins } from "../integrations/health.js";
 import { probeIntegration } from "../integrations/probe.js";
+import { describeGitignoreUpgrade, upgradeManagedGitignore } from "../integrations/gitignore.js";
 export function registerIntegrationCommands(program, refreshGrounding) {
     const integrations = program.command("integrations").description("Check harness coverage and repair stale repository Hunch pins");
     integrations.command("check")
@@ -34,6 +35,15 @@ export function registerIntegrationCommands(program, refreshGrounding) {
         if (files.includes(".codex/hooks.json")) {
             console.log("Codex: open /hooks to review and trust the changed commands, then start a new session. Command changes require renewed trust; Hunch does not grant it automatically.");
         }
+        // `hunch update` runs this command with the NEW release, so existing repos pick up
+        // managed .gitignore entries added since they were set up (no re-init needed).
+        try {
+            for (const line of describeGitignoreUpgrade(upgradeManagedGitignore(root)))
+                console.log(line);
+        }
+        catch (error) {
+            console.log(`.gitignore not upgraded: ${error.message}`);
+        }
         const grounding = refreshGrounding();
         if (grounding.length)
             console.log(`Updated Hunch instructions: ${grounding.join(", ")}. Reconnect the agent to load task reporting instructions.`);

package/dist/client/state.d.ts

@@ -306,11 +306,12 @@ export declare function createStateClient(opts: StateClientOptions): {
         missing: string[];
         denied: string[];
     }>;
+    /** Liveness; `partitions` is present because this client sends its credential. */
     health: () => Promise<{
         ok: boolean;
         version: string;
         protocol: string;
-        partitions: string[];
+        partitions?: string[];
     }>;
 };
 export type StateClient = ReturnType<typeof createStateClient>;

package/dist/client/state.js

@@ -59,6 +59,7 @@ export function createStateClient(opts) {
         captureBatch: (request) => call("POST", "/nuryel/v1/capture-batch", request),
         subscribe: (request) => call("POST", "/nuryel/v1/subscribe", request),
         records: (request) => call("POST", "/nuryel/v1/records", request),
+        /** Liveness; `partitions` is present because this client sends its credential. */
         health: () => call("GET", "/nuryel/v1/health"),
     };
 }

package/dist/core/agenthook.d.ts

@@ -8,6 +8,16 @@
 export declare const HOOK_PROVIDERS: readonly ["claude", "codex", "vscode", "windsurf", "antigravity", "cursor"];
 export type HookProvider = (typeof HOOK_PROVIDERS)[number];
 export type HunchHookEvent = "PreToolUse" | "PostToolUse" | "PostToolUseFailure" | "UserPromptSubmit" | "SessionStart" | "SubagentStart" | "PreCompact" | "Stop";
+/** One file section of a Codex `apply_patch` payload. */
+export interface HunchPatchFile {
+    /** The path as written in the patch (may be absolute). */
+    path: string;
+    action: "update" | "add" | "delete";
+    /** `*** Move to:` destination, when the section renames the file. */
+    moved_to?: string;
+    /** Only the lines this section adds (`+` prefix stripped). */
+    added_lines: string[];
+}
 export interface HunchToolInput {
     file_path?: string;
     new_string?: string;
@@ -17,6 +27,9 @@ export interface HunchToolInput {
     }>;
     command?: string;
     skill?: string;
+    /** Codex `apply_patch` only: every file the patch touches. `file_path` is the
+     * first entry's path and `content` the raw patch, for single-file consumers. */
+    patch_files?: HunchPatchFile[];
 }
 /** A provider-neutral observation of the tool result. Output is ephemeral: the
  * pipeline compares it with bounded expectations but never persists it. */
@@ -41,6 +54,7 @@ export interface HunchHookInput {
     /** SubagentStart: the delegated agent's type (e.g. "Explore", "Plan"). */
     agent_type?: string;
 }
+export declare function parseApplyPatch(patch: string): HunchPatchFile[];
 /** Parse a provider name supplied by a hook config. Unknown values intentionally
  * return null so a bad config cannot make an edit fail. */
 export declare function hookProvider(value: unknown): HookProvider | null;