rulereceipt 0.1.32 → 0.1.33

package/dist/checks/codeContent.js

@@ -1,3 +1,4 @@
+import { violation } from "../types.js";
 /**
  * Second structured-check primitive: only scans the actual content of
  * real file edits for a code-construct pattern (e.g. `print(`,
@@ -35,7 +36,7 @@ export function runCodeContentChecks(classifications, events) {
         if (content)
             editedContents.push(content);
     }
-    return classifications.map(({ rule, patterns, polarity }) => {
+    return classifications.map(({ rule, patterns, polarity, polarityInferred }) => {
         let foundPattern;
         let foundContent;
         for (const content of editedContents) {
@@ -51,19 +52,22 @@ export function runCodeContentChecks(classifications, events) {
         }
         if (polarity === "forbid") {
             if (foundPattern && foundContent) {
-                return {
-                    ruleId: rule.id,
-                    ruleTitle: rule.title,
-                    ruleSource: rule.source,
-                    status: "FAIL",
-                    evidence: `found "${foundPattern}" actually written into a file: ${foundContent.slice(0, 160)}`,
-                };
+                return violation(rule, polarity, `found "${foundPattern}" actually written into a file: ${foundContent.slice(0, 160)}`, { method: "code_content", polarityInferred });
             }
+            // Trigger evaluated and absent: the rule never applied. Not
+            // "followed" — that word claims something the check cannot show.
             return {
                 ruleId: rule.id,
                 ruleTitle: rule.title,
                 ruleSource: rule.source,
-                status: "PASS",
+                // status stays UNCLEAR: a legacy reader must not see a green
+                // tick for a rule that never applied. Setting PASS here while the
+                // outcome said not_applicable was the same word-borrowing this
+                // vocabulary exists to stop, one field further down.
+                status: "UNCLEAR",
+                outcome: "not_applicable",
+                method: "code_content",
+                ceiling: "a scan of content written through Write/Edit — it does not see content written by a shell command",
                 evidence: `no file edit actually contained ${patterns.map((p) => `"${p}"`).join(" or ")} this session`,
             };
         }

package/dist/checks/deterministicChecks.js

@@ -81,7 +81,12 @@ function matchesPattern(haystack, pattern) {
     const lastChar = pattern[pattern.length - 1];
     const needsTrailingBoundary = /[\w-]/.test(lastChar);
     const suffix = needsTrailingBoundary ? "(?![\\w-])" : "";
-    const regex = new RegExp(escapeRegex(pattern) + suffix);
+    // There was a trailing boundary and no leading one, so a short real
+    // pattern like `rm` matched inside "form", "storm" and "performance".
+    // Found 2026-09-12 running 559 rules files against 5 real sessions.
+    const firstChar = pattern[0];
+    const prefix = /[\w]/.test(firstChar) ? "(?<![\\w-])" : "";
+    const regex = new RegExp(prefix + escapeRegex(pattern) + suffix);
     return regex.test(haystack);
 }
 /**
@@ -130,12 +135,23 @@ export function runDeterministicChecks(classifications, events) {
                         evidence: `"${foundPattern}" appears in a ${foundEvent.kind === "tool_use" ? foundEvent.toolName + " call" : foundEvent.kind}, but a text match alone can't tell an actual violation from a mention (a search for it, a quote, an explanation) — needs a human look: ${haystack.slice(0, 160)}`,
                     };
                 }
+                // For a prohibition the trigger IS the forbidden act. Evaluated and
+                // absent means the rule never applied — not that it was followed.
+                // Reporting it as followed is how an empty transcript produced 2,770
+                // green ticks across the 559-file corpus.
                 return {
                     ruleId: rule.id,
                     ruleTitle: rule.title,
                     ruleSource: rule.source,
-                    status: "PASS",
-                    evidence: `no occurrence of ${patterns.map((p) => `"${p}"`).join(" or ")} in the commands and messages recorded this session — this is a text scan of the transcript, so it is evidence rather than proof: a spelling this checker does not know would not be caught`,
+                    // status stays UNCLEAR: a legacy reader must not see a green
+                    // tick for a rule that never applied. Setting PASS here while the
+                    // outcome said not_applicable was the same word-borrowing this
+                    // vocabulary exists to stop, one field further down.
+                    status: "UNCLEAR",
+                    outcome: "not_applicable",
+                    method: "text_scan",
+                    ceiling: "a text scan of the recorded commands and messages — evidence, not proof the act did not happen, since a spelling this checker does not know would not be caught",
+                    evidence: `no occurrence of ${patterns.map((p) => `"${p}"`).join(" or ")} in the commands and messages recorded this session`,
                 };
             }
             // polarity === "require": absence is the failure, not presence. But

package/dist/checks/fileLifecycle.js

@@ -1,3 +1,5 @@
+import { violation } from "../types.js";
+import { isProjectPath } from "./projectPaths.js";
 /**
  * Third structured-check primitive: only counts real MUTATIONS of a
  * protected file, never reads of it. Real false-positive this fixes
@@ -36,6 +38,11 @@ function escapeRegex(literal) {
 function pathPattern(filePath) {
     return `(?:^|[\\s'"=/])${escapeRegex(filePath.replace(/^\.\//, ""))}(?=$|[\\s'";)])`;
 }
+/**
+ * The command moves into a throwaway tree before doing anything. Anything
+ * it mutates after that is a scratch file, not the project's.
+ */
+const CD_INTO_TEMP = /\bcd\s+["']?(?:\/private)?\/(?:tmp|var\/folders)\b|\bcd\s+["']?[^\s"'&|;]*\/(?:scratchpad|node_modules)\b/;
 function mutatesPathInBash(command, filePath) {
     const p = pathPattern(filePath);
     const mutations = [
@@ -61,6 +68,12 @@ function findMutation(events, filePath) {
             const input = event.input;
             if (typeof input?.file_path === "string") {
                 const actual = input.file_path.replace(/^\.\//, "");
+                // A throwaway copy is not the project's file. A rule saying
+                // "CHANGELOG.md is release-only" fired on a scratchpad CHANGELOG.md
+                // written during a probe and deleted minutes later — the basename
+                // matched and nothing else was checked.
+                if (!isProjectPath(actual))
+                    continue;
                 if (actual === normalized || actual.endsWith(`/${normalized}`)) {
                     return `${event.toolName} on ${input.file_path}`;
                 }
@@ -70,6 +83,16 @@ function findMutation(events, filePath) {
         if (event.toolName === "Bash") {
             const input = event.input;
             if (typeof input?.command === "string" && mutatesPathInBash(input.command, filePath)) {
+                // A command whose working directory is a temp tree is operating on
+                // throwaway files, however the paths inside it are spelled.
+                //
+                // The first version required the temp prefix to sit next to the
+                // filename, which cannot work: the real command that exposed this
+                // does `cd /tmp` on its first line and writes `.claude/CLAUDE.md`
+                // three lines later. A shortened one-line fixture passed while the
+                // real command kept failing.
+                if (CD_INTO_TEMP.test(input.command))
+                    continue;
                 return input.command;
             }
         }
@@ -77,23 +100,26 @@ function findMutation(events, filePath) {
     return null;
 }
 export function runFileLifecycleChecks(classifications, events) {
-    return classifications.map(({ rule, filePath, polarity }) => {
+    return classifications.map(({ rule, filePath, polarity, polarityInferred }) => {
         const mutation = findMutation(events, filePath);
         if (polarity === "forbid") {
             if (mutation) {
-                return {
-                    ruleId: rule.id,
-                    ruleTitle: rule.title,
-                    ruleSource: rule.source,
-                    status: "FAIL",
-                    evidence: `"${filePath}" was actually modified: ${mutation.slice(0, 160)}`,
-                };
+                return violation(rule, polarity, `"${filePath}" was actually modified: ${mutation.slice(0, 160)}`, { method: "file_events", polarityInferred });
             }
+            // Trigger evaluated and absent: the rule never applied. Not
+            // "followed" — that word claims something the check cannot show.
             return {
                 ruleId: rule.id,
                 ruleTitle: rule.title,
                 ruleSource: rule.source,
-                status: "PASS",
+                // status stays UNCLEAR: a legacy reader must not see a green
+                // tick for a rule that never applied. Setting PASS here while the
+                // outcome said not_applicable was the same word-borrowing this
+                // vocabulary exists to stop, one field further down.
+                status: "UNCLEAR",
+                outcome: "not_applicable",
+                method: "file_events",
+                ceiling: "a check of file-mutation events — it shows no mutation of this path was recorded, not that the file is untouched on disk",
                 evidence: `"${filePath}" was never written to, deleted, or moved this session (reading it does not count)`,
             };
         }

package/dist/checks/gitBranchPolicy.js

@@ -1,3 +1,4 @@
+import { violation } from "../types.js";
 /**
  * First real structured-check primitive: parses actual git command
  * arguments instead of searching prose for a branch name as a substring.
@@ -86,26 +87,44 @@ export function runGitBranchPolicyChecks(classifications, events) {
             allTargets.push({ branch, command });
         }
     }
-    return classifications.map(({ rule, branchName, polarity }) => {
+    const anyGitCommand = events.some((e) => e.kind === "tool_use" && /\bgit\s/.test(JSON.stringify(e.input ?? "")));
+    return classifications.map(({ rule, branchName, polarity, polarityInferred }) => {
+        // No git command ran, so a git rule never had a situation to govern.
+        // Calling that "followed" is how an empty session produced 2,770 green
+        // ticks across the 559-file corpus — every one true, none meaningful.
+        if (!anyGitCommand) {
+            return {
+                ruleId: rule.id,
+                ruleTitle: rule.title,
+                ruleSource: rule.source,
+                status: "UNCLEAR",
+                outcome: "not_applicable",
+                method: "git_events",
+                evidence: "no git command ran this session, so this rule never applied",
+            };
+        }
         const pushOrCreateHit = allTargets.find((t) => t.branch === branchName &&
             (GIT_PUSH.test(t.command) || GIT_BRANCH_CREATE.test(t.command) || GIT_CHECKOUT_CREATE.test(t.command)));
         const commitViolationCommand = findCheckoutCommitViolation(commands, branchName);
         const hit = pushOrCreateHit ?? (commitViolationCommand ? { branch: branchName, command: commitViolationCommand } : undefined);
         if (polarity === "forbid") {
             if (hit) {
-                return {
-                    ruleId: rule.id,
-                    ruleTitle: rule.title,
-                    ruleSource: rule.source,
-                    status: "FAIL",
-                    evidence: `a git command actually targeted the "${branchName}" branch: ${hit.command}`,
-                };
+                return violation(rule, polarity, `a git command actually targeted the "${branchName}" branch: ${hit.command}`, { method: "git_events", polarityInferred });
             }
+            // Trigger evaluated and absent: the rule never applied. Not
+            // "followed" — that word claims something the check cannot show.
             return {
                 ruleId: rule.id,
                 ruleTitle: rule.title,
                 ruleSource: rule.source,
-                status: "PASS",
+                // status stays UNCLEAR: a legacy reader must not see a green
+                // tick for a rule that never applied. Setting PASS here while the
+                // outcome said not_applicable was the same word-borrowing this
+                // vocabulary exists to stop, one field further down.
+                status: "UNCLEAR",
+                outcome: "not_applicable",
+                method: "git_events",
+                ceiling: "a scan of recorded git commands — it does not see commands run outside this session",
                 evidence: `no git command targeted the "${branchName}" branch this session`,
             };
         }

package/dist/checks/ifEditThenTest.js

@@ -1,3 +1,5 @@
+import { findTestRun } from "./testCommands.js";
+import { isProjectPath } from "./projectPaths.js";
 const TEST_FILE_PATTERN = /(\.test\.|\.spec\.|__tests__\/|_test\.|\/tests?\/)/i;
 // Real false-positive found 2026-08-30 on an actual session: editing a
 // markdown documentation file flagged "no test file touched" four
@@ -5,6 +7,18 @@ const TEST_FILE_PATTERN = /(\.test\.|\.spec\.|__tests__\/|_test\.|\/tests?\/)/i;
 // companion under any reasonable reading of an "add tests for every
 // change" rule. Excluded from prodPaths entirely, same as test files.
 const NON_TESTABLE_FILE_PATTERN = /\.(md|mdx|txt|rst|json|ya?ml|toml|lock|csv|log)$/i;
+/**
+ * Paths that are not this project's source, whatever their extension.
+ *
+ * Found 2026-09-12 running 559 real rules files against 5 real sessions: 24
+ * FAILs said "edited /private/tmp/.../scratchpad/probe.mjs but no matching
+ * test file was touched". That is a throwaway probe, written to inspect
+ * something and deleted minutes later. Demanding a test for it is nonsense;
+ * demanding one as a FAIL is a false accusation.
+ *
+ * Only file extensions were excluded before, so any temp file that happened
+ * to end in .ts or .mjs counted as production code.
+ */
 const WRITE_LIKE_TOOLS = new Set(["Write", "Edit", "NotebookEdit"]);
 function extractEditedPaths(events) {
     const paths = [];
@@ -40,8 +54,21 @@ function extractEditedPaths(events) {
  */
 export function runIfEditThenTestChecks(classifications, events) {
     const editedPaths = extractEditedPaths(events);
+    // Running the suite honours "add tests for every change" as much as
+    // touching a test file does. Without this, the most ordinary workflow
+    // there is — change code, run the tests, commit — produced a FAIL saying
+    // no test file was touched. Twelve rules across the 559-file corpus hit
+    // it on one synthetic session (2026-09-11).
+    //
+    // Any run in the session counts, not only one after the edit. Requiring
+    // the stricter ordering would buy a little precision and risk the
+    // expensive direction of error, and in this project a wrong FAIL costs
+    // more than a missed detection.
+    const testRun = findTestRun(events);
     const testPaths = editedPaths.filter((p) => TEST_FILE_PATTERN.test(p));
-    const prodPaths = editedPaths.filter((p) => !TEST_FILE_PATTERN.test(p) && !NON_TESTABLE_FILE_PATTERN.test(p));
+    const prodPaths = editedPaths.filter((p) => !TEST_FILE_PATTERN.test(p) &&
+        !NON_TESTABLE_FILE_PATTERN.test(p) &&
+        isProjectPath(p));
     return classifications.map(({ rule }) => {
         if (prodPaths.length === 0) {
             return {
@@ -54,6 +81,15 @@ export function runIfEditThenTestChecks(classifications, events) {
                     : "no code file was edited this session (only test/doc/config files, if any) — the rule never had a chance to apply",
             };
         }
+        if (testPaths.length === 0 && testRun !== null) {
+            return {
+                ruleId: rule.id,
+                ruleTitle: rule.title,
+                ruleSource: rule.source,
+                status: "PASS",
+                evidence: `edited ${prodPaths[0]} and ran the suite: \`${testRun}\` (no test file was edited, but the code was exercised)`,
+            };
+        }
         if (testPaths.length === 0) {
             return {
                 ruleId: rule.id,

package/dist/checks/judgmentChecks.js

@@ -31,6 +31,21 @@ function modelId() {
 const MAX_TRANSCRIPT_CHARS = 120_000;
 const HEAD_CHARS = 40_000;
 const TAIL_CHARS = MAX_TRANSCRIPT_CHARS - HEAD_CHARS;
+/**
+ * How much of a rule's own text goes into the prompt.
+ *
+ * The transcript was capped and the rule body was not. One rule in the
+ * 559-file corpus is 122,000 characters — a section heading whose body is
+ * an entire architecture document, parsed as a single rule — and it would
+ * have been sent whole on top of a 120,000-character transcript. Roughly
+ * 60k tokens for one verdict, with nothing bounding it.
+ *
+ * A rule that does not fit in 8,000 characters is not really one rule, and
+ * the model does not need the rest to judge it. The prompt says when it was
+ * cut, so a verdict is never formed from a fragment the model believes is
+ * whole.
+ */
+const MAX_RULE_CHARS = 8_000;
 /** How many judgment calls may be in flight at once. */
 const MAX_CONCURRENT_CALLS = 4;
 const TRUNCATION_NOTE = "[judged on a truncated transcript — the middle of this session was not shown to the model]";
@@ -99,6 +114,13 @@ const INSTRUCTIONS = "You judge whether one rule from a CLAUDE.md/AGENTS.md file
  * about 13 rules it had never examined. Found 2026-09-08 by running the
  * published package; nothing in 167 lines of tests here asserted the field.
  */
+function ruleBody(text) {
+    if (text.length <= MAX_RULE_CHARS)
+        return text;
+    return (text.slice(0, MAX_RULE_CHARS) +
+        `\n\n...[rule text truncated at ${MAX_RULE_CHARS} characters — this rule's body is ` +
+        `${text.length} characters long and is probably a whole document parsed as one rule]`);
+}
 function didNotRun(rule, reason) {
     return {
         ruleId: rule.id,
@@ -106,6 +128,10 @@ function didNotRun(rule, reason) {
         ruleSource: rule.source,
         status: "UNCLEAR",
         needsHuman: true,
+        // The check did not happen. Rendering that as a judgment call, or worse
+        // as "couldn't tell", was the original defect in this file.
+        outcome: "not_run",
+        method: "none",
         evidence: reason,
     };
 }
@@ -177,7 +203,7 @@ export async function runJudgmentChecks(classifications, events) {
                                 text: `SESSION TRANSCRIPT:\n${transcript.text}`,
                                 cache_control: { type: "ephemeral" },
                             },
-                            { type: "text", text: `RULE — ${rule.title}\n${rule.text}` },
+                            { type: "text", text: `RULE — ${rule.title}\n${ruleBody(rule.text)}` },
                         ],
                     },
                 ],

package/dist/checks/projectPaths.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Paths that are not the project's own files, whatever their name.
+ *
+ * One definition, shared. Found the hard way twice: ifEditThenTest demanded
+ * a test for /private/tmp/.../scratchpad/probe.mjs, and fileLifecycle fired
+ * a "CHANGELOG.md is release-only" rule on a scratchpad copy of that file
+ * written during a probe and deleted minutes later. Two checkers needed the
+ * same exclusion and only one had it, which is exactly how the two copies
+ * of TEST_COMMAND would have drifted.
+ *
+ * Both callers use this to decide whether to accuse someone, so the cost of
+ * a miss here is a false FAIL on a throwaway file.
+ */
+export declare const NON_PROJECT_PATH: RegExp;
+/** True when this path is somewhere the project's own rules should govern. */
+export declare function isProjectPath(path: string): boolean;

package/dist/checks/projectPaths.js

@@ -0,0 +1,18 @@
+/**
+ * Paths that are not the project's own files, whatever their name.
+ *
+ * One definition, shared. Found the hard way twice: ifEditThenTest demanded
+ * a test for /private/tmp/.../scratchpad/probe.mjs, and fileLifecycle fired
+ * a "CHANGELOG.md is release-only" rule on a scratchpad copy of that file
+ * written during a probe and deleted minutes later. Two checkers needed the
+ * same exclusion and only one had it, which is exactly how the two copies
+ * of TEST_COMMAND would have drifted.
+ *
+ * Both callers use this to decide whether to accuse someone, so the cost of
+ * a miss here is a false FAIL on a throwaway file.
+ */
+export const NON_PROJECT_PATH = /(?:^|\/)(?:tmp|temp|scratch|scratchpad|node_modules|dist|build|out|coverage|\.git|\.next|\.cache|vendor|__pycache__)(?:\/|$)|^\/(?:private\/)?(?:tmp|var)\//i;
+/** True when this path is somewhere the project's own rules should govern. */
+export function isProjectPath(path) {
+    return !NON_PROJECT_PATH.test(path);
+}

package/dist/checks/testCommands.d.ts

@@ -0,0 +1,23 @@
+import type { TranscriptEvent } from "../types.js";
+/**
+ * Commands that run a project's test suite.
+ *
+ * One definition, imported by every checker that needs it. Two checkers
+ * now ask "did the tests run" — claimEvidence, to see whether a claim of a
+ * passing suite had anything behind it, and ifEditThenTest, to see whether
+ * changed code was exercised. Two copies of this list would drift, and the
+ * drift would show up as one checker contradicting the other in the same
+ * report.
+ *
+ * It can never be complete — projects wire their suite to whatever script
+ * name they like — so callers must never let a miss become an accusation.
+ * See UNKNOWN_SCRIPT_RUNNER in claimEvidence.ts.
+ *
+ * Deliberately a known list rather than anything test-shaped. Both callers
+ * use it to decide whether to report a FAIL, and a rule that fires because
+ * someone ran a script with "test" in its name is the expensive kind of
+ * wrong.
+ */
+export declare const TEST_COMMAND: RegExp;
+/** The first test command run in this session, or null if none ran. */
+export declare function findTestRun(events: TranscriptEvent[]): string | null;

package/dist/checks/testCommands.js

@@ -0,0 +1,32 @@
+/**
+ * Commands that run a project's test suite.
+ *
+ * One definition, imported by every checker that needs it. Two checkers
+ * now ask "did the tests run" — claimEvidence, to see whether a claim of a
+ * passing suite had anything behind it, and ifEditThenTest, to see whether
+ * changed code was exercised. Two copies of this list would drift, and the
+ * drift would show up as one checker contradicting the other in the same
+ * report.
+ *
+ * It can never be complete — projects wire their suite to whatever script
+ * name they like — so callers must never let a miss become an accusation.
+ * See UNKNOWN_SCRIPT_RUNNER in claimEvidence.ts.
+ *
+ * Deliberately a known list rather than anything test-shaped. Both callers
+ * use it to decide whether to report a FAIL, and a rule that fires because
+ * someone ran a script with "test" in its name is the expensive kind of
+ * wrong.
+ */
+export const TEST_COMMAND = /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|verify|check|ci)\b|\bnpx\s+(?:vitest|jest|mocha|ava)\b|\b(?:vitest|jest|mocha|pytest|phpunit|rspec|tox)\b|\bcargo\s+test\b|\bgo\s+test\b|\bmvn\s+(?:test|verify)\b|\bgradle\s+test\b|\bdotnet\s+test\b|\bpython\s+-m\s+(?:pytest|unittest)\b/i;
+/** The first test command run in this session, or null if none ran. */
+export function findTestRun(events) {
+    for (const event of events) {
+        if (event.kind !== "tool_use")
+            continue;
+        const input = event.input;
+        const command = input && typeof input.command === "string" ? input.command : "";
+        if (command && TEST_COMMAND.test(command))
+            return command;
+    }
+    return null;
+}

package/dist/cli.js

@@ -15,6 +15,7 @@ import { runIfEditThenTestChecks } from "./checks/ifEditThenTest.js";
 import { runGitBranchPolicyChecks } from "./checks/gitBranchPolicy.js";
 import { runCodeContentChecks } from "./checks/codeContent.js";
 import { runFileLifecycleChecks } from "./checks/fileLifecycle.js";
+import { runClaimEvidenceChecks } from "./checks/claimEvidence.js";
 import { runJudgmentChecks } from "./checks/judgmentChecks.js";
 import { generateReport, generateMarkdownReport } from "./report/generateReport.js";
 import { generateHtmlReport } from "./report/generateHtmlReport.js";
@@ -212,6 +213,7 @@ async function runCheck(opts) {
     const gitBranchPolicy = classifications.filter((c) => c.kind === "gitBranchPolicy");
     const codeContent = classifications.filter((c) => c.kind === "codeContent");
     const fileLifecycle = classifications.filter((c) => c.kind === "fileLifecycle");
+    const claimEvidence = classifications.filter((c) => c.kind === "claimEvidence");
     const judgment = classifications.filter((c) => c.kind === "judgment");
     // Not rules at all — documentation, glossary entries, reference tables,
     // URLs, directory listings, code examples.
@@ -236,6 +238,7 @@ async function runCheck(opts) {
         ...runGitBranchPolicyChecks(gitBranchPolicy, events),
         ...runCodeContentChecks(codeContent, events),
         ...runFileLifecycleChecks(fileLifecycle, events),
+        ...runClaimEvidenceChecks(claimEvidence, events),
     ];
     // Deterministic checks run by default, always, with no key — judgment
     // rules only call out to an LLM with an explicit --llm on THIS run, never

package/dist/report/generateReport.js

@@ -60,18 +60,46 @@ function ruleLabel(r, results) {
  * as a division of labour.
  */
 function summaryLine(results) {
-    const pass = results.filter((r) => r.status === "PASS").length;
-    const fail = results.filter((r) => r.status === "FAIL").length;
-    const needsHuman = results.filter((r) => r.status === "UNCLEAR" && r.needsHuman).length;
-    const couldntTell = results.filter((r) => r.status === "UNCLEAR" && !r.needsHuman).length;
-    const parts = [`${pass} followed`, `${fail} not followed`];
-    if (couldntTell > 0)
-        parts.push(`${couldntTell} couldn't tell`);
-    if (needsHuman > 0)
-        parts.push(`${needsHuman} need your judgment`);
+    const n = (b) => results.filter((r) => bucketOf(r) === b).length;
+    const parts = [`${n("PASS")} followed`, `${n("FAIL")} not followed`];
+    if (n("UNCLEAR_EVIDENCE") > 0)
+        parts.push(`${n("UNCLEAR_EVIDENCE")} couldn't tell`);
+    if (n("NOT_RUN") > 0)
+        parts.push(`${n("NOT_RUN")} not run`);
+    if (n("NOT_APPLICABLE") > 0)
+        parts.push(`${n("NOT_APPLICABLE")} didn't apply`);
+    if (n("UNCLEAR_JUDGMENT") > 0)
+        parts.push(`${n("UNCLEAR_JUDGMENT")} need your judgment`);
     return parts.join(" · ");
 }
+/**
+ * Six buckets, because "the tool looked and could not decide", "the tool
+ * never ran", and "the situation never arose" are three different things
+ * that were all rendering as one.
+ *
+ * From anthropics/claude-code#90542. With no API key the report printed
+ * "13 couldn't tell" — a phrase defined in this file as the tool having
+ * looked — about thirteen rules it had never examined. And an empty
+ * transcript produced 2,770 green ticks across the 559-file corpus, every
+ * one of them true and none of them meaning anything, because a rule whose
+ * situation never arose was being counted as followed.
+ *
+ * `outcome` is preferred where a checker sets it; `status` remains the
+ * fallback while the rest are migrated.
+ */
 function bucketOf(result) {
+    switch (result.outcome) {
+        case "fail":
+            return "FAIL";
+        case "pass":
+            return "PASS";
+        case "not_run":
+            return "NOT_RUN";
+        case "not_applicable":
+            return "NOT_APPLICABLE";
+        case "inconclusive":
+            return result.needsHuman ? "UNCLEAR_JUDGMENT" : "UNCLEAR_EVIDENCE";
+    }
     if (result.status === "FAIL")
         return "FAIL";
     if (result.status === "PASS")
@@ -90,10 +118,25 @@ function bucketOf(result) {
 const BUCKET_LABEL = {
     FAIL: "Not followed",
     UNCLEAR_EVIDENCE: "Couldn't tell",
-    UNCLEAR_JUDGMENT: "Needs your judgment",
+    NOT_RUN: "Not run",
     PASS: "Followed",
+    NOT_APPLICABLE: "Didn't apply this session",
+    UNCLEAR_JUDGMENT: "Needs your judgment",
 };
-const BUCKET_ORDER = ["FAIL", "UNCLEAR_EVIDENCE", "PASS", "UNCLEAR_JUDGMENT"];
+/**
+ * Failures, then the two kinds of gap, then what held, then what never came
+ * up, then the human's half. "Not run" sits near the top on purpose: a
+ * check that did not happen is closer to a gap than to a result, and
+ * burying it is how it got mistaken for one.
+ */
+const BUCKET_ORDER = [
+    "FAIL",
+    "UNCLEAR_EVIDENCE",
+    "NOT_RUN",
+    "PASS",
+    "NOT_APPLICABLE",
+    "UNCLEAR_JUDGMENT",
+];
 /**
  * The explanation shared by every rule in a section, or null when they
  * differ.
@@ -142,6 +185,12 @@ export function generateReport(results, meta) {
             lines.push(`${MARK[r.status]} ${r.status.padEnd(7)} ${ruleLabel(r, clean)}`);
             if (r.evidence)
                 lines.push(`  evidence: ${r.evidence}`);
+            // What this method was ALLOWED to conclude, travelling with the
+            // verdict. A text scan may say it saw no occurrence of a spelling; it
+            // may not say the act did not happen. That distinction shipped for six
+            // versions as a PASS on a session that ran `git push -f`.
+            if (r.ceiling)
+                lines.push(`  this means: ${r.ceiling}`);
         }
     }
     lines.push("");

package/dist/types.d.ts

@@ -26,6 +26,32 @@ export interface TranscriptToolResultEvent {
 }
 export type TranscriptEvent = TranscriptTextEvent | TranscriptToolUseEvent | TranscriptToolResultEvent;
 export type CheckStatus = "PASS" | "FAIL" | "UNCLEAR";
+/**
+ * Five outcomes, not three.
+ *
+ * From anthropics/claude-code#90542. The failure that started this was not a
+ * bad matcher — it was vocabulary reuse. With no API key the tool printed
+ * "13 couldn't tell", a phrase this codebase defines as "the tool looked and
+ * the evidence was ambiguous", about thirteen rules it had never examined.
+ * Once `not_run` is its own outcome that lie has nowhere to sit, however
+ * good or bad the matcher is.
+ *
+ * `not_applicable` earns its place the same way. A session that never
+ * touched git cannot have violated a git rule, and calling that "followed"
+ * is how an empty transcript produced 2,770 green ticks across the 559-file
+ * corpus — every one of them true and none of them meaning anything.
+ */
+export type CheckOutcome = "pass" | "fail"
+/** It looked, and the evidence did not settle it. */
+ | "inconclusive"
+/** No check happened: no key, an error, no ratified reading. */
+ | "not_run"
+/** The trigger never fired, so there was nothing to judge. */
+ | "not_applicable";
+/** How a verdict was reached. A verdict with no method is a verdict with no standing. */
+export type CheckMethod = "text_scan" | "file_events" | "git_events" | "code_content" | "edit_test_pairing" | "claim_vs_evidence" | "model_judgment"
+/** Nothing ran. */
+ | "none";
 export interface CheckResult {
     ruleId: string;
     ruleTitle: string;
@@ -48,4 +74,49 @@ export interface CheckResult {
      * not blur them.
      */
     needsHuman?: boolean;
+    /**
+     * The outcome in the five-value vocabulary. Optional while the checkers
+     * are migrated one at a time; `status` remains the fallback.
+     */
+    outcome?: CheckOutcome;
+    /** How this verdict was reached. */
+    method?: CheckMethod;
+    /**
+     * What this method is ALLOWED to claim.
+     *
+     * A text scan may say "no occurrence of these spellings in this scope".
+     * It may not say "the act did not happen" — that PASS shipped for six
+     * versions and passed a session that ran `git push -f`. The ceiling
+     * travels with the verdict so the report cannot overclaim on its behalf.
+     */
+    ceiling?: string;
+    /** Why an inconclusive or not_run outcome came out that way, e.g. scope_incomplete. */
+    reason?: string;
+    /**
+     * Set when the rule's direction was inferred rather than read from an
+     * explicit signal word — a bare imperative like "Use `npm`" taken as a
+     * requirement.
+     *
+     * Named on the verdict so a measurement can split inferred rows from
+     * explicit ones and settle whether the leftover is coverage or noise,
+     * rather than the question being argued. Suggested on
+     * anthropics/claude-code#90542.
+     */
+    polarityInferred?: boolean;
 }
+/**
+ * A FAIL may only be constructed from a forbidding rule.
+ *
+ * This is the "cannot accuse" property as a compile-time invariant rather
+ * than a convention. It held by inspection — every `status: "FAIL"` sat
+ * inside a `polarity === "forbid"` branch — and inspection is exactly what
+ * stops holding the day someone adds a require-FAIL path. Passing the
+ * polarity in means a require branch cannot call this: `"require"` is not
+ * assignable to `"forbid"`, and the build fails rather than a user being
+ * accused of not doing something the tool guessed they had to do.
+ */
+export declare function violation(rule: {
+    id: string;
+    title: string;
+    source: "global" | "project";
+}, polarity: "forbid", evidence: string, extra?: Partial<CheckResult>): CheckResult;