@davesheffer/hunch 1.39.0 → 1.39.1

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";
@@ -341,6 +341,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 +397,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 +413,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 +486,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 +1261,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 +1326,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 +1539,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 +1555,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 +1573,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 +4044,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 +4192,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 +4754,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 ?? "");
@@ -5046,18 +5071,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 +5112,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;
             }
         }
@@ -6562,8 +6590,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();
@@ -6983,16 +7011,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 +7045,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 +7213,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/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;

package/dist/core/agenthook.js

@@ -49,16 +49,59 @@ function edits(value) {
         .map((item) => ({ new_string: stringAt(item, "new_string", "newString", "ReplacementContent", "replacementContent") }));
     return normalized.length ? normalized : undefined;
 }
+/** Parse Codex `apply_patch` text into one entry per touched file. Only `+` lines
+ * inside a file section count as added: removed (`-`) and context (` `) lines are
+ * text the edit takes away or leaves alone, so a content-matched gate must not read
+ * them as proposed content. Paths are returned exactly as written in the patch;
+ * the CLI normalizes them against the repository root. */
+const PATCH_HEADER = /^\*\*\* (Update|Add|Delete) File: (.+?)\s*$/;
+const PATCH_MOVE = /^\*\*\* Move to: (.+?)\s*$/;
+export function parseApplyPatch(patch) {
+    const files = [];
+    let current;
+    for (const line of patch.split(/\r?\n/)) {
+        const header = PATCH_HEADER.exec(line);
+        if (header) {
+            current = { path: header[2], action: header[1].toLowerCase(), added_lines: [] };
+            files.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        const move = PATCH_MOVE.exec(line);
+        if (move) {
+            current.moved_to = move[1];
+            continue;
+        }
+        // `*** End Patch` / `*** End of File` close sections; they carry no content.
+        if (line.startsWith("*** "))
+            continue;
+        // A unified-diff style file header is not content; apply_patch has none, but
+        // a model can still emit one.
+        if (/^\+\+\+ (?:[ab]\/|\/dev\/null)/.test(line))
+            continue;
+        if (line.startsWith("+"))
+            current.added_lines.push(line.slice(1));
+    }
+    return files;
+}
 /** Codex edits files through `apply_patch`, whose input is the patch text itself
- * (`*** Update File: path`). The first touched path becomes the edit target so the
- * per-file pre-edit gate applies; the whole patch stands in for the new content. */
-const PATCH_FILE = /^\*\*\* (?:Update|Add|Delete) File: (.+?)\s*$/m;
+ * (`*** Update File: path`). Every touched file is listed in `patch_files` so the
+ * pre-edit gate runs per file; the first path stays `file_path` and the whole patch
+ * stays `content` for consumers that read the single-file shape.
+ *
+ * TODO(codex-exec-patch): a Codex code-mode `exec` tool call that embeds an
+ * apply_patch does NOT reach this parser: `.codex/hooks.json` (integrations/
+ * providers.ts) matches PreToolUse on `apply_patch` only, and `normalizeHookEvent`
+ * enables patch parsing only for tool names `apply_patch`/`patch`. No captured
+ * payload of such a call exists in the repo, so its shape is not guessed here;
+ * capture a real hook payload before extending the matcher or this parser. */
 function applyPatchInput(raw) {
     const patch = [raw.input, raw.patch, raw.content].find((v) => typeof v === "string" && /\*\*\* Begin Patch/.test(v));
     if (!patch)
         return undefined;
-    const file = PATCH_FILE.exec(patch)?.[1];
-    return file ? { file_path: file, content: patch } : undefined;
+    const files = parseApplyPatch(patch);
+    return files.length ? { file_path: files[0].path, content: patch, patch_files: files } : undefined;
 }
 function normalizeToolInput(value, allowPatch = false) {
     const raw = obj(value);

package/dist/core/changeProof.js

@@ -94,7 +94,8 @@ function exactChangedPaths(root, baseRevision, resultRevision) {
 }
 function exactDiff(root, baseRevision, resultRevision) {
     const raw = gitBytes(root, [
-        "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--no-renames", "--unified=2",
+        "-c", "core.quotePath=false",
+        "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--no-renames", "--unified=2", "--src-prefix=a/", "--dst-prefix=b/",
         baseRevision, resultRevision, "--",
     ]);
     if (raw.byteLength <= MAX_DIFF_BYTES)
@@ -309,6 +310,9 @@ export function deriveChangeProof(root, store, baseRef, resultRef = "HEAD", opti
     const guardReport = store.buildCheckReport(changed.paths, diff.diff, {
         strict: true,
         publicOnly,
+        // A diff cut at MAX_DIFF_BYTES is a prefix: content-matched blocking rules over the
+        // files it omits fail closed rather than read as compliant (dec_20db57c576).
+        diffStatus: diff.gaps.length ? { incomplete: `the guard diff exceeded ${MAX_DIFF_BYTES} bytes and was cut`, truncated: true } : undefined,
         lastChange: (path) => lastChangeAt(root, change.head_revision, path),
     });
     const allStrictBlockerIds = sortedUnique([

package/dist/core/checkreport.d.ts

@@ -29,6 +29,13 @@ export interface CheckDirect {
     strictBlocks: boolean;
     /** If a blocking invariant is downgraded to advisory under strict, why. */
     downgrade?: "stale" | "low-confidence";
+    /** Set when a content-matched blocking invariant could NOT be evaluated because the
+     *  added lines of some scoped files are missing from the diff (truncated diff, git
+     *  failure, unreadable file). Reported as a hit, never as compliance: it fails closed. */
+    unevaluable?: {
+        reason: string;
+        files: string[];
+    };
     /** The causal citation (the "why this guard exists") — present when the graph links it. */
     why?: CausalWhy;
 }

package/dist/core/checkreport.js

@@ -44,6 +44,16 @@ export function renderImpact(im, scope) {
     }
     return out.join("\n");
 }
+/** Strict-failure reason fragments for direct invariants: proven hits and the
+ *  content-matched invariants that could not be evaluated are named separately. */
+function strictBlockerReasons(r) {
+    const unevaluable = r.direct.filter((d) => d.strictBlocks && d.unevaluable).length;
+    const proven = r.strictBlockers - unevaluable;
+    return [
+        proven > 0 ? `${proven} high-confidence blocking invariant(s) directly in scope` : "",
+        unevaluable > 0 ? `${unevaluable} blocking invariant(s) that could not be evaluated against the complete diff` : "",
+    ];
+}
 /** True when --strict should FAIL the commit/PR. */
 export function reportFailsStrict(r) {
     return r.strict && (r.strictBlockers > 0 || r.regBlocking > 0 || r.vetoBlocking > 0);
@@ -93,7 +103,10 @@ export function renderText(r) {
             const note = r.strict && c.severity === "blocking" && !c.strictBlocks
                 ? c.downgrade === "stale" ? "  (advisory: stale)" : "  (advisory: low confidence)"
                 : "";
-            out.push(`  ${mark(c.severity)} [${c.severity}] ${c.statement}${note}\n      ${c.id} · in: ${c.files.join(", ")}\n      rationale: ${c.rationale || "—"}${whyText(c.why)}`);
+            const unevaluable = c.unevaluable
+                ? `\n      ‼ NOT EVALUATED — ${c.unevaluable.reason}; added lines unavailable for: ${c.unevaluable.files.join(", ")} (fails closed)`
+                : "";
+            out.push(`  ${mark(c.severity)} [${c.severity}] ${c.statement}${note}\n      ${c.id} · in: ${c.files.join(", ")}\n      rationale: ${c.rationale || "—"}${unevaluable}${whyText(c.why)}`);
         }
     }
     if (r.near.length) {
@@ -122,7 +135,7 @@ export function renderText(r) {
     }
     if (reportFailsStrict(r)) {
         const reasons = [
-            r.strictBlockers ? `${r.strictBlockers} high-confidence blocking invariant(s) directly in scope` : "",
+            ...strictBlockerReasons(r),
             r.regBlocking ? `${r.regBlocking} blocking-linked regression(s)` : "",
             r.vetoBlocking ? `${r.vetoBlocking} reversed-decision veto(es)` : "",
         ].filter(Boolean).join(" + ");
@@ -153,6 +166,8 @@ export function renderMarkdown(r) {
                 : "";
             out.push(`- **[${c.severity}] ${c.statement}** — \`${c.id}\`${note}`);
             out.push(`  - in: ${c.files.map((f) => `\`${f}\``).join(", ")}`);
+            if (c.unevaluable)
+                out.push(`  - ‼ **Not evaluated** — ${c.unevaluable.reason}; added lines unavailable for ${c.unevaluable.files.map((f) => `\`${f}\``).join(", ")} _(fails closed)_`);
             if (c.rationale)
                 out.push(`  - _${c.rationale}_`);
             for (const line of whyMd(c.why))
@@ -196,7 +211,7 @@ export function renderMarkdown(r) {
     out.push("---");
     if (reportFailsStrict(r)) {
         const reasons = [
-            r.strictBlockers ? `${r.strictBlockers} high-confidence blocking invariant(s) directly in scope` : "",
+            ...strictBlockerReasons(r),
             r.regBlocking ? `${r.regBlocking} blocking-linked regression(s)` : "",
             r.vetoBlocking ? `${r.vetoBlocking} reversed-decision veto(es)` : "",
         ].filter(Boolean).join(" + ");
@@ -233,6 +248,8 @@ export function renderSarif(r, version, extras = {}) {
             text += ` — ${c.rationale}`;
         if (c.downgrade)
             text += ` (advisory under strict: ${c.downgrade})`;
+        if (c.unevaluable)
+            text += `\nNOT EVALUATED (fails closed): ${c.unevaluable.reason}; added lines unavailable for ${c.unevaluable.files.join(", ")}`;
         if (c.why?.decision)
             text += `\nwhy: “${c.why.decision.title}” (${c.why.decision.id})`;
         if (c.why?.bug)

package/dist/core/compare.js

@@ -1,5 +1,5 @@
 import { verdict } from "./checkreport.js";
-import { revExists, rangeFiles, rangeDiff } from "../extractors/git.js";
+import { revExists, rangeFiles, rangeGateDiff } from "../extractors/git.js";
 /** A lower fit score is better. Verdict dominates (pass < warn < block), then the
  *  blocking count, then total advisory hits. Errored candidates sort last. */
 function fitKey(c) {
@@ -14,7 +14,8 @@ export function compareCandidates(store, root, base, candidates) {
         const files = rangeFiles(base, root, ref);
         if (!files.length)
             return { ...zero, verdict: "pass", error: `no changes vs ${base}` };
-        const r = store.buildCheckReport(files, rangeDiff(base, root, ref), { strict: true });
+        const gate = rangeGateDiff(base, root, ref);
+        const r = store.buildCheckReport(files, gate.diff, { strict: true, diffStatus: gate });
         return {
             ref,
             verdict: verdict(r),