prizmkit 1.1.99 → 1.1.101

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

@@ -60,30 +60,66 @@ PHASE_KEYWORDS = {
     },
 }
 
-CONTEXT_ERROR_PATTERNS = [
+CONTEXT_OVERFLOW_CODE = "context_overflow"
+
+# Exact machine/wrapper signals. These are only treated as self-sufficient when
+# they appear in structured error-code fields or as explicit wrapper markers.
+CONTEXT_CODE_PATTERNS = [
+    re.compile(pattern, re.IGNORECASE)
+    for pattern in (
+        r"\bcontext_overflow\b",
+        r"\bcontext_too_large\b",
+        r"\bcontext_length_exceeded\b",
+        r"\bmodel_context_window_exceeded\b",
+    )
+]
+
+WRAPPER_CONTEXT_ERROR_PATTERNS = [
+    re.compile(pattern, re.IGNORECASE)
+    for pattern in (
+        r"\bPRIZMKIT_FATAL_ERROR\s*=\s*context_overflow\b",
+    )
+]
+
+# Natural-language provider messages are weak signals: they require an adjacent
+# runtime/API error context unless a structured field already proves the result
+# is an error.
+WEAK_CONTEXT_ERROR_PATTERNS = [
     re.compile(pattern, re.IGNORECASE)
     for pattern in (
-        r"context_too_large",
-        r"model_context_window_exceeded",
         r"Your input exceeds the context window",
-        r"input exceeds the context window",
+        r"input exceeds (?:the )?(?:model )?context window",
         r"context window of this model",
-        r"context window exceeded",
-        r"invalid_request_error.*context window",
-        r"context window.*invalid_request_error",
+        r"context window (?:was )?exceeded",
+        r"exceeded (?:the )?context window",
+        r"maximum context length exceeded",
+        r"prompt is too long",
+        r"too many tokens",
+        r"input token count exceeds",
+        r"input tokens? exceeds?",
+        r"token count exceeds",
     )
 ]
 
+REQUEST_TOO_LARGE_PATTERN = re.compile(r"\brequest (?:is )?too large\b", re.IGNORECASE)
+REQUEST_TOO_LARGE_SEMANTIC_PATTERN = re.compile(
+    r"\b(context|token|tokens|prompt|input|model)\b",
+    re.IGNORECASE,
+)
+
 ERROR_CONTEXT_PATTERNS = [
     re.compile(pattern, re.IGNORECASE)
     for pattern in (
         r"\bapi error\b",
         r"invalid_request_error",
+        r"\bbad request\b",
         r"\bstatus\s*[:=]?\s*(400|413)\b",
         r"\bapi_error_status\b",
         r"\bapi_error_code\b",
         r"\blast_result_is_error\b\s*[\"':=]*\s*true\b",
         r"\bis_error\b\s*[\"':=]*\s*true\b",
+        r"\berror\s*[:=]",
+        r"\bfatal\s*[:=]",
     )
 ]
 
@@ -95,21 +131,41 @@ def _has_error_context(text):
     return any(pattern.search(text) for pattern in ERROR_CONTEXT_PATTERNS)
 
 
-def detect_api_error_code(text, require_error_context=False):
+def _has_context_overflow_signal(text, structured_code=False):
+    """Return true when text contains a context-window/token overflow signal."""
+    if not text:
+        return False
+    if any(pattern.search(text) for pattern in WRAPPER_CONTEXT_ERROR_PATTERNS):
+        return True
+    if structured_code and any(pattern.search(text) for pattern in CONTEXT_CODE_PATTERNS):
+        return True
+    if any(pattern.search(text) for pattern in CONTEXT_CODE_PATTERNS):
+        return True
+    if any(pattern.search(text) for pattern in WEAK_CONTEXT_ERROR_PATTERNS):
+        return True
+    if REQUEST_TOO_LARGE_PATTERN.search(text) and REQUEST_TOO_LARGE_SEMANTIC_PATTERN.search(text):
+        return True
+    return False
+
+
+def detect_api_error_code(text, require_error_context=False, structured_code=False):
     """Return a normalized fatal/runtime error code from terminal text.
 
-    Structured terminal result/error events and raw stderr can be matched
-    directly. Ordinary assistant prose is noisier: it may mention the phrase
-    "input exceeds the context window" while explaining a test or recovery
-    rule, so callers can require additional error-like context there.
+    Structured error-code fields and explicit wrapper markers can be matched
+    directly. Natural-language provider messages require runtime/API context to
+    avoid false positives from prompts, tests, or documentation that merely
+    mention context windows or token limits.
     """
     if not text:
         return ""
+    if any(pattern.search(text) for pattern in WRAPPER_CONTEXT_ERROR_PATTERNS):
+        return CONTEXT_OVERFLOW_CODE
+    if structured_code and any(pattern.search(text) for pattern in CONTEXT_CODE_PATTERNS):
+        return CONTEXT_OVERFLOW_CODE
     if require_error_context and not _has_error_context(text):
         return ""
-    for pattern in CONTEXT_ERROR_PATTERNS:
-        if pattern.search(text):
-            return "context_too_large"
+    if _has_context_overflow_signal(text, structured_code=structured_code):
+        return CONTEXT_OVERFLOW_CODE
     return ""
 
 
@@ -119,6 +175,7 @@ class ProgressTracker:
     def __init__(self, session_log=None):
         self.session_log_path = Path(session_log).expanduser() if session_log else None
         self.message_count = 0
+        self.event_type_counts = Counter()
         self.current_tool = None
         self.current_tool_input_summary = ""
         self.current_phase = None
@@ -140,6 +197,10 @@ class ProgressTracker:
         self._subagent_spawn_count = 0
         self.codex_child_thread_ids = set()
         self.cb_session_id = ""
+        self.result_subtype = ""
+        self.stop_reason = ""
+        self.has_usage = False
+        self.permission_denials = []
         self.cb_cwd = ""
         self.claude_session_id = ""
         self.claude_cwd = ""
@@ -171,6 +232,10 @@ class ProgressTracker:
            with sessionId/cwd metadata, function_call for tool invocations).
         """
         event_type = event.get("type", "")
+        if event_type:
+            self.event_type_counts[str(event_type)] += 1
+        self._detect_structured_terminal_fields(event)
+        self._record_usage_and_permission_metadata(event)
 
         # ── Codex exec --json JSONL format ──────────────────────────
         if event_type in (
@@ -472,6 +537,8 @@ class ProgressTracker:
                     self._update_claude_subagent_status_counts()
 
         elif event_type == "result":
+            self.result_subtype = str(event.get("subtype") or event.get("result_subtype") or "")
+            self.stop_reason = str(event.get("stop_reason") or "")
             self.event_format = self.event_format or "stream-json"
             self.is_active = False
             result_text = event.get("result") or event.get("message") or ""
@@ -491,6 +558,7 @@ class ProgressTracker:
                 is_error=bool(event.get("is_error")),
                 api_error_status=event.get("api_error_status"),
                 api_error_code=str(api_error_code or ""),
+                stop_reason=str(event.get("stop_reason") or ""),
             )
 
         # ── Claude API raw stream format ────────────────────────────
@@ -579,6 +647,99 @@ class ProgressTracker:
             # This is a sub-agent event; tool name is still tracked normally
             pass
 
+
+    def _record_usage_and_permission_metadata(self, event):
+        """Record additive metadata required by Python runtime parity tests."""
+        if not isinstance(event, dict):
+            return
+        if event.get("usage") not in (None, "", {}):
+            self.has_usage = True
+        denial_text = json.dumps(event, ensure_ascii=False).lower()
+        if any(
+            marker in denial_text
+            for marker in (
+                "permission denied",
+                "permission_denied",
+                "permission denial",
+                "denied by user",
+                "user denied",
+                "not permitted",
+            )
+        ):
+            self.permission_denials.append(json.dumps(event, ensure_ascii=False)[:500])
+            self.permission_denials = self.permission_denials[-10:]
+
+    def _detect_structured_terminal_fields(self, event):
+        """Detect provider-neutral terminal/context errors before format routing."""
+        if not isinstance(event, dict):
+            return
+
+        code_parts = []
+        text_parts = []
+        terminal_parts = []
+
+        for key in ("fatal_error_code", "api_error_code", "error_code", "stop_reason"):
+            value = event.get(key)
+            if isinstance(value, (str, int, float)) and str(value).strip():
+                code_parts.append(str(value))
+
+        for key in ("terminal_result_text", "message", "result"):
+            value = event.get(key)
+            if isinstance(value, (str, int, float)) and str(value).strip():
+                text_parts.append(str(value))
+                terminal_parts.append(str(value))
+
+        error_obj = event.get("error")
+        if isinstance(error_obj, dict):
+            for key in ("type", "code", "message"):
+                value = error_obj.get(key)
+                if isinstance(value, (str, int, float)) and str(value).strip():
+                    text_parts.append(str(value))
+                    terminal_parts.append(str(value))
+        elif isinstance(error_obj, (str, int, float)) and str(error_obj).strip():
+            text_parts.append(str(error_obj))
+            terminal_parts.append(str(error_obj))
+
+        combined_code_text = " ".join(code_parts)
+        combined_text = " ".join(code_parts + text_parts)
+        if not combined_text:
+            return
+
+        error_like = (
+            bool(code_parts)
+            or event.get("api_error_status") not in (None, "")
+            or bool(event.get("last_result_is_error"))
+            or bool(event.get("is_error"))
+            or _has_error_context(combined_text)
+        )
+        normalized_code = detect_api_error_code(
+            combined_code_text,
+            require_error_context=False,
+            structured_code=True,
+        ) or detect_api_error_code(
+            combined_text,
+            require_error_context=not error_like,
+            structured_code=bool(code_parts),
+        )
+        if not normalized_code:
+            return
+
+        self.last_result_is_error = True
+        api_error_status = event.get("api_error_status") or event.get("status")
+        if api_error_status not in (None, ""):
+            try:
+                self.api_error_status = int(api_error_status)
+            except (TypeError, ValueError):
+                self.api_error_status = api_error_status
+        self.api_error_code = normalized_code
+        self.fatal_error_code = normalized_code
+        terminal_text = " ".join(terminal_parts) or combined_text
+        self.terminal_result_text = terminal_text[:1000]
+        if terminal_text.strip():
+            self.last_text_snippet = terminal_text.strip()[:120]
+        if not self.errors or self.errors[-1] != normalized_code:
+            self.errors.append(normalized_code)
+
     def _record_cb_agent_tool_call(self, tool_name, raw_args):
         """Record a CodeBuddy Agent/Task* tool invocation for sub-agent tracking.
 
