prizmkit 1.1.140 → 1.1.142

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

@@ -4,7 +4,14 @@ from __future__ import annotations
 
 import json
 
-from prizmkit_runtime.checkpoint_state import load_checkpoint_state, read_checkpoint_cursor, validate_checkpoint_data
+from prizmkit_runtime.checkpoint_state import (
+    VALID_CHECKPOINT_STATUSES,
+    VALID_STAGE_RESULTS,
+    expected_status_for_stage_result,
+    load_checkpoint_state,
+    read_checkpoint_cursor,
+    validate_checkpoint_data,
+)
 from update_checkpoint import update_checkpoint
 
 
@@ -24,10 +31,74 @@ def _step(step_id, skill="skill", name="Step", status="pending", depends_on=None
 
 
 def _write(path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(json.dumps(data), encoding="utf-8")
     return path
 
 
+def _write_test_artifacts(root, slug="feature", *, result="TEST_PASS"):
+    artifact_dir = root / ".prizmkit" / "specs" / slug
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    (artifact_dir / "test-report.md").write_text(
+        f"# Test Report\n\n## Final Result\n\n- Result: {result}\n",
+        encoding="utf-8",
+    )
+    projection = {
+        "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": False,
+        "review_scope": None,
+        "unresolved_items": [],
+    }
+    (artifact_dir / "test-result.json").write_text(
+        json.dumps(projection), encoding="utf-8"
+    )
+    return artifact_dir
+
+
+def _family_checkpoint(root=None, *, semantic=None, terminal=True):
+    skills = [
+        "prizmkit-implement",
+        "prizmkit-code-review",
+        "prizmkit-test",
+        "prizmkit-retrospective",
+        "prizmkit-committer",
+        "completion-summary",
+    ]
+    steps = []
+    previous = None
+    for index, skill in enumerate(skills, start=1):
+        step = _step(f"S{index:02d}", skill, skill, "completed", previous)
+        if skill == "prizmkit-code-review":
+            step["stage_result"] = "REVIEW_PASS"
+        if skill == "prizmkit-test":
+            step["stage_result"] = "TEST_PASS"
+            step["required_artifacts"] = [
+                ".prizmkit/specs/feature/test-report.md",
+                ".prizmkit/specs/feature/test-result.json",
+            ]
+        steps.append(step)
+        previous = step["id"]
+    if root is not None:
+        _write_test_artifacts(root)
+    return {
+        "version": 1,
+        "workflow_type": "feature-pipeline",
+        "steps": steps,
+        "feature_state": semantic or ({"terminal_status": "WORKFLOW_COMPLETED"} if terminal else {}),
+    }
+
+
 def test_valid_checkpoint_current_step_uses_first_non_terminal(tmp_path):
     path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
         _step("S01", "plan", "Plan", "completed"),
@@ -44,36 +115,17 @@ def test_valid_checkpoint_current_step_uses_first_non_terminal(tmp_path):
     assert read_checkpoint_cursor(path) == 2
 
 
-def test_all_completed_checkpoint_has_complete_cursor(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "plan", "Plan", "completed"),
-        _step("S02", "commit", "Commit", "skipped", "S01"),
-    ]))
-
-    state = load_checkpoint_state(path)
-
-    assert state.valid is True
-    assert state.all_completed is True
-    assert state.current_step is None
-    assert state.current_step_name == ""
-    assert state.cursor == 2
-    assert state.cursor_signature == "complete"
-
-
 def test_missing_and_malformed_checkpoints_are_invalid(tmp_path):
     missing = load_checkpoint_state(tmp_path / "missing.json")
     assert missing.valid is False
     assert missing.exists is False
     assert missing.error_code == "missing"
-    assert missing.current_step_name == ""
 
     malformed_path = tmp_path / "bad.json"
     malformed_path.write_text("{not-json", encoding="utf-8")
     malformed = load_checkpoint_state(malformed_path)
     assert malformed.valid is False
-    assert malformed.exists is True
     assert malformed.error_code == "malformed_json"
-    assert malformed.current_step_name == ""
 
 
 def test_structural_validation_error_codes(tmp_path):
@@ -83,7 +135,6 @@ def test_structural_validation_error_codes(tmp_path):
         ("duplicate_step_id", _checkpoint([_step("S01"), _step("S01")])),
         ("invalid_status", _checkpoint([_step("S01", status="done")])),
         ("invalid_depends_on", _checkpoint([_step("S01", depends_on="S99")])),
-        ("invalid_depends_on", _checkpoint([_step("S01", depends_on="S02"), _step("S02")])),
         ("malformed_step_id", _checkpoint([_step("one")])),
         ("invalid_step", {"steps": ["not-object"]}),
     ]
@@ -92,183 +143,230 @@ def test_structural_validation_error_codes(tmp_path):
         state = load_checkpoint_state(path)
         assert state.valid is False
         assert state.error_code == expected_code
-        assert state.current_step_name == ""
         assert read_checkpoint_cursor(path) is None
 
 
