@alook/daemon 0.1.24 → 0.1.26

package/dist/index.js

@@ -865,6 +865,9 @@ class ProcessLane {
       return false;
     return proc.kill("SIGINT");
   }
+  updateSettings(input) {
+    return this.driver.updateSettings?.(input) ?? Promise.resolve({ status: "unsupported" });
+  }
   attachProcess(proc) {
     proc.stdout?.on("data", (chunk) => {
       const chunkText = chunk.toString();
@@ -939,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;
@@ -1252,25 +1255,19 @@ class ClaudeEventNormalizer {
   }
   buildUsageTelemetry(event) {
     const u = event?.usage;
-    if (!u && event?.total_cost_usd == null)
+    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",
       source: "claude_result_usage",
-      usageKind: "per_turn",
-      attrs: {
-        inputTokens: u?.input_tokens,
-        outputTokens: u?.output_tokens,
-        cachedInputTokens: u?.cache_read_input_tokens,
-        cacheCreationInputTokens: u?.cache_creation_input_tokens,
-        totalCostUsd: event?.total_cost_usd,
-        durationMs: event?.duration_ms,
-        durationApiMs: event?.duration_api_ms,
-        numTurns: event?.num_turns,
-        resultSubtype: event?.subtype,
-        resultIsError: event?.is_error,
-        serviceTier: u?.service_tier
+      usage: {
+        input: metric(u.input_tokens),
+        output: metric(u.output_tokens),
+        cache
       }
     };
   }
@@ -1281,6 +1278,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);
@@ -1331,6 +1329,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);
 }
@@ -1437,6 +1452,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"] };
@@ -1453,10 +1476,11 @@ class ClaudeDriver {
   }
   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 });
@@ -1502,49 +1526,153 @@ class ClaudeDriver {
 }
 
 // agent-driver/dist/adapters/codex/telemetry.js
