prizmkit 1.1.141 → 1.1.143

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.141",
-  "bundledAt": "2026-07-21T00:43:15.672Z",
-  "bundledFrom": "df5581e"
+  "frameworkVersion": "1.1.143",
+  "bundledAt": "2026-07-21T14:41:54.248Z",
+  "bundledFrom": "1e6fbd1"
 }

package/bundled/dev-pipeline/README.md

@@ -359,7 +359,7 @@ python3 scripts/update-feature-status.py \
 | `complete` | `--feature-id` | Shortcut for manually marking completed |
 
 **Session status values (for `--session-status`):**
-`success`, `partial_resumable`, `partial_not_resumable`, `failed`, `crashed`, `commit_missing`, `docs_missing`, `merge_conflict`
+`success`, `partial_resumable`, `partial_not_resumable`, `failed`, `crashed`, `timed_out`, `infra_error`, `context_overflow`, `stalled_context_continuation`, `workflow_blocked`, `workflow_skipped`, `commit_missing`, `docs_missing`, `merge_conflict`
 
 **Output (JSON to stdout):**
 

package/bundled/dev-pipeline/prizmkit_runtime/checkpoint_state.py

@@ -17,7 +17,37 @@ MAX_OUTER_REPAIR_ROUNDS = 3
 
 REVIEW_RESULTS = {"REVIEW_PASS", "REVIEW_NEEDS_FIXES"}
 TEST_RESULTS = {"TEST_PASS", "TEST_NEEDS_FIXES", "TEST_BLOCKED"}
