prizmkit 1.1.99 → 1.1.100

package/bundled/dev-pipeline-windows/scripts/generate-bugfix-prompt.py

@@ -20,11 +20,11 @@ import re
 import sys
 
 from utils import enrich_global_context, load_json_file, read_platform_conventions, setup_logging
+from continuation import add_continuation_args, append_continuation_handoff, is_continuation
 
 
 DEFAULT_MAX_RETRIES = 3
 DEFAULT_MAX_LOG_SIZE = 2097152
-DEFAULT_LOG_MONITOR_POLL_INTERVAL = 30
 
 LOGGER = setup_logging("generate-bugfix-prompt")
 
@@ -48,6 +48,8 @@ def parse_args():
     parser.add_argument("--mode", default=None, help="Pipeline execution mode override: lite, standard, full")
     parser.add_argument("--critic", default=None, help="Enable critic agent: true/false")
     parser.add_argument("--no-checkpoint", action="store_true", help="Do not write workflow-checkpoint.json (used by pipeline dry-run)")
+    add_continuation_args(parser, "bugfix")
+
     return parser.parse_args()
 
 
@@ -358,33 +360,15 @@ def build_replacements(args, bug, global_context, script_dir):
             browser_verify_steps = "   # (reproduce bug and verify fix)"
 
     max_log_size = _parse_non_negative_int_env("MAX_LOG_SIZE", DEFAULT_MAX_LOG_SIZE)
