@pushpalsdev/cli 1.1.20 → 1.1.22

package/dist/pushpals-cli.js

@@ -4299,6 +4299,25 @@ async function probeRemoteBuddySessionConsumer(serverUrl, sessionId) {
     };
   }
 }
+async function waitForRemoteBuddySessionConsumer(opts) {
+  const timeoutMs = Math.max(0, opts.timeoutMs);
+  const pollMs = Math.max(50, opts.pollMs ?? DEFAULT_RUNTIME_BOOT_POLL_MS);
+  const nowFn = opts.nowFn ?? Date.now;
+  const deadline = nowFn() + timeoutMs;
+  let lastHealth = {
+    ok: false,
+    detail: `No connected RemoteBuddy session consumer found for session ${opts.sessionId}`
+  };
+  while (true) {
+    lastHealth = await (opts.probeFn ?? probeRemoteBuddySessionConsumer)(opts.serverUrl, opts.sessionId);
+    if (lastHealth.ok)
+      return lastHealth;
+    const remainingMs = deadline - nowFn();
+    if (remainingMs <= 0)
+      return lastHealth;
+    await (opts.sleepFn ?? Bun.sleep)(Math.min(pollMs, remainingMs));
+  }
+}
 async function probeSourceControlManager(port) {
   if (!Number.isFinite(port) || port <= 0)
     return false;
@@ -5831,7 +5850,11 @@ async function main() {
       process.exit(1);
     }
   }
