prizmkit 1.1.130 → 1.1.134

package/bundled/dev-pipeline/templates/sections/phase-review-agent.md

@@ -2,13 +2,13 @@
 
 Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so `/prizmkit-code-review` can read the spec, plan, context snapshot, implementation log, and current diff. Do not require a prior `/prizmkit-test` report here; the next phase owns the formal test gate.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill runs a Main-Agent review loop for up to ten completed rounds. The current Main Agent is the only Code Review executor: it reviews the complete current change, rejects unsupported candidate findings, directly repairs accepted findings, verifies repairs, and repeats until `accepted = 0` with no unresolved findings.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill runs a mandatory Main-Agent review loop for up to ten completed rounds: the Main Agent reviews the complete current change, rejects unsupported candidate findings, directly repairs accepted findings, verifies repairs, and repeats until `accepted = 0` with no unresolved findings. After convergence, one skill-owned independent Reviewer is optional only when the strict structural capability gate passes; otherwise no Reviewer is created.
 
-The Code Review execution boundary is absolute for this phase:
+The Code Review execution boundary is closed for this phase:
 
-- Do not delegate any review work directly or indirectly.
-- Do not invoke another review skill or review workflow.
-- Do not use a general-purpose execution unit for review or relabel delegated work as a finder, verifier, audit, compatibility review, verification, or gap sweep.
+- Do not delegate the mandatory Main-Agent review or invoke another review skill or workflow.
+- Do not add review execution outside the single optional Reviewer owned and gated by `prizmkit-code-review`.
+- The optional Reviewer must be structurally read-only, unable to execute arbitrary commands or downstream execution, and natively resumable as the same unit; otherwise strict downgrade applies.
 - Direct reading, searching, editing, and testing by the current Main Agent remain allowed.
 - `review-report.md` is the only persisted review artifact; do not append separate Review Notes to `context-snapshot.md`.
 

package/bundled/dev-pipeline/templates/sections/phase-review-full.md

@@ -1,19 +1,23 @@
 ### Review — Code Review
 
-Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so `/prizmkit-code-review` can read the spec, plan, context snapshot, implementation log, and current diff. Do not require a prior `/prizmkit-test` report here; the next phase owns the formal test gate.
+Review the completed implementation before the full Feature test gate runs. A review result is a required predecessor; never accept or route around testing as if a review had passed.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill runs a Main-Agent review loop for up to ten completed rounds. The current Main Agent is the only Code Review executor: it reviews the complete current change, rejects unsupported candidate findings, directly repairs accepted findings, verifies repairs, and repeats until `accepted = 0` with no unresolved findings.
+Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so `/prizmkit-code-review` can read the spec, plan, context snapshot, implementation log, and current diff. The skill runs a mandatory Main-Agent review loop of up to ten completed rounds and writes only `review-report.md`. After Main-Agent convergence, the skill may create one skill-owned independent Reviewer only when its strict structural capability gate passes; otherwise it records downgrade and creates none.
 
-The Code Review execution boundary is absolute for this phase:
+- `REVIEW_PASS` → update checkpoint metadata with `stage=code-review`, `status=REVIEW_PASS`, `stage_result=REVIEW_PASS`, `next_stage=prizmkit-test`, and `resume_from=prizmkit-test`; then run the full test gate.
+- `REVIEW_NEEDS_FIXES` → preserve findings, increment the shared outer `repair_round`, route `prizmkit-implement` → `prizmkit-code-review` → `prizmkit-test`, and do not accept any test result from before the repaired review.
+- If the outer repair round is already three, record `WORKFLOW_BLOCKED`; do not start another repair route.
 
-- Do not delegate any review work directly or indirectly.
-- Do not invoke another review skill or review workflow.
-- Do not use a general-purpose execution unit for review or relabel delegated work as a finder, verifier, audit, compatibility review, verification, or gap sweep.
+Missing required evidence, unsafe repair, failed verification, or failure to converge by round ten produces `REVIEW_NEEDS_FIXES`.
+
+The Code Review execution boundary is closed:
+
+- Do not delegate the mandatory Main-Agent review or invoke another review skill or workflow.
+- Do not add review execution outside the single optional Reviewer owned and gated by `prizmkit-code-review`.
+- The optional Reviewer must be structurally read-only, unable to execute arbitrary commands or downstream execution, and natively resumable as the same unit; otherwise strict downgrade applies.
 - Direct reading, searching, editing, and testing by the current Main Agent remain allowed.
 - `review-report.md` is the only persisted review artifact; do not append separate Review Notes to `context-snapshot.md`.
 
