prizmkit 1.1.106 → 1.1.108

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

@@ -318,6 +318,7 @@ def test_runner_models_parse_legacy_args_and_environment(tmp_path):
     assert env.stale_kill_threshold_seconds == 9
     assert env.max_retries == 9
     assert env.strict_behavior_check is False
+    assert not hasattr(env, "max_" + "log_size")
 
 
 def test_runner_environment_disables_worktree_by_default_and_accepts_truthy_opt_in():
@@ -414,10 +415,67 @@ def test_stop_on_failure_does_not_stop_on_retryable_pending(monkeypatch, tmp_pat
 
     result = runners._run_pipeline(family, invocation, paths)
 
+    assert processed == ["F-001", "F-002"]
+    assert result.completed is False
+    assert result.stopped_reason == "pipeline_complete_with_non_terminal_history"
+    assert result.last_status == "completed"
+    assert result.details == ("F-001:pending", "F-002:completed")
+
+
+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
+
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    queue = [
+        SimpleNamespace(ok=True, stdout=json.dumps({"feature_id": "F-001"}), data={"feature_id": "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+
+    monkeypatch.setenv("STOP_ON_FAILURE", "0")
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+    monkeypatch.setattr(runners, "_process_item", lambda *args, **kwargs: "retryable")
+
+    result = runners._run_pipeline(family, invocation, paths)
+
+    assert result.completed is False
+    assert result.stopped_reason == "pipeline_complete_with_non_terminal_history"
+    assert result.last_status == "retryable"
+    assert result.details == ("F-001:retryable",)
+
+
+def test_full_list_continues_from_completed_item_to_next_pending(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    queue = [
+        SimpleNamespace(ok=True, stdout=json.dumps({"feature_id": "F-001"}), data={"feature_id": "F-001"}, text=""),
+        SimpleNamespace(ok=True, stdout=json.dumps({"feature_id": "F-002"}), data={"feature_id": "F-002"}, text=""),
+        SimpleNamespace(ok=True, stdout="PIPELINE_COMPLETE\n", data=None, text="PIPELINE_COMPLETE"),
+    ]
+    processed = []
+
+    monkeypatch.setattr(runners, "get_next", lambda *args, **kwargs: queue.pop(0))
+
+    def fake_process(_family, _invocation, item_id, _paths, *, initial_metadata):
+        processed.append(item_id)
+        return "completed"
+
+    monkeypatch.setattr(runners, "_process_item", fake_process)
+
+    result = runners._run_pipeline(family, invocation, paths)
+
     assert processed == ["F-001", "F-002"]
     assert result.completed is True
     assert result.stopped_reason == "pipeline_complete"
-    assert result.details == ("F-001:pending", "F-002:completed")
+    assert result.details == ("F-001:completed", "F-002:completed")
 
 
 def test_stop_on_failure_still_stops_on_terminal_status(monkeypatch, tmp_path):
@@ -546,6 +604,7 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
 
     prompt_calls = []
     launch_cwds = []
+    launch_configs = []
     updates = []
     cleanup_calls = []
     merge_calls = []
@@ -563,6 +622,7 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
     )
     monkeypatch.setattr(runners, "detect_stream_json_support", lambda command, platform: SimpleNamespace(enabled=False))
     monkeypatch.setattr(runners, "start_item", lambda *args, **kwargs: SimpleNamespace(ok=True, text="", data={"new_status": "in_progress"}))
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=False, committed=False, ok=True, result=None))
     monkeypatch.setattr(runners, "commit_pre_branch_bookkeeping", lambda *args, **kwargs: None)
     monkeypatch.setattr(runners, "commit_final_bookkeeping", lambda *args, **kwargs: None)
     monkeypatch.setattr(runners, "current_branch", lambda _root: "main")
@@ -594,6 +654,7 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
 
         def run(self):
             launch_cwds.append(self.config.cwd)
+            launch_configs.append(self.config)
             return SimpleNamespace(progress_summary=SimpleNamespace(), fatal_error_code="")
 
     def fake_classify(*args, **kwargs):
@@ -632,6 +693,7 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
     return SimpleNamespace(
         prompt_calls=prompt_calls,
         launch_cwds=launch_cwds,
+        launch_configs=launch_configs,
         updates=updates,
         cleanup_calls=cleanup_calls,
         merge_calls=merge_calls,
@@ -639,6 +701,36 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
     )
 
 
+
+def test_runner_launch_config_preserves_artifact_paths_live_output_and_split_thresholds(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("PRIZMKIT_LIVE_OUTPUT", "0")
+    monkeypatch.setenv("HEARTBEAT_INTERVAL", "7")
+    monkeypatch.setenv("HEARTBEAT_STALE_THRESHOLD", "11")
+    monkeypatch.setenv("STALE_KILL_THRESHOLD", "13")
+    paths = _make_paths(tmp_path / "artifact-wiring")
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    observed = _install_runner_session_fakes(monkeypatch, runners)
+    monkeypatch.setattr(runners, "run_git_plan", lambda *args, **kwargs: SimpleNamespace(ok=True, reason="", results=()))
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    config = observed.launch_configs[0]
+    expected_log = paths.feature_state_dir / "F-001" / "sessions" / "F-001-session-1" / "logs" / "session.log"
+    assert status == "completed"
+    assert config.live_output is False
+    assert config.live_progress_interval_seconds == 7
+    assert config.heartbeat_stale_threshold_seconds == 11
+    assert config.stale_kill_threshold_seconds == 13
+    assert config.log_path == expected_log
+    assert config.progress_path == expected_log.with_name("progress.json")
+    assert config.heartbeat_path == expected_log.with_name("heartbeat.json")
+
+
 @pytest.mark.parametrize(("kind", "item_id", "branch"), [("feature", "F-001", "dev/F-001-test"), ("bugfix", "B-001", "bugfix/B-001-test")])
 def test_feature_and_bugfix_explicit_worktree_launches_from_worktree_and_renders_worktree_root(monkeypatch, tmp_path, kind, item_id, branch):
     from prizmkit_runtime import runners
@@ -652,18 +744,26 @@ def test_feature_and_bugfix_explicit_worktree_launches_from_worktree_and_renders
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan if kind == "feature" else paths.bugfix_plan})
     observed = _install_runner_session_fakes(monkeypatch, runners)
     setup_calls = []
+    lifecycle_order = []
 
     def fake_setup(runtime):
+        lifecycle_order.append("worktree_setup")
         setup_calls.append(runtime)
         runtime.worktree_path.mkdir(parents=True, exist_ok=True)
         return SimpleNamespace(ok=True, runtime=runtime, reason="")
 
+    def fake_preflight(*args, **kwargs):
+        lifecycle_order.append("preflight")
+        return SimpleNamespace(attempted=False, committed=False, ok=True, result=None)
+
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", fake_preflight)
     monkeypatch.setattr(runners, "ensure_linked_worktree", fake_setup, raising=False)
 
     status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
 
     expected_worktree = paths.state_dir / "worktrees" / branch.replace("/", "-")
     assert status == "completed"
+    assert lifecycle_order[:2] == ["preflight", "worktree_setup"]
     assert setup_calls[0].worktree_path == expected_worktree.resolve()
     assert observed.launch_cwds == [expected_worktree.resolve()]
     assert observed.prompt_calls[0]["project_root"] == paths.project_root
@@ -784,6 +884,7 @@ def test_explicit_worktree_materializes_ignored_support_assets_before_prompt_and
     )
     monkeypatch.setattr(runners, "detect_stream_json_support", lambda command, platform: SimpleNamespace(enabled=False))
     monkeypatch.setattr(runners, "start_item", lambda *args, **kwargs: SimpleNamespace(ok=True, text="", data={"new_status": "in_progress"}))
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=False, committed=False, ok=True, result=None))
     monkeypatch.setattr(runners, "commit_pre_branch_bookkeeping", lambda *args, **kwargs: None)
     monkeypatch.setattr(runners, "commit_final_bookkeeping", lambda *args, **kwargs: None)
     monkeypatch.setattr(runners, "_session_id", lambda item_id: f"{item_id}-session")
