@pushpalsdev/cli 1.1.36 → 1.1.37

package/package.json

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

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

@@ -2519,16 +2519,14 @@ def _run_codex_task(
                 if no_edit_watchdog_s is not None
                 else None
             )
-            no_edit_command_grace_cap_deadline = (
-                started_at + float(no_edit_watchdog_s + no_edit_command_grace_s)
-                if no_edit_watchdog_s is not None and no_edit_command_grace_s is not None
-                else None
-            )
             rollout_deadline = (
                 started_at + float(rollout_watchdog_s)
                 if rollout_watchdog_s is not None
                 else None
             )
+            publishable_progress_seen_at: Optional[float] = None
+            publishable_progress_finalized = False
+            publishable_progress_paths: List[str] = []
 
             while proc.poll() is None:
                 now = time.monotonic()
@@ -2605,11 +2603,6 @@ def _run_codex_task(
                                 command_grace_deadline = last_command_activity_at + float(
                                     no_edit_command_grace_s
                                 )
-                            if no_edit_command_grace_cap_deadline is not None:
-                                command_grace_deadline = min(
-                                    command_grace_deadline,
-                                    no_edit_command_grace_cap_deadline,
-                                )
                             if command_grace_deadline > now:
                                 no_edit_deadline = command_grace_deadline
                                 remaining_s = int(max(1.0, command_grace_deadline - now))
@@ -2645,6 +2638,22 @@ def _run_codex_task(
                             )
                         _terminate_active_child()
                         break
+                    if publishable_progress_seen_at is None:
+                        publishable_progress_seen_at = now
+                        publishable_progress_paths = list(effective_paths)
+                    elif _has_credible_shell_wrapper_progress(effective_paths):
+                        publishable_progress_paths = list(effective_paths)
+                        publishable_age_s = now - publishable_progress_seen_at
+                        if publishable_age_s >= float(no_edit_recheck_s):
+                            publishable_progress_finalized = True
+                            log.info(
+                                "No-edit watchdog observed durable publishable file changes "
+                                f"({_describe_publishable_paths(effective_paths)}) for "
+                                f"{int(publishable_age_s)}s; stopping Codex early so "
+                                "QualityGate/ValidationGate can use the remaining budget."
+                            )
+                            _terminate_active_child()
+                            break
                     no_edit_deadline = now + float(no_edit_recheck_s)
                     log.info(
                         "No-edit watchdog observed publishable-looking file changes "
@@ -2806,6 +2815,35 @@ def _run_codex_task(
                 "cooldownMs": _NO_PUBLISHABLE_FAILURE_COOLDOWN_MS,
             }
 
+        if publishable_progress_finalized:
+            changed_paths, _, effective_paths = _codex_changed_paths(repo, baseline_snapshot)
+            effective_paths = effective_paths or publishable_progress_paths
+            last_message = _read_text_if_exists(last_message_path)
+            log_git_status(repo, log)
+            prefix = (
+                "Codex produced durable publishable file changes. PushPals stopped the "
+                "Codex child early to preserve validation and revision budget; the normal "
+                "QualityGate/ValidationGate will catch any incomplete edit."
+            )
+            return {
+                "ok": True,
+                "summary": (
+                    "openai_codex stopped after durable publishable progress "
+                    f"({len(effective_paths)} file(s))"
+                ),
+                "stdout": _truncate(
+                    _build_success_stdout(
+                        effective_paths=effective_paths,
+                        last_message=last_message,
+                        trace_excerpt=trace_excerpt,
+                        prefix=prefix,
+                    )
+                ),
+                "stderr": _truncate(stderr),
+                "exitCode": 0,
+                "usage": usage,
+            }
+
         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:

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

@@ -1431,6 +1431,175 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("Patched after command-backed discovery", str(result.get("stdout") or ""))
         self.assertIn("src/", str(result.get("stdout") or ""))
 
+    def test_run_codex_task_no_edit_watchdog_extends_after_later_command_progress(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-no-edit-late-command-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# late command grace 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 late command repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            stub_path = Path(temp_dir) / "fake_codex_late_command_grace.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",
+                        "",
+                        "sys.stdin.read()",
+                        "print(json.dumps({'type': 'thread.started'}), flush=True)",
+                        "print(json.dumps({'type': 'turn.started'}), flush=True)",
+                        "print(json.dumps({'type': 'item.started', 'item': {'id': 'cmd-one', 'type': 'command_execution', 'command': 'cat README.md', 'status': 'in_progress'}}), flush=True)",
+                        "time.sleep(0.2)",
+                        "print(json.dumps({'type': 'item.completed', 'item': {'id': 'cmd-one', 'type': 'command_execution', 'command': 'cat README.md', 'status': 'completed', 'exit_code': 0}}), flush=True)",
+                        "time.sleep(2.2)",
+                        "print(json.dumps({'type': 'item.started', 'item': {'id': 'cmd-two', 'type': 'command_execution', 'command': 'ls', 'status': 'in_progress'}}), flush=True)",
+                        "time.sleep(0.2)",
+                        "print(json.dumps({'type': 'item.completed', 'item': {'id': 'cmd-two', 'type': 'command_execution', 'command': 'ls', 'status': 'completed', 'exit_code': 0}}), flush=True)",
+                        "time.sleep(2.0)",
+                        "Path('src').mkdir(exist_ok=True)",
+                        "Path('src/late-command-grace.txt').write_text('patched after later command progress\\n', encoding='utf-8')",
+                        "if last_message_path:",
+                        "    Path(last_message_path).write_text('Patched after later command progress.', encoding='utf-8')",
+                        "print(json.dumps({'type': 'item.completed', 'item': {'type': 'message', 'text': 'Patched after later command progress.'}}), flush=True)",
+                    ]
+                ),
+                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-no-edit-late-command-test-key",
+                "WORKERPALS_OPENAI_CODEX_JSON": "true",
+                "WORKERPALS_OPENAI_CODEX_TIMEOUT_S": "20",
+                "WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": "1",
+                "WORKERPALS_OPENAI_CODEX_NO_EDIT_COMMAND_GRACE_S": "3",
+                "WORKERPALS_OPENAI_CODEX_PROGRESS_LOG_INTERVAL_S": "1",
+            }
+            with mock.patch.dict(os.environ, env_overrides, clear=False):
+                result = _run_codex_task(
+                    str(repo),
+                    "Add one focused contract assertion after a later targeted read.",
+                    [],
+                )
+
+        self.assertTrue(result.get("ok"), result)
+        self.assertEqual(result.get("exitCode"), 0)
+        self.assertIn("Patched after later command progress", str(result.get("stdout") or ""))
+        self.assertIn("src/", str(result.get("stdout") or ""))
+
+    def test_run_codex_task_finalizes_after_durable_publishable_progress(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-durable-progress-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# durable progress 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 durable progress repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            stub_path = Path(temp_dir) / "fake_codex_durable_progress.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",
+                        "",
+                        "sys.stdin.read()",
+                        "print(json.dumps({'type': 'thread.started'}), flush=True)",
+                        "print(json.dumps({'type': 'turn.started'}), flush=True)",
+                        "Path('src').mkdir(exist_ok=True)",
+                        "Path('src/durable-progress.txt').write_text('durable patch\\n', encoding='utf-8')",
+                        "if last_message_path:",
+                        "    Path(last_message_path).write_text('Created durable patch and kept thinking.', encoding='utf-8')",
+                        "print(json.dumps({'type': 'item.completed', 'item': {'type': 'message', 'text': 'Created durable patch and kept thinking.'}}), 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-durable-progress-test-key",
+                "WORKERPALS_OPENAI_CODEX_JSON": "true",
+                "WORKERPALS_OPENAI_CODEX_TIMEOUT_S": "20",
+                "WORKERPALS_OPENAI_CODEX_NO_EDIT_WATCHDOG_S": "1",
+                "WORKERPALS_OPENAI_CODEX_NO_EDIT_RECHECK_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),
+                    "Make a focused patch and stop once it is durable.",
+                    [],
+                )
+
+        self.assertTrue(result.get("ok"), result)
+        self.assertEqual(result.get("exitCode"), 0)
+        self.assertIn("stopped after durable publishable progress", str(result.get("summary") or ""))
+        self.assertIn("src/", str(result.get("stdout") or ""))
+
     def test_run_codex_task_recovery_attempt_is_still_guarded_by_no_edit_watchdog(self) -> None:
         with tempfile.TemporaryDirectory(prefix="pushpals-codex-no-edit-watchdog-fail-") as temp_dir:
             repo = Path(temp_dir) / "repo"

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

