prizmkit 1.1.120 → 1.1.121

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.120",
-  "bundledAt": "2026-07-10T01:27:14.094Z",
-  "bundledFrom": "3d5e4ff"
+  "frameworkVersion": "1.1.121",
+  "bundledAt": "2026-07-11T06:00:42.680Z",
+  "bundledFrom": "c2f98e2"
 }

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

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import hashlib
+import json
 import subprocess
 from pathlib import Path
 
 from .checkpoint_state import load_checkpoint_state
-from .gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES, git_status_safe, run_git_command
+from .gitops import git_status_safe, run_git_command
 from .runner_models import PromptGenerationResult, SessionClassification
 from .sessions import AISessionResult
 
@@ -54,8 +55,6 @@ def classify_session(
             reason=f"invalid_workflow_checkpoint:{invalid_checkpoint.error_code}",
             progress_fingerprint=fingerprint,
         )
-    has_commit_since_base = _has_commit_since(project_root, base_head)
-
     if _is_terminal_success(result) and _has_completed_workflow_artifact(prompt):
         return SessionClassification(
             "success",
@@ -63,7 +62,7 @@ def classify_session(
             progress_fingerprint=fingerprint,
         )
 
-    if _has_late_runtime_error_after_completion(result, prompt, has_commit_since_base):
+    if _has_late_runtime_error_after_completion(result, prompt):
         return SessionClassification(
             "success",
             reason="completed_checkpoint_with_late_runtime_error",
@@ -71,8 +70,6 @@ def classify_session(
         )
 
     if _is_context_overflow(result):
-        if has_commit_since_base:
-            return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
         no_progress_count = _next_no_progress_count(previous_fingerprint, fingerprint, previous_no_progress_count)
         if no_progress_count >= 2:
             return SessionClassification(
@@ -90,19 +87,14 @@ def classify_session(
             no_progress_count=no_progress_count,
         )
 
-    if _is_infra_error(result):
-        return SessionClassification("infra_error", reason="ai_runtime_or_provider_error", progress_fingerprint=fingerprint)
     if result.termination_reason == "stale_session":
         return SessionClassification("crashed", reason="stale_session", progress_fingerprint=fingerprint)
     if result.timed_out or result.termination_reason == "timeout":
         return SessionClassification("timed_out", reason="timeout", progress_fingerprint=fingerprint)
+    if _is_infra_error(result):
+        return SessionClassification("infra_error", reason="ai_runtime_or_provider_error", progress_fingerprint=fingerprint)
     if result.exit_code not in (0, None):
         return SessionClassification("crashed", reason=f"exit_code={result.exit_code}", progress_fingerprint=fingerprint)
-    if has_commit_since_base:
-        return SessionClassification("success", reason="commit_since_base", progress_fingerprint=fingerprint)
-    if _has_workspace_changes(project_root):
-        _auto_commit_workspace(project_root)
-        return SessionClassification("success", reason="auto_commit_uncommitted_changes", progress_fingerprint=fingerprint)
     return SessionClassification("crashed", reason="no_durable_success", progress_fingerprint=fingerprint)
 
 
@@ -138,9 +130,8 @@ def _is_terminal_success(result: AISessionResult) -> bool:
 def _has_late_runtime_error_after_completion(
     result: AISessionResult,
     prompt: PromptGenerationResult | None,
-    has_commit_since_base: bool,
 ) -> bool:
-    if not has_commit_since_base or not _has_completed_workflow_artifact(prompt):
+    if not _has_completed_workflow_artifact(prompt):
         return False
     return _is_context_overflow(result) or _is_infra_error(result)
 
@@ -148,6 +139,8 @@ def _has_late_runtime_error_after_completion(
 def _has_completed_workflow_artifact(prompt: PromptGenerationResult | None) -> bool:
     if prompt is None:
         return False
+    if _invalid_existing_workflow_checkpoint(prompt) is not None:
+        return False
     if prompt.checkpoint_path and prompt.checkpoint_path.is_file():
         state = load_checkpoint_state(prompt.checkpoint_path)
         return state.valid and state.all_completed
@@ -170,7 +163,21 @@ def has_completed_artifact_path(artifact_path: Path | None) -> bool:
     if checkpoint.is_file():
         state = load_checkpoint_state(checkpoint)
         return state.valid and state.all_completed
-    return (artifact_path / "completion-summary.json").is_file()
+    return _has_valid_completion_summary(artifact_path / "completion-summary.json")
+
+
+def _has_valid_completion_summary(path: Path) -> bool:
+    """Return whether a completion summary contains usable durable notes."""
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return False
+    if not isinstance(data, dict):
+        return False
+    notes = data.get("completion_notes")
+    return isinstance(notes, list) and bool(notes) and all(
+        isinstance(note, str) and note.strip() for note in notes
+    )
 
 
 def _invalid_existing_workflow_checkpoint(prompt: PromptGenerationResult | None):
@@ -226,15 +233,6 @@ def _has_commit_since(project_root: Path, base_head: str) -> bool:
     return _has_commit_range(project_root, base_head, "HEAD")
 
 
-def _has_workspace_changes(project_root: Path) -> bool:
-    return bool(git_status_safe(project_root).strip())
-
-
-def _auto_commit_workspace(project_root: Path) -> None:
-    run_git_command(project_root, ("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
-    run_git_command(project_root, ("commit", "--no-verify", "-m", "chore: save runner session changes"))
-
-
 def _tail(path: Path, max_bytes: int = 8192) -> str:
     try:
         data = path.read_bytes()

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

@@ -133,17 +133,23 @@ class SessionPaths:
 
 @dataclass(frozen=True)
 class ContinuationState:
-    """Context-overflow continuation inputs for the next prompt/status update."""
+    """Provider-neutral durable handoff inputs for the next AI session."""
 
     active: bool = False
     previous_session_id: str = ""
+    failure_classification: str = ""
     continuation_count: int = 0
     context_overflow_count: int = 0
+    retry_count: int = 0
+    infra_error_count: int = 0
+    max_retries: int = 0
+    max_infra_retries: int = 0
     no_progress_count: int = 0
+    progress_fingerprint: Mapping[str, object] = field(default_factory=dict)
     summary_path: Path | None = None
     active_dev_branch: str = ""
     base_branch: str = ""
-    fatal_error_code: str = "context_overflow"
+    fatal_error_code: str = ""
 
 
 @dataclass(frozen=True)

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

@@ -50,11 +50,18 @@ def generate_prompt(
     if invocation.mode:
         command.extend(["--mode", invocation.mode])
     if continuation:
-        command.extend(["--continuation-mode", "context_overflow"])
+        command.extend(["--continuation-mode", "ai_error"])
         for flag, key in (
             ("--previous-session-id", "previous_session_id"),
+            ("--failure-classification", "failure_classification"),
             ("--continuation-count", "continuation_count"),
             ("--context-overflow-count", "context_overflow_count"),
+            ("--code-retry-count", "retry_count"),
+            ("--infra-error-count", "infra_error_count"),
+            ("--max-code-retries", "max_retries"),
+            ("--max-infra-retries", "max_infra_retries"),
+            ("--no-progress-count", "no_progress_count"),
+            ("--progress-fingerprint", "progress_fingerprint"),
             ("--task-type", "task_type"),
             ("--active-dev-branch", "active_dev_branch"),
             ("--base-branch", "base_branch"),
@@ -62,6 +69,8 @@ def generate_prompt(
         ):
             value = continuation.get(key)
             if value not in (None, ""):
+                if key == "progress_fingerprint":
+                    value = json.dumps(value, sort_keys=True)
                 command.extend([flag, str(value)])
 
     completed = subprocess.run(

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

@@ -531,8 +531,11 @@ def _process_item(
         previous_no_progress_count = int(metadata.get("no_progress_count") or 0)
         continuation_pending = bool(metadata.get("continuation_pending"))
         previous_session_id = str(metadata.get("previous_session_id") or metadata.get("last_context_overflow_session_id") or "")
+        failure_classification = str(metadata.get("continuation_reason") or "context_overflow")
         continuation_count = int(metadata.get("continuation_count") or 0)
         context_overflow_count = int(metadata.get("context_overflow_count") or 0)
+        retry_count = int(metadata.get("retry_count") or 0)
+        infra_error_count = int(metadata.get("infra_error_count") or 0)
 
         while True:
             session_id = _session_id(item_id)
@@ -541,8 +544,15 @@ def _process_item(
             if continuation_pending:
                 continuation = {
                     "previous_session_id": previous_session_id,
+                    "failure_classification": failure_classification,
                     "continuation_count": continuation_count,
                     "context_overflow_count": context_overflow_count,
+                    "retry_count": retry_count,
+                    "infra_error_count": infra_error_count,
+                    "max_retries": _max_retries(invocation),
+                    "max_infra_retries": invocation.max_infra_retries,
+                    "no_progress_count": previous_no_progress_count,
+                    "progress_fingerprint": previous_fingerprint or {},
                     "task_type": family.task_type,
                     "active_dev_branch": branch_name,
                     "base_branch": base_branch,
@@ -554,7 +564,7 @@ def _process_item(
                 item_id=item_id,
                 session_id=session_id,
                 run_id="run-python",
-                retry_count=0,
+                retry_count=retry_count,
                 session_paths=session_paths,
                 project_root=paths.project_root,
                 execution_root=execution_root,
@@ -599,34 +609,8 @@ def _process_item(
                 previous_no_progress_count=previous_no_progress_count,
             )
             _emit_session_summary(session_result, session_paths, classification)
-            if classification.session_status == "context_overflow":
-                summary_path = _continuation_summary_path(execution_root, family, item_id, prompt)
-                update = update_item(
-                    status_family,
-                    status_invocation,
-                    item_id,
-                    "context_overflow",
-                    session_id,
-                    status_root,
-                    active_dev_branch=branch_name,
-                    base_branch=base_branch,
-                    last_fatal_error_code=classification.fatal_error_code or "context_overflow",
-                    continuation_summary_path=summary_path,
-                    no_progress_count=classification.no_progress_count,
-                    progress_fingerprint=classification.progress_fingerprint,
-                )
-                if not update.ok:
-                    raise RuntimeError(update.text)
-                _emit_update_summary(family, item_id, update)
-                previous_fingerprint = classification.progress_fingerprint
-                previous_no_progress_count = classification.no_progress_count
-                continuation_pending = True
-                previous_session_id = session_id
-                continuation_count += 1
-                context_overflow_count += 1
-                continue
-
             final_session_status = classification.session_status
+            summary_path = _continuation_summary_path(execution_root, family, item_id, prompt)
 
             _write_session_status(
                 session_paths,
@@ -651,6 +635,7 @@ def _process_item(
                 active_dev_branch=branch_name,
                 base_branch=base_branch,
                 last_fatal_error_code=classification.fatal_error_code,
+                continuation_summary_path=summary_path,
                 no_progress_count=classification.no_progress_count,
                 progress_fingerprint=classification.progress_fingerprint,
             )
@@ -658,6 +643,22 @@ def _process_item(
                 raise RuntimeError(update.text)
             _emit_update_summary(family, item_id, update)
             new_status = _status_from_update(update)
+            update_data = update.data if isinstance(update.data, dict) else {}
+            retry_count = int(update_data.get("retry_count", retry_count) or 0)
+            infra_error_count = int(update_data.get("infra_error_count", infra_error_count) or 0)
+
+            if _is_retryable_ai_outcome(final_session_status, new_status):
+                previous_fingerprint = classification.progress_fingerprint
+                previous_no_progress_count = classification.no_progress_count
+                continuation_pending = True
+                previous_session_id = session_id
+                failure_classification = classification.reason or final_session_status
+                continuation_count = int(update_data.get("continuation_count", continuation_count + 1) or 0)
+                context_overflow_count = int(update_data.get("context_overflow_count", context_overflow_count) or 0)
+                _emit_info(f"Retryable AI outcome persisted ({failure_classification}); continuing in 5s...")
+                time.sleep(5)
+                continue
+
             if final_session_status != "success":
                 commit_final_bookkeeping(status_root, status_family, item_id, new_status)
                 _save_failure_wip(execution_root, family, item_id, new_status, worktree_runtime)
@@ -694,6 +695,19 @@ def _process_item(
         raise
 
 
+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":
+        return False
+    return new_status in {"in_progress", "pending"} and session_status in {
+        "context_overflow",
+        "infra_error",
+        "crashed",
+        "timed_out",
+        "failed",
+    }
+
+
 def _finalize_recovered_success(
     family: RunnerFamily,
     item_id: str,
@@ -1012,7 +1026,7 @@ def _default_branch_name(family: RunnerFamily, item_id: str) -> str:
 
 
 def _session_id(item_id: str) -> str:
-    return f"{item_id}-{time.strftime('%Y%m%d%H%M%S')}"
+    return f"{item_id}-{time.strftime('%Y%m%d%H%M%S')}-{time.time_ns()}"
 
 
 def _continuation_summary_path(project_root: Path, family: RunnerFamily, item_id: str, prompt: PromptGenerationResult | None) -> Path:

package/bundled/dev-pipeline/scripts/continuation.py

@@ -1,5 +1,6 @@
 """Continuation prompt and durable handoff helpers for pipeline prompt generators."""
 
+import json
 import os
 import sys
 
@@ -9,7 +10,7 @@ if _PIPELINE_ROOT not in sys.path:
 
 from prizmkit_runtime.checkpoint_state import checkpoint_cursor as shared_checkpoint_cursor  # noqa: E402
 
-SUPPORTED_CONTINUATION_MODES = {"context_overflow"}
+SUPPORTED_CONTINUATION_MODES = {"context_overflow", "ai_error"}
 TASK_TYPES = {"feature", "bugfix", "refactor"}
 
 
@@ -19,13 +20,18 @@ def add_continuation_args(parser, default_task_type):
         "--continuation-mode",
         choices=sorted(SUPPORTED_CONTINUATION_MODES),
         default="",
-        help="Continuation recovery mode, currently context_overflow.",
+        help="Provider-neutral in-process AI error continuation mode.",
     )
     parser.add_argument(
         "--previous-session-id",
         default="",
         help="Session ID that triggered this continuation.",
     )
+    parser.add_argument(
+        "--failure-classification",
+        default="context_overflow",
+        help="Classified outcome from the previous launched AI session.",
+    )
     parser.add_argument(
         "--continuation-count",
         default="0",
@@ -36,6 +42,12 @@ def add_continuation_args(parser, default_task_type):
         default="0",
         help="Cumulative context overflow count for this task.",
     )
+    parser.add_argument("--code-retry-count", default="0", help="Persisted code retry count.")
+    parser.add_argument("--infra-error-count", default="0", help="Persisted infrastructure retry count.")
+    parser.add_argument("--max-code-retries", default="0", help="Configured code retry budget.")
+    parser.add_argument("--max-infra-retries", default="0", help="Configured infrastructure retry budget.")
+    parser.add_argument("--no-progress-count", default="0", help="Consecutive context continuations without durable progress.")
+    parser.add_argument("--progress-fingerprint", default="", help="JSON durable Git/checkpoint/artifact progress summary.")
     parser.add_argument(
         "--task-type",
         choices=sorted(TASK_TYPES),
@@ -72,6 +84,16 @@ def _safe_int(value, default=0):
     return parsed if parsed >= 0 else default
 
 
+def _safe_json_object(value):
+    if isinstance(value, dict):
+        return value
+    try:
+        parsed = json.loads(str(value or ""))
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
 def _norm(path):
     return str(path).replace(os.sep, "/")
 
@@ -193,7 +215,7 @@ def _build_summary(context):
         "## Reason",
         "",
         "- Continuation mode: {}".format(context["mode"]),
-        "- This continuation was started after context overflow.",
+        "- Previous AI session classification: {}".format(context["failure_classification"]),
         "- This artifact is the durable handoff summary; do not rely on the previous full transcript.",
         "",
         "## Previous Session",
@@ -211,6 +233,17 @@ def _build_summary(context):
         "- Base branch: {}".format(context["base_branch"] or "(unknown)"),
         "- Continuation count: {}".format(context["continuation_count"]),
         "- Context overflow count: {}".format(context["context_overflow_count"]),
+        "- Code retry count: {} / {}".format(context["code_retry_count"], context["max_code_retries"]),
+        "- Infrastructure retry count: {} / {}".format(context["infra_error_count"], context["max_infra_retries"]),
+        "- Consecutive no-progress context count: {}".format(context["no_progress_count"]),
+        "",
+        "## Git and Checkpoint Progress",
+        "",
+        "- Current checkpoint phase: {}".format(cursor["first_cursor"]),
+        "- Git status fingerprint: {}".format(context["progress_fingerprint"].get("git_diff_fingerprint", "(unknown)")),
+        "- HEAD commit: {}".format(context["progress_fingerprint"].get("head_commit", "(unknown)")),
+        "- Artifact fingerprint: {}".format(context["progress_fingerprint"].get("artifact_fingerprint", "(unknown)")),
+        "- Checkpoint cursor fingerprint: {}".format(context["progress_fingerprint"].get("checkpoint_cursor", "(unknown)")),
         "",
         "## Observed Partial Progress",
         "",
@@ -247,16 +280,18 @@ def _build_addendum(context):
     runtime = context["runtime"]
     summary_paths = context["summary_paths"]
     lines = [
-        "## Continuation Addendum — Context Overflow Recovery",
+        "## Continuation Addendum — In-Process AI Error Recovery",
         "",
-        "This is an automatic continuation after context overflow.",
+        "This is an automatic continuation after the previous launched AI session ended with `{}`.".format(context["failure_classification"]),
         "This is a fresh headless AI CLI session for the same task.",
         "Continue on the current branch/worktree.",
         "Do not reset, clean, switch branches, or discard work.",
         "",
         "### Required First Actions",
         "",
-        "- Start with `git status` and `git diff`.",
+        "- Inspect `git status` and `git diff` before editing.",
+        "- Validate the workflow checkpoint and current phase before resuming.",
+        "- Inspect existing task artifacts and run only the tests necessary to establish current test state.",
         "- Reuse the same durable task artifact directory: `{}`.".format(_norm(durable["artifact_dir"])),
         "- Treat completed/skipped checkpoint steps as already done.",
         "- Continue from the first pending/in-progress checkpoint step: `{}`.".format(cursor["first_cursor"]),
@@ -276,7 +311,10 @@ def _build_addendum(context):
         "- Failure log path: `{}`".format(_norm(durable["failure_log"])),
         "- Continuation summary path(s): `{}`".format(", ".join(_norm(p) for p in summary_paths)),
         "- Continuation count: `{}`".format(context["continuation_count"]),
+        "- Previous failure classification: `{}`".format(context["failure_classification"]),
         "- Context overflow count: `{}`".format(context["context_overflow_count"]),
+        "- Code retry count: `{}` / `{}`".format(context["code_retry_count"], context["max_code_retries"]),
+        "- Infrastructure retry count: `{}` / `{}`".format(context["infra_error_count"], context["max_infra_retries"]),
         "- Previous session id: `{}`".format(context["previous_session_id"] or "(unknown)"),
         "- Previous session log reference: `{}`".format(runtime["previous_session_log"]),
         "",
@@ -316,8 +354,15 @@ def append_continuation_handoff(rendered_prompt, args, project_root, task_type,
         "task_id": task_id,
         "task_slug": task_slug,
         "previous_session_id": previous_session_id,
+        "failure_classification": getattr(args, "failure_classification", "") or "context_overflow",
         "continuation_count": _safe_int(getattr(args, "continuation_count", 0)),
         "context_overflow_count": _safe_int(getattr(args, "context_overflow_count", 0)),
+        "code_retry_count": _safe_int(getattr(args, "code_retry_count", 0)),
+        "infra_error_count": _safe_int(getattr(args, "infra_error_count", 0)),
+        "max_code_retries": _safe_int(getattr(args, "max_code_retries", 0)),
+        "max_infra_retries": _safe_int(getattr(args, "max_infra_retries", 0)),
+        "no_progress_count": _safe_int(getattr(args, "no_progress_count", 0)),
+        "progress_fingerprint": _safe_json_object(getattr(args, "progress_fingerprint", "")),
         "active_dev_branch": getattr(args, "active_dev_branch", ""),
         "base_branch": getattr(args, "base_branch", ""),
         "durable": durable,

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

@@ -276,6 +276,33 @@ def _set_continuation_common(status_data, args, session_id):
         status_data["last_session_id"] = session_id
 
 
+def _set_ai_error_continuation_metadata(status_data, args, session_id, reason):
+    """Preserve durable task/session state for any retryable launched AI error."""
+    if args.active_dev_branch:
+        status_data["active_dev_branch"] = args.active_dev_branch
+    if args.base_branch:
+        status_data["base_branch"] = args.base_branch
+    status_data["continuation_pending"] = True
+    status_data["continuation_reason"] = reason
+    status_data["continuation_count"] = status_data.get("continuation_count", 0) + 1
+    status_data["previous_session_id"] = session_id
+    status_data["last_fatal_error_code"] = args.last_fatal_error_code or reason
+    if args.continuation_summary_path:
+        status_data["continuation_summary_path"] = args.continuation_summary_path
+    if args.no_progress_count is not None:
+        status_data["no_progress_count"] = max(0, args.no_progress_count)
+    fingerprint = _load_progress_fingerprint(args.progress_fingerprint)
+    if fingerprint is not None:
+        status_data["last_progress_fingerprint"] = fingerprint
+    status_data["resume_from_phase"] = None
+    if session_id:
+        sessions = status_data.get("sessions", [])
+        if session_id not in sessions:
+            sessions.append(session_id)
+        status_data["sessions"] = sessions
+        status_data["last_session_id"] = session_id
+
+
 def set_context_overflow_continuation_metadata(status_data, args, session_id):
     """Record continuation metadata for a context-overflow outcome in status.json."""
     status_data["context_overflow_count"] = status_data.get("context_overflow_count", 0) + 1
@@ -456,6 +483,18 @@ def action_update(args, bug_list_path, state_dir):
 
     # Track what status we write to bug-fix-list.json
     new_status = current_list_status
+    if args.active_dev_branch:
+        bs["active_dev_branch"] = args.active_dev_branch
+    if args.base_branch:
+        bs["base_branch"] = args.base_branch
+    if args.last_fatal_error_code:
+        bs["last_fatal_error_code"] = args.last_fatal_error_code
+    if args.continuation_summary_path:
+        bs["continuation_summary_path"] = args.continuation_summary_path
+    fingerprint = _load_progress_fingerprint(args.progress_fingerprint)
+    if fingerprint is not None:
+        bs["last_progress_fingerprint"] = fingerprint
+
 
     if session_status == "success":
         bs["infra_error_count"] = 0
@@ -499,10 +538,14 @@ def action_update(args, bug_list_path, state_dir):
 
         if infra_error_count >= max_infra_retries:
             new_status = "failed"
+            bs["continuation_pending"] = False
+            bs["continuation_reason"] = session_status
+            bs["needs_attention"] = True
             if session_id:
                 bs["last_failed_session_id"] = session_id
         else:
-            new_status = "pending"
+            new_status = "in_progress"
+            _set_ai_error_continuation_metadata(bs, args, session_id, session_status)
 
         err = update_bug_in_list(bug_list_path, bug_id, new_status)
         if err:
@@ -528,27 +571,25 @@ def action_update(args, bug_list_path, state_dir):
     else:
         bs["retry_count"] = bs.get("retry_count", 0) + 1
 
-        cleaned = cleanup_bug_artifacts(
-            state_dir=state_dir,
-            bug_id=bug_id,
-            project_root=args.project_root,
-        )
-
         if bs["retry_count"] >= max_retries:
             new_status = "failed"
+            bs["continuation_pending"] = False
+            bs["continuation_reason"] = session_status
+            bs["needs_attention"] = True
         else:
-            new_status = "pending"
+            new_status = "in_progress"
+            _set_ai_error_continuation_metadata(bs, args, session_id, session_status)
 
         bs["resume_from_phase"] = None
-        bs["sessions"] = []
-        bs["last_session_id"] = None
+        if session_id:
+            bs["last_failed_session_id"] = session_id
 
         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
 
-    if session_status == "success" and session_id:
+    if session_id:
         sessions = bs.get("sessions", [])
         if session_id not in sessions:
             sessions.append(session_id)
@@ -581,8 +622,9 @@ def action_update(args, bug_list_path, state_dir):
         summary["degraded_reason"] = session_status
         summary["restart_policy"] = "finalization_retry"
     elif session_status == "infra_error":
-        summary["restart_policy"] = "infra_retry"
+        summary["restart_policy"] = "in_process_ai_error_continuation" if new_status == "in_progress" else "needs_attention"
         summary["infra_error_count"] = bs.get("infra_error_count", 0)
+        summary.update(continuation_metadata_summary(bs))
         summary["artifacts_preserved"] = True
     elif session_status == "context_overflow":
         summary["restart_policy"] = "context_overflow_continuation"
@@ -593,8 +635,9 @@ def action_update(args, bug_list_path, state_dir):
         summary.update(continuation_metadata_summary(bs))
         summary["artifacts_preserved"] = True
     elif session_status != "success":
-        summary["restart_policy"] = "full_restart"
-        summary["cleanup_performed"] = cleaned
+        summary["restart_policy"] = "in_process_ai_error_continuation" if new_status == "in_progress" else "needs_attention"
+        summary.update(continuation_metadata_summary(bs))
+        summary["artifacts_preserved"] = True
 
     print(json.dumps(summary, indent=2, ensure_ascii=False))