-Missing required evidence, an unsafe repair, a failed verification, or failure to converge by round ten produces `NEEDS_FIXES`.
-
 **Gate Check — Final Review Result**:
 
 ```bash
@@ -22,9 +26,9 @@ Missing required evidence, an unsafe repair, a failed verification, or failure t
 
 Handle the marker:
 
-- `REVIEW_PASS` → proceed to next phase.
-- `REVIEW_NEEDS_FIXES` → log unresolved findings and follow the task failure policy; do not externally restart the review loop.
-- `REVIEW_INCOMPLETE` or `REVIEW_INVALID` → inspect the append-only progress once, write `failure-log.md`, and stop. Do not treat an old or incidental verdict as completion and do not synthesize a passing result outside the skill.
+- `REVIEW_PASS` → proceed to the structured test gate.
+- `REVIEW_NEEDS_FIXES` → follow the repair route above; do not externally restart the review loop.
+- `REVIEW_INCOMPLETE` or `REVIEW_INVALID` → inspect append-only progress once, write `failure-log.md`, and stop. Do not accept old/incidental verdict text or synthesize a pass.
 
 **CP-3**: Review has a valid Final Result and `review-report.md` preserves this execution's progress.
 

package/bundled/dev-pipeline/templates/sections/refactor-phase-commit-report.md

@@ -14,7 +14,7 @@ Run `/prizmkit-committer` with commit prefix:
 refactor({{REFACTOR_ID}}): {{REFACTOR_TITLE}}
 ```
 
-Do not push.
+The runtime controls any optional remote publication after this local commit; do not make a publication decision in this session.
 
 Write `.prizmkit/refactor/{{REFACTOR_ID}}/refactor-report.md` with:
 - refactor summary;

package/bundled/dev-pipeline/templates/sections/refactor-phase-review.md

@@ -1,12 +1,12 @@
 ### Phase 3: Review — Code Review & Behavior Verification
 
-Run `/prizmkit-code-review` directly with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/`. The skill runs a Main-Agent review loop for up to ten completed rounds. The current Main Agent is the only Code Review executor: it reviews the complete current change, rejects unsupported candidate findings, directly repairs accepted findings, verifies repairs, and repeats until `accepted = 0` with no unresolved findings.
+Run `/prizmkit-code-review` directly with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/`. The skill runs a mandatory Main-Agent review loop for up to ten completed rounds: the Main Agent reviews the complete current change, rejects unsupported candidate findings, directly repairs accepted findings, verifies repairs, and repeats until `accepted = 0` with no unresolved findings. After convergence, one skill-owned independent Reviewer is optional only when the strict structural capability gate passes; otherwise no Reviewer is created.
 
-The Code Review execution boundary is absolute for this phase:
+The Code Review execution boundary is closed for this phase:
 
-- Do not delegate any review work directly or indirectly.
-- Do not invoke another review skill or review workflow.
-- Do not use a general-purpose execution unit for review or relabel delegated work as a finder, verifier, audit, compatibility review, verification, or gap sweep.
+- Do not delegate the mandatory Main-Agent review or invoke another review skill or workflow.
+- Do not add review execution outside the single optional Reviewer owned and gated by `prizmkit-code-review`.
+- The optional Reviewer must be structurally read-only, unable to execute arbitrary commands or downstream execution, and natively resumable as the same unit; otherwise strict downgrade applies.
 - Direct reading, searching, editing, and testing by the current Main Agent remain allowed.
 - `review-report.md` is the only persisted review artifact; do not append separate Review Notes to another artifact.
 
@@ -24,4 +24,4 @@ Missing required evidence, an unsafe repair, a failed verification, or failure t
 
 Verify directly that the review checks behavior preservation, public API compatibility, imports, tests, and rollback assumptions.
 
-**Checkpoint update**: Set step `prizmkit-code-review` to `completed` only for an accepted valid Final Result. Do not complete the checkpoint for incomplete or invalid reports.
+**Checkpoint update**: Set step `prizmkit-code-review` to `completed` with `stage_result=REVIEW_PASS` only for an accepted valid Final Result. Do not complete the checkpoint for incomplete or invalid reports.

