prizmkit 1.1.140 → 1.1.142

package/bundled/dev-pipeline/tests/test_generate_bootstrap_prompt.py

@@ -1,11 +1,9 @@
 """Tests for generate-bootstrap-prompt.py core functions."""
 
 import json
-import hashlib
 import importlib.util
 import os
 import re
-import time
 from argparse import Namespace
 from pathlib import Path
 
@@ -28,12 +26,12 @@ from generate_bootstrap_prompt import (
     merge_checkpoint_state,
     load_active_agent_prompts,
     validate_rendered,
-    validate_feature_test_evidence,
     route_feature_repair,
     feature_checkpoint_metadata,
     main as generate_bootstrap_main,
 )
 from continuation import append_continuation_handoff, checkpoint_cursor
+from prompt_framework import pipeline_checkpoint_metadata
 from utils import resolve_prompt_platform
 
 REMOVED_MAX_LOG_ENV = "MAX_" + "LOG_SIZE"
@@ -112,197 +110,6 @@ def test_rendered_prompt_validation_rejects_unresolved_control_placeholders():
     assert errors == ["Unreplaced placeholders: {{INIT_SCRIPT_PATH}}"]
 
 
-def scoped_report_text(verdict="PASS", boundary_missing=0,
-                       happy_path_only=0, completion_gate="yes",
-                       validator_result="passed"):
-    """Build a scoped report with a complete boundary contract."""
-    return "\n".join([
-        "# Test Report",
-        "",
-        "## Scope",
-        "- Mode: this-change",
-        "- Artifact Dir: .prizmkit/specs/123-scope-test/",
-        "- In-Scope Source Files:",
-        "  - src/feature.js",
-        "- In-Scope Test Files:",
-        "  - tests/feature.test.js",
-        "",
-        "## Boundary Matrix",
-        "| 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 |",
-        "|--------|-----------|--------------|------------|--------------------|-------------------------------|-------------------|-------------------------|-------------|-------------------|-------------------|-------------------|-------------|--------------|",
-        "| feature | POST /feature | API | covered | covered | covered | covered | covered | covered | covered | covered | covered | none | boundary-covered |",
-        "",
-        "## Boundary Completion Gate",
-        "- Interfaces total: 1",
-        "- Boundary-covered: 1",
-        "- Generated-needs-review: 0",
-        "- Skipped-with-reason: 0",
-        f"- Boundary-missing: {boundary_missing}",
-        f"- Happy-path-only: {happy_path_only}",
-        f"- Completion gate passed: {completion_gate}",
-        "",
-        "## Boundary Validation",
-        "- Validator command: `python3 validate_boundary_report.py`",
-        f"- Validator result: {validator_result}",
-        "- Validator output: Boundary report validation: PASS",
-        "",
-        "## Verdict",
-        verdict,
-        "",
-        "## Final Status",
-        "- All tests passing: yes",
-        f"- Boundary completion gate passed: {completion_gate}",
-        "- Ready for commit: yes",
-        "- Needs human review: None",
-        "",
-    ])
-
-
-def write_fresh_scoped_report(project_root, report_path, report_text=None):
-    """Write marker, in-scope files, and a fresh derived report."""
-    source = project_root / "src" / "feature.js"
-    test = project_root / "tests" / "feature.test.js"
-    marker = project_root / ".prizmkit" / "specs" / "123-scope-test" / ".prizmkit-test-started"
-    source.parent.mkdir(parents=True, exist_ok=True)
-    test.parent.mkdir(parents=True, exist_ok=True)
-    marker.parent.mkdir(parents=True, exist_ok=True)
-    report_path.parent.mkdir(parents=True, exist_ok=True)
-    source.write_text("export const feature = true;\n", encoding="utf-8")
-    test.write_text("test('feature', () => {});\n", encoding="utf-8")
-    marker.write_text("started\n", encoding="utf-8")
-    time.sleep(0.01)
-    report_path.write_text(report_text or scoped_report_text(), encoding="utf-8")
-    return source, test, marker
-
-
-def write_fresh_structured_evidence(project_root):
-    """Create the smallest protocol-shaped, validator-attested pass package."""
-    source, test, marker = write_fresh_scoped_report(
-        project_root,
-        project_root / ".prizmkit" / "test" / "unused" / "test-report.md",
-    )
-    evidence_base = project_root / ".prizmkit" / "test" / "evidence"
-    environment = {}
-    plan_inputs = {"feature": "123-scope-test"}
-    categories = {
-        "source": [{"path": "src/feature.js", "sha256": hashlib.sha256(source.read_bytes()).hexdigest()}],
-        "tests": [{"path": "tests/feature.test.js", "sha256": hashlib.sha256(test.read_bytes()).hexdigest()}],
-        "contracts": [],
-        "lockfiles": [],
-    }
-    target_hashes = {
-        category: hashlib.sha256(json.dumps(
-            sorted(records, key=lambda item: item["path"]),
-            sort_keys=True, separators=(",", ":"),
-        ).encode()).hexdigest()
-        for category, records in categories.items()
-    }
-    target_hashes["environment"] = hashlib.sha256(b"{}").hexdigest()
-    target_hashes["plan"] = hashlib.sha256(json.dumps(
-        plan_inputs, sort_keys=True, separators=(",", ":"),
-    ).encode()).hexdigest()
-    inventory = {
-        "categories": categories,
-        "plan_inputs": plan_inputs,
-    }
-    scope = {"feature": "123-scope-test"}
-    zero_hash = "0" * 64
-    identity = {
-        "baseline_commit": "baseline",
-        "working_diff_sha256": zero_hash,
-        "scope_sha256": hashlib.sha256(json.dumps(
-            scope, sort_keys=True, separators=(",", ":"),
-        ).encode()).hexdigest(),
-    }
-    evidence_id = hashlib.sha256(json.dumps(
-        identity, sort_keys=True, separators=(",", ":"),
-    ).encode()).hexdigest()
-    evidence_root = evidence_base / evidence_id
-    evidence_root.mkdir(parents=True, exist_ok=True)
-    (evidence_root / "environment.json").write_text("{}\n", encoding="utf-8")
-    (evidence_root / "target-inventory.json").write_text(
-        json.dumps(inventory), encoding="utf-8",
-    )
-    (evidence_root / "scope.json").write_text(json.dumps(scope), encoding="utf-8")
-    verdict = {
-        "verdict": "TEST_PASS",
-        "testing_domain_only": True,
-        "authorizes_commit_or_release": False,
-        "real_environment_validated": False,
-        "repairs_business_defects": False,
-        "code_evidence_replayable": True,
-        "blockers": [],
-        "reproduced_failures": [],
-    }
-    (evidence_root / "verdict.json").write_text(json.dumps(verdict), encoding="utf-8")
-    report = scoped_report_text()
-    (evidence_root / "test-report.md").write_text(report, encoding="utf-8")
-    stages = []
-    stage_names = [
-        "CHANGE_CLASSIFY", "SCOPE_DISCOVER", "CONTRACT_MODEL", "TEST_PLAN",
-        "INFRA_READY", "TEST_BUILD", "EXECUTE_PROVE", "EVIDENCE_PACKAGE",
-        "EVIDENCE_VALIDATE",
-    ]
-    for name in stage_names:
-        stages.append({"name": name, "status": "complete", "outputs": []})
-    manifest = {
-        "protocol_version": "1.0",
-        "evidence_id": evidence_id,
-        "evidence_id_inputs": identity,
-        "sensitivity": "project-controlled",
-        "environment_claim": "mocked-code-level-only",
-        "compatibility": "legacy-test-report-interface-not-supported",
-        "change_class": "lightweight",
-        "baseline_commit": "baseline",
-        "working_diff_sha256": zero_hash,
-        "target_hashes": target_hashes,
-        "stages": stages,
-        "files": [],
-        "final_verdict": "TEST_PASS",
-    }
-    file_records = []
-    for path in sorted(evidence_root.rglob("*")):
-        if path.is_file():
-            relative = path.relative_to(evidence_root).as_posix()
-            file_records.append({
-                "path": relative,
-                "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
-                "produced_by": "EVIDENCE_PACKAGE",
-            })
-    payload = sorted(
-        ({"path": item["path"], "sha256": item["sha256"]}
-         for item in file_records
-         if item["path"] not in {"verdict.json", "test-report.md"}),
-        key=lambda item: item["path"],
-    )
-    validation = {
-        "validator": "validate_test_evidence.py",
-        "validator_sha256": zero_hash,
-        "payload_sha256": hashlib.sha256(json.dumps(
-            payload, sort_keys=True, separators=(",", ":"),
-        ).encode()).hexdigest(),
-        "result": "passed",
-        "verdict": "TEST_PASS",
-        "semantics": "integrity-and-protocol-validation-not-hostile-producer-proof",
-        "replay_receipt_ids": [],
-    }
-    (evidence_root / "validation.json").write_text(json.dumps(validation), encoding="utf-8")
-    file_records.append({
-        "path": "validation.json",
-        "sha256": hashlib.sha256((evidence_root / "validation.json").read_bytes()).hexdigest(),
-        "produced_by": "EVIDENCE_VALIDATE",
-    })
-    manifest["files"] = file_records
-    (evidence_root / "manifest.json").write_text(json.dumps(manifest), encoding="utf-8")
-    pointer = project_root / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-    pointer.parent.mkdir(parents=True, exist_ok=True)
-    pointer.write_text(str(evidence_root / "test-report.md"), encoding="utf-8")
-    report_path = evidence_root / "test-report.md"
-    now = time.time()
-    os.utime(marker, (now, now))
-    os.utime(report_path, (now + 1, now + 1))
-    return evidence_root
-
 
 # ---------------------------------------------------------------------------
 # compute_feature_slug