-VALID_STAGE_RESULTS = REVIEW_RESULTS | TEST_RESULTS
+PLAN_RESULTS = {"PLAN_READY", "PLAN_BLOCKED"}
+IMPLEMENT_RESULTS = {"IMPLEMENTED", "IMPLEMENT_REPAIR", "IMPLEMENT_BLOCKED"}
+RETROSPECTIVE_RESULTS = {"RETRO_COMPLETE", "RETRO_BLOCKED"}
+COMMIT_RESULTS = {"COMMIT_PENDING", "COMMITTED", "COMMIT_BLOCKED"}
+VALID_STAGE_RESULTS = (
+    REVIEW_RESULTS
+    | TEST_RESULTS
+    | PLAN_RESULTS
+    | IMPLEMENT_RESULTS
+    | RETROSPECTIVE_RESULTS
+    | COMMIT_RESULTS
+)
+STAGE_RESULT_OWNERS = {
+    "prizmkit-plan": PLAN_RESULTS,
+    "prizmkit-implement": IMPLEMENT_RESULTS,
+    "prizmkit-code-review": REVIEW_RESULTS,
+    "prizmkit-test": TEST_RESULTS,
+    "prizmkit-retrospective": RETROSPECTIVE_RESULTS,
+    "prizmkit-committer": COMMIT_RESULTS,
+}
+WORKFLOW_STAGE_SKILLS = {
+    "plan": "prizmkit-plan",
+    "implement": "prizmkit-implement",
+    "code-review": "prizmkit-code-review",
+    "test": "prizmkit-test",
+    "retrospective": "prizmkit-retrospective",
+    "committer": "prizmkit-committer",
+}
+SKILL_WORKFLOW_STAGES = {
+    skill: stage for stage, skill in WORKFLOW_STAGE_SKILLS.items()
+}
 VALID_TERMINAL_STATUSES = {"WORKFLOW_COMPLETED", "WORKFLOW_BLOCKED"}
 VALID_REPAIR_SCOPES = {
     "production",
@@ -270,6 +300,23 @@ def validate_checkpoint_data(
         stage_result = raw_step.get("stage_result")
         if stage_result is not None and stage_result not in VALID_STAGE_RESULTS:
             return _invalid(checkpoint_path, exists, "invalid_stage_result", f"Step {step_id} has invalid stage_result", data)
+        if stage_result is not None and not stage_result_allowed_for_skill(skill, stage_result):
+            return _invalid(
+                checkpoint_path,
+                exists,
+                "stage_result_owner_mismatch",
+                f"Step {step_id} cannot record {stage_result} for {skill}",
+                data,
+            )
+        expected_status = _expected_status_for_result(stage_result)
+        if expected_status is not None and status != expected_status:
+            return _invalid(
+                checkpoint_path,
+                exists,
+                "stage_result_status_mismatch",
+                f"Step {step_id} requires status={expected_status} for {stage_result}",
+                data,
+            )
 
         step = CheckpointStep(
             id=step_id,
@@ -401,6 +448,47 @@ def semantic_state_key(workflow_type: str) -> str:
     return SEMANTIC_STATE_KEYS.get(workflow_type, "l4_state")
 
 
+def expected_status_for_stage_result(stage_result: str | None) -> str | None:
+    """Return the lifecycle status required by one domain stage result."""
+    return _expected_status_for_result(stage_result)
+
+
+def stage_result_allowed_for_skill(skill: str, stage_result: str | None) -> bool:
+    """Return whether one stage owns the supplied domain result."""
+    if stage_result is None:
+        return True
+    allowed_results = STAGE_RESULT_OWNERS.get(skill)
+    return allowed_results is not None and stage_result in allowed_results
+
+
+def _expected_status_for_result(stage_result: str | None) -> str | None:
+    if stage_result is None:
+        return None
+    if stage_result == "COMMIT_PENDING":
+        return "in_progress"
+    if stage_result in {
+        "REVIEW_PASS",
+        "TEST_PASS",
+        "PLAN_READY",
+        "IMPLEMENTED",
+        "RETRO_COMPLETE",
+        "COMMITTED",
+    }:
+        return "completed"
+    if stage_result in {
+        "REVIEW_NEEDS_FIXES",
+        "TEST_NEEDS_FIXES",
+        "TEST_BLOCKED",
+        "PLAN_BLOCKED",
+        "IMPLEMENT_REPAIR",
+        "IMPLEMENT_BLOCKED",
+        "RETRO_BLOCKED",
+        "COMMIT_BLOCKED",
+    }:
+        return "failed"
+    return None
+
+
 def _progress_error(steps: list[CheckpointStep]) -> str:
     active_seen = False
     for step in steps:
@@ -435,6 +523,32 @@ def _derive_semantic_state(
     repair_scope = raw_state.get("repair_scope")
     if repair_scope is not None and repair_scope not in VALID_REPAIR_SCOPES:
         return _semantic_error(workflow_type, current_step, "invalid_repair_scope", "repair_scope is not a safe shared scope")
+    semantic_status = raw_state.get("status")
+    if semantic_status is not None and semantic_status not in VALID_CHECKPOINT_STATUSES:
+        return _semantic_error(workflow_type, current_step, "invalid_semantic_status", "semantic status is not a lifecycle status")
+    semantic_stage_result = raw_state.get("stage_result")
+    if semantic_stage_result is not None and semantic_stage_result not in VALID_STAGE_RESULTS:
+        return _semantic_error(workflow_type, current_step, "invalid_semantic_stage_result", "semantic stage_result is not recognized")
+    expected_semantic_status = _expected_status_for_result(semantic_stage_result)
+    if semantic_status is not None and expected_semantic_status is not None and semantic_status != expected_semantic_status:
+        return _semantic_error(
+            workflow_type,
+            current_step,
+            "semantic_stage_result_status_mismatch",
+            f"Semantic {semantic_stage_result} requires status={expected_semantic_status}",
+        )
+    semantic_stage = raw_state.get("stage")
+    if semantic_stage is not None and (not isinstance(semantic_stage, str) or not semantic_stage.strip()):
+        return _semantic_error(workflow_type, current_step, "invalid_semantic_stage", "semantic stage must be a non-empty string")
+    if semantic_stage_result is not None:
+        semantic_skill = WORKFLOW_STAGE_SKILLS.get(semantic_stage, semantic_stage)
+        if not stage_result_allowed_for_skill(semantic_skill, semantic_stage_result):
+            return _semantic_error(
+                workflow_type,
+                current_step,
+                "semantic_stage_result_owner_mismatch",
+                f"Semantic stage {semantic_stage} cannot record {semantic_stage_result}",
+            )
     terminal_status = raw_state.get("terminal_status")
     if terminal_status is not None and terminal_status not in VALID_TERMINAL_STATUSES:
         return _semantic_error(workflow_type, current_step, "invalid_terminal_status", "terminal_status is not recognized")
@@ -475,9 +589,15 @@ def _derive_semantic_state(
     current_stage = current_step.skill if current_step is not None else None
     next_stage = current_stage
     if current_step is not None and current_step.status == "in_progress":
-        later = steps[current_step.index + 1:]
-        next_step = next((step for step in later if step.status not in TERMINAL_STEP_STATUSES), None)
-        next_stage = next_step.skill if next_step is not None else None
+        next_stage = current_stage
+    if (
+        current_step is not None
+        and current_step.status == "failed"
+        and current_step.stage_result == "REVIEW_NEEDS_FIXES"
+        and raw_state.get("stage_result") == "REVIEW_NEEDS_FIXES"
+        and raw_state.get("next_stage") == "prizmkit-implement"
+    ):
+        next_stage = "prizmkit-implement"
     if terminal_status is not None:
         current_stage = None
         next_stage = None

package/bundled/dev-pipeline/prizmkit_runtime/runner_classification.py

@@ -13,6 +13,7 @@ from .sessions import AISessionResult
 
 CONTEXT_OVERFLOW = "context_overflow"
 WORKFLOW_BLOCKED = "workflow_blocked"
+WORKFLOW_SKIPPED = "workflow_skipped"
 STALL_REASON = "context_overflow_without_git_checkpoint_or_artifact_progress"
 CONTEXT_MARKERS = (
     "context_overflow",
@@ -50,8 +51,9 @@ def classify_session(
     fingerprint = progress_fingerprint(project_root, prompt)
     checkpoint = _workflow_checkpoint(prompt, project_root)
     if checkpoint is not None and not checkpoint.valid:
+        session_status = WORKFLOW_SKIPPED if _is_terminal_success(result) else "crashed"
         return SessionClassification(
-            "crashed",
+            session_status,
             reason=f"invalid_workflow_checkpoint:{checkpoint.error_code}",
             progress_fingerprint=fingerprint,
             checkpoint_state=checkpoint.semantic_snapshot,
@@ -79,6 +81,16 @@ def classify_session(
         )
 
     semantic = checkpoint.semantic_snapshot if checkpoint is not None else {}
+    if _is_terminal_success(result):
+        reason = "no_semantic_completion"
+        if checkpoint is not None and checkpoint.semantic.error_code:
+            reason = f"{reason}:{checkpoint.semantic.error_code}"
+        return SessionClassification(
+            WORKFLOW_SKIPPED,
+            reason=reason,
+            progress_fingerprint=fingerprint,
+            checkpoint_state=semantic,
+        )
     if _is_context_overflow(result):
         no_progress_count = _next_no_progress_count(previous_fingerprint, fingerprint, previous_no_progress_count)
         if no_progress_count >= 2:

package/bundled/dev-pipeline/prizmkit_runtime/runners.py

@@ -862,7 +862,10 @@ def _emit_interruption_cleanup_failure(result, message: str, recovery: str) -> N
 
 def _is_retryable_ai_outcome(session_status: str, new_status: str) -> bool:
     """Return whether a persisted post-launch outcome should continue in-process."""
-    if session_status in {"success", "stalled_context_continuation", "workflow_blocked"}:
+    if session_status in {
+        "success", "stalled_context_continuation", "workflow_blocked",
+        "workflow_skipped",
+    }:
         return False
     return new_status in {"in_progress", "pending"} and session_status in {
         "context_overflow",

package/bundled/dev-pipeline/prizmkit_runtime/test_result.py

@@ -9,6 +9,12 @@ from typing import Any
 
 TEST_RESULTS = {"TEST_PASS", "TEST_NEEDS_FIXES", "TEST_BLOCKED"}
 INDEPENDENT_REVIEW_STATUSES = {"completed", "downgraded", "not_applicable"}
+_RESULT_LINE_PATTERN = re.compile(
+    r"(?m)^- Result:\s*(TEST_PASS|TEST_NEEDS_FIXES|TEST_BLOCKED)\s*$"
+)
+_BARE_RESULT_LINE_PATTERN = re.compile(
+    r"(?m)^(TEST_PASS|TEST_NEEDS_FIXES|TEST_BLOCKED)\s*$"
+)
 _RESULT_KEYS = {
     "schema_version",
     "result",
@@ -128,18 +134,22 @@ def valid_test_artifact_pair(
 
 
 def _report_final_result(report: str) -> str | None:
-    """Extract the result declared in the report's Final Result section."""
-    match = re.search(
-        r"(?ms)^## Final Result\s*$\n(?P<body>.*?)(?=^## |\Z)",
+    """Extract one unambiguous result from a supported terminal section."""
+    declared_results: list[str] = []
+    for match in re.finditer(
+        r"(?ms)^## (?P<title>Final Result|Terminal Result|Final Decision)\s*$\n"
+        r"(?P<body>.*?)(?=^## |\Z)",
         report,
-    )
-    if not match:
+    ):
+        body = match.group("body")
+        result_lines = _RESULT_LINE_PATTERN.findall(body)
+        if match.group("title") == "Final Decision":
+            result_lines.extend(_BARE_RESULT_LINE_PATTERN.findall(body))
+        declared_results.extend(result_lines)
+
+    if not declared_results or len(set(declared_results)) != 1:
         return None
-    result = re.search(
-        r"(?m)^- Result:\s*(TEST_PASS|TEST_NEEDS_FIXES|TEST_BLOCKED)\s*$",
-        match.group("body"),
-    )
-    return result.group(1) if result else None
+    return declared_results[0]
 
 
 def _integer_in_range(value: object, minimum: int, maximum: int) -> bool:

package/bundled/dev-pipeline/scripts/check-session-status.py

@@ -150,7 +150,9 @@ def determine_status(data):
     """Determine the single-line status string from the parsed data.
 
     Returns one of: success, partial_resumable, partial_not_resumable,
-    failed, commit_missing, docs_missing, merge_conflict, context_overflow.
+    failed, crashed, timed_out, infra_error, commit_missing, docs_missing,
+    merge_conflict, context_overflow, stalled_context_continuation,
+    workflow_blocked, workflow_skipped.
     """
     status = data.get("status", "")
 
@@ -174,12 +176,20 @@ def determine_status(data):
         return "crashed"
     elif status == "timed_out":
         return "timed_out"
+    elif status == "infra_error":
+        return "infra_error"
+    elif status == "stalled_context_continuation":
+        return "stalled_context_continuation"
     elif status == "commit_missing":
         return "commit_missing"
     elif status == "docs_missing":
         return "docs_missing"
     elif status == "merge_conflict":
         return "merge_conflict"
+    elif status == "workflow_blocked":
+        return "workflow_blocked"
+    elif status == "workflow_skipped":
+        return "workflow_skipped"
     else:
         # Unknown status value — treat as crashed
         return "crashed"

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

@@ -717,7 +717,7 @@ def route_feature_repair(stage_result, repair_scope=None, repair_round=0):
 
 
 def feature_checkpoint_metadata(artifact_dir, stage="plan",
-                                status="PLAN_READY", stage_result=None,
+                                status="pending", stage_result=None,
                                 repair_scope=None, repair_round=0,
                                 next_stage="prizmkit-implement",
                                 resume_from="prizmkit-implement"):
@@ -1478,7 +1478,7 @@ def main():
         checkpoint["feature_state"] = feature_checkpoint_metadata(
             os.path.join(".prizmkit", "specs", feature_slug),
             stage="plan",
-            status="PLAN_READY",
+            status="pending",
             stage_result=None,
             next_stage="prizmkit-implement",
             resume_from="prizmkit-implement",

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

@@ -41,7 +41,7 @@ def route_bugfix_repair(stage_result, repair_scope=None, repair_round=0):
 
 
 def bugfix_checkpoint_metadata(artifact_dir, stage="plan",
-                               status="PLAN_READY", stage_result=None,
+                               status="pending", stage_result=None,
                                repair_scope=None, repair_round=0,
                                next_stage="prizmkit-implement",
                                resume_from="prizmkit-implement"):
@@ -536,7 +536,7 @@ def main():
     checkpoint["bugfix_state"] = bugfix_checkpoint_metadata(
         replacements["{{ARTIFACT_DIR}}"],
         stage="plan",
-        status="PLAN_READY",
+        status="pending",
         stage_result=None,
         repair_scope=None,
         repair_round=0,

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

@@ -41,7 +41,7 @@ def route_refactor_repair(stage_result, repair_scope=None, repair_round=0):
 
 
 def refactor_checkpoint_metadata(artifact_dir, stage="plan",
-                                 status="PLAN_READY", stage_result=None,
+                                 status="pending", stage_result=None,
                                  repair_scope=None, repair_round=0,
                                  next_stage="prizmkit-implement",
                                  resume_from="prizmkit-implement"):
@@ -554,7 +554,7 @@ def main():
     checkpoint["refactor_state"] = refactor_checkpoint_metadata(
         replacements["{{ARTIFACT_DIR}}"],
         stage="plan",
-        status="PLAN_READY",
+        status="pending",
         stage_result=None,
         repair_scope=None,
         repair_round=0,

package/bundled/dev-pipeline/scripts/prompt_framework.py

@@ -14,6 +14,10 @@ _PIPELINE_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 if _PIPELINE_ROOT not in sys.path:
     sys.path.insert(0, _PIPELINE_ROOT)
 
+from prizmkit_runtime.checkpoint_state import (  # noqa: E402
+    VALID_CHECKPOINT_STATUSES,
+    expected_status_for_stage_result,
+)
 from prizmkit_runtime.test_result import valid_test_artifact_pair  # noqa: E402
 
 
@@ -95,12 +99,19 @@ def route_pipeline_repair(stage_result, repair_scope=None, repair_round=0):
 
 
 def pipeline_checkpoint_metadata(artifact_dir, stage="plan",
-                                 status="PLAN_READY", stage_result=None,
+                                 status="pending", stage_result=None,
                                  repair_scope=None, repair_round=0,
                                  next_stage="prizmkit-implement",
                                  resume_from="prizmkit-implement",
                                  blocked_reason=None, terminal_status=None):
     """Build family-neutral pipeline metadata without replacing skill state."""
+    if status not in VALID_CHECKPOINT_STATUSES:
+        raise ValueError("Invalid checkpoint lifecycle status: {}".format(status))
+    expected_status = expected_status_for_stage_result(stage_result)
+    if expected_status is None and stage_result is not None:
+        raise ValueError("Invalid checkpoint stage result: {}".format(stage_result))
+    if expected_status is not None and status != expected_status:
+        raise ValueError("{} requires status={}".format(stage_result, expected_status))
     current_stage = None if terminal_status else stage
     semantic_next_stage = None if terminal_status else next_stage
     return {

package/bundled/dev-pipeline/scripts/update-bug-status.py

@@ -47,6 +47,7 @@ SESSION_STATUS_VALUES = [
     "context_overflow",
     "stalled_context_continuation",
     "workflow_blocked",
+    "workflow_skipped",
     "commit_missing",
     "docs_missing",
     "merge_conflict",
@@ -593,6 +594,20 @@ def action_update(args, bug_list_path, state_dir):
             if err:
                 error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
                 return
+    elif session_status == "workflow_skipped":
+        # A completed AI CLI session without authoritative workflow evidence is
+        # skipped, not crashed. Preserve diagnostics and spend no retry budget.
+        new_status = "skipped"
+        bs["continuation_pending"] = False
+        bs.pop("continuation_reason", None)
+        bs.pop("terminal_status", None)
+        bs.pop("blocked_reason", None)
+        bs["needs_attention"] = True
+        bs["skipped_reason"] = "workflow_completion_evidence_invalid"
+        err = update_bug_in_list(bug_list_path, bug_id, new_status)
+        if err:
+            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
+            return
     elif session_status == "workflow_blocked":
         # Semantic terminal state: preserve partial work without consuming any retry budget.
         new_status = "needs_info"
@@ -677,6 +692,11 @@ def action_update(args, bug_list_path, state_dir):
         summary["restart_policy"] = "context_overflow_continuation"
         summary.update(continuation_metadata_summary(bs))
         summary["artifacts_preserved"] = True
+    elif session_status == "workflow_skipped":
+        summary["restart_policy"] = "terminal_skipped"
+        summary.update(continuation_metadata_summary(bs))
+        summary["checkpoint_state"] = semantic_checkpoint
+        summary["artifacts_preserved"] = True
     elif session_status == "workflow_blocked":
         summary["restart_policy"] = "terminal_blocked"
         summary.update(continuation_metadata_summary(bs))

package/bundled/dev-pipeline/scripts/update-checkpoint.py

@@ -15,12 +15,16 @@ if _PIPELINE_ROOT not in sys.path:
 from prizmkit_runtime.checkpoint_state import (  # noqa: E402
     MAX_OUTER_REPAIR_ROUNDS,
     REVIEW_RESULTS,
+    SKILL_WORKFLOW_STAGES,
     STEP_ID_PATTERN,
     TERMINAL_STEP_STATUSES,
     TEST_RESULTS,
     VALID_CHECKPOINT_STATUSES,
+    VALID_STAGE_RESULTS,
     VALID_REPAIR_SCOPES,
     VALID_TERMINAL_STATUSES,
+    expected_status_for_stage_result,
+    stage_result_allowed_for_skill,
     load_checkpoint_state,
     semantic_state_key,
     validate_checkpoint_data,
@@ -134,6 +138,12 @@ def _validate_semantic_update(step, semantic_update):
         return "Review verdicts may only be recorded on prizmkit-code-review"
     if stage_result in TEST_RESULTS and skill != "prizmkit-test":
         return "Test verdicts may only be recorded on prizmkit-test"
+    if not stage_result_allowed_for_skill(skill, stage_result):
+        return "{} cannot record stage result {}".format(skill, stage_result)
+    expected_status = expected_status_for_stage_result(stage_result)
+    if expected_status is not None and semantic_update.get("status") is not None:
+        if semantic_update["status"] != expected_status:
+            return "{} requires status={}".format(stage_result, expected_status)
     repair_scope = semantic_update.get("repair_scope")
     if repair_scope is not None and repair_scope not in VALID_REPAIR_SCOPES:
         return "Invalid repair_scope '{}'".format(repair_scope)
@@ -150,7 +160,7 @@ def _validate_semantic_update(step, semantic_update):
 
 def _apply_repair_policy(l4_state, stage_result, repair_scope):
     if stage_result not in {"REVIEW_NEEDS_FIXES", "TEST_NEEDS_FIXES", "TEST_BLOCKED"}:
-        return
+        return False
     current_round = l4_state.get("repair_round", 0)
     if not isinstance(current_round, int) or isinstance(current_round, bool):
         current_round = MAX_OUTER_REPAIR_ROUNDS
@@ -165,7 +175,7 @@ def _apply_repair_policy(l4_state, stage_result, repair_scope):
             current_stage=None,
             next_stage=None,
         )
-        return
+        return False
     if current_round >= MAX_OUTER_REPAIR_ROUNDS:
         l4_state.update(
             repair_round=MAX_OUTER_REPAIR_ROUNDS,
@@ -174,7 +184,7 @@ def _apply_repair_policy(l4_state, stage_result, repair_scope):
             current_stage=None,
             next_stage=None,
         )
-        return
+        return False
     if repair_scope not in VALID_REPAIR_SCOPES:
         l4_state.update(
             terminal_status="WORKFLOW_BLOCKED",
@@ -182,14 +192,15 @@ def _apply_repair_policy(l4_state, stage_result, repair_scope):
             current_stage=None,
             next_stage=None,
         )
-        return
+        return False
     l4_state["repair_round"] = current_round + 1
     l4_state["terminal_status"] = None
     l4_state["blocked_reason"] = None
     l4_state["next_stage"] = "prizmkit-implement"
+    return True
 
 
-def _sync_cursor(data, l4_state):
+def _sync_cursor(data, l4_state, preserve_next_stage=False):
     active = next(
         (step for step in data["steps"] if step.get("status") not in TERMINAL_STEP_STATUSES),
         None,
@@ -198,8 +209,9 @@ def _sync_cursor(data, l4_state):
         l4_state["current_stage"] = None
         l4_state["next_stage"] = None
         return
+    routed_stage = l4_state.get("next_stage") if preserve_next_stage else None
     l4_state["current_stage"] = active.get("skill") if active else None
-    l4_state["next_stage"] = active.get("skill") if active else None
+    l4_state["next_stage"] = routed_stage or (active.get("skill") if active else None)
 
 def _checkpoint_project_root(checkpoint_path):
     """Resolve the project root from a conventional .prizmkit checkpoint path."""
@@ -296,6 +308,12 @@ def update_checkpoint(
         stage_result = stage_result or step.get("stage_result")
         if stage_result != "TEST_PASS":
             return {"ok": False, "error": "Test completion requires TEST_PASS"}
+    expected_status = expected_status_for_stage_result(stage_result)
+    if expected_status is not None and new_status != expected_status:
+        return {
+            "ok": False,
+            "error": "{} requires status={}".format(stage_result, expected_status),
+        }
 
     old_status = step.get("status", "unknown")
     step["status"] = new_status
@@ -303,6 +321,8 @@ def update_checkpoint(
         step["note"] = note
     if stage_result:
         step["stage_result"] = stage_result
+    else:
+        step.pop("stage_result", None)
 
     workflow_type = str(data.get("workflow_type") or "")
     state_key = semantic_state_key(workflow_type)
@@ -320,10 +340,19 @@ def update_checkpoint(
             l4_state[key] = semantic_update[key]
     l4_state["schema_version"] = 1
     l4_state["orchestrator"] = "prizmkit-l4"
+    skill = step.get("skill")
+    l4_state["stage"] = SKILL_WORKFLOW_STAGES.get(skill, skill)
+    l4_state["status"] = new_status
     if stage_result:
         l4_state["stage_result"] = stage_result
-    _apply_repair_policy(l4_state, stage_result, semantic_update.get("repair_scope") or l4_state.get("repair_scope"))
-    _sync_cursor(data, l4_state)
+    else:
+        l4_state.pop("stage_result", None)
+    repair_route_selected = _apply_repair_policy(
+        l4_state,
+        stage_result,
+        semantic_update.get("repair_scope") or l4_state.get("repair_scope"),
+    )
+    _sync_cursor(data, l4_state, preserve_next_stage=repair_route_selected)
     _finalize_semantics(checkpoint_path, data, state_key)
 
     final_state = validate_checkpoint_data(
@@ -362,7 +391,7 @@ def main():
     parser.add_argument("--step", required=True)
     parser.add_argument("--status", required=True, choices=sorted(VALID_STATUSES))
     parser.add_argument("--note", default=None)
-    parser.add_argument("--stage-result", choices=sorted(REVIEW_RESULTS | TEST_RESULTS), default=None)
+    parser.add_argument("--stage-result", choices=sorted(VALID_STAGE_RESULTS), default=None)
     parser.add_argument("--repair-scope", choices=sorted(VALID_REPAIR_SCOPES), default=None)
     parser.add_argument("--repair-round", type=int, default=None)
     parser.add_argument("--blocked-reason", default=None)

package/bundled/dev-pipeline/scripts/update-feature-status.py

@@ -51,6 +51,7 @@ SESSION_STATUS_VALUES = [
     "context_overflow",
     "stalled_context_continuation",
     "workflow_blocked",
+    "workflow_skipped",
     "commit_missing",
     "docs_missing",
     "merge_conflict",
@@ -1021,6 +1022,20 @@ def action_update(args, feature_list_path, state_dir):
             if err:
                 error_out("Failed to update .prizmkit/plans/feature-list.json: {}".format(err))
                 return
+    elif session_status == "workflow_skipped":
+        # A completed AI CLI session without authoritative workflow evidence is
+        # skipped, not crashed. Preserve diagnostics and spend no retry budget.
+        new_status = "skipped"
+        fs["continuation_pending"] = False
+        fs.pop("continuation_reason", None)
+        fs.pop("terminal_status", None)
+        fs.pop("blocked_reason", None)
+        fs["needs_attention"] = True
+        fs["skipped_reason"] = "workflow_completion_evidence_invalid"
+        err = update_feature_in_list(feature_list_path, feature_id, new_status)
+        if err:
+            error_out("Failed to update .prizmkit/plans/feature-list.json: {}".format(err))
+            return
     elif session_status == "workflow_blocked":
         # Semantic terminal state: preserve partial work without consuming any retry budget.
         new_status = "failed"
@@ -1119,6 +1134,11 @@ def action_update(args, feature_list_path, state_dir):
         summary["restart_policy"] = "context_overflow_continuation"
         summary.update(continuation_metadata_summary(fs))
         summary["artifacts_preserved"] = True
+    elif session_status == "workflow_skipped":
+        summary["restart_policy"] = "terminal_skipped"
+        summary.update(continuation_metadata_summary(fs))
+        summary["checkpoint_state"] = semantic_checkpoint
+        summary["artifacts_preserved"] = True
     elif session_status == "workflow_blocked":
         summary["restart_policy"] = "terminal_blocked"
         summary.update(continuation_metadata_summary(fs))

package/bundled/dev-pipeline/scripts/update-refactor-status.py

@@ -48,6 +48,7 @@ SESSION_STATUS_VALUES = [
     "context_overflow",
     "stalled_context_continuation",
     "workflow_blocked",
+    "workflow_skipped",
     "commit_missing",
     "docs_missing",
     "merge_conflict",
@@ -597,6 +598,20 @@ def action_update(args, refactor_list_path, state_dir):
             if err:
                 error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
                 return
+    elif session_status == "workflow_skipped":
+        # A completed AI CLI session without authoritative workflow evidence is
+        # skipped, not crashed. Preserve diagnostics and spend no retry budget.
+        new_status = "skipped"
+        rs["continuation_pending"] = False
+        rs.pop("continuation_reason", None)
+        rs.pop("terminal_status", None)
+        rs.pop("blocked_reason", None)
+        rs["needs_attention"] = True
+        rs["skipped_reason"] = "workflow_completion_evidence_invalid"
+        err = update_refactor_in_list(refactor_list_path, refactor_id, new_status)
+        if err:
+            error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
+            return
     elif session_status == "workflow_blocked":
         # Semantic terminal state: preserve partial work without consuming any retry budget.
         new_status = "failed"
@@ -690,6 +705,11 @@ def action_update(args, refactor_list_path, state_dir):
         summary["restart_policy"] = "context_overflow_continuation"
         summary.update(continuation_metadata_summary(rs))
         summary["artifacts_preserved"] = True
+    elif session_status == "workflow_skipped":
+        summary["restart_policy"] = "terminal_skipped"
+        summary.update(continuation_metadata_summary(rs))
+        summary["checkpoint_state"] = semantic_checkpoint
+        summary["artifacts_preserved"] = True
     elif session_status == "workflow_blocked":
         summary["restart_policy"] = "terminal_blocked"
         summary.update(continuation_metadata_summary(rs))