prizmkit 1.1.8 → 1.1.9

package/bundled/skills/prizmkit-verify/SKILL.md

@@ -1,281 +0,0 @@
----
-name: "prizmkit-verify"
-description: "Automated framework verification for PrizmKit's 4-layer architecture (Skill → Pipeline → Workflow → Script). Use this skill to validate structural integrity, contract consistency between layers, cross-scenario alignment, and adapter/installer correctness. Trigger whenever: verifying framework health, checking skill contracts, auditing layer integration, running pre-release checks, or after significant framework modifications."
----
-
-# PrizmKit Framework Verification
-
-Verify PrizmKit's four-layer architecture for structural integrity, contract consistency, and cross-scenario alignment.
-
-## Execution Modes
-
-Parse the user's arguments to determine scope and depth:
-
-| Command | What Runs | When to Use |
-|---------|-----------|-------------|
-| `/prizmkit-verify light` | Light checks only (R1-R4) | Quick CI gate, seconds |
-| `/prizmkit-verify medium` | Light + Medium (R1-R4) | Regular development, recommended default |
-| `/prizmkit-verify full` | All rounds (R1-R6) including E2E | Pre-release, after major changes |
-| `/prizmkit-verify --round R1` | Specific round only | Targeted check after editing a layer |
-| `/prizmkit-verify` (no args) | Same as `medium` | Default |
-
-## Architecture Context
-
-PrizmKit has four layers, bottom to top:
-
-```
-L1 Skill layer     → core/skills/prizmkit-skill/         (10 skills, dev lifecycle)
-L2 Pipeline layer   → core/skills/orchestration-skill/pipelines/  (7 skills, planners + launchers)
-L3 Workflow layer   → core/skills/orchestration-skill/workflows/  (4 skills, scenario entry points)
-L4 Script layer     → dev-pipeline/                       (Bash + Python runtime engine)
-```
-
-Three verification depths, cumulative:
-- **Light**: Structural/static checks, scriptable, zero tokens
-- **Medium**: AI reads SKILL.md content, verifies inter-layer contracts
-- **Deep**: End-to-end scenario traces through all 4 layers
-
-## Execution
-
-### Phase 0: Setup
-
-1. Create output directory: `.prizmkit/verify/` (timestamp-based run dir)
-2. Determine which rounds to run based on user args
-3. Initialize the report structure
-
-### Phase 1: Horizontal Verification (R1-R4)
-
-Run rounds sequentially. For each round, run Light first, then Medium if in scope.
-
----
-
-#### R1: L1 Skill Layer
-
-**Target**: All skills in `core/skills/prizmkit-skill/` (expect ~10)
-
-**Light checks** — run `${SKILL_DIR}/scripts/verify-light.py --round R1` if available, otherwise check manually:
-
-| Check | How | Pass Criteria |
-|-------|-----|---------------|
-| Frontmatter validity | Read each SKILL.md YAML header | `name` + `description` present; `name` is lowercase-hyphens; `name` matches directory name |
-| Asset reference integrity | Grep `${SKILL_DIR}` in each SKILL.md, resolve path relative to skill dir | Every referenced file exists on disk |
-| Cross-skill references | Grep `/prizmkit-*` references in each SKILL.md | Every referenced skill exists under `core/skills/` |
-| Orphaned assets | List files in each skill's `assets/`, `scripts/`, `references/` dirs | Every file is referenced by SKILL.md (warn if not) |
-| Lint: ESLint | Run `npm run lint` | 0 errors (warnings OK) |
-| Lint: Ruff | Run `npm run lint:py` | 0 errors |
-
-**Medium checks** — read each SKILL.md FULLY and verify artifact chain contracts:
-
-For each adjacent skill pair in the chain:
-`prizmkit-plan → prizmkit-analyze → prizmkit-implement → prizmkit-code-review → prizmkit-retrospective → prizmkit-committer → prizmkit-deploy`
-
-| Verification Point | What to Check |
-|-------------------|---------------|
-| Output format defined? | Does the producer skill explicitly describe its output structure (file name, format, key sections)? |
-| Input expectation defined? | Does the consumer skill explicitly state what it reads and in what format? |
-| Format match | Do output and input specifications agree on structure, field names, file paths? |
-| Path convention | Do both skills reference the same directory convention (e.g., `.prizmkit/specs/###-feature-name/`)? |
-| Error handling | What happens if upstream artifact is missing or malformed? Is fallback defined? |
-| Quality gate | Does each consumer check preconditions before proceeding? |
-
-Record each pair as: `PASS` / `WARN (gap described)` / `FAIL (mismatch described)`
-
----
-
-#### R2: L2 Pipeline Layer
-
-**Target**: All skills in `core/skills/orchestration-skill/pipelines/` (expect 7)
-
-**Light checks**:
-
-| Check | How | Pass Criteria |
-|-------|-----|---------------|
-| Frontmatter validity | Same as R1 | `name` + `description`; name matches dir |
-| Asset reference integrity | Same as R1 | All `${SKILL_DIR}` refs resolve |
-| Planner→Launcher coupling | For each scenario (feature/bugfix/refactor): check planner mentions correct JSON filename, launcher references correct script | All 3 pairs coupled correctly |
-| Script path references | Launchers reference `dev-pipeline/run-*.sh` | All referenced scripts exist and are executable |
-| Schema consistency | Compare planner SKILL.md output schema with `dev-pipeline/templates/*-list-schema.json` | Field names, types, required fields match |
-| Schema version match | Compare `dev-pipeline/templates/*-list-schema.json` const value with `dev-pipeline/scripts/init-*-pipeline.py` EXPECTED_SCHEMA | Versions identical |
-
-**Medium checks** — read each SKILL.md FULLY:
-
-For each scenario (feature, bugfix, refactor):
-1. What JSON format does the planner produce? What fields, what validation?
-2. What JSON format does the launcher expect? What fields does it read?
-3. Do they match? Any fields the launcher expects but planner doesn't produce?
-4. What command does the launcher assemble? What env vars? Do they match `run-*.sh` expectations?
-
----
-
-#### R3: L3 Workflow Layer
-
-**Target**: All skills in `core/skills/orchestration-skill/workflows/` (expect 4)
-
-**Light checks**:
-
-| Check | How | Pass Criteria |
-|-------|-----|---------------|
-| Frontmatter validity | Same as R1 | `name` + `description`; name matches dir |
-| Pipeline skill references | Grep each workflow for planner/launcher skill names | All referenced pipeline skills exist |
-| Checkpoint naming | Grep for `CP-` patterns | Follows `CP-{XW}-{N}` convention |
-| Flow completeness markers | Each workflow has: When to Use, Execution phases, Error handling table, Relationship table | All sections present |
-
-**Medium checks** — read each SKILL.md FULLY:
-
-| Verification Point | What to Check |
-|-------------------|---------------|
-| Workflow → Pipeline handoff | What does workflow pass to each pipeline skill? Is the input format documented? |
-| Flow completeness | feature-workflow: requirements→planning→launch→monitor? bug-fix-workflow: diagnosis→triage→fix→review→commit? refactor-workflow: goals→planning→launch→monitor? recovery-workflow: detect→diagnose→recover? |
-| Fast path integration | If fast path exists, is there a decision tree for when to use it? |
-| Cross-workflow consistency | Same checkpoint naming, phase structure, error handling patterns? |
-
----
-
-#### R4: L4 Script Layer
-
-**Target**: `dev-pipeline/` directory
-
-**Light checks**:
-
-| Check | How | Pass Criteria |
-|-------|-----|---------------|
-| Shell scripts executable | `ls -la dev-pipeline/*.sh` | All `.sh` files have `+x` permission |
-| Python scripts compile | `python3 -m py_compile` each `.py` file | All compile without error |
-| Bash lib sourcing | Grep `run-*.sh` for `source.*lib/` | Each sources common.sh, heartbeat.sh, branch.sh |
-| JSON templates valid | `python3 -c "import json; json.load(open(f))"` for each `.json` in `templates/` | All parse without error |
-| Ruff Python lint | `ruff check dev-pipeline/scripts/` | 0 errors |
-| Test file existence | List `dev-pipeline/tests/` | At least test files exist for prompt generation |
-
-**Medium checks** — read key scripts:
-
-| Verification Point | What to Check |
-|-------------------|---------------|
-| Shell → Python integration | For each `run-*.sh`: list all Python scripts invoked, verify each exists, verify argument names match |
-| Bootstrap prompt generation | Read `generate-bootstrap-prompt.py` (or per-scenario variant): does it reference correct skill names? Are all `{{PLACEHOLDER}}` variables populated? |
-| State management | Read `init-*-pipeline.py`: correct schema validation? Proper state dir initialization? |
-| Cross-scenario consistency | Compare `run-feature.sh` vs `run-bugfix.sh` vs `run-refactor.sh`: same structure? Same error handling patterns? Note intentional divergences vs unintentional gaps |
-
----
-
-### Phase 2: Vertical E2E Verification (R5-R6)
-
-Only runs in `full` mode. For each scenario, trace data flow through all 4 layers.
-
-#### R5: Feature Scenario
-
-Trace "Add user authentication with JWT" through:
-
-1. **L3→L2**: feature-workflow → feature-planner → feature-pipeline-launcher
-   - What format does workflow pass to planner?
-   - What JSON does planner produce?
-   - What command does launcher assemble?
-
-2. **L2→L4**: feature-pipeline-launcher → run-feature.sh
-   - What args/env vars are passed?
-   - How does init-pipeline.py consume .prizmkit/plans/feature-list.json?
-   - What bootstrap prompt does generate-bootstrap-prompt.py produce?
-
-3. **L4→L1**: run-feature.sh → AI CLI → Skills
-   - What skills does the bootstrap prompt reference?
-   - In what order?
-   - Are skill names correct?
-
-At each transition, verify: **format match**, **field completeness**, **path consistency**, **error propagation**.
-
-#### R6: Bugfix + Refactor Scenarios
-
-Same trace for:
-- Bugfix: "Fix login crash when email is empty"
-- Refactor: "Extract authentication logic into shared module"
-
-Then cross-scenario comparison:
-- Layer transition patterns structurally similar?
-- Schema conventions consistent (F-NNN / B-NNN / R-NNN)?
-- Bootstrap prompt patterns consistent?
-- State management patterns consistent?
-- Intentional divergences documented?
-
----
-
-### Phase 3: Supplementary Checks
-
-These address gaps identified in the first verification run. Include in `medium` and `full` modes.
-
-#### S1: Adapter Layer Verification
-
-| Check | How |
-|-------|-----|
-| Claude adapter output | Run `node adapters/claude/command-adapter.js` on a sample skill, verify output format |
-| CodeBuddy adapter output | Run `node adapters/codebuddy/skill-adapter.js` on same skill, verify output |
-| Cross-platform equivalence | Diff the two outputs for semantic equivalence |
-| ${SKILL_DIR} resolution | Verify Claude resolves to `.claude/command-assets/`, CodeBuddy to `.codebuddy/skills/` |
-
-#### S2: Installer & Distribution Verification
-
-| Check | How |
-|-------|-----|
-| _metadata.json completeness | All skills listed in `core/skills/_metadata.json` suites? |
-| Bundle sync | `npm run bundle && npm run bundle:verify` passes |
-| Skill count | Bundled skill count matches source skill count |
-
-#### S3: Rules Consistency
-
-| Check | How |
-|-------|-----|
-| Rules exist | All files in `core/rules/` referenced by `_rules-metadata.json` |
-| Rule-skill alignment | Rules reference skill names that exist |
-
----
-
-## Report Format
-
-Generate the verification report at `.prizmkit/verify/verify-report-{timestamp}.md`:
-
-```markdown
-# PrizmKit Verification Report
-**Date**: {date}  **Mode**: {light|medium|full}
-
-## Summary
-| Round | Layer | Light | Medium | Deep | Issues |
-|-------|-------|-------|--------|------|--------|
-| R1 | L1 Skill | PASS/WARN/FAIL | PASS/WARN/FAIL | — | count |
-| R2 | L2 Pipeline | ... | ... | — | count |
-| R3 | L3 Workflow | ... | ... | — | count |
-| R4 | L4 Script | ... | ... | — | count |
-| R5 | E2E Feature | — | — | PASS/WARN/FAIL | count |
-| R6 | E2E Bug+Refactor | — | — | PASS/WARN/FAIL | count |
-| S1 | Adapters | ... | ... | — | count |
-| S2 | Distribution | ... | ... | — | count |
-| S3 | Rules | ... | ... | — | count |
-
-## Issues by Severity
-### Critical
-- [C1] Description... (Round, Layer, Location)
-
-### High
-- [H1] Description...
-
-### Medium
-- [M1] Description...
-
-## Cross-Scenario Comparison (full mode only)
-| Dimension | Feature | Bugfix | Refactor | Consistent? |
-|-----------|---------|--------|----------|-------------|
-| ...       | ...     | ...    | ...      | ✅/⚠️      |
-
-## Recommendations
-1. **P0**: ...
-2. **P1**: ...
-```
-
-## Parallelization Strategy
-
-For efficiency, run independent checks concurrently:
-- R1 Light + R2 Light + R3 Light + R4 Light can run in parallel
-- R1 Medium depends on R1 Light passing
-- R5/R6 depend on R1-R4 completing (need full picture of each layer)
-- S1/S2/S3 can run in parallel with R1-R4
-
-## Previous Verification Findings
-
-Reference `docs/framework-verification-report.md` for the baseline findings from the initial verification run. This helps track whether previously identified issues have been resolved.

