prizmkit 1.1.153 → 1.1.155

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

@@ -76,6 +76,102 @@ def _write_family_plan(paths, kind, items):
     return plan_path
 
 
+@pytest.mark.parametrize(
+    ("kind", "item_id", "filename", "list_key", "schema", "item"),
+    [
+        (
+            "feature", "F-001", "feature-list.json", "features",
+            "dev-pipeline-feature-list-v1",
+            {
+                "id": "F-001", "title": "Preview Feature", "description": "Preview only",
+                "priority": "high", "dependencies": [],
+                "acceptance_criteria": ["Prompt validates"], "status": "pending",
+            },
+        ),
+        (
+            "bugfix", "B-001", "bug-fix-list.json", "bugs",
+            "dev-pipeline-bug-fix-list-v1",
+            {
+                "id": "B-001", "title": "Preview Bug", "description": "Preview only",
+                "severity": "high", "priority": "high", "dependencies": [],
+                "error_source": {"type": "user_report", "reproduction_steps": ["preview"]},
+                "verification_type": "automated",
+                "acceptance_criteria": ["Prompt validates"], "status": "pending",
+            },
+        ),
+        (
+            "refactor", "R-001", "refactor-list.json", "refactors",
+            "dev-pipeline-refactor-list-v1",
+            {
+                "id": "R-001", "title": "Preview Refactor", "description": "Preview only",
+                "scope": {"files": ["src/example.js"], "modules": ["example"]},
+                "type": "simplify", "priority": "high", "complexity": "low",
+                "behavior_preservation": {"strategy": "test-gate", "existing_tests": True},
+                "acceptance_criteria": ["Prompt validates"],
+                "dependencies": [], "status": "pending",
+            },
+        ),
+    ],
+)
+def test_actual_dry_run_is_read_only_and_successful(
+    tmp_path, kind, item_id, filename, list_key, schema, item,
+):
+    from prizmkit_runtime.paths import resolve_runtime_paths
+    from prizmkit_runtime.runners import run_pipeline_command
+
+    project = tmp_path / kind
+    plans = project / ".prizmkit" / "plans"
+    plans.mkdir(parents=True)
+    plan_path = plans / filename
+    plan_path.write_text(
+        json.dumps({"$schema": schema, "project_name": "Dry Run", list_key: [item]}),
+        encoding="utf-8",
+    )
+    fake_cli = project / "fake-ai.py"
+    fake_cli.write_text(
+        "#!/usr/bin/env python3\nfrom pathlib import Path\nPath('AI_WAS_LAUNCHED').write_text('bad')\n",
+        encoding="utf-8",
+    )
+    fake_cli.chmod(0o755)
+    (project / ".prizmkit" / "config.json").write_text(
+        json.dumps({
+            "platform": "pi",
+            "ai_cli": str(fake_cli),
+            "ai_cli_launch": {"profile": "custom", "prompt_arg": "--prompt"},
+        }),
+        encoding="utf-8",
+    )
+    subprocess.run(["git", "init", "-b", "main"], cwd=project, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.name", "Dry Run Test"], cwd=project, check=True)
+    subprocess.run(["git", "config", "user.email", "dry-run@example.invalid"], cwd=project, check=True)
+    subprocess.run(["git", "add", "."], cwd=project, check=True)
+    subprocess.run(["git", "commit", "-m", "initial"], cwd=project, check=True, stdout=subprocess.DEVNULL)
+    paths = resolve_runtime_paths(pipeline_root=PIPELINE_ROOT, project_root=project)
+    branch_before = subprocess.check_output(["git", "branch", "--show-current"], cwd=project, text=True).strip()
+    head_before = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=project, text=True).strip()
+    status_before = subprocess.check_output(["git", "status", "--porcelain=v1", "-uall"], cwd=project, text=True)
+
+    run_args = (
+        (str(plan_path), "--dry-run")
+        if kind == "feature"
+        else (item_id, str(plan_path), "--dry-run")
+    )
+    result = run_pipeline_command(kind, "run", run_args, paths)
+
+    assert result.exit_code == 0
+    assert "processed=1 completed=False stopped_reason=dry_run" in result.render()
+    assert "last_status: dry_run" in result.render()
+    assert json.loads(plan_path.read_text(encoding="utf-8"))[list_key][0]["status"] == "pending"
+    assert subprocess.check_output(["git", "branch", "--show-current"], cwd=project, text=True).strip() == branch_before
+    assert subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=project, text=True).strip() == head_before
+    assert subprocess.check_output(["git", "status", "--porcelain=v1", "-uall"], cwd=project, text=True) == status_before
+    assert not (project / "AI_WAS_LAUNCHED").exists()
+    assert not (project / ".prizmkit" / "state").exists()
+    assert not (project / ".prizmkit" / "specs").exists()
+    assert not (project / ".prizmkit" / "bugfix").exists()
+    assert not (project / ".prizmkit" / "refactor").exists()
+
+
 def _get_next_result(kind, paths):
     from prizmkit_runtime.runner_models import family_for, parse_invocation
     from prizmkit_runtime.runner_status import get_next
