session-orchestrator 3.21.0 → 3.23.0

package/scripts/lib/validate/check-hooks-symmetry.mjs

@@ -12,18 +12,12 @@
 import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
-// The pi projection is IMPORTED, not copied: pi-hook-bridge.mjs is the runtime
-// that actually rewrites `hook_event_name` for every Pi event, so it is the one
-// source of truth for which pi event becomes which Claude event (#953). A local
-// literal here was a second copy of the same 5 pairs — it could drift silently,
-// and the validator would then certify a projection the runtime does not use.
-// Deliberately NOT the same for `cursorEventMap` below: nothing at runtime
-// projects Cursor events (Cursor calls the handlers directly), so the
-// validator's copy is the only witness there. Even if a runtime source existed,
-// reading Check 3's expectation from the artefact it checks would make the
-// check self-certifying — the "undocumented pi-native event" test at
-// tests/scripts/check-hooks-symmetry.test.mjs would become unreachable. Keep
-// cursorEventMap validator-owned; do not "helpfully" collapse it too.
+// The pi and cursor projections are IMPORTED, not copied: the runtime bridges
+// rewrite `hook_event_name` for every native event, so they are the source of
+// truth for which native event becomes which Claude event (#953). A local
+// literal here was a second copy — it could drift silently, and the validator
+// would then certify a projection the runtime does not use.
+import { CURSOR_TO_CANONICAL_EVENT } from '../cursor-hook-bridge.mjs';
 import { PI_TO_CANONICAL_EVENT } from '../pi-hook-bridge.mjs';
 
 const PLUGIN_ROOT = process.argv[2];
