@rmyndharis/aimhooman 0.1.4 → 0.1.6

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
             "name": "aimhooman",
             "source": "./",
             "description": "Keeps AI session files, secrets, and unwanted attribution out at the agent and Git boundary.",
-            "version": "0.1.4",
+            "version": "0.1.6",
             "license": "MIT",
             "keywords": [
                 "git",
@@ -20,4 +20,4 @@
             ]
         }
     ]
-}
+}

package/.claude-plugin/plugin.json

@@ -1,9 +1,9 @@
 {
     "name": "aimhooman",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "AI works. Hoomans ship. Keeps AI session files, secrets, and unwanted attribution out at the agent and Git boundary.",
     "author": {
         "name": "aimhooman"
     },
     "hooks": "./hooks/hooks.json"
-}
+}

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "aimhooman",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "AI works. Hoomans ship. Keeps AI session files, secrets, and unwanted attribution out at the agent and Git boundary.",
     "author": {
         "name": "aimhooman maintainers",
@@ -34,4 +34,4 @@
         ],
         "brandColor": "#111827"
     }
-}
+}

package/CHANGELOG.md

@@ -5,6 +5,87 @@ 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.1.6] - 2026-07-18
+
+### Fixed
+
+- A tracked file over the per-file scan budget no longer blocks every commit in
+  the repository. 0.1.5 content-scanned the whole tree on every commit, so a 3 MiB
+  vendored bundle that crossed the 2 MiB default budget wedged every later commit
+  with `scan incomplete (size-limit=1)` — even one-line edits to an unrelated file
+  — and the only way out was to raise the budget above the largest tracked file.
+  Path rules still run on the full tree, so a staged `.env` stays blocked, but the
+  content scan now reads only the files a commit actually changes. Editing the
+  oversized file itself still fails the commit until the budget is raised.
+- An oversized file that is binary now skips as `binary` (complete) instead of
+  `size-limit` (incomplete). A PSD, WOFF, or PNG cannot hide the text-pattern
+  secrets the content scan looks for, so it was never really an incomplete scan.
+  The first 8 KB of each oversized file is probed for a NUL byte to tell binary
+  from text; files above 16 MiB stay `size-limit` without probing, because
+  `cat-file --batch` reads the whole blob into memory and probing a 500 MB file
+  just to check for NULs is not worth it. A text file over budget stays a real
+  `size-limit` skip, and the owner must raise `AIMHOOMAN_MAX_FILE_BYTES` to cover
+  it.
+- `secret.dotenv` now excepts `*.minimal`. A `.env.minimal` shipped as a template
+  was blocked by the same rule that catches a real `.env`, because `*.sample`,
+  `*.template`, `*.dist`, and `*.defaults` were excepted but `*.minimal` was not.
+  The rule's version bumps to 4.
+
+### Added
+
+- Incomplete-scan messages name the files that were dropped and why. A budget
+  miss used to print a count (`size-limit=3`) with no path, so the owner had to
+  hunt for the offender. The CLI now lists up to five skipped paths with their
+  sizes and reason, and the JSON scan report carries a `skippedPaths` object so a
+  caller can see every dropped file the same way. The schema documents the field.
+- `aimhooman explain` prints a rule's `except` clause when it has one, so an
+  `allow`/`deny` override can be reasoned about without opening the rule pack.
+
+## [0.1.5] - 2026-07-18
+
+### Fixed
+
+- AWS's own published example key no longer blocks a commit. 0.1.4 began matching bare
+  `AKIA…`/`ASIA…` access key IDs, which also matched `AKIAIOSFODNN7EXAMPLE` — the value AWS
+  prints in its own documentation, and one that lands in READMEs, Terraform samples, and test
+  fixtures. Because the rule's category is `secret`, neither a rule allow nor a plain path
+  allow is accepted, so a documentation example became an unconditional block on every profile
+  with only a per-file escape. Every AWS example key ends in `EXAMPLE`, so the pattern now
+  excludes that suffix and keeps blocking real keys. Path scoping was deliberately not used:
+  excluding `docs/` or `tests/` from secret scanning would hide genuine keys in the places they
+  most often leak.
+- `uninstall --purge-state` no longer leaves a backup behind in a linked worktree. Git writes
+  the commit message file into the per-worktree Git directory, so 0.1.4's sweep — which looked
+  only in the common directory — printed "state purged" with `COMMIT_EDITMSG.aimhooman-bak`
+  still on disk. Uninstall disarms every worktree at once, so it now sweeps the main Git
+  directory and each linked one, and matches the `.aimhooman-bak` suffix so a backup left by a
+  merge goes with it.
+- A plain `uninstall` keeps the attribution backup. It printed "state kept" and then deleted
+  the one file holding the lines stripped from the last commit message. Only `--purge-state`,
+  which promises to remove everything, takes it now.
+- Sweeping an empty lock queue can no longer stop a concurrent `aimhooman init`. Between its
+  `mkdir` and its first publication a lock contender owns no file in the queue, so the sweep
+  saw an empty directory and removed it, and the contender then failed on a bare `ENOENT`. The
+  window is wide enough to lose because building the candidate probes the process identity,
+  which spawns `ps` on macOS and BSD. Publication now recreates the directory and retries once.
+- The unstage summary no longer claims the files were "kept in your working tree". That is
+  false when a path was staged and then deleted before the commit, and when a staged deletion
+  is unstaged — the file is absent either way, though aimhooman never removed it. Unstaging
+  only ever touches the index, so the note says that instead of guessing where the file is.
+
+### Changed
+
+- An ordinary commit no longer pays a Node cold start for a phase that does nothing. Git fires
+  `reference-transaction` twice per commit, and `refcheck` returns immediately for `committed`
+  and `aborted`, so the dispatcher now short-circuits those phases in the shell — after the
+  chained-hook call, so a chained hook still sees every phase. Measured locally, an ordinary
+  commit drops from about 870ms to about 710ms. The `prepared` scan, and the `--no-verify`
+  backstop that rides on it, are unchanged. A repository installed with an earlier release
+  keeps a valid dispatcher; re-run `aimhooman init` to pick up the faster one.
+- The attribution backup no longer lingers indefinitely. `commit-msg` clears the previous run's
+  backup before it may write its own, so at most one exists at a time and a later clean commit
+  leaves none. The recovery window is now until your next commit rather than unbounded.
+
 ## [0.1.4] - 2026-07-18
 
 ### Fixed

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.1.4-blue" alt="v0.1.4">
+  <img src="https://img.shields.io/badge/version-v0.1.6-blue" alt="v0.1.6">
   <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">