package/bundled/dev-pipeline/templates/sections/refactor-phase-test.md

@@ -0,0 +1,21 @@
+### Refactor Test Gate — PrizmKit Test
+
+After Main-Agent code review returns a valid `PASS`, run the mandatory post-review test stage against the same Refactor artifact root. Behavior-preservation checks collected during planning and implementation remain supporting evidence; they never replace this authoritative evidence gate.
+
+```text
+/prizmkit-test scope=this-change artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/
+```
+
+Read the current structured evidence package under `.prizmkit/test/evidence/<evidence-id>/`: `manifest.json`, `verdict.json`, and `validation.json`. A derived Markdown report is not completion authority. Confirm scope, hashes, final verdict, and validator result before accepting `TEST_PASS`.
+
+Gate outcomes and authoritative routing:
+
+- `TEST_PASS`: verify behavior-preservation evidence remains recorded, update the checkpoint handoff, and continue to retrospective.
+- `TEST_FAIL` with `repair_scope=test-infrastructure`: return to `/prizmkit-implement`, preserve the behavior baseline, then return directly to this test gate; do not make speculative production edits.
+- `TEST_FAIL` with `repair_scope=production|runtime|schema|dependency|public-interface`: return to implementation, obtain a fresh code-review result, then return to this test gate.
+- `TEST_FAIL` with an unknown or missing `repair_scope`: record `WORKFLOW_BLOCKED` and leave a safe checkpoint at the test stage; do not guess a production edit.
+- `TEST_BLOCKED`: preserve all evidence and artifacts, perform only bounded automatic environment recovery, then terminate as `WORKFLOW_BLOCKED` with `blocked_reason=test_blocked`. Never edit production speculatively and never ask the user.
+
+The `repair_round` counter is shared with review failures and may not exceed three outer rounds. At the limit, leave a truthful blocked terminal result. Internal code-review convergence has its separate ten-round limit.
+
+**Checkpoint update**: Only a validated structured `TEST_PASS` may complete `prizmkit-test` with `stage_result=TEST_PASS` plus `manifest`, `verdict`, and `validation` evidence paths, then proceed to retrospective.

package/bundled/dev-pipeline/templates/sections/refactor-reminders.md

@@ -3,7 +3,7 @@
 - Use L1 skills: `/prizmkit-plan`, `/prizmkit-implement`, `/prizmkit-code-review`, `/prizmkit-retrospective`, `/prizmkit-committer`.
 - All refactor skills use `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/`.
 - Behavior preservation is the first priority.
-- Do not spawn a top-level Dev implementation subagent; Code Review runs only in the current Main Agent without delegation.
+- Do not spawn a top-level Dev implementation subagent; Code Review keeps mandatory Main-Agent ownership and may use only its strict-gated skill-owned Reviewer after convergence.
 - Main orchestrator runs `/prizmkit-code-review` directly.
 - Commit with `refactor(<scope>):`, not `feat:` or `fix:`.
 - Checkpoint state is the recovery truth; skipped steps must be marked `skipped`.

package/bundled/dev-pipeline/templates/sections/subagent-timeout-recovery.md

@@ -1,6 +1,6 @@
 ## Normal Work Delegation Timeout Recovery
 
-This recovery path applies only to normal work delegated outside Code Review. Code Review never uses delegated execution or this retry procedure.
+This recovery path applies only to normal work delegated outside the optional skill-owned review contract. Code Review never applies this retry procedure to its independent Reviewer; Reviewer creation or native-resume failure uses the skill's strict downgrade instead.
 
 If a normal work execution unit times out:
 1. `{{RUNTIME_HELPER_CMD}} artifact list .prizmkit/specs/{{FEATURE_SLUG}}` — check what exists

package/bundled/dev-pipeline/templates/sections/task-contract.md

