@codexhost/cli-darwin-x64 0.13.0 → 0.13.2

package/app/host-runtime.mjs

@@ -4295,9 +4295,11 @@ async function runDelegationCli(input) {
           "INVALID_ARGUMENT",
           "--host conflicts with the Thread reference"
         );
+      const caller = command === "read" ? callerThreadId(environment) : void 0;
       const body = {
         ...reference,
         ...hostId2 ? { hostId: hostId2 } : {},
+        ...caller ? { callerThreadId: normalizeThreadId(caller) } : {},
         view,
         ...value(parsed2, "--cursor") ? { cursor: value(parsed2, "--cursor") } : {},
         ...value(parsed2, "--limit") ? { limit: positiveInteger(value(parsed2, "--limit"), "--limit", MAX_LIMIT) } : {},
@@ -4434,6 +4436,7 @@ import {
   realpath,
   stat,
   readdir as readdir2,
+  unlink,
   writeFile as writeFile3
 } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -4894,39 +4897,25 @@ async function regularFile(filePath) {
     throw error51;
   }
 }
-async function isUpdateOperationActive(stateDirectory) {
+async function discoverActiveUpdateStatus(stateDirectory) {
   if (!path4.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
-  return regularFile(path4.join(stateDirectory, LOCK_FILE));
-}
-async function discoverLatestUpdateStatus(stateDirectory) {
-  if (!path4.isAbsolute(stateDirectory))
-    throw new Error("update state directory must be absolute");
-  let entries;
+  const lockPath = path4.join(stateDirectory, LOCK_FILE);
+  if (!await regularFile(lockPath))
+    return null;
   try {
-    entries = await readdir(stateDirectory, { withFileTypes: true });
-  } catch (error51) {
-    if (error51.code === "ENOENT")
+    const lock = JSON.parse(await readFile3(lockPath, "utf8"));
+    if (typeof lock.statusPath !== "string" || !path4.isAbsolute(lock.statusPath))
       return null;
-    throw error51;
-  }
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
-      continue;
-    const statusPath = path4.join(stateDirectory, entry.name, STATUS_FILE);
-    if (!await regularFile(statusPath))
-      continue;
-    try {
-      candidates.push({
-        statusPath,
-        status: parseUpdateStatus(JSON.parse(await readFile3(statusPath, "utf8")))
-      });
-    } catch {
-    }
+    if (!await regularFile(lock.statusPath))
+      return null;
+    const status2 = parseUpdateStatus(JSON.parse(await readFile3(lock.statusPath, "utf8")));
+    if (TERMINAL_PHASES.has(status2.phase))
+      return null;
+    return { statusPath: lock.statusPath, status: status2 };
+  } catch {
+    return null;
   }
-  candidates.sort((left, right) => right.status.updatedAt - left.status.updatedAt);
-  return candidates[0] ?? null;
 }
 async function cleanupTerminalUpdateState(stateDirectory, options2 = {}) {
   const now = Math.floor((options2.now ?? Date.now()) / 1e3);
@@ -5124,6 +5113,48 @@ async function verifyDownloadedArtifact(source, filePath, result) {
   }
 }
 
+// packages/update-manager/dist/updater-ready.js
+import { setTimeout as delay } from "node:timers/promises";
+async function waitForUpdaterReady(child, readStatus, timeoutMs = 1e4) {
+  let failure;
+  const onError = (error51) => {
+    failure = error51;
+  };
+  const onExit = () => {
+    failure = new Error("Background Updater exited before completing handoff");
+  };
+  child.on("error", onError);
+  child.on("exit", onExit);
+  const deadline = performance.now() + timeoutMs;
+  try {
+    while (true) {
+      const status2 = await readStatus();
+      if (status2?.phase === "failed")
+        throw new Error(status2.error ?? "Background Updater failed");
+      if (failure)
+        throw failure;
+      if (child.exitCode != null || child.signalCode != null) {
+        throw new Error("Background Updater exited before completing handoff");
+      }
+      if (status2?.phase === "waiting-for-exit")
+        return;
+      if (status2 && status2.phase !== "prepared") {
+        throw new Error(`Unexpected Updater phase during handoff: ${status2.phase}`);
+      }
+      if (performance.now() >= deadline) {
+        throw new Error("Background Updater did not confirm handoff before the startup timeout");
+      }
+      await delay(20);
+    }
+  } catch (error51) {
+    child.kill();
+    throw error51;
+  } finally {
+    child.removeListener("error", onError);
+    child.removeListener("exit", onExit);
+  }
+}
+
 // packages/update-manager/dist/update-manager.js
 var REQUEST_SCHEMA_VERSION = 1;
 var WINDOWS_RENAME_RETRY_DELAYS_MS = [10, 30, 70, 150, 300];
@@ -5133,7 +5164,7 @@ function errorMessage(error51) {
 function systemErrorCode(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 ? String(error51.code) : null;
 }
-function delay(milliseconds) {
+function delay2(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 async function replaceStatusFile(temporaryPath, statusPath) {
@@ -5149,7 +5180,7 @@ async function replaceStatusFile(temporaryPath, statusPath) {
         throw error51;
       }
       retryIndex += 1;
-      await delay(retryDelay);
+      await delay2(retryDelay);
     }
   }
 }
@@ -5369,14 +5400,20 @@ function createBackgroundUpdateManager(dependencies2 = {}) {
         app_path: appPath
       }, artifact.artifactPath);
     },
