rulereceipt 0.1.64 → 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/browser/analyze.d.ts

@@ -43,3 +43,4 @@ export declare const CORPUS: {
     checkablePct: number;
 };
 export declare function analyze(text: string): AnalysisResult;
+export { evaluateBrowserSession, checkSessionInBrowser, type BrowserSessionSummary } from "./evaluateBrowser.js";

package/dist/browser/analyze.js

@@ -47,3 +47,6 @@ export function analyze(text) {
         judgmentSamples,
     };
 }
+// Client-side SESSION check for the browser demo: drop a session .jsonl +
+// paste rules, get per-rule verdicts, nothing uploaded. Same checkers as the CLI.
+export { evaluateBrowserSession, checkSessionInBrowser } from "./evaluateBrowser.js";

package/dist/browser/evaluateBrowser.d.ts

@@ -0,0 +1,23 @@
+import type { CheckResult } from "../types.js";
+/**
+ * Evaluate a session against rules ENTIRELY in the browser — the same checkers
+ * the CLI uses, run on a file the user dropped, with nothing leaving the page.
+ *
+ * This is the CLI's evaluateSession minus the parts that need a machine: no
+ * saved overrides, no git rule-age split, no reading the user's settings.json
+ * for a permissions.allow list (so the approval check runs with an empty allow
+ * list — it can only be MORE cautious, never less). Everything reachable from
+ * here is pure string work; keep it that way so the site's "your file never
+ * leaves this page" promise stays true. Judgment rules report UNCLEAR (no LLM
+ * call), exactly as `check` without `--llm` does.
+ */
+export declare function evaluateBrowserSession(rulesText: string, sessionText: string): CheckResult[];
+export interface BrowserSessionSummary {
+    results: CheckResult[];
+    pass: number;
+    fail: number;
+    unclear: number;
+    events: number;
+}
+/** The whole client-side session check: parse, evaluate, and count. */
+export declare function checkSessionInBrowser(rulesText: string, sessionText: string): BrowserSessionSummary;

package/dist/browser/evaluateBrowser.js

@@ -0,0 +1,78 @@
+import { parseTranscriptText } from "../parsers/transcriptLine.js";
+import { parseClaudeMdText } from "../parsers/claudeMdParser.js";
+import { classifyRules } from "../checks/classify.js";
+import { runDeterministicChecks } from "../checks/deterministicChecks.js";
+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 { runEmojiChecks } from "../checks/emojiOutput.js";
+import { runAttributionChecks } from "../checks/attribution.js";
+import { runApprovalGateChecks } from "../checks/approvalGate.js";
+import { touchedPaths, ruleWasLoaded } from "../checks/pathScope.js";
+/**
+ * Evaluate a session against rules ENTIRELY in the browser — the same checkers
+ * the CLI uses, run on a file the user dropped, with nothing leaving the page.
+ *
+ * This is the CLI's evaluateSession minus the parts that need a machine: no
+ * saved overrides, no git rule-age split, no reading the user's settings.json
+ * for a permissions.allow list (so the approval check runs with an empty allow
+ * list — it can only be MORE cautious, never less). Everything reachable from
+ * here is pure string work; keep it that way so the site's "your file never
+ * leaves this page" promise stays true. Judgment rules report UNCLEAR (no LLM
+ * call), exactly as `check` without `--llm` does.
+ */
+export function evaluateBrowserSession(rulesText, sessionText) {
+    const rules = parseClaudeMdText(rulesText, "project");
+    const events = parseTranscriptText(sessionText);
+    const touched = touchedPaths(events);
+    const classified = classifyRules(rules);
+    // A path-scoped rule the session never touched a matching file for was never
+    // loaded by the agent, so it is reported not-applicable rather than judged.
+    const notLoaded = classified.filter((c) => c.kind !== "notARule" && c.rule.paths && !ruleWasLoaded(c.rule.paths, touched));
+    const classifications = classified.filter((c) => !notLoaded.includes(c));
+    const scopeResults = notLoaded.map(({ rule }) => ({
+        ruleId: rule.id,
+        ruleTitle: rule.title,
+        ruleSource: rule.source,
+        status: "UNCLEAR",
+        outcome: "not_applicable",
+        method: "file_events",
+        reason: "path_scope_not_loaded",
+        evidence: `path-scoped rule (${rule.paths.join(", ")}): this session touched no matching file, so it was never loaded`,
+    }));
+    const of = (kind) => classifications.filter((c) => c.kind === kind);
+    const deterministicResults = [
+        ...runDeterministicChecks(of("deterministic"), events),
+        ...runIfEditThenTestChecks(of("ifEditThenTest"), events),
+        ...runGitBranchPolicyChecks(of("gitBranchPolicy"), events),
+        ...runCodeContentChecks(of("codeContent"), events),
+        ...runFileLifecycleChecks(of("fileLifecycle"), events),
+        ...runClaimEvidenceChecks(of("claimEvidence"), events),
+        ...runEmojiChecks(of("emojiOutput"), events),
+        ...runAttributionChecks(of("attribution"), events),
+        ...runApprovalGateChecks(of("approvalGate"), events, { allow: [] }),
+    ];
+    const judgmentResults = of("judgment").map(({ rule }) => ({
+        ruleId: rule.id,
+        ruleTitle: rule.title,
+        ruleSource: rule.source,
+        status: "UNCLEAR",
+        needsHuman: true,
+        evidence: "",
+    }));
+    return [...deterministicResults, ...judgmentResults, ...scopeResults];
+}
+/** The whole client-side session check: parse, evaluate, and count. */
+export function checkSessionInBrowser(rulesText, sessionText) {
+    const results = evaluateBrowserSession(rulesText, sessionText);
+    const count = (s) => results.filter((r) => r.status === s).length;
+    return {
+        results,
+        pass: count("PASS"),
+        fail: count("FAIL"),
+        unclear: count("UNCLEAR"),
+        events: parseTranscriptText(sessionText).length,
+    };
+}

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

