replicas-engine 0.1.869 → 0.1.871

package/dist/src/index.js

@@ -91,7 +91,7 @@ import {
   evaluateCommandProtection,
   extractToolCommand,
   reportCommandProtectionBlock
-} from "./chunk-RMSEJMO4.js";
+} from "./chunk-6YEU4TRD.js";
 import {
   ACCOUNT_RATE_LIMITS_UPDATED_METHOD,
   AGENT_MESSAGE_DELTA_METHOD,
@@ -132,20 +132,20 @@ import {
   recordCredentialFallback,
   recordExhaustedCredential,
   restartCodexAspHost
-} from "./chunk-COJG7NIH.js";
+} from "./chunk-TGECCL6C.js";
 import {
   ENGINE_ENV,
   IS_WARMING_MODE,
   monolithRequest,
   monolithService,
   setAgentCredentialSnapshot
-} from "./chunk-AZVITHZV.js";
+} from "./chunk-VXF4AHJU.js";
 import {
   AspClient,
   SUBPROCESS_MAX_BUFFER,
   execAsync,
   execFileAsync
-} from "./chunk-TZGLNBWY.js";
+} from "./chunk-GN43A3FI.js";
 import {
   isRecord as isRecord2
 } from "./chunk-UZSNFLDQ.js";
