prizmkit 1.1.105 → 1.1.107

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):
@@ -847,12 +905,24 @@ def test_default_no_worktree_preserves_main_worktree_branch_launch(monkeypatch,
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
     observed = _install_runner_session_fakes(monkeypatch, runners)
     plan_names = []
+    branch_events = []
+    lifecycle_order = []
 
     def fake_run_git_plan(project_root, plan):
         plan_names.append(plan.name)
+        if plan.name == "branch_create":
+            lifecycle_order.append("branch_create")
+            branch_events.append(("create", plan.commands[1].args[2]))
+        if plan.name == "branch_merge":
+            branch_events.append(("merge", plan.commands[5].args[2]))
         return SimpleNamespace(ok=True, plan=plan, results=())
 
+    def fake_start_item(*args, **kwargs):
+        lifecycle_order.append("start_item")
+        return SimpleNamespace(ok=True, text="", data={"new_status": "in_progress"})
+
     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)
 
     status = runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
@@ -862,6 +932,228 @@ 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 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)
+
+    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)
+
+    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
+
+    monkeypatch.setattr(runners.time, "strftime", lambda fmt: "20260707010203")
+    paths = _make_paths(tmp_path)
+
+    assert runners._default_branch_name(family_for("feature", paths), "F-001") == "dev/F-001-20260707010203"
+    assert runners._default_branch_name(family_for("bugfix", paths), "B-001") == "bugfix/B-001-20260707010203"
+    assert runners._default_branch_name(family_for("refactor", paths), "R-001") == "refactor/R-001-20260707010203"
+
+
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-20260707010203"),
+        ("bugfix", "B-001", "bugfix/B-001-20260707010203"),
+        ("refactor", "R-001", "refactor/R-001-20260707010203"),
+    ],
+)
+def test_no_worktree_failure_stays_on_task_branch_without_merge_for_all_families(monkeypatch, tmp_path, kind, item_id, branch):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", branch)
+    paths = _make_paths(tmp_path / kind)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    plan_path = {"feature": paths.feature_plan, "bugfix": paths.bugfix_plan, "refactor": paths.refactor_plan}[kind]
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": plan_path})
+    _install_runner_session_fakes(monkeypatch, runners, statuses=("crashed",), update_status="pending")
+    events = []
+    final_commits = []
+    wip_commits = []
+
+    def fake_run_git_plan(project_root, plan):
+        events.append(plan.name)
+        return SimpleNamespace(ok=True, plan=plan, results=())
+
+    monkeypatch.setattr(runners, "run_git_plan", fake_run_git_plan)
+    monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, task_branch: events.append(("return", base, task_branch)))
+    monkeypatch.setattr(runners, "commit_final_bookkeeping", lambda project_root, family, item_id, status: final_commits.append((project_root, item_id, status)))
+    monkeypatch.setattr(runners, "commit_wip_changes", lambda project_root, family, item_id, status: wip_commits.append((project_root, item_id, status)))
+
+    status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
+
+    assert status == "pending"
+    assert events[0] == "branch_create"
+    assert "branch_merge" not in events
+    assert events[-1] == ("return", "main", branch)
+    assert final_commits == [(paths.project_root, item_id, "pending")]
+    assert wip_commits == [(paths.project_root, item_id, "pending")]
 
 
 def test_no_worktree_runner_ignores_recovery_side_effect_branch(monkeypatch, tmp_path):
@@ -956,6 +1248,63 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
     assert ensure_calls == [("main", "dev/F-001-interrupt")]
 
 
+def test_bookkeeping_commits_only_runner_owned_paths(tmp_path):
+    from prizmkit_runtime.runner_bookkeeping import commit_final_bookkeeping
+    from prizmkit_runtime.runner_models import RunnerFamily
+
+    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)
+    plans = tmp_path / ".prizmkit" / "plans"
+    state = tmp_path / ".prizmkit" / "state" / "features"
+    item_state = state / "F-001"
+    plans.mkdir(parents=True)
+    item_state.mkdir(parents=True)
+    plan = plans / "feature-list.json"
+    plan.write_text('{"features": []}', encoding="utf-8")
+    (item_state / "status.json").write_text("{}", encoding="utf-8")
+    source = tmp_path / "src.txt"
+    source.write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", ".prizmkit/plans/feature-list.json", ".prizmkit/state/features/F-001/status.json", "src.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    plan.write_text('{"features": [{"id": "F-001", "status": "completed"}]}', encoding="utf-8")
+    (item_state / "status.json").write_text('{"last_session_id": "s1"}', encoding="utf-8")
+    source.write_text("dirty source change", encoding="utf-8")
+    family = RunnerFamily(
+        kind="feature",
+        id_prefix="F-",
+        list_key="features",
+        list_arg="--feature-list",
+        item_id_arg="--feature-id",
+        state_dir=state,
+        plan_path=plan,
+        updater_script=tmp_path / "update-feature-status.py",
+        prompt_script=tmp_path / "generate-bootstrap-prompt.py",
+        branch_prefix="dev",
+        artifact_root_name="specs",
+    )
+
+    result = commit_final_bookkeeping(tmp_path, family, "F-001", "completed")
+    committed_files = subprocess.run(
+        ["git", "show", "--name-only", "--format=", "HEAD"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.splitlines()
+    dirty_files = subprocess.run(
+        ["git", "status", "--porcelain", "--", "src.txt"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+
+    assert result.committed is True
+    assert committed_files == [".prizmkit/plans/feature-list.json", ".prizmkit/state/features/F-001/status.json"]
+    assert dirty_files.startswith(" M src.txt")
+
+
 def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outcome(monkeypatch, tmp_path):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
@@ -983,6 +1332,179 @@ 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
+    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 / ".gitignore").write_text(".prizmkit/*\n", encoding="utf-8")
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", ".gitignore", "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()
+    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")
+    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    log = tmp_path / "session.log"
+    log.write_text("terminal success", encoding="utf-8")
+    raw = AISessionResult(
+        command=AISessionCommand(("fake",), None, "claude", "stdin"),
+        exit_code=0,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="",
+        progress_summary=ProgressSummary(result_subtype="success", terminal_result_text="Completed; working tree clean"),
+        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 == "terminal_success_with_completed_checkpoint"
+
+
 def test_classification_preserves_success_before_context_overflow(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
@@ -1021,6 +1543,43 @@ def test_classification_preserves_success_before_context_overflow(tmp_path):
     assert classification.reason == "commit_since_base"
 
 
+def test_classification_crash_with_commit_since_base_does_not_become_success(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()
+    (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)
+    log = tmp_path / "session.log"
+    log.write_text("hard failure", 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="",
+        progress_summary=ProgressSummary(terminal_result_text="hard failure"),
+        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 == "crashed"
+    assert classification.reason == "exit_code=1"
+
+
 def test_classification_stalls_after_repeated_no_progress_context_overflow(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session, progress_fingerprint
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult