@pushpalsdev/cli 1.0.22 → 1.0.24

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();
@@ -2154,6 +2158,52 @@ function stopRuntimeServices(services) {
     } catch {}
   }
 }
+function resolveGracefulShutdownPriority(name) {
+  if (name === "source_control_manager")
+    return 0;
+  if (name === "remotebuddy")
+    return 1;
+  if (name === "localbuddy")
+    return 2;
+  return 3;
+}
+async function waitForRuntimeServicesExit(services, timeoutMs) {
+  if (services.length === 0)
+    return true;
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (Date.now() < deadline) {
+    if (services.every((service) => service.exited))
+      return true;
+    await Bun.sleep(100);
+  }
+  return services.every((service) => service.exited);
+}
+async function stopRuntimeServicesGracefully(services, timeoutMs = 1e4) {
+  if (services.length === 0)
+    return;
+  const running = services.filter((service) => !service.exited);
+  if (running.length === 0)
+    return;
+  const ordered = [...running].sort((a, b) => resolveGracefulShutdownPriority(a.name) - resolveGracefulShutdownPriority(b.name));
+  const nonServer = ordered.filter((service) => service.name !== "server");
+  const server = ordered.filter((service) => service.name === "server");
+  for (const service of nonServer) {
+    try {
+      service.proc.kill("SIGTERM");
+    } catch {}
+  }
+  await waitForRuntimeServicesExit(nonServer, Math.max(1000, timeoutMs - 2000));
+  for (const service of server) {
+    try {
+      service.proc.kill("SIGTERM");
+    } catch {}
+  }
+  await waitForRuntimeServicesExit(server, Math.min(3000, timeoutMs));
+  const remaining = ordered.filter((service) => !service.exited);
+  if (remaining.length > 0) {
+    stopRuntimeServices(remaining);
+  }
+}
 function prependExecutableDirToPath(env, executablePath, platform = process.platform) {
   const resolvedPath = String(executablePath ?? "").trim();
   if (!resolvedPath)
@@ -2700,7 +2750,7 @@ function removeCliClearTarget(target) {
     };
   }
 }
-async function requestLocalRuntimeShutdownForClear(serverUrl, repoRoot) {
+async function requestLocalRuntimeShutdown(serverUrl, repoRoot, reason) {
   if (!await probeServer(serverUrl)) {
     return { attempted: false, accepted: false };
   }
@@ -2717,7 +2767,7 @@ async function requestLocalRuntimeShutdownForClear(serverUrl, repoRoot) {
     const response = await fetchWithTimeout(`${serverUrl}/admin/shutdown`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ reason: "pushpals --clear" })
+      body: JSON.stringify({ reason })
     }, 5000);
     if (!response.ok) {
       const detail = await response.text().catch(() => "");
@@ -2738,7 +2788,7 @@ async function requestLocalRuntimeShutdownForClear(serverUrl, repoRoot) {
 }
 async function clearPushpalsState(opts) {
   console.log("[pushpals] Clear requested. Removing repo-local PushPals state.");
-  const shutdown = await requestLocalRuntimeShutdownForClear(opts.serverUrl, opts.repoRoot);
+  const shutdown = await requestLocalRuntimeShutdown(opts.serverUrl, opts.repoRoot, "pushpals --clear");
   if (shutdown.attempted && shutdown.accepted) {
     console.log("[pushpals] Local runtime shutdown accepted; waiting for services to exit...");
     await Bun.sleep(1500);
@@ -3875,6 +3925,22 @@ async function main() {
     stopRuntimeServices(autoStartedServices);
     autoStartedServices = [];
   };
+  const stopAutoStartedServicesGracefully = async (reason) => {
+    if (autoStartedServices.length === 0)
+      return;
+    const services = autoStartedServices;
+    autoStartedServices = [];
+    const shutdown = await requestLocalRuntimeShutdown(serverUrl, repoRoot, reason);
+    if (shutdown.attempted && shutdown.accepted) {
+      console.log("[pushpals] Local runtime shutdown accepted; waiting for services to exit...");
+      await Bun.sleep(1500);
+    } else if (shutdown.attempted) {
+      console.warn(`[pushpals] Local runtime shutdown request was not accepted${shutdown.detail ? `: ${shutdown.detail}` : "."}`);
+    } else if (shutdown.detail) {
+      console.warn(`[pushpals] ${shutdown.detail}`);
+    }
+    await stopRuntimeServicesGracefully(services);
+  };
   let serverHealthy = await probeServer(serverUrl);
   const serverWasAlreadyHealthy = serverHealthy;
   if (!serverHealthy && workerpalDockerPrecheck.status === "failed") {
@@ -4042,26 +4108,36 @@ ${line}
     console.log(line);
   };
   const streamTask = parsed.noStream ? Promise.resolve() : parsed.runtimeOnly ? Promise.resolve() : runSessionStream(serverUrl, activeSessionId, cliClient, printIncoming, streamAbort.signal);
-  let shuttingDown = false;
+  let stopPromise = null;
   const requestStop = () => {
-    if (shuttingDown)
-      return;
-    shuttingDown = true;
-    console.log("[pushpals] Shutting down CLI session...");
-    streamAbort.abort();
-    if (rl)
-      rl.close();
-    try {
-      monitoringHub?.stop();
-    } catch {}
-    if (autoStartedServices.length > 0) {
-      console.log("[pushpals] Stopping embedded runtime services...");
-    }
-    stopAutoStartedServices();
+    if (stopPromise)
+      return stopPromise;
+    stopPromise = (async () => {
+      console.log("[pushpals] Shutting down CLI session...");
+      streamAbort.abort();
+      const activeRl = rl;
+      rl = null;
+      if (activeRl)
+        activeRl.close();
+      try {
+        monitoringHub?.stop();
+      } catch {}
+      if (autoStartedServices.length > 0) {
+        console.log("[pushpals] Stopping embedded runtime services...");
+      }
+      await stopAutoStartedServicesGracefully("pushpals CLI exit");
+    })();
+    return stopPromise;
   };
-  process.once("SIGINT", requestStop);
-  process.once("SIGTERM", requestStop);
-  process.once("exit", requestStop);
+  process.once("SIGINT", () => {
+    requestStop();
+  });
+  process.once("SIGTERM", () => {
+    requestStop();
+  });
+  process.once("exit", () => {
+    stopAutoStartedServices();
+  });
   if (parsed.runtimeOnly) {
     console.log("[pushpals] Runtime-only mode is active. Send `exit` on stdin or terminate the process to stop.");
     await new Promise((resolveStop) => {
@@ -4091,7 +4167,7 @@ ${line}
         finish();
       });
     });
-    requestStop();
+    await requestStop();
     await Promise.race([streamTask, Bun.sleep(2000)]);
     return;
   }
@@ -4109,7 +4185,7 @@ ${line}
       continue;
     }
     if (isCliExitCommand(text)) {
-      requestStop();
+      await requestStop();
       break;
     }
     if (text === "/hub") {
@@ -4149,7 +4225,7 @@ ${line}
     }
     rl.prompt();
   }
