rulereceipt 0.1.85 → 0.1.87

package/README.md

@@ -538,6 +538,15 @@ rm -rf .rulereceipt/           # the local reports/receipts folder, if you want
 `protect --undo` is only needed if you ran `protect`. Nothing else is
 installed anywhere on your system.
 
+## Team plan
+
+The CLI is free and runs locally, forever. A separate **Team plan** — an
+org-wide, hosted view with trends over time, history, cross-repo dashboards and
+compliance-ready exports — is a genuinely different product from the local
+check. It's in **early access** while we finish setting it up; email
+hello@rulereceipt.dev if you want it early. The local check (and the free
+`rulereceipt team <folder>` snapshot of exports you already have) stays free.
+
 ## Contact
 
 Questions, bugs, or anything else — hello@rulereceipt.dev.

package/dist/cli.js

@@ -32,6 +32,7 @@ import { runGuard } from "./guard.js";
 import { generateReport, generateMarkdownReport, generateJsonReport, computeTranscriptHash } from "./report/generateReport.js";
 import { buildTeamExport, parseExport, mergeTeamExports, renderTeamHtml } from "./teamExport.js";
 import { applyVisibility } from "./visibility.js";
+import { teamPlanNote, activateNote } from "./teamPlan.js";
 import { gateOffer, hookIsInstalled } from "./report/gateOffer.js";
 import { generateHtmlReport } from "./report/generateHtmlReport.js";
 import { verifySessionHash } from "./verifyHash.js";
@@ -1411,6 +1412,13 @@ program
     const outPath = opts.out ? resolve(process.cwd(), opts.out) : join(dir, "team-report.html");
     writeFileSync(outPath, renderTeamHtml(merged));
     console.log(`team preview: merged ${merged.exportsRead} export(s) from ${merged.devs.length} dev(s), ${merged.totalBroken} break(s) — wrote ${outPath}`);
+    console.log(`\n${teamPlanNote()}`);
+});
+program
+    .command("activate <key>")
+    .description("activate a Team plan seat. (Early access while the paid tier is being set up.)")
+    .action((key) => {
+    console.log(activateNote(key));
 });
 // Bare `rulereceipt` (no subcommand, no flags) runs history mode — the first-run
 // "wait, what?" screen across the last 30 days of sessions. Anything with a

package/dist/guard.d.ts

@@ -74,5 +74,16 @@ export interface GuardDecision {
 export declare function guardDecision(cwd: string, toolName: string, toolInput: {
     command?: unknown;
 } & Record<string, unknown>, events?: TranscriptEvent[], permissionMode?: string): GuardDecision;
+/** One line for the guard receipt log — every block (or would-block) is recorded. */
+export declare function guardReceiptLine(decision: GuardDecision, command: string, shadow: boolean): {
+    ts: string;
+    mode: "shadow" | "enforce";
+    action: "deny" | "would-deny" | "ask" | "would-ask";
+    command: string;
+    rules: {
+        id: string;
+        title: string;
+    }[];
+};
 export declare function runGuard(): Promise<void>;
 export {};

package/dist/guard.js

@@ -25,9 +25,9 @@ function gitCurrentBranch(cwd) {
         return undefined;
     }
 }