-function mapCodexTelemetry(method, params) {
+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;
+}
+function mappedPlanName(value) {
+  switch (value) {
+    case "free":
+      return "Free";
+    case "plus":
+      return "Plus";
+    case "pro":
+      return "Pro";
+    case "team":
+      return "Team";
+    case "business":
+      return "Business";
+    case "enterprise":
+      return "Enterprise";
+    case "edu":
+      return "Education";
+    default:
+      return;
+  }
+}
+function quotaWindow(minutes, slot) {
+  if (typeof minutes !== "number" || !Number.isSafeInteger(minutes) || minutes <= 0)
+    return null;
+  if (minutes === 1440)
+    return { kind: "calendar", period: "day", displayName: "Daily usage limit" };
+  if (minutes === 10080)
+    return { kind: "calendar", period: "week", displayName: "Weekly usage limit" };
+  if (minutes === 43200)
+    return { kind: "calendar", period: "month", displayName: "Monthly usage limit" };
+  return {
+    kind: "rolling",
+    durationSeconds: minutes * 60,
+    displayName: slot === "primary" && minutes === 300 ? "5 hour usage limit" : `${minutes} minute usage limit`
+  };
+}
+function resetIso(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    const date = new Date(value < 10000000000 ? value * 1000 : value);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+  }
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+  }
+  return;
+}
+function mapCodexQuotaSnapshots(snapshots, sourceEpoch) {
+  const limits = [];
+  let planName;
+  for (const snapshot of snapshots) {
+    const limitId = canonicalId(snapshot?.limitId ?? snapshot?.limit_id, "codex");
+    const spark = /spark/i.test(limitId) || /spark/i.test(String(snapshot?.limitName ?? snapshot?.limit_name ?? ""));
+    const product = spark ? { kind: "reported", id: "codex-spark", displayName: "Spark" } : { kind: "reported", id: "codex", displayName: "Codex" };
+    const model = spark ? { kind: "reported", id: "gpt-5.3-codex-spark" } : { kind: "not_applicable" };
+    planName ??= mappedPlanName(snapshot?.planType ?? snapshot?.plan_type);
+    for (const slot of ["primary", "secondary"]) {
+      const value = snapshot?.[slot];
+      const window2 = quotaWindow(value?.windowDurationMins ?? value?.window_duration_mins, slot);
+      const usedPercent = value?.usedPercent ?? value?.used_percent;
+      if (!window2 || typeof usedPercent !== "number" || !Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100)
+        continue;
+      const resetsAt = resetIso(value?.resetsAt ?? value?.resets_at);
+      limits.push({
+        bucket: { limitId, product, model, window: window2 },
+        usedPercent,
+        ...resetsAt ? { resetsAt } : {}
+      });
+    }
+  }
+  if (limits.length === 0) {
+    return {
+      kind: "telemetry",
+      name: "rate_limits",
+      source: "codex_account_rate_limits_updated",
+      quota: { status: "error", sourceEpoch, code: "invalid_response", retryable: true }
+    };
+  }
+  return {
+    kind: "telemetry",
+    name: "rate_limits",
+    source: "codex_account_rate_limits_updated",
+    quota: {
+      status: "available",
+      sourceEpoch,
+      ...planName ? { planName } : {},
+      freshForSeconds: 300,
+      limits
+    }
+  };
+}
+function mapCodexTelemetry(method, params, sourceEpoch) {
   if (method === "thread/tokenUsage/updated") {
-    const u = params?.usage ?? params ?? {};
-    return [
-      {
-        kind: "telemetry",
-        name: "token_usage",
-        source: "codex_thread_token_usage_updated",
-        usageKind: "cumulative_session",
-        attrs: {
-          totalTokens: u.totalTokens ?? u.total_tokens,
-          inputTokens: u.inputTokens ?? u.input_tokens,
-          cachedInputTokens: u.cachedInputTokens ?? u.cached_input_tokens,
-          outputTokens: u.outputTokens ?? u.output_tokens,
-          reasoningOutputTokens: u.reasoningOutputTokens ?? u.reasoning_output_tokens,
-          modelContextWindow: u.modelContextWindow ?? u.model_context_window,
-          cachedInputRatio: u.cachedInputRatio,
-          contextUtilization: u.contextUtilization
-        }
+    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") {
-    const r = params ?? {};
-    return [
-      {
-        kind: "telemetry",
-        name: "rate_limits",
-        source: "codex_account_rate_limits_updated",
-        attrs: {
-          limitId: r.limitId,
-          planType: r.planType,
-          usedPercent: r.usedPercent,
-          windowDurationMins: r.windowDurationMins,
-          resetsAt: r.resetsAt
-        }
-      }
-    ];
+    return [mapCodexQuotaSnapshots([params?.rateLimits ?? params ?? {}], sourceEpoch)];
   }
   return [];
 }
 
 // agent-driver/dist/adapters/codex/normalizer.js
+import { randomBytes } from "node:crypto";
+var codexQuotaSourceEpoch = randomBytes(16).toString("base64url");
+var codexQuotaSourceGeneration = 0;
+var codexAccountFingerprint = null;
+function rotateCodexQuotaSource() {
+  codexQuotaSourceEpoch = randomBytes(16).toString("base64url");
+  codexQuotaSourceGeneration += 1;
+  codexAccountFingerprint = null;
+}
+function observeCodexAccount(result) {
+  const account = result?.account;
+  const fingerprint = account && typeof account === "object" ? JSON.stringify([
+    account.type ?? "unknown",
+    account.email ?? null,
+    account.planType ?? account.plan_type ?? null
+  ]) : "none";
+  if (codexAccountFingerprint !== null && codexAccountFingerprint !== fingerprint) {
+    rotateCodexQuotaSource();
+  }
+  codexAccountFingerprint = fingerprint;
+}
 function normalizeFileChangeInput(item) {
   const paths = [];
   const seen = new Set;
@@ -1567,6 +1695,12 @@ function normalizeFileChangeInput(item) {
 }
 
 class CodexEventNormalizer {
+  quotaReadRequestIds = new Set;
+  accountReadRequestIds = new Set;
+  rateLimitSnapshots = new Map;
+  quotaSnapshotInitialized = false;
+  quotaSourceGeneration = codexQuotaSourceGeneration;
+  pendingTurnUsage = null;
   threadId = null;
   turnId = null;
   terminalTurn = null;
@@ -1577,10 +1711,69 @@ class CodexEventNormalizer {
   get currentTurnId() {
     return this.turnId;
   }
+  registerQuotaReadRequest(requestId) {
+    this.quotaReadRequestIds.add(requestId);
+  }
+  registerAccountReadRequest(requestId) {
+    this.accountReadRequestIds.add(requestId);
+  }
+  syncQuotaSourceGeneration() {
+    if (this.quotaSourceGeneration === codexQuotaSourceGeneration)
+      return;
+    this.quotaSourceGeneration = codexQuotaSourceGeneration;
+    this.rateLimitSnapshots.clear();
+    this.quotaSnapshotInitialized = false;
+  }
+  quotaSnapshots(value) {
+    const byLimitId = value?.rateLimitsByLimitId ?? value?.rate_limits_by_limit_id;
+    if (byLimitId && typeof byLimitId === "object" && !Array.isArray(byLimitId)) {
+      return Object.entries(byLimitId).flatMap(([key2, snapshot2]) => {
+        if (!snapshot2 || typeof snapshot2 !== "object" || Array.isArray(snapshot2))
+          return [];
+        return [[key2, {
+          ...snapshot2,
+          limitId: snapshot2.limitId ?? snapshot2.limit_id ?? key2
+        }]];
+      });
+    }
+    const snapshot = value?.rateLimits ?? value?.rate_limits ?? value;
+    if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot))
+      return [];
+    const record = snapshot;
+    const key = typeof record.limitId === "string" ? record.limitId : typeof record.limit_id === "string" ? record.limit_id : "codex";
+    return [[key, { ...record, limitId: key }]];
+  }
+  replaceQuotaSnapshots(value) {
+    this.syncQuotaSourceGeneration();
+    this.rateLimitSnapshots.clear();
+    for (const [key, snapshot] of this.quotaSnapshots(value)) {
+      this.rateLimitSnapshots.set(key, snapshot);
+    }
+    this.quotaSnapshotInitialized = true;
+    return [mapCodexQuotaSnapshots([...this.rateLimitSnapshots.values()], codexQuotaSourceEpoch)];
+  }
+  mergeQuotaSnapshots(value) {
+    this.syncQuotaSourceGeneration();
+    for (const [key, update] of this.quotaSnapshots(value)) {
+      const merged = {
+        ...this.rateLimitSnapshots.get(key) ?? {},
+        limitId: key
+      };
+      for (const [field, fieldValue] of Object.entries(update)) {
+        if (fieldValue !== undefined && fieldValue !== null)
+          merged[field] = fieldValue;
+      }
+      this.rateLimitSnapshots.set(key, merged);
+    }
+    if (!this.quotaSnapshotInitialized)
+      return [];
+    return [mapCodexQuotaSnapshots([...this.rateLimitSnapshots.values()], codexQuotaSourceEpoch)];
+  }
   adoptThreadId(threadId) {
     if (threadId !== this.threadId) {
       this.turnId = null;
       this.terminalTurn = null;
+      this.pendingTurnUsage = null;
     }
     this.threadId = threadId;
   }
@@ -1598,6 +1791,25 @@ class CodexEventNormalizer {
     const msg = tryParseJsonLine(line);
     if (!msg)
       return [];
+    if (msg?.id !== undefined && this.accountReadRequestIds.delete(msg.id)) {
+      if (!msg.error) {
+        observeCodexAccount(msg.result);
+        this.syncQuotaSourceGeneration();
+      }
+      return [];
+    }
+    if (msg?.id !== undefined && this.quotaReadRequestIds.delete(msg.id)) {
+      this.syncQuotaSourceGeneration();
+      if (msg.error) {
+        return [{
+          kind: "telemetry",
+          name: "rate_limits",
+          source: "codex_account_rate_limits_read",
+          quota: { status: "error", sourceEpoch: codexQuotaSourceEpoch, code: "provider_error", retryable: true }
+        }];
+      }
+      return this.replaceQuotaSnapshots(msg.result ?? {});
+    }
     if (msg?.error && msg.id !== undefined) {
       return [{ kind: "error", message: msg.error?.message ?? "Codex RPC error" }];
     }
@@ -1622,6 +1834,7 @@ class CodexEventNormalizer {
           return [];
         this.turnId = params.turn.id;
         this.terminalTurn = null;
+        this.pendingTurnUsage = null;
         return [
           {
             kind: "turn_owner",
@@ -1650,24 +1863,36 @@ class CodexEventNormalizer {
       case "turn/completed":
         if (!this.acceptRootTerminal(params))
           return [];
+        const usage = this.pendingTurnUsage;
+        this.pendingTurnUsage = null;
         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 [{ 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: "error", message: "Codex turn interrupted" }, { 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) }];
+        return [...usage ? [usage] : [], { 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":
+      case "thread/tokenUsage/updated": {
+        const usage2 = mapCodexTelemetry(method, params, codexQuotaSourceEpoch)[0];
+        if (usage2)
+          this.pendingTurnUsage = usage2;
+        return [];
+      }
       case "account/rateLimits/updated":
-        return mapCodexTelemetry(method, params);
+        return this.mergeQuotaSnapshots(params);
+      case "account/updated":
+        rotateCodexQuotaSource();
+        this.syncQuotaSourceGeneration();
+        return [];
       default:
         return [];
     }
@@ -1780,7 +2005,102 @@ function resolveCodexHomeRootFromEnv(env = process.env, opts = {}) {
   return path5.join(opts.defaultHomeDir ?? os.homedir(), ".codex");
 }
 
+// agent-driver/dist/internal/errors.js
+var MAX_PUBLIC_ERROR_MESSAGE = 1000;
+var CREDENTIAL_NAME = String.raw`(?:[A-Za-z0-9]{1,32}[_-]){0,4}(?:api[_-]?key|access[_-]?key|secret(?:[_-]?access[_-]?key)?|client[_-]?secret|access[_-]?token|auth(?:orization)?|password|passwd|token|voucher)(?:[_-][A-Za-z0-9]{1,32}){0,4}`;
+var QUOTED_CREDENTIAL_ASSIGNMENT = new RegExp(String.raw`(["'])(${CREDENTIAL_NAME})\1\s*[:=]\s*(["'])[^"'\r\n]*\3`, "gi");
+var CREDENTIAL_ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9_-])((?:${CREDENTIAL_NAME})\s*[:=]\s*)(?!\[redacted\])[^\s,;}\]]+`, "gi");
+function scrubDriverErrorMessage(value, fallback = "Runtime operation failed") {
+  const text = value instanceof Error ? value.message : String(value ?? "");
+  const scrubbed = text.replace(/\b(?:cmk|cmt|crk)_[A-Za-z0-9_-]+\b/g, "[redacted-token]").replace(/(Authorization\s*:\s*)(?:Bearer|Basic)\s+[^\s,;]+/gi, "$1[redacted]").replace(/Bearer\s+[A-Za-z0-9._\-]+/gi, "Bearer [redacted]").replace(/\b(?:sk|sk-ant|sk-proj|xox[abprs])-[A-Za-z0-9._\-]+/gi, "[redacted-token]").replace(QUOTED_CREDENTIAL_ASSIGNMENT, "$1$2$1:$3[redacted]$3").replace(CREDENTIAL_ASSIGNMENT, "$1[redacted]").replace(/(?<![A-Za-z0-9._%+\-])[A-Za-z0-9._%+\-]{1,320}@[A-Za-z0-9.\-]{1,255}\.[A-Za-z]{2,63}/g, "[redacted-email]").replace(/([?&])([^=\s]+)=([^&\s]+)/g, "$1$2=[redacted]").replace(/\/(?:Users|home)\/[^\r\n,;]+/g, "[redacted-path]").replace(/[A-Za-z]:\\Users\\[^\r\n,;]+/gi, "[redacted-path]").replace(/\\\\[^\\\s]+\\[^\r\n,;]+/g, "[redacted-path]").replace(/(?:[A-Za-z]:\\|\/)(?:[^\s/:]+[\\/]){1,}[^\s:]*/g, "[redacted-path]").trim();
+  return (scrubbed || fallback).slice(0, MAX_PUBLIC_ERROR_MESSAGE);
+}
+function scrubDriverError(error) {
+  return {
+    ...error,
+    code: stableErrorCode(error.code, "runtime_error"),
+    message: scrubDriverErrorMessage(error.message),
+    ...error.details ? { details: scrubDetails(error.details) } : {}
+  };
+}
+function scrubDetails(details) {
+  const scrubValue = (value, key) => {
+    if (key && /api[_-]?key|access[_-]?token|auth(?:orization)?|password|passwd|secret|token/i.test(key)) {
+      return "[redacted]";
+    }
+    if (typeof value === "string")
+      return scrubDriverErrorMessage(value, "[redacted]");
+    if (Array.isArray(value))
+      return value.map((item) => scrubValue(item));
+    if (value && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [
+        childKey,
+        scrubValue(child, childKey)
+      ]));
+    }
+    return value;
+  };
+  return scrubValue(details);
+}
+function stableErrorCode(value, fallback) {
+  const code = String(value ?? "");
+  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_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);
 }
@@ -1801,19 +2121,173 @@ class CodexDriver {
     }
   };
   eventNormalizer = new CodexEventNormalizer;
+  pendingAccountReadRequestIds = new Set;
   requestId = 0;
   codexHomeRoot = null;
   proc = null;
   pendingInitialPrompt = null;
   pendingResumeFallbackParams = null;
+  pendingSettingsUpdates = new Map;
   nextRequestId() {
     return ++this.requestId;
   }
+  requestAccountQuotaSnapshot() {
+    if (!this.proc?.stdin || this.proc.stdin.destroyed)
+      return;
+    const accountReadRequestId = this.nextRequestId();
+    this.pendingAccountReadRequestIds.add(accountReadRequestId);
+    this.eventNormalizer.registerAccountReadRequest(accountReadRequestId);
+    this.proc.stdin.write(jsonRpcRequest("account/read", { refreshToken: false }, accountReadRequestId) + `
+`);
+  }
+  requestQuotaSnapshot() {
+    if (!this.proc?.stdin || this.proc.stdin.destroyed)
+      return;
+    const quotaReadRequestId = this.nextRequestId();
+    this.eventNormalizer.registerQuotaReadRequest(quotaReadRequestId);
+    this.proc.stdin.write(jsonRpcRequest("account/rateLimits/read", {}, quotaReadRequestId) + `
+`);
+  }
   get codexHome() {
     return this.codexHomeRoot;
   }
-  probe(command) {
-    return probeCliRuntime("codex", {}, command);
+  async probe(command) {
+    const result = await probeCliRuntime("codex", {}, command);
+    if (result.status !== "healthy")
+      return result;
+    return {
+      ...result,
+      reasoning: await this.probeReasoningCatalog(command)
+    };
+  }
+  async probeReasoningCatalog(command) {
+    const spec = resolveSpawnSpec("codex", ["app-server", "--listen", "stdio://"], command);
+    let proc;
+    try {
+      proc = spawnAgentProcess(spec.command, spec.args, {
+        cwd: process.cwd(),
+        env: { ...process.env, CI: "1" },
+        shell: spec.shell
+      });
+    } catch {
+      return;
+    }
+    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)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        const done = proc.pid ? killProcessTree(proc.pid, { graceMs: 250 }).catch(() => {}) : Promise.resolve().then(() => {
+          proc.kill("SIGTERM");
+        });
+        done.finally(() => resolve2(catalog));
+      };
+      const requestModelPage = (cursor) => {
+        listId = ++nextId;
+        proc.stdin?.write(jsonRpcRequest("model/list", { limit: Math.min(MODEL_LIST_MAX - models.length, MODEL_LIST_MAX), includeHidden: false, ...cursor ? { cursor } : {} }, listId) + `
+`);
+      };
+      const consumeModel = (value) => {
+        if (!value || typeof value !== "object")
+          return;
+        const model = value;
+        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) => {
+          if (!raw || typeof raw !== "object")
+            return [];
+          const option = raw;
+          const value2 = typeof option.reasoningEffort === "string" ? option.reasoningEffort.trim() : "";
+          if (!value2 || value2.length > 32 || !/^[A-Za-z0-9._-]+$/.test(value2) || seenEfforts.has(value2))
+            return [];
+          seenEfforts.add(value2);
+          const description = typeof option.description === "string" ? option.description.slice(0, 256) : undefined;
+          return [{ value: value2, ...description ? { description } : {} }];
+        }).slice(0, MODEL_EFFORT_MAX);
+        const candidateDefault = typeof model.defaultReasoningEffort === "string" ? model.defaultReasoningEffort : undefined;
+        seenModels.add(id);
+        if (model.isDefault === true)
+          defaultModelId = id;
+        models.push({
+          id,
+          supportedReasoningEfforts,
+          ...candidateDefault && supportedReasoningEfforts.some((item) => item.value === candidateDefault) ? { defaultReasoningEffort: candidateDefault } : {}
+        });
+      };
+      const onLine = (line) => {
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          return;
+        }
+        if (message.id === initializeId) {
+          if (message.error)
+            return finish();
+          requestModelPage();
+          return;
+        }
+        if (message.id !== listId)
+          return;
+        if (message.error || !message.result || typeof message.result !== "object")
+          return finish();
+        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)
+          return finish();
+        if (cursor)
+          return requestModelPage(cursor);
+        if (models.length === 0)
+          return finish();
+        finish({
+          updateMode: "live_next_turn",
+          ...defaultModelId ? { defaultModelId } : {},
+          models
+        });
+      };
+      const timer = setTimeout(() => finish(), MODEL_LIST_TIMEOUT_MS);
+      timer.unref?.();
+      proc.stdout?.on("data", (chunk) => {
+        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() ?? "";
+        for (const line of lines)
+          if (line.trim())
+            onLine(line);
+      });
+      proc.on("error", () => finish());
+      proc.on("exit", () => finish());
+      initializeId = ++nextId;
+      proc.stdin?.write(jsonRpcRequest("initialize", { clientInfo: { name: "alook-agent-driver-probe", version: "0.1.24" }, capabilities: { experimentalApi: true } }, initializeId) + `
+`);
+    });
   }
   async openLane(ctx, options) {
     return createProcessLane(this, ctx, { onRawStdoutLine: options?.onRawStdoutLine });
@@ -1829,6 +2303,9 @@ class CodexDriver {
       shell: spec.shell
     });
     this.proc = proc;
+    proc.once("exit", () => {
+      this.failPendingSettingsUpdates("settings_process_exited", "Codex exited before acknowledging the settings update");
+    });
     const initialPrompt = ctx.prompt?.trim() ? ctx.prompt : null;
     this.pendingInitialPrompt = initialPrompt;
     queueMicrotask(() => {
@@ -1857,11 +2334,21 @@ class CodexDriver {
         proc.stdin?.write(jsonRpcRequest("thread/start", freshParams, this.nextRequestId()) + `
 `);
       }
+      this.requestAccountQuotaSnapshot();
     });
     return { process: proc };
   }
   normalizeLine(line) {
+    const settingsResponse = this.consumeSettingsUpdateResponse(line);
+    if (settingsResponse)
+      return [];
+    const parsed = tryParseJsonLine(line);
     const events = this.eventNormalizer.normalizeLine(line);
+    if (typeof parsed?.id === "number" && this.pendingAccountReadRequestIds.delete(parsed.id)) {
+      this.requestQuotaSnapshot();
+    }
+    if (parsed?.method === "account/updated")
+      this.requestAccountQuotaSnapshot();
     if (this.pendingResumeFallbackParams && this.proc?.stdin && !this.proc.stdin.destroyed) {
       const rolloutErr = events.find((e) => e.kind === "error" && isCodexMissingRolloutError(e.message));
       if (rolloutErr) {
@@ -1885,6 +2372,90 @@ class CodexDriver {
     }
     return events;
   }
+  updateSettings(input) {
+    const threadId = this.eventNormalizer.currentSessionId;
+    const stdin = this.proc?.stdin;
+    if (!threadId || !stdin || stdin.destroyed || stdin.writableEnded || stdin.writable === false) {
+      return Promise.resolve({
+        status: "failed",
+        error: this.settingsError("process", "settings_thread_unavailable", "Codex thread is not available for a settings update", true)
+      });
+    }
+    const id = this.nextRequestId();
+    return new Promise((resolve2) => {
+      const timer = setTimeout(() => {
+        if (!this.pendingSettingsUpdates.delete(id))
+          return;
+        resolve2({
+          status: "failed",
+          error: this.settingsError("timeout", "settings_update_timeout", "Codex did not acknowledge the settings update before the deadline", true)
+        });
+      }, SETTINGS_UPDATE_TIMEOUT_MS);
+      timer.unref?.();
+      this.pendingSettingsUpdates.set(id, { resolve: resolve2, timer });
+      try {
+        stdin.write(jsonRpcRequest("thread/settings/update", { threadId, effort: input.reasoningEffort }, id) + `
+`);
+      } catch (error) {
+        clearTimeout(timer);
+        this.pendingSettingsUpdates.delete(id);
+        resolve2({
+          status: "failed",
+          error: this.settingsError("process", "settings_update_write_failed", String(error), true)
+        });
+      }
+    });
+  }
+  consumeSettingsUpdateResponse(line) {
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      return false;
+    }
+    if (!value || typeof value !== "object")
+      return false;
+    const record = value;
+    if (typeof record.id !== "number")
+      return false;
+    const pending = this.pendingSettingsUpdates.get(record.id);
+    if (!pending)
+      return false;
+    clearTimeout(pending.timer);
+    this.pendingSettingsUpdates.delete(record.id);
+    const error = record.error;
+    if (!error || typeof error !== "object") {
+      pending.resolve({ status: "applied" });
+      return true;
+    }
+    const rpcError = error;
+    const message = typeof rpcError.message === "string" ? rpcError.message : "Codex rejected the settings update";
+    if (rpcError.code === -32601 || /method\s+not\s+found/i.test(message)) {
+      pending.resolve({
+        status: "unsupported",
+        error: this.settingsError("protocol", "settings_update_unsupported", "Codex does not support live reasoning settings updates", false)
+      });
+    } else {
+      pending.resolve({
+        status: "failed",
+        error: this.settingsError("protocol", "settings_update_rejected", message, true)
+      });
+    }
+    return true;
+  }
+  settingsError(category, code, message, retryable) {
+    return { category, code, message: scrubDriverErrorMessage(message), retryable };
+  }
+  failPendingSettingsUpdates(code, message) {
+    for (const [id, pending] of this.pendingSettingsUpdates) {
+      clearTimeout(pending.timer);
+      this.pendingSettingsUpdates.delete(id);
+      pending.resolve({
+        status: "failed",
+        error: this.settingsError("process", code, message, true)
+      });
+    }
+  }
   get currentSessionId() {
     return this.eventNormalizer.currentSessionId;
   }
@@ -1906,9 +2477,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",
@@ -1932,16 +2683,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;
 }
@@ -1949,26 +2700,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;
@@ -2092,30 +2823,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: []
@@ -2127,15 +2858,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) {
@@ -2143,24 +2884,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)
@@ -2196,22 +2943,13 @@ 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;
     }
     this.activePrompt = null;
     this.openToolCalls.clear();
-    const usage = record(result.usage);
-    if (usage) {
-      this.events.emit("runtime_event", {
-        kind: "telemetry",
-        name: "token_usage",
-        source: "cursor.acp",
-        attrs: usage
-      });
-    }
     this.events.emit("runtime_event", {
       kind: "turn_end",
       sessionId: this.sessionId ?? undefined,
@@ -2347,7 +3085,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;
@@ -2375,7 +3113,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"));
@@ -2385,7 +3123,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;
     }
@@ -2417,9 +3155,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" } } });
@@ -2440,7 +3178,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;
@@ -2449,18 +3187,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 });
         }
@@ -2532,6 +3270,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 = {
@@ -2540,8 +3279,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 });
@@ -2561,10 +3315,10 @@ class CursorDriver {
 }
 
 // agent-driver/dist/adapters/opencode/index.js
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { randomBytes as randomBytes3 } from "node:crypto";
 
 // agent-driver/dist/adapters/opencode/service-lane.js
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 import { EventEmitter as EventEmitter3 } from "node:events";
 import { createServer as createServer2 } from "node:net";
 var SUPPORTED_VERSION = "1.17.20";
@@ -2598,7 +3352,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) {
@@ -2645,7 +3399,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";
 }
@@ -2703,7 +3457,7 @@ class OpenCodeServiceLane {
     this.ctx = ctx;
     this.options = options;
     this.fetchFn = options.fetch ?? fetch;
-    this.password = options.password ?? randomBytes(32).toString("base64url");
+    this.password = options.password ?? randomBytes2(32).toString("base64url");
   }
   get currentSessionId() {
     return this.sessionId;
@@ -2979,7 +3733,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}`);
           }
@@ -3000,8 +3754,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",
@@ -3014,7 +3768,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");
     }
   }
