@makerbi/remodex 2.0.1 → 2.3.1

package/src/rollout-live-mirror.js

@@ -13,15 +13,38 @@ const {
 } = require("./rollout-watch");
 const { resolveCodexGeneratedImagesRoot } = require("./codex-home");
 const { buildApplyPatchFileChangeItem } = require("./apply-patch-changes");
-
-const DEFAULT_POLL_INTERVAL_MS = 700;
+const {
+  TERMINAL_TASK_EVENT_TYPES,
+  terminalEventClosesTrackedTurn,
+} = require("./rollout-turn-semantics");
+const {
+  hasVisiblePlanUpdate,
+  buildRemodexSourceItemKey,
+  visibleUserPromptFromInputEntries,
+  visibleUserPromptText,
+  responseItemMessageText,
+} = require("./desktop-ipc-shared");
+
+// The phone batches each poll tick's notifications and settles its timeline
+// ~80ms after the batch ends (CodexService liveMirrorBatchFlushNanoseconds).
+// Keep this interval comfortably above that settle window, or lower both
+// together, so consecutive ticks never merge into one batch.
+const DEFAULT_POLL_INTERVAL_MS = 250;
 const DEFAULT_LOOKUP_TIMEOUT_MS = 5_000;
 const DEFAULT_IDLE_TIMEOUT_MS = 60_000;
 const DEFAULT_ACTIVITY_HEARTBEAT_MS = 5_000;
-const DEFAULT_BOOTSTRAP_REPLAY_BATCH_INTERVAL_MS = 0;
-const BOOTSTRAP_REPLAY_CHUNK_SIZE = 50;
-const BOOTSTRAP_REPLAY_CHUNK_MAX_BYTES = 128 * 1024;
-const BOOTSTRAP_REPLAY_CACHE_LIMIT = 32;
+// Bootstrap replay must not resurrect runs whose rollout stopped growing long ago
+// (aborted/killed desktop runs never write task_complete).
+const DEFAULT_STALE_ACTIVE_RUN_MAX_AGE_MS = 10 * 60_000;
+const DEFAULT_SYNTHETIC_TERMINAL_GRACE_MS = 1_000;
+// Rollouts can be tens of megabytes. They are a live-delta fallback, not the
+// durable conversation history, so bootstrap must never synchronously parse
+// the entire file just to discover an active turn.
+const DEFAULT_BOOTSTRAP_METADATA_HEAD_BYTES = 256 * 1024;
+const DEFAULT_BOOTSTRAP_TAIL_BYTES = 4 * 1024 * 1024;
+// Keep a hard bound, but match the JSONL history reader's 64MB recovery window
+// so a long active turn does not degrade permanently to no live context.
+const DEFAULT_BOOTSTRAP_MAX_BYTES = 64 * 1024 * 1024;
 const DESKTOP_RESUME_METHODS = new Set(["thread/read", "thread/resume"]);
 
 // Observes desktop-authored rollout files and replays the currently active run as
@@ -33,19 +56,21 @@ function createRolloutLiveMirrorController({
   now = () => Date.now(),
   setIntervalFn = setInterval,
   clearIntervalFn = clearInterval,
-  setTimeoutFn = setTimeout,
-  clearTimeoutFn = clearTimeout,
   pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
   lookupTimeoutMs = DEFAULT_LOOKUP_TIMEOUT_MS,
   idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS,
   activityHeartbeatMs = DEFAULT_ACTIVITY_HEARTBEAT_MS,
-  bootstrapReplayBatchIntervalMs = DEFAULT_BOOTSTRAP_REPLAY_BATCH_INTERVAL_MS,
+  staleActiveRunMaxAgeMs = DEFAULT_STALE_ACTIVE_RUN_MAX_AGE_MS,
+  syntheticTerminalGraceMs = DEFAULT_SYNTHETIC_TERMINAL_GRACE_MS,
+  // Rollout tailing is the fallback mirror; when another live source already
+  // streams a thread (IPC follower state or bridge-owned app-server stream),
+  // emitting from the file too would double every row on the phone.
+  shouldSuppressThread = null,
 } = {}) {
   const mirrorsByThreadId = new Map();
-  const bootstrapReplayCache = new Map();
 
-  function observeInbound(rawMessage) {
-    const request = safeParseJSON(rawMessage);
+  function observeInbound(rawMessage, parsedMessage = null) {
+    const request = parsedMessage ?? safeParseJSON(rawMessage);
     const method = readString(request?.method);
     if (!DESKTOP_RESUME_METHODS.has(method)) {
       return;
@@ -63,22 +88,34 @@ function createRolloutLiveMirrorController({
     }
 
     let mirror;
+    let suppressionContext = {};
+    const isThreadSuppressed = () => Boolean(shouldSuppressThread?.(threadId, suppressionContext));
     mirror = createThreadRolloutLiveMirror({
       threadId,
-      sendApplicationResponse,
+      sendApplicationResponse: typeof shouldSuppressThread === "function"
+        ? (rawNotification) => {
+          if (!isThreadSuppressed()) {
+            sendApplicationResponse(rawNotification);
+          }
+        }
+        : sendApplicationResponse,
+      isSuppressed: typeof shouldSuppressThread === "function"
+        ? (context) => {
+          suppressionContext = context || {};
+          return isThreadSuppressed();
+        }
+        : () => false,
       logPrefix,
       fsModule,
       now,
       setIntervalFn,
       clearIntervalFn,
-      setTimeoutFn,
-      clearTimeoutFn,
       pollIntervalMs,
       lookupTimeoutMs,
       idleTimeoutMs,
       activityHeartbeatMs,
-      bootstrapReplayBatchIntervalMs,
-      bootstrapReplayCache,
+      staleActiveRunMaxAgeMs,
+      syntheticTerminalGraceMs,
       onStop() {
         if (mirrorsByThreadId.get(threadId) === mirror) {
           mirrorsByThreadId.delete(threadId);
@@ -106,32 +143,35 @@ function createRolloutLiveMirrorController({
 function createThreadRolloutLiveMirror({
   threadId,
   sendApplicationResponse,
+  isSuppressed = () => false,
   logPrefix,
   fsModule,
   now,
   setIntervalFn,
   clearIntervalFn,
-  setTimeoutFn,
-  clearTimeoutFn,
   pollIntervalMs,
   lookupTimeoutMs,
   idleTimeoutMs,
   activityHeartbeatMs,
-  bootstrapReplayBatchIntervalMs,
-  bootstrapReplayCache,
+  staleActiveRunMaxAgeMs,
+  syntheticTerminalGraceMs,
   onStop = () => {},
 }) {
   const startedAt = now();
   const state = createMirrorState(threadId);
-  const bootstrapReplayTimeouts = new Set();
 
   let isStopped = false;
   let rolloutPath = null;
   let lastSize = 0;
   let partialLine = "";
   let lastActivityAt = startedAt;
+  // Rollout growth only: heartbeats deliberately never refresh this clock, so a
+  // desktop process that died mid-run (no terminal event, file frozen) cannot
+  // keep the mirror heartbeating "running" forever.
+  let lastGrowthAt = startedAt;
   let lastHeartbeatAt = 0;
   let didBootstrap = false;
+  let wasSuppressed = false;
 
   const intervalId = setIntervalFn(tick, pollIntervalMs);
   tick();
@@ -159,7 +199,22 @@ function createThreadRolloutLiveMirror({
         }
       }
 
-      const fileSize = readFileSize(rolloutPath, fsModule);
+      const rolloutStat = fsModule.statSync(rolloutPath);
+      const fileSize = rolloutStat.size;
+      // While another live source streams this thread the tail keeps consuming
+      // rollout lines with its emissions muted. Compare per-thread activity so
+      // a quiet Desktop turn stays owned, while newer rollout growth can recover
+      // from a stale connected snapshot.
+      const suppressed = isSuppressed({
+        fallbackActivityAt: Number(rolloutStat.mtimeMs) || 0,
+      });
+      if (wasSuppressed && !suppressed && didBootstrap) {
+        lastSize = 0;
+        partialLine = "";
+        didBootstrap = false;
+        resetRunState(state);
+      }
+      wasSuppressed = suppressed;
       if (!didBootstrap) {
         didBootstrap = true;
         bootstrapFromExistingRollout({
@@ -168,13 +223,12 @@ function createThreadRolloutLiveMirror({
           state,
           fsModule,
           sendApplicationResponse,
-          bootstrapReplayCache,
-          setTimeoutFn,
-          bootstrapReplayBatchIntervalMs,
-          pendingTimeouts: bootstrapReplayTimeouts,
+          nowMs: currentTime,
+          staleActiveRunMaxAgeMs,
         });
         lastSize = fileSize;
         lastActivityAt = currentTime;
+        lastGrowthAt = currentTime;
         lastHeartbeatAt = currentTime;
         if (state.isDesktopOrigin === false) {
           stop();
@@ -182,10 +236,28 @@ function createThreadRolloutLiveMirror({
         return;
       }
 
+      if (fileSize < lastSize) {
+        // Rollout files can be rewritten/truncated by desktop recovery. The
+        // rewritten contents are a different history, not live growth: reset the
+        // cursor and re-run the bootstrap path (tagged catch-up / terminal
+        // catch-up) instead of replaying the whole file as untagged live events.
+        lastSize = 0;
+        partialLine = "";
+        didBootstrap = false;
+        resetRunState(state);
+        lastGrowthAt = currentTime;
+        return;
+      }
+
       if (fileSize > lastSize) {
+        // A capped bootstrap has no verified active-turn opener. Never append
+        // arbitrary deltas to that unknown state: wait for growth, then retry
+        // a bounded coherent bootstrap. A new task_started+prompt near EOF
+        // recovers immediately; an old huge run remains canonical-history only.
         const chunk = readFileSlice(rolloutPath, lastSize, fileSize, fsModule);
         lastSize = fileSize;
         lastActivityAt = currentTime;
+        lastGrowthAt = currentTime;
         lastHeartbeatAt = currentTime;
         if (!chunk) {
           return;
@@ -200,16 +272,51 @@ function createThreadRolloutLiveMirror({
           searchStart = nlIndex + 1;
         }
         partialLine = searchStart < combined.length ? combined.substring(searchStart) : "";
-        processRolloutLines(lines, state, sendApplicationResponse);
+        if (state.awaitingCoherentBoundary) {
+          if (processAwaitingCoherentBoundary(lines, state, sendApplicationResponse, currentTime)) {
+            state.awaitingCoherentBoundary = false;
+          }
+          return;
+        }
+        // Real growth proves the run is alive again; resume normal mirroring.
+        state.suppressLiveActivityUntilGrowth = false;
+        processRolloutLines(lines, state, sendApplicationResponse, { nowMs: currentTime });
+        return;
+      }
+
+      const syntheticTerminalNotifications = finalizePendingSyntheticTerminalIfReady(
+        state,
+        currentTime,
+        syntheticTerminalGraceMs
+      );
+      if (syntheticTerminalNotifications.length > 0) {
+        for (const notification of syntheticTerminalNotifications) {
+          sendApplicationResponse(JSON.stringify(notification));
+        }
+        lastActivityAt = currentTime;
+        lastHeartbeatAt = currentTime;
+        return;
+      }
+
+      // A frozen rollout with a still-open turn means the desktop process died
+      // mid-run (crash / kill: no terminal event will ever arrive). Stop before
+      // heartbeating so the phone is not kept in "running" forever.
+      if (state.activeTurnId && currentTime - lastGrowthAt >= staleActiveRunMaxAgeMs) {
+        stop();
         return;
       }
 
       if (
         state.isDesktopOrigin !== false
         && state.activeTurnId
+        && !state.suppressLiveActivityUntilGrowth
         && currentTime - lastHeartbeatAt >= activityHeartbeatMs
       ) {
         lastHeartbeatAt = currentTime;
+        // Heartbeats keep the idle timeout from killing a quiet-but-alive run
+        // (long thinking stretches legitimately exceed the 60s idle window);
+        // the growth-stale guard above still bounds crashed runs.
+        lastActivityAt = currentTime;
         sendApplicationResponse(JSON.stringify(createNotification("turn/activity", {
           threadId: state.threadId,
           turnId: state.activeTurnId,
@@ -235,12 +342,19 @@ function createThreadRolloutLiveMirror({
       return;
     }
 
+    // Mark stopped and clear the interval first: a throwing send during the
+    // final partial-line flush must never leak the poll interval.
     isStopped = true;
     clearIntervalFn(intervalId);
-    for (const timeout of bootstrapReplayTimeouts) {
-      clearTimeoutFn(timeout);
+    if (partialLine) {
+      const flushLine = partialLine;
+      partialLine = "";
+      try {
+        processRolloutLines([flushLine], state, sendApplicationResponse, { nowMs: now() });
+      } catch (error) {
+        console.warn(`${logPrefix} rollout live mirror final flush failed for ${threadId}: ${error.message}`);
+      }
     }
-    bootstrapReplayTimeouts.clear();
     onStop();
   }
 
@@ -256,12 +370,55 @@ function bootstrapFromExistingRollout({
   state,
   fsModule,
   sendApplicationResponse,
-  bootstrapReplayCache,
-  setTimeoutFn = setTimeout,
-  bootstrapReplayBatchIntervalMs = DEFAULT_BOOTSTRAP_REPLAY_BATCH_INTERVAL_MS,
-  pendingTimeouts,
+  nowMs = Date.now(),
+  staleActiveRunMaxAgeMs = DEFAULT_STALE_ACTIVE_RUN_MAX_AGE_MS,
 }) {
-  const initialContents = readFileSlice(rolloutPath, 0, fileSize, fsModule);
+  // Read metadata independently from the tail. session_meta is written at the
+  // beginning, while the active run lives at the end. This keeps reopening a
+  // 30MB rollout bounded and avoids treating a partial tail as history.
+  const metadataContents = readFileSlice(
+    rolloutPath,
+    0,
+    Math.min(fileSize, DEFAULT_BOOTSTRAP_METADATA_HEAD_BYTES),
+    fsModule
+  );
+  for (const rawLine of metadataContents.split("\n")) {
+    const parsed = safeParseJSON(rawLine.trim());
+    if (parsed?.type === "session_meta") {
+      populateSessionMetaState(state, parsed.payload);
+      break;
+    }
+  }
+  if (!isDesktopRolloutOrigin(state.sessionMeta)) {
+    state.isDesktopOrigin = false;
+    return;
+  }
+  state.isDesktopOrigin = true;
+
+  const bootstrapWindow = readCoherentBootstrapWindow({
+    rolloutPath,
+    fileSize,
+    fsModule,
+  });
+  if (!bootstrapWindow) {
+    // The active run starts outside the bounded bootstrap window. Do not emit
+    // a plausible-looking tail: canonical history remains the baseline and
+    // this mirror will still consume future growth normally.
+    state.awaitingCoherentBoundary = true;
+    return;
+  }
+  const { tailStart, contents: bootstrapContents } = bootstrapWindow;
+  let initialContents = bootstrapContents;
+  if (!initialContents) {
+    return;
+  }
+  // The first bytes may be the end of a JSON record. Drop that fragment rather
+  // than guessing, because an incomplete task_started record would lose the
+  // user opener and recreate the exact tail-only regression we are fixing.
+  if (tailStart > 0) {
+    const firstNewline = initialContents.indexOf("\n");
+    initialContents = firstNewline >= 0 ? initialContents.slice(firstNewline + 1) : "";
+  }
   if (!initialContents) {
     return;
   }
@@ -271,6 +428,7 @@ function bootstrapFromExistingRollout({
   let insideActiveRun = false;
   let activeTurnId = null;
   let pendingUserPreludeLine = null;
+  let latestTerminalRun = null;
 
   for (const rawLine of lines) {
     const line = rawLine.trim();
@@ -283,14 +441,20 @@ function bootstrapFromExistingRollout({
       continue;
     }
 
-    if (parsed.type === "session_meta") {
-      populateSessionMetaState(state, parsed.payload);
-    }
-
     const taskEventType = parsed?.type === "event_msg"
       ? readString(parsed?.payload?.type)
       : "";
-    if (taskEventType === "user_message" && !insideActiveRun) {
+    const eventUserMessage = taskEventType === "user_message"
+      && Boolean(visibleUserPromptFromInputEntries(
+        readString(parsed?.payload?.message) || readString(parsed?.payload?.text)
+      ));
+    const responseUserMessage = parsed?.type === "response_item"
+      && readString(parsed?.payload?.role).toLowerCase() === "user"
+      && Boolean(
+        visibleUserPromptFromInputEntries(extractResponseItemMessageText(parsed?.payload || {}))
+        || responseItemHasUserImage(parsed?.payload)
+      );
+    if (eventUserMessage || responseUserMessage) {
       pendingUserPreludeLine = line;
     }
     if (taskEventType === "task_started") {
@@ -298,11 +462,11 @@ function bootstrapFromExistingRollout({
       activeTurnId = readString(parsed?.payload?.turn_id)
         || readString(parsed?.payload?.turnId)
         || "";
+      latestTerminalRun = null;
       activeRunLines.length = 0;
       if (pendingUserPreludeLine) {
         activeRunLines.push(pendingUserPreludeLine);
       }
-      pendingUserPreludeLine = null;
       activeRunLines.push(line);
       continue;
     }
@@ -312,173 +476,309 @@ function bootstrapFromExistingRollout({
     }
 
     activeRunLines.push(line);
-    if (isRolloutTerminalTaskEvent(taskEventType)) {
-      insideActiveRun = false;
-      activeTurnId = "";
-      activeRunLines.length = 0;
-      pendingUserPreludeLine = null;
+    if (TERMINAL_TASK_EVENT_TYPES.has(taskEventType)) {
+      // A sibling parallel turn's terminal event must not close the newest
+      // run's window; its own terminal event is still honored later.
+      const terminalTurnId = readString(parsed?.payload?.turn_id)
+        || readString(parsed?.payload?.turnId);
+      if (terminalEventClosesTrackedTurn(terminalTurnId, activeTurnId)) {
+        latestTerminalRun = terminalRunFromEvent(parsed, activeTurnId);
+        insideActiveRun = false;
+        activeTurnId = "";
+        activeRunLines.length = 0;
+        pendingUserPreludeLine = null;
+      }
     }
   }
 
-  if (!isDesktopRolloutOrigin(state.sessionMeta)) {
-    state.isDesktopOrigin = false;
+  if (activeRunLines.length === 0 && latestTerminalRun) {
+    sendApplicationResponse(JSON.stringify(terminalCatchUpNotification(state.threadId, latestTerminalRun)));
     return;
   }
 
-  state.isDesktopOrigin = true;
-  const replayId = bootstrapReplayId(state.threadId, rolloutPath, initialContents);
-  const cachedBatches = bootstrapReplayCache?.get(replayId);
-  const replayNotifications = cachedBatches ? null : [];
-  // Rebuild local mirror state from the already-written run while collecting
-  // every notification into bounded catch-up batches for the phone.
-  processRolloutLines(activeRunLines, state, (rawNotification) => {
-    if (cachedBatches) {
-      return;
-    }
-    const notification = safeParseJSON(rawNotification);
-    if (notification) {
-      replayNotifications.push(notification);
-    }
-  });
-  const batches = cachedBatches || chunkBootstrapReplayNotifications(replayNotifications);
-  rememberBootstrapReplayBatches(bootstrapReplayCache, replayId, batches);
-  emitBootstrapReplayBatches(state, replayId, batches, sendApplicationResponse, {
-    setTimeoutFn,
-    batchIntervalMs: bootstrapReplayBatchIntervalMs,
-    pendingTimeouts,
-  });
-}
+  // A run with no terminal marker whose rollout stopped growing long ago is dead
+  // (killed process / lost session); replaying it would fake a live stream and
+  // pin the reopened thread in "running" forever. Hydrate the run context
+  // silently instead, so heartbeats stay off but a run that resumes writing can
+  // still mirror its new activity live.
+  if (
+    activeRunLines.length > 0
+    && isRolloutFileStale(rolloutPath, fsModule, nowMs, staleActiveRunMaxAgeMs)
+  ) {
+    processRolloutLines(activeRunLines, state, () => {});
+    // task_started resets per-run state while hydrating. Apply the stale-run
+    // suppression afterwards so it survives until real file growth proves the
+    // desktop process is alive again.
+    state.suppressLiveActivityUntilGrowth = true;
+    return;
+  }
 
-function isRolloutTerminalTaskEvent(eventType) {
-  return eventType === "task_complete"
-    || eventType === "turn_aborted"
-    || eventType === "task_aborted";
+  // Bootstrap replay is catch-up history, not live streaming: tag it so the
+  // phone can batch-apply it, then close the burst with an explicit marker so
+  // the run still reads as active without waiting for the next heartbeat.
+  processRolloutLines(activeRunLines, state, sendApplicationResponse, {
+    tagBootstrapReplay: true,
+  });
+  if (activeRunLines.length > 0 && state.activeTurnId) {
+    sendApplicationResponse(JSON.stringify(createNotification("turn/activity", {
+      threadId: state.threadId,
+      turnId: state.activeTurnId,
+      id: state.activeTurnId,
+      remodexRolloutBootstrapComplete: true,
+    })));
+  }
 }
 
-function processRolloutLines(lines, state, sendApplicationResponse) {
-  if (!Array.isArray(lines) || lines.length === 0) {
-    return;
+// Expands backwards only until the newest active task has its opening user
+// message. Every expansion reads just the newly needed prefix, so a 30MB file
+// is read at most once rather than once per retry. The hard cap keeps bootstrap
+// work/memory bounded; no coherent opener means no replay.
+function readCoherentBootstrapWindow({ rolloutPath, fileSize, fsModule }) {
+  const maxBytes = Math.min(fileSize, DEFAULT_BOOTSTRAP_MAX_BYTES);
+  let windowBytes = Math.min(fileSize, DEFAULT_BOOTSTRAP_TAIL_BYTES);
+  let tailStart = Math.max(0, fileSize - windowBytes);
+  let contents = readFileSlice(rolloutPath, tailStart, fileSize, fsModule);
+  if (!contents) {
+    return null;
   }
 
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line) {
-      continue;
+  while (true) {
+    const alignedContents = alignedBootstrapContents(contents, tailStart);
+    const boundary = inspectBootstrapRunBoundary(alignedContents);
+    // When the window already reaches byte zero it is the complete rollout:
+    // some legitimate system/continuation turns have no materialized user row.
+    // The opener requirement only protects a truncated tail.
+    if (!boundary.hasActiveRun || boundary.hasOpeningUser || tailStart === 0) {
+      return { tailStart, contents };
     }
-
-    const parsed = safeParseJSON(line);
-    if (!parsed) {
-      continue;
+    if (windowBytes >= maxBytes || tailStart === 0) {
+      return null;
     }
 
-    const notifications = synthesizeNotificationsFromRolloutEntry(parsed, state);
-    for (const notification of notifications) {
-      sendApplicationResponse(JSON.stringify(notification));
+    const nextWindowBytes = Math.min(maxBytes, windowBytes * 2);
+    const nextTailStart = Math.max(0, fileSize - nextWindowBytes);
+    const prefix = readFileSlice(rolloutPath, nextTailStart, tailStart, fsModule);
+    if (!prefix) {
+      return null;
     }
+    contents = `${prefix}${contents}`;
+    windowBytes = nextWindowBytes;
+    tailStart = nextTailStart;
   }
 }
 
-function emitBootstrapReplayBatches(
-  state,
-  replayId,
-  batches,
-  sendApplicationResponse,
-  {
-    setTimeoutFn = setTimeout,
-    batchIntervalMs = DEFAULT_BOOTSTRAP_REPLAY_BATCH_INTERVAL_MS,
-    pendingTimeouts,
-  } = {}
-) {
-  if (!Array.isArray(batches) || batches.length === 0) {
-    return;
+function alignedBootstrapContents(contents, tailStart) {
+  if (tailStart === 0) {
+    return contents;
   }
+  const firstNewline = contents.indexOf("\n");
+  return firstNewline >= 0 ? contents.slice(firstNewline + 1) : "";
+}
 
-  const sendBatch = (batch, batchIndex) => {
-    sendApplicationResponse(JSON.stringify(createNotification("remodex/rollout/bootstrapReplay", {
-      threadId: state.threadId,
-      replayId,
-      batchIndex,
-      batchCount: batches.length,
-      notifications: batch,
-    })));
-  };
-
-  for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
-    const batch = batches[batchIndex];
-    if (batchIndex === 0) {
-      sendBatch(batch, batchIndex);
+function inspectBootstrapRunBoundary(contents) {
+  let activeTurnId = "";
+  let hasOpeningUser = false;
+  let hasTurnOutputSinceStart = false;
+  let pendingUserBeforeStart = false;
+  // A tail can begin after task_started. In that case activity without a
+  // closing terminal is evidence of an unknown active boundary, not permission
+  // to replay a partial conversation.
+  let unboundedActivitySinceTerminal = false;
+
+  for (const rawLine of contents.split("\n")) {
+    const parsed = safeParseJSON(rawLine.trim());
+    if (!parsed) {
       continue;
     }
-
-    if (batchIntervalMs <= 0) {
-      sendBatch(batch, batchIndex);
+    const taskEventType = parsed?.type === "event_msg"
+      ? readString(parsed?.payload?.type)
+      : "";
+    const isUser = taskEventType === "user_message"
+      || (parsed?.type === "response_item" && readString(parsed?.payload?.role).toLowerCase() === "user");
+    const isResponseUser = parsed?.type === "response_item"
+      && readString(parsed?.payload?.role).toLowerCase() === "user";
+    const userText = isResponseUser
+      ? extractResponseItemMessageText(parsed?.payload || {})
+      : firstNonEmptyString([readString(parsed?.payload?.message), readString(parsed?.payload?.text)]);
+    const isVisibleUser = isUser && Boolean(
+      visibleUserPromptText(userText).trim()
+      || (isResponseUser && responseItemHasUserImage(parsed?.payload))
+    );
+    if (taskEventType === "task_started") {
+      activeTurnId = readString(parsed?.payload?.turn_id)
+        || readString(parsed?.payload?.turnId)
+        || "synthetic-active-turn";
+      hasOpeningUser = pendingUserBeforeStart;
+      hasTurnOutputSinceStart = false;
+      pendingUserBeforeStart = false;
       continue;
     }
-
-    const timeout = setTimeoutFn(() => {
-      pendingTimeouts?.delete(timeout);
-      sendBatch(batch, batchIndex);
-    }, batchIndex * batchIntervalMs);
-    pendingTimeouts?.add(timeout);
+    if (!activeTurnId) {
+      const isNeutral = isBootstrapNeutralRecord(parsed, taskEventType)
+        || (isUser && !isVisibleUser);
+      if (TERMINAL_TASK_EVENT_TYPES.has(taskEventType)) {
+        unboundedActivitySinceTerminal = false;
+      } else if (!isNeutral) {
+        unboundedActivitySinceTerminal = true;
+      }
+      if (isVisibleUser) {
+        pendingUserBeforeStart = true;
+      } else if (!isNeutral) {
+        pendingUserBeforeStart = false;
+      }
+      continue;
+    }
+    // The only user item that can certify a truncated active run is the one
+    // adjacent to task_started, before any assistant/tool output. Later user
+    // messages are steering/follow-up input and must never turn a partial tail
+    // into a valid bootstrap baseline.
+    if (isVisibleUser && !hasTurnOutputSinceStart) {
+      hasOpeningUser = true;
+    }
+    if (TERMINAL_TASK_EVENT_TYPES.has(taskEventType)) {
+      const terminalTurnId = readString(parsed?.payload?.turn_id)
+        || readString(parsed?.payload?.turnId);
+      if (terminalEventClosesTrackedTurn(terminalTurnId, activeTurnId)) {
+        activeTurnId = "";
+        hasOpeningUser = false;
+        hasTurnOutputSinceStart = false;
+        pendingUserBeforeStart = false;
+        unboundedActivitySinceTerminal = false;
+      }
+    } else if (!isUser && !isBootstrapNeutralRecord(parsed, taskEventType)) {
+      hasTurnOutputSinceStart = true;
+    }
   }
+
+  return {
+    hasActiveRun: Boolean(activeTurnId) || unboundedActivitySinceTerminal,
+    hasOpeningUser,
+  };
 }
 
-function chunkBootstrapReplayNotifications(notifications) {
-  const batches = [];
-  let batch = [];
-  let batchBytes = 0;
+// These records describe the runtime envelope around a turn. They are neither
+// visible assistant output nor tool activity, so they must not turn the first
+// real user prompt into a later steer during a bounded bootstrap scan.
+function isBootstrapNeutralRecord(entry, taskEventType = "") {
+  const entryType = readString(entry?.type).toLowerCase();
+  return entryType === "session_meta"
+    || entryType === "world_state"
+    || entryType === "turn_context"
+    || taskEventType === "context_updated";
+}
 
-  for (const notification of notifications) {
-    const notificationBytes = Buffer.byteLength(JSON.stringify(notification), "utf8");
-    const shouldStartNextBatch = batch.length > 0
-      && (
-        batch.length >= BOOTSTRAP_REPLAY_CHUNK_SIZE
-        || batchBytes + notificationBytes > BOOTSTRAP_REPLAY_CHUNK_MAX_BYTES
-      );
-    if (shouldStartNextBatch) {
-      batches.push(batch);
-      batch = [];
-      batchBytes = 0;
-    }
+// After a bounded bootstrap cannot reach the old opener, consume only new
+// bytes. A later real user+task_started boundary safely starts a new live run;
+// everything before it remains canonical-history territory.
+function processAwaitingCoherentBoundary(lines, state, sendApplicationResponse, nowMs) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index];
+    const line = rawLine.trim();
+    const parsed = safeParseJSON(line);
+    if (!parsed) continue;
+    const eventType = parsed?.type === "event_msg" ? readString(parsed?.payload?.type) : "";
+    const responseUser = parsed?.type === "response_item"
+      && readString(parsed?.payload?.role).toLowerCase() === "user";
+    const visibleUser = eventType === "user_message"
+      ? Boolean(visibleUserPromptFromInputEntries(readString(parsed?.payload?.message) || readString(parsed?.payload?.text)))
+      : responseUser && Boolean(visibleUserPromptFromInputEntries(extractResponseItemMessageText(parsed?.payload || {})) || responseItemHasUserImage(parsed?.payload));
+    if (visibleUser) state.awaitingBoundaryPreludeLine = line;
+    if (eventType !== "task_started" || !state.awaitingBoundaryPreludeLine) continue;
+    const boundaryLines = [state.awaitingBoundaryPreludeLine, line];
+    state.awaitingBoundaryPreludeLine = "";
+    resetRunState(state);
+    processRolloutLines(boundaryLines, state, sendApplicationResponse, { nowMs });
+    // The boundary and its first output frequently land in the same filesystem
+    // read. Replay the remainder immediately so recovery never drops that
+    // assistant/tool burst while changing modes.
+    processRolloutLines(lines.slice(index + 1), state, sendApplicationResponse, { nowMs });
+    return true;
+  }
+  return false;
+}
 
-    batch.push(notification);
-    batchBytes += notificationBytes;
+function isRolloutFileStale(rolloutPath, fsModule, nowMs, staleActiveRunMaxAgeMs) {
+  try {
+    const modifiedAtMs = fsModule.statSync(rolloutPath).mtimeMs;
+    return Number.isFinite(modifiedAtMs) && nowMs - modifiedAtMs >= staleActiveRunMaxAgeMs;
+  } catch {
+    return false;
   }
+}
 
-  if (batch.length > 0) {
-    batches.push(batch);
+function terminalRunFromEvent(entry, fallbackTurnId = "") {
+  const payload = entry?.payload || {};
+  const eventType = readString(payload.type);
+  if (!TERMINAL_TASK_EVENT_TYPES.has(eventType)) {
+    return null;
+  }
+
+  const turnId = readString(payload.turn_id)
+    || readString(payload.turnId)
+    || readString(fallbackTurnId);
+  if (!turnId) {
+    return null;
   }
-  return batches;
+
+  return {
+    eventType,
+    turnId,
+    message: readString(payload.message),
+  };
 }
 
-function bootstrapReplayId(threadId, rolloutPath, contents) {
-  return crypto
-    .createHash("sha256")
-    .update(readString(threadId))
-    .update("\0")
-    .update(readString(rolloutPath))
-    .update("\0")
-    .update(String(contents || ""))
-    .digest("hex")
-    .slice(0, 24);
+function terminalCatchUpNotification(threadId, terminalRun) {
+  const params = {
+    threadId,
+    turnId: terminalRun.turnId,
+    id: terminalRun.turnId,
+    remodexRolloutTerminalCatchUp: true,
+  };
+  if (terminalRun.eventType === "turn_aborted") {
+    params.status = "aborted";
+  } else if (terminalRun.eventType === "error") {
+    params.status = "failed";
+    if (terminalRun.message) {
+      params.error = { message: terminalRun.message };
+    }
+  }
+  return createNotification("turn/completed", params);
 }
 
-function rememberBootstrapReplayBatches(cache, replayId, batches) {
-  if (!cache || cache.has(replayId)) {
+function processRolloutLines(lines, state, sendApplicationResponse, {
+  tagBootstrapReplay = false,
+  nowMs = Date.now(),
+} = {}) {
+  if (!Array.isArray(lines) || lines.length === 0) {
     return;
   }
 
-  cache.set(replayId, batches);
-  while (cache.size > BOOTSTRAP_REPLAY_CACHE_LIMIT) {
-    const oldestKey = cache.keys().next().value;
-    if (!oldestKey) {
-      break;
+  const emitNotification = (notification) => {
+    if (tagBootstrapReplay && notification.params && typeof notification.params === "object") {
+      notification.params.remodexRolloutBootstrapReplay = true;
+    }
+    sendApplicationResponse(JSON.stringify(notification));
+  };
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+
+    const parsed = safeParseJSON(line);
+    if (!parsed) {
+      continue;
+    }
+
+    const notifications = synthesizeNotificationsFromRolloutEntry(parsed, state, { nowMs });
+    for (const notification of notifications) {
+      emitNotification(notification);
     }
-    cache.delete(oldestKey);
   }
 }
 
-function synthesizeNotificationsFromRolloutEntry(entry, state) {
+function synthesizeNotificationsFromRolloutEntry(entry, state, { nowMs = Date.now() } = {}) {
   if (entry?.type === "session_meta") {
     populateSessionMetaState(state, entry.payload);
     if (!isDesktopRolloutOrigin(state.sessionMeta)) {
@@ -500,12 +800,15 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
     const eventType = readString(payload.type);
 
     if (eventType === "task_started") {
+      notifications.push(...finalizePendingSyntheticTerminal(state));
       const explicitTurnId = readString(payload.turn_id) || readString(payload.turnId);
       const turnId = explicitTurnId || buildSyntheticTurnId(state, entry);
       state.activeTurnId = turnId;
       state.activeTurnIdIsSynthetic = !explicitTurnId;
       state.reasoningItemId = buildSyntheticItemId("thinking", state.threadId, turnId);
       state.hasThinking = false;
+      state.hasReasoningContent = false;
+      state.emittedReasoningSummaryKeys.clear();
       state.commandCalls.clear();
       state.applyPatchCalls.clear();
       state.emittedPatchApplyEndCalls.clear();
@@ -523,44 +826,66 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
       return notifications;
     }
 
+    if (eventType && !TERMINAL_TASK_EVENT_TYPES.has(eventType)) {
+      clearPendingSyntheticTerminal(state);
+    }
+
     if (eventType === "user_message") {
-      const message = readString(payload.message) || readString(payload.text);
-      if (!message) {
-        return [];
-      }
+      // Rollouts persist injected context (AGENTS.md instructions, IDE prompt
+      // wrappers) as user_message events; only the real request is a bubble.
+      notifications.push(...userMessageNotifications(state, entry, payload));
+      return notifications;
+    }
 
-      const turnId = resolveRolloutEventTurnId(state, payload);
+    if (eventType === "task_complete") {
+      const turnId = resolveRolloutEventTurnId(state, payload, { allowSyntheticPromotion: false });
       if (!turnId) {
-        state.pendingUserMessages.push({
-          id: readString(payload.id),
-          message,
-          timestamp: readUserMessageTimestamp(entry, payload),
-        });
         return [];
       }
 
-      notifications.push(createNotification("codex/event/user_message", {
+      // Desktop runs parallel turns in one rollout: a sibling turn finishing
+      // must not wipe the tracked state of the turn that is still streaming.
+      const closesActiveRun = terminalEventClosesTrackedTurn(turnId, state.activeTurnId);
+      if (closesActiveRun) {
+        notifications.push(...turnFileChangeSnapshotNotifications(state, turnId));
+      }
+      notifications.push(createNotification("turn/completed", {
         threadId: state.threadId,
         turnId,
-        message,
-        ...timestampParams(readUserMessageTimestamp(entry, payload)),
+        id: turnId,
       }));
+      if (closesActiveRun) {
+        resetRunState(state);
+      } else if (isSyntheticTerminalMismatch(state, turnId)) {
+        markPendingSyntheticTerminal(state, { status: "completed" }, nowMs);
+      }
       return notifications;
     }
 
-    if (eventType === "task_complete") {
-      const turnId = resolveRolloutEventTurnId(state, payload);
+    // Aborted/failed desktop runs never write task_complete; close the mirrored
+    // turn anyway so the phone does not keep the thread pinned as running.
+    if (eventType === "turn_aborted" || eventType === "error") {
+      const turnId = resolveRolloutEventTurnId(state, payload, { allowSyntheticPromotion: false });
       if (!turnId) {
         return [];
       }
 
-      notifications.push(...turnFileChangeSnapshotNotifications(state, turnId));
-      notifications.push(createNotification("turn/completed", {
+      const terminalParams = {
         threadId: state.threadId,
         turnId,
         id: turnId,
-      }));
-      resetRunState(state);
+        status: eventType === "error" ? "failed" : "aborted",
+      };
+      const errorMessage = readString(payload.message);
+      if (eventType === "error" && errorMessage) {
+        terminalParams.error = { message: errorMessage };
+      }
+      notifications.push(createNotification("turn/completed", terminalParams));
+      if (terminalEventClosesTrackedTurn(turnId, state.activeTurnId)) {
+        resetRunState(state);
+      } else if (isSyntheticTerminalMismatch(state, turnId)) {
+        markPendingSyntheticTerminal(state, terminalParams, nowMs);
+      }
       return notifications;
     }
 
@@ -579,18 +904,7 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
     }
 
     if (eventType === "agent_message") {
-      const message = readString(payload.message) || readString(payload.text);
-      if (!message || !shouldMirrorAgentMessage(payload)) {
-        return [];
-      }
-      const turnId = resolveRolloutEventTurnId(state, payload);
-
-      notifications.push(createNotification("codex/event/agent_message", {
-        threadId: state.threadId,
-        turnId,
-        itemId: buildAgentMessageItemId(state.threadId, turnId, entry, message),
-        message,
-      }));
+      notifications.push(...agentMessageNotifications(state, entry, payload));
       return notifications;
     }
 
@@ -613,9 +927,16 @@ function synthesizeNotificationsFromRolloutEntry(entry, state) {
     return [];
   }
 
+  clearPendingSyntheticTerminal(state);
+
   const payload = entry.payload || {};
   const itemType = normalizeRolloutItemType(payload.type);
 
+  if (itemType === "message") {
+    notifications.push(...responseItemMessageNotifications(state, entry, payload));
+    return notifications;
+  }
+
   if (itemType === "reasoning") {
     notifications.push(...reasoningNotifications(state, extractReasoningText(payload)));
     return notifications;
@@ -649,12 +970,32 @@ function reasoningNotifications(state, text) {
     return [];
   }
 
-  const delta = readString(text);
-  if (!delta) {
+  const rawText = readString(text);
+  if (!rawText) {
     return ensureThinkingNotifications(state);
   }
 
+  const summaryEntries = summaryOnlyReasoningEntries(rawText);
+  let visibleText = rawText;
+  if (summaryEntries) {
+    const unseenEntries = summaryEntries.filter((entry) => {
+      if (state.emittedReasoningSummaryKeys.has(entry.key)) {
+        return false;
+      }
+      state.emittedReasoningSummaryKeys.add(entry.key);
+      return true;
+    });
+    if (unseenEntries.length === 0) {
+      return [];
+    }
+    visibleText = unseenEntries
+      .map((entry) => `**${entry.title}**\n\n<!-- -->`)
+      .join("\n\n");
+  }
+
   state.hasThinking = true;
+  const delta = `${state.hasReasoningContent ? "\n\n" : ""}${visibleText}`;
+  state.hasReasoningContent = true;
   return [
     createNotification("item/reasoning/textDelta", {
       threadId: state.threadId,
@@ -665,6 +1006,188 @@ function reasoningNotifications(state, text) {
   ];
 }
 
+// Newer Codex rollouts write the same cumulative reasoning summaries through
+// both event_msg and response_item records. Recognize only title/comment-only
+// payloads here; detailed reasoning remains a separate opaque stream.
+function summaryOnlyReasoningEntries(text) {
+  const entries = [];
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || /^<!--.*-->$/.test(line)) {
+      continue;
+    }
+    const match = /^\*\*(.+?)\*\*$/.exec(line);
+    if (!match) {
+      return null;
+    }
+    const title = match[1].trim();
+    if (!title) {
+      return null;
+    }
+    entries.push({
+      title,
+      key: title.replace(/\s+/g, " ").toLowerCase(),
+    });
+  }
+  return entries.length > 0 ? entries : null;
+}
+
+function responseItemMessageNotifications(state, entry, payload) {
+  const role = readString(payload?.role).toLowerCase();
+  if (role === "user") {
+    return userMessageNotifications(state, entry, payload, {
+      rawMessage: extractResponseItemMessageText(payload),
+      isResponseItem: true,
+    });
+  }
+  if (role && role !== "assistant") {
+    return [];
+  }
+
+  const message = extractResponseItemMessageText(payload);
+  if (!message) {
+    return [];
+  }
+
+  return agentMessageNotifications(state, entry, {
+    message,
+    phase: payload?.phase,
+    itemId: readString(payload?.id),
+    turn_id: readString(payload?.turn_id) || readString(payload?.internal_chat_message_metadata_passthrough?.turn_id),
+    turnId: readString(payload?.turnId) || readString(payload?.internal_chat_message_metadata_passthrough?.turnId),
+  });
+}
+
+function userMessageNotifications(state, entry, payload, {
+  rawMessage = "",
+  isResponseItem = false,
+} = {}) {
+  const imagePlaceholder = responseItemHasUserImage(payload) ? "Image attachment" : "";
+  const message = visibleUserPromptFromInputEntries(
+    rawMessage || readString(payload?.message) || readString(payload?.text) || imagePlaceholder
+  );
+  if (!message) {
+    return [];
+  }
+  const turnId = resolveRolloutEventTurnId(state, payload);
+  const itemId = readString(payload?.id) || readString(payload?.itemId) || readString(payload?.item_id);
+  const timestamp = readUserMessageTimestamp(entry, payload);
+  if (!turnId) {
+    // response_item(user) can precede task_started. Hold it exactly like the
+    // event_msg form so task_started flushes the opener before thinking/output.
+    const pendingKey = `${itemId || ""}:${message}`;
+    if (!state.pendingUserMessages.some((pending) => `${pending.id || ""}:${pending.message}` === pendingKey)) {
+      state.pendingUserMessages.push({ id: itemId, message, timestamp, isResponseItem });
+    }
+    return [];
+  }
+
+  const dedupeKey = userMessageOccurrenceKey(state, turnId, message, { isResponseItem });
+  if (state.emittedUserMessageKeys.has(dedupeKey)) {
+    return [];
+  }
+  state.emittedUserMessageKeys.add(dedupeKey);
+  return [createNotification("codex/event/user_message", {
+    threadId: state.threadId,
+    turnId,
+    message,
+    ...(itemId ? { id: itemId } : {}),
+    ...timestampParams(timestamp),
+  })];
+}
+
+// Rollouts commonly persist one user message twice as an event_msg and a
+// response_item pair, in either order: desktop-started turns log event_msg
+// first, phone/app-server-started turns log response_item first. Pair the two
+// shapes by occurrence in both directions instead of collapsing every
+// identical text in the turn, because repeated steers are legitimate.
+function userMessageOccurrenceKey(state, turnId, message, { isResponseItem = false } = {}) {
+  const baseKey = buildRemodexSourceItemKey(turnId, message);
+  const unpairedMap = isResponseItem
+    ? state.pendingEventUserMessageOccurrencesByBaseKey
+    : state.pendingResponseItemUserMessageOccurrencesByBaseKey;
+  const ownPendingMap = isResponseItem
+    ? state.pendingResponseItemUserMessageOccurrencesByBaseKey
+    : state.pendingEventUserMessageOccurrencesByBaseKey;
+
+  const unpaired = unpairedMap.get(baseKey) || [];
+  if (unpaired.length > 0) {
+    const occurrence = unpaired.shift();
+    if (unpaired.length === 0) {
+      unpairedMap.delete(baseKey);
+    } else {
+      unpairedMap.set(baseKey, unpaired);
+    }
+    return `user:${baseKey}:${occurrence}`;
+  }
+
+  const occurrence = (state.userMessageOccurrencesByBaseKey.get(baseKey) || 0) + 1;
+  state.userMessageOccurrencesByBaseKey.set(baseKey, occurrence);
+  const ownPending = ownPendingMap.get(baseKey) || [];
+  ownPending.push(occurrence);
+  ownPendingMap.set(baseKey, ownPending);
+  return `user:${baseKey}:${occurrence}`;
+}
+
+function responseItemHasUserImage(payload) {
+  return Array.isArray(payload?.content) && payload.content.some((part) => {
+    const type = readString(part?.type).toLowerCase();
+    return type === "input_image" || type === "image" || type === "image_url";
+  });
+}
+
+function agentMessageNotifications(state, entry, payload) {
+  const message = readString(payload?.message) || readString(payload?.text);
+  if (!message) {
+    return [];
+  }
+
+  const turnId = resolveRolloutEventTurnId(state, payload);
+  const baseKey = agentMessageDedupeKey(turnId, message);
+  const providerItemId = readString(payload?.itemId);
+  const nextOccurrence = (state.agentMessageOccurrencesByBaseKey.get(baseKey) || 0) + 1;
+  const occurrence = providerItemId && state.pendingEventAgentMessageOccurrencesByBaseKey.has(baseKey)
+    ? state.pendingEventAgentMessageOccurrencesByBaseKey.get(baseKey)
+    : nextOccurrence;
+  state.agentMessageOccurrencesByBaseKey.set(baseKey, Math.max(nextOccurrence, occurrence));
+  if (providerItemId) {
+    state.pendingEventAgentMessageOccurrencesByBaseKey.delete(baseKey);
+  } else {
+    state.pendingEventAgentMessageOccurrencesByBaseKey.set(baseKey, occurrence);
+  }
+  const dedupeKey = `${baseKey}:${occurrence}`;
+  if (state.emittedAgentMessageKeys.has(dedupeKey)) {
+    return [];
+  }
+  state.emittedAgentMessageKeys.add(dedupeKey);
+
+  // Commentary (interleaved progress prose) is mirrored too: desktop renders it
+  // between tool calls, and dropping it would glue every tool row into one burst
+  // on the phone. The phase rides along so the app can keep commentary rows
+  // distinct from the final answer.
+  const params = {
+    threadId: state.threadId,
+    turnId,
+    itemId: providerItemId || buildAgentMessageItemId(state.threadId, turnId, entry, message),
+    // The same assistant item may first arrive as event_msg (without Codex's
+    // item id) and later as response_item/history (with one). Preserve a
+    // stable source alias across bootstrap/reconnect so the phone can merge
+    // those representations without using unsafe global text deduplication.
+    ...(occurrence === 1 ? { remodexSourceItemKey: baseKey } : {}),
+    message,
+  };
+  const phase = readString(payload?.phase);
+  if (phase) {
+    params.phase = phase;
+  }
+
+  return [createNotification("codex/event/agent_message", params)];
+}
+
+function extractResponseItemMessageText(payload) {
+  return responseItemMessageText(payload);
+}
+
 function toolStartNotifications(state, payload) {
   if (!state.activeTurnId) {
     return [];
@@ -684,6 +1207,40 @@ function toolStartNotifications(state, payload) {
     ];
   }
 
+  if (readString(toolName).toLowerCase() === "apply_patch") {
+    const item = buildApplyPatchFileChangeItem({
+      callId,
+      patch: readString(argumentsObject.patch) || readString(argumentsObject.input) || readString(payload.input),
+      status: readString(payload.status) || "completed",
+      idFallback: buildSyntheticItemId("file-change", state.threadId, state.activeTurnId, callId),
+    });
+    const notifications = [...ensureThinkingNotifications(state)];
+    if (!item) {
+      return [
+        ...notifications,
+        createNotification("codex/event/background_event", {
+          threadId: state.threadId,
+          turnId: state.activeTurnId,
+          call_id: callId,
+          message: genericToolActivityMessage(toolName),
+        }),
+      ];
+    }
+    state.applyPatchCalls.set(callId, item);
+    return [
+      ...notifications,
+      createNotification("codex/event/patch_apply_begin", {
+        threadId: state.threadId,
+        turnId: state.activeTurnId,
+        id: state.activeTurnId,
+        call_id: callId,
+        itemId: item.id,
+        status: "inProgress",
+        changes: item.changes,
+      }),
+    ];
+  }
+
   state.commandCalls.set(callId, {
     toolName,
     command: resolveToolCommand(toolName, argumentsObject),
@@ -845,8 +1402,15 @@ function toolOutputNotifications(state, payload) {
   }
 
   if (!isCommandToolName(toolCall.toolName)) {
+    const notifications = [...ensureThinkingNotifications(state)];
+    notifications.push(createNotification("codex/event/background_event", {
+      threadId: state.threadId,
+      turnId: state.activeTurnId,
+      call_id: callId,
+      message: genericToolCompletionMessage(toolCall.toolName),
+    }));
     state.commandCalls.delete(callId);
-    return [];
+    return notifications;
   }
 
   const output = readString(payload.output);
@@ -945,6 +1509,75 @@ function itemCompletedNotifications(state, payload) {
   ];
 }
 
+// Synthetic turn ids are a temporary stand-in; close them if a terminal event
+// had no later activity proving it belonged to a sibling parallel run.
+function markPendingSyntheticTerminal(state, terminalParams = {}, nowMs = Date.now()) {
+  if (state.activeTurnIdIsSynthetic && state.activeTurnId) {
+    state.pendingSyntheticTerminalTurnId = state.activeTurnId;
+    state.pendingSyntheticTerminalStartedAt = nowMs;
+    state.pendingSyntheticTerminalStatus = readString(terminalParams.status) || "";
+    state.pendingSyntheticTerminalErrorMessage = readString(terminalParams.error?.message) || "";
+  }
+}
+
+function clearPendingSyntheticTerminal(state) {
+  state.pendingSyntheticTerminalTurnId = null;
+  state.pendingSyntheticTerminalStartedAt = 0;
+  state.pendingSyntheticTerminalStatus = "";
+  state.pendingSyntheticTerminalErrorMessage = "";
+}
+
+function isSyntheticTerminalMismatch(state, terminalTurnId) {
+  return Boolean(
+    state.activeTurnIdIsSynthetic
+    && state.activeTurnId
+    && terminalTurnId
+    && terminalTurnId !== state.activeTurnId
+  );
+}
+
+function finalizePendingSyntheticTerminal(state) {
+  const turnId = state.pendingSyntheticTerminalTurnId;
+  if (!turnId) {
+    return [];
+  }
+
+  const terminalParams = {
+    threadId: state.threadId,
+    turnId,
+    id: turnId,
+  };
+  if (state.pendingSyntheticTerminalStatus) {
+    terminalParams.status = state.pendingSyntheticTerminalStatus;
+  }
+  if (state.pendingSyntheticTerminalErrorMessage) {
+    terminalParams.error = { message: state.pendingSyntheticTerminalErrorMessage };
+  }
+
+  const notifications = [
+    ...turnFileChangeSnapshotNotifications(state, turnId),
+    createNotification("turn/completed", terminalParams),
+  ];
+  resetRunState(state);
+  return notifications;
+}
+
+function finalizePendingSyntheticTerminalIfReady(state, nowMs, graceMs) {
+  if (!state.pendingSyntheticTerminalTurnId) {
+    return [];
+  }
+  const startedAt = Number.isFinite(state.pendingSyntheticTerminalStartedAt)
+    ? state.pendingSyntheticTerminalStartedAt
+    : nowMs;
+  const resolvedGraceMs = Number.isFinite(graceMs)
+    ? Math.max(0, graceMs)
+    : DEFAULT_SYNTHETIC_TERMINAL_GRACE_MS;
+  if (nowMs - startedAt < resolvedGraceMs) {
+    return [];
+  }
+  return finalizePendingSyntheticTerminal(state);
+}
+
 function ensureThinkingNotifications(state) {
   if (!state.activeTurnId || state.hasThinking) {
     return [];
@@ -973,11 +1606,29 @@ function createMirrorState(threadId) {
     activeTurnId: null,
     reasoningItemId: null,
     hasThinking: false,
+    hasReasoningContent: false,
+    emittedReasoningSummaryKeys: new Set(),
     commandCalls: new Map(),
     applyPatchCalls: new Map(),
     emittedPatchApplyEndCalls: new Set(),
+    emittedAgentMessageKeys: new Set(),
+    agentMessageOccurrencesByBaseKey: new Map(),
+    pendingEventAgentMessageOccurrencesByBaseKey: new Map(),
+    emittedUserMessageKeys: new Set(),
+    userMessageOccurrencesByBaseKey: new Map(),
+    pendingEventUserMessageOccurrencesByBaseKey: new Map(),
+    pendingResponseItemUserMessageOccurrencesByBaseKey: new Map(),
     pendingUserMessages: [],
+    pendingSyntheticTerminalTurnId: null,
+    pendingSyntheticTerminalStartedAt: 0,
+    pendingSyntheticTerminalStatus: "",
+    pendingSyntheticTerminalErrorMessage: "",
     activeTurnIdIsSynthetic: false,
+    // True after a stale bootstrap: run context is hydrated but nothing is
+    // emitted (including heartbeats) until the rollout file grows again.
+    suppressLiveActivityUntilGrowth: false,
+    awaitingCoherentBoundary: false,
+    awaitingBoundaryPreludeLine: "",
   };
 }
 
@@ -1031,7 +1682,8 @@ function parseToolArguments(rawArguments) {
 
 function planUpdateNotifications(state, argumentsObject) {
   const plan = normalizeProgressPlanSteps(argumentsObject.plan);
-  if (plan.length === 0) {
+  const explanation = readString(argumentsObject.explanation);
+  if (!hasVisiblePlanUpdate(explanation, plan)) {
     return [];
   }
 
@@ -1040,7 +1692,6 @@ function planUpdateNotifications(state, argumentsObject) {
     turnId: state.activeTurnId,
     plan,
   };
-  const explanation = readString(argumentsObject.explanation);
   if (explanation) {
     params.explanation = explanation;
   }
@@ -1125,9 +1776,8 @@ function genericToolActivityMessage(toolName) {
   }
 }
 
-function shouldMirrorAgentMessage(payload) {
-  const phase = readString(payload?.phase).toLowerCase();
-  return phase !== "commentary";
+function genericToolCompletionMessage(toolName) {
+  return `Completed ${readString(toolName)}`;
 }
 
 function createNotification(method, params = {}) {
@@ -1151,13 +1801,29 @@ function flushPendingUserMessageNotifications(state, turnId) {
     return [];
   }
 
-  return messages.map((pending) => createNotification("codex/event/user_message", {
-    threadId: state.threadId,
-    turnId: turnId || state.activeTurnId || "",
-    message: pending.message,
-    ...(pending.id ? { id: pending.id } : {}),
-    ...timestampParams(pending.timestamp),
-  }));
+  const resolvedTurnId = readString(turnId) || readString(state.activeTurnId);
+  return messages
+    .map((pending) => ({ ...pending, message: visibleUserPromptFromInputEntries(pending.message) }))
+    .filter((pending) => pending.message)
+    .filter((pending) => {
+      const dedupeKey = userMessageOccurrenceKey(state, resolvedTurnId, pending.message, {
+        isResponseItem: pending.isResponseItem === true,
+      });
+      if (state.emittedUserMessageKeys.has(dedupeKey)) {
+        return false;
+      }
+      state.emittedUserMessageKeys.add(dedupeKey);
+      return true;
+    })
+    .map((pending) => createNotification("codex/event/user_message", {
+      threadId: state.threadId,
+      // An empty turnId reads as "no turn identity" on the phone and blocks
+      // dedup against the turn-bound row of the same prompt; omit it instead.
+      ...(resolvedTurnId ? { turnId: resolvedTurnId } : {}),
+      message: pending.message,
+      ...(pending.id ? { id: pending.id } : {}),
+      ...timestampParams(pending.timestamp),
+    }));
 }
 
 function readUserMessageTimestamp(entry, payload = {}) {
@@ -1187,11 +1853,36 @@ function buildSyntheticTurnId(state, entry) {
   return `rollout-turn:${state.threadId}:${timestamp}`;
 }
 
-function resolveRolloutEventTurnId(state, payload = {}) {
+function resolveRolloutEventTurnId(state, payload = {}, { allowSyntheticPromotion = true } = {}) {
+  const explicitTurnId = readString(payload.turn_id) || readString(payload.turnId);
   if (state.activeTurnIdIsSynthetic && state.activeTurnId) {
+    if (explicitTurnId) {
+      // Terminal events must not promote: with parallel turns, a sibling's
+      // terminal explicit id would hijack the synthetic run and wipe it. The
+      // active run's real id is adopted from its own non-terminal events.
+      if (allowSyntheticPromotion) {
+        promoteSyntheticTurnId(state, explicitTurnId);
+      }
+      return explicitTurnId;
+    }
     return state.activeTurnId;
   }
-  return readString(payload.turn_id) || readString(payload.turnId) || state.activeTurnId || "";
+  return explicitTurnId || state.activeTurnId || "";
+}
+
+function promoteSyntheticTurnId(state, explicitTurnId) {
+  const oldTurnId = state.activeTurnId;
+  if (!oldTurnId || oldTurnId === explicitTurnId) {
+    state.activeTurnId = explicitTurnId;
+    state.activeTurnIdIsSynthetic = false;
+    return;
+  }
+
+  state.activeTurnId = explicitTurnId;
+  state.activeTurnIdIsSynthetic = false;
+  if (state.reasoningItemId === buildSyntheticItemId("thinking", state.threadId, oldTurnId)) {
+    state.reasoningItemId = buildSyntheticItemId("thinking", state.threadId, explicitTurnId);
+  }
 }
 
 function buildAgentMessageItemId(threadId, turnId, entry, message) {
@@ -1209,6 +1900,15 @@ function buildAgentMessageItemId(threadId, turnId, entry, message) {
   );
 }
 
+// Keyed on turn + text only: the same assistant text often arrives twice per
+// turn (event_msg agent_message and response_item message), and only one side
+// carries `phase`, so phase must stay out of the key for them to collide.
+// Legitimately repeated identical prose in one turn is rare and the phone's
+// item-scoped dedup covers the remainder.
+function agentMessageDedupeKey(turnId, message) {
+  return buildRemodexSourceItemKey(turnId, message);
+}
+
 function generatedImagePathForRolloutItem(threadId, callId) {
   const resolvedThreadId = readString(threadId);
   const resolvedCallId = readString(callId);
@@ -1227,11 +1927,27 @@ function resetRunState(state) {
   state.activeTurnId = null;
   state.reasoningItemId = null;
   state.hasThinking = false;
+  state.hasReasoningContent = false;
+  state.emittedReasoningSummaryKeys.clear();
   state.commandCalls.clear();
   state.applyPatchCalls.clear();
   state.emittedPatchApplyEndCalls.clear();
+  state.emittedAgentMessageKeys.clear();
+  state.agentMessageOccurrencesByBaseKey.clear();
+  state.pendingEventAgentMessageOccurrencesByBaseKey.clear();
+  state.emittedUserMessageKeys.clear();
+  state.userMessageOccurrencesByBaseKey.clear();
+  state.pendingEventUserMessageOccurrencesByBaseKey.clear();
+  state.pendingResponseItemUserMessageOccurrencesByBaseKey.clear();
   state.pendingUserMessages.length = 0;
+  state.pendingSyntheticTerminalTurnId = null;
+  state.pendingSyntheticTerminalStartedAt = 0;
+  state.pendingSyntheticTerminalStatus = "";
+  state.pendingSyntheticTerminalErrorMessage = "";
   state.activeTurnIdIsSynthetic = false;
+  state.suppressLiveActivityUntilGrowth = false;
+  state.awaitingCoherentBoundary = false;
+  state.awaitingBoundaryPreludeLine = "";
 }
 
 function readThreadId(params) {
@@ -1241,10 +1957,6 @@ function readThreadId(params) {
   ]) || "";
 }
 
-function readFileSize(filePath, fsModule) {
-  return fsModule.statSync(filePath).size;
-}
-
 function readFileSlice(filePath, start, endExclusive, fsModule) {
   const length = Math.max(0, endExclusive - start);
   if (length === 0) {