@@ -335,6 +335,22 @@ export function shouldSkipCriticForDeterministicValidationRevision(opts: {
   return opts.validationRuns.some(isDeterministicFastValidationFailure);
 }
 
+export function shouldSkipCriticToPreserveRevisionBudget(opts: {
+  deterministicRequiresRevision: boolean;
+  remainingBudgetMs: number;
+  minimumRevisionBudgetMs: number;
+  criticTimeoutMs: number;
+  criticTimeoutBehavior: "skip" | "retry_once" | "block" | string;
+}): boolean {
+  if (!opts.deterministicRequiresRevision) return false;
+  const remainingBudgetMs = Math.max(0, Math.floor(opts.remainingBudgetMs));
+  const minimumRevisionBudgetMs = Math.max(0, Math.floor(opts.minimumRevisionBudgetMs));
+  const criticTimeoutMs = Math.max(0, Math.floor(opts.criticTimeoutMs));
+  const criticAttempts = opts.criticTimeoutBehavior === "retry_once" ? 2 : 1;
+  const criticWorstCaseMs = criticTimeoutMs * criticAttempts;
+  return remainingBudgetMs < minimumRevisionBudgetMs + criticWorstCaseMs;
+}
+
 export function workerAttemptRolloutScore(params: {
   executorElapsedMs: number;
   qualityElapsedMs: number;
@@ -7975,11 +7991,23 @@ export async function executeJob(
         validationOutsideTaskScope,
         validationRuns: quality.validationRuns,
       });
+    const preCriticRevisionBudget = qualityRevisionBudgetDecision({
+      jobElapsedMs: Date.now() - jobStartedAt,
+      executionBudgetMs,
+    });
+    const skipCriticForRevisionBudget = shouldSkipCriticToPreserveRevisionBudget({
+      deterministicRequiresRevision: preCriticDeterministicRequiresRevision,
+      remainingBudgetMs: preCriticRevisionBudget.remainingBudgetMs,
+      minimumRevisionBudgetMs: preCriticRevisionBudget.minimumRevisionBudgetMs,
+      criticTimeoutMs: resolveQualityCriticTimeoutMs(runtimeConfig),
+      criticTimeoutBehavior: resolveQualityCriticTimeoutBehavior(runtimeConfig),
+    });
     const critic =
       quality.skipped ||
       !qualityGatePolicy.criticGateEnabled ||
       skipCriticAfterExecutorTimeout ||
-      skipCriticForDeterministicValidationRevision
+      skipCriticForDeterministicValidationRevision ||
+      skipCriticForRevisionBudget
         ? null
         : executor === "openai_codex"
           ? await runCodexCriticReview(repo, attemptParams, qualityForCritic, runtimeConfig, onLog)
@@ -8020,6 +8048,11 @@ export async function executeJob(
         "stdout",
         "[CriticGate] Skipping critic because deterministic fast validation already requires a quality revision.",
       );
+    } else if (skipCriticForRevisionBudget) {
+      onLog?.(
+        "stdout",
+        `[CriticGate] Skipping critic because deterministic quality already requires revision and remaining budget (${preCriticRevisionBudget.remainingBudgetMs}ms) must be reserved for the next worker turn.`,
+      );
     }
     const rolloutScore = workerAttemptRolloutScore({
       executorElapsedMs,