@bonesofspring/ai-rules 0.2.18 → 0.2.20

package/scripts/check-preset-leakage.sh

@@ -0,0 +1,450 @@
+#!/usr/bin/env bash
+# FAIL on cross-stack leakage in hooks (hard) and agent filenames (hard).
+# Agent body: positive forbidden mentions → FAIL; explicit negation → silent
+# (counted in summary); build-verifier packaging refs without negation → WARN.
+# Exit 0 on OK; exit 1 on any FAIL.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+export AI_RULES_PRESETS_ROOT="$ROOT/packages/ai-rules/presets"
+
+python3 <<'PY'
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+presets = Path(os.environ["AI_RULES_PRESETS_ROOT"])
+PLATFORMS = ("cursor", "claude")
+STACKS = ("next", "nuxt", "svelte", "ios-swift", "android-kotlin", "go", "java", "mcp-ts", "php-hexagonal", "php-laravel")
+
+NEGATION_RE = re.compile(
+    r"(?i)\b("
+    r"never|do\s+not|don't|must\s+not|forbidden|ban(?:ned)?|avoid|"
+    r"instead|not\s+require|no\s+playwright|without\s+playwright|"
+    r"iOS\s+uses|Go\s+backend|≠|not\s+be\s+byte|leakage|soft\s*/\s*document"
+    r")\b"
+)
+
+def pats(*exprs: str) -> list[re.Pattern[str]]:
+    return [re.compile(e) for e in exprs]
+
+IOS_FORBIDDEN_IN_CHAIN = pats(
+    r"playwright-test-",
+    r"playwright-agents",
+    r"playwright-e2e",
+    r"user-playwright",
+    r"instrumentation-test-",
+    r"app/__tests__/e2e",
+    r"(?i)(?:\brun\s+|`|\b)lint:js\b",
+    r"(?i)(?:\brun\s+|`|\b)lint:css\b",
+)
+NEXT_FORBIDDEN_IN_CHAIN = pats(
+    r"xcuitest-test-",
+    r"instrumentation-test-",
+    r"(?i)\bxcodebuild\b",
+    r"(?i)\bSwiftLint\b",
+)
+GO_FORBIDDEN_IN_CHAIN = pats(
+    r"playwright-test-",
+    r"playwright-agents",
+    r"playwright-e2e",
+    r"user-playwright",
+    r"app/__tests__/e2e",
+    r"(?i)(?:\brun\s+|`|\b)lint:js\b",
+    r"(?i)(?:\brun\s+|`|\b)lint:css\b",
+    r"xcuitest-test-",
+    r"instrumentation-test-",
+    r"(?i)\bxcodebuild\b",
+    r"(?i)\bSwiftLint\b",
+)
+
+IOS_FORBIDDEN_AGENT_STEMS = (
+    "playwright-test-planner",
+    "playwright-test-generator",
+    "playwright-test-healer",
+
+    "instrumentation-test-planner",
+    "instrumentation-test-generator",
+    "instrumentation-test-healer",
+    "storybook-reviewer",
+)
+NEXT_FORBIDDEN_AGENT_STEMS = (
+    "xcuitest-test-planner",
+    "xcuitest-test-generator",
+    "xcuitest-test-healer",
+
+    "instrumentation-test-planner",
+    "instrumentation-test-generator",
+    "instrumentation-test-healer",
+)
+GO_FORBIDDEN_AGENT_STEMS = (
+    "playwright-test-planner",
+    "playwright-test-generator",
+    "playwright-test-healer",
+    "xcuitest-test-planner",
+    "xcuitest-test-generator",
+    "xcuitest-test-healer",
+    "accessibility-reviewer",
+    "mockup-reviewer",
+    "storybook-reviewer",
+
+    "instrumentation-test-planner",
+    "instrumentation-test-generator",
+    "instrumentation-test-healer",
+)
+
+IOS_SOFT = list(IOS_FORBIDDEN_IN_CHAIN)
+NEXT_SOFT = list(NEXT_FORBIDDEN_IN_CHAIN)
+
+NUXT_FORBIDDEN_IN_CHAIN = list(NEXT_FORBIDDEN_IN_CHAIN)
+NUXT_FORBIDDEN_AGENT_STEMS = NEXT_FORBIDDEN_AGENT_STEMS
+NUXT_SOFT = list(NEXT_FORBIDDEN_IN_CHAIN)
+
+SVELTE_FORBIDDEN_IN_CHAIN = list(NEXT_FORBIDDEN_IN_CHAIN)
+SVELTE_FORBIDDEN_AGENT_STEMS = NEXT_FORBIDDEN_AGENT_STEMS
+SVELTE_SOFT = list(NEXT_FORBIDDEN_IN_CHAIN)
+GO_SOFT = list(GO_FORBIDDEN_IN_CHAIN)
+
+JAVA_FORBIDDEN_IN_CHAIN = pats(
+    r"playwright-test-",
+    r"playwright-agents",
+    r"playwright-e2e",
+    r"user-playwright",
+    r"app/__tests__/e2e",
+    r"(?i)(?:\brun\s+|`|\b)lint:js\b",
+    r"(?i)(?:\brun\s+|`|\b)lint:css\b",
+    r"xcuitest-test-",
+    r"instrumentation-test-",
+    r"(?i)\bxcodebuild\b",
+    r"(?i)\bSwiftLint\b",
+)
+JAVA_FORBIDDEN_AGENT_STEMS = (
+    "playwright-test-planner",
+    "playwright-test-generator",
+    "playwright-test-healer",
+    "xcuitest-test-planner",
+    "xcuitest-test-generator",
+    "xcuitest-test-healer",
+    "accessibility-reviewer",
+    "mockup-reviewer",
+    "storybook-reviewer",
+
+    "instrumentation-test-planner",
+    "instrumentation-test-generator",
+    "instrumentation-test-healer",
+)
+JAVA_SOFT = list(JAVA_FORBIDDEN_IN_CHAIN)
+
+PHP_FORBIDDEN_IN_CHAIN = pats(
+    r"playwright-test-",
+    r"playwright-agents",
+    r"playwright-e2e",
+    r"user-playwright",
+    r"app/__tests__/e2e",
+    r"(?i)(?:\brun\s+|`|\b)lint:js\b",
+    r"(?i)(?:\brun\s+|`|\b)lint:css\b",
+    r"xcuitest-test-",
+    r"instrumentation-test-",
+    r"(?i)\bxcodebuild\b",
+    r"(?i)\bSwiftLint\b",
+)
+PHP_FORBIDDEN_AGENT_STEMS = (
+    "playwright-test-planner",
+    "playwright-test-generator",
+    "playwright-test-healer",
+    "xcuitest-test-planner",
+    "xcuitest-test-generator",
+    "xcuitest-test-healer",
+    "accessibility-reviewer",
+    "mockup-reviewer",
+    "storybook-reviewer",
+
+    "instrumentation-test-planner",
+    "instrumentation-test-generator",
+    "instrumentation-test-healer",
+)
+PHP_SOFT = list(PHP_FORBIDDEN_IN_CHAIN)
+
+MCP_TS_FORBIDDEN_IN_CHAIN = pats(
+    r"playwright-test-",
+    r"playwright-agents",
+    r"playwright-e2e",
+    r"user-playwright",
+    r"app/__tests__/e2e",
+    r"(?i)(?:\brun\s+|`|\b)lint:js\b",
+    r"(?i)(?:\brun\s+|`|\b)lint:css\b",
+    r"xcuitest-test-",
+    r"instrumentation-test-",
+    r"(?i)\bxcodebuild\b",
+    r"(?i)\bSwiftLint\b",
+    r"(?i)(?:\brun\s+|`|\b)go\s+test\b",
+    r"(?i)(?:\brun\s+|`|\b)go\s+vet\b",
+    r"(?i)\bgolangci-lint\b",
+)
+MCP_TS_FORBIDDEN_AGENT_STEMS = (
+    "playwright-test-planner",
+    "playwright-test-generator",
+    "playwright-test-healer",
+    "xcuitest-test-planner",
+    "xcuitest-test-generator",
+    "xcuitest-test-healer",
+    "integration-test-planner",
+    "integration-test-generator",
+    "integration-test-healer",
+    "accessibility-reviewer",
+    "mockup-reviewer",
+    "storybook-reviewer",
+
+    "instrumentation-test-planner",
+    "instrumentation-test-generator",
+    "instrumentation-test-healer",
+)
+MCP_TS_SOFT = list(MCP_TS_FORBIDDEN_IN_CHAIN)
+
+
+ANDROID_FORBIDDEN_IN_CHAIN = pats(
+    r"playwright-test-",
+    r"playwright-agents",
+    r"playwright-e2e",
+    r"user-playwright",
+    r"app/__tests__/e2e",
+    r"(?i)(?:\brun\s+|`|\b)lint:js\b",
+    r"(?i)(?:\brun\s+|`|\b)lint:css\b",
+    r"xcuitest-test-",
+    r"(?i)\bxcodebuild\b",
+    r"(?i)\bSwiftLint\b",
+)
+ANDROID_FORBIDDEN_AGENT_STEMS = (
+    "playwright-test-planner",
+    "playwright-test-generator",
+    "playwright-test-healer",
+    "xcuitest-test-planner",
+    "xcuitest-test-generator",
+    "xcuitest-test-healer",
+    "integration-test-planner",
+    "integration-test-generator",
+    "integration-test-healer",
+    "storybook-reviewer",
+)
+ANDROID_SOFT = list(ANDROID_FORBIDDEN_IN_CHAIN)
+
+STACK_CFG = {
+    "next": (NEXT_FORBIDDEN_IN_CHAIN, NEXT_SOFT, NEXT_FORBIDDEN_AGENT_STEMS),
+    "nuxt": (NUXT_FORBIDDEN_IN_CHAIN, NUXT_SOFT, NUXT_FORBIDDEN_AGENT_STEMS),
+    "svelte": (SVELTE_FORBIDDEN_IN_CHAIN, SVELTE_SOFT, SVELTE_FORBIDDEN_AGENT_STEMS),
+    "ios-swift": (IOS_FORBIDDEN_IN_CHAIN, IOS_SOFT, IOS_FORBIDDEN_AGENT_STEMS),
+    "android-kotlin": (ANDROID_FORBIDDEN_IN_CHAIN, ANDROID_SOFT, ANDROID_FORBIDDEN_AGENT_STEMS),
+    "go": (GO_FORBIDDEN_IN_CHAIN, GO_SOFT, GO_FORBIDDEN_AGENT_STEMS),
+    "java": (JAVA_FORBIDDEN_IN_CHAIN, JAVA_SOFT, JAVA_FORBIDDEN_AGENT_STEMS),
+    "mcp-ts": (MCP_TS_FORBIDDEN_IN_CHAIN, MCP_TS_SOFT, MCP_TS_FORBIDDEN_AGENT_STEMS),
+    "php-hexagonal": (PHP_FORBIDDEN_IN_CHAIN, PHP_SOFT, PHP_FORBIDDEN_AGENT_STEMS),
+    "php-laravel": (PHP_FORBIDDEN_IN_CHAIN, PHP_SOFT, PHP_FORBIDDEN_AGENT_STEMS),
+}
+
+
+def iter_hook_scripts(stack: str, platform: str) -> list[Path]:
+    hooks = presets / platform / stack / "hooks"
+    if not hooks.is_dir():
+        return []
+    return sorted(p for p in hooks.rglob("*.sh") if p.is_file())
+
+
+def iter_agent_files(stack: str, platform: str) -> list[Path]:
+    agents = presets / platform / stack / "agents"
+    if not agents.is_dir():
+        return []
+    return sorted(
+        p for p in agents.iterdir() if p.is_file() and p.suffix == ".md" and p.name != "README.md"
+    )
+
+
+def iter_fixture_files(stack: str, platform: str) -> list[Path]:
+    fixtures = presets / platform / stack / "team" / "fixtures"
+    if not fixtures.is_dir():
+        return []
+    return sorted(p for p in fixtures.glob("*.json") if p.is_file())
+
+
+def normalize_prose(line: str) -> str:
+    return re.sub(r"[*_`]+", "", line)
+
+
+def line_is_negation(line: str) -> bool:
+    return bool(NEGATION_RE.search(normalize_prose(line)))
+
+
+def is_forbidden_agent(name: str, bad_stems: tuple[str, ...]) -> bool:
+    return name in bad_stems or any(name.startswith(s) for s in bad_stems)
+
+
+def collect_step_agents(steps) -> list[str]:
+    """Flatten pipeline steps[].agent (string or parallel array)."""
+    names: list[str] = []
+    if not isinstance(steps, list):
+        return names
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        agent = step.get("agent")
+        if isinstance(agent, str):
+            names.append(agent)
+        elif isinstance(agent, list):
+            names.extend(a for a in agent if isinstance(a, str))
+    return names
+
+
+def collect_skipped_agents(skipped) -> set[str]:
+    names: set[str] = set()
+    if not isinstance(skipped, list):
+        return names
+    for entry in skipped:
+        if isinstance(entry, dict) and isinstance(entry.get("agent"), str):
+            names.add(entry["agent"])
+    return names
+
+
+failed = 0
+warned = 0
+negation_suppressed = 0
+fixture_skipped_ok = 0
+
+print("Preset cross-stack leakage scan")
+print(f"Presets: {presets}")
+print()
+
+for stack in STACKS:
+    print(f"=== {stack} ===")
+    hard_patterns, soft_patterns, bad_stems = STACK_CFG[stack]
+    stack_negation = 0
+    stack_fixture_skipped = 0
+
+    for platform in PLATFORMS:
+        for script in iter_hook_scripts(stack, platform):
+            text = script.read_text(encoding="utf-8")
+            for pat in hard_patterns:
+                if pat.search(text):
+                    print(
+                        f"FAIL: [{platform}/{stack}] {script.name} matches "
+                        f"/{pat.pattern}/"
+                    )
+                    failed += 1
+
+        for agent in iter_agent_files(stack, platform):
+            stem = agent.stem
+            if is_forbidden_agent(stem, bad_stems):
+                print(
+                    f"FAIL: [{platform}/{stack}] forbidden agent file: {agent.name}"
+                )
+                failed += 1
+                continue
+
+            text = agent.read_text(encoding="utf-8")
+            for i, line in enumerate(text.splitlines(), 1):
+                for pat in soft_patterns:
+                    if not pat.search(line):
+                        continue
+                    if line_is_negation(line):
+                        # Documented bans are expected — do not soft-WARN per line.
+                        stack_negation += 1
+                        negation_suppressed += 1
+                    elif agent.stem == "build-verifier":
+                        print(
+                            f"WARN: [{platform}/{stack}] {agent.name}:{i} "
+                            f"mentions /{pat.pattern}/ (verifier packaging — soft)"
+                        )
+                        warned += 1
+                    else:
+                        print(
+                            f"FAIL: [{platform}/{stack}] {agent.name}:{i} "
+                            f"positive forbidden mention /{pat.pattern}/"
+                        )
+                        print(f"       {line.strip()[:120]}")
+                        failed += 1
+
+        # team/fixtures: forbidden stems in active steps[] → FAIL;
+        # same stems under skipped[] are intentional anti-patterns → OK.
+        for fixture in iter_fixture_files(stack, platform):
+            try:
+                data = json.loads(fixture.read_text(encoding="utf-8"))
+            except json.JSONDecodeError as exc:
+                print(
+                    f"FAIL: [{platform}/{stack}] {fixture.name} invalid JSON: {exc}"
+                )
+                failed += 1
+                continue
+            if not isinstance(data, dict):
+                print(
+                    f"FAIL: [{platform}/{stack}] {fixture.name} root must be object"
+                )
+                failed += 1
+                continue
+            for name in collect_step_agents(data.get("steps")):
+                if is_forbidden_agent(name, bad_stems):
+                    print(
+                        f"FAIL: [{platform}/{stack}] {fixture.name} steps[] "
+                        f"schedules forbidden agent {name!r}"
+                    )
+                    failed += 1
+            for name in collect_skipped_agents(data.get("skipped")):
+                if is_forbidden_agent(name, bad_stems):
+                    stack_fixture_skipped += 1
+                    fixture_skipped_ok += 1
+
+    if stack_negation:
+        print(
+            f"INFO: [{stack}] suppressed {stack_negation} negation mention(s) "
+            f"(not a merge blocker)"
+        )
+    if stack_fixture_skipped:
+        print(
+            f"INFO: [{stack}] fixtures skipped[] documents "
+            f"{stack_fixture_skipped} forbidden agent stem(s) "
+            f"(intentional anti-pattern — OK)"
+        )
+    print()
+
+# --- Chain fork: pairwise among stacks that have chain scripts ---
+print("=== chain fork ===")
+for platform in PLATFORMS:
+    chains: dict[str, Path] = {}
+    for stack in STACKS:
+        p = presets / platform / stack / "hooks" / "chain-team-phases.sh"
+        if p.is_file():
+            chains[stack] = p
+    names = sorted(chains)
+    if len(names) < 2:
+        print(f"WARN: [{platform}] fewer than 2 chain scripts — skip")
+        warned += 1
+        continue
+    for i, a in enumerate(names):
+        for b in names[i + 1 :]:
+            if chains[a].read_bytes() == chains[b].read_bytes():
+                print(
+                    f"FAIL: [{platform}] {a} chain-team-phases.sh is byte-identical to {b}"
+                )
+                failed += 1
+            else:
+                print(f"OK: [{platform}] {a} chain ≠ {b} chain")
+
+print()
+print(f"WARN count: {warned} (build-verifier packaging refs / chain skips)")
+print(
+    f"Negation mentions suppressed: {negation_suppressed} "
+    f"(documented bans — not a merge blocker)"
+)
+print(
+    f"Fixture skipped[] anti-patterns allowed: {fixture_skipped_ok} "
+    f"(forbidden stems only in skipped — not a merge blocker)"
+)
+
+if failed:
+    print(f"Result: FAIL ({failed} issue(s))")
+    sys.exit(1)
+
+print("Result: OK")
+sys.exit(0)
+PY

