prizmkit 1.1.152 → 1.1.154

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

@@ -215,9 +215,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 +282,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 +290,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"]
@@ -722,7 +715,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 +736,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 +778,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 +825,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 +882,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 +916,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 +949,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
@@ -1898,6 +1972,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", ())
@@ -1976,6 +2051,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)
@@ -3390,37 +3467,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 +3531,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 +3573,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 +3605,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 +3725,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 +3758,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 +3776,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
 
@@ -4396,38 +4449,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 +4519,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