@@ -17,6 +17,9 @@ import { evaluateSession } from "./evaluate.js";
 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";
@@ -410,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),
@@ -797,9 +806,31 @@ program
 });
 program
     .command("init")
-    .description("Guided setup: shows what's configured and the exact next steps. Read-only — writes nothing.")
-    .action(() => {
+    .description("Guided setup: shows what's configured and the exact next steps. Read-only — writes nothing (except --from-history, which drafts a starter rules file you approve).")
+    .option("--from-history", "draft a starter rules file from what your agent did in recent sessions, written to .rulereceipt/draft-CLAUDE.md (never overwrites an existing rules file)")
+    .option("--days <n>", "how many days back to look, with --from-history", "30")
+    .action((opts) => {
     const cwd = process.cwd();
+    if (opts.fromHistory) {
+        const d = Number.parseInt(opts.days ?? "30", 10);
+        const obs = observeSessions(cwd, Number.isFinite(d) && d > 0 ? d : 30);
+        if (obs.sessions === 0) {
+            console.log("No sessions found for this project yet, so there's nothing to draft rules from. Run your agent here first.");
+            process.exitCode = 1;
+            return;
+        }
+        const draftPath = join(cwd, ".rulereceipt", "draft-CLAUDE.md");
+        if (existsSync(draftPath)) {
+            console.log(`A draft already exists at ${draftPath} — open it, or delete it and re-run. Not overwriting.`);
+            return;
+        }
+        mkdirSync(dirname(draftPath), { recursive: true });
+        writeFileSync(draftPath, draftRulesFromHistory(obs));
+        console.log(`Drafted a starter rules file from ${obs.sessions} session${obs.sessions === 1 ? "" : "s"} → ${draftPath}`);
+        console.log("Read it, keep the rules you want, then move it to CLAUDE.md (or AGENTS.md) in your project root.");
+        console.log("It's a draft only — nothing is enforced until you move it into place and run `rulereceipt`.");
+        return;
+    }
     console.log(buildInitGuidance({
         hasClaudeMd: existsSync(join(cwd, "CLAUDE.md")),
         hasAgentsMd: existsSync(join(cwd, "AGENTS.md")),
@@ -808,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")
@@ -1131,15 +1171,24 @@ program
 });
 async function runHistory(opts) {
     const cwd = process.cwd();
+    const parsedDays = Number.parseInt(opts.days ?? "30", 10);
+    const days = Number.isFinite(parsedDays) && parsedDays > 0 ? parsedDays : 30;
     const rules = loadRules(cwd);
     if (rules.length === 0) {
-        console.log("No rules file found for this project (checked CLAUDE.md / AGENTS.md and every ~/.claude*/CLAUDE.md).\n" +
-            "Add a CLAUDE.md or AGENTS.md with the rules you want checked, then run `rulereceipt` again.\n" +
-            "To score a rules file you already have: rulereceipt audit");
+        // No rules to judge against — but we can still show what the agent DID, so a
+        // first-time user sees something true about their own work.
+        const obs = observeSessions(cwd, days);
+        if (obs.sessions === 0) {
+            console.log("No rules file and no coding-agent sessions found for this project yet.\n" +
+                "Run Claude Code (or Codex) here, then `rulereceipt` shows what it did — or `rulereceipt demo` for a sample.\n" +
+                "To score a rules file you already have: rulereceipt audit");
+        }
+        else {
+            console.log(renderNoRules(obs, basename(cwd) || "this project"));
+        }
         return;
     }
-    const days = Number.parseInt(opts.days ?? "30", 10);
-    const summary = await scanHistory(cwd, rules, Number.isFinite(days) && days > 0 ? days : 30);
+    const summary = await scanHistory(cwd, rules, days);
     console.log(renderHistory(summary, basename(cwd) || "this project"));
 }
 // Bare `rulereceipt` (no subcommand, no flags) runs history mode — the first-run

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/parsers/transcriptLine.d.ts

@@ -0,0 +1,8 @@
+import type { TranscriptEvent } from "../types.js";
+export declare function parseLine(line: string): TranscriptEvent[];
+/**
+ * Parse a whole session file's TEXT (not a path) into events, tracking the
+ * permission mode the same way readTranscriptFromFile does — so the browser
+ * demo and the CLI agree. Pure: takes the file contents as a string.
+ */
+export declare function parseTranscriptText(raw: string): TranscriptEvent[];

package/dist/parsers/transcriptLine.js

@@ -0,0 +1,121 @@
+/**
+ * The pure, Node-free half of transcript parsing: one JSONL line → events.
+ *
+ * Extracted from transcriptParser.ts 2026-09-28 so the browser demo can parse a
+ * dropped session file client-side, with the SAME logic as the CLI and no
+ * filesystem dependency. The site's "your file never leaves this page" claim
+ * depends on everything reachable from here being pure string work — keep it
+ * that way (no node: imports, no network, no storage).
+ */
+function extractToolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => (typeof part === "object" && part && "text" in part ? String(part.text) : ""))
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+export function parseLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    // JSON.parse accepts any valid JSON value, not just objects — "null", "42",
+    // "\"a string\"" all parse without throwing. A transcript line is only ever
+    // meaningful as an object; anything else is skipped, not a crash.
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return [];
+    }
+    const obj = parsed;
+    const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : "";
+    const events = [];
+    if (obj.type === "assistant" && !obj.isApiErrorMessage) {
+        const message = obj.message;
+        const content = message?.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (typeof block !== "object" || block === null)
+                    continue;
+                const b = block;
+                if (b.type === "text" && typeof b.text === "string") {
+                    events.push({ role: "assistant", kind: "text", text: b.text, timestamp });
+                }
+                else if (b.type === "tool_use" && typeof b.name === "string") {
+                    events.push({ role: "assistant", kind: "tool_use", toolName: b.name, input: b.input, timestamp, toolUseId: typeof b.id === "string" ? b.id : undefined });
+                }
+            }
+        }
+    }
+    else if (obj.type === "user") {
+        const message = obj.message;
+        const content = message?.content;
+        if (typeof content === "string") {
+            events.push({ role: "user", kind: "text", text: content, timestamp });
+        }
+        else if (Array.isArray(content)) {
+            for (const block of content) {
+                if (typeof block !== "object" || block === null)
+                    continue;
+                const b = block;
+                // User text sent as blocks (VS Code / IDE extension, or any message with
+                // an image) was dropped until 2026-09-28: in real sessions whole
+                // conversations had no user message at all, so every check that reads
+                // what the user said saw nothing. Harness-injected context wrapped in
+                // tags (<ide_opened_file>, <system-reminder>, …) is not the user
+                // speaking and is stripped; what remains is.
+                if (b.type === "text" && typeof b.text === "string") {
+                    const said = b.text.replace(/<([a-z][\w-]*)>[\s\S]*?<\/\1>/gi, "").trim();
+                    if (said.length > 0)
+                        events.push({ role: "user", kind: "text", text: said, timestamp });
+                    continue;
+                }
+                if (b.type === "tool_result") {
+                    events.push({
+                        role: "user",
+                        kind: "tool_result",
+                        content: extractToolResultText(b.content),
+                        isError: b.is_error === true,
+                        timestamp,
+                        toolUseId: typeof b.tool_use_id === "string" ? b.tool_use_id : undefined,
+                    });
+                }
+            }
+        }
+    }
+    return events;
+}
+/**
+ * Parse a whole session file's TEXT (not a path) into events, tracking the
+ * permission mode the same way readTranscriptFromFile does — so the browser
+ * demo and the CLI agree. Pure: takes the file contents as a string.
+ */
+export function parseTranscriptText(raw) {
+    const events = [];
+    let mode;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const m = line.match(/"(?:permissionMode|permission_mode)":"([A-Za-z]+)"/) ??
+                (line.includes('"permission-mode"') ? line.match(/"mode":"([A-Za-z]+)"/) : null);
+            if (m)
+                mode = m[1];
+            const parsed = parseLine(line);
+            if (mode)
+                for (const e of parsed)
+                    if (e.kind === "tool_use")
+                        e.permissionMode = mode;
+            events.push(...parsed);
+        }
+        catch {
+            continue;
+        }
+    }
+    return events;
+}

