@alook/daemon 0.1.25 → 0.1.27

package/dist/index.js

@@ -942,8 +942,8 @@ function resolveLaunchFieldsOrDefault(input) {
   const envVars = Object.fromEntries(Object.entries(normalized.environment ?? {}).filter(([key]) => !controlled.has(key)));
   const providerEnv = {};
   const model = normalized.model.kind === "default" ? undefined : normalized.model.name;
-  if (normalized.model.kind === "custom" && normalized.provider?.kind === "custom_endpoint") {
-    providerEnv.ANTHROPIC_CUSTOM_MODEL_OPTION = normalized.model.name;
+  if (model && normalized.provider?.kind === "custom_endpoint") {
+    providerEnv.ANTHROPIC_CUSTOM_MODEL_OPTION = model;
   }
   if (normalized.provider?.kind === "custom_endpoint") {
     providerEnv.ANTHROPIC_BASE_URL = normalized.provider.apiUrl;
@@ -1125,6 +1125,66 @@ function buildClaudeArgs(config) {
   return args;
 }
 
+// agent-driver/dist/internal/token-usage.js
+function validIdentityPart(value) {
+  return value.trim().length > 0 && Buffer.byteLength(value, "utf8") <= 512;
+}
+function identityKey(identity) {
+  if (!validIdentityPart(identity.runtime) || !validIdentityPart(identity.backendSessionId) || !validIdentityPart(identity.providerRecordId))
+    return null;
+  return JSON.stringify([identity.runtime, identity.backendSessionId, identity.providerRecordId]);
+}
+function metric(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function cacheMetric(read, write) {
+  const present = [read, write].filter((value) => value !== undefined);
+  if (present.length === 0)
+    return null;
+  const metrics = present.map(metric);
+  if (metrics.some((value) => value === null))
+    return null;
+  const total = metrics.reduce((sum, value) => sum + value, 0);
+  return Number.isSafeInteger(total) ? total : null;
+}
+
+class SettledUsageProjector {
+  active = new Set;
+  project(record) {
+    const key = identityKey(record);
+    if (!key || this.active.has(key))
+      return null;
+    this.active.add(key);
+    const cache = cacheMetric(record.cacheRead, record.cacheWrite);
+    const rawInput = metric(record.input);
+    const input = record.inputIncludesCache ? rawInput !== null && cache !== null && cache <= rawInput ? rawInput - cache : null : rawInput;
+    const rawOutput = metric(record.output);
+    const reasoning = metric(record.reasoning);
+    const output = record.outputIncludesReasoning ? rawOutput : rawOutput !== null && reasoning !== null && Number.isSafeInteger(rawOutput + reasoning) ? rawOutput + reasoning : null;
+    if (input === null && output === null && cache === null) {
+      this.active.delete(key);
+      return null;
+    }
+    return {
+      kind: "telemetry",
+      name: "token_usage",
+      source: record.source,
+      usage: { input, output, cache }
+    };
+  }
+  release(identity) {
+    const key = identityKey(identity);
+    if (key)
+      this.active.delete(key);
+  }
+  reset() {
+    this.active.clear();
+  }
+  get activeCount() {
+    return this.active.size;
+  }
+}
+
 // agent-driver/dist/internal/utils.js
 import { randomUUID as randomUUID3 } from "crypto";
 function jsonRpcRequest(method, params, id) {
@@ -1144,9 +1204,13 @@ var API_ERROR_RE = /API Error:.*(?:Connection error|\b[45]\d{2}\b)/i;
 class ClaudeEventNormalizer {
   turnProtocol;
   currentSession = null;
+  usageProjector = new SettledUsageProjector;
   constructor(turnProtocol) {
     this.turnProtocol = turnProtocol;
   }
+  beginTurn() {
+    this.usageProjector.reset();
+  }
   get currentSessionId() {
     return this.currentSession;
   }
@@ -1238,7 +1302,7 @@ class ClaudeEventNormalizer {
     const turnOwner = rawOwner ? this.turnProtocol?.claimResult(rawOwner) ?? (this.turnProtocol ? null : `claude:${rawOwner}`) : null;
     if (this.turnProtocol && !turnOwner)
       return;
-    const usage = this.buildUsageTelemetry(event);
+    const usage = this.buildUsageTelemetry(event, rawOwner);
     if (usage)
       out.push(usage);
     if (event.is_error || event.subtype === "error_during_execution") {
@@ -1253,23 +1317,26 @@ class ClaudeEventNormalizer {
   acceptsTurnWork() {
     return this.turnProtocol?.acceptsTurnWork() ?? true;
   }
-  buildUsageTelemetry(event) {
+  buildUsageTelemetry(event, rootRequestId) {
     const u = event?.usage;
     if (!u)
       return null;
-    const metric = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
-    const cacheParts = [u.cache_read_input_tokens, u.cache_creation_input_tokens].filter((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0);
-    const cache = cacheParts.length > 0 && Number.isSafeInteger(cacheParts.reduce((sum, value) => sum + value, 0)) ? cacheParts.reduce((sum, value) => sum + value, 0) : null;
-    return {
-      kind: "telemetry",
-      name: "token_usage",
+    const backendSessionId = event.session_id ?? this.currentSession;
+    if (typeof backendSessionId !== "string" || !backendSessionId)
+      return null;
+    const providerRecordId = rootRequestId ?? (typeof event.request_id === "string" ? event.request_id : "invocation-result");
+    return this.usageProjector.project({
+      runtime: "claude",
+      backendSessionId,
+      providerRecordId,
       source: "claude_result_usage",
-      usage: {
-        input: metric(u.input_tokens),
-        output: metric(u.output_tokens),
-        cache
-      }
-    };
+      input: u.input_tokens,
+      output: u.output_tokens,
+      cacheRead: u.cache_read_input_tokens,
+      cacheWrite: u.cache_creation_input_tokens,
+      inputIncludesCache: false,
+      outputIncludesReasoning: true
+    });
   }
 }
 
@@ -1278,6 +1345,7 @@ import { execFileSync as execFileSync2 } from "child_process";
 import * as fs4 from "fs";
 import * as path4 from "path";
 var PROBE_TIMEOUT_MS = 5000;
+var PROBE_OUTPUT_MAX_BYTES = 1024 * 1024;
 function resolveCommandOnPath(command, deps = {}) {
   if (deps.which)
     return deps.which(command);
@@ -1328,6 +1396,23 @@ function probeCommandVersion(command, args = [], deps = {}, platform = process.p
     return { ok: false, error: String(code) };
   }
 }
+function probeCommandOutput(command, args, platform = process.platform) {
+  try {
+    const output = execFileSync2(command, args, {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      maxBuffer: PROBE_OUTPUT_MAX_BYTES,
+      shell: needsWindowsShimShell(command, platform),
+      stdio: ["pipe", "pipe", "ignore"],
+      input: "",
+      env: { ...process.env, CI: "1" }
+    });
+    return { ok: true, output };
+  } catch (err) {
+    const code = err?.code ?? "command_probe_failed";
+    return { ok: false, error: String(code) };
+  }
+}
 function resolveHomePath(relativePath, deps = {}) {
   return path4.join(deps.homeDir || process.env.HOME || ".", relativePath);
 }
@@ -1434,6 +1519,14 @@ class ClaudeTurnProtocol {
 }
 
 // agent-driver/dist/adapters/claude/index.js
+var CLAUDE_MODEL_CATALOG = {
+  updateMode: "unsupported",
+  models: ["opus", "sonnet", "haiku"].map((id) => ({
+    id,
+    supportedReasoningEfforts: []
+  }))
+};
+
 class ClaudeDriver {
   id = "claude";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
@@ -1446,14 +1539,17 @@ class ClaudeDriver {
   turnProtocol = new ClaudeTurnProtocol;
   eventNormalizer = new ClaudeEventNormalizer(this.turnProtocol);
   beginTurn() {
-    return this.turnProtocol.beginTurn();
+    const receipt = this.turnProtocol.beginTurn();
+    this.eventNormalizer.beginTurn();
+    return receipt;
   }
   probe(command) {
     const explicit = command?.trim();
-    if (!explicit)
-      return probeClaude();
-    const result = probeCommandVersion(explicit);
-    return result.ok ? { status: "healthy", version: result.version } : { status: "unhealthy", lastError: result.error };
+    const base = explicit ? (() => {
+      const result = probeCommandVersion(explicit);
+      return result.ok ? { status: "healthy", version: result.version } : { status: "unhealthy", lastError: result.error };
+    })() : probeClaude();
+    return base.status === "healthy" ? { ...base, reasoning: CLAUDE_MODEL_CATALOG } : base;
   }
   async openLane(ctx, options) {
     return createProcessLane(this, ctx, { onRawStdoutLine: options?.onRawStdoutLine });
@@ -1499,14 +1595,6 @@ class ClaudeDriver {
 }
 
 // agent-driver/dist/adapters/codex/telemetry.js
-function metric(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
-}
-function nonCachedInput(input, cached) {
-  if (typeof input !== "number" || !Number.isSafeInteger(input) || input < 0 || typeof cached !== "number" || !Number.isSafeInteger(cached) || cached < 0 || cached > input)
-    return null;
-  return input - cached;
-}
 function canonicalId(value, fallback) {
   return typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).length <= 64 ? value : fallback;
 }
@@ -1600,28 +1688,24 @@ function mapCodexQuotaSnapshots(snapshots, sourceEpoch) {
     }
   };
 }
-function mapCodexTelemetry(method, params, sourceEpoch) {
-  if (method === "thread/tokenUsage/updated") {
-    const u = params?.tokenUsage?.last ?? params?.token_usage?.last;
-    if (!u)
-      return [];
-    const input = u.inputTokens ?? u.input_tokens;
-    const cached = u.cachedInputTokens ?? u.cached_input_tokens;
-    return [{
-      kind: "telemetry",
-      name: "token_usage",
-      source: "codex_thread_token_usage_updated",
-      usage: {
-        input: nonCachedInput(input, cached),
-        output: metric(u.outputTokens ?? u.output_tokens),
-        cache: metric(cached)
-      }
-    }];
-  }
-  if (method === "account/rateLimits/updated") {
-    return [mapCodexQuotaSnapshots([params?.rateLimits ?? params ?? {}], sourceEpoch)];
-  }
-  return [];
+function mapCodexSettledUsage(params, projector) {
+  const backendSessionId = params?.threadId ?? params?.thread_id;
+  const providerRecordId = params?.responseId ?? params?.response_id;
+  const usage = params?.usage;
+  if (typeof backendSessionId !== "string" || typeof providerRecordId !== "string" || !usage)
+    return null;
+  return projector.project({
+    runtime: "codex",
+    backendSessionId,
+    providerRecordId,
+    source: "codex_raw_response_completed",
+    input: usage.inputTokens ?? usage.input_tokens,
+    output: usage.outputTokens ?? usage.output_tokens,
+    cacheRead: usage.cachedInputTokens ?? usage.cached_input_tokens,
+    cacheWrite: usage.cacheWriteInputTokens ?? usage.cache_write_input_tokens,
+    inputIncludesCache: true,
+    outputIncludesReasoning: true
+  });
 }
 
 // agent-driver/dist/adapters/codex/normalizer.js
@@ -1673,7 +1757,8 @@ class CodexEventNormalizer {
   rateLimitSnapshots = new Map;
   quotaSnapshotInitialized = false;
   quotaSourceGeneration = codexQuotaSourceGeneration;
-  pendingTurnUsage = null;
+  usageProjector = new SettledUsageProjector;
+  usageRecordsBySessionAndTurn = new Map;
   threadId = null;
   turnId = null;
   terminalTurn = null;
@@ -1746,7 +1831,8 @@ class CodexEventNormalizer {
     if (threadId !== this.threadId) {
       this.turnId = null;
       this.terminalTurn = null;
-      this.pendingTurnUsage = null;
+      this.usageProjector.reset();
+      this.usageRecordsBySessionAndTurn.clear();
     }
     this.threadId = threadId;
   }
@@ -1795,6 +1881,22 @@ class CodexEventNormalizer {
   }
   handleNotification(method, params) {
     const notificationThreadId = typeof params?.threadId === "string" ? params.threadId : null;
+    if (method === "rawResponse/completed")
+      return this.handleSettledUsage(params);
+    if (method === "turn/completed" && notificationThreadId !== null && notificationThreadId !== this.threadId) {
+      const turnId = this.notificationTurnId(params);
+      if (turnId)
+        this.releaseUsageForTurn(notificationThreadId, turnId);
+      return [];
+    }
+    if (method === "item/completed" && notificationThreadId !== null && notificationThreadId !== this.threadId) {
+      const turnId = this.notificationTurnId(params);
+      const itemType = params?.item?.type ?? params?.type;
+      if (turnId && itemType === "contextCompaction") {
+        this.releaseUsageForTurn(notificationThreadId, turnId);
+      }
+      return [];
+    }
     if (this.threadId !== null && notificationThreadId !== null && notificationThreadId !== this.threadId)
       return [];
     if (this.isRootWorkNotification(method) && !this.acceptRootWork(params))
@@ -1807,7 +1909,6 @@ class CodexEventNormalizer {
           return [];
         this.turnId = params.turn.id;
         this.terminalTurn = null;
-        this.pendingTurnUsage = null;
         return [
           {
             kind: "turn_owner",
@@ -1823,7 +1924,7 @@ class CodexEventNormalizer {
       case "item/started":
         return this.handleItemStarted(params);
       case "item/completed":
-        return this.handleItemCompleted(params);
+        return this.handleItemCompletedAndReleaseUsage(params);
       case "rawResponseItem/completed":
         return [{ kind: "internal_progress", source: "codex_raw_item", itemType: "rawResponseItem" }];
       case "configWarning":
@@ -1836,30 +1937,24 @@ class CodexEventNormalizer {
       case "turn/completed":
         if (!this.acceptRootTerminal(params))
           return [];
-        const usage = this.pendingTurnUsage;
-        this.pendingTurnUsage = null;
+        this.releaseUsageForTurn(params.threadId, params.turn.id);
         if (params.turn.status === "failed") {
           return [
-            ...usage ? [usage] : [],
             { kind: "error", message: "Codex turn failed" },
             { kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }
           ];
         }
         if (params.turn.status === "interrupted") {
-          return [...usage ? [usage] : [], { kind: "error", message: "Codex turn interrupted" }, { kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }];
+          return [{ kind: "error", message: "Codex turn interrupted" }, { kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }];
         }
-        return [...usage ? [usage] : [], { kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }];
+        return [{ kind: "turn_end", sessionId: this.threadId ?? undefined, turnOwner: this.turnReceipt(params.threadId, params.turn.id) }];
       case "error":
         if (params?.willRetry === true) {
           return [{ kind: "runtime_recovery", stage: "retrying", source: "codex_stream" }];
         }
         return [{ kind: "error", message: params?.error?.message ?? params?.message ?? "Codex error" }];
-      case "thread/tokenUsage/updated": {
-        const usage2 = mapCodexTelemetry(method, params, codexQuotaSourceEpoch)[0];
-        if (usage2)
-          this.pendingTurnUsage = usage2;
+      case "thread/tokenUsage/updated":
         return [];
-      }
       case "account/rateLimits/updated":
         return this.mergeQuotaSnapshots(params);
       case "account/updated":
@@ -1870,6 +1965,42 @@ class CodexEventNormalizer {
         return [];
     }
   }
+  handleSettledUsage(params) {
+    const notificationTurnId = this.notificationTurnId(params);
+    if (this.turnId === null && this.terminalTurn?.state === "closed" && notificationTurnId === this.terminalTurn.turnId && params?.threadId === this.terminalTurn.threadId)
+      return [];
+    const backendSessionId = params?.threadId ?? params?.thread_id;
+    const providerRecordId = params?.responseId ?? params?.response_id;
+    if (!notificationTurnId || typeof backendSessionId !== "string" || typeof providerRecordId !== "string")
+      return [];
+    const usage = mapCodexSettledUsage(params, this.usageProjector);
+    if (!usage)
+      return [];
+    const recordsByTurn = this.usageRecordsBySessionAndTurn.get(backendSessionId) ?? new Map;
+    const recordIds = recordsByTurn.get(notificationTurnId) ?? new Set;
+    recordIds.add(providerRecordId);
+    recordsByTurn.set(notificationTurnId, recordIds);
+    this.usageRecordsBySessionAndTurn.set(backendSessionId, recordsByTurn);
+    return [usage];
+  }
+  releaseUsageForTurn(backendSessionId, turnId) {
+    const recordsByTurn = this.usageRecordsBySessionAndTurn.get(backendSessionId);
+    for (const providerRecordId of recordsByTurn?.get(turnId) ?? []) {
+      this.usageProjector.release({ runtime: "codex", backendSessionId, providerRecordId });
+    }
+    recordsByTurn?.delete(turnId);
+    if (recordsByTurn?.size === 0)
+      this.usageRecordsBySessionAndTurn.delete(backendSessionId);
+  }
+  handleItemCompletedAndReleaseUsage(params) {
+    const events = this.handleItemCompleted(params);
+    const turnId = this.notificationTurnId(params);
+    const itemType = params?.item?.type ?? params?.type;
+    if (turnId && itemType === "contextCompaction" && turnId !== this.turnId && typeof params?.threadId === "string") {
+      this.releaseUsageForTurn(params.threadId, turnId);
+    }
+    return events;
+  }
   isRootWorkNotification(method) {
     return method === "item/reasoning/textDelta" || method === "item/reasoning/summaryTextDelta" || method === "item/agentMessage/delta" || method === "item/started" || method === "item/completed" || method === "rawResponseItem/completed";
   }
@@ -2020,10 +2151,59 @@ function stableErrorCode(value, fallback) {
   return /^[A-Za-z0-9_.-]{1,100}$/.test(code) ? code : fallback;
 }
 
+// agent-driver/dist/internal/modelCatalog.js
+var RUNTIME_MODEL_CATALOG_MAX = 512;
+var RUNTIME_MODEL_ID_MAX = 100;
+function normalizeRuntimeModelId(value) {
+  if (typeof value !== "string")
+    return;
+  const id = value.trim();
+  if (!id || id.length > RUNTIME_MODEL_ID_MAX || /\s/.test(id))
+    return;
+  return id;
+}
+function catalogFromIds(ids) {
+  const seen = new Set;
+  const models = [];
+  for (const rawId of ids) {
+    const id = normalizeRuntimeModelId(rawId);
+    if (!id || seen.has(id))
+      continue;
+    if (models.length >= RUNTIME_MODEL_CATALOG_MAX)
+      return;
+    seen.add(id);
+    models.push({ id, supportedReasoningEfforts: [] });
+  }
+  if (models.length === 0)
+    return;
+  return { updateMode: "unsupported", models };
+}
+function parseOpenCodeModelCatalog(output) {
+  const ids = output.split(/\r?\n/).flatMap((line) => {
+    const id = normalizeRuntimeModelId(line);
+    return id && /^[^/]+\/.+$/.test(id) ? [id] : [];
+  });
+  return catalogFromIds(ids);
+}
+function parsePiModelCatalog(values) {
+  if (!Array.isArray(values))
+    return;
+  const ids = values.flatMap((value) => {
+    if (!value || typeof value !== "object")
+      return [];
+    const model = value;
+    const provider = normalizeRuntimeModelId(model.provider);
+    const id = normalizeRuntimeModelId(model.id);
+    return provider && id && !provider.includes("/") ? [`${provider}/${id}`] : [];
+  });
+  return catalogFromIds(ids);
+}
+
 // agent-driver/dist/adapters/codex/index.js
 var SETTINGS_UPDATE_TIMEOUT_MS = 5000;
 var MODEL_LIST_TIMEOUT_MS = 5000;
-var MODEL_LIST_MAX = 64;
+var MODEL_LIST_OUTPUT_MAX_BYTES = 1024 * 1024;
+var MODEL_LIST_MAX = RUNTIME_MODEL_CATALOG_MAX;
 var MODEL_EFFORT_MAX = 16;
 function isCodexMissingRolloutError(message) {
   return /\bno\s+rollout\s+found\b/i.test(message) || /\bmissing\s+rollout\b/i.test(message) || /\brollout\b.*\b(not found|missing)\b/i.test(message) || /\b(not found|missing)\b.*\brollout\b/i.test(message);
@@ -2099,11 +2279,13 @@ class CodexDriver {
     return new Promise((resolve2) => {
       let settled = false;
       let buffer = "";
+      let outputBytes = 0;
       let nextId = 0;
       let initializeId = 0;
       let listId = 0;
       const models = [];
       const seenModels = new Set;
+      let overflow = false;
       let defaultModelId;
       const finish = (catalog) => {
         if (settled)
@@ -2121,12 +2303,16 @@ class CodexDriver {
 `);
       };
       const consumeModel = (value) => {
-        if (!value || typeof value !== "object" || models.length >= MODEL_LIST_MAX)
+        if (!value || typeof value !== "object")
           return;
         const model = value;
-        const id = typeof model.id === "string" ? model.id.trim() : "";
-        if (!id || id.length > 100 || seenModels.has(id))
+        const id = normalizeRuntimeModelId(model.id);
+        if (!id || seenModels.has(id))
+          return;
+        if (models.length >= MODEL_LIST_MAX) {
+          overflow = true;
           return;
+        }
         const rawOptions = Array.isArray(model.supportedReasoningEfforts) ? model.supportedReasoningEfforts : [];
         const seenEfforts = new Set;
         const supportedReasoningEfforts = rawOptions.flatMap((raw) => {
@@ -2170,9 +2356,15 @@ class CodexDriver {
         const result = message.result;
         for (const model of Array.isArray(result.data) ? result.data : [])
           consumeModel(model);
+        if (overflow)
+          return finish();
         const cursor = typeof result.nextCursor === "string" ? result.nextCursor : undefined;
-        if (cursor && models.length < MODEL_LIST_MAX)
+        if (cursor && models.length >= MODEL_LIST_MAX)
+          return finish();
+        if (cursor)
           return requestModelPage(cursor);
+        if (models.length === 0)
+          return finish();
         finish({
           updateMode: "live_next_turn",
           ...defaultModelId ? { defaultModelId } : {},
@@ -2182,7 +2374,11 @@ class CodexDriver {
       const timer = setTimeout(() => finish(), MODEL_LIST_TIMEOUT_MS);
       timer.unref?.();
       proc.stdout?.on("data", (chunk) => {
-        buffer += chunk.toString();
+        const text = chunk.toString();
+        outputBytes += Buffer.byteLength(text);
+        if (outputBytes > MODEL_LIST_OUTPUT_MAX_BYTES)
+          return finish();
+        buffer += text;
         const lines = buffer.split(`
 `);
         buffer = lines.pop() ?? "";
@@ -2385,9 +2581,189 @@ class CodexDriver {
 
 // agent-driver/dist/adapters/cursor/acp-lane.js
 import { EventEmitter as EventEmitter2 } from "node:events";
+
+// agent-driver/dist/adapters/cursor/catalog-probe.js
 var ACP_PROTOCOL_VERSION = 1;
-var HANDSHAKE_TIMEOUT_MS = 15000;
 var AUTH_METHOD_ID = "cursor_login";
+var CATALOG_PROBE_TIMEOUT_MS = 15000;
+var CATALOG_PROBE_OUTPUT_MAX_BYTES = 1024 * 1024;
+var MODEL_DISPLAY_NAME_MAX = 256;
+var MODEL_OPTION_NESTING_MAX = 16;
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function normalizeDisplayName(value) {
+  if (typeof value !== "string")
+    return;
+  const displayName = value.trim();
+  return displayName && displayName.length <= MODEL_DISPLAY_NAME_MAX ? displayName : undefined;
+}
+function flattenCursorAcpSelectOptions(value, depth = 0) {
+  if (!Array.isArray(value) || depth > MODEL_OPTION_NESTING_MAX)
+    return [];
+  const options = [];
+  for (const item of value) {
+    if (Array.isArray(item)) {
+      options.push(...flattenCursorAcpSelectOptions(item, depth + 1));
+      continue;
+    }
+    const candidate = record(item);
+    if (!candidate)
+      continue;
+    const exactValue = normalizeRuntimeModelId(candidate.value);
+    if (exactValue) {
+      const name = normalizeDisplayName(candidate.name);
+      options.push({ value: exactValue, ...name ? { name } : {} });
+    }
+    if (Array.isArray(candidate.options)) {
+      options.push(...flattenCursorAcpSelectOptions(candidate.options, depth + 1));
+    }
+  }
+  return options;
+}
+function parseCursorAcpModelCatalog(session) {
+  const payload = record(session);
+  const configOptions = Array.isArray(payload?.configOptions) ? payload.configOptions : [];
+  const modelConfig = configOptions.map(record).find((option) => option?.id === "model") ?? null;
+  if (!modelConfig)
+    return;
+  const seen = new Set;
+  const models = [];
+  for (const option of flattenCursorAcpSelectOptions(modelConfig.options)) {
+    if (option.value === "default[]" || seen.has(option.value))
+      continue;
+    if (models.length >= RUNTIME_MODEL_CATALOG_MAX)
+      return;
+    seen.add(option.value);
+    models.push({
+      id: option.value,
+      ...option.name ? { displayName: option.name } : {},
+      supportedReasoningEfforts: []
+    });
+  }
+  return models.length > 0 ? { updateMode: "unsupported", models } : undefined;
+}
+async function cleanupProbeProcess(process2) {
+  if (process2.pid) {
+    await killProcessTree(process2.pid, { graceMs: 250 }).catch(() => {});
+    return;
+  }
+  if (process2.exitCode === null && process2.signalCode === null)
+    process2.kill("SIGTERM");
+}
+async function probeCursorAcpCatalog(command, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const spec = resolveSpawnSpec("cursor-agent", ["acp"], command);
+  let processHandle;
+  try {
+    processHandle = (options.spawn ?? spawnAgentProcess)(spec.command, spec.args, {
+      cwd,
+      env: { ...process.env, CI: "1" },
+      shell: spec.shell
+    });
+  } catch {
+    return;
+  }
+  return new Promise((resolve2) => {
+    let settled = false;
+    let buffer = "";
+    let outputBytes = 0;
+    let requestId = 0;
+    let expectedId = 0;
+    let expectedMethod = "";
+    const finish = (catalog) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      const cleanup = options.cleanup ?? cleanupProbeProcess;
+      Promise.resolve().then(() => cleanup(processHandle)).catch(() => {}).finally(() => resolve2(catalog));
+    };
+    const request = (method, params) => {
+      if (settled)
+        return;
+      const stdin = processHandle.stdin;
+      if (!stdin || stdin.destroyed || stdin.writableEnded || stdin.writable === false)
+        return finish();
+      expectedId = ++requestId;
+      expectedMethod = method;
+      try {
+        stdin.write(`${jsonRpcRequest(method, params, expectedId)}
+`);
+      } catch {
+        finish();
+      }
+    };
+    const onLine = (line) => {
+      const parsed = tryParseJsonLine(line);
+      const message = record(parsed);
+      if (!message)
+        return finish();
+      if (message.id !== expectedId)
+        return;
+      if (message.error !== undefined)
+        return finish();
+      if (!Object.prototype.hasOwnProperty.call(message, "result"))
+        return finish();
+      if (expectedMethod === "authenticate") {
+        request("session/new", { cwd, mcpServers: [] });
+        return;
+      }
+      const result = record(message.result);
+      if (!result)
+        return finish();
+      if (expectedMethod === "initialize") {
+        const authMethods = Array.isArray(result.authMethods) ? result.authMethods : [];
+        if (result.protocolVersion !== ACP_PROTOCOL_VERSION || !authMethods.some((method) => record(method)?.id === AUTH_METHOD_ID))
+          return finish();
+        request("authenticate", { methodId: AUTH_METHOD_ID });
+        return;
+      }
+      if (expectedMethod !== "session/new" || typeof result.sessionId !== "string" || !result.sessionId.trim())
+        return finish();
+      finish(parseCursorAcpModelCatalog(result));
+    };
+    const timer = setTimeout(() => finish(), options.timeoutMs ?? CATALOG_PROBE_TIMEOUT_MS);
+    timer.unref?.();
+    processHandle.stdout?.on("data", (chunk) => {
+      if (settled)
+        return;
+      const text = chunk.toString();
+      outputBytes += Buffer.byteLength(text);
+      if (outputBytes > (options.outputMaxBytes ?? CATALOG_PROBE_OUTPUT_MAX_BYTES))
+        return finish();
+      buffer += text;
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines)
+        if (line.trim())
+          onLine(line);
+    });
+    processHandle.stderr?.on("data", (chunk) => {
+      if (settled)
+        return;
+      outputBytes += Buffer.byteLength(chunk.toString());
+      if (outputBytes > (options.outputMaxBytes ?? CATALOG_PROBE_OUTPUT_MAX_BYTES))
+        finish();
+    });
+    processHandle.on("error", () => finish());
+    processHandle.on("exit", () => finish());
+    request("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false },
+        terminal: false
+      },
+      clientInfo: { name: "alook-agent-driver-probe", version: "0.1.25" }
+    });
+  });
+}
+
+// agent-driver/dist/adapters/cursor/acp-lane.js
+var ACP_PROTOCOL_VERSION2 = 1;
+var HANDSHAKE_TIMEOUT_MS = 15000;
+var AUTH_METHOD_ID2 = "cursor_login";
 var PROMPT_STOP_REASONS = new Set([
   "end_turn",
   "max_tokens",
@@ -2411,16 +2787,16 @@ class CursorAcpRpcError extends Error {
     this.code = code;
   }
 }
-function record(value) {
+function record2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function safeLabel(value) {
   return typeof value === "string" && /^[a-z0-9_-]{1,64}$/i.test(value) ? value : "unknown";
 }
 function rpcErrorMessage(error) {
-  const payload = record(error);
+  const payload = record2(error);
   const message = typeof payload?.message === "string" && payload.message.trim() ? payload.message : "Cursor ACP request failed";
-  const data = record(payload?.data);
+  const data = record2(payload?.data);
   const detail = typeof data?.message === "string" && data.message.trim() ? data.message : undefined;
   return detail ? `${message}: ${detail}` : message;
 }
@@ -2428,26 +2804,6 @@ function isMissingSessionError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return /\bsession\b.*\b(not found|missing|unknown|invalid)\b/i.test(message) || /\b(not found|missing|unknown|invalid)\b.*\bsession\b/i.test(message);
 }
-function flattenSelectOptions(value) {
-  if (!Array.isArray(value))
-    return [];
-  const out = [];
-  for (const item of value) {
-    if (Array.isArray(item)) {
-      out.push(...flattenSelectOptions(item));
-      continue;
-    }
-    const candidate = record(item);
-    if (!candidate)
-      continue;
-    if (typeof candidate.value === "string") {
-      out.push({ value: candidate.value, ...typeof candidate.name === "string" ? { name: candidate.name } : {} });
-    }
-    if (Array.isArray(candidate.options))
-      out.push(...flattenSelectOptions(candidate.options));
-  }
-  return out;
-}
 
 class CursorAcpLane {
   factory;
@@ -2571,30 +2927,30 @@ class CursorAcpLane {
     }
   }
   async handshake(ctx) {
-    const initialize = record(await this.call("initialize", {
-      protocolVersion: ACP_PROTOCOL_VERSION,
+    const initialize = record2(await this.call("initialize", {
+      protocolVersion: ACP_PROTOCOL_VERSION2,
       clientCapabilities: {
         fs: { readTextFile: false, writeTextFile: false },
         terminal: false
       },
       clientInfo: { name: "alook-agent-driver", version: "0.1.14" }
     }));
-    if (initialize?.protocolVersion !== ACP_PROTOCOL_VERSION) {
+    if (initialize?.protocolVersion !== ACP_PROTOCOL_VERSION2) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not support protocol version 1");
     }
-    const capabilities = record(initialize.agentCapabilities);
+    const capabilities = record2(initialize.agentCapabilities);
     if (capabilities?.loadSession !== true) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not support persistent session loading");
     }
     const authMethods = Array.isArray(initialize.authMethods) ? initialize.authMethods : [];
-    if (!authMethods.some((method) => record(method)?.id === AUTH_METHOD_ID)) {
+    if (!authMethods.some((method) => record2(method)?.id === AUTH_METHOD_ID2)) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not expose Cursor login authentication");
     }
-    await this.call("authenticate", { methodId: AUTH_METHOD_ID });
+    await this.call("authenticate", { methodId: AUTH_METHOD_ID2 });
     let session;
     if (ctx.config.sessionId) {
       try {
-        session = record(await this.call("session/load", {
+        session = record2(await this.call("session/load", {
           sessionId: ctx.config.sessionId,
           cwd: ctx.workingDirectory,
           mcpServers: []
@@ -2606,15 +2962,25 @@ class CursorAcpLane {
         throw error;
       }
     } else {
-      session = record(await this.call("session/new", { cwd: ctx.workingDirectory, mcpServers: [] }));
+      session = record2(await this.call("session/new", { cwd: ctx.workingDirectory, mcpServers: [] }));
     }
-    if (!session || typeof session.sessionId !== "string" || !session.sessionId.trim()) {
+    if (!session)
+      throw new Error("Cursor ACP did not return a valid session response");
+    const returnedSessionId = session.sessionId;
+    if (returnedSessionId !== undefined && (typeof returnedSessionId !== "string" || !returnedSessionId.trim())) {
       throw new Error("Cursor ACP did not return a valid session id");
     }
-    if (ctx.config.sessionId && session.sessionId !== ctx.config.sessionId) {
-      throw new CursorAcpResetRequiredError("Cursor ACP loaded a different session; reset this agent before continuing");
+    if (ctx.config.sessionId) {
+      if (returnedSessionId !== undefined && returnedSessionId !== ctx.config.sessionId) {
+        throw new CursorAcpResetRequiredError("Cursor ACP loaded a different session; reset this agent before continuing");
+      }
+      this.sessionId = ctx.config.sessionId;
+    } else {
+      if (typeof returnedSessionId !== "string") {
+        throw new Error("Cursor ACP did not return a valid session id");
+      }
+      this.sessionId = returnedSessionId;
     }
-    this.sessionId = session.sessionId;
     await this.configureModel(session, ctx);
   }
   async configureModel(session, ctx) {
@@ -2622,24 +2988,30 @@ class CursorAcpLane {
     if (!requestedModel)
       return;
     const configOptions = Array.isArray(session.configOptions) ? session.configOptions : [];
-    const modelConfig = configOptions.map(record).find((option) => option?.id === "model") ?? null;
+    const modelConfig = configOptions.map(record2).find((option) => option?.id === "model") ?? null;
     if (!modelConfig) {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP does not support model configuration");
     }
-    const options = flattenSelectOptions(modelConfig.options);
-    const match = options.find((option) => option.value === requestedModel) ?? options.find((option) => option.name === requestedModel);
+    const options = flattenCursorAcpSelectOptions(modelConfig.options);
+    const match = options.find((option) => option.value === requestedModel);
     if (!match) {
       throw new CursorAcpIncompatibleError(`Configured Cursor model is unavailable through ACP: ${requestedModel}`);
     }
+    let response;
     try {
-      await this.call("session/set_config_option", {
+      response = record2(await this.call("session/set_config_option", {
         sessionId: this.sessionId,
         configId: "model",
         value: match.value
-      });
+      }));
     } catch {
       throw new CursorAcpIncompatibleError("Installed Cursor ACP rejected model configuration");
     }
+    const confirmedOptions = Array.isArray(response?.configOptions) ? response.configOptions : [];
+    const confirmedModel = confirmedOptions.map(record2).find((option) => option?.id === "model") ?? null;
+    if (confirmedModel?.currentValue !== match.value) {
+      throw new CursorAcpIncompatibleError("Cursor ACP did not confirm the exact configured model");
+    }
   }
   admitPrompt(text) {
     if (!this.sessionId)
@@ -2675,7 +3047,7 @@ class CursorAcpLane {
   completePrompt(active, value) {
     if (this.activePrompt?.requestId !== active.requestId)
       return;
-    const result = record(value);
+    const result = record2(value);
     if (!result || typeof result.stopReason !== "string" || !PROMPT_STOP_REASONS.has(result.stopReason)) {
       this.failPrompt(active, new Error("Cursor ACP prompt response did not contain a supported stopReason"));
       return;
@@ -2817,7 +3189,7 @@ class CursorAcpLane {
     });
   }
   handleMessage(value) {
-    const message = record(value);
+    const message = record2(value);
     if (!message || message.jsonrpc !== "2.0") {
       this.protocolFailure("Cursor ACP emitted an invalid JSON-RPC message");
       return;
@@ -2845,7 +3217,7 @@ class CursorAcpLane {
     if (pending.kind === "prompt") {
       this.pending.delete(id);
       if (message.error !== undefined) {
-        const payload = record(message.error);
+        const payload = record2(message.error);
         this.failPrompt(pending.active, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message.error)));
       } else if (!("result" in message)) {
         this.failPrompt(pending.active, new Error("Cursor ACP response omitted result"));
@@ -2855,7 +3227,7 @@ class CursorAcpLane {
       return;
     }
     if (message.error !== undefined) {
-      const payload = record(message.error);
+      const payload = record2(message.error);
       this.settleRequest(id, false, new CursorAcpRpcError(pending.method, typeof payload?.code === "number" ? payload.code : undefined, rpcErrorMessage(message.error)));
       return;
     }
@@ -2887,9 +3259,9 @@ class CursorAcpLane {
       this.diagnostic("warning", `Unsupported Cursor ACP client request: ${safeLabel(method)}`);
       return;
     }
-    const payload = record(params);
+    const payload = record2(params);
     const sameSession = payload?.sessionId === this.sessionId;
-    const options = Array.isArray(payload?.options) ? payload.options.map(record).filter(Boolean) : [];
+    const options = Array.isArray(payload?.options) ? payload.options.map(record2).filter(Boolean) : [];
     const allowOnce = options.find((option) => option.kind === "allow_once" && typeof option.optionId === "string" && option.optionId.trim().length > 0);
     if (!this.ready || !this.activePrompt || !sameSession || !allowOnce) {
       this.write({ jsonrpc: "2.0", id, result: { outcome: { outcome: "cancelled" } } });
@@ -2910,7 +3282,7 @@ class CursorAcpLane {
     this.diagnostic("warning", `Unsupported Cursor ACP notification: ${safeLabel(method)}`);
   }
   handleSessionUpdate(params) {
-    const payload = record(params);
+    const payload = record2(params);
     if (!payload || payload.sessionId !== this.sessionId) {
       this.diagnostic("warning", "Cursor ACP emitted an update for a different session");
       return;
@@ -2919,18 +3291,18 @@ class CursorAcpLane {
       this.diagnostic("warning", "Cursor ACP emitted a session update without an active prompt");
       return;
     }
-    const update = record(payload.update) ?? {};
+    const update = record2(payload.update) ?? {};
     const updateType = update?.sessionUpdate;
     switch (updateType) {
       case "agent_message_chunk": {
-        const content = record(update.content);
+        const content = record2(update.content);
         if (content?.type === "text" && typeof content.text === "string") {
           this.events.emit("runtime_event", { kind: "assistant_message_delta", text: content.text });
         }
         return;
       }
       case "agent_thought_chunk": {
-        const content = record(update.content);
+        const content = record2(update.content);
         if (content?.type === "text" && typeof content.text === "string") {
           this.events.emit("runtime_event", { kind: "assistant_reasoning_delta", text: content.text });
         }
@@ -3002,6 +3374,7 @@ class CursorAcpLane {
 
 // agent-driver/dist/adapters/cursor/index.js
 class CursorDriver {
+  catalogProbe;
   id = "cursor";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -3010,8 +3383,23 @@ class CursorDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
-  probe(command) {
-    return probeCliRuntime("cursor-agent", {}, command);
+  constructor(catalogProbe = probeCursorAcpCatalog) {
+    this.catalogProbe = catalogProbe;
+  }
+  async probe(command) {
+    const result = probeCliRuntime("cursor-agent", {}, command);
+    if (result.status !== "healthy")
+      return result;
+    let reasoning;
+    try {
+      reasoning = await this.catalogProbe(command);
+    } catch {
+      reasoning = undefined;
+    }
+    return {
+      ...result,
+      reasoning
+    };
   }
   async openLane(ctx, options) {
     return new CursorAcpLane(this, ctx, { onRawStdoutLine: options?.onRawStdoutLine });
@@ -3068,7 +3456,7 @@ class OpenCodeHttpError extends Error {
     this.status = status;
   }
 }
-function record2(value) {
+function record3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function safeLabel2(value) {
@@ -3115,7 +3503,7 @@ function parseModelRef(model) {
   return { providerID: model.slice(0, slash), id: model.slice(slash + 1) };
 }
 function messageFromError(value) {
-  const payload = record2(value);
+  const payload = record3(value);
   const message = typeof payload?.message === "string" && payload.message.trim() ? payload.message : undefined;
   return message ? "OpenCode turn failed" : "OpenCode reported an inconsistent turn outcome";
 }
@@ -3157,6 +3545,7 @@ class OpenCodeServiceLane {
   lastDurableSeq = 0;
   durableSeqById = new Map;
   durableIdBySeq = new Map;
+  usageProjector = new SettledUsageProjector;
   toolNames = new Map;
   handledPermissions = new Set;
   permissionFlights = new Map;
@@ -3449,7 +3838,7 @@ class OpenCodeServiceLane {
         const healthTimeoutMs = Math.max(1, Math.min(1000, deadline - Date.now(), this.options.requestTimeoutMs ?? REQUEST_TIMEOUT_MS));
         const { response, body } = await this.fetchJsonWithTimeout("/global/health", { method: "GET" }, "health", healthTimeoutMs);
         if (response.ok) {
-          const health = record2(body);
+          const health = record3(body);
           if (health?.healthy !== true || health.version !== SUPPORTED_VERSION) {
             throw new OpenCodeIncompatibleError(`Installed OpenCode service must be version ${SUPPORTED_VERSION}`);
           }
@@ -3470,8 +3859,8 @@ class OpenCodeServiceLane {
     const { response, body } = await this.fetchJsonWithTimeout("/doc", { method: "GET" }, "OpenAPI");
     if (!response.ok)
       throw new OpenCodeIncompatibleError("Installed OpenCode service does not expose its OpenAPI document");
-    const document = record2(body);
-    const paths = record2(document?.paths);
+    const document = record3(body);
+    const paths = record3(document?.paths);
     const required = [
       "/api/session",
       "/api/session/active",
@@ -3484,7 +3873,7 @@ class OpenCodeServiceLane {
       "/api/session/{sessionID}/permission/{requestID}/reply",
       "/api/event"
     ];
-    if (!paths || required.some((path6) => !record2(paths[path6]))) {
+    if (!paths || required.some((path6) => !record3(paths[path6]))) {
       throw new OpenCodeIncompatibleError("Installed OpenCode service is missing required v2 session capabilities");
     }
   }
@@ -3497,7 +3886,7 @@ class OpenCodeServiceLane {
       }
       if (!response2.ok)
         throw new OpenCodeHttpError(response2.status, "session resume");
-      const session2 = record2(record2(body2)?.data);
+      const session2 = record3(record3(body2)?.data);
       if (session2?.id !== resumeId) {
         throw new OpenCodeResetRequiredError("OpenCode v2 returned a different resumed session; reset this agent before continuing");
       }
@@ -3518,8 +3907,8 @@ class OpenCodeServiceLane {
     }, "session create");
     if (!response.ok)
       throw new OpenCodeHttpError(response.status, "session create");
-    const payload = record2(responseBody);
-    const session = record2(payload?.data);
+    const payload = record3(responseBody);
+    const session = record3(payload?.data);
     if (typeof session?.id !== "string" || !/^ses/.test(session.id)) {
       throw new Error("OpenCode v2 did not return a valid session id");
     }
@@ -3676,7 +4065,7 @@ class OpenCodeServiceLane {
         const { response, body: responseBody } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/history?after=${historyCursor}&limit=${HISTORY_PAGE_LIMIT}`, { method: "GET" }, "session history");
         if (!response.ok)
           throw new OpenCodeHttpError(response.status, "session history");
-        const body = record2(responseBody);
+        const body = record3(responseBody);
         if (!Array.isArray(body?.data) || typeof body.hasMore !== "boolean") {
           throw new OpenCodeProtocolError("OpenCode session history returned an invalid page");
         }
@@ -3694,10 +4083,11 @@ class OpenCodeServiceLane {
     return run;
   }
   async handleDurableEvent(value, project) {
-    const event = record2(value);
-    const durable = record2(event?.durable);
-    const data = record2(event?.data);
-    if (!event || typeof event.id !== "string" || typeof event.type !== "string" || !durable || durable.aggregateID !== this.sessionId || !Number.isInteger(durable.seq) || Number(durable.seq) < 0 || data?.sessionID !== this.sessionId) {
+    const event = record3(value);
+    const durable = record3(event?.durable);
+    const data = record3(event?.data);
+    const backendSessionId = this.sessionId;
+    if (!event || !backendSessionId || typeof event.id !== "string" || typeof event.type !== "string" || !durable || durable.aggregateID !== this.sessionId || !Number.isInteger(durable.seq) || Number(durable.seq) < 0 || data?.sessionID !== this.sessionId) {
       throw new OpenCodeProtocolError("OpenCode session stream emitted an invalid durable event");
     }
     const seq = Number(durable.seq);
@@ -3786,22 +4176,28 @@ class OpenCodeServiceLane {
             ...!successful ? { message: "OpenCode reported an unsupported final step outcome" } : {}
           });
         }
-        const tokens = record2(data.tokens);
-        if (tokens && data.finish !== "tool-calls") {
-          const cache = record2(tokens.cache);
-          const metric2 = (value2) => typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0 ? value2 : null;
-          const cacheParts = [cache?.read, cache?.write].filter((value2) => typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0);
-          const cacheTotal = cacheParts.reduce((sum, value2) => sum + value2, 0);
-          this.events.emit("runtime_event", {
-            kind: "telemetry",
-            name: "token_usage",
+        const tokens = record3(data.tokens);
+        if (tokens) {
+          const cache = record3(tokens.cache);
+          const identity = {
+            runtime: "opencode",
+            backendSessionId,
+            providerRecordId: event.id
+          };
+          const usage = this.usageProjector.project({
+            ...identity,
             source: "opencode.v2",
-            usage: {
-              input: metric2(tokens.input),
-              output: metric2(tokens.output),
-              cache: cacheParts.length > 0 && Number.isSafeInteger(cacheTotal) ? cacheTotal : null
-            }
+            input: tokens.input,
+            output: tokens.output,
+            reasoning: tokens.reasoning,
+            cacheRead: cache?.read,
+            cacheWrite: cache?.write,
+            inputIncludesCache: false,
+            outputIncludesReasoning: false
           });
+          if (usage)
+            this.events.emit("runtime_event", usage);
+          this.usageProjector.release(identity);
         }
         break;
       }
@@ -3815,8 +4211,8 @@ class OpenCodeServiceLane {
     return seq;
   }
   async handleLiveEvent(value) {
-    const event = record2(value);
-    const data = record2(event?.data);
+    const event = record3(value);
+    const data = record3(event?.data);
     if (event?.type !== "permission.v2.asked" || data?.sessionID !== this.sessionId)
       return;
     if (typeof data.id !== "string" || !/^per/.test(data.id)) {
@@ -3830,11 +4226,11 @@ class OpenCodeServiceLane {
     const { response, body: responseBody } = await this.fetchJsonWithTimeout(`/api/session/${encodeURIComponent(this.sessionId)}/permission`, { method: "GET" }, "permission list");
     if (!response.ok)
       throw new OpenCodeHttpError(response.status, "permission list");
-    const body = record2(responseBody);
+    const body = record3(responseBody);
     if (!Array.isArray(body?.data))
       throw new OpenCodeProtocolError("OpenCode permission list returned invalid data");
     for (const item of body.data) {
-      const permission = record2(item);
+      const permission = record3(item);
       if (permission?.sessionID === this.sessionId && typeof permission.id === "string") {
         await this.replyPermission(permission.id);
       }
@@ -3901,8 +4297,8 @@ class OpenCodeServiceLane {
       }, "prompt admission");
       if (!response.ok)
         throw new OpenCodeHttpError(response.status, "prompt admission");
-      const body = record2(responseBody);
-      const admitted = record2(body?.data);
+      const body = record3(responseBody);
+      const admitted = record3(body?.data);
       if (admitted?.id !== messageId || admitted.sessionID !== this.sessionId || admitted.delivery !== delivery || !Number.isInteger(admitted.admittedSeq) || Number(admitted.admittedSeq) < 0) {
         throw new OpenCodeProtocolError("OpenCode prompt admission returned an invalid receipt");
       }
@@ -3969,8 +4365,8 @@ class OpenCodeServiceLane {
       const { response, body: responseBody } = await this.fetchJsonWithTimeout("/api/session/active", { method: "GET" }, "active session query");
       if (!response.ok)
         throw new OpenCodeHttpError(response.status, "active session query");
-      const body = record2(responseBody);
-      const active = record2(body?.data);
+      const body = record3(responseBody);
+      const active = record3(body?.data);
       if (!active)
         throw new OpenCodeProtocolError("OpenCode active session query returned invalid data");
       if (!this.barrierStillCurrent(root, identity, generation))
@@ -4175,6 +4571,7 @@ function createOpenCodeMessageId() {
 }
 
 class OpenCodeDriver {
+  outputProbe;
   id = "opencode";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -4183,8 +4580,19 @@ class OpenCodeDriver {
     wakeStart: "immediate",
     terminalOwnership: "transport_request"
   };
+  constructor(outputProbe = probeCommandOutput) {
+    this.outputProbe = outputProbe;
+  }
   probe(command) {
-    return probeCliRuntime("opencode", {}, command);
+    const result = probeCliRuntime("opencode", {}, command);
+    if (result.status !== "healthy")
+      return result;
+    const spec = resolveSpawnSpec("opencode", ["models", "--pure"], command);
+    const output = this.outputProbe(spec.command, spec.args);
+    return {
+      ...result,
+      reasoning: output.ok ? parseOpenCodeModelCatalog(output.output) : undefined
+    };
   }
   beginTurn() {
     return createOpenCodeMessageId();
@@ -4438,6 +4846,7 @@ function createPiSessionDependencies(ctx, loadSdk = loadPiSdkModule) {
 
 // agent-driver/dist/adapters/pi/index.js
 var PI_SDK_PACKAGE_NAME2 = "@earendil-works/pi-coding-agent";
+var PI_MODEL_PROBE_TIMEOUT_MS = 5000;
 function isPiSdkPackageJson(pkgJsonPath) {
   if (!existsSync3(pkgJsonPath))
     return false;
@@ -4507,6 +4916,11 @@ function readPiSdkVersion() {
   } catch {}
   return resolvePiSdkVersionFromPath();
 }
+function piUsageState(state) {
+  state.usageProjector ??= new SettledUsageProjector;
+  state.pendingUsageRecordIds ??= new Set;
+  return { projector: state.usageProjector, pending: state.pendingUsageRecordIds };
+}
 function mapPiSdkEvent(event, sessionId, state) {
   if (event?.type === "message_update") {
     const d = event.assistantMessageEvent ?? {};
@@ -4527,6 +4941,35 @@ function mapPiSdkEvent(event, sessionId, state) {
     }
   }
   switch (event?.type) {
+    case "message_end": {
+      const message = event.message;
+      if (message?.role !== "assistant" || !message.usage)
+        return [];
+      state.usageRecordSequence = (state.usageRecordSequence ?? 0) + 1;
+      const providerRecordId = typeof message.responseId === "string" && message.responseId ? message.responseId : `live:${message.timestamp ?? "unknown"}:${state.usageRecordSequence}`;
+      const { projector, pending } = piUsageState(state);
+      const identity = { runtime: "pi", backendSessionId: sessionId, providerRecordId };
+      const usage = projector.project({
+        ...identity,
+        source: "pi_message_end",
+        input: message.usage.input,
+        output: message.usage.output,
+        cacheRead: message.usage.cacheRead,
+        cacheWrite: message.usage.cacheWrite,
+        inputIncludesCache: false,
+        outputIncludesReasoning: true
+      });
+      pending.add(providerRecordId);
+      return usage ? [usage] : [];
+    }
+    case "turn_end": {
+      const { projector, pending } = piUsageState(state);
+      for (const providerRecordId of pending) {
+        projector.release({ runtime: "pi", backendSessionId: sessionId, providerRecordId });
+      }
+      pending.clear();
+      return [];
+    }
     case "auto_retry_start":
       return [{ kind: "runtime_recovery", stage: "retrying", source: "pi_auto_retry" }];
     case "auto_retry_end":
@@ -4546,6 +4989,8 @@ function mapPiSdkEvent(event, sessionId, state) {
 
 class PiDriver {
   dependenciesFor;
+  loadSdk;
+  readVersion;
   id = "pi";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -4556,15 +5001,36 @@ class PiDriver {
   };
   sessionId = null;
   terminalSequence = 0;
-  constructor(dependenciesFor = createPiSessionDependencies) {
+  constructor(dependenciesFor = createPiSessionDependencies, loadSdk = loadPiSdkModule, readVersion = readPiSdkVersion) {
     this.dependenciesFor = dependenciesFor;
+    this.loadSdk = loadSdk;
+    this.readVersion = readVersion;
   }
-  probe() {
-    const version = readPiSdkVersion();
+  async probe() {
+    const version = this.readVersion();
     if (!version) {
       return { status: "unhealthy", lastError: "sdk_not_installed" };
     }
-    return { status: "healthy", version };
+    let timer;
+    try {
+      const reasoning = await Promise.race([
+        this.loadSdk().then(async (sdk) => {
+          const authStorage = sdk.AuthStorage.create();
+          const registry = sdk.ModelRegistry.create(authStorage);
+          return parsePiModelCatalog(await registry.getAvailable());
+        }),
+        new Promise((resolve3) => {
+          timer = setTimeout(() => resolve3(undefined), PI_MODEL_PROBE_TIMEOUT_MS);
+          timer.unref?.();
+        })
+      ]);
+      return { status: "healthy", version, reasoning };
+    } catch {
+      return { status: "healthy", version, reasoning: undefined };
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
   }
   async openLane(ctx) {
     const deps = this.dependenciesFor(ctx);
@@ -6596,8 +7062,8 @@ async function readClaudeQuota(options) {
   if (!body || typeof body !== "object") {
     return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
-  const record3 = body;
-  const limits = ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"].map((key) => claudeLimit(key, record3[key])).filter((limit) => limit !== null);
+  const record4 = body;
+  const limits = ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"].map((key) => claudeLimit(key, record4[key])).filter((limit) => limit !== null);
   if (limits.length === 0) {
     return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
@@ -7254,10 +7720,10 @@ function stableNormalizeApmHeldFreshness(value) {
     return value.map((item) => stableNormalizeApmHeldFreshness(item));
   if (!value || typeof value !== "object")
     return value;
-  const record3 = value;
+  const record4 = value;
   const normalized = {};
-  for (const key of Object.keys(record3).sort()) {
-    normalized[key] = stableNormalizeApmHeldFreshness(record3[key]);
+  for (const key of Object.keys(record4).sort()) {
+    normalized[key] = stableNormalizeApmHeldFreshness(record4[key]);
   }
   return normalized;
 }
@@ -7373,13 +7839,13 @@ function reduceManager(state, event) {
       const existing = state.agents[event.agentId];
       if (!existing || existing.execution.sessionInstanceId !== event.sessionInstanceId)
         return { state, effects: [] };
-      const record3 = existing.pendingAdmissions.find((entry) => entry.sessionInstanceId === event.sessionInstanceId && entry.commandId === event.commandId);
-      if (!record3)
+      const record4 = existing.pendingAdmissions.find((entry) => entry.sessionInstanceId === event.sessionInstanceId && entry.commandId === event.commandId);
+      if (!record4)
         return { state, effects: [] };
       const agent = clone(existing);
       agent.pendingAdmissions = agent.pendingAdmissions.filter((entry) => entry.sessionInstanceId !== event.sessionInstanceId || entry.commandId !== event.commandId);
       syncExecutionProjection(agent);
-      return commit(state, agent, event.outcome === "failed" ? recoveryEffects(agent, [record3]) : []);
+      return commit(state, agent, event.outcome === "failed" ? recoveryEffects(agent, [record4]) : []);
     }
     case "admission_acknowledged": {
       const existing = state.agents[event.agentId];
@@ -7897,11 +8363,11 @@ function syncExecutionProjection(agent) {
   agent.lastDeliverAt = agent.pendingAdmissions.length > 0 ? Math.max(...agent.pendingAdmissions.map((entry) => entry.admittedAt)) : null;
 }
 function recoveryEffects(agent, records) {
-  return records.filter((record3) => record3.requeueOnFailure).map((record3) => ({
+  return records.filter((record4) => record4.requeueOnFailure).map((record4) => ({
     type: "requeue_delivery",
     agentId: agent.agentId,
-    message: record3.exactAgentMsg,
-    mode: record3.mode
+    message: record4.exactAgentMsg,
+    mode: record4.mode
   }));
 }
 function commit(state, agent, effects) {
@@ -8312,14 +8778,14 @@ function createLogger(options = {}) {
 `));
   const err = options.err ?? ((line) => process.stderr.write(line + `
 `));
-  const record3 = options.record;
+  const record4 = options.record;
   const emit = (level, message, data) => {
     if (LEVEL_RANK[level] < minRank)
       return;
     const time = now();
     const line = `${time} ${header} ${level.toUpperCase().padEnd(5)} ${message}${formatData(data)}`;
     try {
-      record3?.({ time, header, level, message, fields: recordFields(data) });
+      record4?.({ time, header, level, message, fields: recordFields(data) });
     } catch {}
     (level === "warn" || level === "error" ? err : out)(line);
   };
@@ -10058,7 +10524,7 @@ __export(exports_external, {
   regexes: () => exports_regexes,
   regex: () => _regex,
   refine: () => refine,
-  record: () => record3,
+  record: () => record4,
   readonly: () => readonly,
   property: () => _property,
   promise: () => promise,
@@ -22214,7 +22680,7 @@ __export(exports_schemas2, {
   strictObject: () => strictObject,
   set: () => set,
   refine: () => refine,
-  record: () => record3,
+  record: () => record4,
   readonly: () => readonly,
   promise: () => promise,
   preprocess: () => preprocess,
@@ -23291,7 +23757,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
-function record3(keyType, valueType, params) {
+function record4(keyType, valueType, params) {
   if (!valueType || !valueType._zod) {
     return new ZodRecord({
       type: "record",
@@ -23756,7 +24222,7 @@ var stringbool = (...args) => _stringbool({
 }, ...args);
 function json(params) {
   const jsonSchema = lazy(() => {
-    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record3(string2(), jsonSchema)]);
+    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record4(string2(), jsonSchema)]);
   });
   return jsonSchema;
 }
@@ -26554,6 +27020,7 @@ var communityMachine = sqliteTable("community_machine", {
   arch: text("arch").notNull().default(""),
   osRelease: text("os_release").notNull().default(""),
   daemonVersion: text("daemon_version").notNull().default(""),
+  timeZone: text("time_zone"),
   metadata: text("metadata"),
   availableRuntimes: text("available_runtimes", { mode: "json" }).$type().notNull().default([]),
   status: text("status").notNull().default("offline"),
@@ -26905,6 +27372,7 @@ class AgentRouter {
     await this.opts.channel.reportReady(this.buildReady());
   }
   buildReady() {
+    const timeZone = typeof this.opts.timeZone === "function" ? this.opts.timeZone() : this.opts.timeZone;
     return {
       runtimeReport: [...this.runtimes.values()],
       capabilities: [CONTROL_HEARTBEAT_CAPABILITY],
@@ -26914,6 +27382,7 @@ class AgentRouter {
       arch: this.opts.arch,
       osRelease: this.opts.osRelease,
       daemonVersion: this.opts.daemonVersion,
+      timeZone,
       ...this.opts.providerQuotas ? { providerQuotas: this.opts.providerQuotas() } : {}
     };
   }
@@ -26955,11 +27424,10 @@ class AgentRouter {
       return;
     if (existing.status === "healthy" && !existing.lastError && !existing.lastErrorAt)
       return;
-    this.runtimes.set(id, {
-      id: existing.id,
-      version: existing.version,
-      status: "healthy"
-    });
+    const healthy = { ...existing, status: "healthy" };
+    delete healthy.lastError;
+    delete healthy.lastErrorAt;
+    this.runtimes.set(id, healthy);
     this.log.info("runtime marked healthy again", { runtimeId: id });
     this.scheduleReadyFrameResend();
   }
@@ -27379,20 +27847,20 @@ function parseLocalMessageReminderBody(body, agentId) {
   }
   if (!value || typeof value !== "object" || Array.isArray(value))
     return null;
-  const record4 = value;
-  if (Object.keys(record4).sort().join(",") !== "channel,remindAfterMs,sentSeq")
+  const record5 = value;
+  if (Object.keys(record5).sort().join(",") !== "channel,remindAfterMs,sentSeq")
     return null;
-  if (typeof record4.channel !== "string" || !isCanonicalChannelScope(record4.channel))
+  if (typeof record5.channel !== "string" || !isCanonicalChannelScope(record5.channel))
     return null;
-  if (!Number.isSafeInteger(record4.sentSeq) || record4.sentSeq < 1)
+  if (!Number.isSafeInteger(record5.sentSeq) || record5.sentSeq < 1)
     return null;
-  if (!Number.isSafeInteger(record4.remindAfterMs) || record4.remindAfterMs !== 0 && record4.remindAfterMs < LOCAL_MESSAGE_REMINDER_MIN_MS || record4.remindAfterMs > LOCAL_MESSAGE_REMINDER_MAX_MS)
+  if (!Number.isSafeInteger(record5.remindAfterMs) || record5.remindAfterMs !== 0 && record5.remindAfterMs < LOCAL_MESSAGE_REMINDER_MIN_MS || record5.remindAfterMs > LOCAL_MESSAGE_REMINDER_MAX_MS)
     return null;
   return {
     agentId,
-    channel: record4.channel,
-    sentSeq: record4.sentSeq,
-    remindAfterMs: record4.remindAfterMs
+    channel: record5.channel,
+    sentSeq: record5.sentSeq,
+    remindAfterMs: record5.remindAfterMs
   };
 }
 async function handleLocalMessageReminder(req, res, agentId, onArm) {
@@ -28529,7 +28997,7 @@ var REASONING_EFFORT_RE = /^[A-Za-z0-9._-]+$/;
 var COMMUNITY_REASONING_EFFORT_MAX = 32;
 var COMMUNITY_REASONING_DESCRIPTION_MAX = 256;
 var COMMUNITY_REASONING_OPTIONS_MAX = 16;
-var COMMUNITY_REASONING_MODELS_MAX = 64;
+var COMMUNITY_REASONING_MODELS_MAX = 512;
 var ReasoningEffortSchema = exports_external.string().min(1).max(COMMUNITY_REASONING_EFFORT_MAX).regex(REASONING_EFFORT_RE, "invalid reasoning effort charset");
 var RuntimeReasoningOptionSchema = exports_external.object({
   value: ReasoningEffortSchema,
@@ -28537,6 +29005,7 @@ var RuntimeReasoningOptionSchema = exports_external.object({
 });
 var RuntimeReasoningModelSchema = exports_external.object({
   id: exports_external.string().min(1).max(100),
+  displayName: exports_external.string().min(1).max(COMMUNITY_REASONING_DESCRIPTION_MAX).optional().catch(undefined),
   supportedReasoningEfforts: exports_external.array(exports_external.unknown()).max(COMMUNITY_REASONING_OPTIONS_MAX).transform((options) => {
     const seen = new Set;
     return options.flatMap((candidate) => {
@@ -28631,6 +29100,7 @@ var HostReadyMessageSchema = exports_external.object({
   arch: exports_external.string().optional(),
   osRelease: exports_external.string().optional(),
   daemonVersion: exports_external.string().optional(),
+  timeZone: exports_external.string().min(1).max(128).optional(),
   providerQuotas: exports_external.array(ProviderQuotaSnapshotSchema).max(2).optional().default([])
 });
 var CommunityDaemonReadySchema = exports_external.object({
@@ -28653,6 +29123,8 @@ var AgentActivityMessageSchema = exports_external.object({
   type: exports_external.literal("agent_activity"),
   agentId: exports_external.string(),
   state: exports_external.enum(["idle", "starting", "running", "stopping"]),
+  usageTimeZone: exports_external.string().min(1).max(128).optional(),
+  usageDay: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
   dailyUsage: exports_external.array(DailyUsageSnapshotSchema).max(7).optional(),
   quota: ProviderQuotaSnapshotSchema.optional()
 });
@@ -28918,6 +29390,42 @@ var BotAuditEventAckFrameSchema = exports_external.strictObject({
   type: exports_external.literal("bot_audit_event_ack"),
   eventId: exports_external.string().min(1).max(128)
 });
+// ../shared/src/utils/day-key.ts
+function utcDayKey(now) {
+  const d = now instanceof Date ? now : new Date(now);
+  return d.toISOString().slice(0, 10);
+}
+function calendarDayKeyDaysAgo(day, days) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(day);
+  if (!match)
+    throw new RangeError("invalid calendar day key");
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const date5 = Number(match[3]);
+  const parsed = new Date(Date.UTC(year, month - 1, date5));
+  if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== date5) {
+    throw new RangeError("invalid calendar day key");
+  }
+  parsed.setUTCDate(parsed.getUTCDate() - days);
+  return utcDayKey(parsed);
+}
+function dayKeyInTimeZone(now, timeZone) {
+  const date5 = now instanceof Date ? now : new Date(now);
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(date5);
+  const values = new Map(parts.map((part) => [part.type, part.value]));
+  const year = values.get("year");
+  const month = values.get("month");
+  const day = values.get("day");
+  if (!year || !month || !day)
+    throw new RangeError("unable to format calendar day key");
+  return `${year}-${month}-${day}`;
+}
+
 // ../shared/src/db/community-schema.ts
 var exports_community_schema = {};
 __export(exports_community_schema, {
@@ -32111,15 +32619,15 @@ class MessageReminderScheduler {
     const startedAt = this.now();
     const dueAt = startedAt + input.remindAfterMs;
     const sentRef = `${input.channel}#${input.sentSeq}`;
-    const record4 = {
+    const record5 = {
       ...input,
       sentRef,
       startedAt,
       dueAt,
       timer: undefined
     };
-    record4.timer = this.setTimer(() => {
-      if (this.reminders.get(key) !== record4)
+    record5.timer = this.setTimer(() => {
+      if (this.reminders.get(key) !== record5)
         return;
       this.reminders.delete(key);
       try {
@@ -32130,8 +32638,8 @@ class MessageReminderScheduler {
         Promise.resolve(delivery).catch(() => {});
       } catch {}
     }, input.remindAfterMs);
-    record4.timer.unref?.();
-    this.reminders.set(key, record4);
+    record5.timer.unref?.();
+    this.reminders.set(key, record5);
     return { armed: true, dueAt };
   }
   observe(agentId, channel2, latestSeq) {
@@ -32406,15 +32914,12 @@ class DaemonSelfSleepScheduler {
 import { chmod, mkdir, open, readFile as readFile2, rename, rm } from "node:fs/promises";
 import { dirname as dirname5, join as join14 } from "node:path";
 import { randomUUID as randomUUID7 } from "node:crypto";
-function dayKey(at) {
-  return at.toISOString().slice(0, 10);
+function oldestRetainedDay(at, timeZone) {
+  const today = dayKeyInTimeZone(at, timeZone);
+  return calendarDayKeyDaysAgo(today, 8);
 }
-function retainedDays(at) {
-  const days = new Set;
-  for (let offset = 0;offset < 7; offset += 1) {
-    days.add(dayKey(new Date(at.getTime() - offset * 86400000)));
-  }
-  return days;
+function oldestVisibleDay(today) {
+  return calendarDayKeyDaysAgo(today, 6);
 }
 function isMetric(value) {
   return value === null || typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
@@ -32459,16 +32964,25 @@ class DailyTokenUsageStore {
   loaded = false;
   data = { version: 1, bots: {} };
   filePath;
-  constructor(workingDirectoryBase, now = () => new Date) {
+  resolveTimeZone;
+  constructor(workingDirectoryBase, now = () => new Date, timeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone) {
     this.now = now;
+    this.resolveTimeZone = typeof timeZone === "string" ? () => timeZone : timeZone;
+    this.timeZone;
     this.filePath = join14(workingDirectoryBase, ".telemetry", "daily-token-usage.json");
   }
+  get timeZone() {
+    const timeZone = this.resolveTimeZone();
+    dayKeyInTimeZone(0, timeZone);
+    return timeZone;
+  }
   record(botId, delta) {
     return this.enqueue(async () => {
       await this.load();
       const at = this.now();
-      this.prune(at);
-      const day = dayKey(at);
+      const timeZone = this.timeZone;
+      this.prune(at, timeZone);
+      const day = dayKeyInTimeZone(at, timeZone);
       const snapshots = this.data.bots[botId] ?? [];
       const existing = snapshots.find((snapshot) => snapshot.day === day);
       const next = existing ?? emptySnapshot(botId, day);
@@ -32485,13 +32999,27 @@ class DailyTokenUsageStore {
     });
   }
   snapshots(botId) {
+    return this.usageWindow(botId).then((window2) => window2.snapshots);
+  }
+  usageWindow(botId) {
     let result = [];
+    let usageDay = "";
+    let usageTimeZone = "";
     return this.enqueue(async () => {
       await this.load();
-      if (this.prune(this.now()))
+      const at = this.now();
+      const timeZone = this.timeZone;
+      usageTimeZone = timeZone;
+      usageDay = dayKeyInTimeZone(at, timeZone);
+      if (this.prune(at, timeZone))
         await this.persist();
-      result = (this.data.bots[botId] ?? []).map((snapshot) => structuredClone(snapshot));
-    }).then(() => result);
+      const oldestDay = oldestVisibleDay(usageDay);
+      result = (this.data.bots[botId] ?? []).filter((snapshot) => snapshot.day >= oldestDay && snapshot.day <= usageDay).map((snapshot) => structuredClone(snapshot));
+    }).then(() => ({
+      usageDay,
+      usageTimeZone,
+      snapshots: result
+    }));
   }
   enqueue(operation) {
     const result = this.tail.then(operation, operation);
@@ -32536,11 +33064,11 @@ class DailyTokenUsageStore {
     this.data = { version: 1, bots: valid };
     this.loaded = true;
   }
-  prune(at) {
-    const keep = retainedDays(at);
+  prune(at, timeZone) {
+    const oldestDay = oldestRetainedDay(at, timeZone);
     let changed = false;
     for (const [botId, snapshots] of Object.entries(this.data.bots)) {
-      const retained = snapshots.filter((snapshot) => keep.has(snapshot.day)).sort((a, b) => a.day.localeCompare(b.day)).slice(-7);
+      const retained = snapshots.filter((snapshot) => snapshot.day >= oldestDay).sort((a, b) => a.day.localeCompare(b.day));
       if (retained.length !== snapshots.length || retained.some((snapshot, index2) => snapshot !== snapshots[index2]))
         changed = true;
       if (retained.length === 0)
@@ -32584,6 +33112,7 @@ var WARMUP_CEILING_MS = 30000;
 var RUNTIME_RAW_TRACE_MAX_BYTES = 8 * 1024 * 1024;
 var RUNTIME_RAW_TRACE_AGENT_IDS_ENV = "ALOOK_RUNTIME_RAW_TRACE_AGENT_IDS";
 var STATUS_WRITE_INTERVAL_MS = 5000;
+var TOKEN_USAGE_BACKENDS = new Set(["claude", "codex", "opencode", "pi"]);
 function parseRuntimeRawTraceAgentIds(value) {
   return new Set((value ?? "").split(",").map((agentId) => agentId.trim()).filter((agentId) => agentId.length > 0 && agentId !== "*"));
 }
@@ -32760,10 +33289,14 @@ async function createDaemon(opts) {
         recordProviderQuota("claude", observed);
     }
     const quota = backendId === "claude" || backendId === "codex" ? providerQuotaByBackend.get(backendId) : undefined;
-    const dailyUsage = await dailyTokenUsage2.snapshots(info.agentId);
+    const usageWindow = backendId && TOKEN_USAGE_BACKENDS.has(backendId) ? await dailyTokenUsage2.usageWindow(info.agentId) : null;
     return {
       ...info,
-      ...dailyUsage.length > 0 ? { dailyUsage } : {},
+      ...usageWindow ? {
+        usageTimeZone: usageWindow.usageTimeZone,
+        usageDay: usageWindow.usageDay,
+        ...usageWindow.snapshots.length > 0 ? { dailyUsage: usageWindow.snapshots } : {}
+      } : {},
       ...quota ? { quota: structuredClone(quota) } : {}
     };
   };
@@ -33175,6 +33708,7 @@ async function createDaemon(opts) {
     arch: opts.arch,
     osRelease: opts.osRelease,
     daemonVersion: opts.daemonVersion,
+    timeZone: () => dailyTokenUsage2.timeZone,
     providerQuotas: providerQuotaSnapshots,
     resyncActivities: async () => {
       const activities = await Promise.all(manager.liveAgentActivities().map((info) => activityPayload(info)));