@@ -863,6 +964,11 @@ def test_default_no_worktree_preserves_main_worktree_branch_launch(monkeypatch,
         lifecycle_order.append("start_item")
         return SimpleNamespace(ok=True, text="", data={"new_status": "in_progress"})
 
+    def fake_preflight(*args, **kwargs):
+        lifecycle_order.append("preflight")
+        return SimpleNamespace(attempted=False, committed=False, ok=True, result=None)
+
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", fake_preflight)
     monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
     monkeypatch.setattr(runners, "start_item", fake_start_item)
     monkeypatch.setattr(runners, "ensure_linked_worktree", lambda runtime: (_ for _ in ()).throw(AssertionError("worktree setup should not run")), raising=False)
@@ -874,10 +980,178 @@ def test_default_no_worktree_preserves_main_worktree_branch_launch(monkeypatch,
     assert observed.prompt_calls[0].get("execution_root") == paths.project_root
     assert "branch_create" in plan_names
     assert "branch_merge" in plan_names
-    assert lifecycle_order[:2] == ["branch_create", "start_item"]
+    assert lifecycle_order[:3] == ["preflight", "branch_create", "start_item"]
     assert branch_events == [("create", "dev/F-001-test"), ("merge", "dev/F-001-test")]
 
 
+def test_has_branch_completion_evidence_requires_task_branch_ahead_of_base(tmp_path):
+    from prizmkit_runtime.runner_classification import has_branch_completion_evidence
+
+    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)
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
+    artifact_dir.mkdir(parents=True)
+    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    (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)
+    subprocess.run(["git", "checkout", "-b", "dev/F-001"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (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)
+
+    assert has_branch_completion_evidence(tmp_path, "main", "dev/F-001", artifact_dir) is True
+
+    subprocess.run(["git", "checkout", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "main.txt").write_text("main", encoding="utf-8")
+    subprocess.run(["git", "add", "main.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "advance-main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "branch", "stale/F-001", "HEAD~1"], cwd=tmp_path, check=True)
+
+    assert has_branch_completion_evidence(tmp_path, "main", "stale/F-001", artifact_dir) is False
+
+
+def test_no_worktree_late_runtime_error_success_updates_and_merges(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import SessionClassification, family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-late-error")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    observed = _install_runner_session_fakes(monkeypatch, runners, statuses=("infra_error",))
+    events = []
+
+    def fake_classify(*args, **kwargs):
+        return SessionClassification("success", reason="completed_checkpoint_with_late_runtime_error")
+
+    def fake_run_git_plan(project_root, plan):
+        events.append(plan.name)
+        return SimpleNamespace(ok=True, plan=plan, results=())
+
+    monkeypatch.setattr(runners, "classify_session", fake_classify)
+    monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert status == "completed"
+    assert observed.updates[-1][0] == "success"
+    assert "branch_merge" in events
+
+
+def test_no_worktree_recovers_completed_pending_branch_before_new_session(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-recover")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    session_dir = paths.feature_state_dir / "F-001" / "sessions" / "F-001-session-old"
+    session_dir.mkdir(parents=True)
+    artifact_dir = paths.project_root / ".prizmkit" / "specs" / "001-low"
+    artifact_dir.mkdir(parents=True)
+    (artifact_dir / "workflow-checkpoint.json").write_text(
+        json.dumps({"steps": [{"id": "S01", "skill": "done", "status": "completed"}]}),
+        encoding="utf-8",
+    )
+    updates = []
+    events = []
+
+    monkeypatch.setattr(
+        runners,
+        "load_runtime_config",
+        lambda paths: SimpleNamespace(ai_client=SimpleNamespace(command="fake-ai", platform="codebuddy"), model="", effort=None),
+    )
+    monkeypatch.setattr(runners, "current_branch", lambda _root: "main")
+    monkeypatch.setattr(runners, "start_item", lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("should not restart completed work")))
+    monkeypatch.setattr(runners, "generate_prompt", lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("should not launch prompt")))
+    monkeypatch.setattr(runners, "has_branch_completion_evidence", lambda *args, **kwargs: True)
+    monkeypatch.setattr(runners, "commit_final_bookkeeping", lambda *args, **kwargs: None)
+    monkeypatch.setattr(runners, "commit_task_branch_changes", lambda *args, **kwargs: None)
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=False, committed=False, ok=True, result=None))
+
+    def fake_update(family, invocation, item_id, session_status, session_id, project_root, **metadata):
+        updates.append((session_status, session_id, metadata))
+        return SimpleNamespace(ok=True, text="", data={"new_status": "completed"})
+
+    def fake_run_git_plan(project_root, plan):
+        events.append(plan.name)
+        return SimpleNamespace(ok=True, plan=plan, results=())
+
+    monkeypatch.setattr(runners, "update_item", fake_update)
+    monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={"title": "Low"})
+
+    assert status == "completed"
+    assert updates == [("success", "F-001-session-old", {"active_dev_branch": "dev/F-001-recover", "base_branch": "main"})]
+    assert "branch_merge" in events
+
+
+def test_worktree_recovers_completed_pending_branch_from_base_session_history(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("USE_WORKTREE", "1")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    base_session_dir = paths.feature_state_dir / "F-001" / "sessions" / "F-001-session-old"
+    base_session_dir.mkdir(parents=True)
+    (base_session_dir / "session-status.json").write_text(
+        json.dumps({"base_branch": "main", "active_dev_branch": "dev/F-001-worktree"}),
+        encoding="utf-8",
+    )
+    updates = []
+    cleanup_calls = []
+    merge_calls = []
+
+    monkeypatch.setattr(
+        runners,
+        "load_runtime_config",
+        lambda paths: SimpleNamespace(ai_client=SimpleNamespace(command="fake-ai", platform="codebuddy"), model="", effort=None),
+    )
+    monkeypatch.setattr(runners, "current_branch", lambda _root: "main")
+    monkeypatch.setattr(runners, "ensure_linked_worktree", lambda runtime: SimpleNamespace(ok=True, runtime=runtime, reason=""), raising=False)
+    monkeypatch.setattr(runners, "materialize_worktree_support_assets", lambda runtime: SimpleNamespace(ok=True, reason=""), raising=False)
+    monkeypatch.setattr(runners, "has_completed_artifact_path", lambda artifact: True)
+    monkeypatch.setattr(runners, "has_branch_completion_evidence", lambda *args, **kwargs: True)
+    monkeypatch.setattr(runners, "start_item", lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("should not restart completed work")))
+    monkeypatch.setattr(runners, "generate_prompt", lambda *args, **kwargs: (_ for _ in ()).throw(AssertionError("should not launch prompt")))
+    monkeypatch.setattr(runners, "commit_final_bookkeeping", lambda *args, **kwargs: None)
+    monkeypatch.setattr(runners, "commit_task_branch_changes", lambda *args, **kwargs: None)
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=False, committed=False, ok=True, result=None))
+
+    def fake_update(family, invocation, item_id, session_status, session_id, project_root, **metadata):
+        updates.append((session_status, session_id, project_root, metadata))
+        return SimpleNamespace(ok=True, text="", data={"new_status": "completed"})
+
+    def fake_merge(runtime, *, auto_push=False):
+        merge_calls.append((runtime, auto_push))
+        return SimpleNamespace(ok=True, reason="", runtime=runtime, results=())
+
+    def fake_cleanup(runtime, *, delete_branch=True):
+        cleanup_calls.append((runtime, delete_branch))
+        return SimpleNamespace(ok=True, reason="")
+
+    monkeypatch.setattr(runners, "update_item", fake_update)
+    monkeypatch.setattr(runners, "merge_linked_worktree", fake_merge, raising=False)
+    monkeypatch.setattr(runners, "guarded_worktree_remove", fake_cleanup, raising=False)
+
+    status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={"title": "Low"})
+
+    assert status == "completed"
+    assert updates[0][0] == "success"
+    assert updates[0][1] == "F-001-session-old"
+    assert updates[0][2] != paths.project_root
+    assert merge_calls and cleanup_calls[-1][1] is True
+
+
 def test_default_branch_names_keep_timestamp_for_each_runner_family(monkeypatch, tmp_path):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for