package/bin/aimhooman.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { execFileSync } from 'node:child_process';
-import { chmodSync, lstatSync, readFileSync, rmdirSync, rmSync } from 'node:fs';
+import { chmodSync, lstatSync, readdirSync, readFileSync, rmdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { GIT_TIMEOUT_MS } from '../src/git-environment.mjs';
@@ -212,7 +212,24 @@ function incompleteMessage(scan) {
         : budgeted
             ? 'reduce the target, or raise AIMHOOMAN_MAX_FILE_BYTES / AIMHOOMAN_MAX_TOTAL_BYTES, and retry'
             : 'reduce the target or limits and retry';
-    return `aimhooman: scan incomplete${skipped ? ` (${skipped})` : ''}; ${hint}\n`;
+    let message = `aimhooman: scan incomplete${skipped ? ` (${skipped})` : ''}; ${hint}\n`;
+    const skippedPaths = scan.stats?.skippedPaths || {};
+    const pathLines = [];
+    for (const [reason, entries] of Object.entries(skippedPaths)) {
+        for (const entry of entries.slice(0, 5)) {
+            const sizeStr = formatBytes(entry.size);
+            pathLines.push(`  skipped: ${entry.path} (${reason}, ${sizeStr})\n`);
+        }
+        if (entries.length > 5) pathLines.push(`  ... and ${entries.length - 5} more\n`);
+    }
+    return message + pathLines.join('');
+}
+
+function formatBytes(bytes) {
+    if (bytes == null || bytes < 0) return '?';
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
 function snapshotFile(path) {
@@ -372,7 +389,7 @@ function cmdPrecommit(args) {
         emptied = stagedBefore !== null
             && stagedBefore.every((path) => unstageTargets.has(path));
         process.stderr.write(
-            `aimhooman: unstaged ${paths.length} file(s) from this commit: ${paths.map(visible).join(', ')}${emptied ? ' — nothing else was staged, so the commit is stopped rather than left empty' : ''}\n`
+            `aimhooman: unstaged ${paths.length} file(s) from this commit: ${paths.map(visible).join(', ')} (index only; nothing on disk was deleted)${emptied ? ' — nothing else was staged, so the commit is stopped rather than left empty' : ''}\n`
         );
     } catch (e) {
         process.stderr.write(
@@ -409,6 +426,10 @@ function cmdCommitmsg(args) {
     const file = positionals[0];
     const repo = tryRepo();
     if (!repo) { console.error('aimhooman: not a git repository'); return 30; }
+    // A .aimhooman-bak from an earlier commit went stale the moment that commit
+    // finished, and git reuses this message path. Clear the previous run's backup
+    // now, before this run may write its own, so at most one ever lingers.
+    try { rmSync(`${file}.aimhooman-bak`, { force: true }); } catch { /* best effort */ }
     // Frictionless profiles (clean/compliance) never cancel a commit merely
     // because the message file cannot be read; only strict fails closed.
     let hookProfile = 'clean';
@@ -974,6 +995,7 @@ function cmdExplain(args) {
     console.log(`Actions:     clean=${af('clean')} strict=${af('strict')} compliance=${af('compliance')}`);
     console.log(`Reason:      ${r.reason}`);
     if (r.match?.paths) console.log(`Paths:       ${r.match.paths.join(', ')}`);
+    if (r.match?.except) console.log(`Except:      ${r.match.except.join(', ')}`);
     if (r.match?.content) console.log(`Content:     ${r.match.content.join(', ')}`);
     if (r.remediation?.length) {
         console.log('Remediation:');
@@ -1696,9 +1718,29 @@ function cmdUninstall(args) {
     ]) {
         try { rmdirSync(queue); } catch { /* held by another aimhooman, or already gone */ }
     }
-    // A one-commit-ago attribution backup that git's next COMMIT_EDITMSG makes stale.
-    try { rmSync(join(repo.commonDir, 'COMMIT_EDITMSG.aimhooman-bak'), { force: true }); }
-    catch { /* nothing to remove */ }
+    // The attribution backup is the user's only copy of the lines stripped from
+    // their last message — commit-msg already clears the previous one, so what
+    // survives here is current, not stale. A plain uninstall says "state kept"
+    // and must not delete it; only --purge-state, which promises to remove
+    // everything, sweeps it. Git names the message file per operation
+    // (COMMIT_EDITMSG, MERGE_MSG, ...) and the backup inherits that name, so
+    // match the suffix rather than one filename. It lands beside that file, in
+    // the per-worktree git directory rather than the common one, and uninstall
+    // disarms every worktree at once — so cover the main one and each linked.
+    if (purge) {
+        const messageDirs = [repo.commonDir];
+        try {
+            const linked = join(repo.commonDir, 'worktrees');
+            for (const name of readdirSync(linked)) messageDirs.push(join(linked, name));
+        } catch { /* no linked worktrees */ }
+        for (const dir of messageDirs) {
+            try {
+                for (const name of readdirSync(dir)) {
+                    if (name.endsWith('.aimhooman-bak')) rmSync(join(dir, name), { force: true });
+                }
+            } catch { /* directory missing or unreadable */ }
+        }
+    }
     return exitStatus;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rmyndharis/aimhooman",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "AI works. Hoomans ship. Keep AI session files, secrets, and attribution out of your commits.",
     "homepage": "https://github.com/rmyndharis/aimhooman#readme",
     "repository": {
@@ -74,4 +74,4 @@
         "developer-tools",
         "pre-commit"
     ]
-}
+}

package/rules/paths.json

@@ -218,7 +218,7 @@
     },
     {
         "id": "secret.dotenv",
-        "version": 3,
+        "version": 4,
         "provider": "generic",
         "category": "secret",
         "confidence": "high",
@@ -236,7 +236,8 @@
                 "**/*.sample",
                 "**/*.template",
                 "**/*.dist",
-                "**/*.defaults"
+                "**/*.defaults",
+                "**/*.minimal"
             ]
         },
         "actions": {

package/rules/secrets.json

@@ -53,7 +53,7 @@
         "match": {
             "content": [
                 "(?i)\\baws_(?:secret_access_key|session_token)\\b\\s*[:=]\\s*[\\\"']?[A-Za-z0-9/+=]{32,}(?![A-Za-z0-9/+=])",
-                "\\b(?:AKIA|ASIA)[A-Z0-9]{16}\\b"
+                "\\b(?:AKIA|ASIA)(?![A-Z0-9]{9}EXAMPLE\\b)[A-Z0-9]{16}\\b"
             ]
         },
         "actions": {

package/schemas/scan-report.schema.json

@@ -82,6 +82,21 @@
                 "skipped": {
                     "type": "object",
                     "additionalProperties": { "type": "integer", "minimum": 1 }
+                },
+                "skippedPaths": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "required": ["path", "size"],
+                            "properties": {
+                                "path": { "type": "string" },
+                                "size": { "type": ["integer", "null"], "minimum": 0 }
+                            },
+                            "additionalProperties": false
+                        }
+                    }
                 }
             },
             "additionalProperties": false

package/src/atomic-write.mjs

@@ -259,18 +259,34 @@ export function withLock(lockPath, fn, options = {}) {
     let held = false;
     let published = false;
     let primaryError = null;
+    // Between the mkdir above and the first publication below this contender owns
+    // no file in the queue, so a concurrent cleanup that removes empty queue
+    // directories — `aimhooman uninstall` sweeps them — can delete it out from
+    // under us. The gap is wide enough to lose: building the candidate probes the
+    // process identity, which spawns `ps` on macOS and BSD. Recreate and retry
+    // once rather than failing the caller with a bare ENOENT. Once a candidate is
+    // published the directory is no longer empty, so no cleanup can remove it.
+    const publish = () => {
+        try {
+            publishCandidate(candidatePath, candidate, options.candidateOperations);
+        } catch (error) {
+            if (error?.code !== 'ENOENT') throw error;
+            mkdirSync(queueDir, { recursive: true });
+            publishCandidate(candidatePath, candidate, options.candidateOperations);
+        }
+    };
     try {
         // Own the UUID pathname before publication begins. If the rename lands
         // but its directory fsync fails, finally still removes the candidate;
         // unlinking ENOENT is harmless when publication failed earlier.
         published = true;
-        publishCandidate(candidatePath, candidate, options.candidateOperations);
+        publish();
         const observed = queueCandidates(queueDir, staleMs);
         candidate.ticket = observed.reduce((maximum, peer) => (
             peer.ticket === null ? maximum : Math.max(maximum, peer.ticket)
         ), 0) + 1;
         candidate.choosing = false;
-        publishCandidate(candidatePath, candidate, options.candidateOperations);
+        publish();
 
         for (let attempt = 0; attempt < retries; attempt += 1) {
             // A file at the pre-queue lock path may belong to a concurrently

package/src/githooks.mjs

@@ -642,6 +642,14 @@ function hookScript(name, cmd, cliPath, chainedPath) {
     const aimInvocation = name === 'reference-transaction'
         ? `printf '%s\\n' "$AIMHOOMAN_REF_UPDATES" | run_aimhooman ${aimCommand} || exit $?`
         : `run_aimhooman ${aimCommand} || exit $?`;
+    // committed/aborted fire only after refs are locked in, and refcheck can do
+    // nothing but return 0 for them (see cmdRefcheck). Short-circuit in the shell
+    // so an ordinary commit no longer pays a Node cold start for the committed
+    // phase. Placed after the chained-hook call, so a chained hook still sees
+    // every phase.
+    const phaseShortCircuit = name === 'reference-transaction'
+        ? 'case "$1" in committed|aborted) exit 0 ;; esac\n'
+        : '';
     const template = `#!/bin/sh -p
 ${MARKER} (${name})
 # aimhooman-hook-version: ${HOOK_FORMAT_VERSION}
@@ -691,7 +699,7 @@ fi
 if [ -x "$CHAINED" ]; then
 ${chainedInvocation}
 fi
-${aimInvocation}
+${phaseShortCircuit}${aimInvocation}
 `;
     const fingerprint = hookFingerprint(template);
     return template.replace(FINGERPRINT_PLACEHOLDER, fingerprint);

package/src/scan-session.mjs

@@ -18,9 +18,11 @@ export function scanEntries(repo, engine, entries, options = {}) {
         findings_total: 0,
         findings_returned: 0,
         skipped: {},
+        skippedPaths: {},
     };
     const candidates = [];
     let selectedBytes = 0;
+    const oversized = [];
 
     for (const entry of entries) {
         if (entry.type !== 'blob') {
@@ -37,17 +39,48 @@ export function scanEntries(repo, engine, entries, options = {}) {
             continue;
         }
         if (entry.size > limits.maxFileBytes) {
-            increment(stats.skipped, 'size-limit');
+            oversized.push(entry);
             continue;
         }
         if (selectedBytes + entry.size > limits.maxTotalBytes) {
             increment(stats.skipped, 'total-byte-limit');
+            appendPath(stats.skippedPaths, 'total-byte-limit', entry.path, entry.size);
             continue;
         }
         selectedBytes += entry.size;
         candidates.push(entry);
     }
 
+    // Oversized files: probe the first 8 KB to separate binary from text.
+    // A binary file (PSD, WOFF, PNG) can't hide text-pattern secrets that
+    // the full content scan would find, so it skips as 'binary' (complete).
+    // A text file that exceeds the budget is a genuine 'size-limit' skip
+    // (incomplete) and the caller must raise the limit to cover it.
+    // Cap probing at 16 MiB: cat-file --batch reads the full blob into memory,
+    // so probing a 500 MB file just to check for NULs is wasteful. Files above
+    // the cap are classified as size-limit without probing.
+    const PROBE_CAP = 16 * 1024 * 1024;
+    const probeable = oversized.filter((entry) => entry.size <= PROBE_CAP);
+    const tooBig = oversized.filter((entry) => entry.size > PROBE_CAP);
+    for (const entry of tooBig) {
+        increment(stats.skipped, 'size-limit');
+        appendPath(stats.skippedPaths, 'size-limit', entry.path, entry.size);
+    }
+    if (probeable.length) {
+        const probeOids = [...new Set(probeable.map((entry) => entry.oid))];
+        const probes = probeObjects(repo, probeOids, probeable);
+        for (const entry of probeable) {
+            const header = probes.get(entry.oid);
+            if (header && isBinary(header)) {
+                increment(stats.skipped, 'binary');
+                appendPath(stats.skippedPaths, 'binary', entry.path, entry.size);
+            } else {
+                increment(stats.skipped, 'size-limit');
+                appendPath(stats.skippedPaths, 'size-limit', entry.path, entry.size);
+            }
+        }
+    }
+
     const objectIds = [...new Set(candidates.map((entry) => entry.oid))];
     const batch = readObjects(repo, objectIds, selectedBytes);
     stats.objects_read = batch.objects.size;
@@ -65,6 +98,7 @@ export function scanEntries(repo, engine, entries, options = {}) {
         let matched;
         if (isBinary(blob)) {
             increment(stats.skipped, 'binary');
+            appendPath(stats.skippedPaths, 'binary', entry.path, blob.length);
             // Binary classification only skips text-oriented policy rules. Secret
             // signatures are ASCII byte sequences, so latin1 preserves a
             // one-byte-to-one-code-unit view and keeps the existing byte limits.
@@ -148,10 +182,55 @@ function readObjects(repo, objectIds, expectedBytes = 0) {
     return { objects, failures };
 }
 
+// probeObjects reads the first 8000 bytes of each blob to decide whether it is
+// binary (contains a NUL). cat-file --batch outputs full blobs, so the buffer
+// must accommodate total blob sizes, but we only inspect the leading bytes.
+function probeObjects(repo, objectIds, entries) {
+    const unique = [...new Set(objectIds.filter(Boolean))];
+    if (!unique.length) return new Map();
+    const PROBE_BYTES = 8000;
+    // Sum the actual sizes so the buffer can hold the full output.
+    const sizeByOid = new Map();
+    for (const entry of entries) {
+        if (entry.oid && entry.size > 0) sizeByOid.set(entry.oid, Math.max(sizeByOid.get(entry.oid) || 0, entry.size));
+    }
+    const totalExpected = unique.reduce((sum, oid) => sum + (sizeByOid.get(oid) || 0), 0);
+    const output = execFileSync('git', ['cat-file', '--batch'], {
+        cwd: repo.root,
+        env: gitEnvironment(),
+        input: Buffer.from(unique.join('\n') + '\n'),
+        encoding: 'buffer',
+        maxBuffer: Math.max(2 * 1024 * 1024, totalExpected + unique.length * 256 + 1024),
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const probes = new Map();
+    let offset = 0;
+    for (const requested of unique) {
+        const newline = output.indexOf(0x0a, offset);
+        if (newline < 0) break;
+        const header = output.subarray(offset, newline).toString('utf8');
+        offset = newline + 1;
+        const fields = header.split(' ');
+        if (fields[1] === 'missing' || fields.length !== 3 || fields[1] !== 'blob') continue;
+        const size = Number(fields[2]);
+        const end = offset + size;
+        if (end > output.length || output[end] !== 0x0a) break;
+        probes.set(requested, output.subarray(offset, offset + Math.min(size, PROBE_BYTES)));
+        offset = end + 1;
+    }
+    return probes;
+}
+
 function increment(record, key) {
     record[key] = (record[key] || 0) + 1;
 }
 
+function appendPath(record, reason, path, size) {
+    if (!record[reason]) record[reason] = [];
+    if (record[reason].length < 10) record[reason].push({ path, size });
+}
+
 function isBinary(buffer) {
     const length = Math.min(buffer.length, 8000);
     for (let index = 0; index < length; index++) if (buffer[index] === 0) return true;

package/src/scan-target.mjs

@@ -217,6 +217,7 @@ function scanCommit(repo, options) {
     }
     scanEntryGroup(repo, loaded.engine, snapshot.entries, policy, accumulator, {
         reviewPathEntries: snapshot.changes,
+        contentEntries: snapshot.changes,
         allowMissingPolicy: acknowledged && !rawPolicy.policy_object_id,
         transition: snapshot.commit,
     });
@@ -367,8 +368,15 @@ function scanEntryGroup(repo, engine, entries, policy, accumulator, options = {}
         })
             .map((finding) => decorate(finding, entry, policy)));
     }
+    // Content scanning can target a narrower set than the path check. When
+    // contentEntries is provided (e.g. only changed files in a commit), read
+    // blobs only for those entries instead of the full snapshot. Path-based
+    // rules already ran on the full tree above, so secrets like .env are still
+    // caught even when their blob isn't re-read.
+    const contentScannable = (options.contentEntries ?? entries)
+        .filter((entry) => entry.status !== 'D' && entry.type !== 'deleted');
     const remaining = accumulator.remaining();
-    const scanned = scanEntries(repo, engine, scannable, {
+    const scanned = scanEntries(repo, engine, contentScannable, {
         maxFileBytes: accumulator.limits.maxFileBytes,
         maxTotalBytes: accumulator.remainingBytes(),
         maxFindings: remaining,
@@ -628,6 +636,7 @@ function createAccumulator(limits = {}) {
         findings_total: 0,
         findings_returned: 0,
         skipped: {},
+        skippedPaths: {},
     };
     let complete = true;
 
@@ -665,6 +674,12 @@ function createAccumulator(limits = {}) {
             for (const [reason, count] of Object.entries(scanned.stats.skipped || {})) {
                 stats.skipped[reason] = (stats.skipped[reason] || 0) + count;
             }
+            for (const [reason, paths] of Object.entries(scanned.stats.skippedPaths || {})) {
+                if (!stats.skippedPaths[reason]) stats.skippedPaths[reason] = [];
+                for (const entry of paths) {
+                    if (stats.skippedPaths[reason].length < 10) stats.skippedPaths[reason].push(entry);
+                }
+            }
             if (!scanned.complete) complete = false;
         },
         addSkipped(skipped = {}) {