package/scripts/check-preset-structure.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# Orchestrator: twin map + token budget + leakage + hook-only lifecycle + shared-core drift + i18n (hard).
+# All gates exit non-zero on FAIL.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+export AI_RULES_PRESETS_ROOT="$ROOT/packages/ai-rules/presets"
+
+echo "========================================"
+echo "Preset structure checks"
+echo "ROOT=$ROOT"
+echo "========================================"
+echo
+
+status=0
+
+run_gate() {
+  local label="$1"
+  local script="$2"
+  shift 2
+  echo ">>> $label"
+  if env "$@" bash "$script"; then
+    echo "<<< $label: OK"
+  else
+    echo "<<< $label: FAIL"
+    status=1
+  fi
+  echo
+}
+
+run_gate "twin-map" "$SCRIPT_DIR/check-preset-twin-map.sh"
+run_gate "token-budget" "$SCRIPT_DIR/check-preset-token-budget.sh"
+run_gate "leakage" "$SCRIPT_DIR/check-preset-leakage.sh"
+run_gate "hook-only-lifecycle" "$SCRIPT_DIR/check-hook-only-lifecycle.sh"
+run_gate "shared-core-drift" "$SCRIPT_DIR/check-shared-core-drift.sh" AI_RULES_DRIFT_FAIL=1
+run_gate "i18n" "$SCRIPT_DIR/check-preset-i18n.sh" AI_RULES_I18N_FAIL=1 AI_RULES_I18N_SOFT=0
+
+echo ">>> cli-mcp-merge"
+if node "$SCRIPT_DIR/test-cli-mcp-merge.mjs"; then
+  echo "<<< cli-mcp-merge: OK"
+else
+  echo "<<< cli-mcp-merge: FAIL"
+  status=1
+fi
+echo
+
+# Soft WARN: dogfood product-specs (never fails the orchestrator).
+# Default check-product-specs exits 0 even when issues are found unless --strict.
+# Use --strict here only to surface problems as WARN in logs; do not flip status.
+DOGFOOD_SPECS_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)/dogfood/mcp-ts-sample"
+echo ">>> product-specs (dogfood soft WARN)"
+if [[ -d "$DOGFOOD_SPECS_ROOT/docs/specs" ]]; then
+  if bash "$SCRIPT_DIR/check-product-specs.sh" --strict "$DOGFOOD_SPECS_ROOT"; then
+    echo "<<< product-specs (dogfood soft WARN): OK"
+  else
+    echo "<<< product-specs (dogfood soft WARN): WARN (issues logged; not a hard gate — re-run with yarn check:product-specs:dogfood -- --strict locally)"
+  fi
+else
+  echo "<<< product-specs (dogfood soft WARN): SKIP (no $DOGFOOD_SPECS_ROOT/docs/specs)"
+fi
+echo
+
+if [[ "$status" -ne 0 ]]; then
+  echo "Result: FAIL (one or more hard gates)"
+  exit 1
+fi
+
+echo "Result: OK (all hard gates passed)"
+exit 0