-def test_failed_checkpoint_step_is_current_cursor(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "plan", "Plan", "completed"),
-        _step("S02", "review", "Review", "failed", "S01"),
-    ]))
+def test_domain_results_map_to_lifecycle_statuses():
+    expected = {
+        "PLAN_READY": "completed",
+        "PLAN_BLOCKED": "failed",
+        "IMPLEMENTED": "completed",
+        "IMPLEMENT_REPAIR": "failed",
+        "IMPLEMENT_BLOCKED": "failed",
+        "REVIEW_PASS": "completed",
+        "REVIEW_NEEDS_FIXES": "failed",
+        "TEST_PASS": "completed",
+        "TEST_NEEDS_FIXES": "failed",
+        "TEST_BLOCKED": "failed",
+        "RETRO_COMPLETE": "completed",
+        "RETRO_BLOCKED": "failed",
+        "COMMIT_PENDING": "in_progress",
+        "COMMITTED": "completed",
+        "COMMIT_BLOCKED": "failed",
+    }
 
-    state = load_checkpoint_state(path)
+    assert VALID_CHECKPOINT_STATUSES == {
+        "pending", "in_progress", "completed", "failed", "skipped",
+    }
+    for result, status in expected.items():
+        assert expected_status_for_stage_result(result) == status
+
+
+def test_structural_validation_rejects_domain_result_as_status(tmp_path):
+    for domain_status in [
+        "PLAN_READY", "IMPLEMENTED", "REVIEW_PASS", "REVIEW_NEEDS_FIXES",
+        "TEST_PASS", "TEST_NEEDS_FIXES", "TEST_BLOCKED", "RETRO_COMPLETE",
+        "COMMIT_PENDING", "COMMITTED",
+    ]:
+        state = validate_checkpoint_data(
+            _checkpoint([_step("S01", status=domain_status)]),
+            path=tmp_path / f"{domain_status}.json",
+        )
+        assert state.valid is False
+        assert state.error_code == "invalid_status"
 
-    assert state.valid is True
-    assert state.current_step_name == "Review"
-    assert state.cursor == 2
 
+def test_structural_validation_rejects_status_result_mismatch(tmp_path):
+    step = _step("S01", "prizmkit-code-review", "Review", "failed")
+    step["stage_result"] = "REVIEW_PASS"
 
-def test_duplicate_skills_are_reported_but_exact_ids_remain_valid(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "prizmkit-committer", "Commit First", "pending"),
-        _step("S02", "prizmkit-committer", "Commit Second", "pending", "S01"),
-    ]))
+    state = validate_checkpoint_data(
+        _checkpoint([step]),
+        path=tmp_path / "mismatch.json",
+    )
 
-    state = load_checkpoint_state(path)
+    assert state.valid is False
+    assert state.error_code == "stage_result_status_mismatch"
 
-    assert state.valid is True
-    assert state.duplicate_skills == {"prizmkit-committer": ("S01", "S02")}
 
+def test_structural_validation_rejects_stage_result_owner_mismatch(tmp_path):
+    for skill in ("prizmkit-test", "custom-stage"):
+        step = _step("S01", skill, "Step", "completed")
+        step["stage_result"] = "REVIEW_PASS"
 
-def test_update_checkpoint_rejects_ambiguous_skill_without_mutation(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "prizmkit-committer", "Commit First", "pending"),
-        _step("S02", "prizmkit-committer", "Commit Second", "pending", "S01"),
-    ]))
-    before = path.read_text(encoding="utf-8")
+        state = validate_checkpoint_data(
+            _checkpoint([step]),
+            path=tmp_path / f"{skill}-owner-mismatch.json",
+        )
 
-    result = update_checkpoint(str(path), "prizmkit-committer", "completed")
+        assert state.valid is False
+        assert state.error_code == "stage_result_owner_mismatch"
 
-    assert result["ok"] is False
-    assert "matches multiple checkpoint steps" in result["error"]
-    assert "Use an explicit step ID" in result["error"]
-    assert path.read_text(encoding="utf-8") == before
 
+def test_semantic_metadata_rejects_legacy_or_mismatched_status(tmp_path):
+    invalid = [
+        ({"status": "TEST_PASS", "stage_result": "TEST_PASS"}, "invalid_semantic_status"),
+        ({"status": "failed", "stage_result": "TEST_PASS"}, "semantic_stage_result_status_mismatch"),
+        ({"status": "completed", "stage_result": "UNKNOWN_RESULT"}, "invalid_semantic_stage_result"),
+        ({"stage": "test", "status": "completed", "stage_result": "REVIEW_PASS"}, "semantic_stage_result_owner_mismatch"),
+    ]
 
-def test_update_checkpoint_exact_id_updates_one_duplicate_skill_step(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "prizmkit-committer", "Commit First", "completed"),
-        _step("S02", "prizmkit-committer", "Commit Second", "pending", "S01"),
-    ]))
+    for index, (semantic, error_code) in enumerate(invalid):
+        state = validate_checkpoint_data(
+            _checkpoint([_step("S01")]) | {"feature_state": semantic},
+            path=tmp_path / f"semantic-status-{index}.json",
+        )
 
-    result = update_checkpoint(str(path), "S02", "completed")
-    data = json.loads(path.read_text(encoding="utf-8"))
+        assert state.valid is True
+        assert state.semantic.error_code == error_code
 