-  requestStop();
+  await requestStop();
   await Promise.race([streamTask, Bun.sleep(2000)]);
 }
 if (import.meta.main) {
@@ -4171,6 +4247,7 @@ export {
   resolveCliLocalBuddyAutostart,
   resolveBundledRuntimeAssetSource,
   resolveBundledMonitoringHubRoot,
+  repoLooksLikePushPalsSourceCheckout,
   prepareEmbeddedWorkerpalDockerImageIfNeeded,
   prepareCliRuntime,
   precheckWorkerpalDockerAvailability,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "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

package/runtime/configs/local.example.toml

@@ -8,7 +8,7 @@
 
 [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
@@ -16,7 +16,7 @@ reasoning_effort = "high"
 
 [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
@@ -42,7 +42,7 @@ 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

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,19 @@ _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"}
+
+
+def _model_supports_xhigh_reasoning(model: str) -> bool:
+    normalized = str(model or "").strip().lower()
+    if not normalized:
+        return False
+    return not (
+        normalized == "gpt-5.4"
+        or normalized.startswith("gpt-5.4-")
+        or normalized == "codex-1p"
+        or normalized.startswith("codex-1p-")
+    )
 
 
 @dataclass(frozen=True)
@@ -188,12 +201,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:
@@ -320,14 +328,21 @@ def _resolve_communicate_timeout_seconds(config: OpenAICodexRuntimeConfig) -> Op
     return max(1, timeout_ms // 1000)
 
 
-def _resolve_reasoning_effort(config: OpenAICodexRuntimeConfig) -> str:
+def _resolve_reasoning_effort(config: OpenAICodexRuntimeConfig, model: str = DEFAULT_CODEX_MODEL) -> str:
     raw = config.reasoning_effort
     normalized = str(raw).strip().lower()
+    if normalized in {"extra high", "extra-high", "extrahigh", "x-high"}:
+        normalized = "xhigh"
+    if normalized == "xhigh" and not _model_supports_xhigh_reasoning(model):
+        log.info(
+            f"Downgrading workerpals.openai_codex.reasoning_effort='xhigh' to 'high' for model {model!r}."
+        )
+        return "high"
     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 'high'. Allowed: low, medium, high, xhigh."
     )
     return "high"
 
@@ -419,6 +434,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 +678,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 +711,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 +788,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 +812,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:
@@ -873,7 +1023,7 @@ def _run_codex_task(
     )
     # JSON event output is noisy by default; prefer plain text + output-last-message.
     use_json = runtime_config.json_output
-    reasoning_effort = _resolve_reasoning_effort(runtime_config)
+    reasoning_effort = _resolve_reasoning_effort(runtime_config, model)
     communicate_timeout_s = _resolve_communicate_timeout_seconds(runtime_config)
     prompt = _build_instruction(instruction, supplemental_guidance)
     baseline_changes = summarize_git_changes(repo)
@@ -1125,6 +1275,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 +1294,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 +1307,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 +1317,7 @@ def _run_codex_task(
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(stderr),
                 "exitCode": 1,
+                "usage": usage,
             }
 
         exit_code = int(return_code)
@@ -1177,6 +1334,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 +1357,7 @@ def _run_codex_task(
                 "stdout": _truncate(stdout),
                 "stderr": _truncate(detail),
                 "exitCode": 5,
+                "usage": usage,
             }
 
         changed_paths = summarize_git_changes(repo)
@@ -1220,6 +1379,7 @@ def _run_codex_task(
                 "stdout": "\n\n".join(stdout_parts),
                 "stderr": "",
                 "exitCode": 0,
+                "usage": usage,
             }
 
         if not stdout_parts:
@@ -1230,6 +1390,7 @@ def _run_codex_task(
             "stdout": "\n\n".join(stdout_parts),
             "stderr": "",
             "exitCode": 0,
+            "usage": usage,
         }