-    start(prepared) {
+    async start(prepared) {
       if (!preparedRequests.delete(prepared.requestPath)) {
         throw new Error("background update was not prepared by this manager or was already started");
       }
-      const child = spawnUpdater(prepared.helperPath, prepared.requestPath);
-      if (child.pid === void 0)
-        throw new Error("background Updater did not report a process ID");
-      return Object.freeze({ ...prepared, updaterPid: child.pid });
+      try {
+        const child = spawnUpdater(prepared.helperPath, prepared.requestPath);
+        await waitForUpdaterReady(child, () => this.readStatus(prepared.statusPath));
+        if (child.pid === void 0)
+          throw new Error("background Updater did not report a process ID");
+        return Object.freeze({ ...prepared, updaterPid: child.pid });
+      } catch (error51) {
+        await writeFailedStatus(prepared.statusPath, prepared.version, prepared.installation, error51);
+        throw error51;
+      }
     },
     async readStatus(statusPathValue) {
       const statusPath = requireAbsolutePath(statusPathValue, "update status path");
@@ -19909,6 +19946,7 @@ config(en_default());
 var REMOTE_THREAD_REPLY_MAX_BYTES = 16 * 1024 * 1024;
 var REMOTE_THREAD_CONTROL_TIMEOUT_MS = 4e4;
 var DELEGATION_READ_METHOD = "codexhost/thread/delegation-read";
+var THREAD_REFERENCE_SOURCE_HOST_PARAM = "codexhostSourceHostId";
 var delegationReadParamsSchema = external_exports.strictObject({
   threadId: external_exports.string().min(1).max(1024),
   view: external_exports.enum(["result", "messages"]),
@@ -20071,6 +20109,8 @@ var usageStatisticsSessionSchema = external_exports.strictObject({
   harness,
   sessionId: external_exports.string().min(1).max(512),
   project: project.nullable(),
+  /** Persisted Desktop title for a mapped Session, otherwise its native name; may be absent. */
+  title: external_exports.string().min(1).max(200).optional(),
   /** Models the session used, most requests first. */
   models: external_exports.array(model).max(16),
   firstAtMs: count,
@@ -20137,7 +20177,12 @@ var usageStatisticsResultSchema = external_exports.strictObject({
    * The sessions that spent the most, by cost and by tokens without cache, all filters applied;
    * requests without a native session are not listed here but count everywhere else.
    */
-  sessions: external_exports.array(usageStatisticsSessionSchema).max(100)
+  sessions: external_exports.array(usageStatisticsSessionSchema).max(100),
+  /**
+   * The sessions last active in the range, newest first, all filters applied. Optional for older
+   * Hosts; missing is treated as no list rather than no sessions.
+   */
+  recentSessions: external_exports.array(usageStatisticsSessionSchema).max(100).optional()
 });
 
 // packages/shared-contracts/dist/ids.js
@@ -21426,14 +21471,37 @@ var RuntimeMaintenance = class {
       options2.environment.CODEXHOST_DATA_DIR ?? path7.join(home, ".codexhost", "remote", "data"),
       "remote-update.json"
     );
+    this.#cancelPath = path7.join(path7.dirname(this.#statusPath), "remote-update.cancel");
   }
   options;
   #running;
   #statusPath;
+  #cancelPath;
   #update = { phase: "idle", targetVersion: null, error: null };
   #blocked = false;
+  #watch = null;
   #starting = null;
   #startingVersion = null;
+  #ensureWatching() {
+    if (this.#watch) return;
+    this.#watch = setInterval(() => {
+      void this.status().catch(() => void 0).then(() => {
+        if (!this.#blocked && this.#watch) {
+          clearInterval(this.#watch);
+          this.#watch = null;
+        }
+      });
+    }, UPDATER_WATCH_INTERVAL_MS);
+    this.#watch.unref();
+  }
+  async #recordStartFailure(version2, failure) {
+    await writeFile3(this.#cancelPath, JSON.stringify({ targetVersion: version2 }), { mode: 384 });
+    await writeFile3(
+      this.#statusPath,
+      JSON.stringify({ phase: "failed", targetVersion: version2, error: failure }),
+      { mode: 384 }
+    );
+  }
   #sshPending = /* @__PURE__ */ new Set();
   async setupSsh(input) {
     if (this.options.remote) throw new Error("SSH installation must run from the local computer");
@@ -21494,7 +21562,7 @@ var RuntimeMaintenance = class {
       installation(this.options.runtimePath, this.options.environment),
       this.#resources()
     ]);
-    if (this.#update.phase === "idle" || this.#blocked) {
+    if (this.#update.phase === "idle" || this.#blocked || this.#update.phase === "failed") {
       try {
         const value2 = JSON.parse(await readFile5(this.#statusPath, "utf8"));
         const parsed2 = runtimeStatusSchema.shape.update.parse(value2);
@@ -21517,8 +21585,15 @@ var RuntimeMaintenance = class {
             parsed2.error = "The previous remote update was interrupted; retry the update";
           }
         }
-        if (this.#update === observedUpdate) this.#update = parsed2;
-        if (["failed", "succeeded"].includes(this.#update.phase)) this.#blocked = false;
+        if (this.#update === observedUpdate) {
+          this.#update = parsed2;
+          if (["installing", "restarting"].includes(this.#update.phase)) {
+            this.#blocked = true;
+            this.#ensureWatching();
+          } else if (["failed", "succeeded"].includes(this.#update.phase)) {
+            this.#blocked = false;
+          }
+        }
       } catch {
       }
     }
@@ -21590,6 +21665,7 @@ var RuntimeMaintenance = class {
     await chmod2(helper, 448);
     const request = path7.join(work, "request.json");
     this.#update = { phase: "installing", targetVersion: version2, error: null };
+    await unlink(this.#cancelPath).catch(() => void 0);
     await writeFile3(this.#statusPath, JSON.stringify(this.#update), { mode: 384 });
     await writeFile3(
       request,
@@ -21608,35 +21684,38 @@ var RuntimeMaintenance = class {
     );
     const starter = spawn3(
       "/bin/sh",
-      ["-c", '"$0" remote --request "$1" </dev/null >/dev/null 2>&1 &', helper, request],
-      { detached: true, stdio: "ignore", env: this.options.environment }
+      ["-c", '"$0" remote --request "$1" </dev/null >/dev/null 2>&1 & echo $!', helper, request],
+      { detached: true, stdio: ["ignore", "pipe", "ignore"], env: this.options.environment }
     );
+    let pidOutput = "";
+    starter.stdout?.on("data", (chunk) => {
+      pidOutput += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    });
     await new Promise((resolve, reject) => {
       starter.once("error", reject);
       starter.once(
-        "exit",
+        "close",
         (code) => code === 0 ? resolve() : reject(new Error("Remote updater could not be started"))
       );
     });
+    const helperPid = Number.parseInt(pidOutput.trim(), 10);
+    if (!Number.isSafeInteger(helperPid) || helperPid <= 0) {
+      throw new Error("Remote updater could not be started");
+    }
     const deadline = Date.now() + UPDATER_START_TIMEOUT_MS;
     while (!await this.#helperReported()) {
       if (Date.now() >= deadline) {
+        try {
+          process.kill(helperPid);
+        } catch {
+        }
         const failure = "Remote updater did not start";
-        await writeFile3(
-          this.#statusPath,
-          JSON.stringify({ phase: "failed", targetVersion: version2, error: failure }),
-          { mode: 384 }
-        );
+        await this.#recordStartFailure(version2, failure);
         throw new Error(failure);
       }
       await new Promise((resolve) => setTimeout(resolve, 50));
     }
-    const watch = setInterval(() => {
-      void this.status().catch(() => void 0).then(() => {
-        if (!this.#blocked) clearInterval(watch);
-      });
-    }, UPDATER_WATCH_INTERVAL_MS);
-    watch.unref();
+    this.#ensureWatching();
   }
   async #helperReported() {
     try {
@@ -21650,6 +21729,7 @@ var RuntimeMaintenance = class {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes as randomBytes4 } from "node:crypto";
+import { statSync } from "node:fs";
 import path37 from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -26894,61 +26974,6 @@ function finitePercent(value2) {
 function optionalReset(value2) {
   return nonNegativeSafeInteger(value2);
 }
-function addBreakdown(target, source) {
-  if (!source)
-    return;
-  const fields = [
-    ["totalTokens", "totalTokens"],
-    ["inputTokens", "inputTokens"],
-    ["cachedInputTokens", "cachedInputTokens"],
-    ["cacheWriteInputTokens", "cacheWriteInputTokens"],
-    ["outputTokens", "outputTokens"],
-    ["reasoningOutputTokens", "reasoningOutputTokens"]
-  ];
-  for (const [sourceField, targetField] of fields) {
-    const value2 = nonNegativeSafeInteger(source[sourceField]);
-    if (value2 !== void 0)
-      target[targetField] = value2;
-  }
-}
-function observeCodexTokenUsage(value2) {
-  if (!isRecord9(value2) || value2.method !== "thread/tokenUsage/updated")
-    return null;
-  const params = value2.params;
-  if (!isRecord9(params))
-    return null;
-  const threadId2 = hostThreadIdSchema.safeParse(params.threadId);
-  const turnId = hostTurnIdSchema.safeParse(params.turnId);
-  if (!threadId2.success || !turnId.success)
-    return null;
-  const tokenUsage = params.tokenUsage;
-  if (!isRecord9(tokenUsage))
-    return null;
-  const total = isRecord9(tokenUsage.total) ? tokenUsage.total : void 0;
-  const last = isRecord9(tokenUsage.last) ? tokenUsage.last : void 0;
-  const usage = {};
-  addBreakdown(usage, total);
-  const contextUsedTokens = nonNegativeSafeInteger(last?.totalTokens);
-  const contextWindowTokens = nonNegativeSafeInteger(tokenUsage.modelContextWindow);
-  if (contextUsedTokens !== void 0 && contextWindowTokens !== void 0 && contextWindowTokens > 0) {
-    usage.contextUsedTokens = contextUsedTokens;
-    usage.contextWindowTokens = contextWindowTokens;
-  }
-  const inputTokens = nonNegativeSafeInteger(last?.inputTokens);
-  const cachedInputTokens = nonNegativeSafeInteger(last?.cachedInputTokens);
-  if (inputTokens !== void 0 && cachedInputTokens !== void 0 && inputTokens > 0) {
-    usage.cacheHitRatePercent = Math.min(100, cachedInputTokens / inputTokens * 100);
-  }
-  try {
-    return {
-      threadId: threadId2.data,
-      turnId: turnId.data,
-      usage: parseHostUsage(usage)
-    };
-  } catch {
-    return null;
-  }
-}
 function parseRateLimitWindow(value2) {
   if (!isRecord9(value2))
     return null;
@@ -31759,6 +31784,16 @@ var ExternalThreadIdleRelease = class {
     const state = this.#activity.get(thread);
     if (state) state.outputFailed = true;
   }
+  /** After a successful Session revival, allow idle release again. */
+  clearOutputFailed(thread) {
+    const state = this.#activity.get(thread);
+    if (state) {
+      state.outputFailed = false;
+      state.lastActivity = Date.now();
+    } else {
+      this.touch(thread);
+    }
+  }
   failure(thread) {
     return this.#activity.get(thread)?.closeFailed ? CLOSE_FAILURE : void 0;
   }
@@ -31907,6 +31942,80 @@ var ExternalThreadIdleRelease = class {
   }
 };
 
+// packages/host-runtime/src/external-thread-lifecycle.ts
+var RELEASE_TIMEOUT_MS = 6e4;
+var ExternalSessionReleaseError = class extends Error {
+  constructor(cause) {
+    super(
+      "External Session shutdown could not be confirmed. Retry to confirm release; recovery is blocked until the old Session closes and its output drains. If the Harness cannot retry shutdown, stop residual processes and restart Codex Desktop.",
+      { cause }
+    );
+    this.name = "ExternalSessionReleaseError";
+  }
+};
+var ExternalThreadLifecycle = class {
+  #pending = /* @__PURE__ */ new Map();
+  #closing = /* @__PURE__ */ new WeakMap();
+  #releasing = /* @__PURE__ */ new Map();
+  busy(id2) {
+    return this.#pending.has(id2) || this.#releasing.has(id2);
+  }
+  pending() {
+    return [...this.#pending];
+  }
+  run(id2, operation) {
+    const previous = this.#pending.get(id2) ?? Promise.resolve();
+    const task = previous.then(async () => {
+      const releasing = this.#releasing.get(id2);
+      if (releasing) await this.release(id2, releasing.session, releasing.output);
+      return operation();
+    });
+    const settled = task.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#pending.set(id2, settled);
+    void settled.then(() => {
+      if (this.#pending.get(id2) === settled) this.#pending.delete(id2);
+    });
+    return task;
+  }
+  /** Call inside the Thread's lifecycle operation. A timeout never cancels the owned close. */
+  async release(id2, session, output) {
+    this.#releasing.set(id2, { session, output });
+    let closing = this.#closing.get(session);
+    if (!closing) {
+      closing = Promise.resolve().then(() => session.close());
+      this.#closing.set(session, closing);
+      const attempt = closing;
+      void closing.catch(() => {
+        if (this.#closing.get(session) === attempt) this.#closing.delete(session);
+      });
+    }
+    let timeout;
+    try {
+      await Promise.race([
+        closing.then(() => output),
+        new Promise((_, reject) => {
+          timeout = setTimeout(
+            () => reject(new Error("Session shutdown timed out")),
+            RELEASE_TIMEOUT_MS
+          );
+          timeout.unref();
+        })
+      ]);
+      this.#releasing.delete(id2);
+    } catch (error51) {
+      throw new ExternalSessionReleaseError(error51);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  async drain() {
+    while (this.#pending.size) await Promise.all(this.#pending.values());
+  }
+};
+
 // packages/host-runtime/src/usage-metering.ts
 var TOKENS_PER_PRICE_UNIT = 1e6;
 var UsageMeter = class {
@@ -31922,6 +32031,8 @@ var UsageMeter = class {
   #turnOutputMs = 0;
   #timeToFirstOutputMs;
   #outputTokensPerSecond;
+  #timingUnavailable = false;
+  #timedRequests = /* @__PURE__ */ new Set();
   get metered() {
     return this.#metered;
   }
@@ -31938,12 +32049,53 @@ var UsageMeter = class {
     this.#requests.set(request.requestId, request);
     const duration4 = request.startedAtMs !== void 0 && request.completedAtMs !== void 0 ? request.completedAtMs - request.startedAtMs : 0;
     if (!request.historical && duration4 > 0 && activeTurnId !== null && activeTurnId === this.#turnId) {
-      this.#turnOutputTokens += request.outputTokens;
-      this.#turnOutputMs += duration4;
-      this.#outputTokensPerSecond = this.#turnOutputTokens / (this.#turnOutputMs / 1e3);
+      this.recordOutputTiming(
+        {
+          requestId: request.requestId,
+          outputTokens: request.outputTokens,
+          startedAtMs: request.startedAtMs ?? 0,
+          completedAtMs: request.completedAtMs ?? 0
+        },
+        activeTurnId
+      );
     }
     return true;
   }
+  /** Live timing is independent of history replacement and cannot create billing entries. */
+  recordOutputTiming(request, turnId) {
+    if (turnId !== this.#turnId || this.#timingUnavailable || this.#timedRequests.has(request.requestId))
+      return false;
+    if (!request.requestId || ![request.outputTokens, request.startedAtMs, request.completedAtMs].every(
+      (value2) => Number.isSafeInteger(value2) && value2 >= 0
+    ) || request.completedAtMs <= request.startedAtMs) {
+      this.invalidateOutputTiming(turnId);
+      return true;
+    }
+    this.#timedRequests.add(request.requestId);
+    this.#turnOutputTokens += request.outputTokens;
+    this.#turnOutputMs += request.completedAtMs - request.startedAtMs;
+    this.#outputTokensPerSecond = this.#turnOutputTokens / (this.#turnOutputMs / 1e3);
+    return true;
+  }
+  invalidateOutputTiming(turnId) {
+    if (turnId !== this.#turnId) return;
+    this.#timingUnavailable = true;
+  }
+  /** Discard in-flight timing across connections, but keep the last valid displayed speed. */
+  resetTurnTiming() {
+    this.#turnId = null;
+    this.#turnStartedAtMs = null;
+    this.#timeToFirstOutputMs = void 0;
+    this.#timedRequests.clear();
+    this.#timingUnavailable = false;
+  }
+  /** Replace a read-only session history after recovery, append, rollback or file replacement. */
+  replaceHistory(requests, complete) {
+    this.#requests.clear();
+    this.#invalidRecord = false;
+    for (const request of requests) this.recordRequest({ ...request, historical: true }, null);
+    this.recordHistory(complete);
+  }
   recordHistory(complete) {
     this.#metered = true;
     this.#historyComplete = complete;
@@ -31954,6 +32106,8 @@ var UsageMeter = class {
     this.#turnOutputObserved = false;
     this.#turnOutputTokens = 0;
     this.#turnOutputMs = 0;
+    this.#timedRequests.clear();
+    this.#timingUnavailable = false;
   }
   /** Returns true when this is the Turn's first visible output. */
   outputObserved(turnId, nowMs) {
@@ -31966,7 +32120,6 @@ var UsageMeter = class {
   }
   turnCompleted(turnId) {
     if (turnId !== this.#turnId) return;
-    if (this.#turnOutputMs === 0) this.#outputTokensPerSecond = void 0;
     this.#turnId = null;
     this.#turnStartedAtMs = null;
   }
@@ -32001,12 +32154,12 @@ var UsageMeter = class {
         const cacheHitRate = this.#sessionCacheHitRatePercent();
         if (cacheHitRate !== null) usage.sessionCacheHitRatePercent = cacheHitRate;
       }
-      if (this.#outputTokensPerSecond !== void 0) {
-        usage.outputTokensPerSecond = this.#outputTokensPerSecond;
-      }
     } else if (usage.totalCostUsd !== void 0) {
       usage.costSource = "native";
     }
+    if (this.#timingUnavailable) delete usage.outputTokensPerSecond;
+    if (this.#outputTokensPerSecond !== void 0)
+      usage.outputTokensPerSecond = this.#outputTokensPerSecond;
     if (this.#timeToFirstOutputMs !== void 0) {
       usage.timeToFirstOutputMs = this.#timeToFirstOutputMs;
     }
@@ -32145,6 +32298,11 @@ var ExternalThreadOpenError = class extends Error {
 function errorMessage3(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
+function recoveryError(error51) {
+  if (error51 instanceof ExternalThreadOpenError) return error51.rpcError;
+  if (error51 instanceof ExternalSessionReleaseError) return { code: -32075, message: error51.message };
+  return { code: -32076, message: "External Thread recovery failed; retry the request" };
+}
 var ExternalThreadRuntime = class {
   idleRelease;
   #adapters;
@@ -32152,7 +32310,8 @@ var ExternalThreadRuntime = class {
   #diagnose;
   #environment;
   #repository;
-  #restores = /* @__PURE__ */ new Map();
+  #lifecycle = new ExternalThreadLifecycle();
+  #hasRunningDescendants;
   #subagentRunning;
   #threads = /* @__PURE__ */ new Map();
   constructor(input) {
@@ -32162,12 +32321,13 @@ var ExternalThreadRuntime = class {
     this.#consumeOutputs = input.consumeOutputs;
     this.#diagnose = input.diagnose;
     this.#subagentRunning = input.subagentRunning ?? (() => false);
+    this.#hasRunningDescendants = input.hasRunningDescendants ?? (() => false);
     this.idleRelease = new ExternalThreadIdleRelease({
       threads: () => this.values(),
       get: (id2) => this.get(id2),
       remove: (id2) => this.remove(id2),
       queue: input.idleRelease?.queue ?? new DesktopRequestQueue(),
-      canRelease: input.idleRelease?.canRelease ?? (() => false),
+      canRelease: (thread) => !thread.sessionUnavailable && !this.#lifecycle.busy(thread.id) && (input.idleRelease?.canRelease(thread) ?? false),
       ...input.idleRelease?.onClosed ? { onClosed: input.idleRelease.onClosed } : {},
       diagnose: input.diagnose
     });
@@ -32183,7 +32343,45 @@ var ExternalThreadRuntime = class {
   }
   clear() {
     this.#threads.clear();
-    this.#restores.clear();
+  }
+  drain() {
+    return this.#lifecycle.drain();
+  }
+  #withLifecycle(threadId2, operation) {
+    return this.#lifecycle.run(threadId2, async () => {
+      await this.idleRelease.waitForClose(threadId2);
+      return operation();
+    });
+  }
+  markSessionUnavailable(thread) {
+    thread.sessionUnavailable = true;
+  }
+  #idleForRestore(thread) {
+    if (thread.running || thread.activeTurnId !== null) return false;
+    if (thread.session.hasBackgroundWork?.()) return false;
+    if (this.#hasRunningDescendants(thread.id)) return false;
+    return true;
+  }
+  async #dropIdleSession(thread) {
+    if (this.#threads.get(thread.id) !== thread) return;
+    thread.sessionUnavailable = true;
+    await this.#lifecycle.release(thread.id, thread.session, thread.outputTask);
+    if (this.#threads.get(thread.id) !== thread) return;
+    await this.#retireSubagents(thread);
+    if (this.#threads.get(thread.id) === thread) this.#threads.delete(thread.id);
+  }
+  /** Called without awaiting from the output consumer: release itself drains that consumer. */
+  async discardUnavailableIdle(thread) {
+    const session = thread.session;
+    try {
+      await this.#withLifecycle(thread.id, async () => {
+        if (this.#threads.get(thread.id) !== thread || thread.session !== session || !thread.sessionUnavailable || !this.#idleForRestore(thread))
+          return;
+        await this.#dropIdleSession(thread);
+      });
+    } catch (error51) {
+      this.#diagnose(error51);
+    }
   }
   register(input) {
     const harnessId = input.record.harnessId;
@@ -32228,7 +32426,8 @@ var ExternalThreadRuntime = class {
       ephemeralTurnIds: /* @__PURE__ */ new Set(),
       persistenceError: null,
       projectedTerminalTurnId: null,
-      ignoredInteractionIds: /* @__PURE__ */ new Set()
+      ignoredInteractionIds: /* @__PURE__ */ new Set(),
+      sessionUnavailable: false
     };
     this.idleRelease.touch(externalThread);
     externalThread.outputTask = this.#consumeOutputs(externalThread);
@@ -32255,11 +32454,12 @@ var ExternalThreadRuntime = class {
     } catch (error51) {
       this.#diagnose(error51);
     }
-    await this.#retireSubagents(current.id);
+    await this.#retireSubagents(current, true);
     this.#threads.delete(current.id);
     return this.register(input);
   }
-  async #retireSubagents(parentId) {
+  async #retireSubagents(parent, bestEffort = false) {
+    const parentId = parent.id;
     const ancestors = /* @__PURE__ */ new Map();
     const descendant = async (record4) => {
       const visited = /* @__PURE__ */ new Set();
@@ -32276,24 +32476,35 @@ var ExternalThreadRuntime = class {
       }
       return false;
     };
-    for (const [id2, restoring] of [...this.#restores]) {
-      if (await descendant(await this.#repository.find(id2))) {
-        await restoring.catch(this.#diagnose);
-      }
+    for (const [id2, pending] of this.#lifecycle.pending()) {
+      if (id2 !== parentId && await descendant(await this.#repository.find(id2))) await pending;
     }
-    for (const child of this.#threads.values()) {
+    for (const child of [...this.#threads.values()]) {
       if (!await descendant(child.record)) continue;
-      this.#threads.delete(child.id);
-      try {
-        await child.session.close();
-        await child.outputTask;
-      } catch (error51) {
-        this.#diagnose(error51);
-      }
+      const retire = async () => {
+        if (this.#threads.get(parentId) !== parent || this.#threads.get(child.id) !== child) return;
+        if (bestEffort) {
+          this.#threads.delete(child.id);
+          await child.session.close();
+          await child.outputTask;
+        } else {
+          child.sessionUnavailable = true;
+          await this.#lifecycle.release(child.id, child.session, child.outputTask);
+          if (this.#threads.get(child.id) === child) this.#threads.delete(child.id);
+        }
+      };
+      if (bestEffort) await retire().catch(this.#diagnose);
+      else await this.#withLifecycle(child.id, retire);
     }
   }
   async locate(threadId2) {
-    await this.idleRelease.waitForClose(threadId2);
+    try {
+      return await this.#withLifecycle(threadId2, () => this.#locate(threadId2));
+    } catch (error51) {
+      return { kind: "error", error: recoveryError(error51) };
+    }
+  }
+  async #locate(threadId2) {
     const loaded = this.#threads.get(threadId2);
     if (loaded) {
       const failure = this.idleRelease.failure(loaded);
@@ -32319,37 +32530,61 @@ var ExternalThreadRuntime = class {
     return { kind: "external", record: record4, thread: null };
   }
   async resolve(threadId2) {
-    const location = await this.locate(threadId2);
-    if (location.kind !== "external") return location;
-    if (location.thread) {
-      this.idleRelease.touch(location.thread);
-      return { kind: "external", thread: location.thread, historyFresh: false };
-    }
-    const { record: record4 } = location;
-    let restoring = this.#restores.get(threadId2);
-    if (!restoring) {
-      const restored = this.#threads.get(threadId2);
-      if (restored) {
-        this.idleRelease.touch(restored);
-        return { kind: "external", thread: restored, historyFresh: false };
-      }
-      restoring = this.#restore(record4).finally(() => {
-        this.#restores.delete(threadId2);
+    try {
+      return await this.#withLifecycle(threadId2, async () => {
+        const location = await this.#locate(threadId2);
+        if (location.kind !== "external") return location;
+        if (location.thread) {
+          if (location.thread.sessionUnavailable && this.#idleForRestore(location.thread)) {
+            await this.#dropIdleSession(location.thread);
+            const current = this.#threads.get(threadId2);
+            if (current) return { kind: "external", thread: current, historyFresh: false };
+          } else {
+            this.idleRelease.touch(location.thread);
+            return { kind: "external", thread: location.thread, historyFresh: false };
+          }
+        }
+        return {
+          kind: "external",
+          thread: await this.#restore(location.record),
+          historyFresh: true
+        };
       });
-      this.#restores.set(threadId2, restoring);
+    } catch (error51) {
+      return { kind: "error", error: recoveryError(error51) };
     }
+  }
+  async refresh(thread) {
     try {
-      return { kind: "external", thread: await restoring, historyFresh: true };
+      return await this.#withLifecycle(thread.id, () => this.#refresh(thread));
     } catch (error51) {
+      return recoveryError(error51);
+    }
+  }
+  async #refresh(thread) {
+    if (this.#threads.get(thread.id) !== thread) {
       return {
-        kind: "error",
-        error: error51 instanceof ExternalThreadOpenError ? error51.rpcError : { code: -32076, message: "External Thread recovery failed" }
+        code: -32076,
+        message: "External Session changed during recovery; retry the request"
       };
     }
-  }
-  async refresh(thread) {
-    const snapshot2 = await thread.session.readSnapshot();
-    if (!snapshot2.ok) return mapExternalThreadHarnessError(snapshot2.error, "read");
+    const failure = this.idleRelease.failure(thread);
+    if (failure) return { code: -32075, message: failure };
+    if (thread.sessionUnavailable && this.#idleForRestore(thread)) {
+      const revived = await this.#reviveIdleSession(thread);
+      if (revived) return revived;
+    }
+    let snapshot2 = await thread.session.readSnapshot();
+    if (!snapshot2.ok) {
+      if (snapshot2.error.code === "invalidState" && this.#idleForRestore(thread) && this.#threads.get(thread.id) === thread) {
+        const revived = await this.#reviveIdleSession(thread);
+        if (revived) return revived;
+        snapshot2 = await thread.session.readSnapshot();
+        if (!snapshot2.ok) return mapExternalThreadHarnessError(snapshot2.error, "read");
+      } else {
+        return mapExternalThreadHarnessError(snapshot2.error, "read");
+      }
+    }
     try {
       const aligned = await this.#repository.alignSnapshot(thread.record, snapshot2.value);
       thread.record = aligned.record;
@@ -32366,6 +32601,122 @@ var ExternalThreadRuntime = class {
       return { code: -32081, message: "External Thread history could not be persisted" };
     }
   }
+  async #reviveIdleSession(thread) {
+    thread.sessionUnavailable = true;
+    const harnessId = thread.record.harnessId;
+    const adapter = this.#adapters.get(harnessId);
+    if (!adapter || !thread.record.nativeSessionRef) {
+      await this.#dropIdleSession(thread);
+      return { code: -32077, message: "External Harness is unavailable" };
+    }
+    await this.#lifecycle.release(thread.id, thread.session, thread.outputTask);
+    await this.#retireSubagents(thread);
+    if (this.#threads.get(thread.id) !== thread) {
+      return { code: -32076, message: "External Thread recovery failed" };
+    }
+    const restoredSelection = decodeExternalTransportSelection(
+      harnessId,
+      thread.record.transportModelId
+    );
+    const opened = await adapter.open({
+      kind: "resume",
+      cwd: thread.record.cwd,
+      environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: thread.record.hostThreadId },
+      nativeRef: thread.record.nativeSessionRef,
+      knownTurnRefs: thread.record.turnMappings.map(({ nativeTurnRef }) => nativeTurnRef),
+      ...restoredSelection?.model ? { model: restoredSelection.model } : {},
+      ...restoredSelection?.thinkingOptionId ? { thinkingOptionId: restoredSelection.thinkingOptionId } : {},
+      ...restoredSelection?.permissionModeId ? { permissionModeId: restoredSelection.permissionModeId } : {}
+    });
+    if (!opened.ok) {
+      await this.#dropIdleSession(thread);
+      return mapExternalThreadHarnessError(opened.error, "resume");
+    }
+    const session = opened.value;
+    if (this.#threads.get(thread.id) !== thread) {
+      await this.#lifecycle.release(thread.id, session, Promise.resolve());
+      return { code: -32076, message: "External Thread recovery failed" };
+    }
+    try {
+      const snapshot2 = await session.readSnapshot();
+      if (!snapshot2.ok) {
+        await this.#lifecycle.release(thread.id, session, Promise.resolve());
+        await this.#dropIdleSession(thread);
+        return mapExternalThreadHarnessError(snapshot2.error, "read");
+      }
+      let aligned = await this.#repository.alignSnapshot(thread.record, snapshot2.value);
+      if (this.#threads.get(thread.id) !== thread) {
+        await this.#lifecycle.release(thread.id, session, Promise.resolve());
+        return { code: -32076, message: "External Thread recovery failed" };
+      }
+      const restoredState = snapshot2.value.state;
+      const effectiveModel = restoredState ? restoredState.effectiveModel : restoredSelection?.model;
+      const effectiveThinkingOptionId = restoredState ? restoredState.effectiveThinkingOptionId : restoredSelection?.thinkingOptionId;
+      const effectivePermissionModeId = restoredState ? restoredState.effectivePermissionModeId : restoredSelection?.permissionModeId;
+      let transportModelId = aligned.record.transportModelId;
+      if (restoredState && effectiveModel) {
+        const liveSelection = {
+          model: effectiveModel,
+          ...effectiveThinkingOptionId ? { thinkingOptionId: effectiveThinkingOptionId } : {},
+          ...effectivePermissionModeId ? { permissionModeId: effectivePermissionModeId } : {}
+        };
+        transportModelId = encodeExternalTransportSelection(harnessId, liveSelection);
+        if (transportModelId !== aligned.record.transportModelId) {
+          try {
+            aligned = {
+              ...aligned,
+              record: await this.#repository.setTransportModelId(
+                aligned.record.hostThreadId,
+                transportModelId
+              )
+            };
+          } catch (error51) {
+            this.#diagnose(error51);
+          }
+        }
+      }
+      if (this.#threads.get(thread.id) !== thread) {
+        await this.#lifecycle.release(thread.id, session, Promise.resolve());
+        return { code: -32076, message: "External Thread recovery failed" };
+      }
+      const initialState = restoredState ?? session.initialState;
+      const observerState = {
+        ...initialState,
+        ...effectiveModel ? { effectiveModel } : {},
+        ...effectiveThinkingOptionId ? { effectiveThinkingOptionId } : {},
+        ...effectivePermissionModeId ? { effectivePermissionModeId } : {}
+      };
+      thread.session = session;
+      thread.record = aligned.record;
+      thread.turns = aligned.turns;
+      thread.historyHydrated = true;
+      thread.sessionUnavailable = false;
+      thread.persistenceError = null;
+      thread.transportModelId = transportModelId;
+      if (effectiveModel) thread.requestedModel = effectiveModel;
+      if (effectiveThinkingOptionId) thread.requestedThinkingOptionId = effectiveThinkingOptionId;
+      if (effectivePermissionModeId) thread.requestedPermissionModeId = effectivePermissionModeId;
+      thread.stateObserver = new SessionStateObserver(observerState);
+      thread.latestUsage = session.initialUsage;
+      thread.usageMeter = new UsageMeter();
+      thread.usageTurnId = null;
+      thread.thread = externalThreadValue({
+        record: aligned.record,
+        turns: aligned.turns,
+        sessionId: thread.sessionId,
+        running: thread.running
+      });
+      thread.outputTask = this.#consumeOutputs(thread);
+      this.idleRelease.clearOutputFailed(thread);
+      return null;
+    } catch (error51) {
+      if (error51 instanceof ExternalSessionReleaseError) throw error51;
+      await this.#lifecycle.release(thread.id, session, Promise.resolve());
+      this.#diagnose(error51);
+      await this.#dropIdleSession(thread);
+      return { code: -32081, message: "External Thread history could not be persisted" };
+    }
+  }
   async persistTerminalIdentity(thread, event) {
     if (thread.persistenceError) return thread.persistenceError;
     if (!event.nativeTurnRef) {
@@ -32504,7 +32855,8 @@ var ExternalThreadRuntime = class {
         transportModelId
       });
     } catch (error51) {
-      await session.close().catch(() => void 0);
+      if (error51 instanceof ExternalSessionReleaseError) throw error51;
+      await this.#lifecycle.release(record4.hostThreadId, session, Promise.resolve());
       throw error51;
     }
   }
@@ -32905,7 +33257,7 @@ function projectDelegationThreadSnapshot(input) {
 // packages/host-runtime/src/harness-delegation-coordinator.ts
 var IMPLICIT_DEDUPLICATION_MS = 3e4;
 var NATIVE_REF_TIMEOUT_MS = 1e4;
-function delay2(milliseconds) {
+function delay3(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 function terminal(status2) {
@@ -33295,7 +33647,7 @@ var HarnessDelegationCoordinator = class {
       if (terminal(snapshot2.status)) return { ...snapshot2, timedOut: false };
       const remaining = deadline - Date.now();
       if (remaining <= 0) return { ...snapshot2, timedOut: true };
-      await delay2(Math.min(100, remaining));
+      await delay3(Math.min(100, remaining));
     }
   }
   async list(input) {
@@ -35429,15 +35781,21 @@ var HarnessPluginRegistry = class {
 };
 
 // packages/host-runtime/src/harness-plugin-loader.ts
+function hasValidSessionUsage(value2) {
+  const capability = Reflect.get(value2, "sessionUsage");
+  return capability === void 0 || capability !== null && typeof capability === "object" && ["observe", "read"].every((key) => typeof Reflect.get(capability, key) === "function") && ["requestOptions", "shouldForwardNotification", "reset"].every(
+    (key) => Reflect.get(capability, key) === void 0 || typeof Reflect.get(capability, key) === "function"
+  );
+}
 function isAdapter(value2) {
   if (!value2 || typeof value2 !== "object") return false;
-  return ["inspect", "open", "close"].every((key) => typeof Reflect.get(value2, key) === "function");
+  return hasValidSessionUsage(value2) && ["inspect", "open", "close"].every((key) => typeof Reflect.get(value2, key) === "function");
 }
 function isUsageAdapter(value2) {
   if (!value2 || typeof value2 !== "object" || typeof Reflect.get(value2, "close") !== "function")
     return false;
   const capability = Reflect.get(value2, "usageStatistics");
-  return !!capability && typeof capability === "object" && ["listSources", "readSource"].every(
+  return hasValidSessionUsage(value2) && !!capability && typeof capability === "object" && ["listSources", "readSource"].every(
     (key) => typeof Reflect.get(capability, key) === "function"
   ) && !("open" in value2) && !("inspect" in value2);
 }
@@ -35578,11 +35936,12 @@ async function loadHarnessPlugins(options2) {
   }
   if (options2.signal?.aborted) return registry2;
   let next = 0;
+  let batch = pending;
   const loaded = /* @__PURE__ */ new Map();
   const worker = async () => {
     for (; ; ) {
       if (options2.signal?.aborted) return;
-      const candidate = pending[next++];
+      const candidate = batch[next++];
       if (!candidate) return;
       if (options2.signal?.aborted) return;
       const { manifest } = candidate;
@@ -35628,10 +35987,19 @@ async function loadHarnessPlugins(options2) {
       loaded.set(candidate, { descriptor, adapter });
     }
   };
-  await Promise.all(Array.from({ length: Math.min(4, pending.length) }, () => worker()));
-  for (const candidate of pending) {
-    const entry = loaded.get(candidate);
-    if (entry) await registry2.register(entry.descriptor, entry.adapter);
+  const batches = options2.onUsageAdaptersLoaded ? [
+    pending.filter((c) => c.manifest.kind === "usage"),
+    pending.filter((c) => c.manifest.kind !== "usage")
+  ] : [pending];
+  for (const [index, candidates2] of batches.entries()) {
+    batch = candidates2;
+    next = 0;
+    await Promise.all(Array.from({ length: Math.min(4, batch.length) }, () => worker()));
+    for (const candidate of batch) {
+      const entry = loaded.get(candidate);
+      if (entry) await registry2.register(entry.descriptor, entry.adapter);
+    }
+    if (index === 0) options2.onUsageAdaptersLoaded?.(registry2.usageAdapters);
   }
   return registry2;
 }
@@ -36533,16 +36901,16 @@ var OfficialRuntimeScope = class {
   #scheduleRecovery() {
     if (!this.#recovery || this.#closed || this.#recoveryTimer || this.#starting) return;
     const { delaysMs } = this.#recovery;
-    const delay5 = delaysMs[Math.min(this.#recoveryAttempt, delaysMs.length - 1)] ?? 0;
+    const delay6 = delaysMs[Math.min(this.#recoveryAttempt, delaysMs.length - 1)] ?? 0;
     this.#recoveryAttempt++;
     this.#diagnosticOutput.write(
-      `codexhost: official Codex is unavailable; restarting in ${String(delay5)}ms
+      `codexhost: official Codex is unavailable; restarting in ${String(delay6)}ms
 `
     );
     const timer = setTimeout(() => {
       this.#recoveryTimer = void 0;
       this.start().catch(() => void 0);
-    }, delay5);
+    }, delay6);
     timer.unref();
     this.#recoveryTimer = timer;
   }
@@ -37289,11 +37657,163 @@ async function moveThreadSection(input) {
   }
 }
 
+// packages/host-runtime/src/observed-session-usage.ts
+var ObservedSessionUsage = class {
+  constructor(providers, prices, diagnose) {
+    this.providers = providers;
+    this.prices = prices;
+    this.diagnose = diagnose;
+  }
+  providers;
+  prices;
+  diagnose;
+  #states = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Map();
+  #abort = new AbortController();
+  #initializeParams = null;
+  initialized(params) {
+    this.#initializeParams = params;
+    for (const state of this.#states.values()) {
+      state.meter.resetTurnTiming();
+      state.activeTurnId = null;
+    }
+    for (const provider of this.providers()) {
+      try {
+        provider.reset?.();
+      } catch (error51) {
+        this.diagnose(error51);
+      }
+    }
+  }
+  requestOptions(method, params) {
+    if (this.#abort.signal.aborted) return null;
+    let result = null;
+    for (const provider of this.providers()) {
+      try {
+        const patch = provider.requestOptions?.({
+          method,
+          params,
+          initializeParams: this.#initializeParams
+        });
+        if (patch) result = Object.assign(result ?? {}, jsonObjectSchema.parse(patch));
+      } catch (error51) {
+        this.diagnose(error51);
+      }
+    }
+    return result;
+  }
+  shouldForwardNotification(message2) {
+    if (this.#abort.signal.aborted) return true;
+    for (const provider of this.providers()) {
+      try {
+        if (provider.shouldForwardNotification?.(message2) === false) return false;
+      } catch (error51) {
+        this.diagnose(error51);
+      }
+    }
+    return true;
+  }
+  observe(message2, now = Date.now()) {
+    if (this.#abort.signal.aborted) return [];
+    const changed = /* @__PURE__ */ new Set();
+    for (const provider of this.providers()) {
+      try {
+        const observation = provider.observe(message2, now);
+        if (!observation) continue;
+        const state = this.#state(observation.sessionId, provider);
+        if (state.provider !== provider) continue;
+        if (observation.usage) {
+          state.live = parseHostUsage(observation.usage);
+          state.revision++;
+        }
+        const turn = observation.turn;
+        if (turn?.phase === "started" && state.activeTurnId !== turn.id) {
+          state.meter.resetTurnTiming();
+          state.meter.turnStarted(turn.id, now);
+          state.activeTurnId = turn.id;
+        }
+        const timing = observation.requestTiming;
+        if (timing) state.meter.recordOutputTiming(timing, timing.turnId);
+        if (observation.timingUnavailable)
+          state.meter.invalidateOutputTiming(observation.timingUnavailable.turnId);
+        if (turn?.phase === "completed") {
+          state.meter.turnCompleted(turn.id);
+          if (state.activeTurnId === turn.id) state.activeTurnId = null;
+        }
+        const firstOutput = turn?.phase === "output" && state.meter.outputObserved(turn.id, now);
+        if (observation.usage || firstOutput || timing || observation.timingUnavailable || turn?.phase === "started" || turn?.phase === "completed")
+          changed.add(observation.sessionId);
+      } catch (error51) {
+        this.diagnose(error51);
+      }
+    }
+    return [...changed];
+  }
+  async read(sessionId) {
+    if (this.#abort.signal.aborted) return null;
+    let pending = this.#pending.get(sessionId);
+    if (!pending) {
+      pending = this.#refresh(sessionId).finally(() => this.#pending.delete(sessionId));
+      this.#pending.set(sessionId, pending);
+    }
+    await pending;
+    const state = this.#states.get(sessionId);
+    if (!state || this.#abort.signal.aborted) return null;
+    const native = state.live ?? state.history;
+    const result = state.meter.derive(native, await this.prices.lookup());
+    if (result?.unpricedModels?.length) this.prices.missing();
+    return result;
+  }
+  async #refresh(sessionId) {
+    const existing = this.#states.get(sessionId);
+    for (const provider of existing ? [existing.provider] : this.providers()) {
+      const revision = existing?.revision ?? 0;
+      try {
+        const history = await provider.read(sessionId, this.#abort.signal);
+        if (this.#abort.signal.aborted) return;
+        if (!history) {
+          if (existing?.meter.metered) existing.meter.recordHistory(false);
+          continue;
+        }
+        const state = this.#state(sessionId, provider);
+        state.history = history.usage ? parseHostUsage(history.usage) : null;
+        state.meter.replaceHistory(
+          history.requests,
+          history.complete && state.revision === revision
+        );
+        return;
+      } catch (error51) {
+        existing?.meter.recordHistory(false);
+        if (!this.#abort.signal.aborted) this.diagnose(error51);
+      }
+    }
+  }
+  #state(id2, provider) {
+    let state = this.#states.get(id2);
+    if (!state) {
+      state = {
+        provider,
+        meter: new UsageMeter(),
+        live: null,
+        history: null,
+        revision: 0,
+        activeTurnId: null
+      };
+      this.#states.set(id2, state);
+    }
+    return state;
+  }
+  close() {
+    this.#abort.abort();
+    this.#states.clear();
+  }
+};
+
 // packages/host-runtime/src/app-server-host.ts
 var CONSOLE_REQUEST_TIMEOUT_MS = 12e4;
 var SUBAGENT_TERMINAL_REFRESH_DELAYS_MS = [0, 50, 100, 150];
 var THREAD_USAGE_UPDATED_METHOD = "codexhost/thread/usage/updated";
-function delay3(milliseconds) {
+function delay4(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 function isRecord18(value2) {
@@ -37486,10 +38006,12 @@ var AppServerHost = class {
   #launchSettings;
   #accountInspections = new HarnessAccountInspectionCache();
   #externalRuntime;
+  #executionHosts = /* @__PURE__ */ new WeakMap();
   #externalPrewarms = new ExternalThreadPrewarms();
   #externalSteering = new ExternalTurnSteering();
   #liveCommandCache = new LiveCommandCatalogCache();
   #modelPrices;
+  #observedSessionUsage;
   #repository;
   #pendingDesktopApprovals = /* @__PURE__ */ new Map();
   #pendingDesktopQuestions = /* @__PURE__ */ new Map();
@@ -37506,7 +38028,6 @@ var AppServerHost = class {
   #activeWorkDrainWaiters = /* @__PURE__ */ new Set();
   #pendingOfficialDelegationThreads = /* @__PURE__ */ new Set();
   #pendingOfficialTerminalStatuses = /* @__PURE__ */ new Map();
-  #officialUsageByThread = /* @__PURE__ */ new Map();
   #officialRateLimits = new AccountRateLimits();
   #routeObservationTracker = new RequestRouteObservationTracker();
   #officialServerRequests = /* @__PURE__ */ new Map();
@@ -37524,6 +38045,7 @@ var AppServerHost = class {
   #closeRequested = false;
   #pluginLoadAbort = new AbortController();
   #pluginLoading;
+  #usagePluginsReady;
   #desktopRequests = new DesktopRequestQueue();
   #drainActiveWorkOnInputEnd = false;
   #desktopInputEnded = false;
@@ -37535,6 +38057,13 @@ var AppServerHost = class {
       ...options2
     };
     this.#modelPrices = options2.modelPrices ?? new ModelPriceCatalog();
+    this.#observedSessionUsage = new ObservedSessionUsage(
+      () => [...this.#externalAdapters.values(), ...this.#usageOnlyAdapters].flatMap(
+        (adapter) => adapter.sessionUsage ? [adapter.sessionUsage] : []
+      ),
+      this.#modelPrices,
+      (error51) => this.#diagnose(error51)
+    );
     this.#writer = new OrderedWriter(this.#options.desktopOutput, (value2) => {
       this.#noteDesktopReply(value2);
       return this.#takeConsoleReply(value2);
@@ -37612,6 +38141,7 @@ var AppServerHost = class {
       consumeOutputs: (thread) => this.#consumeHarnessOutputs(thread),
       diagnose: (error51) => this.#diagnose(error51),
       subagentRunning: (threadId2) => this.#subagentThreadStatuses.get(threadId2) === "active",
+      hasRunningDescendants: (threadId2) => this.#hasRunningSubagents(threadId2),
       idleRelease: {
         queue: this.#desktopRequests,
         onClosed: async (thread) => {
@@ -37670,7 +38200,11 @@ var AppServerHost = class {
       wait: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.wait(input)),
       list: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.list(input)),
       canHandleStart: (input) => this.#canHandleDelegationStart(input),
-      ownsThread: (threadId2) => this.#ownsDelegationThread(threadId2)
+      ownsThread: (threadId2) => this.#ownsDelegationThread(threadId2),
+      executionHostId: (threadId2) => {
+        const thread = this.#externalRuntime.get(threadId2);
+        return thread ? this.#executionHosts.get(thread) : void 0;
+      }
     });
     this.#unregisterDelegationApi = typeof unregisterDelegationApi === "function" ? unregisterDelegationApi : void 0;
   }
@@ -37702,18 +38236,29 @@ var AppServerHost = class {
     this.#options.usageStatistics?.attach(
       () => [.../* @__PURE__ */ new Set([...this.#externalAdapters.values(), ...this.#usageOnlyAdapters])].flatMap(
         (adapter) => adapter.usageStatistics ? [{ harness: adapter.harnessId, capability: adapter.usageStatistics }] : []
-      )
+      ),
+      () => this.#repository.list()
     );
   }
   #waitForPlugins() {
-    return this.#pluginLoading ??= this.#loadInstalledPlugins().catch((error51) => {
-      this.#diagnose(`Harness plugin load failed: ${errorMessage4(error51)}`);
-    });
+    if (!this.#pluginLoading) {
+      const ready = Promise.withResolvers();
+      const usageReady = () => ready.resolve(void 0);
+      this.#usagePluginsReady = ready.promise;
+      this.#pluginLoading = this.#loadInstalledPlugins(usageReady).catch((error51) => {
+        this.#diagnose(`Harness plugin load failed: ${errorMessage4(error51)}`);
+      }).finally(usageReady);
+    }
+    return this.#pluginLoading;
   }
-  async #loadInstalledPlugins() {
+  async #loadInstalledPlugins(usageReady) {
     if (!this.#options.pluginRoots || this.#pluginLoadAbort.signal.aborted) return;
     const plugins = await loadHarnessPlugins({
       roots: this.#options.pluginRoots,
+      onUsageAdaptersLoaded: (adapters) => {
+        if (!this.#pluginLoadAbort.signal.aborted) this.#usageOnlyAdapters = [...adapters.values()];
+        usageReady();
+      },
       launchCommandForPlugin: (id2) => this.#launchSettings.initialCommand(id2),
       context: this.#options.pluginContext ?? {
         environment: this.#options.environment ?? process.env,
@@ -37734,6 +38279,7 @@ var AppServerHost = class {
     for (const [id2, adapter] of plugins.adapters) this.#externalAdapters.set(id2, adapter);
   }
   async #closeAdapters() {
+    this.#observedSessionUsage.close();
     const results = await Promise.allSettled([
       this.#plugins?.close(),
       ...[...new Set(this.#options.externalAdapters?.values())].map(
@@ -37795,6 +38341,7 @@ var AppServerHost = class {
       await Promise.allSettled(threads.map(({ session }) => session.close()));
       await Promise.allSettled(threads.map(({ outputTask }) => outputTask));
       await this.#closeAdapters();
+      await this.#externalRuntime.drain();
       for (const pending of [...this.#pendingDesktopApprovals.values()]) {
         await this.#resolveDesktopApproval(pending.interaction.interactionId).catch(
           () => void 0
@@ -37937,7 +38484,13 @@ var AppServerHost = class {
       if (request.method === "initialize") {
         try {
           const nativeGeneration = this.#officialRuntimeScope.gate.phase === "ready" ? this.#officialRuntimeScope.owner.generation : void 0;
-          const response = await this.#officialRuntime.initializeProtocol(requestObject(request));
+          void this.#waitForPlugins();
+          await this.#usagePluginsReady;
+          const params = requestObject(request);
+          const options2 = this.#observedSessionUsage.requestOptions("initialize", params);
+          const nativeParams = options2 ? { ...params, ...options2 } : params;
+          const response = await this.#officialRuntime.initializeProtocol(nativeParams);
+          if (!isRecord18(response.error)) this.#observedSessionUsage.initialized(nativeParams);
           await this.#writer.json({ ...response, id: request.id });
           this.#nativeAccountObserver?.initialized(nativeGeneration);
         } catch (error51) {
@@ -38768,6 +39321,15 @@ var AppServerHost = class {
       return;
     }
     try {
+      const options2 = isRecord18(request.params) ? this.#observedSessionUsage.requestOptions(request.method, request.params) : null;
+      if (options2) {
+        const original = parseJsonFrame(frame);
+        if (isRecord18(original))
+          frame = encodeJsonFrame({
+            ...original,
+            params: { ...isRecord18(original.params) ? original.params : {}, ...options2 }
+          });
+      }
       await this.#officialRuntime.sendFrame(frame);
       this.#markDesktopRequestAnswered(request.id);
     } catch {
@@ -38786,6 +39348,7 @@ var AppServerHost = class {
       return;
     }
     const parsed2 = input.value;
+    const observedAtMs = Date.now();
     this.#observeOfficialTurnStartResponse(parsed2);
     let forwarded = parsed2;
     if (isRecord18(parsed2) && typeof parsed2.method === "string" && "id" in parsed2) {
@@ -38800,17 +39363,6 @@ var AppServerHost = class {
     if (accountScopedNotification) {
       if (parsed2.method === "account/updated") this.#officialRateLimits.reset(input.accountId);
     }
-    const tokenUsage = observeCodexTokenUsage(parsed2);
-    if (tokenUsage) {
-      const previous = this.#officialUsageByThread.get(tokenUsage.threadId);
-      try {
-        this.#officialUsageByThread.set(
-          tokenUsage.threadId,
-          parseHostUsage({ ...previous ?? {}, ...tokenUsage.usage })
-        );
-      } catch {
-      }
-    }
     const rateLimits = observeCodexRateLimits(parsed2);
     if (rateLimits) this.#officialRateLimits.observe(input.accountId, rateLimits);
     try {
@@ -38819,8 +39371,16 @@ var AppServerHost = class {
       this.#diagnose(error51);
     }
     this.#routeObservationTracker.bindOfficialResponse(parsed2);
-    if (forwarded === parsed2) await this.#writer.frame(input.frame);
-    else await this.#writer.json(forwarded);
+    const privateTelemetry = isRecord18(parsed2) && typeof parsed2.method === "string" && !("id" in parsed2) && !this.#observedSessionUsage.shouldForwardNotification(parsed2);
+    if (!privateTelemetry) {
+      if (forwarded === parsed2) await this.#writer.frame(input.frame);
+      else await this.#writer.json(forwarded);
+    }
+    void (this.#usagePluginsReady ?? Promise.resolve()).then(async () => {
+      for (const threadId2 of this.#observedSessionUsage.observe(parsed2, observedAtMs)) {
+        await this.#writer.json({ method: THREAD_USAGE_UPDATED_METHOD, params: { threadId: threadId2 } });
+      }
+    }).catch((error51) => this.#diagnose(error51));
     this.#nativeAccountObserver?.observe(parsed2);
     const deletedProjectId = observeDeletedProject(parsed2);
     if (deletedProjectId) {
@@ -39761,12 +40321,13 @@ var AppServerHost = class {
         );
         return;
       }
+      await this.#waitForPlugins();
       const accountId = await this.#currentCodexAccountId();
       if (accountId) await this.#refreshOfficialRateLimits(accountId);
       const accountCredits = this.#officialAccountCredits(accountId ?? void 0);
       const result2 = threadUsageInspectionSchema.parse({
         threadId: params.data.threadId,
-        usage: this.#officialUsageByThread.get(params.data.threadId) ?? null,
+        usage: await this.#observedSessionUsage.read(params.data.threadId),
         ...accountCredits ? { accountCredits } : {}
       });
       await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result2) }));
@@ -39974,7 +40535,7 @@ var AppServerHost = class {
       this.#pendingExternalCommandRequests.delete(thread.id);
     }
   }
-  async #beginExternalCommand(thread, descriptor, arguments_2, requestedTurnId) {
+  async #beginExternalCommand(thread, descriptor, arguments_2, requestedTurnId, sourceHostId) {
     const commands = thread.session.commands;
     if (!commands) {
       throw new ExternalCommandError(-32078, "External Harness does not expose commands");
@@ -40003,6 +40564,7 @@ var AppServerHost = class {
     thread.ephemeralTurnIds.add(turnId);
     if (descriptor.invocation === "/compact") this.#manualCompactionTurns.set(thread, turnId);
     else this.#manualCompactionTurns.delete(thread);
+    const restoreExecutionHost = this.#setExecutionHost(thread, sourceHostId);
     try {
       if (thread.unsubmittedPrewarm && await this.#externalRuntime.submitPrewarm(thread)) {
         await this.#notifyExternalThreadStarted(thread.thread);
@@ -40015,6 +40577,7 @@ var AppServerHost = class {
       if (!result.ok) throw new ExternalCommandError(-32073, result.error.message);
       return { turnId: result.value.turnId, turn: projection.projector.pendingTurn(), gate };
     } catch (error51) {
+      restoreExecutionHost();
       thread.running = false;
       thread.activeTurnId = null;
       thread.projectedTurns.delete(turnId);
@@ -40794,7 +41357,8 @@ var AppServerHost = class {
         thread,
         text,
         void 0,
-        typeof params.clientUserMessageId === "string" ? params.clientUserMessageId : void 0
+        typeof params.clientUserMessageId === "string" ? params.clientUserMessageId : void 0,
+        params[THREAD_REFERENCE_SOURCE_HOST_PARAM]
       );
       try {
         await this.#writer.json(rpcEnvelope(request, { result: { turn: started.turn } }));
@@ -40820,7 +41384,8 @@ var AppServerHost = class {
           thread,
           text,
           assertActive,
-          typeof requestObject(request).clientUserMessageId === "string" ? requestObject(request).clientUserMessageId : void 0
+          typeof requestObject(request).clientUserMessageId === "string" ? requestObject(request).clientUserMessageId : void 0,
+          requestObject(request)[THREAD_REFERENCE_SOURCE_HOST_PARAM]
         )
       );
       try {
@@ -40841,12 +41406,12 @@ var AppServerHost = class {
     }
   }
   /** Keep command restoration and dispatch identical for start and steer submissions. */
-  async #beginExternalInputTurn(thread, inputText, assertActive, clientUserMessageId) {
+  async #beginExternalInputTurn(thread, inputText, assertActive, clientUserMessageId, sourceHostId) {
     const text = restoreHarnessCommandMentions(inputText);
     const commands = thread.session.commands;
     if (!commands || !isExternalCommandCandidate(text)) {
       assertActive?.();
-      return this.#beginExternalTurn(thread, text, clientUserMessageId);
+      return this.#beginExternalTurn(thread, text, clientUserMessageId, sourceHostId);
     }
     this.#pendingExternalCommandRequests.add(thread.id);
     try {
@@ -40857,9 +41422,15 @@ var AppServerHost = class {
       assertActive?.();
       if (!command) {
         this.#pendingExternalCommandRequests.delete(thread.id);
-        return await this.#beginExternalTurn(thread, text, clientUserMessageId);
+        return await this.#beginExternalTurn(thread, text, clientUserMessageId, sourceHostId);
       }
-      return await this.#beginExternalCommand(thread, command.descriptor, command.arguments);
+      return await this.#beginExternalCommand(
+        thread,
+        command.descriptor,
+        command.arguments,
+        void 0,
+        sourceHostId
+      );
     } catch (error51) {
       if (error51 instanceof ExternalCommandError || error51 instanceof ExternalSteerError) throw error51;
       this.#diagnose(error51);
@@ -40871,7 +41442,20 @@ var AppServerHost = class {
       this.#pendingExternalCommandRequests.delete(thread.id);
     }
   }
-  async #beginExternalTurn(thread, text, clientUserMessageId) {
+  /** Apply context before native execution; a rejected start restores the prior identity. */
+  #setExecutionHost(thread, sourceHostId) {
+    const previousHostId = this.#executionHosts.get(thread);
+    if (typeof sourceHostId === "string" && sourceHostId.length > 0 && sourceHostId.length <= 1024 && !/[\u0000-\u0020\u007f]/u.test(sourceHostId)) {
+      this.#executionHosts.set(thread, sourceHostId);
+    } else {
+      this.#executionHosts.delete(thread);
+    }
+    return () => {
+      if (previousHostId === void 0) this.#executionHosts.delete(thread);
+      else this.#executionHosts.set(thread, previousHostId);
+    };
+  }
+  async #beginExternalTurn(thread, text, clientUserMessageId, sourceHostId) {
     if (this.#closeRequested || this.#externalRuntime.get(thread.id) !== thread) {
       throw new ExternalSteerError(-32073, "External Thread is no longer available");
     }
@@ -40898,6 +41482,7 @@ var AppServerHost = class {
     thread.projectedTerminalTurnId = null;
     thread.projectedTurns.set(turnId, projection);
     thread.responseGates.set(turnId, gate);
+    const restoreExecutionHost = this.#setExecutionHost(thread, sourceHostId);
     try {
       if (thread.unsubmittedPrewarm && await this.#externalRuntime.submitPrewarm(thread)) {
         await this.#notifyExternalThreadStarted(thread.thread);
@@ -40910,6 +41495,7 @@ var AppServerHost = class {
       if (!result.ok) throw new ExternalSteerError(-32073, result.error.message);
       return { turnId, turn: projection.projector.pendingTurn(), gate };
     } catch (error51) {
+      restoreExecutionHost();
       thread.running = false;
       thread.activeTurnId = null;
       thread.projectedTurns.delete(turnId);
@@ -41138,7 +41724,11 @@ var AppServerHost = class {
     if (event.type === "session.faulted") {
       this.#externalSteering.fault(thread.id, new Error(event.error.message));
       thread.stateObserver.fault(new Error(event.error.message));
+      this.#externalRuntime.markSessionUnavailable(thread);
       this.#diagnose(`${thread.harnessId} Harness Session faulted: ${event.error.message}`);
+      if (!thread.running && !thread.activeTurnId && !this.#hasRunningSubagents(thread.id) && !thread.session.hasBackgroundWork?.()) {
+        void this.#externalRuntime.discardUnavailableIdle(thread);
+      }
       return;
     }
     if (event.type === "turn.autonomous.started") {
@@ -41267,6 +41857,11 @@ var AppServerHost = class {
     return { ...subagent, subagentId: record4.hostThreadId };
   }
   async #refreshOpenSubagentThread(threadId2, terminal3 = true) {
+    await this.#desktopRequests.run(threadId2, async () => {
+      await this.#refreshOpenSubagentThreadBody(threadId2, terminal3);
+    });
+  }
+  async #refreshOpenSubagentThreadBody(threadId2, terminal3) {
     const child = this.#externalRuntime.get(threadId2);
     if (!child) return;
     const previousItems = new Map(
@@ -41366,7 +41961,7 @@ var AppServerHost = class {
     }
     if (status2 === "idle" && previousStatus === "active") {
       for (const [index, waitMs] of SUBAGENT_TERMINAL_REFRESH_DELAYS_MS.entries()) {
-        if (waitMs > 0) await delay3(waitMs);
+        if (waitMs > 0) await delay4(waitMs);
         await this.#refreshOpenSubagentThread(
           threadId2,
           index === SUBAGENT_TERMINAL_REFRESH_DELAYS_MS.length - 1
@@ -41744,7 +42339,7 @@ import { randomUUID as randomUUID15 } from "node:crypto";
 import { chmod as chmod3, lstat as lstat5, mkdir as mkdir12, open as open9, readFile as readFile16, readdir as readdir5, rename as rename11, rm as rm11 } from "node:fs/promises";
 import { uptime } from "node:os";
 import path26 from "node:path";
-import { setTimeout as delay4 } from "node:timers/promises";
+import { setTimeout as delay5 } from "node:timers/promises";
 var LOCK_RETRY_COUNT = 200;
 var LOCK_RETRY_DELAY_MS = 25;
 var LOCK_MALFORMED_GRACE_MS = 1e3;
@@ -42000,7 +42595,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
           return await action();
         }
       }
-      await delay4(LOCK_RETRY_DELAY_MS);
+      await delay5(LOCK_RETRY_DELAY_MS);
     }
     throw new Error(
       `Remote app-server socket initialization is already in progress at ${socketPath}`
@@ -43291,15 +43886,28 @@ var DelegationControlRegistry = class {
     return (await this.#registrationForThread(input.threadId)).cancel(input);
   }
   async read(input) {
-    if (input.hostId !== void 0 && input.hostId !== "local") {
-      if (!input.hostId || !this.#remoteRead)
+    const { callerThreadId: callerThreadId2, ...read } = input;
+    if (read.hostId !== void 0 && read.hostId !== "local") {
+      if (typeof callerThreadId2 === "string" && callerThreadId2) {
+        const callers = await this.#matching(
+          (registration) => registration.executionHostId?.(callerThreadId2) === read.hostId && registration.ownsThread(callerThreadId2)
+        );
+        if (callers.length > 1)
+          only(callers, "Calling Thread has ambiguous execution Host context");
+        if (callers.length === 1) {
+          const { hostId: hostId2, ...local } = read;
+          const snapshot2 = await (await this.#registrationForThread(local.threadId)).read(local);
+          return { ...snapshot2, hostId: hostId2 };
+        }
+      }
+      if (!read.hostId || !this.#remoteRead)
         throw new DelegationControlError(
           "RUNTIME_UNREACHABLE",
           "Remote Thread reading is unavailable"
         );
-      return this.#remoteRead(input);
+      return this.#remoteRead(read);
     }
-    return (await this.#registrationForThread(input.threadId)).read(input);
+    return (await this.#registrationForThread(read.threadId)).read(read);
   }
   async wait(input) {
     if (input.hostId !== void 0 && input.hostId !== "local")
@@ -44462,13 +45070,15 @@ function createHostUpdateCoordinator(options2) {
     return authenticated ?? fetchLatestGitHubRelease({ signal: requestSignal });
   });
   let candidate = null;
+  let currentStatusPath = null;
   async function latestStatus(context) {
-    const discovered = await discoverLatestUpdateStatus(context.common.stateDirectory);
-    if (!discovered) return null;
-    if (discovered.status.phase !== "succeeded" && discovered.status.phase !== "failed" && !await isUpdateOperationActive(context.common.stateDirectory)) {
-      return null;
+    if (!currentStatusPath) {
+      const active = await discoverActiveUpdateStatus(context.common.stateDirectory);
+      if (!active) return null;
+      currentStatusPath = active.statusPath;
     }
-    return publicStatus(discovered.status);
+    const status2 = await manager.readStatus(currentStatusPath);
+    return status2 ? publicStatus(status2) : null;
   }
   async function installable(context, release) {
     if (context.installation.kind === "npm") return true;
@@ -44552,6 +45162,7 @@ function createHostUpdateCoordinator(options2) {
         if (existing) return { status: existing };
         throw new Error("Another update operation is already active");
       }
+      currentStatusPath = null;
       let resolvePrepared;
       let rejectPrepared;
       const preparedReady = new Promise((resolve, reject) => {
@@ -44565,6 +45176,7 @@ function createHostUpdateCoordinator(options2) {
         }
         const onPrepared = async (info) => {
           await lock.setStatusPath(info.statusPath);
+          currentStatusPath = info.statusPath;
           resolvePrepared(info);
         };
         const prepareAndStart = async () => {
@@ -44594,7 +45206,7 @@ function createHostUpdateCoordinator(options2) {
                 onPrepared
               });
             }
-            if (platform !== "darwin") manager.start(prepared2);
+            if (platform !== "darwin") await manager.start(prepared2);
           } catch (error51) {
             await lock.release();
             rejectPrepared(error51);
@@ -44631,6 +45243,20 @@ import { setImmediate as yieldToEventLoop } from "node:timers/promises";
 // packages/harness-adapter/dist/usage-statistics.js
 var MAX_SESSION_ID_LENGTH = 512;
 var MAX_CWD_LENGTH = 4096;
+var MAX_SESSION_TITLE_LENGTH = 200;
+function usageSessionTitle(value2) {
+  if (typeof value2 !== "string")
+    return void 0;
+  const normalized = value2.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
+  if (!normalized)
+    return void 0;
+  if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
+    return normalized;
+  const characters = [...normalized];
+  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
+    return normalized;
+  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+}
 function sessionIdOk(value2) {
   return typeof value2 === "string" && value2.length > 0 && value2.length <= MAX_SESSION_ID_LENGTH;
 }
@@ -44674,6 +45300,12 @@ function parseHarnessUsageEntry(value2) {
     return null;
   if (entry.cwd !== void 0 && !cwdOk(entry.cwd))
     return null;
+  if (entry.sessionTitle !== void 0) {
+    const sessionTitle = usageSessionTitle(entry.sessionTitle);
+    if (sessionTitle === void 0)
+      return null;
+    entry.sessionTitle = sessionTitle;
+  }
   if (entry.tokensUnknown !== void 0 && entry.tokensUnknown !== true)
     return null;
   if (entry.costUsd !== void 0 && (typeof entry.costUsd !== "number" || !Number.isFinite(entry.costUsd) || entry.costUsd < 0)) {
@@ -44685,8 +45317,31 @@ function parseHarnessUsageEntry(value2) {
   return entry;
 }
 
+// packages/host-runtime/src/usage-session-titles.ts
+function withHostSessionTitles(result, records) {
+  const titles = /* @__PURE__ */ new Map();
+  for (const record4 of records) {
+    const ref = record4.nativeSessionRef;
+    const title = usageSessionTitle(record4.title);
+    if (record4.state !== "ready" || !ref || ref.harnessId !== record4.harnessId || !title) continue;
+    const key = `${record4.harnessId}\0${ref.nativeSessionId}`;
+    const previous = titles.get(key);
+    if (!previous || record4.updatedAt > previous.updatedAt)
+      titles.set(key, { title, updatedAt: record4.updatedAt });
+  }
+  const decorate = (sessions) => sessions.map((session) => {
+    const title = titles.get(`${session.harness}\0${session.sessionId}`)?.title;
+    return title ? { ...session, title } : session;
+  });
+  return {
+    ...result,
+    sessions: decorate(result.sessions),
+    ...result.recentSessions ? { recentSessions: decorate(result.recentSessions) } : {}
+  };
+}
+
 // packages/host-runtime/src/usage-statistics.ts
-var CACHE_VERSION = 6;
+var CACHE_VERSION = 7;
 var STALE_AFTER_MS = 1e4;
 var WARM_DELAY_MS = 3e3;
 var PERSIST_INTERVAL_MS = 6e4;
@@ -44706,7 +45361,8 @@ function compact(entry) {
     entry.cwd ?? null,
     entry.costUsd ?? null,
     entry.credits ?? null,
-    entry.tokensUnknown === true
+    entry.tokensUnknown === true,
+    entry.sessionTitle ?? null
   ];
 }
 function interner() {
@@ -44720,9 +45376,9 @@ function interner() {
   };
 }
 function expand(value2, intern) {
-  if (!Array.isArray(value2) || value2.length !== 14) return null;
+  if (!Array.isArray(value2) || value2.length !== 15) return null;
   const [id2, occurredAtMs, model2, input, cached2, written, written1h, output, reasoning] = value2;
-  const [sessionId, cwd, costUsd, credits, tokensUnknown] = value2.slice(9);
+  const [sessionId, cwd, costUsd, credits, tokensUnknown, sessionTitle] = value2.slice(9);
   return parseHarnessUsageEntry({
     id: id2,
     occurredAtMs,
@@ -44737,7 +45393,8 @@ function expand(value2, intern) {
     ...cwd !== null ? { cwd: intern(cwd) } : {},
     ...costUsd !== null ? { costUsd } : {},
     ...credits !== null ? { credits } : {},
-    ...tokensUnknown === true ? { tokensUnknown } : {}
+    ...tokensUnknown === true ? { tokensUnknown } : {},
+    ...sessionTitle !== null ? { sessionTitle: intern(sessionTitle) } : {}
   });
 }
 function message(error51) {
@@ -44828,6 +45485,7 @@ var UsageStatistics = class {
   #caches = /* @__PURE__ */ new Map();
   #failures = /* @__PURE__ */ new Map();
   #sources = null;
+  #readThreadTitles;
   #loaded = null;
   #refreshing = null;
   #refreshedAtMs = 0;
@@ -44842,9 +45500,10 @@ var UsageStatistics = class {
     this.#options = options2;
     this.#directory = path36.join(options2.directory, `v${CACHE_VERSION}`);
   }
-  /** The Harnesses to read; call once their plugins are loaded. */
-  attach(sources) {
+  /** Attach native storage and, optionally, fresh persisted Desktop title metadata. */
+  attach(sources, readThreadTitles) {
     this.#sources = sources;
+    this.#readThreadTitles = readThreadTitles;
     this.#scheduleWarm();
   }
   /** Reads every source in the background soon after the sources are attached. */
@@ -44871,11 +45530,19 @@ var UsageStatistics = class {
     }
     const now = this.#now();
     if (!this.#refreshing && now - this.#refreshedAtMs > STALE_AFTER_MS) this.#startRefresh();
-    return this.#aggregate(
+    const result = this.#aggregate(
       typeof params === "string" ? { range: params } : params,
       now,
       await this.#options.prices.lookup()
     );
+    if (this.#readThreadTitles && (result.sessions.length || result.recentSessions?.length)) {
+      try {
+        return withHostSessionTitles(result, await this.#readThreadTitles());
+      } catch (error51) {
+        this.#options.diagnose?.(`Usage statistics Thread titles unavailable: ${message(error51)}`);
+      }
+    }
+    return result;
   }
   /** Completes the current refresh, for tests and callers that need a settled result. */
   async settled() {
@@ -45153,6 +45820,10 @@ var UsageStatistics = class {
           sessions.set(key, session);
         }
         session.project ??= project2;
+        if (entry.sessionTitle && (session.titleAtMs === void 0 || entry.occurredAtMs >= session.titleAtMs)) {
+          session.title = entry.sessionTitle;
+          session.titleAtMs = entry.occurredAtMs;
+        }
         if (model2 !== null) session.models.set(model2, (session.models.get(model2) ?? 0) + 1);
         session.firstAtMs = Math.min(session.firstAtMs, entry.occurredAtMs);
         session.lastAtMs = Math.max(session.lastAtMs, entry.occurredAtMs);
@@ -45160,21 +45831,26 @@ var UsageStatistics = class {
       }
     }
     const allSessions = [...sessions.values()];
-    const top = /* @__PURE__ */ new Set([
-      ...[...allSessions].sort((left, right) => right.totals.costUsd - left.totals.costUsd).slice(0, SESSIONS_PER_MEASURE),
-      ...[...allSessions].sort((left, right) => tokensWithoutCache(right.totals) - tokensWithoutCache(left.totals)).slice(0, SESSIONS_PER_MEASURE)
-    ]);
-    const sessionList = [...top].map((session) => ({
+    const toSession = (session) => ({
       harness: session.harness,
       sessionId: session.sessionId,
       project: session.project,
+      ...session.title ? { title: session.title } : {},
       models: [...session.models].sort((left, right) => right[1] - left[1]).slice(0, MODELS_PER_SESSION).map(([name]) => name),
       firstAtMs: session.firstAtMs,
       lastAtMs: session.lastAtMs,
       ...session.totals
-    })).sort(
+    });
+    const top = /* @__PURE__ */ new Set([
+      ...[...allSessions].sort((left, right) => right.totals.costUsd - left.totals.costUsd).slice(0, SESSIONS_PER_MEASURE),
+      ...[...allSessions].sort((left, right) => tokensWithoutCache(right.totals) - tokensWithoutCache(left.totals)).slice(0, SESSIONS_PER_MEASURE)
+    ]);
+    const sessionList = [...top].map(toSession).sort(
       (left, right) => right.costUsd - left.costUsd || tokensWithoutCache(right) - tokensWithoutCache(left)
     );
+    const recentSessions = [...allSessions].sort(
+      (left, right) => right.lastAtMs - left.lastAtMs || right.firstAtMs - left.firstAtMs || left.sessionId.localeCompare(right.sessionId)
+    ).slice(0, SESSIONS_PER_MEASURE).map(toSession);
     if (unlistedModel) this.#options.prices.missing();
     const byName = (left, right) => left === right ? 0 : left === null ? 1 : right === null ? -1 : left.localeCompare(right);
     return {
@@ -45219,7 +45895,8 @@ var UsageStatistics = class {
       byHarness: grouped(byHarness, (name) => ({ harness: name })),
       byModel: grouped(byModel, (name) => ({ model: name })).slice(0, 4096).map((row) => ({ ...row, harnessPricedRequests: harnessPriced.get(row.model) ?? 0 })),
       byProject: grouped(byProject, (name) => ({ project: name })).slice(0, 4096),
-      sessions: sessionList
+      sessions: sessionList,
+      recentSessions
     };
   }
 };
@@ -45254,9 +45931,21 @@ function requiredRuntimeConfiguration(environment) {
   if (!stockCodexPath) throw new Error(`${STOCK_CODEX_PATH_ENV} is required`);
   return { stockCodexPath };
 }
-function delegationCliEnvironment(environment) {
-  const cliPath = environment[DELEGATION_CLI_PATH_ENV] ?? environment[UPDATE_RUNTIME_ENV.launcherExecutable];
-  const nodePath2 = environment[UPDATE_RUNTIME_ENV.npmNodePath];
+function delegationCliEnvironment(environment, hostRuntimePath) {
+  let packagedCli;
+  if (hostRuntimePath && path37.isAbsolute(hostRuntimePath)) {
+    const candidate = path37.resolve(
+      path37.dirname(hostRuntimePath),
+      "../bin",
+      process.platform === "win32" ? "codexhost.exe" : "codexhost"
+    );
+    try {
+      if (statSync(candidate).isFile()) packagedCli = candidate;
+    } catch {
+    }
+  }
+  const cliPath = environment[DELEGATION_CLI_PATH_ENV] ?? environment[UPDATE_RUNTIME_ENV.launcherExecutable] ?? packagedCli;
+  const nodePath2 = environment[DELEGATION_CLI_NODE_PATH_ENV] ?? environment[UPDATE_RUNTIME_ENV.npmNodePath] ?? (packagedCli && cliPath === packagedCli ? process.execPath : void 0);
   return {
     ...cliPath ? { [DELEGATION_CLI_PATH_ENV]: cliPath } : {},
     ...nodePath2 && path37.isAbsolute(nodePath2) ? { [DELEGATION_CLI_NODE_PATH_ENV]: nodePath2 } : {}
@@ -45274,7 +45963,7 @@ async function prepareDelegationRuntime(input) {
   const server = await startDelegationControlServer({ token, api: registry2, watchApi: registry2 });
   const environment = {
     ...input.environment,
-    ...delegationCliEnvironment(input.environment),
+    ...delegationCliEnvironment(input.environment, input.hostRuntimePath),
     [DELEGATION_RUNTIME_ENDPOINT_ENV]: server.endpoint,
     [DELEGATION_RUNTIME_TOKEN_ENV]: token
   };
@@ -45349,6 +46038,7 @@ async function runHostRuntime(input) {
     const environment = remoteControlPlan?.environment ?? input.environment;
     return prepareDelegationRuntime({
       environment,
+      ...hostRuntimePath ? { hostRuntimePath } : {},
       createHost: async (delegationEnvironment, onDelegationApi, registry2) => {
         const official = await prepareLocalCodex({
           stockCodexPath,
@@ -45457,6 +46147,7 @@ async function runHostRuntime(input) {
   if (!listenUrl) throw new Error("Remote app-server listener URL is unavailable");
   return prepareDelegationRuntime({
     environment: input.environment,
+    ...hostRuntimePath ? { hostRuntimePath } : {},
     createHost: async (delegationEnvironment, _onDelegationApi, registry2) => {
       const socketPath = remoteAppServerSocketPath(delegationEnvironment, listenUrl);
       const officialPlan = createRemoteOfficialAppServerPlan(input.arguments, socketPath);
@@ -47690,7 +48381,7 @@ import {
   readdirSync,
   renameSync,
   rmSync,
-  statSync,
+  statSync as statSync2,
   writeFileSync
 } from "node:fs";
 import os12 from "node:os";
@@ -47720,7 +48411,7 @@ function pruneRuntimeLogs(input) {
       if (!Number.isSafeInteger(pid)) continue;
       try {
         const filePath = path42.join(input.directory, entry.name);
-        const stats = statSync(filePath);
+        const stats = statSync2(filePath);
         files.push({
           filePath,
           pid,