-    assert result["ok"] is True
-    assert result["step_id"] == "S02"
-    assert data["steps"][0]["status"] == "completed"
-    assert data["steps"][1]["status"] == "completed"
 
+def test_update_checkpoint_reenters_failed_stage_without_stale_result(tmp_path):
+    payload = _family_checkpoint(
+        tmp_path,
+        semantic={
+            "stage": "code-review",
+            "status": "failed",
+            "stage_result": "REVIEW_NEEDS_FIXES",
+            "repair_scope": "production",
+            "repair_round": 1,
+        },
+        terminal=False,
+    )
+    payload["steps"][1]["status"] = "failed"
+    payload["steps"][1]["stage_result"] = "REVIEW_NEEDS_FIXES"
+    for step in payload["steps"][2:]:
+        step["status"] = "pending"
+        step.pop("stage_result", None)
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-def test_update_checkpoint_invalid_checkpoint_fails_without_mutation(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "plan", "Plan", "done"),
-    ]))
-    before = path.read_text(encoding="utf-8")
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-code-review",
+        "in_progress",
+    )
+    persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
 
-    result = update_checkpoint(str(path), "S01", "completed")
+    assert result["ok"] is True
+    assert result["semantic"]["current_stage"] == "prizmkit-code-review"
+    assert result["semantic"]["next_stage"] == "prizmkit-code-review"
+    assert persisted["steps"][1]["status"] == "in_progress"
+    assert "stage_result" not in persisted["steps"][1]
+    assert persisted["feature_state"]["stage"] == "code-review"
+    assert persisted["feature_state"]["status"] == "in_progress"
+    assert "stage_result" not in persisted["feature_state"]
 
-    assert result["ok"] is False
-    assert "invalid_status" in result["error"]
-    assert path.read_text(encoding="utf-8") == before
 
+def test_checkpoint_updater_supports_every_owned_stage_result(tmp_path):
+    cases = [
+        ("prizmkit-plan", "PLAN_READY", "completed"),
+        ("prizmkit-implement", "IMPLEMENTED", "completed"),
+        ("prizmkit-code-review", "REVIEW_PASS", "completed"),
+        ("prizmkit-test", "TEST_BLOCKED", "failed"),
+        ("prizmkit-retrospective", "RETRO_COMPLETE", "completed"),
+        ("prizmkit-committer", "COMMIT_PENDING", "in_progress"),
+        ("prizmkit-committer", "COMMITTED", "completed"),
+    ]
 
+    assert {stage_result for _skill, stage_result, _status in cases} <= VALID_STAGE_RESULTS
+    for index, (skill, stage_result, status) in enumerate(cases):
+        step = _step("S01", skill, skill, "pending")
+        checkpoint = _write(
+            tmp_path / f"owned-result-{index}.json",
+            _checkpoint([step]),
+        )
+
+        result = update_checkpoint(
+            str(checkpoint),
+            skill,
+            status,
+            semantic_update={"stage_result": stage_result},
+        )
+
+        assert result["ok"] is True
+        persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
+        assert persisted["steps"][0]["status"] == status
+        assert persisted["steps"][0]["stage_result"] == stage_result
+        assert persisted["feature_state"]["stage"] == {
+            "prizmkit-plan": "plan",
+            "prizmkit-implement": "implement",
+            "prizmkit-code-review": "code-review",
+            "prizmkit-test": "test",
+            "prizmkit-retrospective": "retrospective",
+            "prizmkit-committer": "committer",
+        }[skill]
+        assert persisted["feature_state"]["status"] == status
+        assert persisted["feature_state"]["stage_result"] == stage_result
+
+
+def test_duplicate_skills_require_exact_step_id(tmp_path):
+    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
+        _step("S01", "prizmkit-committer", "First", "completed"),
+        _step("S02", "prizmkit-committer", "Second", "pending", "S01"),
+    ]))
 
-def _family_checkpoint(workflow_type, skills, *, semantic=None):
-    steps = []
-    previous = None
-    for index, skill in enumerate(skills, start=1):
-        step = _step(f"S{index:02d}", skill, skill, "completed", previous)
-        if skill == "prizmkit-code-review":
-            step["stage_result"] = "REVIEW_PASS"
-        if skill == "prizmkit-test":
-            step["stage_result"] = "TEST_PASS"
-        steps.append(step)
-        previous = step["id"]
-    payload = {"version": 1, "workflow_type": workflow_type, "steps": steps}
-    state_key = {
-        "feature-pipeline": "feature_state",
-        "bugfix-pipeline": "bugfix_state",
-        "refactor-pipeline": "refactor_state",
-    }[workflow_type]
-    payload[state_key] = semantic or {}
-    return payload
-
-
-def _write_test_evidence(root, verdict="TEST_PASS", validation_result="passed", evidence_id="evidence-1"):
-    evidence = root / ".prizmkit" / "test" / "evidence" / evidence_id
-    evidence.mkdir(parents=True)
-    manifest = evidence / "manifest.json"
-    verdict_path = evidence / "verdict.json"
-    validation = evidence / "validation.json"
-    manifest.write_text(json.dumps({"evidence_id": evidence_id, "final_verdict": verdict}), encoding="utf-8")
-    verdict_path.write_text(json.dumps({"verdict": verdict}), encoding="utf-8")
-    validation.write_text(json.dumps({"verdict": verdict, "result": validation_result}), encoding="utf-8")
-    return {
-        "manifest": str(manifest.relative_to(root)),
-        "verdict": str(verdict_path.relative_to(root)),
-        "validation": str(validation.relative_to(root)),
-    }
+    rejected = update_checkpoint(str(path), "prizmkit-committer", "completed")
+    accepted = update_checkpoint(str(path), "S02", "completed")
 