@@ -3027,7 +3781,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");
       }
@@ -3048,8 +3802,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");
     }
@@ -3206,7 +3960,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");
         }
@@ -3224,9 +3978,9 @@ class OpenCodeServiceLane {
     return run;
   }
   async handleDurableEvent(value, project) {
-    const event = record2(value);
-    const durable = record2(event?.durable);
-    const data = record2(event?.data);
+    const event = record3(value);
+    const durable = record3(event?.durable);
+    const data = record3(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) {
       throw new OpenCodeProtocolError("OpenCode session stream emitted an invalid durable event");
     }
@@ -3316,13 +4070,21 @@ class OpenCodeServiceLane {
             ...!successful ? { message: "OpenCode reported an unsupported final step outcome" } : {}
           });
         }
-        const tokens = record2(data.tokens);
-        if (tokens) {
+        const tokens = record3(data.tokens);
+        if (tokens && data.finish !== "tool-calls") {
+          const cache = record3(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",
             source: "opencode.v2",
-            attrs: tokens
+            usage: {
+              input: metric2(tokens.input),
+              output: metric2(tokens.output),
+              cache: cacheParts.length > 0 && Number.isSafeInteger(cacheTotal) ? cacheTotal : null
+            }
           });
         }
         break;
@@ -3337,8 +4099,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)) {
@@ -3352,11 +4114,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);
       }
@@ -3423,8 +4185,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");
       }
