prizmkit 1.1.150 → 1.1.152

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.150",
-  "bundledAt": "2026-07-25T15:41:05.690Z",
-  "bundledFrom": "a759b38"
+  "frameworkVersion": "1.1.152",
+  "bundledAt": "2026-07-26T05:11:00.580Z",
+  "bundledFrom": "4db7f74"
 }

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

@@ -14,6 +14,77 @@ from dataclasses import dataclass, field
 from pathlib import Path
 
 
+@dataclass(frozen=True)
+class InterruptionDetails:
+    """Diagnostic-only description of an interruption received by the runtime."""
+
+    trigger: str
+    signal_number: int | None
+    signal_name: str
+    signal_description: str
+    signal_exact: bool
+
+    @property
+    def signal_label(self) -> str:
+        """Return a concise platform signal label for human-readable logs."""
+        if self.signal_number is None:
+            return "unavailable"
+        suffix = "" if self.signal_exact else " (inferred)"
+        return f"{self.signal_name}({self.signal_number}){suffix}"
+
+
+class RuntimeInterruption(KeyboardInterrupt):
+    """KeyboardInterrupt-compatible carrier for an explicitly observed platform signal."""
+
+    def __init__(self, signal_number: int) -> None:
+        self.signal_number = signal_number
+        super().__init__(f"runtime interrupted by {_signal_name(signal_number)}({signal_number})")
+
+
+def _signal_name(signal_number: int) -> str:
+    try:
+        return signal.Signals(signal_number).name
+    except (TypeError, ValueError):
+        return f"SIGNAL_{signal_number}"
+
+
+def _signal_description(signal_number: int) -> str:
+    try:
+        return signal.strsignal(signal_number) or "unavailable"
+    except (AttributeError, TypeError, ValueError):
+        return "unavailable"
+
+
+def describe_interruption(interruption: BaseException) -> InterruptionDetails:
+    """Describe an interruption without changing retry, task, or session state."""
+    if isinstance(interruption, RuntimeInterruption):
+        signal_number = interruption.signal_number
+        return InterruptionDetails(
+            trigger="platform_signal",
+            signal_number=signal_number,
+            signal_name=_signal_name(signal_number),
+            signal_description=_signal_description(signal_number),
+            signal_exact=True,
+        )
+
+    signal_number = getattr(signal, "SIGINT", None)
+    if isinstance(signal_number, int):
+        return InterruptionDetails(
+            trigger="keyboard_interrupt",
+            signal_number=signal_number,
+            signal_name=_signal_name(signal_number),
+            signal_description=_signal_description(signal_number),
+            signal_exact=False,
+        )
+    return InterruptionDetails(
+        trigger="keyboard_interrupt",
+        signal_number=None,
+        signal_name="unavailable",
+        signal_description="unavailable",
+        signal_exact=False,
+    )
+
+
 @dataclass(frozen=True)
 class ProcessSpec:
     """Portable process launch specification for runtime porting."""

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import os
 import signal
 import sys
 import threading
@@ -31,7 +32,7 @@ from .gitops import (
     worktree_runtime_context,
     worktree_save_wip,
 )
