replicas-engine 0.1.462 → 0.1.463

package/dist/src/index.js

@@ -51,6 +51,9 @@ function isValidAgentProvider(value) {
   return VALID_AGENT_PROVIDERS.some((p) => p === value);
 }
 var VALID_THINKING_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+function isValidThinkingLevel(value) {
+  return VALID_THINKING_LEVELS.some((l) => l === value);
+}
 var CODEX_REASONING_EFFORT_BY_THINKING_LEVEL = {
   low: "low",
   medium: "medium",
@@ -64,6 +67,21 @@ function codexReasoningEffortForThinkingLevel(thinkingLevel) {
 
 // ../shared/src/event.ts
 var CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE = "claude-partial-message";
+function coerceClaudePartialMessagePayload(payload) {
+  const streamId = payload.streamId;
+  if (typeof streamId !== "string" || !streamId) return null;
+  const parentToolUseId = payload.parent_tool_use_id;
+  const text = typeof payload.text === "string" && payload.text ? payload.text : void 0;
+  const thinking = typeof payload.thinking === "string" && payload.thinking ? payload.thinking : void 0;
+  if (!text && !thinking) return null;
+  return {
+    streamId,
+    parent_tool_use_id: typeof parentToolUseId === "string" ? parentToolUseId : null,
+    ...text ? { text } : {},
+    ...thinking ? { thinking } : {},
+    status: payload.status === "completed" ? "completed" : "in_progress"
+  };
+}
 var ACCEPTED_USER_MESSAGE_SOURCE = "replicas-chat-turn-accepted";
 var USER_MESSAGE_ID_PAYLOAD_KEY = "replicasMessageId";
 var CODEX_ASP_ITEM_ID_PAYLOAD_KEY = "codexAspItemId";
@@ -543,7 +561,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-07-19-v14";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-07-19-v15";
 
 // ../shared/src/runtime-env.ts
 function shellQuotePosix(value) {
@@ -3154,6 +3172,654 @@ 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/codex-parser.ts
+function getStatusFromExitCode(exitCode) {
+  return exitCode === 0 ? "completed" : "failed";
+}
+function getPayloadString(event, key) {
+  const value = event.payload?.[key];
+  return typeof value === "string" ? value : null;
+}
+function displayId(event, eventIndex, prefix) {
+  const stableId = getPayloadString(event, USER_MESSAGE_ID_PAYLOAD_KEY) ?? getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY);
+  return stableId ? `${prefix}-${stableId}` : `${prefix}-${event.timestamp}-${eventIndex}`;
+}
+function userMessageImages(value) {
+  if (!Array.isArray(value)) return void 0;
+  const images = value.filter((item) => {
+    if (!isRecord(item)) return false;
+    return item.type === "image" && typeof item.mediaType === "string" && typeof item.data === "string";
+  });
+  return images.length > 0 ? images : void 0;
+}
+function parseShellOutput(raw) {
+  const exitCodeMatch = raw.match(/^Exit code: (\d+)/m) || raw.match(/Process exited with code (\d+)/);
+  const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 0;
+  const outputIndex = raw.indexOf("Output:\n");
+  const output = outputIndex >= 0 ? raw.slice(outputIndex + "Output:\n".length) : raw;
+  return { exitCode, output };
+}
+function parsePatch(input) {
+  const operations = [];
+  const lines = input.split("\n");
+  let currentOp = null;
+  let diffLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("*** Add File:")) {
+      if (currentOp) {
+        if (diffLines.length > 0) currentOp.diff = diffLines.join("\n");
+        operations.push(currentOp);
+        diffLines = [];
+      }
+      currentOp = {
+        action: "add",
+        path: line.replace("*** Add File:", "").trim()
+      };
+    } else if (line.startsWith("*** Update File:")) {
+      if (currentOp) {
+        if (diffLines.length > 0) currentOp.diff = diffLines.join("\n");
+        operations.push(currentOp);
+        diffLines = [];
+      }
+      currentOp = {
+        action: "update",
+        path: line.replace("*** Update File:", "").trim()
+      };
+    } else if (line.startsWith("*** Delete File:")) {
+      if (currentOp) {
+        if (diffLines.length > 0) currentOp.diff = diffLines.join("\n");
+        operations.push(currentOp);
+        diffLines = [];
+      }
+      currentOp = {
+        action: "delete",
+        path: line.replace("*** Delete File:", "").trim()
+      };
+    } else if (line.startsWith("*** Move to:")) {
+      if (currentOp) {
+        currentOp.moveTo = line.replace("*** Move to:", "").trim();
+      }
+    } else if (line.startsWith("*** Begin Patch") || line.startsWith("*** End Patch")) {
+      continue;
+    } else if (currentOp && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ") || line.startsWith("@@") || line.trim() === "")) {
+      diffLines.push(line);
+    }
+  }
+  if (currentOp) {
+    if (diffLines.length > 0) currentOp.diff = diffLines.join("\n");
+    operations.push(currentOp);
+  }
+  return operations;
+}
+function parseCodexEvents(events) {
+  const messages = [];
+  const pendingCommands = /* @__PURE__ */ new Map();
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  const pendingPatches = /* @__PURE__ */ new Map();
+  events.forEach((event, eventIndex) => {
+    if (event.type === CODEX_QUOTA_STATUS_EVENT_TYPE) {
+      const state = event.payload?.state;
+      if (state) {
+        messages.push({
+          id: `codex-quota-${event.timestamp}-${eventIndex}`,
+          type: "quota_status",
+          provider: "codex",
+          state,
+          balance: event.payload?.balance ?? null,
+          rateLimitResetType: event.payload?.rateLimitResetType ?? null,
+          planType: event.payload?.planType ?? null,
+          timestamp: event.timestamp
+        });
+      }
+      return;
+    }
+    if (event.type === "event_msg" && event.payload?.type === "user_message") {
+      const message = getPayloadString(event, "message");
+      messages.push({
+        id: displayId(event, eventIndex, "user"),
+        type: "user",
+        content: message ?? "",
+        images: userMessageImages(event.payload.images),
+        timestamp: event.timestamp
+      });
+    }
+    if (event.type === "event_msg" && event.payload?.type === "agent_reasoning") {
+      messages.push({
+        id: displayId(event, eventIndex, "reasoning"),
+        type: "reasoning",
+        content: event.payload.text || "",
+        status: "completed",
+        timestamp: event.timestamp
+      });
+    }
+    if (event.type === "response_item") {
+      const payloadType = event.payload?.type;
+      if (payloadType === "message" && event.payload?.role === "assistant") {
+        const content = event.payload.content || [];
+        const textContent = content.filter((c) => c.type === "output_text").map((c) => c.text || "").join("\n");
+        if (textContent) {
+          messages.push({
+            id: displayId(event, eventIndex, "agent"),
+            type: "agent",
+            content: textContent,
+            timestamp: event.timestamp
+          });
+        }
+      }
+      if (payloadType === "function_call" && (event.payload?.name === "shell" || event.payload?.name === "shell_command" || event.payload?.name === "exec_command")) {
+        const callId = event.payload.call_id;
+        const args = safeJsonParse(event.payload.arguments || "{}", {});
+        const command = args.cmd || (Array.isArray(args.command) ? args.command.join(" ") : args.command) || "";
+        const msg = {
+          id: `command-${callId || "no-call-id"}-${eventIndex}`,
+          type: "command",
+          command,
+          output: "",
+          status: "in_progress",
+          timestamp: event.timestamp
+        };
+        messages.push(msg);
+        if (callId) {
+          pendingCommands.set(callId, msg);
+        }
+      }
+      if (payloadType === "function_call_output") {
+        const callId = event.payload.call_id;
+        const rawOutput = event.payload.output || "";
+        const commandMsg = callId ? pendingCommands.get(callId) : void 0;
+        if (commandMsg) {
+          const { exitCode, output } = parseShellOutput(rawOutput);
+          commandMsg.output = output;
+          commandMsg.exitCode = exitCode;
+          commandMsg.status = getStatusFromExitCode(exitCode);
+          pendingCommands.delete(callId);
+        }
+      }
+      if (payloadType === "custom_tool_call") {
+        const callId = event.payload.call_id;
+        const name = event.payload.name;
+        const input = event.payload.input || "";
+        const server = typeof event.payload.server === "string" ? event.payload.server : "custom";
+        const status = event.payload.status || "in_progress";
+        if (name === "apply_patch") {
+          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",
+            server,
+            tool: name,
+            input,
+            status,
+            timestamp: event.timestamp
+          };
+          messages.push(msg);
+          if (callId) {
+            pendingToolCalls.set(callId, msg);
+          }
+        }
+      }
+      if (payloadType === "custom_tool_call_output") {
+        const callId = event.payload.call_id;
+        const output = safeJsonParse(
+          event.payload.output || "{}",
+          {}
+        );
+        const pendingPatch = pendingPatches.get(callId);
+        if (pendingPatch) {
+          messages.push({
+            id: `patch-${pendingPatch.timestamp}-${eventIndex}`,
+            type: "patch",
+            operations: pendingPatch.operations,
+            output: output.output || "",
+            exitCode: output.metadata?.exit_code,
+            status: getStatusFromExitCode(output.metadata?.exit_code),
+            timestamp: pendingPatch.timestamp
+          });
+          pendingPatches.delete(callId);
+        } else {
+          const fallbackToolCallMsg = messages.findLast((m) => m.type === "tool_call");
+          const toolCallMsg = pendingToolCalls.get(callId) ?? fallbackToolCallMsg;
+          if (toolCallMsg) {
+            toolCallMsg.status = getStatusFromExitCode(output.metadata?.exit_code);
+            toolCallMsg.output = output.output ?? (typeof event.payload.output === "string" ? event.payload.output : "");
+            if (callId) {
+              pendingToolCalls.delete(callId);
+            }
+          }
+        }
+      }
+      if (payloadType === "function_call" && event.payload?.name === "update_plan") {
+        const args = safeJsonParse(
+          event.payload.arguments || "{}",
+          {}
+        );
+        if (args.plan && Array.isArray(args.plan)) {
+          const todoItems = args.plan.map((item) => ({
+            text: item.step,
+            completed: item.status === "completed"
+          }));
+          messages.push({
+            id: `todo-${event.timestamp}-${eventIndex}`,
+            type: "todo_list",
+            items: todoItems,
+            status: "completed",
+            timestamp: event.timestamp
+          });
+        }
+      }
+    }
+  });
+  return messages;
+}
+
+// ../shared/src/display-message/parsers/utils.ts
+function stringifyDisplayValue(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+// ../shared/src/display-message/parsers/cursor-parser.ts
+function getTextContent(value) {
+  if (!Array.isArray(value)) return "";
+  return value.map((block) => isRecord(block) && block.type === "text" && typeof block.text === "string" ? block.text : "").join("");
+}
+function cursorStatusToDisplayStatus(status) {
+  return status === "completed" || status === "FINISHED" ? "completed" : status === "error" || status === "ERROR" || status === "CANCELLED" || status === "EXPIRED" ? "failed" : "in_progress";
+}
+function cursorRunId(event) {
+  const runId = event.payload.run_id;
+  return typeof runId === "string" ? runId : "unknown-run";
+}
+function getCursorAssistantText(event) {
+  const message = isRecord(event.payload.message) ? event.payload.message : null;
+  return getTextContent(message?.content);
+}
+function getCursorThinkingText(event) {
+  const text = event.payload.text;
+  if (typeof text === "string") return text;
+  const message = isRecord(event.payload.message) ? event.payload.message : null;
+  return typeof message?.text === "string" ? message.text : "";
+}
+function isTerminalStatus(status) {
+  return status === "FINISHED" || status === "ERROR" || status === "CANCELLED" || status === "EXPIRED";
+}
+function finalizeOpenTools(messages, toolIndexes, status) {
+  for (const index of toolIndexes.values()) {
+    const message = messages[index];
+    if (message?.type === "tool_call" && message.status === "in_progress") {
+      messages[index] = {
+        ...message,
+        status
+      };
+    }
+  }
+}
+function parseCursorEvents(events) {
+  const messages = [];
+  const toolIndexes = /* @__PURE__ */ new Map();
+  const runAssistantSegments = /* @__PURE__ */ new Map();
+  const runThinkingSegments = /* @__PURE__ */ new Map();
+  let activeAssistant = null;
+  let activeThinking = null;
+  const finalizeActiveThinking = (status) => {
+    if (!activeThinking) return;
+    const message = messages[activeThinking.index];
+    if (message?.type === "reasoning") {
+      messages[activeThinking.index] = {
+        ...message,
+        status
+      };
+    }
+  };
+  for (const event of events) {
+    if (event.type === "event_msg" && event.payload.type === "user_message") {
+      activeAssistant = null;
+      activeThinking = null;
+      const message = event.payload.message;
+      if (typeof message === "string" && message.trim()) {
+        messages.push({
+          id: `cursor-user-${event.timestamp}-${messages.length}`,
+          type: "user",
+          content: message,
+          timestamp: event.timestamp
+        });
+      }
+      continue;
+    }
+    if (event.type === "cursor-assistant") {
+      const text = getCursorAssistantText(event);
+      if (text) {
+        const runId = cursorRunId(event);
+        if (!activeAssistant || activeAssistant.runId !== runId) {
+          const segment = runAssistantSegments.get(runId) ?? 0;
+          runAssistantSegments.set(runId, segment + 1);
+          activeAssistant = {
+            runId,
+            index: messages.push({
+              id: `cursor-agent-${runId}-${segment}`,
+              type: "agent",
+              content: "",
+              timestamp: event.timestamp
+            }) - 1
+          };
+        }
+        const message = messages[activeAssistant.index];
+        if (message?.type === "agent") {
+          messages[activeAssistant.index] = {
+            ...message,
+            content: `${message.content}${text}`
+          };
+        }
+      }
+      continue;
+    }
+    if (event.type === "cursor-thinking") {
+      const text = getCursorThinkingText(event);
+      if (text.trim()) {
+        const runId = cursorRunId(event);
+        if (!activeThinking || activeThinking.runId !== runId) {
+          const segment = runThinkingSegments.get(runId) ?? 0;
+          runThinkingSegments.set(runId, segment + 1);
+          activeThinking = {
+            runId,
+            index: messages.push({
+              id: `cursor-reasoning-${runId}-${segment}`,
+              type: "reasoning",
+              content: "",
+              status: "in_progress",
+              timestamp: event.timestamp
+            }) - 1
+          };
+        }
+        const message = messages[activeThinking.index];
+        if (message?.type === "reasoning") {
+          messages[activeThinking.index] = {
+            ...message,
+            content: `${message.content}${text}`,
+            status: "in_progress"
+          };
+        }
+      }
+      continue;
+    }
+    if (event.type === "cursor-tool_call") {
+      activeAssistant = null;
+      const callId = typeof event.payload.call_id === "string" ? event.payload.call_id : `cursor-tool-${event.timestamp}-${messages.length}`;
+      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 = {
+        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);
+      } else {
+        messages[existing] = { ...messages[existing], ...next };
+      }
+      continue;
+    }
+    if (event.type === "cursor-task") {
+      activeAssistant = null;
+      const text = event.payload.text;
+      if (typeof text === "string" && text.trim()) {
+        messages.push({
+          id: `cursor-task-${event.timestamp}-${messages.length}`,
+          type: "agent",
+          content: text,
+          timestamp: event.timestamp
+        });
+      }
+      continue;
+    }
+    if (event.type === "cursor-status") {
+      const status = event.payload.status;
+      if (isTerminalStatus(status)) {
+        const displayStatus = cursorStatusToDisplayStatus(status);
+        finalizeActiveThinking(displayStatus);
+        finalizeOpenTools(messages, toolIndexes, displayStatus);
+        activeThinking = null;
+        activeAssistant = null;
+      }
+      continue;
+    }
+    if (event.type === "cursor-error") {
+      finalizeActiveThinking("failed");
+      finalizeOpenTools(messages, toolIndexes, "failed");
+      activeAssistant = null;
+      activeThinking = null;
+      const message = typeof event.payload.message === "string" ? event.payload.message : "Cursor run failed";
+      messages.push({
+        id: `cursor-error-${event.timestamp}-${messages.length}`,
+        type: "error",
+        message,
+        timestamp: event.timestamp
+      });
+    }
+  }
+  return messages;
+}
+
+// ../shared/src/display-message/parsers/opencode-parser.ts
+function timestampFromMs(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : fallback;
+}
+function partFromEvent(event) {
+  return isRecord(event.payload.part) ? event.payload.part : null;
+}
+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;
+  if (typeof data?.message === "string") return data.message;
+  if (typeof info.error.message === "string") return info.error.message;
+  return stringifyDisplayValue(info.error) ?? "Opencode run failed";
+}
+function parseOpencodeEvents(events) {
+  const messages = [];
+  for (const event of events) {
+    if (event.type === "event_msg" && event.payload.type === "user_message") {
+      const message = event.payload.message;
+      if (typeof message === "string" && message.trim()) {
+        messages.push({
+          id: `opencode-user-${event.timestamp}-${messages.length}`,
+          type: "user",
+          content: message,
+          timestamp: event.timestamp
+        });
+      }
+      continue;
+    }
+    if (event.type === "opencode-message.updated") {
+      const error = assistantError(event.payload.info);
+      if (error) {
+        messages.push({
+          id: `opencode-error-${event.timestamp}-${messages.length}`,
+          type: "error",
+          message: error,
+          timestamp: event.timestamp
+        });
+      }
+      continue;
+    }
+    if (event.type === "opencode-error") {
+      const message = typeof event.payload.message === "string" ? event.payload.message : "Opencode run failed";
+      messages.push({
+        id: `opencode-error-${event.timestamp}-${messages.length}`,
+        type: "error",
+        message,
+        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}`;
+    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, {
+          id,
+          type: "agent",
+          content: text,
+          timestamp
+        });
+      }
+      continue;
+    }
+    if (part.type === "reasoning") {
+      const text = typeof part.text === "string" ? part.text : "";
+      if (text.trim()) {
+        setById(messages, id, {
+          id,
+          type: "reasoning",
+          content: text,
+          status: time?.end ? "completed" : "in_progress",
+          timestamp
+        });
+      }
+      continue;
+    }
+    if (part.type === "tool" && isRecord(part.state)) {
+      const state = part.state;
+      const status = toolStatus(state.status);
+      const output = state.status === "completed" ? stringifyDisplayValue(state.output) : state.status === "error" ? stringifyDisplayValue(state.error) : void 0;
+      setById(messages, id, {
+        id,
+        type: "tool_call",
+        server: "opencode",
+        tool: typeof part.tool === "string" ? part.tool : "tool",
+        input: isRecord(state.input) ? state.input : stringifyDisplayValue(state.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, {
+          id,
+          type: "file_change",
+          changes: files.map((path6) => ({ path: path6, kind: "update" })),
+          status: "completed",
+          timestamp
+        });
+      }
+    }
+  }
+  return messages;
+}
+
+// ../shared/src/display-message/parsers/pi-parser.ts
+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";
+}
+function assistantErrorMessage(value) {
+  if (!isRecord(value) || value.role !== "assistant" || value.stopReason !== "error") return null;
+  return typeof value.errorMessage === "string" && value.errorMessage ? value.errorMessage : "Pi run failed";
+}
+function parsePiEvents(events) {
+  const messages = [];
+  const text = /* @__PURE__ */ new Map();
+  const thinking = /* @__PURE__ */ new Map();
+  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 });
+      continue;
+    }
+    if (event.type === "pi-error") {
+      messages.push({ id: `pi-error-${event.timestamp}-${messages.length}`, type: "error", message: String(event.payload.message ?? "Pi run failed"), timestamp: event.timestamp });
+      continue;
+    }
+    if (event.type === "pi-message_end") {
+      const error = assistantErrorMessage(event.payload.message);
+      if (error) {
+        messages.push({ id: `pi-error-${event.timestamp}-${messages.length}`, type: "error", message: error, timestamp: event.timestamp });
+      }
+      continue;
+    }
+    if (event.type === "pi-message_update") {
+      const payload = nestedPayload(event);
+      const id = typeof payload.id === "string" ? payload.id : activeMessageId;
+      if (payload.type === "text_delta" && typeof payload.delta === "string") text.set(id, `${text.get(id) ?? ""}${payload.delta}`);
+      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 });
+      continue;
+    }
+    if (event.type === "pi-message_start") {
+      const message = isRecord(event.payload.message) ? event.payload.message : null;
+      activeMessageId = typeof message?.id === "string" ? message.id : `assistant-${event.timestamp}`;
+      continue;
+    }
+    if (event.type === "pi-tool_execution_start" || event.type === "pi-tool_execution_update" || event.type === "pi-tool_execution_end") {
+      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",
+        server: "pi",
+        tool: typeof payload.toolName === "string" ? payload.toolName : "tool",
+        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",
+        timestamp: event.timestamp
+      });
+    }
+  }
+  return messages;
+}
+
 // ../shared/src/display-message/task-accumulator.ts
 function mapTaskStatus(status) {
   if (status === "in_progress" || status === "completed") return status;
@@ -3281,6 +3947,19 @@ var TaskAccumulator = class {
   }
 };
 
+// ../shared/src/display-message/parsers/mcp.ts
+function parseMcpToolName(name) {
+  const prefix = "mcp__";
+  if (!name.startsWith(prefix)) return null;
+  const rest = name.slice(prefix.length);
+  const sep = rest.indexOf("__");
+  if (sep <= 0) return null;
+  const server = rest.slice(0, sep);
+  const tool2 = rest.slice(sep + 2);
+  if (!server || !tool2) return null;
+  return { server, tool: tool2 };
+}
+
 // ../shared/src/display-message/parsers/claude-parser.ts
 function coerceClaudeResultPayload(payload) {
   return {
@@ -3292,6 +3971,436 @@ function coerceClaudeResultPayload(payload) {
 function isClaudeResultError(payload) {
   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 = [];
+  const filterValue = parentToolUseId !== void 0 ? parentToolUseId : null;
+  const filteredEvents = events.filter((e) => {
+    const eventParentToolUseId = e.payload.parent_tool_use_id ?? null;
+    return eventParentToolUseId === filterValue;
+  });
+  const toolCallMap = /* @__PURE__ */ new Map();
+  const taskMessageMap = /* @__PURE__ */ new Map();
+  const partialIndexes = /* @__PURE__ */ new Map();
+  const completedStreamIds = /* @__PURE__ */ new Set();
+  const supersededStreamIds = /* @__PURE__ */ new Set();
+  let liveStreamId = null;
+  const assistantThinking = /* @__PURE__ */ new Map();
+  const assistantTextCounts = /* @__PURE__ */ new Map();
+  const taskAccumulator = new TaskAccumulator();
+  const taskSnapshot = () => taskAccumulator.getTasks().map((task) => ({
+    text: task.subject,
+    completed: task.status === "completed",
+    itemStatus: task.status
+  }));
+  filteredEvents.forEach((event) => {
+    if (event.type === CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE) {
+      const payload = coerceClaudePartialMessagePayload(event.payload);
+      if (!payload) return;
+      if (liveStreamId !== null && liveStreamId !== payload.streamId) {
+        supersededStreamIds.add(liveStreamId);
+      }
+      liveStreamId = payload.streamId;
+      const existing = partialIndexes.get(payload.streamId) ?? {};
+      if (payload.thinking) {
+        const reasoningMessage = {
+          id: `reasoning-${payload.streamId}-thinking`,
+          type: "reasoning",
+          content: payload.thinking,
+          status: payload.status,
+          timestamp: event.timestamp
+        };
+        if (existing.reasoning !== void 0) messages[existing.reasoning] = reasoningMessage;
+        else existing.reasoning = messages.push(reasoningMessage) - 1;
+      }
+      if (payload.text) {
+        const agentMessage = {
+          id: `agent-${payload.streamId}-0`,
+          type: "agent",
+          content: payload.text,
+          timestamp: event.timestamp
+        };
+        if (existing.agent !== void 0) messages[existing.agent] = agentMessage;
+        else existing.agent = messages.push(agentMessage) - 1;
+      }
+      partialIndexes.set(payload.streamId, existing);
+      return;
+    }
+    if (event.type === "claude-user") {
+      const content = normalizeContentBlocks(event.payload.message?.content);
+      const toolResult = content.find((c) => c.type === "tool_result");
+      if (toolResult && toolResult.tool_use_id) {
+        if (!toolResult.is_error) {
+          taskAccumulator.processContentBlock(toolResult);
+        }
+        return;
+      }
+      if (event.payload.isSynthetic) {
+        return;
+      }
+      const textContent = content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
+      if (LOCAL_COMMAND_ECHO_REGEX.test(textContent.trim())) {
+        return;
+      }
+      const images = content.filter((c) => c.type === "image" && c.source).map((c) => {
+        const source = c.source;
+        return {
+          type: "image",
+          mediaType: source.media_type || "image/png",
+          data: source.data || ""
+        };
+      }).filter((img) => img.data);
+      if (textContent || images.length > 0) {
+        messages.push({
+          id: `user-${event.timestamp}`,
+          type: "user",
+          content: textContent || (images.length > 0 ? `[${images.length} image${images.length > 1 ? "s" : ""} attached]` : ""),
+          images: images.length > 0 ? images : void 0,
+          timestamp: event.timestamp
+        });
+      }
+    }
+    if (event.type === "claude-assistant") {
+      const messageId = event.payload.message?.id;
+      const contentBlocks = normalizeContentBlocks(event.payload.message?.content);
+      const messageKey = messageId || event.timestamp;
+      const streamRefs = messageId ? partialIndexes.get(messageId) : void 0;
+      if (messageId) {
+        completedStreamIds.add(messageId);
+        if (liveStreamId !== null && liveStreamId !== messageId) {
+          supersededStreamIds.add(liveStreamId);
+        }
+        liveStreamId = null;
+      }
+      const thinkingBlocks = contentBlocks.flatMap(
+        (block) => block.type === "thinking" && typeof block.thinking === "string" ? [block.thinking] : []
+      );
+      if (thinkingBlocks.length > 0) {
+        const allThinking = [...assistantThinking.get(messageKey) ?? [], ...thinkingBlocks];
+        assistantThinking.set(messageKey, allThinking);
+        const reasoningMessage = {
+          id: `reasoning-${messageKey}-thinking`,
+          type: "reasoning",
+          content: allThinking.join("\n\n"),
+          status: "completed",
+          timestamp: event.timestamp
+        };
+        if (streamRefs?.reasoning !== void 0) {
+          messages[streamRefs.reasoning] = reasoningMessage;
+          streamRefs.reasoning = void 0;
+        } else {
+          upsertDisplayMessage(messages, reasoningMessage);
+        }
+      }
+      contentBlocks.forEach((block) => {
+        if (block.type === "text" && block.text) {
+          const textIndex = assistantTextCounts.get(messageKey) ?? 0;
+          assistantTextCounts.set(messageKey, textIndex + 1);
+          const agentMessage = {
+            id: `agent-${messageKey}-${textIndex}`,
+            type: "agent",
+            content: block.text,
+            timestamp: event.timestamp
+          };
+          if (streamRefs?.agent !== void 0) {
+            messages[streamRefs.agent] = agentMessage;
+            streamRefs.agent = void 0;
+          } else {
+            upsertDisplayMessage(messages, agentMessage);
+          }
+        }
+        if (block.type === "tool_use" && block.id) {
+          const toolName = block.name || "unknown";
+          const toolInput = block.input || {};
+          const toolUseId = block.id;
+          toolCallMap.set(toolUseId, {
+            messageIndex: messages.length,
+            toolName,
+            input: toolInput
+          });
+          if (toolName === "Task" || toolName === "Agent") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            const nestedEvents = events.filter((e) => e.payload.parent_tool_use_id === toolUseId).map((e) => ({
+              timestamp: e.timestamp,
+              type: e.type,
+              payload: e.payload
+            }));
+            messages.push({
+              id: `subagent-${event.timestamp}-${messages.length}`,
+              type: "subagent",
+              toolUseId,
+              description: inputObj.description || "Subagent Task",
+              prompt: inputObj.prompt || "",
+              subagentType: inputObj.subagent_type || "general",
+              model: inputObj.model,
+              status: "in_progress",
+              nestedEvents,
+              timestamp: event.timestamp
+            });
+          } else if (toolName === "Bash" || toolName === "bash" || toolName === "shell") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            const command = inputObj.command || "";
+            messages.push({
+              id: `command-${event.timestamp}-${messages.length}`,
+              type: "command",
+              command,
+              output: "",
+              status: "in_progress",
+              timestamp: event.timestamp
+            });
+          } else if (toolName === "Write" || toolName === "Edit") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            const filePath = inputObj.file_path || "";
+            const action = toolName === "Write" ? "add" : "update";
+            let diff;
+            if (toolName === "Edit" && inputObj.old_string != null && inputObj.new_string != null) {
+              const oldLines = inputObj.old_string.replace(/\n$/, "").split("\n");
+              const newLines = inputObj.new_string.replace(/\n$/, "").split("\n");
+              const hunk = `@@ -1,${oldLines.length} +1,${newLines.length} @@`;
+              diff = [
+                `--- a/${filePath}`,
+                `+++ b/${filePath}`,
+                hunk,
+                ...oldLines.map((l) => `-${l}`),
+                ...newLines.map((l) => `+${l}`)
+              ].join("\n");
+            } else if (toolName === "Write" && inputObj.content != null) {
+              const newLines = inputObj.content.replace(/\n$/, "").split("\n");
+              const hunk = `@@ -0,0 +1,${newLines.length} @@`;
+              diff = [
+                `--- /dev/null`,
+                `+++ b/${filePath}`,
+                hunk,
+                ...newLines.map((l) => `+${l}`)
+              ].join("\n");
+            }
+            messages.push({
+              id: `patch-${event.timestamp}-${messages.length}`,
+              type: "patch",
+              operations: [{
+                action,
+                path: filePath,
+                diff
+              }],
+              status: "in_progress",
+              timestamp: event.timestamp
+            });
+          } else if (toolName === "TaskCreate" || toolName === "TaskUpdate" || toolName === "TaskList") {
+            taskAccumulator.processContentBlock(block);
+            const snapshot = taskSnapshot();
+            if (snapshot.length > 0) {
+              messages.push({
+                id: `todo-${event.timestamp}-${messages.length}`,
+                type: "todo_list",
+                items: snapshot,
+                status: "completed",
+                timestamp: event.timestamp
+              });
+            }
+          } else if (toolName === "WebSearch") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            const query2 = inputObj.query || "";
+            messages.push({
+              id: `search-${event.timestamp}-${messages.length}`,
+              type: "web_search",
+              query: query2,
+              status: "in_progress",
+              timestamp: event.timestamp
+            });
+          } else if (toolName === "Skill") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            messages.push({
+              id: `skill-${event.timestamp}-${messages.length}`,
+              type: "skill",
+              skillName: inputObj.skill || "unknown",
+              args: inputObj.args,
+              status: "in_progress",
+              timestamp: event.timestamp
+            });
+          } else if (toolName === "mcp__relay-subagent-tools__spawn_agent") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            const provider = typeof inputObj.provider === "string" ? inputObj.provider : "unknown";
+            const prompt = typeof inputObj.prompt === "string" ? inputObj.prompt : "";
+            const model = typeof inputObj.model === "string" ? inputObj.model : void 0;
+            const title = typeof inputObj.title === "string" ? inputObj.title : void 0;
+            messages.push({
+              id: `subagent-${event.timestamp}-${messages.length}`,
+              type: "subagent",
+              toolUseId,
+              description: title || `Relay subagent (${provider})`,
+              prompt,
+              subagentType: provider,
+              model,
+              thinkingLevel: isValidThinkingLevel(inputObj.thinking_level) ? inputObj.thinking_level : void 0,
+              status: "in_progress",
+              nestedEvents: [],
+              isChatBased: true,
+              timestamp: event.timestamp
+            });
+          } else if (toolName === "mcp__relay-subagent-tools__delete_agent") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            const mcp = parseMcpToolName(toolName);
+            messages.push({
+              id: `toolcall-${event.timestamp}-${messages.length}`,
+              type: "tool_call",
+              server: mcp?.server ?? "relay-subagent-tools",
+              tool: mcp?.tool ?? "delete_agent",
+              input: inputObj,
+              status: "in_progress",
+              timestamp: event.timestamp
+            });
+          } else {
+            messages.push({
+              id: `toolcall-${event.timestamp}-${messages.length}`,
+              type: "tool_call",
+              server: "claude",
+              tool: toolName,
+              input: toolInput,
+              status: "in_progress",
+              timestamp: event.timestamp
+            });
+          }
+        }
+      });
+    }
+    if (event.type === "claude-result") {
+      const payload = coerceClaudeResultPayload(event.payload);
+      if (isClaudeResultError(payload)) {
+        const errorList = payload.errors || [];
+        const errorMessage = errorList.length > 0 ? errorList.join("\n") : "Claude session encountered an unexpected error.";
+        messages.push({
+          id: `error-${event.timestamp}`,
+          type: "error",
+          message: errorMessage,
+          timestamp: event.timestamp
+        });
+      }
+    }
+    if (event.type === "claude-system") {
+      const payload = coerceBackgroundTaskPayload(event.payload);
+      if (payload) {
+        const existing = taskMessageMap.get(payload.taskId);
+        const nextStatus = payload.subtype === "task_notification" ? normalizeBackgroundTaskStatus(payload.status) : payload.subtype === "task_updated" ? normalizeBackgroundTaskStatus(payload.patch?.status) : existing?.status ?? "in_progress";
+        const nextMessage = {
+          id: existing?.id ?? `task-${event.timestamp}-${messages.length}`,
+          type: "background_task",
+          taskId: payload.taskId,
+          status: nextStatus,
+          description: payload.description ?? payload.patch?.description ?? existing?.description,
+          summary: payload.summary ?? existing?.summary,
+          outputFile: payload.outputFile ?? existing?.outputFile,
+          taskType: payload.taskType ?? existing?.taskType,
+          workflowName: payload.workflowName ?? existing?.workflowName,
+          prompt: payload.prompt ?? existing?.prompt,
+          lastToolName: payload.lastToolName ?? existing?.lastToolName,
+          usage: payload.usage ?? existing?.usage,
+          error: payload.patch?.error ?? existing?.error,
+          isBackgrounded: payload.patch?.isBackgrounded ?? existing?.isBackgrounded,
+          timestamp: existing?.timestamp ?? event.timestamp
+        };
+        if (existing) {
+          Object.assign(existing, nextMessage);
+        } else {
+          taskMessageMap.set(payload.taskId, nextMessage);
+          messages.push(nextMessage);
+        }
+      }
+    }
+  });
+  filteredEvents.forEach((event) => {
+    if (event.type === "replicas-tool-input-request") {
+      const payload = event.payload;
+      if (!payload.toolUseId || !payload.requestId) return;
+      if (!Array.isArray(payload.options) && !Array.isArray(payload.questions)) return;
+      const toolInfo = toolCallMap.get(payload.toolUseId);
+      if (!toolInfo) return;
+      const message = messages[toolInfo.messageIndex];
+      if (!message || message.type !== "tool_call") return;
+      message.inputRequest = {
+        requestId: payload.requestId,
+        status: "pending",
+        options: payload.options,
+        questions: payload.questions
+      };
+    }
+    if (event.type === "replicas-tool-input-resolved") {
+      const payload = event.payload;
+      if (!payload.toolUseId || !payload.selectionId) return;
+      const toolInfo = toolCallMap.get(payload.toolUseId);
+      if (!toolInfo) return;
+      const message = messages[toolInfo.messageIndex];
+      if (!message || message.type !== "tool_call" || !message.inputRequest) return;
+      message.inputRequest = {
+        ...message.inputRequest,
+        status: payload.selectionId === "aborted" ? "aborted" : "resolved",
+        selectionId: payload.selectionId,
+        selectionSummary: payload.selectionSummary
+      };
+    }
+  });
+  filteredEvents.forEach((event) => {
+    if (event.type === "claude-user") {
+      const content = normalizeContentBlocks(event.payload.message?.content);
+      const toolResult = content.find((c) => c.type === "tool_result");
+      if (toolResult && toolResult.tool_use_id) {
+        const toolInfo = toolCallMap.get(toolResult.tool_use_id);
+        if (!toolInfo) return;
+        const resultContent = extractToolResultText(toolResult.content);
+        const isError = toolResult.is_error || false;
+        const status = isError ? "failed" : "completed";
+        if (toolInfo.toolName === "TaskCreate" && !isError) {
+          taskAccumulator.processContentBlock(toolResult);
+        }
+        const message = messages[toolInfo.messageIndex];
+        if (!message) return;
+        if (message.type === "command") {
+          message.output = resultContent;
+          message.status = status;
+          const exitCodeMatch = resultContent.match(/exit code:?\s*(\d+)/i);
+          if (exitCodeMatch) {
+            message.exitCode = parseInt(exitCodeMatch[1], 10);
+          } else {
+            message.exitCode = isError ? 1 : 0;
+          }
+        } else if (message.type === "patch") {
+          message.status = status;
+        } else if (message.type === "web_search") {
+          message.status = status;
+        } else if (message.type === "tool_call") {
+          message.output = resultContent;
+          message.status = status;
+        } else if (message.type === "skill") {
+          message.status = status;
+        } else if (message.type === "subagent") {
+          message.output = resultContent;
+          message.status = status;
+          if (!message.chatId && resultContent) {
+            const parsed = safeJsonParse(resultContent, {});
+            if (parsed.chatId) {
+              message.chatId = parsed.chatId;
+            }
+          }
+        }
+      }
+    }
+  });
+  const staleIndexes = /* @__PURE__ */ new Set();
+  for (const streamId of [...completedStreamIds, ...supersededStreamIds]) {
+    const refs = partialIndexes.get(streamId);
+    if (refs?.reasoning !== void 0) staleIndexes.add(refs.reasoning);
+    if (refs?.agent !== void 0) staleIndexes.add(refs.agent);
+  }
+  if (staleIndexes.size === 0) return messages;
+  return messages.filter((_, index) => !staleIndexes.has(index));
+}
 
 // ../shared/src/agent-event-utils.ts
 function getUserMessage(event) {
@@ -3369,6 +4478,21 @@ function parseAgentEventJsonlWithCodexAspTranscript(content, options = {}) {
 var DUPLICATE_WINDOW_MS = 5 * 60 * 1e3;
 
 // ../shared/src/display-message/parsers/index.ts
+function parseAgentEvents(events, agentType) {
+  if (agentType === "codex") {
+    return parseCodexEvents(events);
+  }
+  if (agentType === "cursor") {
+    return parseCursorEvents(events);
+  }
+  if (agentType === "opencode") {
+    return parseOpencodeEvents(events);
+  }
+  if (agentType === "pi") {
+    return parsePiEvents(events);
+  }
+  return parseClaudeEvents(events);
+}
 function isAgentBackendEvent(value) {
   if (!value || typeof value !== "object") return false;
   const candidate = value;
@@ -8617,7 +9741,7 @@ var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
 var MIN_CODEX_CLI_VERSION = "0.144.0";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.462";
+var ENGINE_PACKAGE_VERSION = "0.1.463";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -9828,16 +10952,25 @@ var CodexAspManager = class extends CodingAgentManager {
     try {
       await dispatch();
     } catch (error) {
-      if (isCodexAuthError(error)) {
-        const refreshed = await codexTokenManager.fetchFreshCredentials(error instanceof Error ? error.message : String(error));
+      let terminalError = error;
+      if (isCodexAuthError(terminalError)) {
+        const refreshed = await codexTokenManager.fetchFreshCredentials(terminalError instanceof Error ? terminalError.message : String(terminalError));
         if (refreshed) {
-          await restartCodexAspHost();
-          this.threadAttached = false;
-          await dispatch();
-          return;
+          try {
+            await restartCodexAspHost();
+            this.threadAttached = false;
+            await dispatch();
+            return;
+          } catch (retryError) {
+            terminalError = retryError;
+          }
         }
       }
-      throw error;
+      const event = this.recordHistoryEvent("codex-asp-error", {
+        message: terminalError instanceof Error ? terminalError.message : String(terminalError)
+      });
+      this.onEvent(event);
+      throw terminalError;
     } finally {
       this.transcriptUpdateCoalescer.flushPending();
       this.transcriptUpdateCoalescer.dispose();
@@ -12984,6 +14117,28 @@ function getCodexTranscriptFromEvent(event) {
   }
   return applyCodexAspTranscriptDelta(null, transcriptDelta);
 }
+function terminalErrorsFromEvent(event, provider, codexTranscript) {
+  if (event.type === "claude-result") {
+    const payload = coerceClaudeResultPayload(event.payload);
+    if (!isClaudeResultError(payload)) return null;
+    return payload.errors?.length ? payload.errors : ["Claude run failed"];
+  }
+  if (event.type === CODEX_QUOTA_STATUS_EVENT_TYPE) {
+    return event.payload.state === "out_of_credits" ? ["Codex is out of credits. Top up the connected OpenAI account to resume."] : null;
+  }
+  if (event.type === "codex-asp-error") {
+    return [typeof event.payload.message === "string" ? event.payload.message : "Codex run failed"];
+  }
+  const failedCodexTurn = codexTranscript?.turns.at(-1);
+  if (failedCodexTurn?.status === "failed") {
+    const errors2 = failedCodexTurn.items.flatMap((item) => item.type === "error" ? [item.message] : []);
+    return errors2.length > 0 ? errors2 : ["Codex run failed"];
+  }
+  const mayContainProviderError = provider === "cursor" && event.type === "cursor-error" || provider === "opencode" && (event.type === "opencode-error" || event.type === "opencode-message.updated") || provider === "pi" && (event.type === "pi-error" || event.type === "pi-message_end");
+  if (!mayContainProviderError) return void 0;
+  const errors = parseAgentEvents([event], provider).flatMap((message) => message.type === "error" ? [message.message] : []);
+  return errors.length > 0 ? errors : void 0;
+}
 function acceptedEventInCodexTranscript(acceptedEvent, transcript) {
   const message = getUserMessage(acceptedEvent);
   if (!message) return false;
@@ -13149,6 +14304,9 @@ var ChatService = class {
     }
     const acceptedEvent = createUserMessageEvent(request.message, result.messageId, request.images);
     chat.pendingMessageIds.push(result.messageId);
+    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);
@@ -13515,7 +14673,9 @@ var ChatService = class {
       activeMessageId: null,
       hasActiveTurn: false,
       observedBranchesByRepo: /* @__PURE__ */ new Map(),
-      lastTurnErrors: null
+      lastTurnErrors: null,
+      errorNotificationTargets: /* @__PURE__ */ new Map(),
+      activeErrorNotificationTarget: null
     };
   }
   touch(chat) {
@@ -13560,6 +14720,8 @@ var ChatService = class {
       }
       chat.hasActiveTurn = true;
       chat.activeMessageId = messageId;
+      chat.activeErrorNotificationTarget = chat.errorNotificationTargets.get(messageId) ?? null;
+      chat.errorNotificationTargets.delete(messageId);
       this.publish({
         type: "chat.turn.started",
         payload: {
@@ -13569,9 +14731,10 @@ var ChatService = class {
       }).catch(() => {
       });
     }
-    if (event.type === "claude-result") {
-      const payload = coerceClaudeResultPayload(event.payload);
-      chat.lastTurnErrors = isClaudeResultError(payload) && payload.errors?.length ? payload.errors : null;
+    const codexTranscript = getCodexTranscriptFromEvent(event);
+    const terminalErrors = terminalErrorsFromEvent(event, chat.persisted.provider, codexTranscript);
+    if (terminalErrors !== void 0) {
+      chat.lastTurnErrors = terminalErrors;
     }
     let eventToPublish = event;
     if (event.type === "event_msg" && event.payload.type === "user_message") {
@@ -13592,7 +14755,6 @@ var ChatService = class {
         }
       }
     }
-    const codexTranscript = getCodexTranscriptFromEvent(event);
     if (codexTranscript) {
       for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
         if (acceptedEventInCodexTranscript(acceptedEvent, codexTranscript)) {
@@ -13746,6 +14908,8 @@ var ChatService = class {
     chat.observedBranchesByRepo = /* @__PURE__ */ new Map();
     const errors = chat.persisted.parentChatId === null ? chat.lastTurnErrors : null;
     chat.lastTurnErrors = null;
+    const errorNotificationTarget = chat.activeErrorNotificationTarget;
+    chat.activeErrorNotificationTarget = null;
     let repoStatuses = [];
     let repoStateComplete = false;
     try {
@@ -13765,7 +14929,8 @@ var ChatService = class {
       const payload = {
         ...linearSessionId ? { linearSessionId } : {},
         repoStatuses,
-        ...errors?.length ? { errors } : {}
+        ...errors?.length ? { errors } : {},
+        ...errors?.length && errorNotificationTarget ? { errorNotificationTarget } : {}
       };
       await monolithService.sendEvent({ type: "agent_turn_complete", payload });
     } catch (error) {
@@ -14603,7 +15768,19 @@ var sendMessageSchema = z4.object({
   senderUserId: z4.string().optional(),
   senderEmail: z4.string().optional(),
   senderDisplayName: z4.string().optional(),
-  senderAvatarUrl: z4.string().optional()
+  senderAvatarUrl: z4.string().optional(),
+  errorNotificationTarget: z4.discriminatedUnion("type", [
+    z4.object({ type: z4.literal("slack") }),
+    z4.object({ type: z4.literal("linear"), sessionId: z4.string().min(1) }),
+    z4.object({
+      type: z4.literal("code_host"),
+      provider: z4.enum(["github", "gitlab"]),
+      resource: z4.enum(["issue", "pull_request"]),
+      repositoryId: z4.string().min(1),
+      resourceNumber: z4.number().int().positive()
+    }),
+    z4.object({ type: z4.literal("automation"), executionId: z4.string().min(1) })
+  ]).optional()
 });
 var respondToolInputSchema = z4.object({
   requestId: z4.string().min(1),

package/package.json

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