@makerbi/remodex 2.3.2 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makerbi/remodex",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
   "repository": {
     "type": "git",

package/src/bridge.js

@@ -55,6 +55,7 @@ const { createBridgeSecureTransport } = require("./secure-transport");
 const { createRolloutLiveMirrorController } = require("./rollout-live-mirror");
 const {
   isContextualUserText,
+  isThreadTurnStateProbeRequest,
   isUserRoleItem,
   readUserItemText,
   sanitizeUserRoleItem,
@@ -577,6 +578,33 @@ function threadTurnsListHandoffDescriptor(cursor) {
   return { anchorTurnId, token };
 }
 
+// The bounded canonical page can read a busy mirrored run as closed for a
+// beat, which used to flap the phone's running state. When the rollout mirror
+// is actively tailing a real turn, ride its id along on the turn-state probe
+// as an advisory field; history pages stay untouched.
+function annotateTurnStateProbeWithMirrorActiveTurn(request, response, getMirrorActiveTurnId) {
+  if (!isThreadTurnStateProbeRequest(request)) {
+    return response;
+  }
+  const params = request?.params || {};
+  const threadId = normalizeNonEmptyString(params.threadId)
+    || normalizeNonEmptyString(params.thread_id);
+  const mirrorActiveTurnId = threadId ? getMirrorActiveTurnId?.(threadId) : null;
+  const result = response?.result;
+  if (!mirrorActiveTurnId || !result || typeof result !== "object" || Array.isArray(result)) {
+    return response;
+  }
+  // Page responses can come from the fast-page cache: never mutate a shared
+  // object, or the annotation would outlive the mirror on later replays.
+  return {
+    ...response,
+    result: {
+      ...result,
+      remodexMirrorActiveTurnId: mirrorActiveTurnId,
+    },
+  };
+}
+
 function canonicalThreadTurnsListRequest(request) {
   const params = { ...(request?.params || {}) };
   delete params.remodexRequireCanonical;
@@ -1433,6 +1461,11 @@ function startBridge({
   function sendBridgeManagedThreadTurnsListResponse(request, response, sendResponse, {
     skipJsonlArtifactAugmentation = false,
   } = {}) {
+    response = annotateTurnStateProbeWithMirrorActiveTurn(
+      request,
+      response,
+      (threadId) => rolloutLiveMirror?.getActiveTurnId(threadId) || null
+    );
     const finalSanitizeContext = buildThreadTurnsListRelaySanitizeContext(request, {
       skipJsonlArtifactAugmentation,
     });
@@ -5109,6 +5142,7 @@ function shouldSuppressRolloutMirrorForThread(
 }
 
 module.exports = {
+  annotateTurnStateProbeWithMirrorActiveTurn,
   buildThreadTurnsListRelaySanitizeContext,
   buildHeartbeatBridgeStatus,
   buildRelayAccessTokenHeaders,

package/src/desktop-ipc-action-follower.js

@@ -19,6 +19,7 @@ const {
   FRAME_HEADER_BYTES,
   MAX_FRAME_BYTES,
   cloneJSON,
+  isThreadTurnStateProbeRequest,
   normalizeToken,
   readString,
   requestIdKey,
@@ -36,7 +37,6 @@ const MAX_BASELINE_RECOVERY_ATTEMPTS = 5;
 const BASELINE_RECOVERY_BASE_DELAY_MS = 1_000;
 const BASELINE_RECOVERY_MAX_DELAY_MS = 15_000;
 const MAX_QUEUED_CHANGES_PER_THREAD = 300;
-const BACKGROUND_DISCONNECT_GRACE_MS = 30_000;
 // Phone interest survives per-thread release by design, so cap the set to keep a
 // marathon single Desktop connection from accumulating every thread id forever.
 const MAX_ACTIVE_THREAD_IDS = 512;
@@ -53,12 +53,13 @@ const DESKTOP_STATE_READ_METHODS = new Set([
 // cannot discover runs that started on the Mac.
 const DESKTOP_BACKGROUND_DISCOVERY_METHODS = new Set(["thread/list"]);
 const DESKTOP_TURNS_CURSOR_PREFIX = "remodex-desktop-turns:";
-// A cached Desktop state that claims an active turn is only trustworthy while
-// Desktop keeps streaming updates for it. Live runs broadcast deltas far more
-// often than this window; a silent "active" cache is a stale reconnect echo
-// (e.g. Desktop never saw the turn finish) and must not answer phone reads, or
-// the phone shows a phantom running indicator until real history loads.
+// Per-thread activity can be quiet during tools and subagents, so the short
+// freshness window alone does not revoke a healthy Desktop owner.
 const STALE_ACTIVE_READ_MAX_AGE_MS = 20_000;
+// An open Unix socket is not unlimited proof of a functioning publisher. If no
+// frame arrives for this generous lease, yield stale active reads so canonical
+// or rollout recovery can clear a phantom run.
+const CONNECTED_IPC_ACTIVITY_LEASE_MS = 5 * 60_000;
 const MAX_NORMALIZED_REVIEW_FINGERPRINTS_PER_THREAD = 128;
 const DESKTOP_FOLLOWER_REQUEST_METHODS = new Set([
   "turn/start",
@@ -229,7 +230,6 @@ function createDesktopIpcActionFollower({
   onNormalizedHistoryIndexRebuilt = () => {},
   requestTimeoutMs = REQUEST_TIMEOUT_MS,
   ownershipProbeTimeoutMs = OWNERSHIP_PROBE_TIMEOUT_MS,
-  backgroundDisconnectGraceMs = BACKGROUND_DISCONNECT_GRACE_MS,
 } = {}) {
   const ipc = createDesktopIpcClient({
     socketPath,
@@ -268,7 +268,6 @@ function createDesktopIpcActionFollower({
   // baseline. Otherwise a disconnect/eviction can erase the only evidence
   // needed to send the matching completion and leave a phantom running badge.
   const announcedBackgroundTurnsByThreadId = new Map();
-  const backgroundDisconnectTimersByThreadId = new Map();
   // JS Set preserves insertion order; delete-before-add refreshes recency, and
   // cap eviction skips threads with pending prompts so approvals are not lost.
   function rememberActiveThread(threadId) {
@@ -364,7 +363,6 @@ function createDesktopIpcActionFollower({
         } else {
           settleAnnouncedBackgroundTurn(threadId, "interrupted");
         }
-        clearBackgroundDisconnectTimer(threadId);
         announcedBackgroundTurnsByThreadId.delete(threadId);
         if (rawState) {
           const liveState = boundedDesktopLiveStateForThread(threadId, rawState);
@@ -500,10 +498,6 @@ function createDesktopIpcActionFollower({
     activeThreadIds.clear();
     backgroundOnlyThreadIds.clear();
     announcedBackgroundTurnsByThreadId.clear();
-    for (const timer of backgroundDisconnectTimersByThreadId.values()) {
-      clearTimeout(timer);
-    }
-    backgroundDisconnectTimersByThreadId.clear();
     recoveringThreadIds.clear();
     baselineRecoveryStateByThreadId.clear();
     queuedChangesByThreadId.clear();
@@ -546,9 +540,6 @@ function createDesktopIpcActionFollower({
     if (!threadId) {
       return;
     }
-    if (isSnapshotChange(params.change)) {
-      clearBackgroundDisconnectTimer(threadId);
-    }
     const peerOwnershipSnapshot = isPeerOwnershipSnapshot(params);
     if (peerOwnershipSnapshot && !isLocallyOwnedThread(threadId)) {
       liveOwnerThreadIds.delete(threadId);
@@ -744,9 +735,9 @@ function createDesktopIpcActionFollower({
     queuedChangesByThreadId.clear();
     pendingOwnershipProbeTokensByThreadId.clear();
     desktopOwnedByProbeThreadIds.clear();
-    for (const threadId of announcedBackgroundTurnsByThreadId.keys()) {
-      scheduleBackgroundDisconnectSettlement(threadId);
-    }
+    // A lost IPC connection is not evidence that Desktop stopped the turn.
+    // Keep announced lifecycle state until a reconnect snapshot, archive, or
+    // another authoritative state transition supplies a real terminal status.
     // Keep activeThreadIds: phone interest is phone-scoped, not connection-scoped.
     // Clearing it here would make reconnect snapshots for a thread the phone is
     // still viewing fail the activeThreadIds.has() guard until the phone happens
@@ -1086,7 +1077,7 @@ function createDesktopIpcActionFollower({
       canonicalHistoryThreadIds.add(threadId);
     }
     if (canonicalHistoryThreadIds.has(threadId)) {
-      if (isDesktopLiveTurnStateSnapshotRequest(message)) {
+      if (isThreadTurnStateProbeRequest(message)) {
         const liveState = boundedDesktopLiveStateForThread(threadId, rawState);
         sendApplicationResponse(JSON.stringify({
           id: message.id,
@@ -1100,11 +1091,13 @@ function createDesktopIpcActionFollower({
       return ownsDesktopCursor ? rejectDesktopTurnsCursor(message) : false;
     }
     const thread = projectDesktopConversationStateToThread(threadId, rawState, { now });
-    // A run that Desktop stopped streaming updates for is not a live run: serving
-    // it from cache would answer thread-list refreshes with a phantom "running"
-    // turn until real history loads. Let the local app-server answer instead.
+    // While IPC remains connected, an explicitly active Desktop snapshot stays
+    // authoritative through quiet tools, reasoning, approvals, and subagents.
+    // Falling through to a second app-server here can replace a genuinely
+    // running turn with stale idle history and make the phone clear Stop.
     if (hasActiveProjectedTurn(thread)
       && isRawStateStaleForActiveRead(threadId)
+      && !hasResponsiveDesktopIpc()
       && !ownsDesktopCursor) {
       staleYieldedThreadIds.add(threadId);
       return false;
@@ -1139,21 +1132,6 @@ function createDesktopIpcActionFollower({
     return true;
   }
 
-  function isDesktopLiveTurnStateSnapshotRequest(message) {
-    if (readString(message?.method) !== "thread/turns/list"
-      || readString(message?.params?.cursor)
-      || message?.params?.remodexRequireCanonical === true) {
-      return false;
-    }
-    if (message?.params?.remodexTurnStateOnly === true) {
-      return true;
-    }
-    // Remodex iPhone 2.1 predates the explicit marker. Its running-state probe
-    // has this unique request shape; actual history pages use limits 1 and 5.
-    return Number(message?.params?.limit) === 8
-      && normalizeToken(readString(message?.params?.sortDirection) || "desc") === "desc";
-  }
-
   function buildDesktopLiveTurnStateResult(turns) {
     const data = (Array.isArray(turns) ? turns : [])
       .slice()
@@ -1215,6 +1193,10 @@ function createDesktopIpcActionFollower({
     return now() - updatedAt > STALE_ACTIVE_READ_MAX_AGE_MS;
   }
 
+  function hasResponsiveDesktopIpc() {
+    return ipc.hasRecentActivity(CONNECTED_IPC_ACTIVITY_LEASE_MS);
+  }
+
   function boundedDesktopLiveStateForThread(threadId, state) {
     return boundedDesktopLiveState(
       state,
@@ -1242,6 +1224,8 @@ function createDesktopIpcActionFollower({
     const previousById = desktopLiveLifecycleByThreadId.get(threadId) || new Map();
     const nextTurns = activeDesktopTurnDescriptors(liveState);
     const nextById = new Map(nextTurns.map((turn) => [turn.id, turn]));
+    const completedTurnIds = new Set();
+    const startedTurnIds = new Set();
     const {
       previousTurnIds: continuityPreviousTurnIds,
       nextTurnIds: continuityNextTurnIds,
@@ -1266,6 +1250,7 @@ function createDesktopIpcActionFollower({
         threadId,
         { id: previous.id, status: terminalStatus }
       )));
+      completedTurnIds.add(previous.id);
     }
     for (const next of nextTurns) {
       if (previousById.has(next.id)) {
@@ -1281,7 +1266,52 @@ function createDesktopIpcActionFollower({
           ? notificationWithTurnIdentityContinuity(startedNotification)
           : startedNotification
       ));
+      startedTurnIds.add(next.id);
     }
+    reannounceRemainingParallelTurn(
+      threadId,
+      previousById,
+      nextTurns,
+      completedTurnIds,
+      startedTurnIds
+    );
+  }
+
+  // iOS tracks one phone-visible active turn per thread. If parallel turn B was
+  // the most recently announced turn and finishes while older A is still live,
+  // B's completion clears that slot. Re-announce A as continuity so Stop and
+  // running state stay attached to the existing run without advancing its
+  // generation. A newly started replacement already performs this handoff.
+  function reannounceRemainingParallelTurn(
+    threadId,
+    previousById,
+    nextTurns,
+    completedTurnIds,
+    startedTurnIds
+  ) {
+    const restorationTurnId = remainingParallelTurnRestorationId(
+      previousById,
+      nextTurns,
+      completedTurnIds
+    );
+    if (!restorationTurnId || startedTurnIds.has(restorationTurnId)) {
+      return;
+    }
+    const nextVisibleTurn = nextTurns.find((turn) => turn.id === restorationTurnId);
+    sendApplicationResponse(JSON.stringify(notificationWithTurnIdentityContinuity(
+      desktopLiveTurnLifecycleNotification("turn/started", threadId, nextVisibleTurn)
+    )));
+  }
+
+  function remainingParallelTurnRestorationId(previousById, nextTurns, completedTurnIds) {
+    const previousVisibleTurn = [...previousById.values()].at(-1);
+    if (!previousVisibleTurn || !completedTurnIds.has(previousVisibleTurn.id)) {
+      return "";
+    }
+    const nextVisibleTurn = nextTurns.at(-1);
+    return nextVisibleTurn && previousById.has(nextVisibleTurn.id)
+      ? nextVisibleTurn.id
+      : "";
   }
 
   function syncProjectedConversationState(threadId, nextState, { isFullSnapshot = false } = {}) {
@@ -1298,10 +1328,13 @@ function createDesktopIpcActionFollower({
       && !canonicalHistoryReplacementSentThreadIds.has(threadId)) {
       canonicalHistoryReplacementSentThreadIds.add(threadId);
       conversationProjector.remove(threadId);
-      // Seed the bounded live tail before asking the phone for canonical
-      // history. Subsequent 8-50ms Desktop patches then become small deltas
-      // instead of replaying hundreds of current-turn items as a baseline.
-      conversationProjector.seed(threadId, liveState);
+      // Project the bounded active tail before asking the phone for canonical
+      // history. On reconnect this snapshot may contain output produced while
+      // IPC was unavailable; silently seeding it would permanently eat that
+      // content when canonical JSONL/rollout history is still behind.
+      const bootstrapOutput = conversationProjector.project(threadId, liveState, {
+        includeAllActiveTurns: true,
+      });
       sendApplicationResponse(JSON.stringify({
         method: "thread/replaced",
         params: {
@@ -1316,6 +1349,11 @@ function createDesktopIpcActionFollower({
         normalizedLiveIndexesByThreadId.get(threadId)
       );
       emitDesktopSnapshotLifecycleTransition(threadId, liveState);
+      for (const notification of bootstrapOutput.notifications || []) {
+        if (readString(notification?.method).startsWith("item/")) {
+          sendApplicationResponse(JSON.stringify(notification));
+        }
+      }
       rememberDesktopLiveProjection(threadId, liveState);
       return;
     }
@@ -1361,16 +1399,39 @@ function createDesktopIpcActionFollower({
         },
       }));
     }
-    for (const notification of output.notifications || []) {
+    const outputNotifications = output.notifications || [];
+    const previousById = desktopLiveLifecycleByThreadId.get(threadId) || new Map();
+    const nextTurns = activeDesktopTurnDescriptors(liveState);
+    const completedTurnIds = new Set(outputNotifications
+      .filter((notification) => notification.method === "turn/completed")
+      .map((notification) => readString(notification.params?.turnId))
+      .filter(Boolean));
+    const startedTurnIds = new Set(outputNotifications
+      .filter((notification) => notification.method === "turn/started")
+      .map((notification) => readString(notification.params?.turnId))
+      .filter(Boolean));
+    const parallelRestorationTurnId = remainingParallelTurnRestorationId(
+      previousById,
+      nextTurns,
+      completedTurnIds
+    );
+    for (const notification of outputNotifications) {
+      const notificationTurnId = readString(notification.params?.turnId);
       const preservesTurnIdentity = notification.method === "turn/started"
-        && output.turnIdentityContinuityTurnIds?.includes(
-          readString(notification.params?.turnId)
-        );
+        && (parallelRestorationTurnId === notificationTurnId
+          || output.turnIdentityContinuityTurnIds?.includes(notificationTurnId));
       const projectedNotification = preservesTurnIdentity
         ? notificationWithTurnIdentityContinuity(notification)
         : notification;
       sendApplicationResponse(JSON.stringify(projectedNotification));
     }
+    reannounceRemainingParallelTurn(
+      threadId,
+      previousById,
+      nextTurns,
+      completedTurnIds,
+      startedTurnIds
+    );
     rememberDesktopLiveProjection(threadId, liveState);
   }
 
@@ -1470,14 +1531,12 @@ function createDesktopIpcActionFollower({
         nextActiveTurn
       )));
       announcedBackgroundTurnsByThreadId.set(threadId, nextActiveTurn);
-      clearBackgroundDisconnectTimer(threadId);
     }
   }
 
   function settleAnnouncedBackgroundTurn(threadId, status = "interrupted", turn = null) {
     const announcedTurn = announcedBackgroundTurnsByThreadId.get(threadId);
     if (!announcedTurn) {
-      clearBackgroundDisconnectTimer(threadId);
       return false;
     }
     const settledTurn = {
@@ -1492,36 +1551,9 @@ function createDesktopIpcActionFollower({
       settledTurn
     )));
     announcedBackgroundTurnsByThreadId.delete(threadId);
-    clearBackgroundDisconnectTimer(threadId);
     return true;
   }
 
-  function scheduleBackgroundDisconnectSettlement(threadId) {
-    if (!announcedBackgroundTurnsByThreadId.has(threadId)
-      || backgroundDisconnectTimersByThreadId.has(threadId)) {
-      return;
-    }
-    const expectedTurnId = announcedBackgroundTurnsByThreadId.get(threadId)?.id;
-    const timer = setTimeout(() => {
-      backgroundDisconnectTimersByThreadId.delete(threadId);
-      if (announcedBackgroundTurnsByThreadId.get(threadId)?.id !== expectedTurnId) {
-        return;
-      }
-      settleAnnouncedBackgroundTurn(threadId, "interrupted");
-    }, Math.max(0, backgroundDisconnectGraceMs));
-    timer.unref?.();
-    backgroundDisconnectTimersByThreadId.set(threadId, timer);
-  }
-
-  function clearBackgroundDisconnectTimer(threadId) {
-    const timer = backgroundDisconnectTimersByThreadId.get(threadId);
-    if (!timer) {
-      return;
-    }
-    clearTimeout(timer);
-    backgroundDisconnectTimersByThreadId.delete(threadId);
-  }
-
   function syncThreadArchiveBroadcast(envelope) {
     const params = envelope.params || {};
     const threadId = readString(params.conversationId) || readString(params.conversation_id);
@@ -1914,7 +1946,9 @@ function createDesktopIpcActionFollower({
         return false;
       }
       const thread = projectDesktopConversationStateToThread(normalizedThreadId, liveState, { now });
-      if (hasActiveProjectedTurn(thread) && isRawStateStaleForActiveRead(normalizedThreadId)) {
+      if (hasActiveProjectedTurn(thread)
+        && isRawStateStaleForActiveRead(normalizedThreadId)
+        && !hasResponsiveDesktopIpc()) {
         staleYieldedThreadIds.add(normalizedThreadId);
         return false;
       }
@@ -1945,7 +1979,7 @@ function createDesktopIpcActionFollower({
       if (hasActiveProjectedTurn(thread)) {
         const updatedAt = rawStateUpdatedAtByThreadId.get(normalizedThreadId) || 0;
         const hasNewerFallbackActivity = Number(fallbackActivityAt) > updatedAt;
-        return ipc.isConnected()
+        return hasResponsiveDesktopIpc()
           && (!isRawStateStaleForActiveRead(normalizedThreadId) || !hasNewerFallbackActivity);
       }
       return !isRawStateStaleForActiveRead(normalizedThreadId);
@@ -1967,6 +2001,7 @@ function createDesktopIpcClient({
   let socket = null;
   let clientId = "";
   let isConnecting = false;
+  let lastActivityAt = 0;
   let readBuffer = Buffer.alloc(0);
   const pendingRequests = new Map();
   const pendingDiscoveries = new Map();
@@ -2078,6 +2113,9 @@ function createDesktopIpcClient({
   }
 
   function handleData(chunk) {
+    if (chunk.length > 0) {
+      lastActivityAt = now();
+    }
     readBuffer = Buffer.concat([readBuffer, chunk]);
     while (readBuffer.length >= FRAME_HEADER_BYTES) {
       const frameLength = readBuffer.readUInt32LE(0);
@@ -2153,6 +2191,7 @@ function createDesktopIpcClient({
     socket = null;
     clientId = "";
     isConnecting = false;
+    lastActivityAt = 0;
     readBuffer = Buffer.alloc(0);
     for (const waiter of pendingRequests.values()) {
       clearTimeout(waiter.timeout);
@@ -2191,6 +2230,11 @@ function createDesktopIpcClient({
     isConnected() {
       return Boolean(socket && !socket.destroyed && clientId);
     },
+    hasRecentActivity(maxAgeMs) {
+      return Boolean(socket && !socket.destroyed && clientId)
+        && lastActivityAt > 0
+        && now() - lastActivityAt <= Math.max(0, Number(maxAgeMs) || 0);
+    },
     sendRequest,
     sendDiscoveryRequest,
     close,
@@ -2717,7 +2761,8 @@ function boundedDesktopLiveTurns(
   if (orderedTurns.length <= 1) {
     return normalizeBoundedTurnsForRuntime(
       orderedTurns.map((turn, index) => withStableProjectedTurnId(turn, index)),
-      state
+      state,
+      retainedTurnIds
     );
   }
 
@@ -2744,7 +2789,7 @@ function boundedDesktopLiveTurns(
   const selectedTurns = Array.from(selectedIndexes)
     .sort((left, right) => left - right)
     .map((index) => withStableProjectedTurnId(orderedTurns[index], index));
-  return normalizeBoundedTurnsForRuntime(selectedTurns, state);
+  return normalizeBoundedTurnsForRuntime(selectedTurns, state, retainedTurnIds);
 }
 
 function boundedIndexedDesktopLiveTurns(state, index, nowValue, retainedTurnIds) {
@@ -2791,7 +2836,7 @@ function boundedIndexedDesktopLiveTurns(state, index, nowValue, retainedTurnIds)
       return turnIdOf(turn) ? turn : { ...turn, id: entry.id };
     })
     .filter(Boolean);
-  return normalizeBoundedTurnsForRuntime(selectedTurns, state);
+  return normalizeBoundedTurnsForRuntime(selectedTurns, state, retainedTurnIds);
 }
 
 function resolveIndexedTurn(state, entry) {
@@ -2868,12 +2913,12 @@ function notificationWithTurnIdentityContinuity(notification) {
   };
 }
 
-function normalizeBoundedTurnsForRuntime(turns, state) {
+function normalizeBoundedTurnsForRuntime(turns, state, retainedTurnIds = new Set()) {
   if (!isExplicitlyIdleDesktopRuntime(state)) {
     return turns;
   }
   return turns.map((turn) => (
-    isActiveRawTurn(turn)
+    isActiveRawTurn(turn) && !retainedTurnIds.has(turnIdOf(turn))
       ? { ...turn, status: "completed" }
       : turn
   ));

package/src/desktop-ipc-shared.js

@@ -63,8 +63,10 @@ const LEGACY_CONTEXT_WARNING_PREFIXES = [
 const LEGACY_APPLY_PATCH_WARNING_PREFIX = "Warning: apply_patch was requested via ";
 const LEGACY_APPLY_PATCH_WARNING_SUFFIX = "Use the apply_patch tool instead of exec_command.";
 const AGENTS_INSTRUCTIONS_PREFIX = "# AGENTS.md instructions";
-const INTERNAL_CONTEXT_PATTERN = /^<codex_internal_context\s+source=(?:"[a-z][a-z0-9_]*"|'[a-z][a-z0-9_]*')>[\s\S]*<\/codex_internal_context>$/;
-const EXTERNAL_CONTEXT_PATTERN = /^<external_([a-z0-9_-]+)>[\s\S]*<\/external_\1>$/;
+const AGENTS_INSTRUCTIONS_BEGIN = "<instructions>";
+const AGENTS_INSTRUCTIONS_END = "</instructions>";
+const INTERNAL_CONTEXT_PREFIX_PATTERN = /^<codex_internal_context\s+source=(?:"[a-z][a-z0-9_]*"|'[a-z][a-z0-9_]*')>[\s\S]*?<\/codex_internal_context>/;
+const EXTERNAL_CONTEXT_PREFIX_PATTERN = /^<external_([a-z0-9_-]+)>[\s\S]*?<\/external_\1>/;
 const PROMPT_REQUEST_BEGIN = "## My request for Codex:";
 const REVIEW_PROMPT_PREFIX = "## Code review guidelines:";
 
@@ -91,38 +93,116 @@ function stripImagePlaceholders(text) {
   return IMAGE_PLACEHOLDER_TOKEN.test(withoutPairs.trim()) ? "" : withoutPairs;
 }
 
-function isContextualUserText(text) {
-  const raw = typeof text === "string" ? text : "";
-  const trimmed = stripImagePlaceholders(raw).trim();
-  if (!trimmed) {
-    return false;
+// Review envelopes contain a real request after the delimiter and are never
+// wholly contextual, even when that request itself contains reserved markup.
+function isReviewEnvelopeText(trimmed) {
+  return trimmed.startsWith(REVIEW_PROMPT_PREFIX) && trimmed.includes(PROMPT_REQUEST_BEGIN);
+}
+
+// Consumes one runtime-owned fragment anchored at the start of `text` and
+// returns what follows it, or null when the text does not open with one.
+// Codex packs several fragments into a single user item, so the opening and
+// closing markers routinely belong to different fragments (a desktop opener
+// reads "<recommended_plugins>...</recommended_plugins>" + AGENTS.md
+// instructions + "<environment_context>...</environment_context>"). Matching
+// the blob as a whole classifies that item as visible and turns the entire
+// injected preamble into the thread's first user bubble.
+function consumeLeadingContextFragment(text) {
+  const lower = text.toLowerCase();
+
+  for (const [start, end] of CONTEXT_MARKER_PAIRS) {
+    if (!lower.startsWith(start)) {
+      continue;
+    }
+    const closeIndex = lower.indexOf(end, start.length);
+    // An unterminated marker is not a fragment we can bound. Leave it visible
+    // rather than swallow a message that merely opens with reserved markup.
+    return closeIndex === -1 ? null : text.slice(closeIndex + end.length);
   }
-  // Review envelopes contain a real request after the delimiter and are never
-  // wholly contextual, even when that request itself contains reserved markup.
-  if (trimmed.startsWith(REVIEW_PROMPT_PREFIX) && trimmed.includes(PROMPT_REQUEST_BEGIN)) {
-    return false;
+
+  const internal = INTERNAL_CONTEXT_PREFIX_PATTERN.exec(text);
+  if (internal) {
+    return text.slice(internal[0].length);
   }
-  const normalized = trimmed.toLowerCase();
-  if (normalized.startsWith(AGENTS_INSTRUCTIONS_PREFIX.toLowerCase())) {
-    // Runtime context can concatenate AGENTS.md with any registered hidden
-    // fragment. Only classify the whole item as hidden when its final fragment
-    // is also runtime-owned; a following real user request must stay visible.
-    return normalized.endsWith("</instructions>")
-      || CONTEXT_MARKER_PAIRS.some(([, end]) => normalized.endsWith(end));
-  }
-  if (CONTEXT_MARKER_PAIRS.some(([start, end]) => (
-    normalized.startsWith(start) && normalized.endsWith(end)
-  ))) {
-    return true;
+  const external = EXTERNAL_CONTEXT_PREFIX_PATTERN.exec(text);
+  if (external) {
+    return text.slice(external[0].length);
   }
-  if (INTERNAL_CONTEXT_PATTERN.test(trimmed) || EXTERNAL_CONTEXT_PATTERN.test(trimmed)) {
-    return true;
+
+  if (lower.startsWith(AGENTS_INSTRUCTIONS_PREFIX.toLowerCase())) {
+    return consumeAgentsInstructionsFragment(text, lower);
   }
-  if (LEGACY_CONTEXT_WARNING_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
-    return true;
+
+  // Unlike the marked fragments above, runtime warnings carry no closing marker
+  // and trail free-form runtime lines ("Shell cwd was reset to ..."), so there is
+  // no boundary to peel at. They are emitted as whole items that never contain a
+  // user request, hence consuming the remainder rather than bounding it.
+  if (LEGACY_CONTEXT_WARNING_PREFIXES.some((prefix) => text.startsWith(prefix))) {
+    return "";
+  }
+  return text.startsWith(LEGACY_APPLY_PATCH_WARNING_PREFIX)
+    && text.endsWith(LEGACY_APPLY_PATCH_WARNING_SUFFIX)
+    ? ""
+    : null;
+}
+
+function consumeAgentsInstructionsFragment(text, lower) {
+  const closeIndex = lower.indexOf(AGENTS_INSTRUCTIONS_END);
+  if (closeIndex >= 0) {
+    return consumeChainedInstructionsBlocks(text.slice(closeIndex + AGENTS_INSTRUCTIONS_END.length));
+  }
+  // Older runtimes emit the AGENTS.md body unwrapped and then append another
+  // registered fragment; that next marker is the only reliable boundary.
+  const nextMarkerIndex = CONTEXT_MARKER_PAIRS
+    .map(([start]) => lower.indexOf(start, 1))
+    .filter((index) => index > 0)
+    .sort((left, right) => left - right)[0];
+  return nextMarkerIndex === undefined ? null : text.slice(nextMarkerIndex);
+}
+
+// A single "# AGENTS.md instructions" header can carry one <INSTRUCTIONS> block
+// per nested AGENTS.md file. Stopping at the first close would leave the rest of
+// the preamble in front of the real request, where no registered marker matches
+// and the peeler gives up, turning the leftover into the first user bubble.
+function consumeChainedInstructionsBlocks(text) {
+  let rest = text;
+  for (;;) {
+    const trimmed = rest.trimStart();
+    const lower = trimmed.toLowerCase();
+    if (!lower.startsWith(AGENTS_INSTRUCTIONS_BEGIN)) {
+      return rest;
+    }
+    const closeIndex = lower.indexOf(AGENTS_INSTRUCTIONS_END, AGENTS_INSTRUCTIONS_BEGIN.length);
+    // Unterminated: same rule as everywhere else, leave it visible rather than
+    // guess where the injected block ends.
+    if (closeIndex === -1) {
+      return rest;
+    }
+    rest = trimmed.slice(closeIndex + AGENTS_INSTRUCTIONS_END.length);
+  }
+}
+
+// Peels every injected fragment off the front of an already trimmed message and
+// returns the text the user actually typed (empty when nothing else remains).
+function stripLeadingContextFragments(trimmed) {
+  let rest = trimmed;
+  while (rest) {
+    const remainder = consumeLeadingContextFragment(rest);
+    if (remainder === null) {
+      break;
+    }
+    rest = remainder.trim();
+  }
+  return rest;
+}
+
+function isContextualUserText(text) {
+  const raw = typeof text === "string" ? text : "";
+  const trimmed = stripImagePlaceholders(raw).trim();
+  if (!trimmed || isReviewEnvelopeText(trimmed)) {
+    return false;
   }
-  return trimmed.startsWith(LEGACY_APPLY_PATCH_WARNING_PREFIX)
-    && trimmed.endsWith(LEGACY_APPLY_PATCH_WARNING_SUFFIX);
+  return stripLeadingContextFragments(trimmed) === "";
 }
 
 function decodeXmlText(text) {
@@ -173,14 +253,25 @@ function visibleUserPromptText(text) {
     return "";
   }
   const cleaned = stripImagePlaceholders(text);
-  // Context bodies can contain the request delimiter as ordinary text. Classify
-  // the complete fragment first so the delimiter cannot reveal hidden content.
-  if (isContextualUserText(cleaned)) {
+  const trimmed = cleaned.trim();
+  if (!trimmed) {
     return "";
   }
-  const requestIndex = cleaned.lastIndexOf(PROMPT_REQUEST_BEGIN);
+  // Context bodies can contain the request delimiter as ordinary text. Peel the
+  // injected fragments off first so the delimiter cannot reveal hidden content,
+  // and so a real request that trails them survives instead of the whole blob.
+  const stripped = isReviewEnvelopeText(trimmed)
+    ? trimmed
+    : stripLeadingContextFragments(trimmed);
+  if (!stripped) {
+    return "";
+  }
+  // Untouched prompts keep their original spacing so callers can still detect
+  // "nothing changed" by identity and skip cloning the item.
+  const body = stripped === trimmed ? cleaned : stripped;
+  const requestIndex = body.lastIndexOf(PROMPT_REQUEST_BEGIN);
   if (requestIndex >= 0) {
-    const request = cleaned.slice(requestIndex + PROMPT_REQUEST_BEGIN.length).trim();
+    const request = body.slice(requestIndex + PROMPT_REQUEST_BEGIN.length).trim();
     // A few IDE/review exports end with the delimiter but omit its request
     // suffix. They still contain a real visible prompt before that marker;
     // returning an empty string made live mirroring erase the opener while
@@ -191,14 +282,14 @@ function visibleUserPromptText(text) {
     if (request) {
       return request;
     }
-    const body = cleaned.slice(0, requestIndex).trimEnd();
-    return isContextualUserText(body) ? "" : body;
+    const precedingBody = body.slice(0, requestIndex).trimEnd();
+    return isContextualUserText(precedingBody) ? "" : precedingBody;
   }
-  const envelopeText = extractVisibleRuntimeEnvelope(cleaned);
+  const envelopeText = extractVisibleRuntimeEnvelope(body);
   if (envelopeText != null) {
     return envelopeText;
   }
-  return cleaned;
+  return body;
 }
 
 // Sanitizes text fragments independently so a hidden fragment cannot cause a
@@ -327,6 +418,24 @@ function normalizeToken(value) {
     : "";
 }
 
+// The phone's running-state probe, as opposed to a history page: the explicit
+// marker on current clients, or the probe's unique legacy shape (Remodex iPhone
+// 2.1 predates the marker, and real history pages use limits 1 and 5). Every
+// live source answers this request, so they must all recognize it identically.
+function isThreadTurnStateProbeRequest(message) {
+  const params = message?.params;
+  if (readString(message?.method) !== "thread/turns/list"
+    || readString(params?.cursor)
+    || params?.remodexRequireCanonical === true) {
+    return false;
+  }
+  if (params?.remodexTurnStateOnly === true) {
+    return true;
+  }
+  return Number(params?.limit) === 8
+    && normalizeToken(readString(params?.sortDirection) || "desc") === "desc";
+}
+
 function cloneJSON(value) {
   if (value == null) {
     return value;
@@ -456,6 +565,7 @@ module.exports = {
   hasVisiblePlanUpdate,
   isContextualUserText,
   isPlainJSONObject,
+  isThreadTurnStateProbeRequest,
   isUserRoleItem,
   normalizeToken,
   readString,

package/src/rollout-live-mirror.js

@@ -132,9 +132,17 @@ function createRolloutLiveMirrorController({
     mirrorsByThreadId.clear();
   }
 
+  // The real turn id this mirror is actively tailing, or null. Lets the bridge
+  // answer the phone's turn-state probe from mirror truth when the bounded
+  // canonical page reads a busy run as closed.
+  function getActiveTurnId(threadId) {
+    return mirrorsByThreadId.get(threadId)?.getActiveTurnId() || null;
+  }
+
   return {
     observeInbound,
     stopAll,
+    getActiveTurnId,
   };
 }
 
@@ -358,9 +366,30 @@ function createThreadRolloutLiveMirror({
     onStop();
   }
 
+  // Only a healthy, actively-tailed run with a real id counts: synthetic ids
+  // are not actionable app-server turn ids, and suppressed/awaiting states
+  // mean the mirror does not actually know what is running. While another live
+  // source owns the thread the tail keeps parsing with its emissions muted, so
+  // reporting that turn id would resurrect exactly the state the bridge muted.
+  function getActiveTurnId() {
+    if (
+      isStopped
+      || wasSuppressed
+      || state.isDesktopOrigin === false
+      || state.awaitingCoherentBoundary
+      || state.suppressLiveActivityUntilGrowth
+      || state.activeTurnIdIsSynthetic
+      || state.pendingSyntheticTerminalTurnId
+    ) {
+      return null;
+    }
+    return state.activeTurnId || null;
+  }
+
   return {
     bump,
     stop,
+    getActiveTurnId,
   };
 }
 
@@ -401,12 +430,30 @@ function bootstrapFromExistingRollout({
     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;
   }
+  if (!bootstrapWindow.coherent) {
+    // The active run starts outside the bounded bootstrap window. Do not emit
+    // a plausible-looking tail: canonical history remains the baseline. But do
+    // not go dark either — a long busy run would stop mirroring tool activity
+    // until its next turn boundary. Attach to the run in place instead, so
+    // growth from here on keeps streaming live.
+    const attached = attachToActiveRunFromTruncatedTail({
+      contents: bootstrapWindow.alignedContents,
+      boundary: bootstrapWindow.boundary,
+      state,
+      rolloutPath,
+      fsModule,
+      sendApplicationResponse,
+      nowMs,
+      staleActiveRunMaxAgeMs,
+    });
+    if (!attached) {
+      state.awaitingCoherentBoundary = true;
+    }
+    return;
+  }
   const { tailStart, contents: bootstrapContents } = bootstrapWindow;
   let initialContents = bootstrapContents;
   if (!initialContents) {
@@ -532,7 +579,8 @@ function bootstrapFromExistingRollout({
 // 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.
+// work/memory bounded; a capped window without a coherent opener comes back
+// with `coherent: false` and must never be replayed as history.
 function readCoherentBootstrapWindow({ rolloutPath, fileSize, fsModule }) {
   const maxBytes = Math.min(fileSize, DEFAULT_BOOTSTRAP_MAX_BYTES);
   let windowBytes = Math.min(fileSize, DEFAULT_BOOTSTRAP_TAIL_BYTES);
@@ -549,10 +597,16 @@ function readCoherentBootstrapWindow({ rolloutPath, fileSize, fsModule }) {
     // 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 };
+      return { tailStart, contents, coherent: true };
     }
     if (windowBytes >= maxBytes || tailStart === 0) {
-      return null;
+      return {
+        tailStart,
+        contents,
+        coherent: false,
+        alignedContents,
+        boundary,
+      };
     }
 
     const nextWindowBytes = Math.min(maxBytes, windowBytes * 2);
@@ -584,12 +638,21 @@ function inspectBootstrapRunBoundary(contents) {
   // 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());
+  // Attach metadata for the incoherent-window case, so the caller never has to
+  // re-parse the (up to 64MB) window a second time.
+  let newestTaskStartedLineIndex = -1;
+  let lastEntryTimestamp = "";
+
+  const lines = contents.split("\n");
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const parsed = safeParseJSON(lines[lineIndex].trim());
     if (!parsed) {
       continue;
     }
+    const entryTimestamp = readString(parsed.timestamp);
+    if (entryTimestamp) {
+      lastEntryTimestamp = entryTimestamp;
+    }
     const taskEventType = parsed?.type === "event_msg"
       ? readString(parsed?.payload?.type)
       : "";
@@ -611,6 +674,7 @@ function inspectBootstrapRunBoundary(contents) {
       hasOpeningUser = pendingUserBeforeStart;
       hasTurnOutputSinceStart = false;
       pendingUserBeforeStart = false;
+      newestTaskStartedLineIndex = lineIndex;
       continue;
     }
     if (!activeTurnId) {
@@ -653,6 +717,8 @@ function inspectBootstrapRunBoundary(contents) {
   return {
     hasActiveRun: Boolean(activeTurnId) || unboundedActivitySinceTerminal,
     hasOpeningUser,
+    newestTaskStartedLineIndex,
+    lastEntryTimestamp,
   };
 }
 
@@ -667,6 +733,58 @@ function isBootstrapNeutralRecord(entry, taskEventType = "") {
     || taskEventType === "context_updated";
 }
 
+// Attaches mid-run when the active run's opener is beyond the bounded window:
+// nothing already in the tail is emitted (it stays canonical-history
+// territory), but run state is hydrated so subsequent growth mirrors live.
+// Returns false when the tail proves the visible runs all closed — trailing
+// bytes then belong to an unknown older boundary and stay suppressed.
+function attachToActiveRunFromTruncatedTail({
+  contents,
+  boundary,
+  state,
+  rolloutPath,
+  fsModule,
+  sendApplicationResponse,
+  nowMs,
+  staleActiveRunMaxAgeMs,
+}) {
+  const newestTaskStartedIndex = boundary?.newestTaskStartedLineIndex ?? -1;
+  if (newestTaskStartedIndex >= 0) {
+    // Hydrate through the shared reducer so parallel-turn and terminal
+    // semantics stay authoritative for what is still open at EOF.
+    processRolloutLines(contents.split("\n").slice(newestTaskStartedIndex), state, () => {});
+    if (!state.activeTurnId) {
+      return false;
+    }
+  } else {
+    // Mid-turn tail without its task_started: adopt a synthetic turn. The
+    // first non-terminal event carrying the real id promotes it, and a
+    // mismatched terminal closes it via the synthetic-terminal path.
+    state.activeTurnId = buildSyntheticTurnId(state, { timestamp: boundary?.lastEntryTimestamp || "" });
+    state.activeTurnIdIsSynthetic = true;
+    state.reasoningItemId = buildSyntheticItemId("thinking", state.threadId, state.activeTurnId);
+  }
+
+  if (isRolloutFileStale(rolloutPath, fsModule, nowMs, staleActiveRunMaxAgeMs)) {
+    // Same contract as the stale coherent bootstrap: stay silent until real
+    // growth proves the desktop process is alive again.
+    state.suppressLiveActivityUntilGrowth = true;
+    return true;
+  }
+
+  // A hydrated run that already carries a pending synthetic terminal is
+  // closing, not running: announcing it as live would just be followed by the
+  // tick's synthetic turn/completed one grace period later.
+  if (!state.pendingSyntheticTerminalTurnId) {
+    sendApplicationResponse(JSON.stringify(createNotification("turn/activity", {
+      threadId: state.threadId,
+      turnId: state.activeTurnId,
+      id: state.activeTurnId,
+    })));
+  }
+  return true;
+}
+
 // 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.
@@ -972,7 +1090,7 @@ function synthesizeNotificationsFromRolloutEntry(entry, state, { nowMs = Date.no
     return notifications;
   }
 
-  if (itemType === "functioncalloutput") {
+  if (itemType === "functioncalloutput" || itemType === "customtoolcalloutput") {
     notifications.push(...toolOutputNotifications(state, payload));
     return notifications;
   }
@@ -1336,6 +1454,16 @@ function customToolStartNotifications(state, payload) {
     return notifications;
   }
 
+  // Custom tool calls settle through custom_tool_call_output. Without tracking
+  // them the activity row never completes, so it lingers between command groups.
+  if (!isCommandToolName(toolName) && !state.applyPatchCalls.has(callId)) {
+    state.commandCalls.set(callId, {
+      toolName,
+      command: toolName,
+      cwd: readString(state.sessionMeta?.cwd) || "",
+    });
+  }
+
   return [
     ...notifications,
     createNotification("codex/event/background_event", {
@@ -1796,8 +1924,19 @@ function genericToolActivityMessage(toolName) {
   }
 }
 
+// Mirrors the wording of genericToolActivityMessage so the completion line
+// supersedes the start line instead of stacking a second row beside it.
 function genericToolCompletionMessage(toolName) {
-  return `Completed ${readString(toolName)}`;
+  switch (readString(toolName).toLowerCase()) {
+  case "apply_patch":
+    return "Applied patch";
+  case "write_stdin":
+    return "Wrote to terminal";
+  case "read_thread_terminal":
+    return "Read terminal output";
+  default:
+    return `Completed ${readString(toolName)}`;
+  }
 }
 
 function createNotification(method, params = {}) {

package/src/session-jsonl-history.js

@@ -10,6 +10,7 @@ const {
   isContextualUserText,
   isUserRoleItem,
   responseItemMessageText: sharedResponseItemMessageText,
+  sanitizeUserRoleItem,
   visibleUserPromptText,
 } = require("./desktop-ipc-shared");
 
@@ -862,7 +863,10 @@ function normalizeResponseItemForHistory(payload, lineNumber, { cwd = "", toolCa
     item.role = "assistant";
   }
 
-  return item;
+  // A single user item can carry injected context next to the real request.
+  // Sanitize here so history readers (including the thread/read JSONL merge,
+  // which runs after the relay sanitizer) never rebuild the hidden fragments.
+  return isUserRoleItem(item) ? sanitizeUserRoleItem(item) : item;
 }
 
 function applyHistoryAssistantSourceAlias(item, turnId, occurrencesByBaseKey = new Map()) {