@@ -616,7 +777,7 @@ class ProgressTracker:
         elif tool_name == "TaskCreate":
             self._subagent_spawn_count += 1
 
-    def _record_terminal_result(self, text="", is_error=False, api_error_status=None, api_error_code=""):
+    def _record_terminal_result(self, text="", is_error=False, api_error_status=None, api_error_code="", stop_reason=""):
         """Record a Claude Code terminal result event."""
         terminal_text = str(text or "")
         self.last_result_is_error = bool(is_error)
@@ -1071,6 +1232,13 @@ class ProgressTracker:
         return {
             "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
             "event_format": self.event_format,
+            "event_type_counts": dict(self.event_type_counts),
+            "claude_session_id": self.claude_session_id,
+            "result_subtype": self.result_subtype,
+            "stop_reason": self.stop_reason,
+            "has_usage": self.has_usage,
+            "permission_denial_count": len(self.permission_denials),
+            "permission_denials": self.permission_denials[-10:],
             "message_count": self.message_count,
             "current_tool": self.current_tool,
             "current_tool_input_summary": self.current_tool_input_summary,
@@ -1127,6 +1295,7 @@ def tail_and_parse(session_log, progress_file, poll_interval=0.5):
     def state_key(state):
         return (
             state["message_count"],
+            tuple(sorted(state.get("event_type_counts", {}).items())),
             state["current_tool"],
             state["current_phase"],
             state["total_tool_calls"],

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

@@ -42,6 +42,8 @@ SESSION_STATUS_VALUES = [
     "crashed",
     "timed_out",
     "infra_error",
+    "context_overflow",
+    "stalled_context_continuation",
     "commit_missing",
     "docs_missing",
     "merge_conflict",
@@ -78,6 +80,12 @@ def parse_args():
     parser.add_argument("--max-retries", type=int, default=3, help="Maximum code retry count (default: 3)")
     parser.add_argument("--max-infra-retries", type=int, default=3, help="Maximum infrastructure retry count (default: 3)")
     parser.add_argument("--project-root", default=None, help="Project root directory. Required for 'clean' action.")
+    parser.add_argument("--active-dev-branch", default=None, help="Development branch preserved for continuation after context overflow.")
+    parser.add_argument("--base-branch", default=None, help="Original/base branch for continuation branch reuse.")
+    parser.add_argument("--last-fatal-error-code", default=None, help="Fatal runtime error code associated with continuation.")
+    parser.add_argument("--continuation-summary-path", default=None, help="Optional continuation summary artifact path.")
+    parser.add_argument("--no-progress-count", type=int, default=None, help="Consecutive context-overflow sessions without objective progress.")
+    parser.add_argument("--progress-fingerprint", default=None, help="JSON progress fingerprint captured after the session.")
     return parser.parse_args()
 
 
@@ -164,6 +172,128 @@ def update_bug_in_list(bug_list_path, bug_id, new_status):
     return write_json_file(bug_list_path, data)
 
 
+CONTINUATION_PENDING_FIELDS = [
+    "active_dev_branch",
+    "base_branch",
+    "continuation_pending",
+    "continuation_reason",
+    "last_context_overflow_session_id",
+    "previous_session_id",
+    "last_fatal_error_code",
+    "continuation_summary_path",
+    "no_progress_count",
+    "last_progress_fingerprint",
+    "needs_attention",
+    "stalled_context_continuation",
+    "stalled_reason",
+]
+
+CONTINUATION_COUNTER_FIELDS = [
+    "context_overflow_count",
+    "continuation_count",
+]
+
+
+def has_pending_continuation_metadata(status_data):
+    """Return True when runtime state still has pending continuation metadata."""
+    return any(key in status_data for key in CONTINUATION_PENDING_FIELDS)
+
+
+def clear_pending_continuation_metadata(status_data):
+    """Clear branch/pending continuation fields while preserving observability counters."""
+    for key in CONTINUATION_PENDING_FIELDS:
+        status_data.pop(key, None)
+
+
+def reset_continuation_metadata(status_data):
+    """Clear all continuation runtime metadata, including manual-reset counters."""
+    clear_pending_continuation_metadata(status_data)
+    for key in CONTINUATION_COUNTER_FIELDS:
+        status_data.pop(key, None)
+
+
+STALL_REASON = "context_overflow_without_git_checkpoint_or_artifact_progress"
+
+
+def _load_progress_fingerprint(raw):
+    if not raw:
+        return None
+    try:
+        return json.loads(raw)
+    except (TypeError, ValueError):
+        return {"unparsed": str(raw)}
+
+
+def _set_continuation_common(status_data, args, session_id):
+    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["last_context_overflow_session_id"] = session_id
+    status_data["previous_session_id"] = session_id
+    status_data["last_fatal_error_code"] = args.last_fatal_error_code or "context_overflow"
+    if args.continuation_summary_path:
+        status_data["continuation_summary_path"] = args.continuation_summary_path
+    else:
+        status_data.pop("continuation_summary_path", None)
+    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["last_infra_error_session_id"] = None
+    status_data["resume_from_phase"] = None
+    if session_id:
+        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
+    status_data["continuation_count"] = status_data.get("continuation_count", 0) + 1
+    status_data["continuation_pending"] = True
+    status_data["continuation_reason"] = "context_overflow"
+    status_data.pop("needs_attention", None)
+    status_data.pop("stalled_context_continuation", None)
+    status_data.pop("stalled_reason", None)
+    _set_continuation_common(status_data, args, session_id)
+
+
+def set_stalled_context_continuation_metadata(status_data, args, session_id):
+    """Record no-progress context-overflow stall without consuming retry budgets."""
+    status_data["context_overflow_count"] = status_data.get("context_overflow_count", 0) + 1
+    status_data["continuation_count"] = status_data.get("continuation_count", 0) + 1
+    _set_continuation_common(status_data, args, session_id)
+    status_data["continuation_pending"] = False
+    status_data["continuation_reason"] = STALL_REASON
+    status_data["needs_attention"] = True
+    status_data["stalled_context_continuation"] = True
+    status_data["stalled_reason"] = STALL_REASON
+    if args.no_progress_count is None or args.no_progress_count < 2:
+        status_data["no_progress_count"] = 2
+
+
+def continuation_metadata_summary(status_data):
+    """Return additive continuation fields for CLI JSON outputs."""
+    return {
+        "active_dev_branch": status_data.get("active_dev_branch"),
+        "base_branch": status_data.get("base_branch"),
+        "continuation_pending": status_data.get("continuation_pending", False),
+        "continuation_reason": status_data.get("continuation_reason"),
+        "last_context_overflow_session_id": status_data.get("last_context_overflow_session_id"),
+        "last_fatal_error_code": status_data.get("last_fatal_error_code"),
+        "previous_session_id": status_data.get("previous_session_id"),
+        "context_overflow_count": status_data.get("context_overflow_count", 0),
+        "continuation_count": status_data.get("continuation_count", 0),
+        "no_progress_count": status_data.get("no_progress_count", 0),
+        "last_progress_fingerprint": status_data.get("last_progress_fingerprint"),
+        "needs_attention": status_data.get("needs_attention", False),
+        "stalled_context_continuation": status_data.get("stalled_context_continuation", False),
+        "stalled_reason": status_data.get("stalled_reason"),
+        "continuation_summary_path": status_data.get("continuation_summary_path"),
+    }
+
+
 # ---------------------------------------------------------------------------
 # Action: get_next
 # ---------------------------------------------------------------------------
@@ -244,6 +374,7 @@ def action_get_next(bug_list_data, state_dir):
         "infra_error_count": chosen_status_data.get("infra_error_count", 0),
         "resume_from_phase": chosen_status_data.get("resume_from_phase", None),
     }
+    result.update(continuation_metadata_summary(chosen_status_data))
     print(json.dumps(result, indent=2, ensure_ascii=False))
 
 
@@ -267,12 +398,15 @@ def action_update(args, bug_list_path, state_dir):
 
     bs = load_bug_status(state_dir, bug_id)
 
+    current_list_status = get_bug_status_from_list(bug_list_path, bug_id)
+
     # Track what status we write to bug-fix-list.json
-    new_status = get_bug_status_from_list(bug_list_path, bug_id)
+    new_status = current_list_status
 
     if session_status == "success":
         bs["infra_error_count"] = 0
         bs["last_infra_error_session_id"] = None
+        clear_pending_continuation_metadata(bs)
         new_status = "completed"
         bs["resume_from_phase"] = None
         err = update_bug_in_list(bug_list_path, bug_id, "completed")
@@ -304,7 +438,7 @@ def action_update(args, bug_list_path, state_dir):
         bs["infra_error_count"] = infra_error_count
         bs["last_infra_error_session_id"] = session_id
         bs["max_infra_retries"] = max_infra_retries
-        bs["degraded_reason"] = "infra_error"
+        bs["degraded_reason"] = session_status
         if session_id:
             bs["last_session_id"] = session_id
         bs["resume_from_phase"] = None
@@ -316,6 +450,23 @@ def action_update(args, bug_list_path, state_dir):
         else:
             new_status = "pending"
 
+        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
+    elif session_status == "context_overflow":
+        # Context overflow is continuation state, not code or infra retry state.
+        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")
+            if err:
+                error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
+                return
+    elif session_status == "stalled_context_continuation":
+        # No-progress context-overflow stall pauses automation without consuming retry budgets.
+        set_stalled_context_continuation_metadata(bs, args, session_id)
+        new_status = "needs_info"
         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))
