rulereceipt 0.1.63 → 0.1.65

package/README.md

@@ -49,6 +49,17 @@ showing you exactly what it will add and asking. `protect --undo` restores the
 file byte-for-byte. It's the only place RuleReceipt writes settings, and only
 with your yes.
 
+To share the result:
+
+```bash
+npx rulereceipt card
+```
+
+Writes a small SVG summary and prints ready-to-post links for X, LinkedIn,
+Bluesky and Reddit, plus copy-text for Slack or a PR. It carries **counts
+only** — no code, paths, or rule text (add rule names to the copy-text with
+`--show-rules`). Nothing is posted for you and nothing is uploaded.
+
 ## Status
 
 Published and live on npm, actively developed.

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

@@ -0,0 +1,36 @@
+/**
+ * `rulereceipt card` — a shareable image and pre-filled share links, built from
+ * history-mode counts. This is the "share it" step: someone runs RuleReceipt,
+ * sees their agent's mistakes, fixes them with `protect`, and posts the card.
+ *
+ * Privacy is the whole point of it being shareable: by default the card and the
+ * share text carry ONLY counts — never code, file paths, or rule text. A rule's
+ * name appears only when the user passes `--show-rules`, and even then only in
+ * the copy-text, never the image. Nothing is posted automatically and nothing
+ * is uploaded; the links open a compose window the user chooses to send.
+ */
+export interface CardData {
+    broken: number;
+    followed: number;
+    judgment: number;
+    sessions: number;
+    days: number;
+    /** "Claude" when the sessions are all Claude Code, else "the agent". */
+    who: string;
+    /** Titles of the broken rules — only used with --show-rules. */
+    brokenTitles?: string[];
+}
+/** The share caption. Counts only, unless showRules adds the broken rule names. */
+export declare function shareText(d: CardData, showRules?: boolean): string;
+export interface ShareLinks {
+    x: string;
+    linkedin: string;
+    bluesky: string;
+    reddit: string;
+}
+/** Compose-window links for each network. No auth, no posting — the user sends it. */
+export declare function shareLinks(text: string): ShareLinks;
+/** A self-contained SVG card. Counts only — never rule text, paths or code. */
+export declare function cardSvg(d: CardData): string;
+/** The terminal block: where the image went, the share links, and the copy-text. */
+export declare function renderCardShare(d: CardData, outPath: string, showRules?: boolean): string;

package/dist/card.js