@@ -963,6 +1237,33 @@ def test_no_worktree_runner_ignores_recovery_side_effect_branch(monkeypatch, tmp
     assert observed.updates[-1][2]["base_branch"] == "main"
 
 
+def test_no_worktree_preflight_commit_failure_aborts_before_branch_or_status(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-preflight-fail")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    events = []
+
+    monkeypatch.setattr(
+        runners,
+        "load_runtime_config",
+        lambda paths: SimpleNamespace(ai_client=SimpleNamespace(command="fake-ai", platform="codebuddy"), model="", effort=None),
+    )
+    monkeypatch.setattr(runners, "current_branch", lambda _root: "main")
+    monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=True, committed=False, result=SimpleNamespace(stderr="commit failed\n", stdout="")))
+    monkeypatch.setattr(runners, "run_git_plan", lambda *args, **kwargs: events.append("branch_create"))
+    monkeypatch.setattr(runners, "start_item", lambda *args, **kwargs: events.append("start_item"))
+
+    with pytest.raises(RuntimeError, match="Preflight dirty workspace preservation failed"):
+        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    assert events == []
+
+
 def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_path, capsys):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
@@ -988,7 +1289,7 @@ def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_pa
     assert "────────────────────────────────────────────────────" in captured.err
     assert "Feature: F-001 — Readable output" in captured.err
     assert "Code retry: 1 / 3" in captured.err