@@ -3491,8 +4253,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))
@@ -3628,7 +4390,7 @@ class OpenCodeServiceLane {
     return headers;
   }
   newMessageId() {
-    return `msg_${randomBytes(16).toString("hex")}`;
+    return `msg_${randomBytes2(16).toString("hex")}`;
   }
   diagnostic(severity, message) {
     this.events.emit("runtime_event", {
@@ -3693,10 +4455,11 @@ class OpenCodeServiceLane {
 
 // agent-driver/dist/adapters/opencode/index.js
 function createOpenCodeMessageId() {
-  return `msg_${randomBytes2(16).toString("hex")}`;
+  return `msg_${randomBytes3(16).toString("hex")}`;
 }
 
 class OpenCodeDriver {
+  outputProbe;
   id = "opencode";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -3705,8 +4468,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();
@@ -3960,6 +4734,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;
@@ -4068,6 +4843,8 @@ function mapPiSdkEvent(event, sessionId, state) {
 
 class PiDriver {
   dependenciesFor;
+  loadSdk;
+  readVersion;
   id = "pi";
   instructionDelivery = { kind: "workspace_file", canonical: "AGENTS.md", aliases: ["CLAUDE.md"] };
   execution = {
@@ -4078,15 +4855,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);
@@ -4471,48 +5269,6 @@ function assertInstructionFileName(name) {
   }
 }
 
-// agent-driver/dist/internal/errors.js
-var MAX_PUBLIC_ERROR_MESSAGE = 1000;
-var CREDENTIAL_NAME = String.raw`(?:[A-Za-z0-9]{1,32}[_-]){0,4}(?:api[_-]?key|access[_-]?key|secret(?:[_-]?access[_-]?key)?|client[_-]?secret|access[_-]?token|auth(?:orization)?|password|passwd|token|voucher)(?:[_-][A-Za-z0-9]{1,32}){0,4}`;
-var QUOTED_CREDENTIAL_ASSIGNMENT = new RegExp(String.raw`(["'])(${CREDENTIAL_NAME})\1\s*[:=]\s*(["'])[^"'\r\n]*\3`, "gi");
-var CREDENTIAL_ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9_-])((?:${CREDENTIAL_NAME})\s*[:=]\s*)(?!\[redacted\])[^\s,;}\]]+`, "gi");
-function scrubDriverErrorMessage(value, fallback = "Runtime operation failed") {
-  const text = value instanceof Error ? value.message : String(value ?? "");
-  const scrubbed = text.replace(/\b(?:cmk|cmt|crk)_[A-Za-z0-9_-]+\b/g, "[redacted-token]").replace(/(Authorization\s*:\s*)(?:Bearer|Basic)\s+[^\s,;]+/gi, "$1[redacted]").replace(/Bearer\s+[A-Za-z0-9._\-]+/gi, "Bearer [redacted]").replace(/\b(?:sk|sk-ant|sk-proj|xox[abprs])-[A-Za-z0-9._\-]+/gi, "[redacted-token]").replace(QUOTED_CREDENTIAL_ASSIGNMENT, "$1$2$1:$3[redacted]$3").replace(CREDENTIAL_ASSIGNMENT, "$1[redacted]").replace(/(?<![A-Za-z0-9._%+\-])[A-Za-z0-9._%+\-]{1,320}@[A-Za-z0-9.\-]{1,255}\.[A-Za-z]{2,63}/g, "[redacted-email]").replace(/([?&])([^=\s]+)=([^&\s]+)/g, "$1$2=[redacted]").replace(/\/(?:Users|home)\/[^\r\n,;]+/g, "[redacted-path]").replace(/[A-Za-z]:\\Users\\[^\r\n,;]+/gi, "[redacted-path]").replace(/\\\\[^\\\s]+\\[^\r\n,;]+/g, "[redacted-path]").replace(/(?:[A-Za-z]:\\|\/)(?:[^\s/:]+[\\/]){1,}[^\s:]*/g, "[redacted-path]").trim();
-  return (scrubbed || fallback).slice(0, MAX_PUBLIC_ERROR_MESSAGE);
-}
-function scrubDriverError(error) {
-  return {
-    ...error,
-    code: stableErrorCode(error.code, "runtime_error"),
-    message: scrubDriverErrorMessage(error.message),
-    ...error.details ? { details: scrubDetails(error.details) } : {}
-  };
-}
-function scrubDetails(details) {
-  const scrubValue = (value, key) => {
-    if (key && /api[_-]?key|access[_-]?token|auth(?:orization)?|password|passwd|secret|token/i.test(key)) {
-      return "[redacted]";
-    }
-    if (typeof value === "string")
-      return scrubDriverErrorMessage(value, "[redacted]");
-    if (Array.isArray(value))
-      return value.map((item) => scrubValue(item));
-    if (value && typeof value === "object") {
-      return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [
-        childKey,
-        scrubValue(child, childKey)
-      ]));
-    }
-    return value;
-  };
-  return scrubValue(details);
-}
-function stableErrorCode(value, fallback) {
-  const code = String(value ?? "");
-  return /^[A-Za-z0-9_.-]{1,100}$/.test(code) ? code : fallback;
-}
-
 // agent-driver/dist/controller/logical-session.js
 import { mkdirSync as mkdirSync3 } from "node:fs";
 var SEMANTIC_ASSEMBLER_MAX_BYTES = 1048576;
@@ -4630,6 +5386,8 @@ class LogicalAgentSession {
   toolBoundaryFlushDisabled = false;
   safeBoundaryFlush;
   safeBoundaryDelivery;
+  settingsUpdateTail = Promise.resolve();
+  settingsUpdatePending = false;
   turnAdmission;
   instructionsMaterialized = false;
   lifecycleGeneration = 0;
@@ -4685,6 +5443,35 @@ class LogicalAgentSession {
   send(message) {
     return this.admit("send", message);
   }
+  updateSettings(input) {
+    if (this.state === "closed" || this.state === "stopping" || this.finishing) {
+      return Promise.resolve({
+        status: "failed",
+        error: driverError("process", "settings_session_closed", "Runtime session is closed", true)
+      });
+    }
+    this.settingsUpdatePending = true;
+    const operation = this.settingsUpdateTail.then(async () => {
+      if (!this.lane?.updateSettings)
+        return { status: "unsupported" };
+      try {
+        return await this.lane.updateSettings(input);
+      } catch (error) {
+        return {
+          status: "failed",
+          error: driverError("process", "settings_update_failed", String(error), true)
+        };
+      }
+    });
+    this.settingsUpdateTail = operation.then((result) => {
+      if (result.status === "applied") {
+        this.settingsUpdatePending = false;
+        return;
+      }
+      return new Promise(() => {});
+    });
+    return operation;
+  }
   async interrupt(input) {
     if (this.state === "closed" || this.state === "stopping" || this.finishing)
       return { status: "closed" };
@@ -4846,7 +5633,7 @@ class LogicalAgentSession {
       }
       return receipt;
     }
-    if (this.state === "idle" && (this.queued.length > 0 || this.safeBoundaryFlush !== undefined || this.safeBoundaryDelivery !== undefined)) {
+    if (this.state === "idle" && (this.queued.length > 0 || this.safeBoundaryFlush !== undefined || this.safeBoundaryDelivery !== undefined || this.settingsUpdatePending)) {
       return this.queue(message, "runtime_busy");
     }
     return this.startTurn([message], "prompt");
@@ -5154,11 +5941,10 @@ class LogicalAgentSession {
         }
         return;
       case "telemetry": {
-        const details = jsonValue(event.attrs);
         if (event.name === "token_usage") {
-          this.emit({ type: "token_usage", turnId, source: event.source, usage: {}, details });
+          this.emit({ type: "token_usage", turnId, source: event.source, usage: event.usage });
         } else {
-          this.emit({ type: "rate_limits", turnId, source: event.source, details });
+          this.emit({ type: "rate_limits", turnId, source: event.source, quota: event.quota });
         }
         return;
       }
@@ -5259,7 +6045,7 @@ class LogicalAgentSession {
     if (this.adapter.execution.lifetime === "turn") {
       this.processTurnEnded = true;
     } else {
-      Promise.resolve().then(() => this.safeBoundaryFlush).then(() => this.startNextQueued());
+      Promise.resolve().then(() => this.safeBoundaryFlush).then(() => this.settingsUpdateTail).then(() => this.startNextQueued());
     }
   }
   flushSafeBoundaryQueue() {
@@ -5759,8 +6545,14 @@ function createAgentDriverSdkWithRegistry(options) {
         assertAdapterCompatibility(String(registration.id), registration.capabilities, adapter);
         const command = capabilities2.commandOverride ? input.command : undefined;
         const result = await adapter.probe(command);
-        if (result.status === "healthy")
-          return { status: "healthy", version: result.version, capabilities: capabilities2 };
+        if (result.status === "healthy") {
+          return {
+            status: "healthy",
+            version: result.version,
+            capabilities: capabilities2,
+            reasoning: result.reasoning
+          };
+        }
         return {
           status: "unhealthy",
           error: {
@@ -5769,7 +6561,8 @@ function createAgentDriverSdkWithRegistry(options) {
             message: `Backend ${input.backend} is unavailable`,
             retryable: true
           },
-          capabilities: capabilities2
+          capabilities: capabilities2,
+          reasoning: result.reasoning
         };
       } catch (error) {
         const contractInvalid = error instanceof Error && (error.message.startsWith("Adapter ") || error.message.startsWith("Agent backend registration "));
@@ -5963,45 +6756,184 @@ class RuntimeNotificationState {
       return false;
     return this.lastEncodeFailedFingerprint === fingerprint && this.lastEncodeFailedSessionId === sessionId;
   }
-  filterUncontributedMessages(messages, sessionId) {
-    if (this.contributionSessionId !== sessionId)
-      return messages;
-    return messages.filter((m) => {
-      const identity = inboxNoticeMessageIdentity(m);
-      return identity.length === 0 || !this.contributedIdentities.has(identity);
+  filterUncontributedMessages(messages, sessionId) {
+    if (this.contributionSessionId !== sessionId)
+      return messages;
+    return messages.filter((m) => {
+      const identity = inboxNoticeMessageIdentity(m);
+      return identity.length === 0 || !this.contributedIdentities.has(identity);
+    });
+  }
+  add(count = 1) {
+    this.pendingCountValue += count;
+  }
+  schedule(callback, delayMs) {
+    if (this.timerValue)
+      return false;
+    this.timerValue = setTimeout(() => {
+      this.timerValue = null;
+      callback();
+    }, delayMs);
+    this.timerValue.unref?.();
+    return true;
+  }
+  takePendingAndClearTimer() {
+    const count = this.pendingCountValue;
+    this.pendingCountValue = 0;
+    if (this.timerValue) {
+      clearTimeout(this.timerValue);
+      this.timerValue = null;
+    }
+    return count;
+  }
+  ensureContributionSession(sessionId) {
+    if (this.contributionSessionId !== sessionId) {
+      this.contributionSessionId = sessionId;
+      this.contributedIdentities = new Set;
+    }
+  }
+}
+// src/runtime/errorDiagnostics.ts
+import { createHash as createHash2 } from "crypto";
+// agent-driver/dist/provider-quota.js
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join9 } from "node:path";
+import { promisify } from "node:util";
+import { randomBytes as randomBytes4 } from "node:crypto";
+var execFileAsync = promisify(execFile);
+var claudeAccessToken = null;
+var claudeSourceEpoch = randomBytes4(16).toString("base64url");
+function parseCredentials(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function claudeCredentials(options) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") {
+    try {
+      const value = options.readKeychain ? await options.readKeychain() : (await execFileAsync("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], {
+        timeout: 3000,
+        maxBuffer: 256 * 1024
+      })).stdout;
+      const parsed = parseCredentials(value.trim());
+      if (parsed)
+        return parsed;
+    } catch {}
+  }
+  const env = options.env ?? process.env;
+  const root = env.CLAUDE_CONFIG_DIR || join9(options.home ?? homedir3(), ".claude");
+  try {
+    const value = options.readCredentialsFile ? await options.readCredentialsFile(join9(root, ".credentials.json")) : await readFile(join9(root, ".credentials.json"), "utf8");
+    return parseCredentials(value);
+  } catch {
+    return null;
+  }
+}
+function mappedPlanName2(value) {
+  switch (value) {
+    case "free":
+      return "Free";
+    case "pro":
+      return "Pro";
+    case "max":
+      return "Max";
+    case "team":
+      return "Team";
+    case "enterprise":
+      return "Enterprise";
+    default:
+      return;
+  }
+}
+function resetIso2(value) {
+  if (typeof value !== "string")
+    return;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function claudeLimit(key, value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const row = value;
+  if (typeof row.utilization !== "number" || !Number.isFinite(row.utilization) || row.utilization < 0 || row.utilization > 100)
+    return null;
+  const model = key.includes("sonnet") ? { kind: "reported", id: "claude-sonnet" } : key.includes("opus") ? { kind: "reported", id: "claude-opus" } : { kind: "not_applicable" };
+  const window2 = key === "five_hour" ? { kind: "rolling", durationSeconds: 18000, displayName: "5 hour usage limit" } : { kind: "rolling", durationSeconds: 604800, displayName: "7 day usage limit" };
+  const resetsAt = resetIso2(row.resets_at ?? row.resetsAt);
+  return {
+    bucket: {
+      limitId: key,
+      product: { kind: "reported", id: "claude", displayName: "Claude" },
+      model,
+      window: window2
+    },
+    usedPercent: row.utilization,
+    ...resetsAt ? { resetsAt } : {}
+  };
+}
+async function readClaudeQuota(options) {
+  const env = options.env ?? process.env;
+  if (env.ANTHROPIC_API_KEY || env.ANTHROPIC_BASE_URL)
+    return null;
+  const credentials = await claudeCredentials(options);
+  const token = credentials?.claudeAiOauth?.accessToken;
+  if (typeof token !== "string" || token.length === 0)
+    return null;
+  if (claudeAccessToken !== token) {
+    claudeAccessToken = token;
+    claudeSourceEpoch = randomBytes4(16).toString("base64url");
+  }
+  let response;
+  try {
+    response = await (options.fetchUsage ?? fetch)("https://api.anthropic.com/api/oauth/usage", {
+      headers: {
+        authorization: `Bearer ${token}`,
+        "anthropic-beta": "oauth-2025-04-20"
+      },
+      signal: AbortSignal.timeout(5000)
     });
+  } catch {
+    return { status: "error", sourceEpoch: claudeSourceEpoch, code: "network", retryable: true };
   }
-  add(count = 1) {
-    this.pendingCountValue += count;
+  if (response.status === 401 || response.status === 403) {
+    return { status: "error", sourceEpoch: claudeSourceEpoch, code: "unauthorized", retryable: false };
   }
-  schedule(callback, delayMs) {
-    if (this.timerValue)
-      return false;
-    this.timerValue = setTimeout(() => {
-      this.timerValue = null;
-      callback();
-    }, delayMs);
-    this.timerValue.unref?.();
-    return true;
+  if (!response.ok) {
+    return { status: "error", sourceEpoch: claudeSourceEpoch, code: "provider_error", retryable: response.status === 429 || response.status >= 500 };
   }
-  takePendingAndClearTimer() {
-    const count = this.pendingCountValue;
-    this.pendingCountValue = 0;
-    if (this.timerValue) {
-      clearTimeout(this.timerValue);
-      this.timerValue = null;
-    }
-    return count;
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
-  ensureContributionSession(sessionId) {
-    if (this.contributionSessionId !== sessionId) {
-      this.contributionSessionId = sessionId;
-      this.contributedIdentities = new Set;
-    }
+  if (!body || typeof body !== "object") {
+    return { status: "error", sourceEpoch: claudeSourceEpoch, code: "invalid_response", retryable: true };
   }
+  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 };
+  }
+  const planName = mappedPlanName2(credentials?.claudeAiOauth?.subscriptionType);
+  return {
+    status: "available",
+    sourceEpoch: claudeSourceEpoch,
+    ...planName ? { planName } : {},
+    freshForSeconds: 300,
+    limits
+  };
+}
+async function readBuiltinProviderQuota(backend, options = {}) {
+  return backend === "claude" ? readClaudeQuota(options) : null;
 }
 // src/runtime/errorDiagnostics.ts
-import { createHash as createHash2 } from "crypto";
 var ERROR_EXCERPT_MAX_BYTES = 4000;
 var ERROR_FINGERPRINT_LEN = 16;
 var ERROR_LEN_BUCKETS = [
@@ -6642,10 +7574,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;
 }
@@ -6761,13 +7693,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];
@@ -6824,6 +7756,29 @@ function reduceManager(state, event) {
         a.inbox = [...a.inbox, event.message];
         a.idleSince = null;
       });
+    case "runtime_config_queued":
+      return mutate(state, event.agentId, (a) => {
+        if (!a.inbox.some((message) => message.id === event.message.id)) {
+          a.inbox = [...a.inbox, event.message];
+        }
+        syncExecutionProjection(a);
+        a.idleSince = null;
+      });
+    case "runtime_config_applied": {
+      const existing = state.agents[event.agentId];
+      if (!existing)
+        return { state, effects: [] };
+      const agent = clone(existing);
+      if (agent.status !== "running" || leaseIsWorking(agent.execution.lease) || agent.pendingAdmissions.length > 0 || agent.inbox.length === 0)
+        return { state, effects: [] };
+      const messages = drainInbox(agent);
+      return commit(state, agent, messages.map((message) => ({
+        type: "send",
+        agentId: event.agentId,
+        message,
+        mode: "idle"
+      })));
+    }
     case "turn_started": {
       const existing = state.agents[event.agentId];
       if (!existing || existing.execution.sessionInstanceId !== event.sessionInstanceId)
@@ -7031,7 +7986,7 @@ function onTurnCompleted(state, agentId, sessionInstanceId, nowMs, turnId, endRe
     agent.stalledSessionId = null;
   syncExecutionProjection(agent);
   const clearEffects = clearedStallSessionId === null ? [] : [{ type: "clear_stall_recovery", agentId, sessionId: clearedStallSessionId }];
-  if (agent.inbox.length > 0) {
+  if (agent.inbox.length > 0 && !agent.resetting) {
     const messages = drainInbox(agent);
     return commit(state, agent, [
       ...clearEffects,
@@ -7262,11 +8217,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) {
@@ -7677,14 +8632,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);
   };
@@ -7946,9 +8901,13 @@ class AgentProcessManager {
   state;
   sessions = new Map;
   runtimeConfigs = new Map;
+  appliedRuntimeConfigs = new Map;
+  pendingRuntimeConfigUpdates = new Map;
+  runtimeConfigApplyRunning = new Set;
   resumeSessions = new Map;
   launchIds = new Map;
   liveSessions = new Map;
+  liveBackendIds = new Map;
   activeSpawnState = new Map;
   publishedAgentActivity = new Map;
   traceProcessNonce = randomUUID5();
@@ -7977,19 +8936,156 @@ class AgentProcessManager {
     this.state = createInitialManagerState(this.opts.staleThresholdMs, this.opts.idleTimeoutMs, this.opts.resetStuckThresholdMs, this.opts.stoppingStuckThresholdMs, this.opts.idleResetTimeoutMs);
   }
   register(agentId, launch) {
-    if (launch?.runtimeConfig)
-      this.runtimeConfigs.set(agentId, launch.runtimeConfig);
+    const runtimeConfigAcceptance = launch?.runtimeConfig ? this.acceptRuntimeConfig(agentId, launch.runtimeConfig) : undefined;
     if (launch?.sessionId)
       this.resumeSessions.set(agentId, launch.sessionId);
     if (launch?.launchId)
       this.launchIds.set(agentId, launch.launchId);
     this.dispatch({ type: "register", agentId });
+    const registered = this.state.agents[agentId];
+    if (launch?.runtimeConfig && launch.applyRuntimeConfig !== false && (runtimeConfigAcceptance === "accepted" || this.pendingRuntimeConfigUpdates.has(agentId)) && this.sessions.has(agentId) && registered && !isActivelyWorking(registered)) {
+      this.convergeRuntimeConfig(agentId);
+    }
+  }
+  async updateRuntimeConfig(agentId, config) {
+    const accepted = this.acceptRuntimeConfig(agentId, config);
+    if (accepted === "stale" || accepted === "idempotent")
+      return accepted;
+    const session = this.sessions.get(agentId);
+    if (!session) {
+      this.pendingRuntimeConfigUpdates.delete(agentId);
+      return "saved_for_start";
+    }
+    const agent = this.state.agents[agentId];
+    if (agent && (agent.turnActive || isActivelyWorking(agent)))
+      return "deferred";
+    return this.convergeRuntimeConfig(agentId);
+  }
+  acceptRuntimeConfig(agentId, config) {
+    const desired = this.runtimeConfigs.get(agentId);
+    const revision = config.runtimeConfigRevision ?? 0;
+    const desiredRevision = desired?.runtimeConfigRevision ?? 0;
+    if (desired && revision < desiredRevision)
+      return "stale";
+    if (desired && revision === desiredRevision) {
+      if (this.runtimeConfigTuple(desired) !== this.runtimeConfigTuple(config)) {
+        throw new Error(`Conflicting runtime config for ${agentId} at revision ${revision}`);
+      }
+      this.runtimeConfigs.set(agentId, config);
+      return "idempotent";
+    }
+    this.runtimeConfigs.set(agentId, config);
+    this.pendingRuntimeConfigUpdates.set(agentId, config);
+    return "accepted";
+  }
+  runtimeConfigTuple(config) {
+    return JSON.stringify({
+      version: config.version,
+      runtime: config.runtime,
+      model: config.model,
+      mode: config.mode,
+      reasoningEffort: config.reasoningEffort ?? null,
+      provider: config.provider ?? null,
+      command: config.command ?? null,
+      disallowedTools: config.disallowedTools ?? null,
+      envVars: config.envVars ?? null
+    });
+  }
+  runtimeLaunchTuple(config) {
+    return JSON.stringify({
+      version: config.version,
+      runtime: config.runtime,
+      model: config.model,
+      mode: config.mode,
+      provider: config.provider ?? null,
+      command: config.command ?? null,
+      disallowedTools: config.disallowedTools ?? null,
+      envVars: config.envVars ?? null
+    });
+  }
+  async convergeRuntimeConfig(agentId, restartOnFailure = true) {
+    if (this.runtimeConfigApplyRunning.has(agentId))
+      return "deferred";
+    const session = this.sessions.get(agentId);
+    if (!session)
+      return "saved_for_start";
+    this.runtimeConfigApplyRunning.add(agentId);
+    try {
+      while (this.sessions.get(agentId) === session) {
+        const desired = this.pendingRuntimeConfigUpdates.get(agentId) ?? this.runtimeConfigs.get(agentId);
+        if (!desired)
+          return "idempotent";
+        const desiredRevision = desired.runtimeConfigRevision ?? 0;
+        const applied = this.appliedRuntimeConfigs.get(agentId);
+        const appliedRevision = applied?.runtimeConfigRevision ?? -1;
+        if (applied && desiredRevision <= appliedRevision) {
+          this.pendingRuntimeConfigUpdates.delete(agentId);
+          return desiredRevision === appliedRevision ? "idempotent" : "stale";
+        }
+        const canApplyNatively = applied && this.runtimeLaunchTuple(applied) === this.runtimeLaunchTuple(desired) && typeof session.updateSettings === "function";
+        let result = { status: "unsupported" };
+        if (canApplyNatively) {
+          try {
+            result = await session.updateSettings({
+              reasoningEffort: desired.reasoningEffort ?? null
+            });
+          } catch (error) {
+            this.log.warn("runtime config live apply threw; restarting at safe boundary", {
+              agentId,
+              revision: desiredRevision,
+              error: String(error)
+            });
+            if (restartOnFailure)
+              await this.restartForRuntimeConfig(agentId, session);
+            return "saved_for_start";
+          }
+        }
+        if (result.status !== "applied") {
+          this.log.warn("runtime config live apply unavailable; restarting at safe boundary", {
+            agentId,
+            revision: desiredRevision,
+            status: result.status,
+            code: result.error?.code
+          });
+          if (restartOnFailure)
+            await this.restartForRuntimeConfig(agentId, session);
+          return "saved_for_start";
+        }
+        this.appliedRuntimeConfigs.set(agentId, desired);
+        if ((this.pendingRuntimeConfigUpdates.get(agentId)?.runtimeConfigRevision ?? -1) === desiredRevision) {
+          this.pendingRuntimeConfigUpdates.delete(agentId);
+        }
+        const latestRevision = this.runtimeConfigs.get(agentId)?.runtimeConfigRevision ?? 0;
+        if (latestRevision <= desiredRevision) {
+          this.dispatch({ type: "runtime_config_applied", agentId });
+          return "applied";
+        }
+      }
+      return "saved_for_start";
+    } finally {
+      this.runtimeConfigApplyRunning.delete(agentId);
+    }
+  }
+  async restartForRuntimeConfig(agentId, session) {
+    if (this.sessions.get(agentId) !== session)
+      return;
+    this.opts.timeline?.fenceSession(agentId);
+    this.markResetting(agentId);
+    await this.stop(agentId);
   }
   deliver(agentId, message) {
     const normalized = message.id ? message : {
       ...message,
       id: message.seq !== undefined ? `${agentId}:source:${message.seq}` : `${agentId}:synthetic:${this.nextDeliveryOrdinal++}`
     };
+    if (this.sessions.has(agentId) && this.pendingRuntimeConfigUpdates.has(agentId)) {
+      this.dispatch({
+        type: "runtime_config_queued",
+        agentId,
+        message: normalized
+      });
+      return this.state.agents[agentId] !== undefined;
+    }
     const effects = this.dispatch({ type: "wake", agentId, message: normalized, nowMs: this.now() });
     return effects.length > 0;
   }
@@ -8033,7 +9129,11 @@ class AgentProcessManager {
       this.emitErrorAudit(agentId, "reset", "resume_control_update_failed", "Reset aborted because resume control could not be persisted");
       throw new Error("Reset aborted because resume control could not be persisted");
     }
-    this.register(agentId, { runtimeConfig: opts.runtimeConfig, launchId: opts.launchId });
+    this.register(agentId, {
+      runtimeConfig: opts.runtimeConfig,
+      launchId: opts.launchId,
+      applyRuntimeConfig: false
+    });
     if (!opts.forgetSession)
       this.opts.timeline?.fenceSession(agentId);
     this.abortCurrentTurn(agentId, opts.abortCause);
@@ -8134,6 +9234,9 @@ class AgentProcessManager {
     const agent = this.state.agents[agentId];
     return agent ? this.deriveActivity(agent) : null;
   }
+  agentBackendId(agentId) {
+    return this.liveBackendIds.get(agentId) ?? null;
+  }
   statusProjection(nowMs) {
     return Object.values(this.state.agents).map((a) => ({
       agentId: a.agentId,
@@ -8659,6 +9762,7 @@ ${this.opts.wakePromptFooter}` : text;
       throw new Error(`AgentProcessManager: spawn for ${agentId} has no command`);
     const prompt = this.withFooter(first.text);
     const driver = this.opts.driverFor(agentId, this.runtimeConfigs.get(agentId));
+    this.liveBackendIds.set(agentId, driver.id);
     const base = this.opts.baseContextFor(agentId);
     const configuredRuntime = this.runtimeConfigs.get(agentId) ?? base.config?.runtimeConfig;
     this.log.info("spawning agent", {
@@ -8779,7 +9883,10 @@ ${this.opts.wakePromptFooter}` : text;
       if (state.session && this.sessions.get(agentId) === state.session)
         this.sessions.delete(agentId);
       this.liveSessions.delete(agentId);
+      if (this.activeSpawnState.get(agentId) === state)
+        this.liveBackendIds.delete(agentId);
       if (this.activeSpawnState.get(agentId) === state) {
+        this.appliedRuntimeConfigs.delete(agentId);
         this.activeSpawnState.delete(agentId);
         this.nonCleanEndMarker.delete(agentId);
       }
@@ -8827,6 +9934,10 @@ ${this.opts.wakePromptFooter}` : text;
       state.session = session;
       state.sessionInstanceId = session.sessionInstanceId;
       this.sessions.set(agentId, session);
+      this.appliedRuntimeConfigs.set(agentId, runtimeConfig);
+      if ((this.pendingRuntimeConfigUpdates.get(agentId)?.runtimeConfigRevision ?? -1) <= (runtimeConfig.runtimeConfigRevision ?? 0)) {
+        this.pendingRuntimeConfigUpdates.delete(agentId);
+      }
       this.dispatch({
         type: "attach_session",
         agentId,
@@ -9060,6 +10171,12 @@ ${this.opts.wakePromptFooter}` : text;
         runtime: runtimeId
       });
     }
+    if (event.type === "token_usage") {
+      this.opts.onTokenUsage?.({ agentId, backendId: runtimeId, usage: event.usage });
+    }
+    if (event.type === "rate_limits") {
+      this.opts.onProviderQuota?.({ agentId, backendId: runtimeId, quota: event.quota });
+    }
     if (event.type === "turn_started") {
       const timelineTurnOwner = {
         sessionInstanceId: event.sessionInstanceId,
@@ -9174,7 +10291,7 @@ ${this.opts.wakePromptFooter}` : text;
       this.logSessionEnded(agentId, "turn_end");
       const marker = this.nonCleanEndMarker.get(agentId);
       this.nonCleanEndMarker.delete(agentId);
-      this.dispatch(marker !== undefined ? {
+      const completionEvent = marker !== undefined ? {
         type: "turn_completed",
         agentId,
         sessionInstanceId: event.sessionInstanceId,
@@ -9189,7 +10306,26 @@ ${this.opts.wakePromptFooter}` : text;
         sessionInstanceId: event.sessionInstanceId,
         nowMs: this.now(),
         turnId: event.turnId
-      }, owner);
+      };
+      if (this.pendingRuntimeConfigUpdates.has(agentId) && this.sessions.get(agentId) === owner.session) {
+        this.convergeRuntimeConfig(agentId, false).then((result) => {
+          if (result === "saved_for_start" && owner.session)
+            this.markResetting(agentId);
+          this.dispatch(completionEvent, owner);
+          if (result === "saved_for_start" && owner.session) {
+            this.restartForRuntimeConfig(agentId, owner.session);
+          }
+        }).catch((error) => {
+          this.log.error("runtime config convergence failed", { agentId, error: String(error) });
+          if (owner.session)
+            this.markResetting(agentId);
+          this.dispatch(completionEvent, owner);
+          if (owner.session)
+            this.restartForRuntimeConfig(agentId, owner.session);
+        });
+        return;
+      }
+      this.dispatch(completionEvent, owner);
     }
   }
 }
@@ -9242,7 +10378,7 @@ __export(exports_external, {
   regexes: () => exports_regexes,
   regex: () => _regex,
   refine: () => refine,
-  record: () => record3,
+  record: () => record4,
   readonly: () => readonly,
   property: () => _property,
   promise: () => promise,
@@ -21398,7 +22534,7 @@ __export(exports_schemas2, {
   strictObject: () => strictObject,
   set: () => set,
   refine: () => refine,
-  record: () => record3,
+  record: () => record4,
   readonly: () => readonly,
   promise: () => promise,
   preprocess: () => preprocess,
@@ -22475,7 +23611,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",
@@ -22940,7 +24076,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;
 }
@@ -23489,6 +24625,7 @@ var exports_community_machine_schema = {};
 __export(exports_community_machine_schema, {
   communityMachineToken: () => communityMachineToken,
   communityMachineCredential: () => communityMachineCredential,
+  communityMachineBackendQuota: () => communityMachineBackendQuota,
   communityMachine: () => communityMachine,
   communityDiagnosticReport: () => communityDiagnosticReport,
   communityBotBinding: () => communityBotBinding,
@@ -24085,7 +25222,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join9(chunks, separator) {
+  function join10(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== undefined) {
@@ -24095,7 +25232,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join9;
+  sql2.join = join10;
   function identifier(value) {
     return new Name(value);
   }
@@ -25092,6 +26229,8 @@ var user = sqliteTable("user", {
   email: text("email").unique().notNull(),
   emailVerified: integer2("emailVerified", { mode: "boolean" }),
   image: text("image"),
+  avatarVersion: integer2("avatarVersion").notNull().default(0),
+  avatarObjectKey: text("avatarObjectKey"),
   createdAt: text("createdAt").notNull().$defaultFn(() => new Date().toISOString()),
   updatedAt: text("updatedAt").notNull().$defaultFn(() => new Date().toISOString()),
   isBot: integer2("isBot", { mode: "boolean" }).notNull().default(false),
@@ -25765,8 +26904,23 @@ var communityBotBinding = sqliteTable("community_bot_binding", {
   runtime: text("runtime").notNull(),
   instruction: text("instruction").notNull().default(""),
   modelName: text("model_name"),
+  reasoningEffort: text("reasoning_effort"),
+  runtimeConfigRevision: integer2("runtime_config_revision").notNull().default(0),
   createdAt: text("created_at").notNull().$defaultFn(() => new Date().toISOString())
 }, (t) => [index("idx_community_bot_binding_machine").on(t.machineId)]);
+var communityMachineBackendQuota = sqliteTable("community_machine_backend_quota", {
+  machineId: text("machine_id").notNull().references(() => communityMachine.id, { onDelete: "cascade" }),
+  agentBackendId: text("agent_backend_id").$type().notNull(),
+  sourceEpoch: text("source_epoch").notNull(),
+  status: text("status").$type().notNull(),
+  planName: text("plan_name"),
+  freshForSeconds: integer2("fresh_for_seconds"),
+  limits: text("limits", { mode: "json" }).$type(),
+  errorCode: text("error_code"),
+  retryable: integer2("retryable", { mode: "boolean" }),
+  observedAt: text("observed_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+}, (t) => [primaryKey({ columns: [t.machineId, t.agentBackendId] })]);
 var communityAgentRunnerKey = sqliteTable("community_agent_runner_key", {
   id: text("id").primaryKey().$defaultFn(() => "crkid_" + nanoid3()),
   userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
@@ -25945,6 +27099,11 @@ var HostCommandSchema = exports_external.discriminatedUnion("type", [
     config: exports_external.unknown(),
     launchId: exports_external.string().min(1)
   }),
+  exports_external.object({
+    type: exports_external.literal("agent:runtime_config_update"),
+    agentId: exports_external.string().min(1),
+    config: exports_external.unknown()
+  }),
   exports_external.object({
     type: exports_external.literal("machine:reset_all"),
     resets: exports_external.array(exports_external.object({
@@ -26051,7 +27210,8 @@ class AgentRouter {
         version: r.version,
         status: r.status ?? "healthy",
         lastError: r.lastError,
-        lastErrorAt: r.lastErrorAt
+        lastErrorAt: r.lastErrorAt,
+        reasoning: r.reasoning
       });
     }
   }
@@ -26060,7 +27220,7 @@ class AgentRouter {
     this.opts.channel.onResync?.(() => ({
       ready: this.buildReady(),
       sessions: this.opts.manager.liveSessionReports(),
-      activities: this.opts.manager.liveAgentActivities()
+      activities: this.opts.resyncActivities ? this.opts.resyncActivities() : this.opts.manager.liveAgentActivities()
     }));
     await this.opts.channel.reportReady(this.buildReady());
   }
@@ -26073,7 +27233,8 @@ class AgentRouter {
       platform: this.opts.platform,
       arch: this.opts.arch,
       osRelease: this.opts.osRelease,
-      daemonVersion: this.opts.daemonVersion
+      daemonVersion: this.opts.daemonVersion,
+      ...this.opts.providerQuotas ? { providerQuotas: this.opts.providerQuotas() } : {}
     };
   }
   healthyRuntimeIds() {
@@ -26114,11 +27275,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();
   }
@@ -26295,6 +27455,27 @@ class AgentRouter {
           rewakePrompt: MODEL_SWITCH_REWAKE_PROMPT
         }));
         break;
+      case "agent:runtime_config_update": {
+        this.log.info("agent:runtime_config_update received", {
+          agentId: cmd.agentId,
+          revision: cmd.config.runtimeConfigRevision ?? 0
+        });
+        try {
+          const result = await this.opts.manager.updateRuntimeConfig(cmd.agentId, cmd.config);
+          this.log.info("agent:runtime_config_update accepted", {
+            agentId: cmd.agentId,
+            revision: cmd.config.runtimeConfigRevision ?? 0,
+            result
+          });
+        } catch (err) {
+          this.log.warn("agent:runtime_config_update rejected", {
+            agentId: cmd.agentId,
+            revision: cmd.config.runtimeConfigRevision ?? 0,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+        break;
+      }
       case "agent:stop":
         this.log.info("agent:stop received", { agentId: cmd.agentId });
         try {
@@ -26517,20 +27698,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) {
@@ -26779,7 +27960,7 @@ function joinPath(basePath, reqUrl) {
   return base + reqPath || "/";
 }
 // src/daemon/createDaemon.ts
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7 } from "node:fs";
 
 // src/util/rotatingFileSink.ts
@@ -27054,7 +28235,7 @@ var MAX_PROFILE_ABOUT_LENGTH = 1000;
 var MAX_MESSAGE_CONTENT_LENGTH = 4000;
 var MAX_ATTACHMENTS_PER_MESSAGE = 10;
 var MAX_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
-var MAX_ATTACHMENT_THUMBNAIL_SIZE_BYTES = 50 * 1024;
+var MAX_ATTACHMENT_THUMBNAIL_SIZE_BYTES = 512 * 1024;
 var MAX_SERVER_ICON_SIZE_BYTES = 5 * 1024 * 1024;
 var ALLOWED_ICON_MIME_TYPES = [
   "image/png",
@@ -27063,6 +28244,92 @@ var ALLOWED_ICON_MIME_TYPES = [
   "image/gif"
 ];
 var MAX_ICON_SOURCE_FILE_SIZE_BYTES = 15 * 1024 * 1024;
+// ../shared/src/provider-telemetry.ts
+var safeToken = exports_external.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var boundedText = exports_external.string().min(1).refine((value) => new TextEncoder().encode(value).length <= 64, { message: "must be at most 64 UTF-8 bytes" });
+var DailyUsageMetricSchema = safeToken.nullable();
+var DailyUsageSnapshotSchema = exports_external.object({
+  botId: exports_external.string().min(1),
+  day: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  metrics: exports_external.object({
+    input: DailyUsageMetricSchema,
+    output: DailyUsageMetricSchema,
+    cache: DailyUsageMetricSchema
+  }).strict()
+}).strict();
+var QuotaProductIdentitySchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({ kind: exports_external.literal("reported"), id: boundedText, displayName: boundedText }).strict(),
+  exports_external.object({ kind: exports_external.literal("unknown"), displayName: boundedText }).strict()
+]);
+var QuotaModelIdentitySchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({ kind: exports_external.literal("reported"), id: boundedText }).strict(),
+  exports_external.object({ kind: exports_external.literal("not_applicable") }).strict(),
+  exports_external.object({ kind: exports_external.literal("unknown") }).strict()
+]);
+var QuotaWindowIdentitySchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    kind: exports_external.literal("rolling"),
+    durationSeconds: exports_external.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    displayName: boundedText
+  }).strict(),
+  exports_external.object({
+    kind: exports_external.literal("calendar"),
+    period: exports_external.enum(["day", "week", "month"]),
+    displayName: boundedText
+  }).strict(),
+  exports_external.object({
+    kind: exports_external.literal("provider_defined"),
+    id: boundedText,
+    durationSeconds: exports_external.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+    displayName: boundedText
+  }).strict()
+]);
+var QuotaLimitSchema = exports_external.object({
+  bucket: exports_external.object({
+    limitId: boundedText,
+    product: QuotaProductIdentitySchema,
+    model: QuotaModelIdentitySchema,
+    window: QuotaWindowIdentitySchema
+  }).strict(),
+  usedPercent: exports_external.number().finite().min(0).max(100),
+  resetsAt: exports_external.string().datetime({ offset: true }).optional()
+}).strict();
+function quotaIdentity(limit) {
+  const { product, model, window: window2, limitId } = limit.bucket;
+  const productKey = product.kind === "reported" ? `reported:${product.id}` : "unknown";
+  const modelKey = model.kind === "reported" ? `reported:${model.id}` : model.kind;
+  const windowKey = window2.kind === "rolling" ? `rolling:${window2.durationSeconds}` : window2.kind === "calendar" ? `calendar:${window2.period}` : `provider_defined:${window2.id}:${window2.durationSeconds === undefined ? "absent" : window2.durationSeconds}`;
+  return `${productKey}\x00${modelKey}\x00${windowKey}\x00${limitId}`;
+}
+var AvailableQuotaObservationSchema = exports_external.object({
+  status: exports_external.literal("available"),
+  sourceEpoch: exports_external.string().regex(/^[A-Za-z0-9_-]{22}$/),
+  planName: boundedText.optional(),
+  freshForSeconds: exports_external.number().int().positive().max(86400),
+  limits: exports_external.array(QuotaLimitSchema).min(1).max(8)
+}).strict().superRefine((value, ctx) => {
+  const identities = new Set;
+  for (const [index2, limit] of value.limits.entries()) {
+    const identity = quotaIdentity(limit);
+    if (identities.has(identity)) {
+      ctx.addIssue({ code: "custom", message: "duplicate quota bucket identity", path: ["limits", index2] });
+    }
+    identities.add(identity);
+  }
+});
+var ProviderQuotaObservationSchema = exports_external.union([
+  AvailableQuotaObservationSchema,
+  exports_external.object({
+    status: exports_external.literal("error"),
+    sourceEpoch: exports_external.string().regex(/^[A-Za-z0-9_-]{22}$/),
+    code: exports_external.enum(["unavailable", "unauthorized", "network", "provider_error", "invalid_response"]),
+    retryable: exports_external.boolean()
+  }).strict()
+]);
+var ProviderQuotaSnapshotSchema = exports_external.object({
+  agentBackendId: exports_external.enum(["claude", "codex"]),
+  observation: ProviderQuotaObservationSchema
+}).strict();
 // ../shared/src/utils/slug.ts
 init_nanoid();
 var slugId = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz");
@@ -27577,12 +28844,61 @@ var CreateThreadRequestSchema = exports_external.object({
   attachment_ids: exports_external.array(exports_external.string()).optional()
 });
 var RUNTIME_ID_RE = /^[A-Za-z0-9._@/-]+$/;
+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 = 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,
+  description: exports_external.string().max(COMMUNITY_REASONING_DESCRIPTION_MAX).optional()
+});
+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) => {
+      const parsed = RuntimeReasoningOptionSchema.safeParse(candidate);
+      if (!parsed.success)
+        return [];
+      const option = parsed.data;
+      if (seen.has(option.value))
+        return [];
+      seen.add(option.value);
+      return [option];
+    });
+  }),
+  defaultReasoningEffort: ReasoningEffortSchema.optional().catch(undefined)
+}).transform((model) => {
+  const { defaultReasoningEffort, ...rest } = model;
+  return defaultReasoningEffort !== undefined && model.supportedReasoningEfforts.some((option) => option.value === defaultReasoningEffort) ? { ...rest, defaultReasoningEffort } : rest;
+});
+var RuntimeReasoningCatalogSchema = exports_external.object({
+  updateMode: exports_external.enum(["live_next_turn", "context_preserving_restart", "unsupported"]),
+  defaultModelId: exports_external.string().min(1).max(100).optional().catch(undefined),
+  models: exports_external.array(exports_external.unknown()).max(COMMUNITY_REASONING_MODELS_MAX).transform((models) => {
+    const seen = new Set;
+    return models.flatMap((candidate) => {
+      const parsed = RuntimeReasoningModelSchema.safeParse(candidate);
+      if (!parsed.success)
+        return [];
+      const model = parsed.data;
+      if (seen.has(model.id))
+        return [];
+      seen.add(model.id);
+      return [model];
+    });
+  })
+});
 var CommunityMachineRuntimeSchema = exports_external.object({
   id: exports_external.string().min(1).max(COMMUNITY_RUNTIME_ID_MAX).regex(RUNTIME_ID_RE, "invalid runtime id charset"),
   version: exports_external.string().max(COMMUNITY_RUNTIME_VERSION_MAX).optional(),
   status: exports_external.enum(["healthy", "unhealthy"]).catch("healthy").default("healthy"),
   lastError: exports_external.string().max(128).optional(),
-  lastErrorAt: exports_external.string().optional()
+  lastErrorAt: exports_external.string().optional(),
+  reasoning: RuntimeReasoningCatalogSchema.optional().catch(undefined)
 });
 var CommunityMachineRuntimeListSchema = exports_external.array(CommunityMachineRuntimeSchema).max(COMMUNITY_RUNTIME_LIST_MAX).transform((list) => {
   const seen = new Set;
@@ -27634,7 +28950,8 @@ var HostReadyMessageSchema = exports_external.object({
   platform: exports_external.string().optional(),
   arch: exports_external.string().optional(),
   osRelease: exports_external.string().optional(),
-  daemonVersion: exports_external.string().optional()
+  daemonVersion: exports_external.string().optional(),
+  providerQuotas: exports_external.array(ProviderQuotaSnapshotSchema).max(2).optional().default([])
 });
 var CommunityDaemonReadySchema = exports_external.object({
   runtimeReport: CommunityMachineRuntimeListSchema.optional(),
@@ -27655,7 +28972,9 @@ var SessionErrorFrameSchema = exports_external.object({
 var AgentActivityMessageSchema = exports_external.object({
   type: exports_external.literal("agent_activity"),
   agentId: exports_external.string(),
-  state: exports_external.enum(["idle", "starting", "running", "stopping"])
+  state: exports_external.enum(["idle", "starting", "running", "stopping"]),
+  dailyUsage: exports_external.array(DailyUsageSnapshotSchema).max(7).optional(),
+  quota: ProviderQuotaSnapshotSchema.optional()
 });
 var AgentTypingMessageSchema = exports_external.object({
   type: exports_external.literal("agent_typing"),
@@ -27730,15 +29049,17 @@ var CommunityBotCreateRequestSchema = exports_external.object({
   machineId: exports_external.string().min(1),
   runtime: exports_external.string().min(1),
   image: BotImageUrlSchema.optional(),
-  model: exports_external.string().trim().min(1).max(100).nullable().optional()
+  model: exports_external.string().trim().min(1).max(100).nullable().optional(),
+  reasoningEffort: ReasoningEffortSchema.nullable().optional()
 });
 var CommunityBotPatchRequestSchema = exports_external.object({
   name: exports_external.string().trim().min(COMMUNITY_BOT_NAME_MIN).max(COMMUNITY_BOT_NAME_MAX).refine(isMentionSafeName, { message: MENTION_SAFE_NAME_MSG }).optional(),
   description: exports_external.string().max(COMMUNITY_BOT_DESCRIPTION_MAX).optional(),
   image: BotImageUrlSchema.nullable().optional(),
   model: exports_external.string().trim().min(1).max(100).nullable().optional(),
-  runtime: exports_external.string().trim().min(1).max(COMMUNITY_RUNTIME_ID_MAX).optional()
-}).refine((v) => v.name !== undefined || v.description !== undefined || v.image !== undefined || v.runtime !== undefined || ("model" in v), {
+  runtime: exports_external.string().trim().min(1).max(COMMUNITY_RUNTIME_ID_MAX).optional(),
+  reasoningEffort: ReasoningEffortSchema.nullable().optional()
+}).refine((v) => v.name !== undefined || v.description !== undefined || v.image !== undefined || v.runtime !== undefined || ("reasoningEffort" in v) || ("model" in v), {
   message: "at least one field must be provided"
 });
 var CommunityBotAddToServerRequestSchema = exports_external.object({
@@ -27940,6 +29261,7 @@ __export(exports_community_schema, {
   communityChannelMember: () => communityChannelMember,
   communityChannel: () => communityChannel,
   communityCategory: () => communityCategory,
+  communityBotDailyTokenUsage: () => communityBotDailyTokenUsage,
   communityBotDailyActivity: () => communityBotDailyActivity,
   communityBotApprovalRequest: () => communityBotApprovalRequest,
   communityBotActivityEvent: () => communityBotActivityEvent,
@@ -28192,6 +29514,17 @@ var communityBotDailyActivity = sqliteTable("community_bot_daily_activity", {
   handledCount: integer2("handled_count").notNull().default(0),
   sentCount: integer2("sent_count").notNull().default(0)
 }, (t) => [primaryKey({ columns: [t.botId, t.day] })]);
+var communityBotDailyTokenUsage = sqliteTable("community_bot_daily_token_usage", {
+  botId: text("bot_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  day: text("day").notNull(),
+  inputTokens: integer2("input_tokens"),
+  outputTokens: integer2("output_tokens"),
+  cacheTokens: integer2("cache_tokens"),
+  updatedAt: text("updated_at").notNull()
+}, (t) => [
+  primaryKey({ columns: [t.botId, t.day] }),
+  index("idx_community_bot_daily_token_usage_day").on(t.day)
+]);
 var communityMessageMark = sqliteTable("community_message_mark", {
   id: text("id").primaryKey().$defaultFn(() => nanoid3()),
   userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
@@ -28316,7 +29649,8 @@ var listedMessageProjection = {
   clientNonce: communityMessage.clientNonce,
   authorName: user.name,
   authorEmail: user.email,
-  authorImage: user.image
+  authorImage: user.image,
+  authorAvatarVersion: user.avatarVersion
 };
 
 // ../shared/src/db/queries/user.ts
@@ -28326,6 +29660,7 @@ var publicUserColumns = {
   email: user.email,
   emailVerified: user.emailVerified,
   image: user.image,
+  avatarVersion: user.avatarVersion,
   createdAt: user.createdAt,
   updatedAt: user.updatedAt,
   discriminator: user.discriminator
@@ -28336,6 +29671,12 @@ var internalUserColumns = {
   ownerUserId: user.ownerUserId,
   deletedAt: user.deletedAt
 };
+var avatarPublishColumns = {
+  id: user.id,
+  image: user.image,
+  avatarVersion: user.avatarVersion,
+  avatarObjectKey: user.avatarObjectKey
+};
 
 // ../shared/src/db/queries/community/channel.ts
 var CHANNEL_COLUMNS = {
@@ -28388,7 +29729,8 @@ var friendApprovalProfileSchema = exports_external.strictObject({
   id: string4,
   name: string4,
   discriminator: string4,
-  image: nullableString
+  image: nullableString,
+  avatarVersion: exports_external.number().int().nonnegative()
 });
 var FriendApprovalPayloadSchema = exports_external.strictObject({
   friendshipId: string4,
@@ -28414,6 +29756,7 @@ var messageSchema = exports_external.strictObject({
   authorId: string4,
   authorName: string4,
   authorAvatar: string4.optional(),
+  authorAvatarVersion: exports_external.number().int().nonnegative(),
   content: string4,
   type: exports_external.enum(["chat", "system"]),
   systemKind: exports_external.literal("thread").optional(),
@@ -28421,6 +29764,7 @@ var messageSchema = exports_external.strictObject({
   replyToId: nullableString.optional(),
   replyTo: exports_external.strictObject({
     id: string4,
+    authorId: string4.optional(),
     authorName: string4,
     text: string4,
     deleted: exports_external.boolean().optional()
@@ -28615,6 +29959,7 @@ var communityMemberJoinSchema = exports_external.strictObject({
     name: string4,
     discriminator: string4,
     avatar: string4.optional(),
+    avatarVersion: exports_external.number().int().nonnegative(),
     role: string4,
     joinedAt: string4
   })
@@ -28717,6 +30062,22 @@ var communityStatusUpdateSchema = exports_external.strictObject({
   statusEmoji: nullableString,
   statusText: nullableString
 });
+var communityIdentityUpdateSchema = exports_external.strictObject({
+  type: exports_external.literal("community:identity.update"),
+  userId: string4,
+  avatar: string4,
+  avatarVersion: exports_external.number().int().positive()
+});
+var communityProfileUpdateSchema = exports_external.strictObject({
+  type: exports_external.literal("community:profile.update"),
+  userId: string4,
+  name: string4,
+  discriminator: string4,
+  aboutMe: string4,
+  bannerColor: nullableString,
+  kind: exports_external.enum(["human", "bot"]),
+  ownerUserId: nullableString
+});
 var machineRuntimeSchema = CommunityMachineRuntimeSchema.strict();
 var CommunityMachineSummarySchema2 = exports_external.strictObject({
   id: string4,
@@ -28805,6 +30166,8 @@ var CommunityWsEventDiscriminatedSchema = exports_external.discriminatedUnion("t
   communityInboxChangedSchema,
   communityPresenceUpdateSchema,
   communityStatusUpdateSchema,
+  communityIdentityUpdateSchema,
+  communityProfileUpdateSchema,
   communityMachineCreatedSchema,
   communityMachineStatusSchema,
   communityMachineUpdatedSchema,
@@ -28851,6 +30214,8 @@ var WS_EVENTS = {
   INBOX_CHANGED: "community:inbox.changed",
   PRESENCE_UPDATE: "community:presence.update",
   STATUS_UPDATE: "community:status.update",
+  IDENTITY_UPDATE: "community:identity.update",
+  PROFILE_UPDATE: "community:profile.update",
   MACHINE_CREATED: "community:machine.created",
   MACHINE_STATUS: "community:machine.status",
   MACHINE_UPDATED: "community:machine.updated",
@@ -29411,23 +30776,43 @@ class WsControlChannel {
     this.ws.send(JSON.stringify(frame));
   }
   resyncOnConnect() {
+    const sendActivities = (activities, counts) => {
+      for (const activity of activities) {
+        this.sendFrame({ type: "agent_activity", ...activity });
+      }
+      this.log.info("resync sent", {
+        ready: counts.ready,
+        sessions: counts.sessions,
+        activities: activities.length,
+        pendingAuditEvents: this.pendingBotAuditEvents.size
+      });
+    };
     if (this.resyncProvider) {
-      const { ready, sessions, activities } = this.resyncProvider();
-      this.sendFrame({ type: "ready", ...ready });
-      for (const s of sessions)
-        this.sendFrame({ type: "agent_session", ...s });
-      const liveActivities = activities ?? [];
-      for (const a of liveActivities)
-        this.sendFrame({ type: "agent_activity", ...a });
+      const socketAtStart = this.ws;
+      const snapshot = this.resyncProvider();
+      this.sendFrame({ type: "ready", ...snapshot.ready });
+      for (const session2 of snapshot.sessions) {
+        this.sendFrame({ type: "agent_session", ...session2 });
+      }
       for (const frame of this.pendingBotAuditEvents.values())
         this.sendFrame(frame);
       this.scheduleAuditRetry();
-      this.log.info("resync sent", {
-        ready: ready.runtimeReport.length,
-        sessions: sessions.length,
-        activities: liveActivities.length,
-        pendingAuditEvents: this.pendingBotAuditEvents.size
-      });
+      const activities = snapshot.activities ?? [];
+      const counts = {
+        ready: snapshot.ready.runtimeReport.length,
+        sessions: snapshot.sessions.length
+      };
+      if (activities instanceof Promise) {
+        activities.then((resolved) => {
+          if (this.ws === socketAtStart && this.statusValue === "open") {
+            sendActivities(resolved, counts);
+          }
+        }).catch((err) => {
+          this.log.warn("resync provider failed", { err: describeErr(err) });
+        });
+      } else {
+        sendActivities(activities, counts);
+      }
     }
     for (const hook of this.resyncHooks) {
       try {
@@ -29645,8 +31030,8 @@ class WsControlChannel {
 }
 // src/timeline/timeline.ts
 import * as fs7 from "node:fs";
-import { createHash as createHash4, randomBytes as randomBytes4 } from "node:crypto";
-import { basename, dirname as dirname3, join as join10 } from "node:path";
+import { createHash as createHash4, randomBytes as randomBytes6 } from "node:crypto";
+import { basename, dirname as dirname3, join as join11 } from "node:path";
 
 // src/timeline/filelock.ts
 import * as fs6 from "fs";
@@ -29989,7 +31374,7 @@ function scanTimelineFile(filePath) {
   }
 }
 function atomicReplaceTimeline(filePath, lines) {
-  const tempPath = join10(dirname3(filePath), `.${basename(filePath)}.${process.pid}.${randomBytes4(12).toString("hex")}.tmp`);
+  const tempPath = join11(dirname3(filePath), `.${basename(filePath)}.${process.pid}.${randomBytes6(12).toString("hex")}.tmp`);
   let fd = null;
   try {
     fd = fs7.openSync(tempPath, "wx", 384);
@@ -30073,14 +31458,14 @@ function readRecentEntries(timelineDir, opts = {}) {
   const filenames = recentFilenames(maxDays, now).reverse();
   const entries = [];
   for (const filename of filenames) {
-    entries.push(...readJsonl(join10(timelineDir, filename)));
+    entries.push(...readJsonl(join11(timelineDir, filename)));
   }
   return entries;
 }
 function readResumeControlState(timelineDir) {
   if (timelineDirectoryState(timelineDir) !== "safe")
     return { kind: "missing" };
-  const filePath = join10(timelineDir, RESUME_CONTROL_FILENAME);
+  const filePath = join11(timelineDir, RESUME_CONTROL_FILENAME);
   let source;
   try {
     source = fs7.lstatSync(filePath);
@@ -30156,8 +31541,8 @@ function updateResumeControlState(timelineDir, update) {
 `;
     if (Buffer.byteLength(body, "utf8") > RESUME_CONTROL_MAX_BYTES)
       return false;
-    const filePath = join10(timelineDir, RESUME_CONTROL_FILENAME);
-    const tempPath = join10(timelineDir, `.${RESUME_CONTROL_FILENAME}.${process.pid}.${randomBytes4(12).toString("hex")}.tmp`);
+    const filePath = join11(timelineDir, RESUME_CONTROL_FILENAME);
+    const tempPath = join11(timelineDir, `.${RESUME_CONTROL_FILENAME}.${process.pid}.${randomBytes6(12).toString("hex")}.tmp`);
     let fd = null;
     try {
       fd = fs7.openSync(tempPath, "wx", 384);
@@ -30187,7 +31572,7 @@ function appendTrackedEntry(timelineDir, entry, now = new Date) {
   if (timelineDirectoryState(timelineDir) !== "safe")
     return { status: "rejected", reason: "unsafe" };
   const filename = filenameForDate(now);
-  const filePath = join10(timelineDir, filename);
+  const filePath = join11(timelineDir, filename);
   const lockPath = lockPathFor(timelineDir, filename);
   try {
     if (!acquireLock(lockPath))
@@ -30215,7 +31600,7 @@ function updateTrackedEntry(timelineDir, handle, update) {
   if (!DATE_FILENAME_PATTERN.test(handle.filename) || basename(handle.filename) !== handle.filename) {
     return { status: "rejected", reason: "unsafe" };
   }
-  const filePath = join10(timelineDir, handle.filename);
+  const filePath = join11(timelineDir, handle.filename);
   const lockPath = lockPathFor(timelineDir, handle.filename);
   try {
     if (!acquireLock(lockPath))
@@ -30274,10 +31659,10 @@ async function sweepTimelineHistory(workingDirectoryBase, opts = {}) {
     return;
   }
   for (const agentName of agentNames) {
-    const agentDir = join10(workingDirectoryBase, agentName);
+    const agentDir = join11(workingDirectoryBase, agentName);
     if (!isRealDirectory(agentDir))
       continue;
-    const timelineDir = join10(agentDir, ".context_timeline");
+    const timelineDir = join11(agentDir, ".context_timeline");
     if (!isRealDirectory(timelineDir))
       continue;
     let filenames;
@@ -30287,7 +31672,7 @@ async function sweepTimelineHistory(workingDirectoryBase, opts = {}) {
       continue;
     }
     for (const filename of filenames) {
-      const filePath = join10(timelineDir, filename);
+      const filePath = join11(timelineDir, filename);
       let source;
       try {
         source = fs7.lstatSync(filePath);
@@ -30936,7 +32321,12 @@ async function detectRuntimes() {
       const driver = getDriver(id);
       const probe = await driver.probe();
       if (probe.status === "healthy") {
-        results.push({ id, status: "healthy", version: probe.version });
+        results.push({
+          id,
+          status: "healthy",
+          version: probe.version,
+          reasoning: probe.reasoning
+        });
       } else {
         results.push({
           id,
@@ -31041,15 +32431,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 {
@@ -31060,8 +32450,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) {
@@ -31101,8 +32491,8 @@ class MessageReminderScheduler {
 
 // src/manager/agentDriverHost.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { homedir as homedir3 } from "node:os";
-import { join as join12 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join13 } from "node:path";
 
 // src/drivers/gitIdentityEnv.ts
 import { execFileSync as execFileSync3 } from "child_process";
@@ -31227,7 +32617,7 @@ function createDaemonAgentDriverHost(ctx, onRawLine) {
             hostUser: readHostGitIdentity() ?? undefined
           }),
           platformProtected: {
-            ALOOK_HOME: process.env.ALOOK_HOME ?? join12(homedir3(), ".alook"),
+            ALOOK_HOME: process.env.ALOOK_HOME ?? join13(homedir4(), ".alook"),
             ALOOK_ID: ctx.agentId,
             ALOOK_CLI: ctx.agentCliPath,
             ALOOK_SERVER_URL: ctx.config.serverUrl,
@@ -31332,6 +32722,182 @@ class DaemonSelfSleepScheduler {
   }
 }
 
+// src/telemetry/dailyTokenUsage.ts
+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 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 isMetric(value) {
+  return value === null || typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isSnapshot(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const snapshot = value;
+  const metrics = snapshot.metrics;
+  return typeof snapshot.botId === "string" && snapshot.botId.length > 0 && typeof snapshot.day === "string" && /^\d{4}-\d{2}-\d{2}$/.test(snapshot.day) && !!metrics && isMetric(metrics.input) && isMetric(metrics.output) && isMetric(metrics.cache);
+}
+function mergeMetric(existing, delta, hasExistingSnapshot) {
+  if (delta === null)
+    return null;
+  if (!Number.isSafeInteger(delta) || delta < 0) {
+    throw new RangeError("token usage delta must be a non-negative safe integer");
+  }
+  if (!hasExistingSnapshot)
+    return delta;
+  if (existing === null)
+    return null;
+  const sum = existing + delta;
+  if (!Number.isSafeInteger(sum))
+    throw new RangeError("daily token usage exceeds safe integer range");
+  return sum;
+}
+function emptySnapshot(botId, day) {
+  return {
+    botId,
+    day,
+    metrics: {
+      input: null,
+      output: null,
+      cache: null
+    }
+  };
+}
+
+class DailyTokenUsageStore {
+  now;
+  tail = Promise.resolve();
+  loaded = false;
+  data = { version: 1, bots: {} };
+  filePath;
+  constructor(workingDirectoryBase, now = () => new Date) {
+    this.now = now;
+    this.filePath = join14(workingDirectoryBase, ".telemetry", "daily-token-usage.json");
+  }
+  record(botId, delta) {
+    return this.enqueue(async () => {
+      await this.load();
+      const at = this.now();
+      this.prune(at);
+      const day = dayKey(at);
+      const snapshots = this.data.bots[botId] ?? [];
+      const existing = snapshots.find((snapshot) => snapshot.day === day);
+      const next = existing ?? emptySnapshot(botId, day);
+      next.metrics = {
+        input: mergeMetric(next.metrics.input, delta.input, existing !== undefined),
+        output: mergeMetric(next.metrics.output, delta.output, existing !== undefined),
+        cache: mergeMetric(next.metrics.cache, delta.cache, existing !== undefined)
+      };
+      if (!existing)
+        snapshots.push(next);
+      snapshots.sort((a, b) => a.day.localeCompare(b.day));
+      this.data.bots[botId] = snapshots;
+      await this.persist();
+    });
+  }
+  snapshots(botId) {
+    let result = [];
+    return this.enqueue(async () => {
+      await this.load();
+      if (this.prune(this.now()))
+        await this.persist();
+      result = (this.data.bots[botId] ?? []).map((snapshot) => structuredClone(snapshot));
+    }).then(() => result);
+  }
+  enqueue(operation) {
+    const result = this.tail.then(operation, operation);
+    this.tail = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  }
+  async load() {
+    if (this.loaded)
+      return;
+    let source;
+    try {
+      source = await readFile2(this.filePath, "utf8");
+    } catch (error51) {
+      if (!error51 || typeof error51 !== "object" || !("code" in error51) || error51.code !== "ENOENT") {
+        throw error51;
+      }
+      this.data = { version: 1, bots: {} };
+      this.loaded = true;
+      return;
+    }
+    const parsed = JSON.parse(source);
+    if (!parsed || typeof parsed !== "object" || parsed.version !== 1) {
+      throw new Error("invalid daily token usage file version");
+    }
+    const bots = parsed.bots;
+    if (!bots || typeof bots !== "object" || Array.isArray(bots)) {
+      throw new Error("invalid daily token usage bots map");
+    }
+    const valid = {};
+    for (const [botId, value] of Object.entries(bots)) {
+      if (!Array.isArray(value) || !value.every(isSnapshot) || value.some((snapshot) => snapshot.botId !== botId)) {
+        throw new Error(`invalid daily token usage snapshots for bot ${botId}`);
+      }
+      if (value.length > 0) {
+        valid[botId] = value;
+      }
+    }
+    this.data = { version: 1, bots: valid };
+    this.loaded = true;
+  }
+  prune(at) {
+    const keep = retainedDays(at);
+    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);
+      if (retained.length !== snapshots.length || retained.some((snapshot, index2) => snapshot !== snapshots[index2]))
+        changed = true;
+      if (retained.length === 0)
+        delete this.data.bots[botId];
+      else
+        this.data.bots[botId] = retained;
+    }
+    return changed;
+  }
+  async persist() {
+    const directory = dirname5(this.filePath);
+    await mkdir(directory, { recursive: true, mode: 448 });
+    const temporary = `${this.filePath}.${randomUUID7()}.tmp`;
+    try {
+      const file2 = await open(temporary, "wx", 384);
+      try {
+        await file2.writeFile(JSON.stringify(this.data), { encoding: "utf8" });
+        await file2.sync();
+      } finally {
+        await file2.close();
+      }
+      await rename(temporary, this.filePath);
+      await chmod(this.filePath, 384);
+      try {
+        const directoryHandle = await open(directory, "r");
+        try {
+          await directoryHandle.sync();
+        } finally {
+          await directoryHandle.close();
+        }
+      } catch {}
+    } catch (error51) {
+      await rm(temporary, { force: true }).catch(() => {});
+      throw error51;
+    }
+  }
+}
 // src/daemon/createDaemon.ts
 var WARMUP_BACKOFF_MS = [250, 500, 1000, 2000, 4000];
 var WARMUP_CEILING_MS = 30000;
@@ -31469,9 +33035,25 @@ function createBuiltinDaemonSessionFactory(onRuntimeRawLine) {
 }
 async function createDaemon(opts) {
   const log2 = opts.logger ?? createLogger({ header: "@alook/daemon" });
-  const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir4()}/.alook`) + "/daemon";
+  const fallbackBase = (process.env.ALOOK_PROJECT_ROOT || `${homedir5()}/.alook`) + "/daemon";
   const workingDirectoryBase = opts.workingDirectoryBase ?? fallbackBase;
   const workdirFor = (agentId) => `${workingDirectoryBase}/${agentId}`;
+  const dailyTokenUsage2 = new DailyTokenUsageStore(workingDirectoryBase);
+  const providerQuotaReader = opts.providerQuotaReader ?? (opts.sessionFactory ? async () => null : readBuiltinProviderQuota);
+  const providerQuotaByBackend = new Map;
+  let requestReadyQuotaResend = () => {};
+  const recordProviderQuota = (backendId, quota) => {
+    const previous = providerQuotaByBackend.get(backendId);
+    if (previous?.observation.status === "available" && quota.status === "error" && previous.observation.sourceEpoch === quota.sourceEpoch)
+      return;
+    providerQuotaByBackend.set(backendId, {
+      agentBackendId: backendId,
+      observation: structuredClone(quota)
+    });
+    if (previous && previous.observation.sourceEpoch !== quota.sourceEpoch) {
+      requestReadyQuotaResend();
+    }
+  };
   sweepTimelineHistory(workingDirectoryBase).catch(() => {
     log2.warn("timeline startup sweep failed");
   });
@@ -31487,6 +33069,27 @@ async function createDaemon(opts) {
   });
   let channelRef = null;
   let managerRef = null;
+  const providerQuotaSnapshots = () => [...providerQuotaByBackend.values()].map((snapshot) => structuredClone(snapshot));
+  const activityPayload = async (info) => {
+    if (info.state !== "idle")
+      return info;
+    const backendId = managerRef?.agentBackendId(info.agentId);
+    if (backendId === "claude") {
+      const observed = await providerQuotaReader("claude");
+      if (observed)
+        recordProviderQuota("claude", observed);
+    }
+    const quota = backendId === "claude" || backendId === "codex" ? providerQuotaByBackend.get(backendId) : undefined;
+    const dailyUsage = await dailyTokenUsage2.snapshots(info.agentId);
+    return {
+      ...info,
+      ...dailyUsage.length > 0 ? { dailyUsage } : {},
+      ...quota ? { quota: structuredClone(quota) } : {}
+    };
+  };
+  let reportAgentActivity = (info) => {
+    channelRef?.reportAgentActivity?.(info);
+  };
   let reminderSchedulerRef = null;
   const selfSleepScheduler = opts.onSelfSleep ? new DaemonSelfSleepScheduler({
     onSleep: opts.onSelfSleep,
@@ -31551,7 +33154,7 @@ async function createDaemon(opts) {
   function reassertAgentActivity(agentId) {
     const state = managerRef?.agentActivity(agentId);
     if (state)
-      channel2.reportAgentActivity?.({ agentId, state });
+      reportAgentActivity({ agentId, state });
   }
   function startTypingHeartbeat(agentId) {
     stopTypingHeartbeat(agentId);
@@ -31695,6 +33298,20 @@ async function createDaemon(opts) {
     logger: log2.child("ws")
   });
   channelRef = channel2;
+  const activityReportTails = new Map;
+  reportAgentActivity = (info) => {
+    const prior = activityReportTails.get(info.agentId) ?? Promise.resolve();
+    const next = prior.then(async () => {
+      await channel2.reportAgentActivity(await activityPayload(info));
+    }).catch(() => {
+      log2.warn("agent activity telemetry report failed", { agentId: info.agentId, state: info.state });
+    });
+    activityReportTails.set(info.agentId, next);
+    next.finally(() => {
+      if (activityReportTails.get(info.agentId) === next)
+        activityReportTails.delete(info.agentId);
+    });
+  };
   function restorePendingIdleResetEvents(agentId) {
     for (const pending of timeline2.pendingIdleResetEvents(agentId)) {
       channel2.restorePendingBotAuditEvent({
@@ -31813,7 +33430,7 @@ async function createDaemon(opts) {
     onAgentSession: (info) => void channel2.reportAgentSession(info),
     onAgentActivity: (info) => {
       selfSleepScheduler?.observeAgentActivity(info.agentId, info.state === "running");
-      channel2.reportAgentActivity?.(info);
+      reportAgentActivity(info);
       if (info.state === "starting" || info.state === "running") {
         if (!typingHeartbeats.has(info.agentId)) {
           startTypingHeartbeat(info.agentId);
@@ -31822,6 +33439,16 @@ async function createDaemon(opts) {
         emitTypingStopsAndClear(info.agentId);
       }
     },
+    onTokenUsage: ({ agentId, usage }) => {
+      dailyTokenUsage2.record(agentId, usage).catch(() => {
+        log2.warn("daily token usage persistence failed", { agentId });
+      });
+    },
+    onProviderQuota: ({ backendId, quota }) => {
+      if (backendId !== "claude" && backendId !== "codex")
+        return;
+      recordProviderQuota(backendId, quota);
+    },
     onBotAuditEvent: (agentId, event, context) => emitBotAuditEvent(agentId, event, context),
     onAgentLocallyStopped: (info) => router?.markLocallyStopped(info.agentId),
     onRuntimeRawLine,
@@ -31868,6 +33495,11 @@ async function createDaemon(opts) {
     arch: opts.arch,
     osRelease: opts.osRelease,
     daemonVersion: opts.daemonVersion,
+    providerQuotas: providerQuotaSnapshots,
+    resyncActivities: async () => {
+      const activities = await Promise.all(manager.liveAgentActivities().map((info) => activityPayload(info)));
+      return activities.filter((activity) => manager.agentActivity(activity.agentId) === activity.state);
+    },
     typingTracker,
     logger: log2.child("router"),
     onBeforeAgent: async (agentId) => {
@@ -31883,6 +33515,10 @@ async function createDaemon(opts) {
       await enrollAgent(agentId);
     }
   });
+  requestReadyQuotaResend = () => {
+    if (router)
+      channel2.sendReady?.(router.buildReady());
+  };
   channel2.onCommand(createSelfUpdateCommandListener(opts.handleSelfUpdate));
   channel2.onCommand(createDiagnosticsCommandListener({
     handleDiagnosticCommand: opts.handleDiagnosticCommand,
@@ -31912,6 +33548,11 @@ async function createDaemon(opts) {
     resyncPendingWakes();
     resyncPendingDiagnostics();
   });
+  if (opts.runtimeReport.some((runtime) => runtime.id === "claude")) {
+    const observed = await providerQuotaReader("claude");
+    if (observed)
+      recordProviderQuota("claude", observed);
+  }
   channel2.connect();
   await router.start();
   selfSleepScheduler?.start();