package/bundled/skills/prizmkit-verify/scripts/verify-light.py

@@ -1,402 +0,0 @@
-#!/usr/bin/env python3
-"""PrizmKit Light Verification Script — static checks for framework integrity.
-
-Usage:
-    python3 verify-light.py                    # Run all rounds
-    python3 verify-light.py --round R1         # Run specific round
-    python3 verify-light.py --round R1 R2 R4   # Run multiple rounds
-"""
-
-import argparse
-import json
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-# --- Configuration ---
-
-PROJECT_ROOT = Path(__file__).resolve().parents[5]  # core/skills/prizmkit-skill/prizmkit-verify/scripts/verify-light.py → root (5 levels up)
-
-SKILL_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "prizmkit-skill"
-PIPELINE_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "orchestration-skill" / "pipelines"
-WORKFLOW_LAYER_DIR = PROJECT_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
-DEV_PIPELINE_DIR = PROJECT_ROOT / "dev-pipeline"
-ALL_SKILLS_DIR = PROJECT_ROOT / "core" / "skills"
-
-# Expected items per layer
-EXPECTED_PIPELINE_SKILLS = {
-    "app-planner", "feature-planner", "bug-planner", "refactor-planner",
-    "feature-pipeline-launcher", "bugfix-pipeline-launcher", "refactor-pipeline-launcher",
-}
-EXPECTED_WORKFLOW_SKILLS = {
-    "feature-workflow", "bug-fix-workflow", "refactor-workflow", "recovery-workflow",
-}
-
-# --- Helpers ---
-
-class Result:
-    def __init__(self):
-        self.passed = 0
-        self.warned = 0
-        self.failed = 0
-        self.details = []
-
-    def ok(self, msg):
-        self.passed += 1
-        self.details.append(("PASS", msg))
-
-    def warn(self, msg):
-        self.warned += 1
-        self.details.append(("WARN", msg))
-
-    def fail(self, msg):
-        self.failed += 1
-        self.details.append(("FAIL", msg))
-
-    @property
-    def status(self):
-        if self.failed > 0:
-            return "FAIL"
-        if self.warned > 0:
-            return "WARN"
-        return "PASS"
-
-    def summary(self):
-        return f"PASS={self.passed} WARN={self.warned} FAIL={self.failed}"
-
-
-def parse_frontmatter(skill_md_path):
-    """Extract YAML frontmatter from SKILL.md."""
-    text = skill_md_path.read_text(encoding="utf-8")
-    match = re.match(r"^---\n(.*?)\n---", text, re.DOTALL)
-    if not match:
-        return {}
-    fm = {}
-    for line in match.group(1).split("\n"):
-        if ":" in line:
-            key, val = line.split(":", 1)
-            fm[key.strip()] = val.strip().strip('"').strip("'")
-    return fm
-
-
-def find_skill_dirs(base_dir):
-    """Find all directories containing SKILL.md under base_dir."""
-    return sorted(
-        d for d in base_dir.iterdir()
-        if d.is_dir() and (d / "SKILL.md").exists()
-    )
-
-
-def collect_all_skill_names():
-    """Collect all known skill names across all categories."""
-    names = set()
-    for category_dir in ALL_SKILLS_DIR.iterdir():
-        if not category_dir.is_dir() or category_dir.name.startswith("."):
-            continue
-        # Direct skill dirs
-        for d in category_dir.iterdir():
-            if d.is_dir() and (d / "SKILL.md").exists():
-                names.add(d.name)
-            # Nested (pipelines/, workflows/)
-            if d.is_dir() and not (d / "SKILL.md").exists():
-                for sub in d.iterdir():
-                    if sub.is_dir() and (sub / "SKILL.md").exists():
-                        names.add(sub.name)
-    return names
-
-
-# --- Round Checks ---
-
-def run_r1(result: Result):
-    """R1: L1 Skill Layer Light checks."""
-    print("\n=== R1: L1 Skill Layer ===")
-    skill_dirs = find_skill_dirs(SKILL_LAYER_DIR)
-    all_skill_names = collect_all_skill_names()
-
-    if not skill_dirs:
-        result.fail("No skill directories found in prizmkit-skill/")
-        return
-
-    print(f"  Found {len(skill_dirs)} skills")
-
-    for skill_dir in skill_dirs:
-        skill_name = skill_dir.name
-        skill_md = skill_dir / "SKILL.md"
-
-        # 1. Frontmatter validation
-        fm = parse_frontmatter(skill_md)
-        if not fm.get("name"):
-            result.fail(f"[{skill_name}] Missing 'name' in frontmatter")
-        elif fm["name"] != skill_name:
-            result.fail(f"[{skill_name}] name '{fm['name']}' != dir '{skill_name}'")
-        else:
-            result.ok(f"[{skill_name}] Frontmatter name OK")
-
-        if not fm.get("description"):
-            result.fail(f"[{skill_name}] Missing 'description' in frontmatter")
-        else:
-            result.ok(f"[{skill_name}] Frontmatter description OK")
-
-        # 2. ${SKILL_DIR} reference resolution
-        content = skill_md.read_text(encoding="utf-8")
-        refs = re.findall(r'\$\{SKILL_DIR\}/([^\s`"\')]+)', content)
-        for ref in refs:
-            resolved = skill_dir / ref
-            if resolved.exists():
-                result.ok(f"[{skill_name}] Asset ref '{ref}' exists")
-            else:
-                result.fail(f"[{skill_name}] Asset ref '{ref}' NOT FOUND at {resolved}")
-
-        # 3. Cross-skill references
-        cross_refs = re.findall(r'(?<!\w)/prizmkit-[\w-]+(?=[\s`"\',\)])', content)
-        for ref in cross_refs:
-            ref_name = ref.lstrip("/")
-            if ref_name in all_skill_names:
-                result.ok(f"[{skill_name}] Cross-ref '{ref_name}' exists")
-            else:
-                result.warn(f"[{skill_name}] Cross-ref '{ref_name}' not found as skill dir")
-
-    # 4. ESLint
-    try:
-        lint_result = subprocess.run(
-            ["npm", "run", "lint"], capture_output=True, text=True,
-            cwd=str(PROJECT_ROOT), timeout=30,
-        )
-        errors = len(re.findall(r"(\d+) error[^s]", lint_result.stdout + lint_result.stderr))
-        if lint_result.returncode == 0 or errors == 0:
-            result.ok("ESLint: 0 errors")
-        else:
-            result.fail(f"ESLint: {errors} errors found")
-    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
-        result.warn(f"ESLint: could not run ({e})")
-
-    # 5. Ruff
-    try:
-        ruff_result = subprocess.run(
-            ["npm", "run", "lint:py"], capture_output=True, text=True,
-            cwd=str(PROJECT_ROOT), timeout=30,
-        )
-        if ruff_result.returncode == 0:
-            result.ok("Ruff: all checks passed")
-        else:
-            result.fail(f"Ruff: {ruff_result.stdout.strip()}")
-    except (subprocess.TimeoutExpired, FileNotFoundError) as e:
-        result.warn(f"Ruff: could not run ({e})")
-
-
-def run_r2(result: Result):
-    """R2: L2 Pipeline Layer Light checks."""
-    print("\n=== R2: L2 Pipeline Layer ===")
-    skill_dirs = find_skill_dirs(PIPELINE_LAYER_DIR)
-    found_names = {d.name for d in skill_dirs}
-
-    # Check expected skills present
-    for expected in EXPECTED_PIPELINE_SKILLS:
-        if expected in found_names:
-            result.ok(f"[{expected}] Skill exists")
-        else:
-            result.fail(f"[{expected}] Expected skill NOT FOUND")
-
-    # Frontmatter validation
-    for skill_dir in skill_dirs:
-        fm = parse_frontmatter(skill_dir / "SKILL.md")
-        if fm.get("name") == skill_dir.name and fm.get("description"):
-            result.ok(f"[{skill_dir.name}] Frontmatter OK")
-        else:
-            result.fail(f"[{skill_dir.name}] Frontmatter invalid: {fm}")
-
-    # Schema version consistency
-    scenarios = [
-        ("feature", "feature-list-schema.json", "init-pipeline.py"),
-        ("bugfix", "bug-fix-list-schema.json", "init-bugfix-pipeline.py"),
-        ("refactor", "refactor-list-schema.json", "init-refactor-pipeline.py"),
-    ]
-    for scenario, schema_file, init_script in scenarios:
-        schema_path = DEV_PIPELINE_DIR / "templates" / schema_file
-        init_path = DEV_PIPELINE_DIR / "scripts" / init_script
-
-        if not schema_path.exists():
-            result.fail(f"[{scenario}] Schema file missing: {schema_file}")
-            continue
-        if not init_path.exists():
-            result.fail(f"[{scenario}] Init script missing: {init_script}")
-            continue
-
-        # Extract schema const value
-        try:
-            schema_data = json.loads(schema_path.read_text())
-            schema_const = (
-                schema_data.get("properties", {})
-                .get("$schema", {})
-                .get("const", "NOT_FOUND")
-            )
-        except json.JSONDecodeError:
-            result.fail(f"[{scenario}] Schema file is not valid JSON")
-            continue
-
-        # Extract expected schema from init script
-        init_content = init_path.read_text()
-        match = re.search(r'EXPECTED_SCHEMA\s*=\s*["\']([^"\']+)', init_content)
-        init_expected = match.group(1) if match else "NOT_FOUND"
-
-        if schema_const == init_expected:
-            result.ok(f"[{scenario}] Schema version match: {schema_const}")
-        else:
-            result.fail(f"[{scenario}] Schema version MISMATCH: template={schema_const}, init={init_expected}")
-
-    # Launcher script path references
-    for scenario, script in [("feature", "run-feature.sh"), ("bugfix", "run-bugfix.sh"), ("refactor", "run-refactor.sh")]:
-        script_path = DEV_PIPELINE_DIR / script
-        if script_path.exists() and os.access(script_path, os.X_OK):
-            result.ok(f"[{scenario}] Script {script} exists and executable")
-        elif script_path.exists():
-            result.warn(f"[{scenario}] Script {script} exists but NOT executable")
-        else:
-            result.fail(f"[{scenario}] Script {script} NOT FOUND")
-
-
-def run_r3(result: Result):
-    """R3: L3 Workflow Layer Light checks."""
-    print("\n=== R3: L3 Workflow Layer ===")
-    skill_dirs = find_skill_dirs(WORKFLOW_LAYER_DIR)
-    found_names = {d.name for d in skill_dirs}
-    pipeline_names = {d.name for d in find_skill_dirs(PIPELINE_LAYER_DIR)}
-
-    # Check expected skills
-    for expected in EXPECTED_WORKFLOW_SKILLS:
-        if expected in found_names:
-            result.ok(f"[{expected}] Workflow exists")
-        else:
-            result.fail(f"[{expected}] Expected workflow NOT FOUND")
-
-    for skill_dir in skill_dirs:
-        skill_name = skill_dir.name
-        skill_md = skill_dir / "SKILL.md"
-
-        # Frontmatter
-        fm = parse_frontmatter(skill_md)
-        if fm.get("name") == skill_name and fm.get("description"):
-            result.ok(f"[{skill_name}] Frontmatter OK")
-        else:
-            result.fail(f"[{skill_name}] Frontmatter invalid")
-
-        # Pipeline skill references
-        content = skill_md.read_text(encoding="utf-8")
-        for pipeline_ref in re.findall(r'`([\w-]+-planner|[\w-]+-pipeline-launcher)`', content):
-            if pipeline_ref in pipeline_names:
-                result.ok(f"[{skill_name}] Pipeline ref '{pipeline_ref}' exists")
-            else:
-                result.warn(f"[{skill_name}] Pipeline ref '{pipeline_ref}' not found")
-
-        # Checkpoint naming
-        checkpoints = re.findall(r'CP-\w+-\d+', content)
-        if checkpoints:
-            result.ok(f"[{skill_name}] {len(checkpoints)} checkpoints found (CP-*-N pattern)")
-        else:
-            result.warn(f"[{skill_name}] No checkpoint markers found")
-
-
-def run_r4(result: Result):
-    """R4: L4 Script Layer Light checks."""
-    print("\n=== R4: L4 Script Layer ===")
-
-    # 1. Shell scripts executable
-    for sh_file in sorted(DEV_PIPELINE_DIR.glob("*.sh")):
-        if os.access(sh_file, os.X_OK):
-            result.ok(f"[{sh_file.name}] Executable")
-        else:
-            result.fail(f"[{sh_file.name}] NOT executable")
-
-    # 2. Python scripts compile
-    scripts_dir = DEV_PIPELINE_DIR / "scripts"
-    if scripts_dir.exists():
-        for py_file in sorted(scripts_dir.glob("*.py")):
-            try:
-                subprocess.run(
-                    [sys.executable, "-m", "py_compile", str(py_file)],
-                    capture_output=True, text=True, timeout=10,
-                )
-                result.ok(f"[{py_file.name}] Compiles OK")
-            except subprocess.TimeoutExpired:
-                result.warn(f"[{py_file.name}] Compile check timed out")
-
-    # 3. Bash lib sourcing
-    for run_script in ["run-feature.sh", "run-bugfix.sh", "run-refactor.sh"]:
-        script_path = DEV_PIPELINE_DIR / run_script
-        if not script_path.exists():
-            result.fail(f"[{run_script}] NOT FOUND")
-            continue
-        content = script_path.read_text(encoding="utf-8")
-        for lib in ["common.sh", "heartbeat.sh", "branch.sh"]:
-            if lib in content:
-                result.ok(f"[{run_script}] Sources {lib}")
-            else:
-                result.fail(f"[{run_script}] Does NOT source {lib}")
-
-    # 4. JSON templates valid
-    templates_dir = DEV_PIPELINE_DIR / "templates"
-    if templates_dir.exists():
-        for json_file in sorted(templates_dir.glob("*.json")):
-            try:
-                json.loads(json_file.read_text())
-                result.ok(f"[{json_file.name}] Valid JSON")
-            except json.JSONDecodeError as e:
-                result.fail(f"[{json_file.name}] Invalid JSON: {e}")
-
-    # 5. Test file existence
-    tests_dir = DEV_PIPELINE_DIR / "tests"
-    if tests_dir.exists():
-        test_files = list(tests_dir.glob("test_*.py"))
-        if test_files:
-            result.ok(f"Test files found: {len(test_files)}")
-        else:
-            result.warn("No test_*.py files found in dev-pipeline/tests/")
-    else:
-        result.warn("dev-pipeline/tests/ directory not found")
-
-
-# --- Main ---
-
-def main():
-    parser = argparse.ArgumentParser(description="PrizmKit Light Verification")
-    parser.add_argument("--round", nargs="*", default=["R1", "R2", "R3", "R4"],
-                        help="Rounds to run (R1, R2, R3, R4)")
-    args = parser.parse_args()
-
-    rounds_to_run = [r.upper() for r in args.round]
-    result = Result()
-
-    round_map = {"R1": run_r1, "R2": run_r2, "R3": run_r3, "R4": run_r4}
-
-    for round_name in rounds_to_run:
-        if round_name in round_map:
-            round_map[round_name](result)
-        else:
-            print(f"  Unknown round: {round_name}")
-
-    # Print results
-    print("\n" + "=" * 60)
-    print(f"  RESULT: {result.status}")
-    print(f"  {result.summary()}")
-    print("=" * 60)
-
-    if result.failed > 0:
-        print("\n  FAILURES:")
-        for status, msg in result.details:
-            if status == "FAIL":
-                print(f"    {msg}")
-
-    if result.warned > 0:
-        print("\n  WARNINGS:")
-        for status, msg in result.details:
-            if status == "WARN":
-                print(f"    {msg}")
-
-    print()
-    return 0 if result.failed == 0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())