+    assert rejected["ok"] is False
+    assert "matches multiple checkpoint steps" in rejected["error"]
+    assert accepted["ok"] is True
 
-def test_semantic_completion_requires_family_sequence_verdicts_and_structured_evidence(tmp_path, monkeypatch):
-    monkeypatch.setattr(
-        "prizmkit_runtime.checkpoint_state._resolve_evidence_validator",
-        lambda _root: tmp_path / "validator.py",
-    )
-    monkeypatch.setattr(
-        "prizmkit_runtime.checkpoint_state._evidence_validator_passes",
-        lambda *_args: True,
-    )
-    paths = _write_test_evidence(tmp_path)
-    skills = [
-        "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-        "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-    ]
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        skills,
-        semantic={
-            "repair_round": 0,
-            "authoritative_evidence_paths": paths,
-            "terminal_status": "WORKFLOW_COMPLETED",
-        },
+
+def test_semantic_completion_requires_family_sequence_and_domain_results(tmp_path):
+    path = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        _family_checkpoint(tmp_path),
     )
-    payload["steps"][2]["authoritative_evidence_paths"] = paths
-    checkpoint = tmp_path / ".prizmkit" / "specs" / "feature" / "workflow-checkpoint.json"
-    checkpoint.parent.mkdir(parents=True)
-    _write(checkpoint, payload)
 
-    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
+    state = load_checkpoint_state(path, project_root=tmp_path)
 
     assert state.valid is True
     assert state.all_completed is True
     assert state.semantic_complete is True
-    assert state.semantic.evidence_valid is True
+    assert state.semantic.test_result_valid is True
     assert state.semantic.terminal_status == "WORKFLOW_COMPLETED"
 
 
-def test_completed_steps_without_stage_verdicts_are_not_semantic_completion(tmp_path):
-    skills = [
-        "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-        "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-    ]
-    payload = _family_checkpoint("feature-pipeline", skills)
+def test_completion_does_not_require_retired_evidence_paths(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    assert "authoritative_evidence_paths" not in payload["steps"][2]
+    assert "authoritative_evidence_paths" not in payload["feature_state"]
+
+    state = validate_checkpoint_data(payload, project_root=tmp_path)
+
+    assert state.semantic_complete is True
+    assert state.semantic.test_result_valid is True
+
+
+def test_completed_steps_without_review_or_test_results_do_not_complete(tmp_path):
+    payload = _family_checkpoint(tmp_path)
     payload["steps"][1].pop("stage_result")
     payload["steps"][2].pop("stage_result")
-    payload["feature_state"]["terminal_status"] = "WORKFLOW_COMPLETED"
 
     state = validate_checkpoint_data(payload, project_root=tmp_path)
 
-    assert state.valid is True
-    assert state.all_completed is True
     assert state.semantic_complete is False
     assert state.semantic.error_code == "incomplete_semantic_evidence"
 
 
 def test_family_sequence_mismatch_cannot_complete(tmp_path):
-    paths = _write_test_evidence(tmp_path)
-    skills = [
-        "prizmkit-implement", "prizmkit-test", "prizmkit-code-review",
-        "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-    ]
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        skills,
-        semantic={"authoritative_evidence_paths": paths, "terminal_status": "WORKFLOW_COMPLETED"},
-    )
-    payload["steps"][1]["authoritative_evidence_paths"] = paths
+    payload = _family_checkpoint(tmp_path)
+    payload["steps"][1], payload["steps"][2] = payload["steps"][2], payload["steps"][1]
+    payload["steps"][1]["id"] = "S02"
+    payload["steps"][2]["id"] = "S03"
+    payload["steps"][1]["depends_on"] = "S01"
+    payload["steps"][2]["depends_on"] = "S02"
 
     state = validate_checkpoint_data(payload, project_root=tmp_path)
 
@@ -277,157 +375,139 @@ def test_family_sequence_mismatch_cannot_complete(tmp_path):
     assert state.semantic.error_code == "invalid_stage_sequence"
 
 
-def test_stale_or_mismatched_test_evidence_cannot_complete(tmp_path):
-    paths = _write_test_evidence(tmp_path, verdict="TEST_FAIL")
-    skills = [
-        "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-        "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-    ]
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        skills,
-        semantic={"authoritative_evidence_paths": paths, "terminal_status": "WORKFLOW_COMPLETED"},
+def test_test_needs_fixes_is_valid_domain_result_and_blocks_l4(tmp_path):
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    payload["steps"][2]["status"] = "in_progress"
+    payload["steps"][2].pop("stage_result")
+    for step in payload["steps"][3:]:
+        step["status"] = "pending"
+        step.pop("stage_result", None)
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
+
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-test",
+        "failed",
+        semantic_update={"stage_result": "TEST_NEEDS_FIXES"},
     )
