prizmkit 1.1.106 → 1.1.107

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

@@ -28,6 +28,20 @@ from generate_bootstrap_prompt import (
 )
 from continuation import append_continuation_handoff, checkpoint_cursor
 
+REMOVED_MAX_LOG_ENV = "MAX_" + "LOG_SIZE"
+REMOVED_MAX_LOG_HUMAN = REMOVED_MAX_LOG_ENV + "_HUMAN"
+
+FORBIDDEN_DEV_FIX_PROMPT = "dev-" + "fix.md"
+FORBIDDEN_DEV_RESUME_PROMPT = "dev-" + "resume.md"
+FORBIDDEN_DEV_FIX_PLACEHOLDER = "{{AGENT_PROMPT_DEV_" + "FIX}}"
+FORBIDDEN_DEV_RESUME_PLACEHOLDER = "{{AGENT_PROMPT_DEV_" + "RESUME}}"
+FORBIDDEN_REVIEW_DEV_FIX = "Reviewer Agent → filter → " + "Dev Agent fix"
+FORBIDDEN_REVIEWER_DEV_SPAWN = "Reviewer/" + "Dev agent spawn"
+FORBIDDEN_EXPLORE_SUBAGENT = "subagent_type: " + "Explore"
+FORBIDDEN_TEST_CMD_PLACEHOLDER = "(" + "$TEST_CMD" + ")"
+FORBIDDEN_THREE_STRIKE = "3-" + "strike"
+FORBIDDEN_TWENTY_STEP = "20-" + "step window"
+
 
 def scoped_report_text(verdict="PASS", boundary_missing=0,
                        happy_path_only=0, completion_gate="yes",
@@ -222,6 +236,11 @@ class TestExplicitProjectRoot:
         assert not replacements["{{SESSION_STATUS_PATH}}"].startswith(str(execution_root.resolve()))
         assert replacements["{{PROJECT_BRIEF}}"] == "worktree brief"
         assert replacements["{{DEV_SUBAGENT_PATH}}"].startswith(str(execution_root.resolve()))
+        assert replacements["{{SESSION_LOG_PATH}}"].endswith(
+            ".prizmkit/state/features/F-001/sessions/session-1/logs/session.log"
+        )
+        assert "{{" + REMOVED_MAX_LOG_ENV + "}}" not in replacements
+        assert "{{" + REMOVED_MAX_LOG_HUMAN + "}}" not in replacements
 
 
     def test_main_writes_checkpoint_under_cli_project_root_and_status_under_state_dir(self, tmp_path, monkeypatch):
@@ -779,11 +798,14 @@ class TestHeadlessRecoveryReframing:
     def test_log_size_awareness_is_passive_checkpoint_guidance(self):
         content = load_log_size_section(str(Path("dev-pipeline/scripts").resolve()))
 
-        assert "Session Log Budget Awareness" in content
+        assert "Session Checkpoint Awareness" in content
         assert "passive checkpoint guidance" in content
         assert "durable checkpoints and artifacts" in content
         assert "fresh continuation session" in content
         assert "optional interactive convenience only" in content
+        assert REMOVED_MAX_LOG_ENV not in content
+        assert ("maximum-" + "log-size") not in content
+        assert ("log size " + "limit") not in content.lower()
         assert "COMPACT_NEEDED" not in content
         assert "monitor-log" not in content
         assert "background monitoring subagent" not in content
@@ -802,6 +824,10 @@ class TestHeadlessRecoveryReframing:
             )
             assert "Headless recovery must rely on durable checkpoints" in rendered
             assert "fresh continuation session" in rendered
+            assert REMOVED_MAX_LOG_ENV not in rendered
+            assert REMOVED_MAX_LOG_HUMAN not in rendered
+            assert ("209" + "7152") not in rendered
+            assert ("2" + "MB") not in rendered
             assert "monitor-log" not in rendered
             assert "COMPACT_NEEDED" not in rendered
             assert "log-size monitor" not in rendered
@@ -818,9 +844,16 @@ class TestDirectOrchestratorImplementationPrompts:
         replacements = load_active_agent_prompts(str(templates_dir))
 
         assert "dev-implement.md" not in ACTIVE_AGENT_PROMPTS
+        assert FORBIDDEN_DEV_FIX_PROMPT not in ACTIVE_AGENT_PROMPTS
+        assert FORBIDDEN_DEV_RESUME_PROMPT not in ACTIVE_AGENT_PROMPTS
         assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in replacements
+        assert FORBIDDEN_DEV_FIX_PLACEHOLDER not in replacements
+        assert FORBIDDEN_DEV_RESUME_PLACEHOLDER not in replacements
         assert "{{AGENT_PROMPT_CRITIC_PLAN_CHALLENGE}}" in replacements
