@runuai/host 0.8.28 → 0.8.33

package/lib/agents/claude.ts

@@ -23,12 +23,12 @@
 import { newId } from "../ulid";
 import { createAgentTransport, type LineTransport } from "./transport";
 import { register } from "./registry";
+import { extractResultUsage } from "./usage";
 import type {
   AgentEvent,
   AgentEventHandler,
   AgentKind,
   AgentSession,
-  AgentUsage,
   RosterAgent,
 } from "./types";
 
@@ -60,32 +60,6 @@ function isObj(v: unknown): v is Record<string, unknown> {
   return typeof v === "object" && v !== null;
 }
 
-function num(v: unknown): number | undefined {
-  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
-}
-
-/**
- * Token + cost accounting from a Claude `result` line. Claude Code reports the
- * exact `total_cost_usd` (no estimation needed) plus a token `usage` breakdown
- * and per-model `modelUsage`. The billed model is the single modelUsage key
- * (or, on a multi-model turn, joined).
- */
-function claudeUsage(json: Record<string, unknown>): AgentUsage | undefined {
-  const u = isObj(json.usage) ? json.usage : {};
-  const cost = num(json.total_cost_usd);
-  const models = isObj(json.modelUsage) ? Object.keys(json.modelUsage) : [];
-  const usage: AgentUsage = {
-    model: models.length ? models.join(", ") : undefined,
-    inputTokens: num(u.input_tokens),
-    outputTokens: num(u.output_tokens),
-    cacheReadTokens: num(u.cache_read_input_tokens),
-    cacheCreateTokens: num(u.cache_creation_input_tokens),
-    costUsd: cost,
-  };
-  // Nothing usable reported → omit rather than send an empty object.
-  return Object.values(usage).some((v) => v !== undefined) ? usage : undefined;
-}
-
 /**
  * Map one stream-json stdout line to zero or more AgentEvents.
  *
@@ -146,7 +120,7 @@ export function mapClaudeLine(raw: string): AgentEvent[] {
   // --- turn result ------------------------------------------------------
   if (type === "result") {
     const text = typeof json.result === "string" ? json.result : "";
-    const usage = claudeUsage(json);
+    const usage = extractResultUsage(json);
     if (json.is_error === true) {
       // An errored turn still cost tokens — meter it.
       return [
@@ -235,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;
@@ -288,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;
@@ -327,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/cursor.ts

@@ -31,11 +31,13 @@ import { spawn, type ChildProcess } from "node:child_process";
 
 import { newId } from "../ulid";
 import { register } from "./registry";
+import { extractResultUsage } from "./usage";
 import type {
   AgentEvent,
   AgentEventHandler,
   AgentKind,
   AgentSession,
+  AgentUsage,
   RosterAgent,
 } from "./types";
 
@@ -83,6 +85,9 @@ export interface MappedCursorLine {
   finalText?: string;
   sessionId?: string;
   errorText?: string;
+  /** Token/cost from the result envelope — Cursor uses the Claude-compatible
+   *  shape (usage + total_cost_usd + modelUsage). ADR-071 metering. */
+  usage?: AgentUsage;
 }
 
 export function mapCursorLine(line: string): MappedCursorLine {
@@ -131,6 +136,7 @@ export function mapCursorLine(line: string): MappedCursorLine {
           ? m.result
           : "cursor turn failed"
         : undefined,
+      usage: extractResultUsage(m),
     };
   }
   // thinking / user / other → nothing.
@@ -235,6 +241,9 @@ export class CursorSession implements AgentSession {
     let acc = "";
     let sawText = false;
     let buf = "";
+    // Usage rides the result line but turn_complete fires on process exit;
+    // capture it here and attach it below (ADR-071 metering).
+    let turnUsage: AgentUsage | undefined;
     const consume = (chunk: string): void => {
       buf += chunk;
       let nl: number;
@@ -279,6 +288,7 @@ export class CursorSession implements AgentSession {
           });
         }
         if (m.end) {
+          if (m.usage) turnUsage = m.usage;
           if (m.errorText) this.emit({ type: "error", message: m.errorText });
           const finalText = m.finalText ?? acc;
           if (sawText || finalText) {
@@ -307,7 +317,7 @@ export class CursorSession implements AgentSession {
             message: `cursor exited ${code ?? "null"}${tail ? `: ${tail}` : ""}`,
           });
         }
-        this.emit({ type: "turn_complete" });
+        this.emit({ type: "turn_complete", usage: turnUsage });
         resolve();
       };
       child.on("exit", (code) => finish(code));

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/agents/usage.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared token/cost extraction for the Claude-Code-compatible stream-json
+ * `result` envelope (ADR-071 metering). Claude Code AND Cursor Agent both emit
+ * this exact shape — `usage` token breakdown, an exact `total_cost_usd`, and
+ * per-model `modelUsage` — so both engines share this one extractor.
+ *
+ * Codex (app-server protocol) and Kimi/Grok (plain text streams) report no
+ * token/cost data, so they have no extractor.
+ */
+
+import type { AgentUsage } from "./types";
+
+function isObj(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null;
+}
+
+function num(v: unknown): number | undefined {
+  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+
+/** Pull AgentUsage from a `result` line, or undefined when none is reported. */
+export function extractResultUsage(
+  json: Record<string, unknown>,
+): AgentUsage | undefined {
+  const u = isObj(json.usage) ? json.usage : {};
+  const models = isObj(json.modelUsage) ? Object.keys(json.modelUsage) : [];
+  const usage: AgentUsage = {
+    model: models.length ? models.join(", ") : undefined,
+    inputTokens: num(u.input_tokens),
+    outputTokens: num(u.output_tokens),
+    cacheReadTokens: num(u.cache_read_input_tokens),
+    cacheCreateTokens: num(u.cache_creation_input_tokens),
+    costUsd: num(json.total_cost_usd),
+  };
+  // Nothing usable reported → omit rather than send an empty object.
+  return Object.values(usage).some((v) => v !== undefined) ? usage : undefined;
+}

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.28",
+  "version": "0.8.33",
   "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 });