prizmkit 1.1.139 → 1.1.141

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -23,24 +23,30 @@ Usage:
 """
 
 import argparse
-import glob
-import hashlib
 import json
 import os
 import re
-import subprocess
 import sys
 
 from utils import enrich_global_context, helper_replacements, load_json_file, resolve_prompt_platform, setup_logging
 from continuation import add_continuation_args, append_continuation_handoff, is_continuation
-from prompt_framework import browser_enabled_from_item, checkpoint_group, checkpoint_skip, checkpoint_step, detect_dev_server_port, generate_checkpoint_from_sections, merge_checkpoint_state as merge_shared_checkpoint_state, pipeline_checkpoint_metadata, route_pipeline_repair
+from prompt_framework import (
+    artifact_exists,
+    browser_enabled_from_item,
+    checkpoint_group,
+    checkpoint_skip,
+    checkpoint_step,
+    completed_test_artifacts_valid,
+    detect_dev_server_port,
+    generate_checkpoint_from_sections,
+    merge_checkpoint_state as merge_shared_checkpoint_state,
+    pipeline_checkpoint_metadata,
+    route_pipeline_repair,
+)
 
 
 DEFAULT_MAX_RETRIES = 3
 MAX_OUTER_REPAIR_ROUNDS = 3
-EVIDENCE_FINAL_RECORDS = {"validation.json", "verdict.json", "test-report.md"}
-EVIDENCE_SHA256_RE = re.compile(r"^[a-f0-9]{64}$")
-EVIDENCE_TARGET_HASH_KEYS = ("source", "tests", "contracts", "lockfiles", "environment", "plan")
 
 LOGGER = setup_logging("generate-bootstrap-prompt")
 
@@ -684,10 +690,8 @@ SECTION_TO_SKILL = {
     "phase-implement": checkpoint_step("prizmkit-implement", "Implement", []),
     "phase-prizmkit-test": checkpoint_step(
         "prizmkit-test", "Scoped Feature Test Gate",
-        [".prizmkit/specs/{slug}/test-report-path.txt",
-         ".prizmkit/test/evidence/*/manifest.json",
-         ".prizmkit/test/evidence/*/verdict.json",
-         ".prizmkit/test/evidence/*/validation.json"],
+        [".prizmkit/specs/{slug}/test-report.md",
+         ".prizmkit/specs/{slug}/test-result.json"],
     ),
     "phase-review": checkpoint_step("prizmkit-code-review", "Code Review", []),
     "phase-browser": checkpoint_step("browser-verification", "Browser Verification", []),
@@ -707,817 +711,30 @@ def _resolve_artifacts(artifact_templates, slug):
     return [a.replace("{slug}", slug) for a in artifact_templates]
 
 
-def _artifact_exists(project_root, artifact):
-    """Return whether an artifact path or glob exists under project_root."""
-    full_path = os.path.join(project_root, artifact)
-    if glob.has_magic(full_path):
-        return bool(glob.glob(full_path))
-    return os.path.exists(full_path)
-
-
-def _read_text(path):
-    """Read a UTF-8 text file, returning an empty string on IO errors."""
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            return f.read()
-    except IOError:
-        return ""
-
-
-def _canonical_sha256(value):
-    """Return the protocol's compact, key-sorted JSON SHA-256."""
-    payload = json.dumps(
-        value, ensure_ascii=False, sort_keys=True, separators=(",", ":"),
-    )
-    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
-
-
-def _file_sha256(path):
-    """Hash a file without loading large evidence records into memory."""
-    digest = hashlib.sha256()
-    try:
-        with open(path, "rb") as f:
-            for chunk in iter(lambda: f.read(1024 * 1024), b""):
-                digest.update(chunk)
-    except OSError:
-        return ""
-    return digest.hexdigest()
-
-
-def _load_strict_json(path):
-    """Load JSON while rejecting duplicate keys and non-JSON constants."""
-    def reject_duplicates(pairs):
-        result = {}
-        for key, value in pairs:
-            if key in result:
-                raise ValueError("duplicate object key: {}".format(key))
-            result[key] = value
-        return result
-
-    def reject_constant(value):
-        raise ValueError("non-JSON numeric constant: {}".format(value))
-
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            return json.load(
-                f, object_pairs_hook=reject_duplicates,
-                parse_constant=reject_constant,
-            )
-    except (OSError, ValueError, TypeError):
-        return None
-
-
-def _is_sha256(value):
-    return isinstance(value, str) and bool(EVIDENCE_SHA256_RE.fullmatch(value))
-
-
-def _path_is_within(root, candidate):
-    """Return whether candidate resolves below root without escaping it."""
-    try:
-        return os.path.commonpath([
-            os.path.realpath(root), os.path.realpath(candidate),
-        ]) == os.path.realpath(root)
-    except ValueError:
-        return False
-
-
-def _resolve_test_evidence_validator(project_root):
-    """Return the installed validator path used by the current project."""
-    candidates = [
-        os.path.join(
-            project_root, ".claude", "command-assets", "prizmkit-test",
-            "scripts", "validate_test_evidence.py",
-        ),
-        os.path.join(
-            project_root, ".agents", "skills", "prizmkit-test", "scripts",
-            "validate_test_evidence.py",
-        ),
-        os.path.join(
-            project_root, ".codebuddy", "skills", "prizmkit-test", "scripts",
-            "validate_test_evidence.py",
-        ),
-    ]
-    return next((path for path in candidates if os.path.isfile(path)), "")
-
-
-def _evidence_validator_passes(project_root, evidence_root, validation):
-    """Re-run the authoritative L1 validator before accepting any verdict."""
-    validator_path = _resolve_test_evidence_validator(project_root)
-    if (not validator_path or
-            validation.get("validator_sha256") != _file_sha256(validator_path)):
-        return False
-    try:
-        result = subprocess.run(
-            [sys.executable, validator_path,
-             "--evidence-dir", evidence_root,
-             "--project-root", project_root],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            timeout=120,
-            check=False,
-        )
-    except (OSError, subprocess.SubprocessError):
-        return False
-    return result.returncode == 0
-
-
-def _evidence_package_from_pointer(project_root, pointer_artifact):
-    """Resolve a Feature report pointer to the structured evidence package."""
-    pointer_path = os.path.join(project_root, pointer_artifact)
-    pointed = _read_text(pointer_path).strip().splitlines()
-    if not pointed:
-        return None, None
-
-    report_path = pointed[0].strip()
-    if not os.path.isabs(report_path):
-        report_path = os.path.join(project_root, report_path)
-    evidence_root = os.path.dirname(report_path)
-    expected_root = os.path.join(project_root, ".prizmkit", "test", "evidence")
-    if not _path_is_within(expected_root, evidence_root):
-        return None, None
-    relative_root = os.path.relpath(evidence_root, expected_root)
-    if (not relative_root or relative_root.startswith("..") or
-            os.sep in relative_root):
-        return None, None
-    if os.path.basename(report_path) != "test-report.md":
-        return None, None
-    if not os.path.isfile(report_path):
-        return None, None
-    return os.path.realpath(evidence_root), os.path.realpath(report_path)
-
-
-def _manifest_entries(evidence_root, manifest):
-    """Validate the manifest file list and return path -> entry."""
-    entries = manifest.get("files")
-    if not isinstance(entries, list):
-        return None
-    result = {}
-    for entry in entries:
-        if not isinstance(entry, dict):
-            return None
-        relative = entry.get("path")
-        if (not isinstance(relative, str) or not relative or
-                os.path.isabs(relative) or relative in result or
-                ".." in relative.split("/") or "\\" in relative):
-            return None
-        path = os.path.join(evidence_root, relative)
-        if not _path_is_within(evidence_root, path) or not os.path.isfile(path):
-            return None
-        if not _is_sha256(entry.get("sha256")):
-            return None
-        if not isinstance(entry.get("produced_by"), str) or not entry["produced_by"].strip():
-            return None
-        if _file_sha256(path) != entry["sha256"]:
-            return None
-        result[relative] = entry
-
-    actual = set()
-    for root, _dirs, files in os.walk(evidence_root):
-        for filename in files:
-            relative = os.path.relpath(os.path.join(root, filename), evidence_root)
-            if relative != "manifest.json":
-                actual.add(relative)
-    return result if set(result) == actual else None
-
-
-def _extract_report_scope(report_text):
-    """Read only the derived report's artifact identity, never its verdict."""
-    in_scope = False
-    for raw_line in report_text.splitlines():
-        line = raw_line.strip()
-        if line == "## Scope":
-            in_scope = True
-            continue
-        if in_scope and line.startswith("## "):
-            break
-        if in_scope and line.startswith("- Artifact Dir:"):
-            return line.split(":", 1)[1].strip()
-    return ""
-
-
-def _validate_target_hashes(evidence_root, project_root, manifest, entry_map):
-    """Validate live inventoried files against the manifest target hashes."""
-    inventory_path = os.path.join(evidence_root, "target-inventory.json")
-    environment_path = os.path.join(evidence_root, "environment.json")
-    inventory = _load_strict_json(inventory_path)
-    environment = _load_strict_json(environment_path)
-    if not isinstance(inventory, dict) or not isinstance(environment, dict):
-        return False
-    if "target-inventory.json" not in entry_map or "environment.json" not in entry_map:
-        return False
-
-    categories = inventory.get("categories")
-    expected = set(EVIDENCE_TARGET_HASH_KEYS[:4])
-    if not isinstance(categories, dict) or set(categories) != expected:
-        return False
-    aggregates = {}
-    for category in sorted(expected):
-        records = categories.get(category)
-        if not isinstance(records, list):
-            return False
-        normalized = []
-        for record in records:
-            if not isinstance(record, dict):
-                return False
-            relative = record.get("path")
-            expected_hash = record.get("sha256")
-            if (not isinstance(relative, str) or os.path.isabs(relative) or
-                    not _is_sha256(expected_hash)):
-                return False
-            live_path = os.path.join(project_root, relative)
-            if (not _path_is_within(project_root, live_path) or
-                    not os.path.isfile(live_path) or
-                    _file_sha256(live_path) != expected_hash):
-                return False
-            normalized.append({"path": relative, "sha256": expected_hash})
-        aggregates[category] = _canonical_sha256(
-            sorted(normalized, key=lambda item: item["path"]),
-        )
-
-    aggregates["environment"] = _canonical_sha256(environment)
-    plan_inputs = inventory.get("plan_inputs")
-    if not isinstance(plan_inputs, dict) or not plan_inputs:
-        return False
-    aggregates["plan"] = _canonical_sha256(plan_inputs)
-    target_hashes = manifest.get("target_hashes")
-    return target_hashes == aggregates
-
-
-def validate_feature_test_evidence(project_root, artifact_dir):
-    """Return structured Feature test evidence, or None when it is unsafe."""
-    pointer_artifact = os.path.join(artifact_dir, "test-report-path.txt")
-    evidence_root, report_path = _evidence_package_from_pointer(
-        project_root, pointer_artifact,
-    )
-    if not evidence_root or not report_path:
-        return None
-
-    marker_path = os.path.join(project_root, artifact_dir, ".prizmkit-test-started")
-    if not os.path.isfile(marker_path):
-        return None
-    try:
-        if os.path.getmtime(report_path) < os.path.getmtime(marker_path):
-            return None
-    except OSError:
-        return None
-
-    manifest = _load_strict_json(os.path.join(evidence_root, "manifest.json"))
-    verdict = _load_strict_json(os.path.join(evidence_root, "verdict.json"))
-    validation = _load_strict_json(os.path.join(evidence_root, "validation.json"))
-    if not all(isinstance(record, dict) for record in (manifest, verdict, validation)):
-        return None
-    entry_map = _manifest_entries(evidence_root, manifest)
-    if entry_map is None or not {"verdict.json", "validation.json"}.issubset(entry_map):
-        return None
-
-    identity = manifest.get("evidence_id_inputs")
-    evidence_id = manifest.get("evidence_id")
-    if (not isinstance(identity, dict) or not _is_sha256(identity.get("working_diff_sha256")) or
-            not _is_sha256(identity.get("scope_sha256")) or
-            not isinstance(identity.get("baseline_commit"), str) or
-            evidence_id != _canonical_sha256(identity) or
-            os.path.basename(evidence_root) != evidence_id):
-        return None
-    if (manifest.get("protocol_version") != "1.0" or
-            manifest.get("sensitivity") != "project-controlled" or
-            manifest.get("environment_claim") != "mocked-code-level-only" or
-            manifest.get("compatibility") != "legacy-test-report-interface-not-supported" or
-            manifest.get("final_verdict") not in {"TEST_PASS", "TEST_FAIL", "TEST_BLOCKED"}):
-        return None
-    stages = manifest.get("stages")
-    stage_names = [stage.get("name") for stage in stages] if isinstance(stages, list) else []
-    if stage_names != [
-            "CHANGE_CLASSIFY", "SCOPE_DISCOVER", "CONTRACT_MODEL", "TEST_PLAN",
-            "INFRA_READY", "TEST_BUILD", "EXECUTE_PROVE", "EVIDENCE_PACKAGE",
-            "EVIDENCE_VALIDATE"]:
-        return None
-    for stage in stages:
-        if (not isinstance(stage, dict) or stage.get("status") not in {"complete", "not_applicable"} or
-                not isinstance(stage.get("outputs"), list)):
-            return None
-    if (not _is_sha256(manifest.get("working_diff_sha256")) or
-            manifest.get("working_diff_sha256") != identity.get("working_diff_sha256")):
-        return None
-
-    final_verdict = manifest["final_verdict"]
-    if (verdict.get("verdict") != final_verdict or
-            verdict.get("testing_domain_only") is not True or
-            verdict.get("authorizes_commit_or_release") is not False or
-            verdict.get("real_environment_validated") is not False or
-            verdict.get("repairs_business_defects") is not False or
-            not isinstance(verdict.get("blockers"), list) or
-            not isinstance(verdict.get("reproduced_failures"), list)):
-        return None
-    if final_verdict == "TEST_PASS" and (
-            verdict.get("code_evidence_replayable") is not True or
-            verdict.get("blockers") or verdict.get("reproduced_failures")):
-        return None
-    if final_verdict == "TEST_FAIL" and not verdict.get("reproduced_failures"):
-        return None
-    if final_verdict == "TEST_BLOCKED" and not verdict.get("blockers"):
-        return None
-
-    payload = sorted(
-        ({"path": path, "sha256": entry["sha256"]}
-         for path, entry in entry_map.items()
-         if path not in EVIDENCE_FINAL_RECORDS),
-        key=lambda item: item["path"],
-    )
-    if (validation.get("validator") != "validate_test_evidence.py" or
-            not _is_sha256(validation.get("validator_sha256")) or
-            validation.get("payload_sha256") != _canonical_sha256(payload) or
-            validation.get("result") != "passed" or
-            validation.get("verdict") != final_verdict or
-            validation.get("semantics") != "integrity-and-protocol-validation-not-hostile-producer-proof" or
-            not isinstance(validation.get("replay_receipt_ids"), list)):
-        return None
-    if not _evidence_validator_passes(project_root, evidence_root, validation):
-        return None
-
-    report_scope = _normalize_artifact_dir(_extract_report_scope(_read_text(report_path)))
-    expected_scope = _normalize_artifact_dir(artifact_dir)
-    if report_scope != expected_scope:
-        return None
-    if not _validate_target_hashes(evidence_root, project_root, manifest, entry_map):
-        return None
-    scope = _load_strict_json(os.path.join(evidence_root, "scope.json"))
-    if not isinstance(scope, dict) or identity.get("scope_sha256") != _canonical_sha256(scope):
-        return None
-
-    state_path = os.path.join(
-        project_root, ".prizmkit", "state", "workflows",
-        os.path.basename(artifact_dir) + ".json",
-    )
-    state = _load_strict_json(state_path) if os.path.isfile(state_path) else {}
-    if state and (not isinstance(state, dict) or state.get("stage_result") not in {None, final_verdict, "TEST_PASS", "TEST_FAIL", "TEST_BLOCKED"}):
-        return None
-    return {
-        "evidence_id": evidence_id,
-        "evidence_dir": os.path.relpath(evidence_root, project_root),
-        "manifest_path": os.path.relpath(os.path.join(evidence_root, "manifest.json"), project_root),
-        "verdict_path": os.path.relpath(os.path.join(evidence_root, "verdict.json"), project_root),
-        "validation_path": os.path.relpath(os.path.join(evidence_root, "validation.json"), project_root),
-        "verdict": final_verdict,
-        "repair_scope": state.get("repair_scope") if isinstance(state, dict) else None,
-        "repair_round": state.get("repair_round", 0) if isinstance(state, dict) else 0,
-        "target_hashes": manifest.get("target_hashes"),
-    }
-
-
 def route_feature_repair(stage_result, repair_scope=None, repair_round=0):
     """Map Feature review/test outcomes to the shared safe route contract."""
     return route_pipeline_repair(stage_result, repair_scope, repair_round)
 
 