-    if max_log_size == 0:
-        poll_interval = DEFAULT_LOG_MONITOR_POLL_INTERVAL
-    else:
-        poll_interval = _parse_positive_int_env(
-            "LOG_MONITOR_POLL_INTERVAL", DEFAULT_LOG_MONITOR_POLL_INTERVAL,
-        )
 
     replacements = {
         "{{LOG_SIZE_AWARENESS}}": load_log_size_section(script_dir),
         "{{MAX_LOG_SIZE}}": str(max_log_size),
         "{{MAX_LOG_SIZE_HUMAN}}": _format_bytes(max_log_size),
-        "{{LOG_MONITOR_POLL_INTERVAL}}": str(poll_interval),
-        "{{LOG_MONITOR_STATUS_FILE}}": os.path.join(
-            ".prizmkit", "state", "bugfix", args.bug_id,
-            "sessions", args.session_id, "logs", "log-monitor-status.txt",
-        ),
-        "{{LOG_MONITOR_BASELINE_FILE}}": os.path.join(
-            ".prizmkit", "state", "bugfix", args.bug_id,
-            "sessions", args.session_id, "logs", "log-monitor-baseline.txt",
-        ),
         "{{SESSION_LOG_PATH}}": os.path.join(
             ".prizmkit", "state", "bugfix", args.bug_id,
             "sessions", args.session_id, "logs", "session.log",
         ),
-        "{{LOG_MONITOR_SCRIPT}}": os.path.join(
-            ".prizmkit", "dev-pipeline", "scripts", "monitor-log.ps1",
-        ),
         "{{RUN_ID}}": args.run_id,
         "{{SESSION_ID}}": args.session_id,
         "{{BUG_ID}}": args.bug_id,
@@ -662,6 +646,8 @@ def main():
 
     # Build replacements
     replacements = build_replacements(args, bug, global_context, script_dir)
+    if is_continuation(args):
+        replacements["{{LOG_SIZE_AWARENESS}}"] = ""
 
     # Add checkpoint path to replacements
     checkpoint_rel = os.path.join(
@@ -680,6 +666,7 @@ def main():
     # Generate checkpoint file
     project_root = resolve_project_root(script_dir)
     checkpoint_path = os.path.join(project_root, checkpoint_rel)
+    checkpoint = {}
     if not args.no_checkpoint:
         checkpoint_dir = os.path.dirname(checkpoint_path)
         os.makedirs(checkpoint_dir, exist_ok=True)
@@ -687,7 +674,7 @@ def main():
         checkpoint = generate_bugfix_checkpoint(args.bug_id, args.session_id)
 
         is_resume = args.resume_phase != "null"
-        if is_resume and os.path.exists(checkpoint_path):
+        if (is_resume or is_continuation(args)) and os.path.exists(checkpoint_path):
             try:
                 with open(checkpoint_path, "r", encoding="utf-8") as f:
                     existing = json.load(f)
@@ -706,6 +693,15 @@ def main():
             json.dump(checkpoint, f, indent=2, ensure_ascii=False)
         LOGGER.info("Wrote bugfix checkpoint to %s", checkpoint_path)
 
+    if is_continuation(args):
+        rendered = append_continuation_handoff(
+            rendered, args, project_root, args.task_type, args.bug_id,
+            args.bug_id, checkpoint,
+        )
+        err = write_output(args.output, rendered)
+        if err:
+            emit_failure(err)
+
     # Resolve critic and mode
     bug_critic = bug.get("critic", False)
     if args.critic is not None:

package/bundled/dev-pipeline-windows/scripts/generate-refactor-prompt.py

@@ -20,11 +20,11 @@ import re
 import sys
 
 from utils import enrich_global_context, load_json_file, read_platform_conventions, setup_logging
+from continuation import add_continuation_args, append_continuation_handoff, is_continuation
 
 
 DEFAULT_MAX_RETRIES = 3
 DEFAULT_MAX_LOG_SIZE = 2097152
-DEFAULT_LOG_MONITOR_POLL_INTERVAL = 30
 
 LOGGER = setup_logging("generate-refactor-prompt")
 
@@ -139,6 +139,8 @@ def parse_args():
     parser.add_argument("--mode", default=None, help="Pipeline execution mode override: lite, standard, full")
     parser.add_argument("--critic", default=None, help="Enable critic agent: true/false")
     parser.add_argument("--no-checkpoint", action="store_true", help="Do not write workflow-checkpoint.json (used by pipeline dry-run)")
+    add_continuation_args(parser, "refactor")
+
     return parser.parse_args()
 
 
@@ -518,33 +520,15 @@ def build_replacements(args, refactor, refactors, global_context, script_dir):
             browser_verify_steps = "   # (validate UI renders correctly and feature still works)"
 
     max_log_size = _parse_non_negative_int_env("MAX_LOG_SIZE", DEFAULT_MAX_LOG_SIZE)
-    if max_log_size == 0:
-        poll_interval = DEFAULT_LOG_MONITOR_POLL_INTERVAL
-    else:
-        poll_interval = _parse_positive_int_env(
-            "LOG_MONITOR_POLL_INTERVAL", DEFAULT_LOG_MONITOR_POLL_INTERVAL,
-        )
 
     replacements = {
         "{{LOG_SIZE_AWARENESS}}": load_log_size_section(script_dir),
         "{{MAX_LOG_SIZE}}": str(max_log_size),
         "{{MAX_LOG_SIZE_HUMAN}}": _format_bytes(max_log_size),
-        "{{LOG_MONITOR_POLL_INTERVAL}}": str(poll_interval),
-        "{{LOG_MONITOR_STATUS_FILE}}": os.path.join(
-            ".prizmkit", "state", "refactor", args.refactor_id,
-            "sessions", args.session_id, "logs", "log-monitor-status.txt",
-        ),
-        "{{LOG_MONITOR_BASELINE_FILE}}": os.path.join(
-            ".prizmkit", "state", "refactor", args.refactor_id,
-            "sessions", args.session_id, "logs", "log-monitor-baseline.txt",
-        ),
         "{{SESSION_LOG_PATH}}": os.path.join(
             ".prizmkit", "state", "refactor", args.refactor_id,
             "sessions", args.session_id, "logs", "session.log",
         ),
-        "{{LOG_MONITOR_SCRIPT}}": os.path.join(
-            ".prizmkit", "dev-pipeline", "scripts", "monitor-log.ps1",
-        ),
         "{{RUN_ID}}": args.run_id,
         "{{SESSION_ID}}": args.session_id,
         "{{REFACTOR_ID}}": args.refactor_id,
@@ -744,6 +728,8 @@ def main():
 
     # Build replacements
     replacements = build_replacements(args, refactor, refactors, global_context, script_dir)
+    if is_continuation(args):
+        replacements["{{LOG_SIZE_AWARENESS}}"] = ""
 
     # Render the template
     rendered = render_template(template_content, replacements, args.resume_phase, refactor)
@@ -759,6 +745,7 @@ def main():
         ".prizmkit", "refactor", args.refactor_id, "workflow-checkpoint.json",
     )
     checkpoint_path = os.path.join(project_root, checkpoint_rel)
+    checkpoint = {}
     if not args.no_checkpoint:
         checkpoint_dir = os.path.dirname(checkpoint_path)
         os.makedirs(checkpoint_dir, exist_ok=True)
@@ -766,7 +753,7 @@ def main():
         checkpoint = generate_refactor_checkpoint(args.refactor_id, args.session_id)
 
         is_resume = args.resume_phase != "null"
-        if is_resume and os.path.exists(checkpoint_path):
+        if (is_resume or is_continuation(args)) and os.path.exists(checkpoint_path):
             try:
                 with open(checkpoint_path, "r", encoding="utf-8") as f:
                     existing = json.load(f)
@@ -785,6 +772,15 @@ def main():
             json.dump(checkpoint, f, indent=2, ensure_ascii=False)
         LOGGER.info("Wrote refactor checkpoint to %s", checkpoint_path)
 
+    if is_continuation(args):
+        rendered = append_continuation_handoff(
+            rendered, args, project_root, args.task_type, args.refactor_id,
+            args.refactor_id, checkpoint,
+        )
+        err = write_output(args.output, rendered)
+        if err:
+            emit_failure(err)
+
     # Resolve critic and mode
     refactor_critic = refactor.get("critic", False)
     if args.critic is not None:

package/bundled/dev-pipeline-windows/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 ""
 
 
@@ -171,6 +227,7 @@ class ProgressTracker:
            with sessionId/cwd metadata, function_call for tool invocations).
         """
         event_type = event.get("type", "")
+        self._detect_structured_terminal_fields(event)
 
         # ── Codex exec --json JSONL format ──────────────────────────
         if event_type in (
@@ -491,6 +548,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 +637,78 @@ class ProgressTracker:
             # This is a sub-agent event; tool name is still tracked normally
             pass
 
+
+    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 +746,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)