@@ -180,12 +180,13 @@ import {
   CLAUDE_SONNET_5_BEDROCK_MODEL,
   CLAUDE_SONNET_5_MODEL,
   CODEX_ASP_ITEM_ID_PAYLOAD_KEY,
-  CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE,
+  CODEX_HISTORY_FORMAT_EVENT_TYPE,
   CODEX_QUOTA_STATUS_EVENT_TYPE,
   COMPACTION_STATUS_EVENT_TYPE,
   CONTEXT_USAGE_EVENT_TYPE,
   CREDENTIAL_METHOD,
   CURSOR_CONNECTION_STATUS_EVENT_TYPE,
+  CodexHistoryEventFolder,
   DEFAULT_ASTER_MODEL,
   DEFAULT_CHAT_TITLES,
   DEFAULT_CLAUDE_MODEL,
@@ -233,7 +234,6 @@ import {
   USER_MESSAGE_ID_PAYLOAD_KEY,
   VALID_AGENT_PROVIDERS,
   agentQuotaExhaustedPayloadSchema,
-  applyCodexAspTranscriptDelta,
   areSameUserMessageEvents,
   areUserMessagesWithinMatchWindow,
   autoCompactThresholdField,
@@ -248,7 +248,12 @@ import {
   clampWarmHookTimeoutMs,
   classifyCanvasFilename,
   claudeAuthEnvFromResponse,
+  codexHistoryFormatEvent,
+  codexItemEvent,
   codexReasoningEffortForThinkingLevel,
+  codexTranscriptToEvents,
+  codexTurnEvent,
+  codexTurnFromEvent,
   coerceBackgroundTaskPayload,
   coerceChatForkInfo,
   coerceChatGoalPayload,
@@ -256,7 +261,6 @@ import {
   createAcceptedUserMessageEvent,
   createChatHistoryCursor,
   createChatRequestSchema,
-  createChatTranscriptPages,
   createErrorResult,
   createProviderSlashCommand,
   createSuccessResult,
@@ -276,12 +280,9 @@ import {
   formatChatForkHandoffMessage,
   getChatExecutionProvider,
   getChatHistoryPageSenders,
-  getChatHistoryPageWindow,
-  getChatTranscriptHistorySize,
   getClaudeModelContextWindow,
-  getClaudePartialMessageStreamId,
-  getCodexAspTurnResponse,
   getDefaultAgentModel,
+  getEventStreamId,
   getEventTimestampMs,
   getGitHubAccessToken,
   getGoalCommand,
@@ -295,17 +296,15 @@ import {
   githubCredentialLines,
   hasChatStarted,
   imageContentToUserMessageImages,
-  isAgentBackendEvent,
   isAgentChatMcpActivityRecord,
   isAgentChatSkillActivityRecord,
   isAgentChatTurnActivityRecord,
   isAuthenticationErrorText,
   isCanvasTextKind,
+  isChatHistoryEvent,
   isChatMessageSender,
   isClaudeAuthErrorText,
   isClaudeResultError,
-  isCodexAspTranscript,
-  isCodexAspTranscriptDelta,
   isCodexAuthError,
   isDefaultChat,
   isExcludedRepoFilePath,
@@ -330,20 +329,18 @@ import {
   normalizeContentBlocks,
   paginateChatHistory,
   paginateEngineLogContent,
-  parseAgentEventJsonlWithCodexAspTranscript,
+  parseAgentEventJsonlLine,
   parseAgentEvents,
   parseChatHistoryCursor,
   parseChatTranscriptArtifact,
   parseDisplayMessages,
   parseFrontmatter,
   parseGitRemote,
-  parseLatestCodexAspTranscriptTurn,
   parseMcpToolName,
   parseReplicasConfigString,
   percentage,
   raceWithTimeout,
   readJsonlPage,
-  renumberCodexAspTranscriptItems,
   resolveWarmHookConfig,
   safeJsonParse,
   sanitizeCanvasFilename,
@@ -358,7 +355,7 @@ import {
   waitRelaySubagentRequestSchema,
   withTimeout,
   workspaceCredentialProviderSchema
-} from "./chunk-IT5R5GJT.js";
+} from "./chunk-XHX6IRSG.js";
 import {
   __commonJS,
   __export,
@@ -10701,8 +10698,8 @@ async function registerDesktopPreview() {
 }
 
 // src/services/chat/chat-service.ts
-import { appendFile as appendFile5, copyFile as copyFile2, mkdir as mkdir21, readFile as readFile24, rename as rename4, rm as rm4 } from "fs/promises";
-import { join as join37 } from "path";
+import { appendFile as appendFile5, copyFile as copyFile2, mkdir as mkdir21, readFile as readFile23, rename as rename5, rm as rm4 } from "fs/promises";
+import { join as join36 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 
 // ../shared/src/workspace-chat.ts
@@ -10740,7 +10737,7 @@ function workspaceChatEventSignals(event) {
     eventJsonCache.set(event, json);
   }
   return {
-    streamId: getClaudePartialMessageStreamId(event),
+    streamId: getEventStreamId(event),
     json,
     userMessage: getComparableUserMessage(event),
     userMessageId: event.type === QUEUED_MESSAGE_REMOVED_EVENT_TYPE ? null : getUserMessageId(event)
@@ -10850,7 +10847,7 @@ function mergeWorkspaceChatHistoryEvents(primary, supplemental, removedMessageId
       list[position] = null;
       unindexEvent(listIndex, previous, position);
       addEvent(event);
-    } else if (getClaudePartialMessageStreamId(event) !== null || messageId !== null && messageId === getUserMessageId(previous)) {
+    } else if (getEventStreamId(event) !== null || messageId !== null && messageId === getUserMessageId(previous)) {
       list[position] = event;
       unindexEvent(listIndex, previous, position);
       indexMergedEvent(listIndex, event, position);
@@ -10880,7 +10877,7 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname4, join as join16 } from "path";
-import { mkdir as mkdir10, readdir as readdir4, readFile as readFile11 } from "fs/promises";
+import { mkdir as mkdir10, readdir as readdir4, readFile as readFile10 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 
 // src/utils/linear-converter.ts
@@ -12444,7 +12441,13 @@ function isNotFoundError(error) {
 }
 
 // src/managers/codex-asp/codex-history-file.ts
-import { appendFile as appendFile2, open, readFile as readFile10 } from "fs/promises";
+import { createReadStream } from "fs";
+import { appendFile as appendFile2, open, rename as rename2 } from "fs/promises";
+import { createInterface } from "readline";
+var MIGRATION_FLUSH_CHARS = 1 << 20;
+function isMissingFile(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
 var CodexHistoryFile = class {
   constructor(filePath) {
     this.filePath = filePath;
@@ -12464,40 +12467,79 @@ var CodexHistoryFile = class {
   async flush() {
     await this.writeLock.drain();
   }
-  async load() {
+  /**
+   * Rewrites a file that still holds legacy Codex transcript records as plain
+   * item events, once. The file is read line by line: a long-lived chat can
+   * exceed the largest string V8 will hold. The rewritten file starts with a
+   * format marker so later starts only read that first line.
+   */
+  async ensureItemEventFormat() {
+    const firstLine = await this.readFirstLine();
+    if (firstLine === null) {
+      await this.appendDurably(codexHistoryFormatEvent());
+      return;
+    }
+    if (parseAgentEventJsonlLine(firstLine)?.type === CODEX_HISTORY_FORMAT_EVENT_TYPE) return;
+    await this.writeLock.run(async () => {
+      const events = await this.loadAll();
+      const rewritten = `${this.filePath}.migrating`;
+      const handle = await open(rewritten, "w");
+      try {
+        let pending = "";
+        for (const event of [codexHistoryFormatEvent(), ...events]) {
+          pending += `${JSON.stringify(event)}
+`;
+          if (pending.length >= MIGRATION_FLUSH_CHARS) {
+            await handle.write(pending);
+            pending = "";
+          }
+        }
+        if (pending) await handle.write(pending);
+      } finally {
+        await handle.close();
+      }
+      await rename2(rewritten, this.filePath);
+    });
+  }
+  /**
+   * Newest event of `type`, scanning the whole file so a value older than the
+   * most recent page is still found. Streams line by line and retains only the
+   * match, so history size does not bound memory.
+   */
+  async findLastEventOfType(type) {
+    let found = null;
     try {
-      const content = await readFile10(this.filePath, "utf-8");
-      return parseAgentEventJsonlWithCodexAspTranscript(content);
+      for await (const line of createInterface({ input: createReadStream(this.filePath), crlfDelay: Infinity })) {
+        const event = parseAgentEventJsonlLine(line);
+        if (event?.type === type) found = event;
+      }
     } catch (error) {
-      if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
-        console.error("[CodexHistoryFile] Failed to load history file:", error);
+      if (!isMissingFile(error)) throw error;
+    }
+    return found;
+  }
+  async loadAll() {
+    const folder = new CodexHistoryEventFolder();
+    try {
+      for await (const line of createInterface({ input: createReadStream(this.filePath), crlfDelay: Infinity })) {
+        const event = parseAgentEventJsonlLine(line);
+        if (event) folder.push(event);
       }
-      return { events: [], transcript: null, transcriptsByThreadId: /* @__PURE__ */ new Map() };
+    } catch (error) {
+      if (!isMissingFile(error)) throw error;
     }
+    return folder.finish();
   }
   async loadEventsPage(page2) {
-    if (page2.limit === void 0) {
-      const history = await this.load();
-      return { events: history.events };
-    }
+    if (page2.limit === void 0) return { events: await this.loadAll() };
     const cursor = parseChatHistoryCursor(page2.beforeCursor);
     if (page2.beforeCursor !== void 0 && cursor?.mode !== "range") throw new RangeError("Invalid chat history cursor");
-    if (cursor?.events === null) {
-      return {
-        events: [],
-        beforeCursor: createChatHistoryCursor({
-          events: null,
-          turns: cursor.turns
-        })
-      };
-    }
+    if (cursor?.events === null) return { events: [], beforeCursor: null };
     let file;
     try {
       file = await open(this.filePath, "r");
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-        return { events: [], beforeCursor: null };
-      }
+      if (isMissingFile(error)) return { events: [], beforeCursor: null };
       throw error;
     }
     try {
@@ -12510,19 +12552,35 @@ var CodexHistoryFile = class {
           const { bytesRead } = await file.read(bytes, 0, bytes.length, startByte);
           return bytes.subarray(0, bytesRead);
         },
-        parse: (value) => isAgentBackendEvent(value) && value.type !== CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE ? value : void 0
+        parse: (value) => isChatHistoryEvent(value) ? value : void 0
       });
       return {
         events: result.items,
-        beforeCursor: createChatHistoryCursor({
-          events: result.before,
-          turns: cursor?.turns ?? null
-        })
+        beforeCursor: createChatHistoryCursor({ events: result.before, turns: null })
       };
     } finally {
       await file.close();
     }
   }
+  async readFirstLine() {
+    let file;
+    try {
+      file = await open(this.filePath, "r");
+    } catch (error) {
+      if (isMissingFile(error)) return null;
+      throw error;
+    }
+    try {
+      const bytes = Buffer.allocUnsafe(4096);
+      const { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
+      if (bytesRead === 0) return null;
+      const text = bytes.subarray(0, bytesRead).toString("utf-8");
+      const newline = text.indexOf("\n");
+      return newline === -1 ? text : text.slice(0, newline);
+    } finally {
+      await file.close();
+    }
+  }
 };
 
 // src/managers/claude-activity.ts
@@ -13100,7 +13158,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       const agentId = /^agent-(.+)\.jsonl$/.exec(file)?.[1];
       if (!agentId) continue;
       const offset = workflow.offsets.get(file) ?? 0;
-      const buffer = await readFile11(join16(workflow.dir, file)).catch(() => Buffer.alloc(0));
+      const buffer = await readFile10(join16(workflow.dir, file)).catch(() => Buffer.alloc(0));
       const end = buffer.lastIndexOf(10);
       if (end < offset) continue;
       workflow.offsets.set(file, end + 1);
@@ -14077,10 +14135,6 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   }
 };
 
-// src/managers/codex-asp/codex-asp-manager.ts
-import { readdir as readdir5 } from "fs/promises";
-import { join as join18 } from "path";
-
 // src/utils/codex-quota.ts
 function buildCodexRateLimitsSnapshot(fields) {
   if (fields.authMethod !== "oauth") return null;
@@ -14508,128 +14562,7 @@ function turnsToAspTranscript(threadId, updatedAt, sourceTurns) {
       items
     };
   });
-  return renumberCodexAspTranscriptItems({
-    threadId,
-    updatedAt,
-    turns
-  });
-}
-function latestIsoTimestamp(a, b) {
-  return Date.parse(a) >= Date.parse(b) ? a : b;
-}
-function nextTranscriptSequence(transcript) {
-  let max = -1;
-  for (const turn of transcript.turns) {
-    for (const item of turn.items) {
-      if (typeof item.sequence === "number" && item.sequence > max) {
-        max = item.sequence;
-      }
-    }
-  }
-  return max + 1;
-}
-function transcriptItemRank(item) {
-  return item.type === "userMessage" ? 0 : 1;
-}
-function transcriptItemSignature(item) {
-  if (item.type === "userMessage") return `user:${item.content.trim()}`;
-  if (item.type === "agentMessage" && item.text.trim()) return `agent:${item.text.trim()}`;
-  if (item.type === "plan" && item.text.trim()) return `plan:${item.text.trim()}`;
-  if (item.type === "error" && item.message.trim()) return `error:${item.message.trim()}`;
-  return null;
-}
-function areEquivalentTranscriptItems(current, candidate) {
-  if (current.id === candidate.id) return true;
-  if (current.type !== candidate.type) return false;
-  const signature = transcriptItemSignature(current);
-  return signature !== null && signature === transcriptItemSignature(candidate);
-}
-function findEquivalentCodexAspTranscriptItemIndex(items, candidate) {
-  return items.findIndex((current) => areEquivalentTranscriptItems(current, candidate));
-}
-function sortTranscriptItems(items) {
-  return [...items].map((item, index) => ({ item, index })).sort((a, b) => {
-    const aSequence = a.item.sequence ?? Number.MAX_SAFE_INTEGER;
-    const bSequence = b.item.sequence ?? Number.MAX_SAFE_INTEGER;
-    return transcriptItemRank(a.item) - transcriptItemRank(b.item) || aSequence - bSequence || Date.parse(a.item.timestamp) - Date.parse(b.item.timestamp) || a.index - b.index;
-  }).map(({ item }) => item);
-}
-function dedupeTranscriptItems(items) {
-  const deduped = [];
-  for (const item of items) {
-    const existingIndex = findEquivalentCodexAspTranscriptItemIndex(deduped, item);
-    if (existingIndex === -1) {
-      deduped.push(item);
-      continue;
-    }
-    deduped[existingIndex] = mergeCodexAspTranscriptItem(deduped[existingIndex], item);
-  }
-  return deduped;
-}
-function normalizeCodexAspTranscriptSequences(transcript) {
-  const turns = [...transcript.turns].map((turn, index) => ({ turn, index })).sort((a, b) => Date.parse(a.turn.startedAt) - Date.parse(b.turn.startedAt) || a.index - b.index).map(({ turn }) => ({
-    ...turn,
-    items: sortTranscriptItems(dedupeTranscriptItems(turn.items))
-  }));
-  return renumberCodexAspTranscriptItems({
-    ...transcript,
-    turns
-  });
-}
-function mergeCodexAspTranscriptItem(current, candidate) {
-  if (current.type === "agentMessage" && candidate.type === "agentMessage" && candidate.text.length === 0) {
-    return {
-      ...current,
-      sequence: current.sequence ?? candidate.sequence
-    };
-  }
-  return {
-    ...current,
-    ...candidate,
-    id: current.id,
-    ...current.type === "userMessage" && candidate.type === "userMessage" && !candidate.images && current.images ? { images: current.images } : {},
-    timestamp: current.timestamp,
-    sequence: current.sequence ?? candidate.sequence
-  };
-}
-function mergeCodexAspTranscripts(primary, supplemental) {
-  if (!primary) return supplemental ? normalizeCodexAspTranscriptSequences(supplemental) : null;
-  if (!supplemental) return normalizeCodexAspTranscriptSequences(primary);
-  if (primary.threadId !== supplemental.threadId) return normalizeCodexAspTranscriptSequences(supplemental);
-  let sequence = nextTranscriptSequence(primary);
-  const turns = primary.turns.map((turn) => ({
-    ...turn,
-    items: [...turn.items]
-  }));
-  for (const supplementalTurn of supplemental.turns) {
-    const existingTurn = turns.find((turn) => turn.id === supplementalTurn.id);
-    if (!existingTurn) {
-      turns.push({
-        ...supplementalTurn,
-        items: supplementalTurn.items.map((item) => typeof item.sequence === "number" ? item : { ...item, sequence: sequence++ })
-      });
-      continue;
-    }
-    existingTurn.status = supplementalTurn.status;
-    existingTurn.completedAt = supplementalTurn.completedAt ?? existingTurn.completedAt;
-    existingTurn.startedAt = Date.parse(existingTurn.startedAt) <= Date.parse(supplementalTurn.startedAt) ? existingTurn.startedAt : supplementalTurn.startedAt;
-    for (const item of supplementalTurn.items) {
-      const existingIndex = findEquivalentCodexAspTranscriptItemIndex(existingTurn.items, item);
-      if (existingIndex === -1) {
-        existingTurn.items.push(
-          typeof item.sequence === "number" ? item : { ...item, sequence: sequence++ }
-        );
-        continue;
-      }
-      existingTurn.items[existingIndex] = mergeCodexAspTranscriptItem(existingTurn.items[existingIndex], item);
-    }
-    existingTurn.items = sortTranscriptItems(existingTurn.items);
-  }
-  return normalizeCodexAspTranscriptSequences({
-    threadId: primary.threadId,
-    updatedAt: latestIsoTimestamp(primary.updatedAt, supplemental.updatedAt),
-    turns: turns.sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt))
-  });
+  return { threadId, updatedAt, turns };
 }
 async function buildThreadStartParams(workingDirectory, request, developerInstructions, serviceTier, relayParentChatId) {
   const additionalDirectories = await getAgentAdditionalDirectories();
@@ -14716,96 +14649,42 @@ async function buildTurnStartParams(threadId, request, serviceTier) {
   };
 }
 
-// src/managers/codex-asp/transcript-update-coalescer.ts
-var TRANSCRIPT_UPDATE_COALESCE_MS = 1e3;
-var TranscriptUpdateCoalescer = class {
-  constructor(flush, intervalMs = TRANSCRIPT_UPDATE_COALESCE_MS) {
+// src/managers/codex-asp/item-update-coalescer.ts
+var ITEM_UPDATE_COALESCE_MS = 250;
+var ItemUpdateCoalescer = class {
+  constructor(flush, intervalMs = ITEM_UPDATE_COALESCE_MS) {
     this.flush = flush;
     this.intervalMs = intervalMs;
   }
   flush;
   intervalMs;
-  timer = null;
-  pendingThreadId = null;
-  lastFlushAt = 0;
-  schedule(threadId, options = {}) {
-    this.pendingThreadId = threadId;
-    if (options.immediate) {
-      this.flushNow(threadId);
-      return;
-    }
-    const now = Date.now();
-    const elapsed = now - this.lastFlushAt;
-    if (elapsed >= this.intervalMs) {
-      this.flushNow(threadId);
-      return;
-    }
-    if (this.timer) {
+  timers = /* @__PURE__ */ new Map();
+  lastFlushAt = /* @__PURE__ */ new Map();
+  schedule(key, options = {}) {
+    if (this.timers.has(key)) return;
+    const elapsed = Date.now() - (this.lastFlushAt.get(key) ?? 0);
+    if (options.immediate || elapsed >= this.intervalMs) {
+      this.flushNow(key);
       return;
     }
-    this.timer = setTimeout(() => {
-      const pendingThreadId = this.pendingThreadId;
-      if (pendingThreadId) {
-        this.flushNow(pendingThreadId);
-      }
-    }, this.intervalMs - elapsed);
+    this.timers.set(key, setTimeout(() => this.flushNow(key), this.intervalMs - elapsed));
   }
   flushPending() {
-    const pendingThreadId = this.pendingThreadId;
-    if (pendingThreadId) {
-      this.flushNow(pendingThreadId);
-      return;
-    }
-    this.clearTimer();
+    for (const key of [...this.timers.keys()]) this.flushNow(key);
   }
   dispose() {
-    this.pendingThreadId = null;
-    this.clearTimer();
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
   }
-  flushNow(threadId) {
-    this.clearTimer();
-    this.pendingThreadId = null;
-    this.lastFlushAt = Date.now();
-    this.flush(threadId);
-  }
-  clearTimer() {
-    if (!this.timer) return;
-    clearTimeout(this.timer);
-    this.timer = null;
+  flushNow(key) {
+    const timer = this.timers.get(key);
+    if (timer) clearTimeout(timer);
+    this.timers.delete(key);
+    this.lastFlushAt.set(key, Date.now());
+    this.flush(key);
   }
 };
 
-// src/services/chat/history-paths.ts
-import { homedir as homedir12 } from "os";
-import { join as join17 } from "path";
-var ENGINE_DIR2 = join17(homedir12(), ".replicas", "engine");
-var CHATS_FILE = join17(ENGINE_DIR2, "chats.json");
-var CLAUDE_HISTORY_DIR = join17(ENGINE_DIR2, "claude-histories");
-var RELAY_HISTORY_DIR = join17(ENGINE_DIR2, "relay-histories");
-var CODEX_HISTORY_DIR = join17(ENGINE_DIR2, "codex-histories");
-var CURSOR_HISTORY_DIR = join17(ENGINE_DIR2, "cursor-histories");
-var OPENCODE_HISTORY_DIR = join17(ENGINE_DIR2, "opencode-histories");
-var PI_HISTORY_DIR = join17(ENGINE_DIR2, "pi-histories");
-var DEEPSEEK_HISTORY_DIR = join17(ENGINE_DIR2, "deepseek-histories");
-var FX_HISTORY_DIR = join17(ENGINE_DIR2, "fx-histories");
-var GEMINI_HISTORY_DIR = join17(ENGINE_DIR2, "gemini-histories");
-var KIMI_HISTORY_DIR = join17(ENGINE_DIR2, "kimi-histories");
-var MUSE_HISTORY_DIR = join17(ENGINE_DIR2, "muse-histories");
-var FORKS_DIR = join17(ENGINE_DIR2, "forks");
-var HISTORY_DIR_BY_PROVIDER = {
-  claude: CLAUDE_HISTORY_DIR,
-  relay: RELAY_HISTORY_DIR,
-  codex: CODEX_HISTORY_DIR,
-  cursor: CURSOR_HISTORY_DIR,
-  deepseek: DEEPSEEK_HISTORY_DIR,
-  fx: FX_HISTORY_DIR,
-  gemini: GEMINI_HISTORY_DIR,
-  kimi: KIMI_HISTORY_DIR,
-  muse: MUSE_HISTORY_DIR,
-  opencode: OPENCODE_HISTORY_DIR,
-  pi: PI_HISTORY_DIR
-};
-
 // src/services/chat/errors.ts
 var ChatNotFoundError = class extends Error {
   constructor(chatId) {
@@ -14853,44 +14732,17 @@ function formatBlockedCommandReason(reason) {
   return reason?.includes("Blocked by organization policy") ? reason : `Blocked by organization policy: ${reason || "agents may not merge pull requests."}`;
 }
 async function readCodexAspThreadHistory(threadId) {
-  let entries;
-  try {
-    entries = await readdir5(CODEX_HISTORY_DIR, { withFileTypes: true });
-  } catch (error) {
-    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-      entries = [];
-    } else {
-      throw error;
-    }
-  }
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".jsonl") || entry.name.endsWith(".pages.jsonl")) continue;
-    const history = await new CodexHistoryFile(join18(CODEX_HISTORY_DIR, entry.name)).load();
-    const transcript = history.transcriptsByThreadId.get(threadId);
-    if (transcript) {
-      return {
-        thread_id: threadId,
-        events: [],
-        codexAspTranscript: transcript,
-        goal: null
-      };
-    }
-  }
+  let thread;
   try {
     const host = await getCodexAspHost();
-    const response = await host.client.request(
+    ({ thread } = await host.client.request(
       THREAD_READ_METHOD,
       { threadId, includeTurns: true }
-    );
-    return {
-      thread_id: threadId,
-      events: [],
-      codexAspTranscript: threadToAspTranscript(response.thread),
-      goal: null
-    };
+    ));
   } catch {
+    throw new CodexThreadNotFoundError(threadId);
   }
-  throw new CodexThreadNotFoundError(threadId);
+  return { thread_id: threadId, events: codexTranscriptToEvents(threadToAspTranscript(thread)), goal: null };
 }
 function skillToSlashCommand(skill) {
   if (!skill.enabled) return null;
@@ -14911,19 +14763,18 @@ function isCompactCommand(message) {
 var CodexAspManager = class extends CodingAgentManager {
   currentThreadId = null;
   activeTurnId = null;
+  lastTurnFailure = null;
   attachedClient = null;
   attachedModel = null;
   attachedDeveloperInstructions = null;
   historyFile;
-  codexAspTranscript = null;
-  lastEmittedTranscript = null;
-  dirtyTranscriptTurns = /* @__PURE__ */ new Map();
-  codexAspSequence = 0;
+  liveTurn = null;
   quotaStatus = new CodexQuotaStatusTracker();
   currentGoal = null;
   goalHistoryKnown = false;
-  transcriptUpdateCoalescer = new TranscriptUpdateCoalescer((threadId) => {
-    this.flushTranscriptUpdated(threadId);
+  itemUpdateCoalescer = new ItemUpdateCoalescer((itemId) => {
+    const item = this.liveTurn?.items.get(itemId);
+    if (this.liveTurn && item) this.onEvent(codexItemEvent(this.liveTurn.id, item, true));
   });
   skillRegistriesApplied = false;
   modelServiceTierCache = null;
@@ -14946,16 +14797,13 @@ var CodexAspManager = class extends CodingAgentManager {
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
-    const replayed = await this.historyFile?.load();
-    if (replayed?.transcript && (!this.initialSessionId || replayed.transcript.threadId === this.initialSessionId)) {
-      this.mergeTranscriptSnapshot(replayed.transcript);
-    }
-    const goalEvent = replayed?.events.findLast((event) => event.type === CHAT_GOAL_EVENT_TYPE);
+    await this.historyFile?.ensureItemEventFormat();
+    this.currentThreadId = this.initialSessionId;
+    const goalEvent = await this.historyFile?.findLastEventOfType(CHAT_GOAL_EVENT_TYPE);
     if (goalEvent) {
       this.currentGoal = coerceChatGoalPayload(goalEvent.payload);
       this.goalHistoryKnown = true;
     }
-    this.currentThreadId = this.initialSessionId ?? replayed?.transcript?.threadId ?? null;
   }
   getHistorySink() {
     return {
@@ -15046,61 +14894,25 @@ var CodexAspManager = class extends CodingAgentManager {
   }
   async getHistory(page2 = {}) {
     await this.initialized;
-    this.transcriptUpdateCoalescer.flushPending();
     await this.historyFile?.flush();
-    const transcript = await this.ensureTranscriptHistory();
-    const events = await this.historyFile?.loadEventsPage(page2) ?? { events: [], beforeCursor: null };
-    if (page2.limit === void 0) {
-      return {
-        thread_id: this.currentThreadId,
-        events: events.events,
-        codexAspTranscript: transcript,
-        goal: this.currentGoal
-      };
-    }
-    if (!this.currentThreadId) return { thread_id: null, ...events, goal: this.currentGoal };
-    const cursor = parseChatHistoryCursor(page2.beforeCursor);
-    if (page2.beforeCursor !== void 0 && cursor?.mode !== "range") throw new RangeError("Invalid chat history cursor");
-    if (page2.beforeCursor === void 0 && !this.goalHistoryKnown) {
+    const latestPage = isLatestChatHistoryPage(page2);
+    if (latestPage && !this.goalHistoryKnown && this.currentThreadId) {
       try {
         await this.refreshThreadGoal(await getCodexAspHost(), this.currentThreadId);
       } catch (error) {
         console.warn("[CodexAspManager] Failed to connect while refreshing thread goal:", error);
       }
     }
-    let transcriptPage = null;
-    let turnsBefore = null;
-    if (cursor?.turns !== null && transcript) {
-      const before = cursor?.turns === void 0 ? transcript.turns.length : /^\d+$/.test(cursor.turns) ? Number(cursor.turns) : Number.NaN;
-      if (!Number.isSafeInteger(before) || before < 0) throw new RangeError("Invalid chat history cursor");
-      const { startIndex, endIndex } = getChatHistoryPageWindow(transcript.turns.length, page2.limit, before);
-      transcriptPage = {
-        ...transcript,
-        turns: transcript.turns.slice(startIndex, endIndex)
-      };
-      turnsBefore = startIndex > 0 ? String(startIndex) : null;
-    }
-    const eventCursor = parseChatHistoryCursor(events.beforeCursor ?? void 0);
+    const history = await this.historyFile?.loadEventsPage(page2) ?? { events: [] };
+    const liveTurn = latestPage ? this.liveTurn : null;
+    const liveEvents = liveTurn ? [...liveTurn.items.values()].map((item) => codexItemEvent(liveTurn.id, item, true)) : [];
     return {
       thread_id: this.currentThreadId,
-      ...events,
-      codexAspTranscript: transcriptPage,
-      goal: this.currentGoal,
-      beforeCursor: createChatHistoryCursor({
-        events: eventCursor?.events ?? null,
-        turns: turnsBefore
-      })
+      ...history,
+      events: [...history.events, ...liveEvents],
+      goal: this.currentGoal
     };
   }
-  async ensureTranscriptHistory() {
-    if (this.codexAspTranscript || !this.currentThreadId) return this.codexAspTranscript;
-    const host = await getCodexAspHost();
-    const response = await host.client.request(
-      THREAD_READ_METHOD,
-      { threadId: this.currentThreadId, includeTurns: true }
-    );
-    return this.mergeTranscriptSnapshot(threadToAspTranscript(response.thread));
-  }
   getGoal() {
     return this.currentGoal;
   }
@@ -15257,16 +15069,16 @@ var CodexAspManager = class extends CodingAgentManager {
         }
       }
       const message = terminalError instanceof Error ? terminalError.message : String(terminalError);
-      const transcriptError = this.codexAspTranscript?.turns.find((turn) => turn.id === this.activeTurnId)?.items.find((item) => item.type === "error" && item.message === message);
+      const failedTurnId = this.lastTurnFailure?.message === message ? this.lastTurnFailure.turnId : null;
       const event = this.recordCodexHistoryEvent("codex-asp-error", {
         message,
-        ...transcriptError ? { [CODEX_ASP_ITEM_ID_PAYLOAD_KEY]: transcriptError.id } : {}
+        ...failedTurnId ? { [CODEX_ASP_ITEM_ID_PAYLOAD_KEY]: failedTurnId } : {}
       });
       this.onEvent(event);
       throw terminalError;
     } finally {
-      this.transcriptUpdateCoalescer.flushPending();
-      this.transcriptUpdateCoalescer.dispose();
+      this.itemUpdateCoalescer.flushPending();
+      this.itemUpdateCoalescer.dispose();
       this.activeTurnId = null;
       await removeTempImageFiles(this.steeredTempImagePaths.splice(0));
       await this.historyFile?.flush();
@@ -15339,7 +15151,6 @@ var CodexAspManager = class extends CodingAgentManager {
         this.attachedClient = host.client;
         this.attachedModel = requestedModel;
         this.attachedDeveloperInstructions = developerInstructions ?? null;
-        this.seedHistoryFromThread(response.thread);
         await this.onSaveSessionId(this.currentThreadId);
       }
       return this.currentThreadId ?? existingThreadId;
@@ -15443,7 +15254,6 @@ var CodexAspManager = class extends CodingAgentManager {
     const observedTurnIds = /* @__PURE__ */ new Set();
     let lastCompletedTurn = null;
     let completedResolved = false;
-    let userMessageAttached = false;
     let goalContinuationTimer = null;
     const completedItems = [];
     const agentMessageDeltas = /* @__PURE__ */ new Map();
@@ -15472,11 +15282,6 @@ var CodexAspManager = class extends CodingAgentManager {
         resolveCompleted(lastCompletedTurn);
       }, GOAL_TURN_CONTINUATION_GRACE_MS);
     };
-    const attachUserMessage = (turn) => {
-      if (userMessageAttached) return;
-      userMessageAttached = true;
-      this.ensureTranscriptTurnUserMessage(threadId, turn, request);
-    };
     const handlers = {
       [ACCOUNT_RATE_LIMITS_UPDATED_METHOD]: (notification) => {
         this.handleRateLimits(notification.params.rateLimits);
@@ -15518,14 +15323,11 @@ var CodexAspManager = class extends CodingAgentManager {
         lastCompletedTurn = null;
         completedItems.length = 0;
         agentMessageDeltas.clear();
-        attachUserMessage(notification.params.turn);
-        this.mergeTranscriptTurn(notification.params.threadId, notification.params.turn);
-        this.emitTranscriptUpdated(notification.params.threadId, { immediate: true });
+        this.startTurn(notification.params.turn);
         linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
       },
       [TURN_PLAN_UPDATED_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.emitTranscriptUpdated(notification.params.threadId);
         linearForwarder.sendPlan(extractPlanFromCodexAspNotification(notification));
       },
       [ITEM_STARTED_METHOD]: (notification) => {
@@ -15533,15 +15335,10 @@ var CodexAspManager = class extends CodingAgentManager {
         if (notification.params.item.type === "contextCompaction") {
           this.setCompacting(true);
         }
-        this.upsertTranscriptItem(
-          notification.params.threadId,
+        this.startItem(
           notification.params.turnId,
-          notification.params.item,
-          timestampFromMilliseconds(notification.params.startedAtMs),
-          "in_progress",
-          "started"
+          itemToTranscriptItem(notification.params.item, timestampFromMilliseconds(notification.params.startedAtMs), "in_progress")
         );
-        this.emitTranscriptUpdated(notification.params.threadId, { immediate: true });
         linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
       },
       [ITEM_COMPLETED_METHOD]: (notification) => {
@@ -15551,15 +15348,14 @@ var CodexAspManager = class extends CodingAgentManager {
           this.setCompacting(false);
         }
         const itemFailed = notification.params.item.type === "commandExecution" && typeof notification.params.item.exitCode === "number" && notification.params.item.exitCode !== 0;
-        this.upsertTranscriptItem(
-          notification.params.threadId,
+        this.completeItem(
           notification.params.turnId,
-          notification.params.item,
-          timestampFromMilliseconds(notification.params.completedAtMs),
-          itemFailed ? "failed" : "completed",
-          "completed"
+          itemToTranscriptItem(
+            notification.params.item,
+            timestampFromMilliseconds(notification.params.completedAtMs),
+            itemFailed ? "failed" : "completed"
+          )
         );
-        this.emitTranscriptUpdated(notification.params.threadId, { immediate: true });
         linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
         const completedItem = notification.params.item;
         if (completedItem.type === "commandExecution" && completedItem.exitCode === 0 && shouldRefreshPullRequests("commandExecution", { command: completedItem.command }) || completedItem.type === "mcpToolCall" && completedItem.status === "completed" && shouldRefreshPullRequests(completedItem.tool, completedItem.arguments) || completedItem.type === "dynamicToolCall" && completedItem.success !== false && shouldRefreshPullRequests(completedItem.tool, completedItem.arguments)) {
@@ -15571,53 +15367,27 @@ var CodexAspManager = class extends CodingAgentManager {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
         const currentText = agentMessageDeltas.get(notification.params.itemId) ?? "";
         agentMessageDeltas.set(notification.params.itemId, currentText + notification.params.delta);
-        this.appendAgentMessageDelta(
-          notification.params.threadId,
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.delta
-        );
-        this.emitTranscriptUpdated(notification.params.threadId);
+        this.appendAgentMessageDelta(notification.params.turnId, notification.params.itemId, notification.params.delta);
       },
       [REASONING_SUMMARY_TEXT_DELTA_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.appendReasoningDelta(
-          notification.params.threadId,
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.delta
-        );
-        this.emitTranscriptUpdated(notification.params.threadId);
+        this.appendReasoningDelta(notification.params.turnId, notification.params.itemId, notification.params.delta);
       },
       [REASONING_TEXT_DELTA_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.appendReasoningDelta(
-          notification.params.threadId,
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.delta
-        );
-        this.emitTranscriptUpdated(notification.params.threadId);
+        this.appendReasoningDelta(notification.params.turnId, notification.params.itemId, notification.params.delta);
       },
       [REASONING_SUMMARY_PART_ADDED_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.appendReasoningDelta(
-          notification.params.threadId,
-          notification.params.turnId,
-          notification.params.itemId,
-          "\n\n"
-        );
-        this.emitTranscriptUpdated(notification.params.threadId);
+        this.appendReasoningDelta(notification.params.turnId, notification.params.itemId, "\n\n");
       },
       [COMMAND_EXECUTION_OUTPUT_DELTA_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.appendTranscriptOutput(notification.params.turnId, notification.params.itemId, notification.params.delta);
-        this.emitTranscriptUpdated(notification.params.threadId);
+        this.appendOutputDelta(notification.params.turnId, notification.params.itemId, notification.params.delta);
       },
       [FILE_CHANGE_OUTPUT_DELTA_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.appendTranscriptOutput(notification.params.turnId, notification.params.itemId, notification.params.delta);
-        this.emitTranscriptUpdated(notification.params.threadId);
+        this.appendOutputDelta(notification.params.turnId, notification.params.itemId, notification.params.delta);
       },
       [TURN_COMPLETED_METHOD]: (notification) => {
         if (notification.params.threadId !== threadId) return;
@@ -15626,8 +15396,7 @@ var CodexAspManager = class extends CodingAgentManager {
         observedTurnId = notification.params.turn.id;
         this.onCodexTurnCompleted?.(threadId, notification.params.turn.id);
         const completedTurn = recoverCompletedTurn(notification.params.turn, completedItems, agentMessageDeltas);
-        this.mergeTranscriptTurn(notification.params.threadId, completedTurn);
-        this.emitTranscriptUpdated(notification.params.threadId, { immediate: true });
+        this.completeTurn(completedTurn);
         lastCompletedTurn = completedTurn;
         resolveIfGoalIdle();
         if (options.waitForActiveGoal && this.currentGoal?.status === "active") {
@@ -15668,11 +15437,7 @@ var CodexAspManager = class extends CodingAgentManager {
         observedTurnIds.add(started.turn.id);
         this.activeTurnId = started.turn.id;
         if (!alreadyObserved) this.onCodexTurnStarted?.(threadId, started.turn.id);
-        if (!alreadyObserved) {
-          attachUserMessage(started.turn);
-          this.mergeTranscriptTurn(threadId, started.turn);
-          this.emitTranscriptUpdated(threadId, { immediate: true });
-        }
+        if (!alreadyObserved) this.startTurn(started.turn);
       }
       const turn = await Promise.race([completed, disposed]);
       linearForwarder.flushThoughtAsResponse();
@@ -15684,7 +15449,7 @@ var CodexAspManager = class extends CodingAgentManager {
       if (goalContinuationTimer) {
         clearTimeout(goalContinuationTimer);
       }
-      this.transcriptUpdateCoalescer.flushPending();
+      this.itemUpdateCoalescer.flushPending();
       await removeTempImageFiles(tempImagePaths);
       if (host.client.isDisposed) {
         this.attachedClient = null;
@@ -15711,7 +15476,6 @@ var CodexAspManager = class extends CodingAgentManager {
         if (!result.allowed) {
           console.warn(`[CodexAspManager] blocked command approval: ${result.reason ?? "unknown reason"}`);
           this.recordBlockedCommand(
-            serverRequest.params.threadId,
             serverRequest.params.turnId,
             serverRequest.params.itemId,
             serverRequest.params.command ?? "",
@@ -15752,7 +15516,6 @@ var CodexAspManager = class extends CodingAgentManager {
         if (!result.allowed) {
           console.warn(`[CodexAspManager] blocked legacy command approval: ${result.reason ?? "unknown reason"}`);
           this.recordBlockedCommand(
-            this.currentThreadId ?? serverRequest.params.conversationId,
             this.activeTurnId ?? `legacy-${requestId}`,
             serverRequest.params.callId,
             command,
@@ -15842,12 +15605,7 @@ var CodexAspManager = class extends CodingAgentManager {
       console.warn("[CodexAspManager] Failed to inject blocked command reason:", error);
     }
   }
-  nextTranscriptSequence() {
-    return this.codexAspSequence++;
-  }
-  recordBlockedCommand(threadId, turnId, itemId, command, reason, startedAtMs, cwd, commandActions) {
-    const output = formatBlockedCommandReason(reason);
-    const timestamp = timestampFromMilliseconds(startedAtMs);
+  recordBlockedCommand(turnId, itemId, command, reason, startedAtMs, cwd, commandActions) {
     const blockedItem = {
       type: "commandExecution",
       id: itemId,
@@ -15856,231 +15614,80 @@ var CodexAspManager = class extends CodingAgentManager {
       processId: null,
       source: "agent",
       commandActions: commandActions ?? [{ type: "unknown", command }],
-      aggregatedOutput: output,
+      aggregatedOutput: formatBlockedCommandReason(reason),
       exitCode: null,
       status: "declined",
       durationMs: null
     };
-    this.upsertTranscriptItem(threadId, turnId, blockedItem, timestamp, "failed", "completed");
-    this.emitTranscriptUpdated(threadId, { immediate: true });
-  }
-  syncTranscriptSequence(transcript) {
-    if (!transcript) return;
-    let next = 0;
-    for (const turn of transcript.turns) {
-      for (const item of turn.items) {
-        if (typeof item.sequence === "number" && item.sequence >= next) {
-          next = item.sequence + 1;
-        }
-      }
-    }
-    this.codexAspSequence = next;
-  }
-  mergeTranscriptSnapshot(snapshot) {
-    if (snapshot?.threadId && this.codexAspTranscript?.threadId !== snapshot.threadId) {
-      this.lastEmittedTranscript = null;
-      this.dirtyTranscriptTurns.clear();
-    }
-    this.codexAspTranscript = mergeCodexAspTranscripts(this.codexAspTranscript, snapshot);
-    for (const turn of this.codexAspTranscript?.turns ?? []) {
-      this.dirtyTranscriptTurns.set(turn.id, turn);
-    }
-    this.syncTranscriptSequence(this.codexAspTranscript);
-    return this.codexAspTranscript;
-  }
-  ensureTranscript(threadId) {
-    if (this.codexAspTranscript?.threadId === threadId) {
-      return this.codexAspTranscript;
-    }
-    this.lastEmittedTranscript = null;
-    this.dirtyTranscriptTurns.clear();
-    this.codexAspTranscript = {
-      threadId,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      turns: []
-    };
-    this.codexAspSequence = 0;
-    return this.codexAspTranscript;
-  }
-  ensureTranscriptTurn(threadId, turnId, startedAt) {
-    const transcript = this.ensureTranscript(threadId);
-    let turn = transcript.turns.find((candidate) => candidate.id === turnId);
-    if (!turn) {
-      turn = {
-        id: turnId,
-        status: "inProgress",
-        startedAt,
-        completedAt: null,
-        items: []
-      };
-      transcript.turns.push(turn);
-      transcript.turns.sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt));
-    }
-    this.dirtyTranscriptTurns.set(turnId, turn);
-    if (Date.parse(startedAt) < Date.parse(turn.startedAt)) {
-      turn.startedAt = startedAt;
-    }
-    return turn;
+    this.completeItem(turnId, itemToTranscriptItem(blockedItem, timestampFromMilliseconds(startedAtMs), "failed"));
   }
-  ensureTranscriptTurnUserMessage(threadId, turn, request) {
-    const timestamp = timestampFromSeconds(turn.startedAt);
-    const transcriptTurn = this.ensureTranscriptTurn(threadId, turn.id, timestamp);
-    const images = imageContentToUserMessageImages(request.images);
-    const userMessage = {
-      type: "userMessage",
-      id: request.messageId ?? `user-${turn.id}`,
-      content: request.message,
-      ...images ? { images } : {},
-      timestamp,
-      sequence: this.nextTranscriptSequence()
-    };
-    const existingIndex = findEquivalentCodexAspTranscriptItemIndex(transcriptTurn.items, userMessage);
-    if (existingIndex === -1) {
-      transcriptTurn.items.push(userMessage);
-    } else {
-      transcriptTurn.items[existingIndex] = mergeCodexAspTranscriptItem(
-        transcriptTurn.items[existingIndex],
-        userMessage
-      );
+  ensureLiveTurn(turnId) {
+    if (this.liveTurn?.id !== turnId) {
+      this.liveTurn = { id: turnId, items: /* @__PURE__ */ new Map(), persistedItemIds: /* @__PURE__ */ new Set() };
     }
+    return this.liveTurn;
   }
-  mergeTranscriptTurn(threadId, turn) {
+  startTurn(turn) {
+    this.ensureLiveTurn(turn.id);
     const startedAt = timestampFromSeconds(turn.startedAt);
-    const completedAt = turn.completedAt === null ? null : timestampFromSeconds(turn.completedAt);
-    const itemTimestamp = completedAt ?? startedAt;
-    const transcriptTurn = this.ensureTranscriptTurn(threadId, turn.id, startedAt);
-    transcriptTurn.status = turn.status;
-    transcriptTurn.completedAt = completedAt;
-    const itemStatus = turn.status === "failed" ? "failed" : turn.status === "completed" ? "completed" : "in_progress";
     for (const item of turn.items) {
-      this.upsertTranscriptItem(
-        threadId,
-        turn.id,
-        item,
-        item.type === "userMessage" ? startedAt : itemTimestamp,
-        itemStatus,
-        "completed"
-      );
-    }
-    if (turn.status === "completed" || turn.status === "failed") {
-      transcriptTurn.items = transcriptTurn.items.map((item) => item.type === "reasoning" && item.status === "in_progress" ? { ...item, status: "completed" } : item);
-    }
-    if (turn.error) {
-      const existingIndex = transcriptTurn.items.findIndex((item) => item.id === `${turn.id}-error`);
-      const errorItem = {
-        type: "error",
-        id: `${turn.id}-error`,
-        message: formatTurnFailure(turn),
-        timestamp: itemTimestamp,
-        sequence: existingIndex === -1 ? this.nextTranscriptSequence() : transcriptTurn.items[existingIndex].sequence
-      };
-      if (existingIndex === -1) {
-        transcriptTurn.items.push(errorItem);
-      } else {
-        transcriptTurn.items[existingIndex] = errorItem;
-      }
-    }
-    if (this.codexAspTranscript) {
-      this.codexAspTranscript.updatedAt = itemTimestamp;
-    }
-  }
-  upsertTranscriptItem(threadId, turnId, item, timestamp, status, lifecycle) {
-    const turn = this.ensureTranscriptTurn(threadId, turnId, timestamp);
-    const candidate = itemToTranscriptItem(item, timestamp, status);
-    if (!candidate) return;
-    const existingIndex = findEquivalentCodexAspTranscriptItemIndex(turn.items, candidate);
-    const existing = existingIndex === -1 ? null : turn.items[existingIndex];
-    const sequence = existing?.sequence ?? this.nextTranscriptSequence();
-    const itemTimestamp = existing && lifecycle === "completed" ? existing.timestamp : timestamp;
-    const transcriptItem = itemToTranscriptItem(item, itemTimestamp, status);
-    if (!transcriptItem) return;
-    const sequencedItem = { ...transcriptItem, sequence };
-    if (existingIndex === -1) {
-      turn.items.push(sequencedItem);
-    } else {
-      const existingItem = turn.items[existingIndex];
-      const mergedItem = mergeCodexAspTranscriptItem(existingItem, {
-        ...sequencedItem,
-        timestamp: itemTimestamp,
-        sequence
-      });
-      turn.items[existingIndex] = existingItem.type === "agentMessage" && mergedItem.type === "agentMessage" && lifecycle === "started" && mergedItem.text.length === 0 ? { ...mergedItem, text: existingItem.text } : mergedItem;
-    }
-    if (this.codexAspTranscript) {
-      this.codexAspTranscript.updatedAt = timestamp;
-    }
-  }
-  appendAgentMessageDelta(threadId, turnId, itemId, delta) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const turn = this.ensureTranscriptTurn(threadId, turnId, timestamp);
-    const existingIndex = turn.items.findIndex((item) => item.id === itemId);
-    if (existingIndex === -1) {
-      turn.items.push({
-        type: "agentMessage",
-        id: itemId,
-        text: delta,
-        timestamp,
-        sequence: this.nextTranscriptSequence()
-      });
-    } else {
-      const existing = turn.items[existingIndex];
-      if (existing.type === "agentMessage") {
-        turn.items[existingIndex] = {
-          ...existing,
-          text: `${existing.text}${delta}`
-        };
-      }
-    }
-    if (this.codexAspTranscript) {
-      this.codexAspTranscript.updatedAt = timestamp;
-    }
+      this.startItem(turn.id, itemToTranscriptItem(item, startedAt, "in_progress"));
+    }
+  }
+  startItem(turnId, item) {
+    if (!item) return;
+    const turn = this.ensureLiveTurn(turnId);
+    const existing = turn.items.get(item.id);
+    const started = existing?.type === "agentMessage" && item.type === "agentMessage" && !item.text ? { ...item, text: existing.text } : item;
+    turn.items.set(item.id, { ...started, timestamp: existing?.timestamp ?? item.timestamp });
+    this.itemUpdateCoalescer.schedule(item.id, { immediate: true });
+  }
+  completeItem(turnId, item) {
+    if (!item) return;
+    const turn = this.ensureLiveTurn(turnId);
+    const live = turn.items.get(item.id);
+    turn.items.delete(item.id);
+    turn.persistedItemIds.add(item.id);
+    const event = codexItemEvent(turnId, live ? { ...item, timestamp: live.timestamp } : item);
+    this.historyFile?.append(event);
+    this.onEvent(event);
   }
-  appendReasoningDelta(threadId, turnId, itemId, delta) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const turn = this.ensureTranscriptTurn(threadId, turnId, timestamp);
-    const existingIndex = turn.items.findIndex((item) => item.id === itemId);
-    if (existingIndex === -1) {
-      if (!delta.trim()) return;
-      turn.items.push({
-        type: "reasoning",
-        id: itemId,
-        text: delta,
-        timestamp,
-        status: "in_progress",
-        sequence: this.nextTranscriptSequence()
-      });
-    } else {
-      const existing = turn.items[existingIndex];
-      if (existing.type === "reasoning") {
-        if (!delta.trim() && !existing.text.trim()) return;
-        turn.items[existingIndex] = {
-          ...existing,
-          text: `${existing.text}${delta}`
-        };
-      }
+  completeTurn(turn) {
+    const live = this.ensureLiveTurn(turn.id);
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const status = turn.status === "failed" ? "failed" : "completed";
+    for (const item of turn.items) {
+      if (!live.persistedItemIds.has(item.id)) this.completeItem(turn.id, itemToTranscriptItem(item, completedAt, status));
     }
-    if (this.codexAspTranscript) {
-      this.codexAspTranscript.updatedAt = timestamp;
+    for (const item of live.items.values()) {
+      this.completeItem(turn.id, item.type === "reasoning" ? { ...item, status } : item);
     }
-  }
-  appendTranscriptOutput(turnId, itemId, delta) {
-    if (!this.codexAspTranscript) return;
-    const turn = this.codexAspTranscript.turns.find((candidate) => candidate.id === turnId);
-    if (!turn) return;
-    const itemIndex = turn.items.findIndex((item2) => item2.id === itemId);
-    if (itemIndex === -1) return;
-    const item = turn.items[itemIndex];
-    if (item.type !== "commandExecution" && item.type !== "fileChange") return;
-    this.dirtyTranscriptTurns.set(turnId, turn);
-    turn.items[itemIndex] = {
-      ...item,
-      output: appendCodexAspTranscriptOutput(item.output, delta),
-      status: "in_progress"
-    };
-    this.codexAspTranscript.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  seedHistoryFromThread(thread) {
-    this.mergeTranscriptSnapshot(threadToAspTranscript(thread));
+    const failure = turn.error ? formatTurnFailure(turn) : void 0;
+    this.lastTurnFailure = failure === void 0 ? null : { turnId: turn.id, message: failure };
+    const event = codexTurnEvent(turn.id, turn.status, completedAt, failure);
+    this.historyFile?.append(event);
+    this.onEvent(event);
+    this.liveTurn = null;
+  }
+  appendAgentMessageDelta(turnId, itemId, delta) {
+    const turn = this.ensureLiveTurn(turnId);
+    const existing = turn.items.get(itemId);
+    turn.items.set(itemId, existing?.type === "agentMessage" ? { ...existing, text: `${existing.text}${delta}` } : { type: "agentMessage", id: itemId, text: delta, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    this.itemUpdateCoalescer.schedule(itemId);
+  }
+  appendReasoningDelta(turnId, itemId, delta) {
+    const turn = this.ensureLiveTurn(turnId);
+    const existing = turn.items.get(itemId);
+    if (!existing && !delta.trim()) return;
+    turn.items.set(itemId, existing?.type === "reasoning" ? { ...existing, text: `${existing.text}${delta}` } : { type: "reasoning", id: itemId, text: delta, timestamp: (/* @__PURE__ */ new Date()).toISOString(), status: "in_progress" });
+    this.itemUpdateCoalescer.schedule(itemId);
+  }
+  appendOutputDelta(turnId, itemId, delta) {
+    const turn = this.ensureLiveTurn(turnId);
+    const item = turn.items.get(itemId);
+    if (item?.type !== "commandExecution" && item?.type !== "fileChange") return;
+    turn.items.set(itemId, { ...item, output: appendCodexAspTranscriptOutput(item.output, delta), status: "in_progress" });
+    this.itemUpdateCoalescer.schedule(itemId);
   }
   async refreshThreadGoal(host, threadId) {
     try {
@@ -16119,109 +15726,6 @@ var CodexAspManager = class extends CodingAgentManager {
   trackHistoryEvent(event) {
     this.historyFile?.append(event);
   }
-  emitTranscriptUpdated(threadId, options = {}) {
-    this.transcriptUpdateCoalescer.schedule(threadId, options);
-  }
-  buildTranscriptItemDelta(previous, current) {
-    if (previous === current) return null;
-    if (!previous || previous.type !== current.type) {
-      return { id: current.id, item: structuredClone(current) };
-    }
-    if (current.type === "agentMessage" && previous.type === "agentMessage" && current.text.startsWith(previous.text) && current.text.length > previous.text.length) {
-      return {
-        id: current.id,
-        appendText: current.text.slice(previous.text.length)
-      };
-    }
-    if ((current.type === "commandExecution" || current.type === "fileChange") && previous.type === current.type && current.output && current.output.startsWith(previous.output ?? "") && current.output.length > (previous.output ?? "").length) {
-      const { output: _output, ...itemWithoutOutput } = current;
-      const item = {
-        ...itemWithoutOutput,
-        output: previous.output
-      };
-      return {
-        id: current.id,
-        item,
-        appendOutput: current.output.slice((previous.output ?? "").length)
-      };
-    }
-    if (JSON.stringify(previous) === JSON.stringify(current)) {
-      return null;
-    }
-    return { id: current.id, item: structuredClone(current) };
-  }
-  buildTranscriptDelta(threadId, current) {
-    const previous = this.lastEmittedTranscript;
-    const updatedAt = current?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    if (!current || !previous || previous.threadId !== current.threadId) {
-      return {
-        threadId,
-        updatedAt,
-        reset: current ? structuredClone(current) : null,
-        turns: []
-      };
-    }
-    const turnDeltas = [];
-    for (const currentTurn of this.dirtyTranscriptTurns.values()) {
-      const previousTurn = previous.turns.get(currentTurn.id);
-      if (!previousTurn) {
-        turnDeltas.push({
-          id: currentTurn.id,
-          status: currentTurn.status,
-          startedAt: currentTurn.startedAt,
-          completedAt: currentTurn.completedAt,
-          items: currentTurn.items.map((item) => ({ id: item.id, item: structuredClone(item) }))
-        });
-        continue;
-      }
-      const previousItems = new Map(previousTurn.items.map((item) => [item.id, item]));
-      const itemDeltas = currentTurn.items.map((item) => this.buildTranscriptItemDelta(
-        previousItems.get(item.id),
-        item
-      )).filter((item) => item !== null);
-      if (itemDeltas.length > 0 || currentTurn.status !== previousTurn.status || currentTurn.startedAt !== previousTurn.startedAt || currentTurn.completedAt !== previousTurn.completedAt) {
-        turnDeltas.push({
-          id: currentTurn.id,
-          status: currentTurn.status,
-          startedAt: currentTurn.startedAt,
-          completedAt: currentTurn.completedAt,
-          items: itemDeltas
-        });
-      }
-    }
-    return {
-      threadId: current.threadId,
-      updatedAt,
-      turns: turnDeltas
-    };
-  }
-  flushTranscriptUpdated(threadId) {
-    const updatedAt = this.codexAspTranscript?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    const transcriptDelta = this.buildTranscriptDelta(threadId, this.codexAspTranscript);
-    const updatePayload = {
-      updatedAt,
-      threadId,
-      transcript: transcriptDelta.reset ?? null,
-      transcriptDelta
-    };
-    if (this.codexAspTranscript) {
-      const snapshot = this.lastEmittedTranscript ?? { threadId, turns: /* @__PURE__ */ new Map() };
-      for (const turn of this.dirtyTranscriptTurns.values()) {
-        snapshot.turns.set(turn.id, { ...turn, items: [...turn.items] });
-      }
-      this.lastEmittedTranscript = snapshot;
-    } else {
-      this.lastEmittedTranscript = null;
-    }
-    this.dirtyTranscriptTurns.clear();
-    const event = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      type: CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE,
-      payload: updatePayload
-    };
-    this.historyFile?.append(event);
-    this.onEvent(event);
-  }
   handleRateLimits(rateLimits) {
     const snapshot = extractRateLimitsSnapshot(rateLimits);
     if (snapshot) {
@@ -16282,23 +15786,23 @@ var CodexAspManager = class extends CodingAgentManager {
 };
 
 // src/managers/cursor-manager.ts
-import { mkdir as mkdir12, readFile as readFile13, readdir as readdir6 } from "fs/promises";
-import { basename as basename2, dirname as dirname6, extname, join as join20 } from "path";
+import { mkdir as mkdir12, readFile as readFile12, readdir as readdir5 } from "fs/promises";
+import { basename as basename2, dirname as dirname6, extname, join as join18 } from "path";
 import { Agent as CursorAgent2 } from "@cursor/sdk";
 
 // src/services/native-command-protection-hooks.ts
 import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir11, readFile as readFile12, writeFile as writeFile6 } from "fs/promises";
-import { basename, dirname as dirname5, join as join19 } from "path";
+import { mkdir as mkdir11, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { basename, dirname as dirname5, join as join17 } from "path";
 import { fileURLToPath } from "url";
 var moduleDirectory = dirname5(fileURLToPath(import.meta.url));
 var hookPath = [
-  join19(moduleDirectory, "command-protection-hook.js"),
-  join19(moduleDirectory, "..", "command-protection-hook.ts")
+  join17(moduleDirectory, "command-protection-hook.js"),
+  join17(moduleDirectory, "..", "command-protection-hook.ts")
 ].find(existsSync8);
 var postToolHookPath = [
-  join19(moduleDirectory, "post-tool-pr-hook.js"),
-  join19(moduleDirectory, "..", "post-tool-pr-hook.ts")
+  join17(moduleDirectory, "post-tool-pr-hook.js"),
+  join17(moduleDirectory, "..", "post-tool-pr-hook.ts")
 ].find(existsSync8);
 function shellCommand(path7, provider) {
   if (!path7) throw new Error("Replicas hook executable is missing.");
@@ -16319,10 +15823,10 @@ function getPostToolPrHookPath() {
   return postToolHookPath;
 }
 async function ensureCursorCommandProtectionHook() {
-  const path7 = join19(ENGINE_ENV.HOME_DIR, ".cursor", "hooks.json");
+  const path7 = join17(ENGINE_ENV.HOME_DIR, ".cursor", "hooks.json");
   let config = {};
   try {
-    const parsed = JSON.parse(await readFile12(path7, "utf8"));
+    const parsed = JSON.parse(await readFile11(path7, "utf8"));
     if (!isRecord2(parsed)) throw new Error("Invalid Cursor hooks configuration.");
     config = parsed;
   } catch (error) {
@@ -16344,10 +15848,10 @@ async function ensureCursorCommandProtectionHook() {
 `, "utf8");
 }
 async function ensureGeminiCommandProtectionHook() {
-  const path7 = join19(ENGINE_ENV.HOME_DIR, ".gemini", "settings.json");
+  const path7 = join17(ENGINE_ENV.HOME_DIR, ".gemini", "settings.json");
   let config = {};
   try {
-    const parsed = JSON.parse(await readFile12(path7, "utf8"));
+    const parsed = JSON.parse(await readFile11(path7, "utf8"));
     if (!isRecord2(parsed)) throw new Error("Invalid Gemini hooks configuration.");
     config = parsed;
   } catch (error) {
@@ -16372,12 +15876,12 @@ async function ensureGeminiCommandProtectionHook() {
 `, "utf8");
 }
 async function ensureKimiCommandProtectionHook() {
-  const path7 = join19(ENGINE_ENV.HOME_DIR, ".kimi-code", "config.toml");
+  const path7 = join17(ENGINE_ENV.HOME_DIR, ".kimi-code", "config.toml");
   const start = "# Replicas command protection hook";
   const end = "# End Replicas command protection hook";
   let config = "";
   try {
-    config = await readFile12(path7, "utf8");
+    config = await readFile11(path7, "utf8");
   } catch (error) {
     if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
   }
@@ -16464,7 +15968,7 @@ function extractCursorCommandDescription(content) {
 async function listCursorCommandsInDirectory(directory) {
   let entries;
   try {
-    entries = await readdir6(directory, { withFileTypes: true });
+    entries = await readdir5(directory, { withFileTypes: true });
   } catch (error) {
     if (isRecord2(error) && error.code === "ENOENT") return [];
     console.warn("[CursorManager] Failed to read slash command directory:", error);
@@ -16474,7 +15978,7 @@ async function listCursorCommandsInDirectory(directory) {
     const name = basename2(entry.name, ".md");
     let description;
     try {
-      description = extractCursorCommandDescription(await readFile13(join20(directory, entry.name), "utf8"));
+      description = extractCursorCommandDescription(await readFile12(join18(directory, entry.name), "utf8"));
     } catch (error) {
       console.warn("[CursorManager] Failed to read slash command file:", error);
     }
@@ -16496,7 +16000,7 @@ var CursorManager = class extends CodingAgentManager {
   slashCommandsRequest = null;
   constructor(options) {
     super(options);
-    this.historyFilePath = options.historyFilePath ?? join20(ENGINE_ENV.HOME_DIR, ".replicas", "cursor", "history.jsonl");
+    this.historyFilePath = options.historyFilePath ?? join18(ENGINE_ENV.HOME_DIR, ".replicas", "cursor", "history.jsonl");
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
@@ -16571,7 +16075,7 @@ var CursorManager = class extends CodingAgentManager {
     this.slashCommandsRequest ??= (async () => {
       try {
         const repoDirectories = await getAgentAdditionalDirectories();
-        const commandDirectories = [this.workingDirectory, ...repoDirectories, ENGINE_ENV.HOME_DIR].map((directory) => join20(directory, ".cursor", "commands"));
+        const commandDirectories = [this.workingDirectory, ...repoDirectories, ENGINE_ENV.HOME_DIR].map((directory) => join18(directory, ".cursor", "commands"));
         const commands = mergeSlashCommands(
           ...await Promise.all(commandDirectories.map(listCursorCommandsInDirectory))
         );
@@ -16852,10 +16356,10 @@ ${instructions}
 import { spawn as spawn3 } from "child_process";
 import { createHash as createHash2, randomUUID as randomUUID6 } from "crypto";
 import { createRequire } from "module";
-import { basename as basename3, dirname as dirname7, join as join21 } from "path";
+import { basename as basename3, dirname as dirname7, join as join19 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { existsSync as existsSync9 } from "fs";
-import { mkdir as mkdir13, readFile as readFile14, rename as rename2, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir13, readFile as readFile13, rename as rename3, writeFile as writeFile7 } from "fs/promises";
 import { z as z2 } from "zod";
 import WebSocket from "ws";
 import { AbstractApiClient } from "@deepseek-ai/dsh-host-apiproxy/client";
@@ -16867,17 +16371,17 @@ var questionSelectionSchema = z2.record(z2.string(), z2.object({
   custom: z2.string().optional()
 }));
 var require2 = createRequire(import.meta.url);
-var DSH_BIN = join21(dirname7(require2.resolve("@deepseek-ai/dsh/package.json")), "lib", "bin.js");
+var DSH_BIN = join19(dirname7(require2.resolve("@deepseek-ai/dsh/package.json")), "lib", "bin.js");
 var MANAGER_DIR = dirname7(fileURLToPath2(import.meta.url));
 var DSH_PATCH = [
-  join21(MANAGER_DIR, "..", "..", "scripts", "deepseek", "replicas.cordis.patch.yml"),
-  join21(MANAGER_DIR, "..", "..", "..", "scripts", "deepseek", "replicas.cordis.patch.yml")
+  join19(MANAGER_DIR, "..", "..", "scripts", "deepseek", "replicas.cordis.patch.yml"),
+  join19(MANAGER_DIR, "..", "..", "..", "scripts", "deepseek", "replicas.cordis.patch.yml")
 ].find(existsSync9) ?? "";
 var DSH_COMMAND_PROTECTION_PLUGIN = [
-  join21(MANAGER_DIR, "deepseek-command-protection-plugin.js"),
-  join21(MANAGER_DIR, "..", "deepseek-command-protection-plugin.ts")
+  join19(MANAGER_DIR, "deepseek-command-protection-plugin.js"),
+  join19(MANAGER_DIR, "..", "deepseek-command-protection-plugin.ts")
 ].find(existsSync9) ?? "";
-var DEEPSEEK_HOME = join21(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek");
+var DEEPSEEK_HOME = join19(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek");
 function relayPresetContent(content, instructions, mcp) {
   const personaMarker = "    text: >-\n";
   const personaStart = content.indexOf(personaMarker);
@@ -17022,8 +16526,8 @@ var DeepseekManager = class extends CodingAgentManager {
   constructor(options) {
     super(options);
     this.sessionId = options.initialSessionId ? sessionIdSchema.parse(options.initialSessionId) : null;
-    this.historyFilePath = options.historyFilePath ?? join21(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek", "history.jsonl");
-    this.deepseekHome = this.isRelay ? join21(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek-relay", basename3(this.historyFilePath, ".jsonl")) : DEEPSEEK_HOME;
+    this.historyFilePath = options.historyFilePath ?? join19(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek", "history.jsonl");
+    this.deepseekHome = this.isRelay ? join19(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek-relay", basename3(this.historyFilePath, ".jsonl")) : DEEPSEEK_HOME;
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
@@ -17102,9 +16606,9 @@ var DeepseekManager = class extends CodingAgentManager {
   async ensureClient() {
     if (this.client) return this.client;
     if (!DSH_PATCH || !DSH_COMMAND_PROTECTION_PLUGIN) throw new Error("DeepSeek Harness configuration is missing from the engine package.");
-    const runtimePatch = join21(this.deepseekHome, "replicas.cordis.patch.yml");
+    const runtimePatch = join19(this.deepseekHome, "replicas.cordis.patch.yml");
     await mkdir13(dirname7(runtimePatch), { recursive: true });
-    await writeFile7(runtimePatch, (await readFile14(DSH_PATCH, "utf8")).replace(
+    await writeFile7(runtimePatch, (await readFile13(DSH_PATCH, "utf8")).replace(
       "__REPLICAS_DSH_COMMAND_PROTECTION_PLUGIN__",
       JSON.stringify(DSH_COMMAND_PROTECTION_PLUGIN)
     ));
@@ -17177,10 +16681,10 @@ var DeepseekManager = class extends CodingAgentManager {
     if (!roster.some((preset) => preset.id === agentPreset)) {
       const stage = `relay-stage-${randomUUID6().replaceAll("-", "")}`;
       unwrap(await client2.agentPresets.copy({ from: "standard", agentPreset: stage, name: "Relay" }));
-      const stageDirectory = join21(this.deepseekHome, ".agent-presets", stage);
+      const stageDirectory = join19(this.deepseekHome, ".agent-presets", stage);
       try {
-        await writeFile7(join21(stageDirectory, "agent.cordis.yml"), content, "utf8");
-        await rename2(stageDirectory, join21(this.deepseekHome, ".agent-presets", agentPreset));
+        await writeFile7(join19(stageDirectory, "agent.cordis.yml"), content, "utf8");
+        await rename3(stageDirectory, join19(this.deepseekHome, ".agent-presets", agentPreset));
       } catch (error) {
         unwrap(await client2.agentPresets.remove({ agentPreset: stage }));
         if (!unwrap(await client2.agentPresets.list({})).presets.some((preset) => preset.id === agentPreset)) throw error;
@@ -17354,13 +16858,13 @@ ${request.message}` : request.message;
 };
 
 // src/managers/fx-manager.ts
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 import { spawn as spawn5 } from "child_process";
 
 // src/managers/acp-manager.ts
 import { spawn as spawn4 } from "child_process";
 import { randomUUID as randomUUID7 } from "crypto";
-import { mkdir as mkdir14, readFile as readFile16, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
 import { dirname as dirname8 } from "path";
 import { Writable } from "stream";
 import {
@@ -17371,24 +16875,24 @@ import {
 } from "@agentclientprotocol/sdk";
 
 // src/services/installed-skill-service.ts
-import { readFile as readFile15, readdir as readdir7 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile14, readdir as readdir6 } from "fs/promises";
+import { join as join20 } from "path";
 var installedSkillsByHome = /* @__PURE__ */ new Map();
 function isNotFoundError2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 async function loadInstalledSkills(homeDir) {
-  const skillsDir = join22(homeDir, ".agents/skills");
+  const skillsDir = join20(homeDir, ".agents/skills");
   let entries;
   try {
-    entries = await readdir7(skillsDir, { withFileTypes: true });
+    entries = await readdir6(skillsDir, { withFileTypes: true });
   } catch (error) {
     if (!isNotFoundError2(error)) console.warn("[InstalledSkills] Failed to list installed skills:", error);
     return [];
   }
   const skills = await Promise.all(entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map(async (entry) => {
     try {
-      const metadata = parseFrontmatter(await readFile15(join22(skillsDir, entry.name, "SKILL.md"), "utf8"));
+      const metadata = parseFrontmatter(await readFile14(join20(skillsDir, entry.name, "SKILL.md"), "utf8"));
       return metadata.name && metadata.description ? metadata : null;
     } catch (error) {
       if (!isNotFoundError2(error)) console.warn(`[InstalledSkills] Failed to read ${entry.name}:`, error);
@@ -17473,7 +16977,7 @@ var AcpManager = class extends CodingAgentManager {
     });
     const app2 = client({ name: "Replicas" }).onNotification(methods.client.session.update, ({ params }) => this.recordUpdate(params)).onRequest(methods.client.fs.readTextFile, async ({ params }) => {
       this.assertSession(params.sessionId);
-      const content = await readFile16(params.path, "utf8");
+      const content = await readFile15(params.path, "utf8");
       if (params.line === void 0 && params.limit === void 0) return { content };
       const start = Math.max(0, (params.line ?? 1) - 1);
       const end = params.limit === null || params.limit === void 0 ? void 0 : start + params.limit;
@@ -17864,7 +17368,7 @@ ${request.message}` : request.message
 
 // src/managers/fx-manager.ts
 async function ensureResolvableDnsConfig() {
-  const contents = await readFile17("/etc/resolv.conf");
+  const contents = await readFile16("/etc/resolv.conf");
   if (contents.length === 0 || contents.at(-1) === 10) return;
   await new Promise((resolve7, reject) => {
     const child = spawn5("sudo", ["tee", "-a", "/etc/resolv.conf"], { stdio: ["pipe", "ignore", "pipe"] });
@@ -18474,8 +17978,8 @@ ${pending}
 
 // src/managers/opencode-manager.ts
 import { existsSync as existsSync10 } from "fs";
-import { copyFile, mkdir as mkdir16, readFile as readFile18, rm as rm2 } from "fs/promises";
-import { delimiter, dirname as dirname10, join as join23 } from "path";
+import { copyFile, mkdir as mkdir16, readFile as readFile17, rm as rm2 } from "fs/promises";
+import { delimiter, dirname as dirname10, join as join21 } from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Agent } from "undici";
@@ -18504,10 +18008,10 @@ async function getAllowedOpenRouterModels() {
 
 // src/managers/opencode-manager.ts
 var OPENCODE_SHIM_DIR = dirname10(fileURLToPath3(new URL("../../scripts/opencode", import.meta.url)));
-var OPENCODE_COMMAND_PROTECTION_PLUGIN_SOURCE = join23(OPENCODE_SHIM_DIR, "opencode-command-protection-plugin.ts");
-var OPENCODE_COMMAND_PROTECTION_PLUGIN_PATH = join23(ENGINE_ENV.HOME_DIR, ".config", "opencode", "plugins", "replicas-command-protection.ts");
-var OPENCODE_LEGACY_COMMAND_PROTECTION_PLUGIN_PATH = join23(ENGINE_ENV.HOME_DIR, ".config", "opencode", "plugins", "replicas-command-protection.mjs");
-var OPENCODE_CONFIG_PATH = join23(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
+var OPENCODE_COMMAND_PROTECTION_PLUGIN_SOURCE = join21(OPENCODE_SHIM_DIR, "opencode-command-protection-plugin.ts");
+var OPENCODE_COMMAND_PROTECTION_PLUGIN_PATH = join21(ENGINE_ENV.HOME_DIR, ".config", "opencode", "plugins", "replicas-command-protection.ts");
+var OPENCODE_LEGACY_COMMAND_PROTECTION_PLUGIN_PATH = join21(ENGINE_ENV.HOME_DIR, ".config", "opencode", "plugins", "replicas-command-protection.mjs");
+var OPENCODE_CONFIG_PATH = join21(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
 var OPENCODE_FETCH_DISPATCHER = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
 var OPENCODE_SERVER_STARTUP_TIMEOUT_MS = 3e4;
 var OPENCODE_WORKSPACE_PERMISSION = "allow";
@@ -18528,7 +18032,7 @@ var opencodeAuthSchema = z3.record(z3.string(), z3.object({
 async function hasOpencodeCredentials(provider) {
   if (!existsSync10(OPENCODE_AUTH_PATH)) return false;
   try {
-    const auth2 = opencodeAuthSchema.safeParse(JSON.parse(await readFile18(OPENCODE_AUTH_PATH, "utf8")));
+    const auth2 = opencodeAuthSchema.safeParse(JSON.parse(await readFile17(OPENCODE_AUTH_PATH, "utf8")));
     return auth2.success && auth2.data[provider]?.type === "api" && Boolean(auth2.data[provider]?.key);
   } catch {
     return false;
@@ -18633,7 +18137,7 @@ function isOpencodeMcpEntry(value) {
 async function readProvisionedOpencodeMcpConfig() {
   let raw;
   try {
-    raw = await readFile18(OPENCODE_CONFIG_PATH, "utf8");
+    raw = await readFile17(OPENCODE_CONFIG_PATH, "utf8");
   } catch (error) {
     if (isRecord2(error) && error.code === "ENOENT") return void 0;
     console.error("[OpencodeManager] Failed to read Opencode config:", error);
@@ -18719,7 +18223,7 @@ var OpencodeManager = class extends CodingAgentManager {
   constructor(options) {
     super({ ...options, provider: "opencode" });
     this.sessionId = options.initialSessionId;
-    this.historyFilePath = options.historyFilePath ?? join23(ENGINE_ENV.HOME_DIR, ".replicas", "opencode", "history.jsonl");
+    this.historyFilePath = options.historyFilePath ?? join21(ENGINE_ENV.HOME_DIR, ".replicas", "opencode", "history.jsonl");
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
@@ -19139,8 +18643,8 @@ var OpencodeManager = class extends CodingAgentManager {
 };
 
 // src/managers/pi-manager.ts
-import { mkdir as mkdir18, readFile as readFile19 } from "fs/promises";
-import { dirname as dirname18, join as join30 } from "path";
+import { mkdir as mkdir18, readFile as readFile18 } from "fs/promises";
+import { dirname as dirname18, join as join29 } from "path";
 import {
   createAgentSession,
   ModelRegistry,
@@ -19149,6 +18653,37 @@ import {
   DefaultResourceLoader
 } from "@earendil-works/pi-coding-agent";
 
+// src/services/chat/history-paths.ts
+import { homedir as homedir12 } from "os";
+import { join as join22 } from "path";
+var ENGINE_DIR2 = join22(homedir12(), ".replicas", "engine");
+var CHATS_FILE = join22(ENGINE_DIR2, "chats.json");
+var CLAUDE_HISTORY_DIR = join22(ENGINE_DIR2, "claude-histories");
+var RELAY_HISTORY_DIR = join22(ENGINE_DIR2, "relay-histories");
+var CODEX_HISTORY_DIR = join22(ENGINE_DIR2, "codex-histories");
+var CURSOR_HISTORY_DIR = join22(ENGINE_DIR2, "cursor-histories");
+var OPENCODE_HISTORY_DIR = join22(ENGINE_DIR2, "opencode-histories");
+var PI_HISTORY_DIR = join22(ENGINE_DIR2, "pi-histories");
+var DEEPSEEK_HISTORY_DIR = join22(ENGINE_DIR2, "deepseek-histories");
+var FX_HISTORY_DIR = join22(ENGINE_DIR2, "fx-histories");
+var GEMINI_HISTORY_DIR = join22(ENGINE_DIR2, "gemini-histories");
+var KIMI_HISTORY_DIR = join22(ENGINE_DIR2, "kimi-histories");
+var MUSE_HISTORY_DIR = join22(ENGINE_DIR2, "muse-histories");
+var FORKS_DIR = join22(ENGINE_DIR2, "forks");
+var HISTORY_DIR_BY_PROVIDER = {
+  claude: CLAUDE_HISTORY_DIR,
+  relay: RELAY_HISTORY_DIR,
+  codex: CODEX_HISTORY_DIR,
+  cursor: CURSOR_HISTORY_DIR,
+  deepseek: DEEPSEEK_HISTORY_DIR,
+  fx: FX_HISTORY_DIR,
+  gemini: GEMINI_HISTORY_DIR,
+  kimi: KIMI_HISTORY_DIR,
+  muse: MUSE_HISTORY_DIR,
+  opencode: OPENCODE_HISTORY_DIR,
+  pi: PI_HISTORY_DIR
+};
+
 // ../node_modules/.bun/typebox@1.3.7/node_modules/typebox/build/system/memory/memory.mjs
 var memory_exports = {};
 __export(memory_exports, {
@@ -41679,7 +41214,7 @@ async function probeMcpEndpoint(url3) {
 
 // ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/npx-resolver.ts
 import { existsSync as existsSync11, readFileSync as readFileSync4, realpathSync, readdirSync, statSync, writeFileSync, renameSync, mkdirSync, openSync, readSync, closeSync, unlinkSync } from "fs";
-import { join as join24, dirname as dirname11, extname as extname2, resolve as resolve2, sep } from "path";
+import { join as join23, dirname as dirname11, extname as extname2, resolve as resolve2, sep } from "path";
 
 // ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/abort.ts
 function throwIfAborted(signal) {
@@ -41836,7 +41371,7 @@ function resolveFromNpmCache(packageSpec, binName) {
   const { packageName, exactVersion } = parsedSpec;
   const packageDir = findCachedPackageDir(cacheDir, packageName, exactVersion);
   if (!packageDir) return null;
-  const packageJsonPath = join24(packageDir, "package.json");
+  const packageJsonPath = join23(packageDir, "package.json");
   if (!existsSync11(packageJsonPath)) return null;
   let pkg = null;
   try {
@@ -41870,7 +41405,7 @@ function resolveFromNpmCache(packageSpec, binName) {
   }
   if (!binRel) return null;
   const nodeModulesDir = findNodeModulesDir(packageDir);
-  const binLink = chosenBinName ? join24(nodeModulesDir, ".bin", chosenBinName) : null;
+  const binLink = chosenBinName ? join23(nodeModulesDir, ".bin", chosenBinName) : null;
   let resolvedBin = binLink && existsSync11(binLink) ? safeRealpath(binLink) : "";
   if (!resolvedBin) {
     resolvedBin = resolve2(packageDir, binRel);
@@ -41972,17 +41507,17 @@ function defaultBinName(packageName) {
   return packageName;
 }
 function findCachedPackageDir(cacheDir, packageName, exactVersion) {
-  const npxDir = join24(cacheDir, "_npx");
+  const npxDir = join23(cacheDir, "_npx");
   if (!existsSync11(npxDir)) return null;
   const packagePathParts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
   const candidates = readdirSync(npxDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
-    const full = join24(npxDir, entry.name);
+    const full = join23(npxDir, entry.name);
     const mtime = safeStatMtime(full);
     return { name: entry.name, mtime };
   }).sort((a, b) => b.mtime - a.mtime);
   for (const entry of candidates) {
-    const pkgDir = join24(npxDir, entry.name, "node_modules", ...packagePathParts);
-    const packageJsonPath = join24(pkgDir, "package.json");
+    const pkgDir = join23(npxDir, entry.name, "node_modules", ...packagePathParts);
+    const packageJsonPath = join23(pkgDir, "package.json");
     if (!existsSync11(packageJsonPath)) continue;
     if (exactVersion) {
       try {
@@ -42002,7 +41537,7 @@ function findNodeModulesDir(packageDir) {
   if (idx >= 0) {
     return parts.slice(0, idx + 1).join(sep);
   }
-  return join24(packageDir, "..");
+  return join23(packageDir, "..");
 }
 function detectJsBinary(binPath) {
   const ext = extname2(binPath).toLowerCase();
@@ -42194,7 +41729,7 @@ import { spawnSync } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { createRequire as createRequire2 } from "module";
 import { readFileSync as readFileSync5, existsSync as existsSync12, rmSync } from "fs";
-import { dirname as dirname12, join as join25 } from "path";
+import { dirname as dirname12, join as join24 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var require3 = createRequire2(import.meta.url);
 var AUTH_SECRET_SERVICE = "pi-mcp-adapter.oauth";
@@ -42350,7 +41885,7 @@ function loadKeyringNativeBindingFallback(keyringRequire, platform3, arch2) {
   for (const target of targets) {
     try {
       const packageJsonPath = keyringRequire.resolve(`${target.packageName}/package.json`);
-      return keyringRequire(join25(dirname12(packageJsonPath), target.bindingFile));
+      return keyringRequire(join24(dirname12(packageJsonPath), target.bindingFile));
     } catch (error) {
       lastError = error;
     }
@@ -42455,7 +41990,7 @@ function getServerDir(serverName, options) {
     throw new Error(`Invalid MCP server name: ${JSON.stringify(serverName)}`);
   }
   const storageKey = getAuthEntryAccount(serverName);
-  return join25(getAuthBaseDir(options), storageKey);
+  return join24(getAuthBaseDir(options), storageKey);
 }
 function getAuthEntryAccount(serverName) {
   if (typeof serverName !== "string") {
@@ -42464,7 +41999,7 @@ function getAuthEntryAccount(serverName) {
   return `sha256-${createHash3("sha256").update(serverName, "utf8").digest("hex")}`;
 }
 function getAuthEntryFilePath(serverName, options) {
-  return join25(getServerDir(serverName, options), "tokens.json");
+  return join24(getServerDir(serverName, options), "tokens.json");
 }
 function parseJsonPayload(serverName, payload, source) {
   try {
@@ -45067,7 +44602,7 @@ async function shutdownOAuth(runtime = legacyRuntime) {
 // ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/mcp-bearer-store.ts
 import { createHash as createHash4 } from "crypto";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname13, join as join26 } from "path";
+import { dirname as dirname13, join as join25 } from "path";
 var require4 = createRequire3(import.meta.url);
 var BEARER_SECRET_SERVICE = "pi-mcp-adapter.bearer";
 var TEST_AUTH_STORE_ENV2 = "PI_MCP_ADAPTER_TEST_AUTH_STORE";
@@ -45169,7 +44704,7 @@ function loadKeyringNativeBindingFallback2(keyringRequire, platform3, arch2) {
   for (const target of targets) {
     try {
       const packageJsonPath = keyringRequire.resolve(`${target.packageName}/package.json`);
-      return keyringRequire(join26(dirname13(packageJsonPath), target.bindingFile));
+      return keyringRequire(join25(dirname13(packageJsonPath), target.bindingFile));
     } catch (error) {
       lastError = error;
     }
@@ -49636,7 +49171,7 @@ async function openMcpAuthPanel(state, pi, ctx, configOverridePath) {
 // ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/tool-registrar.ts
 import { mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join27 } from "path";
+import { join as join26 } from "path";
 var MAX_BINARY_RESOURCE_BYTES = 10 * 1024 * 1024;
 var MAX_SESSION_RESOURCE_BYTES = 100 * 1024 * 1024;
 var MAX_SESSION_RESOURCE_FILES = 1e4;
@@ -49743,11 +49278,11 @@ function materializeBinaryResource(resource, scope) {
     return omitBinaryResource(resource, "session resource limit reached");
   }
   try {
-    session.directory ??= mkdtempSync(join27(tmpdir(), "pi-mcp-resource-"));
+    session.directory ??= mkdtempSync(join26(tmpdir(), "pi-mcp-resource-"));
   } catch {
     return omitBinaryResource(resource, "could not be saved");
   }
-  const filePath = join27(session.directory, `resource-${++session.sequence}.bin`);
+  const filePath = join26(session.directory, `resource-${++session.sequence}.bin`);
   session.bytes += decodedBytes;
   session.files += 1;
   try {
@@ -49840,7 +49375,7 @@ function stringifyStructuredContent(value) {
 import { randomBytes as randomBytes4 } from "crypto";
 import { mkdtemp, rm as rm3, writeFile as writeFile10 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname16, join as join28 } from "path";
+import { dirname as dirname16, join as join27 } from "path";
 var DEFAULT_MCP_OUTPUT_MAX_BYTES = 50 * 1024;
 var DEFAULT_MCP_OUTPUT_MAX_LINES = 2e3;
 var DEFAULT_MCP_DETAILS_MAX_BYTES = 16 * 1024;
@@ -50148,8 +49683,8 @@ function serializedObjectEntryBytes(key, value, hasPrevious) {
 }
 async function saveArtifact(kind, text) {
   try {
-    const dir = await mkdtemp(join28(tmpdir2(), "pi-mcp-output-"));
-    const path7 = join28(dir, `${kind}-${randomBytes4(4).toString("hex")}.txt`);
+    const dir = await mkdtemp(join27(tmpdir2(), "pi-mcp-output-"));
+    const path7 = join27(dir, `${kind}-${randomBytes4(4).toString("hex")}.txt`);
     await writeFile10(path7, text, { encoding: "utf8", mode: 384 });
     return { path: path7 };
   } catch (error) {
@@ -51796,7 +51331,7 @@ function sendText(res, status, text) {
 // ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/glimpse-ui.ts
 import { existsSync as existsSync15 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
-import { join as join29, dirname as dirname17 } from "path";
+import { join as join28, dirname as dirname17 } from "path";
 import { platform as platform2 } from "os";
 import { createRequire as createRequire4 } from "module";
 var glimpseAvailable = null;
@@ -51818,20 +51353,20 @@ function getGlimpseBinaryPath() {
   try {
     const require7 = createRequire4(import.meta.url);
     const glimpseuiPath = require7.resolve("glimpseui");
-    const binaryPath = join29(dirname17(glimpseuiPath), "glimpse");
+    const binaryPath = join28(dirname17(glimpseuiPath), "glimpse");
     if (existsSync15(binaryPath)) return binaryPath;
   } catch {
   }
   try {
     const globalRoot = execFileSync2("npm", ["root", "-g"], { encoding: "utf-8" }).trim();
-    const binaryPath = join29(globalRoot, "glimpseui", "src", "glimpse");
+    const binaryPath = join28(globalRoot, "glimpseui", "src", "glimpse");
     if (existsSync15(binaryPath)) return binaryPath;
   } catch {
   }
   return null;
 }
 async function openGlimpseWindow(html, options) {
-  const modulePath = resolvedBinaryPath ? join29(dirname17(resolvedBinaryPath), "glimpse.mjs") : "glimpseui";
+  const modulePath = resolvedBinaryPath ? join28(dirname17(resolvedBinaryPath), "glimpse.mjs") : "glimpseui";
   const glimpse = await import(modulePath);
   let active = true;
   const win = glimpse.open(html, {
@@ -59621,7 +59156,7 @@ var pi_mcp_adapter_default = createMcpAdapter();
 // src/managers/pi-manager.ts
 async function getManagedPiMcpServers() {
   try {
-    const parsed = JSON.parse(await readFile19(PI_MCP_CONFIG_PATH, "utf8"));
+    const parsed = JSON.parse(await readFile18(PI_MCP_CONFIG_PATH, "utf8"));
     if (!isRecord2(parsed) || !isRecord2(parsed.mcpServers)) return {};
     return Object.fromEntries(Object.entries(parsed.mcpServers).filter(
       (entry) => isRecord2(entry[1]) && (typeof entry[1].command === "string" || typeof entry[1].url === "string")
@@ -59743,7 +59278,7 @@ var PiManager = class extends CodingAgentManager {
   modelRuntime = null;
   constructor(options) {
     super(options);
-    this.historyFilePath = options.historyFilePath ?? join30(PI_HISTORY_DIR, `${Date.now()}.jsonl`);
+    this.historyFilePath = options.historyFilePath ?? join29(PI_HISTORY_DIR, `${Date.now()}.jsonl`);
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
@@ -59879,7 +59414,7 @@ var PiManager = class extends CodingAgentManager {
     }
     const resourceLoader = new DefaultResourceLoader({
       cwd: this.workingDirectory,
-      agentDir: join30(ENGINE_ENV.HOME_DIR, ".pi", "agent"),
+      agentDir: join29(ENGINE_ENV.HOME_DIR, ".pi", "agent"),
       extensionFactories,
       appendSystemPrompt: [this.buildCombinedInstructions() ?? ""]
     });
@@ -59977,11 +59512,6 @@ Match verification depth to the change: use focused checks for small changes and
 
 // src/managers/relay-tools.ts
 function extractFinalResponse(history, provider) {
-  const turns = history.codexAspTranscript?.turns ?? [];
-  for (let index = turns.length - 1; index >= 0; index--) {
-    const response = getCodexAspTurnResponse(turns[index]);
-    if (response?.text) return response.text;
-  }
   const message = parseAgentEvents(history.events ?? [], provider).findLast((candidate) => candidate.type === "agent");
   return message?.type === "agent" && message.content ? message.content : null;
 }
@@ -60001,13 +59531,13 @@ async function uploadAnalytics(endpoint, body) {
 import {
   appendFile as appendFile4,
   mkdir as mkdir19,
-  readFile as readFile20,
-  readdir as readdir8,
-  rename as rename3,
+  readFile as readFile19,
+  readdir as readdir7,
+  rename as rename4,
   unlink as unlink3
 } from "fs/promises";
 import { existsSync as existsSync16, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "fs";
-import { join as join31 } from "path";
+import { join as join30 } from "path";
 var MAX_FAILED_RECORDS = 500;
 var FLUSH_DEBOUNCE_MS = 15e3;
 var MAX_UPLOADED_SEGMENTS = 50;
@@ -60019,7 +59549,7 @@ var AnalyticsRecordBuffer = class {
       options.storageName,
       ...options.legacyStorageNames ?? []
     ];
-    this.liveFile = join31(ENGINE_DIR2, `${options.storageName}.jsonl`);
+    this.liveFile = join30(ENGINE_DIR2, `${options.storageName}.jsonl`);
     this.segmentFilePatterns = this.storageNames.map(
       (storageName) => new RegExp(`^${storageName}\\.(\\d+)\\.jsonl$`)
     );
@@ -60057,7 +59587,7 @@ var AnalyticsRecordBuffer = class {
     if (!existsSync16(ENGINE_DIR2)) return [];
     return readdirSync2(ENGINE_DIR2, { withFileTypes: true }).filter((entry) => entry.isFile() && this.storageNames.some(
       (storageName) => entry.name === `${storageName}.jsonl` || entry.name.startsWith(`${storageName}.`) && (entry.name.endsWith(".jsonl") || entry.name.endsWith(`.jsonl${UPLOADED_SUFFIX}`))
-    )).map(({ name }) => name).sort().flatMap((name) => this.parseRecords(readFileSync7(join31(ENGINE_DIR2, name), "utf-8"))).map((record3) => {
+    )).map(({ name }) => name).sort().flatMap((name) => this.parseRecords(readFileSync7(join30(ENGINE_DIR2, name), "utf-8"))).map((record3) => {
       const recordId = this.options.getRecordId?.(record3);
       if (recordId) this.recordIds.add(recordId);
       return record3;
@@ -60091,19 +59621,19 @@ var AnalyticsRecordBuffer = class {
       await Promise.allSettled([...this.pendingAppends]);
     }
     for (const storageName of this.storageNames) {
-      await rename3(
-        join31(ENGINE_DIR2, `${storageName}.jsonl`),
-        join31(ENGINE_DIR2, `${storageName}.${Date.now()}.jsonl`)
+      await rename4(
+        join30(ENGINE_DIR2, `${storageName}.jsonl`),
+        join30(ENGINE_DIR2, `${storageName}.${Date.now()}.jsonl`)
       ).catch(() => {
       });
     }
-    const entries = await readdir8(ENGINE_DIR2).catch(() => []);
+    const entries = await readdir7(ENGINE_DIR2).catch(() => []);
     let flushed = 0;
     let failed = 0;
     for (const entry of entries) {
       if (!this.segmentFilePatterns.some((pattern) => pattern.test(entry))) continue;
       try {
-        await this.uploadSegment(join31(ENGINE_DIR2, entry));
+        await this.uploadSegment(join30(ENGINE_DIR2, entry));
         flushed++;
       } catch (error) {
         failed++;
@@ -60132,16 +59662,16 @@ var AnalyticsRecordBuffer = class {
         (storageName) => entry.startsWith(`${storageName}.`)
       ) && entry.endsWith(UPLOADED_SUFFIX)).sort();
       for (const entry of uploaded.slice(0, -MAX_UPLOADED_SEGMENTS)) {
-        await unlink3(join31(ENGINE_DIR2, entry)).catch(() => {
+        await unlink3(join30(ENGINE_DIR2, entry)).catch(() => {
         });
       }
     }
     return { flushed, failed };
   }
   async uploadSegment(filePath) {
-    const records = this.parseRecords(await readFile20(filePath, "utf-8"));
+    const records = this.parseRecords(await readFile19(filePath, "utf-8"));
     if (records.length > 0) await this.options.upload(records);
-    await rename3(filePath, `${filePath}${UPLOADED_SUFFIX}`).catch(() => {
+    await rename4(filePath, `${filePath}${UPLOADED_SUFFIX}`).catch(() => {
     });
   }
   parseRecords(contents) {
@@ -60981,9 +60511,9 @@ var KeepAliveService = class _KeepAliveService {
 var keepAliveService = new KeepAliveService();
 
 // src/services/canvas-service.ts
-import { readdir as readdir9, readFile as readFile22, stat as stat4 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile21, stat as stat4 } from "fs/promises";
 import { homedir as homedir13 } from "os";
-import { join as join32 } from "path";
+import { join as join31 } from "path";
 
 // src/utils/contained-file.ts
 import { realpath, stat as stat3 } from "fs/promises";
@@ -61009,9 +60539,9 @@ function fileRevision(content) {
 }
 
 // src/utils/revisioned-text-file.ts
-import { readFile as readFile21 } from "fs/promises";
+import { readFile as readFile20 } from "fs/promises";
 async function writeRevisionedTextFile(filePath, content, expectedRevision) {
-  const current = await readFile21(filePath, "utf8");
+  const current = await readFile20(filePath, "utf8");
   const revision = fileRevision(current);
   if (revision !== expectedRevision) {
     return {
@@ -61025,15 +60555,15 @@ async function writeRevisionedTextFile(filePath, content, expectedRevision) {
 
 // src/services/canvas-service.ts
 var GLOBAL_CANVAS_DIRECTORIES = [
-  join32(homedir13(), ".claude", "plans"),
-  join32(process.env.XDG_DATA_HOME ?? join32(homedir13(), ".local", "share"), "opencode", "plans"),
-  join32(homedir13(), ".replicas", "canvas")
+  join31(homedir13(), ".claude", "plans"),
+  join31(process.env.XDG_DATA_HOME ?? join31(homedir13(), ".local", "share"), "opencode", "plans"),
+  join31(homedir13(), ".replicas", "canvas")
 ];
 async function canvasDirectories() {
   const repositories = await gitService.listRepositories().catch(() => []);
   return [
     ...GLOBAL_CANVAS_DIRECTORIES,
-    ...repositories.map((repository) => join32(repository.path, ".opencode", "plans"))
+    ...repositories.map((repository) => join31(repository.path, ".opencode", "plans"))
   ];
 }
 var CanvasService = class {
@@ -61051,14 +60581,14 @@ var CanvasService = class {
         if (!current) continue;
         let entries;
         try {
-          entries = await readdir9(current.directory, { withFileTypes: true });
+          entries = await readdir8(current.directory, { withFileTypes: true });
         } catch {
           continue;
         }
         for (const entry of entries) {
           if (entry.name.startsWith(".")) continue;
           const filename = current.relativePath ? `${current.relativePath}/${entry.name}` : entry.name;
-          const filePath = join32(current.directory, entry.name);
+          const filePath = join31(current.directory, entry.name);
           if (entry.isDirectory()) {
             pending.push({ directory: filePath, relativePath: filename });
             continue;
@@ -61083,7 +60613,7 @@ var CanvasService = class {
     if (!safe) return null;
     const { kind, mimeType } = classifyCanvasFilename(safe);
     for (const directory of await this.directories()) {
-      const filePath = join32(directory, safe);
+      const filePath = join31(directory, safe);
       let sizeBytes = 0;
       let updatedAt = "";
       try {
@@ -61104,7 +60634,7 @@ var CanvasService = class {
         };
       }
       try {
-        const bytes = await readFile22(filePath);
+        const bytes = await readFile21(filePath);
         return { filename: safe, kind, sizeBytes, mimeType, updatedAt, bytes };
       } catch {
         continue;
@@ -61264,16 +60794,16 @@ async function reconcileCanvasItems(filenames) {
 }
 
 // src/services/upload-chat-transcripts.ts
-import { createReadStream } from "fs";
+import { createReadStream as createReadStream2 } from "fs";
 import { createHash as createHash8 } from "crypto";
-import { readFile as readFile23, readdir as readdir10, stat as stat5 } from "fs/promises";
-import { basename as basename4, join as join34 } from "path";
+import { readFile as readFile22, readdir as readdir9, stat as stat5 } from "fs/promises";
+import { basename as basename4, join as join33 } from "path";
 
 // src/services/chat/chat-senders.ts
-import { join as join33 } from "path";
-var CHAT_SENDERS_DIR = join33(ENGINE_DIR2, "chat-senders");
+import { join as join32 } from "path";
+var CHAT_SENDERS_DIR = join32(ENGINE_DIR2, "chat-senders");
 function chatMessageSendersFilePath(chatId) {
-  return join33(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
+  return join32(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
 }
 function parseChatMessageSendersJsonl(content) {
   return content.split("\n").flatMap((line) => {
@@ -61306,7 +60836,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), ca
   for (const dir of HISTORY_DIRS) {
     let entries;
     try {
-      entries = await readdir10(dir);
+      entries = await readdir9(dir);
     } catch {
       continue;
     }
@@ -61316,7 +60846,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), ca
       const chat = chatsById.get(chatId);
       if (!shouldFlushChatTranscript(dir, chat, chatsById)) continue;
       tasks.push(
-        uploadChatTranscript(chatId, join34(dir, entry), chat, capture).then((artifact) => {
+        uploadChatTranscript(chatId, join33(dir, entry), chat, capture).then((artifact) => {
           flushed++;
           if (artifact && capture) revisions.push(artifact);
         }).catch((err) => {
@@ -61332,7 +60862,6 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), ca
 async function uploadChatTranscript(chatId, filePath, chat, capture) {
   const { size } = await stat5(filePath);
   if (size === 0) return null;
-  const historyPages = createChatTranscriptPages(await readFile23(filePath));
   const metadata = chat ? {
     provider: chat.provider,
     ...chat.relayBaseProvider ? { relayBaseProvider: chat.relayBaseProvider } : {},
@@ -61346,21 +60875,23 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
   } : {};
   if (capture) {
     const hash = createHash8("sha256");
-    for await (const chunk of createReadStream(filePath)) hash.update(chunk);
+    for await (const chunk of createReadStream2(filePath)) hash.update(chunk);
     metadata.captureId = capture.captureId;
     metadata.captureReason = capture.reason;
     metadata.sha256 = hash.digest("hex");
   }
   try {
     metadata.senders = parseChatMessageSendersJsonl(
-      await readFile23(chatMessageSendersFilePath(chatId), "utf-8")
+      await readFile22(chatMessageSendersFilePath(chatId), "utf-8")
     );
   } catch (error) {
     if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
   }
-  if (historyPages.index.codexAspTranscript || historyPages.index.removedMessageIds?.length) {
-    metadata.historyIndex = historyPages.index;
-  }
+  metadata.historyIndex = {
+    version: 2,
+    sourceSize: size,
+    ...chat?.removedMessageIds?.length ? { removedMessageIds: chat.removedMessageIds } : {}
+  };
   const uploadRequest = { chatId, size, metadata };
   const prepareResponse = await monolithRequest("/v1/engine/chat-transcripts/upload-url", {
     body: uploadRequest
@@ -61369,25 +60900,11 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
     throw new Error(`prepare failed: ${prepareResponse.status} ${await prepareResponse.text()}`);
   }
   const prepareBody = await prepareResponse.json();
-  if (!isRecord(prepareBody) || typeof prepareBody.uploadUrl !== "string" && prepareBody.uploadUrl !== null || prepareBody.historyPagesUploadUrl !== void 0 && typeof prepareBody.historyPagesUploadUrl !== "string") {
+  if (!isRecord(prepareBody) || typeof prepareBody.uploadUrl !== "string" && prepareBody.uploadUrl !== null) {
     throw new Error("prepare failed: invalid response");
   }
   if (prepareBody.uploadUrl === null) return null;
-  const uploads = [putPresignedFile(prepareBody.uploadUrl, filePath, size, "application/x-ndjson")];
-  const historyPagesSize = getChatTranscriptHistorySize(historyPages.index);
-  if (historyPagesSize > 0) {
-    if (typeof prepareBody.historyPagesUploadUrl !== "string") {
-      throw new Error("prepare failed: missing history pages upload URL");
-    }
-    uploads.push(fetch(prepareBody.historyPagesUploadUrl, {
-      method: "PUT",
-      headers: { "content-type": "application/x-ndjson" },
-      body: new Uint8Array(historyPages.bytes).buffer
-    }).then((response) => {
-      if (!response.ok) throw new Error(`history pages upload failed: ${response.status}`);
-    }));
-  }
-  await Promise.all(uploads);
+  await putPresignedFile(prepareBody.uploadUrl, filePath, size, "application/x-ndjson");
   const finalizeResponse = await monolithRequest("/v1/engine/chat-transcripts/finalize", {
     body: uploadRequest
   });
@@ -61403,9 +60920,9 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
 }
 
 // src/services/upload-engine-logs.ts
-import { createReadStream as createReadStream2 } from "fs";
-import { readdir as readdir11, stat as stat6 } from "fs/promises";
-import { join as join35 } from "path";
+import { createReadStream as createReadStream3 } from "fs";
+import { readdir as readdir10, stat as stat6 } from "fs/promises";
+import { join as join34 } from "path";
 var MAX_ENGINE_LOG_FLUSH_SESSIONS = 10;
 var MAX_ENGINE_LOG_FLUSH_BYTES = 5 * 1024 * 1024;
 var ENGINE_LOG_FLUSH_TIMEOUT_MS = 2e4;
@@ -61415,7 +60932,7 @@ async function flushAllEngineLogs() {
   let failed = 0;
   const deadline = Date.now() + ENGINE_LOG_FLUSH_TIMEOUT_MS;
   await runBeforeDeadline((signal) => engineLogger.flush(signal), deadline);
-  const files = await runBeforeDeadline(() => readdir11(LOG_DIR), deadline).catch(() => []);
+  const files = await runBeforeDeadline(() => readdir10(LOG_DIR), deadline).catch(() => []);
   const currentFilename = engineLogger.sessionId ? `${engineLogger.sessionId}.log` : null;
   const filenames = files.filter((filename) => {
     if (!filename.endsWith(".log")) return false;
@@ -61434,7 +60951,7 @@ async function flushAllEngineLogs() {
   const candidates = (await Promise.all(filenames.slice(0, MAX_ENGINE_LOG_FLUSH_SESSIONS).map(async (filename) => {
     try {
       const sessionId = filename.slice(0, -".log".length);
-      const filePath = join35(LOG_DIR, filename);
+      const filePath = join34(LOG_DIR, filename);
       const fileStat = await runBeforeDeadline(() => stat6(filePath), deadline);
       if (!fileStat.isFile()) {
         skipped++;
@@ -61467,7 +60984,7 @@ async function flushAllEngineLogs() {
       const content = await runBeforeDeadline(async (signal) => {
         if (candidate.length === 0) return Buffer.alloc(0);
         const chunks = [];
-        for await (const chunk of createReadStream2(candidate.filePath, {
+        for await (const chunk of createReadStream3(candidate.filePath, {
           start: candidate.offset,
           end: candidate.offset + candidate.length - 1,
           signal
@@ -61531,7 +61048,7 @@ async function uploadEngineLog(input, timeoutMs) {
 
 // src/services/chat/fork-handoff.ts
 import { mkdir as mkdir20, open as open3, writeFile as writeFile11 } from "fs/promises";
-import { join as join36 } from "path";
+import { join as join35 } from "path";
 var EXCERPT_MAX_CHARS = 24e3;
 var MAX_SANITIZED_SOURCE_BYTES = 32 * 1024 * 1024;
 function unansweredRequest(blocks) {
@@ -61566,7 +61083,7 @@ function tailBlocks(blocks, maxChars) {
   return { excerpt, truncated: start > 0 };
 }
 async function buildForkHandoff(input) {
-  const rawHistoryPath = join36(HISTORY_DIR_BY_PROVIDER[input.sourceProvider], `${input.sourceChatId}.jsonl`);
+  const rawHistoryPath = join35(HISTORY_DIR_BY_PROVIDER[input.sourceProvider], `${input.sourceChatId}.jsonl`);
   const { content, truncated: sourceTruncated } = await readHistoryTail(rawHistoryPath, MAX_SANITIZED_SOURCE_BYTES);
   let blocks = canonicalizeChatTranscriptBlocks(content, input.executionProvider, input.senders);
   if (input.turnLimit !== void 0) {
@@ -61574,9 +61091,9 @@ async function buildForkHandoff(input) {
     const start = blocks.findLastIndex((block) => block.startsWith("## User") && ++turns === input.turnLimit);
     blocks = blocks.slice(Math.max(0, start));
   }
-  const forkDir = join36(FORKS_DIR, input.targetChatId);
+  const forkDir = join35(FORKS_DIR, input.targetChatId);
   await mkdir20(forkDir, { recursive: true });
-  const transcriptPath = join36(forkDir, "source-transcript.md");
+  const transcriptPath = join35(forkDir, "source-transcript.md");
   const header = sourceTruncated ? `_This file was generated from only the most recent ${MAX_SANITIZED_SOURCE_BYTES / 1024 / 1024} MB of the source chat.${input.turnLimit === void 0 ? ` The complete raw event log is at ${rawHistoryPath}; grep it for anything earlier.` : ""}_
 
 ` : "";
@@ -61624,25 +61141,7 @@ function isSameAcceptedUserEvent(event, acceptedEvent) {
     { content: acceptedMessage, timestamp: acceptedEvent.timestamp }
   );
 }
-function getCodexTranscriptUserMessages(transcript) {
-  if (!transcript) return [];
-  const messages = [];
-  for (const turn of transcript.turns) {
-    for (const item of turn.items) {
-      if (item.type === "userMessage" && item.content.trim()) {
-        messages.push(item.content);
-      }
-    }
-  }
-  return messages;
-}
-function getCodexTranscriptFromEvent(event) {
-  if (event.type !== CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE) return null;
-  if (isCodexAspTranscript(event.payload.transcript)) return event.payload.transcript;
-  if (!isCodexAspTranscriptDelta(event.payload.transcriptDelta)) return null;
-  return applyCodexAspTranscriptDelta(null, event.payload.transcriptDelta);
-}
-function terminalErrorsFromEvent(event, provider, codexTranscript) {
+function terminalErrorsFromEvent(event, provider) {
   if (event.type === "claude-result") {
     const payload = coerceClaudeResultPayload(event.payload);
     if (!isClaudeResultError(payload)) return null;
@@ -61655,21 +61154,15 @@ function terminalErrorsFromEvent(event, provider, codexTranscript) {
   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 codexTurn = codexTurnFromEvent(event);
+  if (codexTurn) {
+    return normalizeCodexAspTranscriptStatus(codexTurn.status) === "failed" ? [codexTurn.error ?? "Codex run failed"] : void 0;
   }
   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;
-  return getCodexTranscriptUserMessages(transcript).includes(message);
-}
 var LAST_MESSAGE_PREVIEW_MAX = 200;
 var MAX_ACCEPTED_SEND_RESPONSES = 50;
 var MAX_REMOVED_MESSAGE_IDS = 6e3;
@@ -62060,9 +61553,13 @@ var ChatService = class {
         event: acceptedEvent,
         ...recordedSender ? { sender: recordedSender } : {}
       }
+    }).catch((error) => {
+      console.error("[ChatService] Failed to publish accepted turn:", { chatId, messageId: result.messageId, error });
     });
     if (chat.persisted.model !== previousModel) {
-      await this.publish({ type: "chat.updated", payload: { chat: this.toSummary(chat) } });
+      await this.publish({ type: "chat.updated", payload: { chat: this.toSummary(chat) } }).catch((error) => {
+        console.error("[ChatService] Failed to publish accepted chat update:", { chatId, error });
+      });
     }
   }
   async appendSender(chatId, sender) {
@@ -62073,7 +61570,7 @@ var ChatService = class {
     }
   }
   async readSenders(chatId) {
-    return readFile24(chatMessageSendersFilePath(chatId), "utf-8").then(parseChatMessageSendersJsonl).catch((error) => {
+    return readFile23(chatMessageSendersFilePath(chatId), "utf-8").then(parseChatMessageSendersJsonl).catch((error) => {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return [];
       console.error("[ChatService] Failed to read sender records:", error);
       return [];
@@ -62326,17 +61823,24 @@ var ChatService = class {
     return descendants;
   }
   async deleteHistoryFile(persisted) {
-    const historyPath = join37(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`);
+    const historyPath = join36(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`);
     await Promise.all([
       historyPath,
       `${historyPath}.pages.jsonl`,
       `${historyPath}.pages.index.json`
     ].map((path7) => rm4(path7, { force: true })));
     await rm4(chatMessageSendersFilePath(persisted.id), { force: true });
-    await rm4(join37(FORKS_DIR, persisted.id), { recursive: true, force: true });
+    await rm4(join36(FORKS_DIR, persisted.id), { recursive: true, force: true });
   }
   /** Resolves once the target chat exists; the handoff and its first turn run in the background. */
   async forkChat(sourceChatId, request, trigger = "manual", reason) {
+    const target = await this.createForkTarget(sourceChatId, request, trigger, reason);
+    this.runFork(target.id, request).catch((error) => {
+      console.error("[ChatService] Fork failed:", { sourceChatId, targetChatId: target.id, error });
+    });
+    return target;
+  }
+  async createForkTarget(sourceChatId, request, trigger, reason) {
     const source = this.requireChat(sourceChatId);
     const relayBaseProvider = await resolveRelayBaseProvider(request.provider, request.relayBaseProvider);
     const executionProvider = request.provider === "relay" ? relayBaseProvider : request.provider;
@@ -62350,7 +61854,7 @@ var ChatService = class {
       state: "preparing",
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const target = await this.createChat({
+    return this.createChat({
       id: request.id,
       provider: request.provider,
       ...relayBaseProvider ? { relayBaseProvider } : {},
@@ -62358,10 +61862,6 @@ var ChatService = class {
       clientRequestId: request.clientRequestId,
       fork
     });
-    this.runFork(target.id, request).catch((error) => {
-      console.error("[ChatService] Fork failed:", { sourceChatId, targetChatId: target.id, error });
-    });
-    return target;
   }
   async createForkHandoffMessage(targetChatId, options) {
     const source = this.requireChat(options.source.chatId);
@@ -62376,10 +61876,10 @@ var ChatService = class {
     });
     return formatChatForkHandoffMessage({ ...handoff, ...options });
   }
-  async runFork(targetId, request) {
+  async runFork(targetId, request, errorNotificationTarget) {
     const target = this.chats.get(targetId);
     const fork = target?.persisted.fork;
-    if (!target || !fork) return;
+    if (!target || !fork) return false;
     try {
       if (!isAgentAvailable(getChatExecutionProvider(target.persisted))) throw new ChatProviderUnavailableError(request.provider);
       const message = await this.createForkHandoffMessage(targetId, {
@@ -62388,7 +61888,7 @@ var ChatService = class {
         reason: fork.reason,
         message: request.message
       });
-      if (target.persisted.deletedAt) return;
+      if (target.persisted.deletedAt) return false;
       await this.sendMessage(targetId, {
         message,
         model: request.model,
@@ -62398,15 +61898,19 @@ var ChatService = class {
         senderEmail: request.senderEmail,
         senderDisplayName: request.senderDisplayName,
         senderAvatarUrl: request.senderAvatarUrl,
+        errorNotificationTarget,
         idempotencyKey: `chat-fork:${targetId}`
       });
-      await this.updateFork(target, { state: "ready", completedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
-      if (target.persisted.deletedAt) return;
+      if (target.persisted.deletedAt) return false;
       const message = error instanceof Error ? error.message : String(error);
       await this.updateFork(target, { state: "failed", error: message.slice(0, 500), completedAt: (/* @__PURE__ */ new Date()).toISOString() });
       throw error;
     }
+    await this.updateFork(target, { state: "ready", completedAt: (/* @__PURE__ */ new Date()).toISOString() }).catch((error) => {
+      console.error("[ChatService] Failed to finalize accepted fork:", { targetId, error });
+    });
+    return true;
   }
   async updateFork(chat, patch) {
     if (!chat.persisted.fork) return;
@@ -62430,11 +61934,11 @@ var ChatService = class {
   }
   async autoForkAfterQuota(chat, exhaustion) {
     const target = exhaustion.forkTo;
-    if (!target || chat.persisted.deletedAt) return;
+    if (!target || chat.persisted.deletedAt) return false;
     const alreadyForked = [...this.chats.values()].some((other) => other.persisted.fork?.trigger === "auto" && other.persisted.fork.source.chatId === chat.persisted.id && !other.persisted.deletedAt);
-    if (alreadyForked) return;
+    if (alreadyForked) return false;
     const last = chat.lastSendRequest;
-    await this.forkChat(chat.persisted.id, {
+    const request = {
       provider: target.provider,
       relayBaseProvider: target.relayBaseProvider,
       model: target.model,
@@ -62444,7 +61948,13 @@ var ChatService = class {
       senderEmail: last?.senderEmail,
       senderDisplayName: last?.senderDisplayName,
       senderAvatarUrl: last?.senderAvatarUrl
-    }, "auto", exhaustion.reason);
+    };
+    const fallback = await this.createForkTarget(chat.persisted.id, request, "auto", exhaustion.reason);
+    const accepted = await this.runFork(fallback.id, request, chat.activeErrorNotificationTarget ?? void 0);
+    if (!accepted) return false;
+    chat.lastTurnErrors = null;
+    chat.activeErrorNotificationTarget = null;
+    return true;
   }
   async getChatHistory(chatId, page2 = {}) {
     const chat = this.requireChat(chatId);
@@ -62458,13 +61968,13 @@ var ChatService = class {
       chat.persisted.removedMessageIds
     );
     for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
-      if (acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) || historyEvents.some((event) => isSameAcceptedUserEvent(event, acceptedEvent))) {
+      if (historyEvents.some((event) => isSameAcceptedUserEvent(event, acceptedEvent))) {
         chat.acceptedUserEvents.delete(messageId);
       }
     }
     const isLatestPage = isLatestChatHistoryPage(page2);
     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) && !historyEvents.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
+    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) => !historyEvents.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
     const events = excludeQueuedAcceptedEvents(
       [...historyEvents, ...acceptedEvents].sort((a, b) => getEventTimestampMs(a) - getEventTimestampMs(b)),
       [],
@@ -62498,7 +62008,6 @@ var ChatService = class {
       thread_id: history.thread_id,
       events,
       removedMessageIds: chat.persisted.removedMessageIds,
-      codexAspTranscript: history.codexAspTranscript ?? null,
       goal: history.goal ?? chat.provider.getGoal?.() ?? null,
       senders
     }, page2);
@@ -62512,14 +62021,17 @@ var ChatService = class {
     }
     return count;
   }
+  toTranscriptSource(chat) {
+    return { ...this.toSummary(chat), removedMessageIds: chat.persisted.removedMessageIds };
+  }
   async flushAllChatTranscripts() {
     return flushAllChatTranscripts(new Map(
-      [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toSummary(chat)])
+      [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toTranscriptSource(chat)])
     ));
   }
   async flushAllWorkspaceArtifacts(capture) {
     const chatsById = new Map(
-      [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toSummary(chat)])
+      [...this.chats.entries()].map(([chatId, chat]) => [chatId, this.toTranscriptSource(chat)])
     );
     const [chatTranscripts, canvas, repoState, engineLogs, [chatActivity]] = await Promise.all([
       flushAllChatTranscripts(chatsById, capture),
@@ -62581,7 +62093,7 @@ var ChatService = class {
     }
     const baseProvider = getChatExecutionProvider(persisted);
     const additionalInstructions = persisted.provider === "relay" ? buildRelayInstructions(this.workingDirectory) : void 0;
-    const historyFilePath = join37(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`);
+    const historyFilePath = join36(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`);
     const managerOptions = {
       provider: baseProvider,
       workingDirectory: this.workingDirectory,
@@ -62738,15 +62250,16 @@ var ChatService = class {
       });
     }
     this.agentTokenUsageTracker.noteAgentEvent(chatId, event);
-    const codexTranscript = getCodexTranscriptFromEvent(event);
     if (chat.hasActiveTurn) {
-      const displayMessages = codexTranscript ? parseLatestCodexAspTranscriptTurn(codexTranscript) : parseDisplayMessages([event], getChatExecutionProvider(chat.persisted), null, {
-        filter: false,
-        parentToolUseId: typeof event.payload.parent_tool_use_id === "string" ? event.payload.parent_tool_use_id : null
-      });
-      this.agentChatActivityTrackerService.noteSkillMcpCalls(chatId, displayMessages);
+      this.agentChatActivityTrackerService.noteSkillMcpCalls(
+        chatId,
+        parseDisplayMessages([event], getChatExecutionProvider(chat.persisted), {
+          filter: false,
+          parentToolUseId: typeof event.payload.parent_tool_use_id === "string" ? event.payload.parent_tool_use_id : null
+        })
+      );
     }
-    const terminalErrors = terminalErrorsFromEvent(event, getChatExecutionProvider(chat.persisted), codexTranscript);
+    const terminalErrors = terminalErrorsFromEvent(event, getChatExecutionProvider(chat.persisted));
     if (terminalErrors !== void 0) {
       chat.lastTurnErrors = terminalErrors;
     }
@@ -62772,13 +62285,6 @@ var ChatService = class {
         }
       }
     }
-    if (codexTranscript) {
-      for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
-        if (acceptedEventInCodexTranscript(acceptedEvent, codexTranscript)) {
-          chat.acceptedUserEvents.delete(messageId);
-        }
-      }
-    }
     if (event.type !== CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE) {
       this.touch(chat);
       this.observeCurrentBranches(chat).catch(() => {
@@ -62827,25 +62333,29 @@ var ChatService = class {
     this.endTrackedTurn(chatId);
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
     const processing = chat.provider.getQueue().length > 0 || (chat.provider.hasActiveBackgroundTasks?.() ?? false);
-    this.publishTurnCompleted(chat, completedAt, processing);
+    const exhaustion = chat.quotaExhaustion;
+    chat.quotaExhaustion = null;
     uploadChatTranscript(
       chatId,
-      join37(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
-      this.toSummary(chat)
+      join36(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
+      this.toTranscriptSource(chat)
     ).catch((err) => {
       console.error("[ChatService] Failed to upload chat transcript:", { chatId, err });
     });
     flushAllCanvasItems().catch((err) => {
       console.error("[ChatService] Failed to upload canvas items:", { chatId, err });
     });
-    await this.publishAgentTurnCompleteWebhook(chat, completedAt, processing);
-    const exhaustion = chat.quotaExhaustion;
-    chat.quotaExhaustion = null;
+    let forked = false;
     if (exhaustion) {
-      this.autoForkAfterQuota(chat, exhaustion).catch((error) => {
+      try {
+        forked = await this.autoForkAfterQuota(chat, exhaustion);
+      } catch (error) {
         console.error("[ChatService] Automatic fork after quota limit failed:", { chatId, error });
-      });
+      }
     }
+    const stillProcessing = processing || forked;
+    this.publishTurnCompleted(chat, completedAt, stillProcessing);
+    await this.publishAgentTurnCompleteWebhook(chat, completedAt, stillProcessing);
     this.notifyWorkspaceAgentIdle();
   }
   publishTurnCompleted(chat, completedAt, processing) {
@@ -62878,7 +62388,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile24(CHATS_FILE, "utf-8");
+      const content = await readFile23(CHATS_FILE, "utf-8");
       return parsePersistedChatsContent(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -62887,13 +62397,13 @@ var ChatService = class {
       const quarantinePath = corruptChatsFilePath();
       console.error(`[ChatService] Failed to load ${CHATS_FILE}; quarantining and trying backup:`, error);
       try {
-        await rename4(CHATS_FILE, quarantinePath);
+        await rename5(CHATS_FILE, quarantinePath);
         console.error(`[ChatService] Quarantined corrupt chats file at ${quarantinePath}`);
       } catch (renameError) {
         console.error("[ChatService] Failed to quarantine corrupt chats file:", renameError);
       }
       try {
-        const backupContent = await readFile24(CHATS_BACKUP_FILE, "utf-8");
+        const backupContent = await readFile23(CHATS_BACKUP_FILE, "utf-8");
         return parsePersistedChatsContent(backupContent);
       } catch (backupError) {
         if (backupError && typeof backupError === "object" && "code" in backupError && backupError.code === "ENOENT") {
@@ -62988,14 +62498,14 @@ var ChatService = class {
 
 // src/services/repo-file-service.ts
 import { execFile as execFile7 } from "child_process";
-import { readFile as readFile25 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 import { extname as extname3 } from "path";
 
 // src/services/language-server-service.ts
 import { spawn as spawn9 } from "child_process";
 import { existsSync as existsSync17, readFileSync as readFileSync8 } from "fs";
 import { createRequire as createRequire6 } from "module";
-import { delimiter as delimiter2, dirname as dirname19, join as join38, relative as relative2 } from "path";
+import { delimiter as delimiter2, dirname as dirname19, join as join37, relative as relative2 } from "path";
 import { setTimeout as setTimeout2 } from "timers/promises";
 import { fileURLToPath as fileURLToPath6, pathToFileURL } from "url";
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node.js";
@@ -63114,7 +62624,7 @@ var LanguageServerService = class {
     if (config.package && config.bin) command = process.execPath;
     else if (config.command) {
       const commandName = config.command;
-      command = process.env.PATH?.split(delimiter2).map((directory) => join38(directory, commandName)).find(existsSync17);
+      command = process.env.PATH?.split(delimiter2).map((directory) => join37(directory, commandName)).find(existsSync17);
     }
     const args = config.package && config.bin ? [packageBin(config.package, config.bin), ...config.args] : config.args;
     if (!command) return null;
@@ -63285,7 +62795,7 @@ var RepoFileService = class {
             sizeBytes,
             binary: true,
             tooLarge: false,
-            base64: (await readFile25(fullPath)).toString("base64"),
+            base64: (await readFile24(fullPath)).toString("base64"),
             mimeType
           };
         }
@@ -63310,7 +62820,7 @@ var RepoFileService = class {
           tooLarge: true
         };
       }
-      const content = await readFile25(fullPath, "utf-8");
+      const content = await readFile24(fullPath, "utf-8");
       return {
         repoName,
         path: filePath,
@@ -63342,7 +62852,7 @@ var RepoFileService = class {
   async inspectSymbol(repoName, filePath, line, character, action) {
     const resolved = await this.resolveFile(repoName, filePath);
     if (!resolved || line < 1 || character < 0 || isBinaryExtension(filePath)) return null;
-    const content = await readFile25(resolved.fullPath, "utf8");
+    const content = await readFile24(resolved.fullPath, "utf8");
     const sourceLine = content.split("\n")[line - 1];
     if (sourceLine === void 0) return null;
     const symbolMatch = Array.from(sourceLine.matchAll(/[\p{L}_$][\p{L}\p{N}_$]*/gu)).find((match) => character >= match.index && character <= match.index + match[0].length);
@@ -63455,21 +62965,21 @@ var RepoFileService = class {
 // src/v1-routes.ts
 import { Hono } from "hono";
 import { z as z6 } from "zod";
-import { readdir as readdir13, stat as stat7, readFile as readFile28 } from "fs/promises";
-import { join as join41, resolve as resolve5 } from "path";
+import { readdir as readdir12, stat as stat7, readFile as readFile27 } from "fs/promises";
+import { join as join40, resolve as resolve5 } from "path";
 
 // src/services/warm-hooks-service.ts
 import { spawn as spawn10 } from "child_process";
-import { readFile as readFile27 } from "fs/promises";
+import { readFile as readFile26 } from "fs/promises";
 import { existsSync as existsSync18 } from "fs";
-import { join as join40 } from "path";
+import { join as join39 } from "path";
 
 // src/services/warm-hook-logs-service.ts
-import { mkdir as mkdir22, readFile as readFile26, writeFile as writeFile12, readdir as readdir12, appendFile as appendFile6, unlink as unlink4 } from "fs/promises";
+import { mkdir as mkdir22, readFile as readFile25, writeFile as writeFile12, readdir as readdir11, appendFile as appendFile6, unlink as unlink4 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { join as join39 } from "path";
-var LOGS_DIR2 = join39(homedir14(), ".replicas", "warm-hook-logs");
-var CURRENT_RUN_LOG = join39(LOGS_DIR2, "current-run.log");
+import { join as join38 } from "path";
+var LOGS_DIR2 = join38(homedir14(), ".replicas", "warm-hook-logs");
+var CURRENT_RUN_LOG = join38(LOGS_DIR2, "current-run.log");
 var GLOBAL_FILENAME = "global.json";
 function withPreview2(stored) {
   const preview = buildHookOutputPreview(stored.output);
@@ -63486,7 +62996,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile12(join39(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile12(join38(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -63496,7 +63006,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile12(join39(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile12(join38(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -63506,13 +63016,13 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile12(join39(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile12(join38(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
     let files;
     try {
-      files = await readdir12(LOGS_DIR2);
+      files = await readdir11(LOGS_DIR2);
     } catch (err) {
       if (err.code === "ENOENT") {
         return [];
@@ -63525,7 +63035,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile26(join39(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile25(join38(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -63554,7 +63064,7 @@ var WarmHookLogsService = class {
   }
   async getCurrentRunLog() {
     try {
-      return await readFile26(CURRENT_RUN_LOG, "utf-8");
+      return await readFile25(CURRENT_RUN_LOG, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -63563,7 +63073,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? GLOBAL_FILENAME : hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile26(join39(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile25(join38(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -63582,12 +63092,12 @@ var warmHookLogsService = new WarmHookLogsService();
 // src/services/warm-hooks-service.ts
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join40(repoPath, filename);
+    const configPath = join39(repoPath, filename);
     if (!existsSync18(configPath)) {
       continue;
     }
     try {
-      const raw = await readFile27(configPath, "utf-8");
+      const raw = await readFile26(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -64912,11 +64422,11 @@ data: ${JSON.stringify("Terminal session not found")}
   });
   app2.get("/logs", async (c) => {
     try {
-      const files = await readdir13(LOG_DIR).catch(() => []);
+      const files = await readdir12(LOG_DIR).catch(() => []);
       const logFiles = files.filter((f) => f.endsWith(".log"));
       const sessions = await Promise.all(
         logFiles.map(async (filename) => {
-          const filePath = join41(LOG_DIR, filename);
+          const filePath = join40(LOG_DIR, filename);
           const fileStat = await stat7(filePath);
           const sessionId = filename.replace(/\.log$/, "");
           return {
@@ -64951,7 +64461,7 @@ data: ${JSON.stringify("Terminal session not found")}
       }
       let content;
       try {
-        content = await readFile28(filePath, "utf-8");
+        content = await readFile27(filePath, "utf-8");
       } catch {
         return c.json(jsonError("Log session not found"), 404);
       }