@rmyndharis/aimhooman 0.3.0 → 0.4.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
             "name": "aimhooman",
             "source": "./",
             "description": "Keeps AI session files and unwanted attribution out at the agent and Git boundary.",
-            "version": "0.3.0",
+            "version": "0.4.0",
             "license": "MIT",
             "keywords": [
                 "git",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "aimhooman",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "AI works. Hoomans ship. Keeps AI session files and unwanted attribution out at the agent and Git boundary.",
     "author": {
         "name": "aimhooman"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "aimhooman",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "AI works. Hoomans ship. Keeps AI session files and unwanted attribution out at the agent and Git boundary.",
     "author": {
         "name": "aimhooman maintainers",

package/.cursor/rules/aimhooman.mdc

@@ -1,5 +1,5 @@
 ---
-description: aimhooman - keep AI session files, secrets, and unwanted AI attribution out of Git.
+description: aimhooman - keep AI session files and unwanted AI attribution out of Git.
 globs:
 alwaysApply: true
 ---

package/CHANGELOG.md

@@ -5,6 +5,92 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2026-07-20
+
+### Added
+
+- New managed `pre-push` hook (`pushcheck`) that scans every commit a push
+  would introduce, messages included. A commit vetoed by the
+  reference-transaction guard stays in the local object store, and pushing that
+  raw object ID (`git push <remote> <sha>:<ref>`) moved no local branch, so it
+  sailed past every guard; the veto message even printed the SHA. Such pushes
+  are now rejected before any objects are sent. Deletions carry nothing and
+  pass without scanning.
+
+### Changed
+
+- A scan whose only gap is a file over the per-file size budget no longer
+  wedges commits on `clean`/`compliance`: the final ref guard warns and
+  continues instead of vetoing, because path rules still covered the file.
+  `strict` stays fail-closed (exit 31) on any incomplete scan, and every other
+  gap (total byte budget, unreadable objects, rule-pack errors) stays
+  fail-closed on all profiles.
+- Commit overhead: the `commit-msg` dispatcher greps the message for the
+  attribution-rule anchors and skips its Node spawn when none is present (a
+  local rule pack or a missing `pre-commit` dispatcher re-enables the spawn,
+  since the "tree already scanned" premise needs both), and `pre-commit` skips
+  its spawn when the index is empty. A typical commit goes from three Node
+  spawns to two; an empty commit to one.
+- The `not very hooman.` banner now appears only when a finding actually stops
+  or reshapes the operation (a block). A pure review advisory, where the
+  commit proceeds untouched, prints without it so the banner keeps its meaning.
+- A blocked strict-policy downgrade or deletion now prints the exact
+  `aimhooman policy-review` invocation — oids included — instead of pointing at
+  "the reviewed migration command"; running the printed command unlocks the
+  commit.
+- A non-blocking "scan incomplete" warning (the oversized-file case) prints
+  once per tree and gap instead of once per hook: pre-commit, commit-msg, the
+  final ref guard, and pre-push share a notice marker, so the same oversized
+  file no longer warns three times in one commit.
+
+## [0.3.1] - 2026-07-19
+
+### Fixed
+
+- `fix` on a strict policy no longer exits 11 (review required) when the
+  message holds a removable attribution line but the recheck of the cleaned
+  message stays incomplete; it exits 31, the same verdict `--apply` reaches
+  for the same content.
+- `commitmsg` printed the blocking "scan incomplete … and retry" framing for
+  a tree scan that stopped at exit 11 on the compliance profile; the framing
+  now follows the profile, matching `check` and `fix`.
+- `loadOverrides` burned the full lock retry budget (~50 × 10 ms) when a
+  caller already held `overrides.json.lock` (every `allow`/`deny`/`override`/
+  `review`/`policy-review` write); the warn-once migration persist now takes
+  one lock attempt and skips quietly when the lock is held.
+- Two-arg `loadConfig(stateDir, root)` dropped the per-clone `gitignore`
+  record whenever a project policy owned the profile; the record is now read
+  best effort from config.json.
+- Session-start hook: a failed `.git/info/exclude` refresh no longer skips
+  the worktree `.gitignore` refresh; each has its own silent failure, like
+  the pre-tool-use path.
+- `uninstall` now also sweeps the worktree `.gitignore` lock queue left by
+  `init --gitignore`; the sweep previously covered only the three `.git`-side
+  queues.
+- `action.yml` gained a `version` input (default `latest`) so the installed
+  CLI can be pinned (pinning the action tag never pinned the CLI), and its
+  `actions/setup-node` step is pinned to the same SHA the test workflow uses.
+- The tarball now ships `docs/secrets.md`, `docs/policy.md`,
+  `docs/cli-reference.md`, `docs/faq.md`, and `docs/integrations.md`; links
+  to them from the README and the catalog dangled inside node_modules.
+- Documentation and comment accuracy: the Cursor manifest description and the
+  usage and integrations exit-code lines no longer mention secret scanning
+  and now name the strict/final-guard scope of exit 31; the README flowchart
+  no longer implies an incomplete scan blocks pre-commit on every profile;
+  `docs/policy.md` states correctly that strict turns policy-file and
+  agent-instruction findings into blocks and that only the policy
+  downgrade/removal block is allow-proof; the 0.3.0 binary bullet, the FAQ
+  budget answer, and two stale comments now describe what the code does.
+
+### Removed
+
+- Dead code: the unreachable `release` branch of
+  `scripts/scan-ci-history.mjs` (no workflow sets that context) along with
+  `selectReleaseBase` and the `RELEASE_ENVIRONMENT_VERIFIED` contract; the
+  never-produced `object-read-failed` incomplete reason; the callerless
+  `repeatable` option in the argument parser; and eight unused `node:fs`
+  imports in `src/gitx.mjs`.
+
 ## [0.3.0] - 2026-07-19
 
 This release narrows aimhooman to the job it does better than anyone else:
@@ -30,8 +116,11 @@ reference-transaction guard keeps its veto on every profile.
   `overrides.json` are dropped on load with a warning naming the file.
   A secret already in history needs rotation and a gitleaks run, not
   aimhooman.
-- With no rule reading binary content, an oversized binary file no longer
-  makes a scan incomplete; oversized text still does.
+- In-budget binary blobs are no longer content-scanned: v0.2.0 read their
+  bytes for secrets, and with the scanner gone they now skip as binary. The
+  oversized-file probe is unchanged — binary up to 16 MiB still skips
+  complete, and binary over it is still a size-limit skip that leaves the
+  scan incomplete.
 
 ### Added
 

package/README.md

@@ -9,7 +9,7 @@
 
 <p align="center">
   <img src="https://img.shields.io/github/actions/workflow/status/rmyndharis/aimhooman/test.yml?branch=main&label=CI" alt="CI">
-  <img src="https://img.shields.io/badge/version-v0.3.0-blue" alt="v0.3.0">
+  <img src="https://img.shields.io/badge/version-v0.4.0-blue" alt="v0.4.0">
   <img src="https://img.shields.io/badge/node-%E2%89%A522.8-339933?logo=node.js&logoColor=white" alt="Node 22.8+">
   <img src="https://img.shields.io/badge/dependencies-0-brightgreen" alt="Zero dependencies">
   <img src="https://img.shields.io/badge/license-MIT-111111" alt="MIT">
@@ -41,7 +41,9 @@ One detection core, many enforcement surfaces. On the default profile the ordina
 path repairs hygiene findings when it can; `commit-msg` checks the pinned would-be tree,
 and the final ref boundary independently scans every commit introduced to `HEAD` or a
 branch. A block that survives repair stops the commit; an incomplete scan warns on
-`clean`/`compliance` and still vetoes at the final ref guard.
+`clean`/`compliance` and still vetoes at the final ref guard, unless the only gap is a
+file over the per-file size budget. `pre-push` scans what a push would send, so a commit
+pushed by raw object ID cannot bypass the local guards.
 
 ```mermaid
 flowchart TD
@@ -52,20 +54,23 @@ flowchart TD
     COMMIT([Ordinary git commit or merge]) --> PRE["pre-commit / pre-merge-commit<br/>run predecessor, resolve staged policy,<br/>scan exact index"]
     DIRECT([Sequencer or direct ref path<br/>cherry-pick · rebase · fetch · worktree · update-ref]) --> REF
     PRE -->|clean: safe repair| MSG["commit-msg snapshots would-be tree,<br/>runs predecessor, then checks<br/>the message and pinned full tree"]
-    PRE -->|strict violation, incomplete scan,<br/>or failed repair| BLOCK([Operation stops])
+    PRE -->|strict violation or failed repair| BLOCK([Operation stops])
     MSG -->|message and tree accepted| REF["reference-transaction prepared<br/>scans what each introduced commit changes<br/>(messages of locally authored commits only)"]
     MSG -->|unsafe or unrepairable| BLOCK
     REF -->|accepted| SHIP([Ref update commits])
     REF -->|violation or incomplete scan| BLOCK
+    PUSH([git push]) --> PREPUSH["pre-push<br/>scans every commit the push would send,<br/>messages included — even a push by raw object ID"]
+    PREPUSH -->|accepted| SENT([Objects leave for the remote])
+    PREPUSH -->|violation| BLOCK
 
     classDef entry fill:#f8fafc,stroke:#94a3b8,color:#0f172a,stroke-width:1.5px
     classDef hook fill:#eef2ff,stroke:#6366f1,color:#312e81,stroke-width:2px
     classDef ok fill:#ecfdf5,stroke:#10b981,color:#064e3b,stroke-width:1.5px
     classDef stop fill:#fef2f2,stroke:#ef4444,color:#7f1d1d,stroke-width:2px
 
-    class SESS,AGENT,RUN,COMMIT,DIRECT entry
-    class PRE,MSG,REF hook
-    class SHIP ok
+    class SESS,AGENT,RUN,COMMIT,DIRECT,PUSH entry
+    class PRE,MSG,REF,PREPUSH hook
+    class SHIP,SENT ok
     class BLOCK stop
 ```
 

package/bin/aimhooman.mjs

@@ -128,7 +128,7 @@ function main(argv) {
     // switch below.
     const SUBCOMMAND_HELP_FLAGS = new Set(['--help', '-h', 'help']);
     const knownSubcommands = new Set([
-        'check', 'audit', 'scan', 'precommit', 'commitmsg', 'refcheck', 'init',
+        'check', 'audit', 'scan', 'precommit', 'commitmsg', 'refcheck', 'pushcheck', 'init',
         'status', 'explain', 'allow', 'deny', 'override', 'review',
         'policy-review', 'fix', 'doctor', 'uninstall',
     ]);
@@ -148,6 +148,8 @@ function main(argv) {
             return cmdCommitmsg(rest);
         case 'refcheck':
             return cmdRefcheck(rest);
+        case 'pushcheck':
+            return cmdPushcheck(rest);
         case 'init':
             return cmdInit(rest);
         case 'status':
@@ -249,6 +251,31 @@ function incompleteMessage(scan, { blocking = true } = {}) {
     return message + pathLines.join('');
 }
 
+// One oversized file trips the same non-blocking "scan incomplete" warning in
+// up to three hooks of a single commit (pre-commit, commit-msg, the final ref
+// guard) and again in pre-push. Print it once per tree and gap: the first
+// guard to warn records the tree plus the skip signature, later guards stay
+// silent for the identical gap. State failures degrade to printing — a
+// duplicate warning is noise, a swallowed one is a miss.
+const INCOMPLETE_NOTICE_VERSION = 1;
+function warnIncompleteOnce(repo, treeSha, scan) {
+    const signature = createHash('sha256')
+        .update(JSON.stringify([scan.stats?.skipped || {}, scan.stats?.skippedPaths || {}]))
+        .digest('hex');
+    if (treeSha) {
+        try {
+            const statePath = join(repo.stateDir, 'incomplete-notice.json');
+            let previous = null;
+            try { previous = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first run or corrupt state */ }
+            if (previous?.version === INCOMPLETE_NOTICE_VERSION
+                && previous.tree === treeSha
+                && previous.signature === signature) return;
+            writeFileSync(statePath, JSON.stringify({ version: INCOMPLETE_NOTICE_VERSION, tree: treeSha, signature }));
+        } catch { /* fall through to printing */ }
+    }
+    process.stderr.write(incompleteMessage(scan, { blocking: false }));
+}
+
 // Most skip reasons tally files; the three below tally something else, so the
 // noun travels with the reason instead of reading "local-pack-error=1 file".
 function skipCountNoun(reason, count) {
@@ -444,11 +471,15 @@ function cmdPrecommit(args) {
         if (reviews.length) process.stderr.write(human(reviews, tone()));
         if (!scan.complete) {
             // Strict stops on an unchecked remainder. Clean/compliance go ahead
-            // with a warning: the reference-transaction guard rescans the
-            // introduced commit before any ref moves. The clean marker stays
-            // unwritten so commit-msg does not skip its own tree scan.
-            process.stderr.write(incompleteMessage(scan, { blocking: profile === 'strict' }));
-            return profile === 'strict' ? 31 : 0;
+            // with a warning — printed once per tree across all of a commit's
+            // hooks (see warnIncompleteOnce). The clean marker stays unwritten
+            // so commit-msg does not skip its own tree scan.
+            if (profile === 'strict') {
+                process.stderr.write(incompleteMessage(scan));
+                return 31;
+            }
+            warnIncompleteOnce(repo, stagedTreeSha(repo), scan);
+            return 0;
         }
         // W5 marker dedup: record that this staged tree scanned clean so the
         // upcoming commit-msg hook can skip its duplicate tree scan. The tree
@@ -611,12 +642,13 @@ function cmdCommitmsg(args) {
         const treeCode = exitCode(treeScan.findings, treeScan.profile, treeScan.complete);
         if (treeCode !== 0) {
             if (treeScan.findings.length) process.stderr.write(human(treeScan.findings, tone()));
-            if (!treeScan.complete) process.stderr.write(incompleteMessage(treeScan));
+            if (!treeScan.complete) process.stderr.write(incompleteMessage(treeScan, { blocking: treeScan.profile === 'strict' }));
             return treeCode;
         }
         // exitCode passes an incomplete tree scan on frictionless profiles; the
         // skip still names itself so the commit does not sail through silently.
-        if (!treeScan.complete) process.stderr.write(incompleteMessage(treeScan, { blocking: false }));
+        // pre-commit already printed this exact gap for this tree — warn once.
+        if (!treeScan.complete) warnIncompleteOnce(repo, options.tree, treeScan);
     }
     if (dispatchHooksChanged(repo, profile)) return 20;
     // Strict must fail closed on an incomplete scan: a block still wins (10),
@@ -626,7 +658,7 @@ function cmdCommitmsg(args) {
         process.stderr.write(incompleteMessage(scan));
         return findings.some((finding) => finding.decision === 'block') ? 10 : 31;
     }
-    if (!scan.complete) process.stderr.write(incompleteMessage(scan, { blocking: false }));
+    if (!scan.complete) warnIncompleteOnce(repo, options.tree, scan);
     if (!findings.length) return 0;
     const blocks = findings.filter((finding) => finding.decision === 'block');
     if (profile === 'strict') {
@@ -659,6 +691,180 @@ function cmdCommitmsg(args) {
     return remaining.some((finding) => finding.decision === 'block') ? 10 : 0;
 }
 
+// resolveIntroduced maps each proposed update to the commits it introduces,
+// with the review contexts and local-authorship flags the scan needs. Shared
+// by refcheck (local ref updates) and pushcheck (about-to-be-pushed refs).
+// includeStagedContexts carries a staged review into the direct tip's scan;
+// pushcheck leaves it off because a pushed commit is judged as an object, not
+// against the live index it may never have passed through.
+function resolveIntroduced(repo, updates, { includeStagedContexts = true } = {}) {
+    const contextsByCommit = new Map();
+    // A commit's message belongs to whoever wrote it. Attribution and marker
+    // rules police the text a local developer can edit, so they are scoped
+    // to commits authored here: an update that introduces exactly one new
+    // commit on top of a non-zero old tip (a plain commit, an --amend, or a
+    // local --no-ff merge of an already-gated branch). Anything else — a new
+    // branch pulled in by `gh pr checkout` or `git fetch`, a merge of fetched
+    // history — imports other people's commit text the developer cannot
+    // change, and scanning it only blocks the review.
+    const localAuthorTips = new Set();
+    for (const update of updates) {
+        const introduced = introducedCommits(repo, [update]);
+        if (!/^0+$/.test(update.oldObjectId)
+            && introduced.length === 1
+            && introduced[0] === update.newObjectId) {
+            localAuthorTips.add(update.newObjectId);
+        }
+        for (const revision of introduced) {
+            const contexts = contextsByCommit.get(revision) || [];
+            contexts.push({
+                head: update.newObjectId,
+                storedTransition: revision,
+                scanTransition: revision,
+            });
+            // A staged review is bound to the exact old tip. It can be
+            // carried into the final full-snapshot scan only for the direct
+            // proposed tip whose parent is that old tip, never for an
+            // intermediate commit or a newly created branch ancestry.
+            if (includeStagedContexts && revision === update.newObjectId && !/^0+$/.test(update.oldObjectId)) {
+                const { parents } = commitParents(repo, revision);
+                if (parents.includes(update.oldObjectId)) {
+                    contexts.push({
+                        head: update.oldObjectId,
+                        storedTransition: 'staged',
+                        scanTransition: revision,
+                    });
+                }
+            }
+            contextsByCommit.set(revision, contexts);
+        }
+    }
+    return [...contextsByCommit].map(([revision, reviewContexts]) => [
+        revision,
+        reviewContexts,
+        localAuthorTips.has(revision),
+    ]);
+}
+
+// scanProposedCommits scans each introduced commit and returns the first
+// non-zero verdict. rejectNote(revision) supplies the caller-specific veto
+// line(s) printed after the findings; callers without a note pass null.
+function scanProposedCommits(repo, commits, { rejectNote }) {
+    const limits = scanLimits();
+    for (const [revision, reviewContexts, authoredLocally] of commits) {
+        let scan;
+        try {
+            scan = scanGitTarget(repo, {
+                kind: 'commit',
+                revision,
+                reviewContexts,
+                policyMigrationContexts: reviewContexts,
+                limits,
+                messageScope: authoredLocally ? 'commit' : 'changes-only',
+            });
+        }
+        catch (error) {
+            console.error(`aimhooman: cannot scan proposed commit ${revision}: ${error.message}`);
+            return expectedErrorCode(error);
+        }
+        emitDiagnostics(scan.diagnostics);
+        // The reference transaction is the final boundary --no-verify cannot
+        // skip, so an incomplete scan vetoes the update on every profile, even
+        // though earlier guards let frictionless profiles through with a
+        // warning. The single carve-out (a size-limit-only gap, see exitCode)
+        // warns here instead of vetoing.
+        const code = exitCode(scan.findings, scan.profile, scan.complete, {
+            failClosedIncomplete: true,
+            incompleteReasons: scan.incomplete_reasons,
+        });
+        if (code !== 0) {
+            process.stderr.write(human(scan.findings, tone()));
+            if (!scan.complete) process.stderr.write(incompleteMessage(scan));
+            if (rejectNote) process.stderr.write(rejectNote(revision));
+            return code;
+        }
+        if (!scan.complete) {
+            // The commit's tree is the staged tree pre-commit already warned
+            // about, so this is usually the duplicate the once-guard swallows.
+            // rev-parse runs only on this rare path.
+            let treeSha = null;
+            try {
+                treeSha = execFileSync('git', ['rev-parse', `${revision}^{tree}`], {
+                    cwd: repo.root,
+                    encoding: 'utf8',
+                    timeout: GIT_TIMEOUT_MS,
+                }).trim();
+            } catch { /* warn without dedup */ }
+            warnIncompleteOnce(repo, treeSha, scan);
+        }
+    }
+    return 0;
+}
+
+function cmdPushcheck(args) {
+    parseNoArguments(args);
+    let input;
+    try { input = readFileSync(0, 'utf8'); }
+    catch (error) {
+        console.error(`aimhooman: cannot read pre-push input: ${error.message}`);
+        return 30;
+    }
+    // pre-push lines: <local ref> <local oid> <remote ref> <remote oid>. The
+    // local ref name is irrelevant (it is the raw oid for a dangling push);
+    // what matters is which objects are about to be published. Deletions
+    // (zero local oid) carry nothing and were already filtered by the
+    // dispatcher, but belt-and-braces here since pushcheck can be driven
+    // directly.
+    const updates = [];
+    for (const line of input.split('\n').filter(Boolean)) {
+        const match = /^(\S+) (\S+) (\S+) (\S+)$/.exec(line);
+        if (!match) {
+            console.error('aimhooman: malformed pre-push input; push stopped');
+            return 30;
+        }
+        const [, , localOid, remoteRef, remoteOid] = match;
+        if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(localOid)
+            || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(remoteOid)) {
+            console.error('aimhooman: malformed object ID in pre-push input; push stopped');
+            return 30;
+        }
+        if (/^0+$/.test(localOid)) continue;
+        updates.push({ oldObjectId: remoteOid, newObjectId: localOid, ref: remoteRef });
+    }
+    if (!updates.length) return 0;
+    const repo = tryRepo();
+    if (!repo) {
+        // Same bare carve-out as refcheck: a global dispatcher must stay
+        // transparent where no worktree/index policy boundary exists.
+        if (currentRepositoryIsBare()) return 0;
+        console.error('aimhooman: not a git repository');
+        return 30;
+    }
+    let commits;
+    try {
+        // Every pushed commit gets its message scanned (final `true`):
+        // publishing is the act being gated, and a rejected commit pushed by
+        // raw oid has no local branch to vouch for its message. Reachability
+        // trust stays with refs/heads/*, exactly as in refcheck — remote
+        // tracking refs arrive ungated via fetch.
+        commits = resolveIntroduced(repo, updates, { includeStagedContexts: false })
+            .map(([revision, reviewContexts]) => [revision, reviewContexts, true]);
+    }
+    catch (error) {
+        console.error(`aimhooman: cannot resolve pushed commits: ${error.message}`);
+        return 30;
+    }
+    const code = scanProposedCommits(repo, commits, {
+        rejectNote: (revision) =>
+            `aimhooman: push of commit ${revision} was rejected before any objects were sent\n`,
+    });
+    if (code !== 0) return code;
+    // Same last-veto-point integrity check as refcheck: if a chained
+    // predecessor removed any required dispatcher, every profile stops.
+    if (dispatchHooksChanged(repo, 'clean')) return 20;
+    return 0;
+}
+
 function cmdRefcheck(args) {
     const { positionals } = parseArguments(args, {
         minPositionals: 1,
@@ -734,96 +940,24 @@ function cmdRefcheck(args) {
 
     let commits;
     try {
-        const contextsByCommit = new Map();
-        // A commit's message belongs to whoever wrote it. Attribution and marker
-        // rules police the text a local developer can edit, so they are scoped
-        // to commits authored here: an update that introduces exactly one new
-        // commit on top of a non-zero old tip (a plain commit, an --amend, or a
-        // local --no-ff merge of an already-gated branch). Anything else — a new
-        // branch pulled in by `gh pr checkout` or `git fetch`, a merge of fetched
-        // history — imports other people's commit text the developer cannot
-        // change, and scanning it only blocks the review.
-        const localAuthorTips = new Set();
-        for (const update of updates) {
-            const introduced = introducedCommits(repo, [update]);
-            if (!/^0+$/.test(update.oldObjectId)
-                && introduced.length === 1
-                && introduced[0] === update.newObjectId) {
-                localAuthorTips.add(update.newObjectId);
-            }
-            for (const revision of introduced) {
-                const contexts = contextsByCommit.get(revision) || [];
-                contexts.push({
-                    head: update.newObjectId,
-                    storedTransition: revision,
-                    scanTransition: revision,
-                });
-                // A staged review is bound to the exact old tip. It can be
-                // carried into the final full-snapshot scan only for the direct
-                // proposed tip whose parent is that old tip, never for an
-                // intermediate commit or a newly created branch ancestry.
-                if (revision === update.newObjectId && !/^0+$/.test(update.oldObjectId)) {
-                    const { parents } = commitParents(repo, revision);
-                    if (parents.includes(update.oldObjectId)) {
-                        contexts.push({
-                            head: update.oldObjectId,
-                            storedTransition: 'staged',
-                            scanTransition: revision,
-                        });
-                    }
-                }
-                contextsByCommit.set(revision, contexts);
-            }
-        }
-        commits = [...contextsByCommit].map(([revision, reviewContexts]) => [
-            revision,
-            reviewContexts,
-            localAuthorTips.has(revision),
-        ]);
+        commits = resolveIntroduced(repo, updates);
     }
     catch (error) {
         console.error(`aimhooman: cannot resolve proposed commits: ${error.message}`);
         return 30;
     }
-    const limits = scanLimits();
-    for (const [revision, reviewContexts, authoredLocally] of commits) {
-        let scan;
-        try {
-            scan = scanGitTarget(repo, {
-                kind: 'commit',
-                revision,
-                reviewContexts,
-                policyMigrationContexts: reviewContexts,
-                limits,
-                messageScope: authoredLocally ? 'commit' : 'changes-only',
-            });
-        }
-        catch (error) {
-            console.error(`aimhooman: cannot scan proposed commit ${revision}: ${error.message}`);
-            return expectedErrorCode(error);
-        }
-        emitDiagnostics(scan.diagnostics);
-        // The reference transaction is the final boundary --no-verify cannot
-        // skip, so an incomplete scan vetoes the update on every profile, even
-        // though earlier guards let frictionless profiles through with a
-        // warning.
-        const code = exitCode(scan.findings, scan.profile, scan.complete, { failClosedIncomplete: true });
-        if (code !== 0) {
-            process.stderr.write(human(scan.findings, tone()));
-            if (!scan.complete) process.stderr.write(incompleteMessage(scan));
-            process.stderr.write(`aimhooman: proposed commit ${revision} was rejected before refs changed\n`);
+    const code = scanProposedCommits(repo, commits, {
+        rejectNote: (revision) =>
+            `aimhooman: proposed commit ${revision} was rejected before refs changed\n`
             // The vetoed commit stays in the object store: the ref never
             // moved, but the bytes — including whatever triggered the block —
             // are still on disk. Whether gc collects it depends on other refs,
             // so phrase the cleanup as conditional; rotating an exposed secret
             // stays the operator's call either way.
-            process.stderr.write(
-                `aimhooman: note: the rejected commit object remains in the local object store; `
-                + "if nothing else references it, 'git gc --prune=now' removes it when you are done inspecting\n"
-            );
-            return code;
-        }
-    }
+            + 'aimhooman: note: the rejected commit object remains in the local object store; '
+            + "if nothing else references it, 'git gc --prune=now' removes it when you are done inspecting\n",
+    });
+    if (code !== 0) return code;
     // The reference-transaction hook is the last veto point. If its chained
     // predecessor removed any required dispatcher, every profile stops: there
     // is no downstream guard that can repair the lost boundary safely.
@@ -1645,9 +1779,13 @@ function cmdFix(args) {
                     ? `aimhooman: strict policy would remove ${repair.removed.length} exact attribution line(s); rerun with --apply to write the repair`
                     : 'aimhooman: strict policy found no automatically repairable attribution lines'
             );
+            // 11 asks a human to review the lines a repair would remove, which is
+            // only honest when the recheck saw the whole message. An incomplete
+            // recheck on strict fails closed (31) — the same verdict --apply
+            // reaches below for the same content.
             return remaining.some((finding) => finding.decision === 'block')
                 ? 10
-                : repair.removed.length ? 11 : exitCode(remaining, scan.profile, remainingComplete);
+                : repair.removed.length && remainingComplete ? 11 : exitCode(remaining, scan.profile, remainingComplete);
         }
     } else if (options.apply) {
         throw new ArgumentError('--apply is only needed when the active profile is strict');
@@ -1975,6 +2113,7 @@ function cmdUninstall(args) {
     for (const queue of [
         `${lifecycleLock}.queue`,
         `${repo.excludeFile}.aimhooman.lock.queue`,
+        `${join(repo.root, '.gitignore')}.aimhooman.lock.queue`,
         join(effectiveHooksDir(repo), '.aimhooman-hooks.lock.queue'),
     ]) {
         try { rmdirSync(queue); } catch { /* held by another aimhooman, or already gone */ }
@@ -2030,7 +2169,8 @@ Usage:
   aimhooman version
 
 Exit codes: 0 clean, 10 blocked, 11 review required, 20 invalid input or policy,
-30 Git or I/O failure, 31 incomplete scan.
+30 Git or I/O failure, 31 incomplete scan on strict or at the final ref guard
+(clean/compliance warn and continue).
 `);
 }