replicas-engine 0.1.552 → 0.1.553

package/README.md

@@ -135,3 +135,5 @@ Outgoing endpoints:
 - `POST /v1/engine/codex/refresh-credentials`
 - `POST /v1/engine/infisical/refresh-token`
 - `POST /v1/engine/chat-turn-usage`
+- `POST /v1/engine/skill-usage`
+- `POST /v1/engine/mcp-usage`

package/dist/src/index.js

@@ -260,7 +260,10 @@ var AGENT_CREDENTIAL_METHODS_IN_ORDER = {
   ]
 };
 
-// ../shared/src/chat-turn-usage.ts
+// ../shared/src/analytics/types.ts
+function isUsageRecord(value) {
+  return isRecord(value) && typeof value.chatId === "string" && typeof value.provider === "string" && isValidAgentProvider(value.provider) && typeof value.model === "string" && (value.credentialMethod === void 0 || isAuthMethod(value.credentialMethod)) && (value.credentialScope === void 0 || isCredentialScope(value.credentialScope)) && value.credentialMethod === void 0 === (value.credentialScope === void 0) && (value.senderUserId === void 0 || typeof value.senderUserId === "string") && typeof value.occurredAt === "string";
+}
 function isAuthMethod(value) {
   return typeof value === "string" && Object.values(CREDENTIAL_METHOD).some((method) => method === value);
 }
@@ -268,7 +271,21 @@ function isCredentialScope(value) {
   return typeof value === "string" && CREDENTIAL_SCOPES.some((scope) => scope === value);
 }
 function isChatTurnUsageRecord(value) {
-  return isRecord(value) && typeof value.turnId === "string" && typeof value.chatId === "string" && typeof value.provider === "string" && isValidAgentProvider(value.provider) && typeof value.model === "string" && (value.credentialMethod === void 0 || isAuthMethod(value.credentialMethod)) && (value.credentialScope === void 0 || isCredentialScope(value.credentialScope)) && value.credentialMethod === void 0 === (value.credentialScope === void 0) && (value.senderUserId === void 0 || typeof value.senderUserId === "string") && typeof value.occurredAt === "string" && typeof value.seconds === "number" && Number.isFinite(value.seconds) && value.seconds >= 0;
+  return isUsageRecord(value) && typeof value.turnId === "string" && typeof value.seconds === "number" && Number.isFinite(value.seconds) && value.seconds >= 0;
+}
+function isCallUsageRecord(value) {
+  return isUsageRecord(value) && typeof value.callId === "string" && value.callId.length > 0;
+}
+function isNamedCallUsageRecord(value, field) {
+  if (!isCallUsageRecord(value)) return false;
+  const name = value[field];
+  return typeof name === "string" && name.length > 0;
+}
+function isSkillUsageRecord(value) {
+  return isNamedCallUsageRecord(value, "skillName");
+}
+function isMcpUsageRecord(value) {
+  return isNamedCallUsageRecord(value, "mcpName");
 }
 
 // ../shared/src/aster.ts
@@ -708,7 +725,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-08-03-v2";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-08-03-v3";
 
 // ../shared/src/runtime-env.ts
 function shellQuotePosix(value) {
@@ -2809,6 +2826,16 @@ var DEFAULT_DEFAULT_SKILLS = {
   }
 };
 
+// ../shared/src/prompts.ts
+var REPLICAS_INSTRUCTIONS_TAG = "replicas_instructions";
+function removeTag(text, tag) {
+  const regex = new RegExp(`<${tag}>[\\s\\S]*?</${tag}>`, "g");
+  return text.replace(regex, "").trim();
+}
+function removeReplicasInstructions(text) {
+  return removeTag(text, REPLICAS_INSTRUCTIONS_TAG);
+}
+
 // ../shared/src/replicas-config.ts
 import { parse as parseYaml } from "yaml";
 
