prizmkit 1.1.130 → 1.1.134

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

@@ -3,9 +3,12 @@
 from __future__ import annotations
 
 import json
+import signal
 import sys
+import threading
 import time
-from collections.abc import Mapping
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
 from pathlib import Path
 
 from .commands import CommandResult  # type: ignore  # imported only at runtime by commands.py
@@ -27,6 +30,7 @@ from .gitops import (
     worktree_runtime_context,
     worktree_save_wip,
 )
+from .processes import shield_interruption_signals
 from .runner_bookkeeping import (
     commit_final_bookkeeping,
     commit_pre_branch_bookkeeping,
@@ -51,6 +55,26 @@ from .task_checkout import (
 )
 
 
+def _interrupt_from_sigterm(_signal_number, _frame) -> None:
+    """Translate daemon SIGTERM into the existing fail-closed interrupt path."""
+    raise KeyboardInterrupt
+
+
+@contextmanager
+def _bridge_sigterm_to_interrupt() -> Iterator[None]:
+    """Install a scoped SIGTERM bridge when running on the main thread."""
+    if threading.current_thread() is not threading.main_thread():
+        yield
+        return
+
+    previous_handler = signal.getsignal(signal.SIGTERM)
+    try:
+        signal.signal(signal.SIGTERM, _interrupt_from_sigterm)
+        yield
+    finally:
+        signal.signal(signal.SIGTERM, previous_handler)
+
+
 def run_pipeline_command(kind: str, action: str, legacy_args: tuple[str, ...], paths) -> CommandResult:
     """Dispatch a feature/bugfix/refactor Python foreground command."""
     family = family_for(kind, paths)
@@ -89,7 +113,8 @@ def run_pipeline_command(kind: str, action: str, legacy_args: tuple[str, ...], p
     if not invocation.list_path.is_file():
         return CommandResult(1, f"Python {kind} runner", f"Plan list not found: {invocation.list_path}")
     try:
-        result = _run_pipeline(family, invocation, paths)
+        with _bridge_sigterm_to_interrupt():
+            result = _run_pipeline(family, invocation, paths)
     except Exception as exc:  # keep CLI boundary traceback-free
         return CommandResult(1, f"Python {kind} runner failed", str(exc))
     details = result.details + ((f"last_status: {result.last_status}",) if result.last_status else ())
@@ -121,7 +146,8 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
         try:
             status = _process_item(family, invocation, invocation.item_id, paths, initial_metadata={})
         except KeyboardInterrupt:
-            return PipelineRunResult(False, 1, "interrupted", "interrupted")
+            with shield_interruption_signals():
+                return PipelineRunResult(False, 1, "interrupted", "interrupted")
         return PipelineRunResult(status == "completed", 1, "single_item_done", status)
 
     while True:
@@ -157,15 +183,16 @@ def _run_pipeline(family: RunnerFamily, invocation: RunnerInvocation, paths) ->
         try:
             final_status = _process_item(family, invocation, item_id, paths, initial_metadata=next_result.data)
         except KeyboardInterrupt:
-            processed += 1
-            item_statuses[item_id] = "interrupted"
-            return PipelineRunResult(
-                False,
-                processed,
-                "interrupted",
-                "interrupted",
-                _render_item_statuses(item_statuses),
-            )
+            with shield_interruption_signals():
+                processed += 1
+                item_statuses[item_id] = "interrupted"
+                return PipelineRunResult(
+                    False,
+                    processed,
+                    "interrupted",
+                    "interrupted",
+                    _render_item_statuses(item_statuses),
+                )
         processed += 1
         item_statuses[item_id] = final_status
         if final_status in _completion_compatible_statuses(family):
@@ -621,6 +648,15 @@ def _process_item_locked(
                     "max_infra_retries": invocation.max_infra_retries,
                     "no_progress_count": previous_no_progress_count,
                     "progress_fingerprint": previous_fingerprint or {},
+                    "checkpoint_state": {
+                        key: metadata.get(key)
+                        for key in (
+                            "current_stage", "next_stage", "stage_result",
+                            "repair_scope", "repair_round",
+                            "authoritative_evidence_paths", "blocked_reason",
+                            "terminal_status",
+                        )
+                    },
                     "task_type": family.task_type,
                     "active_dev_branch": branch_name,
                     "base_branch": base_branch,
@@ -691,6 +727,7 @@ def _process_item_locked(
                 worktree_path=worktree_runtime.worktree_path if worktree_runtime is not None else None,
                 reason=classification.reason,
                 fatal_error_code=classification.fatal_error_code,
+                checkpoint_state=classification.checkpoint_state,
             )
 
             update = update_item(
@@ -706,6 +743,7 @@ def _process_item_locked(
                 continuation_summary_path=summary_path,
                 no_progress_count=classification.no_progress_count,
                 progress_fingerprint=classification.progress_fingerprint,
+                checkpoint_state=classification.checkpoint_state,
             )
             if not update.ok:
                 raise RuntimeError(update.text)
@@ -757,17 +795,77 @@ def _process_item_locked(
                 classification_fatal_error_code=classification.fatal_error_code,
             )
     except KeyboardInterrupt:
-        _emit_warning(f"Interrupted while processing {item_id}; preserving work and returning to {base_branch}")
-        if use_worktree and worktree_runtime is not None:
-            worktree_save_wip(worktree_runtime)
-        else:
-            branch_ensure_return(paths.project_root, base_branch, branch_name)
+        with shield_interruption_signals():
+            _cleanup_interrupted_task(
+                item_id=item_id,
+                paths=paths,
+                base_branch=base_branch,
+                branch_name=branch_name,
+                use_worktree=use_worktree,
+                worktree_runtime=worktree_runtime,
+            )
         raise
 
 
+def _cleanup_interrupted_task(
+    *,
+    item_id: str,
+    paths,
+    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
+        _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}",
+        )
+        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}")
+        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}",
+    )
+
+
+def _emit_interruption_cleanup_failure(result, message: str, recovery: str) -> None:
+    """Emit a concise failed Git step and a non-destructive recovery action."""
+    _emit_warning(message)
+    commands = tuple(getattr(getattr(result, "plan", None), "commands", ()))
+    results = tuple(getattr(result, "results", ()))
+    for index, command_result in enumerate(results):
+        if getattr(command_result, "return_code", 0) == 0:
+            continue
+        command = commands[index] if index < len(commands) else None
+        if command is not None and getattr(command, "allow_failure", False):
+            continue
+        args = " ".join(map(str, getattr(command_result, "args", ())))
+        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}")
+        break
+    _emit_warning(recovery)
+
+
 def _is_retryable_ai_outcome(session_status: str, new_status: str) -> bool:
     """Return whether a persisted post-launch outcome should continue in-process."""