@@ -97,22 +193,22 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             "feature_state",
             [
                 "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-                "prizmkit-retrospective", "prizmkit-committer", "completion-summary",
+                "completion-summary", "prizmkit-retrospective", "prizmkit-committer",
             ],
         ),
         "bugfix-pipeline": (
             "bugfix_state",
             [
                 "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-                "prizmkit-retrospective", "prizmkit-committer", "bug-report",
+                "bug-report", "prizmkit-retrospective", "prizmkit-committer",
             ],
         ),
         "refactor-pipeline": (
             "refactor_state",
             [
                 "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
-                "prizmkit-retrospective", "prizmkit-committer", "refactor-report",
-                "completion-summary",
+                "refactor-report", "completion-summary", "prizmkit-retrospective",
+                "prizmkit-committer",
             ],
         ),
     }
@@ -128,6 +224,8 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             "required_artifacts": [],
             "depends_on": previous,
         }
+        if skill == "prizmkit-implement":
+            step["stage_result"] = "IMPLEMENTED"
         if skill == "prizmkit-code-review":
             step["stage_result"] = "REVIEW_PASS"
         if skill == "prizmkit-test":
@@ -137,6 +235,10 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
                 str(relative_artifact / "test-report.md"),
                 str(relative_artifact / "test-result.json"),
             ]
+        if skill == "prizmkit-retrospective":
+            step["stage_result"] = "RETRO_COMPLETE"
+        if skill == "prizmkit-committer":
+            step["stage_result"] = "COMMITTED"
         steps.append(step)
         previous = step["id"]
     artifact_dir.mkdir(parents=True, exist_ok=True)
@@ -158,12 +260,31 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             },
             "repair_rounds": 0,
             "production_changed": False,
-            "review_required": False,
-            "review_scope": None,
             "unresolved_items": [],
         }),
         encoding="utf-8",
     )
+    runtime_commit_hash = "b" * 40
+    runtime_base_head = "a" * 40
+    head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=project_root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        text=True,
+        check=False,
+    )
+    parent = subprocess.run(
+        ["git", "rev-parse", "HEAD^"],
+        cwd=project_root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        text=True,
+        check=False,
+    )
+    if head.returncode == 0 and parent.returncode == 0:
+        runtime_commit_hash = head.stdout.strip()
+        runtime_base_head = parent.stdout.strip()
     checkpoint = artifact_dir / "workflow-checkpoint.json"
     checkpoint.write_text(
         json.dumps({
@@ -173,6 +294,8 @@ def _write_semantic_completion_checkpoint(project_root, artifact_dir, workflow_t
             state_key: {
                 "repair_round": 0,
                 "terminal_status": "WORKFLOW_COMPLETED",
+                "runtime_base_head": runtime_base_head,
+                "runtime_commit_hash": runtime_commit_hash,
             },
         }),
         encoding="utf-8",
@@ -215,9 +338,8 @@ def test_python_parity_suite_declares_coverage_for_all_legacy_unix_snapshot_scen
         "entrypointContracts": {
             "runnerHelpContracts": ["test_cli_help_exposes_python_runtime_command_groups"],
             "runnerMissingListErrors": ["test_python_runner_missing_list_errors_match_snapshot_contract"],
-            "recoveryHelpContract": ["test_python_entrypoint_contracts_match_snapshot_contracts"],
-            "resetHelpContracts": ["test_python_entrypoint_contracts_match_snapshot_contracts"],
-            "daemonStatusContracts": ["test_python_entrypoint_contracts_match_snapshot_contracts"],
+            "resetHelpContracts": ["test_reset_and_daemon_entrypoint_contracts_match_snapshot_contracts"],
+            "daemonStatusContracts": ["test_reset_and_daemon_entrypoint_contracts_match_snapshot_contracts"],
         },
         "envResolution": {
             "verboseAndStreamJson": ["test_python_env_resolution_scenarios_match_snapshot_contracts"],
@@ -283,8 +405,7 @@ def test_python_runner_missing_list_errors_match_snapshot_contract(tmp_path):
         assert "Plan list not found" in result.render()
 
 
-def test_python_entrypoint_contracts_match_snapshot_contracts(tmp_path):
-    from prizmkit_runtime.commands import handle_runtime_command
+def test_reset_and_daemon_entrypoint_contracts_match_snapshot_contracts(tmp_path):
     from prizmkit_runtime.daemon import run_daemon_command
     from prizmkit_runtime.paths import resolve_runtime_paths
     from prizmkit_runtime.reset import run_reset_command
@@ -292,11 +413,6 @@ def test_python_entrypoint_contracts_match_snapshot_contracts(tmp_path):
     snapshot = _load_unix_runtime_snapshot()["entrypointContracts"]
     paths = _make_paths(tmp_path / "entrypoints")
 
-    recovery = handle_runtime_command("recovery", "describe", paths=paths)
-    assert recovery.exit_code == snapshot["recoveryHelpContract"]["exitCode"]
-    assert "Python runtime command contract" in recovery.render()
-    assert "recovery describe" in recovery.render()
-
     for kind in ("feature", "bugfix", "refactor"):
         reset = run_reset_command(kind, ("--help",), paths)
         assert reset.exit_code == snapshot["resetHelpContracts"][kind]["exitCode"]
@@ -410,7 +526,7 @@ def test_runner_models_parse_legacy_args_and_environment(tmp_path):
     invocation = parse_invocation(
         family,
         "run",
-        ("custom-list.json", "F-2", "--features", "F-003:F-001", "--max-retries", "7", "--max-infra-retries=5", "--mode", "full"),
+        ("custom-list.json", "F-2", "--features", "F-003:F-001", "--max-retries", "7", "--max-infra-retries=5"),
     )
     env = RunnerEnvironment.from_env(
         {
@@ -429,7 +545,7 @@ def test_runner_models_parse_legacy_args_and_environment(tmp_path):
     assert invocation.item_filter == "F-003:F-001"
     assert invocation.max_retries == 7
     assert invocation.max_infra_retries == 5
-    assert invocation.mode == "full"
+    assert not hasattr(invocation, "mode")
     assert env.stop_on_failure is True
     assert env.auto_push is True
     assert env.dev_branch == "dev/custom"
@@ -722,7 +838,7 @@ def test_status_bridge_passes_max_retries_from_invocation_or_environment(monkeyp
     ("kind", "item_key"),
     (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
 )
-def test_pipeline_aggregate_replaces_same_item_status_in_first_seen_order(monkeypatch, tmp_path, kind, item_key):
+def test_pipeline_aggregate_reselection_keeps_first_seen_details_and_stops(monkeypatch, tmp_path, kind, item_key):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
@@ -743,11 +859,11 @@ def test_pipeline_aggregate_replaces_same_item_status_in_first_seen_order(monkey
 
     result = runners._run_pipeline(family, invocation, paths)
 
-    assert result.processed == 3
-    assert result.completed is True
-    assert result.stopped_reason == "pipeline_complete"
-    assert result.last_status == "completed"
-    assert result.details == ("F-049:completed", "F-050:completed")
+    assert result.processed == 2
+    assert result.completed is False
+    assert result.stopped_reason == "reselected_item"
+    assert result.last_status == "pending"
+    assert result.details == ("F-049:completed", "F-050:pending")
 
 
 @pytest.mark.parametrize(
@@ -785,7 +901,46 @@ def test_pipeline_aggregate_keeps_distinct_unresolved_item_blocking(monkeypatch,
     ("kind", "item_key"),
     (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
 )
-def test_pipeline_aggregate_repeated_terminal_update_remains_unique(monkeypatch, tmp_path, kind, item_key):
+def test_full_list_stops_after_newly_skipped_item(monkeypatch, tmp_path, kind, item_key):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    selector_calls = 0
+    processor_calls = []
+
+    def fake_get_next(*args, **kwargs):
+        nonlocal selector_calls
+        selector_calls += 1
+        if selector_calls > 1:
+            raise AssertionError("selector called after terminal skipped item")
+        return SimpleNamespace(ok=True, stdout="", data={item_key: "X-001"}, text="")
+
+    def fake_process(_family, _invocation, item_id, _paths, *, initial_metadata):
+        processor_calls.append(item_id)
+        return "skipped"
+
+    monkeypatch.setattr(runners, "get_next", fake_get_next)
+    monkeypatch.setattr(runners, "_process_item", fake_process)
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert selector_calls == 1
+    assert processor_calls == ["X-001"]
+    assert result.completed is False
+    assert result.processed == 1
+    assert result.stopped_reason == "item_skipped"
+    assert result.last_status == "skipped"
+    assert result.details == ("X-001:skipped",)
+
+
+@pytest.mark.parametrize(
+    ("kind", "item_key"),
+    (("feature", "feature_id"), ("bugfix", "bug_id"), ("refactor", "refactor_id")),
+)
+def test_full_list_rejects_reselected_processed_item_before_second_launch(monkeypatch, tmp_path, kind, item_key):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
@@ -793,20 +948,29 @@ def test_pipeline_aggregate_repeated_terminal_update_remains_unique(monkeypatch,
     family = family_for(kind, paths)
     invocation = parse_invocation(family, "run", ())
     queue = [
-        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
-        SimpleNamespace(ok=True, stdout="", data={item_key: "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "X-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="", data={item_key: "X-001"}, text=""),
         SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
     ]
+    processor_calls = []
 
     monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
-    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: "completed")
+
+    def fake_process(_family, _invocation, item_id, _paths, *, initial_metadata):
+        processor_calls.append(item_id)
+        return "completed"
+
+    monkeypatch.setattr(runners, "_process_item", fake_process)
     monkeypatch.setattr(runners, "_emit_info", lambda *args, **kwargs: None)
 
     result = runners._run_pipeline(family, invocation, paths)
 
-    assert result.processed == 2
-    assert result.details == ("F-001:completed",)
+    assert processor_calls == ["X-001"]
+    assert result.completed is False
+    assert result.processed == 1
+    assert result.stopped_reason == "reselected_item"
     assert result.last_status == "completed"
+    assert result.details == ("X-001:completed",)
 
 
 @pytest.mark.parametrize("kind", ("feature", "bugfix", "refactor"))
@@ -841,15 +1005,15 @@ def test_pipeline_aggregate_empty_authoritative_completion(monkeypatch, tmp_path
     ("kind", "status", "expected_completed"),
     (
         ("feature", "completed", True),
-        ("feature", "skipped", True),
+        ("feature", "skipped", False),
         ("feature", "auto_skipped", True),
         ("feature", "split", True),
         ("bugfix", "completed", True),
-        ("bugfix", "skipped", True),
+        ("bugfix", "skipped", False),
         ("bugfix", "auto_skipped", True),
         ("bugfix", "split", False),
         ("refactor", "completed", True),
-        ("refactor", "skipped", True),
+        ("refactor", "skipped", False),
         ("refactor", "auto_skipped", True),
         ("refactor", "split", False),
     ),
@@ -875,7 +1039,9 @@ def test_pipeline_aggregate_completion_compatible_statuses(monkeypatch, tmp_path
 
     assert result.completed is expected_completed
     assert result.stopped_reason == (
-        "pipeline_complete" if expected_completed else "pipeline_complete_with_non_terminal_history"
+        "item_skipped"
+        if status == "skipped"
+        else ("pipeline_complete" if expected_completed else "pipeline_complete_with_non_terminal_history")
     )
     assert result.last_status == status
     assert result.details == (f"X-001:{status}",)
@@ -906,6 +1072,37 @@ def test_run_pipeline_command_omits_empty_last_status_detail(monkeypatch, tmp_pa
     assert result.details == ()
 
 
+@pytest.mark.parametrize("kind", ("feature", "bugfix", "refactor"))
+def test_run_pipeline_command_returns_nonzero_for_terminal_skipped_item(monkeypatch, tmp_path, kind):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import PipelineRunResult
+
+    paths = _make_paths(tmp_path)
+    plan_path = {
+        "feature": paths.feature_plan,
+        "bugfix": paths.bugfix_plan,
+        "refactor": paths.refactor_plan,
+    }[kind]
+    plan_path.write_text("{}", encoding="utf-8")
+    monkeypatch.setattr(
+        runners,
+        "_run_pipeline",
+        lambda *args, **kwargs: PipelineRunResult(
+            False,
+            1,
+            "item_skipped",
+            "skipped",
+            ("X-001:skipped",),
+        ),
+    )
+
+    result = runners.run_pipeline_command(kind, "run", (), paths)
+
+    assert result.exit_code == 1
+    assert result.message == "processed=1 completed=False stopped_reason=item_skipped"
+    assert result.details == ("X-001:skipped", "last_status: skipped")
+
+
 def test_pipeline_complete_rejects_retryable_detail(monkeypatch, tmp_path):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
@@ -1008,7 +1205,6 @@ def test_prompt_generation_result_preserves_per_item_model(monkeypatch, tmp_path
                     "output_path": str(session_paths.prompt_path),
                     "checkpoint_path": str(paths.project_root / ".prizmkit" / "bugfix" / "B-001" / "workflow-checkpoint.json"),
                     "model": "per-item-model",
-                    "pipeline_mode": "standard",
                 }
             ),
             stderr="",
@@ -1056,7 +1252,6 @@ def test_prompt_generation_passes_explicit_execution_root_to_generator(monkeypat
                     "output_path": str(session_paths.prompt_path),
                     "checkpoint_path": str(execution_root / ".prizmkit" / "specs" / "001-low" / "workflow-checkpoint.json"),
                     "model": "",
-                    "pipeline_mode": "full",
                 }
             ),
             stderr="",
@@ -1121,7 +1316,6 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
         return PromptGenerationResult(
             output_path=session_paths.prompt_path,
             model="per-item-model",
-            pipeline_mode="full",
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-low" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-low",
             raw={},
@@ -1454,7 +1648,6 @@ def test_explicit_worktree_materializes_ignored_support_assets_before_prompt_and
         return PromptGenerationResult(
             output_path=session_paths.prompt_path,
             model="",
-            pipeline_mode="full",
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-support" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-support",
             raw={},
@@ -1541,7 +1734,6 @@ def test_has_branch_completion_evidence_requires_task_branch_ahead_of_base(tmp_p
     subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
     subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
     artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
-    _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
     (tmp_path / "base.txt").write_text("base", encoding="utf-8")
     subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
     subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
@@ -1549,6 +1741,7 @@ def test_has_branch_completion_evidence_requires_task_branch_ahead_of_base(tmp_p
     (tmp_path / "done.txt").write_text("done", encoding="utf-8")
     subprocess.run(["git", "add", "done.txt"], cwd=tmp_path, check=True)
     subprocess.run(["git", "commit", "-m", "done"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
 
     assert has_branch_completion_evidence(tmp_path, "main", "dev/F-001", artifact_dir) is True
 
@@ -1898,6 +2091,7 @@ def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_pa
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
     monkeypatch.setenv("DEV_BRANCH", "dev/F-001-output")
+    monkeypatch.delenv("MAX_RETRIES", raising=False)
     paths = _make_paths(tmp_path)
     family = family_for("feature", paths)
     invocation = parse_invocation(family, "run", ())
@@ -1919,7 +2113,7 @@ def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_pa
     assert "Feature: F-001 — Readable output" in captured.err
     assert "Code retry: 1 / 3" in captured.err
     assert "Preflight: no user-visible changes to preserve before feature task F-001" in captured.err
-    assert "Pipeline mode: full (Full Guidance)" in captured.err
+    assert "Pipeline mode:" not in captured.err
     assert "Spawning AI CLI session: F-001-session-1" in captured.err
     assert "Session result: success" in captured.err
 
@@ -1976,6 +2170,8 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
     from prizmkit_runtime.task_checkout import load_task_checkout
 
     monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
+    monkeypatch.delenv("MAX_RETRIES", raising=False)
+    monkeypatch.delenv("MAX_INFRA_RETRIES", raising=False)
     paths = _make_paths(tmp_path)
     _init_bookkeeping_repo(paths.project_root)
     family = family_for("feature", paths)
@@ -3089,6 +3285,14 @@ def test_classification_accepts_final_success_after_internal_stream_retry(tmp_pa
         stdout=subprocess.PIPE,
         text=True,
     ).stdout.strip()
+    (tmp_path / "done.txt").write_text("done", encoding="utf-8")
+    subprocess.run(["git", "add", "done.txt"], cwd=tmp_path, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "done"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
     artifact_dir = tmp_path / ".prizmkit" / "bugfix" / "B-004"
     checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir, "bugfix-pipeline")
 
@@ -3236,7 +3440,7 @@ def test_classification_keeps_pre_completion_provider_error_as_infra_error(tmp_p
     assert classification.reason == "ai_runtime_or_provider_error"
 
 
-def test_classification_accepts_terminal_success_with_completed_checkpoint_without_git_delta(tmp_path):
+def test_classification_rejects_completed_checkpoint_without_runtime_git_receipt(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.runner_models import PromptGenerationResult
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
@@ -3276,8 +3480,8 @@ def test_classification_accepts_terminal_success_with_completed_checkpoint_witho
     )
 
     classification = classify_session(raw, project_root=tmp_path, base_head=base_head, prompt=prompt)
-    assert classification.session_status == "success"
-    assert classification.reason == "terminal_success_with_semantic_checkpoint"
+    assert classification.session_status == "commit_missing"
+    assert classification.reason == "runtime_commit_receipt_mismatch"
 
 
 def test_classification_preserves_success_before_context_overflow(tmp_path):
@@ -3390,37 +3594,11 @@ def test_classification_stalls_after_repeated_no_progress_context_overflow(tmp_p
     assert classification.no_progress_count == 2
 
 
-def test_recovery_prompt_keeps_existing_branch_instead_of_recovery_suffix():
-    text = (PIPELINE_ROOT / "scripts" / "generate-recovery-prompt.py").read_text(encoding="utf-8")
-
-    assert "fix/{bug_id}-recovery" not in text
-    assert "do not create an additional" in text
-    assert "last-resort fallback" in text
-
-
-def test_recovery_detector_resolver_prefers_installed_platform_asset(tmp_path):
-    from prizmkit_runtime.paths import resolve_runtime_paths
-    from prizmkit_runtime.runner_recovery import RecoveryDetectorResolver
-
-    project = tmp_path / "project"
-    agents = project / ".agents" / "skills" / "recovery-workflow" / "scripts"
-    claude = project / ".claude" / "command-assets" / "recovery-workflow" / "scripts"
-    agents.mkdir(parents=True)
-    claude.mkdir(parents=True)
-    agent_detector = agents / "detect-recovery-state.py"
-    claude_detector = claude / "detect-recovery-state.py"
-    agent_detector.write_text("# agent", encoding="utf-8")
-    claude_detector.write_text("# claude", encoding="utf-8")
-    paths = resolve_runtime_paths(pipeline_root=PIPELINE_ROOT, project_root=project)
-
-    assert RecoveryDetectorResolver(paths).resolve() == agent_detector
-
-
 def test_cli_family_status_uses_python_dispatch_not_transition_description(tmp_path):
     paths = _make_paths(tmp_path)
     _write_feature_list(paths)
     result = subprocess.run(
-        [PYTHON_310_PLUS, str(CLI_PATH), "--project-root", str(paths.project_root), "feature", "status"],
+        [PYTHON_310_PLUS, str(CLI_PATH), "--project-root", str(paths.project_root), "status", "feature"],
         cwd=REPO_ROOT,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
@@ -3480,7 +3658,7 @@ def test_python_reset_warns_before_mutation_and_matches_snapshot_cleanup(tmp_pat
     for kind, item_id in [("feature", "F-001"), ("bugfix", "B-001"), ("refactor", "R-001")]:
         paths = _make_paths(tmp_path / kind)
         _plan, _state_dir, status_file = _write_family_case(paths, kind, item_id)
-        result = run_reset_command(kind, (item_id,), paths)
+        result = run_reset_command(kind, (item_id, "--fresh-checkout"), paths)
         output = result.render()
         reset_marker = f"Resetting {item_id} status"
 
@@ -3522,7 +3700,7 @@ def test_python_reset_cleans_authoritative_custom_branch_before_reset_marker(mon
         or SimpleNamespace(branch=branch, cleaned=True, deleted=False, returned_to=return_branch, warnings=()),
     )
 
-    result = run_reset_command("feature", ("F-001",), paths)
+    result = run_reset_command("feature", ("F-001", "--fresh-checkout"), paths)
 
     assert result.exit_code == 0
     assert cleanup_calls == [(custom_branch, False)]
@@ -3554,7 +3732,7 @@ def test_python_reset_failure_keeps_authoritative_checkout_active(monkeypatch, t
         ),
     )
 
-    result = run_reset_command("feature", ("F-001",), paths)
+    result = run_reset_command("feature", ("F-001", "--fresh-checkout"), paths)
 
     assert result.exit_code == 1
     assert load_task_checkout(family.state_dir, family.task_type, "F-001") == checkout
@@ -3674,7 +3852,7 @@ def test_python_reset_stalled_filter_selects_stalled_context_items(tmp_path):
         data[{"feature": "features", "bugfix": "bugs", "refactor": "refactors"}[kind]][0]["status"] = "stalled_context_continuation"
         plan.write_text(json.dumps(data), encoding="utf-8")
 
-        result = run_reset_command(kind, ("--stalled",), paths)
+        result = run_reset_command(kind, ("--stalled", "--fresh-checkout"), paths)
 
         assert result.exit_code == 0
         assert f"Reset: {item_id}" in result.render()
@@ -3707,6 +3885,7 @@ def test_python_daemon_progress_uses_list_status_without_runtime_files(tmp_path)
                     {"id": "B-001", "title": "Done", "status": "completed"},
                     {"id": "B-002", "title": "Failed", "status": "failed"},
                     {"id": "B-003", "title": "Needs Info", "status": "needs_info"},
+                    {"id": "B-004", "title": "Blocked", "status": "auto_skipped"},
                 ]}),
                 encoding="utf-8",
             )
@@ -3724,12 +3903,13 @@ def test_python_daemon_progress_uses_list_status_without_runtime_files(tmp_path)
 
         summary = _progress_summary(family_for(kind, paths), plan)
 
-        assert summary["total"] == 3
+        assert summary["total"] == (4 if kind == "bugfix" else 3)
         assert summary["completed"] == 1
         assert summary["failed"] == 1
-        assert summary["percent"] == 33.3
+        assert summary["percent"] == (25.0 if kind == "bugfix" else 33.3)
         if kind == "bugfix":
             assert summary["needs_info"] == 1
+            assert summary["auto_skipped"] == 1
         else:
             assert summary["auto_skipped"] == 1
 
@@ -3862,6 +4042,14 @@ def test_pi_length_stop_does_not_override_completed_checkpoint(tmp_path):
     from prizmkit_runtime.status import ProgressSummary
 
     base_head = _init_git_repo_for_invalid_checkpoint_test(tmp_path)
+    (tmp_path / "done.txt").write_text("done", encoding="utf-8")
+    subprocess.run(["git", "add", "done.txt"], cwd=tmp_path, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "done"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
     artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-length-complete"
     checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
     prompt = PromptGenerationResult(
@@ -4308,6 +4496,21 @@ def test_semantic_completion_classification_has_cross_family_parity(tmp_path, wo
     (tmp_path / "base.txt").write_text("base", encoding="utf-8")
     subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
     subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    base_head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip()
+    (tmp_path / "done.txt").write_text("done", encoding="utf-8")
+    subprocess.run(["git", "add", "done.txt"], cwd=tmp_path, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "done"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
     artifact = tmp_path / ".prizmkit" / "artifacts" / workflow_type
     checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact, workflow_type)
     log = tmp_path / f"{workflow_type}.log"
@@ -4330,7 +4533,7 @@ def test_semantic_completion_classification_has_cross_family_parity(tmp_path, wo
     classification = classify_session(
         raw,
         project_root=tmp_path,
-        base_head="",
+        base_head=base_head,
         prompt=PromptGenerationResult(
             output_path=tmp_path / "prompt.md",
             checkpoint_path=checkpoint,
@@ -4396,38 +4599,10 @@ def test_semantic_blocked_classification_is_terminal_and_retry_neutral(tmp_path)
     assert classification.checkpoint_state["repair_round"] == 3
 
 
-def test_recovery_outcome_preserves_dirty_partial_work_and_uses_semantic_checkpoint(tmp_path):
-    from prizmkit_runtime.runner_recovery import _recovery_outcome
-
-    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
-    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
-    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
-    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
-    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
-    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
-    (tmp_path / "partial.txt").write_text("preserve me", encoding="utf-8")
-    artifact = tmp_path / ".prizmkit" / "specs" / "done"
-    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact)
-
-    outcome, semantic = _recovery_outcome(tmp_path, 1, checkpoint_path=checkpoint)
-
-    assert outcome == "success"
-    assert semantic["terminal_status"] == "WORKFLOW_COMPLETED"
-    assert (tmp_path / "partial.txt").read_text(encoding="utf-8") == "preserve me"
-    assert subprocess.run(
-        ["git", "status", "--porcelain", "--", "partial.txt"],
-        cwd=tmp_path,
-        check=True,
-        stdout=subprocess.PIPE,
-        text=True,
-    ).stdout.startswith("??")
-
-
 def test_runtime_semantic_paths_do_not_invoke_composite_workflow():
     sources = [
         PIPELINE_ROOT / "prizmkit_runtime" / "checkpoint_state.py",
         PIPELINE_ROOT / "prizmkit_runtime" / "runner_classification.py",
-        PIPELINE_ROOT / "prizmkit_runtime" / "runner_recovery.py",
         PIPELINE_ROOT / "prizmkit_runtime" / "runners.py",
     ]
 
@@ -4494,110 +4669,10 @@ def test_family_status_persists_identical_semantic_blocked_snapshot_without_retr
         assert status[key] == value
 
 
-
-def test_recovery_detector_returns_no_candidate_for_empty_project(tmp_path):
-    import importlib.util
-
-    detector_path = (
-        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
-        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
-    )
-    spec = importlib.util.spec_from_file_location("recovery_detector_empty", detector_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-
-    report = module.build_report(tmp_path)
-
-    assert report["detected"] is False
-    assert report["candidates"] == []
-
-
-def test_recovery_detector_returns_active_checkout_command(tmp_path, monkeypatch):
-    import importlib.util
-
-    detector_path = (
-        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
-        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
-    )
-    spec = importlib.util.spec_from_file_location("recovery_detector_active", detector_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-
-    checkout_path = tmp_path / ".prizmkit" / "state" / "features" / "F-001" / "checkout.json"
-    checkout_path.parent.mkdir(parents=True)
-    checkout_path.write_text(
-        json.dumps({
-            "task_type": "feature",
-            "task_id": "F-001",
-            "state": "active",
-            "active_dev_branch": "dev/F-001-resume",
-            "base_branch": "main",
-            "checkout_mode": "branch",
-        }),
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(module, "branch_exists", lambda *_args: True)
-
-    report = module.build_report(tmp_path)
-
-    assert report["detected"] is True
-    assert report["selection_required"] is False
-    assert report["candidates"][0]["continue_command"] == (
-        "python3 ./.prizmkit/dev-pipeline/cli.py feature run F-001"
-    )
-
-
-def test_recovery_detector_ignores_completed_checkout(tmp_path, monkeypatch):
-    import importlib.util
-
-    detector_path = (
-        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
-        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
-    )
-    spec = importlib.util.spec_from_file_location("recovery_detector_completed", detector_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-
-    checkout_path = tmp_path / ".prizmkit" / "state" / "bugfix" / "B-001" / "checkout.json"
-    checkout_path.parent.mkdir(parents=True)
-    checkout_path.write_text(
-        json.dumps({
-            "task_type": "bugfix",
-            "task_id": "B-001",
-            "state": "completed",
-            "active_dev_branch": "bugfix/B-001-done",
-            "base_branch": "main",
-        }),
-        encoding="utf-8",
-    )
-    monkeypatch.setattr(module, "branch_exists", lambda *_args: True)
-
-    report = module.build_report(tmp_path)
-
-    assert report["detected"] is False
-
-
-def test_l4_runtime_and_recovery_sources_do_not_depend_on_direct_l1_composite():
+def test_runtime_sources_do_not_depend_on_direct_lifecycle_composite():
     runtime_root = REPO_ROOT / "dev-pipeline"
     source_files = list(runtime_root.rglob("*.py"))
     for source in source_files:
         if "__pycache__" in source.parts or "tests" in source.parts or not source.is_file():
             continue
         assert "prizmkit-workflow" not in source.read_text(encoding="utf-8")
-
-
-def test_recovery_detector_has_no_direct_lifecycle_fallback(tmp_path):
-    import importlib.util
-
-    detector_path = (
-        REPO_ROOT / "core" / "skills" / "orchestration-skill" / "workflows"
-        / "recovery-workflow" / "scripts" / "detect-recovery-state.py"
-    )
-    spec = importlib.util.spec_from_file_location("recovery_detector_contract", detector_path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-
-    report = module.build_report(tmp_path)
-
-    assert "continue_command" not in report
-    assert report["detected"] is False