rulereceipt 0.1.65 → 0.1.66

package/README.md

@@ -431,6 +431,12 @@ npx tsx src/cli.ts demo
 
 ## Trust, privacy and licensing
 
+**Verify it yourself.** `npx rulereceipt selftest` runs a set of bundled
+golden fixtures on your machine and reports how many verdicts are correct, with
+**zero network calls** — watch it with `lsof` or Little Snitch if you like. The
+same fixtures are the project's regression suite, so "all correct" is a promise
+the build enforces, not a claim.
+
 **What it can't see, it says so.** [KNOWN-GAPS.md](KNOWN-GAPS.md) lists
 exactly where the evidence runs out — commands in another terminal, clicks on
 the permission prompt, `rm`/delete not bound to a rule's subject, edited

package/dist/audit.d.ts

@@ -27,6 +27,7 @@ export interface RulesAudit {
     topFixes: {
         title: string;
         suggestion: string;
+        handle?: string;
     }[];
 }
 export declare function auditRules(rules: Rule[]): RulesAudit;
@@ -39,7 +40,7 @@ export declare function renderAudit(a: RulesAudit, md?: boolean): string;
  * cannot know without a transcript.
  */
 export interface Diagnostic {
-    id: "no-rules-file" | "empty-or-pointer" | "zero-rules" | "docs-heavy" | "shadowed-file" | "size-warn" | "template-text" | "broken-import";
+    id: "no-rules-file" | "empty-or-pointer" | "zero-rules" | "docs-heavy" | "shadowed-file" | "size-warn" | "template-text" | "broken-import" | "hook-config" | "dead-globs";
     severity: "info" | "warn";
     message: string;
 }

package/dist/audit.js

@@ -1,8 +1,39 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { classifyRules } from "./checks/classify.js";
 import { adviseRules } from "./checkability.js";
+import { ruleWasLoaded } from "./checks/pathScope.js";
 import { describeRuleSources, loadRules } from "./rules.js";
