replicas-engine 0.1.699 → 0.1.701

package/dist/src/index.js

@@ -68,6 +68,7 @@ import {
   MEMORY_ROOT,
   MEMORY_SUMMARY_FILENAME,
   MERGED_MESSAGE_SEPARATOR,
+  MODEL_REROUTED_METHOD,
   REASONING_SUMMARY_PART_ADDED_METHOD,
   REASONING_SUMMARY_TEXT_DELTA_METHOD,
   REASONING_TEXT_DELTA_METHOD,
@@ -80,6 +81,7 @@ import {
   THREAD_GOAL_UPDATED_METHOD,
   THREAD_TOKEN_USAGE_UPDATED_METHOD,
   TIMEOUT,
+  TOKEN_USAGE_PATH,
   TURN_COMPLETED_METHOD,
   TURN_PLAN_UPDATED_METHOD,
   TURN_STARTED_METHOD,
@@ -116,6 +118,7 @@ import {
   createErrorResult,
   createProviderSlashCommand,
   createSuccessResult,
+  createUuidFromHex,
   decodePathSegments,
   detectAgentQuotaLimit,
   detectLanguageByPath,
@@ -126,6 +129,7 @@ import {
   extractErrorText,
   extractToolResultText,
   fetchAiGatewayModels,
+  fetchModelsDevCatalog,
   findGitCommitSignals,
   findPrMergeSignals,
   getChatHistoryPageSenders,
@@ -159,9 +163,12 @@ import {
   isDefaultChat,
   isGitHubUrl,
   isLatestChatHistoryPage,
+  isNonEmptyString,
   isRecord,
   isSkillRegistryManifest,
   isTerminalBackgroundTaskStatus,
+  isTokenUsageCounts,
+  isTokenUsageUploadRecord,
   isTransientErrorText,
   isValidAgentProvider,
   isValidEngineLogSessionId,
@@ -191,15 +198,16 @@ import {
   renumberCodexAspTranscriptItems,
   resolveWarmHookConfig,
   sanitizeCanvasFilename,
+  sendChatMessageRequestSchema,
   serializeCanvasContentResponse,
   shellQuotePosix,
   stripAgentDiagnosticErrors
-} from "./chunk-UTGTXG54.js";
+} from "./chunk-OI5T44T7.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { randomUUID as randomUUID11 } from "crypto";
 import { connect } from "net";
 
@@ -2814,7 +2822,7 @@ async function registerDesktopPreview() {
 }
 
 // src/services/chat/chat-service.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { appendFile as appendFile4, copyFile, mkdir as mkdir17, readFile as readFile17, rename as rename3, rm as rm2 } from "fs/promises";
 import { join as join29 } from "path";
 import { randomUUID as randomUUID9 } from "crypto";
@@ -3741,6 +3749,7 @@ var CodingAgentManager = class {
   initialSessionId;
   onSaveSessionId;
   onEvent;
+  onUsageUpdate;
   hostOnTurnComplete;
   onProcessingChanged;
   onMessageStarted;
@@ -3751,6 +3760,8 @@ var CodingAgentManager = class {
     this.initialSessionId = options.initialSessionId;
     this.onSaveSessionId = options.onSaveSessionId;
     this.onEvent = options.onEvent;
+    this.onUsageUpdate = options.onUsageUpdate ?? (() => {
+    });
     this.hostOnTurnComplete = options.onTurnComplete;
     this.onProcessingChanged = options.onProcessingChanged ?? (() => {
     });
@@ -6738,9 +6749,17 @@ var CodexAspManager = class extends CodingAgentManager {
   slashCommandsRequest = null;
   steeredTempImagePaths = [];
   steerLock = new AsyncLock();
+  onCodexTurnStarted;
+  onCodexTokenUsage;
+  onCodexModelRerouted;
+  onCodexTurnCompleted;
   constructor(options) {
     super({ ...options, provider: AGENT.CODEX });
     this.historyFile = options.historyFilePath ? new CodexHistoryFile(options.historyFilePath) : null;
+    this.onCodexTurnStarted = options.onCodexTurnStarted;
+    this.onCodexTokenUsage = options.onCodexTokenUsage;
+    this.onCodexModelRerouted = options.onCodexModelRerouted;
+    this.onCodexTurnCompleted = options.onCodexTurnCompleted;
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
@@ -7261,7 +7280,13 @@ var CodexAspManager = class extends CodingAgentManager {
       },
       [THREAD_TOKEN_USAGE_UPDATED_METHOD]: (notification) => {
         if (notification.params.threadId !== threadId) return;
-        this.emitCodexTokenUsage(notification.params.tokenUsage, model);
+        const occurredAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.onCodexTokenUsage?.(notification.params, occurredAt);
+        this.emitCodexTokenUsage(notification.params.tokenUsage, model, occurredAt);
+      },
+      [MODEL_REROUTED_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        this.onCodexModelRerouted?.(notification.params);
       },
       [THREAD_GOAL_UPDATED_METHOD]: (notification) => {
         if (notification.params.threadId !== threadId) return;
@@ -7282,6 +7307,7 @@ var CodexAspManager = class extends CodingAgentManager {
         observedTurnId = notification.params.turn.id;
         observedTurnIds.add(notification.params.turn.id);
         this.activeTurnId = notification.params.turn.id;
+        this.onCodexTurnStarted?.(threadId, notification.params.turn.id);
         if (goalContinuationTimer) {
           clearTimeout(goalContinuationTimer);
           goalContinuationTimer = null;
@@ -7390,6 +7416,7 @@ var CodexAspManager = class extends CodingAgentManager {
         if (!observedTurnIds.has(notification.params.turn.id) && notification.params.turn.id !== this.activeTurnId) return;
         observedTurnIds.add(notification.params.turn.id);
         observedTurnId = notification.params.turn.id;
+        this.onCodexTurnCompleted?.(threadId, notification.params.turn.id);
         const completedTurn = recoverCompletedTurn(notification.params.turn, completedItems, agentMessageDeltas);
         this.mergeTranscriptTurn(notification.params.threadId, completedTurn);
         this.emitTranscriptUpdated(notification.params.threadId, { immediate: true });
@@ -7432,6 +7459,7 @@ var CodexAspManager = class extends CodingAgentManager {
         observedTurnId = started.turn.id;
         observedTurnIds.add(started.turn.id);
         this.activeTurnId = started.turn.id;
+        if (!alreadyObserved) this.onCodexTurnStarted?.(threadId, started.turn.id);
         if (!alreadyObserved) {
           attachUserMessage(started.turn);
           this.mergeTranscriptTurn(threadId, started.turn);
@@ -8015,7 +8043,7 @@ var CodexAspManager = class extends CodingAgentManager {
     this.trackHistoryEvent(event);
     this.onEvent(event);
   }
-  emitCodexTokenUsage(tokenUsage, model) {
+  emitCodexTokenUsage(tokenUsage, model, updatedAt) {
     const payload = buildCodexTokenUsageContextUsagePayload({
       model,
       modelContextWindow: tokenUsage.modelContextWindow,
@@ -8029,7 +8057,7 @@ var CodexAspManager = class extends CodingAgentManager {
       total: {
         totalTokens: tokenUsage.total.totalTokens
       },
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      updatedAt
     });
     const event = this.emitContextUsage(payload);
     this.trackHistoryEvent(event);
@@ -8469,6 +8497,7 @@ ${instructions}
     const outputTokens = finiteNumber(update.usage.outputTokens);
     const rawTotalTokens = inputTokens + cacheReadTokens + cacheWriteTokens + outputTokens;
     if (rawTotalTokens <= 0) return;
+    this.onUsageUpdate(update, (/* @__PURE__ */ new Date()).toISOString());
     const maxTokens = CURSOR_COMPOSER_CONTEXT_WINDOW;
     const { totalTokens, totalProcessedTokens } = clampTokensToWindow(rawTotalTokens, maxTokens);
     const categories = [
@@ -8811,8 +8840,10 @@ var DeepseekManager = class extends CodingAgentManager {
     if (frame.type === "session/projection") {
       if (frame.key === "contextPressure" && isRecord2(frame.value)) this.contextPressure = frame.value;
       else if (frame.key === "contextBreakdown" && isRecord2(frame.value)) this.contextBreakdown = frame.value;
-      else if (frame.key === "tokenUsage" && isRecord2(frame.value)) this.tokenUsage = frame.value;
-      else return;
+      else if (frame.key === "tokenUsage" && isRecord2(frame.value)) {
+        this.tokenUsage = frame.value;
+        this.onUsageUpdate(frame.value, (/* @__PURE__ */ new Date()).toISOString());
+      } else return;
       this.emitDeepseekContextUsage();
       return;
     }
@@ -9162,6 +9193,7 @@ var AcpManager = class extends CodingAgentManager {
     } else if (update.sessionUpdate === "current_mode_update" && this.modes) {
       this.modes = { ...this.modes, currentModeId: update.currentModeId };
     } else if (update.sessionUpdate === "usage_update" && !this.replaying) {
+      const occurredAt = (/* @__PURE__ */ new Date()).toISOString();
       const { used, size } = update;
       this.historyFile.append(this.emitContextUsage({
         provider: this.acp.provider,
@@ -9171,7 +9203,7 @@ var AcpManager = class extends CodingAgentManager {
         maxTokens: size,
         percentage: size > 0 ? used / size * 100 : 0,
         categories: [],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        updatedAt: occurredAt
       }));
     }
     if (!this.replaying) {
@@ -9458,59 +9490,27 @@ import { delimiter, dirname as dirname8, join as join22 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Agent } from "undici";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // ../shared/src/credentials/opencode-go.ts
-import { z as z3 } from "zod";
 var OPENCODE_GO_PROVIDER = "opencode-go";
 var OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
-var OPENCODE_MODELS_DEV_URL = "https://models.dev/api.json";
 var DEFAULT_OPENCODE_GO_MODEL = "glm-5.2";
-var opencodeGoModelsDevSchema = z3.object({
-  "opencode-go": z3.object({
-    models: z3.record(z3.string(), z3.object({
-      id: z3.string().optional(),
-      name: z3.string(),
-      description: z3.string().optional(),
-      status: z3.enum(["alpha", "beta", "deprecated"]).optional()
-    }))
-  }).optional()
-});
-function parseOpenCodeGoCatalog(value) {
-  const parsed = opencodeGoModelsDevSchema.safeParse(value);
-  const provider = parsed.success ? parsed.data["opencode-go"] : void 0;
-  if (!provider) return null;
-  const models = Object.fromEntries(
-    Object.entries(provider.models).filter(([, definition]) => definition.status !== "deprecated" && definition.status !== "alpha").map(([id, definition]) => [id, {
-      id: definition.id ?? id,
-      name: definition.name,
-      ...definition.description ? { description: definition.description } : {},
-      ...definition.status ? { status: definition.status } : {}
-    }])
-  );
-  if (Object.keys(models).length === 0) return null;
-  return { models, authoritative: true };
-}
-var OPENCODE_GO_CATALOG_CACHE_MS = 5 * 6e4;
-var openCodeGoCatalogCache;
-var openCodeGoCatalogRequest;
 async function fetchOpenCodeGoCatalog(fallbackModelIds = [DEFAULT_OPENCODE_GO_MODEL]) {
-  if (openCodeGoCatalogCache && openCodeGoCatalogCache.expiresAt > Date.now()) {
-    return openCodeGoCatalogCache.catalog;
-  }
-  openCodeGoCatalogRequest ??= (async () => {
-    const response = await fetch(OPENCODE_MODELS_DEV_URL, { signal: AbortSignal.timeout(5e3) });
-    if (!response.ok) throw new Error(`Failed to load OpenCode Go models (${response.status})`);
-    const catalog = parseOpenCodeGoCatalog(await response.json());
-    if (!catalog) throw new Error("OpenCode Go model catalog is unavailable");
-    return catalog;
-  })();
   try {
-    const catalog = await openCodeGoCatalogRequest;
-    openCodeGoCatalogCache = { catalog, expiresAt: Date.now() + OPENCODE_GO_CATALOG_CACHE_MS };
-    return catalog;
+    const provider = (await fetchModelsDevCatalog())[OPENCODE_GO_PROVIDER];
+    if (!provider) throw new Error("OpenCode Go model catalog is unavailable");
+    const models = Object.fromEntries(
+      Object.entries(provider.models).filter(([, definition]) => definition.status !== "deprecated" && definition.status !== "alpha").map(([id, definition]) => [id, {
+        id: definition.id ?? id,
+        name: definition.name,
+        ...definition.description ? { description: definition.description } : {},
+        ...definition.status ? { status: definition.status } : {}
+      }])
+    );
+    if (Object.keys(models).length === 0) throw new Error("OpenCode Go model catalog is unavailable");
+    return { models, authoritative: true };
   } catch {
-    if (openCodeGoCatalogCache) return openCodeGoCatalogCache.catalog;
     return {
       authoritative: false,
       models: Object.fromEntries(fallbackModelIds.map((id) => [id, {
@@ -9518,8 +9518,6 @@ async function fetchOpenCodeGoCatalog(fallbackModelIds = [DEFAULT_OPENCODE_GO_MO
         name: id === DEFAULT_OPENCODE_GO_MODEL ? "GLM 5.2" : id
       }]))
     };
-  } finally {
-    openCodeGoCatalogRequest = void 0;
   }
 }
 
@@ -9578,9 +9576,9 @@ var OPENCODE_VARIANT_CANDIDATES_BY_THINKING_LEVEL = {
   ultra: ["max", "xhigh", "high"],
   ultracode: ["max", "xhigh", "high"]
 };
-var opencodeAuthSchema = z4.record(z4.string(), z4.object({
-  type: z4.string().optional(),
-  key: z4.string().optional()
+var opencodeAuthSchema = z3.record(z3.string(), z3.object({
+  type: z3.string().optional(),
+  key: z3.string().optional()
 }));
 async function hasOpencodeCredentials(provider) {
   if (!existsSync7(OPENCODE_AUTH_PATH)) return false;
@@ -10311,6 +10309,7 @@ var OpencodeManager = class extends CodingAgentManager {
     this.activeLinearForwarder.sendEvent(event);
   }
   recordOpencodePart(part) {
+    if (part.type === "step-finish") this.onUsageUpdate(part, (/* @__PURE__ */ new Date()).toISOString());
     this.recordHistoryEvent(`opencode-part-${part.type}`, { part }, this.historyFile);
     this.forwardOpencodePartToLinear(part);
   }
@@ -10565,6 +10564,7 @@ var PiManager = class extends CodingAgentManager {
     return null;
   }
   handleEvent(event) {
+    if (event.type === "message_end") this.onUsageUpdate(event, (/* @__PURE__ */ new Date()).toISOString());
     const payload = eventPayload(event);
     this.recordHistoryEvent(`pi-${event.type}`, payload, this.historyFile);
   }
@@ -10597,7 +10597,7 @@ var PiManager = class extends CodingAgentManager {
 
 // src/managers/relay-tools.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/managers/relay-providers.ts
 function isRelaySubagentProviderAllowed(provider, allowedProviders) {
@@ -10727,7 +10727,7 @@ async function getChatFinalResponse(chatId) {
   return extractFinalResponse(history) ?? "[No response from subagent]";
 }
 function buildSpawnAgentTool(parentChatId, availability = {}, getAllowedProviders = () => monolithService.getRelaySubagentProviders(), getProviderAvailability = () => availability) {
-  const providerEnum = z5.enum(VALID_RELAY_SUBAGENT_PROVIDERS);
+  const providerEnum = z4.enum(VALID_RELAY_SUBAGENT_PROVIDERS);
   return tool(
     "spawn_agent",
     `Spawn a new subagent to perform a task. The subagent runs in its own chat with a fresh context window.
@@ -10742,8 +10742,8 @@ The tool blocks until the subagent completes and returns its final response.
 You will also receive the chatId so you can send follow-up messages or clean up the chat.`,
     {
       provider: providerEnum.describe("Which agent to use. Choose from the providers listed as currently available in Relay guidance. Prefer an available code provider for code writing, claude for exploration/analysis, and relay for complex multi-step orchestration."),
-      prompt: z5.string().describe("The full prompt/instructions for the subagent. Be detailed - it has no context from your conversation."),
-      model: z5.string().optional().describe([
+      prompt: z4.string().describe("The full prompt/instructions for the subagent. Be detailed - it has no context from your conversation."),
+      model: z4.string().optional().describe([
         `Model override. Claude: ${AGENT_MODELS.claude.join(", ")} (opus is the default; sonnet is faster).`,
         `Codex: ${AGENT_MODELS.codex.join(", ")}.`,
         `Cursor: ${AGENT_MODELS.cursor.join(", ")}.`,
@@ -10753,11 +10753,11 @@ You will also receive the chatId so you can send follow-up messages or clean up
         `Opencode: ${AGENT_MODELS.opencode.join(", ")}.`,
         `Pi: ${AGENT_MODELS.pi.join(", ")}.`
       ].join(" ")),
-      thinking_level: z5.enum(VALID_THINKING_LEVELS).optional().describe(
+      thinking_level: z4.enum(VALID_THINKING_LEVELS).optional().describe(
         "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, xhigh = extended effort, max = maximum effort, ultra = Codex ultra, ultracode = Claude Code dynamic workflows. Defaults: Claude = high; Codex, Cursor, DeepSeek Harness, fx, Kimi Code, Opencode, and Pi = medium."
       ),
-      title: z5.string().optional().describe("Optional title for the subagent chat (for identification)."),
-      timeout_minutes: z5.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
+      title: z4.string().optional().describe("Optional title for the subagent chat (for identification)."),
+      timeout_minutes: z4.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
     },
     async (args) => {
       try {
@@ -10838,13 +10838,13 @@ var messageAgentTool = tool(
 
 The tool blocks until the subagent completes and returns its response.`,
   {
-    chatId: z5.string().describe("The chat ID of the subagent (returned by spawn_agent)."),
-    message: z5.string().describe("The follow-up message to send."),
-    model: z5.string().optional().describe("Optional model override for this message."),
-    thinking_level: z5.enum(VALID_THINKING_LEVELS).optional().describe(
+    chatId: z4.string().describe("The chat ID of the subagent (returned by spawn_agent)."),
+    message: z4.string().describe("The follow-up message to send."),
+    model: z4.string().optional().describe("Optional model override for this message."),
+    thinking_level: z4.enum(VALID_THINKING_LEVELS).optional().describe(
       "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, xhigh = extended effort, max = maximum effort, ultra = Codex ultra, ultracode = Claude Code dynamic workflows. Defaults: Claude = high, Codex = medium, Cursor = medium, Opencode = medium."
     ),
-    timeout_minutes: z5.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
+    timeout_minutes: z4.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
   },
   async (args) => {
     try {
@@ -10882,7 +10882,7 @@ var deleteAgentTool = tool(
   "delete_agent",
   `Delete a subagent chat to free resources. Use this after a subagent has completed its work and you no longer need to send it follow-up messages.`,
   {
-    chatId: z5.string().describe("The chat ID of the subagent to delete.")
+    chatId: z4.string().describe("The chat ID of the subagent to delete.")
   },
   async (args) => {
     try {
@@ -11248,6 +11248,17 @@ var RelayManager = class {
 };
 
 // src/analytics/agent/activity/agent-chat-activity-tracker-service.ts
+import { randomUUID as randomUUID8 } from "crypto";
+
+// src/analytics/analytics-upload.ts
+async function uploadAnalytics(endpoint, body) {
+  const response = await monolithRequest(endpoint, { body });
+  if (!response.ok) {
+    throw new Error(`Analytics upload failed: ${response.status} ${await response.text()}`);
+  }
+}
+
+// src/analytics/analytics-record-buffer.ts
 import {
   appendFile as appendFile3,
   mkdir as mkdir16,
@@ -11256,51 +11267,13 @@ import {
   rename as rename2,
   unlink as unlink3
 } from "fs/promises";
+import { existsSync as existsSync8, readFileSync as readFileSync7, readdirSync } from "fs";
 import { join as join24 } from "path";
-import { randomUUID as randomUUID8 } from "crypto";
-
-// src/analytics/agent/activity/skill-mcp-call-extractor.ts
-var NON_MCP_SERVERS = /* @__PURE__ */ new Set(["claude", "cursor", "deepseek", "fx", "kimi", "opencode", "pi", "custom", "dynamic"]);
-function mcpNameFromToolCall(message) {
-  const parsedName = parseMcpToolName(message.tool);
-  if (parsedName) return parsedName.server;
-  if (message.tool.startsWith("mcp.")) {
-    const [server, ...toolParts] = message.tool.slice("mcp.".length).split(".");
-    if (server && toolParts.length > 0) return server;
-  }
-  return NON_MCP_SERVERS.has(message.server) ? null : message.server;
-}
-function skillCallsFromCommand(message) {
-  const skillNames = message.skillNames ?? [];
-  return skillNames.map((skillName, index) => ({
-    kind: "skill",
-    id: skillNames.length === 1 ? message.id : `${message.id}-${index}`,
-    skillName,
-    occurredAt: message.timestamp
-  }));
-}
-function extractSkillMcpCalls(messages, provider) {
-  return messages.flatMap((message) => {
-    if (message.type === "skill") {
-      if (provider === "relay") return [];
-      return [{ kind: "skill", id: message.id, skillName: message.skillName, occurredAt: message.timestamp }];
-    }
-    if (message.type === "command") {
-      return skillCallsFromCommand(message);
-    }
-    if (message.type !== "tool_call") return [];
-    const mcpName = mcpNameFromToolCall(message);
-    return mcpName ? [{ kind: "mcp", id: message.id, mcpName, occurredAt: message.timestamp }] : [];
-  });
-}
-
-// src/analytics/agent/activity/agent-chat-activity-tracker-service.ts
 var MAX_FAILED_RECORDS = 500;
 var FLUSH_DEBOUNCE_MS = 15e3;
 var MAX_UPLOADED_SEGMENTS = 50;
 var UPLOADED_SUFFIX = ".uploaded";
-var MAX_TRACKED_MESSAGES = 500;
-var AgentChatActivityBuffer = class {
+var AnalyticsRecordBuffer = class {
   constructor(options) {
     this.options = options;
     this.storageNames = [
@@ -11318,26 +11291,39 @@ var AgentChatActivityBuffer = class {
   segmentFilePatterns;
   failedRecords = [];
   pendingAppends = /* @__PURE__ */ new Set();
+  recordIds = /* @__PURE__ */ new Set();
   flushTimer = null;
   activeFlush = Promise.resolve({
     flushed: 0,
     failed: 0
   });
-  append(record) {
-    const pending = mkdir16(ENGINE_DIR2, { recursive: true }).then(
-      () => appendFile3(this.liveFile, `${JSON.stringify(record)}
-`, "utf-8")
-    ).catch((error) => {
+  append(record, retry = false) {
+    const recordId = this.options.getRecordId?.(record);
+    if (!retry && recordId) {
+      if (this.recordIds.has(recordId)) return;
+      this.recordIds.add(recordId);
+    }
+    const pending = mkdir16(ENGINE_DIR2, { recursive: true }).then(() => appendFile3(this.liveFile, `${JSON.stringify(record)}
+`, "utf-8")).catch((error) => {
       console.error(
         `[${this.options.storageName}] Append failed, will retry on flush:`,
         error
       );
-      if (this.failedRecords.length < MAX_FAILED_RECORDS)
-        this.failedRecords.push(record);
+      if (this.failedRecords.length < MAX_FAILED_RECORDS) this.failedRecords.push(record);
     });
     this.pendingAppends.add(pending);
     void pending.finally(() => this.pendingAppends.delete(pending));
   }
+  readStoredRecords() {
+    if (!existsSync8(ENGINE_DIR2)) return [];
+    return readdirSync(ENGINE_DIR2, { withFileTypes: true }).filter((entry) => entry.isFile() && this.storageNames.some(
+      (storageName) => entry.name === `${storageName}.jsonl` || entry.name.startsWith(`${storageName}.`) && (entry.name.endsWith(".jsonl") || entry.name.endsWith(`.jsonl${UPLOADED_SUFFIX}`))
+    )).map(({ name }) => name).sort().flatMap((name) => this.parseRecords(readFileSync7(join24(ENGINE_DIR2, name), "utf-8"))).map((record) => {
+      const recordId = this.options.getRecordId?.(record);
+      if (recordId) this.recordIds.add(recordId);
+      return record;
+    });
+  }
   scheduleFlush() {
     if (this.flushTimer) return;
     this.flushTimer = setTimeout(() => {
@@ -11361,9 +11347,10 @@ var AgentChatActivityBuffer = class {
     return this.activeFlush;
   }
   async runFlush() {
-    for (const record of this.failedRecords.splice(0)) this.append(record);
-    while (this.pendingAppends.size > 0)
+    for (const record of this.failedRecords.splice(0)) this.append(record, true);
+    while (this.pendingAppends.size > 0) {
       await Promise.allSettled([...this.pendingAppends]);
+    }
     for (const storageName of this.storageNames) {
       await rename2(
         join24(ENGINE_DIR2, `${storageName}.jsonl`),
@@ -11375,8 +11362,7 @@ var AgentChatActivityBuffer = class {
     let flushed = 0;
     let failed = 0;
     for (const entry of entries) {
-      if (!this.segmentFilePatterns.some((pattern) => pattern.test(entry)))
-        continue;
+      if (!this.segmentFilePatterns.some((pattern) => pattern.test(entry))) continue;
       try {
         await this.uploadSegment(join24(ENGINE_DIR2, entry));
         flushed++;
@@ -11395,28 +11381,32 @@ var AgentChatActivityBuffer = class {
         flushed++;
       } catch (error) {
         failed++;
-        this.failedRecords.unshift(
-          ...failedRecords.slice(0, MAX_FAILED_RECORDS)
-        );
+        this.failedRecords.unshift(...failedRecords.slice(0, MAX_FAILED_RECORDS));
         console.error(
           `[${this.options.storageName}] Failed records upload failed, retained for retry:`,
           error
         );
       }
     }
-    const uploaded = entries.filter(
-      (entry) => this.storageNames.some(
+    if (!this.options.retainUploadedSegments) {
+      const uploaded = entries.filter((entry) => this.storageNames.some(
         (storageName) => entry.startsWith(`${storageName}.`)
-      ) && entry.endsWith(UPLOADED_SUFFIX)
-    ).sort();
-    for (const entry of uploaded.slice(0, -MAX_UPLOADED_SEGMENTS)) {
-      await unlink3(join24(ENGINE_DIR2, entry)).catch(() => {
-      });
+      ) && entry.endsWith(UPLOADED_SUFFIX)).sort();
+      for (const entry of uploaded.slice(0, -MAX_UPLOADED_SEGMENTS)) {
+        await unlink3(join24(ENGINE_DIR2, entry)).catch(() => {
+        });
+      }
     }
     return { flushed, failed };
   }
   async uploadSegment(filePath) {
-    const records = (await readFile14(filePath, "utf-8")).split("\n").flatMap((line) => {
+    const records = this.parseRecords(await readFile14(filePath, "utf-8"));
+    if (records.length > 0) await this.options.upload(records);
+    await rename2(filePath, `${filePath}${UPLOADED_SUFFIX}`).catch(() => {
+    });
+  }
+  parseRecords(contents) {
+    return contents.split("\n").flatMap((line) => {
       try {
         const parsed = JSON.parse(line);
         return this.options.validate(parsed) ? [parsed] : [];
@@ -11424,16 +11414,51 @@ var AgentChatActivityBuffer = class {
         return [];
       }
     });
-    if (records.length > 0) await this.options.upload(records);
-    await rename2(filePath, `${filePath}${UPLOADED_SUFFIX}`).catch(() => {
-    });
   }
 };
+
+// src/analytics/agent/activity/skill-mcp-call-extractor.ts
+var NON_MCP_SERVERS = /* @__PURE__ */ new Set(["claude", "cursor", "deepseek", "fx", "kimi", "opencode", "pi", "custom", "dynamic"]);
+function mcpNameFromToolCall(message) {
+  const parsedName = parseMcpToolName(message.tool);
+  if (parsedName) return parsedName.server;
+  if (message.tool.startsWith("mcp.")) {
+    const [server, ...toolParts] = message.tool.slice("mcp.".length).split(".");
+    if (server && toolParts.length > 0) return server;
+  }
+  return NON_MCP_SERVERS.has(message.server) ? null : message.server;
+}
+function skillCallsFromCommand(message) {
+  const skillNames = message.skillNames ?? [];
+  return skillNames.map((skillName, index) => ({
+    kind: "skill",
+    id: skillNames.length === 1 ? message.id : `${message.id}-${index}`,
+    skillName,
+    occurredAt: message.timestamp
+  }));
+}
+function extractSkillMcpCalls(messages, provider) {
+  return messages.flatMap((message) => {
+    if (message.type === "skill") {
+      if (provider === "relay") return [];
+      return [{ kind: "skill", id: message.id, skillName: message.skillName, occurredAt: message.timestamp }];
+    }
+    if (message.type === "command") {
+      return skillCallsFromCommand(message);
+    }
+    if (message.type !== "tool_call") return [];
+    const mcpName = mcpNameFromToolCall(message);
+    return mcpName ? [{ kind: "mcp", id: message.id, mcpName, occurredAt: message.timestamp }] : [];
+  });
+}
+
+// src/analytics/agent/activity/agent-chat-activity-tracker-service.ts
+var MAX_TRACKED_MESSAGES = 500;
 var AgentChatActivityRecordTracker = class {
   pendingRecords = /* @__PURE__ */ new Map();
   buffer;
   constructor(options) {
-    this.buffer = new AgentChatActivityBuffer(options);
+    this.buffer = new AnalyticsRecordBuffer(options);
   }
   track(chatId, record) {
     const records = this.pendingRecords.get(chatId) ?? [];
@@ -11456,17 +11481,20 @@ var AgentChatTurnActivityTracker = class {
   activeTurns = /* @__PURE__ */ new Map();
   turnBuffer;
   constructor(uploadTurns) {
-    this.turnBuffer = new AgentChatActivityBuffer({
+    this.turnBuffer = new AnalyticsRecordBuffer({
       storageName: "chat-turn-activity",
       legacyStorageNames: ["turn-usage"],
       validate: isAgentChatTurnActivityRecord,
-      upload: uploadTurns
+      upload: uploadTurns,
+      getRecordId: (turn) => turn.turnId
     });
   }
   noteMessageAccepted(messageId, request) {
     this.pendingMessages.set(messageId, {
       model: request.model,
-      senderUserId: request.senderUserId
+      senderUserId: request.senderUserId,
+      automationId: request.automationId,
+      environmentId: request.environmentId
     });
     for (const key of this.pendingMessages.keys()) {
       if (this.pendingMessages.size <= MAX_TRACKED_MESSAGES) break;
@@ -11477,16 +11505,23 @@ var AgentChatTurnActivityTracker = class {
     const attributes = this.pendingMessages.get(messageId) ?? {};
     const credential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[provider];
     this.pendingMessages.delete(messageId);
-    this.activeTurns.set(chatId, {
+    const context = {
+      chatId,
       turnId: randomUUID8(),
-      startedAtMs: Date.now(),
       provider,
       model: attributes.model ?? getDefaultAgentModel(provider),
       senderUserId: attributes.senderUserId,
+      automationId: attributes.automationId,
+      environmentId: attributes.environmentId,
       credentialMethod: credential?.method,
-      credentialScope: credential?.scope,
+      credentialScope: credential?.scope
+    };
+    this.activeTurns.set(chatId, {
+      ...context,
+      startedAtMs: Date.now(),
       seenCallIds: /* @__PURE__ */ new Set()
     });
+    return context;
   }
   getActiveTurn(chatId) {
     return this.activeTurns.get(chatId);
@@ -11515,39 +11550,32 @@ var AgentChatTurnActivityTracker = class {
     return this.turnBuffer.flush();
   }
 };
-async function uploadAgentChatActivity(endpoint, body) {
-  const response = await monolithRequest(endpoint, { body });
-  if (!response.ok)
-    throw new Error(
-      `upload failed: ${response.status} ${await response.text()}`
-    );
-}
 var AgentChatActivityTrackerService = class {
   turnActivityTracker;
   skillActivityTracker;
   mcpActivityTracker;
   constructor() {
     this.turnActivityTracker = new AgentChatTurnActivityTracker(
-      (turns) => uploadAgentChatActivity("/v1/engine/chat-turn-activity", { turns })
+      (turns) => uploadAnalytics("/v1/engine/chat-turn-activity", { turns })
     );
     this.skillActivityTracker = new AgentChatActivityRecordTracker({
       storageName: "skill-activity",
       legacyStorageNames: ["skill-usage"],
       validate: isAgentChatSkillActivityRecord,
-      upload: (skills) => uploadAgentChatActivity("/v1/engine/skill-activity", { skills })
+      upload: (skills) => uploadAnalytics("/v1/engine/skill-activity", { skills })
     });
     this.mcpActivityTracker = new AgentChatActivityRecordTracker({
       storageName: "mcp-activity",
       legacyStorageNames: ["mcp-usage"],
       validate: isAgentChatMcpActivityRecord,
-      upload: (mcps) => uploadAgentChatActivity("/v1/engine/mcp-activity", { mcps })
+      upload: (mcps) => uploadAnalytics("/v1/engine/mcp-activity", { mcps })
     });
   }
   noteMessageAccepted(messageId, request) {
     this.turnActivityTracker.noteMessageAccepted(messageId, request);
   }
   noteTurnStarted(chatId, messageId, provider) {
-    this.turnActivityTracker.noteTurnStarted(chatId, messageId, provider);
+    return this.turnActivityTracker.noteTurnStarted(chatId, messageId, provider);
   }
   noteSkillMcpCalls(chatId, messages) {
     const turn = this.turnActivityTracker.getActiveTurn(chatId);
@@ -11597,6 +11625,523 @@ var AgentChatActivityTrackerService = class {
   }
 };
 
+// src/analytics/token-usage/agent-token-usage-tracker.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/analytics/token-usage/types.ts
+function calculateCumulativeTokenUsageDelta(current, previous) {
+  if (!previous || current.inputTokens < previous.inputTokens || current.outputTokens < previous.outputTokens || current.cacheReadInputTokens < previous.cacheReadInputTokens || current.cacheWriteInputTokens < previous.cacheWriteInputTokens) return current;
+  return {
+    inputTokens: current.inputTokens - previous.inputTokens,
+    outputTokens: current.outputTokens - previous.outputTokens,
+    cacheReadInputTokens: current.cacheReadInputTokens - previous.cacheReadInputTokens,
+    cacheWriteInputTokens: current.cacheWriteInputTokens - previous.cacheWriteInputTokens
+  };
+}
+
+// src/analytics/token-usage/claude/parse.ts
+function isClaudeModelUsage(value) {
+  if (!isRecord(value) || !isTokenUsageCounts(value)) return false;
+  return (value.costUsd === void 0 || typeof value.costUsd === "number" && Number.isFinite(value.costUsd) && value.costUsd >= 0) && (value.pricingProvider === void 0 || isNonEmptyString(value.pricingProvider));
+}
+function parseClaudeResult(payload) {
+  if (!isRecord(payload) || payload.type !== "result") return null;
+  if (!isNonEmptyString(payload.session_id) || !isRecord(payload.modelUsage)) return null;
+  const snapshot = {};
+  for (const [rawModel, rawUsage] of Object.entries(payload.modelUsage)) {
+    if (!isNonEmptyString(rawModel) || !isRecord(rawUsage)) continue;
+    const usage = {
+      inputTokens: rawUsage.inputTokens,
+      outputTokens: rawUsage.outputTokens,
+      cacheReadInputTokens: rawUsage.cacheReadInputTokens,
+      cacheWriteInputTokens: rawUsage.cacheCreationInputTokens,
+      ...typeof rawUsage.costUSD === "number" && Number.isFinite(rawUsage.costUSD) && rawUsage.costUSD >= 0 ? { costUsd: rawUsage.costUSD } : {},
+      ...isNonEmptyString(rawUsage.provider) ? { pricingProvider: rawUsage.provider } : {}
+    };
+    if (!isClaudeModelUsage(usage)) continue;
+    const model = isNonEmptyString(rawUsage.canonicalModel) ? rawUsage.canonicalModel : rawModel.replace(/-\d{8}$/, "");
+    const previous = snapshot[model];
+    snapshot[model] = previous ? {
+      inputTokens: previous.inputTokens + usage.inputTokens,
+      outputTokens: previous.outputTokens + usage.outputTokens,
+      cacheReadInputTokens: previous.cacheReadInputTokens + usage.cacheReadInputTokens,
+      cacheWriteInputTokens: previous.cacheWriteInputTokens + usage.cacheWriteInputTokens,
+      ...previous.costUsd !== void 0 || usage.costUsd !== void 0 ? { costUsd: (previous.costUsd ?? 0) + (usage.costUsd ?? 0) } : {},
+      ...usage.pricingProvider ?? previous.pricingProvider ? { pricingProvider: usage.pricingProvider ?? previous.pricingProvider } : {}
+    } : usage;
+  }
+  if (Object.keys(snapshot).length === 0) return null;
+  return {
+    sessionId: payload.session_id,
+    snapshot
+  };
+}
+
+// src/analytics/token-usage/claude/index.ts
+function isClaudeTokenUsageCheckpoint(value) {
+  return isRecord(value) && isNonEmptyString(value.chatId) && isNonEmptyString(value.sessionId) && isRecord(value.snapshot) && Object.values(value.snapshot).every(isClaudeModelUsage);
+}
+function normalizeClaudeTokenUsage(result, previous, context, occurredAt) {
+  return Object.entries(result.snapshot).flatMap(([model, currentMetrics]) => {
+    const previousMetrics = previous?.[model];
+    const tokenCounts = calculateCumulativeTokenUsageDelta(currentMetrics, previousMetrics);
+    const providerCostUsd = currentMetrics.costUsd === void 0 ? void 0 : previousMetrics?.costUsd === void 0 || currentMetrics.costUsd < previousMetrics.costUsd ? currentMetrics.costUsd : currentMetrics.costUsd - previousMetrics.costUsd;
+    const pricingProvider = currentMetrics.pricingProvider ?? previousMetrics?.pricingProvider;
+    return Object.values(tokenCounts).some((count) => count > 0) ? [{
+      ...context,
+      model,
+      ...tokenCounts,
+      harness: AGENT.CLAUDE,
+      occurredAt,
+      ...pricingProvider ? { pricingProvider } : {},
+      ...providerCostUsd !== void 0 ? { reportedCostUsd: providerCostUsd } : {}
+    }] : [];
+  });
+}
+var ClaudeTokenUsageService = class {
+  snapshots = /* @__PURE__ */ new Map();
+  record(event) {
+    if (event.type !== "usage-updated") return void 0;
+    const result = parseClaudeResult(event.payload);
+    if (!result) return void 0;
+    const snapshotsBySession = this.snapshots.get(event.chatId) ?? /* @__PURE__ */ new Map();
+    this.snapshots.set(event.chatId, snapshotsBySession);
+    const previous = snapshotsBySession.get(result.sessionId);
+    const records = normalizeClaudeTokenUsage(
+      result,
+      previous,
+      event.context,
+      event.occurredAt
+    );
+    snapshotsBySession.set(result.sessionId, result.snapshot);
+    return {
+      records,
+      checkpoint: {
+        chatId: event.chatId,
+        sessionId: result.sessionId,
+        snapshot: result.snapshot
+      }
+    };
+  }
+  restoreCheckpoint(value) {
+    if (!isClaudeTokenUsageCheckpoint(value)) return;
+    const snapshotsBySession = this.snapshots.get(value.chatId) ?? /* @__PURE__ */ new Map();
+    snapshotsBySession.set(value.sessionId, value.snapshot);
+    this.snapshots.set(value.chatId, snapshotsBySession);
+  }
+};
+
+// src/analytics/token-usage/codex/parse.ts
+function isTokenCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function parseCodexTurn(value) {
+  if (!isRecord(value) || !isNonEmptyString(value.threadId) || !isNonEmptyString(value.turnId)) return void 0;
+  return { threadId: value.threadId, turnId: value.turnId };
+}
+function parseCodexUsage(value) {
+  if (!isRecord(value) || !isTokenCount(value.inputTokens) || !isTokenCount(value.cachedInputTokens) || !isTokenCount(value.outputTokens)) {
+    return void 0;
+  }
+  const cacheWriteInputTokens = value.cacheWriteInputTokens;
+  if (cacheWriteInputTokens !== void 0 && !isTokenCount(cacheWriteInputTokens)) return void 0;
+  return {
+    inputTokens: value.inputTokens,
+    cachedInputTokens: value.cachedInputTokens,
+    outputTokens: value.outputTokens,
+    ...cacheWriteInputTokens === void 0 ? {} : { cacheWriteInputTokens }
+  };
+}
+function parseCodexUsageUpdate(value) {
+  if (!isRecord(value)) return void 0;
+  const turn = parseCodexTurn(value);
+  const usage = isRecord(value.tokenUsage) ? parseCodexUsage(value.tokenUsage.last) : void 0;
+  if (!turn || !usage) return void 0;
+  return { ...turn, usage };
+}
+function parseCodexModelReroute(value) {
+  if (!isRecord(value) || !isNonEmptyString(value.toModel)) return void 0;
+  const turn = parseCodexTurn(value);
+  return turn ? { ...turn, model: value.toModel } : void 0;
+}
+
+// src/analytics/token-usage/codex/index.ts
+var CodexTokenUsageAdapter = class {
+  constructor(chatId, getContext, recordEvent) {
+    this.chatId = chatId;
+    this.getContext = getContext;
+    this.recordEvent = recordEvent;
+  }
+  chatId;
+  getContext;
+  recordEvent;
+  onTurnStarted = (threadId, turnId) => {
+    const context = this.getContext();
+    if (!context) return;
+    this.recordEvent({
+      harness: AGENT.CODEX,
+      type: "turn-started",
+      chatId: this.chatId,
+      payload: { threadId, turnId },
+      context
+    });
+  };
+  onTokenUsage = (notification, occurredAt) => {
+    const context = this.getContext();
+    if (!context) return;
+    this.recordEvent({
+      harness: AGENT.CODEX,
+      type: "usage-updated",
+      chatId: this.chatId,
+      payload: notification,
+      context,
+      occurredAt
+    });
+  };
+  onModelRerouted = (notification) => {
+    if (!this.getContext()) return;
+    this.recordEvent({
+      harness: AGENT.CODEX,
+      type: "model-rerouted",
+      chatId: this.chatId,
+      payload: notification
+    });
+  };
+  onTurnCompleted = (threadId, turnId) => {
+    this.recordEvent({
+      harness: AGENT.CODEX,
+      type: "turn-completed",
+      chatId: this.chatId,
+      payload: { threadId, turnId }
+    });
+  };
+};
+function getTurnKey({ threadId, turnId }) {
+  return `${threadId}\0${turnId}`;
+}
+var CodexTokenUsageService = class {
+  turns = /* @__PURE__ */ new Map();
+  record(event) {
+    switch (event.type) {
+      case "turn-started": {
+        const turn = parseCodexTurn(event.payload);
+        if (!turn) return void 0;
+        const key = getTurnKey(turn);
+        if (!this.turns.has(key)) {
+          this.turns.set(key, { ...turn, context: event.context });
+        }
+        return void 0;
+      }
+      case "usage-updated": {
+        const update = parseCodexUsageUpdate(event.payload);
+        if (!update) return void 0;
+        const key = getTurnKey(update);
+        const turn = this.turns.get(key) ?? {
+          ...update,
+          context: event.context
+        };
+        turn.latestUsage = update.usage;
+        turn.occurredAt = event.occurredAt;
+        this.turns.set(key, turn);
+        return void 0;
+      }
+      case "model-rerouted": {
+        const reroute = parseCodexModelReroute(event.payload);
+        if (!reroute) return void 0;
+        const tracked = this.turns.get(getTurnKey(reroute));
+        if (tracked) tracked.context = { ...tracked.context, model: reroute.model };
+        return void 0;
+      }
+      case "turn-completed": {
+        const turn = parseCodexTurn(event.payload);
+        return turn ? this.finishTurn(event.chatId, turn) : void 0;
+      }
+      case "chat-ended": {
+        const records = [];
+        for (const turn of this.turns.values()) {
+          if (turn.context.chatId !== event.chatId) continue;
+          const batch = this.finishTurn(event.chatId, turn);
+          if (batch) records.push(...batch.records);
+        }
+        return records.length > 0 ? { records } : void 0;
+      }
+    }
+  }
+  finishTurn(chatId, turn) {
+    const key = getTurnKey(turn);
+    const tracked = this.turns.get(key);
+    if (!tracked || tracked.context.chatId !== chatId) return void 0;
+    this.turns.delete(key);
+    if (!tracked.latestUsage || !tracked.occurredAt) return void 0;
+    const cacheWriteInputTokens = tracked.latestUsage.cacheWriteInputTokens ?? 0;
+    return {
+      records: [{
+        ...tracked.context,
+        harness: AGENT.CODEX,
+        inputTokens: Math.max(
+          0,
+          tracked.latestUsage.inputTokens - tracked.latestUsage.cachedInputTokens - cacheWriteInputTokens
+        ),
+        outputTokens: tracked.latestUsage.outputTokens,
+        cacheReadInputTokens: tracked.latestUsage.cachedInputTokens,
+        cacheWriteInputTokens,
+        occurredAt: tracked.occurredAt
+      }]
+    };
+  }
+};
+
+// src/analytics/token-usage/cursor/index.ts
+function parseCursorTokenUsage(payload) {
+  if (!isRecord(payload) || payload.type !== "turn-ended" || !isRecord(payload.usage)) return void 0;
+  const usage = {
+    inputTokens: payload.usage.inputTokens,
+    outputTokens: payload.usage.outputTokens,
+    cacheReadInputTokens: payload.usage.cacheReadTokens,
+    cacheWriteInputTokens: payload.usage.cacheWriteTokens
+  };
+  return isTokenUsageCounts(usage) ? usage : void 0;
+}
+var CursorTokenUsageService = class {
+  turns = /* @__PURE__ */ new Map();
+  record(event) {
+    if (event.type === "usage-updated") {
+      const usage = parseCursorTokenUsage(event.payload);
+      if (!usage) return void 0;
+      const turnId2 = event.turnId ?? event.chatId;
+      this.turns.set(`${event.chatId}\0${turnId2}`, {
+        context: event.context,
+        usage,
+        occurredAt: event.occurredAt
+      });
+      return void 0;
+    }
+    if (event.type !== "chat-ended") return void 0;
+    const turnId = event.turnId ?? event.chatId;
+    const key = `${event.chatId}\0${turnId}`;
+    const turn = this.turns.get(key);
+    if (!turn) return void 0;
+    this.turns.delete(key);
+    const record = {
+      ...turn.context,
+      harness: AGENT.CURSOR,
+      ...turn.usage,
+      occurredAt: turn.occurredAt
+    };
+    return { records: [record] };
+  }
+};
+
+// src/analytics/token-usage/deepseek/index.ts
+function parseDeepseekTokenUsage(payload) {
+  if (!isRecord(payload)) return void 0;
+  const source = isRecord(payload.totals) ? payload.totals : payload;
+  const snapshot = {
+    inputTokens: source.uncachedInputTokens,
+    outputTokens: source.outputTokens,
+    cacheReadInputTokens: source.cacheReadTokens,
+    cacheWriteInputTokens: source.cacheWriteTokens
+  };
+  return isTokenUsageCounts(snapshot) ? snapshot : void 0;
+}
+var DeepseekTokenUsageService = class {
+  snapshots = /* @__PURE__ */ new Map();
+  record(event) {
+    if (event.type !== "usage-updated") return void 0;
+    const current = parseDeepseekTokenUsage(event.payload);
+    if (!current) return void 0;
+    const previous = this.snapshots.get(event.chatId);
+    this.snapshots.set(event.chatId, current);
+    const usage = calculateCumulativeTokenUsageDelta(current, previous);
+    const records = Object.values(usage).some((count) => count > 0) ? [{ ...event.context, harness: AGENT.DEEPSEEK, ...usage, occurredAt: event.occurredAt }] : [];
+    return {
+      records,
+      checkpoint: { chatId: event.chatId, snapshot: current }
+    };
+  }
+  restoreCheckpoint(value) {
+    if (!isRecord(value) || !isNonEmptyString(value.chatId) || !isTokenUsageCounts(value.snapshot)) return;
+    this.snapshots.set(value.chatId, value.snapshot);
+  }
+};
+
+// src/analytics/token-usage/opencode/index.ts
+function parseOpencodeTokenUsage(payload) {
+  if (!isRecord(payload) || payload.type !== "step-finish" || !isRecord(payload.tokens) || !isRecord(payload.tokens.cache)) return void 0;
+  const usage = {
+    inputTokens: payload.tokens.input,
+    outputTokens: payload.tokens.output,
+    cacheReadInputTokens: payload.tokens.cache.read,
+    cacheWriteInputTokens: payload.tokens.cache.write
+  };
+  return isTokenUsageCounts(usage) ? usage : void 0;
+}
+var OpencodeTokenUsageService = class {
+  record(event) {
+    if (event.type !== "usage-updated") return void 0;
+    const usage = parseOpencodeTokenUsage(event.payload);
+    if (!usage) return void 0;
+    const record = {
+      ...event.context,
+      harness: AGENT.OPENCODE,
+      ...usage,
+      occurredAt: event.occurredAt
+    };
+    return { records: [record] };
+  }
+};
+
+// src/analytics/token-usage/pi/index.ts
+function parsePiTokenUsage(payload) {
+  if (!isRecord(payload) || payload.type !== "message_end" || !isRecord(payload.message) || payload.message.role !== "assistant" || !isRecord(payload.message.usage)) return void 0;
+  const usage = {
+    inputTokens: payload.message.usage.input,
+    outputTokens: payload.message.usage.output,
+    cacheReadInputTokens: payload.message.usage.cacheRead,
+    cacheWriteInputTokens: payload.message.usage.cacheWrite
+  };
+  if (!isTokenUsageCounts(usage)) return void 0;
+  const model = isNonEmptyString(payload.message.responseModel) ? payload.message.responseModel : isNonEmptyString(payload.message.model) ? payload.message.model : void 0;
+  return { model, usage };
+}
+var PiTokenUsageService = class {
+  record(event) {
+    if (event.type !== "usage-updated") return void 0;
+    const result = parsePiTokenUsage(event.payload);
+    if (!result) return void 0;
+    const record = {
+      ...event.context,
+      harness: AGENT.PI,
+      model: result.model ?? event.context.model,
+      ...result.usage,
+      occurredAt: event.occurredAt
+    };
+    return { records: [record] };
+  }
+};
+
+// src/analytics/token-usage/agent-token-usage-factory.ts
+function createAgentTokenUsageService(harness) {
+  switch (harness) {
+    case AGENT.CLAUDE:
+      return new ClaudeTokenUsageService();
+    case AGENT.CODEX:
+      return new CodexTokenUsageService();
+    case AGENT.CURSOR:
+      return new CursorTokenUsageService();
+    case AGENT.DEEPSEEK:
+      return new DeepseekTokenUsageService();
+    case AGENT.OPENCODE:
+      return new OpencodeTokenUsageService();
+    case AGENT.PI:
+      return new PiTokenUsageService();
+    default:
+      return void 0;
+  }
+}
+
+// src/analytics/token-usage/agent-token-usage-tracker.ts
+var AgentTokenUsageTracker = class {
+  activeTurns = /* @__PURE__ */ new Map();
+  services = /* @__PURE__ */ new Map();
+  buffer;
+  constructor(uploadAnalytics2) {
+    this.buffer = new AnalyticsRecordBuffer({
+      storageName: "chat-token-usage",
+      validate: (value) => isRecord(value) && isNonEmptyString(value.harness) && Array.isArray(value.records) && value.records.every(isTokenUsageUploadRecord),
+      upload: (batches) => uploadAnalytics2(TOKEN_USAGE_PATH, {
+        records: batches.flatMap(({ records }) => records)
+      }),
+      getRecordId: ({ harness, records }) => {
+        const eventIds = records.flatMap((record) => record.eventId ? [record.eventId] : []);
+        if (eventIds.length === 0 || eventIds.length !== records.length) return void 0;
+        return [harness, ...eventIds].join("\0");
+      },
+      retainUploadedSegments: true
+    });
+    for (const batch of this.buffer.readStoredRecords()) {
+      if (batch.checkpoint !== void 0) {
+        this.getService(batch.harness)?.restoreCheckpoint?.(batch.checkpoint);
+      }
+    }
+  }
+  startTurn(context) {
+    this.activeTurns.set(context.chatId, context);
+  }
+  getTokenUsageContext(chatId) {
+    const context = this.activeTurns.get(chatId);
+    if (!context?.environmentId) return void 0;
+    return {
+      chatId: context.chatId,
+      model: context.model,
+      credentialMethod: context.credentialMethod,
+      credentialScope: context.credentialScope,
+      senderUserId: context.senderUserId,
+      automationId: context.automationId,
+      environmentId: context.environmentId
+    };
+  }
+  noteAgentEvent(chatId, event) {
+    if (event.type !== "claude-result") return;
+    this.noteUsage(chatId, event.payload, event.timestamp);
+  }
+  noteUsage(chatId, payload, occurredAt) {
+    const context = this.activeTurns.get(chatId);
+    const tokenUsageContext = this.getTokenUsageContext(chatId);
+    if (!context || !tokenUsageContext) return;
+    this.recordEvent({
+      harness: context.provider,
+      type: "usage-updated",
+      chatId,
+      turnId: context.turnId,
+      payload,
+      context: tokenUsageContext,
+      occurredAt
+    });
+  }
+  endTurn(chatId) {
+    const context = this.activeTurns.get(chatId);
+    if (!context) return;
+    this.recordEvent({
+      harness: context.provider,
+      type: "chat-ended",
+      chatId,
+      turnId: context.turnId
+    });
+    this.activeTurns.delete(chatId);
+  }
+  flush(finalizeInFlight = true) {
+    if (finalizeInFlight) {
+      for (const chatId of [...this.activeTurns.keys()]) this.endTurn(chatId);
+    }
+    return this.buffer.flush();
+  }
+  recordEvent(event) {
+    const batch = this.getService(event.harness)?.record(event);
+    if (!batch) return;
+    this.buffer.append({
+      harness: event.harness,
+      records: batch.records.map((record) => ({
+        ...record,
+        eventId: record.eventId ?? createUuidFromHex(createHash2("sha256").update(JSON.stringify([
+          event.harness,
+          event.type,
+          event.chatId,
+          event.turnId ?? "",
+          record
+        ])).digest("hex"))
+      })),
+      checkpoint: batch.checkpoint
+    });
+    this.buffer.scheduleFlush();
+  }
+  getService(harness) {
+    const service = this.services.get(harness) ?? createAgentTokenUsageService(harness);
+    if (service) this.services.set(harness, service);
+    return service;
+  }
+};
+
 // src/services/keep-alive-service.ts
 var KeepAliveService = class _KeepAliveService {
   interval = null;
@@ -11872,7 +12417,7 @@ async function reconcileCanvasItems(filenames) {
 
 // src/services/upload-chat-transcripts.ts
 import { createReadStream } from "fs";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { readFile as readFile16, readdir as readdir8, stat as stat4 } from "fs/promises";
 import { basename as basename2, join as join27 } from "path";
 
@@ -11943,7 +12488,7 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
     deletedAt: chat.deletedAt ?? null
   } : {};
   if (capture) {
-    const hash = createHash2("sha256");
+    const hash = createHash3("sha256");
     for await (const chunk of createReadStream(filePath)) hash.update(chunk);
     metadata.captureId = capture.captureId;
     metadata.captureReason = capture.reason;
@@ -12164,7 +12709,7 @@ function isCodexAvailable() {
   return detectCodexAuthMethod() !== "none";
 }
 function isOpencodeAvailable() {
-  return existsSync8(OPENCODE_AUTH_PATH);
+  return existsSync9(OPENCODE_AUTH_PATH);
 }
 function isDeepseekAvailable() {
   return Boolean(getDeepseekApiKey());
@@ -12176,7 +12721,7 @@ function isKimiAvailable() {
   return Boolean(ENGINE_ENV.AI_GATEWAY_API_KEY);
 }
 function isPiAvailable() {
-  return existsSync8(PI_AUTH_PATH);
+  return existsSync9(PI_AUTH_PATH);
 }
 function isCursorAvailable() {
   return Boolean(ENGINE_ENV.CURSOR_API_KEY);
@@ -12300,15 +12845,17 @@ function corruptChatsFilePath() {
   return `${CHATS_FILE}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
 }
 var ChatService = class {
-  constructor(workingDirectory, agentChatActivityTrackerService2) {
+  constructor(workingDirectory, agentChatActivityTrackerService2, agentTokenUsageTracker2) {
     this.workingDirectory = workingDirectory;
     this.agentChatActivityTrackerService = agentChatActivityTrackerService2;
+    this.agentTokenUsageTracker = agentTokenUsageTracker2;
     keepAliveService.setActivityCheck(
       () => [...this.chats.values()].some((chat) => !chat.persisted.deletedAt && hasActiveAgentWork(chat))
     );
   }
   workingDirectory;
   agentChatActivityTrackerService;
+  agentTokenUsageTracker;
   chats = /* @__PURE__ */ new Map();
   persistPromise = null;
   persistQueued = false;
@@ -12528,7 +13075,7 @@ var ChatService = class {
   async interrupt(chatId) {
     const chat = this.requireChat(chatId);
     const result = await chat.provider.interrupt();
-    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
+    this.endTrackedTurn(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     chat.pendingMessageIds = [];
@@ -12550,7 +13097,7 @@ var ChatService = class {
       return { interrupted: false, queue: [], goal: null };
     }
     const interruptResult = await chat.provider.interrupt();
-    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
+    this.endTrackedTurn(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     chat.pendingMessageIds = [];
@@ -12677,7 +13224,7 @@ var ChatService = class {
       messageId,
       ...chat.pendingMessageIds.filter((pendingMessageId) => pendingMessageId !== messageId && pendingMessageId !== interruptedMessageId)
     ];
-    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
+    this.endTrackedTurn(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     if (interruptedMessageId) {
@@ -12830,12 +13377,15 @@ var ChatService = class {
     const chatsById = new Map(
       [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toSummary(chat)])
     );
-    const [chatTranscripts, canvas, repoState, engineLogs, chatActivity] = await Promise.all([
+    const [chatTranscripts, canvas, repoState, engineLogs, [chatActivity]] = await Promise.all([
       flushAllChatTranscripts(chatsById, capture),
       flushAllCanvasItems(),
       flushRepoState(),
       flushAllEngineLogs(),
-      this.agentChatActivityTrackerService.flush()
+      Promise.all([
+        this.agentChatActivityTrackerService.flush(),
+        this.agentTokenUsageTracker.flush()
+      ])
     ]);
     return {
       chatTranscripts,
@@ -12865,6 +13415,9 @@ var ChatService = class {
     const onProviderEvent = (event) => {
       this.handleTurnEvent(persisted.id, event);
     };
+    const onProviderUsage = (payload, occurredAt) => {
+      this.agentTokenUsageTracker.noteUsage(persisted.id, payload, occurredAt);
+    };
     const onMessageStarted = (message) => this.handleTurnStarted(persisted.id, message);
     const onProcessingChanged = (processing) => {
       if (processing) return;
@@ -12923,7 +13476,8 @@ var ChatService = class {
         onTurnComplete: onProviderTurnComplete,
         onEvent: onProviderEvent,
         onProcessingChanged,
-        onMessageStarted
+        onMessageStarted,
+        onUsageUpdate: onProviderUsage
       });
     } else if (persisted.provider === "deepseek") {
       provider = new DeepseekManager({
@@ -12934,7 +13488,8 @@ var ChatService = class {
         onTurnComplete: onProviderTurnComplete,
         onEvent: onProviderEvent,
         onProcessingChanged,
-        onMessageStarted
+        onMessageStarted,
+        onUsageUpdate: onProviderUsage
       });
     } else if (persisted.provider === "fx") {
       provider = new FxManager({
@@ -12967,7 +13522,8 @@ var ChatService = class {
         onTurnComplete: onProviderTurnComplete,
         onEvent: onProviderEvent,
         onProcessingChanged,
-        onMessageStarted
+        onMessageStarted,
+        onUsageUpdate: onProviderUsage
       });
     } else if (persisted.provider === "pi") {
       provider = new PiManager({
@@ -12978,9 +13534,15 @@ var ChatService = class {
         onTurnComplete: onProviderTurnComplete,
         onEvent: onProviderEvent,
         onProcessingChanged,
-        onMessageStarted
+        onMessageStarted,
+        onUsageUpdate: onProviderUsage
       });
     } else {
+      const codexTokenUsage = new CodexTokenUsageAdapter(
+        persisted.id,
+        () => this.agentTokenUsageTracker.getTokenUsageContext(persisted.id),
+        (event) => this.agentTokenUsageTracker.recordEvent(event)
+      );
       provider = new CodexAspManager({
         workingDirectory: this.workingDirectory,
         historyFilePath: join29(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
@@ -12989,7 +13551,11 @@ var ChatService = class {
         onTurnComplete: onProviderTurnComplete,
         onEvent: onProviderEvent,
         onProcessingChanged,
-        onMessageStarted
+        onMessageStarted,
+        onCodexTurnStarted: codexTokenUsage.onTurnStarted,
+        onCodexTokenUsage: codexTokenUsage.onTokenUsage,
+        onCodexModelRerouted: codexTokenUsage.onModelRerouted,
+        onCodexTurnCompleted: codexTokenUsage.onTurnCompleted
       });
     }
     return {
@@ -13039,25 +13605,29 @@ var ChatService = class {
     }
     return chat;
   }
+  activateTurn(chat, messageId) {
+    chat.hasActiveTurn = true;
+    chat.activeMessageId = messageId;
+    const context = this.agentChatActivityTrackerService.noteTurnStarted(
+      chat.persisted.id,
+      messageId,
+      chat.persisted.provider
+    );
+    this.agentTokenUsageTracker.startTurn(context);
+    chat.activeErrorNotificationTarget = chat.errorNotificationTargets.get(messageId) ?? null;
+    chat.errorNotificationTargets.delete(messageId);
+  }
   async handleTurnStarted(chatId, message) {
     const chat = this.getRuntimeChat(chatId);
     if (!chat) return;
     chat.pendingMessageIds = chat.pendingMessageIds.filter((messageId) => messageId !== message.id);
-    chat.hasActiveTurn = true;
-    chat.activeMessageId = message.id;
     const { event: acceptedEvent, sender } = createTurnMetadata(
       message,
       message.id,
       message.queuedAt
     );
     chat.acceptedUserEvents.set(message.id, acceptedEvent);
-    this.agentChatActivityTrackerService.noteTurnStarted(
-      chat.persisted.id,
-      message.id,
-      chat.persisted.provider
-    );
-    chat.activeErrorNotificationTarget = chat.errorNotificationTargets.get(message.id) ?? null;
-    chat.errorNotificationTargets.delete(message.id);
+    this.activateTurn(chat, message.id);
     await this.publish({
       type: "chat.turn.started",
       payload: {
@@ -13074,6 +13644,22 @@ var ChatService = class {
       return;
     }
     keepAliveService.noteActivity();
+    if (!chat.hasActiveTurn && chat.pendingMessageIds.length > 0) {
+      const messageId = chat.pendingMessageIds.shift();
+      if (!messageId) {
+        return;
+      }
+      this.activateTurn(chat, messageId);
+      this.publish({
+        type: "chat.turn.started",
+        payload: {
+          chatId: chat.persisted.id,
+          messageId
+        }
+      }).catch(() => {
+      });
+    }
+    this.agentTokenUsageTracker.noteAgentEvent(chatId, event);
     const codexTranscript = getCodexTranscriptFromEvent(event);
     if (chat.hasActiveTurn) {
       const displayMessages = codexTranscript ? parseLatestCodexAspTranscriptTurn(codexTranscript) : parseDisplayMessages([event], chat.persisted.provider, null, {
@@ -13134,6 +13720,10 @@ var ChatService = class {
       });
     }
   }
+  endTrackedTurn(chatId) {
+    this.agentTokenUsageTracker.endTurn(chatId);
+    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
+  }
   async handleTurnFinished(chatId) {
     const chat = this.getRuntimeChat(chatId);
     if (!chat) {
@@ -13146,7 +13736,7 @@ var ChatService = class {
     }
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
-    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
+    this.endTrackedTurn(chatId);
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
     const processing = chat.provider.getQueue().length > 0 || (chat.provider.hasActiveBackgroundTasks?.() ?? false);
     this.publish({
@@ -13584,14 +14174,14 @@ var RepoFileService = class {
 
 // src/v1-routes.ts
 import { Hono } from "hono";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 import { readdir as readdir11, stat as stat7, readFile as readFile21 } from "fs/promises";
 import { join as join33, resolve as resolve3 } from "path";
 
 // src/services/warm-hooks-service.ts
 import { spawn as spawn6 } from "child_process";
 import { readFile as readFile20 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join32 } from "path";
 
 // src/services/warm-hook-logs-service.ts
@@ -13713,7 +14303,7 @@ var warmHookLogsService = new WarmHookLogsService();
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
     const configPath = join32(repoPath, filename);
-    if (!existsSync9(configPath)) {
+    if (!existsSync10(configPath)) {
       continue;
     }
     try {
@@ -13974,7 +14564,7 @@ ${combinedScript}` : combinedScript;
 
 // src/services/terminal-service.ts
 import { randomUUID as randomUUID10 } from "crypto";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { spawn as spawn7 } from "node-pty";
 var MAX_REPLAY_CHARS = 1024 * 1024;
 var MAX_TERMINAL_SESSIONS = 8;
@@ -13993,7 +14583,7 @@ var TerminalService = class {
       });
     }
     const id = randomUUID10();
-    const shell = process.env.SHELL && existsSync10(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
+    const shell = process.env.SHELL && existsSync11(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
     const pty = spawn7(shell, ["-l"], {
       name: "xterm-256color",
       cols,
@@ -14092,72 +14682,26 @@ var TerminalService = class {
 var terminalService = new TerminalService();
 
 // src/v1-routes.ts
-var imageMediaTypeSchema = z6.enum(IMAGE_MEDIA_TYPES);
-var createPreviewSchema = z6.object({
-  port: z6.number().int().min(1).max(65535),
-  publicUrl: z6.string().min(1)
-});
-var terminalSizeSchema = z6.object({
-  cols: z6.number().int().min(2).max(500),
-  rows: z6.number().int().min(1).max(200)
+var createPreviewSchema = z5.object({
+  port: z5.number().int().min(1).max(65535),
+  publicUrl: z5.string().min(1)
 });
-var writeTerminalSessionSchema = z6.object({
-  data: z6.string().max(64 * 1024),
-  generation: z6.number().int().nonnegative(),
-  sequence: z6.number().int().nonnegative()
+var terminalSizeSchema = z5.object({
+  cols: z5.number().int().min(2).max(500),
+  rows: z5.number().int().min(1).max(200)
 });
-var sendMessageSchema = z6.object({
-  messageId: z6.string().min(1).optional(),
-  submittedAt: z6.string().datetime().optional(),
-  message: z6.string().min(1),
-  model: z6.string().optional(),
-  customInstructions: z6.string().optional(),
-  planMode: z6.boolean().optional(),
-  images: z6.array(z6.object({
-    type: z6.literal("image"),
-    source: z6.union([
-      z6.object({
-        type: z6.literal("base64"),
-        media_type: imageMediaTypeSchema,
-        data: z6.string().min(1)
-      }),
-      z6.object({
-        type: z6.literal("url"),
-        url: z6.string().url()
-      })
-    ])
-  })).optional(),
-  thinkingLevel: z6.enum(VALID_THINKING_LEVELS).optional(),
-  goalMode: z6.boolean().optional(),
-  fastMode: z6.boolean().optional(),
-  enableInteractiveTools: z6.boolean().optional(),
-  type: z6.string().min(1).optional(),
-  merge: z6.boolean().optional(),
-  idempotencyKey: z6.string().min(1).max(128).optional(),
-  senderUserId: z6.string().optional(),
-  senderEmail: z6.string().optional(),
-  senderDisplayName: z6.string().optional(),
-  senderAvatarUrl: z6.string().optional(),
-  errorNotificationTarget: z6.discriminatedUnion("type", [
-    z6.object({ type: z6.literal("slack") }),
-    z6.object({ type: z6.literal("linear"), sessionId: z6.string().min(1) }),
-    z6.object({
-      type: z6.literal("code_host"),
-      provider: z6.enum(["github", "gitlab"]),
-      resource: z6.enum(["issue", "pull_request"]),
-      repositoryId: z6.string().min(1),
-      resourceNumber: z6.number().int().positive()
-    }),
-    z6.object({ type: z6.literal("automation"), executionId: z6.string().min(1) })
-  ]).optional()
+var writeTerminalSessionSchema = z5.object({
+  data: z5.string().max(64 * 1024),
+  generation: z5.number().int().nonnegative(),
+  sequence: z5.number().int().nonnegative()
 });
-var respondToolInputSchema = z6.object({
-  requestId: z6.string().min(1),
-  selectionId: z6.string().min(1)
+var respondToolInputSchema = z5.object({
+  requestId: z5.string().min(1),
+  selectionId: z5.string().min(1)
 });
-var updateGoalSchema = z6.object({
-  objective: z6.string().trim().min(1).max(MAX_CODEX_GOAL_OBJECTIVE_CHARS).optional(),
-  status: z6.enum(["active", "paused"]).optional()
+var updateGoalSchema = z5.object({
+  objective: z5.string().trim().min(1).max(MAX_CODEX_GOAL_OBJECTIVE_CHARS).optional(),
+  status: z5.enum(["active", "paused"]).optional()
 }).refine((body) => body.objective !== void 0 || body.status !== void 0, {
   message: "Goal objective or status required"
 });
@@ -14332,7 +14876,7 @@ function createV1Routes(deps) {
   });
   app2.post("/chats/:chatId/messages", async (c) => {
     try {
-      const body = sendMessageSchema.parse(await c.req.json());
+      const body = sendChatMessageRequestSchema.strip().parse(await c.req.json());
       const goalValidationError = getGoalCommandObjectiveValidationError(body.message, body.goalMode);
       if (goalValidationError) {
         return c.json(jsonError(goalValidationError), 400);
@@ -14371,7 +14915,7 @@ function createV1Routes(deps) {
       const result = await deps.chatService.updateGoal(c.req.param("chatId"), body);
       return c.json(result);
     } catch (error) {
-      if (error instanceof z6.ZodError) {
+      if (error instanceof z5.ZodError) {
         return c.json(jsonError(error.issues[0]?.message || "Invalid goal update"), 400);
       }
       if (error instanceof ChatNotFoundError) {
@@ -15114,7 +15658,7 @@ async function timeStartupStep(name, fn) {
 async function waitForInitializationGate() {
   if (!ENGINE_ENV.REPLICAS_ENGINE_DEFER_INITIALIZATION) return;
   const deadline = Date.now() + ENGINE_INIT_GATE_TIMEOUT_MS;
-  while (!existsSync11(SANDBOX_PATHS.ENGINE_INIT_GATE)) {
+  while (!existsSync12(SANDBOX_PATHS.ENGINE_INIT_GATE)) {
     if (Date.now() >= deadline) {
       throw new Error("Timed out waiting for deferred engine initialization gate");
     }
@@ -15179,7 +15723,12 @@ var authMiddleware = async (c, next) => {
   await next();
 };
 var agentChatActivityTrackerService = new AgentChatActivityTrackerService();
-var chatService = new ChatService(gitService.getWorkspaceRoot(), agentChatActivityTrackerService);
+var agentTokenUsageTracker = new AgentTokenUsageTracker(uploadAnalytics);
+var chatService = new ChatService(
+  gitService.getWorkspaceRoot(),
+  agentChatActivityTrackerService,
+  agentTokenUsageTracker
+);
 app.get("/health", async (c) => {
   const requestedWaitMs = Number(c.req.query(ENGINE_HEALTH_WAIT_QUERY_PARAM));
   const waitMs = Number.isFinite(requestedWaitMs) ? Math.min(Math.max(requestedWaitMs, 0), ENGINE_HEALTH_MAX_WAIT_MS) : 0;