prizmkit 1.1.119 → 1.1.121

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

@@ -1,5 +1,6 @@
 """Tests for generate-refactor-prompt.py continuation behavior."""
 
+import json
 from argparse import Namespace
 from pathlib import Path
 import os
@@ -20,7 +21,14 @@ class TestRefactorContinuationHandoff:
         args = Namespace(
             output=str(tmp_path / ".prizmkit/state/refactor/R-007/sessions/R-007-new/bootstrap-prompt.md"),
             state_dir=str(tmp_path / ".prizmkit/state/refactor"),
-            continuation_mode="context_overflow",
+            continuation_mode="ai_error",
+            failure_classification="ai_runtime_or_provider_error",
+            code_retry_count="1",
+            infra_error_count="2",
+            max_code_retries="3",
+            max_infra_retries="3",
+            no_progress_count="0",
+            progress_fingerprint=json.dumps({"git_diff_fingerprint": "diff", "head_commit": "abc", "checkpoint_cursor": "S03:pending"}),
             previous_session_id="R-007-old",
             continuation_count="1",
             context_overflow_count="1",
@@ -82,10 +90,7 @@ class TestExplicitProjectRoot:
         )
 
         assert replacements["{{PROJECT_ROOT}}"] == str(project.resolve())
-        assert replacements["{{REVIEWER_SUBAGENT_PATH}}"].endswith(
-            ".claude/agents/prizm-dev-team-reviewer.md"
-        )
-        assert replacements["{{REVIEWER_SUBAGENT_PATH}}"].startswith(str(project.resolve()))
+        assert "{{" + "REVIEWER_" + "SUBAGENT_PATH" + "}}" not in replacements
         assert replacements["{{SESSION_STATUS_PATH}}"] == str(
             project / ".prizmkit" / "state" / "refactor" / "R-001" /
             "sessions" / "session-1" / "session-status.json"
@@ -126,7 +131,7 @@ class TestExplicitProjectRoot:
             "sessions" / "session-1" / "session-status.json"
         )
         assert not replacements["{{SESSION_STATUS_PATH}}"].startswith(str(execution_root.resolve()))
-        assert replacements["{{DEV_SUBAGENT_PATH}}"].startswith(str(execution_root.resolve()))
+        assert "{{" + "DEV_" + "SUBAGENT_PATH" + "}}" not in replacements
         assert "### Checkpoint Update Helper" in replacements["{{CHECKPOINT_SYSTEM}}"]
         assert "{{CHECKPOINT_PYTHON_CMD}}" in replacements["{{CHECKPOINT_SYSTEM}}"]
         assert "pipeline progress mechanism" not in replacements["{{CHECKPOINT_SYSTEM}}"]
@@ -234,14 +239,6 @@ def _render_refactor_prompt_full(tmp_path, platform="claude"):
     (project / ".prizmkit" / "config.json").write_text(
         json.dumps({"platform": platform, "ai_cli": platform}), encoding="utf-8"
     )
-    # Ensure agent files
-    for plat in ("claude", "codex"):
-        platform_dir = ".codex" if plat == "codex" else ".claude"
-        suffix = ".toml" if plat == "codex" else ".md"
-        agents_dir = project / platform_dir / "agents"
-        agents_dir.mkdir(parents=True, exist_ok=True)
-        for name in ("dev", "reviewer"):
-            (agents_dir / f"prizm-dev-team-{name}{suffix}").write_text("agent\n", encoding="utf-8")
 
     refactor_list = project / ".prizmkit" / "plans" / "refactor-list.json"
     refactor_list.parent.mkdir(parents=True)

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

@@ -811,8 +811,8 @@ def test_prompt_generation_passes_explicit_execution_root_to_generator(monkeypat
                     "output_path": str(session_paths.prompt_path),
                     "checkpoint_path": str(execution_root / ".prizmkit" / "specs" / "001-low" / "workflow-checkpoint.json"),
                     "model": "",
-                    "pipeline_mode": "lite",
-                    "agent_count": 1,
+                    "pipeline_mode": "full",
+                    "agent_count": 3,
                 }
             ),
             stderr="",
