prizmkit 1.1.139 → 1.1.141

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.139",
-  "bundledAt": "2026-07-20T10:59:24.300Z",
-  "bundledFrom": "a055a29"
+  "frameworkVersion": "1.1.141",
+  "bundledAt": "2026-07-21T00:43:15.672Z",
+  "bundledFrom": "df5581e"
 }

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

@@ -4,19 +4,19 @@ 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"}
+TEST_RESULTS = {"TEST_PASS", "TEST_NEEDS_FIXES", "TEST_BLOCKED"}
 VALID_STAGE_RESULTS = REVIEW_RESULTS | TEST_RESULTS
 VALID_TERMINAL_STATUSES = {"WORKFLOW_COMPLETED", "WORKFLOW_BLOCKED"}
 VALID_REPAIR_SCOPES = {
@@ -59,11 +59,6 @@ FAMILY_REQUIRED_STAGES = {
         "completion-summary",
     ),
 }
-EVIDENCE_FILENAMES = {
-    "manifest": "manifest.json",
-    "verdict": "verdict.json",
-    "validation": "validation.json",
-}
 
 
 @dataclass(frozen=True)
@@ -77,7 +72,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 +95,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 +114,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 +270,6 @@ 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)
 
         step = CheckpointStep(
             id=step_id,
@@ -292,7 +279,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)
@@ -465,29 +451,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
@@ -511,8 +491,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 +506,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 +542,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 +577,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 +587,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 / ".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",
-        project_root / "core" / "skills" / "prizmkit-skill" / "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_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",
                         )
                     },

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

@@ -0,0 +1,150 @@
+"""Validation for prizmkit-test terminal result and report artifacts."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+TEST_RESULTS = {"TEST_PASS", "TEST_NEEDS_FIXES", "TEST_BLOCKED"}
+INDEPENDENT_REVIEW_STATUSES = {"completed", "downgraded", "not_applicable"}
+_RESULT_KEYS = {
+    "schema_version",
+    "result",
+    "report",
+    "main_review_rounds",
+    "independent_review",
+    "repair_rounds",
+    "production_changed",
+    "review_required",
+    "review_scope",
+    "unresolved_items",
+}
+_INDEPENDENT_REVIEW_KEYS = {
+    "status",
+    "responses",
+    "downgrade_reason",
+    "final_state_rechecked",
+}
+
+
+def load_test_result(path: str | Path) -> dict[str, Any] | None:
+    """Load one valid terminal projection, or return None."""
+    try:
+        value = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, ValueError, TypeError):
+        return None
+    if not isinstance(value, dict):
+        return None
+    if set(value) != _RESULT_KEYS or value.get("schema_version") != 1:
+        return None
+    if value.get("result") not in TEST_RESULTS or value.get("report") != "test-report.md":
+        return None
+
+    rounds = value.get("main_review_rounds")
+    repairs = value.get("repair_rounds")
+    if not _integer_in_range(rounds, 0, 10) or not _integer_in_range(repairs, 0, 3):
+        return None
+
+    independent = value.get("independent_review")
+    if not isinstance(independent, dict) or set(independent) != _INDEPENDENT_REVIEW_KEYS:
+        return None
+    status = independent.get("status")
+    responses = independent.get("responses")
+    if status not in INDEPENDENT_REVIEW_STATUSES or not _integer_in_range(responses, 0, 5):
+        return None
+    if not isinstance(independent.get("final_state_rechecked"), bool):
+        return None
+    downgrade_reason = independent.get("downgrade_reason")
+    if status == "downgraded":
+        if not isinstance(downgrade_reason, str) or not downgrade_reason.strip():
+            return None
+        if responses != 0 or independent["final_state_rechecked"]:
+            return None
+    elif downgrade_reason is not None:
+        return None
+    if status == "completed":
+        if responses < 1 or not independent["final_state_rechecked"]:
+            return None
+    if status == "not_applicable":
+        if responses != 0 or independent["final_state_rechecked"]:
+            return None
+
+    if not isinstance(value.get("production_changed"), bool):
+        return None
+    if not isinstance(value.get("review_required"), bool):
+        return None
+    expected_scope = "delta" if value["review_required"] else None
+    if value.get("review_scope") != expected_scope:
+        return None
+    unresolved = value.get("unresolved_items")
+    if not isinstance(unresolved, list) or any(
+        not isinstance(item, str) or not item.strip() for item in unresolved
+    ):
+        return None
+
+    if value["result"] == "TEST_PASS":
+        if value["review_required"] or unresolved or rounds < 1:
+            return None
+    return value
+
+
+def valid_test_result(path: str | Path, *, required_result: str | None = None) -> bool:
+    """Return whether the terminal projection is valid and has the required result."""
+    value = load_test_result(path)
+    return value is not None and (
+        required_result is None or value.get("result") == required_result
+    )
+
+
+def valid_test_artifact_pair(
+    report_path: str | Path,
+    result_path: str | Path,
+    *,
+    required_result: str | None = None,
+) -> bool:
+    """Validate one sibling report/result pair and their terminal result."""
+    report = Path(report_path)
+    result = Path(result_path)
+    if not report.is_file() or not result.is_file():
+        return False
+    if report.resolve().parent != result.resolve().parent:
+        return False
+    projection = load_test_result(result)
+    if projection is None:
+        return False
+    if required_result is not None and projection.get("result") != required_result:
+        return False
+    try:
+        report_text = report.read_text(encoding="utf-8")
+    except OSError:
+        return False
+    final_result = _report_final_result(report_text)
+    return (
+        report_text.startswith("# Test Report")
+        and final_result == projection["result"]
+    )
+
+
+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)",
+        report,
+    )
+    if not match:
+        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
+
+
+def _integer_in_range(value: object, minimum: int, maximum: int) -> bool:
+    return (
+        isinstance(value, int)
+        and not isinstance(value, bool)
+        and minimum <= value <= maximum
+    )