-def feature_checkpoint_metadata(artifact_dir, evidence=None, stage="plan",
+def feature_checkpoint_metadata(artifact_dir, stage="plan",
                                 status="PLAN_READY", stage_result=None,
                                 repair_scope=None, repair_round=0,
                                 next_stage="prizmkit-implement",
                                 resume_from="prizmkit-implement"):
-    """Build Feature L4 handoff metadata through the shared semantic contract."""
+    """Build Feature caller handoff metadata through the shared semantic contract."""
     return pipeline_checkpoint_metadata(
-        artifact_dir, evidence=evidence, stage=stage, status=status,
+        artifact_dir, stage=stage, status=status,
         stage_result=stage_result, repair_scope=repair_scope,
         repair_round=repair_round, next_stage=next_stage,
         resume_from=resume_from,
     )
 
 
-def _normalize_artifact_dir(path):
-    """Normalize report artifact_dir values for comparison."""
-    return path.strip().replace("\\", "/").rstrip("/")
-
-
-def _report_path_matches_artifacts(project_root, report_path, artifacts):
-    """Return whether report_path is an in-project test report artifact."""
-    test_root = os.path.realpath(
-        os.path.join(project_root, ".prizmkit", "test")
-    )
-    resolved_report = os.path.realpath(report_path)
-
-    try:
-        if os.path.commonpath([test_root, resolved_report]) != test_root:
-            return False
-    except ValueError:
-        return False
-
-    report_artifacts = [a for a in artifacts if a.endswith("test-report.md")]
-    for artifact in report_artifacts:
-        artifact_path = os.path.join(project_root, artifact)
-        if glob.has_magic(artifact_path):
-            candidates = glob.glob(artifact_path)
-        else:
-            candidates = [artifact_path]
-        for candidate in candidates:
-            if os.path.realpath(candidate) == resolved_report:
-                return True
-    return False
-
-
-def _extract_scope_field(report_text, field_name):
-    """Extract a '- Field: value' entry from the report Scope section."""
-    in_scope = False
-    prefix = "- {}:".format(field_name)
-    for raw_line in report_text.splitlines():
-        line = raw_line.strip()
-        if line == "## Scope":
-            in_scope = True
-            continue
-        if in_scope and line.startswith("## "):
-            break
-        if in_scope and line.startswith(prefix):
-            return line[len(prefix):].strip()
-    return ""
-
-
-def _extract_report_verdict(report_text):
-    """Extract the first non-empty line after the report Verdict heading."""
-    in_verdict = False
-    for raw_line in report_text.splitlines():
-        line = raw_line.strip()
-        if line == "## Verdict":
-            in_verdict = True
-            continue
-        if in_verdict:
-            if line.startswith("## "):
-                break
-            if line:
-                return line
-    return ""
-
-
-def _extract_report_section(report_text, heading):
-    """Extract text under a level-2 markdown heading."""
-    in_section = False
-    lines = []
-    for raw_line in report_text.splitlines():
-        line = raw_line.strip()
-        if line == heading:
-            in_section = True
-            continue
-        if in_section and line.startswith("## "):
-            break
-        if in_section:
-            lines.append(raw_line)
-    return "\n".join(lines)
-
-
-def _discover_openapi_file(project_root):
-    """Return the first common OpenAPI/Swagger file under project_root."""
-    candidates = [
-        "openapi.yaml", "openapi.yml", "swagger.yaml", "swagger.yml",
-        "docs/openapi.yaml", "docs/openapi.yml",
-        "docs/swagger.yaml", "docs/swagger.yml",
-        "api/openapi.yaml", "api/openapi.yml",
-        "api/swagger.yaml", "api/swagger.yml",
-    ]
-    for candidate in candidates:
-        full_path = os.path.join(project_root, candidate)
-        if os.path.isfile(full_path):
-            return full_path
-    return ""
-
-
-def _normalize_api_path(path):
-    """Normalize API path tokens for exact comparison."""
-    normalized = path.strip().strip("'\"`")
-    if len(normalized) > 1:
-        normalized = normalized.rstrip("/")
-    return normalized
-
-
-def _extract_openapi_operations(openapi_text):
-    """Extract OpenAPI method+path operations without requiring PyYAML."""
-    methods = {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE"}
-    operations = []
-    in_paths = False
-    paths_indent = 0
-    current_path = ""
-    current_path_indent = 0
-    path_key_re = re.compile(
-        r"^\s*(?:(['\"])(/.*?)\1|(/[^:\s]+))\s*:\s*(?:#.*)?$"
-    )
-    method_re = re.compile(r"^\s*([A-Za-z]+)\s*:\s*(?:#.*)?$")
-
-    for raw_line in openapi_text.splitlines():
-        stripped = raw_line.strip()
-        if not stripped or stripped.startswith("#"):
-            continue
-
-        indent = len(raw_line) - len(raw_line.lstrip())
-        if not in_paths:
-            if re.match(r"^\s*paths\s*:\s*(?:#.*)?$", raw_line):
-                in_paths = True
-                paths_indent = indent
-            continue
-
-        if indent <= paths_indent:
-            break
-
-        path_match = path_key_re.match(raw_line)
-        if path_match:
-            current_path = path_match.group(2) or path_match.group(3) or ""
-            current_path_indent = indent
-            continue
-
-        method_match = method_re.match(raw_line)
-        if current_path and method_match and indent > current_path_indent:
-            method = method_match.group(1).upper()
-            if method in methods:
-                operations.append((method, _normalize_api_path(current_path)))
-
-    return operations
-
-
-def _extract_matrix_operations(rows):
-    """Extract exact method+path tokens from Boundary Matrix rows."""
-    operations = set()
-    path_only = set()
-    token_re = re.compile(
-        r"(?:(\b(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\b)\s+)?(/[^\s,`|)]+)",
-        flags=re.IGNORECASE,
-    )
-    for row in rows:
-        interface = row.get("Interface", "")
-        for match in token_re.finditer(interface):
-            method = match.group(1).upper() if match.group(1) else ""
-            path = _normalize_api_path(match.group(2))
-            if not path:
-                continue
-            if method:
-                operations.add((method, path))
-            else:
-                path_only.add(path)
-    return operations, path_only
-
-
-def _boundary_report_sections_valid(project_root, report_text):
-    """Return whether required boundary sections do not report failure."""
-    required_columns = [
-        "Module",
-        "Interface",
-        "Service Type",
-        "Happy Path",
-        "Request Validation",
-        "Auth / Permission / Ownership",
-        "Domain Invariants",
-        "Collection / Pagination",
-        "Date / Time",
-        "State Transitions",
-        "Dependency Failure",
-        "Response Contract",
-        "N/A Reasons",
-        "Final Status",
-    ]
-    category_columns = [
-        "Happy Path",
-        "Request Validation",
-        "Auth / Permission / Ownership",
-        "Domain Invariants",
-        "Collection / Pagination",
-        "Date / Time",
-        "State Transitions",
-        "Dependency Failure",
-        "Response Contract",
-    ]
-    allowed_final_statuses = {
-        "boundary-covered",
-        "generated-needs-review",
-        "skipped-with-reason",
-    }
-    incomplete_markers = {
-        "boundary-missing",
-        "happy-path-only",
-        "unresolved",
-    }
-
-    matrix_section = _extract_report_section(report_text, "## Boundary Matrix")
-    if not matrix_section:
-        return False
-    matrix_lines = [line.strip() for line in matrix_section.splitlines()
-                    if line.strip().startswith("|")]
-    headers = []
-    rows = []
-    for line in matrix_lines:
-        cells = [cell.strip() for cell in line.strip().strip("|").split("|")]
-        if not headers:
-            if "Interface" in cells and "Final Status" in cells:
-                headers = cells
-            continue
-        if all(re.fullmatch(r":?-{3,}:?", cell) for cell in cells):
-            continue
-        if len(cells) < len(headers):
-            cells.extend([""] * (len(headers) - len(cells)))
-        row = {header: cells[i] if i < len(cells) else ""
-               for i, header in enumerate(headers)}
-        if row.get("Interface", "").strip(".` ") in {"", "..."}:
-            continue
-        rows.append(row)
-
-    if not headers or not rows:
-        return False
-    if any(column not in headers for column in required_columns):
-        return False
-
-    for row in rows:
-        final_status = row.get("Final Status", "").strip().lower()
-        if final_status not in allowed_final_statuses:
-            return False
-        for column in category_columns:
-            if not row.get(column, "").strip():
-                return False
-        for value in row.values():
-            normalized = value.strip().lower()
-            if any(marker in normalized for marker in incomplete_markers):
-                return False
-
-    openapi_file = _discover_openapi_file(project_root)
-    if openapi_file:
-        operations = _extract_openapi_operations(_read_text(openapi_file))
-        matrix_operations, _matrix_path_only = _extract_matrix_operations(rows)
-        for method, path in operations:
-            if (method, path) not in matrix_operations:
-                return False
-
-    gate_section = _extract_report_section(report_text,
-                                           "## Boundary Completion Gate")
-    if not gate_section:
-        return False
-    completion_gate_passed = False
-    boundary_missing_seen = False
-    happy_path_only_seen = False
-    for raw_line in gate_section.splitlines():
-        line = raw_line.strip()
-        match = re.match(r"-?\s*(Boundary-missing|Happy-path-only):\s*(\d+)\s*$",
-                         line, re.IGNORECASE)
-        if match:
-            if match.group(1).lower() == "boundary-missing":
-                boundary_missing_seen = True
-            if match.group(1).lower() == "happy-path-only":
-                happy_path_only_seen = True
-            if int(match.group(2)) > 0:
-                return False
-        if re.match(r"-?\s*Completion gate passed:\s*yes\s*$",
-                    line, re.IGNORECASE):
-            completion_gate_passed = True
-        if re.match(r"-?\s*Completion gate passed:\s*no\b",
-                    line, re.IGNORECASE):
-            return False
-    if not (completion_gate_passed and boundary_missing_seen and
-            happy_path_only_seen):
-        return False
-
-    validation_section = _extract_report_section(report_text,
-                                                 "## Boundary Validation")
-    if not validation_section:
-        return False
-    validator_result = ""
-    for raw_line in validation_section.splitlines():
-        line = raw_line.strip()
-        match = re.match(r"-?\s*Validator result:\s*(\S+)",
-                         line, re.IGNORECASE)
-        if match:
-            validator_result = match.group(1).strip().lower()
-            break
-
-    return validator_result == "passed"
-
-
-def _extract_scope_list(report_text, list_name):
-    """Extract a nested file list from the report Scope section."""
-    in_scope = False
-    in_list = False
-    list_marker = "- {}:".format(list_name)
-    values = []
-    for raw_line in report_text.splitlines():
-        line = raw_line.strip()
-        if line == "## Scope":
-            in_scope = True
-            continue
-        if in_scope and line.startswith("## "):
-            break
-        if not in_scope:
-            continue
-        if line == list_marker:
-            in_list = True
-            continue
-        if in_list:
-            if raw_line.startswith("  -") or raw_line.startswith("\t-"):
-                value = line[2:].strip().strip("`")
-                if value and value not in {"{...}", "..."}:
-                    values.append(value)
-                continue
-            if line.startswith("- "):
-                break
-    return values
-
-
-def _scoped_report_fresh(project_root, pointer_artifact, report_path, report_text):
-    """Return whether the report is newer than the gate marker and in-scope files."""
-    marker_path = os.path.join(
-        project_root,
-        os.path.dirname(pointer_artifact),
-        ".prizmkit-test-started",
-    )
-    if not os.path.exists(marker_path):
-        return False
-
-    try:
-        report_mtime = os.path.getmtime(report_path)
-        marker_mtime = os.path.getmtime(marker_path)
-    except OSError:
-        return False
-
-    if report_mtime < marker_mtime:
-        return False
-
-    project_root_real = os.path.realpath(project_root)
-    source_files = _extract_scope_list(report_text, "In-Scope Source Files")
-    test_files = _extract_scope_list(report_text, "In-Scope Test Files")
-    if not source_files or not test_files:
-        return False
-
-    ignored = {"none", "n/a", "not applicable", "(none)", "{...}", "..."}
-    for listed_file in source_files + test_files:
-        normalized = listed_file.strip().strip("`")
-        if not normalized or normalized.lower() in ignored:
-            return False
-        candidate = (normalized if os.path.isabs(normalized)
-                     else os.path.join(project_root, normalized))
-        candidate_real = os.path.realpath(candidate)
-        try:
-            if os.path.commonpath([project_root_real, candidate_real]) != project_root_real:
-                return False
-        except ValueError:
-            return False
-        if not os.path.isfile(candidate_real):
-            return False
-        if os.path.getmtime(candidate_real) > report_mtime:
-            return False
-
-    return True
-
-
-def _validate_legacy_scoped_test_report(project_root, artifacts):
-    """Validate the legacy Markdown report for old callers only.
-
-    Feature checkpoints must use ``_validate_scoped_test_report`` below; this
-    retained helper is intentionally not used by Feature prompt generation.
-    """
-    pointer_artifacts = [a for a in artifacts
-                         if a.endswith("/test-report-path.txt")]
-    if not pointer_artifacts:
-        return False
-
-    pointer_artifact = pointer_artifacts[0]
-    pointer_path = os.path.join(project_root, pointer_artifact)
-    pointed_report = _read_text(pointer_path).strip().splitlines()
-    if not pointed_report:
-        return False
-
-    report_path = pointed_report[0].strip()
-    if not os.path.isabs(report_path):
-        report_path = os.path.join(project_root, report_path)
-    if not os.path.exists(report_path):
-        return False
-    if not _report_path_matches_artifacts(project_root, report_path, artifacts):
-        return False
-
-    report_text = _read_text(report_path)
-    mode = _extract_scope_field(report_text, "Mode")
-    artifact_dir = _extract_scope_field(report_text, "Artifact Dir")
-    verdict = _extract_report_verdict(report_text)
-
-    expected_artifact_dir = _normalize_artifact_dir(
-        os.path.dirname(pointer_artifact)
-    )
-    actual_artifact_dir = _normalize_artifact_dir(artifact_dir)
-
-    return (mode == "this-change" and
-            actual_artifact_dir == expected_artifact_dir and
-            verdict == "PASS" and
-            _boundary_report_sections_valid(project_root, report_text) and
-            _scoped_report_fresh(project_root, pointer_artifact,
-                                 report_path, report_text))
-
-
-def _validate_scoped_test_report(project_root, artifacts):
-    """Validate current Feature structured evidence, never Markdown authority."""
-    pointer_artifacts = [a for a in artifacts if a.endswith("/test-report-path.txt")]
-    if not pointer_artifacts:
-        return False
-    return validate_feature_test_evidence(
-        project_root, os.path.dirname(pointer_artifacts[0]),
-    ) is not None
-
-
 def _completed_step_artifacts_valid(project_root, skill_key, artifacts):
     """Return whether a completed checkpoint step can be preserved."""
-    if not all(_artifact_exists(project_root, a) for a in artifacts):
-        return False
     if skill_key == "prizmkit-test":
-        return _validate_scoped_test_report(project_root, artifacts)
-    return True
+        return completed_test_artifacts_valid(project_root, artifacts)
+    return all(artifact_exists(project_root, artifact) for artifact in artifacts)
 
 
 def generate_checkpoint_definition(sections, pipeline_mode, workflow_type,
@@ -2257,7 +1474,7 @@ def main():
             checkpoint_dir, "workflow-checkpoint.json",
         )
 
-        # L4 metadata remains separate from the L1 workflow-state contract.
+        # Pipeline metadata remains separate from the skill workflow-state contract.
         checkpoint["feature_state"] = feature_checkpoint_metadata(
             os.path.join(".prizmkit", "specs", feature_slug),
             stage="plan",