@@ -0,0 +1,76 @@
+/**
+ * `rulereceipt card` — a shareable image and pre-filled share links, built from
+ * history-mode counts. This is the "share it" step: someone runs RuleReceipt,
+ * sees their agent's mistakes, fixes them with `protect`, and posts the card.
+ *
+ * Privacy is the whole point of it being shareable: by default the card and the
+ * share text carry ONLY counts — never code, file paths, or rule text. A rule's
+ * name appears only when the user passes `--show-rules`, and even then only in
+ * the copy-text, never the image. Nothing is posted automatically and nothing
+ * is uploaded; the links open a compose window the user chooses to send.
+ */
+const SITE = "rulereceipt.dev";
+/** The share caption. Counts only, unless showRules adds the broken rule names. */
+export function shareText(d, showRules = false) {
+    const base = d.broken > 0
+        ? `${d.who} broke my written rules ${d.broken} time${d.broken === 1 ? "" : "s"} in ${d.days} days (${d.sessions} session${d.sessions === 1 ? "" : "s"}) — now it can't.`
+        : `RuleReceipt checked ${d.sessions} of my agent session${d.sessions === 1 ? "" : "s"} over ${d.days} days against my written rules: ${d.broken} broken.`;
+    const tail = `Checked with RuleReceipt — runs locally, nothing uploaded. ${SITE}`;
+    if (showRules && d.broken > 0 && d.brokenTitles && d.brokenTitles.length > 0) {
+        const list = d.brokenTitles.slice(0, 3).map((t) => `“${t.replace(/\s+/g, " ").trim().slice(0, 50)}”`).join(", ");
+        return `${base}\nBroke: ${list}.\n${tail}`;
+    }
+    return `${base}\n${tail}`;
+}
+/** Compose-window links for each network. No auth, no posting — the user sends it. */
+export function shareLinks(text) {
+    const t = encodeURIComponent(text);
+    const url = encodeURIComponent(`https://${SITE}`);
+    const title = encodeURIComponent(text.split("\n")[0]);
+    return {
+        x: `https://twitter.com/intent/tweet?text=${t}`,
+        // LinkedIn's offsite share only takes a URL; the caption is added by the user.
+        linkedin: `https://www.linkedin.com/sharing/share-offsite/?url=${url}`,
+        bluesky: `https://bsky.app/intent/compose?text=${t}`,
+        reddit: `https://www.reddit.com/submit?title=${title}&url=${url}`,
+    };
+}
+function esc(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** A self-contained SVG card. Counts only — never rule text, paths or code. */
+export function cardSvg(d) {
+    const headline = d.broken > 0 ? `${d.who} broke your rules ${d.broken}×` : `0 rules broken`;
+    const sub = `${d.sessions} session${d.sessions === 1 ? "" : "s"} · last ${d.days} days`;
+    const stats = `${d.followed} followed · ${d.judgment} need judgment`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="800" height="418" viewBox="0 0 800 418" role="img" aria-label="RuleReceipt summary">
+  <rect width="800" height="418" fill="#0b0d10"/>
+  <rect x="0" y="0" width="800" height="6" fill="${d.broken > 0 ? "#e5534b" : "#3fb950"}"/>
+  <text x="56" y="86" fill="#8b949e" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="20">RuleReceipt</text>
+  <text x="56" y="196" fill="#e6edf3" font-family="-apple-system, Segoe UI, Roboto, sans-serif" font-size="52" font-weight="700">${esc(headline)}</text>
+  <text x="56" y="248" fill="#8b949e" font-family="-apple-system, Segoe UI, Roboto, sans-serif" font-size="24">${esc(sub)}</text>
+  <text x="56" y="300" fill="#8b949e" font-family="-apple-system, Segoe UI, Roboto, sans-serif" font-size="22">${esc(stats)}</text>
+  <text x="56" y="372" fill="#6e7681" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="18">proof from real sessions · local · nothing uploaded · ${SITE}</text>
+</svg>`;
+}
+/** The terminal block: where the image went, the share links, and the copy-text. */
+export function renderCardShare(d, outPath, showRules = false) {
+    const text = shareText(d, showRules);
+    const links = shareLinks(text);
+    const out = [];
+    out.push(`Saved a shareable card to ${outPath} (counts only — no code, paths or rule text).`);
+    out.push("");
+    out.push("Share it (opens a compose window — nothing is posted for you):");
+    out.push(`  X / Twitter  ${links.x}`);
+    out.push(`  LinkedIn     ${links.linkedin}`);
+    out.push(`  Bluesky      ${links.bluesky}`);
+    out.push(`  Reddit       ${links.reddit}`);
+    out.push("");
+    out.push("Copy text (for Slack / Discord / a PR):");
+    out.push(text.split("\n").map((l) => `  ${l}`).join("\n"));
+    if (!showRules && d.broken > 0) {
+        out.push("");
+        out.push("(Rule names are left out. Add them with --show-rules if you want them in the copy-text.)");
+    }
+    return out.join("\n");
+}

package/dist/cli.js

@@ -17,7 +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 { planProtect, applyProtect, undoProtect } from "./protect.js";
+import { cardSvg, renderCardShare } from "./card.js";
 import { createInterface } from "node:readline";
 import { loadOverrides, saveOverride, clearOverride, staleOverrides, ruleFingerprint, OVERRIDES_PATH } from "./overrides.js";
 import { runHook } from "./hook.js";
@@ -796,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")),
@@ -1087,6 +1111,40 @@ program
     console.log("The hooks call `rulereceipt` on your PATH (install once with `npm i -g rulereceipt`); they fail open if it's missing.");
     console.log("Undo:  rulereceipt protect --undo");
 });
+program
+    .command("card")
+    .description("Make a shareable image and pre-filled share links from your last 30 days of sessions — counts only, no code, paths or rule text (add rule names to the copy-text with --show-rules). Saves an SVG locally and prints X/LinkedIn/Bluesky/Reddit compose links. Nothing is posted and nothing is uploaded.")
+    .option("--out <path>", "where to write the SVG card", "rulereceipt-card.svg")
+    .option("--show-rules", "include the broken rule names in the copy-text (never in the image)")
+    .option("--days <n>", "how many days back to summarize", "30")
+    .action(async (opts) => {
+    const cwd = process.cwd();
+    const rules = loadRules(cwd);
+    if (rules.length === 0) {
+        console.log("No rules file found for this project, so there's nothing to summarize. Add a CLAUDE.md or AGENTS.md first.");
+        process.exitCode = 1;
+        return;
+    }
+    const days = Number.parseInt(opts.days ?? "30", 10);
+    const s = await scanHistory(cwd, rules, Number.isFinite(days) && days > 0 ? days : 30);
+    if (s.sessionsScanned === 0) {
+        console.log("No sessions found for this project in the window, so there's nothing to put on a card yet. Run your agent here, then try again.");
+        process.exitCode = 1;
+        return;
+    }
+    const data = {
+        broken: s.totalBrokenCount,
+        followed: s.followedRules,
+        judgment: s.judgmentRules,
+        sessions: s.sessionsScanned,
+        days: s.days,
+        who: s.tools.length === 1 && s.tools[0] === "claude-code" ? "Claude" : "the agent",
+        brokenTitles: s.breaks.map((b) => b.ruleTitle),
+    };
+    const outPath = resolve(cwd, opts.out ?? "rulereceipt-card.svg");
+    writeFileSync(outPath, cardSvg(data));
+    console.log(renderCardShare(data, outPath, Boolean(opts.showRules)));
+});
 program
     .command("history")
     .description("Check EVERY session for this project in the last 30 days (this is what runs when you type `rulereceipt` with no arguments). Leads with the rules broken most, each with a count, the last date and one quoted line. Counts only proven breaks; judgment rules stay separate. No session to pick, no API key, nothing uploaded.")
@@ -1096,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.63",
+  "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",