@codexhost/cli-darwin-x64 0.13.0 → 0.13.1

package/app/host-runtime.mjs

@@ -4894,39 +4894,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 +5110,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 +5161,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 +5177,7 @@ async function replaceStatusFile(temporaryPath, statusPath) {
         throw error51;
       }
       retryIndex += 1;
-      await delay(retryDelay);
+      await delay2(retryDelay);
     }
   }
 }
@@ -5369,14 +5397,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");
@@ -20071,6 +20105,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 +20173,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
@@ -26894,61 +26935,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;
@@ -31922,6 +31908,8 @@ var UsageMeter = class {
   #turnOutputMs = 0;
   #timeToFirstOutputMs;
   #outputTokensPerSecond;
+  #timingUnavailable = false;
+  #timedRequests = /* @__PURE__ */ new Set();
   get metered() {
     return this.#metered;
   }
@@ -31938,12 +31926,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 +31983,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 +31997,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 +32031,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;
     }
@@ -32905,7 +32935,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 +33325,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 +35459,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 +35614,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 +35665,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 +36579,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 +37335,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) {
@@ -37490,6 +37688,7 @@ var AppServerHost = class {
   #externalSteering = new ExternalTurnSteering();
   #liveCommandCache = new LiveCommandCatalogCache();
   #modelPrices;
+  #observedSessionUsage;
   #repository;
   #pendingDesktopApprovals = /* @__PURE__ */ new Map();
   #pendingDesktopQuestions = /* @__PURE__ */ new Map();
@@ -37506,7 +37705,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 +37722,7 @@ var AppServerHost = class {
   #closeRequested = false;
   #pluginLoadAbort = new AbortController();
   #pluginLoading;
+  #usagePluginsReady;
   #desktopRequests = new DesktopRequestQueue();
   #drainActiveWorkOnInputEnd = false;
   #desktopInputEnded = false;
@@ -37535,6 +37734,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);
@@ -37702,18 +37908,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 +37951,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(
@@ -37937,7 +38155,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 +38992,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 +39019,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 +39034,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 +39042,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 +39992,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) }));
@@ -41366,7 +41598,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 +41976,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 +42232,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}`
@@ -44462,13 +44694,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 +44786,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 +44800,7 @@ function createHostUpdateCoordinator(options2) {
         }
         const onPrepared = async (info) => {
           await lock.setStatusPath(info.statusPath);
+          currentStatusPath = info.statusPath;
           resolvePrepared(info);
         };
         const prepareAndStart = async () => {
@@ -44594,7 +44830,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 +44867,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 +44924,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 +44941,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 +44985,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 +45000,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 +45017,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 +45109,7 @@ var UsageStatistics = class {
   #caches = /* @__PURE__ */ new Map();
   #failures = /* @__PURE__ */ new Map();
   #sources = null;
+  #readThreadTitles;
   #loaded = null;
   #refreshing = null;
   #refreshedAtMs = 0;
@@ -44842,9 +45124,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 +45154,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 +45444,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 +45455,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 +45519,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
     };
   }
 };