+/** Files in the repo, for checking whether a path-scoped rule matches anything. */
+function repoFiles(cwd, cap = 4000) {
+    const out = [];
+    const skip = new Set(["node_modules", ".git", "dist", "build", ".next", "out", "coverage", ".rulereceipt", ".vercel", ".turbo", "vendor"]);
+    const walk = (dir) => {
+        if (out.length >= cap)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (out.length >= cap)
+                return;
+            const full = join(dir, e.name);
+            if (e.isDirectory()) {
+                if (!skip.has(e.name))
+                    walk(full);
+            }
+            else {
+                out.push(full);
+            }
+        }
+    };
+    walk(cwd);
+    return out;
+}
 export function auditRules(rules) {
     let checkable = 0;
     let judgment = 0;
@@ -19,7 +50,7 @@ export function auditRules(rules) {
     const topFixes = adviseRules(rules)
         .filter((a) => a.actionable)
         .slice(0, 5)
-        .map((a) => ({ title: a.ruleTitle, suggestion: a.suggestion }));
+        .map((a) => ({ title: a.ruleTitle, suggestion: a.suggestion, handle: a.handle }));
     return {
         total: checkable + judgment + skipped,
         checkable,
@@ -60,6 +91,30 @@ export function renderAudit(a, md = false) {
     out.push("Full advice, rule by rule:  rulereceipt rules --advise");
     return out.join("\n");
 }
+/** Hook events Claude Code recognises. A hook under any other name never fires. */
+const KNOWN_HOOK_EVENTS = new Set([
+    "PreToolUse", "PostToolUse", "Stop", "SubagentStop", "UserPromptSubmit",
+    "SessionStart", "SessionEnd", "Notification", "PreCompact", "PostCompact",
+    "PermissionRequest", "PermissionDenied", "InstructionsLoaded",
+]);
+/** Hook event names in the project/user settings that Claude Code won't recognise. */
+function unknownHookEvents(cwd) {
+    const bad = new Set();
+    for (const p of [join(cwd, ".claude", "settings.json"), join(cwd, ".claude", "settings.local.json")]) {
+        try {
+            const hooks = JSON.parse(readFileSync(p, "utf-8")).hooks;
+            if (hooks && typeof hooks === "object") {
+                for (const name of Object.keys(hooks))
+                    if (!KNOWN_HOOK_EVENTS.has(name))
+                        bad.add(name);
+            }
+        }
+        catch {
+            /* absent or unreadable */
+        }
+    }
+    return [...bad];
+}
 /**
  * Claude Code reads a bounded prefix of a rules file; past it the rest is
  * silently dropped, so a rule below the cut never loads. The figure is a
@@ -104,7 +159,7 @@ function isPointerFile(path) {
         return false;
     }
 }
-function buildDiagnostics(cwd, graph, a) {
+function buildDiagnostics(cwd, graph, a, rules) {
     const diags = [];
     const loaded = graph.filter((g) => g.status === "loaded");
     const shadowed = graph.filter((g) => g.status === "shadowed");
@@ -187,6 +242,29 @@ function buildDiagnostics(cwd, graph, a) {
             });
         }
     }
+    // A path-scoped rule whose globs match no file in the repo never loads.
+    const scoped = rules.filter((r) => r.paths && r.paths.length > 0);
+    if (scoped.length > 0) {
+        const files = repoFiles(cwd);
+        for (const r of scoped) {
+            if (!ruleWasLoaded(r.paths, files)) {
+                diags.push({
+                    id: "dead-globs",
+                    severity: "warn",
+                    message: `"${r.title.replace(/\s+/g, " ").trim().slice(0, 50)}" is scoped to ${r.paths.join(", ")}, which matches no file in this repo — so it never loads and governs nothing. Fix the glob.`,
+                });
+            }
+        }
+    }
+    // A hook wired under a misspelled/unknown event name never fires — silently.
+    const badHooks = unknownHookEvents(cwd);
+    if (badHooks.length > 0) {
+        diags.push({
+            id: "hook-config",
+            severity: "warn",
+            message: `.claude/settings.json has hook${badHooks.length === 1 ? "" : "s"} under ${badHooks.map((h) => `"${h}"`).join(", ")}, which ${badHooks.length === 1 ? "is not a" : "are not"} Claude Code hook event${badHooks.length === 1 ? "" : "s"} — ${badHooks.length === 1 ? "it never fires" : "they never fire"}. Check the spelling (e.g. PreToolUse, PostToolUse, Stop).`,
+        });
+    }
     // A handbook, not a policy: mostly documentation, little to enforce.
     if (a.total >= 8 && a.skipped / a.total > 0.7) {
         diags.push({
@@ -206,7 +284,7 @@ export function auditProject(cwd) {
     const rules = loadRules(cwd);
     const base = auditRules(rules);
     const loadGraph = describeRuleSources(cwd);
-    const diagnostics = buildDiagnostics(cwd, loadGraph, base);
+    const diagnostics = buildDiagnostics(cwd, loadGraph, base, rules);
     const memoryRules = rules.filter((r) => r.id.startsWith("memory:")).length;
     return { ...base, loadGraph, diagnostics, memoryRules };
 }
@@ -251,7 +329,7 @@ export function renderProjectAudit(pa, md = false) {
     if (pa.topFixes.length > 0) {
         out.push(H("Top fixes to unlock more checks"));
         for (const f of pa.topFixes) {
-            out.push(`  • ${f.title.replace(/\s+/g, " ").trim().slice(0, 60)}`);
+            out.push(`  • ${f.title.replace(/\s+/g, " ").trim().slice(0, 60)}${f.handle ? `  [${f.handle}]` : ""}`);
             out.push(`      ${f.suggestion}`);
         }
         out.push("");

package/dist/checkability.d.ts

@@ -30,6 +30,8 @@ export interface RuleAdvice {
      * actionable ones as the top fixes.
      */
     actionable?: boolean;
+    /** Stable content-hash handle for `rules --include/--exclude`. */
+    handle?: string;
 }
 /**
  * Advice for one rule, or null when the rule is already mechanically checked.

package/dist/checkability.js

@@ -1,4 +1,5 @@
 import { classifyRule } from "./checks/classify.js";
+import { ruleFingerprint } from "./overrides.js";
 /** A concrete action the rule is plausibly about, so we can name what to quote. */
 const CONCRETE_SUBJECT = /\b(?:push(?:es|ed|ing)?|commit(?:s|ted|ting)?|merge[ds]?|rebase|delet\w*|remov\w*|\brm\b|drop|truncate|deploy\w*|migrat\w*|branch|tag|force[- ]?push|test|lint|build|install|env|secret|token|password|key|\.env|database|table|file|path|directory|endpoint|api)\b/i;
 /** A rule that is qualitative by nature — no literal makes it mechanical. */
@@ -65,5 +66,14 @@ export function adviseRule(rule) {
 }
 /** Advice for every rule that isn't already mechanically checked. */
 export function adviseRules(rules) {
-    return rules.map(adviseRule).filter((a) => a !== null);
+    const out = [];
+    for (const rule of rules) {
+        const a = adviseRule(rule);
+        // Attach the stable content-hash handle so `audit`'s top fixes can be acted
+        // on with `rules --include/--exclude <handle>` (ids are positional and
+        // renumber; the handle survives edits above the rule).
+        if (a)
+            out.push({ ...a, handle: ruleFingerprint(rule) });
+    }
+    return out;
 }

package/dist/checks/approvalGate.js

@@ -1,5 +1,5 @@
 import { violation } from "../types.js";
-import { withoutHeredocs } from "./shellCommand.js";
+import { withoutHeredocs, withoutQuotedMentions } from "./shellCommand.js";
 const IN_COMMAND = {
     push: /\bgit\s+(?:\S+\s+){0,4}?push(?![\w-])/,
     commit: /\bgit\s+(?:\S+\s+){0,4}?commit(?![\w-])/,
@@ -29,7 +29,10 @@ function commandOf(e) {
     const c = e.input?.command;
     // A heredoc that WRITES "git push" into a file is not a push. Strip heredoc
     // bodies so only the commands actually invoked are inspected.
-    return typeof c === "string" ? withoutHeredocs(c) : "";
+    // Strip heredoc bodies (a heredoc that WRITES "git push" is not a push) and
+    // blank quoted/commented mentions (`echo "git push"`, `# git push`), so only
+    // a command actually being run is matched.
+    return typeof c === "string" ? withoutQuotedMentions(withoutHeredocs(c)) : "";
 }
 /** The result for the call at `i`: matched by id when present, else the next result. */
 function resultOf(events, i) {

package/dist/checks/shellCommand.d.ts

@@ -44,3 +44,15 @@ export declare function leadingCommand(segment: string): string;
  * false-matched on commit-message text — findings 2026-09-26).
  */
 export declare function withoutCommitMessage(command: string): string;
+/**
+ * Blanks out quoted-string CONTENTS and drops #-comments, so a command MENTION
+ * inside a quote or a comment is not read as the command running.
+ *
+ * Found 2026-09-28: `echo "git push"` and `cat notes.md # git push` were both
+ * flagged as an unapproved push, because the matcher saw "git push" anywhere in
+ * the string. Blanking quote contents keeps the real verb visible (`git commit
+ * -m "msg"` still reads as a commit) while removing the mention. Use this only
+ * where a MENTION must not count as an action; checks that need the quoted text
+ * (attribution's commit-message trailer) must not use it.
+ */
+export declare function withoutQuotedMentions(command: string): string;

package/dist/checks/shellCommand.js

@@ -104,3 +104,19 @@ export function leadingCommand(segment) {
 export function withoutCommitMessage(command) {
     return command.replace(/(-m|--message)(=|\s+)(['"])(?:\\.|(?!\3)[\s\S])*\3/g, "$1 <message>");
 }
+/**
+ * Blanks out quoted-string CONTENTS and drops #-comments, so a command MENTION
+ * inside a quote or a comment is not read as the command running.
+ *
+ * Found 2026-09-28: `echo "git push"` and `cat notes.md # git push` were both
+ * flagged as an unapproved push, because the matcher saw "git push" anywhere in
+ * the string. Blanking quote contents keeps the real verb visible (`git commit
+ * -m "msg"` still reads as a commit) while removing the mention. Use this only
+ * where a MENTION must not count as an action; checks that need the quoted text
+ * (attribution's commit-message trailer) must not use it.
+ */
+export function withoutQuotedMentions(command) {
+    const noQuotes = command.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, '""');
+    // A `#` that begins a word (start or after whitespace) starts a comment.
+    return noQuotes.replace(/(^|\s)#[^\n]*/g, "$1");
+}

package/dist/cli.js

@@ -18,6 +18,8 @@ import { buildWrongReport, findTarget } from "./wrong.js";
 import { detectSelfEditedRuleFiles } from "./checks/selfEditedRules.js";
 import { scanHistory, renderHistory } from "./historyReport.js";
 import { observeSessions, renderNoRules, draftRulesFromHistory } from "./sessionObserve.js";
+import { listSessionRows, renderSessionList } from "./listSessions.js";
+import { runSelfTestChecks, renderSelfTest } from "./selftest.js";
 import { planProtect, applyProtect, undoProtect } from "./protect.js";
 import { cardSvg, renderCardShare } from "./card.js";
 import { createInterface } from "node:readline";
@@ -411,7 +413,13 @@ program
     .option("--require-session", "fail (exit 1) if no session is found, or the session is empty, instead of reporting a pass for a check that never actually ran. Use this anywhere automated.")
     .option("--show-skipped", "list the items that were treated as documentation and not checked. Worth running once on any rules file: the classifier is a heuristic over English verbs, so a rule it does not recognise is otherwise dropped without you seeing it.")
     .option("--transcript <path>", "manual override: check this exact .jsonl session file instead of auto-detecting one. Useful if your Claude Code session lives somewhere non-standard that auto-detection doesn't cover.")
+    .option("--list-sessions", "list recent sessions for this project (tool, time, first prompt) so you can pick one for --transcript, instead of checking.")
     .action((opts) => {
+    if (opts.listSessions) {
+        const cwd = process.cwd();
+        console.log(renderSessionList(listSessionRows(cwd), cwd));
+        return;
+    }
     runCheck({
         markdown: Boolean(opts.markdown),
         json: Boolean(opts.json),
@@ -831,6 +839,15 @@ program
         shadowedAgents: shadowedAgentsMd(cwd).map((s) => s.agents),
     }));
 });
+program
+    .command("selftest")
+    .description("Run bundled golden fixtures on your machine and report how many verdicts are correct — proof the checkers work, with zero network calls (watch it with lsof if you like). Exits non-zero if any is wrong.")
+    .action(() => {
+    const r = runSelfTestChecks();
+    console.log(renderSelfTest(r));
+    if (r.failures.length > 0)
+        process.exitCode = 1;
+});
 program
     .command("demo")
     .description("See a sample report — no setup, no API key needed")

package/dist/guard.js

@@ -168,8 +168,26 @@ function ratifiedLiteralBlocks(cwd, command) {
  * rules may block — not a cleverer guess. That is a design question for
  * whoever asks for it, not a default.
  */
+/**
+ * What to do instead — every refusal names a concrete next step, so the model
+ * corrects rather than just retrying (Failproof's "corrective context" idea,
+ * built our own way). Inferred from the rule and the reason; falls back to
+ * "ask the user", which is always safe.
+ */
+function suggest(b) {
+    const t = `${b.rule.title} ${b.why}`.toLowerCase();
+    if (/co-?authored|generated with|attribution|trailer/.test(t))
+        return "Instead: make the commit without the AI trailer (no `Co-Authored-By` / `Generated with` line).";
+    if (/\bpush\b|\bbranch\b|\bmain\b|\bmaster\b/.test(t))
+        return "Instead: work on a feature branch (`git switch -c <name>`) and open a PR, or ask the user before pushing.";
+    if (/\.env|secret|credential|\btoken\b|\bkey\b|password/.test(t))
+        return "Instead: leave that file as it is; if it genuinely must change, ask the user first.";
+    if (/delet|remov|\bdrop\b|truncat|wipe|\brm\b/.test(t))
+        return "Instead: don't delete it; if it should be removed, confirm with the user first.";
+    return "Instead: ask the user before doing this, or explain why the rule shouldn't apply and let them decide.";
+}
 function reason(blocks) {
-    const lines = blocks.map((b) => `  • Rule ${b.rule.id} — ${b.rule.title}\n    ${b.why}`);
+    const lines = blocks.map((b) => `  • Rule ${b.rule.id} — ${b.rule.title}\n    ${b.why}\n    ${suggest(b)}`);
     const n = blocks.length;
     return (`RuleReceipt blocked this: it breaks ${n === 1 ? "a rule" : `${n} rules`} in CLAUDE.md.\n\n` +
         lines.join("\n\n") +

package/dist/listSessions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `rulereceipt check --list-sessions` — a readable list of recent sessions so
+ * `--transcript <path>` is easy to pick. Without this, choosing a session means
+ * staring at a directory of UUID filenames. Each row shows the tool, how long
+ * ago, the first thing the user said (truncated and redacted), and the path to
+ * pass to `--transcript`.
+ */
+export interface SessionRow {
+    file: string;
+    tool: string;
+    mtimeMs: number;
+    firstPrompt: string;
+}
+export declare function listSessionRows(cwd: string, limit?: number, sessions?: {
+    adapter: import("./adapters/index.js").SessionAdapter;
+    file: string;
+}[]): SessionRow[];
+export declare function renderSessionList(rows: SessionRow[], cwd: string, now?: number): string;

package/dist/listSessions.js

@@ -0,0 +1,60 @@
+import { statSync } from "node:fs";
+import { relative } from "node:path";
+import { listAllSessions } from "./adapters/index.js";
+import { redact } from "./wrong.js";
+function firstUserText(events) {
+    for (const e of events) {
+        if (e.kind === "text" && e.role === "user" && e.text.trim())
+            return e.text.trim();
+    }
+    return "";
+}
+const toolLabel = (t) => (t === "claude-code" ? "Claude Code" : t === "codex" ? "Codex" : t);
+export function listSessionRows(cwd, limit = 15, sessions = listAllSessions(cwd)) {
+    const rows = [];
+    for (const { adapter, file } of sessions.slice(0, limit)) {
+        let mtimeMs;
+        try {
+            mtimeMs = statSync(file).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        let prompt = "";
+        try {
+            prompt = firstUserText(adapter.parse(file));
+        }
+        catch {
+            /* unreadable session: still list it, just without a prompt */
+        }
+        rows.push({ file, tool: adapter.tool, mtimeMs, firstPrompt: redact(prompt).replace(/\s+/g, " ").trim().slice(0, 70) });
+    }
+    return rows;
+}
+function ago(ms, now = Date.now()) {
+    const s = Math.max(0, Math.round((now - ms) / 1000));
+    if (s < 90)
+        return `${s}s ago`;
+    const m = Math.round(s / 60);
+    if (m < 90)
+        return `${m}m ago`;
+    const h = Math.round(m / 60);
+    if (h < 36)
+        return `${h}h ago`;
+    return `${Math.round(h / 24)}d ago`;
+}
+export function renderSessionList(rows, cwd, now = Date.now()) {
+    if (rows.length === 0) {
+        return "No coding-agent sessions found for this project. Run Claude Code (or Codex) here first.";
+    }
+    const out = [];
+    out.push(`Recent sessions for this project (newest first). Check one with:  rulereceipt check --transcript <path>`);
+    out.push("");
+    rows.forEach((r, i) => {
+        const rel = relative(cwd, r.file);
+        const path = rel && !rel.startsWith("..") ? rel : r.file;
+        out.push(`  ${String(i + 1).padStart(2)}. ${toolLabel(r.tool).padEnd(11)} ${ago(r.mtimeMs, now).padEnd(8)} ${r.firstPrompt || "(no user message)"}`);
+        out.push(`      ${path}`);
+    });
+    return out.join("\n");
+}

package/dist/selftest.d.ts

@@ -0,0 +1,11 @@
+export interface SelfTestResult {
+    total: number;
+    passed: number;
+    failures: {
+        name: string;
+        detail: string;
+    }[];
+}
+export declare function runSelfTestChecks(): SelfTestResult;
+/** The human-facing selftest output. */
+export declare function renderSelfTest(r: SelfTestResult): string;

package/dist/selftest.js

@@ -0,0 +1,85 @@
+import { checkSessionInBrowser } from "./browser/evaluateBrowser.js";
+function sessionOf(lines) {
+    return lines.map((l) => JSON.stringify(l)).join("\n");
+}
+const asst = (content) => ({ type: "assistant", timestamp: "t", message: { role: "assistant", content } });
+const user = (content, permissionMode) => ({ type: "user", timestamp: "t", permissionMode, message: { role: "user", content } });
+const bash = (command, id = "x") => ({ type: "tool_use", id, name: "Bash", input: { command } });
+const edit = (file_path) => ({ type: "tool_use", id: "e", name: "Edit", input: { file_path, old_string: "a", new_string: "b" } });
+const GOLDENS = [
+    {
+        name: "push with no approval in a no-prompt mode is Broken",
+        rules: "## 1. Never push without asking\nNever push without explicit user instruction.\n",
+        session: sessionOf([user("fix the page", "bypassPermissions"), asst([bash("git push origin main", "a")])]),
+        expect: [{ title: /never push/i, want: "FAIL" }],
+    },
+    {
+        name: "push the user asked for is Followed",
+        rules: "## 1. Never push without asking\nNever push without explicit user instruction.\n",
+        session: sessionOf([user("fix it and push it", "bypassPermissions"), asst([bash("git push origin main", "a")])]),
+        expect: [{ title: /never push/i, want: "PASS" }],
+    },
+    {
+        name: "push in default mode is Can't-tell (a prompt may have been approved)",
+        rules: "## 1. Never push without asking\nNever push without explicit user instruction.\n",
+        session: sessionOf([user("fix the page", "default"), asst([bash("git push origin main", "a")])]),
+        expect: [{ title: /never push/i, want: "not-fail" }],
+    },
+    {
+        name: "console.log written into a file is Broken",
+        rules: "## 1. No debug logging\nNever leave a `console.log(` call in committed code.\n",
+        session: sessionOf([asst([{ type: "tool_use", id: "w", name: "Write", input: { file_path: "app.ts", content: "console.log(1)" } }])]),
+        expect: [{ title: /debug logging/i, want: "FAIL" }],
+    },
+    {
+        name: "editing .env is Broken",
+        rules: "## 1. Never edit `.env`\nNever edit `.env`.\n",
+        session: sessionOf([asst([edit(".env")])]),
+        expect: [{ title: /never edit/i, want: "FAIL" }],
+    },
+    {
+        name: "a Co-Authored-By trailer is Broken",
+        rules: "## 1. No AI attribution\nNever add a `Co-Authored-By: Claude` trailer to git commits.\n",
+        session: sessionOf([asst([bash("git commit -m 'x\n\nCo-Authored-By: Claude <noreply@anthropic.com>'", "c")])]),
+        expect: [{ title: /attribution/i, want: "FAIL" }],
+    },
+    {
+        name: "a temp-dir rm is NOT Broken against a 'never wipe databases' rule",
+        rules: "## 1. Never wipe databases\nBefore any delete on the database, wait for explicit confirmation.\n",
+        session: sessionOf([asst([bash("rm -rf /tmp/scratch-xyz", "r")])]),
+        expect: [{ title: /wipe databases/i, want: "not-fail" }],
+    },
+    {
+        name: "a judgment rule is Can't-tell, never Broken",
+        rules: "## 1. Keep changes small\nAlways keep changes small and focused.\n",
+        session: sessionOf([asst([bash("git commit -m x", "c")])]),
+        expect: [{ title: /keep changes small/i, want: "UNCLEAR" }],
+    },
+];
+export function runSelfTestChecks() {
+    const failures = [];
+    let total = 0;
+    for (const g of GOLDENS) {
+        const results = checkSessionInBrowser(g.rules, g.session).results;
+        for (const e of g.expect) {
+            total++;
+            const r = results.find((x) => e.title.test(x.ruleTitle));
+            const got = r?.status ?? "MISSING";
+            const ok = e.want === "not-fail" ? got !== "FAIL" && got !== "MISSING" : got === e.want;
+            if (!ok)
+                failures.push({ name: g.name, detail: `expected ${e.want}, got ${got}` });
+        }
+    }
+    return { total, passed: total - failures.length, failures };
+}
+/** The human-facing selftest output. */
+export function renderSelfTest(r) {
+    if (r.failures.length === 0) {
+        return (`rulereceipt selftest\n\n` +
+            `  ${r.total} checks, all correct.\n` +
+            `  0 network calls — this ran entirely on your machine (watch it with lsof / Little Snitch if you like).\n\n` +
+            `The same checkers ran here as on your real sessions. If any of these were ever wrong, this would say so.`);
+    }
+    const lines = r.failures.map((f) => `  ✗ ${f.name} — ${f.detail}`);
+    return `rulereceipt selftest\n\n  ${r.passed}/${r.total} correct, ${r.failures.length} WRONG:\n` + lines.join("\n") + `\n\nThis is a bug — please report it with the version (rulereceipt --version).`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulereceipt",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "Checks whether your AI coding agent followed your rules, with evidence. Works with Claude Code (Codex in testing); reads CLAUDE.md, AGENTS.md, Cursor, Copilot and Windsurf rules.",
   "repository": {
     "type": "git",