+        assert "{{AGENT_PROMPT_REVIEWER_REVIEW}}" in replacements
         assert (templates_dir / "agent-prompts" / "dev-implement.md").exists() is False
+        assert (templates_dir / "agent-prompts" / FORBIDDEN_DEV_FIX_PROMPT).exists() is False
+        assert (templates_dir / "agent-prompts" / FORBIDDEN_DEV_RESUME_PROMPT).exists() is False
 
     def test_sections_all_modes_use_direct_orchestrator_implementation(self):
         sections_dir = Path("dev-pipeline/templates/sections").resolve()
@@ -840,7 +873,13 @@ class TestDirectOrchestratorImplementationPrompts:
             assert "Implement — Dev" not in rendered
             assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in rendered
             assert "dev-implement.md" not in rendered
-            assert "Reviewer Agent → filter → Dev Agent fix" in rendered
+            assert FORBIDDEN_REVIEW_DEV_FIX not in rendered
+            assert FORBIDDEN_REVIEWER_DEV_SPAWN not in rendered
+            assert FORBIDDEN_EXPLORE_SUBAGENT not in rendered
+            assert FORBIDDEN_TEST_CMD_PLACEHOLDER not in rendered
+            assert FORBIDDEN_THREE_STRIKE not in rendered
+            assert FORBIDDEN_TWENTY_STEP not in rendered
+            assert "Reviewer Agent → filter → orchestrator fix" in rendered
 
     def test_legacy_tier_templates_use_direct_orchestrator_implementation(self):
         for template_name in ("bootstrap-tier2.md", "bootstrap-tier3.md"):
@@ -853,6 +892,12 @@ class TestDirectOrchestratorImplementationPrompts:
             assert "Implement — Dev" not in rendered
             assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in rendered
             assert "dev-implement.md" not in rendered
+            assert FORBIDDEN_REVIEW_DEV_FIX not in rendered
+            assert FORBIDDEN_REVIEWER_DEV_SPAWN not in rendered
+            assert FORBIDDEN_EXPLORE_SUBAGENT not in rendered
+            assert FORBIDDEN_TEST_CMD_PLACEHOLDER not in rendered
+            assert FORBIDDEN_THREE_STRIKE not in rendered
+            assert FORBIDDEN_TWENTY_STEP not in rendered
 
 
 # ---------------------------------------------------------------------------
@@ -898,6 +943,8 @@ class TestContinuationHandoff:
         assert ".prizmkit/state/features/F-123/sessions/F-123-new/logs/session.log" in rendered
         assert ".prizmkit/state/features/F-123/sessions/F-123-new/logs/progress.json" in rendered
         assert ".prizmkit/state/features/F-123/sessions/F-123-new/logs/ai.pid" in rendered
+        assert ("Log " + "monitor") not in rendered
+        assert ("log-" + "monitor") not in rendered
 
         summary = tmp_path / ".prizmkit/specs/123-continuation/continuation-summary.md"
         assert summary.exists()

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

@@ -16,6 +16,9 @@ from generate_bugfix_prompt import (
 )
 from continuation import append_continuation_handoff
 
+REMOVED_MAX_LOG_ENV = "MAX_" + "LOG_SIZE"
+REMOVED_MAX_LOG_HUMAN = REMOVED_MAX_LOG_ENV + "_HUMAN"
+
 
 # ---------------------------------------------------------------------------
 # find_bug
@@ -193,6 +196,11 @@ class TestExplicitProjectRoot:
         )
         assert not replacements["{{SESSION_STATUS_PATH}}"].startswith(str(execution_root.resolve()))
         assert replacements["{{DEV_SUBAGENT_PATH}}"].startswith(str(execution_root.resolve()))
+        assert replacements["{{SESSION_LOG_PATH}}"].endswith(
+            ".prizmkit/state/bugfix/B-001/sessions/session-1/logs/session.log"
+        )
+        assert "{{" + REMOVED_MAX_LOG_ENV + "}}" not in replacements
+        assert "{{" + REMOVED_MAX_LOG_HUMAN + "}}" not in replacements
 
 
 # ---------------------------------------------------------------------------
@@ -225,6 +233,9 @@ class TestHeadlessRecoveryReframing:
         assert "Headless recovery must rely on durable checkpoints" in content
         assert "fresh continuation session" in content
         assert "optional interactive convenience only" in content
+        assert REMOVED_MAX_LOG_ENV not in content
+        assert ("maximum-" + "log-size") not in content
+        assert ("log size " + "limit") not in content.lower()
         assert "COMPACT_NEEDED" not in content
         assert "monitor-log" not in content
         assert "background monitoring subagent" not in content
