@pushpalsdev/cli 1.1.21 → 1.1.23

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.21",
+  "version": "1.1.23",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

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

@@ -8,6 +8,7 @@ that the TypeScript host parses.
 from __future__ import annotations
 
 import json
+import hashlib
 import os
 import re
 from shutil import rmtree, which
@@ -103,11 +104,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 +663,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
@@ -695,9 +714,39 @@ def _resolve_rollout_watchdog_seconds(
     return max(90, min(default_s, max(90, communicate_timeout_s - 60)))
 
 
-def _describe_non_publishable_paths(changed_paths: List[str], baseline_snapshot: List[str]) -> str:
-    delta = [p for p in changed_paths if p not in baseline_snapshot]
-    inspected = delta if delta else changed_paths
+def _baseline_snapshot_paths(baseline_snapshot: Any) -> List[str]:
+    if isinstance(baseline_snapshot, dict):
+        return [str(path) for path in baseline_snapshot.keys()]
+    if isinstance(baseline_snapshot, list):
+        return [str(path) for path in baseline_snapshot]
+    return []
+
+
+def _paths_changed_after_baseline(
+    repo: str,
+    changed_paths: List[str],
+    baseline_snapshot: Any,
+) -> List[str]:
+    baseline_paths = set(_baseline_snapshot_paths(baseline_snapshot))
+    if not baseline_paths:
+        return list(changed_paths)
+
+    delta: List[str] = []
+    baseline_fingerprints = baseline_snapshot if isinstance(baseline_snapshot, dict) else {}
+    for path in changed_paths:
+        if path not in baseline_paths:
+            delta.append(path)
+            continue
+        if baseline_fingerprints:
+            current_fingerprint = _changed_path_fingerprint(repo, path)
+            if current_fingerprint != str(baseline_fingerprints.get(path) or ""):
+                delta.append(path)
+    return delta
+
+
+def _describe_non_publishable_paths(changed_paths: List[str], baseline_snapshot: Any) -> str:
+    baseline_paths = set(_baseline_snapshot_paths(baseline_snapshot))
+    inspected = [p for p in changed_paths if p not in baseline_paths] if baseline_paths else changed_paths
     non_publishable = [p for p in inspected if not _is_publishable_changed_path(p)]
     if not non_publishable:
         return ""
@@ -707,6 +756,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.",
@@ -1661,13 +1717,127 @@ def _is_publishable_changed_path(path: str) -> bool:
     return not re.search(r"(^|/)(outputs|node_modules|\.worktrees|\.codex|dist|build|coverage)(/|$)", normalized)
 
 
-def _codex_changed_paths(repo: str, baseline_snapshot: List[str]) -> Tuple[List[str], List[str], List[str]]:
+def _filesystem_fingerprint(repo: str, raw_path: str) -> str:
+    root = Path(repo)
+    target = (root / raw_path).resolve()
+    try:
+        root_resolved = root.resolve()
+        common = os.path.commonpath([str(root_resolved), str(target)])
+        if common != str(root_resolved):
+            return "outside-repo"
+    except Exception:
+        return "unresolved"
+    digest = hashlib.sha256()
+    if not target.exists():
+        return "missing"
+    if target.is_file():
+        digest.update(b"file\0")
+        try:
+            digest.update(str(target.stat().st_size).encode("utf-8"))
+            with target.open("rb") as handle:
+                while True:
+                    chunk = handle.read(1024 * 1024)
+                    if not chunk:
+                        break
+                    digest.update(chunk)
+        except Exception as exc:
+            digest.update(f"read-error:{type(exc).__name__}:{exc}".encode("utf-8", errors="replace"))
+        return digest.hexdigest()
+    if target.is_dir():
+        digest.update(b"dir\0")
+        files_seen = 0
+        try:
+            for dirpath, dirnames, filenames in os.walk(target):
+                dirnames.sort()
+                filenames.sort()
+                for filename in filenames:
+                    if files_seen >= 128:
+                        digest.update(b"\0truncated")
+                        return digest.hexdigest()
+                    child = Path(dirpath) / filename
+                    try:
+                        rel = child.relative_to(root_resolved).as_posix()
+                    except Exception:
+                        rel = child.name
+                    digest.update(rel.encode("utf-8", errors="replace"))
+                    digest.update(b"\0")
+                    digest.update(str(child.stat().st_size).encode("utf-8"))
+                    digest.update(b"\0")
+                    try:
+                        with child.open("rb") as handle:
+                            digest.update(handle.read(64 * 1024))
+                    except Exception as exc:
+                        digest.update(f"read-error:{type(exc).__name__}:{exc}".encode("utf-8", errors="replace"))
+                    files_seen += 1
+        except Exception as exc:
+            digest.update(f"walk-error:{type(exc).__name__}:{exc}".encode("utf-8", errors="replace"))
+        return digest.hexdigest()
+    return "special"
+
+
+def _changed_path_fingerprint(repo: str, path: str) -> str:
+    normalized = str(path or "").strip()
+    if not normalized:
+        return ""
+    digest = hashlib.sha256()
+    digest.update(normalized.replace("\\", "/").encode("utf-8", errors="replace"))
+    digest.update(b"\0fs\0")
+    digest.update(_filesystem_fingerprint(repo, normalized).encode("utf-8", errors="replace"))
+    return digest.hexdigest()
+
+
+def _capture_git_change_snapshot(repo: str) -> Dict[str, str]:
+    return {path: _changed_path_fingerprint(repo, path) for path in summarize_git_changes(repo)}
+
+
+def _normalize_baseline_snapshot(repo: str, baseline_changes: Any) -> Dict[str, str]:
+    if isinstance(baseline_changes, dict):
+        return {
+            str(path): str(fingerprint)
+            for path, fingerprint in baseline_changes.items()
+            if str(path or "").strip()
+        }
+    if isinstance(baseline_changes, list):
+        return {
+            str(path): _changed_path_fingerprint(repo, str(path))
+            for path in baseline_changes
+            if str(path or "").strip()
+        }
+    return _capture_git_change_snapshot(repo)
+
+
+def _codex_changed_paths(repo: str, baseline_snapshot: Any) -> Tuple[List[str], List[str], List[str]]:
     changed_paths = summarize_git_changes(repo)
-    delta = [p for p in changed_paths if p not in baseline_snapshot]
-    effective = [p for p in (delta if delta else changed_paths) if _is_publishable_changed_path(p)]
+    delta = _paths_changed_after_baseline(repo, changed_paths, baseline_snapshot)
+    effective = [p for p in delta if _is_publishable_changed_path(p)]
     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],
@@ -1801,7 +1971,7 @@ def _run_codex_task(
         prompt,
         model,
     )
-    baseline_snapshot = list(baseline_changes) if baseline_changes is not None else summarize_git_changes(repo)
+    baseline_snapshot = _normalize_baseline_snapshot(repo, baseline_changes)
 
     with tempfile.TemporaryDirectory(prefix="pushpals-codex-") as tmp_dir:
         last_message_path = Path(tmp_dir) / "codex-last-message.txt"
@@ -2028,12 +2198,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 +2251,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 +2289,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 +2375,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 +2396,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 +2450,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 +2479,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 +2524,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 +2548,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 +2579,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 +2640,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