prizmkit 1.1.149 → 1.1.151

package/bundled/dev-pipeline/prizmkit_runtime/runner_bookkeeping.py

@@ -13,11 +13,11 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from .gitops import (
-    HIDDEN_TOOL_WORKTREE_EXCLUDES,
     UNTRACKED_TRANSIENT_EXCLUDES,
     GitCommandResult,
-    git_status_safe,
+    addable_task_paths,
     run_git_command,
+    visible_task_paths,
 )
 from .runner_models import RunnerFamily
 
@@ -203,7 +203,7 @@ def _remaining_preflight_changes(project_root: Path) -> GitCommandResult:
 
 
 def _visible_status_result(project_root: Path) -> GitCommandResult:
-    return run_git_command(project_root, ("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+    return run_git_command(project_root, ("status", "--porcelain", "--", "."))
 
 
 def _paths_from_status(stdout: str) -> tuple[str, ...]:
@@ -294,12 +294,21 @@ def commit_task_branch_changes(
     message = f"chore({item_id}): save {family.kind} {status} state"
     if status == "completed":
         message = f"chore({item_id}): complete {family.kind} task"
-    if not git_status_safe(project_root).strip():
+    paths, status_result = visible_task_paths(project_root)
+    if status_result.return_code != 0:
+        return BookkeepingResult(attempted=True, committed=False, result=status_result)
+    if not paths:
         return BookkeepingResult(attempted=False, committed=False)
-    run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+    add_paths, indexed_result = addable_task_paths(project_root, paths)
+    if indexed_result.return_code != 0:
+        return BookkeepingResult(attempted=True, committed=False, result=indexed_result)
+    if add_paths:
+        add_result = run_git_command(project_root, ("add", "-A", "--", *_literal_pathspecs(add_paths)))
+        if add_result.return_code != 0:
+            return BookkeepingResult(attempted=True, committed=False, result=add_result)
     result = run_git_command(
         project_root,
-        ("commit", "--no-verify", "-m", message, "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES),
+        ("commit", "--no-verify", "-m", message, "--", *_literal_pathspecs(paths)),
     )
     return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)
 
@@ -310,10 +319,19 @@ def commit_wip_changes(
     item_id: str,
     status: str,
 ) -> BookkeepingResult:
-    """Commit all visible task-branch changes as preserved WIP."""
-    if not git_status_safe(project_root).strip():
+    """Commit all Git-visible task-branch changes as preserved WIP."""
+    paths, status_result = visible_task_paths(project_root)
+    if status_result.return_code != 0:
+        return BookkeepingResult(attempted=True, committed=False, result=status_result)
+    if not paths:
         return BookkeepingResult(attempted=False, committed=False)
-    run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
+    add_paths, indexed_result = addable_task_paths(project_root, paths)
+    if indexed_result.return_code != 0:
+        return BookkeepingResult(attempted=True, committed=False, result=indexed_result)
+    if add_paths:
+        add_result = run_git_command(project_root, ("add", "-A", "--", *_literal_pathspecs(add_paths)))
+        if add_result.return_code != 0:
+            return BookkeepingResult(attempted=True, committed=False, result=add_result)
     result = run_git_command(
         project_root,
         (
@@ -324,8 +342,7 @@ def commit_wip_changes(
             "-m",
             "Pipeline preserved task branch work without merging it to the base branch.",
             "--",
-            ".",
-            *HIDDEN_TOOL_WORKTREE_EXCLUDES,
+            *_literal_pathspecs(paths),
         ),
     )
     return BookkeepingResult(attempted=True, committed=result.return_code == 0, result=result)

package/bundled/dev-pipeline/prizmkit_runtime/runner_classification.py

@@ -168,6 +168,7 @@ def _is_terminal_success(result: AISessionResult) -> bool:
         and result.termination_reason not in {"timeout", "stale_session"}
         and not result.fatal_error_code
         and not result.progress_summary.fatal_error_code
+        and result.progress_summary.stop_reason.strip().lower() != "length"
         and result.progress_summary.result_subtype == "success"
     )
 
@@ -228,6 +229,8 @@ def _next_no_progress_count(previous: object | None, current: object, count: int
 
 
 def _is_context_overflow(result: AISessionResult) -> bool:
+    if result.progress_summary.stop_reason.strip().lower() == "length":
+        return True
     if (result.fatal_error_code or "").lower() == CONTEXT_OVERFLOW:
         return True
     text = "\n".join(

package/bundled/dev-pipeline/prizmkit_runtime/runners.py

@@ -19,6 +19,7 @@ from .gitops import (
     branch_create_plan,
     branch_ensure_return,
     branch_merge_plan,
+    branch_save_wip,
     current_branch,
     default_branch,
     ensure_linked_worktree,
@@ -796,10 +797,9 @@ def _process_item_locked(
             _cleanup_interrupted_task(
                 item_id=item_id,
                 paths=paths,
+                execution_root=execution_root,
                 base_branch=base_branch,
                 branch_name=branch_name,
-                use_worktree=use_worktree,
-                worktree_runtime=worktree_runtime,
             )
         raise
 
@@ -808,41 +808,53 @@ def _cleanup_interrupted_task(
     *,
     item_id: str,
     paths,
+    execution_root: Path,
     base_branch: str,
     branch_name: str,
-    use_worktree: bool,
-    worktree_runtime,
 ) -> None:
-    """Preserve interrupted task work and report the verified checkout state."""
-    _emit_warning(f"Interrupted while processing {item_id}; preserving work safely")
-    if use_worktree and worktree_runtime is not None:
-        preserved = worktree_save_wip(worktree_runtime)
-        if getattr(preserved, "ok", True):
-            _emit_warning(
-                f"Interrupted task {item_id}: work preserved in {worktree_runtime.worktree_path}; "
-                "task worktree remains active"
-            )
-            return
+    """Commit interrupted task WIP, then leave the caller checkout on its base branch."""
+    _emit_warning(f"Interrupted while processing {item_id}; preserving task WIP before base return")
+    execution_branch = current_branch(execution_root)
+    if execution_root.resolve() == paths.project_root.resolve() and execution_branch == base_branch:
+        preserved = None
+    else:
+        preserved = branch_save_wip(execution_root, branch_name)
+    if not getattr(preserved, "ok", True):
         _emit_interruption_cleanup_failure(
             preserved,
-            f"Could not preserve interrupted work for {item_id}; leaving task worktree active",
-            f"Inspect the task worktree: {worktree_runtime.worktree_path}",
+            f"Could not commit interrupted WIP for {item_id}; no base return was attempted",
+            f"Task checkout remains active on {branch_name}; resolve the reported Git failure, then resume the recorded task",
         )
         return
 
     returned = branch_ensure_return(paths.project_root, base_branch, branch_name)
-    if getattr(returned, "ok", True) and current_branch(paths.project_root) == base_branch:
-        _emit_warning(f"Interrupted task {item_id}: work preserved and returned to {base_branch}")
+    if not getattr(returned, "ok", True) or current_branch(paths.project_root) != base_branch:
+        _emit_interruption_cleanup_failure(
+            returned,
+            f"Interrupted WIP for {item_id} is safe, but the caller checkout could not return to {base_branch}",
+            f"Task checkout remains recorded on {branch_name}; resolve the reported checkout failure, then resume the task",
+        )
         return
-    _emit_interruption_cleanup_failure(
-        returned,
-        f"Could not safely return to {base_branch}; leaving {branch_name} active",
-        f"After resolving the Git blocker, run: git checkout {base_branch}",
+
+    committed = any(
+        getattr(command_result, "args", ())[:1] == ("commit",)
+        and getattr(command_result, "return_code", 1) == 0
+        for command_result in tuple(getattr(preserved, "results", ()))
     )
+    if committed:
+        _emit_warning(
+            f"Interrupted task {item_id}: WIP committed on {branch_name}; caller checkout returned to {base_branch}; "
+            "no merge or push performed"
+        )
+    else:
+        _emit_warning(
+            f"Interrupted task {item_id}: no WIP commit needed; caller checkout returned to {base_branch}; "
+            "no merge or push performed"
+        )
 
 
 def _emit_interruption_cleanup_failure(result, message: str, recovery: str) -> None:
-    """Emit a concise failed Git step and a non-destructive recovery action."""
+    """Emit the failed Git step, complete Git diagnostics, and a non-destructive recovery action."""
     _emit_warning(message)
     commands = tuple(getattr(getattr(result, "plan", None), "commands", ()))
     results = tuple(getattr(result, "results", ()))
@@ -853,9 +865,10 @@ def _emit_interruption_cleanup_failure(result, message: str, recovery: str) -> N
         if command is not None and getattr(command, "allow_failure", False):
             continue
         args = " ".join(map(str, getattr(command_result, "args", ())))
+        _emit_warning(f"git {args} failed")
         detail = str(getattr(command_result, "stderr", "") or getattr(command_result, "stdout", "")).strip()
-        suffix = f": {detail.splitlines()[0][:500]}" if detail else ""
-        _emit_warning(f"git {args} failed{suffix}")
+        for line in detail.splitlines():
+            _emit_warning(line)
         break
     _emit_warning(recovery)
 
@@ -946,8 +959,38 @@ def _complete_success_merge(
     task_commit = commit_task_branch_changes(execution_root, family, item_id, new_status)
     finalization_committed = getattr(final_bookkeeping, "ok", True) and getattr(task_commit, "ok", True)
     if not finalization_committed:
-        _emit_warning(f"Task finalization commit failed for {item_id}; preserving task checkout without merge")
-    if finalization_committed and worktree_runtime is not None:
+        _emit_warning(f"Task finalization commit failed for {item_id}; merge was not attempted and the task checkout remains active")
+        _write_session_status(
+            session_paths,
+            status="commit_missing",
+            session_id=session_id,
+            task_id=item_id,
+            task_type=family.task_type,
+            base_branch=base_branch,
+            active_dev_branch=branch_name,
+            worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
+            reason="commit_missing",
+            fatal_error_code=classification_fatal_error_code,
+        )
+        update = update_item(
+            status_family,
+            status_invocation,
+            item_id,
+            "commit_missing",
+            session_id,
+            status_root,
+            active_dev_branch=branch_name,
+            base_branch=base_branch,
+            last_fatal_error_code=classification_fatal_error_code,
+        )
+        if not update.ok:
+            raise RuntimeError(update.text)
+        _emit_update_summary(family, item_id, update)
+        commit_missing_status = _status_from_update(update)
+        commit_final_bookkeeping(status_root, status_family, item_id, commit_missing_status)
+        _save_failure_wip(execution_root, family, item_id, commit_missing_status, worktree_runtime)
+        return commit_missing_status
+    if worktree_runtime is not None:
         _emit_info(f"Merging {branch_name} into {base_branch}...")
         merge = merge_linked_worktree(worktree_runtime, auto_push=env.auto_push)
         _emit_git_plan_output(merge)
@@ -959,7 +1002,7 @@ def _complete_success_merge(
             guarded_worktree_remove(worktree_runtime, delete_branch=True)
             _emit_success(f"Merged {branch_name} into {base_branch}")
             return new_status
-    elif finalization_committed:
+    else:
         _emit_info(f"Merging {branch_name} into {base_branch}...")
         merge = run_git_plan(paths.project_root, branch_merge_plan(branch_context, auto_push=env.auto_push))
         _emit_git_plan_output(merge)

package/bundled/dev-pipeline/prizmkit_runtime/task_checkout.py

@@ -262,6 +262,24 @@ def complete_task_checkout_locked(state_dir: Path | str, checkout: TaskCheckout)
     return persist_task_checkout(state_dir, checkout.completed())
 
 
+def replace_active_task_checkout_locked(
+    state_dir: Path | str,
+    expected: TaskCheckout,
+    replacement: TaskCheckout,
+) -> Path:
+    """Replace one active checkout identity after guarded recovery preflight."""
+    if not expected.is_active or not replacement.is_active:
+        raise TaskCheckoutError("Checkout replacement requires active identities")
+    if (expected.task_type, expected.task_id) != (replacement.task_type, replacement.task_id):
+        raise TaskCheckoutError("Checkout replacement cannot change task identity")
+    if expected.base_branch != replacement.base_branch:
+        raise TaskCheckoutError("Checkout replacement cannot change the recorded base branch")
+    current = load_task_checkout(state_dir, expected.task_type, expected.task_id)
+    if current != expected:
+        raise TaskCheckoutError(f"Task {expected.task_id} checkout changed before recovery replacement")
+    return persist_task_checkout(state_dir, replacement)
+
+
 def mark_task_checkout_reset_locked(state_dir: Path | str, task_type: str, task_id: str) -> Path:
     """Publish an explicit reset boundary while the caller holds the task guard."""
     return persist_task_checkout(state_dir, TaskCheckout.reset(task_type, task_id))

package/bundled/dev-pipeline/scripts/parse-stream-progress.py

@@ -277,6 +277,7 @@ class SemanticLogNormalizer:
 
     _SUCCESS_STOPS = {"stop", "end_turn", "completed", "success"}
     _ERROR_STOPS = {"error", "aborted", "failed", "cancelled", "canceled"}
+    _CONTEXT_STOPS = {"length"}
 
     def __init__(self):
         self.renderer = SemanticLogRenderer()
@@ -617,7 +618,10 @@ class SemanticLogNormalizer:
             will_retry = bool(event.get("willRetry"))
             if will_retry:
                 return ""
-            status = "error" if stop_reason in self._ERROR_STOPS else "success"
+            if stop_reason in self._CONTEXT_STOPS:
+                status = CONTEXT_OVERFLOW_CODE
+            else:
+                status = "error" if stop_reason in self._ERROR_STOPS else "success"
             details = f"status={status}"
             if stop_reason:
                 details += f" stop_reason={stop_reason}"
@@ -768,6 +772,16 @@ class ProgressTracker:
         self._current_tool_id = ""
         self._pi_retrying_terminal_error = False
 
+    def _record_pi_length_stop(self):
+        """Normalize Pi's token-limit stop into the existing context continuation path."""
+        self.result_subtype = "error"
+        self.stop_reason = "length"
+        self.last_result_is_error = True
+        self.api_error_code = CONTEXT_OVERFLOW_CODE
+        self.fatal_error_code = CONTEXT_OVERFLOW_CODE
+        self.terminal_result_text = "stop_reason=length"
+        self.terminal_success_at = ""
+
     def process_event(self, event):
         """Process a single stream-json event and update state.
 
@@ -846,7 +860,9 @@ class ProgressTracker:
                     stop_reason = str(message.get("stopReason") or "")
                     if stop_reason:
                         self.stop_reason = stop_reason
-                    if stop_reason in {"error", "aborted"}:
+                    if stop_reason == "length":
+                        self._record_pi_length_stop()
+                    elif stop_reason in {"error", "aborted"}:
                         error_text = str(message.get("errorMessage") or stop_reason)
                         self.result_subtype = "error"
                         self.last_result_is_error = True
@@ -880,6 +896,8 @@ class ProgressTracker:
                 messages = event.get("messages") if isinstance(event.get("messages"), list) else []
                 final_message = messages[-1] if messages and isinstance(messages[-1], dict) else {}
                 final_stop_reason = str(final_message.get("stopReason") or self.stop_reason or "")
+                if final_stop_reason == "length":
+                    self._record_pi_length_stop()
                 will_retry = bool(event.get("willRetry"))
                 if will_retry:
                     self._pi_retrying_terminal_error = bool(

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

@@ -1105,6 +1105,7 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
     monkeypatch.setattr(runners, "commit_preflight_ready_changes", lambda *args, **kwargs: SimpleNamespace(attempted=False, committed=False, ok=True, result=None))
     monkeypatch.setattr(runners, "commit_pre_branch_bookkeeping", lambda *args, **kwargs: None)
     monkeypatch.setattr(runners, "commit_final_bookkeeping", lambda *args, **kwargs: None)
+    monkeypatch.setattr(runners, "commit_task_branch_changes", lambda *args, **kwargs: None)
     monkeypatch.setattr(runners, "current_branch", lambda _root: "main")
     monkeypatch.setattr(runners, "_session_id", lambda item_id: f"{item_id}-session-{len(prompt_calls) + 1}")
     monkeypatch.setattr(
@@ -1722,7 +1723,7 @@ def test_success_final_commit_failure_preserves_checkout_without_merge(monkeypat
     checkout = load_task_checkout(family.state_dir, family.task_type, "F-001")
     assert checkout is not None and checkout.is_active
     session_status = paths.feature_state_dir / "F-001" / "sessions" / "F-001-session-1" / "session-status.json"
-    assert json.loads(session_status.read_text(encoding="utf-8"))["status"] == "merge_conflict"
+    assert json.loads(session_status.read_text(encoding="utf-8"))["status"] == "commit_missing"
 
 
 def test_wip_commit_failure_skips_base_return(monkeypatch, tmp_path):
@@ -1970,7 +1971,7 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
     family = family_for("feature", paths)
     invocation = parse_invocation(family, "run", ())
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
-    _install_runner_session_fakes(monkeypatch, runners)
+    observed = _install_runner_session_fakes(monkeypatch, runners)
     monkeypatch.setattr(runners, "current_branch", real_current_branch)
     monkeypatch.setattr(runners, "run_git_command", real_run_git_command)
 
@@ -2001,7 +2002,10 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
         stdout=subprocess.PIPE,
         text=True,
     ).stdout == "preserved\n"
-    assert "Interrupted task F-001: work preserved and returned to main" in captured.err
+    assert "Interrupted task F-001: WIP committed on dev/F-001-interrupt" in captured.err
+    assert "caller checkout returned to main; no merge or push performed" in captured.err
+    assert observed.merge_calls == []
+    assert observed.cleanup_calls == []
 
 
 def test_interrupt_return_failure_is_reported_without_forcing_checkout(monkeypatch, tmp_path, capsys):
@@ -2034,10 +2038,11 @@ def test_interrupt_return_failure_is_reported_without_forcing_checkout(monkeypat
                 args=("checkout", "main"),
                 return_code=1,
                 stdout="",
-                stderr="untracked files would be overwritten",
+                stderr="untracked files would be overwritten\nconflicting path: local.txt",
             ),
         ),
     )
+    monkeypatch.setattr(runners, "branch_save_wip", lambda project_root, branch: SimpleNamespace(ok=True, results=()))
     monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, branch: failure)
 
     class InterruptingLauncher:
@@ -2053,12 +2058,14 @@ def test_interrupt_return_failure_is_reported_without_forcing_checkout(monkeypat
         runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
 
     captured = capsys.readouterr()
-    assert "Could not safely return to main; leaving dev/F-001-interrupt active" in captured.err
-    assert "git checkout main failed: untracked files would be overwritten" in captured.err
-    assert "After resolving the Git blocker, run: git checkout main" in captured.err
+    assert "Interrupted WIP for F-001 is safe, but the caller checkout could not return to main" in captured.err
+    assert "git checkout main failed" in captured.err
+    assert "untracked files would be overwritten" in captured.err
+    assert "conflicting path: local.txt" in captured.err
+    assert "After resolving the Git blocker" not in captured.err
 
 
-def test_worktree_interrupt_preserves_task_worktree_without_returning_caller_checkout(monkeypatch, tmp_path, capsys):
+def test_worktree_interrupt_uses_same_wip_and_base_return_contract(monkeypatch, tmp_path, capsys):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
@@ -2074,11 +2081,17 @@ def test_worktree_interrupt_preserves_task_worktree_without_returning_caller_che
         "ensure_linked_worktree",
         lambda runtime: SimpleNamespace(ok=True, runtime=runtime, reason=""),
     )
+    preserve_calls = []
     return_calls = []
+    monkeypatch.setattr(
+        runners,
+        "branch_save_wip",
+        lambda root, branch: preserve_calls.append((root, branch)) or SimpleNamespace(ok=True, results=()),
+    )
     monkeypatch.setattr(
         runners,
         "branch_ensure_return",
-        lambda *args: return_calls.append(args),
+        lambda *args: return_calls.append(args) or SimpleNamespace(ok=True, results=()),
     )
 
     class InterruptingLauncher:
@@ -2094,10 +2107,12 @@ def test_worktree_interrupt_preserves_task_worktree_without_returning_caller_che
         runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
 
     captured = capsys.readouterr()
-    assert observed.wip_calls
-    assert return_calls == []
-    assert "Interrupted task F-001: work preserved in" in captured.err
-    assert "task worktree remains active" in captured.err
+    assert preserve_calls and preserve_calls[0][0] != paths.project_root
+    assert return_calls == [(paths.project_root, "main", "dev/F-001-interrupt")]
+    assert "Interrupted task F-001: no WIP commit needed" in captured.err
+    assert "caller checkout returned to main; no merge or push performed" in captured.err
+    assert observed.merge_calls == []
+    assert observed.cleanup_calls == []
 
 
 def test_run_pipeline_command_bridges_sigterm_and_restores_handler(monkeypatch, tmp_path):
@@ -2383,6 +2398,45 @@ def test_tracked_python_cache_remains_visible_to_task_commit(tmp_path):
     ).stdout == ""
 
 
+@pytest.mark.parametrize("helper_name", ["commit_task_branch_changes", "commit_wip_changes"])
+def test_task_commit_helpers_propagate_staging_failure_without_commit(monkeypatch, tmp_path, helper_name):
+    from prizmkit_runtime import runner_bookkeeping
+    from prizmkit_runtime.gitops import GitCommandResult
+    from prizmkit_runtime.runner_models import family_for
+
+    paths = _make_paths(tmp_path)
+    family = family_for("bugfix", paths)
+    status_result = GitCommandResult(("status",), 0, " M app.txt\0", "")
+    indexed_result = GitCommandResult(("ls-files",), 0, "app.txt\0", "")
+    monkeypatch.setattr(
+        runner_bookkeeping,
+        "visible_task_paths",
+        lambda _root: (("app.txt",), status_result),
+    )
+    monkeypatch.setattr(
+        runner_bookkeeping,
+        "addable_task_paths",
+        lambda _root, _paths: (("app.txt",), indexed_result),
+    )
+    calls = []
+
+    def fail_add(_root, args):
+        args = tuple(args)
+        calls.append(args)
+        assert args[0] != "commit"
+        return GitCommandResult(args, 1, "", "staging failed")
+
+    monkeypatch.setattr(runner_bookkeeping, "run_git_command", fail_add)
+    helper = getattr(runner_bookkeeping, helper_name)
+
+    result = helper(paths.project_root, family, "B-001", "failed")
+
+    assert result.attempted is True
+    assert result.committed is False
+    assert result.result is not None and result.result.stderr == "staging failed"
+    assert calls and all(args[0] != "commit" for args in calls)
+
+
 def test_preflight_ready_commit_includes_tracked_state_but_excludes_untracked_state(tmp_path):
     from prizmkit_runtime.runner_bookkeeping import commit_preflight_ready_changes
 
@@ -3741,6 +3795,25 @@ def test_terminal_success_without_semantic_completion_is_skipped(tmp_path):
     assert classification.fatal_error_code == ""
 
 
+def test_pi_length_stop_uses_existing_context_overflow_continuation(tmp_path):
+    from dataclasses import replace
+
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.status import ProgressSummary
+
+    base_head = _init_git_repo_for_invalid_checkpoint_test(tmp_path)
+    raw = replace(
+        _terminal_success_result(tmp_path),
+        progress_summary=ProgressSummary(result_subtype="success", stop_reason="length"),
+    )
+
+    classification = classify_session(raw, project_root=tmp_path, base_head=base_head)
+
+    assert classification.session_status == "context_overflow"
+    assert classification.reason == "context_overflow"
+    assert classification.fatal_error_code == "context_overflow"
+
+
 def test_terminal_success_text_does_not_hide_provider_failure(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.runner_models import PromptGenerationResult