-from .processes import shield_interruption_signals
+from .processes import RuntimeInterruption, describe_interruption, shield_interruption_signals
 from .runner_bookkeeping import (
     commit_final_bookkeeping,
     commit_pre_branch_bookkeeping,
@@ -56,9 +57,9 @@ from .task_checkout import (
 )
 
 
-def _interrupt_from_sigterm(_signal_number, _frame) -> None:
+def _interrupt_from_sigterm(signal_number, _frame) -> None:
     """Translate daemon SIGTERM into the existing fail-closed interrupt path."""
-    raise KeyboardInterrupt
+    raise RuntimeInterruption(signal_number)
 
 
 @contextmanager
@@ -517,6 +518,10 @@ def _process_item_locked(
         use_worktree = _use_worktree_for_family(env, family)
         worktree_path = None
     execution_root = paths.project_root
+    session_id = ""
+    session_paths: SessionPaths | None = None
+    retry_count: int | None = None
+    infra_error_count: int | None = None
 
     try:
         preflight = commit_preflight_ready_changes(paths.project_root, item_id)
@@ -792,7 +797,25 @@ def _process_item_locked(
                 worktree_runtime,
                 classification_fatal_error_code=classification.fatal_error_code,
             )
-    except KeyboardInterrupt:
+    except KeyboardInterrupt as interruption:
+        try:
+            _emit_task_interruption_diagnostics(
+                interruption,
+                family=family,
+                invocation=invocation,
+                item_id=item_id,
+                session_id=session_id,
+                session_paths=session_paths,
+                retry_count=retry_count,
+                infra_error_count=infra_error_count,
+                branch_name=branch_name,
+                base_branch=base_branch,
+            )
+        except Exception as diagnostic_error:
+            _emit_warning(
+                f"Interrupt diagnostic collection failed ({type(diagnostic_error).__name__}); "
+                "continuing existing WIP preservation and checkout recovery behavior"
+            )
         with shield_interruption_signals():
             _cleanup_interrupted_task(
                 item_id=item_id,
@@ -804,6 +827,48 @@ def _process_item_locked(
         raise
 
 
+def _emit_task_interruption_diagnostics(
+    interruption: KeyboardInterrupt,
+    *,
+    family: RunnerFamily,
+    invocation: RunnerInvocation,
+    item_id: str,
+    session_id: str,
+    session_paths: SessionPaths | None,
+    retry_count: int | None,
+    infra_error_count: int | None,
+    branch_name: str,
+    base_branch: str,
+) -> None:
+    """Emit task-level interruption context without mutating pipeline state."""
+    details = describe_interruption(interruption)
+    progress = _progress_data(session_paths.progress_json) if session_paths is not None else {}
+    phase = str(progress.get("current_phase") or "unavailable")
+    tool = str(progress.get("current_tool") or "unavailable")
+    session_text = session_id or "not-started"
+    code_retry = "unavailable" if retry_count is None else str(retry_count)
+    infra_retry = "unavailable" if infra_error_count is None else str(infra_error_count)
+
+    _emit_warning(
+        "Interrupt diagnostics: "
+        f"trigger={details.trigger}; platform_signal={details.signal_label}; "
+        f"description={details.signal_description}; runner_pid={os.getpid()}; "
+        f"parent_pid={os.getppid()}; sender_pid=unavailable"
+    )
+    _emit_warning(
+        f"Interrupt context: task={item_id}; task_type={family.task_type}; session={session_text}; "
+        f"phase={phase}; tool={tool}; branch={branch_name}; base={base_branch}"
+    )
+    _emit_warning(
+        f"Retry accounting unchanged: code={code_retry}/{_max_retries(invocation)}; "
+        f"infrastructure={infra_retry}/{invocation.max_infra_retries}"
+    )
+    _emit_warning(
+        "No session classification or task-status update will be written by the interruption path; "
+        "existing WIP preservation and checkout recovery behavior remains unchanged"
+    )
+
+
 def _cleanup_interrupted_task(
     *,
     item_id: str,

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

@@ -20,7 +20,15 @@ from pathlib import Path
 from .checkpoint_state import load_checkpoint_state
 from .heartbeat import HeartbeatConfig, HeartbeatMonitor, HeartbeatState, observe_heartbeat_state, write_stale_marker
 from .launch_profiles import HeadlessLaunchProfile
-from .processes import ProcessHandle, ProcessSpec, launch_process, shield_interruption_signals, terminate_process_tree
+from .processes import (
+    ProcessHandle,
+    ProcessSpec,
+    ProcessTerminationResult,
+    describe_interruption,
+    launch_process,
+    shield_interruption_signals,
+    terminate_process_tree,
+)
 from .status import ProgressSummary
 
 
@@ -530,6 +538,98 @@ def _emit_live_line(message: str) -> None:
     print(message, file=sys.stderr, flush=True)
 
 
+def _emit_interrupt_line(message: str) -> None:
+    """Best-effort console diagnostics that must never block interruption cleanup."""
+    try:
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        _emit_live_line(f"[prizmkit] INTERRUPT {timestamp} | {message}")
+    except OSError:
+        pass
+
+
+def _process_group_label(pid: int | None) -> str:
+    if pid is None or os.name == "nt":
+        return "unavailable"
+    try:
+        return str(os.getpgid(pid))
+    except OSError:
+        return "unavailable"
+
+
+def _diagnostic_int(value: object) -> int:
+    try:
+        return int(value or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _emit_ai_interruption_received(
+    interruption: KeyboardInterrupt,
+    *,
+    command: AISessionCommand,
+    handle: ProcessHandle,
+    started_epoch: float,
+    session_log: Path,
+    progress_path: Path | None,
+    checkpoint_path: Path | None,
+    heartbeat_state: HeartbeatState | None,
+) -> None:
+    """Emit detailed AI-process context without writing session or task state."""
+    details = describe_interruption(interruption)
+    progress = _read_json_object(progress_path)
+    checkpoint_phase = _checkpoint_phase_label(checkpoint_path)
+    phase = checkpoint_phase or str(progress.get("current_phase") or "unavailable")
+    tool = str(progress.get("current_tool") or "unavailable")
+    messages = _diagnostic_int(progress.get("message_count"))
+    tool_calls = _diagnostic_int(progress.get("total_tool_calls"))
+    active_subagents = _diagnostic_int(progress.get("active_subagent_count"))
+    elapsed = _format_elapsed(time.time() - started_epoch)
+    heartbeat_details = heartbeat_state.details if heartbeat_state is not None else "unavailable"
+    heartbeat_stale = heartbeat_state.stale if heartbeat_state is not None else "unavailable"
+    heartbeat_age = (
+        _format_stale_minutes(heartbeat_state.stale_seconds)
+        if heartbeat_state is not None
+        else "unavailable"
+    )
+    log_size = heartbeat_state.log_size if heartbeat_state is not None else 0
+    if heartbeat_state is None:
+        try:
+            log_size = session_log.stat().st_size
+        except OSError:
+            log_size = 0
+
+    _emit_interrupt_line(
+        f"received trigger={details.trigger}; platform_signal={details.signal_label}; "
+        f"description={details.signal_description}; sender_pid=unavailable"
+    )
+    _emit_interrupt_line(
+        f"process runner_pid={os.getpid()}; parent_pid={os.getppid()}; ai_pid={handle.pid}; "
+        f"ai_process_group={_process_group_label(handle.pid)}; provider={command.provider}"
+    )
+    _emit_interrupt_line(
+        f"session elapsed={elapsed}; phase={phase}; tool={tool}; messages={messages}; "
+        f"tool_calls={tool_calls}; active_subagents={active_subagents}; log_size={_format_bytes(log_size)}"
+    )
+    _emit_interrupt_line(
+        f"artifacts session_log={session_log}; progress={progress_path or 'unavailable'}; "
+        f"checkpoint={checkpoint_path or 'unavailable'}"
+    )
+    _emit_interrupt_line(
+        f"heartbeat details={heartbeat_details}; stale={heartbeat_stale}; age={heartbeat_age}"
+    )
+    _emit_interrupt_line(
+        "terminating the AI process tree; classification and retry accounting have not run for this AI session"
+    )
+
+
+def _emit_ai_interruption_termination(result: ProcessTerminationResult) -> None:
+    detail_text = ",".join(result.details) if result.details else "none"
+    _emit_interrupt_line(
+        f"process-tree termination completed pid={result.pid}; terminated={result.terminated}; "
+        f"forced={result.forced}; return_code={result.return_code}; details={detail_text}"
+    )
+
+
 def _emit_live_output(line: str) -> None:
     """Forward AI CLI output for verbose foreground runs."""
     sys.stdout.write(line)
@@ -982,9 +1082,31 @@ class AISessionLauncher:
                                 stale_threshold_seconds=stale_threshold_seconds,
                             )
                             last_progress_emit = now
-        except KeyboardInterrupt:
+        except KeyboardInterrupt as interruption:
+            monitor_state = heartbeat.state if heartbeat is not None else display_heartbeat_state
+            try:
+                _emit_ai_interruption_received(
+                    interruption,
+                    command=command,
+                    handle=handle,
+                    started_epoch=started,
+                    session_log=session_log,
+                    progress_path=self.config.progress_path,
+                    checkpoint_path=self.config.checkpoint_path,
+                    heartbeat_state=monitor_state,
+                )
+            except Exception as diagnostic_error:
+                _emit_interrupt_line(
+                    f"diagnostic collection failed error={type(diagnostic_error).__name__}; "
+                    "continuing existing process-tree cleanup"
+                )
             with shield_interruption_signals():
-                terminate_process_tree(handle, "interrupted", grace_seconds=self.config.stale_kill_grace_seconds)
+                termination = terminate_process_tree(
+                    handle,
+                    "interrupted",
+                    grace_seconds=self.config.stale_kill_grace_seconds,
+                )
+            _emit_ai_interruption_termination(termination)
             raise
         if self.config.live_output and (not self.config.verbose or self.config.suppress_stream_output):
             final_heartbeat_state = _display_heartbeat_state(

package/bundled/dev-pipeline/scripts/update-bug-status.py

@@ -586,11 +586,20 @@ def action_update(args, bug_list_path, state_dir):
             error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
             return
     elif session_status == "context_overflow":
-        # Context overflow is continuation state, not code or infra retry state.
+        # Preserve resumable context metadata, but every relaunched AI session
+        # must consume the existing bounded retry budget.
         set_context_overflow_continuation_metadata(bs, args, session_id)
-        new_status = "in_progress"
-        if current_list_status != "in_progress":
-            err = update_bug_in_list(bug_list_path, bug_id, "in_progress")
+        bs["retry_count"] = bs.get("retry_count", 0) + 1
+        if bs["retry_count"] >= max_retries:
+            new_status = "failed"
+            bs["continuation_pending"] = False
+            bs["needs_attention"] = True
+            if session_id:
+                bs["last_failed_session_id"] = session_id
+        else:
+            new_status = "in_progress"
+        if current_list_status != new_status:
+            err = update_bug_in_list(bug_list_path, bug_id, new_status)
             if err:
                 error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
                 return
@@ -689,7 +698,7 @@ def action_update(args, bug_list_path, state_dir):
         summary.update(continuation_metadata_summary(bs))
         summary["artifacts_preserved"] = True
     elif session_status == "context_overflow":
-        summary["restart_policy"] = "context_overflow_continuation"
+        summary["restart_policy"] = "context_overflow_continuation" if new_status == "in_progress" else "needs_attention"
         summary.update(continuation_metadata_summary(bs))
         summary["artifacts_preserved"] = True
     elif session_status == "workflow_skipped":

package/bundled/dev-pipeline/scripts/update-feature-status.py

@@ -1014,11 +1014,20 @@ def action_update(args, feature_list_path, state_dir):
             error_out("Failed to update .prizmkit/plans/feature-list.json: {}".format(err))
             return
     elif session_status == "context_overflow":
-        # Context overflow is continuation state, not code or infra retry state.
+        # Preserve resumable context metadata, but every relaunched AI session
+        # must consume the existing bounded retry budget.
         set_context_overflow_continuation_metadata(fs, args, session_id)
-        new_status = "in_progress"
-        if current_list_status != "in_progress":
-            err = update_feature_in_list(feature_list_path, feature_id, "in_progress")
+        fs["retry_count"] = fs.get("retry_count", 0) + 1
+        if fs["retry_count"] >= max_retries:
+            new_status = "failed"
+            fs["continuation_pending"] = False
+            fs["needs_attention"] = True
+            if session_id:
+                fs["last_failed_session_id"] = session_id
+        else:
+            new_status = "in_progress"
+        if current_list_status != new_status:
+            err = update_feature_in_list(feature_list_path, feature_id, new_status)
             if err:
                 error_out("Failed to update .prizmkit/plans/feature-list.json: {}".format(err))
                 return
@@ -1131,7 +1140,7 @@ def action_update(args, feature_list_path, state_dir):
         summary.update(continuation_metadata_summary(fs))
         summary["artifacts_preserved"] = True
     elif session_status == "context_overflow":
-        summary["restart_policy"] = "context_overflow_continuation"
+        summary["restart_policy"] = "context_overflow_continuation" if new_status == "in_progress" else "needs_attention"
         summary.update(continuation_metadata_summary(fs))
         summary["artifacts_preserved"] = True
     elif session_status == "workflow_skipped":

package/bundled/dev-pipeline/scripts/update-refactor-status.py

@@ -590,11 +590,20 @@ def action_update(args, refactor_list_path, state_dir):
             error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
             return
     elif session_status == "context_overflow":
-        # Context overflow is continuation state, not code or infra retry state.
+        # Preserve resumable context metadata, but every relaunched AI session
+        # must consume the existing bounded retry budget.
         set_context_overflow_continuation_metadata(rs, args, session_id)
-        new_status = "in_progress"
-        if current_list_status != "in_progress":
-            err = update_refactor_in_list(refactor_list_path, refactor_id, "in_progress")
+        rs["retry_count"] = rs.get("retry_count", 0) + 1
+        if rs["retry_count"] >= max_retries:
+            new_status = "failed"
+            rs["continuation_pending"] = False
+            rs["needs_attention"] = True
+            if session_id:
+                rs["last_failed_session_id"] = session_id
+        else:
+            new_status = "in_progress"
+        if current_list_status != new_status:
+            err = update_refactor_in_list(refactor_list_path, refactor_id, new_status)
             if err:
                 error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
                 return
@@ -702,7 +711,7 @@ def action_update(args, refactor_list_path, state_dir):
         summary.update(continuation_metadata_summary(rs))
         summary["artifacts_preserved"] = True
     elif session_status == "context_overflow":
-        summary["restart_policy"] = "context_overflow_continuation"
+        summary["restart_policy"] = "context_overflow_continuation" if new_status == "in_progress" else "needs_attention"
         summary.update(continuation_metadata_summary(rs))
         summary["artifacts_preserved"] = True
     elif session_status == "workflow_skipped":

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

@@ -221,7 +221,7 @@ class TestContextOverflowRetrySemantics:
         ]:
             assert key not in status
 
-    def test_context_overflow_stays_in_progress_and_records_continuation_metadata(self, tmp_path):
+    def test_context_overflow_consumes_retry_and_records_bounded_continuation_metadata(self, tmp_path):
         scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
 
         for case in self._script_cases(scripts_dir):
@@ -234,7 +234,7 @@ class TestContextOverflowRetrySemantics:
             write_json_file(str(list_path), case["list_payload"])
             status_path = state_dir / case["id"] / "status.json"
             write_json_file(str(status_path), {
-                "retry_count": 2,
+                "retry_count": 1,
                 "infra_error_count": 1,
                 "sessions": [],
                 "last_session_id": None,
@@ -316,6 +316,64 @@ class TestContextOverflowRetrySemantics:
             assert selected["continuation_count"] == 1
             assert selected["continuation_summary_path"].endswith("continuation-summary.md")
 
+    def test_context_overflow_reaching_retry_limit_stops_all_families(self, tmp_path):
+        scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
+
+        for case in self._script_cases(scripts_dir):
+            case_dir = tmp_path / f"bounded-{case['id']}"
+            state_dir = case_dir / "state"
+            list_path = case_dir / case["list_name"]
+            session_dir = state_dir / case["id"] / "sessions" / "sess-limit"
+            session_dir.mkdir(parents=True)
+            (session_dir / "session.log").write_text("context overflow diagnostics", encoding="utf-8")
+            write_json_file(str(list_path), case["list_payload"])
+            status_path = state_dir / case["id"] / "status.json"
+            write_json_file(str(status_path), {
+                "retry_count": 2,
+                "infra_error_count": 1,
+                "sessions": [],
+                "last_session_id": None,
+                "resume_from_phase": None,
+            })
+
+            summary = self._run_case_update(
+                case,
+                list_path,
+                state_dir,
+                "context_overflow",
+                session_id="sess-limit",
+                extra_args=[
+                    "--active-dev-branch",
+                    "dev/existing-branch",
+                    "--base-branch",
+                    "main",
+                    "--last-fatal-error-code",
+                    "context_overflow",
+                ],
+            )
+
+            assert summary["new_status"] == "failed"
+            assert summary["retry_count"] == 3
+            assert summary["infra_error_count"] == 1
+            assert summary["context_overflow_count"] == 1
+            assert summary["continuation_count"] == 1
+            assert summary["continuation_pending"] is False
+            assert summary["restart_policy"] == "needs_attention"
+            assert summary["artifacts_preserved"] is True
+            assert (session_dir / "session.log").exists()
+
+            list_data, _ = load_json_file(str(list_path))
+            assert list_data[case["collection"]][0]["status"] == "failed"
+
+            runtime = self._runtime_status(state_dir, case["id"])
+            assert runtime["retry_count"] == 3
+            assert runtime["continuation_pending"] is False
+            assert runtime["continuation_reason"] == "context_overflow"
+            assert runtime["needs_attention"] is True
+            assert runtime["last_failed_session_id"] == "sess-limit"
+            assert runtime["context_overflow_count"] == 1
+            assert runtime["continuation_count"] == 1
+
     def test_context_overflow_from_non_started_item_marks_in_progress_once(self, tmp_path):
         scripts_dir = Path(__file__).resolve().parents[1] / "scripts"
 
@@ -768,7 +826,7 @@ def _build_status_updater_behavior_snapshot(tmp_path):
         case_dir, list_path, state_dir = _prepare_snapshot_case(
             tmp_path / "context-overflow",
             case,
-            runtime_status={"retry_count": 2, "infra_error_count": 1},
+            runtime_status={"retry_count": 1, "infra_error_count": 1},
         )
         summary_path = case_dir / "continuation-summary.md"
         summary = _run_status_snapshot_action(
@@ -1484,7 +1542,7 @@ def test_context_overflow_records_no_progress_fingerprint_and_stall(tmp_path):
     ], text=True, capture_output=True, check=True)
     first_summary = json.loads(first.stdout)
     assert first_summary['new_status'] == 'in_progress'
-    assert first_summary['retry_count'] == 0
+    assert first_summary['retry_count'] == 1
     assert first_summary['infra_error_count'] == 0
     assert first_summary['no_progress_count'] == 1
 
@@ -1504,7 +1562,7 @@ def test_context_overflow_records_no_progress_fingerprint_and_stall(tmp_path):
     second_summary = json.loads(second.stdout)
     status = load_feature_status(str(state_dir), 'F-001')
     assert second_summary['new_status'] == 'failed'
-    assert second_summary['retry_count'] == 0
+    assert second_summary['retry_count'] == 1
     assert second_summary['infra_error_count'] == 0
     assert second_summary['needs_attention'] is True
     assert second_summary['stalled_context_continuation'] is True

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

@@ -1079,7 +1079,7 @@ def test_prompt_generation_passes_explicit_execution_root_to_generator(monkeypat
     assert result.artifact_path == execution_root / ".prizmkit" / "specs" / "001-low"
 
 
-def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",), update_status="completed"):
+def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",), update_status="completed", max_retries=3):
     from prizmkit_runtime.runner_models import PromptGenerationResult, SessionClassification
 
     prompt_calls = []
@@ -1148,16 +1148,26 @@ 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))
+        normal_retry_count = sum(
+            status in {"context_overflow", "crashed", "timed_out", "failed"}
+            for status, *_ in updates
+        )
+        infra_error_count = sum(status == "infra_error" for status, *_ in updates)
         current_update_status = update_status
-        if session_status in {"context_overflow", "infra_error", "crashed", "timed_out", "failed"} and len(status_queue) > 0:
+        if session_status in {"context_overflow", "crashed", "timed_out", "failed"}:
+            if normal_retry_count >= max_retries:
+                current_update_status = "failed"
+            elif len(status_queue) > 0:
+                current_update_status = "in_progress"
+        elif session_status == "infra_error" 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),
+                "retry_count": normal_retry_count,
+                "infra_error_count": infra_error_count,
                 "continuation_count": len(updates),
                 "context_overflow_count": sum(status == "context_overflow" for status, *_ in updates),
             },
@@ -2002,8 +2012,14 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
         stdout=subprocess.PIPE,
         text=True,
     ).stdout == "preserved\n"
+    assert "Interrupt diagnostics: trigger=keyboard_interrupt; platform_signal=SIGINT(2) (inferred)" in captured.err
+    assert "Interrupt context: task=F-001; task_type=feature; session=F-001-session-1" in captured.err
+    assert "Retry accounting unchanged: code=0/3; infrastructure=0/3" in captured.err
+    assert "No session classification or task-status update will be written" 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.updates == []
+    assert not observed.prompt_calls[0]["session_paths"].session_status_json.exists()
     assert observed.merge_calls == []
     assert observed.cleanup_calls == []
 
@@ -2117,6 +2133,7 @@ def test_worktree_interrupt_uses_same_wip_and_base_return_contract(monkeypatch,
 
 def test_run_pipeline_command_bridges_sigterm_and_restores_handler(monkeypatch, tmp_path):
     from prizmkit_runtime import runners
+    from prizmkit_runtime.processes import describe_interruption
     from prizmkit_runtime.runner_models import PipelineRunResult
 
     paths = _make_paths(tmp_path)
@@ -2126,10 +2143,10 @@ def test_run_pipeline_command_bridges_sigterm_and_restores_handler(monkeypatch,
 
     def interrupted_pipeline(*args, **kwargs):
         installed = signal.getsignal(signal.SIGTERM)
-        observed.append(installed)
         try:
             installed(signal.SIGTERM, None)
-        except KeyboardInterrupt:
+        except KeyboardInterrupt as interruption:
+            observed.append((installed, describe_interruption(interruption)))
             return PipelineRunResult(False, 1, "interrupted", "interrupted")
         raise AssertionError("SIGTERM handler did not interrupt the pipeline")
 
@@ -2139,7 +2156,10 @@ def test_run_pipeline_command_bridges_sigterm_and_restores_handler(monkeypatch,
 
     assert result.exit_code == 1
     assert result.message == "processed=1 completed=False stopped_reason=interrupted"
-    assert observed and observed[0] not in {previous, signal.SIG_DFL, signal.SIG_IGN}
+    assert observed and observed[0][0] not in {previous, signal.SIG_DFL, signal.SIG_IGN}
+    assert observed[0][1].trigger == "platform_signal"
+    assert observed[0][1].signal_label == "SIGTERM(15)"
+    assert observed[0][1].signal_exact is True
     assert signal.getsignal(signal.SIGTERM) is previous
 
 
@@ -3795,6 +3815,72 @@ def test_terminal_success_without_semantic_completion_is_skipped(tmp_path):
     assert classification.fatal_error_code == ""
 
 
+def test_pi_length_stop_with_nonzero_exit_uses_bounded_crash_path(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),
+        exit_code=143,
+        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 == "crashed"
+    assert classification.reason == "exit_code=143"
+    assert classification.fatal_error_code == ""
+
+
+def test_pi_length_stop_with_zero_exit_and_no_checkpoint_uses_no_completion_policy(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 == "workflow_skipped"
+    assert classification.reason == "no_semantic_completion"
+    assert classification.fatal_error_code == ""
+
+
+def test_pi_length_stop_does_not_override_completed_checkpoint(tmp_path):
+    from dataclasses import replace
+
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    base_head = _init_git_repo_for_invalid_checkpoint_test(tmp_path)
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-length-complete"
+    checkpoint = _write_semantic_completion_checkpoint(tmp_path, artifact_dir)
+    prompt = PromptGenerationResult(
+        output_path=tmp_path / "prompt.md",
+        checkpoint_path=checkpoint,
+        artifact_path=artifact_dir,
+    )
+    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, prompt=prompt)
+
+    assert classification.session_status == "success"
+    assert classification.reason == "terminal_success_with_semantic_checkpoint"
+    assert classification.fatal_error_code == ""
+
+
 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
@@ -4024,6 +4110,46 @@ def test_retryable_ai_errors_continue_in_process_for_all_families(monkeypatch, t
     assert continuation["active_dev_branch"] == branch
 
 
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-context-budget"),
+        ("bugfix", "B-001", "bugfix/B-001-context-budget"),
+        ("refactor", "R-001", "refactor/R-001-context-budget"),
+    ],
+)
+def test_context_overflow_retry_budget_prevents_session_n_plus_one(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})
+    observed = _install_runner_session_fakes(
+        monkeypatch,
+        runners,
+        statuses=("context_overflow", "context_overflow", "context_overflow", "context_overflow"),
+        max_retries=3,
+    )
+    sleep_calls = []
+    monkeypatch.setattr(runners.time, "sleep", lambda seconds: sleep_calls.append(seconds))
+    monkeypatch.setattr(
+        runners,
+        "run_git_plan",
+        lambda project_root, plan: SimpleNamespace(ok=True, plan=plan, results=()),
+    )
+
+    status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
+
+    assert status == "failed"
+    assert len(observed.launch_cwds) == 3
+    assert len(observed.updates) == 3
+    assert sleep_calls == [5, 5]
+
+
 def test_unique_session_ids_do_not_collide_when_wall_clock_second_is_frozen(monkeypatch):
     from prizmkit_runtime import runners
 

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

@@ -994,6 +994,29 @@ def test_progress_parser_does_not_mark_failed_pi_agent_end_as_success():
     assert "provider request failed" in data["errors"]
 
 
+def test_progress_parser_keeps_pi_length_as_nonfatal_diagnostic_metadata():
+    module = _load_progress_parser_module()
+    tracker = module.ProgressTracker()
+    tracker.process_event({"type": "session", "version": 3, "id": "pi-session", "cwd": "/tmp/project"})
+    tracker.process_event({"type": "agent_start"})
+    message = {
+        "role": "assistant",
+        "content": [{"type": "thinking", "thinking": "Planning the next test"}],
+        "stopReason": "length",
+    }
+    tracker.process_event({"type": "message_end", "message": message})
+    tracker.process_event({"type": "agent_end", "willRetry": False, "messages": [message]})
+
+    data = tracker.to_dict()
+
+    assert data["result_subtype"] == "success"
+    assert data["stop_reason"] == "length"
+    assert data["last_result_is_error"] is False
+    assert data["api_error_code"] == ""
+    assert data["fatal_error_code"] == ""
+    assert data["terminal_success_at"]
+
+
 def test_progress_parser_recovers_from_retrying_pi_attempt_before_final_success():
     module = _load_progress_parser_module()
     tracker = module.ProgressTracker()
@@ -1190,6 +1213,21 @@ def test_semantic_log_normalizer_emits_terminal_metadata_once():
     assert "[FINAL] Done" in rendered
 
 
+def test_semantic_log_normalizer_does_not_promote_pi_length_to_context_overflow():
+    module = _load_progress_parser_module()
+    normalizer = module.SemanticLogNormalizer()
+    rendered = normalizer.process_event({
+        "type": "agent_end",
+        "willRetry": False,
+        "messages": [{"role": "assistant", "content": [], "stopReason": "length"}],
+    })
+    rendered += normalizer.finish()
+
+    assert rendered.count("[SESSION_END]") == 1
+    assert "status=success stop_reason=length" in rendered
+    assert "status=context_overflow" not in rendered
+
+
 def test_semantic_log_normalizer_preserves_identical_text_from_distinct_turns():
     module = _load_progress_parser_module()
     normalizer = module.SemanticLogNormalizer()
@@ -2214,6 +2252,159 @@ def test_session_summary_reports_normalized_subagents_and_child_liveness(tmp_pat
     assert "Child log activity: 2KB across 1 files (heartbeat liveness only)" in captured.err
     assert "Subagent calls detected" not in captured.err
 
+def test_ai_interruption_diagnostics_are_detailed_console_only(tmp_path, capsys):
+    import signal
+
+    from prizmkit_runtime.heartbeat import HeartbeatState
+    from prizmkit_runtime.processes import (
+        ProcessHandle,
+        ProcessSpec,
+        ProcessTerminationResult,
+        RuntimeInterruption,
+    )
+    from prizmkit_runtime.sessions import (
+        AISessionCommand,
+        _emit_ai_interruption_received,
+        _emit_ai_interruption_termination,
+    )
+
+    session_log = tmp_path / "sessions" / "sess-interrupt" / "logs" / "session.log"
+    session_log.parent.mkdir(parents=True)
+    session_log.write_text("session activity\n", encoding="utf-8")
+    progress = session_log.with_name("progress.json")
+    progress.write_text(
+        json.dumps(
+            {
+                "current_phase": "implement",
+                "current_tool": "bash",
+                "current_tool_input_summary": "secret-command-must-not-be-logged",
+                "message_count": 455,
+                "total_tool_calls": 453,
+                "active_subagent_count": 0,
+            }
+        ),
+        encoding="utf-8",
+    )
+    handle = ProcessHandle(
+        pid=999_999,
+        spec=ProcessSpec(command=("fake-ai",), cwd=tmp_path),
+        status="running",
+        popen=None,
+    )
+    command = AISessionCommand(
+        argv=("fake-ai",),
+        stdin_text=None,
+        provider="pi",
+        prompt_mode="stdin",
+    )
+    heartbeat = HeartbeatState(
+        last_seen_epoch=time.time() - 1,
+        stale=False,
+        details="no progress",
+        stale_seconds=1.0,
+        log_size=2048,
+    )
+
+    _emit_ai_interruption_received(
+        RuntimeInterruption(signal.SIGTERM),
+        command=command,
+        handle=handle,
+        started_epoch=time.time() - 120,
+        session_log=session_log,
+        progress_path=progress,
+        checkpoint_path=None,
+        heartbeat_state=heartbeat,
+    )
+    _emit_ai_interruption_termination(
+        ProcessTerminationResult(
+            pid=handle.pid,
+            reason="interrupted",
+            terminated=True,
+            forced=False,
+            return_code=-15,
+            details=("sigterm_process_group",),
+        )
+    )
+
+    captured = capsys.readouterr()
+    assert "received trigger=platform_signal; platform_signal=SIGTERM(15)" in captured.err
+    assert "runner_pid=" in captured.err
+    assert "parent_pid=" in captured.err
+    assert "ai_pid=999999" in captured.err
+    assert "provider=pi" in captured.err
+    assert "phase=implement; tool=bash; messages=455; tool_calls=453" in captured.err
+    assert "heartbeat details=no progress; stale=False; age=1s" in captured.err
+    assert "process-tree termination completed" in captured.err
+    assert "forced=False; return_code=-15; details=sigterm_process_group" in captured.err
+    assert "secret-command-must-not-be-logged" not in captured.err
+    assert not session_log.with_name("session-status.json").exists()
+
+
+def test_ai_session_interrupt_diagnostics_are_wired_before_existing_cleanup(monkeypatch, tmp_path, capsys):
+    import io
+
+    from prizmkit_runtime import sessions
+    from prizmkit_runtime.processes import ProcessHandle, ProcessTerminationResult
+    from prizmkit_runtime.sessions import AISessionConfig, AISessionLauncher
+
+    prompt = tmp_path / "prompt.md"
+    prompt.write_text("hello", encoding="utf-8")
+    session_log = tmp_path / "sessions" / "sess-wired" / "logs" / "session.log"
+    termination_calls = []
+
+    class InterruptingProcess:
+        def __init__(self):
+            self.stdout = io.StringIO("")
+            self.stdin = io.StringIO()
+            self.returncode = -2
+
+        def wait(self, timeout=None):
+            raise KeyboardInterrupt
+
+        def poll(self):
+            return self.returncode
+
+    process = InterruptingProcess()
+
+    def fake_launch(spec, **kwargs):
+        return ProcessHandle(pid=777_777, spec=spec, status="running", popen=process)
+
+    def fake_terminate(handle, reason, grace_seconds=10):
+        termination_calls.append((handle.pid, reason, grace_seconds))
+        return ProcessTerminationResult(
+            pid=handle.pid,
+            reason=reason,
+            terminated=True,
+            forced=False,
+            return_code=process.returncode,
+            details=("sigterm_process_group",),
+        )
+
+    monkeypatch.setattr(sessions, "launch_process", fake_launch)
+    monkeypatch.setattr(sessions, "terminate_process_tree", fake_terminate)
+
+    with pytest.raises(KeyboardInterrupt):
+        AISessionLauncher(
+            AISessionConfig(
+                cli_command="fake-ai",
+                platform="pi",
+                model=None,
+                prompt_path=prompt,
+                cwd=tmp_path,
+                log_path=session_log,
+                stale_kill_grace_seconds=4,
+            )
+        ).run()
+
+    captured = capsys.readouterr()
+    assert termination_calls == [(777_777, "interrupted", 4)]
+    assert "received trigger=keyboard_interrupt; platform_signal=SIGINT(2) (inferred)" in captured.err
+    assert "ai_pid=777777" in captured.err
+    assert "classification and retry accounting have not run for this AI session" in captured.err
+    assert "process-tree termination completed pid=777777" in captured.err
+    assert not session_log.with_name("session-status.json").exists()
+
+
 def test_session_live_output_does_not_forward_cli_output_without_verbose(tmp_path, capsys):
     from prizmkit_runtime.sessions import AISessionConfig, AISessionLauncher
 

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.150",
+  "version": "1.1.152",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.150",
+  "version": "1.1.152",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {