@pushpalsdev/cli 1.0.65 → 1.0.67

package/package.json

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

package/runtime/configs/local.example.toml

@@ -8,7 +8,7 @@
 
 [localbuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -16,7 +16,7 @@ reasoning_effort = "high"
 
 [remotebuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -43,7 +43,7 @@ retention_days = 30
 
 [workerpals.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000

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

@@ -43,7 +43,8 @@ from executor_base import (
 )
 
 LOG_PREFIX = "[OpenAICodexExecutor]"
-DEFAULT_CODEX_MODEL = "gpt-5.4"
+DEFAULT_CODEX_MODEL = "gpt-5.5"
+LEGACY_CODEX_MODEL_FALLBACK = "gpt-5.4"
 _ACTIVE_CHILD: Optional[subprocess.Popen[str]] = None
 _INTERRUPTED_SIGNAL: Optional[int] = None
 log = Logger(LOG_PREFIX)
@@ -76,6 +77,10 @@ _CODEX_WORKAROUND_NEGATION_HINTS = (
     "codex cli is required infrastructure",
 )
 _REJECTED_EXEC_COMMAND_PATTERN = re.compile(r"exec_command failed for `([^`]+)`", re.IGNORECASE)
+_MODEL_REQUIRES_NEWER_CODEX_PATTERN = re.compile(
+    r"model requires a newer version of codex|requires a newer version of codex|upgrade to the latest app or cli",
+    re.IGNORECASE,
+)
 _DISALLOWED_SHELL_WRAPPER_PREFIXES = (
     "/bin/bash -lc ",
     "/bin/bash -c ",
@@ -210,6 +215,19 @@ def shutil_which(binary: str) -> str:
     return which(binary) or ""
 
 
+def _resolve_command_executable(binary: str) -> str:
+    value = str(binary or "").strip()
+    if not value or os.path.dirname(value) or os.path.isabs(value):
+        return value
+    return shutil_which(value) or value
+
+
+def _normalize_command_prefix(parts: List[str]) -> List[str]:
+    if not parts:
+        return []
+    return [_resolve_command_executable(parts[0]), *parts[1:]]
+
+
 def _truncate(text: str, max_chars: int = 4000) -> str:
     value = str(text or "")
     if len(value) <= max_chars:
@@ -376,7 +394,7 @@ def _resolve_codex_command_prefix(config: OpenAICodexRuntimeConfig) -> List[str]
             if isinstance(parsed, list):
                 parts = [str(p).strip() for p in parsed if str(p).strip()]
                 if parts:
-                    return parts
+                    return _normalize_command_prefix(parts)
         except Exception:
             log.info(
                 "Invalid PUSHPALS_OPENAI_CODEX_BIN_JSON; expected JSON array of command segments."
@@ -391,13 +409,15 @@ def _resolve_codex_command_prefix(config: OpenAICodexRuntimeConfig) -> List[str]
                 "Invalid PUSHPALS_OPENAI_CODEX_BIN value; expected a command string parseable by shlex."
             )
             return []
-        return parts
+        return _normalize_command_prefix(parts)
 
     # Prefer bunx to avoid requiring a separate node runtime in the container.
-    if shutil_which("bunx"):
-        return ["bunx", "--yes", "@openai/codex"]
-    if shutil_which("codex"):
-        return ["codex"]
+    bunx = shutil_which("bunx")
+    if bunx:
+        return [bunx, "--yes", "@openai/codex"]
+    codex = shutil_which("codex")
+    if codex:
+        return [codex]
     return []
 
 
@@ -964,6 +984,10 @@ def _safe_model_for_codex(raw_model: str, base_url: str) -> str:
     return DEFAULT_CODEX_MODEL
 
 
+def _requires_newer_codex_for_model(*texts: str) -> bool:
+    return any(_MODEL_REQUIRES_NEWER_CODEX_PATTERN.search(str(text or "")) for text in texts)
+
+
 def _build_instruction(instruction: str, supplemental_guidance: List[str]) -> str:
     system_prompt = (_load_prompt_template(_TASK_SYSTEM_PROMPT_PATH) or "").strip()
     if not system_prompt:
@@ -1343,6 +1367,8 @@ def _run_codex_task(
     supplemental_guidance: List[str],
     *,
     wrapper_recovery_attempt: int = 0,
+    model_compatibility_recovery_attempt: int = 0,
+    model_override: Optional[str] = None,
     baseline_changes: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     global _ACTIVE_CHILD, _INTERRUPTED_SIGNAL
@@ -1377,7 +1403,12 @@ def _run_codex_task(
     configured_model, api_key, base_url = resolve_llm_config(DEFAULT_CODEX_MODEL, logger=log)
     auth_mode_raw = runtime_config.auth_mode
     auth_mode_configured = _normalize_auth_mode(auth_mode_raw)
-    model = _safe_model_for_codex(configured_model, base_url)
+    model = str(model_override or "").strip() or _safe_model_for_codex(configured_model, base_url)
+    if model_override:
+        log.info(
+            f"Using Codex model compatibility override {model!r} instead of configured/default "
+            f"model {configured_model!r}."
+        )
     approval = _normalize_choice(
         runtime_config.approval_policy,
         _VALID_APPROVAL_POLICIES,
@@ -1743,6 +1774,8 @@ def _run_codex_task(
                             recovery_guidance,
                         ],
                         wrapper_recovery_attempt=wrapper_recovery_attempt + 1,
+                        model_compatibility_recovery_attempt=model_compatibility_recovery_attempt,
+                        model_override=model_override,
                         baseline_changes=baseline_snapshot,
                     )
                     retry_result["usage"] = _merge_usage_records(usage, retry_result.get("usage"))
@@ -1808,6 +1841,36 @@ def _run_codex_task(
         exit_code = int(return_code)
 
         if exit_code != 0:
+            if (
+                model_compatibility_recovery_attempt < 1
+                and model.strip().lower() == DEFAULT_CODEX_MODEL.lower()
+                and LEGACY_CODEX_MODEL_FALLBACK.strip().lower() != DEFAULT_CODEX_MODEL.lower()
+                and _requires_newer_codex_for_model(stdout, stderr)
+            ):
+                log.warning(
+                    f"Codex CLI rejected default model {DEFAULT_CODEX_MODEL}; retrying once with "
+                    f"{LEGACY_CODEX_MODEL_FALLBACK}. Upgrade Codex CLI to use {DEFAULT_CODEX_MODEL}."
+                )
+                retry_result = _run_codex_task(
+                    repo,
+                    instruction,
+                    effective_supplemental_guidance,
+                    wrapper_recovery_attempt=wrapper_recovery_attempt,
+                    model_compatibility_recovery_attempt=model_compatibility_recovery_attempt + 1,
+                    model_override=LEGACY_CODEX_MODEL_FALLBACK,
+                    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(
+                        (
+                            f"Codex CLI rejected default model {DEFAULT_CODEX_MODEL} because it "
+                            "requires a newer Codex version; recovered by retrying with "
+                            f"{LEGACY_CODEX_MODEL_FALLBACK}.\n\n{recovered_stdout}"
+                        ).strip()
+                    )
+                return retry_result
             detail = stderr.strip() or stdout.strip() or "codex exec exited with a non-zero status"
             if last_message:
                 detail = f"{detail}\nLast assistant message:\n{last_message}"

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

@@ -34,6 +34,7 @@ from openai_codex_executor import (
     _extract_usage_counts,
     _load_prompt_template,
     _repo_root_for_prompt_loading,
+    _resolve_codex_command_prefix,
     _unwrap_shell_wrapper_command,
     _usage_from_trace_or_estimate,
 )
@@ -79,14 +80,52 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertEqual(cfg.reasoning_effort, "high")
         self.assertFalse(cfg.json_output)
 
-    def test_reasoning_effort_caps_extra_high_for_gpt_5_4(self) -> None:
+    def test_resolve_codex_command_prefix_resolves_configured_executable(self) -> None:
+        cfg = OpenAICodexRuntimeConfig.from_sources(
+            SettingsResolver(
+                env={"PUSHPALS_OPENAI_CODEX_BIN": "bun x --yes @openai/codex"},
+                config_loader=lambda: {},
+            ),
+        )
+        with mock.patch(
+            "openai_codex_executor.shutil_which",
+            side_effect=lambda binary: {"bun": r"C:\Tools\bun.CMD"}.get(binary, ""),
+        ):
+            self.assertEqual(
+                _resolve_codex_command_prefix(cfg),
+                [r"C:\Tools\bun.CMD", "x", "--yes", "@openai/codex"],
+            )
+
+    def test_resolve_codex_command_prefix_resolves_fallback_executable(self) -> None:
+        cfg = OpenAICodexRuntimeConfig.from_sources(
+            SettingsResolver(env={}, config_loader=lambda: {}),
+        )
+        with mock.patch(
+            "openai_codex_executor.shutil_which",
+            side_effect=lambda binary: {"bunx": "/usr/local/bin/bunx" }.get(binary, ""),
+        ):
+            self.assertEqual(
+                _resolve_codex_command_prefix(cfg),
+                ["/usr/local/bin/bunx", "--yes", "@openai/codex"],
+            )
+
+    def test_reasoning_effort_caps_extra_high_for_legacy_gpt_5_4(self) -> None:
+        cfg = OpenAICodexRuntimeConfig.from_sources(
+            SettingsResolver(
+                env={"WORKERPALS_OPENAI_CODEX_REASONING_EFFORT": "extra high"},
+                config_loader=lambda: {},
+            ),
+        )
+        self.assertEqual(_resolve_reasoning_effort(cfg, model="gpt-5.4"), "high")
+
+    def test_reasoning_effort_preserves_extra_high_for_default_gpt_5_5(self) -> None:
         cfg = OpenAICodexRuntimeConfig.from_sources(
             SettingsResolver(
                 env={"WORKERPALS_OPENAI_CODEX_REASONING_EFFORT": "extra high"},
                 config_loader=lambda: {},
             ),
         )
-        self.assertEqual(_resolve_reasoning_effort(cfg), "high")
+        self.assertEqual(_resolve_reasoning_effort(cfg), "xhigh")
 
     def test_reasoning_effort_preserves_extra_high_for_future_models(self) -> None:
         cfg = OpenAICodexRuntimeConfig.from_sources(
@@ -436,6 +475,88 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertIn("strict wrapper recovery", str(result.get("stdout") or "").lower())
         self.assertIn("backend-supplied direct command bootstrap", str(result.get("stdout") or ""))
 
+    def test_run_codex_task_recovers_when_default_model_requires_newer_codex(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-codex-model-compat-") as temp_dir:
+            repo = Path(temp_dir) / "repo"
+            repo.mkdir(parents=True, exist_ok=True)
+            (repo / "README.md").write_text("# model compatibility test\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 model compatibility repo"],
+                cwd=repo,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            stub_path = Path(temp_dir) / "fake_codex_model_compat.py"
+            stub_path.write_text(
+                "\n".join(
+                    [
+                        "from pathlib import Path",
+                        "import sys",
+                        "",
+                        "argv = sys.argv[1:]",
+                        "model = ''",
+                        "last_message_path = None",
+                        "for index, arg in enumerate(argv):",
+                        "    if arg == '-m' and index + 1 < len(argv):",
+                        "        model = argv[index + 1]",
+                        "    if arg == '--output-last-message' and index + 1 < len(argv):",
+                        "        last_message_path = argv[index + 1]",
+                        "",
+                        "if model == 'gpt-5.5':",
+                        "    print(\"ERROR: {'detail': \\\"The 'gpt-5.5' model requires a newer version of Codex. Please upgrade to the latest app or CLI and try again.\\\"}\", file=sys.stderr)",
+                        "    sys.exit(1)",
+                        "",
+                        "if model == 'gpt-5.4':",
+                        "    if last_message_path:",
+                        "        Path(last_message_path).write_text('Recovered on legacy model fallback.', encoding='utf-8')",
+                        "    print('item.completed | Used legacy model fallback.', flush=True)",
+                        "    sys.exit(0)",
+                        "",
+                        "print(f'unexpected model {model}', file=sys.stderr)",
+                        "sys.exit(2)",
+                    ]
+                ),
+                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-model-compat-test-key",
+                "WORKERPALS_OPENAI_CODEX_TIMEOUT_S": "10",
+                "WORKERPALS_OPENAI_CODEX_PROGRESS_LOG_INTERVAL_S": "1",
+            }
+            with mock.patch.dict(os.environ, env_overrides, clear=False):
+                result = _run_codex_task(
+                    str(repo),
+                    "Use the configured Codex model.",
+                    [],
+                )
+
+        self.assertTrue(result.get("ok"), result)
+        stdout = str(result.get("stdout") or "")
+        self.assertIn("rejected default model gpt-5.5", stdout.lower())
+        self.assertIn("gpt-5.4", stdout)
+        self.assertIn("Recovered on legacy model fallback.", stdout)
+
     def test_usage_falls_back_to_estimate_when_trace_has_no_usage(self) -> None:
         usage = _usage_from_trace_or_estimate({}, "abc" * 30, "done", model="gpt-5.4")
         self.assertTrue(usage["estimated"])

package/runtime/sandbox/configs/local.example.toml

@@ -8,7 +8,7 @@
 
 [localbuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -16,7 +16,7 @@ reasoning_effort = "high"
 
 [remotebuddy.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
@@ -43,7 +43,7 @@ retention_days = 30
 
 [workerpals.llm]
 backend = "openai_codex"
-model = "gpt-5.4"
+model = "gpt-5.5"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000