package/dist/parsers/transcriptParser.d.ts

@@ -8,7 +8,7 @@ export declare function findClaudeHomeDirNames(): string[];
 /** Every session file for this project, newest first. */
 export declare function listAllSessionFiles(cwd: string): string[];
 export declare function findLatestSessionFile(cwd: string): string | null;
-export declare function parseLine(line: string): TranscriptEvent[];
+export { parseLine } from "./transcriptLine.js";
 /**
  * Read the most recently modified session transcript for a project
  * directory. Returns an empty array (not an error) if no session exists

package/dist/parsers/transcriptParser.js

@@ -1,6 +1,7 @@
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname, basename } from "node:path";
+import { parseTranscriptText } from "./transcriptLine.js";
 /**
  * Claude Code stores each session as a JSONL file at:
  *   ~/.claude/projects/<cwd with every "/" replaced by "-">/<sessionId>.jsonl
@@ -80,89 +81,9 @@ export function findLatestSessionFile(cwd) {
     const all = listAllSessionFiles(cwd);
     return all.length > 0 ? all[0] : null;
 }
-function extractToolResultText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => (typeof part === "object" && part && "text" in part ? String(part.text) : ""))
-            .filter(Boolean)
-            .join("\n");
-    }
-    return "";
-}
-export function parseLine(line) {
-    let parsed;
-    try {
-        parsed = JSON.parse(line);
-    }
-    catch {
-        return [];
-    }
-    // JSON.parse accepts any valid JSON value, not just objects — "null",
-    // "42", "\"a string\"" all parse without throwing. A transcript line is
-    // only ever meaningful as an object; anything else is skipped, not a crash.
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        return [];
-    }
-    const obj = parsed;
-    const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : "";
-    const events = [];
-    if (obj.type === "assistant" && !obj.isApiErrorMessage) {
-        const message = obj.message;
-        const content = message?.content;
-        if (Array.isArray(content)) {
-            for (const block of content) {
-                if (typeof block !== "object" || block === null)
-                    continue;
-                const b = block;
-                if (b.type === "text" && typeof b.text === "string") {
-                    events.push({ role: "assistant", kind: "text", text: b.text, timestamp });
-                }
-                else if (b.type === "tool_use" && typeof b.name === "string") {
-                    events.push({ role: "assistant", kind: "tool_use", toolName: b.name, input: b.input, timestamp, toolUseId: typeof b.id === "string" ? b.id : undefined });
-                }
-            }
-        }
-    }
-    else if (obj.type === "user") {
-        const message = obj.message;
-        const content = message?.content;
-        if (typeof content === "string") {
-            events.push({ role: "user", kind: "text", text: content, timestamp });
-        }
-        else if (Array.isArray(content)) {
-            for (const block of content) {
-                if (typeof block !== "object" || block === null)
-                    continue;
-                const b = block;
-                // User text sent as blocks (VS Code / IDE extension, or any message with
-                // an image) was dropped until 2026-09-28: in real sessions whole
-                // conversations had no user message at all, so every check that reads
-                // what the user said saw nothing. Harness-injected context wrapped in
-                // tags (<ide_opened_file>, <system-reminder>, …) is not the user
-                // speaking and is stripped; what remains is.
-                if (b.type === "text" && typeof b.text === "string") {
-                    const said = b.text.replace(/<([a-z][\w-]*)>[\s\S]*?<\/\1>/gi, "").trim();
-                    if (said.length > 0)
-                        events.push({ role: "user", kind: "text", text: said, timestamp });
-                    continue;
-                }
-                if (b.type === "tool_result") {
-                    events.push({
-                        role: "user",
-                        kind: "tool_result",
-                        content: extractToolResultText(b.content),
-                        isError: b.is_error === true,
-                        timestamp,
-                        toolUseId: typeof b.tool_use_id === "string" ? b.tool_use_id : undefined,
-                    });
-                }
-            }
-        }
-    }
-    return events;
-}
+// parseLine (and its permission-mode-tracking wrapper parseTranscriptText) live
+// in transcriptLine.ts — a pure, Node-free module the browser demo also imports.
+export { parseLine } from "./transcriptLine.js";
 /**
  * Read the most recently modified session transcript for a project
  * directory. Returns an empty array (not an error) if no session exists
@@ -170,35 +91,9 @@ export function parseLine(line) {
  * not a failure.
  */
 export function readTranscriptFromFile(filePath) {
-    const raw = readFileSync(filePath, "utf-8");
-    const events = [];
-    // Permission mode is recorded on user turns (and on `permission-mode` entries
-    // in newer versions); it applies to the tool calls that follow. The approval
-    // check needs it to tell "a prompt may have been approved" (default/
-    // acceptEdits/plan) from "no person was asked" (bypassPermissions/dontAsk/auto).
-    let mode;
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        try {
-            const m = line.match(/"(?:permissionMode|permission_mode)":"([A-Za-z]+)"/) ??
-                (line.includes('"permission-mode"') ? line.match(/"mode":"([A-Za-z]+)"/) : null);
-            if (m)
-                mode = m[1];
-            const parsed = parseLine(line);
-            if (mode)
-                for (const e of parsed)
-                    if (e.kind === "tool_use")
-                        e.permissionMode = mode;
-            events.push(...parsed);
-        }
-        catch {
-            // One malformed/unexpected line must not crash the whole check —
-            // skip it and keep going, same fail-closed principle as everywhere else.
-            continue;
-        }
-    }
-    return events;
+    // Pure parsing (including permission-mode tracking) lives in transcriptLine.ts
+    // so the browser demo can run the exact same logic on a dropped file.
+    return parseTranscriptText(readFileSync(filePath, "utf-8"));
 }
 /**
  * Subagent transcripts for a session.

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/dist/sessionObserve.d.ts

@@ -0,0 +1,20 @@
+export interface SessionObservations {
+    sessions: number;
+    days: number;
+    tools: string[];
+    pushes: number;
+    commits: number;
+    envWrites: number;
+    /** "the tests pass" claims where no test command ran anywhere in that session. */
+    testClaimsNoRun: number;
+    testClaims: number;
+    elapsedMs: number;
+}
+export declare function observeSessions(cwd: string, days?: number, now?: number, sessions?: {
+    adapter: import("./adapters/index.js").SessionAdapter;
+    file: string;
+}[]): SessionObservations;
+/** The no-rules screen: what the agent did, and how to turn it into rules. */
+export declare function renderNoRules(o: SessionObservations, projectName: string): string;
+/** A starter rules file drafted from the observed actions. Only rules for things that happened. */
+export declare function draftRulesFromHistory(o: SessionObservations): string;