@@ -876,8 +876,8 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
         return PromptGenerationResult(
             output_path=session_paths.prompt_path,
             model="per-item-model",
-            pipeline_mode="lite",
-            agent_count=1,
+            pipeline_mode="full",
+            agent_count=3,
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-low" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-low",
             raw={},
@@ -904,7 +904,20 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
 
     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": update_status})
+        current_update_status = update_status
+        if session_status in {"context_overflow", "infra_error", "crashed", "timed_out", "failed"} and len(status_queue) > 0:
+            current_update_status = "in_progress"
+        return SimpleNamespace(
+            ok=True,
+            text="",
+            data={
+                "new_status": current_update_status,
+                "retry_count": sum(status in {"crashed", "timed_out", "failed"} for status, *_ in updates),
+                "infra_error_count": sum(status == "infra_error" for status, *_ in updates),
+                "continuation_count": len(updates),
+                "context_overflow_count": sum(status == "context_overflow" for status, *_ in updates),
+            },
+        )
 
     def fake_cleanup(runtime, *, delete_branch=True):
         cleanup_calls.append((runtime, delete_branch))
@@ -1090,15 +1103,14 @@ def test_explicit_worktree_materializes_ignored_support_assets_before_prompt_and
     subprocess.run(["git", "add", ".gitignore", "tracked.txt"], cwd=project, check=True)
     subprocess.run(["git", "commit", "-m", "base"], cwd=project, check=True, stdout=subprocess.DEVNULL)
 
-    (project / ".claude" / "agents").mkdir(parents=True)
-    (project / ".claude" / "agents" / "prizm-dev-team-dev.md").write_text("dev agent", encoding="utf-8")
-    (project / ".claude" / "team-info.json").write_text("{}", encoding="utf-8")
+    (project / ".claude" / "commands").mkdir(parents=True)
+    (project / ".claude" / "commands" / "prizmkit.md").write_text("skill", encoding="utf-8")
     (project / ".prizmkit" / "prizm-docs").mkdir(parents=True)
     (project / ".prizmkit" / "prizm-docs" / "root.prizm").write_text("PRIZM_VERSION: 1\n", encoding="utf-8")
     (project / ".prizmkit" / "dev-pipeline" / "scripts").mkdir(parents=True)
-    (project / ".prizmkit" / "dev-pipeline" / "scripts" / "init-dev-team.py").write_text("# init", encoding="utf-8")
-    (project / ".prizmkit" / "config.json").write_text("{}", encoding="utf-8")
-    (project / ".prizmkit" / "manifest.json").write_text("{}", encoding="utf-8")
+    (project / ".prizmkit" / "dev-pipeline" / "scripts" / "init-change-artifact.py").write_text("# init", encoding="utf-8")
+    (project / ".prizmkit" / "config.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
+    (project / ".prizmkit" / "manifest.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
 
     paths = resolve_runtime_paths(pipeline_root=PIPELINE_ROOT, project_root=project)
     family = family_for("feature", paths)
@@ -1128,18 +1140,18 @@ def test_explicit_worktree_materializes_ignored_support_assets_before_prompt_and
     def fake_generate_prompt(family, invocation, **kwargs):
         execution_root = kwargs["execution_root"]
         assert execution_root != project
-        assert (execution_root / ".claude" / "agents" / "prizm-dev-team-dev.md").is_file()
+        assert (execution_root / ".claude" / "commands" / "prizmkit.md").is_file()
         assert (execution_root / ".prizmkit" / "prizm-docs" / "root.prizm").is_file()
         assert (execution_root / ".prizmkit" / "config.json").is_file()
         assert (execution_root / ".prizmkit" / "manifest.json").is_file()
-        assert (execution_root / ".prizmkit" / "dev-pipeline" / "scripts" / "init-dev-team.py").is_file()
+        assert (execution_root / ".prizmkit" / "dev-pipeline" / "scripts" / "init-change-artifact.py").is_file()
         assert not (execution_root / ".prizmkit" / "dev-pipeline" / "run-feature.sh").exists()
         session_paths = kwargs["session_paths"]
         return PromptGenerationResult(
             output_path=session_paths.prompt_path,
             model="",
-            pipeline_mode="lite",
-            agent_count=1,
+            pipeline_mode="full",
+            agent_count=3,
             checkpoint_path=execution_root / ".prizmkit" / "specs" / "001-support" / "workflow-checkpoint.json",
             artifact_path=execution_root / ".prizmkit" / "specs" / "001-support",
             raw={},
@@ -1226,7 +1238,7 @@ def test_has_branch_completion_evidence_requires_task_branch_ahead_of_base(tmp_p
     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")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), 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)
@@ -1406,7 +1418,7 @@ def test_default_branch_names_keep_timestamp_for_each_runner_family(monkeypatch,
         ("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):
+def test_no_worktree_exhausted_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
 
@@ -1416,7 +1428,7 @@ def test_no_worktree_failure_stays_on_task_branch_without_merge_for_all_families
     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")
+    _install_runner_session_fakes(monkeypatch, runners, statuses=("crashed",), update_status="failed")
     events = []
     final_commits = []
     wip_commits = []
@@ -1432,12 +1444,12 @@ def test_no_worktree_failure_stays_on_task_branch_without_merge_for_all_families
 
     status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
 
-    assert status == "pending"
+    assert status == "failed"
     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")]
+    assert final_commits == [(paths.project_root, item_id, "failed")]
+    assert wip_commits == [(paths.project_root, item_id, "failed")]
 
 
 def test_no_worktree_runner_ignores_recovery_side_effect_branch(monkeypatch, tmp_path):
@@ -1535,8 +1547,8 @@ def test_foreground_runner_emits_structured_feature_progress(monkeypatch, tmp_pa
     assert "Feature: F-001 — Readable output" in captured.err
     assert "Code retry: 1 / 3" in captured.err
     assert "Preflight: no user-visible changes to preserve before feature task F-001" in captured.err
-    assert "Pipeline mode: lite (Tier 1 — Single Agent)" in captured.err
-    assert "Agents: 1" in captured.err
+    assert "Pipeline mode: full (Tier 3 — Orchestrator + Reviewer)" in captured.err
+    assert "Agents: 3" in captured.err
     assert "Spawning AI CLI session: F-001-session-1" in captured.err
     assert "Session result: success" in captured.err
 
@@ -1846,7 +1858,7 @@ def test_bookkeeping_commits_only_runner_owned_paths(tmp_path):
     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")
+    (item_state / "status.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), 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)
@@ -1900,6 +1912,8 @@ def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outco
     invocation = parse_invocation(family, "run", ())
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
     observed = _install_runner_session_fakes(monkeypatch, runners, statuses=("context_overflow", "success"))
+    sleep_calls = []
+    monkeypatch.setattr(runners.time, "sleep", lambda seconds: sleep_calls.append(seconds))
     setup_calls = []
     monkeypatch.setattr(runners, "ensure_linked_worktree", lambda runtime: (setup_calls.append(runtime) or SimpleNamespace(ok=True, runtime=runtime, reason="")), raising=False)
 
@@ -1912,6 +1926,7 @@ def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outco
     assert observed.prompt_calls[0].get("continuation") is None
     assert observed.prompt_calls[1]["continuation"]["previous_session_id"] == "F-001-session-1"
     assert observed.updates[0][0] == "context_overflow"
+    assert sleep_calls == [5]
     assert len(observed.cleanup_calls) == 1
     assert observed.cleanup_calls[0][1] is True
 
@@ -1960,7 +1975,7 @@ def test_classification_accepts_late_infra_error_with_completed_checkpoint_and_c
     assert classification.reason == "completed_checkpoint_with_late_runtime_error"
 
 
-def test_classification_rejects_late_infra_when_head_diff_has_no_commit_range(tmp_path):
+def test_classification_accepts_late_infra_with_completion_artifact_without_new_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
@@ -1984,7 +1999,7 @@ def test_classification_rejects_late_infra_when_head_diff_has_no_commit_range(tm
     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")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     log = tmp_path / "session.log"
     log.write_text("quota exceeded", encoding="utf-8")
     raw = AISessionResult(
@@ -2005,7 +2020,8 @@ def test_classification_rejects_late_infra_when_head_diff_has_no_commit_range(tm
 
     classification = classify_session(raw, project_root=tmp_path, base_head=side_head, prompt=prompt)
 
-    assert classification.session_status == "infra_error"
+    assert classification.session_status == "success"
+    assert classification.reason == "completed_checkpoint_with_late_runtime_error"
 
 
 def test_classification_keeps_pre_completion_provider_error_as_infra_error(tmp_path):
@@ -2061,7 +2077,7 @@ def test_classification_accepts_terminal_success_with_completed_checkpoint_witho
     artifact_dir.mkdir(parents=True)
     checkpoint = artifact_dir / "workflow-checkpoint.json"
     checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}), encoding="utf-8")
-    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     log = tmp_path / "session.log"
     log.write_text("terminal success", encoding="utf-8")
     raw = AISessionResult(
@@ -2123,8 +2139,8 @@ def test_classification_preserves_success_before_context_overflow(tmp_path):
     )
 
     classification = classify_session(raw, project_root=tmp_path, base_head=base_head)
-    assert classification.session_status == "success"
-    assert classification.reason == "commit_since_base"
+    assert classification.session_status == "context_overflow"
+    assert classification.reason == "context_overflow"
 
 
 def test_classification_crash_with_commit_since_base_does_not_become_success(tmp_path):
@@ -2257,7 +2273,7 @@ def _write_family_case(paths, kind, item_id=""):
         state_dir = paths.refactor_state_dir
         plan = paths.refactor_plan
     state_dir.mkdir(parents=True, exist_ok=True)
-    (state_dir / "pipeline.json").write_text("{}", encoding="utf-8")
+    (state_dir / "pipeline.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     item_state = state_dir / item_id
     item_state.mkdir(parents=True, exist_ok=True)
     (item_state / "status.json").write_text(
@@ -2518,7 +2534,7 @@ def test_invalid_existing_checkpoint_blocks_terminal_success_with_completion_sum
     artifact_dir.mkdir(parents=True)
     checkpoint = artifact_dir / "workflow-checkpoint.json"
     checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "not-valid"}]}), encoding="utf-8")
-    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     prompt = PromptGenerationResult(output_path=tmp_path / "prompt.md", checkpoint_path=checkpoint, artifact_path=artifact_dir)
 
     classification = classify_session(_terminal_success_result(tmp_path), project_root=tmp_path, base_head=base_head, prompt=prompt)
@@ -2598,3 +2614,190 @@ def test_invalid_existing_checkpoint_blocks_workspace_auto_commit_success(tmp_pa
 
     assert classification.session_status == "crashed"
     assert classification.reason == "invalid_workflow_checkpoint:empty_steps"
+
+
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-ai-retry"),
+        ("bugfix", "B-001", "bugfix/B-001-ai-retry"),
+        ("refactor", "R-001", "refactor/R-001-ai-retry"),
+    ],
+)
+@pytest.mark.parametrize("retry_status", ["infra_error", "crashed", "timed_out"])
+def test_retryable_ai_errors_continue_in_process_for_all_families(monkeypatch, tmp_path, kind, item_id, branch, retry_status):
+    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 / retry_status)
+    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})
+    observed = _install_runner_session_fakes(monkeypatch, runners, statuses=(retry_status, "success"))
+    sleep_calls = []
+    branch_plans = []
+    monkeypatch.setattr(runners.time, "sleep", lambda seconds: sleep_calls.append(seconds))
+    monkeypatch.setattr(
+        runners,
+        "run_git_plan",
+        lambda project_root, plan: (branch_plans.append(plan.name) or SimpleNamespace(ok=True, plan=plan, results=())),
+    )
+
+    status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
+
+    assert status == "completed"
+    assert sleep_calls == [5]
+    assert len(observed.launch_cwds) == 2
+    assert observed.launch_cwds[0] == observed.launch_cwds[1]
+    assert branch_plans.count("branch_create") == 1
+    assert observed.updates[0][0] == retry_status
+    continuation = observed.prompt_calls[1]["continuation"]
+    assert continuation["previous_session_id"].endswith("session-1")
+    assert continuation["failure_classification"] == retry_status
+    assert continuation["active_dev_branch"] == branch
+
+
+def test_unique_session_ids_do_not_collide_when_wall_clock_second_is_frozen(monkeypatch):
+    from prizmkit_runtime import runners
+
+    monkeypatch.setattr(runners.time, "strftime", lambda _fmt: "20260711030000")
+    values = iter((101, 102))
+    monkeypatch.setattr(runners.time, "time_ns", lambda: next(values))
+
+    first = runners._session_id("F-001")
+    second = runners._session_id("F-001")
+
+    assert first != second
+    assert first.endswith("-101")
+    assert second.endswith("-102")
+
+
+@pytest.mark.parametrize("summary_text", ["{}", "{not-json", '{"completion_notes": []}', '{"completion_notes": [""]}'])
+def test_invalid_completion_summary_does_not_prove_late_runtime_success(tmp_path, summary_text):
+    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()
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-invalid"
+    artifact_dir.mkdir(parents=True)
+    (artifact_dir / "completion-summary.json").write_text(summary_text, encoding="utf-8")
+    log = tmp_path / "session.log"
+    log.write_text("quota exceeded", encoding="utf-8")
+    result = 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,
+    )
+
+    classification = classify_session(
+        result,
+        project_root=tmp_path,
+        base_head=base_head,
+        prompt=PromptGenerationResult(output_path=tmp_path / "prompt.md", artifact_path=artifact_dir),
+    )
+
+    assert classification.session_status == "infra_error"
+
+
+def test_non_utf8_completion_summary_does_not_abort_classification(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()
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-corrupt"
+    artifact_dir.mkdir(parents=True)
+    (artifact_dir / "completion-summary.json").write_bytes(b"\xff\xfe")
+    log = tmp_path / "session.log"
+    log.write_text("quota exceeded", encoding="utf-8")
+    result = 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,
+    )
+
+    classification = classify_session(
+        result,
+        project_root=tmp_path,
+        base_head=base_head,
+        prompt=PromptGenerationResult(output_path=tmp_path / "prompt.md", artifact_path=artifact_dir),
+    )
+
+    assert classification.session_status == "infra_error"
+
+
+@pytest.mark.parametrize(
+    ("timed_out", "termination_reason", "expected_status", "expected_reason"),
+    [
+        (True, "timeout", "timed_out", "timeout"),
+        (False, "stale_session", "crashed", "stale_session"),
+    ],
+)
+def test_timeout_and_stale_termination_override_provider_error_markers(tmp_path, timed_out, termination_reason, expected_status, expected_reason):
+    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("gateway API error", encoding="utf-8")
+    result = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=timed_out,
+        termination_reason=termination_reason,
+        stale_marker=None,
+        fatal_error_code="api_error",
+        progress_summary=ProgressSummary(terminal_result_text="provider gateway error"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(result, project_root=tmp_path, base_head=base_head)
+
+    assert classification.session_status == expected_status
+    assert classification.reason == expected_reason