@@ -8,6 +8,10 @@ Implement {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
 
 {{FEATURE_DESCRIPTION}}
 
+### User Context
+
+{{USER_CONTEXT}}
+
 ### Scope Rule
 
 Current scope is limited to the intersection of:

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

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 
-from prizmkit_runtime.checkpoint_state import load_checkpoint_state, read_checkpoint_cursor
+from prizmkit_runtime.checkpoint_state import load_checkpoint_state, read_checkpoint_cursor, validate_checkpoint_data
 from update_checkpoint import update_checkpoint
 
 
@@ -138,7 +138,7 @@ def test_update_checkpoint_rejects_ambiguous_skill_without_mutation(tmp_path):
 
 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", "pending"),
+        _step("S01", "prizmkit-committer", "Commit First", "completed"),
         _step("S02", "prizmkit-committer", "Commit Second", "pending", "S01"),
     ]))
 
@@ -147,7 +147,7 @@ def test_update_checkpoint_exact_id_updates_one_duplicate_skill_step(tmp_path):
 
     assert result["ok"] is True
     assert result["step_id"] == "S02"
-    assert data["steps"][0]["status"] == "pending"
+    assert data["steps"][0]["status"] == "completed"
     assert data["steps"][1]["status"] == "completed"
 
 
@@ -162,3 +162,362 @@ def test_update_checkpoint_invalid_checkpoint_fails_without_mutation(tmp_path):
     assert result["ok"] is False
     assert "invalid_status" in result["error"]
     assert path.read_text(encoding="utf-8") == before
+
+
+
+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)),
+    }
+
+
+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",
+        },
+    )
+    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)
+
+    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.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)
+    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
+
+    state = validate_checkpoint_data(payload, project_root=tmp_path)
+
+    assert state.semantic_complete is False
+    assert state.semantic.sequence_valid is False
+    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"},
+    )
+    payload["steps"][2]["authoritative_evidence_paths"] = paths
+
+    state = validate_checkpoint_data(payload, project_root=tmp_path)
+
+    assert state.semantic_complete is False
+    assert state.semantic.evidence_valid is False
+    assert state.semantic.error_code == "incomplete_semantic_evidence"
+
+
+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",
+        },
+    )
+    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"
+
+
+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)
+
+    assert state.valid is False
+    assert state.error_code == "invalid_step_progress"
+
+
+
+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"),
+    ]))
+
+    result = update_checkpoint(str(path), "S02", "in_progress")
+
+    assert result["ok"] is False
+    assert "before all predecessors" 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:]:
+        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_round": 0},
+    )
+    data = json.loads(path.read_text(encoding="utf-8"))
+
+    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"]
+
+
+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:]:
+        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"))
+
+    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"
+
+
+
+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",
+    ]
+    payload = _family_checkpoint(
+        "feature-pipeline",
+        skills,
+        semantic={"authoritative_evidence_paths": paths, "terminal_status": "WORKFLOW_COMPLETED"},
+    )
+    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")
+    present = load_checkpoint_state(checkpoint, project_root=tmp_path)
+
+    assert missing.semantic_complete is False
+    assert missing.semantic.artifacts_valid is False
+    assert present.semantic_complete is True
+    assert present.semantic.artifacts_valid is True
+
+
+
+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",
+    )
+    monkeypatch.setattr(
+        "prizmkit_runtime.checkpoint_state._evidence_validator_passes",
+        lambda *_args: False,
+    )
+
+    result = update_checkpoint(
+        str(checkpoint),
+        "prizmkit-test",
+        "completed",
+        semantic_update={
+            "stage_result": "TEST_PASS",
+            "authoritative_evidence_paths": paths,
+        },
+    )
+
+    assert result["ok"] is False
+    assert "validator-attested" in result["error"]
+
+
+
+def test_update_checkpoint_rejects_test_before_review_pass(tmp_path):
+    payload = _family_checkpoint(
+        "feature-pipeline",
+        [
+            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
+        ],
+    )
+    payload["steps"][1]["status"] = "skipped"
+    payload["steps"][1].pop("stage_result", None)
+    payload["steps"][2]["status"] = "pending"
+    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", "in_progress")
+
+    assert result["ok"] is False
+    assert "REVIEW_PASS" in result["error"]
+
+
+def test_update_checkpoint_rejects_finalization_before_test_pass(tmp_path):
+    payload = _family_checkpoint(
+        "feature-pipeline",
+        [
+            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+            "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
+        ],
+    )
+    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)
+    checkpoint = _write(tmp_path / "workflow-checkpoint.json", payload)
+
+    result = update_checkpoint(str(checkpoint), "prizmkit-retrospective", "in_progress")
+
+    assert result["ok"] is False
+    assert "TEST_PASS" in result["error"]