@@ -235,6 +246,10 @@ class TestHeadlessRecoveryReframing:
         content = Path("dev-pipeline/templates/bugfix-bootstrap-prompt.md").read_text(encoding="utf-8")
 
         assert "Do not spawn persistent background subagents for headless recovery" in content
+        assert REMOVED_MAX_LOG_ENV not in content
+        assert REMOVED_MAX_LOG_HUMAN not in content
+        assert ("209" + "7152") not in content
+        assert ("2" + "MB") not in content
         assert "log-size monitor" not in content
         assert "monitor-log" not in content
         assert "COMPACT_NEEDED" not in content
@@ -264,5 +279,7 @@ class TestBugfixContinuationHandoff:
         assert prompt.startswith("BUGFIX PROMPT")
         assert "This is an automatic continuation after context overflow." in prompt
         assert "Do not attempt `/compact` as the recovery mechanism." in prompt
+        assert ("Log " + "monitor") not in prompt
+        assert ("log-" + "monitor") not in prompt
         assert (tmp_path / ".prizmkit/specs/B-007/continuation-summary.md").exists()
         assert (tmp_path / ".prizmkit/bugfix/B-007/continuation-summary.md").exists()

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

@@ -1,9 +1,18 @@
 """Tests for generate-refactor-prompt.py continuation behavior."""
 
 from argparse import Namespace
+from pathlib import Path
 
 from continuation import append_continuation_handoff
-from generate_refactor_prompt import generate_refactor_checkpoint, merge_refactor_checkpoint_state
+from generate_refactor_prompt import (
+    build_replacements,
+    generate_refactor_checkpoint,
+    load_log_size_section,
+    merge_refactor_checkpoint_state,
+)
+
+REMOVED_MAX_LOG_ENV = "MAX_" + "LOG_SIZE"
+REMOVED_MAX_LOG_HUMAN = REMOVED_MAX_LOG_ENV + "_HUMAN"
 
 
 class TestRefactorContinuationHandoff:
@@ -27,6 +36,8 @@ class TestRefactorContinuationHandoff:
         assert prompt.startswith("REFACTOR PROMPT")
         assert "This is a fresh headless AI CLI session for the same task." in prompt
         assert "Do not attempt `/compact` as the recovery mechanism." in prompt
+        assert ("Log " + "monitor") not in prompt
+        assert ("log-" + "monitor") not in prompt
         assert (tmp_path / ".prizmkit/specs/R-007/continuation-summary.md").exists()
         assert (tmp_path / ".prizmkit/refactor/R-007/continuation-summary.md").exists()
 
@@ -41,3 +52,41 @@ class TestRefactorCheckpointMerge:
 
         assert merged["steps"][0]["status"] == "skipped"
         assert merged["steps"][1]["status"] == "pending"
+
+
+class TestRefactorPromptMaxLogRemoval:
+    def test_refactor_log_size_section_is_checkpoint_guidance_without_max_log_env(self):
+        content = load_log_size_section(str(Path("dev-pipeline/scripts").resolve()))
+
+        assert "passive checkpoint guidance" in content
+        assert "Headless recovery must rely on durable checkpoints" in content
+        assert "fresh continuation session" in content
+        assert REMOVED_MAX_LOG_ENV not in content
+        assert REMOVED_MAX_LOG_HUMAN not in content
+        assert ("maximum-" + "log-size") not in content
+        assert ("log size " + "limit") not in content.lower()
+
+    def test_refactor_replacements_keep_session_log_without_max_log_placeholders(self):
+        args = Namespace(
+            refactor_id="R-001",
+            session_id="session-1",
+            run_id="run-1",
+            retry_count="0",
+            resume_phase="null",
+            state_dir=None,
+            output="out.md",
+            template=None,
+            mode=None,
+            critic=None,
+        )
+        refactor = {"id": "R-001", "title": "Restructure", "description": "d"}
+
+        replacements = build_replacements(
+            args, refactor, [refactor], {}, str(Path("dev-pipeline/scripts").resolve())
+        )
+
+        assert replacements["{{SESSION_LOG_PATH}}"].endswith(
+            ".prizmkit/state/refactor/R-001/sessions/session-1/logs/session.log"
+        )
+        assert "{{" + REMOVED_MAX_LOG_ENV + "}}" not in replacements
+        assert "{{" + REMOVED_MAX_LOG_HUMAN + "}}" not in replacements

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):
@@ -878,6 +936,172 @@ def test_default_no_worktree_preserves_main_worktree_branch_launch(monkeypatch,
     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
@@ -1108,6 +1332,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