prizmkit 1.1.152 → 1.1.154

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

@@ -1,4 +1,4 @@
-"""Tests for auto-skip and unskip functionality in update-feature-status.py."""
+"""Tests for auto-skip and reset_state functionality in update-feature-status.py."""
 
 import json
 import os
@@ -221,6 +221,76 @@ class TestContextOverflowRetrySemantics:
         ]:
             assert key not in status
 
+    def test_start_and_update_persist_effective_retry_budgets_without_charging_workflow_skip(self, tmp_path):
+        scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+
+        for case in self._script_cases(scripts_dir):
+            case_dir = tmp_path / f"budgets-{case['id']}"
+            state_dir = case_dir / "state"
+            list_path = case_dir / case["list_name"]
+            payload = json.loads(json.dumps(case["list_payload"]))
+            payload[case["collection"]][0]["status"] = "pending"
+            write_json_file(str(list_path), payload)
+
+            start = subprocess.run(
+                [
+                    "python3",
+                    str(case["script"]),
+                    case["list_option"],
+                    str(list_path),
+                    "--state-dir",
+                    str(state_dir),
+                    case["id_option"],
+                    case["id"],
+                    "--action",
+                    "start",
+                    "--max-retries",
+                    "7",
+                    "--max-infra-retries",
+                    "4",
+                ],
+                text=True,
+                capture_output=True,
+                check=True,
+            )
+            assert json.loads(start.stdout)["new_status"] == "in_progress"
+            started = self._runtime_status(state_dir, case["id"])
+            assert started["max_retries"] == 7
+            assert started["max_infra_retries"] == 4
+
+            skipped = subprocess.run(
+                [
+                    "python3",
+                    str(case["script"]),
+                    case["list_option"],
+                    str(list_path),
+                    "--state-dir",
+                    str(state_dir),
+                    case["id_option"],
+                    case["id"],
+                    "--session-id",
+                    "sess-skip",
+                    "--session-status",
+                    "workflow_skipped",
+                    "--action",
+                    "update",
+                    "--max-retries",
+                    "5",
+                    "--max-infra-retries",
+                    "2",
+                ],
+                text=True,
+                capture_output=True,
+                check=True,
+            )
+            summary = json.loads(skipped.stdout)
+            runtime = self._runtime_status(state_dir, case["id"])
+            assert summary["new_status"] == "skipped"
+            assert runtime["max_retries"] == 5
+            assert runtime["max_infra_retries"] == 2
+            assert runtime["retry_count"] == 0
+            assert runtime["infra_error_count"] == 0
+
     def test_context_overflow_consumes_retry_and_records_bounded_continuation_metadata(self, tmp_path):
         scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
 
@@ -441,10 +511,10 @@ class TestContextOverflowRetrySemantics:
             assert runtime["context_overflow_count"] == 2
             assert runtime["continuation_count"] == 2
 
-    def test_manual_reset_clean_and_unskip_clear_all_continuation_state(self, tmp_path):
+    def test_manual_reset_clean_and_reset_state_clear_all_continuation_state(self, tmp_path):
         scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
 
-        for action in ["reset", "clean", "unskip"]:
+        for action in ["reset", "clean", "reset_state"]:
             for case in self._script_cases(scripts_dir):
                 case_dir = tmp_path / f"{action}-{case['id']}"
                 state_dir = case_dir / "state"
@@ -503,7 +573,7 @@ class TestContextOverflowRetrySemantics:
                 ]
                 if action in ("reset", "clean"):
                     cmd.extend([case["id_option"], case["id"]])
-                elif action == "unskip":
+                elif action == "reset_state":
                     cmd.extend([case["id_option"], case["id"]])
                 if action == "clean":
                     cmd.extend(["--project-root", str(case_dir)])
@@ -515,7 +585,15 @@ class TestContextOverflowRetrySemantics:
                 for continuation_file in continuation_files:
                     assert not continuation_file.exists()
                 runtime = self._runtime_status(state_dir, case["id"])
-                self._assert_no_continuation_runtime_state(runtime)
+                if action == "reset_state":
+                    assert runtime["active_dev_branch"] == "dev/existing-branch"
+                    assert runtime["base_branch"] == "main"
+                    continuation_only = dict(runtime)
+                    continuation_only.pop("active_dev_branch")
+                    continuation_only.pop("base_branch")
+                    self._assert_no_continuation_runtime_state(continuation_only)
+                else:
+                    self._assert_no_continuation_runtime_state(runtime)
                 assert runtime["retry_count"] == 0
                 assert runtime["infra_error_count"] == 0
                 assert runtime["last_infra_error_session_id"] is None
