replicas-engine 0.1.697 → 0.1.698

package/dist/src/{chunk-2YKP6MBQ.js → chunk-2BBE2BVQ.js}

@@ -724,6 +724,10 @@ function coerceClaudePartialMessagePayload(payload) {
     status: payload.status === "completed" ? "completed" : "in_progress"
   };
 }
+function getClaudePartialMessageStreamId(event) {
+  if (event.type !== CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE) return null;
+  return typeof event.payload.streamId === "string" && event.payload.streamId ? event.payload.streamId : null;
+}
 var ACCEPTED_USER_MESSAGE_SOURCE = "replicas-chat-turn-accepted";
 var USER_MESSAGE_ID_PAYLOAD_KEY = "replicasMessageId";
 var CODEX_ASP_ITEM_ID_PAYLOAD_KEY = "codexAspItemId";
@@ -4059,10 +4063,11 @@ function getEventTimestampMs(event) {
 function areSameUserMessageEvents(a, b) {
   const aMessage = getUserMessage(a);
   const bMessage = getUserMessage(b);
-  if (!aMessage || aMessage !== bMessage) return false;
+  if (!aMessage || !bMessage) return false;
   const aMessageId = getUserMessageId(a);
   const bMessageId = getUserMessageId(b);
   if (aMessageId || bMessageId) return aMessageId === bMessageId;
+  if (aMessage !== bMessage) return false;
   const aItemId = getUserMessageItemId(a);
   const bItemId = getUserMessageItemId(b);
   if (aItemId || bItemId) return aItemId === bItemId;
@@ -4562,7 +4567,7 @@ function parseCursorEvents(events) {
       const message = event.payload.message;
       if (typeof message === "string" && message.trim()) {
         messages.push({
-          id: `cursor-user-${event.timestamp}-${messages.length}`,
+          id: getUserMessageId(event) ?? `cursor-user-${event.timestamp}-${messages.length}`,
           type: "user",
           content: message,
           timestamp: event.timestamp
@@ -5143,7 +5148,7 @@ function parsePiEvents(events) {
   let activeMessageId = "assistant";
   for (const event of events) {
     if (event.type === "event_msg" && event.payload.type === "user_message" && typeof event.payload.message === "string") {
-      messages.push({ id: `pi-user-${event.timestamp}-${messages.length}`, type: "user", content: event.payload.message, timestamp: event.timestamp });
+      messages.push({ id: getUserMessageId(event) ?? `pi-user-${event.timestamp}-${messages.length}`, type: "user", content: event.payload.message, timestamp: event.timestamp });
       if (typeof event.payload.skillName === "string" && event.payload.skillName) {
         messages.push({
           id: `pi-skill-${event.timestamp}-${messages.length}`,
@@ -6184,7 +6189,12 @@ function parseAgentEvents(events, agentType) {
 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;
+  const reconciledEvents = [];
+  for (const message of parsedEvents) {
+    if (message.type === "user") upsertDisplayMessage(reconciledEvents, message);
+    else reconciledEvents.push(message);
+  }
+  const legacyMessages = shouldFilter ? filterDisplayMessages(reconciledEvents, agentType) : reconciledEvents;
   const applySyntheticNotices = (messages) => shouldFilter ? applyAuthFallbackNotices(applyInterruptions(messages, events), events) : messages;
   if (agentType !== "codex" || !codexAspTranscript) {
     return applySyntheticNotices(legacyMessages);
@@ -6765,7 +6775,7 @@ var DEFAULT_CODEX_ARGS = [
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.697";
+var ENGINE_PACKAGE_VERSION = "0.1.698";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -7037,6 +7047,8 @@ export {
   isAgentChatSkillActivityRecord,
   isAgentChatMcpActivityRecord,
   CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE,
+  getClaudePartialMessageStreamId,
+  ACCEPTED_USER_MESSAGE_SOURCE,
   USER_MESSAGE_ID_PAYLOAD_KEY,
   CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE,
   CODEX_QUOTA_STATUS_EVENT_TYPE,

package/dist/src/headless-agent.js

@@ -7,7 +7,7 @@ import {
   headlessAgentRequestSchema,
   putPresignedFile,
   recoverCompletedTurn
-} from "./chunk-2YKP6MBQ.js";
+} from "./chunk-2BBE2BVQ.js";
 
 // src/headless-agent.ts
 import { createHash } from "crypto";

package/dist/src/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  ACCEPTED_USER_MESSAGE_SOURCE,
   ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
   AGENT,
   AGENT_MESSAGE_DELTA_METHOD,
@@ -131,6 +132,7 @@ import {
   getChatHistoryPageWindow,
   getChatTranscriptHistorySize,
   getClaudeModelContextWindow,
+  getClaudePartialMessageStreamId,
   getCodexAspTurnResponse,
   getDeepseekAssistantMessageText,
   getDefaultAgentModel,
@@ -192,13 +194,13 @@ import {
   serializeCanvasContentResponse,
   shellQuotePosix,
   stripAgentDiagnosticErrors
-} from "./chunk-2YKP6MBQ.js";
+} from "./chunk-2BBE2BVQ.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
 import { existsSync as existsSync11 } from "fs";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { connect } from "net";
 
 // src/managers/github-token-manager.ts
@@ -569,6 +571,7 @@ var MonolithService = class {
 var monolithService = new MonolithService();
 
 // src/utils/file.ts
+import { randomUUID } from "crypto";
 import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
 import { dirname, join as join3 } from "path";
 
@@ -587,7 +590,7 @@ var AsyncLock = class {
 
 // src/utils/file.ts
 async function atomicWriteFile(path6, data, options) {
-  const tmpFile = `${path6}.${process.pid}.${Date.now()}.tmp`;
+  const tmpFile = `${path6}.${process.pid}.${randomUUID()}.tmp`;
   try {
     await writeFile(tmpFile, data, { encoding: "utf-8", mode: options?.mode });
     await rename(tmpFile, path6);
@@ -2663,7 +2666,7 @@ var replicasConfigService = new ReplicasConfigService();
 import { mkdir as mkdir7 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { join as join12 } from "path";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var ENGINE_DIR = join12(homedir9(), ".replicas", "engine");
 var EVENTS_FILE = join12(ENGINE_DIR, "events.jsonl");
 var EventService = class {
@@ -2674,7 +2677,7 @@ var EventService = class {
     this.writer.open(EVENTS_FILE);
   }
   subscribe(subscriber) {
-    const id = randomUUID();
+    const id = randomUUID2();
     this.subscribers.set(id, subscriber);
     return () => {
       this.subscribers.delete(id);
@@ -2698,7 +2701,7 @@ var eventService = new EventService();
 // src/services/preview-service.ts
 import { mkdir as mkdir8, readFile as readFile7 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { homedir as homedir10 } from "os";
 import { dirname as dirname2, join as join13 } from "path";
 var PREVIEW_PORTS_FILE = join13(homedir10(), ".replicas", "preview-ports.json");
@@ -2737,7 +2740,7 @@ var PreviewService = class {
     data.previews.push(preview);
     await writePreviewsFile(data);
     eventService.publish({
-      id: randomUUID2(),
+      id: randomUUID3(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "preview.changed",
       payload: { previews: data.previews }
@@ -2757,7 +2760,7 @@ var PreviewService = class {
     }
     await writePreviewsFile(data);
     eventService.publish({
-      id: randomUUID2(),
+      id: randomUUID3(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "preview.changed",
       payload: { previews: data.previews }
@@ -2814,13 +2817,138 @@ async function registerDesktopPreview() {
 import { existsSync as existsSync8 } 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 randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
+
+// ../shared/src/workspace-chat.ts
+var WORKSPACE_CHATS_QUERY_SCHEMA_VERSION = 1;
+var WORKSPACE_CHATS_QUERY_ROOT = `workspace-chats:v${WORKSPACE_CHATS_QUERY_SCHEMA_VERSION}`;
+function isAcceptedUserMessage(event) {
+  return getUserMessage(event) !== null && event.payload.source === ACCEPTED_USER_MESSAGE_SOURCE;
+}
+function getComparableUserMessage(event) {
+  const message = getUserMessage(event);
+  if (message !== null) return message;
+  const payloadMessage = event.payload.message;
+  if (event.type !== "claude-user" || typeof payloadMessage !== "object" || payloadMessage === null || !("content" in payloadMessage)) {
+    return null;
+  }
+  return extractToolResultText(payloadMessage.content) || null;
+}
+function areDuplicateUserMessages(a, b) {
+  if (areSameUserMessageEvents(a, b)) return true;
+  const aMessage = getComparableUserMessage(a);
+  const bMessage = getComparableUserMessage(b);
+  if (!aMessage || aMessage !== bMessage) return false;
+  const aAccepted = isAcceptedUserMessage(a);
+  const bAccepted = isAcceptedUserMessage(b);
+  return aAccepted !== bAccepted ? areUserMessagesWithinMatchWindow(
+    { content: aMessage, timestamp: a.timestamp },
+    { content: bMessage, timestamp: b.timestamp }
+  ) : false;
+}
+var eventJsonCache = /* @__PURE__ */ new WeakMap();
+function workspaceChatEventSignals(event) {
+  let json = eventJsonCache.get(event);
+  if (json === void 0) {
+    json = JSON.stringify(event);
+    eventJsonCache.set(event, json);
+  }
+  return {
+    streamId: getClaudePartialMessageStreamId(event),
+    json,
+    userMessage: getComparableUserMessage(event),
+    userMessageId: getUserMessageId(event)
+  };
+}
+function indexMergedEvent(index, event, position) {
+  const { streamId, json, userMessage, userMessageId } = workspaceChatEventSignals(event);
+  if (streamId !== null && !index.byStreamId.has(streamId)) {
+    index.byStreamId.set(streamId, position);
+  }
+  if (!index.byJson.has(json)) index.byJson.set(json, position);
+  if (userMessageId !== null && !index.byUserMessageId.has(userMessageId)) {
+    index.byUserMessageId.set(userMessageId, position);
+  }
+  if (userMessage !== null) {
+    const bucket = index.byUserMessage.get(userMessage);
+    if (!bucket) {
+      index.byUserMessage.set(userMessage, [{ position, event }]);
+      return;
+    }
+    const insertAt = bucket.findIndex((entry) => entry.position > position);
+    bucket.splice(insertAt === -1 ? bucket.length : insertAt, 0, { position, event });
+  }
+}
+function reindexReplacedEvent(index, previous, event, position) {
+  const { streamId, json, userMessage, userMessageId } = workspaceChatEventSignals(previous);
+  if (streamId !== null && index.byStreamId.get(streamId) === position) {
+    index.byStreamId.delete(streamId);
+  }
+  if (index.byJson.get(json) === position) index.byJson.delete(json);
+  if (userMessageId !== null && index.byUserMessageId.get(userMessageId) === position) {
+    index.byUserMessageId.delete(userMessageId);
+  }
+  if (userMessage !== null) {
+    const bucket = index.byUserMessage.get(userMessage) ?? [];
+    const entryIndex = bucket.findIndex((entry) => entry.position === position);
+    if (entryIndex !== -1) bucket.splice(entryIndex, 1);
+    if (bucket.length === 0) {
+      index.byUserMessage.delete(userMessage);
+    }
+  }
+  indexMergedEvent(index, event, position);
+}
+function findDuplicatePosition(index, event) {
+  const { streamId, json, userMessage, userMessageId } = workspaceChatEventSignals(event);
+  let match = -1;
+  const consider = (position) => {
+    if (position !== void 0 && (match === -1 || position < match)) match = position;
+  };
+  if (streamId !== null) consider(index.byStreamId.get(streamId));
+  consider(index.byJson.get(json));
+  if (userMessageId !== null) consider(index.byUserMessageId.get(userMessageId));
+  if (userMessage !== null) {
+    for (const entry of index.byUserMessage.get(userMessage) ?? []) {
+      if (areDuplicateUserMessages(entry.event, event)) {
+        consider(entry.position);
+        break;
+      }
+    }
+  }
+  return match;
+}
+function mergeWorkspaceChatHistoryEvents(primary, supplemental) {
+  if (supplemental.length === 0) return [...primary];
+  const merged = [...primary];
+  const index = {
+    byStreamId: /* @__PURE__ */ new Map(),
+    byJson: /* @__PURE__ */ new Map(),
+    byUserMessageId: /* @__PURE__ */ new Map(),
+    byUserMessage: /* @__PURE__ */ new Map()
+  };
+  for (let position = 0; position < merged.length; position++) {
+    indexMergedEvent(index, merged[position], position);
+  }
+  for (const event of supplemental) {
+    const position = findDuplicatePosition(index, event);
+    const messageId = getUserMessageId(event);
+    if (position === -1) {
+      indexMergedEvent(index, event, merged.length);
+      merged.push(event);
+    } else if (getClaudePartialMessageStreamId(event) !== null || isAcceptedUserMessage(merged[position]) && !isAcceptedUserMessage(event) || messageId !== null && messageId === getUserMessageId(merged[position])) {
+      const previous = merged[position];
+      merged[position] = event;
+      reindexReplacedEvent(index, previous, event, position);
+    }
+  }
+  return merged;
+}
 
 // src/managers/claude-manager.ts
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname4, join as join17 } from "path";
 import { mkdir as mkdir10 } from "fs/promises";
 import { homedir as homedir12 } from "os";
@@ -3206,7 +3334,7 @@ function extractPlanFromCodexAspNotification(notification) {
 }
 
 // src/utils/image-utils.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { mkdir as mkdir9, unlink as unlink2, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 import { join as join14 } from "path";
@@ -3315,7 +3443,7 @@ async function saveNormalizedImagesToTempFiles(images, tempImageDir = join14(hom
   try {
     for (const image of images) {
       const ext = image.source.media_type.split("/")[1] || "png";
-      const filename = `img_${randomUUID3()}.${ext}`;
+      const filename = `img_${randomUUID4()}.${ext}`;
       const filepath = join14(tempImageDir, filename);
       await writeFile5(filepath, Buffer.from(image.source.data, "base64"));
       tempPaths.push(filepath);
@@ -3385,6 +3513,12 @@ var MessageQueueService = class {
   onProcessingChanged;
   onMessageStarted;
   acceptanceByMessage = /* @__PURE__ */ new WeakMap();
+  // A withdrawal mark implies the entry was present when its acceptance
+  // rejected; intentional removals (remove, clear, drain, steer) can never
+  // coincide with it, so recovery only needs this mark plus the cancellation
+  // version below.
+  acceptanceWithdrawals = /* @__PURE__ */ new WeakSet();
+  queueCancellationVersion = 0;
   constructor(processMessage, onProcessingChanged = () => {
   }, onMessageStarted = async () => {
   }) {
@@ -3403,13 +3537,32 @@ var MessageQueueService = class {
   }) {
     if (this.processing && this.canMergeIntoTail(request)) {
       const tail = this.queue[this.queue.length - 1];
-      this.mergeInto(tail, request);
       const response2 = {
         queued: true,
         messageId: tail.id,
         position: this.queue.length
       };
-      const acceptance = (this.acceptanceByMessage.get(tail) ?? Promise.resolve()).then(() => onAccepted(response2));
+      const cancellationVersion = this.queueCancellationVersion;
+      const prior = this.acceptanceByMessage.get(tail) ?? Promise.resolve();
+      const acceptance = prior.catch(() => {
+      }).then(async () => {
+        let acceptedMessage;
+        while (true) {
+          const baseMessage = tail.message;
+          acceptedMessage = {
+            ...tail,
+            message: `${baseMessage}${MERGED_MESSAGE_SEPARATOR}${request.message}`,
+            ...tail.images || request.images?.length ? { images: [...tail.images ?? [], ...request.images ?? []] } : {}
+          };
+          await onAccepted(response2, acceptedMessage);
+          if (tail.message === baseMessage) break;
+        }
+        tail.message = acceptedMessage.message;
+        if (acceptedMessage.images) tail.images = [...acceptedMessage.images];
+        if (!this.queue.includes(tail) && this.queueCancellationVersion === cancellationVersion && this.acceptanceWithdrawals.delete(tail)) {
+          this.queue.push(tail);
+        }
+      });
       this.acceptanceByMessage.set(tail, acceptance);
       await acceptance;
       return response2;
@@ -3430,7 +3583,14 @@ var MessageQueueService = class {
         messageId,
         position: this.queue.length
       };
-      const acceptance = onAccepted(response2);
+      const acceptance = onAccepted(response2, queuedMessage).catch((error) => {
+        const index = this.queue.indexOf(queuedMessage);
+        if (index !== -1) {
+          this.queue.splice(index, 1);
+          this.acceptanceWithdrawals.add(queuedMessage);
+        }
+        throw error;
+      });
       this.acceptanceByMessage.set(queuedMessage, acceptance);
       await acceptance;
       return response2;
@@ -3440,7 +3600,7 @@ var MessageQueueService = class {
       messageId,
       position: 0
     };
-    await onAccepted(response);
+    await onAccepted(response, queuedMessage);
     this.startProcessing(queuedMessage).catch((error) => {
       console.error("[MessageQueue] Unhandled error in startProcessing:", error);
     });
@@ -3452,12 +3612,6 @@ var MessageQueueService = class {
     if (!tail) return false;
     return tail.merge === true && tail.type === request.type;
   }
-  mergeInto(tail, request) {
-    tail.message = `${tail.message}${MERGED_MESSAGE_SEPARATOR}${request.message}`;
-    if (request.images && request.images.length > 0) {
-      tail.images = [...tail.images ?? [], ...request.images];
-    }
-  }
   async startProcessing(queuedMessage) {
     this.processing = true;
     this.onProcessingChanged(true);
@@ -3506,6 +3660,7 @@ var MessageQueueService = class {
       drained.push(text);
       totalChars += text.length;
     }
+    this.queueCancellationVersion++;
     this.queue = [];
     return drained;
   }
@@ -3526,9 +3681,10 @@ var MessageQueueService = class {
     return true;
   }
   clearQueue() {
-    if (this.queue.length === 0) return false;
+    const hadMessages = this.queue.length > 0;
+    this.queueCancellationVersion++;
     this.queue = [];
-    return true;
+    return hadMessages;
   }
   updateQueuedMessage(messageId, message) {
     const queuedMessage = this.queue.find((item) => item.id === messageId);
@@ -3569,6 +3725,7 @@ var MessageQueueService = class {
    * Reset everything including clearing processing state
    */
   reset() {
+    this.queueCancellationVersion++;
     this.queue = [];
     this.processing = false;
   }
@@ -3647,6 +3804,21 @@ var CodingAgentManager = class {
     this.onEvent(event);
     historyFile.append(event);
   }
+  recordUserMessageHistoryEvent(request, historyFile, extraPayload = {}) {
+    this.recordHistoryEvent(
+      "event_msg",
+      this.createUserMessageHistoryPayload(request, extraPayload),
+      historyFile
+    );
+  }
+  createUserMessageHistoryPayload(request, extraPayload = {}) {
+    return {
+      type: "user_message",
+      message: request.message,
+      ...extraPayload,
+      ...request.messageId ? { [USER_MESSAGE_ID_PAYLOAD_KEY]: request.messageId } : {}
+    };
+  }
   initializeManager(processMessage) {
     this.messageQueue = new MessageQueueService(
       processMessage,
@@ -3655,6 +3827,11 @@ var CodingAgentManager = class {
     );
     this.initialized = this.initialize();
   }
+  async persistAcceptedMessage(event) {
+    const history = this.getHistorySink();
+    if (!history?.appendDurably) throw new Error("Chat history is unavailable");
+    await history.appendDurably(event);
+  }
   async interrupt() {
     const queue = this.messageQueue.drainQueue({
       maxItems: MAX_INTERRUPT_QUEUE_ITEMS,
@@ -4262,12 +4439,13 @@ var CodexHistoryFile = class {
   writeLock = new AsyncLock();
   /** Best-effort ordered append; failures must not disrupt the turn. */
   append(event) {
-    void this.writeLock.run(
-      () => appendFile2(this.filePath, `${JSON.stringify(event)}
-`).catch((error) => {
-        console.error("[CodexHistoryFile] Failed to append event:", error);
-      })
-    );
+    void this.appendDurably(event).catch((error) => {
+      console.error("[CodexHistoryFile] Failed to append event:", error);
+    });
+  }
+  appendDurably(event) {
+    return this.writeLock.run(() => appendFile2(this.filePath, `${JSON.stringify(event)}
+`));
   }
   async flush() {
     await this.writeLock.drain();
@@ -4791,7 +4969,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       if (!handler) {
         return { behavior: "allow" };
       }
-      const requestId = randomUUID4();
+      const requestId = randomUUID5();
       const toolUseId = options.toolUseID;
       const { options: requestOptions, questions: requestQuestions } = handler.getRequest(input);
       const result = await new Promise((resolve5) => {
@@ -6462,6 +6640,13 @@ var DuplicateDefaultChatError = class extends Error {
     this.name = "DuplicateDefaultChatError";
   }
 };
+var ChatMessagePersistenceError = class extends Error {
+  constructor(cause) {
+    super(`Failed to persist user message: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.name = "ChatMessagePersistenceError";
+    this.cause = cause;
+  }
+};
 
 // src/managers/codex-asp/codex-asp-manager.ts
 var CodexQuotaError = class extends Error {
@@ -6571,7 +6756,13 @@ var CodexAspManager = class extends CodingAgentManager {
     this.currentThreadId = this.initialSessionId ?? replayed?.transcript?.threadId ?? null;
   }
   getHistorySink() {
-    return { append: (event) => this.trackHistoryEvent(event) };
+    return {
+      append: (event) => this.trackHistoryEvent(event),
+      appendDurably: (event) => {
+        if (!this.historyFile) throw new Error("Chat history is unavailable");
+        return this.historyFile.appendDurably(event);
+      }
+    };
   }
   async interruptActiveTurn() {
     if (!this.currentThreadId || !this.activeTurnId) {
@@ -6769,13 +6960,10 @@ var CodexAspManager = class extends CodingAgentManager {
   }
   recordUserMessageEvent(request, extraPayload = {}) {
     const images = imageContentToUserMessageImages(request.images);
-    this.recordCodexHistoryEvent("event_msg", {
-      type: "user_message",
-      message: request.message,
-      ...request.messageId ? { [USER_MESSAGE_ID_PAYLOAD_KEY]: request.messageId } : {},
+    this.recordCodexHistoryEvent("event_msg", this.createUserMessageHistoryPayload(request, {
       ...images ? { images } : {},
       ...extraPayload
-    });
+    }));
   }
   async processMessageInternal(request) {
     let userMessageRecorded = false;
@@ -8088,10 +8276,7 @@ var CursorManager = class extends CodingAgentManager {
           }
         }, CURSOR_RECONNECT_NOTICE_DELAY_MS);
         agent = await this.ensureAgent(request);
-        this.recordHistoryEvent("event_msg", {
-          type: "user_message",
-          message: request.message
-        }, this.historyFile);
+        this.recordUserMessageHistoryEvent(request, this.historyFile);
         run = await agent.send(message, {
           model: { id: model },
           mode: request.planMode ? "plan" : "agent",
@@ -8337,7 +8522,7 @@ ${instructions}
 
 // src/managers/deepseek-manager.ts
 import { spawn as spawn3 } from "child_process";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { createRequire } from "module";
 import { dirname as dirname6, join as join21 } from "path";
 import { fileURLToPath } from "url";
@@ -8379,7 +8564,7 @@ var DeepseekApiClient = class extends AbstractApiClient {
     return this.readWebSocket("/api/events.host", signal, hostFrameSchema, onOpen);
   }
   async executeCommand(sessionId, line) {
-    const rpcId = randomUUID5();
+    const rpcId = randomUUID6();
     const response = await this.doFetch(new URL("/api/commands/execute", this.baseUrl), {
       method: "POST",
       headers: { "content-type": "application/json" },
@@ -8492,7 +8677,7 @@ var DeepseekManager = class extends CodingAgentManager {
       mode: "steer",
       content: [{ type: "text", text: request.message }]
     }));
-    this.recordHistoryEvent("event_msg", { type: "user_message", message: request.message }, this.historyFile);
+    this.recordUserMessageHistoryEvent(request, this.historyFile);
     return true;
   }
   async getHistory(page = {}) {
@@ -8706,7 +8891,7 @@ var DeepseekManager = class extends CodingAgentManager {
           ...effort ? { reasoningEffort: effort } : {}
         }));
       }
-      this.recordHistoryEvent("event_msg", { type: "user_message", message: request.message }, this.historyFile);
+      this.recordUserMessageHistoryEvent(request, this.historyFile);
       this.turnCompletion = new Promise((resolve5) => {
         this.resolveTurnCompletion = resolve5;
       });
@@ -8747,7 +8932,7 @@ import { spawn as spawn5 } from "child_process";
 
 // src/managers/acp-manager.ts
 import { spawn as spawn4 } from "child_process";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { mkdir as mkdir13, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname7 } from "path";
 import { Writable } from "stream";
@@ -8920,7 +9105,7 @@ var AcpManager = class extends CodingAgentManager {
   createTerminal(params) {
     this.assertSession(params.sessionId);
     if (this.planMode) throw new Error("ACP terminals are disabled in plan mode.");
-    const terminalId = randomUUID6();
+    const terminalId = randomUUID7();
     const outputByteLimit = Math.max(1, Math.min(params.outputByteLimit ?? 1048576, 10485760));
     const child = spawn4(params.command, params.args ?? [], {
       cwd: params.cwd ?? this.workingDirectory,
@@ -9051,7 +9236,7 @@ var AcpManager = class extends CodingAgentManager {
   }
   async requestUserInput(params) {
     if (!this.interactiveTools) return { outcome: { outcome: "cancelled" } };
-    const requestId = randomUUID6();
+    const requestId = randomUUID7();
     const toolCallId = params.toolCall.toolCallId;
     return new Promise((resolve5) => {
       this.pendingPermissions.set(requestId, { toolCallId, options: params.options, resolve: resolve5 });
@@ -9112,7 +9297,7 @@ var AcpManager = class extends CodingAgentManager {
       const context = this.context;
       const sessionId = this.sessionId;
       if (!context || !sessionId) throw new Error(`${this.acp.command} ACP failed to initialize.`);
-      this.recordHistoryEvent("event_msg", { type: "user_message", message: request.message }, this.historyFile);
+      this.recordUserMessageHistoryEvent(request, this.historyFile);
       this.planMode = request.planMode ?? false;
       this.interactiveTools = request.enableInteractiveTools ?? false;
       await this.setConfig("model", model);
@@ -9824,10 +10009,7 @@ var OpencodeManager = class extends CodingAgentManager {
       const variant = await this.getThinkingVariant(client2, providerModel, request.thinkingLevel);
       const sessionId = await this.ensureSession(client2, providerModel, agent, variant);
       const system = this.buildCombinedInstructions(request.customInstructions);
-      this.recordHistoryEvent("event_msg", {
-        type: "user_message",
-        message: request.message
-      }, this.historyFile);
+      this.recordUserMessageHistoryEvent(request, this.historyFile);
       const result = await client2.session.prompt({
         sessionID: sessionId,
         directory: this.workingDirectory,
@@ -10261,7 +10443,7 @@ var PiManager = class extends CodingAgentManager {
     const session = this.session;
     if (!session?.isStreaming) return false;
     await session.steer(request.message);
-    this.recordUserMessage(session, request.message);
+    this.recordUserMessage(session, request);
     return true;
   }
   async getHistory(page = {}) {
@@ -10386,18 +10568,18 @@ var PiManager = class extends CodingAgentManager {
     const payload = eventPayload(event);
     this.recordHistoryEvent(`pi-${event.type}`, payload, this.historyFile);
   }
-  recordUserMessage(session, message) {
-    const skillName = explicitSkillName(session, message);
-    this.recordHistoryEvent("event_msg", {
-      type: "user_message",
-      message,
-      ...skillName ? { skillName } : {}
-    }, this.historyFile);
+  recordUserMessage(session, request) {
+    const skillName = explicitSkillName(session, request.message);
+    this.recordUserMessageHistoryEvent(
+      request,
+      this.historyFile,
+      skillName ? { skillName } : {}
+    );
   }
   async processMessageInternal(request) {
     try {
       const session = await this.ensureSession(request);
-      this.recordUserMessage(session, request.message);
+      this.recordUserMessage(session, request);
       const images = request.images && request.images.length > 0 ? (await normalizeImages(request.images)).map((image) => ({
         type: "image",
         data: image.source.data,
@@ -11024,6 +11206,9 @@ var RelayManager = class {
   async enqueueMessage(request, onAccepted) {
     return this.inner.enqueueMessage(request, onAccepted);
   }
+  persistAcceptedMessage(event) {
+    return this.inner.persistAcceptedMessage(event);
+  }
   async interrupt() {
     return this.inner.interrupt();
   }
@@ -11072,7 +11257,7 @@ import {
   unlink as unlink3
 } from "fs/promises";
 import { join as join24 } from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+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"]);
@@ -11293,7 +11478,7 @@ var AgentChatTurnActivityTracker = class {
     const credential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[provider];
     this.pendingMessages.delete(messageId);
     this.activeTurns.set(chatId, {
-      turnId: randomUUID7(),
+      turnId: randomUUID8(),
       startedAtMs: Date.now(),
       provider,
       model: attributes.model ?? getDefaultAgentModel(provider),
@@ -12125,7 +12310,7 @@ var ChatService = class {
   workingDirectory;
   agentChatActivityTrackerService;
   chats = /* @__PURE__ */ new Map();
-  persistInFlight = false;
+  persistPromise = null;
   persistQueued = false;
   async initialize() {
     await mkdir17(ENGINE_DIR2, { recursive: true });
@@ -12191,7 +12376,7 @@ var ChatService = class {
     }
     const existingDefault = isDefaultChat({ provider: request.provider, title }) ? Array.from(this.chats.values()).find((chat) => !chat.persisted.deletedAt && chat.persisted.provider === request.provider && isDefaultChat(chat.persisted)) : void 0;
     if (existingDefault) {
-      if (!request.id || hasChatStarted(this.toSummary(existingDefault))) {
+      if (!request.id || existingDefault.acceptingMessages > 0 || hasChatStarted(this.toSummary(existingDefault))) {
         throw new DuplicateDefaultChatError(request.provider);
       }
       this.chats.delete(existingDefault.persisted.id);
@@ -12201,7 +12386,7 @@ var ChatService = class {
       throw new ChatNotFoundError(parentChatId);
     }
     const persisted = {
-      id: request.id ?? randomUUID8(),
+      id: request.id ?? randomUUID9(),
       provider: request.provider,
       title,
       createdAt: now,
@@ -12223,42 +12408,94 @@ var ChatService = class {
   }
   async sendMessage(chatId, request) {
     const chat = this.requireChat(chatId);
-    if (request.idempotencyKey) {
-      const accepted = chat.acceptedSendResponses.get(request.idempotencyKey);
+    const idempotencyKey = request.idempotencyKey ?? request.messageId;
+    if (idempotencyKey) {
+      const accepted = chat.acceptedSendResponses.get(idempotencyKey);
       if (accepted) {
         return accepted;
       }
+      const accepting2 = chat.acceptingSendResponses.get(idempotencyKey);
+      if (accepting2) return accepting2;
     }
-    return chat.provider.enqueueMessage(
-      request,
-      (result) => this.handleMessageAccepted(chatId, chat, request, result)
-    );
-  }
-  async handleMessageAccepted(chatId, chat, request, result) {
-    if (request.idempotencyKey) {
-      chat.acceptedSendResponses.set(request.idempotencyKey, result);
-      for (const key of chat.acceptedSendResponses.keys()) {
-        if (chat.acceptedSendResponses.size <= MAX_ACCEPTED_SEND_RESPONSES) break;
-        chat.acceptedSendResponses.delete(key);
+    const accepting = (async () => {
+      chat.acceptingMessages += 1;
+      try {
+        return await chat.provider.enqueueMessage(
+          request,
+          (result, acceptedMessage) => this.handleMessageAccepted(
+            chatId,
+            chat,
+            request,
+            acceptedMessage,
+            result
+          )
+        );
+      } finally {
+        chat.acceptingMessages -= 1;
+      }
+    })();
+    if (!idempotencyKey) return accepting;
+    chat.acceptingSendResponses.set(idempotencyKey, accepting);
+    try {
+      return await accepting;
+    } finally {
+      if (chat.acceptingSendResponses.get(idempotencyKey) === accepting) {
+        chat.acceptingSendResponses.delete(idempotencyKey);
       }
-      chat.persisted.acceptedSendResponses = Object.fromEntries(chat.acceptedSendResponses);
     }
+  }
+  async handleMessageAccepted(chatId, chat, request, acceptedMessage, result) {
     const submittedAt = request.submittedAt ?? (/* @__PURE__ */ new Date()).toISOString();
     const { event: acceptedEvent, sender: recordedSender } = createTurnMetadata(
-      request,
+      acceptedMessage,
       result.messageId,
       submittedAt
     );
+    try {
+      await chat.provider.persistAcceptedMessage(acceptedEvent);
+    } catch (error) {
+      throw new ChatMessagePersistenceError(error);
+    }
+    const previousAcceptedSendResponses = new Map(chat.acceptedSendResponses);
+    const previousPendingMessageIds = [...chat.pendingMessageIds];
+    const previousAcceptedEvent = chat.acceptedUserEvents.get(result.messageId);
+    const previousPersistedResponses = chat.persisted.acceptedSendResponses;
+    const previousLastMessageText = chat.persisted.lastMessageText;
+    const previousUpdatedAt = chat.persisted.updatedAt;
+    const idempotencyKey = request.idempotencyKey ?? request.messageId;
+    if (idempotencyKey) {
+      chat.acceptedSendResponses.set(idempotencyKey, result);
+      for (const key of chat.acceptedSendResponses.keys()) {
+        if (chat.acceptedSendResponses.size <= MAX_ACCEPTED_SEND_RESPONSES) break;
+        chat.acceptedSendResponses.delete(key);
+      }
+      chat.persisted.acceptedSendResponses = Object.fromEntries(chat.acceptedSendResponses);
+    }
     if (!chat.pendingMessageIds.includes(result.messageId)) {
       chat.pendingMessageIds.push(result.messageId);
     }
+    chat.acceptedUserEvents.set(result.messageId, acceptedEvent);
+    chat.persisted.lastMessageText = request.message.trim().slice(0, LAST_MESSAGE_PREVIEW_MAX) || null;
+    chat.persisted.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      await this.persistAllChats();
+    } catch (error) {
+      chat.acceptedSendResponses.clear();
+      for (const [key, response] of previousAcceptedSendResponses) {
+        chat.acceptedSendResponses.set(key, response);
+      }
+      chat.pendingMessageIds = previousPendingMessageIds;
+      if (previousAcceptedEvent) chat.acceptedUserEvents.set(result.messageId, previousAcceptedEvent);
+      else chat.acceptedUserEvents.delete(result.messageId);
+      chat.persisted.acceptedSendResponses = previousPersistedResponses;
+      chat.persisted.lastMessageText = previousLastMessageText;
+      chat.persisted.updatedAt = previousUpdatedAt;
+      throw new ChatMessagePersistenceError(error);
+    }
     this.agentChatActivityTrackerService.noteMessageAccepted(result.messageId, request);
     if (request.errorNotificationTarget) {
       chat.errorNotificationTargets.set(result.messageId, request.errorNotificationTarget);
     }
-    chat.acceptedUserEvents.set(result.messageId, acceptedEvent);
-    chat.persisted.lastMessageText = request.message.trim().slice(0, LAST_MESSAGE_PREVIEW_MAX) || null;
-    this.touch(chat);
     if (recordedSender) {
       await this.appendSender(chatId, recordedSender);
     }
@@ -12535,15 +12772,16 @@ var ChatService = class {
       chat.provider.getHistory(page),
       this.readSenders(chatId)
     ]);
+    const historyEvents = mergeWorkspaceChatHistoryEvents([], history.events);
     for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
-      if (acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) || history.events.some((event) => isSameAcceptedUserEvent(event, acceptedEvent))) {
+      if (acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) || historyEvents.some((event) => isSameAcceptedUserEvent(event, acceptedEvent))) {
         chat.acceptedUserEvents.delete(messageId);
       }
     }
     const isLatestPage = isLatestChatHistoryPage(page);
     const queuedMessageIds = new Set(chat.provider.getQueue().map((message) => message.id));
-    const acceptedEvents = (isLatestPage ? [...chat.acceptedUserEvents.entries()] : []).filter(([messageId]) => messageId === chat.activeMessageId || !chat.hasActiveTurn && chat.pendingMessageIds[0] === messageId && !queuedMessageIds.has(messageId)).map(([, acceptedEvent]) => acceptedEvent).filter((acceptedEvent) => !acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) && !history.events.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
-    const events = [...history.events, ...acceptedEvents].sort((a, b) => getEventTimestampMs(a) - getEventTimestampMs(b));
+    const acceptedEvents = (isLatestPage ? [...chat.acceptedUserEvents.entries()] : []).filter(([messageId]) => messageId === chat.activeMessageId || !chat.hasActiveTurn && chat.pendingMessageIds[0] === messageId && !queuedMessageIds.has(messageId)).map(([, acceptedEvent]) => acceptedEvent).filter((acceptedEvent) => !acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) && !historyEvents.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
+    const events = [...historyEvents, ...acceptedEvents].sort((a, b) => getEventTimestampMs(a) - getEventTimestampMs(b));
     if (page.limit !== void 0 && "beforeCursor" in history) {
       const cursor = parseChatHistoryCursor(history.beforeCursor ?? void 0);
       return {
@@ -12561,7 +12799,7 @@ var ChatService = class {
       return {
         ...history,
         events,
-        totalEvents: (history.totalEvents ?? history.eventsStartIndex + history.events.length) + acceptedEvents.length,
+        totalEvents: (history.totalEvents ?? history.eventsStartIndex + history.events.length) - (history.events.length - historyEvents.length) + acceptedEvents.length,
         goal: history.goal ?? chat.provider.getGoal?.() ?? null,
         senders
       };
@@ -12760,6 +12998,8 @@ var ChatService = class {
       pendingMessageIds: [],
       acceptedUserEvents: /* @__PURE__ */ new Map(),
       acceptedSendResponses: new Map(Object.entries(persisted.acceptedSendResponses ?? {})),
+      acceptingSendResponses: /* @__PURE__ */ new Map(),
+      acceptingMessages: 0,
       activeMessageId: null,
       hasActiveTurn: false,
       observedBranchesByRepo: /* @__PURE__ */ new Map(),
@@ -12965,35 +13205,33 @@ var ChatService = class {
       }
     }
   }
-  async persistAllChats() {
-    if (this.persistInFlight) {
+  persistAllChats() {
+    if (this.persistPromise) {
       this.persistQueued = true;
-      return;
+      return this.persistPromise;
     }
-    this.persistInFlight = true;
-    try {
-      const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
-      try {
-        await copyFile(CHATS_FILE, CHATS_BACKUP_FILE);
-      } catch (error) {
-        if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
-          console.error("[ChatService] Failed to update chats backup:", error);
+    this.persistPromise = (async () => {
+      do {
+        this.persistQueued = false;
+        const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
+        try {
+          await copyFile(CHATS_FILE, CHATS_BACKUP_FILE);
+        } catch (error) {
+          if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+            console.error("[ChatService] Failed to update chats backup:", error);
+          }
         }
-      }
-      await atomicWriteFile(CHATS_FILE, `${JSON.stringify(payload, null, 2)}
+        await atomicWriteFile(CHATS_FILE, `${JSON.stringify(payload, null, 2)}
 `);
-    } catch {
-    } finally {
-      this.persistInFlight = false;
-      if (this.persistQueued) {
-        this.persistQueued = false;
-        void this.persistAllChats();
-      }
-    }
+      } while (this.persistQueued);
+    })().finally(() => {
+      this.persistPromise = null;
+    });
+    return this.persistPromise;
   }
   async publish(input) {
     const event = {
-      id: randomUUID8(),
+      id: randomUUID9(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       ...input
     };
@@ -13735,7 +13973,7 @@ ${combinedScript}` : combinedScript;
 }
 
 // src/services/terminal-service.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { existsSync as existsSync10 } from "fs";
 import { spawn as spawn7 } from "node-pty";
 var MAX_REPLAY_CHARS = 1024 * 1024;
@@ -13754,7 +13992,7 @@ var TerminalService = class {
         code: "limit"
       });
     }
-    const id = randomUUID9();
+    const id = randomUUID10();
     const shell = process.env.SHELL && existsSync10(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
     const pty = spawn7(shell, ["-l"], {
       name: "xterm-256color",
@@ -14109,6 +14347,9 @@ function createV1Routes(deps) {
       if (details.includes("Chat not found")) {
         return c.json(jsonError("Failed to send message", details), 404);
       }
+      if (error instanceof ChatMessagePersistenceError) {
+        return c.json(jsonError("Failed to save user message", details), 500);
+      }
       return c.json(jsonError("Failed to send message", details), 400);
     }
   });
@@ -15040,7 +15281,7 @@ function startStatusBroadcaster() {
       if (serialized !== previousRepoStatus) {
         previousRepoStatus = serialized;
         eventService.publish({
-          id: randomUUID10(),
+          id: randomUUID11(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "repo.status.changed",
           payload: { repos }
@@ -15061,7 +15302,7 @@ function startStatusBroadcaster() {
       if (engineStatusJson !== previousEngineStatus) {
         previousEngineStatus = engineStatusJson;
         eventService.publish({
-          id: randomUUID10(),
+          id: randomUUID11(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "engine.status.changed",
           payload: { status: engineStatus }
@@ -15080,7 +15321,7 @@ function startStatusBroadcaster() {
         previousHookStatus = hookSnapshot;
         if (!lastHooksRunning && hooksRunning) {
           eventService.publish({
-            id: randomUUID10(),
+            id: randomUUID11(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.started",
             payload: { running: true, completed: false }
@@ -15089,7 +15330,7 @@ function startStatusBroadcaster() {
         }
         if (hooksRunning) {
           eventService.publish({
-            id: randomUUID10(),
+            id: randomUUID11(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.progress",
             payload: { running: true, completed: false }
@@ -15098,7 +15339,7 @@ function startStatusBroadcaster() {
         }
         if (lastHooksRunning && !hooksRunning && hooksCompleted && !hooksFailed) {
           eventService.publish({
-            id: randomUUID10(),
+            id: randomUUID11(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.completed",
             payload: { running: false, completed: true }
@@ -15107,7 +15348,7 @@ function startStatusBroadcaster() {
         }
         if (lastHooksRunning && !hooksRunning && hooksFailed) {
           eventService.publish({
-            id: randomUUID10(),
+            id: randomUUID11(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.failed",
             payload: { running: false, completed: hooksCompleted }
@@ -15115,7 +15356,7 @@ function startStatusBroadcaster() {
           });
         }
         eventService.publish({
-          id: randomUUID10(),
+          id: randomUUID11(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.status",
           payload: {
@@ -15170,20 +15411,20 @@ serve(
     }
     const repos = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID10(),
+      id: randomUUID11(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.discovered",
       payload: { repos }
     });
     const repoStatuses = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID10(),
+      id: randomUUID11(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.status.changed",
       payload: { repos: repoStatuses }
     });
     await eventService.publish({
-      id: randomUUID10(),
+      id: randomUUID11(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "engine.ready",
       payload: { version: "v1" }

package/package.json

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