rulereceipt 0.1.87 → 0.1.89

package/dist/adapters/codex.js

@@ -1,6 +1,40 @@
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import * as zlib from "node:zlib";
+/**
+ * Codex stores rollouts as plain `rollout-*.jsonl` and, once a session is
+ * compacted/paginated, Zstandard-compressed `rollout-*.jsonl.zst`. Reading the
+ * compressed form needs `node:zlib`'s zstd support, added in Node 22.15 / 23.8.
+ * On an older Node it is simply absent — we skip those files with one note
+ * rather than crash. (The package's floor is Node 20.)
+ */
+const zstdDecompressSync = zlib.zstdDecompressSync;
+let warnedNoZstd = false;
+/**
+ * Read a rollout file as text, decompressing a `.jsonl.zst` with zstd. Returns
+ * null when the file can't be read — unreadable on disk, or compressed on a Node
+ * without zstd (noted once). Callers treat null as "no events / no cwd", never a
+ * crash.
+ */
+function readRolloutText(filePath) {
+    try {
+        if (filePath.endsWith(".zst")) {
+            if (!zstdDecompressSync) {
+                if (!warnedNoZstd) {
+                    warnedNoZstd = true;
+                    process.stderr.write("rulereceipt: compressed Codex rollouts (.jsonl.zst) need Node >= 22.15 for zstd; skipping them. Upgrade Node to include them.\n");
+                }
+                return null;
+            }
+            return zstdDecompressSync(readFileSync(filePath)).toString("utf-8");
+        }
+        return readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * OpenAI Codex CLI session adapter.
  *
@@ -193,13 +227,9 @@ export function parseCodexLine(line) {
     return []; // reasoning, unknown payload types: ignored, not guessed at
 }
 export function parseCodexTranscript(filePath) {
-    let raw;
-    try {
-        raw = readFileSync(filePath, "utf-8");
-    }
-    catch {
+    const raw = readRolloutText(filePath);
+    if (raw === null)
         return [];
-    }
     const events = [];
     for (const line of raw.split("\n")) {
         if (!line.trim())
@@ -210,13 +240,9 @@ export function parseCodexTranscript(filePath) {
 }
 /** The cwd a rollout file was recorded in, from its first `session_meta` line. */
 function sessionCwd(filePath) {
-    let raw;
-    try {
-        raw = readFileSync(filePath, "utf-8");
-    }
-    catch {
+    const raw = readRolloutText(filePath);
+    if (raw === null)
         return null;
-    }
     const firstLine = raw.split("\n", 1)[0];
     if (!firstLine)
         return null;
@@ -249,7 +275,7 @@ function collectRolloutFiles(dir, out) {
         const full = join(dir, entry.name);
         if (entry.isDirectory())
             collectRolloutFiles(full, out);
-        else if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl"))
+        else if (entry.isFile() && entry.name.startsWith("rollout-") && (entry.name.endsWith(".jsonl") || entry.name.endsWith(".jsonl.zst")))
             out.push(full);
     }
 }

package/dist/adapters/index.d.ts

@@ -67,7 +67,7 @@ export interface LatestSession {
 /**
  * The single most recently modified session across ALL supported tools for
  * this cwd — the same "newest wins" rule the Claude reader already uses across
- * `.claude` vs `.claude-office`, now extended across tools. Returns null only
+ * every configured Claude home, now extended across tools. Returns null only
  * when no supported tool has a session for this project (the caller then asks
  * or reports "no session found").
  */

package/dist/adapters/index.js

@@ -76,7 +76,7 @@ export const UNSUPPORTED_TOOLS = [
 /**
  * The single most recently modified session across ALL supported tools for
  * this cwd — the same "newest wins" rule the Claude reader already uses across
- * `.claude` vs `.claude-office`, now extended across tools. Returns null only
+ * every configured Claude home, now extended across tools. Returns null only
  * when no supported tool has a session for this project (the caller then asks
  * or reports "no session found").
  */

package/dist/audit.js

@@ -302,13 +302,14 @@ export function renderProjectAudit(pa, md = false) {
     }
     else {
         for (const g of loaded) {
-            out.push(`  loaded    ${g.format} · ${g.ruleCount} rule${g.ruleCount === 1 ? "" : "s"}  (${g.path})`);
+            // Memory and subfolder rows now come through the load graph itself, so
+            // they are listed here like any other source (no separate memory line).
+            const scoped = g.note ? ` · ${g.note}` : "";
+            out.push(`  loaded    ${g.format} · ${g.ruleCount} rule${g.ruleCount === 1 ? "" : "s"}${scoped}  (${g.path})`);
         }
         for (const g of shadowed) {
             out.push(`  ignored   ${g.format} · ${g.note}  (${g.path})`);
         }
-        if (pa.memoryRules > 0)
-            out.push(`  loaded    Claude memory · ${pa.memoryRules} rule${pa.memoryRules === 1 ? "" : "s"}`);
     }
     out.push("");
     if (pa.checkable + pa.judgment > 0) {

package/dist/checks/claimEvidence.js

@@ -124,7 +124,13 @@ const ACTION_CLAIMS = [
         // having read a source (finding #7, 2026-09-26). "PAGES READ: <n>" and
         // "STATUS: READ IN FULL" are the real provenance forms and still count.
         claim: /\b(?:i|we)(?:'ve|’ve| have| had)?\s+(?:\w+ly\s+|just\s+|already\s+|then\s+|also\s+|now\s+)*read\b|^\s*pages?\s+read\s*:\s*(?:[\d\s,-]+|read\s+in\s+full)|^\s*status\s*:\s*read\s+in\s+full|\bread\s+in\s+full\b|\bconfirmed\s+at\s+source\b/im,
-        exclude: /\b(?:will|going\s+to|need\s+to|should|next|plan\s+to|about\s+to|let\s+me|i'?ll|we'?ll)\s+(?:\w+\s+){0,3}read\b/i,
+        // The future tense makes a read a plan, not a claim. Beyond the explicit
+        // modals, a near-future TIME expression ("in a couple minutes", "shortly")
+        // is the same signal written in present tense: "download it and I read it
+        // in a couple minutes and tell you" is a plan. Found dogfooding 2026-10-03
+        // — it fired on a casual planning message and, via the shared fabricated
+        // state, FAILed three unrelated rules at once (claimEvidenceFutureRead.test).
+        exclude: /\b(?:will|going\s+to|need\s+to|should|next|plan\s+to|about\s+to|let\s+me|i'?ll|we'?ll)\s+(?:\w+\s+){0,3}read\b|\bin\s+(?:a\s+)?(?:couple|few|several)?\s*(?:of\s+)?(?:minutes?|mins?|moments?|seconds?|secs?|hours?|a\s+(?:minute|moment|bit|sec|second|while))\b|\b(?:shortly|momentarily|in\s+a\s+bit)\b/i,
         command: /\b(?:cat|head|tail|less|more|bat|nl|strings|pdftotext|xxd|od)\b/i,
     },
 ];

package/dist/cli.js

@@ -194,13 +194,11 @@ async function runCheck(opts) {
         return;
     }
     // --transcript is a manual escape hatch for any layout auto-detection
-    // doesn't cover (a real gap found 2026-08-30: a hosted/enterprise Claude
-    // Code variant used ~/.claude-office/ instead of ~/.claude/ — the
-    // multi-root scan in transcriptParser.ts now catches that automatically,
-    // but this flag stays as a fallback for whatever variant shows up next).
-    // Auto-detect the session across every supported tool (Claude Code, Codex),
-    // newest-modified wins — the same rule the Claude reader already applies
-    // across .claude vs .claude-office, now extended across tools. A
+    // doesn't cover (e.g. a hosted/enterprise Claude Code variant writing to a
+    // non-standard home; configure it via RULERECEIPT_CLAUDE_HOMES, or point this
+    // flag straight at the file). Auto-detect the session across every supported
+    // tool (Claude Code, Codex), newest-modified wins — the same rule the Claude
+    // reader applies across every configured home, now extended across tools. A
     // Claude-only machine picks exactly the file and events it always did.
     const latestSession = transcriptOverride ? null : findLatestSession(cwd);
     const sessionFilePath = transcriptOverride ?? latestSession?.file ?? null;

package/dist/guard.js

@@ -8,6 +8,7 @@ import { loadOverrides, ruleFingerprint, ratifiedForbids } from "./overrides.js"
 import { commandRunsLiteral } from "./checks/proposedAction.js";
 import { approvalOccurrences, allowListed, approvalCommandShort, approvalScopedBranch } from "./checks/approvalGate.js";
 import { readTranscriptFromFile } from "./parsers/transcriptParser.js";
+import { touchedPaths, ruleWasLoaded } from "./checks/pathScope.js";
 import { execFileSync } from "node:child_process";
 /**
  * The current git branch in `cwd`, or undefined if it can't be determined —
@@ -92,8 +93,28 @@ function forbidRules(cwd) {
  * is why the guard cannot drift from the report: same checkers, same
  * verdicts, different tense.
  */
+/**
+ * A path-scoped rule (a subfolder CLAUDE.md, or `paths:`/`globs:` frontmatter)
+ * only governs its own subtree. The guard must honour that: enforcing it on an
+ * action OUTSIDE the subtree is a false-block — the live-blocking equivalent of
+ * a false accusation. Found 2026-10-03: subfolder-rule discovery (0.1.88) made
+ * loadRules return those scoped rules, and the guard applied every forbid
+ * globally, so a demo rule scoped to one subtree blocked an edit elsewhere.
+ *
+ * Direction of error, deliberately toward NOT blocking: an unscoped rule always
+ * applies; a scoped rule applies only when the proposed action's touched path is
+ * inside the scope. A Bash command exposes no file path to match, so a scoped
+ * rule never fires on one here — under-enforcing a subtree is safe, a false-block
+ * is not. (`check` already path-scopes via this same machinery.)
+ */
+function inScope(rule, touched) {
+    if (!rule.paths || rule.paths.length === 0)
+        return true;
+    return ruleWasLoaded(rule.paths, touched);
+}
 function structuredBlocks(cwd, event) {
-    const cls = forbidRules(cwd);
+    const touched = touchedPaths([event]);
+    const cls = forbidRules(cwd).filter((c) => inScope(c.rule, touched));
     const of = (k) => cls.filter((c) => c.kind === k);
     const results = [
         ...runCodeContentChecks(of("codeContent"), [event]),
@@ -218,7 +239,11 @@ function reason(blocks) {
  * decide — by the current permission mode — whether to ask or to deny.
  */
 function unapprovedGate(cwd, command, events) {
-    const gates = classifyRules(loadRules(cwd)).filter((c) => c.kind === "approvalGate");
+    // A Bash command exposes no file path, so a path-scoped gate (a subfolder rule)
+    // can't be confirmed in-scope and is not enforced here — same no-false-block
+    // reasoning as structuredBlocks' inScope.
+    const gates = classifyRules(loadRules(cwd)).filter((c) => c.kind === "approvalGate")
+        .filter((c) => inScope(c.rule, touchedPaths([{ role: "assistant", kind: "tool_use", toolName: "Bash", input: { command }, timestamp: "" }])));
     for (const { rule, actions } of gates) {
         const proposed = { role: "assistant", kind: "tool_use", toolName: "Bash", input: { command }, timestamp: "", permissionMode: "dontAsk" };
         const occ = approvalOccurrences([...events, proposed], actions, { scopedBranch: approvalScopedBranch(rule), currentBranch: gitCurrentBranch(cwd) });

package/dist/parsers/readMemory.d.ts

@@ -1,2 +1,13 @@
 import type { Rule } from "../types.js";
+/**
+ * The memory source for the load graph: the first existing non-office memory
+ * dir for this project, and how many rules load from memory in total. Returns
+ * null when memory contributes no rules. Lets `describeRuleSources` list memory
+ * so the load graph matches what `loadRules` actually checks (memory was
+ * omitted before — a reporting gap found 2026-10-03, not a checking gap).
+ */
+export declare function memoryGraphEntry(cwd: string): {
+    path: string;
+    ruleCount: number;
+} | null;
 export declare function loadMemoryRules(cwd: string): Rule[];

package/dist/parsers/readMemory.js

@@ -1,7 +1,6 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
 import { join, basename } from "node:path";
-import { findClaudeHomeDirNames } from "./transcriptParser.js";
+import { claudeHomes } from "./transcriptParser.js";
 /**
  * Claude Code's memory as a rule source.
  *
@@ -49,14 +48,36 @@ function parseMemoryFile(raw) {
     const description = front.match(/^\s*description:\s*(.+)$/im)?.[1]?.trim() ?? null;
     return { type, name, description, body };
 }
+/**
+ * The memory source for the load graph: the first existing non-office memory
+ * dir for this project, and how many rules load from memory in total. Returns
+ * null when memory contributes no rules. Lets `describeRuleSources` list memory
+ * so the load graph matches what `loadRules` actually checks (memory was
+ * omitted before — a reporting gap found 2026-10-03, not a checking gap).
+ */
+export function memoryGraphEntry(cwd) {
+    const ruleCount = loadMemoryRules(cwd).length;
+    if (ruleCount === 0)
+        return null;
+    const encoded = cwd.replace(/\//g, "-");
+    for (const base of claudeHomes()) {
+        const memoryDir = join(base, "projects", encoded, "memory");
+        try {
+            if (statSync(memoryDir).isDirectory())
+                return { path: memoryDir, ruleCount };
+        }
+        catch {
+            /* no memory dir under this home: try the next */
+        }
+    }
+    return null;
+}
 export function loadMemoryRules(cwd) {
     const rules = [];
     const seenIds = new Set();
     const encoded = cwd.replace(/\//g, "-");
-    for (const dirName of findClaudeHomeDirNames()) {
-        if (/office/i.test(dirName))
-            continue; // never office (project rule)
-        const memoryDir = join(homedir(), dirName, "projects", encoded, "memory");
+    for (const base of claudeHomes()) {
+        const memoryDir = join(base, "projects", encoded, "memory");
         let files;
         try {
             if (!statSync(memoryDir).isDirectory())

package/dist/parsers/transcriptParser.d.ts

@@ -1,10 +1,20 @@
 import type { TranscriptEvent } from "../types.js";
 /**
- * Also used for the global CLAUDE.md lookup (src/cli.ts) — the same
- * ".claude vs .claude-office" gap applies there too: a hosted/enterprise
- * variant could keep its own global rules file under its own home dir.
+ * Absolute paths of every Claude-Code home to search.
+ *
+ * The standard home `~/.claude`, plus `CLAUDE_CONFIG_DIR` (Claude Code's own
+ * override), plus `RULERECEIPT_CLAUDE_HOMES` for anyone running a non-standard
+ * layout — both comma-separated, absolute or relative-to-home.
+ *
+ * It used to glob every `~/.claude*` directory, which swept in whatever extra
+ * homes happened to exist on the machine — including a separate or employer home
+ * the user never meant the tool to read. That also baked one machine's folder
+ * names into the shipped tool. Discovery is now opt-in:
+ * nothing beyond `~/.claude` is read unless the user names it. A hosted or
+ * enterprise variant on a different home is supported by setting
+ * `RULERECEIPT_CLAUDE_HOMES` (or `CLAUDE_CONFIG_DIR`), rather than by guessing.
  */
-export declare function findClaudeHomeDirNames(): string[];
+export declare function claudeHomes(): string[];
 /**
  * Every session file that belongs to this project, newest first.
  *

package/dist/parsers/transcriptParser.js

@@ -1,6 +1,6 @@
 import { readFileSync, readdirSync, statSync, realpathSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, dirname, basename, sep } from "node:path";
+import { join, dirname, basename, sep, isAbsolute } from "node:path";
 import { parseTranscriptText } from "./transcriptLine.js";
 /**
  * Claude Code stores each session as a JSONL file at:
@@ -17,20 +17,13 @@ import { parseTranscriptText } from "./transcriptLine.js";
  * - some assistant entries are API error stubs (isApiErrorMessage: true)
  *   with no real content — skip these.
  *
- * Real gap found 2026-08-30: a hosted/enterprise Claude Code variant on
- * one real machine writes to ~/.claude-office/projects/... instead of
- * ~/.claude/projects/... — same directory-encoding convention, same file
- * format, different root. `rulereceipt check` reported "no session found"
- * on 4 real projects that had extensive real work done, purely because it
- * only ever looked in one root.
- *
- * Hardcoding ".claude-office" specifically would only fix THIS machine's
- * naming — a different org's hosted variant could use any name. Instead,
- * every directory directly under the home dir that starts with ".claude"
- * and has a matching projects/<encoded-cwd> tree is treated as a
- * candidate, and the overall latest file across all of them wins. This
- * generalizes to variants never seen on this machine, at the cost of one
- * extra readdir() of the home directory per check — negligible.
+ * A hosted/enterprise Claude Code variant can write its sessions under a
+ * non-standard home instead of ~/.claude/projects/... — same directory-encoding
+ * convention, same file format, different root. Those homes are searched when
+ * the user names them (CLAUDE_CONFIG_DIR or RULERECEIPT_CLAUDE_HOMES; see
+ * claudeHomes), and the overall latest file across every configured home wins.
+ * Discovery is opt-in rather than guessed from whatever dirs exist on the
+ * machine (see claudeHomes for why).
  */
 /**
  * Claude Code names the per-project directory by mangling the cwd, but the exact
@@ -93,19 +86,36 @@ function sessionCwdOf(sessionFile) {
 function looksLikeProjectRoot(cwd) {
     return [".git", "CLAUDE.md", "AGENTS.md", "GEMINI.md", ".claude", ".cursor", ".github/copilot-instructions.md"].some((marker) => existsSync(join(cwd, marker)));
 }
-/** Absolute paths of every Claude-Code-style home to search, including CLAUDE_CONFIG_DIR. */
-function claudeHomeDirs() {
-    const dirs = new Set();
-    for (const name of findClaudeHomeDirNames())
-        dirs.add(join(homedir(), name));
-    const cfg = process.env.CLAUDE_CONFIG_DIR;
-    if (cfg)
-        for (const part of cfg.split(",")) {
+/**
+ * Absolute paths of every Claude-Code home to search.
+ *
+ * The standard home `~/.claude`, plus `CLAUDE_CONFIG_DIR` (Claude Code's own
+ * override), plus `RULERECEIPT_CLAUDE_HOMES` for anyone running a non-standard
+ * layout — both comma-separated, absolute or relative-to-home.
+ *
+ * It used to glob every `~/.claude*` directory, which swept in whatever extra
+ * homes happened to exist on the machine — including a separate or employer home
+ * the user never meant the tool to read. That also baked one machine's folder
+ * names into the shipped tool. Discovery is now opt-in:
+ * nothing beyond `~/.claude` is read unless the user names it. A hosted or
+ * enterprise variant on a different home is supported by setting
+ * `RULERECEIPT_CLAUDE_HOMES` (or `CLAUDE_CONFIG_DIR`), rather than by guessing.
+ */
+export function claudeHomes() {
+    const out = new Set();
+    out.add(join(homedir(), ".claude"));
+    const add = (list) => {
+        if (!list)
+            return;
+        for (const part of list.split(",")) {
             const p = part.trim();
             if (p)
-                dirs.add(p);
+                out.add(isAbsolute(p) ? p : join(homedir(), p));
         }
-    return [...dirs];
+    };
+    add(process.env.CLAUDE_CONFIG_DIR);
+    add(process.env.RULERECEIPT_CLAUDE_HOMES);
+    return [...out];
 }
 function listSessionFiles(projectDir) {
     let entries;
@@ -127,21 +137,6 @@ function listSessionFiles(projectDir) {
         }
     });
 }
-/**
- * Also used for the global CLAUDE.md lookup (src/cli.ts) — the same
- * ".claude vs .claude-office" gap applies there too: a hosted/enterprise
- * variant could keep its own global rules file under its own home dir.
- */
-export function findClaudeHomeDirNames() {
-    try {
-        return readdirSync(homedir(), { withFileTypes: true })
-            .filter((entry) => entry.isDirectory() && entry.name.startsWith(".claude"))
-            .map((entry) => entry.name);
-    }
-    catch {
-        return [];
-    }
-}
 /**
  * Every session file that belongs to this project, newest first.
  *
@@ -158,7 +153,7 @@ export function listAllSessionFiles(cwd) {
     const allowDescendants = looksLikeProjectRoot(cwd);
     const files = [];
     const seen = new Set();
-    for (const home of claudeHomeDirs()) {
+    for (const home of claudeHomes()) {
         const projectsDir = join(home, "projects");
         let folders;
         try {

package/dist/rules.d.ts

@@ -21,11 +21,11 @@ export interface RuleSource {
     note?: string;
 }
 /**
- * Global rules come from every .claude*-prefixed home dir found, not just
- * ~/.claude — a hosted/enterprise Claude Code variant can keep its own
- * global CLAUDE.md under its own home dir (e.g. ~/.claude-office/CLAUDE.md).
- * Real gap found 2026-08-30, same root cause as the transcript-lookup fix
- * in transcriptParser.ts: hardcoding one home-dir name misses any variant.
+ * Global rules come from every configured Claude home (see claudeHomes): the
+ * standard ~/.claude, plus any the user names via CLAUDE_CONFIG_DIR or
+ * RULERECEIPT_CLAUDE_HOMES — so a hosted/enterprise variant with its own global
+ * CLAUDE.md is supported when the user points at it, rather than by scanning
+ * whatever ~/.claude* dirs happen to exist on the machine.
  *
  * Also reads ~/.claude/rules/*.md, the documented location for personal
  * rules that apply across every project.

package/dist/rules.js

@@ -1,9 +1,9 @@
 import { homedir } from "node:os";
-import { dirname, join, parse, resolve } from "node:path";
+import { dirname, join, parse, relative, resolve } from "node:path";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { parseClaudeMd } from "./parsers/readClaudeMd.js";
-import { findClaudeHomeDirNames } from "./parsers/transcriptParser.js";
-import { loadMemoryRules } from "./parsers/readMemory.js";
+import { claudeHomes } from "./parsers/transcriptParser.js";
+import { loadMemoryRules, memoryGraphEntry } from "./parsers/readMemory.js";
 import { resolveImports } from "./parsers/imports.js";
 /**
  * Every place Claude Code actually reads a rule from, at one directory
@@ -236,11 +236,98 @@ function findProjectRuleFiles(cwd) {
     return projectLevels(cwd).flatMap((dir) => ruleFilesAtLevel(dir));
 }
 /**
- * Global rules come from every .claude*-prefixed home dir found, not just
- * ~/.claude — a hosted/enterprise Claude Code variant can keep its own
- * global CLAUDE.md under its own home dir (e.g. ~/.claude-office/CLAUDE.md).
- * Real gap found 2026-08-30, same root cause as the transcript-lookup fix
- * in transcriptParser.ts: hardcoding one home-dir name misses any variant.
+ * Directories we never descend into when looking for subfolder rules files:
+ * build output, dependencies, VCS internals, RuleReceipt's own state.
+ */
+const SKIP_DESCEND = new Set([
+    "node_modules", ".git", "dist", "build", ".next", "out", "coverage",
+    ".rulereceipt", ".vercel", ".turbo", "vendor", ".cache", "tmp", ".venv",
+    "__pycache__", "target",
+]);
+// Bounded so scanning a large workspace root can never run away.
+const MAX_DESCEND_DEPTH = 8;
+const MAX_DESCEND_DIRS = 3000;
+/**
+ * Every directory strictly BELOW cwd, bounded. The up-walk (`projectLevels`)
+ * covers cwd and its ancestors; this covers its descendants.
+ *
+ * Why descend at all: Claude Code loads a subfolder CLAUDE.md/AGENTS.md on
+ * demand the moment the session touches a file in that subtree (surfaced in the
+ * transcript as a `nested_memory` attachment). The up-only walk never saw
+ * these, so running `check` from a parent dir silently missed every subfolder
+ * rules file — proven 2026-10-03 against real `nested_memory` ground truth
+ * (e.g. `costrr/CLAUDE.md`, `Daily _crypto/CLAUDE.md` loaded while cwd was the
+ * parent workspace). Nested git repos are NOT a stop condition here: Claude's
+ * nested_memory loads a nested-repo CLAUDE.md too, so we must find it.
+ */
+function descendantLevels(cwd) {
+    const out = [];
+    // Breadth-first on purpose: a shallow subfolder rules file is the common case
+    // and the one most likely to have been loaded, so when the dir budget runs
+    // out on a large workspace root it is the DEEP dirs that are dropped, never
+    // the shallow siblings. (A depth-first walk with the same budget could dive
+    // into one big subtree and starve a sibling's depth-1 CLAUDE.md — the bug this
+    // replaces, caught 2026-10-03 when costrr/ and rulereceipt/ were missed from a
+    // workspace root.)
+    let queue = [{ dir: cwd, depth: 0 }];
+    let budget = MAX_DESCEND_DIRS;
+    while (queue.length > 0 && budget > 0) {
+        const next = [];
+        for (const { dir, depth } of queue) {
+            if (budget <= 0)
+                break;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const e of entries) {
+                if (budget <= 0)
+                    break;
+                if (!e.isDirectory())
+                    continue;
+                if (SKIP_DESCEND.has(e.name) || e.name.startsWith("."))
+                    continue; // dotdirs hold tooling, not project subtrees
+                const full = join(dir, e.name);
+                budget--;
+                out.push(full);
+                if (depth + 1 < MAX_DESCEND_DEPTH)
+                    next.push({ dir: full, depth: depth + 1 });
+            }
+        }
+        queue = next;
+    }
+    return out;
+}
+/** The glob that scopes a subfolder rules file to its own subtree, relative to cwd. */
+function subtreeGlob(cwd, dir) {
+    const rel = relative(cwd, dir).replace(/\\/g, "/");
+    return `${rel}/**`;
+}
+/**
+ * Subfolder rules files below cwd, each paired with the subtree glob that
+ * scopes it. A subfolder rule is only applied to a session that actually
+ * touched its subtree (the same path-scope machinery as `paths:` frontmatter),
+ * so discovering them can never manufacture a false accusation against a
+ * session that never worked there.
+ */
+function scopedRuleFilesBelow(cwd) {
+    const out = [];
+    for (const dir of descendantLevels(cwd)) {
+        const glob = subtreeGlob(cwd, dir);
+        for (const path of ruleFilesAtLevel(dir))
+            out.push({ path, scopeGlob: glob });
+    }
+    return out;
+}
+/**
+ * Global rules come from every configured Claude home (see claudeHomes): the
+ * standard ~/.claude, plus any the user names via CLAUDE_CONFIG_DIR or
+ * RULERECEIPT_CLAUDE_HOMES — so a hosted/enterprise variant with its own global
+ * CLAUDE.md is supported when the user points at it, rather than by scanning
+ * whatever ~/.claude* dirs happen to exist on the machine.
  *
  * Also reads ~/.claude/rules/*.md, the documented location for personal
  * rules that apply across every project.
@@ -258,21 +345,30 @@ export function loadRules(cwd) {
     // both ways keeps its "global" label. Without this, running the check from
     // inside the home directory reported every global rule twice.
     const seen = new Set();
-    const read = (path, source) => {
+    const read = (path, source, scopeGlob) => {
         const key = resolve(path);
         if (seen.has(key))
             return;
         seen.add(key);
-        rules.push(...parseClaudeMd(path, source));
+        let parsed = parseClaudeMd(path, source);
+        // A subfolder rules file is loaded by the agent only when the session works
+        // in its subtree, so it is scoped to that subtree unless the file's own
+        // frontmatter already carries a (narrower) `paths:`.
+        if (scopeGlob) {
+            parsed = parsed.map((r) => (r.paths && r.paths.length > 0 ? r : { ...r, paths: [scopeGlob] }));
+        }
+        rules.push(...parsed);
     };
-    for (const dirName of findClaudeHomeDirNames()) {
-        const base = join(homedir(), dirName);
+    for (const base of claudeHomes()) {
         read(join(base, "CLAUDE.md"), "global");
         for (const file of markdownFilesIn(join(base, "rules")))
             read(file, "global");
     }
     for (const path of findProjectRuleFiles(cwd))
         read(path, "project");
+    // Subfolder rules files (below cwd), each scoped to its own subtree.
+    for (const { path, scopeGlob } of scopedRuleFilesBelow(cwd))
+        read(path, "project", scopeGlob);
     // Claude Code memory (feedback/project memories) as a rule source, so a
     // standing correction the user moved into memory is still checked and the
     // tool does not go stale against it. Non-office homes only; ids are
@@ -310,8 +406,7 @@ export function describeRuleSources(cwd) {
     };
     // Globals first, so a file reachable both ways keeps its "global" label —
     // mirrors loadRules' dedup order exactly.
-    for (const dirName of findClaudeHomeDirNames()) {
-        const base = join(homedir(), dirName);
+    for (const base of claudeHomes()) {
         if (existsSync(join(base, "CLAUDE.md")))
             add({ path: join(base, "CLAUDE.md"), status: "loaded", format: "Claude (global CLAUDE.md)" }, "global");
         for (const file of markdownFilesIn(join(base, "rules")))
@@ -321,5 +416,27 @@ export function describeRuleSources(cwd) {
         for (const src of ruleSourcesAtLevel(dir))
             add(src, "project");
     }
+    // Subfolder rules files below cwd: loaded on demand when the session works in
+    // their subtree. Tagged so the graph says WHY they are conditional, matching
+    // the subtree scope `loadRules` applies.
+    for (const dir of descendantLevels(cwd)) {
+        const rel = relative(cwd, dir).replace(/\\/g, "/");
+        for (const src of ruleSourcesAtLevel(dir)) {
+            if (src.status !== "loaded") {
+                add(src, "project");
+                continue;
+            }
+            add({ ...src, note: `subfolder rules — loaded when the agent works in ${rel}/` }, "project");
+        }
+    }
+    // Claude Code memory, as its own load-graph row. loadRules already CHECKS
+    // memory rules; listing them here closes the reporting gap where the graph
+    // undercounted what the checker uses (found 2026-10-03). Office homes are
+    // excluded inside the memory loader.
+    const mem = memoryGraphEntry(cwd);
+    if (mem && !seen.has(resolve(mem.path))) {
+        seen.add(resolve(mem.path));
+        entries.push({ path: mem.path, scope: "project", status: "loaded", format: "Claude memory", ruleCount: mem.ruleCount });
+    }
     return entries;
 }

package/package.json

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