package/scripts/check-preset-token-budget.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# FAIL if session-start / alwaysApply budget invariants break (Option A).
+# Exit 0 on OK; exit 1 on any FAIL.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+export AI_RULES_PRESETS_ROOT="$ROOT/packages/ai-rules/presets"
+
+python3 <<'PY'
+from __future__ import annotations
+
+import os
+import re
+import sys
+from pathlib import Path
+
+presets = Path(os.environ["AI_RULES_PRESETS_ROOT"])
+STACKS = ("next", "nuxt", "svelte", "ios-swift", "android-kotlin", "go", "java", "mcp-ts", "php-hexagonal", "php-laravel")
+BODY_CAP = 140
+MARKER_LINE_RE = re.compile(r"^<!--\s*shared-core:\s*[^>]+?\s*-->\s*$")
+ALWAYS_APPLY_RE = re.compile(r"(?m)^alwaysApply:\s*true\s*$")
+PATHS_RE = re.compile(r"(?m)^paths:\s*")
+
+
+def strip_frontmatter(text: str) -> tuple[str, str]:
+    """Return (frontmatter_or_empty, body)."""
+    if not text.startswith("---\n"):
+        return "", text
+    end = text.find("\n---\n", 4)
+    if end < 0:
+        return "", text
+    return text[4:end], text[end + 5 :]
+
+
+def body_nonempty_lines(body: str) -> int:
+    n = 0
+    for line in body.splitlines():
+        if MARKER_LINE_RE.match(line.strip()):
+            continue
+        if line.strip():
+            n += 1
+    return n
+
+
+def cursor_always_apply(rules_dir: Path) -> list[Path]:
+    out: list[Path] = []
+    for path in sorted(rules_dir.glob("*.mdc")):
+        text = path.read_text(encoding="utf-8")
+        fm, _ = strip_frontmatter(text)
+        if ALWAYS_APPLY_RE.search(fm):
+            out.append(path)
+    return out
+
+
+def claude_session_start(rules_dir: Path) -> list[Path]:
+    """Rules without paths:, excluding **/README.md (Option A)."""
+    out: list[Path] = []
+    for path in sorted(rules_dir.rglob("*.md")):
+        if path.name == "README.md":
+            continue
+        text = path.read_text(encoding="utf-8")
+        fm, _ = strip_frontmatter(text)
+        if PATHS_RE.search(fm):
+            continue
+        out.append(path)
+    return out
+
+
+failed = 0
+
+print("Preset token / session-start budget (Option A)")
+print(f"Presets: {presets}")
+print(f"Body line cap (trio sum): {BODY_CAP}")
+print()
+
+for stack in STACKS:
+    print(f"=== {stack} ===")
+    cursor_rules = presets / "cursor" / stack / "rules"
+    claude_rules = presets / "claude" / stack / "rules"
+
+    # --- Cursor alwaysApply ---
+    always = cursor_always_apply(cursor_rules)
+    print(f"  Cursor alwaysApply: {len(always)}")
+    for p in always:
+        print(f"    - {p.name}")
+        if p.stem.startswith("preset-"):
+            print(f"FAIL: meta preset-* must not be alwaysApply: {p.name}")
+            failed += 1
+
+    if len(always) != 3:
+        print(f"FAIL: Cursor alwaysApply count is {len(always)}, expected exactly 3")
+        failed += 1
+
+    # --- Claude no-paths (excl README) ---
+    session = claude_session_start(claude_rules)
+    print(f"  Claude no-paths (excl README): {len(session)}")
+    for p in session:
+        rel = p.relative_to(claude_rules).as_posix()
+        print(f"    - {rel}")
+        if p.stem.startswith("preset-") or "/preset-" in f"/{rel}":
+            print(f"FAIL: meta preset-* must not be session-start: {rel}")
+            failed += 1
+
+    if len(session) != 3:
+        print(
+            f"FAIL: Claude session-start count is {len(session)}, "
+            "expected exactly 3 (Option A excludes **/README.md)"
+        )
+        failed += 1
+
+    # --- Body sum of intended trio (Cursor alwaysApply + Claude session) ---
+    # Prefer Cursor trio for budget; also check Claude trio independently.
+    for label, files in (("Cursor", always), ("Claude", session)):
+        if len(files) != 3:
+            continue
+        total = 0
+        for path in files:
+            text = path.read_text(encoding="utf-8")
+            _, body = strip_frontmatter(text)
+            n = body_nonempty_lines(body)
+            total += n
+            name = path.name if label == "Cursor" else path.relative_to(claude_rules).as_posix()
+            print(f"  {label} body lines {name}: {n}")
+        print(f"  {label} trio body sum: {total}")
+        if total > BODY_CAP:
+            print(
+                f"FAIL: {label} session-start body sum {total} > {BODY_CAP} ({stack})"
+            )
+            failed += 1
+
+    print()
+
+if failed:
+    print(f"Result: FAIL ({failed} issue(s))")
+    sys.exit(1)
+
+print("Result: OK")
+sys.exit(0)
+PY