replicas-engine 0.1.608 → 0.1.610

package/README.md

@@ -134,6 +134,8 @@ Outgoing endpoints:
 - `POST /v1/engine/claude/refresh-credentials`
 - `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`
+- `POST /v1/engine/chat-turn-activity`
+- `POST /v1/engine/skill-activity`
+- `POST /v1/engine/mcp-activity`
+
+The previous `chat-turn-usage`, `skill-usage`, and `mcp-usage` paths remain accepted for older engine versions.

package/dist/src/index.js

@@ -263,7 +263,7 @@ var AGENT_CREDENTIAL_METHODS_IN_ORDER = {
 };
 
 // ../shared/src/analytics/types.ts
-function isUsageRecord(value) {
+function isAgentChatActivityRecord(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) {
@@ -272,22 +272,22 @@ function isAuthMethod(value) {
 function isCredentialScope(value) {
   return typeof value === "string" && CREDENTIAL_SCOPES.some((scope) => scope === value);
 }
-function isChatTurnUsageRecord(value) {
-  return isUsageRecord(value) && typeof value.turnId === "string" && typeof value.seconds === "number" && Number.isFinite(value.seconds) && value.seconds >= 0;
+function isAgentChatTurnActivityRecord(value) {
+  return isAgentChatActivityRecord(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 isAgentChatActivityCallRecord(value) {
+  return isAgentChatActivityRecord(value) && typeof value.callId === "string" && value.callId.length > 0;
 }
-function isNamedCallUsageRecord(value, field) {
-  if (!isCallUsageRecord(value)) return false;
+function isNamedAgentChatActivityRecord(value, field) {
+  if (!isAgentChatActivityCallRecord(value)) return false;
   const name = value[field];
   return typeof name === "string" && name.length > 0;
 }
-function isSkillUsageRecord(value) {
-  return isNamedCallUsageRecord(value, "skillName");
+function isAgentChatSkillActivityRecord(value) {
+  return isNamedAgentChatActivityRecord(value, "skillName");
 }
-function isMcpUsageRecord(value) {
-  return isNamedCallUsageRecord(value, "mcpName");
+function isAgentChatMcpActivityRecord(value) {
+  return isNamedAgentChatActivityRecord(value, "mcpName");
 }
 
 // ../shared/src/aster.ts
@@ -7594,13 +7594,13 @@ import { mkdir as mkdir7 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { join as join12 } from "path";
 import { randomUUID } from "crypto";
-var ENGINE_DIR = join12(homedir9(), ".replicas", "engine");
-var EVENTS_FILE = join12(ENGINE_DIR, "events.jsonl");
+var ENGINE_DIR2 = join12(homedir9(), ".replicas", "engine");
+var EVENTS_FILE = join12(ENGINE_DIR2, "events.jsonl");
 var EventService = class {
   subscribers = /* @__PURE__ */ new Map();
   writer = new StreamWriter();
   async initialize() {
-    await mkdir7(ENGINE_DIR, { recursive: true });
+    await mkdir7(ENGINE_DIR2, { recursive: true });
     this.writer.open(EVENTS_FILE);
   }
   subscribe(subscriber) {
@@ -10670,7 +10670,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.608";
+var ENGINE_PACKAGE_VERSION = "0.1.610";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -11599,14 +11599,14 @@ var TranscriptUpdateCoalescer = class {
 // src/services/chat/history-paths.ts
 import { homedir as homedir13 } from "os";
 import { join as join17 } from "path";
-var ENGINE_DIR2 = join17(homedir13(), ".replicas", "engine");
-var CHATS_FILE = join17(ENGINE_DIR2, "chats.json");
-var CLAUDE_HISTORY_DIR = join17(ENGINE_DIR2, "claude-histories");
-var RELAY_HISTORY_DIR = join17(ENGINE_DIR2, "relay-histories");
-var CODEX_HISTORY_DIR = join17(ENGINE_DIR2, "codex-histories");
-var CURSOR_HISTORY_DIR = join17(ENGINE_DIR2, "cursor-histories");
-var OPENCODE_HISTORY_DIR = join17(ENGINE_DIR2, "opencode-histories");
-var PI_HISTORY_DIR = join17(ENGINE_DIR2, "pi-histories");
+var ENGINE_DIR3 = join17(homedir13(), ".replicas", "engine");
+var CHATS_FILE = join17(ENGINE_DIR3, "chats.json");
+var CLAUDE_HISTORY_DIR = join17(ENGINE_DIR3, "claude-histories");
+var RELAY_HISTORY_DIR = join17(ENGINE_DIR3, "relay-histories");
+var CODEX_HISTORY_DIR = join17(ENGINE_DIR3, "codex-histories");
+var CURSOR_HISTORY_DIR = join17(ENGINE_DIR3, "cursor-histories");
+var OPENCODE_HISTORY_DIR = join17(ENGINE_DIR3, "opencode-histories");
+var PI_HISTORY_DIR = join17(ENGINE_DIR3, "pi-histories");
 var HISTORY_DIR_BY_PROVIDER = {
   claude: CLAUDE_HISTORY_DIR,
   relay: RELAY_HISTORY_DIR,
@@ -14966,34 +14966,93 @@ var RelayManager = class {
   }
 };
 
-// src/analytics/analytics.service.ts
+// src/analytics/agent/activity/agent-chat-activity-tracker-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";
 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";
+// src/analytics/agent/activity/skill-mcp-call-extractor.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 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 AnalyticsBufferService = class {
+var MAX_TRACKED_MESSAGES = 500;
+var AgentChatActivityBuffer = class {
   constructor(options) {
     this.options = options;
-    this.liveFile = join22(ENGINE_DIR2, `${options.name}.jsonl`);
-    this.segmentFilePattern = new RegExp(`^${options.name}\\.(\\d+)\\.jsonl$`);
+    this.storageNames = [
+      options.storageName,
+      ...options.legacyStorageNames ?? []
+    ];
+    this.liveFile = join22(ENGINE_DIR, `${options.storageName}.jsonl`);
+    this.segmentFilePatterns = this.storageNames.map(
+      (storageName) => new RegExp(`^${storageName}\\.(\\d+)\\.jsonl$`)
+    );
   }
   options;
   liveFile;
-  segmentFilePattern;
+  storageNames;
+  segmentFilePatterns;
   failedRecords = [];
   pendingAppends = /* @__PURE__ */ new Set();
   flushTimer = null;
-  activeFlush = Promise.resolve({ flushed: 0, failed: 0 });
+  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);
+    const pending = mkdir14(ENGINE_DIR, { 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);
     });
     this.pendingAppends.add(pending);
     void pending.finally(() => this.pendingAppends.delete(pending));
@@ -15003,7 +15062,10 @@ var AnalyticsBufferService = class {
     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);
+        console.error(
+          `[${this.options.storageName}] Scheduled flush failed, retrying on the next record:`,
+          error
+        );
       });
     }, FLUSH_DEBOUNCE_MS);
     this.flushTimer.unref?.();
@@ -15019,20 +15081,30 @@ var AnalyticsBufferService = class {
   }
   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(() => []);
+    while (this.pendingAppends.size > 0)
+      await Promise.allSettled([...this.pendingAppends]);
+    for (const storageName of this.storageNames) {
+      await rename2(
+        join22(ENGINE_DIR, `${storageName}.jsonl`),
+        join22(ENGINE_DIR, `${storageName}.${Date.now()}.jsonl`)
+      ).catch(() => {
+      });
+    }
+    const entries = await readdir6(ENGINE_DIR).catch(() => []);
     let flushed = 0;
     let failed = 0;
     for (const entry of entries) {
-      if (!this.segmentFilePattern.test(entry)) continue;
+      if (!this.segmentFilePatterns.some((pattern) => pattern.test(entry)))
+        continue;
       try {
-        await this.uploadSegment(join22(ENGINE_DIR2, entry));
+        await this.uploadSegment(join22(ENGINE_DIR, entry));
         flushed++;
       } catch (error) {
         failed++;
-        console.error(`[${this.options.name}] Segment upload failed, retained for retry:`, { entry, error });
+        console.error(
+          `[${this.options.storageName}] Segment upload failed, retained for retry:`,
+          { entry, error }
+        );
       }
     }
     const failedRecords = this.failedRecords.splice(0);
@@ -15042,13 +15114,22 @@ var AnalyticsBufferService = class {
         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);
+        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) => entry.startsWith(`${this.options.name}.`) && entry.endsWith(UPLOADED_SUFFIX)).sort();
+    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(join22(ENGINE_DIR2, entry)).catch(() => {
+      await unlink3(join22(ENGINE_DIR, entry)).catch(() => {
       });
     }
     return { flushed, failed };
@@ -15067,66 +15148,40 @@ var AnalyticsBufferService = class {
     });
   }
 };
-
-// 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;
+var AgentChatActivityRecordTracker = class {
+  pendingRecords = /* @__PURE__ */ new Map();
+  buffer;
+  constructor(options) {
+    this.buffer = new AgentChatActivityBuffer(options);
   }
-  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/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 {
+  track(chatId, record) {
+    const records = this.pendingRecords.get(chatId) ?? [];
+    records.push(record);
+    this.pendingRecords.set(chatId, records);
+  }
+  noteTurnEnded(chatId) {
+    const records = this.pendingRecords.get(chatId);
+    if (!records) return;
+    this.pendingRecords.delete(chatId);
+    for (const record of records) this.buffer.append(record);
+    this.buffer.scheduleFlush();
+  }
+  flush() {
+    return this.buffer.flush();
+  }
+};
+var AgentChatTurnActivityTracker = 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 })
-  });
-  skillBuffer = new AnalyticsBufferService({
-    name: "skill-usage",
-    validate: isSkillUsageRecord,
-    upload: (skills) => uploadAnalyticsRecords("/v1/engine/skill-usage", { skills })
-  });
-  mcpBuffer = new AnalyticsBufferService({
-    name: "mcp-usage",
-    validate: isMcpUsageRecord,
-    upload: (mcps) => uploadAnalyticsRecords("/v1/engine/mcp-usage", { mcps })
-  });
+  turnBuffer;
+  constructor(uploadTurns) {
+    this.turnBuffer = new AgentChatActivityBuffer({
+      storageName: "chat-turn-activity",
+      legacyStorageNames: ["turn-usage"],
+      validate: isAgentChatTurnActivityRecord,
+      upload: uploadTurns
+    });
+  }
   noteMessageAccepted(messageId, request) {
     this.pendingMessages.set(messageId, {
       model: request.model,
@@ -15149,30 +15204,14 @@ var AnalyticsService = class {
       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, turn.provider)) {
-      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 });
-    }
+  getActiveTurn(chatId) {
+    return this.activeTurns.get(chatId);
+  }
+  getActiveChatIds() {
+    return [...this.activeTurns.keys()];
   }
   noteTurnEnded(chatId) {
     const turn = this.activeTurns.get(chatId);
@@ -15189,22 +15228,91 @@ var AnalyticsService = class {
       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();
+  }
+  flush() {
+    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 })
+    );
+    this.skillActivityTracker = new AgentChatActivityRecordTracker({
+      storageName: "skill-activity",
+      legacyStorageNames: ["skill-usage"],
+      validate: isAgentChatSkillActivityRecord,
+      upload: (skills) => uploadAgentChatActivity("/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 })
+    });
+  }
+  noteMessageAccepted(messageId, request) {
+    this.turnActivityTracker.noteMessageAccepted(messageId, request);
+  }
+  noteTurnStarted(chatId, messageId, provider) {
+    this.turnActivityTracker.noteTurnStarted(chatId, messageId, provider);
+  }
+  noteSkillMcpCalls(chatId, messages) {
+    const turn = this.turnActivityTracker.getActiveTurn(chatId);
+    if (!turn) return;
+    for (const call of extractSkillMcpCalls(messages, turn.provider)) {
+      if (turn.seenCallIds.has(call.id)) continue;
+      turn.seenCallIds.add(call.id);
+      const activityRecord = {
+        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") {
+        this.skillActivityTracker.track(chatId, {
+          ...activityRecord,
+          skillName: call.skillName
+        });
+      } else {
+        this.mcpActivityTracker.track(chatId, {
+          ...activityRecord,
+          mcpName: call.mcpName
+        });
+      }
+    }
+  }
+  noteTurnEnded(chatId) {
+    this.skillActivityTracker.noteTurnEnded(chatId);
+    this.mcpActivityTracker.noteTurnEnded(chatId);
+    this.turnActivityTracker.noteTurnEnded(chatId);
   }
   async flush(finalizeInFlight = true) {
     if (finalizeInFlight) {
-      for (const chatId of this.activeTurns.keys()) this.noteTurnEnded(chatId);
+      for (const chatId of this.turnActivityTracker.getActiveChatIds())
+        this.noteTurnEnded(chatId);
     }
-    const [turnUsage, skillUsage, mcpUsage] = await Promise.all([
-      this.turnBuffer.flush(),
-      this.skillBuffer.flush(),
-      this.mcpBuffer.flush()
+    const [turnActivity, skillActivity, mcpActivity] = await Promise.all([
+      this.turnActivityTracker.flush(),
+      this.skillActivityTracker.flush(),
+      this.mcpActivityTracker.flush()
     ]);
-    return { turnUsage, skillUsage, mcpUsage };
+    return { turnActivity, skillActivity, mcpActivity };
   }
 };
 
@@ -15490,7 +15598,7 @@ import { basename as basename2, join as join25 } from "path";
 
 // src/services/chat/chat-senders.ts
 import { join as join24 } from "path";
-var CHAT_SENDERS_DIR = join24(ENGINE_DIR2, "chat-senders");
+var CHAT_SENDERS_DIR = join24(ENGINE_DIR3, "chat-senders");
 function chatMessageSendersFilePath(chatId) {
   return join24(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
 }
@@ -15508,9 +15616,9 @@ function parseChatMessageSendersJsonl(content) {
 
 // src/services/upload-chat-transcripts.ts
 var HISTORY_DIRS = [
-  join25(ENGINE_DIR2, "claude-histories"),
-  join25(ENGINE_DIR2, "relay-histories"),
-  join25(ENGINE_DIR2, "codex-histories")
+  join25(ENGINE_DIR3, "claude-histories"),
+  join25(ENGINE_DIR3, "relay-histories"),
+  join25(ENGINE_DIR3, "codex-histories")
 ];
 async function putTranscript(uploadUrl, filePath, size) {
   await new Promise((resolve5, reject) => {
@@ -15881,20 +15989,20 @@ function corruptChatsFilePath() {
   return `${CHATS_FILE}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
 }
 var ChatService = class {
-  constructor(workingDirectory, analyticsService2) {
+  constructor(workingDirectory, agentChatActivityTrackerService2) {
     this.workingDirectory = workingDirectory;
-    this.analyticsService = analyticsService2;
+    this.agentChatActivityTrackerService = agentChatActivityTrackerService2;
     keepAliveService.setActivityCheck(
       () => [...this.chats.values()].some((chat) => !chat.persisted.deletedAt && hasActiveAgentWork(chat))
     );
   }
   workingDirectory;
-  analyticsService;
+  agentChatActivityTrackerService;
   chats = /* @__PURE__ */ new Map();
   persistInFlight = false;
   persistQueued = false;
   async initialize() {
-    await mkdir15(ENGINE_DIR2, { recursive: true });
+    await mkdir15(ENGINE_DIR3, { recursive: true });
     await mkdir15(CLAUDE_HISTORY_DIR, { recursive: true });
     await mkdir15(RELAY_HISTORY_DIR, { recursive: true });
     await mkdir15(CODEX_HISTORY_DIR, { recursive: true });
@@ -16011,7 +16119,7 @@ var ChatService = class {
       request.images
     );
     chat.pendingMessageIds.push(result.messageId);
-    this.analyticsService.noteMessageAccepted(result.messageId, request);
+    this.agentChatActivityTrackerService.noteMessageAccepted(result.messageId, request);
     if (request.errorNotificationTarget) {
       chat.errorNotificationTargets.set(result.messageId, request.errorNotificationTarget);
     }
@@ -16067,7 +16175,7 @@ var ChatService = class {
   async interrupt(chatId) {
     const chat = this.requireChat(chatId);
     const result = await chat.provider.interrupt();
-    this.analyticsService.noteTurnEnded(chatId);
+    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     chat.pendingMessageIds = [];
@@ -16089,7 +16197,7 @@ var ChatService = class {
       return { interrupted: false, queue: [], goal: null };
     }
     const interruptResult = await chat.provider.interrupt();
-    this.analyticsService.noteTurnEnded(chatId);
+    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     chat.pendingMessageIds = [];
@@ -16176,7 +16284,7 @@ var ChatService = class {
       messageId,
       ...chat.pendingMessageIds.filter((pendingMessageId) => pendingMessageId !== messageId && pendingMessageId !== interruptedMessageId)
     ];
-    this.analyticsService.noteTurnEnded(chatId);
+    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
     if (interruptedMessageId) {
@@ -16310,14 +16418,22 @@ var ChatService = class {
     const chatsById = new Map(
       [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toSummary(chat)])
     );
-    const [chatTranscripts, canvas, repoState, engineLogs, analytics] = await Promise.all([
+    const [chatTranscripts, canvas, repoState, engineLogs, chatActivity] = await Promise.all([
       flushAllChatTranscripts(chatsById),
       flushAllCanvasItems(),
       flushRepoState(),
       flushAllEngineLogs(),
-      this.analyticsService.flush()
+      this.agentChatActivityTrackerService.flush()
     ]);
-    return { chatTranscripts, canvas, repoState, engineLogs, ...analytics };
+    return {
+      chatTranscripts,
+      canvas,
+      repoState,
+      engineLogs,
+      turnActivity: chatActivity.turnActivity,
+      skillActivity: chatActivity.skillActivity,
+      mcpActivity: chatActivity.mcpActivity
+    };
   }
   createRuntimeChat(persisted) {
     const saveSession = async (sessionId) => {
@@ -16474,7 +16590,7 @@ var ChatService = class {
       }
       chat.hasActiveTurn = true;
       chat.activeMessageId = messageId;
-      this.analyticsService.noteTurnStarted(chat.persisted.id, messageId, chat.persisted.provider);
+      this.agentChatActivityTrackerService.noteTurnStarted(chat.persisted.id, messageId, chat.persisted.provider);
       chat.activeErrorNotificationTarget = chat.errorNotificationTargets.get(messageId) ?? null;
       chat.errorNotificationTargets.delete(messageId);
       this.publish({
@@ -16492,7 +16608,7 @@ var ChatService = class {
         filter: false,
         parentToolUseId: typeof event.payload.parent_tool_use_id === "string" ? event.payload.parent_tool_use_id : null
       });
-      this.analyticsService.noteSkillMcpCalls(chatId, displayMessages);
+      this.agentChatActivityTrackerService.noteSkillMcpCalls(chatId, displayMessages);
     }
     const terminalErrors = terminalErrorsFromEvent(event, chat.persisted.provider, codexTranscript);
     if (terminalErrors !== void 0) {
@@ -16556,7 +16672,7 @@ var ChatService = class {
     }
     chat.hasActiveTurn = false;
     chat.activeMessageId = null;
-    this.analyticsService.noteTurnEnded(chatId);
+    this.agentChatActivityTrackerService.noteTurnEnded(chatId);
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.publish({
       type: "chat.turn.completed",
@@ -18592,8 +18708,8 @@ var authMiddleware = async (c, next) => {
   }
   await next();
 };
-var analyticsService = new AnalyticsService();
-var chatService = new ChatService(gitService.getWorkspaceRoot(), analyticsService);
+var agentChatActivityTrackerService = new AgentChatActivityTrackerService();
+var chatService = new ChatService(gitService.getWorkspaceRoot(), agentChatActivityTrackerService);
 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.608",
+  "version": "0.1.610",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",