prizmkit 1.1.140 → 1.1.142

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.140",
-  "bundledAt": "2026-07-20T13:39:17.949Z",
-  "bundledFrom": "9a25298"
+  "frameworkVersion": "1.1.142",
+  "bundledAt": "2026-07-21T07:43:37.944Z",
+  "bundledFrom": "deb1402"
 }

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

@@ -4,20 +4,50 @@ from __future__ import annotations
 
 import json
 import re
-import subprocess
-import sys
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Mapping
 
+from .test_result import valid_test_artifact_pair
+
 VALID_CHECKPOINT_STATUSES = {"pending", "in_progress", "completed", "skipped", "failed"}
 TERMINAL_STEP_STATUSES = {"completed", "skipped"}
 STEP_ID_PATTERN = re.compile(r"^S[0-9]+$")
 MAX_OUTER_REPAIR_ROUNDS = 3
 
 REVIEW_RESULTS = {"REVIEW_PASS", "REVIEW_NEEDS_FIXES"}
-TEST_RESULTS = {"TEST_PASS", "TEST_FAIL", "TEST_BLOCKED"}
-VALID_STAGE_RESULTS = REVIEW_RESULTS | TEST_RESULTS
+TEST_RESULTS = {"TEST_PASS", "TEST_NEEDS_FIXES", "TEST_BLOCKED"}
+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",
@@ -59,11 +89,6 @@ FAMILY_REQUIRED_STAGES = {
         "completion-summary",
     ),
 }
-EVIDENCE_FILENAMES = {
-    "manifest": "manifest.json",
-    "verdict": "verdict.json",
-    "validation": "validation.json",
-}
 
 
 @dataclass(frozen=True)
@@ -77,7 +102,6 @@ class CheckpointStep:
     depends_on: str | None = None
     required_artifacts: tuple[str, ...] = ()
     stage_result: str | None = None
-    authoritative_evidence_paths: Mapping[str, str | None] = field(default_factory=dict)
     index: int = 0
 
     @property
@@ -101,11 +125,10 @@ class SemanticCheckpoint:
     stage_result: str | None = None
     repair_scope: str | None = None
     repair_round: int = 0
-    authoritative_evidence_paths: Mapping[str, str | None] = field(default_factory=dict)
     blocked_reason: str | None = None
     terminal_status: str | None = None
     sequence_valid: bool = False
-    evidence_valid: bool = False
+    test_result_valid: bool = False
     artifacts_valid: bool = False
     completion_ready: bool = False
     complete: bool = False
@@ -121,7 +144,6 @@ class SemanticCheckpoint:
             "stage_result": self.stage_result,
             "repair_scope": self.repair_scope,
             "repair_round": self.repair_round,
-            "authoritative_evidence_paths": dict(self.authoritative_evidence_paths),
             "blocked_reason": self.blocked_reason,
             "terminal_status": self.terminal_status,
         }