package/dist/sessionObserve.js

@@ -0,0 +1,129 @@
+import { statSync } from "node:fs";
+import { listAllSessions } from "./adapters/index.js";
+import { withoutHeredocs } from "./checks/shellCommand.js";
+/**
+ * "What did your agent actually do?" — for someone with sessions but NO rules
+ * file. History mode needs rules to judge; this needs none. It just reports a
+ * few plainly-observable actions across recent sessions (pushes, edits to
+ * `.env`, "the tests pass" claims), so a first-time user sees something true
+ * about their own work even before they've written a single rule, and then
+ * `init --from-history` drafts a starter rules file from what it saw.
+ *
+ * These are OBSERVATIONS, not verdicts — nothing here says a rule was broken,
+ * because there is no rule yet. The wording stays factual ("pushed 9 times")
+ * and the checkers' polarity/false-accusation discipline does not apply,
+ * precisely because nothing is being accused.
+ */
+const PUSH = /\bgit\s+(?:\S+\s+){0,4}?push(?![\w-])/;
+const COMMIT = /\bgit\s+(?:\S+\s+){0,4}?commit(?![\w-])/;
+const ENV_FILE = /(?:^|[\\/])\.env(?:\.[\w.-]+)?$/;
+// A "the tests pass" style completion claim — the strongest, least-noisy signal.
+const TESTS_PASS_CLAIM = /\b(?:all\s+)?tests?\s+(?:are\s+)?(?:pass(?:ing|ed|es)?|green)\b|\ball\s+green\b|\beverything\s+(?:passes|works)\b/i;
+const TEST_COMMAND = /\b(?:npm\s+(?:run\s+)?test|npx\s+vitest|vitest|jest|pytest|go\s+test|cargo\s+test|mvn\s+test|rspec|phpunit|\btox\b)\b/;
+function bashCommand(e) {
+    if (e.kind !== "tool_use" || e.toolName !== "Bash")
+        return "";
+    const c = e.input?.command;
+    return typeof c === "string" ? withoutHeredocs(c) : "";
+}
+function editedPath(e) {
+    if (e.kind !== "tool_use")
+        return "";
+    if (e.toolName !== "Write" && e.toolName !== "Edit" && e.toolName !== "MultiEdit" && e.toolName !== "NotebookEdit")
+        return "";
+    const p = e.input;
+    const path = p?.file_path ?? p?.notebook_path;
+    return typeof path === "string" ? path : "";
+}
+export function observeSessions(cwd, days = 30, now = Date.now(), sessions = listAllSessions(cwd)) {
+    const started = Date.now();
+    const cutoff = now - days * 24 * 60 * 60 * 1000;
+    const tools = new Set();
+    let scanned = 0, pushes = 0, commits = 0, envWrites = 0, testClaims = 0, testClaimsNoRun = 0;
+    for (const { adapter, file } of sessions) {
+        let ms;
+        try {
+            ms = statSync(file).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        if (ms < cutoff)
+            continue;
+        let events;
+        try {
+            events = adapter.parse(file);
+        }
+        catch {
+            continue;
+        }
+        if (events.length === 0)
+            continue;
+        scanned++;
+        tools.add(adapter.tool);
+        const ranTest = events.some((e) => TEST_COMMAND.test(bashCommand(e)));
+        for (const e of events) {
+            const cmd = bashCommand(e);
+            if (cmd && PUSH.test(cmd))
+                pushes++;
+            if (cmd && COMMIT.test(cmd))
+                commits++;
+            if (ENV_FILE.test(editedPath(e)))
+                envWrites++;
+            if (e.kind === "text" && e.role === "assistant" && TESTS_PASS_CLAIM.test(e.text)) {
+                testClaims++;
+                if (!ranTest)
+                    testClaimsNoRun++;
+            }
+        }
+    }
+    return { sessions: scanned, days, tools: [...tools], pushes, commits, envWrites, testClaims, testClaimsNoRun, elapsedMs: Date.now() - started };
+}
+const toolLabel = (t) => (t === "claude-code" ? "Claude Code" : t === "codex" ? "Codex" : t);
+/** The no-rules screen: what the agent did, and how to turn it into rules. */
+export function renderNoRules(o, projectName) {
+    const who = o.tools.length === 1 && o.tools[0] === "claude-code" ? "Claude" : "your agent";
+    const out = [];
+    const toolNote = o.tools.length ? `${o.tools.map(toolLabel).join(" + ")} ` : "";
+    out.push(`RuleReceipt · ${projectName} · last ${o.days} days · ${o.sessions} ${toolNote}session${o.sessions === 1 ? "" : "s"}`);
+    out.push("");
+    out.push(`You don't have a rules file yet, so there's nothing to check against. Here's what ${who} actually did:`);
+    out.push("");
+    out.push(`  pushed ${o.pushes} time${o.pushes === 1 ? "" : "s"}`);
+    out.push(`  committed ${o.commits} time${o.commits === 1 ? "" : "s"}`);
+    out.push(`  wrote to a .env file ${o.envWrites} time${o.envWrites === 1 ? "" : "s"}`);
+    out.push(`  claimed the tests pass ${o.testClaims} time${o.testClaims === 1 ? "" : "s"}${o.testClaimsNoRun > 0 ? ` (${o.testClaimsNoRun} with no test command run that session)` : ""}`);
+    out.push("");
+    out.push("Turn this into rules to check from now on:");
+    out.push("  rulereceipt init --from-history   (drafts a starter CLAUDE.md from the above — never overwrites)");
+    out.push("");
+    out.push(`checked ${o.sessions} session${o.sessions === 1 ? "" : "s"} in ${(o.elapsedMs / 1000).toFixed(1)}s · nothing uploaded`);
+    return out.join("\n");
+}
+/** A starter rules file drafted from the observed actions. Only rules for things that happened. */
+export function draftRulesFromHistory(o) {
+    const lines = [
+        "# Project rules (draft)",
+        "",
+        "# Drafted by `rulereceipt init --from-history` from what your agent did in the",
+        "# last " + o.days + " days. Keep the ones you want, delete the rest, then move this",
+        "# to CLAUDE.md (or AGENTS.md) in your project root.",
+        "",
+    ];
+    let n = 0;
+    if (o.pushes > 0)
+        lines.push(`## ${++n}. Never push without asking`, "Don't run `git push` unless I've asked for it in this session.", "");
+    if (o.commits > 0)
+        lines.push(`## ${++n}. Ask before committing`, "Don't `git commit` unless I've asked for it.", "");
+    if (o.envWrites > 0)
+        lines.push(`## ${++n}. Never edit \`.env\``, "Don't write to `.env` or any `.env.*` file.", "");
+    if (o.testClaims > 0)
+        lines.push(`## ${++n}. Don't say the tests pass without running them`, "Only say the tests pass after actually running the test command in this session.", "");
+    if (n === 0) {
+        lines.push("# Nothing risky was observed to base a rule on. Write your own, e.g.:");
+        lines.push("## 1. Never push to `main`");
+        lines.push("Never push directly to the `main` branch.");
+        lines.push("");
+    }
+    return lines.join("\n") + "\n";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulereceipt",
-  "version": "0.1.64",
+  "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",