@@ -601,6 +679,7 @@ class TestContextOverflowRetrySemantics:
                     "reset",
                     case["target"],
                     case["item_id"],
+                    "--fresh-checkout",
                     str(prizmkit_dir / "plans" / case["list_name"]),
                 ],
                 cwd=case_dir,
@@ -758,7 +837,7 @@ def _run_status_snapshot_action(case, list_path, state_dir, action, session_stat
         "--action",
         action,
     ]
-    if action in {"update", "reset", "clean", "unskip"}:
+    if action in {"update", "reset", "clean", "reset_state"}:
         cmd.extend([case["id_option"], case["id"]])
     if action == "update":
         cmd.extend([
@@ -1200,7 +1279,7 @@ class TestAutoSkipEdgeCases:
 
 
 # ---------------------------------------------------------------------------
-# action_unskip — via subprocess (tests the full CLI interface)
+# action_reset_state — via subprocess (tests the full CLI interface)
 # ---------------------------------------------------------------------------
 
 import subprocess
@@ -1210,12 +1289,12 @@ _SCRIPT = os.path.join(
 )
 
 
-def _run_unskip(fl_path, state_dir, feature_id=None):
+def _run_reset_state(fl_path, state_dir, feature_id=None):
     cmd = [
         "python3", _SCRIPT,
         "--feature-list", fl_path,
         "--state-dir", state_dir,
-        "--action", "unskip",
+        "--action", "reset_state",
     ]
     if feature_id:
         cmd += ["--feature-id", feature_id]
@@ -1344,7 +1423,7 @@ class TestInfraErrorUpdate:
         assert fs["last_infra_error_session_id"] is None
         assert _read_statuses(fl_path)["F-001"] == "pending"
 
-    def test_unskip_clears_infra_retry_counters(self, tmp_path):
+    def test_reset_state_clears_infra_retry_counters(self, tmp_path):
         features = [_make_feature("F-001", "Root", status="failed")]
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001"])
@@ -1355,7 +1434,7 @@ class TestInfraErrorUpdate:
         fs["last_infra_error_session_id"] = "session-infra-final"
         write_json_file(status_path, fs)
 
-        _run_unskip(fl_path, state_dir, "F-001")
+        _run_reset_state(fl_path, state_dir, "F-001")
 
         fs = load_feature_status(state_dir, "F-001")
         assert fs["retry_count"] == 0
@@ -1363,10 +1442,10 @@ class TestInfraErrorUpdate:
         assert fs["last_infra_error_session_id"] is None
         assert _read_statuses(fl_path)["F-001"] == "pending"
 
-class TestUnskipByFeatureId:
-    """Unskip with --feature-id targets a specific failed feature + downstream."""
+class TestResetStateByFeatureId:
+    """ResetState with --feature-id targets a specific failed feature + downstream."""
 
-    def test_unskip_failed_root_resets_all(self, tmp_path):
+    def test_reset_state_failed_root_resets_all(self, tmp_path):
         features = [
             _make_feature("F-001", "Root", status="failed"),
             _make_feature("F-002", "Mid", deps=["F-001"], status="auto_skipped"),
@@ -1375,14 +1454,14 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
 
-        result = _run_unskip(fl_path, state_dir, "F-001")
+        result = _run_reset_state(fl_path, state_dir, "F-001")
 
         assert result["reset_count"] == 3
         statuses = _read_statuses(fl_path)
         assert all(s == "pending" for s in statuses.values())
 
-    def test_unskip_auto_skipped_leaf_resets_upstream(self, tmp_path):
-        """C2 fix: unskip F-003 must also find and reset F-001 (failed root)."""
+    def test_reset_state_auto_skipped_leaf_resets_upstream(self, tmp_path):
+        """C2 fix: reset_state F-003 must also find and reset F-001 (failed root)."""
         features = [
             _make_feature("F-001", "Root", status="failed"),
             _make_feature("F-002", "Mid", deps=["F-001"], status="auto_skipped"),
@@ -1391,14 +1470,14 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
 
-        result = _run_unskip(fl_path, state_dir, "F-003")
+        result = _run_reset_state(fl_path, state_dir, "F-003")
 
         assert result["reset_count"] == 3
         reset_ids = {f["feature_id"] for f in result["features"]}
         assert "F-001" in reset_ids  # transitive upstream reset
         assert all(s == "pending" for s in _read_statuses(fl_path).values())
 
-    def test_unskip_preserves_completed_features(self, tmp_path):
+    def test_reset_state_preserves_completed_features(self, tmp_path):
         features = [
             _make_feature("F-001", "Done", status="completed"),
             _make_feature("F-002", "Failed", deps=["F-001"], status="failed"),
@@ -1407,7 +1486,7 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
 
-        result = _run_unskip(fl_path, state_dir, "F-002")
+        result = _run_reset_state(fl_path, state_dir, "F-002")
 
         assert result["reset_count"] == 2
         statuses = _read_statuses(fl_path)
@@ -1415,8 +1494,8 @@ class TestUnskipByFeatureId:
         assert statuses["F-002"] == "pending"
         assert statuses["F-003"] == "pending"
 
-    def test_unskip_skipped_feature_resets_downstream(self, tmp_path):
-        """Unskip a manually-skipped feature should also reset its auto_skipped downstream."""
+    def test_reset_state_skipped_feature_resets_downstream(self, tmp_path):
+        """ResetState a manually-skipped feature should also reset its auto_skipped downstream."""
         features = [
             _make_feature("F-001", "Skipped", status="skipped"),
             _make_feature("F-002", "Child", deps=["F-001"], status="auto_skipped"),
@@ -1424,7 +1503,7 @@ class TestUnskipByFeatureId:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002"])
 
-        result = _run_unskip(fl_path, state_dir, "F-001")
+        result = _run_reset_state(fl_path, state_dir, "F-001")
 
         assert result["reset_count"] == 2
         statuses = _read_statuses(fl_path)
@@ -1432,8 +1511,8 @@ class TestUnskipByFeatureId:
         assert statuses["F-002"] == "pending"
 
 
-class TestUnskipAll:
-    """Unskip without --feature-id resets all failed + auto_skipped."""
+class TestResetStateAll:
+    """ResetState without --feature-id resets all failed + auto_skipped."""
 
     def test_resets_all_failed_and_auto_skipped(self, tmp_path):
         features = [
@@ -1445,7 +1524,7 @@ class TestUnskipAll:
         fl_path = _write_fl(tmp_path, features)
         state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003", "F-004"])
 
-        result = _run_unskip(fl_path, state_dir)
+        result = _run_reset_state(fl_path, state_dir)
 
         assert result["reset_count"] == 2
         statuses = _read_statuses(fl_path)
@@ -1456,11 +1535,11 @@ class TestUnskipAll:
 
 
 # ---------------------------------------------------------------------------
-# Integration: auto-skip → get_next → unskip → get_next
+# Integration: auto-skip → get_next → reset_state → get_next
 # ---------------------------------------------------------------------------
 
 class TestAutoSkipIntegration:
-    """Full lifecycle: fail → auto-skip → pipeline complete → unskip → resume."""
+    """Full lifecycle: fail → auto-skip → pipeline complete → reset_state → resume."""
 
     def test_full_lifecycle(self, tmp_path):
         features = [
@@ -1477,8 +1556,8 @@ class TestAutoSkipIntegration:
         # 2. get_next should return PIPELINE_COMPLETE
         assert _run_get_next(fl_path, state_dir) == "PIPELINE_COMPLETE"
 
-        # 3. Unskip recovers everything
-        _run_unskip(fl_path, state_dir, "F-001")
+        # 3. ResetState recovers everything
+        _run_reset_state(fl_path, state_dir, "F-001")
         statuses = _read_statuses(fl_path)
         assert statuses["F-001"] == "pending"
         assert statuses["F-002"] == "pending"
@@ -1488,7 +1567,7 @@ class TestAutoSkipIntegration:
         data = json.loads(output)
         assert data["feature_id"] == "F-001"
 
-    def test_retry_count_reset_after_unskip(self, tmp_path):
+    def test_retry_count_reset_after_reset_state(self, tmp_path):
         features = [
             _make_feature("F-001", "Root", status="failed"),
         ]
@@ -1502,7 +1581,7 @@ class TestAutoSkipIntegration:
         with open(fs_path, "w") as f:
             json.dump(fs, f)
 
-        _run_unskip(fl_path, state_dir, "F-001")
+        _run_reset_state(fl_path, state_dir, "F-001")
 
         with open(fs_path) as f:
             fs = json.load(f)

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

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import json
+import subprocess
+import sys
 
 from prizmkit_runtime.checkpoint_state import (
     VALID_CHECKPOINT_STATUSES,
@@ -231,6 +233,120 @@ def test_semantic_metadata_rejects_legacy_or_mismatched_status(tmp_path):
         assert state.semantic.error_code == error_code
 
 
+def test_semantic_blocker_metadata_requires_blocked_terminal_state(tmp_path):
+    cases = [
+        ({"blocked_reason": ""}, "invalid_blocked_reason"),
+        ({"blocked_reason": "   "}, "invalid_blocked_reason"),
+        ({"blocked_reason": "unexpected blocker"}, "blocked_reason_without_blocked_terminal"),
+        (
+            {"blocked_reason": "unexpected blocker", "terminal_status": "WORKFLOW_COMPLETED"},
+            "completed_workflow_has_blocked_reason",
+        ),
+        ({"terminal_status": "WORKFLOW_BLOCKED"}, "missing_blocked_reason"),
+    ]
+
+    for index, (semantic, expected_error) in enumerate(cases):
+        payload = _family_checkpoint(tmp_path, semantic=semantic)
+        state = validate_checkpoint_data(
+            payload,
+            path=tmp_path / f"invalid-blocker-{index}.json",
+            project_root=tmp_path,
+        )
+
+        assert state.valid is True
+        assert state.semantic.error_code == expected_error
+        assert state.semantic_complete is False
+
+
+def test_checkpoint_updater_rejects_invalid_blocker_metadata_without_mutation(tmp_path):
+    cases = [
+        ({"blocked_reason": "", "terminal_status": "WORKFLOW_COMPLETED"}, True),
+        ({"blocked_reason": "   ", "terminal_status": "WORKFLOW_COMPLETED"}, True),
+        ({"blocked_reason": "unexpected blocker", "terminal_status": "WORKFLOW_COMPLETED"}, True),
+        ({"blocked_reason": "unexpected blocker"}, False),
+        ({"terminal_status": "WORKFLOW_BLOCKED"}, False),
+    ]
+
+    for index, (semantic_update, completed) in enumerate(cases):
+        payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+        if not completed:
+            payload["steps"][0]["status"] = "in_progress"
+            for step in payload["steps"][1:]:
+                step["status"] = "pending"
+                step.pop("stage_result", None)
+        checkpoint = _write(tmp_path / f"atomic-blocker-{index}.json", payload)
+        before = checkpoint.read_bytes()
+
+        result = update_checkpoint(
+            str(checkpoint),
+            "S06" if completed else "S01",
+            "completed" if completed else "in_progress",
+            semantic_update=semantic_update,
+        )
+
+        assert result["ok"] is False
+        assert checkpoint.read_bytes() == before
+
+
+def test_checkpoint_updater_rejects_completed_terminal_for_blocking_stage_result(tmp_path):
+    for index, blocked_reason in enumerate((None, "safe environment unavailable")):
+        payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+        payload["steps"][2]["status"] = "in_progress"
+        payload["steps"][2].pop("stage_result", None)
+        for step in payload["steps"][3:]:
+            step["status"] = "pending"
+            step.pop("stage_result", None)
+        checkpoint = _write(tmp_path / f"conflicting-test-terminal-{index}.json", payload)
+        before = checkpoint.read_bytes()
+        semantic_update = {
+            "stage_result": "TEST_BLOCKED",
+            "terminal_status": "WORKFLOW_COMPLETED",
+        }
+        if blocked_reason is not None:
+            semantic_update["blocked_reason"] = blocked_reason
+
+        result = update_checkpoint(
+            str(checkpoint),
+            "prizmkit-test",
+            "failed",
+            semantic_update=semantic_update,
+        )
+
+        assert result["ok"] is False
+        assert checkpoint.read_bytes() == before
+
+
+def test_checkpoint_updater_cli_returns_nonzero_without_mutating_invalid_blocker_input(tmp_path):
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    checkpoint = _write(tmp_path / "cli-invalid-blocker.json", payload)
+    before = checkpoint.read_bytes()
+    script = __import__("update_checkpoint").__file__
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            script,
+            "--checkpoint-path",
+            str(checkpoint),
+            "--step",
+            "S06",
+            "--status",
+            "completed",
+            "--terminal-status",
+            "WORKFLOW_COMPLETED",
+            "--blocked-reason",
+            "",
+        ],
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+    assert result.returncode == 1
+    assert json.loads(result.stdout)["ok"] is False
+    assert checkpoint.read_bytes() == before
+
+
 def test_update_checkpoint_reenters_failed_stage_without_stale_result(tmp_path):
     payload = _family_checkpoint(
         tmp_path,
@@ -280,11 +396,23 @@ def test_checkpoint_updater_supports_every_owned_stage_result(tmp_path):
 
     assert {stage_result for _skill, stage_result, _status in cases} <= VALID_STAGE_RESULTS
     for index, (skill, stage_result, status) in enumerate(cases):
-        step = _step("S01", skill, skill, "pending")
-        checkpoint = _write(
-            tmp_path / f"owned-result-{index}.json",
-            _checkpoint([step]),
-        )
+        payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+        if skill == "prizmkit-plan":
+            for offset, step in enumerate(payload["steps"], start=2):
+                step["id"] = f"S{offset:02d}"
+                step["depends_on"] = f"S{offset - 1:02d}"
+            payload["steps"].insert(0, _step("S01", skill, skill, "pending"))
+            target_index = 0
+        else:
+            target_index = next(
+                position
+                for position, step in enumerate(payload["steps"])
+                if step["skill"] == skill
+            )
+        for step in payload["steps"][target_index:]:
+            step["status"] = "pending"
+            step.pop("stage_result", None)
+        checkpoint = _write(tmp_path / f"owned-result-{index}.json", payload)
 
         result = update_checkpoint(
             str(checkpoint),
@@ -295,8 +423,9 @@ def test_checkpoint_updater_supports_every_owned_stage_result(tmp_path):
 
         assert result["ok"] is True
         persisted = json.loads(checkpoint.read_text(encoding="utf-8"))
-        assert persisted["steps"][0]["status"] == status
-        assert persisted["steps"][0]["stage_result"] == stage_result
+        target = next(step for step in persisted["steps"] if step["skill"] == skill)
+        assert target["status"] == status
+        assert target["stage_result"] == stage_result
         assert persisted["feature_state"]["stage"] == {
             "prizmkit-plan": "plan",
             "prizmkit-implement": "implement",
@@ -310,12 +439,19 @@ def test_checkpoint_updater_supports_every_owned_stage_result(tmp_path):
 
 
 def test_duplicate_skills_require_exact_step_id(tmp_path):
-    path = _write(tmp_path / "workflow-checkpoint.json", _checkpoint([
-        _step("S01", "prizmkit-committer", "First", "completed"),
-        _step("S02", "prizmkit-committer", "Second", "pending", "S01"),
-    ]))
+    payload = _family_checkpoint(tmp_path, semantic={}, terminal=False)
+    for offset, step in enumerate(payload["steps"], start=3):
+        step["id"] = f"S{offset:02d}"
+        step["depends_on"] = f"S{offset - 1:02d}"
+        step["status"] = "pending"
+        step.pop("stage_result", None)
+    payload["steps"][:0] = [
+        _step("S01", "custom-stage", "First", "completed"),
+        _step("S02", "custom-stage", "Second", "pending", "S01"),
+    ]
+    path = _write(tmp_path / "workflow-checkpoint.json", payload)
 
-    rejected = update_checkpoint(str(path), "prizmkit-committer", "completed")
+    rejected = update_checkpoint(str(path), "custom-stage", "completed")
     accepted = update_checkpoint(str(path), "S02", "completed")
 
     assert rejected["ok"] is False

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

@@ -1,7 +1,6 @@
 """Tests for generate-bootstrap-prompt.py core functions."""
 
 import json
-import importlib.util
 import os
 import re
 from argparse import Namespace
@@ -87,14 +86,6 @@ def assert_complete_prompt_rendering(prompt):
     assert re.findall(r"\{\{[A-Z][A-Z_0-9]+\}\}", prompt) == []
 
 
-def _load_recovery_prompt_module():
-    path = Path("dev-pipeline/scripts/generate-recovery-prompt.py")
-    spec = importlib.util.spec_from_file_location("generate_recovery_prompt", path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
 def test_rendered_prompt_validation_rejects_unresolved_control_placeholders():
     content = (
         "## Your Mission\n"
@@ -698,7 +689,6 @@ class TestDirectOrchestratorImplementationPrompts:
             assert "Reviewer 3" not in rendered
 
     def test_all_rendered_pipeline_prompts_have_one_main_agent_review_model(self, tmp_path):
-        recovery = _load_recovery_prompt_module()
         prompts = [
             _render_feature_prompt(tmp_path / "feature-lite", mode="lite"),
             _render_feature_prompt(tmp_path / "feature-standard", mode="standard"),
@@ -710,15 +700,6 @@ class TestDirectOrchestratorImplementationPrompts:
             ),
             _render_bugfix_prompt(tmp_path / "bugfix"),
             _render_refactor_prompt(tmp_path / "refactor"),
-            recovery.build_bugfix_prompt(
-                {
-                    "workflow_type": "bug-fix-workflow",
-                    "phase": 5,
-                    "phase_name": "Review",
-                    "workflow_data": {"bug_id": "B-001"},
-                },
-                str(tmp_path),
-            ),
         ]
 
         for prompt in prompts: