@pushpalsdev/cli 1.0.22 → 1.0.24

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,69 @@ 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, "high")
         self.assertFalse(cfg.json_output)
 
+    def test_reasoning_effort_caps_extra_high_for_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), "high")
+
+    def test_reasoning_effort_preserves_extra_high_for_future_models(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-6-preview"), "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 +171,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/docker_executor.ts

@@ -1048,6 +1048,7 @@ export class DockerExecutor {
 
     const worktreeRelPath = relative(this.options.repo, worktreePath).replace(/\\/g, "/");
     const containerWorktreePath = `/repo/${worktreeRelPath}`;
+    await this.waitForWorktreePathInWarmContainer(containerWorktreePath);
 
     const args: string[] = [
       "exec",
@@ -1124,6 +1125,26 @@ export class DockerExecutor {
     return result;
   }
 
+  private async waitForWorktreePathInWarmContainer(
+    containerWorktreePath: string,
+    timeoutMs = 5_000,
+  ): Promise<void> {
+    const deadline = Date.now() + timeoutMs;
+    let lastDetail = "";
+    const command = `test -d ${shellSingleQuote(containerWorktreePath)}`;
+    while (Date.now() < deadline) {
+      const result = await this.runWarmShell(command);
+      if (result.ok) return;
+      lastDetail = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+      await this.sleep(100);
+    }
+    throw new Error(
+      `worktree path not visible inside warm container after ${timeoutMs}ms: ${containerWorktreePath}${
+        lastDetail ? ` (${lastDetail})` : ""
+      }`,
+    );
+  }
+
   private normalizeProvider(raw: string): string {
     const value = raw.trim().toLowerCase();
     if (!value) return "auto";
@@ -1450,6 +1471,9 @@ export class DockerExecutor {
       /\btemporary failure\b/i,
       /\bopenhands wrapper timed out\b/i,
       /\bjob timed out in docker executor\b/i,
+      /\bworktree path not visible inside warm container\b/i,
+      /\bchdir to cwd\b/i,
+      /\bunable to start container process\b/i,
     ];
     return transientPatterns.some((pattern) => pattern.test(text));
   }