@pushpalsdev/cli 1.0.21 → 1.0.23

package/dist/pushpals-cli.js

@@ -369,6 +369,8 @@ function loadPushPalsConfig(options = {}) {
   const debugHttp = parseBoolEnv("PUSHPALS_DEBUG_HTTP") ?? asBoolean(serverNode.debug_http, false);
   const staleClaimTtlMs = Math.max(5000, asInt(parseIntEnv("PUSHPALS_STALE_CLAIM_TTL_MS") ?? serverNode.stale_claim_ttl_ms, 120000));
   const staleClaimSweepIntervalMs = Math.max(1000, asInt(parseIntEnv("PUSHPALS_STALE_CLAIM_SWEEP_INTERVAL_MS") ?? serverNode.stale_claim_sweep_interval_ms, 5000));
+  const sessionTokenBudget = Math.max(0, asInt(parseIntEnv("PUSHPALS_SESSION_TOKEN_BUDGET") ?? serverNode.session_token_budget, 1e6));
+  const sessionTokenBudgetAction = "pause";
   const globalStatusHeartbeatMs = parseIntEnv("PUSHPALS_STATUS_HEARTBEAT_MS");
   const localNode = getObject(merged, "localbuddy");
   const localEnabled = parseBoolEnv("LOCALBUDDY_ENABLED") ?? asBoolean(localNode.enabled, false);
@@ -619,7 +621,9 @@ function loadPushPalsConfig(options = {}) {
       port: serverPort,
       debugHttp,
       staleClaimTtlMs,
-      staleClaimSweepIntervalMs
+      staleClaimSweepIntervalMs,
+      sessionTokenBudget,
+      sessionTokenBudgetAction
     },
     localbuddy: {
       enabled: localEnabled,
@@ -1684,7 +1688,7 @@ async function ensureBundledMonitoringHubRoot() {
   return resolveBundledMonitoringHubRoot();
 }
 function repoLooksLikePushPalsSourceCheckout(repoRoot) {
-  return existsSync4(join2(repoRoot, "configs", "default.toml")) || existsSync4(join2(repoRoot, "config", "default.toml"));
+  return existsSync4(join2(repoRoot, "configs", "default.toml"));
 }
 function parseSemverFromPackageVersion(value) {
   const raw = String(value ?? "").trim();
@@ -4171,6 +4175,7 @@ export {
   resolveCliLocalBuddyAutostart,
   resolveBundledRuntimeAssetSource,
   resolveBundledMonitoringHubRoot,
+  repoLooksLikePushPalsSourceCheckout,
   prepareEmbeddedWorkerpalDockerImageIfNeeded,
   prepareCliRuntime,
   precheckWorkerpalDockerAvailability,

package/package.json

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

package/runtime/configs/default.toml

@@ -21,6 +21,7 @@ port = 3001
 debug_http = false
 stale_claim_ttl_ms = 120000
 stale_claim_sweep_interval_ms = 5000
+session_token_budget = 2000000
 
 [localbuddy]
 enabled = false
@@ -197,7 +198,7 @@ session_id = "workerpals-dev"
 [workerpals.openai_codex]
 timeout_ms = 7200000
 progress_log_interval_s = 30
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 approval_policy = "never"
 sandbox = "workspace-write"
 color = "never"

package/runtime/configs/local.example.toml

@@ -8,19 +8,19 @@
 
 [localbuddy.llm]
 backend = "openai_codex"
-model = "gpt-5-codex"
+model = "gpt-5.4"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 
 [remotebuddy.llm]
 backend = "openai_codex"
-model = "gpt-5-codex"
+model = "gpt-5.4"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 
 [remotebuddy]
 max_workerpals = 10
@@ -42,11 +42,11 @@ retention_days = 30
 
 [workerpals.llm]
 backend = "openai_codex"
-model = "gpt-5-codex"
+model = "gpt-5.4"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 
 [workerpals]
 executor = "openai_codex"
@@ -92,7 +92,7 @@ bin = "bun x --yes @openai/codex"
 timeout_ms = 7200000
 progress_log_interval_s = 30
 # timeout_s = 120  # optional; if set, overrides timeout_ms
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 approval_policy = "never"
 sandbox = "workspace-write"
 color = "never"

package/runtime/sandbox/apps/workerpals/src/backends/miniswe/miniswe_executor.py

@@ -57,6 +57,7 @@ from executor_base import (
     log_git_status,
     looks_local_base_url,
     parse_task_execute_payload,
+    prompts_root_for_runtime_assets,
     resolve_llm_config,
     setting_int,
     setting_str,
@@ -992,11 +993,7 @@ def _is_git_porcelain_status_command(cmd: str) -> bool:
 
 
 def _repo_root_for_prompt_loading() -> Path:
-    current = Path(__file__).resolve()
-    for parent in current.parents:
-        if (parent / "prompts").is_dir():
-            return parent
-    return current.parents[5]
+    return prompts_root_for_runtime_assets()
 
 
 def _resolve_prompt_file(relative_path: str) -> Path:

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

@@ -35,6 +35,7 @@ from executor_base import (
     log_git_status,
     looks_local_base_url,
     parse_task_execute_payload,
+    prompts_root_for_runtime_assets,
     resolve_llm_config,
     summarize_git_changes,
     to_int,
@@ -42,7 +43,7 @@ from executor_base import (
 )
 
 LOG_PREFIX = "[OpenAICodexExecutor]"
-DEFAULT_CODEX_MODEL = "gpt-5-codex"
+DEFAULT_CODEX_MODEL = "gpt-5.4"
 _ACTIVE_CHILD: Optional[subprocess.Popen[str]] = None
 _INTERRUPTED_SIGNAL: Optional[int] = None
 log = Logger(LOG_PREFIX)
@@ -79,7 +80,7 @@ _VALID_APPROVAL_POLICIES = {"untrusted", "on-failure", "on-request", "never"}
 _VALID_SANDBOX_POLICIES = {"read-only", "workspace-write", "danger-full-access"}
 _VALID_COLORS = {"always", "never", "auto"}
 _VALID_AUTH_MODES = {"auto", "api_key", "chatgpt"}
-_VALID_REASONING_EFFORTS = {"low", "medium", "high"}
+_VALID_REASONING_EFFORTS = {"low", "medium", "high", "xhigh"}
 
 
 @dataclass(frozen=True)
@@ -151,7 +152,7 @@ class OpenAICodexRuntimeConfig:
             reasoning_effort=cfg.get_str(
                 env_names=("WORKERPALS_LLM_REASONING_EFFORT", "WORKERPALS_OPENAI_CODEX_REASONING_EFFORT"),
                 config_paths=("workerpals.llm.reasoning_effort", "workerpals.openai_codex.reasoning_effort"),
-                default="high",
+                default="xhigh",
             ),
             approval_policy=cfg.get_str(
                 env_names=("WORKERPALS_OPENAI_CODEX_APPROVAL_POLICY",),
@@ -188,12 +189,7 @@ def _truncate(text: str, max_chars: int = 4000) -> str:
 
 
 def _repo_root_for_prompt_loading() -> Path:
-    current = Path(__file__).resolve()
-    for parent in current.parents:
-        if (parent / "prompts").is_dir():
-            return parent
-    # Fallback to historical layout depth if prompts/ cannot be discovered.
-    return current.parents[5]
+    return prompts_root_for_runtime_assets()
 
 
 def _resolve_prompt_file(relative_path: str) -> Path:
@@ -323,13 +319,15 @@ def _resolve_communicate_timeout_seconds(config: OpenAICodexRuntimeConfig) -> Op
 def _resolve_reasoning_effort(config: OpenAICodexRuntimeConfig) -> str:
     raw = config.reasoning_effort
     normalized = str(raw).strip().lower()
+    if normalized in {"extra high", "extra-high", "extrahigh", "x-high"}:
+        normalized = "xhigh"
     if normalized in _VALID_REASONING_EFFORTS:
         return normalized
     log.info(
         "Invalid workerpals.openai_codex.reasoning_effort="
-        f"{raw!r}; using default 'high'. Allowed: low, medium, high."
+        f"{raw!r}; using default 'xhigh'. Allowed: low, medium, high, xhigh."
     )
-    return "high"
+    return "xhigh"
 
 
 def _resolve_progress_log_interval_seconds(config: OpenAICodexRuntimeConfig) -> int:
@@ -419,6 +417,88 @@ def _contains_reasoning_marker(value: str) -> bool:
     return "reasoning" in lowered or "thinking" in lowered
 
 
+def _coerce_non_negative_int(value: Any) -> Optional[int]:
+    try:
+        parsed = int(value)
+    except Exception:
+        return None
+    if parsed < 0:
+        return None
+    return parsed
+
+
+def _normalize_usage_counts(
+    prompt_tokens: Optional[int],
+    completion_tokens: Optional[int],
+    total_tokens: Optional[int],
+) -> Optional[Dict[str, int]]:
+    if prompt_tokens is None and completion_tokens is None and total_tokens is None:
+        return None
+    prompt = prompt_tokens if prompt_tokens is not None else 0
+    completion = completion_tokens if completion_tokens is not None else 0
+    total = total_tokens if total_tokens is not None else prompt + completion
+    if prompt_tokens is None and total_tokens is not None and completion_tokens is not None:
+        prompt = max(0, total - completion)
+    if completion_tokens is None and total_tokens is not None and prompt_tokens is not None:
+        completion = max(0, total - prompt)
+    total = max(total, prompt + completion)
+    if total <= 0:
+        return None
+    return {
+        "prompt_tokens": int(prompt),
+        "completion_tokens": int(completion),
+        "total_tokens": int(total),
+    }
+
+
+def _extract_usage_counts(value: Any) -> Optional[Dict[str, int]]:
+    best: Optional[Dict[str, int]] = None
+    stack: List[Any] = [value]
+    visited = 0
+    max_nodes = 256
+
+    while stack and visited < max_nodes:
+        current = stack.pop()
+        visited += 1
+        if isinstance(current, list):
+            for item in reversed(current[:80]):
+                if isinstance(item, (dict, list)):
+                    stack.append(item)
+            continue
+        if not isinstance(current, dict):
+            continue
+
+        prompt_tokens = _coerce_non_negative_int(
+            current.get("prompt_tokens")
+            or current.get("promptTokens")
+            or current.get("input_tokens")
+            or current.get("inputTokens")
+        )
+        completion_tokens = _coerce_non_negative_int(
+            current.get("completion_tokens")
+            or current.get("completionTokens")
+            or current.get("output_tokens")
+            or current.get("outputTokens")
+        )
+        total_tokens = _coerce_non_negative_int(
+            current.get("total_tokens") or current.get("totalTokens")
+        )
+        normalized = _normalize_usage_counts(prompt_tokens, completion_tokens, total_tokens)
+        if normalized is not None:
+            if best is None or normalized["total_tokens"] > best["total_tokens"]:
+                best = normalized
+
+        usage_node = current.get("usage")
+        if isinstance(usage_node, (dict, list)):
+            stack.append(usage_node)
+
+        for nested in current.values():
+            if isinstance(nested, (dict, list)):
+                stack.append(nested)
+
+    return best
+
+
 def _event_contains_reasoning(value: Any) -> bool:
     max_nodes = 256
     visited = 0
@@ -581,6 +661,9 @@ def _empty_codex_trace() -> Dict[str, Any]:
         "raw_logged": 0,
         "raw_omitted": 0,
         "reasoning_events": 0,
+        "prompt_tokens": 0,
+        "completion_tokens": 0,
+        "total_tokens": 0,
     }
 
 
@@ -611,6 +694,17 @@ def _record_live_codex_stdout_line(line: str, use_json: bool, trace: Dict[str, A
             return
 
         if isinstance(parsed, dict):
+            usage = _extract_usage_counts(parsed)
+            if usage is not None:
+                trace["prompt_tokens"] = max(
+                    to_int(trace.get("prompt_tokens"), 0), usage["prompt_tokens"]
+                )
+                trace["completion_tokens"] = max(
+                    to_int(trace.get("completion_tokens"), 0), usage["completion_tokens"]
+                )
+                trace["total_tokens"] = max(
+                    to_int(trace.get("total_tokens"), 0), usage["total_tokens"]
+                )
             event_type = (
                 str(parsed.get("type") or parsed.get("event") or parsed.get("kind") or "event")
                 .strip()
@@ -677,10 +771,17 @@ def _finalize_codex_stdout_trace(trace: Dict[str, Any], use_json: bool) -> Dict[
     if raw_omitted > 0:
         log.info(f"[codex/raw] ... {raw_omitted} additional line(s) omitted.")
     reasoning_events = to_int(trace.get("reasoning_events"), 0)
+    prompt_tokens = to_int(trace.get("prompt_tokens"), 0)
+    completion_tokens = to_int(trace.get("completion_tokens"), 0)
+    total_tokens = to_int(trace.get("total_tokens"), 0)
     if reasoning_events > 0:
         log.info(f"[codex] Reasoning-like event(s): {reasoning_events}")
     elif use_json and valid_json > 0:
         log.info("[codex] No reasoning-like events observed in this run.")
+    if total_tokens > 0:
+        log.info(
+            f"[codex] Usage observed: prompt={prompt_tokens} completion={completion_tokens} total={total_tokens}"
+        )
 
     if not summaries and event_type_counts:
         ranked = sorted(event_type_counts.items(), key=lambda item: item[1], reverse=True)
@@ -694,9 +795,41 @@ def _finalize_codex_stdout_trace(trace: Dict[str, Any], use_json: bool) -> Dict[
         "summaries": summaries,
         "event_type_counts": event_type_counts,
         "reasoning_events": reasoning_events,
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": total_tokens,
+    }
+
+
+def _estimated_usage(prompt: str, output_text: str, *, model: str) -> Dict[str, Any]:
+    prompt_tokens = max(0, int(len(str(prompt or "")) / 3 + 0.999999))
+    completion_tokens = max(0, int(len(str(output_text or "")) / 3 + 0.999999))
+    return {
+        "promptTokens": prompt_tokens,
+        "completionTokens": completion_tokens,
+        "totalTokens": prompt_tokens + completion_tokens,
+        "estimated": True,
+        "backend": "openai_codex",
+        "modelId": model,
     }
 
 
+def _usage_from_trace_or_estimate(trace: Dict[str, Any], prompt: str, output_text: str, *, model: str) -> Dict[str, Any]:
+    total_tokens = to_int(trace.get("total_tokens"), 0)
+    if total_tokens > 0:
+        prompt_tokens = to_int(trace.get("prompt_tokens"), 0)
+        completion_tokens = to_int(trace.get("completion_tokens"), 0)
+        return {
+            "promptTokens": prompt_tokens,
+            "completionTokens": completion_tokens,
+            "totalTokens": max(total_tokens, prompt_tokens + completion_tokens),
+            "estimated": False,
+            "backend": "openai_codex",
+            "modelId": model,
+        }
+    return _estimated_usage(prompt, output_text, model=model)
+
+
 def _log_stderr(stderr: str) -> None:
     lines = [line.strip() for line in stderr.splitlines() if line.strip()]
     if not lines:
@@ -1125,6 +1258,10 @@ def _run_codex_task(
         stdout_trace = _finalize_codex_stdout_trace(stdout_trace_state, use_json)
         trace_excerpt = _format_codex_trace_excerpt(stdout_trace)
         _log_stderr(stderr)
+        usage_output_text = "\n\n".join(
+            part for part in (stdout, stderr, trace_excerpt) if str(part or "").strip()
+        )
+        usage = _usage_from_trace_or_estimate(stdout_trace, prompt, usage_output_text, model=model)
 
         if timed_out:
             detail = (
@@ -1140,6 +1277,7 @@ def _run_codex_task(
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(f"{detail}\n{stderr}".strip()),
                 "exitCode": 124,
+                "usage": usage,
             }
 
         last_message = _read_text_if_exists(last_message_path)
@@ -1152,6 +1290,7 @@ def _run_codex_task(
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(stderr),
                 "exitCode": 128 + int(_INTERRUPTED_SIGNAL),
+                "usage": usage,
             }
 
         if return_code is None:
@@ -1161,6 +1300,7 @@ def _run_codex_task(
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(stderr),
                 "exitCode": 1,
+                "usage": usage,
             }
 
         exit_code = int(return_code)
@@ -1177,6 +1317,7 @@ def _run_codex_task(
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(detail),
                 "exitCode": exit_code,
+                "usage": usage,
             }
 
         policy_signal = _detect_codex_workaround_signal(last_message)
@@ -1199,6 +1340,7 @@ def _run_codex_task(
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(detail),
                 "exitCode": 5,
+                "usage": usage,
             }
 
         changed_paths = summarize_git_changes(repo)
@@ -1220,6 +1362,7 @@ def _run_codex_task(
                 "stdout": "\n\n".join(stdout_parts),
                 "stderr": "",
                 "exitCode": 0,
+                "usage": usage,
             }
 
         if not stdout_parts:
@@ -1230,6 +1373,7 @@ def _run_codex_task(
             "stdout": "\n\n".join(stdout_parts),
             "stderr": "",
             "exitCode": 0,
+            "usage": usage,
         }
 
 

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

@@ -1,5 +1,7 @@
+import os
 import sys
 import unittest
+import tempfile
 from pathlib import Path
 
 _HERE = Path(__file__).resolve().parent
@@ -8,13 +10,16 @@ for path in (_HERE, _SHARED):
     if str(path) not in sys.path:
         sys.path.insert(0, str(path))
 
-from executor_base import SettingsResolver
+from executor_base import SettingsResolver, config_dir_for_runtime_config, runtime_config
 from openai_codex_executor import (
     OpenAICodexRuntimeConfig,
+    _resolve_reasoning_effort,
     _build_instruction,
     _detect_codex_workaround_signal,
+    _extract_usage_counts,
     _load_prompt_template,
     _repo_root_for_prompt_loading,
+    _usage_from_trace_or_estimate,
 )
 
 
@@ -55,8 +60,60 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         self.assertEqual(cfg.approval_policy, "never")
         self.assertEqual(cfg.sandbox, "workspace-write")
         self.assertEqual(cfg.color, "never")
+        self.assertEqual(cfg.reasoning_effort, "xhigh")
         self.assertFalse(cfg.json_output)
 
+    def test_reasoning_effort_accepts_extra_high_alias(self) -> None:
+        cfg = OpenAICodexRuntimeConfig.from_sources(
+            SettingsResolver(
+                env={"WORKERPALS_OPENAI_CODEX_REASONING_EFFORT": "extra high"},
+                config_loader=lambda: {},
+            ),
+        )
+        self.assertEqual(_resolve_reasoning_effort(cfg), "xhigh")
+
+    def test_runtime_config_prefers_explicit_config_dir_override(self) -> None:
+        import executor_base
+
+        with tempfile.TemporaryDirectory(prefix="pushpals-openai-codex-config-") as root:
+            repo_root = Path(root) / "repo"
+            runtime_config_dir = Path(root) / "runtime" / "configs"
+            repo_config_dir = repo_root / "configs"
+            runtime_config_dir.mkdir(parents=True, exist_ok=True)
+            repo_config_dir.mkdir(parents=True, exist_ok=True)
+
+            (runtime_config_dir / "default.toml").write_text(
+                'profile = "dev"\n[workerpals.openai_codex]\njson = true\n',
+                encoding="utf-8",
+            )
+            (repo_config_dir / "default.toml").write_text(
+                'profile = "dev"\n[workerpals.openai_codex]\njson = false\n',
+                encoding="utf-8",
+            )
+
+            previous_env = {
+                "PUSHPALS_REPO_PATH": os.environ.get("PUSHPALS_REPO_PATH"),
+                "PUSHPALS_CONFIG_DIR_OVERRIDE": os.environ.get("PUSHPALS_CONFIG_DIR_OVERRIDE"),
+                "PUSHPALS_PROFILE": os.environ.get("PUSHPALS_PROFILE"),
+            }
+            previous_cache = executor_base._CONFIG_CACHE
+            try:
+                os.environ["PUSHPALS_REPO_PATH"] = str(repo_root)
+                os.environ["PUSHPALS_CONFIG_DIR_OVERRIDE"] = str(runtime_config_dir)
+                os.environ["PUSHPALS_PROFILE"] = "dev"
+                executor_base._CONFIG_CACHE = None
+
+                self.assertEqual(config_dir_for_runtime_config(), runtime_config_dir)
+                cfg = runtime_config()
+                self.assertTrue(cfg["workerpals"]["openai_codex"]["json"])
+            finally:
+                executor_base._CONFIG_CACHE = previous_cache
+                for key, value in previous_env.items():
+                    if value is None:
+                        os.environ.pop(key, None)
+                    else:
+                        os.environ[key] = value
+
     def test_build_instruction_includes_codex_runtime_invariants(self) -> None:
         prompt = _build_instruction("Add two tests for localbuddy", [])
         self.assertIn("Codex CLI is required infrastructure", prompt)
@@ -105,6 +162,32 @@ class OpenAICodexRuntimeConfigTests(unittest.TestCase):
         template = _load_prompt_template("workerpals/openai_codex_task_execute_system_prompt.md")
         self.assertIn("Codex CLI is required infrastructure", template)
 
+    def test_extracts_usage_counts_from_nested_json_event(self) -> None:
+        usage = _extract_usage_counts(
+            {
+                "type": "response.completed",
+                "response": {
+                    "usage": {
+                        "input_tokens": 120,
+                        "output_tokens": 30,
+                        "total_tokens": 150,
+                    }
+                },
+            }
+        )
+        self.assertEqual(
+            usage,
+            {"prompt_tokens": 120, "completion_tokens": 30, "total_tokens": 150},
+        )
+
+    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"])
+        self.assertEqual(usage["backend"], "openai_codex")
+        self.assertEqual(usage["modelId"], "gpt-5.4")
+        self.assertGreater(usage["promptTokens"], 0)
+        self.assertGreater(usage["totalTokens"], usage["completionTokens"])
+
 
 if __name__ == "__main__":
     unittest.main()

package/runtime/sandbox/apps/workerpals/src/backends/openhands/openhands_executor.py

@@ -28,7 +28,7 @@ from executor_base import (
     log_git_status,
     looks_local_base_url,
     parse_task_execute_payload,
-    repo_root_for_runtime_config,
+    prompts_root_for_runtime_assets,
     resolve_llm_config,
     setting_int,
     setting_str,
@@ -78,7 +78,7 @@ def _session_hint_headers(session_user: str) -> Dict[str, str]:
 
 
 def _repo_root_for_prompt_loading() -> Path:
-    return repo_root_for_runtime_config()
+    return prompts_root_for_runtime_assets()
 
 
 def _resolve_prompt_file(relative_path: str) -> Path:

package/runtime/sandbox/apps/workerpals/src/backends/openhands/test_openhands_runtime_paths.py

@@ -0,0 +1,57 @@
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+_HERE = Path(__file__).resolve().parent
+_SHARED = _HERE.parent / "shared"
+for path in (_HERE, _SHARED):
+    if str(path) not in sys.path:
+        sys.path.insert(0, str(path))
+
+from openhands_executor import _PROMPT_TEMPLATE_CACHE, _load_prompt_template, _resolve_prompt_file
+
+
+class OpenHandsRuntimePathTests(unittest.TestCase):
+    def test_prompt_resolution_prefers_explicit_prompt_root_override(self) -> None:
+        with tempfile.TemporaryDirectory(prefix="pushpals-openhands-prompts-") as root:
+            repo_root = Path(root) / "repo"
+            runtime_root = Path(root) / "runtime"
+            repo_prompt = repo_root / "prompts" / "workerpals" / "openhands_strict_tool_use_message.md"
+            runtime_prompt = (
+                runtime_root / "prompts" / "workerpals" / "openhands_strict_tool_use_message.md"
+            )
+            repo_prompt.parent.mkdir(parents=True, exist_ok=True)
+            runtime_prompt.parent.mkdir(parents=True, exist_ok=True)
+            repo_prompt.write_text("repo prompt", encoding="utf-8")
+            runtime_prompt.write_text("runtime prompt", encoding="utf-8")
+
+            previous_env = {
+                "PUSHPALS_REPO_PATH": os.environ.get("PUSHPALS_REPO_PATH"),
+                "PUSHPALS_PROMPTS_ROOT_OVERRIDE": os.environ.get("PUSHPALS_PROMPTS_ROOT_OVERRIDE"),
+            }
+            previous_cache = dict(_PROMPT_TEMPLATE_CACHE)
+            try:
+                os.environ["PUSHPALS_REPO_PATH"] = str(repo_root)
+                os.environ["PUSHPALS_PROMPTS_ROOT_OVERRIDE"] = str(runtime_root)
+                _PROMPT_TEMPLATE_CACHE.clear()
+
+                resolved = _resolve_prompt_file("workerpals/openhands_strict_tool_use_message.md")
+                self.assertEqual(resolved, runtime_prompt)
+                self.assertEqual(
+                    _load_prompt_template("workerpals/openhands_strict_tool_use_message.md"),
+                    "runtime prompt",
+                )
+            finally:
+                _PROMPT_TEMPLATE_CACHE.clear()
+                _PROMPT_TEMPLATE_CACHE.update(previous_cache)
+                for key, value in previous_env.items():
+                    if value is None:
+                        os.environ.pop(key, None)
+                    else:
+                        os.environ[key] = value
+
+
+if __name__ == "__main__":
+    unittest.main()

package/runtime/sandbox/apps/workerpals/src/backends/openhands_task_execute.ts

@@ -8,7 +8,7 @@
 
 import { existsSync } from "fs";
 import { resolve } from "path";
-import type { JobResult } from "../common/types.js";
+import type { JobResult, JobTokenUsage } from "../common/types.js";
 import type { WorkerpalsRuntimeConfig } from "../common/executor_backend.js";
 import {
   truncate,
@@ -24,6 +24,83 @@ const OPENHANDS_SCRIPT_PATH = resolve(import.meta.dir, "openhands", "openhands_e
 
 // ---- OpenHands-specific helpers ----------------------------------------------
 
+function estimateTokensFromText(text: string): number {
+  return Math.max(0, Math.ceil(String(text ?? "").length / 3));
+}
+
+function estimateJobTokenUsage(
+  runtimeConfig: WorkerpalsRuntimeConfig,
+  params: Record<string, unknown>,
+  summary: string,
+  stdout: string,
+  stderr: string,
+): JobTokenUsage {
+  const promptSource = (() => {
+    try {
+      return JSON.stringify(params);
+    } catch {
+      return String(params?.instruction ?? params?.prompt ?? "");
+    }
+  })();
+  const completionSource = [summary, stdout, stderr].filter(Boolean).join("\n\n");
+  const promptTokens = estimateTokensFromText(promptSource);
+  const completionTokens = estimateTokensFromText(completionSource);
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    estimated: true,
+    backend: "openhands",
+    modelId: runtimeConfig.workerpals.llm.model.trim(),
+  };
+}
+
+function coerceJobTokenUsage(
+  value: unknown,
+  fallback: JobTokenUsage,
+): JobTokenUsage {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return fallback;
+  }
+  const raw = value as Record<string, unknown>;
+  const promptTokens = Number(raw.promptTokens ?? raw.prompt_tokens);
+  const completionTokens = Number(raw.completionTokens ?? raw.completion_tokens);
+  const totalTokens = Number(raw.totalTokens ?? raw.total_tokens);
+  const hasPrompt = Number.isFinite(promptTokens) && promptTokens >= 0;
+  const hasCompletion = Number.isFinite(completionTokens) && completionTokens >= 0;
+  const hasTotal = Number.isFinite(totalTokens) && totalTokens >= 0;
+  if (!hasPrompt && !hasCompletion && !hasTotal) {
+    return fallback;
+  }
+  const normalizedPrompt = hasPrompt
+    ? Math.round(promptTokens)
+    : hasTotal
+      ? Math.max(0, Math.round(totalTokens) - fallback.completionTokens)
+      : fallback.promptTokens;
+  const normalizedCompletion = hasCompletion
+    ? Math.round(completionTokens)
+    : hasTotal
+      ? Math.max(0, Math.round(totalTokens) - normalizedPrompt)
+      : fallback.completionTokens;
+  const normalizedTotal = hasTotal
+    ? Math.round(totalTokens)
+    : normalizedPrompt + normalizedCompletion;
+  return {
+    promptTokens: normalizedPrompt,
+    completionTokens: normalizedCompletion,
+    totalTokens: normalizedTotal,
+    estimated: typeof raw.estimated === "boolean" ? raw.estimated : false,
+    backend:
+      typeof raw.backend === "string" && raw.backend.trim().length > 0
+        ? raw.backend.trim()
+        : fallback.backend,
+    modelId:
+      typeof raw.modelId === "string" && raw.modelId.trim().length > 0
+        ? raw.modelId.trim()
+        : fallback.modelId,
+  };
+}
+
 function classifyShellCommand(cmd: string): "explore" | "progress" {
   const trimmed = cmd.trim().toLowerCase();
   if (!trimmed) return "explore";
@@ -450,6 +527,7 @@ export async function executeWithOpenHands(
 
     const parsed = parseStructuredResult(stdout, outputPolicy.executorResultPrefix);
     const filteredStdout = filterResultLines(stdout, outputPolicy.executorResultPrefix);
+    const fallbackUsage = estimateJobTokenUsage(runtimeConfig, params, "", filteredStdout, stderr);
 
     if (!parsed) {
       if (timedOut) {
@@ -464,6 +542,7 @@ export async function executeWithOpenHands(
           stdout: truncate(filteredStdout, outputPolicy),
           stderr: truncate(stderr, outputPolicy),
           exitCode: exitCode === 0 ? 124 : exitCode,
+          usage: fallbackUsage,
         };
       }
       return {
@@ -472,6 +551,7 @@ export async function executeWithOpenHands(
         stdout: truncate(filteredStdout, outputPolicy),
         stderr: truncate(stderr, outputPolicy),
         exitCode,
+        usage: fallbackUsage,
       };
     }
 
@@ -483,6 +563,10 @@ export async function executeWithOpenHands(
           : `${kind} failed via OpenHands (exit ${exitCode})`;
     const parsedStdout = typeof parsed.stdout === "string" ? parsed.stdout : filteredStdout;
     const parsedStderr = typeof parsed.stderr === "string" ? parsed.stderr : stderr;
+    const usage = coerceJobTokenUsage(
+      parsed.usage,
+      estimateJobTokenUsage(runtimeConfig, params, summary, parsedStdout, parsedStderr),
+    );
     const parsedExitCode =
       typeof parsed.exitCode === "number" && Number.isFinite(parsed.exitCode)
         ? parsed.exitCode
@@ -502,6 +586,7 @@ export async function executeWithOpenHands(
           stdout: truncate(filteredStdout || String(parsedStdout ?? ""), outputPolicy),
           stderr: truncate(`Clarification needed: ${clarificationQuestion}`, outputPolicy),
           exitCode: 0,
+          usage,
         };
       }
     }
@@ -512,12 +597,20 @@ export async function executeWithOpenHands(
       stdout: truncate(parsedStdout ?? "", outputPolicy),
       stderr: truncate(parsedStderr ?? "", outputPolicy),
       exitCode: parsedExitCode,
+      usage,
     };
   } catch (err) {
     return {
       ok: false,
       summary: `OpenHands wrapper execution error for ${kind}: ${String(err)}`,
       exitCode: 1,
+      usage: estimateJobTokenUsage(
+        runtimeConfig,
+        params,
+        `OpenHands wrapper execution error for ${kind}: ${String(err)}`,
+        "",
+        "",
+      ),
     };
   } finally {
     if (warningTimer) {

package/runtime/sandbox/apps/workerpals/src/backends/shared/executor_base.py

@@ -203,6 +203,24 @@ def repo_root_for_runtime_config() -> Path:
     return Path(__file__).resolve().parents[3]
 
 
+def config_dir_for_runtime_config() -> Path:
+    explicit = (os.environ.get("PUSHPALS_CONFIG_DIR_OVERRIDE") or "").strip()
+    if explicit:
+        return Path(explicit)
+    return repo_root_for_runtime_config() / "configs"
+
+
+def prompts_root_for_runtime_assets() -> Path:
+    explicit = (os.environ.get("PUSHPALS_PROMPTS_ROOT_OVERRIDE") or "").strip()
+    if explicit:
+        return Path(explicit)
+    current = Path(__file__).resolve()
+    for parent in current.parents:
+        if (parent / "prompts").is_dir():
+            return parent
+    return repo_root_for_runtime_config()
+
+
 def _parse_toml_file(path: Path) -> Dict[str, Any]:
     if not path.exists() or not tomllib:
         return {}
@@ -217,12 +235,7 @@ def runtime_config() -> Dict[str, Any]:
     global _CONFIG_CACHE
     if _CONFIG_CACHE is not None:
         return _CONFIG_CACHE
-    repo_root = repo_root_for_runtime_config()
-    legacy_config_dir = repo_root / "config"
-    config_dir = repo_root / "configs"
-    if not (config_dir / "default.toml").exists():
-        if (legacy_config_dir / "default.toml").exists():
-            config_dir = legacy_config_dir
+    config_dir = config_dir_for_runtime_config()
     default_cfg = _parse_toml_file(config_dir / "default.toml")
     profile = (
         (os.environ.get("PUSHPALS_PROFILE") or "").strip()
@@ -231,12 +244,6 @@ def runtime_config() -> Dict[str, Any]:
     )
     profile_cfg = _parse_toml_file(config_dir / f"{profile}.toml")
     local_cfg = _parse_toml_file(config_dir / "local.toml")
-    if (
-        not local_cfg
-        and config_dir != legacy_config_dir
-        and (legacy_config_dir / "local.toml").exists()
-    ):
-        local_cfg = _parse_toml_file(legacy_config_dir / "local.toml")
     _CONFIG_CACHE = _deep_merge(_deep_merge(default_cfg, profile_cfg), local_cfg)
     return _CONFIG_CACHE
 

package/runtime/sandbox/apps/workerpals/src/common/generic_python_executor.ts

@@ -9,7 +9,7 @@
 
 import { existsSync } from "fs";
 import { resolve } from "path";
-import type { JobResult } from "./types.js";
+import type { JobResult, JobTokenUsage } from "./types.js";
 import type { WorkerpalsRuntimeConfig } from "./executor_backend.js";
 import type { BackendTaskExecutor } from "../backends/types.js";
 import {
@@ -26,6 +26,84 @@ interface GenericPythonExecutorConfig {
   timeoutConfigKey: string;
 }
 
+function estimateTokensFromText(text: string): number {
+  return Math.max(0, Math.ceil(String(text ?? "").length / 3));
+}
+
+function estimateJobTokenUsage(
+  backendName: string,
+  modelId: string,
+  params: Record<string, unknown>,
+  summary: string,
+  stdout: string,
+  stderr: string,
+): JobTokenUsage {
+  const promptSource = (() => {
+    try {
+      return JSON.stringify(params);
+    } catch {
+      return String(params?.instruction ?? params?.prompt ?? "");
+    }
+  })();
+  const completionSource = [summary, stdout, stderr].filter(Boolean).join("\n\n");
+  const promptTokens = estimateTokensFromText(promptSource);
+  const completionTokens = estimateTokensFromText(completionSource);
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    estimated: true,
+    backend: backendName,
+    modelId,
+  };
+}
+
+function coerceJobTokenUsage(
+  value: unknown,
+  fallback: JobTokenUsage,
+): JobTokenUsage {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return fallback;
+  }
+  const raw = value as Record<string, unknown>;
+  const promptTokens = Number(raw.promptTokens ?? raw.prompt_tokens);
+  const completionTokens = Number(raw.completionTokens ?? raw.completion_tokens);
+  const totalTokens = Number(raw.totalTokens ?? raw.total_tokens);
+  const hasPrompt = Number.isFinite(promptTokens) && promptTokens >= 0;
+  const hasCompletion = Number.isFinite(completionTokens) && completionTokens >= 0;
+  const hasTotal = Number.isFinite(totalTokens) && totalTokens >= 0;
+  if (!hasPrompt && !hasCompletion && !hasTotal) {
+    return fallback;
+  }
+  const normalizedPrompt = hasPrompt
+    ? Math.round(promptTokens)
+    : hasTotal
+      ? Math.max(0, Math.round(totalTokens) - fallback.completionTokens)
+      : fallback.promptTokens;
+  const normalizedCompletion = hasCompletion
+    ? Math.round(completionTokens)
+    : hasTotal
+      ? Math.max(0, Math.round(totalTokens) - normalizedPrompt)
+      : fallback.completionTokens;
+  const normalizedTotal = hasTotal
+    ? Math.round(totalTokens)
+    : normalizedPrompt + normalizedCompletion;
+  return {
+    promptTokens: normalizedPrompt,
+    completionTokens: normalizedCompletion,
+    totalTokens: normalizedTotal,
+    estimated: typeof raw.estimated === "boolean" ? raw.estimated : false,
+    backend:
+      typeof raw.backend === "string" && raw.backend.trim().length > 0
+        ? raw.backend.trim()
+        : fallback.backend,
+    modelId:
+      typeof raw.modelId === "string" && raw.modelId.trim().length > 0
+        ? raw.modelId.trim()
+        : fallback.modelId,
+  };
+}
+
 function resolveRuntimeSettings(
   config: GenericPythonExecutorConfig,
   runtimeConfig: WorkerpalsRuntimeConfig,
@@ -69,6 +147,7 @@ export function createGenericPythonExecutor(
       config,
       runtimeConfig,
     );
+    const modelId = runtimeConfig.workerpals.llm.model.trim();
     const executionBudgetMs =
       typeof budgets?.executionBudgetMs === "number" && Number.isFinite(budgets.executionBudgetMs)
         ? Math.max(10_000, Math.floor(budgets.executionBudgetMs))
@@ -158,6 +237,14 @@ export function createGenericPythonExecutor(
 
       const parsed = parseStructuredResult(stdout, outputPolicy.executorResultPrefix);
       const filteredStdout = filterResultLines(stdout, outputPolicy.executorResultPrefix);
+      const fallbackUsage = estimateJobTokenUsage(
+        backendName,
+        modelId,
+        params,
+        "",
+        filteredStdout,
+        stderr,
+      );
 
       if (!parsed) {
         if (timedOut) {
@@ -167,6 +254,7 @@ export function createGenericPythonExecutor(
             stdout: truncate(filteredStdout, outputPolicy),
             stderr: truncate(stderr, outputPolicy),
             exitCode: exitCode === 0 ? 124 : exitCode,
+            usage: fallbackUsage,
           };
         }
         return {
@@ -175,35 +263,47 @@ export function createGenericPythonExecutor(
           stdout: truncate(filteredStdout, outputPolicy),
           stderr: truncate(stderr, outputPolicy),
           exitCode,
+          usage: fallbackUsage,
         };
       }
 
+      const summary =
+        typeof parsed.summary === "string"
+          ? parsed.summary
+          : exitCode === 0
+            ? `${kind} passed via ${backendName}`
+            : `${kind} failed via ${backendName} (exit ${exitCode})`;
+      const parsedStdout = typeof parsed.stdout === "string" ? parsed.stdout : filteredStdout;
+      const parsedStderr = typeof parsed.stderr === "string" ? parsed.stderr : stderr;
+      const usage = coerceJobTokenUsage(
+        parsed.usage,
+        estimateJobTokenUsage(backendName, modelId, params, summary, parsedStdout, parsedStderr),
+      );
+
       return {
         ok: typeof parsed.ok === "boolean" ? parsed.ok : exitCode === 0,
-        summary:
-          typeof parsed.summary === "string"
-            ? parsed.summary
-            : exitCode === 0
-              ? `${kind} passed via ${backendName}`
-              : `${kind} failed via ${backendName} (exit ${exitCode})`,
-        stdout: truncate(
-          typeof parsed.stdout === "string" ? parsed.stdout : filteredStdout,
-          outputPolicy,
-        ),
-        stderr: truncate(
-          typeof parsed.stderr === "string" ? parsed.stderr : stderr,
-          outputPolicy,
-        ),
+        summary,
+        stdout: truncate(parsedStdout, outputPolicy),
+        stderr: truncate(parsedStderr, outputPolicy),
         exitCode:
           typeof parsed.exitCode === "number" && Number.isFinite(parsed.exitCode)
             ? parsed.exitCode
             : exitCode,
+        usage,
       };
     } catch (err) {
       return {
         ok: false,
         summary: `${backendName} wrapper execution error for ${kind}: ${String(err)}`,
         exitCode: 1,
+        usage: estimateJobTokenUsage(
+          backendName,
+          runtimeConfig.workerpals.llm.model.trim(),
+          params,
+          `${backendName} wrapper execution error for ${kind}: ${String(err)}`,
+          "",
+          "",
+        ),
       };
     }
   };

package/runtime/sandbox/apps/workerpals/src/common/types.ts

@@ -1,9 +1,19 @@
 export type ExecutorBackend = string;
 
+export interface JobTokenUsage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens?: number;
+  estimated?: boolean;
+  backend?: string;
+  modelId?: string;
+}
+
 export interface JobResult {
   ok: boolean;
   summary: string;
   stdout?: string;
   stderr?: string;
   exitCode?: number;
+  usage?: JobTokenUsage;
 }

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

@@ -2022,14 +2022,29 @@ export function shouldUseCodexCliForExecutor(executor: string): boolean {
   return executor.trim().toLowerCase() === "openai_codex";
 }
 
-function normalizeCodexReasoningEffort(value: unknown): "low" | "medium" | "high" {
+function normalizeCodexReasoningEffort(
+  value: unknown,
+): "low" | "medium" | "high" | "xhigh" {
   const normalized = String(value ?? "")
     .trim()
     .toLowerCase();
-  if (normalized === "low" || normalized === "medium" || normalized === "high") {
+  if (
+    normalized === "low" ||
+    normalized === "medium" ||
+    normalized === "high" ||
+    normalized === "xhigh"
+  ) {
     return normalized;
   }
-  return "high";
+  if (
+    normalized === "extra high" ||
+    normalized === "extra-high" ||
+    normalized === "extrahigh" ||
+    normalized === "x-high"
+  ) {
+    return "xhigh";
+  }
+  return "xhigh";
 }
 
 async function generateCommitMessageFromDiff(

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

@@ -91,6 +91,99 @@ function workerLlmConfig(runtimeConfig: ReturnType<typeof loadPushPalsConfig>):
   };
 }
 
+function estimateTokensFromText(text: string): number {
+  return Math.max(0, Math.ceil(String(text ?? "").length / 3));
+}
+
+function buildWorkerLlmUsageEvent(
+  job: {
+    kind: string;
+    sessionId?: string | null;
+    params?: Record<string, unknown> | null;
+  },
+  result: WorkerJobResult,
+): Record<string, unknown> | null {
+  const sessionId = String(job.sessionId ?? CONFIG.sessionId ?? "").trim();
+  if (!sessionId) return null;
+  const llmConfig = workerLlmConfig(CONFIG);
+  const explicitUsage = result.usage;
+  if (
+    explicitUsage &&
+    Number.isFinite(explicitUsage.promptTokens) &&
+    explicitUsage.promptTokens >= 0 &&
+    Number.isFinite(explicitUsage.completionTokens) &&
+    explicitUsage.completionTokens >= 0
+  ) {
+    const promptTokens = Math.round(explicitUsage.promptTokens);
+    const completionTokens = Math.round(explicitUsage.completionTokens);
+    const totalTokens =
+      Number.isFinite(explicitUsage.totalTokens) && (explicitUsage.totalTokens ?? 0) >= 0
+        ? Math.round(explicitUsage.totalTokens ?? promptTokens + completionTokens)
+        : promptTokens + completionTokens;
+    return {
+      service: "workerpals",
+      sessionId,
+      backend: String(explicitUsage.backend ?? resolveExecutor(CONFIG)).trim() || resolveExecutor(CONFIG),
+      modelId: String(explicitUsage.modelId ?? llmConfig.model).trim() || llmConfig.model,
+      promptTokens,
+      completionTokens,
+      totalTokens,
+      estimated: explicitUsage.estimated === true,
+    };
+  }
+
+  const promptSource = (() => {
+    try {
+      return JSON.stringify({
+        kind: job.kind,
+        params: job.params ?? {},
+      });
+    } catch {
+      return `${job.kind}\n${String(job.params?.instruction ?? job.params?.prompt ?? "")}`.trim();
+    }
+  })();
+  const completionSource = [result.summary, result.stdout ?? "", result.stderr ?? ""]
+    .filter(Boolean)
+    .join("\n\n");
+  const promptTokens = estimateTokensFromText(promptSource);
+  const completionTokens = estimateTokensFromText(completionSource);
+  return {
+    service: "workerpals",
+    sessionId,
+    backend: resolveExecutor(CONFIG),
+    modelId: llmConfig.model,
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    estimated: true,
+  };
+}
+
+async function reportWorkerLlmUsage(
+  server: string,
+  headers: Record<string, string>,
+  job: {
+    kind: string;
+    sessionId?: string | null;
+    params?: Record<string, unknown> | null;
+  },
+  result: WorkerJobResult,
+): Promise<void> {
+  const payload = buildWorkerLlmUsageEvent(job, result);
+  if (!payload) return;
+  const response = await fetch(`${server}/telemetry/llm-usage`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload),
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(
+      `usage telemetry rejected (${response.status})${detail ? `: ${detail.trim()}` : ""}`,
+    );
+  }
+}
+
 function integrationBranchName(): string {
   const configuredBaseRef = CONFIG.workerpals.baseRef.trim();
   if (!configuredBaseRef) return "main_agents";
@@ -1047,6 +1140,15 @@ async function workerLoop(
             const jobDurationMs = Math.max(0, Date.now() - jobStartedAtMs);
 
             await logChain;
+            try {
+              await reportWorkerLlmUsage(opts.server, headers, jobData, result);
+            } catch (err) {
+              console.warn(
+                `[WorkerPals] Failed to report LLM usage for job ${job.id}: ${
+                  err instanceof Error ? err.message : String(err)
+                }`,
+              );
+            }
 
             let completionCommit: CommitRef | null = null;
             if (result.ok && shouldCommit(job.kind, CONFIG)) {

package/runtime/sandbox/configs/default.toml

@@ -21,6 +21,7 @@ port = 3001
 debug_http = false
 stale_claim_ttl_ms = 120000
 stale_claim_sweep_interval_ms = 5000
+session_token_budget = 2000000
 
 [localbuddy]
 enabled = false
@@ -197,7 +198,7 @@ session_id = "workerpals-dev"
 [workerpals.openai_codex]
 timeout_ms = 7200000
 progress_log_interval_s = 30
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 approval_policy = "never"
 sandbox = "workspace-write"
 color = "never"

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

@@ -8,19 +8,19 @@
 
 [localbuddy.llm]
 backend = "openai_codex"
-model = "gpt-5-codex"
+model = "gpt-5.4"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 
 [remotebuddy.llm]
 backend = "openai_codex"
-model = "gpt-5-codex"
+model = "gpt-5.4"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 
 [remotebuddy]
 max_workerpals = 10
@@ -42,11 +42,11 @@ retention_days = 30
 
 [workerpals.llm]
 backend = "openai_codex"
-model = "gpt-5-codex"
+model = "gpt-5.4"
 codex_auth_mode = "chatgpt"
 codex_bin = "bun x --yes @openai/codex"
 codex_timeout_ms = 120000
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 
 [workerpals]
 executor = "openai_codex"
@@ -92,7 +92,7 @@ bin = "bun x --yes @openai/codex"
 timeout_ms = 7200000
 progress_log_interval_s = 30
 # timeout_s = 120  # optional; if set, overrides timeout_ms
-reasoning_effort = "high"
+reasoning_effort = "xhigh"
 approval_policy = "never"
 sandbox = "workspace-write"
 color = "never"

package/runtime/sandbox/packages/shared/src/config.ts

@@ -82,6 +82,8 @@ export interface PushPalsConfig {
     debugHttp: boolean;
     staleClaimTtlMs: number;
     staleClaimSweepIntervalMs: number;
+    sessionTokenBudget: number;
+    sessionTokenBudgetAction: "pause";
   };
   localbuddy: {
     enabled: boolean;
@@ -682,6 +684,14 @@ export function loadPushPalsConfig(options: LoadOptions = {}): PushPalsConfig {
       5_000,
     ),
   );
+  const sessionTokenBudget = Math.max(
+    0,
+    asInt(
+      parseIntEnv("PUSHPALS_SESSION_TOKEN_BUDGET") ?? serverNode.session_token_budget,
+      1_000_000,
+    ),
+  );
+  const sessionTokenBudgetAction: "pause" = "pause";
 
   const globalStatusHeartbeatMs = parseIntEnv("PUSHPALS_STATUS_HEARTBEAT_MS");
 
@@ -1467,6 +1477,8 @@ export function loadPushPalsConfig(options: LoadOptions = {}): PushPalsConfig {
       debugHttp,
       staleClaimTtlMs,
       staleClaimSweepIntervalMs,
+      sessionTokenBudget,
+      sessionTokenBudgetAction,
     },
     localbuddy: {
       enabled: localEnabled,