@@ -601,544 +408,196 @@ class TestProcessModeBlocks:
 
 class TestScopedFeatureTestGate:
     @staticmethod
-    def _trust_fixture_validator(monkeypatch):
-        monkeypatch.setattr(
-            "generate_bootstrap_prompt._evidence_validator_passes",
-            lambda _project_root, _evidence_root, _validation: True,
+    def _artifacts(slug="123-scope-test"):
+        return [
+            f".prizmkit/specs/{slug}/test-report.md",
+            f".prizmkit/specs/{slug}/test-result.json",
+        ]
+
+    @staticmethod
+    def _write_result(root, result="TEST_PASS", *, unresolved=None,
+                      review_required=False, review_scope=None):
+        artifact = root / ".prizmkit" / "specs" / "123-scope-test"
+        artifact.mkdir(parents=True, exist_ok=True)
+        (artifact / "test-report.md").write_text(
+            f"# Test Report\n\n## Final Result\n\n- Result: {result}\n",
+            encoding="utf-8",
+        )
+        payload = {
+            "schema_version": 1,
+            "result": result,
+            "report": "test-report.md",
+            "main_review_rounds": 1,
+            "independent_review": {
+                "status": "downgraded",
+                "responses": 0,
+                "downgrade_reason": "read-only continuation capability unavailable",
+                "final_state_rechecked": False,
+            },
+            "repair_rounds": 0,
+            "production_changed": False,
+            "review_required": review_required,
+            "review_scope": review_scope,
+            "unresolved_items": unresolved or [],
+        }
+        (artifact / "test-result.json").write_text(
+            json.dumps(payload), encoding="utf-8",
         )
 
     def test_standard_sections_insert_prizmkit_test_after_review(self):
         sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
         sections = assemble_sections(
-            "standard",
-            str(sections_dir),
-            init_done=True,
-            is_resume=False,
-            browser_enabled=False,
+            "standard", str(sections_dir), init_done=True,
+            is_resume=False, browser_enabled=False,
         )
         names = [name for name, _ in sections]
+        rendered = "\n".join(content for _, content in sections)
 
-        assert "phase-prizmkit-test" in names
         assert names.index("phase-implement") < names.index("phase-review") < names.index("phase-prizmkit-test")
-
-        rendered = "\n".join(content for _, content in sections)
-        assert "prizmkit-test-gate.py" not in rendered
-        assert "{{RUNTIME_HELPER_CMD}} artifact touch .prizmkit/specs/{{FEATURE_SLUG}}/.prizmkit-test-started" in rendered
-        assert "mkdir -p .prizmkit/specs/{{FEATURE_SLUG}}" not in rendered
-        assert "when present" not in rendered
-        assert "Boundary Matrix" in rendered
-        assert "Boundary Completion Gate" in rendered
-        assert "Boundary-missing: 0" in rendered
-        assert "Happy-path-only: 0" in rendered
-        assert "Validator result: passed" in rendered
         assert "/prizmkit-test scope=this-change artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/" in rendered
-        assert ".prizmkit/bugfix/" in rendered  # explicitly forbidden in the gate wording
-        assert ".prizmkit/refactor/" in rendered  # explicitly forbidden in the gate wording
-        assert "latest_test_report=$(python3" not in rendered
-        assert "boundary_columns_ok=$(awk" not in rendered
-        assert "Runs tests using `TEST_CMD` after each task" not in rendered
-        assert "Run the full test suite" not in rendered
-        assert "before code review" not in rendered
-        assert "Precondition: the `prizmkit-test` checkpoint is completed" not in rendered
+        assert "test-report.md" in rendered
+        assert "test-result.json" in rendered
+        assert "TEST_NEEDS_FIXES" in rendered
+        assert ".prizmkit/test/evidence" not in rendered
+        assert "TEST_FAIL" not in rendered
 
     def test_standard_sections_include_central_checkpoint_helper(self):
         sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
         sections = assemble_sections(
-            "standard",
-            str(sections_dir),
-            init_done=True,
-            is_resume=False,
-            browser_enabled=False,
+            "standard", str(sections_dir), init_done=True,
+            is_resume=False, browser_enabled=False,
         )
         rendered = "\n".join(content for _, content in sections)
 
         assert "### Checkpoint Update Helper" in rendered
         assert "{{CHECKPOINT_PYTHON_CMD}}" in rendered
-        assert "python3 .prizmkit/dev-pipeline/scripts/update-checkpoint.py" not in rendered
         assert "--checkpoint-path {{CHECKPOINT_PATH}}" in rendered
-        assert "--step <step-id-or-skill-name>" in rendered
+        assert "--stage-result <optional-domain-result>" in rendered
+        assert "--status completed --stage-result PLAN_READY" in rendered
+        assert "--status completed --stage-result IMPLEMENTED" in rendered
+        assert "--status completed --stage-result REVIEW_PASS" in rendered
+        assert "--status completed --stage-result TEST_PASS" in rendered
+        assert "--status completed --stage-result RETRO_COMPLETE" in rendered
+        assert "--status in_progress --stage-result COMMIT_PENDING" in rendered
+        assert "--status completed --stage-result COMMITTED" in rendered
         assert "Do not hand-edit `workflow-checkpoint.json` directly." in rendered
-        assert "pipeline progress mechanism" not in rendered
-
-    def test_lite_sections_include_review_before_prizmkit_test_and_commit(self):
-        sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
-        sections = assemble_sections(
-            "lite",
-            str(sections_dir),
-            init_done=True,
-            is_resume=False,
-            browser_enabled=False,
-        )
-        names = [name for name, _ in sections]
-
-        assert "phase-prizmkit-test" in names
-        assert "phase-review" in names
-        assert names.index("phase-implement") < names.index("phase-review") < names.index("phase-prizmkit-test") < names.index("phase-commit")
+        assert "authoritative_evidence_paths" not in rendered
 
-    def test_checkpoint_orders_prizmkit_test_after_review(self):
+    def test_checkpoint_orders_test_after_review_with_terminal_artifacts(self):
         sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
         sections = assemble_sections(
-            "standard",
-            str(sections_dir),
-            init_done=True,
-            is_resume=False,
-            browser_enabled=False,
+            "standard", str(sections_dir), init_done=True,
+            is_resume=False, browser_enabled=False,
         )
         checkpoint = generate_checkpoint_definition(
-            sections,
-            pipeline_mode="standard",
-            workflow_type="feature-pipeline",
-            item_id="F-123",
-            item_slug="123-scope-test",
-            session_id="F-123-session",
-            init_done=True,
+            sections, pipeline_mode="standard", workflow_type="feature-pipeline",
+            item_id="F-123", item_slug="123-scope-test",
+            session_id="F-123-session", init_done=True,
         )
         skills = [step["skill"] for step in checkpoint["steps"]]
-
-        assert skills.index("prizmkit-implement") < skills.index("prizmkit-code-review") < skills.index("prizmkit-test")
         test_step = next(step for step in checkpoint["steps"] if step["skill"] == "prizmkit-test")
-        assert test_step["required_artifacts"] == [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/evidence/*/manifest.json",
-            ".prizmkit/test/evidence/*/verdict.json",
-            ".prizmkit/test/evidence/*/validation.json",
-        ]
-
-    def test_merge_resets_completed_prizmkit_test_without_report_artifact(self, tmp_path):
-        existing = {
-            "steps": [
-                {
-                    "id": "S01",
-                    "skill": "prizmkit-test",
-                    "status": "completed",
-                    "required_artifacts": [
-                        ".prizmkit/specs/123-scope-test/test-report-path.txt",
-                        ".prizmkit/test/*/test-report.md",
-                    ],
-                },
-                {"id": "S02", "skill": "prizmkit-code-review", "status": "completed", "required_artifacts": []},
-            ],
-        }
-        fresh = {
-            "steps": [
-                {"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-                    ".prizmkit/specs/123-scope-test/test-report-path.txt",
-                    ".prizmkit/test/*/test-report.md",
-                ]},
-                {"id": "S02", "skill": "prizmkit-code-review", "status": "pending", "required_artifacts": []},
-            ],
-        }
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.parent.mkdir(parents=True, exist_ok=True)
-        pointer.write_text(".prizmkit/test/missing/test-report.md\n", encoding="utf-8")
-
-        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
-
-        assert [step["status"] for step in merged["steps"]] == ["pending", "pending"]
-
-    def test_merge_keeps_completed_prizmkit_test_only_for_scoped_pass_report(self, tmp_path, monkeypatch):
-        self._trust_fixture_validator(monkeypatch)
-        evidence_root = write_fresh_structured_evidence(tmp_path)
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.parent.mkdir(parents=True, exist_ok=True)
-        pointer.write_text(str(evidence_root / "test-report.md") + "\n", encoding="utf-8")
-        existing = {
-            "steps": [
-                {"id": "S01", "skill": "prizmkit-test", "status": "completed", "stage_result": "TEST_PASS", "required_artifacts": [
-                    ".prizmkit/specs/123-scope-test/test-report-path.txt",
-                    ".prizmkit/test/*/test-report.md",
-                ]},
-                {"id": "S02", "skill": "prizmkit-code-review", "status": "completed", "stage_result": "REVIEW_PASS", "required_artifacts": []},
-            ],
-        }
-        fresh = {
-            "steps": [
-                {"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-                    ".prizmkit/specs/123-scope-test/test-report-path.txt",
-                    ".prizmkit/test/*/test-report.md",
-                ]},
-                {"id": "S02", "skill": "prizmkit-code-review", "status": "pending", "required_artifacts": []},
-            ],
-        }
-
-        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
-
-        assert [step["status"] for step in merged["steps"]] == ["completed", "completed"]
-
-    def test_merge_resets_completed_prizmkit_test_for_needs_fixes_report(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        report.parent.mkdir(parents=True)
-        report.write_text(scoped_report_text(verdict="NEEDS_FIXES"), encoding="utf-8")
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.parent.mkdir(parents=True, exist_ok=True)
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-
-        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
-
-        assert merged["steps"][0]["status"] == "pending"
-
-    def test_merge_resets_completed_prizmkit_test_for_absolute_report_outside_project(self, tmp_path):
-        project_root = tmp_path / "project"
-        external_root = tmp_path / "external"
-        in_project_report = project_root / ".prizmkit" / "test" / "run" / "test-report.md"
-        external_report = external_root / "report.md"
-        pointer = project_root / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        for path in (in_project_report.parent, external_report.parent, pointer.parent):
-            path.mkdir(parents=True, exist_ok=True)
-        report_text = "\n".join([
-            "# Test Report",
-            "",
-            "## Scope",
-            "- Mode: this-change",
-            "- Artifact Dir: .prizmkit/specs/123-scope-test/",
-            "",
-            "## Verdict",
-            "PASS",
-            "",
-        ])
-        in_project_report.write_text(report_text, encoding="utf-8")
-        external_report.write_text(report_text, encoding="utf-8")
-        pointer.write_text(f"{external_report}\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-
-        merged = merge_checkpoint_state(existing, fresh, str(project_root))
-
-        assert merged["steps"][0]["status"] == "pending"
-
-    def test_merge_resets_completed_prizmkit_test_for_sibling_workspace_report(self, tmp_path):
-        project_root = tmp_path / "project"
-        sibling_root = tmp_path / "project-sibling"
-        in_project_report = project_root / ".prizmkit" / "test" / "run" / "test-report.md"
-        sibling_report = sibling_root / ".prizmkit" / "test" / "run" / "test-report.md"
-        pointer = project_root / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        for path in (in_project_report.parent, sibling_report.parent, pointer.parent):
-            path.mkdir(parents=True, exist_ok=True)
-        report_text = scoped_report_text()
-        in_project_report.write_text(report_text, encoding="utf-8")
-        sibling_report.write_text(report_text, encoding="utf-8")
-        pointer.write_text(f"{sibling_report}\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-
-        merged = merge_checkpoint_state(existing, fresh, str(project_root))
-
-        assert merged["steps"][0]["status"] == "pending"
-
-    def test_merge_resets_completed_prizmkit_test_for_minimal_boundary_matrix(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        report.parent.mkdir(parents=True)
-        report.write_text(
-            "\n".join([
-                "# Test Report",
-                "",
-                "## Scope",
-                "- Mode: this-change",
-                "- Artifact Dir: .prizmkit/specs/123-scope-test/",
-                "",
-                "## Boundary Matrix",
-                "| Interface | Happy Path | N/A Reasons | Final Status |",
-                "|-----------|------------|-------------|--------------|",
-                "| POST /feature | covered | none | boundary-covered |",
-                "",
-                "## Boundary Completion Gate",
-                "- Interfaces total: 1",
-                "- Boundary-covered: 1",
-                "- Boundary-missing: 0",
-                "- Happy-path-only: 0",
-                "- Completion gate passed: yes",
-                "",
-                "## Boundary Validation",
-                "- Validator result: skipped",
-                "",
-                "## Verdict",
-                "PASS",
-                "",
-            ]),
-            encoding="utf-8",
-        )
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.parent.mkdir(parents=True, exist_ok=True)
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-
-        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
-
-        assert merged["steps"][0]["status"] == "pending"
-
-    def test_merge_resets_completed_prizmkit_test_for_missing_boundary_metrics(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        report_text = scoped_report_text().replace("- Boundary-missing: 0\n", "").replace("- Happy-path-only: 0\n", "")
-        write_fresh_scoped_report(tmp_path, report, report_text)
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.parent.mkdir(parents=True, exist_ok=True)
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
 
-        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
+        assert skills.index("prizmkit-code-review") < skills.index("prizmkit-test")
+        assert test_step["required_artifacts"] == self._artifacts()
 
-        assert merged["steps"][0]["status"] == "pending"
-
-    def test_merge_resets_completed_prizmkit_test_when_marker_newer_than_report(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        _source, _test, marker = write_fresh_scoped_report(tmp_path, report)
-        now = time.time()
-        os.utime(report, (now, now))
-        os.utime(marker, (now + 10, now + 10))
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
+    def test_merge_keeps_only_consistent_test_pass_artifacts(self, tmp_path):
+        self._write_result(tmp_path)
+        existing = {"steps": [{
+            "id": "S01", "skill": "prizmkit-test", "status": "completed",
+            "stage_result": "TEST_PASS", "required_artifacts": self._artifacts(),
+        }]}
+        fresh = {"steps": [{
+            "id": "S01", "skill": "prizmkit-test", "status": "pending",
+            "required_artifacts": self._artifacts(),
+        }]}
 
         merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
 
-        assert merged["steps"][0]["status"] == "pending"
-
-    def test_merge_resets_completed_prizmkit_test_when_in_scope_file_newer_than_report(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        source, _test, _marker = write_fresh_scoped_report(tmp_path, report)
-        now = time.time()
-        os.utime(report, (now, now))
-        os.utime(source, (now + 10, now + 10))
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
+        assert merged["steps"][0]["status"] == "completed"
+        assert merged["steps"][0]["stage_result"] == "TEST_PASS"
+
+    def test_merge_resets_missing_or_non_pass_test_artifacts(self, tmp_path):
+        existing = {"steps": [{
+            "id": "S01", "skill": "prizmkit-test", "status": "completed",
+            "stage_result": "TEST_PASS", "required_artifacts": self._artifacts(),
+        }]}
+        fresh = {"steps": [{
+            "id": "S01", "skill": "prizmkit-test", "status": "pending",
+            "required_artifacts": self._artifacts(),
+        }]}
+        missing = merge_checkpoint_state(existing, fresh, str(tmp_path))
+        assert missing["steps"][0]["status"] == "pending"
+
+        self._write_result(tmp_path, "TEST_NEEDS_FIXES", unresolved=["known correction"])
+        needs_fixes = merge_checkpoint_state(existing, fresh, str(tmp_path))
+        assert needs_fixes["steps"][0]["status"] == "pending"
+
+    def test_merge_rejects_malformed_or_inconsistent_terminal_projection(self, tmp_path):
+        self._write_result(tmp_path)
+        result_path = tmp_path / ".prizmkit/specs/123-scope-test/test-result.json"
+        payload = json.loads(result_path.read_text(encoding="utf-8"))
+        payload["review_required"] = True
+        payload["review_scope"] = None
+        result_path.write_text(json.dumps(payload), encoding="utf-8")
+        existing = {"steps": [{
+            "id": "S01", "skill": "prizmkit-test", "status": "completed",
+            "stage_result": "TEST_PASS", "required_artifacts": self._artifacts(),
+        }]}
+        fresh = {"steps": [{
+            "id": "S01", "skill": "prizmkit-test", "status": "pending",
+            "required_artifacts": self._artifacts(),
+        }]}
 
         merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
 
         assert merged["steps"][0]["status"] == "pending"
 
-    def test_merge_resets_completed_prizmkit_test_without_in_scope_tests(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        report_text = scoped_report_text().replace("- In-Scope Test Files:\n  - tests/feature.test.js\n", "- In-Scope Test Files:\n")
-        write_fresh_scoped_report(tmp_path, report, report_text)
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-
-        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
-
-        assert merged["steps"][0]["status"] == "pending"
-
-    def test_structured_evidence_accepts_current_matching_package(self, tmp_path, monkeypatch):
-        self._trust_fixture_validator(monkeypatch)
-        evidence_root = write_fresh_structured_evidence(tmp_path)
-
-        evidence = validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        )
-
-        assert evidence is not None
-        assert evidence["verdict"] == "TEST_PASS"
-        assert evidence["manifest_path"] == str(
-            (evidence_root / "manifest.json").relative_to(tmp_path),
-        )
-        assert evidence["validation_path"].endswith("/validation.json")
-
-    def test_structured_evidence_requires_authoritative_validator(self, tmp_path, monkeypatch):
-        write_fresh_structured_evidence(tmp_path)
-        monkeypatch.setattr(
-            "generate_bootstrap_prompt._evidence_validator_passes",
-            lambda _project_root, _evidence_root, _validation: False,
-        )
-
-        assert validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        ) is None
-
-    def test_structured_evidence_rejects_legacy_markdown_only_pass(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        write_fresh_scoped_report(tmp_path, report)
-        pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.write_text(str(report), encoding="utf-8")
-
-        assert validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        ) is None
-
-    def test_structured_evidence_rejects_missing_validation(self, tmp_path):
-        evidence_root = write_fresh_structured_evidence(tmp_path)
-        (evidence_root / "validation.json").unlink()
-
-        assert validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        ) is None
-
-    def test_structured_evidence_rejects_tampered_verdict(self, tmp_path, monkeypatch):
-        self._trust_fixture_validator(monkeypatch)
-        evidence_root = write_fresh_structured_evidence(tmp_path)
-        verdict_path = evidence_root / "verdict.json"
-        verdict = json.loads(verdict_path.read_text(encoding="utf-8"))
-        verdict["verdict"] = "TEST_BLOCKED"
-        verdict_path.write_text(json.dumps(verdict), encoding="utf-8")
-
-        assert validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        ) is None
-
-    def test_structured_evidence_rejects_wrong_artifact_scope(self, tmp_path, monkeypatch):
-        self._trust_fixture_validator(monkeypatch)
-        evidence_root = write_fresh_structured_evidence(tmp_path)
-        report_path = evidence_root / "test-report.md"
-        report_path.write_text(
-            scoped_report_text().replace(
-                ".prizmkit/specs/123-scope-test/",
-                ".prizmkit/specs/999-other/",
-            ),
-            encoding="utf-8",
-        )
-
-        assert validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        ) is None
-
-    def test_structured_evidence_rejects_stale_report(self, tmp_path, monkeypatch):
-        self._trust_fixture_validator(monkeypatch)
-        evidence_root = write_fresh_structured_evidence(tmp_path)
-        report = evidence_root / "test-report.md"
-        marker = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / ".prizmkit-test-started"
-        now = time.time()
-        os.utime(report, (now, now))
-        os.utime(marker, (now + 10, now + 10))
-
-        assert validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        ) is None
-
-    def test_structured_evidence_rejects_live_inventory_drift(self, tmp_path, monkeypatch):
-        self._trust_fixture_validator(monkeypatch)
-        write_fresh_structured_evidence(tmp_path)
-        source = tmp_path / "src" / "feature.js"
-        source.write_text("export const feature = false;\n", encoding="utf-8")
-
-        assert validate_feature_test_evidence(
-            str(tmp_path), ".prizmkit/specs/123-scope-test",
-        ) is None
-
-    def test_feature_repair_routing_preserves_review_and_test_boundaries(self):
+    def test_feature_result_routing_stops_test_non_pass_without_outer_repair(self):
         review = route_feature_repair("REVIEW_NEEDS_FIXES", repair_round=0)
-        test_infra = route_feature_repair(
-            "TEST_FAIL", "test-infrastructure", repair_round=1,
-        )
-        production = route_feature_repair("TEST_FAIL", "production", repair_round=1)
+        needs_fixes = route_feature_repair("TEST_NEEDS_FIXES", repair_round=1)
+        blocked = route_feature_repair("TEST_BLOCKED", repair_round=1)
 
         assert review["route"] == [
             "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
         ]
-        assert test_infra["route"] == ["prizmkit-implement", "prizmkit-test"]
-        assert production["route"] == [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-        ]
         assert review["repair_round"] == 1
-
-    def test_feature_repair_routing_blocks_unsafe_and_exhausted_routes(self):
-        unknown = route_feature_repair("TEST_FAIL", "unknown", repair_round=1)
-        blocked = route_feature_repair("TEST_BLOCKED", "production", repair_round=1)
-        exhausted = route_feature_repair("TEST_FAIL", "production", repair_round=3)
-
-        assert unknown["blocked"] is True
-        assert unknown["route"] == []
+        assert needs_fixes["blocked"] is True
+        assert needs_fixes["route"] == []
+        assert needs_fixes["blocked_reason"] == "test_needs_fixes"
         assert blocked["blocked"] is True
-        assert blocked["resumable"] is False
-        assert blocked["next_stage"] is None
-        assert blocked["terminal_status"] == "WORKFLOW_BLOCKED"
         assert blocked["blocked_reason"] == "test_blocked"
-        assert exhausted["blocked"] is True
-        assert exhausted["repair_round"] == 3
-
-    def test_feature_checkpoint_metadata_records_l1_handoff_fields(self):
-        evidence = {
-            "manifest_path": ".prizmkit/test/evidence/id/manifest.json",
-            "verdict_path": ".prizmkit/test/evidence/id/verdict.json",
-            "validation_path": ".prizmkit/test/evidence/id/validation.json",
-        }
+        assert blocked["terminal_status"] == "WORKFLOW_BLOCKED"
 
+    def test_pipeline_checkpoint_metadata_rejects_legacy_or_mismatched_status(self):
+        invalid = [
+            {"status": "TEST_PASS", "stage_result": "TEST_PASS"},
+            {"status": "failed", "stage_result": "TEST_PASS"},
+            {"status": "completed", "stage_result": "UNKNOWN_RESULT"},
+        ]
+
+        for values in invalid:
+            try:
+                pipeline_checkpoint_metadata(
+                    ".prizmkit/specs/contract-test",
+                    stage="test",
+                    **values,
+                )
+            except ValueError:
+                continue
+            raise AssertionError("invalid lifecycle metadata was accepted: {}".format(values))
+
+    def test_feature_checkpoint_metadata_has_no_evidence_paths(self):
         metadata = feature_checkpoint_metadata(
             ".prizmkit/specs/123-scope-test",
-            evidence=evidence,
-            stage="test",
-            status="TEST_FAIL",
-            stage_result="TEST_FAIL",
-            repair_scope="test-infrastructure",
-            repair_round=2,
-            next_stage="prizmkit-implement",
-            resume_from="prizmkit-implement",
+            stage="test", status="failed",
+            stage_result="TEST_NEEDS_FIXES", repair_round=0,
+            next_stage=None, resume_from=None,
         )
 
-        assert metadata == {
-            "schema_version": 1,
-            "artifact_dir": ".prizmkit/specs/123-scope-test",
-            "orchestrator": "prizmkit-l4",
-            "stage": "test",
-            "current_stage": "test",
-            "status": "TEST_FAIL",
-            "stage_result": "TEST_FAIL",
-            "repair_scope": "test-infrastructure",
-            "repair_round": 2,
-            "authoritative_evidence_paths": {
-                "manifest": ".prizmkit/test/evidence/id/manifest.json",
-                "verdict": ".prizmkit/test/evidence/id/verdict.json",
-                "validation": ".prizmkit/test/evidence/id/validation.json",
-            },
-            "next_stage": "prizmkit-implement",
-            "resume_from": "prizmkit-implement",
-            "blocked_reason": None,
-            "terminal_status": None,
-        }
+        assert metadata["status"] == "failed"
+        assert metadata["stage_result"] == "TEST_NEEDS_FIXES"
+        assert "authoritative_evidence_paths" not in metadata
+        assert metadata["artifact_dir"] == ".prizmkit/specs/123-scope-test"
 
 # ---------------------------------------------------------------------------
 # Active compaction harness rollback
@@ -1605,7 +1064,8 @@ class TestFeaturePromptUnifiedFullGuidance:
             assert "### Plan Self-Check — Orchestrator Direct" in prompt
             assert "### Scoped Feature Test Gate — PrizmKit Test" in prompt
             assert "## Test Failure Recovery Protocol" in prompt
-            assert "Boundary Matrix" in prompt
+            assert "test-report.md" in prompt
+            assert "test-result.json" in prompt
             assert "### Browser Verification — MANDATORY" not in prompt
             assert "### TERMINAL STOP — Commit Completed" in prompt
             assert "# Dev-Pipeline Session Bootstrap — Tier 1" not in prompt
@@ -1847,7 +1307,8 @@ class TestHeadlessPromptCleanupF033:
                 assert forbidden not in prompt
             if "Feature ID" in prompt:
                 assert "/prizmkit-test scope=this-change artifact_dir=.prizmkit/specs/123-prompt-cleanup/" in prompt
-                assert ".prizmkit-test-started" in prompt
+                assert "test-report.md" in prompt
+                assert "test-result.json" in prompt
                 assert "{{RUNTIME_HELPER_CMD}}" not in prompt
                 assert "prizmkit-runtime-helper.py" in prompt
             # Anti-Bash guardrails for bugfix/refactor branches (F-039)
@@ -1874,7 +1335,7 @@ class TestHeadlessPromptCleanupF033:
         assert "which playwright-cli" not in prompt
         assert "lsof -ti" not in prompt
         assert "sed -nE" not in prompt
-        assert ".prizmkit-test-started" in prompt
+        assert ".prizmkit-test-started" not in prompt
         assert "{{RUNTIME_HELPER_CMD}}" not in prompt
         assert "prizmkit-runtime-helper.py" in prompt
 
@@ -1991,7 +1452,6 @@ class TestFeatureBootstrapShellExtraction:
         assert "{{RUNTIME_HELPER_CMD}}" not in prompt
         assert "python" in prompt.lower()
         assert ".prizmkit/dev-pipeline/scripts/prizmkit-runtime-helper.py" in prompt
-        assert "artifact touch .prizmkit/specs/123-prompt-cleanup/.prizmkit-test-started" in prompt
         assert "text final-verdict .prizmkit/specs/123-prompt-cleanup/review-report.md" in prompt
 
     def test_rendered_section_feature_prompts_use_runtime_helper_not_extracted_bash(self, tmp_path):