@pushpalsdev/cli 1.1.25 → 1.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.1.25",
+  "version": "1.1.27",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

package/runtime/sandbox/.pushpals-remotebuddy-fallback.js

@@ -6583,6 +6583,8 @@ class RemoteBuddyAutonomousEngine {
   lastOutcome = "none";
   lastDetail = "not_started";
   lastCompletedAtMs = 0;
+  dispatchBackoffUntilMs = 0;
+  dispatchBackoffReason = "";
   pendingIdeationTimeoutRecovery = null;
   constructor(opts) {
     this.server = opts.server;
@@ -7133,10 +7135,32 @@ ${JSON.stringify(input.messages ?? [])}`),
         }
       })
     });
-    if (!res.ok)
+    if (!res.ok) {
+      let errorPayload = {};
+      try {
+        const parsed = await res.json();
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          errorPayload = parsed;
+        }
+      } catch {
+        errorPayload = {};
+      }
+      const code = String(errorPayload.code ?? "").trim();
+      if (res.status === 429 && (code === "autonomy_worker_failure_circuit_open" || code === "autonomy_similar_no_publishable_suppressed" || code === "autonomy_queue_backpressure" || code === "autonomy_open_pr_limit")) {
+        const retryAfterMsRaw = Number(errorPayload.retryAfterMs ?? 0);
+        const retryAfterMs = Number.isFinite(retryAfterMsRaw) ? Math.max(60000, Math.min(60 * 60 * 1000, Math.floor(retryAfterMsRaw))) : 30 * 60 * 1000;
+        this.dispatchBackoffUntilMs = Date.now() + retryAfterMs;
+        this.dispatchBackoffReason = compactStatusDetail(code || String(errorPayload.message ?? "autonomy_enqueue_rejected")) || "autonomy_enqueue_rejected";
+      }
       return null;
+    }
     const data = await res.json();
-    return data.ok && data.requestId ? data.requestId : null;
+    if (data.ok && data.requestId) {
+      this.dispatchBackoffUntilMs = 0;
+      this.dispatchBackoffReason = "";
+      return data.requestId;
+    }
+    return null;
   }
   isSnapshotExpired(snapshot) {
     const createdAt = Date.parse(snapshot.snapshot_created_at);
@@ -7323,6 +7347,12 @@ ${JSON.stringify(input.messages ?? [])}`),
     let outcome = "skipped";
     let outcomeDetail = "not_dispatched";
     try {
+      if (Date.now() < this.dispatchBackoffUntilMs) {
+        this.setPhase("dispatch_backoff");
+        const remainingMs = Math.max(0, this.dispatchBackoffUntilMs - Date.now());
+        outcomeDetail = compactStatusDetail(`dispatch_backoff:${this.dispatchBackoffReason || "autonomy_enqueue_rejected"}:${remainingMs}ms`);
+        return;
+      }
       this.setPhase("acquire_lock");
       const lockResult = await this.acquireDispatchLock(runId);
       lockAcquired = lockResult.ok;
@@ -8651,7 +8681,7 @@ function sanitizeRepoNativeTargetHints(params) {
       const lower = step.replace(/\\/g, "/").toLowerCase();
       return !staleLower.some((path) => lower.includes(path));
     });
-    params.plan.scope.write_globs = params.plan.scope.write_globs.filter((glob) => {
+    params.plan.scope.write_globs = (params.plan.scope.write_globs ?? []).filter((glob) => {
       const normalized = normalizeTargetPath(glob);
       if (!normalized)
         return false;
@@ -10367,8 +10397,10 @@ Please reply with the missing details and I will enqueue a follow-up request.` :
           });
         }
       } else {
-        await this.assistantMessage(requestSessionId, "I could not queue this WorkerPal task. No task was started.", { turnId, correlationId: requestId, from: eventFrom });
-        this.rememberPersistentMemory("job_enqueue_failed", `enqueue_failed lane=${lane} intent=${plan.intent}`, requestId, requestSessionId);
+        if (!autonomyMetadata) {
+          await this.assistantMessage(requestSessionId, "I could not queue this WorkerPal task. No task was started.", { turnId, correlationId: requestId, from: eventFrom });
+        }
+        this.rememberPersistentMemory("job_enqueue_failed", `enqueue_failed lane=${lane} intent=${plan.intent} origin=${autonomyMetadata ? "autonomy" : "user"}`, requestId, requestSessionId);
       }
       await this.fetchImpl(`${this.server}/requests/${requestId}/complete`, {
         method: "POST",

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/openai_codex_executor.py

@@ -106,18 +106,23 @@ _MAX_WRAPPER_BOOTSTRAP_OUTPUT_CHARS = 1_200
 _MAX_WRAPPER_BOOTSTRAP_TOTAL_CHARS = 5_000
 _MAX_CREDIBLE_WRAPPER_LOOP_CHANGED_PATHS = 8
 _MAX_CREDIBLE_WRAPPER_LOOP_TOP_LEVELS = 4
+_MAX_STARTUP_STALL_RECOVERY_ATTEMPTS = 1
 _MAX_NO_EDIT_RECOVERY_ATTEMPTS = 1
 _MAX_ROLLOUT_RECOVERY_ATTEMPTS = 1
 _DEFAULT_NO_EDIT_WATCHDOG_S = 480
 _SMALL_TASK_NO_EDIT_WATCHDOG_S = 240
 _NARROW_TEST_TASK_NO_EDIT_WATCHDOG_S = 180
 _WEB_REVIEW_NO_EDIT_WATCHDOG_S = 240
-_NO_EDIT_RECOVERY_WATCHDOG_S = 180
+_BACKGROUND_NO_EDIT_WATCHDOG_S = 120
+_NO_EDIT_RECOVERY_WATCHDOG_S = 90
 _DEFAULT_NO_EDIT_RECHECK_S = 120
 _DEFAULT_ROLLOUT_WATCHDOG_S = 300
 _SMALL_TASK_ROLLOUT_WATCHDOG_S = 240
 _NARROW_TEST_TASK_ROLLOUT_WATCHDOG_S = 150
 _WEB_REVIEW_ROLLOUT_WATCHDOG_S = 180
+_BACKGROUND_ROLLOUT_WATCHDOG_S = 90
+_NO_PUBLISHABLE_FAILURE_COOLDOWN_MS = 10 * 60 * 1000
+_CODEX_STARTUP_ONLY_EVENT_TYPES = {"thread.started", "turn.started"}
 
 
 def _model_supports_xhigh_reasoning(model: str) -> bool:
@@ -682,6 +687,16 @@ def _resolve_progress_log_interval_seconds(config: OpenAICodexRuntimeConfig) ->
     return max(30, min(120, interval))
 
 
+def _looks_like_background_autonomy_prompt(prompt: str) -> bool:
+    text = str(prompt or "").lower()
+    return (
+        "priority=background" in text
+        or "queuepriority=background" in text
+        or "origin=autonomy" in text
+        or "autonomy background" in text
+    )
+
+
 def _resolve_no_edit_watchdog_seconds(
     prompt: str,
     communicate_timeout_s: Optional[int],
@@ -706,7 +721,10 @@ def _resolve_no_edit_watchdog_seconds(
         return None
 
     prompt_text = str(prompt or "").lower()
-    if _looks_like_narrow_test_task_prompt(prompt):
+    is_background = _looks_like_background_autonomy_prompt(prompt)
+    if is_background:
+        default_s = _BACKGROUND_NO_EDIT_WATCHDOG_S
+    elif _looks_like_narrow_test_task_prompt(prompt):
         default_s = _NARROW_TEST_TASK_NO_EDIT_WATCHDOG_S
     elif "repo-native web review" in prompt_text or "web review path" in prompt_text:
         default_s = _WEB_REVIEW_NO_EDIT_WATCHDOG_S
@@ -718,7 +736,8 @@ def _resolve_no_edit_watchdog_seconds(
         )
     if recovery_attempt > 0:
         default_s = min(default_s, _NO_EDIT_RECOVERY_WATCHDOG_S)
-    return max(120, min(default_s, max(120, communicate_timeout_s - 60)))
+    floor_s = 90 if is_background or recovery_attempt > 0 else 120
+    return max(floor_s, min(default_s, max(floor_s, communicate_timeout_s - 60)))
 
 
 def _resolve_no_edit_recheck_seconds(communicate_timeout_s: Optional[int]) -> int:
@@ -761,7 +780,9 @@ def _resolve_rollout_watchdog_seconds(
         else:
             return max(1, min(parsed, max(1, communicate_timeout_s - 1)))
 
-    if _looks_like_narrow_test_task_prompt(prompt):
+    if _looks_like_background_autonomy_prompt(prompt):
+        default_s = _BACKGROUND_ROLLOUT_WATCHDOG_S
+    elif _looks_like_narrow_test_task_prompt(prompt):
         default_s = _NARROW_TEST_TASK_ROLLOUT_WATCHDOG_S
     elif _looks_like_web_review_prompt(prompt):
         default_s = _WEB_REVIEW_ROLLOUT_WATCHDOG_S
@@ -843,6 +864,19 @@ def _build_no_edit_recovery_guidance(trace_excerpt: str, artifact_only_paths: st
     return "\n".join(lines)
 
 
+def _build_startup_stall_recovery_guidance(trace_excerpt: str) -> str:
+    lines = [
+        "Codex startup-stall recovery: the previous Codex subprocess started but emitted no assistant, tool, or reasoning progress before the watchdog.",
+        "Treat this as a fresh execution with a patch-first contract. After at most one narrow read of the hinted owner, make the smallest publishable edit.",
+        "Do not spend this recovery attempt re-reading broad repository topology or validating before an edit exists.",
+        "If the hinted path is absent, choose the nearest existing repo-native owner or test rather than creating unrelated scaffolding.",
+    ]
+    if trace_excerpt:
+        lines.append("Previous Codex event trace excerpt:")
+        lines.append(trace_excerpt)
+    return "\n".join(lines)
+
+
 def _trace_summaries_text(trace: Dict[str, Any]) -> str:
     summaries = trace.get("summaries")
     if not isinstance(summaries, list):
@@ -850,6 +884,36 @@ def _trace_summaries_text(trace: Dict[str, Any]) -> str:
     return "\n".join(str(item or "") for item in summaries[-80:]).lower()
 
 
+def _codex_trace_has_work_progress(trace: Dict[str, Any]) -> bool:
+    if to_int(trace.get("reasoning_events"), 0) > 0:
+        return True
+
+    event_counts = trace.get("event_type_counts")
+    if isinstance(event_counts, dict):
+        for key, value in event_counts.items():
+            event_type = str(key or "").strip()
+            if to_int(value, 0) > 0 and event_type not in _CODEX_STARTUP_ONLY_EVENT_TYPES:
+                return True
+
+    summaries = trace.get("summaries")
+    if isinstance(summaries, list):
+        for item in summaries:
+            summary = str(item or "").strip()
+            if not summary:
+                continue
+            event_type = summary.split("|", 1)[0].strip()
+            if event_type not in _CODEX_STARTUP_ONLY_EVENT_TYPES:
+                return True
+
+    return False
+
+
+def _codex_trace_is_startup_stall(trace: Dict[str, Any]) -> bool:
+    if to_int(trace.get("total_tokens"), 0) > 0:
+        return False
+    return not _codex_trace_has_work_progress(trace)
+
+
 def _detect_offtrack_rollout(trace: Dict[str, Any], artifact_only_paths: str = "") -> str:
     text = _trace_summaries_text(trace)
     if artifact_only_paths:
@@ -1962,6 +2026,7 @@ def _run_codex_task(
     *,
     wrapper_recovery_attempt: int = 0,
     model_compatibility_recovery_attempt: int = 0,
+    startup_stall_recovery_attempt: int = 0,
     no_edit_recovery_attempt: int = 0,
     rollout_recovery_attempt: int = 0,
     model_override: Optional[str] = None,
@@ -2456,6 +2521,7 @@ def _run_codex_task(
                     retry_guidance,
                     wrapper_recovery_attempt=wrapper_recovery_attempt,
                     model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
+                    startup_stall_recovery_attempt=startup_stall_recovery_attempt,
                     no_edit_recovery_attempt=no_edit_recovery_attempt,
                     rollout_recovery_attempt=rollout_recovery_attempt + 1,
                     model_override=model_override,
@@ -2474,9 +2540,58 @@ def _run_codex_task(
                 "stderr": _truncate(f"{detail}\n{stderr}".strip()),
                 "exitCode": 124,
                 "usage": usage,
+                "cooldownMs": _NO_PUBLISHABLE_FAILURE_COOLDOWN_MS,
             }
 
         if no_edit_watchdog_fired:
+            startup_stall = _codex_trace_is_startup_stall(stdout_trace)
+            if startup_stall and startup_stall_recovery_attempt < _MAX_STARTUP_STALL_RECOVERY_ATTEMPTS:
+                retry_guidance = [
+                    *supplemental_guidance,
+                    _build_startup_stall_recovery_guidance(trace_excerpt),
+                ]
+                log.warning(
+                    "Codex emitted only startup events before the no-edit watchdog; "
+                    "restarting Codex once before classifying the job terminally."
+                )
+                retry_result = _run_codex_task(
+                    repo,
+                    instruction,
+                    retry_guidance,
+                    wrapper_recovery_attempt=wrapper_recovery_attempt,
+                    model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
+                    startup_stall_recovery_attempt=startup_stall_recovery_attempt + 1,
+                    no_edit_recovery_attempt=no_edit_recovery_attempt,
+                    rollout_recovery_attempt=rollout_recovery_attempt,
+                    model_override=model_override,
+                    baseline_changes=baseline_snapshot,
+                )
+                retry_result["usage"] = _merge_usage_records(usage, retry_result.get("usage"))
+                if retry_result.get("ok"):
+                    recovered_stdout = str(retry_result.get("stdout") or "").strip()
+                    retry_result["stdout"] = _truncate(
+                        (
+                            "Recovered after the first Codex subprocess stalled before emitting "
+                            f"assistant/tool progress.\n\n{recovered_stdout}"
+                        ).strip()
+                    )
+                return retry_result
+            if startup_stall:
+                detail = (
+                    "Codex subprocess started but did not emit assistant, tool, reasoning, "
+                    "or usage progress before the startup watchdog."
+                )
+                if trace_excerpt:
+                    detail = f"{detail}\n{trace_excerpt}"
+                return {
+                    "ok": False,
+                    "summary": "openai_codex stalled before first response",
+                    "stdout": _truncate(stdout),
+                    "stderr": _truncate(f"{detail}\n{stderr}".strip()),
+                    "exitCode": 124,
+                    "usage": usage,
+                    "cooldownMs": _NO_PUBLISHABLE_FAILURE_COOLDOWN_MS,
+                }
             if no_edit_recovery_attempt < _MAX_NO_EDIT_RECOVERY_ATTEMPTS:
                 retry_guidance = [
                     *supplemental_guidance,
@@ -2491,6 +2606,7 @@ def _run_codex_task(
                     retry_guidance,
                     wrapper_recovery_attempt=wrapper_recovery_attempt,
                     model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
+                    startup_stall_recovery_attempt=startup_stall_recovery_attempt,
                     no_edit_recovery_attempt=no_edit_recovery_attempt + 1,
                     rollout_recovery_attempt=rollout_recovery_attempt,
                     model_override=model_override,
@@ -2506,6 +2622,7 @@ def _run_codex_task(
                 "stderr": _truncate(f"{detail}\n{stderr}".strip()),
                 "exitCode": 124,
                 "usage": usage,
+                "cooldownMs": _NO_PUBLISHABLE_FAILURE_COOLDOWN_MS,
             }
 
         if timed_out:
@@ -2565,6 +2682,7 @@ def _run_codex_task(
                     "stderr": _truncate(f"{detail}\n{stderr}".strip()),
                     "exitCode": 124,
                     "usage": usage,
+                    "cooldownMs": _NO_PUBLISHABLE_FAILURE_COOLDOWN_MS,
                 }
             artifact_only_paths = _describe_non_publishable_paths(changed_paths, baseline_snapshot)
             if artifact_only_paths:
@@ -2583,6 +2701,7 @@ def _run_codex_task(
                 "stderr": _truncate(f"{detail}\n{stderr}".strip()),
                 "exitCode": 124,
                 "usage": usage,
+                "cooldownMs": _NO_PUBLISHABLE_FAILURE_COOLDOWN_MS,
             }
 
         last_message = _read_text_if_exists(last_message_path)
@@ -2683,6 +2802,7 @@ def _run_codex_task(
                         ],
                         wrapper_recovery_attempt=wrapper_recovery_attempt + 1,
                         model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
+                        startup_stall_recovery_attempt=startup_stall_recovery_attempt,
                         no_edit_recovery_attempt=no_edit_recovery_attempt,
                         rollout_recovery_attempt=rollout_recovery_attempt,
                         model_override=model_override,
@@ -2797,6 +2917,7 @@ def _run_codex_task(
                     effective_supplemental_guidance,
                     wrapper_recovery_attempt=wrapper_recovery_attempt,
                     model_compatibility_recovery_attempt=model_compatibility_recovery_attempt + 1,
+                    startup_stall_recovery_attempt=startup_stall_recovery_attempt,
                     no_edit_recovery_attempt=no_edit_recovery_attempt,
                     rollout_recovery_attempt=rollout_recovery_attempt,
                     model_override=LEGACY_CODEX_MODEL_FALLBACK,

package/runtime/sandbox/apps/workerpals/src/backends/openai_codex/test_openai_codex_runtime_config.py

@@ -229,6 +229,21 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
             "xhigh",
         )
 
+    def test_background_autonomy_uses_short_no_edit_and_rollout_watchdogs(self) -> None:
+        prompt = (
+            "Task planning contract from PushPals:\n"
+            "- Planning summary: intent=code_change, risk=low, priority=background\n"
+            "Make one narrow repo-native patch and avoid broad discovery.\n"
+        )
+
+        no_edit = _resolve_no_edit_watchdog_seconds(prompt, 1200)
+        self.assertEqual(no_edit, 120)
+        self.assertEqual(
+            _resolve_no_edit_watchdog_seconds(prompt, 1200, recovery_attempt=1),
+            90,
+        )
+        self.assertEqual(_resolve_rollout_watchdog_seconds(prompt, 1200, no_edit), 90)
+
     def test_runtime_config_prefers_explicit_config_dir_override(self) -> None:
         import executor_base
 
@@ -1014,6 +1029,159 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertNotIn("broad/noisy", str(result.get("summary") or ""))
         self.assertNotIn("too broad/noisy", str(result.get("stderr") or ""))
 
+    def test_run_codex_task_retries_once_when_codex_stalls_before_first_response(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-startup-stall-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# startup stall repo\n", encoding="utf-8")
+            subprocess.run(["git", "init"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "config", "user.name", "PushPals Test"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(
+                ["git", "config", "user.email", "pushpals-tests@example.com"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(["git", "add", "README.md"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "commit", "-m", "chore: seed startup stall repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            stub_path = Path(temp_dir) / "fake_codex_startup_stall.py"
+            stub_path.write_text(
+                "\n".join(
+                    [
+                        "from pathlib import Path",
+                        "import json",
+                        "import sys",
+                        "import time",
+                        "",
+                        "argv = sys.argv[1:]",
+                        "last_message_path = None",
+                        "for index, arg in enumerate(argv):",
+                        "    if arg == '--output-last-message' and index + 1 < len(argv):",
+                        "        last_message_path = argv[index + 1]",
+                        "        break",
+                        "",
+                        "prompt = sys.stdin.read()",
+                        "if 'Codex startup-stall recovery' in prompt:",
+                        "    Path('src').mkdir(exist_ok=True)",
+                        "    Path('src/startup-stall-recovered.txt').write_text('patched after restart\\n', encoding='utf-8')",
+                        "    if last_message_path:",
+                        "        Path(last_message_path).write_text('Patched after Codex startup-stall recovery.', encoding='utf-8')",
+                        "    print(json.dumps({'type': 'item.completed', 'message': 'Patched after Codex startup-stall recovery.'}), flush=True)",
+                        "    sys.exit(0)",
+                        "",
+                        "print(json.dumps({'type': 'thread.started'}), flush=True)",
+                        "print(json.dumps({'type': 'turn.started'}), flush=True)",
+                        "time.sleep(10)",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+
+            env_overrides = {
+                "PUSHPALS_OPENAI_CODEX_BIN_JSON": json.dumps([sys.executable, str(stub_path)]),
+                "PUSHPALS_OPENAI_CODEX_AUTH_MODE": "api_key",
+                "OPENAI_API_KEY": "pushpals-startup-stall-test-key",
+                "WORKERPALS_OPENAI_CODEX_JSON": "true",
+                "WORKERPALS_OPENAI_CODEX_TIMEOUT_S": "20",
+                "WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": "1",
+                "WORKERPALS_OPENAI_CODEX_PROGRESS_LOG_INTERVAL_S": "1",
+            }
+            with mock.patch.dict(os.environ, env_overrides, clear=False):
+                result = _run_codex_task(
+                    str(repo),
+                    "Rename one misleading test fixture constant and update the related assertions.",
+                    [],
+                )
+
+        self.assertTrue(result.get("ok"), result)
+        self.assertEqual(result.get("exitCode"), 0)
+        stdout = str(result.get("stdout") or "")
+        self.assertIn("Recovered after the first Codex subprocess stalled", stdout)
+        self.assertIn("Patched after Codex startup-stall recovery", stdout)
+        self.assertIn("src/", stdout)
+
+    def test_run_codex_task_reports_startup_stall_when_restart_also_never_responds(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-startup-stall-fail-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# startup stall failure repo\n", encoding="utf-8")
+            subprocess.run(["git", "init"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "config", "user.name", "PushPals Test"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(
+                ["git", "config", "user.email", "pushpals-tests@example.com"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            subprocess.run(["git", "add", "README.md"], cwd=repo, check=True, capture_output=True, text=True)
+            subprocess.run(
+                ["git", "commit", "-m", "chore: seed startup stall failure repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            stub_path = Path(temp_dir) / "fake_codex_startup_stall_fail.py"
+            stub_path.write_text(
+                "\n".join(
+                    [
+                        "import json",
+                        "import sys",
+                        "import time",
+                        "",
+                        "sys.stdin.read()",
+                        "print(json.dumps({'type': 'thread.started'}), flush=True)",
+                        "print(json.dumps({'type': 'turn.started'}), flush=True)",
+                        "time.sleep(10)",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+
+            env_overrides = {
+                "PUSHPALS_OPENAI_CODEX_BIN_JSON": json.dumps([sys.executable, str(stub_path)]),
+                "PUSHPALS_OPENAI_CODEX_AUTH_MODE": "api_key",
+                "OPENAI_API_KEY": "pushpals-startup-stall-fail-test-key",
+                "WORKERPALS_OPENAI_CODEX_JSON": "true",
+                "WORKERPALS_OPENAI_CODEX_TIMEOUT_S": "20",
+                "WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": "1",
+                "WORKERPALS_OPENAI_CODEX_PROGRESS_LOG_INTERVAL_S": "1",
+            }
+            with mock.patch.dict(os.environ, env_overrides, clear=False):
+                result = _run_codex_task(
+                    str(repo),
+                    "Rename one misleading test fixture constant and update the related assertions.",
+                    [],
+                )
+
+        self.assertFalse(result.get("ok"), result)
+        self.assertEqual(result.get("exitCode"), 124)
+        self.assertEqual(result.get("summary"), "openai_codex stalled before first response")
+        self.assertNotIn("no publishable", str(result.get("summary") or "").lower())
+        self.assertEqual(result.get("cooldownMs"), 600000)
+
     def test_run_codex_task_retries_once_when_no_edit_watchdog_fires(self) -> None:
         with tempfile.TemporaryDirectory(prefix="pushpals-codex-no-edit-watchdog-") as temp_dir:
             repo = Path(temp_dir) / "repo"
@@ -1156,6 +1324,7 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertFalse(result.get("ok"), result)
         self.assertEqual(result.get("exitCode"), 124)
         self.assertIn("no publishable changes", str(result.get("summary") or ""))
+        self.assertEqual(result.get("cooldownMs"), 600000)
 
     def test_run_codex_task_no_edit_watchdog_rechecks_transient_publishable_progress(self) -> None:
         with tempfile.TemporaryDirectory(prefix="pushpals-codex-no-edit-recheck-") as temp_dir:
@@ -1407,7 +1576,7 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
 
         self.assertEqual(watchdog_s, 180)
 
-    def test_no_edit_recovery_attempt_uses_patch_first_watchdog(self) -> None:
+    def test_no_edit_recovery_attempt_uses_short_patch_first_watchdog(self) -> None:
         prompt = "Investigate a broad reliability issue and make the smallest safe fix."
         with mock.patch.dict(os.environ, {"WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": ""}, clear=False):
             first_attempt_s = _resolve_no_edit_watchdog_seconds(prompt, 1200)
@@ -1418,7 +1587,7 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
             )
 
         self.assertEqual(first_attempt_s, 480)
-        self.assertEqual(recovery_attempt_s, 180)
+        self.assertEqual(recovery_attempt_s, 90)
 
     def test_explicit_no_edit_watchdog_override_still_controls_recovery_attempts(self) -> None:
         with mock.patch.dict(os.environ, {"WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": "300"}, clear=False):
@@ -1650,6 +1819,7 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("rollout coach", str(result.get("summary") or ""))
         self.assertIn("broad/noisy", str(result.get("stderr") or ""))
         self.assertIn("area0", str(result.get("stderr") or ""))
+        self.assertEqual(result.get("cooldownMs"), 600000)
 
     def test_run_codex_task_timeout_reports_artifact_only_changes(self) -> None:
         with tempfile.TemporaryDirectory(prefix="pushpals-codex-artifact-timeout-") as temp_dir:

package/runtime/sandbox/apps/workerpals/src/workerpals_main.ts

@@ -450,7 +450,7 @@ function mergeWorkerDiagnostics(
 function inferWorkerTerminalFailureClass(result: JobResult): string {
   if (result.ok) return "success";
   const text = `${result.summary ?? ""}\n${result.stderr ?? ""}\n${result.stdout ?? ""}`.toLowerCase();
-  if (/timed out|timeout|signal 15|terminated|exit 143|exit 137/.test(text)) return "timeout";
+  if (/timed out|timeout|signal 15|terminated|exit 143|exit 137|stalled before first response|startup stall/.test(text)) return "timeout";
   if (/no publishable|non-publishable|node_modules/.test(text)) return "artifact_only_no_publishable_patch";
   if (/validationgate|validation/.test(text)) return "validation";
   if (/scopegate|scope/.test(text)) return "scope";