rulereceipt 0.1.64 → 0.1.65

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/cli.js

@@ -17,6 +17,7 @@ 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 { planProtect, applyProtect, undoProtect } from "./protect.js";
 import { cardSvg, renderCardShare } from "./card.js";
 import { createInterface } from "node:readline";
@@ -797,9 +798,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")),
@@ -1131,15 +1154,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/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/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.65",
   "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",