@@ -40,7 +34,19 @@ const DOCUMENTED_ASYMMETRIES = {
   // Events from hooks.json/hooks-codex.json that are intentionally absent in hooks-cursor.json
   cursorMissingFromMain: ['SessionStart', 'SessionEnd', 'PostToolUse', 'PostToolUseFailure', 'PostToolBatch', 'Stop', 'SubagentStart', 'SubagentStop', 'CwdChanged', 'PreToolUse'],
   // Events unique to hooks-cursor.json (Cursor IDE-specific)
-  cursorOnly: ['afterFileEdit', 'beforeShellExecution'],
+  cursorOnly: [
+    'afterFileEdit',
+    'afterShellExecution',
+    'beforeShellExecution',
+    'postToolUse',
+    'postToolUseFailure',
+    'preToolUse',
+    'sessionEnd',
+    'sessionStart',
+    'stop',
+    'subagentStart',
+    'subagentStop',
+  ],
   // Claude/Codex events with no Pi-native v1 mapping yet.
   piMissingFromMain: ['PostToolUseFailure', 'PostToolBatch', 'SubagentStart', 'SubagentStop', 'CwdChanged'],
   // Pi-native extension events that map onto Claude/Codex hook events.
@@ -48,23 +54,10 @@ const DOCUMENTED_ASYMMETRIES = {
   // validator checks hooks-pi.json against is the SAME object pi-hook-bridge.mjs
   // applies to live payloads, so the two cannot drift apart.
   piEventMap: PI_TO_CANONICAL_EVENT,
-  // Cursor-IDE-native events projected onto the logical Claude events they
-  // correspond to. WITHOUT this projection Check 6 compared a FOREIGN event
-  // namespace against hooks.json: not one key matched, the per-event loop
-  // `continue`d on every iteration, and hooks-cursor.json reported
-  // "handler sets match hooks.json (documented asymmetries: 0)" while missing
-  // 20 of 22 handlers — a vacuum-true PASS. Check 6's projection guard now
-  // fails closed PER declared event (#946), so dropping a single entry from
-  // this map is caught too, not only the loss of every projection: the first
-  // version tested `sharedEvents.length === 0`, under which removing just
-  // `afterFileEdit` left the run green and merely moved cursor's documented-
-  // asymmetry count from 12 to 8.
-  // afterFileEdit fires AFTER the edit (hooks-cursor.json `note`,
-  // docs/cursor-setup.md) → it projects onto PostToolUse, never PreToolUse.
-  cursorEventMap: {
-    beforeShellExecution: 'PreToolUse',
-    afterFileEdit: 'PostToolUse',
-  },
+  // Bound to the runtime constant (see the import comment): the projection this
+  // validator checks hooks-cursor.json against is the SAME object
+  // cursor-hook-bridge.mjs applies to live payloads (#919 closed).
+  cursorEventMap: CURSOR_TO_CANONICAL_EVENT,
   // Check 6 (#942): handlers wired on a Claude event but intentionally absent
   // from the SAME logical event on a counterpart manifest. Checks 1-3 compare
   // event KEYS and Check 4 handler EXISTENCE — a handler wired on only one
@@ -84,6 +77,16 @@ const DOCUMENTED_ASYMMETRIES = {
         // Cursor IDE and Pi v1 have no parallel agent dispatch at all
         // (skills/session-plan/SKILL.md Platform Note), and Codex has no payload
         // adapter for it. A matcher that can never fire is not enforcement.
+        // pre-auq-clarity (#1107): NOT ported by construction. The hook matches
+        // the `AskUserQuestion` tool, which this platform does not have — it
+        // renders a numbered Markdown list instead (docs/codex-setup.md:112,
+        // docs/cursor-setup.md:86), and pi-hook-bridge's TOOL_NAME_MAP carries
+        // no `askuserquestion` entry. A matcher on a tool that never fires is a
+        // dead entry: maintenance cost that ASSERTS a protection it does not
+        // provide. Revisit the day the platform gains the tool — the mechanical
+        // witness for that day is the mapPiToolName assertion in
+        // tests/hooks/pre-auq-clarity-wiring.test.mjs, which goes red then.
+        'pre-auq-clarity.mjs',
         'pre-task-scope-disjoint.mjs',
         'skill-invocation-telemetry.mjs',
         'enforce-scope.mjs',
@@ -132,6 +135,16 @@ const DOCUMENTED_ASYMMETRIES = {
         // Cursor IDE and Pi v1 have no parallel agent dispatch at all
         // (skills/session-plan/SKILL.md Platform Note), and Codex has no payload
         // adapter for it. A matcher that can never fire is not enforcement.
+        // pre-auq-clarity (#1107): NOT ported by construction. The hook matches
+        // the `AskUserQuestion` tool, which this platform does not have — it
+        // renders a numbered Markdown list instead (docs/codex-setup.md:112,
+        // docs/cursor-setup.md:86), and pi-hook-bridge's TOOL_NAME_MAP carries
+        // no `askuserquestion` entry. A matcher on a tool that never fires is a
+        // dead entry: maintenance cost that ASSERTS a protection it does not
+        // provide. Revisit the day the platform gains the tool — the mechanical
+        // witness for that day is the mapPiToolName assertion in
+        // tests/hooks/pre-auq-clarity-wiring.test.mjs, which goes red then.
+        'pre-auq-clarity.mjs',
         'pre-task-scope-disjoint.mjs',
         'skill-invocation-telemetry.mjs',
         'pre-bash-sessions-ledger-guard.mjs', // #958
@@ -139,46 +152,29 @@ const DOCUMENTED_ASYMMETRIES = {
         'pre-bash-issue-budget.mjs',    // #946
       ],
     },
-    // Cursor is NOT wired (#919) and will not be: hooks-cursor.json is a
-    // mapping REFERENCE, not live enforcement. Every handler expects Claude
-    // Code payload shapes (tool_name === 'Bash', tool_input.command) and emits
-    // a Claude PreToolUse envelope; fed a Cursor payload enforce-commands.mjs
-    // short-circuits at gate G1 and writes 0 bytes to stdout AND stderr with
-    // exit 0, so the harness sees no decision and the command runs. Cursor
-    // needs an input/output adapter like scripts/lib/pi-hook-bridge.mjs; none
-    // exists. Operator decision 2026-07-31 — gap registered, not closed:
-    // #919 (Cursor no-op) tracks the adapter, #946 the allowlist-provenance
-    // rule that every entry here names its issue. These entries exist so the
-    // gap is MACHINE-readable (Check 6 counts them) rather than prose-only.
+    // Cursor is wired through scripts/lib/cursor-hook-bridge.mjs (#919 closed).
+    // Remaining gaps are tools Cursor does not expose, not missing adapters.
     cursor: {
-      // #919: beforeShellExecution → PreToolUse. Only enforce-commands.mjs is
-      // mapped at all; the other eight PreToolUse handlers have no Cursor
-      // mapping whatsoever.
       PreToolUse: [
         // pre-task-scope-disjoint (#1020): NOT ported by construction. The hook
         // matches the `Agent` dispatch tool, which this platform does not have —
         // Cursor IDE and Pi v1 have no parallel agent dispatch at all
         // (skills/session-plan/SKILL.md Platform Note), and Codex has no payload
         // adapter for it. A matcher that can never fire is not enforcement.
+        // pre-auq-clarity (#1107): NOT ported by construction. The hook matches
+        // the `AskUserQuestion` tool, which this platform does not have — it
+        // renders a numbered Markdown list instead (docs/codex-setup.md:112,
+        // docs/cursor-setup.md:86), and pi-hook-bridge's TOOL_NAME_MAP carries
+        // no `askuserquestion` entry. A matcher on a tool that never fires is a
+        // dead entry: maintenance cost that ASSERTS a protection it does not
+        // provide. Revisit the day the platform gains the tool — the mechanical
+        // witness for that day is the mapPiToolName assertion in
+        // tests/hooks/pre-auq-clarity-wiring.test.mjs, which goes red then.
+        'pre-auq-clarity.mjs',
         'pre-task-scope-disjoint.mjs',
-        'skill-invocation-telemetry.mjs',    // #919
-        'enforce-scope.mjs',                 // #919
-        'config-protection.mjs',             // #919
-        'pre-bash-destructive-guard.mjs',    // #919
-        'pre-bash-staging-fence.mjs',        // #919
-        'pre-bash-memory-propose-audit.mjs', // #919
-        'pre-bash-sessions-ledger-guard.mjs',// #919 (#958 — needs tool_name === 'Bash')
-        'pre-bash-templates-first.mjs',      // #919
-        'pre-bash-issue-budget.mjs',         // #919
-      ],
-      // #919: afterFileEdit → PostToolUse. Cursor maps enforce-scope.mjs here
-      // (post-hoc warning only); none of Claude's four PostToolUse handlers
-      // has a Cursor mapping.
-      PostToolUse: [
-        'post-edit-validate.mjs',          // #919
-        'post-tooluse-frontend-slop.mjs',  // #919
-        'post-bash-write-verify.mjs',      // #919 (#942 class — needs tool_name === 'Bash')
-        'loop-guard.mjs',                  // #919
+        // skill-invocation-telemetry: Cursor has no Skill tool — the matcher
+        // can never fire. Commands Read skills/*/SKILL.md instead.
+        'skill-invocation-telemetry.mjs',
       ],
     },
   },
@@ -328,7 +324,7 @@ function extractHandlersByEvent(json) {
       const hookList = m.hooks || [];
       for (const h of hookList) {
         const cmd = h.command || h.script || '';
-        const match = cmd.match(/(?:hooks\/|\$\{?CLAUDE_PLUGIN_ROOT\}?\/hooks\/|\$\{?CODEX_PLUGIN_ROOT\}?\/hooks\/|\$\{?PI_PLUGIN_ROOT\}?\/hooks\/)([\w/-]+\.mjs)/);
+        const match = cmd.match(/(?:hooks\/|\$\{?CLAUDE_PLUGIN_ROOT\}?\/hooks\/|\$\{?CODEX_PLUGIN_ROOT\}?\/hooks\/|\$\{?PI_PLUGIN_ROOT\}?\/hooks\/|\$\{?CURSOR_PLUGIN_ROOT\}?\/hooks\/)([\w/-]+\.mjs)/);
         if (match) handlers.add(match[1]);
       }
     }

package/scripts/lib/validate/check-playwright-mcp-canary.mjs

@@ -36,8 +36,9 @@
  *   - Verify non-scanned file extensions (e.g. .yaml) are not processed
  */
 
-import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
+import { listRepoFiles } from './repo-files.mjs';
 
 const pluginRoot = process.argv[2];
 if (!pluginRoot) {
@@ -86,26 +87,6 @@ const SCAN_ROOTS = [
 
 const SCAN_EXTENSIONS = ['.md', '.mjs', '.js', '.ts'];
 
-/**
- * Recursively walk a directory and return all file paths with the allowed extensions.
- * @param {string} dir
- * @returns {string[]}
- */
-function walk(dir) {
-  const results = [];
-  if (!existsSync(dir)) return results;
-  for (const name of readdirSync(dir)) {
-    const full = join(dir, name);
-    const st = statSync(full);
-    if (st.isDirectory()) {
-      results.push(...walk(full));
-    } else if (SCAN_EXTENSIONS.some((ext) => name.endsWith(ext))) {
-      results.push(full);
-    }
-  }
-  return results;
-}
-
 const violations = [];
 
 for (const rel of SCAN_ROOTS) {
@@ -114,7 +95,17 @@ for (const rel of SCAN_ROOTS) {
     pass(`${rel}/ does not exist yet (no scan needed)`);
     continue;
   }
-  const files = walk(absDir);
+  // The index, not the filesystem (#1143). This walk carried NO exclusion set
+  // — not even `node_modules` — while SCAN_EXTENSIONS covers .mjs/.js/.ts, so
+  // a vendored copy of the very package this canary forbids (a gitignored
+  // `skills/playwright-driver/node_modules/@playwright/mcp`) would be read as
+  // repo source and fail a BLOCKING gate on someone else's code.
+  // Honest scope note: unlike the other scanners migrated with it, this one is
+  // NOT exposed to the `.claude/worktrees/` case — measured 2026-08-26, its
+  // three SCAN_ROOTS are fixed deep subdirectories that a worktree cannot land
+  // in, and on-disk vs index counts were identical (2/2, 3/3, 2/2). The
+  // gitignored-vendored-tree case above is the reason it moved.
+  const files = listRepoFiles(pluginRoot, { dirs: [rel], exts: SCAN_EXTENSIONS });
   let fileViolations = 0;
   for (const file of files) {
     const text = readFileSync(file, 'utf8');

package/scripts/lib/validate/check-plugin-monitors.mjs

@@ -13,7 +13,8 @@
  *   7. Each name is unique within the array
  *   8. Array contains an entry named "ecosystem-health"
  *   9. Array contains an entry named "convergence-monitor"
- *  10. The 2 referenced watcher scripts exist on filesystem
+ *  10. Array contains an entry named "wave-transcript-tail" (#1114)
+ *  11. The 3 referenced watcher scripts exist on filesystem
  *
  * Path resolution note:
  *   experimental.monitors value "./monitors/monitors.json" is repo-root-relative
@@ -50,11 +51,16 @@ let failed = 0;
 function pass(msg) { console.log(`  PASS: ${msg}`); passed += 1; }
 function fail(msg) { console.log(`  FAIL: ${msg}`); failed += 1; }
 
-const REQUIRED_MONITOR_NAMES = ['ecosystem-health', 'convergence-monitor'];
+const REQUIRED_MONITOR_NAMES = [
+  'ecosystem-health',
+  'convergence-monitor',
+  'wave-transcript-tail',
+];
 const REQUIRED_FIELDS = ['name', 'command', 'description'];
 const REQUIRED_SCRIPTS = [
   'scripts/lib/ecosystem-health.mjs',
   'scripts/lib/convergence-monitor.mjs',
+  'scripts/lib/wave-transcript-tail.mjs',
 ];
 
 // ---------------------------------------------------------------------------
@@ -177,7 +183,7 @@ if (dups.length === 0) {
 }
 
 // ---------------------------------------------------------------------------
-// Checks 8-9: required monitor names present
+// Checks 8-10: required monitor names present
 // ---------------------------------------------------------------------------
 
 for (const required of REQUIRED_MONITOR_NAMES) {
@@ -189,7 +195,7 @@ for (const required of REQUIRED_MONITOR_NAMES) {
 }
 
 // ---------------------------------------------------------------------------
-// Check 10: referenced watcher scripts exist on disk
+// Check 11: referenced watcher scripts exist on disk
 // ---------------------------------------------------------------------------
 
 for (const scriptRel of REQUIRED_SCRIPTS) {

package/scripts/lib/validate/check-rules.mjs

@@ -30,6 +30,51 @@
 //           parse error as always-on with empty meta, so the skipped file is
 //           exactly the one that loads everywhere and clears every gate. See
 //           the inline rationale at the parse site below.
+//       (e) HARNESS-PARITY (#1108): a rule that expresses a path restriction
+//           must express it in `paths:`, because `paths:` is the ONLY key
+//           Claude Code's own rule loader reads. Its documentation
+//           (code.claude.com/docs/en/memory § "Path-specific rules") is
+//           explicit: rules are scoped "using YAML frontmatter with the
+//           `paths` field", and "rules without a `paths` field are loaded
+//           unconditionally and apply to all files". `globs:` is the CURSOR
+//           field name. A `globs:`-only rule is therefore scoped for
+//           rule-loader.mjs (#795 alias) and for Cursor, yet ALWAYS-ON for
+//           Claude Code — the rule *looks* scoped everywhere it is inspected
+//           and is silently loaded everywhere it is used.
+//           Measured 2026-08-22 before the fix: 16 of 31 rule files carried
+//           `globs:` and 0 carried `paths:`, so all 31 loaded unconditionally
+//           — 186,993 bytes ≈ 46,700 tokens per dispatch, 72,195 of them
+//           unwanted (testing.md alone is 36,431 bytes and carries
+//           `tier: wave-only`, i.e. is explicitly meant to be conditional).
+//           This check is the recurrence guard for that fix, not the fix.
+//           It is formulated as a PARITY check rather than a presence check,
+//           which folds two defects into one invariant: the rule must load in
+//           the SAME contexts under Claude Code's loader (which reads
+//           `paths:`, treating absence as always-on) as under rule-loader.mjs
+//           (which reads `globs:` and falls back to `paths:` — #795, globs
+//           wins). Two ways to violate it:
+//             - `globs:` present and non-empty, `paths:` ABSENT → always-on
+//               in Claude Code.
+//             - both present with DIFFERENT pattern sets → Claude Code scopes
+//               on one list, rule-loader.mjs and Cursor on the other.
+//           Order and duplicates are irrelevant (a glob list is matched
+//           any-of), so the comparison is over the sorted unique set.
+//           NOT flagged: `paths:` alone. It is the form the native
+//           documentation prescribes and the form the primary downstream
+//           consumer uses exclusively (projects-baseline: 26 rule files, all
+//           `paths:`, 0 `globs:` — rule-loader.mjs module doc). The
+//           `globs:`-is-canonical preference for VENDORED rules is a separate,
+//           warn-level concern already owned by
+//           scripts/lib/validate-vendored-rules.mjs (~:289, issue #742) and is
+//           deliberately not duplicated here.
+//           NOT flagged either: an EMPTY `globs: []`. That shape is already
+//           owned — with an accurate, opposite message — by the dedicated
+//           empty-globs branches below (#880 QA Defect 1 / #892), and firing
+//           a second, contradictory-sounding finding ("never loads" beside
+//           "always-on in Claude Code") on one file is exactly the confusion
+//           those fixes went out of their way to remove. The parity check
+//           therefore requires a NON-EMPTY `globs:` list; populating it is the
+//           prescribed remedy for `globs: []`, at which point parity binds.
 //
 // (2) HANDWRITTEN rules (no `auto-generated: true` — #880 FA5, WARN-only,
 //     NEVER affects the exit code). The auto-generated brandmauer above only
@@ -70,9 +115,10 @@
 //
 // Usage: check-rules.mjs <plugin-root>
 // Outputs lines of the form "  PASS: ..." / "  FAIL: ..." / "  WARN: ...".
-// Exit 0 = all AUTO-GENERATED invariants satisfied (WARN lines from the
-// handwritten check NEVER affect the exit code); exit 1 = at least one
-// auto-generated FAIL.
+// Exit 0 = all AUTO-GENERATED invariants plus the two cohort-independent
+// invariants (d) frontmatter-parses and (e) harness-parity are satisfied (WARN
+// lines from the handwritten check NEVER affect the exit code); exit 1 = at
+// least one FAIL.
 
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -132,6 +178,69 @@ function hasFrontmatterKey(contents, key) {
   return Boolean(keyMatch && keyMatch[1] && keyMatch[1].trim() !== '');
 }
 
+// ---------------------------------------------------------------------------
+// Per-key list access for the harness-parity check (#1108).
+//
+// `parseGlobsFrontmatter()` deliberately COLLAPSES `globs:` and `paths:` into
+// one value ("callers never see which key produced the value" — rule-loader.mjs
+// module doc, #795 precedence). The parity check needs both lists separately,
+// and re-deriving list parsing here would be a second frontmatter parser — the
+// exact drift class that produced #840. So instead of re-parsing, the OTHER key
+// is MASKED to a name the parser ignores (any key that is neither globs/paths
+// nor in SCALAR_META_KEYS is dropped without error, and its indented `  - x`
+// continuation lines are skipped as "another block's continuation"), and the
+// SAME parser then returns the surviving key's list verbatim — flow style,
+// block style, quote stripping and provenance-header tolerance included.
+//
+// Masking cannot make a parseable file unparseable: it renames a key, so the
+// line keeps its colon. Callers reach this only for files that already parsed.
+// ---------------------------------------------------------------------------
+const MASKED_KEY_PREFIX = 'x-check-rules-masked-';
+
+/**
+ * Returns the value of exactly ONE of the two scope keys, ignoring the other —
+ * `null` when that key is absent, `[]` when present but empty.
+ *
+ * @param {string} contents - raw file contents (must already parse)
+ * @param {'globs'|'paths'} key - the key whose list to return
+ * @returns {string[] | null}
+ */
+function scopeKeyValue(contents, key) {
+  const other = key === 'globs' ? 'paths' : 'globs';
+  const masked = contents.replace(
+    new RegExp(`^${other}:`, 'gm'),
+    `${MASKED_KEY_PREFIX}${other}:`,
+  );
+  return parseGlobsFrontmatter(masked).globs;
+}
+
+/** Sorted, de-duplicated copy — glob lists are matched any-of, so neither
+ * order nor repetition changes which files a rule applies to. */
+function normalizePatterns(list) {
+  return [...new Set(list)].sort();
+}
+
+/**
+ * Harness-parity verdict for one rule file (#1108) — see module doc (e).
+ *
+ * @param {string} contents - raw file contents (must already parse)
+ * @returns {{ ok: true } | { ok: false, kind: 'missing-paths'|'divergent', globs: string[], paths: string[] | null }}
+ */
+function checkHarnessParity(contents) {
+  const globs = scopeKeyValue(contents, 'globs');
+  // Only a NON-EMPTY globs list expresses a path restriction. Absent globs →
+  // whatever `paths:` says is what every loader sees. Empty globs → owned by
+  // the dedicated empty-globs branches, which prescribe populating it.
+  if (!Array.isArray(globs) || globs.length === 0) return { ok: true };
+
+  const paths = scopeKeyValue(contents, 'paths');
+  if (paths === null) return { ok: false, kind: 'missing-paths', globs, paths };
+
+  const same =
+    JSON.stringify(normalizePatterns(globs)) === JSON.stringify(normalizePatterns(paths));
+  return same ? { ok: true } : { ok: false, kind: 'divergent', globs, paths };
+}
+
 // ============================================================================
 // Check: .claude/rules/ rule invariants
 // ============================================================================
@@ -207,17 +316,44 @@ for (const name of mdFiles.sort()) {
   const { globs, meta } = parsed;
   const rel = `.claude/rules/${name}`;
 
+  // (e) HARNESS-PARITY (#1108) — cohort-independent, like the parse check
+  // above: `paths:` is the only scope key Claude Code's own loader reads, so a
+  // `globs:`-only or divergently-scoped rule loads differently there than it
+  // does under rule-loader.mjs. Emitted here, in file order, and recorded on
+  // the entry so the cohort branches below suppress their PASS line — a file
+  // must never both PASS and FAIL.
+  const parity = checkHarnessParity(contents);
+  if (!parity.ok && parity.kind === 'missing-paths') {
+    fail(
+      `${rel} — declares globs: (${parity.globs.length} pattern(s)) but no paths: — Claude Code's native rule ` +
+        'loader reads ONLY the `paths` frontmatter field and treats a rule without it as unconditional ' +
+        '("rules without a paths field are loaded unconditionally and apply to all files" — ' +
+        'code.claude.com/docs/en/memory § Path-specific rules). `globs:` is the Cursor field name, so this rule ' +
+        'is scoped for rule-loader.mjs and Cursor but loads ALWAYS-ON in Claude Code — a silent instruction-budget ' +
+        'failure (#1108). Add a paths: key carrying the same patterns as globs: (keep globs: — it stays the ' +
+        'canonical form for vendored rules, validate-vendored-rules.mjs #742).',
+    );
+  } else if (!parity.ok && parity.kind === 'divergent') {
+    fail(
+      `${rel} — globs: and paths: declare DIFFERENT pattern sets (globs: ${JSON.stringify(parity.globs)} vs ` +
+        `paths: ${JSON.stringify(parity.paths)}) — Claude Code's native loader scopes on paths:, while ` +
+        'rule-loader.mjs and Cursor scope on globs: (globs: wins silently when both are present, #795). The rule ' +
+        'therefore loads in different contexts on different harnesses (#1108). Make the two lists carry the same ' +
+        'patterns — order and duplicates are irrelevant.',
+    );
+  }
+
   if (meta['auto-generated'] === true) {
-    autoGeneratedEntries.push({ rel, globs, meta });
+    autoGeneratedEntries.push({ rel, globs, meta, parityOk: parity.ok });
   } else {
-    handwrittenEntries.push({ rel, globs, meta, contents });
+    handwrittenEntries.push({ rel, globs, meta, contents, parityOk: parity.ok });
   }
 }
 
 // ---------------------------------------------------------------------------
 // Auto-generated branch (FA4 #697) — UNCHANGED behaviour, hard-fail.
 // ---------------------------------------------------------------------------
-for (const { rel, globs, meta } of autoGeneratedEntries) {
+for (const { rel, globs, meta, parityOk } of autoGeneratedEntries) {
   // (a) never-always-on: must have at least one activation axis.
   // globs is one of: null (no frontmatter / no globs key), [] (key present
   // but EMPTY — the #892 QA-Defect special case, see module doc), or a
@@ -264,9 +400,11 @@ for (const { rel, globs, meta } of autoGeneratedEntries) {
   // an empty globs array, which is dead-not-passing regardless of host-class)
   // AND learning-key AND expires-at. When any failed, the FAIL line(s) above
   // already emitted.
+  // `parityOk` joins the conjunction for the same reason `hasEmptyGlobs` does:
+  // its FAIL already emitted above, and a file must never both PASS and FAIL.
   const lkOk = Object.prototype.hasOwnProperty.call(meta, 'learning-key');
   const eaOk = Object.prototype.hasOwnProperty.call(meta, 'expires-at');
-  if (!hasEmptyGlobs && (hasGlobs || hasHostClass) && lkOk && eaOk) {
+  if (!hasEmptyGlobs && (hasGlobs || hasHostClass) && lkOk && eaOk && parityOk) {
     pass(`${rel} — auto-generated rule satisfies all invariants`);
   }
 }
@@ -283,7 +421,7 @@ console.log(
   '--- Check: .claude/rules/ handwritten-rule activation + review-date (warn mode, #880) ---',
 );
 
-for (const { rel, globs, meta, contents } of handwrittenEntries) {
+for (const { rel, globs, meta, contents, parityOk } of handwrittenEntries) {
   // `globs` (the merged globs/paths value from parseGlobsFrontmatter — #795
   // alias, `globs:` wins when both are present) is one of:
   //   - null                     → neither key present
@@ -333,7 +471,13 @@ for (const { rel, globs, meta, contents } of handwrittenEntries) {
     );
   }
 
-  if (!hasEmptyGlobs && hasAxis && hasReviewDate) {
+  // `parityOk` joins the conjunction for the same reason `hasEmptyGlobs` does
+  // (#1108): its FAIL already emitted in the parse loop, and a file must never
+  // both PASS and FAIL. This is the one place a handwritten rule's PASS is
+  // withheld for a HARD-fail reason — the parity invariant is cohort-
+  // independent by construction, so it is not part of this branch's
+  // deliberately warn-only posture.
+  if (!hasEmptyGlobs && hasAxis && hasReviewDate && parityOk) {
     pass(`${rel} — handwritten rule has an activation axis and a review-date`);
   }
 }