rulereceipt 0.1.67 → 0.1.68

package/dist/checks/claimEvidence.js

@@ -83,7 +83,9 @@ const ACTION_CLAIMS = [
         // Idioms that borrow "pushed" but aren't a git push. "pushed the fix/code/
         // changes/branch to <remote>" stays a claim; effort/figurative senses do
         // not (finding #6, 2026-09-26).
-        exclude: /\bpushed\s+(?:back|for|through|forward|ahead|past|hard|on|myself|ourselves|yourself|themselves|the\s+(?:boundar|button|envelope|limit|deadline|pace)|to\s+(?:get|finish|complete|ship|meet|hit|make|wrap|move))/i,
+        // "pushed nothing/none" is a statement that NO push happened — the opposite
+        // of a push claim (finding 2026-09-29, false-accusation corpus run).
+        exclude: /\bpushed\s+(?:back|for|through|forward|ahead|past|hard|on|nothing|none|myself|ourselves|yourself|themselves|the\s+(?:boundar|button|envelope|limit|deadline|pace)|to\s+(?:get|finish|complete|ship|meet|hit|make|wrap|move))/i,
         command: /\bgit\s+push\b/i,
     },
     {

package/dist/checks/classify.js

@@ -312,6 +312,28 @@ function isContentToken(literal) {
         return false;
     return (literal.match(/[A-Za-z0-9]/g) ?? []).length >= 3;
 }
+/**
+ * A file/directory/route token, as opposed to a code construct or an import
+ * specifier. It names a PATH, so searching file CONTENT for it (codeContent's
+ * job) matches every import, changelog line, package.json entry or prose that
+ * merely MENTIONS the path — a "found `dist/` written into a file" false
+ * accusation. Found in the false-accusation corpus run 2026-09-29: ~30 distinct
+ * FAIL texts were exactly this (`dist/`, `src/`, `README.md`, `AGENTS.md`,
+ * `./types`, `/status`, …). These belong to fileLifecycle (a path mutation) or,
+ * absent a mutation verb, to the deterministic checker, which reports UNCLEAR
+ * rather than fabricating a FAIL.
+ *
+ * Deliberately NARROW so real import specifiers stay checkable: `lucide-react`
+ * and `@scope/pkg` are NOT file tokens (no leading `./` or `/`, no trailing
+ * `/`, no file extension), so a "never import X" rule keeps working.
+ */
+const FILE_EXTENSION = /\.(json|ya?ml|toml|md|mdx|env|lock|ini|cfg|conf|xml|txt|js|jsx|mjs|cjs|ts|tsx|py|rb|go|rs|sh|sql|css|scss|html)$/i;
+function looksLikeFilePathToken(literal) {
+    return (/\/$/.test(literal) || // trailing slash: a directory ("dist/", "src/")
+        /^(?:\.{1,2}\/|\/)/.test(literal) || // leading ./ ../ or /: a path or route
+        FILE_EXTENSION.test(literal) // a bare filename with a known extension
+    );
+}
 // Catches rules like "add tests for every change" or "every new function
 // needs a test" - no literal backtick token to pattern-match, so without
 // this they'd fall all the way through to judgment (an LLM call) even
@@ -743,7 +765,11 @@ export function classifyRule(rule) {
     // only, so this is an action not a mention. Plain words and shell commands
     // are excluded by isContentToken; protected files already routed above.
     if (polarity === "forbid") {
-        const contentTokens = [...patterns].filter(isContentToken);
+        // A file/dir/route token is a path reference, not code to search for inside
+        // file content — routing it to codeContent produces "found `dist/` written
+        // into a file" on any mention. Excluded here; it falls through to the
+        // deterministic checker (UNCLEAR, never a fabricated FAIL).
+        const contentTokens = [...patterns].filter((p) => isContentToken(p) && !looksLikeFilePathToken(p));
         if (contentTokens.length > 0) {
             return { kind: "codeContent", rule, patterns: contentTokens, polarity, polarityInferred };
         }

package/dist/checks/codeContent.js

@@ -47,8 +47,28 @@ function editedContentFromEvent(event) {
  */
 function containsCall(content, pattern) {
     const leadsWithIdentifier = /^[A-Za-z0-9_$]/.test(pattern);
-    if (!leadsWithIdentifier)
-        return content.includes(pattern);
+    if (!leadsWithIdentifier) {
+        // A CALL like `.forEach(` legitimately follows an object (`arr.forEach()`),
+        // so member access before it is fine — bare containment.
+        if (pattern.endsWith("("))
+            return content.includes(pattern);
+        // A punct-leading NON-call token (a dotfile/extension like `.env`, `.log`)
+        // sitting right after an identifier is a property access or the tail of a
+        // longer token, not the token itself: `.env` inside `process.env` is not
+        // the .env file. Require a non-identifier char (or the start) before it.
+        // Found in the false-accusation corpus run 2026-09-29 — a `.env` rule
+        // FAILed every file using `process.env`.
+        let fromPunct = 0;
+        for (;;) {
+            const at = content.indexOf(pattern, fromPunct);
+            if (at === -1)
+                return false;
+            const before = at === 0 ? "" : content[at - 1];
+            if (!/[A-Za-z0-9_$]/.test(before))
+                return true;
+            fromPunct = at + 1;
+        }
+    }
     let from = 0;
     for (;;) {
         const at = content.indexOf(pattern, from);

package/package.json

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