-    assert "Infrastructure retry: 2 / 3" in captured.err
+    assert "Preflight: no user-visible changes to preserve before feature task F-001" in captured.err
     assert "Pipeline mode: lite (Tier 1 — Single Agent)" in captured.err
     assert "Agents: 1 (critic: disabled)" in captured.err
     assert "Spawning AI CLI session: F-001-session-1" in captured.err
@@ -1108,6 +1409,133 @@ def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outco
     assert observed.cleanup_calls[0][1] is True
 
 
+def test_classification_accepts_late_infra_error_with_completed_checkpoint_and_commit(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    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)
+    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_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
+    artifact_dir.mkdir(parents=True)
+    checkpoint = artifact_dir / "workflow-checkpoint.json"
+    checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "status": "completed"}]}), encoding="utf-8")
+    log = tmp_path / "session.log"
+    log.write_text("model quota exceeded; API error after commit", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="api_error",
+        progress_summary=ProgressSummary(terminal_result_text="quota exceeded"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+    prompt = PromptGenerationResult(output_path=tmp_path / "prompt.md", checkpoint_path=checkpoint, artifact_path=artifact_dir)
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=base_head, prompt=prompt)
+
+    assert classification.session_status == "success"
+    assert classification.reason == "completed_checkpoint_with_late_runtime_error"
+
+
+def test_classification_rejects_late_infra_when_head_diff_has_no_commit_range(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    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)
+    subprocess.run(["git", "checkout", "-b", "side"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "side.txt").write_text("side", encoding="utf-8")
+    subprocess.run(["git", "add", "side.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "side"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    side_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+    subprocess.run(["git", "checkout", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "main.txt").write_text("main", encoding="utf-8")
+    subprocess.run(["git", "add", "main.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "side"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
+    artifact_dir.mkdir(parents=True)
+    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    log = tmp_path / "session.log"
+    log.write_text("quota exceeded", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="api_error",
+        progress_summary=ProgressSummary(terminal_result_text="quota exceeded"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+    prompt = PromptGenerationResult(output_path=tmp_path / "prompt.md", artifact_path=artifact_dir)
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=side_head, prompt=prompt)
+
+    assert classification.session_status == "infra_error"
+
+
+def test_classification_keeps_pre_completion_provider_error_as_infra_error(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    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)
+    base_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+    log = tmp_path / "session.log"
+    log.write_text("authentication failed", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="authentication_error",
+        progress_summary=ProgressSummary(terminal_result_text="authentication failed"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=base_head)
+
+    assert classification.session_status == "infra_error"
+    assert classification.reason == "ai_runtime_or_provider_error"
+
+
 def test_classification_accepts_terminal_success_with_completed_checkpoint_without_git_delta(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.runner_models import PromptGenerationResult