-    if session_status == "success" or session_status == "stalled_context_continuation":
+    if session_status in {"success", "stalled_context_continuation", "workflow_blocked"}:
         return False
     return new_status in {"in_progress", "pending"} and session_status in {
         "context_overflow",
@@ -1079,6 +1177,7 @@ def _write_session_status(
     worktree_path: Path | None = None,
     reason: str = "",
     fatal_error_code: str = "",
+    checkpoint_state: object | None = None,
 ) -> None:
     payload = {
         "status": status,
@@ -1094,6 +1193,8 @@ def _write_session_status(
         payload["reason"] = reason
     if fatal_error_code:
         payload["fatal_error_code"] = fatal_error_code
+    if isinstance(checkpoint_state, dict):
+        payload["checkpoint_state"] = checkpoint_state
     session_paths.session_status_json.parent.mkdir(parents=True, exist_ok=True)
     session_paths.session_status_json.write_text(
         json.dumps(payload, indent=2, sort_keys=True) + "\n",

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

@@ -20,7 +20,7 @@ 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, terminate_process_tree
+from .processes import ProcessHandle, ProcessSpec, launch_process, shield_interruption_signals, terminate_process_tree
 from .status import ProgressSummary
 
 
@@ -868,7 +868,8 @@ class AISessionLauncher:
                             )
                             last_progress_emit = now
         except KeyboardInterrupt:
-            terminate_process_tree(handle, "interrupted", grace_seconds=self.config.stale_kill_grace_seconds)
+            with shield_interruption_signals():
+                terminate_process_tree(handle, "interrupted", grace_seconds=self.config.stale_kill_grace_seconds)
             raise
         if self.config.live_output and (not self.config.verbose or self.config.suppress_stream_output):
             final_heartbeat_state = _display_heartbeat_state(