-    payload["steps"][2]["authoritative_evidence_paths"] = paths
+    persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
 
-    state = validate_checkpoint_data(payload, project_root=tmp_path)
+    assert result["ok"] is True
+    assert persisted["steps"][2]["stage_result"] == "TEST_NEEDS_FIXES"
+    assert persisted["feature_state"]["stage_result"] == "TEST_NEEDS_FIXES"
+    assert persisted["feature_state"]["blocked_reason"] == "test_needs_fixes"
+    assert persisted["feature_state"]["terminal_status"] == "WORKFLOW_BLOCKED"
+    assert "authoritative_evidence_paths" not in persisted["steps"][2]
 
-    assert state.semantic_complete is False
-    assert state.semantic.evidence_valid is False
-    assert state.semantic.error_code == "incomplete_semantic_evidence"
 
+def test_test_blocked_preserves_l1_result_without_evidence_discovery(tmp_path):
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    payload["steps"][2]["status"] = "in_progress"
+    payload["steps"][2].pop("stage_result")
+    for step in payload["steps"][3:]:
+        step["status"] = "pending"
+        step.pop("stage_result", None)
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-def test_blocked_terminal_is_semantic_and_requires_reason(tmp_path):
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
-        semantic={
-            "repair_scope": "production",
-            "repair_round": 3,
-            "blocked_reason": "repair_round_limit",
-            "terminal_status": "WORKFLOW_BLOCKED",
-        },
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-test",
+        "failed",
+        semantic_update={"stage_result": "TEST_BLOCKED", "blocked_reason": "safe environment unavailable"},
     )
-    payload["steps"][2]["stage_result"] = "TEST_FAIL"
-
-    state = validate_checkpoint_data(payload, project_root=tmp_path)
-
-    assert state.semantic_blocked is True
-    assert state.semantic_complete is False
-    assert state.semantic.blocked_reason == "repair_round_limit"
-    assert state.cursor_signature == "blocked:repair_round_limit"
+    persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
 
+    assert result["ok"] is True
+    assert persisted["steps"][2]["stage_result"] == "TEST_BLOCKED"
+    assert persisted["feature_state"]["stage_result"] == "TEST_BLOCKED"
+    assert persisted["feature_state"]["blocked_reason"] == "test_blocked"
+    assert "authoritative_evidence_paths" not in persisted["feature_state"]
 
-def test_step_progress_must_be_a_terminal_prefix(tmp_path):
-    payload = _checkpoint([
-        _step("S01", "plan", "Plan", "pending"),
-        _step("S02", "implement", "Implement", "completed", "S01"),
-    ])
 
-    state = validate_checkpoint_data(payload)
+def test_update_checkpoint_completes_test_pass_without_validator(tmp_path):
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    payload["steps"][2]["status"] = "in_progress"
+    payload["steps"][2].pop("stage_result")
+    for step in payload["steps"][3:]:
+        step["status"] = "pending"
+        step.pop("stage_result", None)
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-    assert state.valid is False
-    assert state.error_code == "invalid_step_progress"
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-test",
+        "completed",
+        semantic_update={"stage_result": "TEST_PASS"},
+    )
 
+    assert result["ok"] is True
+    persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
+    assert persisted["steps"][2]["status"] == "completed"
+    assert persisted["steps"][2]["stage_result"] == "TEST_PASS"
 
 
-def test_update_checkpoint_rejects_out_of_order_transition(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "plan", "Plan", "pending"),
-        _step("S02", "implement", "Implement", "pending", "S01"),
-    ]))
+def test_update_checkpoint_rejects_test_completion_for_non_pass(tmp_path):
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    payload["steps"][2]["status"] = "in_progress"
+    payload["steps"][2].pop("stage_result")
+    for step in payload["steps"][3:]:
+        step["status"] = "pending"
+        step.pop("stage_result", None)
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-    result = update_checkpoint(str(path), "S02", "in_progress")
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-test",
+        "completed",
+        semantic_update={"stage_result": "TEST_NEEDS_FIXES"},
+    )
 
     assert result["ok"] is False
-    assert "before all predecessors" in result["error"]
+    assert "requires TEST_PASS" in result["error"]
 
 
-def test_update_checkpoint_blocks_unknown_repair_scope_without_mutating_retry_budget(tmp_path):
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
-    )
-    payload["steps"][1]["status"] = "in_progress"
-    for step in payload["steps"][2:]:
+def test_update_checkpoint_rejects_test_before_review_pass(tmp_path):
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    payload["steps"][1]["status"] = "skipped"
+    payload["steps"][1].pop("stage_result", None)
+    payload["steps"][2]["status"] = "pending"
+    payload["steps"][2].pop("stage_result", None)
+    for step in payload["steps"][3:]:
         step["status"] = "pending"
         step.pop("stage_result", None)
-    path = _write(tmp_path / "workflow-checkpoint.json", payload)
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-    result = update_checkpoint(
-        str(path),
-        "prizmkit-code-review",
-        "failed",
-        semantic_update={"stage_result": "REVIEW_NEEDS_FIXES", "repair_round": 0},
-    )
-    data = json.loads(path.read_text(encoding="utf-8"))
+    result = update_checkpoint(str(checkpoint), "prizmkit-test", "in_progress")
 
-    assert result["ok"] is True
-    assert data["feature_state"]["terminal_status"] == "WORKFLOW_BLOCKED"
-    assert data["feature_state"]["blocked_reason"] == "unsafe_repair_scope"
-    assert "retry_count" not in data["feature_state"]
+    assert result["ok"] is False
+    assert "REVIEW_PASS" in result["error"]
 
 
-def test_update_checkpoint_enforces_three_outer_repair_rounds(tmp_path):
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
-        semantic={"repair_scope": "production", "repair_round": 3},
-    )
-    payload["steps"][1]["status"] = "in_progress"
-    for step in payload["steps"][2:]:
+def test_update_checkpoint_rejects_finalization_before_test_pass(tmp_path):
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    payload["steps"][2]["status"] = "skipped"
+    payload["steps"][2].pop("stage_result", None)
+    payload["steps"][3]["status"] = "pending"
+    for step in payload["steps"][4:]:
         step["status"] = "pending"
         step.pop("stage_result", None)
-    path = _write(tmp_path / "workflow-checkpoint.json", payload)
-
-    result = update_checkpoint(
-        str(path),
-        "prizmkit-code-review",
-        "failed",
-        semantic_update={"stage_result": "REVIEW_NEEDS_FIXES", "repair_scope": "production"},
-    )
-    data = json.loads(path.read_text(encoding="utf-8"))
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-    assert result["ok"] is True
-    assert data["feature_state"]["repair_round"] == 3
-    assert data["feature_state"]["terminal_status"] == "WORKFLOW_BLOCKED"
-    assert data["feature_state"]["blocked_reason"] == "repair_round_limit"
+    result = update_checkpoint(str(checkpoint), "prizmkit-retrospective", "in_progress")
 
+    assert result["ok"] is False
+    assert "TEST_PASS" in result["error"]
 
 
-def test_declared_final_artifact_must_exist_for_semantic_completion(tmp_path, monkeypatch):
-    monkeypatch.setattr(
-        "prizmkit_runtime.checkpoint_state._resolve_evidence_validator",
-        lambda _root: tmp_path / "validator.py",
-    )
-    monkeypatch.setattr(
-        "prizmkit_runtime.checkpoint_state._evidence_validator_passes",
-        lambda *_args: True,
-    )
-    paths = _write_test_evidence(tmp_path)
-    skills = [
-        "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-        "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
+def test_declared_final_artifact_must_exist_for_completion(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    payload["steps"][-1]["required_artifacts"] = [
+        ".prizmkit/specs/feature/completion-summary.json"
     ]
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        skills,
-        semantic={"authoritative_evidence_paths": paths, "terminal_status": "WORKFLOW_COMPLETED"},
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
     )
-    payload["steps"][2]["authoritative_evidence_paths"] = paths
-    payload["steps"][-1]["required_artifacts"] = [".prizmkit/specs/feature/completion-summary.json"]
-    checkpoint = tmp_path / ".prizmkit" / "specs" / "feature" / "workflow-checkpoint.json"
-    checkpoint.parent.mkdir(parents=True)
-    _write(checkpoint, payload)
 
     missing = load_checkpoint_state(checkpoint, project_root=tmp_path)
     (checkpoint.parent / "completion-summary.json").write_text("{}", encoding="utf-8")
@@ -439,185 +519,186 @@ def test_declared_final_artifact_must_exist_for_semantic_completion(tmp_path, mo
     assert present.semantic.artifacts_valid is True
 
 
-
-def test_blocked_test_handoff_discovers_finalized_evidence_paths(tmp_path):
-    artifact = tmp_path / ".prizmkit" / "specs" / "feature"
-    artifact.mkdir(parents=True)
-    evidence = tmp_path / ".prizmkit" / "test" / "evidence" / "evidence-1"
-    evidence.mkdir(parents=True)
-    (evidence / "manifest.json").write_text(
-        json.dumps({"evidence_id": "evidence-1", "final_verdict": "TEST_BLOCKED"}),
-        encoding="utf-8",
+def test_completion_rejects_invalid_test_result_projection(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
     )
-    (evidence / "verdict.json").write_text(
-        json.dumps({"verdict": "TEST_BLOCKED"}),
-        encoding="utf-8",
+    result_path = checkpoint.parent / "test-result.json"
+    result = json.loads(result_path.read_text(encoding="utf-8"))
+    result["main_review_rounds"] = 0
+    result_path.write_text(json.dumps(result), encoding="utf-8")
+
+    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
+
+    assert state.semantic_complete is False
+    assert state.semantic.artifacts_valid is False
+
+
+def test_completion_rejects_inconsistent_independent_review_metadata(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
     )
-    (evidence / "validation.json").write_text(
-        json.dumps({"result": "passed", "verdict": "TEST_BLOCKED"}),
-        encoding="utf-8",
+    result_path = checkpoint.parent / "test-result.json"
+    result = json.loads(result_path.read_text(encoding="utf-8"))
+    result["independent_review"] = {
+        "status": "completed",
+        "responses": 0,
+        "downgrade_reason": None,
+        "final_state_rechecked": True,
+    }
+    result_path.write_text(json.dumps(result), encoding="utf-8")
+
+    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
+
+    assert state.semantic_complete is False
+    assert state.semantic.artifacts_valid is False
+
+
+def test_completion_accepts_legacy_terminal_result_report(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
     )
-    (evidence / "lifecycle.json").write_text(
-        json.dumps({"status": "sealed", "finalized": True}),
+    (checkpoint.parent / "test-report.md").write_text(
+        "# Test Report\n\n## Terminal Result\n\n- Result: TEST_PASS\n\n"
+        "## Final Decision\n\nTEST_PASS\n",
         encoding="utf-8",
     )
-    report = evidence / "test-report.md"
-    report.write_text("blocked", encoding="utf-8")
-    (artifact / "test-report-path.txt").write_text(str(report), encoding="utf-8")
 
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
-        semantic={"artifact_dir": ".prizmkit/specs/feature"},
-    )
-    payload["feature_state"]["artifact_dir"] = ".prizmkit/specs/feature"
-    payload["steps"][1]["stage_result"] = "REVIEW_PASS"
-    payload["steps"][2]["status"] = "in_progress"
-    payload["steps"][2].pop("stage_result")
-    for step in payload["steps"][3:]:
-        step["status"] = "pending"
-        step.pop("stage_result", None)
-    checkpoint = _write(tmp_path / ".prizmkit" / "specs" / "feature" / "workflow-checkpoint.json", payload)
+    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
 
-    result = update_checkpoint(
-        str(checkpoint),
-        "prizmkit-test",
-        "failed",
-        semantic_update={
-            "stage_result": "TEST_BLOCKED",
-            "blocked_reason": "test_blocked",
-            "terminal_status": "WORKFLOW_BLOCKED",
-        },
+    assert state.semantic_complete is True
+    assert state.semantic.artifacts_valid is True
+
+
+def test_completion_rejects_conflicting_supported_report_results(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
+    )
+    (checkpoint.parent / "test-report.md").write_text(
+        "# Test Report\n\n## Terminal Result\n\n- Result: TEST_PASS\n\n"
+        "## Final Decision\n\nTEST_BLOCKED\n",
+        encoding="utf-8",
     )
 
-    assert result["ok"] is True
-    paths = json.loads(checkpoint.read_text(encoding="utf-8"))["steps"][2]["authoritative_evidence_paths"]
-    assert paths["manifest"] == ".prizmkit/test/evidence/evidence-1/manifest.json"
-    assert paths["verdict"] == ".prizmkit/test/evidence/evidence-1/verdict.json"
-    assert paths["validation"] == ".prizmkit/test/evidence/evidence-1/validation.json"
+    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
 
+    assert state.semantic_complete is False
+    assert state.semantic.artifacts_valid is False
 
 
-def test_blocked_test_handoff_without_finalized_evidence_preserves_test_result(tmp_path):
-    artifact = tmp_path / ".prizmkit" / "specs" / "feature"
-    artifact.mkdir(parents=True)
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
-        semantic={"artifact_dir": ".prizmkit/specs/feature"},
+def test_completion_rejects_mismatched_test_report_result(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
     )
-    payload["feature_state"]["artifact_dir"] = ".prizmkit/specs/feature"
-    payload["steps"][1]["stage_result"] = "REVIEW_PASS"
-    payload["steps"][2]["status"] = "in_progress"
-    payload["steps"][2].pop("stage_result")
-    for step in payload["steps"][3:]:
-        step["status"] = "pending"
-        step.pop("stage_result", None)
-    checkpoint = _write(artifact / "workflow-checkpoint.json", payload)
-
-    result = update_checkpoint(
-        str(checkpoint),
-        "prizmkit-test",
-        "failed",
-        semantic_update={
-            "stage_result": "TEST_BLOCKED",
-            "blocked_reason": "test_blocked",
-            "terminal_status": "WORKFLOW_BLOCKED",
-        },
+    (checkpoint.parent / "test-report.md").write_text(
+        "# Test Report\n\n## Final Result\n\n- Result: TEST_BLOCKED\n",
+        encoding="utf-8",
     )
 
-    persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
-    assert result["ok"] is True
-    assert result["semantic"]["stage_result"] == "TEST_BLOCKED"
-    assert persisted["steps"][2]["stage_result"] == "TEST_BLOCKED"
-    assert persisted["feature_state"]["stage_result"] == "TEST_BLOCKED"
-    assert "authoritative_evidence_paths" not in persisted["steps"][2]
+    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
 
+    assert state.semantic_complete is False
+    assert state.semantic.artifacts_valid is False
 
-def test_update_checkpoint_rejects_test_pass_when_validator_replay_fails(tmp_path, monkeypatch):
-    paths = _write_test_evidence(tmp_path)
-    payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
-    )
-    payload["steps"][2]["status"] = "in_progress"
-    for step in payload["steps"][3:]:
-        step["status"] = "pending"
-        step.pop("stage_result", None)
-    checkpoint = tmp_path / "workflow-checkpoint.json"
-    _write(checkpoint, payload)
-    monkeypatch.setattr(
-        "prizmkit_runtime.checkpoint_state._resolve_evidence_validator",
-        lambda _root: tmp_path / "validator.py",
+
+def test_completion_rejects_report_with_result_only_outside_final_section(tmp_path):
+    payload = _family_checkpoint(tmp_path)
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
     )
-    monkeypatch.setattr(
-        "prizmkit_runtime.checkpoint_state._evidence_validator_passes",
-        lambda *_args: False,
+    (checkpoint.parent / "test-report.md").write_text(
+        "# Test Report\n\n## Final Result\n\n- Result: TEST_BLOCKED\n\n"
+        "## Remaining Risks and Unresolved Items\n\n- Expected eventual result: TEST_PASS\n",
+        encoding="utf-8",
     )
 
-    result = update_checkpoint(
-        str(checkpoint),
-        "prizmkit-test",
-        "completed",
-        semantic_update={
-            "stage_result": "TEST_PASS",
-            "authoritative_evidence_paths": paths,
-        },
+    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
+
+    assert state.semantic_complete is False
+    assert state.semantic.artifacts_valid is False
+
+
+def test_completion_rejects_test_artifacts_outside_project(tmp_path):
+    outside = tmp_path.parent / f"{tmp_path.name}-outside"
+    outside.mkdir()
+    _write_test_artifacts(outside)
+    payload = _family_checkpoint(tmp_path)
+    test_step = payload["steps"][2]
+    test_step["required_artifacts"] = [
+        f"../{outside.name}/.prizmkit/specs/feature/test-report.md",
+        f"../{outside.name}/.prizmkit/specs/feature/test-result.json",
+    ]
+    checkpoint = _write(
+        tmp_path / ".prizmkit/specs/feature/workflow-checkpoint.json",
+        payload,
     )
 
-    assert result["ok"] is False
-    assert "validator-attested" in result["error"]
+    state = load_checkpoint_state(checkpoint, project_root=tmp_path)
 
+    assert state.semantic_complete is False
+    assert state.semantic.artifacts_valid is False
 
 
-def test_update_checkpoint_rejects_test_before_review_pass(tmp_path):
+def test_review_needs_fixes_preserves_implementation_repair_route(tmp_path):
     payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
+        tmp_path,
+        semantic={"repair_scope": "production", "repair_round": 0},
+        terminal=False,
     )
-    payload["steps"][1]["status"] = "skipped"
-    payload["steps"][1].pop("stage_result", None)
-    payload["steps"][2]["status"] = "pending"
-    for step in payload["steps"][3:]:
+    payload["steps"][1]["status"] = "in_progress"
+    payload["steps"][1].pop("stage_result")
+    for step in payload["steps"][2:]:
         step["status"] = "pending"
         step.pop("stage_result", None)
     checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-    result = update_checkpoint(str(checkpoint), "prizmkit-test", "in_progress")
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-code-review",
+        "failed",
+        semantic_update={"stage_result": "REVIEW_NEEDS_FIXES", "repair_scope": "production"},
+    )
+    persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
 
-    assert result["ok"] is False
-    assert "REVIEW_PASS" in result["error"]
+    assert result["ok"] is True
+    assert result["semantic"]["next_stage"] == "prizmkit-implement"
+    assert persisted["feature_state"]["repair_round"] == 1
+    assert persisted["feature_state"]["current_stage"] == "prizmkit-code-review"
+    assert persisted["feature_state"]["next_stage"] == "prizmkit-implement"
 
 
-def test_update_checkpoint_rejects_finalization_before_test_pass(tmp_path):
+def test_review_outer_repair_cap_remains_runtime_owned(tmp_path):
     payload = _family_checkpoint(
-        "feature-pipeline",
-        [
-            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
-        ],
+        tmp_path, semantic={"repair_scope": "production", "repair_round": 3},
+        terminal=False,
     )
-    payload["steps"][2]["status"] = "skipped"
-    payload["steps"][2].pop("stage_result", None)
-    payload["steps"][3]["status"] = "pending"
-    for step in payload["steps"][4:]:
+    payload["steps"][1]["status"] = "in_progress"
+    payload["steps"][1].pop("stage_result")
+    for step in payload["steps"][2:]:
         step["status"] = "pending"
         step.pop("stage_result", None)
     checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-    result = update_checkpoint(str(checkpoint), "prizmkit-retrospective", "in_progress")
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-code-review",
+        "failed",
+        semantic_update={"stage_result": "REVIEW_NEEDS_FIXES", "repair_scope": "production"},
+    )
+    persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
 
-    assert result["ok"] is False
-    assert "TEST_PASS" in result["error"]
+    assert result["ok"] is True
+    assert persisted["feature_state"]["repair_round"] == 3
+    assert persisted["feature_state"]["blocked_reason"] == "repair_round_limit"
+    assert persisted["feature_state"]["terminal_status"] == "WORKFLOW_BLOCKED"