@@ -3560,7 +3587,17 @@ function isTerminalBackgroundTaskStatus(status) {
 // ../shared/src/display-message/constants.ts
 var USER_MESSAGE_MATCH_GRACE_PERIOD_MS = 3e4;
 
+// ../shared/src/json.ts
+function safeJsonParse(str, fallback) {
+  try {
+    return JSON.parse(str);
+  } catch {
+    return fallback;
+  }
+}
+
 // ../shared/src/display-message/parsers/utils.ts
+var INTERRUPTED_MESSAGE_REGEX = /^\[Request interrupted by user.*\]$/;
 function userMessageImages(value) {
   if (!Array.isArray(value)) return void 0;
   const images = value.filter((item) => isRecord(item) && item.type === "image" && typeof item.mediaType === "string" && typeof item.data === "string");
@@ -3575,6 +3612,32 @@ function stringifyDisplayValue(value) {
     return String(value);
   }
 }
+function upsertDisplayMessage(messages, message) {
+  const index = messages.findIndex((candidate) => candidate.id === message.id);
+  if (index === -1) messages.push(message);
+  else messages[index] = message;
+}
+function parseSkillName(tool2, input) {
+  if (typeof tool2 !== "string") return null;
+  const normalizedTool = tool2.toLowerCase();
+  if (normalizedTool.startsWith("skill.")) return tool2.slice("skill.".length) || null;
+  if (normalizedTool !== "skill") return null;
+  const parsedInput = typeof input === "string" ? safeJsonParse(input, null) : input;
+  if (!isRecord(parsedInput)) return null;
+  const skillName = parsedInput.skill ?? parsedInput.name;
+  return typeof skillName === "string" && skillName ? skillName : null;
+}
+function createCallDisplayMessage(message) {
+  const skillName = message.server.toLowerCase() === "skills" ? message.tool : parseSkillName(message.tool, message.input);
+  if (skillName === null) return { ...message, type: "tool_call" };
+  return {
+    id: message.id,
+    type: "skill",
+    skillName,
+    status: message.status,
+    timestamp: message.timestamp
+  };
+}
 
 // ../shared/src/user-message-matching.ts
 function parseTimestampMs(timestamp) {
@@ -3656,15 +3719,6 @@ function parseAgentEventJsonlWithCodexAspTranscript(content, options = {}) {
   return { events, transcript, transcriptsByThreadId };
 }
 
-// ../shared/src/json.ts
-function safeJsonParse(str, fallback) {
-  try {
-    return JSON.parse(str);
-  } catch {
-    return fallback;
-  }
-}
-
 // ../shared/src/display-message/parsers/codex-parser.ts
 function getStatusFromExitCode(exitCode) {
   return exitCode === 0 ? "completed" : "failed";
@@ -3831,17 +3885,17 @@ function parseCodexEvents(events) {
           const operations = parsePatch(input);
           pendingPatches.set(callId, { input, status, timestamp: event.timestamp, operations });
         } else {
-          const msg = {
-            id: `toolcall-${callId || getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY) || `${event.timestamp}-${eventIndex}`}`,
-            type: "tool_call",
+          const id = `toolcall-${callId || getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY) || `${event.timestamp}-${eventIndex}`}`;
+          const msg = createCallDisplayMessage({
+            id,
             server,
             tool: name,
             input,
             status,
             timestamp: event.timestamp
-          };
+          });
           messages.push(msg);
-          if (callId) {
+          if (callId && msg.type === "tool_call") {
             pendingToolCalls.set(callId, msg);
           }
         }
@@ -3925,10 +3979,10 @@ function getCursorThinkingText(event) {
 function isTerminalStatus(status) {
   return status === "FINISHED" || status === "ERROR" || status === "CANCELLED" || status === "EXPIRED";
 }
-function finalizeOpenTools(messages, toolIndexes, status) {
-  for (const index of toolIndexes.values()) {
+function finalizeOpenCalls(messages, callIndexes, status) {
+  for (const index of callIndexes.values()) {
     const message = messages[index];
-    if (message?.type === "tool_call" && message.status === "in_progress") {
+    if ((message?.type === "tool_call" || message?.type === "skill") && message.status === "in_progress") {
       messages[index] = {
         ...message,
         status
@@ -3938,7 +3992,7 @@ function finalizeOpenTools(messages, toolIndexes, status) {
 }
 function parseCursorEvents(events) {
   const messages = [];
-  const toolIndexes = /* @__PURE__ */ new Map();
+  const callIndexes = /* @__PURE__ */ new Map();
   const runAssistantSegments = /* @__PURE__ */ new Map();
   const runThinkingSegments = /* @__PURE__ */ new Map();
   let activeAssistant = null;
@@ -4030,21 +4084,20 @@ function parseCursorEvents(events) {
       const tool2 = typeof event.payload.name === "string" ? event.payload.name : "tool";
       const status = cursorStatusToDisplayStatus(event.payload.status);
       const input = isRecord(event.payload.args) ? event.payload.args : typeof event.payload.args === "string" ? event.payload.args : void 0;
-      const existing = toolIndexes.get(callId);
-      const next = {
+      const existing = callIndexes.get(callId);
+      const next = createCallDisplayMessage({
         id: callId,
-        type: "tool_call",
         server: "cursor",
         tool: tool2,
         ...input !== void 0 ? { input } : {},
         output: stringifyDisplayValue(event.payload.result),
         status,
         timestamp: event.timestamp
-      };
+      });
       if (existing === void 0) {
-        toolIndexes.set(callId, messages.push(next) - 1);
+        callIndexes.set(callId, messages.push(next) - 1);
       } else {
-        messages[existing] = { ...messages[existing], ...next };
+        messages[existing] = next;
       }
       continue;
     }
@@ -4066,7 +4119,7 @@ function parseCursorEvents(events) {
       if (isTerminalStatus(status)) {
         const displayStatus = cursorStatusToDisplayStatus(status);
         finalizeActiveThinking(displayStatus);
-        finalizeOpenTools(messages, toolIndexes, displayStatus);
+        finalizeOpenCalls(messages, callIndexes, displayStatus);
         activeThinking = null;
         activeAssistant = null;
       }
@@ -4074,7 +4127,7 @@ function parseCursorEvents(events) {
     }
     if (event.type === "cursor-error") {
       finalizeActiveThinking("failed");
-      finalizeOpenTools(messages, toolIndexes, "failed");
+      finalizeOpenCalls(messages, callIndexes, "failed");
       activeAssistant = null;
       activeThinking = null;
       const message = typeof event.payload.message === "string" ? event.payload.message : "Cursor run failed";
@@ -4099,14 +4152,6 @@ function partFromEvent(event) {
 function toolStatus(status) {
   return status === "completed" ? "completed" : status === "error" ? "failed" : "in_progress";
 }
-function setById(messages, id, next) {
-  const index = messages.findIndex((message) => message.id === id);
-  if (index === -1) {
-    messages.push(next);
-  } else {
-    messages[index] = next;
-  }
-}
 function assistantError(info) {
   if (!isRecord(info) || !isRecord(info.error)) return null;
   const data = isRecord(info.error.data) ? info.error.data : null;
@@ -4151,15 +4196,32 @@ function parseOpencodeEvents(events) {
       });
       continue;
     }
+    if (event.type === "opencode-session.next.tool.called") {
+      const tool2 = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
+      const input = event.payload.input ?? event.payload.arguments;
+      const callId = typeof event.payload.callID === "string" ? event.payload.callID : null;
+      const id2 = callId ? `opencode-${callId}` : `opencode-${event.timestamp}-${messages.length}`;
+      upsertDisplayMessage(messages, createCallDisplayMessage({
+        id: id2,
+        server: "opencode",
+        tool: tool2,
+        input: isRecord(input) ? input : stringifyDisplayValue(input),
+        status: "in_progress",
+        timestamp: event.timestamp
+      }));
+      continue;
+    }
     const part = partFromEvent(event);
     if (!part) continue;
-    const id = typeof part.id === "string" ? `opencode-${part.id}` : `opencode-${event.timestamp}-${messages.length}`;
+    let id = `opencode-${event.timestamp}-${messages.length}`;
+    if (typeof part.callID === "string") id = `opencode-${part.callID}`;
+    else if (typeof part.id === "string") id = `opencode-${part.id}`;
     const time = isRecord(part.time) ? part.time : null;
     const timestamp = timestampFromMs(time?.start, event.timestamp);
     if (part.type === "text") {
       const text = typeof part.text === "string" ? part.text : "";
       if (text.trim()) {
-        setById(messages, id, {
+        upsertDisplayMessage(messages, {
           id,
           type: "agent",
           content: text,
@@ -4171,7 +4233,7 @@ function parseOpencodeEvents(events) {
     if (part.type === "reasoning") {
       const text = typeof part.text === "string" ? part.text : "";
       if (text.trim()) {
-        setById(messages, id, {
+        upsertDisplayMessage(messages, {
           id,
           type: "reasoning",
           content: text,
@@ -4184,23 +4246,24 @@ function parseOpencodeEvents(events) {
     if (part.type === "tool" && isRecord(part.state)) {
       const state = part.state;
       const status = toolStatus(state.status);
+      const tool2 = typeof part.tool === "string" ? part.tool : "tool";
+      const input = state.input;
       const output = state.status === "completed" ? stringifyDisplayValue(state.output) : state.status === "error" ? stringifyDisplayValue(state.error) : void 0;
-      setById(messages, id, {
+      upsertDisplayMessage(messages, createCallDisplayMessage({
         id,
-        type: "tool_call",
         server: "opencode",
-        tool: typeof part.tool === "string" ? part.tool : "tool",
-        input: isRecord(state.input) ? state.input : stringifyDisplayValue(state.input),
+        tool: tool2,
+        input: isRecord(input) ? input : stringifyDisplayValue(input),
         output,
         status,
         timestamp
-      });
+      }));
       continue;
     }
     if (part.type === "patch") {
       const files = Array.isArray(part.files) ? part.files.filter((file) => typeof file === "string") : [];
       if (files.length > 0) {
-        setById(messages, id, {
+        upsertDisplayMessage(messages, {
           id,
           type: "file_change",
           changes: files.map((path6) => ({ path: path6, kind: "update" })),
@@ -4217,11 +4280,6 @@ function parseOpencodeEvents(events) {
 function nestedPayload(event) {
   return isRecord(event.payload.assistantMessageEvent) ? event.payload.assistantMessageEvent : event.payload;
 }
-function setById2(messages, id, message) {
-  const index = messages.findIndex((candidate) => candidate.id === id);
-  if (index === -1) messages.push(message);
-  else messages[index] = message;
-}
 function toolStatus2(value) {
   return value === "completed" || value === "success" ? "completed" : value === "error" ? "failed" : "in_progress";
 }
@@ -4257,8 +4315,8 @@ function parsePiEvents(events) {
       if (payload.type === "thinking_delta" && typeof payload.delta === "string") thinking.set(id, `${thinking.get(id) ?? ""}${payload.delta}`);
       const textContent = text.get(id);
       const thinkingContent = thinking.get(id);
-      if (textContent !== void 0) setById2(messages, `pi-${id}`, { id: `pi-${id}`, type: "agent", content: textContent, timestamp: event.timestamp });
-      if (thinkingContent !== void 0) setById2(messages, `pi-thinking-${id}`, { id: `pi-thinking-${id}`, type: "reasoning", content: thinkingContent, status: "in_progress", timestamp: event.timestamp });
+      if (textContent !== void 0) upsertDisplayMessage(messages, { id: `pi-${id}`, type: "agent", content: textContent, timestamp: event.timestamp });
+      if (thinkingContent !== void 0) upsertDisplayMessage(messages, { id: `pi-thinking-${id}`, type: "reasoning", content: thinkingContent, status: "in_progress", timestamp: event.timestamp });
       continue;
     }
     if (event.type === "pi-message_start") {
@@ -4270,16 +4328,18 @@ function parsePiEvents(events) {
       const payload = event.payload;
       const input = payload.args ?? payload.input;
       const id = typeof payload.toolCallId === "string" ? payload.toolCallId : typeof payload.id === "string" ? payload.id : `tool-${event.timestamp}`;
-      setById2(messages, `pi-tool-${id}`, {
-        id: `pi-tool-${id}`,
-        type: "tool_call",
+      const tool2 = typeof payload.toolName === "string" ? payload.toolName : "tool";
+      const messageId = `pi-tool-${id}`;
+      const status = event.type === "pi-tool_execution_end" ? toolStatus2(payload.isError ? "error" : "completed") : "in_progress";
+      upsertDisplayMessage(messages, createCallDisplayMessage({
+        id: messageId,
         server: "pi",
-        tool: typeof payload.toolName === "string" ? payload.toolName : "tool",
+        tool: tool2,
         input: isRecord(input) ? input : stringifyDisplayValue(input),
         output: event.type === "pi-tool_execution_end" ? stringifyDisplayValue(payload.result ?? payload.error) : void 0,
-        status: event.type === "pi-tool_execution_end" ? toolStatus2(payload.isError ? "error" : "completed") : "in_progress",
+        status,
         timestamp: event.timestamp
-      });
+      }));
     }
   }
   return messages;
@@ -4443,14 +4503,6 @@ function isClaudeResultError(payload) {
   if (payload.errors?.length && stripAgentDiagnosticErrors(payload.errors).length === 0) return false;
   return Boolean(payload.is_error) || payload.subtype !== "success";
 }
-function upsertDisplayMessage(messages, message) {
-  const index = messages.findIndex((existing) => existing.id === message.id);
-  if (index === -1) {
-    messages.push(message);
-  } else {
-    messages[index] = message;
-  }
-}
 var LOCAL_COMMAND_ECHO_REGEX = /^<(?:command-name|command-message|local-command-stdout|local-command-stderr)>/;
 function parseClaudeEvents(events, parentToolUseId) {
   const messages = [];
@@ -4733,7 +4785,7 @@ function parseClaudeEvents(events, parentToolUseId) {
           } else if (toolName === "Skill") {
             const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
             messages.push({
-              id: `skill-${event.timestamp}-${messages.length}`,
+              id: `skill-${toolUseId}`,
               type: "skill",
               skillName: inputObj.skill || "unknown",
               args: inputObj.args,
@@ -4942,8 +4994,196 @@ function parseClaudeEvents(events, parentToolUseId) {
 
 // ../shared/src/display-message/parsers/codex-asp-parser.ts
 var DUPLICATE_WINDOW_MS = 5 * 60 * 1e3;
+function nearTimestamp(a, b) {
+  return Math.abs(parseTimestampMs(a) - parseTimestampMs(b)) <= DUPLICATE_WINDOW_MS;
+}
+function inputForDisplay(input) {
+  if (input === void 0 || input === null) return void 0;
+  if (typeof input === "string") return input;
+  if (isRecord(input)) return input;
+  return String(input);
+}
+function isInternalUserMessage(content) {
+  const trimmed = content.trim();
+  return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<goal_context>");
+}
+function messageForItem(item) {
+  if (item.type === "userMessage") {
+    if (isInternalUserMessage(item.content)) return null;
+    return {
+      id: `user-${item.id}`,
+      type: "user",
+      content: item.content,
+      images: item.images,
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "agentMessage") {
+    if (!item.text) return null;
+    return {
+      id: `agent-${item.id}`,
+      type: "agent",
+      content: item.text,
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "reasoning") {
+    if (!item.text || item.status === "completed") return null;
+    return {
+      id: `reasoning-${item.id}`,
+      type: "reasoning",
+      content: item.text,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "commandExecution") {
+    return {
+      id: `command-${item.id}`,
+      type: "command",
+      command: item.command,
+      output: item.output,
+      exitCode: item.exitCode ?? void 0,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "fileChange") {
+    return {
+      id: `patch-${item.id}`,
+      type: "patch",
+      operations: item.operations,
+      output: item.output,
+      exitCode: item.exitCode ?? void 0,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "toolCall") {
+    return createCallDisplayMessage({
+      id: `toolcall-${item.id}`,
+      server: item.server,
+      tool: item.tool,
+      input: inputForDisplay(item.input),
+      output: item.output,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    });
+  }
+  if (item.type === "subagent") {
+    return {
+      id: `subagent-${item.id}`,
+      type: "subagent",
+      toolUseId: item.id,
+      description: item.description,
+      prompt: item.prompt,
+      subagentType: item.subagentType,
+      ...item.receiverThreadIds ? { receiverThreadIds: item.receiverThreadIds } : {},
+      ...item.model ? { model: item.model } : {},
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      ...item.output ? { output: item.output } : {},
+      nestedEvents: [],
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "webSearch") {
+    return {
+      id: `web-search-${item.id}`,
+      type: "web_search",
+      query: item.query,
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "plan") {
+    if (!item.text) return null;
+    return {
+      id: `todo-${item.id}`,
+      type: "todo_list",
+      items: item.text.split("\n").map((line) => line.trim()).filter(Boolean).map((text) => ({ text, completed: item.status === "completed" })),
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  if (item.type === "contextCompaction") {
+    return {
+      id: `reasoning-${item.id}`,
+      type: "reasoning",
+      content: "Context compacted",
+      status: normalizeCodexAspTranscriptStatus(item.status),
+      timestamp: item.timestamp
+    };
+  }
+  return {
+    id: `error-${item.id}`,
+    type: "error",
+    message: item.message,
+    timestamp: item.timestamp
+  };
+}
+function stableString(value) {
+  if (value === void 0) return "";
+  if (typeof value !== "object" || value === null) return String(value);
+  try {
+    return JSON.stringify(value, Object.keys(value).sort());
+  } catch {
+    return String(value);
+  }
+}
+function duplicateMessage(a, b) {
+  if (a.id === b.id) return true;
+  if (a.type !== b.type || !nearTimestamp(a.timestamp, b.timestamp)) {
+    return false;
+  }
+  if (a.type === "user" && b.type === "user") return a.content === b.content;
+  if (a.type === "agent" && b.type === "agent") return a.content === b.content;
+  if (a.type === "reasoning" && b.type === "reasoning") return a.content === b.content;
+  if (a.type === "command" && b.type === "command") return a.command === b.command;
+  if (a.type === "web_search" && b.type === "web_search") return a.query === b.query;
+  if (a.type === "subagent" && b.type === "subagent") {
+    return a.description === b.description && a.prompt === b.prompt && a.subagentType === b.subagentType && a.model === b.model;
+  }
+  if (a.type === "todo_list" && b.type === "todo_list") {
+    return stableString(a.items) === stableString(b.items);
+  }
+  if (a.type === "patch" && b.type === "patch") {
+    return stableString(a.operations) === stableString(b.operations);
+  }
+  if (a.type === "tool_call" && b.type === "tool_call") {
+    return a.server === b.server && a.tool === b.tool && stableString(a.input) === stableString(b.input);
+  }
+  return false;
+}
+function mergeCodexAspDisplayMessages(primary, supplemental) {
+  const merged = [...primary];
+  for (const message of supplemental) {
+    const duplicateIndex = merged.findIndex((existing) => duplicateMessage(existing, message));
+    if (duplicateIndex === -1) {
+      merged.push(message);
+    } else if (message.type === "user") {
+      merged[duplicateIndex] = { ...merged[duplicateIndex], timestamp: message.timestamp };
+    }
+  }
+  return merged.map((message, index) => ({ message, index })).sort((a, b) => parseTimestampMs(a.message.timestamp) - parseTimestampMs(b.message.timestamp) || a.index - b.index).map(({ message }) => message);
+}
+function parseCodexAspTranscript(transcript) {
+  const messages = [];
+  const orderedItems = transcript.turns.map((turn, turnIndex) => ({ turn, turnIndex })).flatMap(({ turn, turnIndex }) => turn.items.map((item, itemIndex) => ({ item, turnIndex, itemIndex }))).sort((a, b) => {
+    const aSequence = a.item.sequence ?? Number.MAX_SAFE_INTEGER;
+    const bSequence = b.item.sequence ?? Number.MAX_SAFE_INTEGER;
+    return aSequence - bSequence || parseTimestampMs(a.item.timestamp) - parseTimestampMs(b.item.timestamp) || a.turnIndex - b.turnIndex || a.itemIndex - b.itemIndex;
+  });
+  for (const { item } of orderedItems) {
+    const message = messageForItem(item);
+    if (message) {
+      messages.push(message);
+    }
+  }
+  return messages;
+}
 
 // ../shared/src/display-message/parsers/index.ts
+var INTERRUPTION_DEDUP_WINDOW_MS = 15e3;
 function parseAgentEvents(events, agentType) {
   if (agentType === "codex") {
     return parseCodexEvents(events);
@@ -4959,11 +5199,82 @@ function parseAgentEvents(events, agentType) {
   }
   return parseClaudeEvents(events);
 }
+function parseDisplayMessages(events, agentType, codexAspTranscript, options = {}) {
+  const shouldFilter = options.filter ?? true;
+  const parsedEvents = agentType === "claude" || agentType === "relay" ? parseClaudeEvents(events, options.parentToolUseId) : parseAgentEvents(events, agentType);
+  const legacyMessages = shouldFilter ? filterDisplayMessages(parsedEvents, agentType) : parsedEvents;
+  if (agentType !== "codex" || !codexAspTranscript) {
+    return shouldFilter ? applyInterruptions(legacyMessages, events) : legacyMessages;
+  }
+  const nativeCodexMessages = shouldFilter ? filterDisplayMessages(parseCodexAspTranscript(codexAspTranscript), agentType) : parseCodexAspTranscript(codexAspTranscript);
+  const merged = mergeCodexAspDisplayMessages(nativeCodexMessages, legacyMessages);
+  return shouldFilter ? applyInterruptions(merged, events) : merged;
+}
+function applyInterruptions(messages, events) {
+  const result = [...messages];
+  for (const event of events) {
+    if (event.type !== CHAT_INTERRUPTED_EVENT_TYPE) continue;
+    const eventMs = parseTimestampMs(event.timestamp);
+    let index = result.length;
+    while (index > 0 && parseTimestampMs(result[index - 1].timestamp) > eventMs) index--;
+    result.splice(index, 0, {
+      id: `interruption-${event.timestamp}`,
+      type: "interruption",
+      timestamp: event.timestamp
+    });
+  }
+  let lastUserMs = null;
+  let lastInterruption = null;
+  const finalized = [];
+  for (const msg of result) {
+    if (msg.type === "user") {
+      lastUserMs = parseTimestampMs(msg.timestamp);
+      lastInterruption = null;
+      finalized.push(msg);
+      continue;
+    }
+    if (msg.type !== "interruption") {
+      finalized.push(msg);
+      continue;
+    }
+    const ms = parseTimestampMs(msg.timestamp);
+    if (lastInterruption && ms - parseTimestampMs(lastInterruption.timestamp) <= INTERRUPTION_DEDUP_WINDOW_MS) {
+      continue;
+    }
+    lastInterruption = {
+      ...msg,
+      ...lastUserMs !== null && ms >= lastUserMs ? { durationMs: ms - lastUserMs } : {}
+    };
+    finalized.push(lastInterruption);
+  }
+  return finalized;
+}
+function isCodexInitializationPrompt(message) {
+  return message.type === "user" && removeReplicasInstructions(message.content).trim() === "Hello";
+}
 function isAgentBackendEvent(value) {
   if (!value || typeof value !== "object") return false;
   const candidate = value;
   return typeof candidate.timestamp === "string" && typeof candidate.type === "string" && typeof candidate.payload === "object" && candidate.payload !== null;
 }
+function filterDisplayMessages(messages, provider) {
+  let result = messages;
+  if (provider === "codex") {
+    const userMessages = result.map((msg, index) => ({ msg, index })).filter(({ msg }) => msg.type === "user");
+    if (userMessages.length >= 2 && isCodexInitializationPrompt(userMessages[0].msg)) {
+      result = result.slice(userMessages[1].index);
+    }
+  }
+  result = result.map((msg) => {
+    if (msg.type !== "user") return msg;
+    const cleaned = removeReplicasInstructions(msg.content).trim();
+    if (INTERRUPTED_MESSAGE_REGEX.test(cleaned)) {
+      return { id: msg.id, type: "interruption", timestamp: msg.timestamp };
+    }
+    return cleaned !== msg.content ? { ...msg, content: cleaned } : msg;
+  });
+  return result;
+}
 
 // ../shared/src/onboarding-emails.ts
 var EMAIL_KEYS = [
@@ -10297,7 +10608,7 @@ var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.552";
+var ENGINE_PACKAGE_VERSION = "0.1.553";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -14519,153 +14830,234 @@ var RelayManager = class {
   }
 };
 
-// src/services/chat/turn-usage.ts
+// src/analytics/analytics.service.ts
 import { randomUUID as randomUUID5 } from "crypto";
+
+// src/analytics/analytics-buffer.service.ts
 import { appendFile as appendFile3, mkdir as mkdir14, readFile as readFile12, readdir as readdir6, rename as rename2, unlink as unlink3 } from "fs/promises";
 import { join as join22 } from "path";
-var LIVE_FILE = join22(ENGINE_DIR2, "turn-usage.jsonl");
-var SEGMENT_FILE_RE = /^turn-usage\.(\d+)\.jsonl$/;
-var UPLOADED_SUFFIX = ".uploaded";
-var MAX_TRACKED_MESSAGES = 500;
 var MAX_FAILED_RECORDS = 500;
 var FLUSH_DEBOUNCE_MS = 15e3;
 var MAX_UPLOADED_SEGMENTS = 50;
-var messageAttrs = /* @__PURE__ */ new Map();
-var activeTurns = /* @__PURE__ */ new Map();
-var flushTimer = null;
-var activeFlush = Promise.resolve({ flushed: 0, failed: 0 });
-var pendingAppends = /* @__PURE__ */ new Set();
-var failedRecords = [];
-function noteMessageAccepted(messageId, request) {
-  messageAttrs.set(messageId, {
-    ...request.model ? { model: request.model } : {},
-    ...request.senderUserId ? { senderUserId: request.senderUserId } : {}
-  });
-  for (const key of messageAttrs.keys()) {
-    if (messageAttrs.size <= MAX_TRACKED_MESSAGES) break;
-    messageAttrs.delete(key);
-  }
-}
-function noteTurnStarted(chatId, messageId, provider) {
-  const credential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[provider];
-  activeTurns.set(chatId, {
-    turnId: randomUUID5(),
-    messageId,
-    startedAtMs: Date.now(),
-    provider,
-    ...credential ? { credentialMethod: credential.method, credentialScope: credential.scope } : {}
-  });
-}
-function noteTurnEnded(chatId) {
-  const turn = activeTurns.get(chatId);
-  if (!turn) return;
-  activeTurns.delete(chatId);
-  recordTurn(chatId, turn);
-  scheduleFlush();
-}
-function scheduleFlush() {
-  if (flushTimer) return;
-  flushTimer = setTimeout(() => {
-    flushTimer = null;
-    void flushAllTurnUsage(false).catch((err) => {
-      console.error("[TurnUsage] Scheduled flush failed, retrying on the next turn:", err);
+var UPLOADED_SUFFIX = ".uploaded";
+var AnalyticsBufferService = class {
+  constructor(options) {
+    this.options = options;
+    this.liveFile = join22(ENGINE_DIR2, `${options.name}.jsonl`);
+    this.segmentFilePattern = new RegExp(`^${options.name}\\.(\\d+)\\.jsonl$`);
+  }
+  options;
+  liveFile;
+  segmentFilePattern;
+  failedRecords = [];
+  pendingAppends = /* @__PURE__ */ new Set();
+  flushTimer = null;
+  activeFlush = Promise.resolve({ flushed: 0, failed: 0 });
+  append(record) {
+    const pending = mkdir14(ENGINE_DIR2, { recursive: true }).then(() => appendFile3(this.liveFile, `${JSON.stringify(record)}
+`, "utf-8")).catch((error) => {
+      console.error(`[${this.options.name}] Append failed, will retry on flush:`, error);
+      if (this.failedRecords.length < MAX_FAILED_RECORDS) this.failedRecords.push(record);
     });
-  }, FLUSH_DEBOUNCE_MS);
-  flushTimer.unref?.();
-}
-function recordTurn(chatId, turn) {
-  const attrs = messageAttrs.get(turn.messageId) ?? {};
-  messageAttrs.delete(turn.messageId);
-  writeRecord({
-    turnId: turn.turnId,
-    chatId,
-    provider: turn.provider,
-    ...turn.credentialMethod && turn.credentialScope ? { credentialMethod: turn.credentialMethod, credentialScope: turn.credentialScope } : {},
-    ...attrs,
-    // A request without a model runs the agent's default, so record that rather than nothing.
-    model: attrs.model ?? getDefaultAgentModel(turn.provider),
-    occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
-    seconds: Math.round((Date.now() - turn.startedAtMs) / 1e3)
-  });
-}
-function writeRecord(record) {
-  const pending = mkdir14(ENGINE_DIR2, { recursive: true }).then(() => appendFile3(LIVE_FILE, JSON.stringify(record) + "\n", "utf-8")).catch((err) => {
-    console.error("[TurnUsage] Append failed, will retry on flush:", err);
-    if (failedRecords.length < MAX_FAILED_RECORDS) failedRecords.push(record);
-  });
-  pendingAppends.add(pending);
-  void pending.finally(() => pendingAppends.delete(pending));
-}
-function flushAllTurnUsage(finalizeInFlight = true) {
-  if (flushTimer) {
-    clearTimeout(flushTimer);
-    flushTimer = null;
-  }
-  activeFlush = activeFlush.catch(() => {
-  }).then(() => runFlush(finalizeInFlight));
-  return activeFlush;
-}
-async function runFlush(finalizeInFlight) {
-  for (const record of failedRecords.splice(0)) writeRecord(record);
-  if (finalizeInFlight) {
-    for (const [chatId, turn] of activeTurns) recordTurn(chatId, turn);
-    activeTurns.clear();
-  }
-  while (pendingAppends.size > 0) await Promise.allSettled([...pendingAppends]);
-  await rename2(LIVE_FILE, join22(ENGINE_DIR2, `turn-usage.${Date.now()}.jsonl`)).catch(() => {
-  });
-  const entries = await readdir6(ENGINE_DIR2).catch(() => []);
-  let flushed = 0;
-  let failed = 0;
-  for (const entry of entries) {
-    if (!SEGMENT_FILE_RE.test(entry)) continue;
-    try {
-      await uploadSegment(join22(ENGINE_DIR2, entry));
-      flushed++;
-    } catch (err) {
-      failed++;
-      console.error("[TurnUsage] Segment upload failed, retained for retry:", { entry, err });
+    this.pendingAppends.add(pending);
+    void pending.finally(() => this.pendingAppends.delete(pending));
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flush().catch((error) => {
+        console.error(`[${this.options.name}] Scheduled flush failed, retrying on the next record:`, error);
+      });
+    }, FLUSH_DEBOUNCE_MS);
+    this.flushTimer.unref?.();
+  }
+  flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
     }
+    this.activeFlush = this.activeFlush.catch(() => {
+    }).then(() => this.runFlush());
+    return this.activeFlush;
   }
-  const stranded = failedRecords.splice(0);
-  if (stranded.length > 0) {
-    try {
-      await uploadTurns(stranded);
-      flushed++;
-    } catch (err) {
-      failed++;
-      failedRecords.unshift(...stranded.slice(0, MAX_FAILED_RECORDS));
-      console.error("[TurnUsage] Stranded-record upload failed, retained for retry:", err);
+  async runFlush() {
+    for (const record of this.failedRecords.splice(0)) this.append(record);
+    while (this.pendingAppends.size > 0) await Promise.allSettled([...this.pendingAppends]);
+    await rename2(this.liveFile, join22(ENGINE_DIR2, `${this.options.name}.${Date.now()}.jsonl`)).catch(() => {
+    });
+    const entries = await readdir6(ENGINE_DIR2).catch(() => []);
+    let flushed = 0;
+    let failed = 0;
+    for (const entry of entries) {
+      if (!this.segmentFilePattern.test(entry)) continue;
+      try {
+        await this.uploadSegment(join22(ENGINE_DIR2, entry));
+        flushed++;
+      } catch (error) {
+        failed++;
+        console.error(`[${this.options.name}] Segment upload failed, retained for retry:`, { entry, error });
+      }
     }
+    const failedRecords = this.failedRecords.splice(0);
+    if (failedRecords.length > 0) {
+      try {
+        await this.options.upload(failedRecords);
+        flushed++;
+      } catch (error) {
+        failed++;
+        this.failedRecords.unshift(...failedRecords.slice(0, MAX_FAILED_RECORDS));
+        console.error(`[${this.options.name}] Failed records upload failed, retained for retry:`, error);
+      }
+    }
+    const uploaded = entries.filter((entry) => entry.startsWith(`${this.options.name}.`) && entry.endsWith(UPLOADED_SUFFIX)).sort();
+    for (const entry of uploaded.slice(0, -MAX_UPLOADED_SEGMENTS)) {
+      await unlink3(join22(ENGINE_DIR2, entry)).catch(() => {
+      });
+    }
+    return { flushed, failed };
   }
-  const uploaded = entries.filter((entry) => entry.endsWith(UPLOADED_SUFFIX)).sort();
-  for (const entry of uploaded.slice(0, -MAX_UPLOADED_SEGMENTS)) {
-    await unlink3(join22(ENGINE_DIR2, entry)).catch(() => {
+  async uploadSegment(filePath) {
+    const records = (await readFile12(filePath, "utf-8")).split("\n").flatMap((line) => {
+      try {
+        const parsed = JSON.parse(line);
+        return this.options.validate(parsed) ? [parsed] : [];
+      } catch {
+        return [];
+      }
+    });
+    if (records.length > 0) await this.options.upload(records);
+    await rename2(filePath, `${filePath}${UPLOADED_SUFFIX}`).catch(() => {
     });
   }
-  return { flushed, failed };
+};
+
+// src/analytics/extract-skill-mcp-calls.ts
+var NON_MCP_SERVERS = /* @__PURE__ */ new Set(["claude", "cursor", "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 extractSkillMcpCalls(messages) {
+  return messages.flatMap((message) => {
+    if (message.type === "skill") {
+      return [{ kind: "skill", id: message.id, skillName: message.skillName, occurredAt: message.timestamp }];
+    }
+    if (message.type !== "tool_call") return [];
+    const mcpName = mcpNameFromToolCall(message);
+    return mcpName ? [{ kind: "mcp", id: message.id, mcpName, occurredAt: message.timestamp }] : [];
+  });
 }
-async function uploadSegment(filePath) {
-  const turns = (await readFile12(filePath, "utf-8")).split("\n").flatMap((line) => {
-    try {
-      const parsed = JSON.parse(line);
-      return isChatTurnUsageRecord(parsed) ? [parsed] : [];
-    } catch {
-      return [];
-    }
+
+// src/analytics/analytics.service.ts
+var MAX_TRACKED_MESSAGES = 500;
+async function uploadAnalyticsRecords(endpoint, body) {
+  const response = await monolithRequest(endpoint, { body });
+  if (!response.ok) throw new Error(`upload failed: ${response.status} ${await response.text()}`);
+}
+var AnalyticsService = class {
+  pendingMessages = /* @__PURE__ */ new Map();
+  activeTurns = /* @__PURE__ */ new Map();
+  turnBuffer = new AnalyticsBufferService({
+    name: "turn-usage",
+    validate: isChatTurnUsageRecord,
+    upload: (turns) => uploadAnalyticsRecords("/v1/engine/chat-turn-usage", { turns })
   });
-  await uploadTurns(turns);
-  await rename2(filePath, `${filePath}${UPLOADED_SUFFIX}`).catch(() => {
+  skillBuffer = new AnalyticsBufferService({
+    name: "skill-usage",
+    validate: isSkillUsageRecord,
+    upload: (skills) => uploadAnalyticsRecords("/v1/engine/skill-usage", { skills })
   });
-}
-async function uploadTurns(turns) {
-  if (turns.length === 0) return;
-  const body = { turns };
-  const response = await monolithRequest("/v1/engine/chat-turn-usage", { body });
-  if (!response.ok) {
-    throw new Error(`upload failed: ${response.status} ${await response.text()}`);
+  mcpBuffer = new AnalyticsBufferService({
+    name: "mcp-usage",
+    validate: isMcpUsageRecord,
+    upload: (mcps) => uploadAnalyticsRecords("/v1/engine/mcp-usage", { mcps })
+  });
+  noteMessageAccepted(messageId, request) {
+    this.pendingMessages.set(messageId, {
+      model: request.model,
+      senderUserId: request.senderUserId
+    });
+    for (const key of this.pendingMessages.keys()) {
+      if (this.pendingMessages.size <= MAX_TRACKED_MESSAGES) break;
+      this.pendingMessages.delete(key);
+    }
+  }
+  noteTurnStarted(chatId, messageId, provider) {
+    const attributes = this.pendingMessages.get(messageId) ?? {};
+    const credential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[provider];
+    this.pendingMessages.delete(messageId);
+    this.activeTurns.set(chatId, {
+      turnId: randomUUID5(),
+      startedAtMs: Date.now(),
+      provider,
+      model: attributes.model ?? getDefaultAgentModel(provider),
+      senderUserId: attributes.senderUserId,
+      credentialMethod: credential?.method,
+      credentialScope: credential?.scope,
+      skills: [],
+      mcps: [],
+      seenCallIds: /* @__PURE__ */ new Set()
+    });
   }
-}
+  noteSkillMcpCalls(chatId, messages) {
+    const turn = this.activeTurns.get(chatId);
+    if (!turn) return;
+    for (const call of extractSkillMcpCalls(messages)) {
+      if (turn.seenCallIds.has(call.id)) continue;
+      turn.seenCallIds.add(call.id);
+      const common = {
+        callId: call.id,
+        chatId,
+        provider: turn.provider,
+        model: turn.model,
+        senderUserId: turn.senderUserId,
+        occurredAt: call.occurredAt,
+        credentialMethod: turn.credentialMethod,
+        credentialScope: turn.credentialScope
+      };
+      if (call.kind === "skill") turn.skills.push({ ...common, skillName: call.skillName });
+      else turn.mcps.push({ ...common, mcpName: call.mcpName });
+    }
+  }
+  noteTurnEnded(chatId) {
+    const turn = this.activeTurns.get(chatId);
+    if (!turn) return;
+    this.activeTurns.delete(chatId);
+    this.turnBuffer.append({
+      turnId: turn.turnId,
+      chatId,
+      provider: turn.provider,
+      model: turn.model,
+      senderUserId: turn.senderUserId,
+      credentialMethod: turn.credentialMethod,
+      credentialScope: turn.credentialScope,
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      seconds: Math.round((Date.now() - turn.startedAtMs) / 1e3)
+    });
+    for (const skill of turn.skills) this.skillBuffer.append(skill);
+    for (const mcp of turn.mcps) this.mcpBuffer.append(mcp);
+    this.turnBuffer.scheduleFlush();
+    if (turn.skills.length > 0) this.skillBuffer.scheduleFlush();
+    if (turn.mcps.length > 0) this.mcpBuffer.scheduleFlush();
+  }
+  async flush(finalizeInFlight = true) {
+    if (finalizeInFlight) {
+      for (const chatId of this.activeTurns.keys()) this.noteTurnEnded(chatId);
+    }
+    const [turnUsage, skillUsage, mcpUsage] = await Promise.all([
+      this.turnBuffer.flush(),
+      this.skillBuffer.flush(),
+      this.mcpBuffer.flush()
+    ]);
+    return { turnUsage, skillUsage, mcpUsage };
+  }
+};
 
 // src/services/keep-alive-service.ts
 var KeepAliveService = class _KeepAliveService {
@@ -15217,15 +15609,9 @@ function getCodexTranscriptUserMessages(transcript) {
 }
 function getCodexTranscriptFromEvent(event) {
   if (event.type !== CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE) return null;
-  const transcript = event.payload.transcript;
-  if (isCodexAspTranscript(transcript)) {
-    return transcript;
-  }
-  const transcriptDelta = event.payload.transcriptDelta;
-  if (!isCodexAspTranscriptDelta(transcriptDelta)) {
-    return null;
-  }
-  return applyCodexAspTranscriptDelta(null, transcriptDelta);
+  if (isCodexAspTranscript(event.payload.transcript)) return event.payload.transcript;
+  if (!isCodexAspTranscriptDelta(event.payload.transcriptDelta)) return null;
+  return applyCodexAspTranscriptDelta(null, event.payload.transcriptDelta);
 }
 function terminalErrorsFromEvent(event, provider, codexTranscript) {
   if (event.type === "claude-result") {
@@ -15296,13 +15682,15 @@ function corruptChatsFilePath() {
   return `${CHATS_FILE}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
 }
 var ChatService = class {
-  constructor(workingDirectory) {
+  constructor(workingDirectory, analyticsService2) {
     this.workingDirectory = workingDirectory;
+    this.analyticsService = analyticsService2;
     keepAliveService.setActivityCheck(
       () => [...this.chats.values()].some((chat) => !chat.persisted.deletedAt && isChatActive(chat))
     );
   }
   workingDirectory;
+  analyticsService;
   chats = /* @__PURE__ */ new Map();
   persistInFlight = false;
   persistQueued = false;
@@ -15424,7 +15812,7 @@ var ChatService = class {
       request.images
     );
     chat.pendingMessageIds.push(result.messageId);
-    noteMessageAccepted(result.messageId, request);
+    this.analyticsService.noteMessageAccepted(result.messageId, request);
     if (request.errorNotificationTarget) {
       chat.errorNotificationTargets.set(result.messageId, request.errorNotificationTarget);
     }
@@ -15480,7 +15868,7 @@ var ChatService = class {
   async interrupt(chatId) {
     const chat = this.requireChat(chatId);
     const result = await chat.provider.interrupt();
-    noteTurnEnded(chatId);
+    this.analyticsService.noteTurnEnded(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     chat.pendingMessageIds = [];
@@ -15502,7 +15890,7 @@ var ChatService = class {
       return { interrupted: false, queue: [], goal: null };
     }
     const interruptResult = await chat.provider.interrupt();
-    noteTurnEnded(chatId);
+    this.analyticsService.noteTurnEnded(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     chat.pendingMessageIds = [];
@@ -15692,14 +16080,14 @@ var ChatService = class {
     const chatsById = new Map(
       [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toSummary(chat)])
     );
-    const [chatTranscripts, canvas, repoState, engineLogs, turnUsage] = await Promise.all([
+    const [chatTranscripts, canvas, repoState, engineLogs, analytics] = await Promise.all([
       flushAllChatTranscripts(chatsById),
       flushAllCanvasItems(),
       flushRepoState(),
       flushAllEngineLogs(),
-      flushAllTurnUsage()
+      this.analyticsService.flush()
     ]);
-    return { chatTranscripts, canvas, repoState, engineLogs, turnUsage };
+    return { chatTranscripts, canvas, repoState, engineLogs, ...analytics };
   }
   createRuntimeChat(persisted) {
     const saveSession = async (sessionId) => {
@@ -15839,7 +16227,7 @@ var ChatService = class {
       }
       chat.hasActiveTurn = true;
       chat.activeMessageId = messageId;
-      noteTurnStarted(chat.persisted.id, messageId, chat.persisted.provider);
+      this.analyticsService.noteTurnStarted(chat.persisted.id, messageId, chat.persisted.provider);
       chat.activeErrorNotificationTarget = chat.errorNotificationTargets.get(messageId) ?? null;
       chat.errorNotificationTargets.delete(messageId);
       this.publish({
@@ -15852,6 +16240,18 @@ var ChatService = class {
       });
     }
     const codexTranscript = getCodexTranscriptFromEvent(event);
+    if (chat.hasActiveTurn) {
+      const displayMessages = parseDisplayMessages(
+        codexTranscript ? [] : [event],
+        chat.persisted.provider,
+        codexTranscript,
+        {
+          filter: false,
+          parentToolUseId: typeof event.payload.parent_tool_use_id === "string" ? event.payload.parent_tool_use_id : null
+        }
+      );
+      this.analyticsService.noteSkillMcpCalls(chatId, displayMessages);
+    }
     const terminalErrors = terminalErrorsFromEvent(event, chat.persisted.provider, codexTranscript);
     if (terminalErrors !== void 0) {
       chat.lastTurnErrors = terminalErrors;
@@ -15914,7 +16314,7 @@ var ChatService = class {
     }
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
-    noteTurnEnded(chatId);
+    this.analyticsService.noteTurnEnded(chatId);
     this.publish({
       type: "chat.turn.completed",
       payload: {
@@ -17912,7 +18312,8 @@ var authMiddleware = async (c, next) => {
   }
   await next();
 };
-var chatService = new ChatService(gitService.getWorkspaceRoot());
+var analyticsService = new AnalyticsService();
+var chatService = new ChatService(gitService.getWorkspaceRoot(), analyticsService);
 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.552",
+  "version": "0.1.553",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",