@@ -375,6 +526,14 @@ def action_update(args, bug_list_path, state_dir):
         summary["restart_policy"] = "infra_retry"
         summary["infra_error_count"] = bs.get("infra_error_count", 0)
         summary["artifacts_preserved"] = True
+    elif session_status == "context_overflow":
+        summary["restart_policy"] = "context_overflow_continuation"
+        summary.update(continuation_metadata_summary(bs))
+        summary["artifacts_preserved"] = True
+    elif session_status == "stalled_context_continuation":
+        summary["restart_policy"] = "needs_attention"
+        summary.update(continuation_metadata_summary(bs))
+        summary["artifacts_preserved"] = True
     elif session_status != "success":
         summary["restart_policy"] = "full_restart"
         summary["cleanup_performed"] = cleaned
@@ -445,6 +604,45 @@ def cleanup_bug_artifacts(state_dir, bug_id, project_root=None):
     return cleaned
 
 
+def _resolve_project_file(project_root, path):
+    if not path:
+        return None
+    if os.path.isabs(path):
+        target = os.path.abspath(path)
+    else:
+        target = os.path.abspath(os.path.join(project_root, path))
+    root = os.path.abspath(project_root)
+    try:
+        rel = os.path.relpath(target, root)
+    except ValueError:
+        return None
+    if rel == os.pardir or rel.startswith(os.pardir + os.sep):
+        return None
+    return target
+
+
+def cleanup_continuation_artifacts(project_root, status_data, candidate_paths=None):
+    """Delete durable continuation handoff files for a manual clean reset."""
+    candidates = []
+    if isinstance(status_data, dict):
+        candidates.append(status_data.get("continuation_summary_path"))
+    candidates.extend(candidate_paths or [])
+
+    cleaned = []
+    seen = set()
+    for candidate in candidates:
+        target = _resolve_project_file(project_root, candidate)
+        if not target or target in seen:
+            continue
+        seen.add(target)
+        if os.path.basename(target) != "continuation-summary.md":
+            continue
+        if os.path.isfile(target):
+            os.remove(target)
+            cleaned.append("Deleted continuation artifact {}".format(target))
+    return cleaned
+
+
 def load_session_status(state_dir, bug_id, session_id):
     session_status_path = os.path.join(state_dir, bug_id, "sessions",
         session_id, "session-status.json"
@@ -608,6 +806,7 @@ def action_reset(args, bug_list_path, state_dir):
     bs["sessions"] = []
     bs["last_session_id"] = None
     bs["resume_from_phase"] = None
+    reset_continuation_metadata(bs)
     bs["updated_at"] = now_iso()
 
     err = save_bug_status(state_dir, bug_id, bs)
@@ -679,12 +878,19 @@ def action_clean(args, bug_list_path, state_dir):
     old_status = get_bug_status_from_list(bug_list_path, bug_id)
     old_retry = bs.get("retry_count", 0)
 
+    continuation_candidates = [
+        os.path.join(".prizmkit", "bugfix", bug_id, "continuation-summary.md"),
+        os.path.join(".prizmkit", "specs", bug_id, "continuation-summary.md"),
+    ]
+    cleaned.extend(cleanup_continuation_artifacts(project_root, bs, continuation_candidates))
+
     bs["retry_count"] = 0
     bs["infra_error_count"] = 0
     bs["last_infra_error_session_id"] = None
     bs["sessions"] = []
     bs["last_session_id"] = None
     bs["resume_from_phase"] = None
+    reset_continuation_metadata(bs)
     bs["updated_at"] = now_iso()
 
     err = save_bug_status(state_dir, bug_id, bs)
@@ -760,10 +966,11 @@ def action_start(args, bug_list_path, state_dir):
         error_out("Failed to save bug status: {}".format(err))
         return
 
-    err = update_bug_in_list(bug_list_path, bug_id, "in_progress")
-    if err:
-        error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
-        return
+    if old_status != "in_progress":
+        err = update_bug_in_list(bug_list_path, bug_id, "in_progress")
+        if err:
+            error_out("Failed to update .prizmkit/plans/bug-fix-list.json: {}".format(err))
+            return
 
     result = {
         "action": "start",
@@ -853,6 +1060,7 @@ def action_unskip(args, bug_list_path, state_dir):
         bs["sessions"] = []
         bs["last_session_id"] = None
         bs["resume_from_phase"] = None
+        reset_continuation_metadata(bs)
         bs["updated_at"] = now_iso()
         save_bug_status(state_dir, bid, bs)