@runuai/host 0.8.29 → 0.8.34

package/lib/agents/claude.ts

@@ -209,6 +209,13 @@ export class ClaudeSession implements AgentSession {
   private readonly proc: LineTransport;
   private readonly handlers = new Set<AgentEventHandler>();
   private closed = false;
+  // Claude's `total_cost_usd` is CUMULATIVE across the persistent session
+  // process (ADR-061 keeps one claude alive across turns), so per-turn cost is
+  // the delta from the previous turn — otherwise summing turns over-counts
+  // wildly (live 2026-07-22: a 4-turn task billed ~4x). Token counts, by
+  // contrast, are per-turn already. Reset per session; a respawn makes a fresh
+  // ClaudeSession, so this starts at 0 alongside the CLI's own counter.
+  private lastCumulativeCostUsd = 0;
 
   constructor(args: {
     taskId: string;
@@ -262,7 +269,7 @@ export class ClaudeSession implements AgentSession {
       debugLabel: `claude:${this.agentId}`,
     });
     this.proc.onLine((line) => {
-      for (const event of mapClaudeLine(line)) this.emit(event);
+      for (const event of mapClaudeLine(line)) this.emit(this.perTurnCost(event));
     });
     this.proc.onExit((code) => {
       if (this.closed) return;
@@ -301,6 +308,23 @@ export class ClaudeSession implements AgentSession {
     for (const h of this.handlers) h(event);
   }
 
+  /** Convert Claude's cumulative session cost to this turn's delta. Tokens are
+   *  already per-turn and pass through untouched. */
+  private perTurnCost(event: AgentEvent): AgentEvent {
+    if (event.type !== "turn_complete" || event.usage?.costUsd === undefined) {
+      return event;
+    }
+    const cumulative = event.usage.costUsd;
+    const delta = cumulative - this.lastCumulativeCostUsd;
+    this.lastCumulativeCostUsd = cumulative;
+    // A negative delta means the CLI's counter reset (a fresh process) — the
+    // reported value is then already this turn's cost.
+    return {
+      ...event,
+      usage: { ...event.usage, costUsd: delta >= 0 ? delta : cumulative },
+    };
+  }
+
   async send(text: string): Promise<void> {
     if (this.closed) return;
     this.proc.writeLine({

package/lib/agents/factory.ts

@@ -21,9 +21,30 @@ import "./kimi";
 import "./grok";
 import "./cursor";
 
+import { agentClisReady } from "../standard-image";
 import { factoryFor } from "./registry";
 import type { AgentSession, AgentSessionFactory } from "./types";
 
+/** Cap the wait on agentClisReady so a spawn can never hang forever if the
+ *  boot reconcile never signals (e.g. an unexpected code path). Generous —
+ *  the reconcile normally settles in seconds; this only guards a stuck boot. */
+const CLIS_READY_TIMEOUT_MS = 90_000;
+
+/** Await the shared-volume CLI reconcile, bounded by a self-clearing timeout so
+ *  neither a stuck boot nor a per-spawn timer leak can bite. */
+async function awaitAgentClisReady(): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const bound = new Promise<void>((resolve) => {
+    timer = setTimeout(resolve, CLIS_READY_TIMEOUT_MS);
+    timer.unref?.();
+  });
+  try {
+    await Promise.race([agentClisReady, bound]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 export const realAgentFactory: AgentSessionFactory = {
   create: async (args): Promise<AgentSession> => {
     const factory = factoryFor(args.agent.kind);
@@ -32,6 +53,11 @@ export const realAgentFactory: AgentSessionFactory = {
         `no agent adapter registered for kind "${args.agent.kind}"`,
       );
     }
+    // Don't spawn a CLI until the shared-volume agent CLIs are reconciled:
+    // at boot the CLI auto-upgrade briefly removes then reinstalls codex/claude,
+    // and a resume that races that window dies with "No codex executable found
+    // for nodejs X". Post-boot this is already resolved (instant).
+    await awaitAgentClisReady();
     return factory.create(args);
   },
 };

package/lib/standard-image.ts

@@ -176,17 +176,28 @@ const VOLUME_AGENT_CLIS: { bin: string; pkg: string }[] = [
  */
 async function ensureVolumeAgentClis(): Promise<void> {
   const bins = VOLUME_AGENT_CLIS.map((c) => c.bin).join(" ");
-  // Sentinel-prefixed output so login-shell init noise can't be misread as a
-  // missing bin.
+  // Probe by EXECUTING each bin (`--version`), not `command -v`. A stale asdf
+  // shim — the shim file survives in the volume but the reshim DB no longer
+  // maps it to an installed exe — passes `command -v` (the file is present and
+  // executable) yet aborts at runtime with "unknown command: codex. Perhaps
+  // you have to reshim?" (exit 1). That made a broken codex/claude read as
+  // "present," so the self-heal skipped it and every task/resume spawn failed,
+  // restart after restart (live 2026-07-22). Running the bin is the only probe
+  // that catches a stale shim. `-w /home/node` so asdf resolves the node
+  // version from /home/node/.tool-versions — the same one the repair installs
+  // against — and the sentinel prefix keeps login-shell noise from being
+  // misread as a missing bin.
   const check = await run("docker", [
     "run",
     "--rm",
+    "-w",
+    "/home/node",
     "-v",
     `${ASDF_DATA_VOLUME}:/opt/asdf-data`,
     STANDARD_IMAGE_TAG,
     "bash",
     "-lc",
-    `for b in ${bins}; do command -v "$b" >/dev/null 2>&1 || echo "UAI_MISSING:$b"; done`,
+    `for b in ${bins}; do "$b" --version >/dev/null 2>&1 || echo "UAI_MISSING:$b"; done`,
   ]);
   if (check.code !== 0) {
     console.warn(
@@ -207,7 +218,7 @@ async function ensureVolumeAgentClis(): Promise<void> {
     .join(" ");
   console.log(
     `[host-agent] repairing ${ASDF_DATA_VOLUME}: agent CLI(s) [${missing.join(", ")}] ` +
-      `missing from the shared volume — installing ${pkgs}`,
+      `broken/missing in the shared volume — reshim + install ${pkgs}`,
   );
   const repair = await run("docker", [
     "run",
@@ -225,7 +236,17 @@ async function ensureVolumeAgentClis(): Promise<void> {
     STANDARD_IMAGE_TAG,
     "bash",
     "-lc",
-    `npm install -g ${pkgs} && asdf reshim nodejs`,
+    // Reshim FIRST and with `;` (not `&&`): the common failure is a stale shim
+    // over an already-installed package, which a bare reshim fixes offline —
+    // gating it behind a network `npm install` (which may be down) would leave
+    // it broken. Then install to cover a genuinely-missing package, and reshim
+    // again for the freshly-installed one. Every step runs regardless of the
+    // previous one's exit. Final loop re-probes by execution so the exit code
+    // (and the log below) reflect whether the bins ACTUALLY run now, not just
+    // the trailing reshim's own exit.
+    `asdf reshim nodejs; npm install -g ${pkgs}; asdf reshim nodejs; ` +
+      `for b in ${bins}; do "$b" --version >/dev/null 2>&1 || ` +
+      `{ echo "UAI_STILL_BROKEN:$b" >&2; exit 1; }; done`,
   ]);
   if (repair.code === 0) {
     console.log(
@@ -313,14 +334,38 @@ export interface StandardImageResult {
   error?: string;
 }
 
+let signalClisReady: (() => void) | null = null;
+/**
+ * Resolves once ensureStandardImage has reconciled the shared-volume agent CLIs
+ * at least once (or bailed because docker is down / the build failed). The agent
+ * factory awaits this before spawning a CLI, so a boot-time resume never races
+ * the CLI auto-upgrade's brief remove-then-reinstall window — the "No codex
+ * executable found for nodejs X" (exit 2) resume failure. Post-boot it is
+ * already resolved, so the await is a no-op.
+ */
+export const agentClisReady: Promise<void> = new Promise<void>((resolve) => {
+  signalClisReady = resolve;
+});
+
 /**
  * Ensure the standard image and the shared asdf data volume exist, and that the
  * agent CLIs are present inside the volume. Builds the image only when `docker
  * image inspect` fails or the content hash is stale. Never throws — returns
  * `{ ok, error? }` so the caller decides (boot: fire-and-forget; taskUp:
- * surface the reason).
+ * surface the reason). Resolves `agentClisReady` on every exit path.
  */
 export async function ensureStandardImage(): Promise<StandardImageResult> {
+  try {
+    return await ensureStandardImageInner();
+  } finally {
+    // Always signal — even a docker-down bail — so agent spawns never hang
+    // waiting on a reconcile that will not happen this boot.
+    signalClisReady?.();
+    signalClisReady = null;
+  }
+}
+
+async function ensureStandardImageInner(): Promise<StandardImageResult> {
   // 1. Shared asdf data volume — idempotent.
   const vol = await run("docker", ["volume", "create", ASDF_DATA_VOLUME]);
   if (vol.code !== 0) {
@@ -412,11 +457,15 @@ export async function ensureStandardImage(): Promise<StandardImageResult> {
     }
   }
 
-  // 3. Reconcile the agent CLIs into the shared volume (it shadows the image's
+  // 3. Reconcile the agent CLIs in the shared volume (it shadows the image's
   //    shims, so a stale volume can be missing one — the claude-127 bug).
+  //    Upgrade FIRST, self-heal LAST: the upgrade's `rm -rf`+reinstall fallback
+  //    can leave a stale shim (a failed reinstall over a removed package), so
+  //    ensureVolumeAgentClis must be the final word — it verifies every bin
+  //    actually runs and repairs whatever the upgrade left broken.
   if (imageReady) {
-    await ensureVolumeAgentClis();
     await upgradeVolumeAgentClis();
+    await ensureVolumeAgentClis();
     return { ok: true };
   }
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.29",
+  "version": "0.8.34",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",

package/runner/runner.mjs

@@ -64,11 +64,17 @@ function meta(kind, extra = {}) {
 // exports its resolved version (ASDF_NODEJS_VERSION et al.) into our env.
 // Passing that through would pin the CLI's own asdf shim to the WORKSPACE's
 // node version — "No claude executable found for nodejs X" when the agent
-// CLIs are installed under a different one. Strip ASDF_* so the CLI shim
-// resolves exactly as a direct `docker exec <cli>` would.
+// CLIs are installed under a different one. So strip the per-tool VERSION
+// PINS only (ASDF_NODEJS_VERSION, ASDF_<TOOL>_VERSION) — NOT the whole ASDF_*
+// namespace: ASDF_DATA_DIR (/opt/asdf-data) and ASDF_DIR (/opt/asdf) tell the
+// shim's `asdf exec` WHERE the tools live. Drop those and asdf falls back to
+// $HOME/.asdf (empty), so EVERY shim aborts with "unknown command: codex.
+// Perhaps you have to reshim?" (exit 1) — the codex/claude resume failure on
+// every host restart, host 0.8.32. `ASDF_VERSION` (asdf's own version) has no
+// middle segment, so the pin regex leaves it — harmless either way.
 const cliEnv = { ...process.env };
 for (const key of Object.keys(cliEnv)) {
-  if (key.startsWith("ASDF_")) delete cliEnv[key];
+  if (/^ASDF_.+_VERSION$/.test(key)) delete cliEnv[key];
 }
 
 const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"], env: cliEnv });

package/scripts/agent/task-up.sh

@@ -206,6 +206,15 @@ while IFS= read -r project_obj; do
     # (found live 2026-07-21). The task branch and any uncommitted work are
     # exactly what the user expects back.
     log "worktree for $project_slug already present — resuming with it"
+    # Self-heal an ORPHANED worktree. The bare mirror is shared by every task
+    # on this project, so a prune of it (auto-gc, or a sibling's task-down)
+    # can delete THIS worktree's admin dir (repo.git/worktrees/<name>) while
+    # its working tree is momentarily unreachable — e.g. the re-mount window on
+    # resume. The .git file is then a dangling pointer and every in-container
+    # git op dies "fatal: not a git repository" (found live 2026-07-24, a
+    # blocked agent unable to commit). `git worktree repair` rebuilds the admin
+    # dir from the intact working tree; it is a no-op when the link is healthy.
+    git -C "$mirror_dir" worktree repair "$worktree_target" 2>/dev/null || true
   elif git -C "$mirror_dir" rev-parse --verify --quiet \
        "refs/remotes/origin/$project_default" >/dev/null 2>&1; then
     # Normal case: branch the task worktree off origin/<defaultBranch>.