-  remoteBuddyConsumerHealth = await probeRemoteBuddySessionConsumer(serverUrl, activeSessionId);
+  remoteBuddyConsumerHealth = autoStartedServiceManager ? await waitForRemoteBuddySessionConsumer({
+    serverUrl,
+    sessionId: activeSessionId,
+    timeoutMs: DEFAULT_REMOTEBUDDY_CONSUMER_STARTUP_GRACE_MS
+  }) : await probeRemoteBuddySessionConsumer(serverUrl, activeSessionId);
   if (!serverHealthy) {
     console.error(`[pushpals] Server is unavailable at ${serverUrl}.`);
     process.exit(1);
@@ -6086,6 +6109,7 @@ if (import.meta.main) {
 }
 export {
   waitForWorkerpalCapacity,
+  waitForRemoteBuddySessionConsumer,
   startEmbeddedMonitoringHub,
   shutdownEmbeddedServiceManagerGracefully,
   shouldUseRemoteBuddySilentStartupFallback,

package/package.json

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

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

@@ -103,11 +103,14 @@ _VALID_REASONING_EFFORTS = {"low", "medium", "high", "xhigh"}
 _MAX_WRAPPER_RECOVERY_ATTEMPTS = 2
 _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_NO_EDIT_RECOVERY_ATTEMPTS = 1
 _MAX_ROLLOUT_RECOVERY_ATTEMPTS = 1
 _DEFAULT_NO_EDIT_WATCHDOG_S = 480
 _SMALL_TASK_NO_EDIT_WATCHDOG_S = 360
 _WEB_REVIEW_NO_EDIT_WATCHDOG_S = 240
+_DEFAULT_NO_EDIT_RECHECK_S = 120
 _DEFAULT_ROLLOUT_WATCHDOG_S = 300
 _SMALL_TASK_ROLLOUT_WATCHDOG_S = 240
 _WEB_REVIEW_ROLLOUT_WATCHDOG_S = 180
@@ -659,6 +662,21 @@ def _resolve_no_edit_watchdog_seconds(
     return max(120, min(default_s, max(120, communicate_timeout_s - 60)))
 
 
+def _resolve_no_edit_recheck_seconds(communicate_timeout_s: Optional[int]) -> int:
+    raw = os.environ.get("WORKERPALS_OPENAI_CODEX_NO_EDIT_RECHECK_S", "").strip()
+    if raw:
+        parsed = _to_positive_int(raw)
+        if parsed is None:
+            log.info(
+                f"Invalid WORKERPALS_OPENAI_CODEX_NO_EDIT_RECHECK_S={raw!r}; using default no-edit recheck interval."
+            )
+        else:
+            upper = max(1, (communicate_timeout_s or parsed + 1) - 1)
+            return max(1, min(parsed, upper))
+    upper = max(1, (communicate_timeout_s or _DEFAULT_NO_EDIT_RECHECK_S + 1) - 1)
+    return max(1, min(_DEFAULT_NO_EDIT_RECHECK_S, upper))
+
+
 def _looks_like_web_review_prompt(prompt: str) -> bool:
     text = str(prompt or "").lower()
     return "repo-native web review" in text or "web review path" in text
@@ -707,6 +725,13 @@ def _describe_non_publishable_paths(changed_paths: List[str], baseline_snapshot:
     return listed
 
 
+def _describe_publishable_paths(paths: List[str]) -> str:
+    listed = ", ".join(paths[:8])
+    if len(paths) > 8:
+        listed = f"{listed}, ..."
+    return listed
+
+
 def _build_no_edit_recovery_guidance(trace_excerpt: str, artifact_only_paths: str = "") -> str:
     lines = [
         "No-edit watchdog recovery: the previous Codex attempt spent too much of the execution budget without producing publishable file changes.",
@@ -1668,6 +1693,31 @@ def _codex_changed_paths(repo: str, baseline_snapshot: List[str]) -> Tuple[List[
     return changed_paths, delta, effective
 
 
+def _changed_path_top_level(path: str) -> str:
+    raw = str(path or "").replace("\\", "/").strip()
+    is_top_level_directory = raw.endswith("/")
+    normalized = raw.strip("/")
+    if not normalized:
+        return ""
+    parts = [part for part in normalized.split("/") if part]
+    if len(parts) > 1 or is_top_level_directory:
+        return parts[0]
+    return "<repo-root>"
+
+
+def _has_credible_shell_wrapper_progress(effective_paths: List[str]) -> bool:
+    if not effective_paths:
+        return False
+    if len(effective_paths) > _MAX_CREDIBLE_WRAPPER_LOOP_CHANGED_PATHS:
+        return False
+    top_levels = {
+        top_level
+        for top_level in (_changed_path_top_level(path) for path in effective_paths)
+        if top_level
+    }
+    return len(top_levels) <= _MAX_CREDIBLE_WRAPPER_LOOP_TOP_LEVELS
+
+
 def _build_success_stdout(
     *,
     effective_paths: List[str],
@@ -2028,12 +2078,14 @@ def _run_codex_task(
             rollout_watchdog_fired = False
             rollout_watchdog_reason = ""
             rollout_artifact_only_paths = ""
+            rollout_watchdog_retryable = True
             command_policy_rejection_loop = False
             no_edit_watchdog_s = (
                 _resolve_no_edit_watchdog_seconds(prompt, communicate_timeout_s)
                 if no_edit_recovery_attempt <= _MAX_NO_EDIT_RECOVERY_ATTEMPTS
                 else None
             )
+            no_edit_recheck_s = _resolve_no_edit_recheck_seconds(communicate_timeout_s)
             rollout_watchdog_s = (
                 _resolve_rollout_watchdog_seconds(
                     prompt,
@@ -2079,16 +2131,36 @@ def _run_codex_task(
                         )
                         _terminate_active_child()
                         break
-                    no_edit_deadline = None
+                    no_edit_deadline = now + float(no_edit_recheck_s)
+                    log.info(
+                        "No-edit watchdog observed publishable-looking file changes "
+                        f"({_describe_publishable_paths(effective_paths)}); rechecking in "
+                        f"{int(no_edit_recheck_s)}s to ensure the worker keeps durable PR content."
+                    )
 
                 if rollout_deadline is not None and now >= rollout_deadline:
                     changed_paths, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
-                    if not effective_paths:
-                        with trace_lock:
-                            live_trace = dict(stdout_trace_state)
-                            summaries = stdout_trace_state.get("summaries")
-                            if isinstance(summaries, list):
-                                live_trace["summaries"] = list(summaries)
+                    with trace_lock:
+                        live_trace = dict(stdout_trace_state)
+                        summaries = stdout_trace_state.get("summaries")
+                        if isinstance(summaries, list):
+                            live_trace["summaries"] = list(summaries)
+                    if effective_paths:
+                        small_or_web_task = (
+                            _looks_like_small_task_prompt(instruction)
+                            or _looks_like_web_review_prompt(instruction)
+                            or _looks_like_small_task_prompt(prompt)
+                            or _looks_like_web_review_prompt(prompt)
+                        )
+                        if small_or_web_task and not _has_credible_shell_wrapper_progress(effective_paths):
+                            rollout_watchdog_reason = (
+                                "publishable-looking changed paths are broad/noisy for a small task: "
+                                f"{_describe_publishable_paths(effective_paths)}"
+                            )
+                            rollout_watchdog_retryable = False
+                        else:
+                            rollout_deadline = None
+                    else:
                         rollout_artifact_only_paths = _describe_non_publishable_paths(
                             changed_paths,
                             baseline_snapshot,
@@ -2097,18 +2169,23 @@ def _run_codex_task(
                             live_trace,
                             rollout_artifact_only_paths,
                         )
-                        if rollout_watchdog_reason:
-                            rollout_watchdog_fired = True
-                            artifact_detail = (
-                                f" Artifact-only dirty paths: {rollout_artifact_only_paths}."
-                                if rollout_artifact_only_paths
-                                else ""
-                            )
-                            log.info(
-                                f"Rollout coach fired after {int(rollout_watchdog_s or 0)}s: {rollout_watchdog_reason}.{artifact_detail} Retrying with course-correction guidance."
-                            )
-                            _terminate_active_child()
-                            break
+                    if rollout_watchdog_reason:
+                        rollout_watchdog_fired = True
+                        artifact_detail = (
+                            f" Artifact-only dirty paths: {rollout_artifact_only_paths}."
+                            if rollout_artifact_only_paths
+                            else ""
+                        )
+                        action = (
+                            "Retrying with course-correction guidance."
+                            if rollout_watchdog_retryable
+                            else "Failing fast instead of retrying on top of a broad/noisy diff."
+                        )
+                        log.info(
+                            f"Rollout coach fired after {int(rollout_watchdog_s or 0)}s: {rollout_watchdog_reason}.{artifact_detail} {action}"
+                        )
+                        _terminate_active_child()
+                        break
 
                 with trace_lock:
                     wrapper_rejections = to_int(wrapper_rejection_state.get("count"), 0)
@@ -2178,7 +2255,7 @@ def _run_codex_task(
                     rejected_shell_wrappers.append(text)
 
         if rollout_watchdog_fired:
-            if rollout_recovery_attempt < _MAX_ROLLOUT_RECOVERY_ATTEMPTS:
+            if rollout_watchdog_retryable and rollout_recovery_attempt < _MAX_ROLLOUT_RECOVERY_ATTEMPTS:
                 retry_guidance = [
                     *supplemental_guidance,
                     _build_rollout_recovery_guidance(
@@ -2199,7 +2276,7 @@ def _run_codex_task(
                     baseline_changes=baseline_snapshot,
                 )
             detail = (
-                "Codex trajectory remained off-track after rollout coach recovery: "
+                "Codex trajectory remained off-track or too broad for safe recovery: "
                 f"{rollout_watchdog_reason or 'no publishable progress'}."
             )
             if trace_excerpt:
@@ -2253,8 +2330,9 @@ def _run_codex_task(
             )
             if trace_excerpt:
                 detail = f"{detail}\n{trace_excerpt}"
-            _, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
-            if effective_paths:
+            changed_paths, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
+            credible_partial_patch = _has_credible_shell_wrapper_progress(effective_paths)
+            if effective_paths and credible_partial_patch:
                 last_message = _read_text_if_exists(last_message_path)
                 log_git_status(repo, log)
                 prefix = (
@@ -2281,7 +2359,27 @@ def _run_codex_task(
                     "exitCode": 0,
                     "usage": usage,
                 }
-            changed_paths, _, _ = _codex_changed_paths(repo, baseline_snapshot)
+            if effective_paths:
+                listed = _describe_publishable_paths(effective_paths)
+                log.warning(
+                    "Codex reached the execution timeout with a broad/noisy changed-path set "
+                    f"({len(effective_paths)} publishable-looking path(s)); refusing to spend "
+                    "additional gate budget on a likely incomplete patch."
+                )
+                detail = (
+                    f"{detail}\nPublishable-looking changed paths at timeout were too broad/noisy "
+                    f"to preserve as a partial patch ({len(effective_paths)} path(s): {listed}). "
+                    "The executor is failing fast so the scheduler can replan instead of running "
+                    "expensive validation on a likely incomplete update."
+                )
+                return {
+                    "ok": False,
+                    "summary": "openai_codex timed out with broad/noisy publishable-looking changes",
+                    "stdout": _truncate(stdout),
+                    "stderr": _truncate(f"{detail}\n{stderr}".strip()),
+                    "exitCode": 124,
+                    "usage": usage,
+                }
             artifact_only_paths = _describe_non_publishable_paths(changed_paths, baseline_snapshot)
             if artifact_only_paths:
                 detail = (
@@ -2306,6 +2404,7 @@ def _run_codex_task(
 
         if command_policy_rejection_loop:
             _, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
+            credible_progress = _has_credible_shell_wrapper_progress(effective_paths)
             if effective_paths:
                 policy_signal = _detect_codex_workaround_signal(last_message)
                 if not policy_signal and not last_message.strip():
@@ -2329,6 +2428,7 @@ def _run_codex_task(
                         "usage": usage,
                     }
 
+            if effective_paths and credible_progress:
                 command_lines = (
                     "\n".join(f"- {command}" for command in rejected_shell_wrappers[:6])
                     if rejected_shell_wrappers
@@ -2359,6 +2459,13 @@ def _run_codex_task(
                     "usage": usage,
                 }
 
+            if effective_paths:
+                log.warning(
+                    "Codex hit a shell-wrapper rejection loop with a broad/noisy changed-path set "
+                    f"({len(effective_paths)} publishable-looking path(s)); retrying before handing "
+                    "the patch to QualityGate."
+                )
+
             if wrapper_recovery_attempt < _MAX_WRAPPER_RECOVERY_ATTEMPTS:
                 hard_recovery = wrapper_recovery_attempt >= 1
                 recovery_guidance = _build_wrapper_recovery_guidance(
@@ -2413,6 +2520,36 @@ def _run_codex_task(
                             ).strip()
                         )
                     return retry_result
+            if effective_paths:
+                command_lines = (
+                    "\n".join(f"- {command}" for command in rejected_shell_wrappers[:6])
+                    if rejected_shell_wrappers
+                    else "- (no command details captured)"
+                )
+                log.warning(
+                    "Codex exhausted shell-wrapper recovery attempts with file changes still present; "
+                    "returning the patch to QualityGate for final assessment."
+                )
+                return {
+                    "ok": True,
+                    "summary": (
+                        "Executed task and modified "
+                        f"{len(effective_paths)} file(s) before shell-wrapper command rejections"
+                    ),
+                    "stdout": _build_success_stdout(
+                        effective_paths=effective_paths,
+                        last_message=last_message,
+                        trace_excerpt=trace_excerpt,
+                        prefix=(
+                            "Codex produced file changes but exhausted command-router shell-wrapper "
+                            "recovery attempts. The patch is being handed to ValidationGate/CriticGate for "
+                            f"normal assessment.\nRejected commands:\n{command_lines}"
+                        ),
+                    ),
+                    "stderr": "",
+                    "exitCode": 0,
+                    "usage": usage,
+                }
             command_lines = (
                 "\n".join(f"- {command}" for command in rejected_shell_wrappers[:6])
                 if rejected_shell_wrappers