@@ -278,11 +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)
-        evidence = raw_step.get("authoritative_evidence_paths", {})
-        if evidence is None:
-            evidence = {}
-        if not _valid_evidence_mapping(evidence):
-            return _invalid(checkpoint_path, exists, "invalid_evidence_paths", f"Step {step_id} has invalid evidence paths", 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,
@@ -292,7 +326,6 @@ def validate_checkpoint_data(
             depends_on=depends_on,
             required_artifacts=tuple(artifacts),
             stage_result=stage_result,
-            authoritative_evidence_paths=dict(evidence),
             index=index,
         )
         steps.append(step)
@@ -415,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:
@@ -449,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")
@@ -465,29 +565,23 @@ def _derive_semantic_state(
         and review_step.status == "completed"
         and review_step.stage_result == "REVIEW_PASS"
     )
-    evidence_paths = (
-        dict(test_step.authoritative_evidence_paths)
-        if test_step and test_step.authoritative_evidence_paths
-        else dict(raw_state.get("authoritative_evidence_paths") or {})
-    )
-    evidence_valid = bool(
+    test_result_valid = bool(
         test_step
         and test_step.status == "completed"
         and test_step.stage_result == "TEST_PASS"
-        and _validate_test_evidence(evidence_paths, checkpoint_path, project_root)
     )
     all_required_completed = bool(required) and all(
         (step := _single_step(steps, skill)) is not None and step.status == "completed"
         for skill in required
     )
     artifacts_valid = all(
-        _required_artifacts_exist(step, checkpoint_path, project_root)
+        _required_step_artifacts_valid(step, checkpoint_path, project_root)
         for step in steps
         if step.status == "completed"
     )
     completion_ready = (
         sequence_valid and all_required_completed and review_valid
-        and evidence_valid and artifacts_valid
+        and test_result_valid and artifacts_valid
     )
     blocked = terminal_status == "WORKFLOW_BLOCKED" and bool(blocked_reason)
     complete = completion_ready and terminal_status == "WORKFLOW_COMPLETED" and not blocked
@@ -495,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
@@ -511,8 +611,8 @@ def _derive_semantic_state(
         error_code = "incomplete_semantic_evidence"
         if not review_valid:
             error_message = "completed checkpoint lacks REVIEW_PASS on the review stage"
-        elif not evidence_valid:
-            error_message = "completed checkpoint lacks valid TEST_PASS structured evidence"
+        elif not test_result_valid:
+            error_message = "completed checkpoint lacks TEST_PASS on the test stage"
         else:
             error_message = "completed checkpoint lacks mandatory completed stages"
     elif terminal_status == "WORKFLOW_COMPLETED" and not completion_ready:
@@ -526,11 +626,10 @@ def _derive_semantic_state(
         stage_result=raw_state.get("stage_result"),
         repair_scope=repair_scope,
         repair_round=repair_round,
-        authoritative_evidence_paths=evidence_paths,
         blocked_reason=blocked_reason,
         terminal_status=terminal_status,
         sequence_valid=sequence_valid,
-        evidence_valid=evidence_valid,
+        test_result_valid=test_result_valid,
         artifacts_valid=artifacts_valid,
         completion_ready=completion_ready,
         complete=complete,
@@ -563,6 +662,30 @@ def _single_step(steps: tuple[CheckpointStep, ...], skill: str) -> CheckpointSte
 
 
 
+def _required_step_artifacts_valid(
+    step: CheckpointStep,
+    checkpoint_path: Path | None,
+    project_root: Path | None,
+) -> bool:
+    """Validate declared artifacts, including semantic test terminal output."""
+    if step.skill == "prizmkit-test":
+        root = (project_root or _infer_project_root(checkpoint_path)).resolve()
+        reports = [item for item in step.required_artifacts if item.endswith("/test-report.md")]
+        results = [item for item in step.required_artifacts if item.endswith("/test-result.json")]
+        if len(reports) != 1 or len(results) != 1:
+            return False
+        report_path = (root / reports[0]).resolve()
+        result_path = (root / results[0]).resolve()
+        if not _is_within_root(report_path, root) or not _is_within_root(result_path, root):
+            return False
+        return valid_test_artifact_pair(
+            report_path,
+            result_path,
+            required_result="TEST_PASS",
+        )
+    return _required_artifacts_exist(step, checkpoint_path, project_root)
+
+
 def _required_artifacts_exist(
     step: CheckpointStep,
     checkpoint_path: Path | None,
@@ -574,7 +697,9 @@ def _required_artifacts_exist(
 
     root = (project_root or _infer_project_root(checkpoint_path)).resolve()
     for artifact in step.required_artifacts:
-        candidate = root / artifact
+        candidate = (root / artifact).resolve()
+        if not _is_within_root(candidate, root):
+            return False
         if glob.has_magic(str(candidate)):
             if not glob.glob(str(candidate)):
                 return False
@@ -582,98 +707,13 @@ def _required_artifacts_exist(
             return False
     return True
 
-def _valid_evidence_mapping(value: object) -> bool:
-    if not isinstance(value, dict):
-        return False
-    return all(
-        key in EVIDENCE_FILENAMES
-        and (path is None or isinstance(path, str))
-        for key, path in value.items()
-    )
-
-
-def _validate_test_evidence(
-    paths: Mapping[str, str | None],
-    checkpoint_path: Path | None,
-    project_root: Path | None,
-) -> bool:
-    if set(paths) != set(EVIDENCE_FILENAMES):
-        return False
-    root = (project_root or _infer_project_root(checkpoint_path)).resolve()
-    resolved: dict[str, Path] = {}
-    for key, filename in EVIDENCE_FILENAMES.items():
-        raw_path = paths.get(key)
-        if not isinstance(raw_path, str) or not raw_path.strip():
-            return False
-        candidate = Path(raw_path)
-        if not candidate.is_absolute():
-            candidate = root / candidate
-        try:
-            candidate = candidate.resolve()
-            candidate.relative_to(root)
-        except (OSError, ValueError):
-            return False
-        if candidate.name != filename or not candidate.is_file():
-            return False
-        resolved[key] = candidate
-    parents = {path.parent for path in resolved.values()}
-    if len(parents) != 1:
-        return False
-    try:
-        manifest = json.loads(resolved["manifest"].read_text(encoding="utf-8"))
-        verdict = json.loads(resolved["verdict"].read_text(encoding="utf-8"))
-        validation = json.loads(resolved["validation"].read_text(encoding="utf-8"))
-    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
-        return False
-    if not all(isinstance(record, dict) for record in (manifest, verdict, validation)):
-        return False
-    evidence_id = manifest.get("evidence_id")
-    if isinstance(evidence_id, str) and evidence_id and resolved["manifest"].parent.name != evidence_id:
-        return False
-    records_agree = (
-        manifest.get("final_verdict") == "TEST_PASS"
-        and verdict.get("verdict") == "TEST_PASS"
-        and validation.get("verdict") == "TEST_PASS"
-        and validation.get("result") == "passed"
-    )
-    if not records_agree:
-        return False
-    validator = _resolve_evidence_validator(root)
-    if validator is None:
-        return False
-    return _evidence_validator_passes(root, resolved["manifest"].parent, validator)
-
 
-def _evidence_validator_passes(
-    project_root: Path,
-    evidence_dir: Path,
-    validator: Path,
-) -> bool:
+def _is_within_root(path: Path, root: Path) -> bool:
     try:
-        result = subprocess.run(
-            [
-                sys.executable, str(validator),
-                "--evidence-dir", str(evidence_dir),
-                "--project-root", str(project_root),
-            ],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            timeout=120,
-            check=False,
-        )
-    except (OSError, subprocess.SubprocessError):
+        path.relative_to(root)
+    except ValueError:
         return False
-    return result.returncode == 0
-
-
-def _resolve_evidence_validator(project_root: Path) -> Path | None:
-    candidates = (
-        project_root / "core" / "skills" / "prizmkit-skill" / "prizmkit-test" / "scripts" / "validate_test_evidence.py",
-        project_root / ".claude" / "command-assets" / "prizmkit-test" / "scripts" / "validate_test_evidence.py",
-        project_root / ".agents" / "skills" / "prizmkit-test" / "scripts" / "validate_test_evidence.py",
-        project_root / ".codebuddy" / "skills" / "prizmkit-test" / "scripts" / "validate_test_evidence.py",
-    )
-    return next((path for path in candidates if path.is_file()), None)
+    return True
 
 
 def _infer_project_root(checkpoint_path: Path | None) -> Path:

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/runner_models.py

@@ -137,23 +137,18 @@ class SemanticCheckpointState:
     stage_result: str | None = None
     repair_scope: str | None = None
     repair_round: int = 0
-    authoritative_evidence_paths: Mapping[str, str | None] = field(default_factory=dict)
     blocked_reason: str | None = None
     terminal_status: str | None = None
 
     @classmethod
     def from_mapping(cls, value: Mapping[str, object] | None) -> "SemanticCheckpointState":
         data = value or {}
-        evidence = data.get("authoritative_evidence_paths")
         return cls(
             current_stage=_optional_text(data.get("current_stage")),
             next_stage=_optional_text(data.get("next_stage")),
             stage_result=_optional_text(data.get("stage_result")),
             repair_scope=_optional_text(data.get("repair_scope")),
             repair_round=max(0, _safe_int(data.get("repair_round"), 0)),
-            authoritative_evidence_paths=(
-                dict(evidence) if isinstance(evidence, Mapping) else {}
-            ),
             blocked_reason=_optional_text(data.get("blocked_reason")),
             terminal_status=_optional_text(data.get("terminal_status")),
         )
@@ -165,7 +160,6 @@ class SemanticCheckpointState:
             "stage_result": self.stage_result,
             "repair_scope": self.repair_scope,
             "repair_round": self.repair_round,
-            "authoritative_evidence_paths": dict(self.authoritative_evidence_paths),
             "blocked_reason": self.blocked_reason,
             "terminal_status": self.terminal_status,
         }

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

@@ -650,8 +650,7 @@ def _process_item_locked(
                         key: metadata.get(key)
                         for key in (
                             "current_stage", "next_stage", "stage_result",
-                            "repair_scope", "repair_round",
-                            "authoritative_evidence_paths", "blocked_reason",
+                            "repair_scope", "repair_round", "blocked_reason",
                             "terminal_status",
                         )
                     },
@@ -863,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",