claudemd-cli 0.71.4 → 0.73.0

package/bin/claudemd-lint.js

@@ -111,9 +111,13 @@ function readCommitTemplate(sourcePath) {
 
   for (const cwd of starts) {
     try {
-      const git = (...a) => spawnSync('git', a, {
-        cwd, encoding: 'utf8', timeout: 5000, windowsHide: true,
-      });
+      const git = (...a) =>
+        spawnSync('git', a, {
+          cwd,
+          encoding: 'utf8',
+          timeout: 5000,
+          windowsHide: true,
+        });
 
       const cfg = git('config', '--get', 'commit.template');
       if (cfg.status !== 0 || !cfg.stdout || !cfg.stdout.trim()) continue;
@@ -152,17 +156,17 @@ function lintCmd(rawArgs) {
     rawArgs,
     ['--json', '--stdin', '--commit-msg', '--no-commit-msg'],
     ['--file', '--comment-char'],
-    'lint',
+    'lint'
   );
-  const json = args.includes('--json');     // argv-lint:allow — validated upstream by validateAndExpandFlags
-  const stdin = args.includes('--stdin');   // argv-lint:allow — validated upstream by validateAndExpandFlags
+  const json = args.includes('--json'); // argv-lint:allow — validated upstream by validateAndExpandFlags
+  const stdin = args.includes('--stdin'); // argv-lint:allow — validated upstream by validateAndExpandFlags
 
   // Commit-message cleanup mode. `--commit-msg` forces it on (needed for the
   // `cat "$1" | claudemd-cli lint --stdin` shape, where there is no filename
   // to key off), `--no-commit-msg` forces it off, otherwise it is inferred
   // from the input FILENAME below.
-  const forceCommitMsg = args.includes('--commit-msg');       // argv-lint:allow — validated upstream by validateAndExpandFlags
-  const denyCommitMsg = args.includes('--no-commit-msg');     // argv-lint:allow — validated upstream by validateAndExpandFlags
+  const forceCommitMsg = args.includes('--commit-msg'); // argv-lint:allow — validated upstream by validateAndExpandFlags
+  const denyCommitMsg = args.includes('--no-commit-msg'); // argv-lint:allow — validated upstream by validateAndExpandFlags
   if (forceCommitMsg && denyCommitMsg) {
     process.stderr.write('lint: choose one of --commit-msg or --no-commit-msg, not both\n');
     process.exit(2);
@@ -193,7 +197,7 @@ function lintCmd(rawArgs) {
 
   // --file <path> consumes the next non-flag arg.
   let filePath = null;
-  const fileIdx = args.indexOf('--file');   // argv-lint:allow — validated upstream by validateAndExpandFlags
+  const fileIdx = args.indexOf('--file'); // argv-lint:allow — validated upstream by validateAndExpandFlags
   if (fileIdx !== -1) {
     const next = args[fileIdx + 1];
     if (!next || next.startsWith('--')) {
@@ -253,7 +257,9 @@ function lintCmd(rawArgs) {
     try {
       const st = fs.statSync(filePath);
       if (!st.isFile()) {
-        process.stderr.write(`lint: '${filePath}' is not a regular file (got ${st.isDirectory() ? 'directory' : 'special file'})\n`);
+        process.stderr.write(
+          `lint: '${filePath}' is not a regular file (got ${st.isDirectory() ? 'directory' : 'special file'})\n`
+        );
         process.exit(2);
       }
     } catch (e) {
@@ -304,7 +310,9 @@ function lintCmd(rawArgs) {
           text = fs.readFileSync(arg, 'utf8');
           sourcePath = arg;
         } else if (looksLikePath) {
-          process.stderr.write(`lint: '${arg}' is not a regular file (use --file PATH for explicit file scan or quote literal text)\n`);
+          process.stderr.write(
+            `lint: '${arg}' is not a regular file (use --file PATH for explicit file scan or quote literal text)\n`
+          );
           process.exit(2);
         }
         // Non-path-shape + non-file (e.g. a symlink loop, fifo) → fall through to text scan.
@@ -349,7 +357,9 @@ function lintCmd(rawArgs) {
   const ESCAPE_HATCH = '[allow-banned-vocab]';
   if (text.includes(ESCAPE_HATCH)) {
     if (json) {
-      process.stdout.write(formatJSON({ scope: 'lint', text, hits: [], bypass: 'allow-banned-vocab', commitMsgCleanup }) + '\n');
+      process.stdout.write(
+        formatJSON({ scope: 'lint', text, hits: [], bypass: 'allow-banned-vocab', commitMsgCleanup }) + '\n'
+      );
     } else {
       process.stdout.write(`OK: §10-V scan bypassed via ${ESCAPE_HATCH}.\n`);
     }
@@ -384,8 +394,8 @@ function lintCmd(rawArgs) {
 
 function auditCmd(rawArgs) {
   const args = validateAndExpandFlags(rawArgs, ['--json', '--include-ratio'], [], 'audit');
-  const json = args.includes('--json');                   // argv-lint:allow — validated upstream by validateAndExpandFlags
-  const includeRatio = args.includes('--include-ratio');  // argv-lint:allow — validated upstream by validateAndExpandFlags
+  const json = args.includes('--json'); // argv-lint:allow — validated upstream by validateAndExpandFlags
+  const includeRatio = args.includes('--include-ratio'); // argv-lint:allow — validated upstream by validateAndExpandFlags
   const positional = args.filter(a => !a.startsWith('--'));
   const transcriptPath = positional[0];
 
@@ -403,7 +413,9 @@ function auditCmd(rawArgs) {
   try {
     const st = fs.statSync(transcriptPath);
     if (!st.isFile()) {
-      process.stderr.write(`audit: '${transcriptPath}' is not a regular file (got ${st.isDirectory() ? 'directory' : 'special file'})\n`);
+      process.stderr.write(
+        `audit: '${transcriptPath}' is not a regular file (got ${st.isDirectory() ? 'directory' : 'special file'})\n`
+      );
       process.exit(2);
     }
   } catch (e) {
@@ -435,12 +447,21 @@ function auditCmd(rawArgs) {
     let sawTypeField = false;
     for (const l of nonEmptyLines) {
       let row;
-      try { row = JSON.parse(l); } catch { continue; }
+      try {
+        row = JSON.parse(l);
+      } catch {
+        continue;
+      }
       parsedAny = true;
-      if (row && typeof row === 'object' && row.type !== undefined) { sawTypeField = true; break; }
+      if (row && typeof row === 'object' && row.type !== undefined) {
+        sawTypeField = true;
+        break;
+      }
     }
     if (!parsedAny) {
-      process.stderr.write(`audit: no parseable JSON rows in ${transcriptPath} (expected JSONL transcript with one JSON object per line)\n`);
+      process.stderr.write(
+        `audit: no parseable JSON rows in ${transcriptPath} (expected JSONL transcript with one JSON object per line)\n`
+      );
       process.exit(2);
     }
     // Parseable JSON but NO row carries a `type` field → not a Claude Code
@@ -452,12 +473,27 @@ function auditCmd(rawArgs) {
     // literal-string-scan bugs. A legit transcript whose only rows are
     // non-assistant still has `type`, so it passes this gate and exits 0.
     if (!sawTypeField) {
-      process.stderr.write(`audit: ${transcriptPath} parses as JSON but no row has a 'type' field — does not look like a Claude Code transcript (expected rows like {"type":"assistant",...}). Wrong file?\n`);
+      process.stderr.write(
+        `audit: ${transcriptPath} parses as JSON but no row has a 'type' field — does not look like a Claude Code transcript (expected rows like {"type":"assistant",...}). Wrong file?\n`
+      );
       process.exit(2);
     }
   }
 
-  const turns = parseTranscript(jsonl);
+  // `integrity` counts the rows parseTranscript drops. The pre-flight above
+  // only catches an ENTIRELY unparseable file; a transcript that is 30%
+  // corrupt passed it and then printed "no §10-V hits across N turn(s)" with N
+  // silently short (audit R11-24). Same warning shape as the string-row skip
+  // below — the verdict still comes from the rows that parsed, but the reader
+  // is told how many did not.
+  const integrity = { totalLines: 0, badLines: 0 };
+  const turns = parseTranscript(jsonl, integrity);
+  if (integrity.badLines > 0) {
+    process.stderr.write(
+      `audit: warning: skipped ${integrity.badLines} of ${integrity.totalLines} non-empty line(s) ` +
+        `that did not parse as JSON — the turn count below covers only the rows that parsed.\n`
+    );
+  }
   // QA ISSUE-002 (option c): string-shape assistant rows are outside the
   // block-array input domain and never reach the scanner. Keep the verdict
   // based on scanned turns, but say so on stderr — a silent skip here is the
@@ -468,8 +504,8 @@ function auditCmd(rawArgs) {
   if (skippedStringRows > 0) {
     process.stderr.write(
       `audit: warning: skipped ${skippedStringRows} assistant row(s) with string-shape ` +
-      `message.content — not the Claude Code block-array shape, so their text was NOT scanned. ` +
-      `Non-CC transcript export?\n`
+        `message.content — not the Claude Code block-array shape, so their text was NOT scanned. ` +
+        `Non-CC transcript export?\n`
     );
   }
   const patterns = readPatterns();
@@ -491,7 +527,9 @@ function auditCmd(rawArgs) {
   const flaggedCount = annotated.reduce((n, t) => n + (t.hits.length > 0 ? 1 : 0), 0);
 
   if (json) {
-    process.stdout.write(formatJSON({ scope: 'audit', transcript: transcriptPath, turns: annotated }) + '\n');
+    process.stdout.write(
+      formatJSON({ scope: 'audit', transcript: transcriptPath, turns: annotated, integrity }) + '\n'
+    );
   } else {
     const out = formatHumanReadable({ scope: 'audit', turns: annotated });
     if (flaggedCount === 0) process.stdout.write(out + '\n');
@@ -506,7 +544,8 @@ function main() {
   // meant `claudemd-cli lint --help` exited 2 with "unknown flag '--help'" — the
   // exact discoverability bug lib/argv.js#printHelpAndExit was written to fix,
   // which this CLI predates.
-  if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {  // argv-lint:allow — help detection runs before subcommand routing; --help takes no value
+  // argv-lint:allow — help detection runs before subcommand routing; --help takes no value
+  if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
     process.stdout.write(USAGE + '\n');
     process.exit(argv.length === 0 ? 2 : 0);
   }
@@ -516,8 +555,10 @@ function main() {
   }
   const sub = argv[0];
   switch (sub) {
-    case 'lint':  return lintCmd(argv.slice(1));
-    case 'audit': return auditCmd(argv.slice(1));
+    case 'lint':
+      return lintCmd(argv.slice(1));
+    case 'audit':
+      return auditCmd(argv.slice(1));
     default:
       process.stderr.write(`unknown subcommand: ${sub}\n${USAGE}\n`);
       process.exit(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudemd-cli",
-  "version": "0.71.4",
+  "version": "0.73.0",
   "description": "Standalone CLI for §10-V banned-vocab + transcript scanning. Companion to the claudemd Claude Code plugin (github.com/sdsrss/claudemd) for use in git pre-commit hooks, GitHub Actions, and other agents.",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
   "scripts": {
     "test": "bash tests/run-all.sh",
     "test:scripts": "bash -c 'source tests/lib/env-hygiene.sh && claudemd_reset_test_env && node --test tests/scripts/*.test.js'",
-    "test:hooks": "for t in tests/hooks/*.test.sh; do bash \"$t\" || exit 1; done",
+    "test:hooks": "bash -c 'source tests/lib/env-hygiene.sh && claudemd_reset_test_env && source tests/lib/run-suite.sh && for t in tests/hooks/*.test.sh; do run_suite \"$t\" 300 || exit 1; done'",
     "lint:argv": "node scripts/lint-argv.js",
     "version-check": "node scripts/version-cascade-check.js",
     "test:coverage": "c8 --all --src=bin --src=scripts --include='bin/**/*.js' --include='scripts/**/*.js' --reporter=text-summary --reporter=html --reports-dir=coverage npm run test:scripts",

package/scripts/lib/argv.js

@@ -12,7 +12,10 @@
 // exit 1) so wrappers can tell parsing-shape errors from validation errors.
 
 export class ArgvError extends Error {
-  constructor(message) { super(message); this.name = 'ArgvError'; }
+  constructor(message) {
+    super(message);
+    this.name = 'ArgvError';
+  }
 }
 
 // Discoverability helper: when `--help` or `-h` is the first non-empty arg
@@ -37,6 +40,39 @@ export function printHelpAndExit(argv, usage) {
 // despite help text promising a "positive integer", a silent contract
 // divergence (inverse of the `parseInt` truncation footgun). Mirrors the
 // `/^[1-9][0-9]*$/` guard already used for CLAUDEMD_BATCH_THRESHOLD in status.js.
+// resolveDaysFlag / resolveDaysListFlag — the `--days` precedence, once.
+//
+// Five scripts carried the same expression with five different env-var names
+// (CLAUDEMD_{AUDIT,RULES,SPARKLINE,SAMPLING,BYPASS}_DAYS), so the RULE — flag
+// beats env, an EMPTY env falls back to the default, and the result must be a
+// plain positive integer — lived nowhere and had to be re-derived by whoever
+// added the sixth (2026-09-02 audit R11-13e). The per-script `--days` examples
+// in the error text stay with each script; only the resolution moves here.
+//
+// Returns `{ raw, days }` (or `{ raw, windows }`), with the parsed value null on
+// a bad shape, matching parsePositiveInt's contract: the CLI decides what to
+// print and which exit code to use, a library does not call process.exit.
+export function resolveDaysFlag(parsed, { env, dflt }) {
+  // `||` not `??` on the env read, deliberately: `CLAUDEMD_AUDIT_DAYS=` (set but
+  // empty, the shape an unset shell variable takes in a wrapper) means "no
+  // preference", not "the empty string is my answer".
+  const raw = parsed.values['--days'] ?? (process.env[env] || String(dflt));
+  return { raw, days: parsePositiveInt(raw) };
+}
+
+// The comma-separated variant (sparkline's three trend windows). `windows` is
+// null when any element fails to parse or fewer than `min` survive — one null in
+// the middle of a list is as useless as an unparseable scalar, and returning a
+// partial list is how '1.5,2,3' silently became [1,2,3] with a wrong header.
+export function resolveDaysListFlag(parsed, { env, dflt, min = 2 }) {
+  const raw = parsed.values['--days'] ?? (process.env[env] || String(dflt));
+  const windows = String(raw)
+    .split(',')
+    .map(x => parsePositiveInt(x));
+  const ok = windows.length >= min && !windows.some(w => w === null);
+  return { raw, windows: ok ? windows : null };
+}
+
 export function parsePositiveInt(raw) {
   if (raw == null) return null;
   const s = String(raw).trim();
@@ -62,12 +98,18 @@ export function parseStrict(argv, { bools = [], values = [] } = {}) {
   const knownBool = new Set(bools);
   const knownValue = new Set(values);
   for (const a of argv) {
-    if (knownBool.has(a)) { out.bools.add(a); continue; }
+    if (knownBool.has(a)) {
+      out.bools.add(a);
+      continue;
+    }
     if (a.startsWith('--') && a.includes('=')) {
       const eq = a.indexOf('=');
       const k = a.slice(0, eq);
       const v = a.slice(eq + 1);
-      if (knownValue.has(k)) { out.values[k] = v; continue; }
+      if (knownValue.has(k)) {
+        out.values[k] = v;
+        continue;
+      }
       if (knownBool.has(k)) {
         throw new ArgvError(`Boolean flag '${k}' does not take a value (got '${a}').`);
       }
@@ -106,13 +148,18 @@ export function validateAndExpandFlags(args, knownBools, knownValues, sub) {
   const bools = new Set(knownBools);
   const values = new Set(knownValues);
   for (const a of args) {
-    if (!a.startsWith('--')) { out.push(a); continue; }
+    if (!a.startsWith('--')) {
+      out.push(a);
+      continue;
+    }
     if (a.includes('=')) {
       const eq = a.indexOf('=');
       const k = a.slice(0, eq);
       const v = a.slice(eq + 1);
       if (bools.has(k)) {
-        process.stderr.write(`${sub}: '${k}' is a boolean flag and does not take a value (got '${a}'). Drop the '=...' suffix.\n`);
+        process.stderr.write(
+          `${sub}: '${k}' is a boolean flag and does not take a value (got '${a}'). Drop the '=...' suffix.\n`
+        );
         process.exit(2);
       }
       if (values.has(k)) {
@@ -123,7 +170,10 @@ export function validateAndExpandFlags(args, knownBools, knownValues, sub) {
       process.stderr.write(`${sub}: unknown flag '${k}' (got '${a}').\n`);
       process.exit(2);
     }
-    if (bools.has(a) || values.has(a)) { out.push(a); continue; }
+    if (bools.has(a) || values.has(a)) {
+      out.push(a);
+      continue;
+    }
     process.stderr.write(`${sub}: unknown flag '${a}'.\n`);
     process.exit(2);
   }

package/scripts/lib/lint.js

@@ -69,7 +69,7 @@ export function readPatterns(patternsFile = DEFAULT_PATTERNS_FILE) {
 const POSIX_TO_JS = [
   [/\[\[:space:\]\]/g, '\\s'],
   [/\[\[:digit:\]\]/g, '\\d'],
-  [/\[\[:alnum:\]\]/g, 'A-Za-z0-9'],   // typically already inside a [...]
+  [/\[\[:alnum:\]\]/g, 'A-Za-z0-9'], // typically already inside a [...]
   [/\[\[:alpha:\]\]/g, 'A-Za-z'],
   [/\[\[:upper:\]\]/g, 'A-Z'],
   [/\[\[:lower:\]\]/g, 'a-z'],
@@ -108,7 +108,7 @@ export function stripIdentifiers(text) {
   //    guard: blanked text is a subset of before, so this can only EXPOSE
   //    more text to the detector, never hide a claim.
   const lines = text.split('\n');
-  const isFence = (l) => /^\s*```/.test(l);
+  const isFence = l => /^\s*```/.test(l);
   // "Is there a closing fence after i?" — precomputed once. The direct
   // `lines.slice(i + 1).some(isFence)` spelling allocates the entire tail array
   // on every fence line even though `.some` short-circuits, which is O(lines²):
@@ -117,21 +117,31 @@ export function stripIdentifiers(text) {
   // after i iff any fence line is after i — in O(1) after one O(lines) pass.
   let lastFence = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (isFence(lines[i])) { lastFence = i; break; }
+    if (isFence(lines[i])) {
+      lastFence = i;
+      break;
+    }
   }
   const kept = [];
   let inFence = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (isFence(line)) {
-      if (inFence) { inFence = false; continue; }
-      if (lastFence > i) { inFence = true; continue; }
+      if (inFence) {
+        inFence = false;
+        continue;
+      }
+      if (lastFence > i) {
+        inFence = true;
+        continue;
+      }
       kept.push(line);
       continue;
     }
     if (!inFence) kept.push(line);
   }
-  const stripped = kept.join('\n')
+  const stripped = kept
+    .join('\n')
     // 2. Inline backtick spans.
     .replace(/`[^`]*`/g, ' ')
     // 3. Slashed-path runs (branch names, file paths, URLs) — Path 2's rule.
@@ -165,31 +175,30 @@ export function stripIdentifiers(text) {
     //
     //    The bash engines need no equivalent: POSIX sed does not backtrack and
     //    the hook caps its input at `tail -c 4096`; the Node path caps nothing.
-    .replace(/(?<![A-Za-z0-9._@~-])[A-Za-z0-9._@~-]*\/[A-Za-z0-9._/@~-]*/g, ' ')
-    // 4. Bare dotted-file tokens (foo.js, comprehensive-parser.ts). JS-only
-    //    when written; the bash sanitizer carries the same clause since
-    //    2026-08-16 and sanitize-stage-parity pins them together.
-    //    The extension must start with a LOWERCASE letter, which
-    //    (a) excludes decimals / versions ("3.5x", "v6.14") whose ".5x"/".14"
-    //    could otherwise swallow a baseline-less ratio claim → false negative,
-    //    and (b) excludes sentence-boundary typos ("comprehensive.Next", capital
-    //    after the dot) so a real claim isn't stripped. Only true `name.ext`
-    //    identifiers with a lowercase extension are removed.
-    //
-    //    Clause 4 canNOT use clause 3's lookbehind: its trailing class
-    //    `[a-z0-9]` is a strict SUBSET of the leading run class, so a match can
-    //    end in the MIDDLE of a run (`_a9Zaz.a|Z9Z_.a` — the ext stops at the
-    //    uppercase Z) and the next legitimate match then starts at a position
-    //    whose predecessor IS a run char. A lookbehind drops that match and
-    //    leaves the identifier unstripped — more text exposed to the detector,
-    //    i.e. the FP deny-loop returning. Clause 3 is immune because its
-    //    trailing class is a SUPERSET of its leading one, so a match always
-    //    ends outside a leading-class run; that equivalence is measured, not
-    //    assumed, in sanitize-anchor-equivalence.test.js.
-    //
-    //    So clause 4 runs as an explicit single-pass scan instead — same
-    //    semantics, O(n) instead of O(run²).
-    ;
+    .replace(/(?<![A-Za-z0-9._@~-])[A-Za-z0-9._@~-]*\/[A-Za-z0-9._/@~-]*/g, ' ');
+  // 4. Bare dotted-file tokens (foo.js, comprehensive-parser.ts). JS-only
+  //    when written; the bash sanitizer carries the same clause since
+  //    2026-08-16 and sanitize-stage-parity pins them together.
+  //    The extension must start with a LOWERCASE letter, which
+  //    (a) excludes decimals / versions ("3.5x", "v6.14") whose ".5x"/".14"
+  //    could otherwise swallow a baseline-less ratio claim → false negative,
+  //    and (b) excludes sentence-boundary typos ("comprehensive.Next", capital
+  //    after the dot) so a real claim isn't stripped. Only true `name.ext`
+  //    identifiers with a lowercase extension are removed.
+  //
+  //    Clause 4 canNOT use clause 3's lookbehind: its trailing class
+  //    `[a-z0-9]` is a strict SUBSET of the leading run class, so a match can
+  //    end in the MIDDLE of a run (`_a9Zaz.a|Z9Z_.a` — the ext stops at the
+  //    uppercase Z) and the next legitimate match then starts at a position
+  //    whose predecessor IS a run char. A lookbehind drops that match and
+  //    leaves the identifier unstripped — more text exposed to the detector,
+  //    i.e. the FP deny-loop returning. Clause 3 is immune because its
+  //    trailing class is a SUPERSET of its leading one, so a match always
+  //    ends outside a leading-class run; that equivalence is measured, not
+  //    assumed, in sanitize-anchor-equivalence.test.js.
+  //
+  //    So clause 4 runs as an explicit single-pass scan instead — same
+  //    semantics, O(n) instead of O(run²).
   return stripDottedFileTokens(stripped);
 }
 
@@ -201,10 +210,9 @@ export function stripIdentifiers(text) {
 // exactly, including the mid-run restart above: after a match the scan resumes
 // at the match end, which becomes the next candidate start even though its
 // predecessor is a run char.
-const isRunChar = (c) =>
-  (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
-  c === '_' || c === '-';
-const isExtChar = (c) => (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9');
+const isRunChar = c =>
+  (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '_' || c === '-';
+const isExtChar = c => (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9');
 
 export function stripDottedFileTokens(text) {
   if (!text) return text;
@@ -213,7 +221,10 @@ export function stripDottedFileTokens(text) {
   let copied = 0;
   let i = 0;
   while (i < n) {
-    if (!isRunChar(text[i])) { i++; continue; }
+    if (!isRunChar(text[i])) {
+      i++;
+      continue;
+    }
     const start = i;
     let e = i;
     while (e < n && isRunChar(text[e])) e++;
@@ -283,7 +294,7 @@ export function looksLikeGitMessageFile(filePath) {
 //     `-m "$(cat notes.md)"` whenever the body carried a markdown heading.
 export function stripGitCommitComments(text, commentChar = '#', { templateLines } = {}) {
   if (!text) return text;
-  const c = (typeof commentChar === 'string' && commentChar.length === 1) ? commentChar : '#';
+  const c = typeof commentChar === 'string' && commentChar.length === 1 ? commentChar : '#';
   const esc = c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const cutLine = new RegExp(`^${esc} -{20,} >8 -{20,}\\s*$`);
 
@@ -299,9 +310,7 @@ export function stripGitCommitComments(text, commentChar = '#', { templateLines
   //    it discards them under the editor path's cleanup=strip. Author-typed
   //    comment lines are absent from the template and stay in scope (P1-3).
   const fromTemplate = templateComments(templateLines, c);
-  const body = fromTemplate.size
-    ? lines.filter(l => !(l.startsWith(c) && fromTemplate.has(l)))
-    : lines;
+  const body = fromTemplate.size ? lines.filter(l => !(l.startsWith(c) && fromTemplate.has(l))) : lines;
 
   // 3. Strip the remaining comment lines only when git wrote a status block or
   //    a cut line here.
@@ -374,19 +383,33 @@ export function scan(text, { excludeRatio = false, patterns, sanitize = false }
   return hits;
 }
 
-// parseTranscript(jsonlText) → [{turnIndex, line, text}, ...]
+// parseTranscript(jsonlText, integrity) → [{turnIndex, line, text}, ...]
 //   Iterates jsonl, returns one entry per assistant text-content turn. Each
 //   entry concatenates all .message.content[*].text blocks for that turn.
-//   Corrupt rows (unparseable JSON, missing fields) silently skipped — matches
+//   Corrupt rows (unparseable JSON, missing fields) are skipped — matches
 //   transcript-vocab-scan.sh's `try fromjson catch empty` design.
-export function parseTranscript(jsonlText) {
+//
+//   `integrity` (out param, optional): `{ totalLines, badLines }` written back
+//   so the skip is countable rather than invisible. Skipping is still the right
+//   behavior — a half-corrupt transcript is worth scanning — but until 2026-09-03
+//   (audit R11-24) nothing downstream could tell "0 hits across 40 turns" from
+//   "0 hits across the 40 turns that happened to parse". readLogRows in
+//   rule-hits-parse.js has carried the same counter since a 33% corruption went
+//   unnoticed there; this is the same counter on the transcript side.
+export function parseTranscript(jsonlText, integrity = null) {
   const lines = jsonlText.split('\n');
   const turns = [];
   let turnIndex = 0;
   for (let i = 0; i < lines.length; i++) {
     if (!lines[i].trim()) continue;
+    if (integrity) integrity.totalLines = (integrity.totalLines || 0) + 1;
     let row;
-    try { row = JSON.parse(lines[i]); } catch { continue; }
+    try {
+      row = JSON.parse(lines[i]);
+    } catch {
+      if (integrity) integrity.badLines = (integrity.badLines || 0) + 1;
+      continue;
+    }
     if (row.type !== 'assistant') continue;
     const content = row.message?.content || [];
     const texts = [];
@@ -414,7 +437,11 @@ export function countStringContentAssistantRows(jsonlText) {
   for (const line of jsonlText.split('\n')) {
     if (!line.trim()) continue;
     let row;
-    try { row = JSON.parse(line); } catch { continue; }
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
     if (row?.type !== 'assistant') continue;
     const content = row.message?.content;
     if (typeof content === 'string' && content.trim().length > 0) count++;