rulereceipt 0.1.39 → 0.1.40

package/README.md

@@ -184,7 +184,7 @@ survives that by saying UNCLEAR. A gate cannot — so you mark it:
 rulereceipt rules --forbid <handle> --literal "git push --force"
 ```
 
-Handles come from `rulereceipt check --show-skipped`. The mark is stored
+Handles come from `rulereceipt rules --handles`. The mark is stored
 against the rule's content hash, and the guard blocks on that literal and no
 other. Three things it deliberately will not do:
 

package/dist/cli.js

@@ -535,6 +535,33 @@ async function runRules(opts) {
         console.log(`your judgment onto words you never read.`);
         return;
     }
+    /**
+     * Every rule with its handle.
+     *
+     * --forbid needs a handle, and before this the only place handles were
+     * printed was `check --show-skipped`, which lists the items the classifier
+     * DISCARDED. A rule that is actually being checked had no handle anywhere,
+     * so the marking feature shipped in 0.1.39 could not be reached for any
+     * rule a user would want to mark. Found by trying to use it.
+     */
+    if (opts.handles) {
+        if (rules.length === 0) {
+            console.log("No CLAUDE.md or AGENTS.md rules found in this project.");
+            return;
+        }
+        console.log(`${rules.length} rule${rules.length === 1 ? "" : "s"} in this project:\n`);
+        for (const r of rules) {
+            const h = ruleFingerprint(r);
+            const marked = overrides.get(h)?.forbids;
+            console.log(`  ${h}  ${r.title.replace(/\s+/g, " ").trim().slice(0, 72)}`);
+            if (marked?.length)
+                console.log(`                blocks on: ${marked.map((f) => `\`${f}\``).join(", ")}`);
+        }
+        console.log(`\nMark which clause of a rule is the prohibition:`);
+        console.log(`  rulereceipt rules --forbid <handle> --literal "<the banned command>"`);
+        console.log(`Only a marked clause can ever refuse a command, and only via \`rulereceipt guard\`.`);
+        return;
+    }
     if (opts.clear) {
         console.log(clearOverride(cwd, opts.clear) ? `Removed the correction for ${opts.clear}.` : `No correction stored for ${opts.clear}.`);
         return;
@@ -651,6 +678,7 @@ program
     .description("correct what the classifier treats as a rule. Handles come from `check --show-skipped`.")
     .option("--include <handle>", "treat this item as a real rule and check it from now on")
     .option("--exclude <handle>", "treat this item as documentation and stop reporting it")
+    .option("--handles", "list every rule with its handle, for use with --forbid")
     .option("--forbid <handle>", "mark which clause of this rule is the prohibition, so the guard may block on it")
     .option("--literal <text>", "the exact banned command, used with --forbid; must appear in the rule")
     .option("--clear <handle>", "remove a stored correction")

package/dist/guard.js

@@ -80,13 +80,22 @@ function structuredBlocks(cwd, event) {
 function ratifiedLiteralBlocks(cwd, command) {
     const overrides = loadOverrides(cwd);
     const blocks = [];
-    for (const c of forbidRules(cwd)) {
-        if (c.kind !== "deterministic")
+    // Read from the RULES, not from the classification. A human mark
+    // supersedes the classifier, including its refusal to classify — and that
+    // refusal is the common case here. "Never use `git push --force`; prefer
+    // `git push --force-with-lease`" goes to judgment via hasMixedPolarity,
+    // for a correct reason: literal matching cannot tell which half owns which
+    // token. A rule naming both the ban and the alternative is the canonical
+    // reason to have someone say which is which, so gating the mark behind the
+    // classifier made the feature unavailable in exactly the case that
+    // motivated it. Shipped that way in 0.1.39 and caught by running it.
+    for (const rule of loadRules(cwd)) {
+        if (overrides.get(ruleFingerprint(rule))?.decision === "notARule")
             continue;
-        for (const literal of ratifiedForbids(overrides, c.rule)) {
+        for (const literal of ratifiedForbids(overrides, rule)) {
             if (!commandRunsLiteral(command, literal))
                 continue;
-            blocks.push({ rule: c.rule, why: `the command about to run does \`${literal}\`, which this rule forbids (marked by you, not inferred)` });
+            blocks.push({ rule, why: `the command about to run does \`${literal}\`, which this rule forbids (marked by you, not inferred)` });
             break;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulereceipt",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "description": "Checks whether a Claude Code session actually followed your CLAUDE.md / AGENTS.md rules, with evidence.",
   "repository": {
     "type": "git",