@alook/daemon 0.1.24 → 0.1.25

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();
@@ -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
       }
     };
   }
@@ -1502,49 +1499,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 +1668,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 +1684,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 +1764,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 +1807,7 @@ class CodexEventNormalizer {
           return [];
         this.turnId = params.turn.id;
         this.terminalTurn = null;
+        this.pendingTurnUsage = null;
         return [
           {
             kind: "turn_owner",
@@ -1650,24 +1836,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 +1978,53 @@ 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/adapters/codex/index.js
+var SETTINGS_UPDATE_TIMEOUT_MS = 5000;
+var MODEL_LIST_TIMEOUT_MS = 5000;
+var MODEL_LIST_MAX = 64;
+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 +2045,157 @@ 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 nextId = 0;
+      let initializeId = 0;
+      let listId = 0;
+      const models = [];
+      const seenModels = new Set;
+      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" || models.length >= MODEL_LIST_MAX)
+          return;
+        const model = value;
+        const id = typeof model.id === "string" ? model.id.trim() : "";
+        if (!id || id.length > 100 || seenModels.has(id))
+          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);
+        const cursor = typeof result.nextCursor === "string" ? result.nextCursor : undefined;
+        if (cursor && models.length < MODEL_LIST_MAX)
+          return requestModelPage(cursor);
+        finish({
+          updateMode: "live_next_turn",
+          ...defaultModelId ? { defaultModelId } : {},
+          models
+        });
+      };
+      const timer = setTimeout(() => finish(), MODEL_LIST_TIMEOUT_MS);
+      timer.unref?.();
+      proc.stdout?.on("data", (chunk) => {
+        buffer += chunk.toString();
+        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 +2211,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 +2242,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 +2280,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;
   }
@@ -2203,15 +2682,6 @@ class CursorAcpLane {
     }
     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,
@@ -2561,10 +3031,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";
@@ -2703,7 +3173,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;
@@ -3317,12 +3787,20 @@ class OpenCodeServiceLane {
           });
         }
         const tokens = record2(data.tokens);
-        if (tokens) {
+        if (tokens && data.finish !== "tool-calls") {
+          const cache = record2(tokens.cache);
+          const metric2 = (value2) => typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0 ? value2 : null;
+          const cacheParts = [cache?.read, cache?.write].filter((value2) => typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0);
+          const cacheTotal = cacheParts.reduce((sum, value2) => sum + value2, 0);
           this.events.emit("runtime_event", {
             kind: "telemetry",
             name: "token_usage",
             source: "opencode.v2",
-            attrs: tokens
+            usage: {
+              input: metric2(tokens.input),
+              output: metric2(tokens.output),
+              cache: cacheParts.length > 0 && Number.isSafeInteger(cacheTotal) ? cacheTotal : null
+            }
           });
         }
         break;
@@ -3628,7 +4106,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,7 +4171,7 @@ 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 {
@@ -4471,48 +4949,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 +5066,8 @@ class LogicalAgentSession {
   toolBoundaryFlushDisabled = false;
   safeBoundaryFlush;
   safeBoundaryDelivery;
+  settingsUpdateTail = Promise.resolve();
+  settingsUpdatePending = false;
   turnAdmission;
   instructionsMaterialized = false;
   lifecycleGeneration = 0;
@@ -4685,6 +5123,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 +5313,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 +5621,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 +5725,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 +6225,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 +6241,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 +6436,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 record3 = body;
+  const limits = ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"].map((key) => claudeLimit(key, record3[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 = [
@@ -6824,6 +7436,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 +7666,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,
@@ -7946,9 +8581,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 +8616,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 +8809,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 +8914,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 +9442,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 +9563,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 +9614,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 +9851,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 +9971,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 +9986,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);
     }
   }
 }
@@ -23489,6 +24305,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 +24902,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 +24912,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join9;
+  sql2.join = join10;
   function identifier(value) {
     return new Name(value);
   }
@@ -25092,6 +25909,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 +26584,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 +26779,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 +26890,8 @@ class AgentRouter {
         version: r.version,
         status: r.status ?? "healthy",
         lastError: r.lastError,
-        lastErrorAt: r.lastErrorAt
+        lastErrorAt: r.lastErrorAt,
+        reasoning: r.reasoning
       });
     }
   }
@@ -26060,7 +26900,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 +26913,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() {
@@ -26295,6 +27136,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 {
@@ -26779,7 +27641,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 +27916,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 +27925,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 +28525,60 @@ 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 = 64;
+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),
+  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 +28630,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 +28652,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 +28729,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 +28941,7 @@ __export(exports_community_schema, {
   communityChannelMember: () => communityChannelMember,
   communityChannel: () => communityChannel,
   communityCategory: () => communityCategory,
+  communityBotDailyTokenUsage: () => communityBotDailyTokenUsage,
   communityBotDailyActivity: () => communityBotDailyActivity,
   communityBotApprovalRequest: () => communityBotApprovalRequest,
   communityBotActivityEvent: () => communityBotActivityEvent,
@@ -28192,6 +29194,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 +29329,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 +29340,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 +29351,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 +29409,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 +29436,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 +29444,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 +29639,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 +29742,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 +29846,8 @@ var CommunityWsEventDiscriminatedSchema = exports_external.discriminatedUnion("t
   communityInboxChangedSchema,
   communityPresenceUpdateSchema,
   communityStatusUpdateSchema,
+  communityIdentityUpdateSchema,
+  communityProfileUpdateSchema,
   communityMachineCreatedSchema,
   communityMachineStatusSchema,
   communityMachineUpdatedSchema,
@@ -28851,6 +29894,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 +30456,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 +30710,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 +31054,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 +31138,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 +31221,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 +31252,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 +31280,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 +31339,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 +31352,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 +32001,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,
@@ -31101,8 +32171,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 +32297,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 +32402,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 +32715,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 +32749,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 +32834,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 +32978,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 +33110,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 +33119,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 +33175,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 +33195,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 +33228,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();