-import { readFileSync } from "node:fs";
+import { readFileSync, appendFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
 /**
  * Modes where Claude Code shows NO permission prompt, so a hook's "ask" is
  * ignored and the call just runs (Claude Code #89561; "ask" also drops bypass
@@ -301,6 +301,38 @@ export function guardDecision(cwd, toolName, toolInput, events = [], permissionM
     }
     return allow;
 }
+/**
+ * Shadow mode (live-blocking rollout, vs Failproof): set RULERECEIPT_GUARD_SHADOW=1
+ * and the guard never blocks — it LOGS what it WOULD have blocked and allows the
+ * call. The honest way to turn on enforcement: run shadow first, read the log,
+ * then drop the flag. Enforcement is the default (no env needed).
+ */
+function guardShadowEnabled() {
+    const v = process.env.RULERECEIPT_GUARD_SHADOW;
+    return v === "1" || v === "true" || v === "yes";
+}
+/** One line for the guard receipt log — every block (or would-block) is recorded. */
+export function guardReceiptLine(decision, command, shadow) {
+    const base = decision.deny ? "deny" : "ask";
+    return {
+        ts: new Date().toISOString(),
+        mode: shadow ? "shadow" : "enforce",
+        action: (shadow ? `would-${base}` : base),
+        command: command.replace(/\s+/g, " ").trim().slice(0, 120),
+        rules: decision.blocks.map((b) => ({ id: b.rule.id, title: b.rule.title })),
+    };
+}
+/** Append a receipt line to .rulereceipt/guard-log.jsonl. Fail-open: never breaks the guard. */
+function writeGuardReceipt(cwd, line) {
+    try {
+        const p = join(cwd, ".rulereceipt", "guard-log.jsonl");
+        mkdirSync(dirname(p), { recursive: true });
+        appendFileSync(p, `${JSON.stringify(line)}\n`);
+    }
+    catch {
+        /* logging must never stop (or crash) the guard */
+    }
+}
 export async function runGuard() {
     const allow = () => {
         process.stdout.write(JSON.stringify({}));
@@ -321,6 +353,15 @@ export async function runGuard() {
             }
         }
         const decision = guardDecision(cwd, tool, toolInput, events, input.permission_mode);
+        const shadow = guardShadowEnabled();
+        const commandStr = typeof toolInput.command === "string" ? toolInput.command : tool;
+        // Every block (or would-block) writes a receipt line — the audit trail of
+        // what the guard stopped, in both shadow and enforce mode.
+        if (decision.deny || decision.ask)
+            writeGuardReceipt(cwd, guardReceiptLine(decision, commandStr, shadow));
+        // Shadow mode: log above, then ALLOW — never block, never ask.
+        if (shadow)
+            return allow();
         if (!decision.deny && decision.ask) {
             // "ask" is not a refusal: no exit 2. Claude Code shows its permission
             // prompt with this reason; the user's click decides.

package/dist/teamPlan.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Team plan — the ONE place the checkout link and its feature flag live, read by
+ * the CLI (the landing pages mirror these exact values; keep them in sync).
+ *
+ * OPEN-CORE: this file holds only a LINK, a flag, and copy — never any paid-tier
+ * LOGIC. Real licence/key validation and the hosted team service live in the
+ * separate PRIVATE repo. `activate` here does not validate or unlock anything;
+ * while the flag is off it only points at early access.
+ *
+ * TEAM_CHECKOUT_LIVE stays `false` until Polar setup is done and a test purchase
+ * works. While false, every surface shows "early access, contact …" and no
+ * checkout/activate link is shown. Flip the flag AND fill `checkoutUrl`/
+ * `portalUrl` together (and mirror them on the landing pages), then rebuild.
+ */
+export declare const TEAM_PLAN: {
+    readonly live: false;
+    /** Polar checkout URL — filled in when going live. Empty while not live. */
+    readonly checkoutUrl: "";
+    /** Polar customer portal (manage subscription) — shown on /thanks when live. */
+    readonly portalUrl: "";
+    readonly contact: "hello@rulereceipt.dev";
+    readonly trialDays: 14;
+};
+/** The one-line Team-plan note for CLI output, flag-aware. */
+export declare function teamPlanNote(): string;
+/** What `rulereceipt activate <key>` prints. No validation here — that is the private tier. */
+export declare function activateNote(key: string): string;

package/dist/teamPlan.js

@@ -0,0 +1,42 @@
+/**
+ * Team plan — the ONE place the checkout link and its feature flag live, read by
+ * the CLI (the landing pages mirror these exact values; keep them in sync).
+ *
+ * OPEN-CORE: this file holds only a LINK, a flag, and copy — never any paid-tier
+ * LOGIC. Real licence/key validation and the hosted team service live in the
+ * separate PRIVATE repo. `activate` here does not validate or unlock anything;
+ * while the flag is off it only points at early access.
+ *
+ * TEAM_CHECKOUT_LIVE stays `false` until Polar setup is done and a test purchase
+ * works. While false, every surface shows "early access, contact …" and no
+ * checkout/activate link is shown. Flip the flag AND fill `checkoutUrl`/
+ * `portalUrl` together (and mirror them on the landing pages), then rebuild.
+ */
+export const TEAM_PLAN = {
+    live: false,
+    /** Polar checkout URL — filled in when going live. Empty while not live. */
+    checkoutUrl: "",
+    /** Polar customer portal (manage subscription) — shown on /thanks when live. */
+    portalUrl: "",
+    contact: "hello@rulereceipt.dev",
+    trialDays: 14,
+};
+/** The one-line Team-plan note for CLI output, flag-aware. */
+export function teamPlanNote() {
+    if (TEAM_PLAN.live && TEAM_PLAN.checkoutUrl) {
+        return (`Team plan (trends over time, history, cross-repo dashboards): ` +
+            `start a ${TEAM_PLAN.trialDays}-day free trial — ${TEAM_PLAN.checkoutUrl}\n` +
+            `Already bought a seat? Run \`rulereceipt activate <key>\`.`);
+    }
+    return `Team plan (trends over time, history, cross-repo dashboards): early access — contact ${TEAM_PLAN.contact}.`;
+}
+/** What `rulereceipt activate <key>` prints. No validation here — that is the private tier. */
+export function activateNote(key) {
+    const masked = key.length > 6 ? `${key.slice(0, 3)}…${key.slice(-2)}` : "(key)";
+    if (!TEAM_PLAN.live) {
+        return `Team plan is in early access — nothing to activate yet. Contact ${TEAM_PLAN.contact} and we'll set you up.`;
+    }
+    return (`Thanks for subscribing. Key ${masked} noted.\n` +
+        `Activation and the hosted team features are handled by the Team service (see rulereceipt.dev/thanks).\n` +
+        `Manage your subscription: ${TEAM_PLAN.portalUrl || TEAM_PLAN.contact}`);
+}

package/package.json

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