@makerbi/remodex 2.3.2 → 2.5.6

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

@@ -15,15 +15,19 @@ const {
   projectDesktopConversationStateToThread,
 } = require("./desktop-ipc-conversation-projector");
 const {
+  CLIENT_STATUS_CHANGED,
   DESKTOP_IPC_METHOD_VERSIONS: METHOD_VERSION_BY_NAME,
-  FRAME_HEADER_BYTES,
-  MAX_FRAME_BYTES,
+  buildIpcRequestEnvelope,
   cloneJSON,
+  createFrameReader,
+  isThreadTurnStateProbeRequest,
   normalizeToken,
   readString,
   requestIdKey,
   resolveDefaultIpcSocketPath,
+  resolveIpcSocketPathCandidates,
   safeParseJSON,
+  toSocketPathCandidatesResolver,
   writeFrame,
 } = require("./desktop-ipc-shared");
 
@@ -36,12 +40,13 @@ 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;
 const DESKTOP_IPC_ACTION_SOURCE = "desktop-ipc-action-follower";
 const REMODEX_LIVE_OWNER_SOURCE = "desktop-ipc-live-owner";
+const THREAD_STREAM_FOLLOWING_CHANGED = "thread-stream-following-changed";
+const THREAD_STREAM_FOLLOWING_STATUS_REQUESTED = "thread-stream-following-status-requested";
 const DESKTOP_STATE_READ_METHODS = new Set([
   "thread/read",
   "thread/resume",
@@ -52,13 +57,20 @@ const DESKTOP_STATE_READ_METHODS = new Set([
 // this, a phone with no selected chat never connects to the Desktop bus and
 // cannot discover runs that started on the Mac.
 const DESKTOP_BACKGROUND_DISCOVERY_METHODS = new Set(["thread/list"]);
+// A run is announced to the phone exactly once, and the phone ignores buffered
+// replays of that announcement by design. An app session that starts after the
+// run did would otherwise never learn about it and show no sidebar badge until
+// the chat is opened. Sidebar refreshes re-announce still-active turns instead,
+// throttled per thread so steady polling costs one idempotent notification.
+const BACKGROUND_TURN_REANNOUNCE_MIN_INTERVAL_MS = 30_000;
 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",
@@ -220,16 +232,18 @@ function createDesktopIpcActionFollower({
   normalizeTurnStartParams = (params) => params,
   runtimeSettingsStore = null,
   logPrefix = "[remodex]",
-  socketPath = resolveDefaultIpcSocketPath(),
+  // Resolved per connect: Codex Desktop can start, stop, or move its bus while
+  // the bridge stays up.
+  socketPath = resolveIpcSocketPathCandidates,
   netModule = net,
   now = () => Date.now(),
   snapshotDebounceMs = 0,
   setTimeoutFn = setTimeout,
   clearTimeoutFn = clearTimeout,
   onNormalizedHistoryIndexRebuilt = () => {},
+  onFollowerStateChanged = null,
   requestTimeoutMs = REQUEST_TIMEOUT_MS,
   ownershipProbeTimeoutMs = OWNERSHIP_PROBE_TIMEOUT_MS,
-  backgroundDisconnectGraceMs = BACKGROUND_DISCONNECT_GRACE_MS,
 } = {}) {
   const ipc = createDesktopIpcClient({
     socketPath,
@@ -239,6 +253,7 @@ function createDesktopIpcActionFollower({
     logPrefix,
     onEnvelope,
     onConnected() {
+      announceDesktopFollowForActiveThreads();
       probeHeldFollowerRequests();
     },
     onDisconnect,
@@ -260,6 +275,8 @@ function createDesktopIpcActionFollower({
   const conversationProjector = createDesktopConversationProjector({ now });
   const pendingRoutesByRequestId = new Map();
   const activeThreadIds = new Set();
+  const desktopFollowThreadIds = new Set();
+  const followerClientIdsByThreadId = new Map();
   // Threads discovered from Litter snapshots before the phone reads them.
   // Their raw state is retained for lifecycle detection, but their transcript
   // stays off the relay until the user actually opens the chat.
@@ -268,7 +285,7 @@ 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();
+  const backgroundTurnReannouncedAtByThreadId = 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) {
@@ -284,6 +301,35 @@ function createDesktopIpcActionFollower({
     }
   }
 
+  function followDesktopThread(threadId, targetClientIds = undefined) {
+    if (!threadId || isLocallyOwnedThread(threadId) || liveOwnerThreadIds.has(threadId)) {
+      return false;
+    }
+    desktopFollowThreadIds.add(threadId);
+    return ipc.sendBroadcast(THREAD_STREAM_FOLLOWING_CHANGED, {
+      hostId: "local",
+      conversationId: threadId,
+      following: true,
+    }, { targetClientIds });
+  }
+
+  function unfollowDesktopThread(threadId) {
+    if (!desktopFollowThreadIds.delete(threadId)) {
+      return false;
+    }
+    return ipc.sendBroadcast(THREAD_STREAM_FOLLOWING_CHANGED, {
+      hostId: "local",
+      conversationId: threadId,
+      following: false,
+    });
+  }
+
+  function announceDesktopFollowForActiveThreads() {
+    for (const threadId of desktopFollowThreadIds) {
+      followDesktopThread(threadId);
+    }
+  }
+
   function oldestEvictableActiveThreadId() {
     for (const threadId of activeThreadIds) {
       if (!hasPendingProjectedActions(threadId)
@@ -308,6 +354,7 @@ function createDesktopIpcActionFollower({
   // without rejecting held requests (removeDesktopThreadState handles real removal).
   function forgetEvictedThreadState(threadId) {
     cancelPendingSnapshot(threadId);
+    unfollowDesktopThread(threadId);
     settleAnnouncedBackgroundTurn(threadId, "interrupted");
     backgroundOnlyThreadIds.delete(threadId);
     rawStatesByThreadId.delete(threadId);
@@ -347,6 +394,7 @@ function createDesktopIpcActionFollower({
     const method = readString(message?.method);
     if (DESKTOP_BACKGROUND_DISCOVERY_METHODS.has(method)) {
       ipc.ensureConnected();
+      reannounceActiveBackgroundTurns();
     }
     if (DESKTOP_STATE_READ_METHODS.has(method)) {
       const threadId = readThreadId(message?.params);
@@ -364,8 +412,8 @@ function createDesktopIpcActionFollower({
         } else {
           settleAnnouncedBackgroundTurn(threadId, "interrupted");
         }
-        clearBackgroundDisconnectTimer(threadId);
         announcedBackgroundTurnsByThreadId.delete(threadId);
+        backgroundTurnReannouncedAtByThreadId.delete(threadId);
         if (rawState) {
           const liveState = boundedDesktopLiveStateForThread(threadId, rawState);
           const hasCanonicalNormalizedHistory = canonicalHistoryThreadIds.has(threadId)
@@ -480,6 +528,7 @@ function createDesktopIpcActionFollower({
       ownershipProbeDeadlinesByThreadId.set(threadId, now() + ownershipProbeTimeoutMs);
     }
     ipc.ensureConnected();
+    followDesktopThread(threadId);
     return false;
   }
 
@@ -497,13 +546,15 @@ function createDesktopIpcActionFollower({
     normalizedReviewFingerprintsByThreadId.clear();
     conversationProjector.reset();
     pendingRoutesByRequestId.clear();
+    for (const threadId of desktopFollowThreadIds) {
+      unfollowDesktopThread(threadId);
+    }
+    desktopFollowThreadIds.clear();
     activeThreadIds.clear();
+    followerClientIdsByThreadId.clear();
     backgroundOnlyThreadIds.clear();
     announcedBackgroundTurnsByThreadId.clear();
-    for (const timer of backgroundDisconnectTimersByThreadId.values()) {
-      clearTimeout(timer);
-    }
-    backgroundDisconnectTimersByThreadId.clear();
+    backgroundTurnReannouncedAtByThreadId.clear();
     recoveringThreadIds.clear();
     baselineRecoveryStateByThreadId.clear();
     queuedChangesByThreadId.clear();
@@ -522,6 +573,25 @@ function createDesktopIpcActionFollower({
 
   // Desktop broadcasts carry the live conversation state Litter projects from.
   function onEnvelope(envelope) {
+    if (envelope?.type === "broadcast" && envelope.method === CLIENT_STATUS_CHANGED) {
+      if (normalizeToken(envelope.params?.status) === "disconnected") {
+        removeFollowerClient(envelope.params?.clientId || envelope.sourceClientId);
+      }
+      return;
+    }
+    if (envelope?.type === "broadcast" && envelope.method === THREAD_STREAM_FOLLOWING_CHANGED) {
+      updateFollowerState(envelope);
+      return;
+    }
+    if (envelope?.type === "broadcast"
+      && envelope.method === THREAD_STREAM_FOLLOWING_STATUS_REQUESTED) {
+      const params = envelope.params || {};
+      const threadId = readString(params.conversationId) || readString(params.conversation_id);
+      if (threadId && desktopFollowThreadIds.has(threadId)) {
+        followDesktopThread(threadId, [envelope.sourceClientId].filter(Boolean));
+      }
+      return;
+    }
     if (envelope?.type === "broadcast"
       && (envelope.method === "thread-archived" || envelope.method === "thread-unarchived")) {
       syncThreadArchiveBroadcast(envelope);
@@ -546,9 +616,6 @@ function createDesktopIpcActionFollower({
     if (!threadId) {
       return;
     }
-    if (isSnapshotChange(params.change)) {
-      clearBackgroundDisconnectTimer(threadId);
-    }
     const peerOwnershipSnapshot = isPeerOwnershipSnapshot(params);
     if (peerOwnershipSnapshot && !isLocallyOwnedThread(threadId)) {
       liveOwnerThreadIds.delete(threadId);
@@ -569,6 +636,14 @@ function createDesktopIpcActionFollower({
       backgroundOnlyThreadIds.add(threadId);
     }
     if (!activeThreadIds.has(threadId)) {
+      // After a bridge restart Desktop can re-announce that a renderer follows
+      // the thread without replaying its baseline snapshot. A request patch may
+      // then be the first state update we see. Preserve that blocking action
+      // immediately instead of waiting for a phone read that may never arrive
+      // while the already-open screen is parked on the question.
+      if (commitSpeculativeActionPatch(threadId, params.change, { backgroundOnly: true })) {
+        return;
+      }
       return;
     }
 
@@ -590,21 +665,11 @@ function createDesktopIpcActionFollower({
     const previousState = rawStatesByThreadId.get(threadId) || null;
     const nextState = applyConversationStateChange(previousState, params.change);
     if (!nextState) {
-      if (isPatchChange(params.change)) {
-        const emptyState = createEmptyConversationState();
-        const speculativeState = applyConversationStateChange(emptyState, params.change);
-        const speculativeActions = projectPendingDesktopActions(threadId, speculativeState);
-        if (speculativeActions.length > 0) {
-          rawStatesByThreadId.set(threadId, speculativeState);
-          rawStateUpdatedAtByThreadId.set(threadId, now());
-          if (!backgroundOnlyThreadIds.has(threadId)) {
-            conversationProjector.seed(threadId, speculativeState);
-          }
-          syncProjectedActions(threadId, speculativeActions);
-          releaseHeldFollowerRequests(threadId, { toDesktop: true });
-          return;
-        }
+      if (commitSpeculativeActionPatch(threadId, params.change)) {
+        return;
+      }
 
+      if (isPatchChange(params.change)) {
         if (typeof readConversationState !== "function") {
           return;
         }
@@ -626,6 +691,31 @@ function createDesktopIpcActionFollower({
     });
   }
 
+  function commitSpeculativeActionPatch(threadId, change, { backgroundOnly = false } = {}) {
+    if (!isPatchChange(change)) {
+      return false;
+    }
+
+    const speculativeState = applyConversationStateChange(createEmptyConversationState(), change);
+    const speculativeActions = projectPendingDesktopActions(threadId, speculativeState);
+    if (speculativeActions.length === 0) {
+      return false;
+    }
+
+    if (backgroundOnly) {
+      rememberActiveThread(threadId);
+      backgroundOnlyThreadIds.add(threadId);
+    }
+    rawStatesByThreadId.set(threadId, speculativeState);
+    rawStateUpdatedAtByThreadId.set(threadId, now());
+    if (!backgroundOnlyThreadIds.has(threadId)) {
+      conversationProjector.seed(threadId, speculativeState);
+    }
+    syncProjectedActions(threadId, speculativeActions);
+    releaseHeldFollowerRequests(threadId, { toDesktop: true });
+    return true;
+  }
+
   function schedulePendingSnapshot(threadId, state) {
     cancelPendingSnapshot(threadId);
     const timer = setTimeoutFn(() => {
@@ -744,9 +834,10 @@ function createDesktopIpcActionFollower({
     queuedChangesByThreadId.clear();
     pendingOwnershipProbeTokensByThreadId.clear();
     desktopOwnedByProbeThreadIds.clear();
-    for (const threadId of announcedBackgroundTurnsByThreadId.keys()) {
-      scheduleBackgroundDisconnectSettlement(threadId);
-    }
+    clearFollowerState();
+    // 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
@@ -759,6 +850,67 @@ function createDesktopIpcActionFollower({
     // a proven delivery failure falls back to the local app-server.
   }
 
+  // The same route-follow handshake is used whether Remodex's app-server owns
+  // the thread or Codex Desktop owns it. The live-owner component covers the
+  // former; this follower covers Desktop-owned threads so the navigation
+  // controller can stop retrying as soon as the renderer is actually mounted.
+  function updateFollowerState(envelope) {
+    const params = envelope?.params || {};
+    const threadId = readString(params.conversationId) || readString(params.conversation_id);
+    const clientId = readString(envelope?.sourceClientId);
+    if (!threadId
+      || !clientId
+      || clientId === ipc.clientId
+      || isLocallyOwnedThread(threadId)
+      || liveOwnerThreadIds.has(threadId)) {
+      return;
+    }
+
+    const followers = followerClientIdsByThreadId.get(threadId) || new Set();
+    if (params.following === true) {
+      rememberActiveThread(threadId);
+      followDesktopThread(threadId);
+      const wasUnfollowed = followers.size === 0;
+      followers.add(clientId);
+      followerClientIdsByThreadId.set(threadId, followers);
+      if (wasUnfollowed) {
+        onFollowerStateChanged?.(threadId, true);
+      }
+      return;
+    }
+
+    if (!followers.delete(clientId)) {
+      return;
+    }
+    if (followers.size === 0) {
+      followerClientIdsByThreadId.delete(threadId);
+      onFollowerStateChanged?.(threadId, false);
+    }
+  }
+
+  function removeFollowerClient(clientId) {
+    const normalizedClientId = readString(clientId);
+    if (!normalizedClientId) {
+      return;
+    }
+    for (const [threadId, followers] of followerClientIdsByThreadId) {
+      if (!followers.delete(normalizedClientId)) {
+        continue;
+      }
+      if (followers.size === 0) {
+        followerClientIdsByThreadId.delete(threadId);
+        onFollowerStateChanged?.(threadId, false);
+      }
+    }
+  }
+
+  function clearFollowerState() {
+    for (const threadId of followerClientIdsByThreadId.keys()) {
+      onFollowerStateChanged?.(threadId, false);
+    }
+    followerClientIdsByThreadId.clear();
+  }
+
   // The bridge's own live owner just claimed this thread's stream, so drop stale
   // Desktop state instead of hijacking future phone requests into Desktop IPC.
   function releaseDesktopThreadState(threadId) {
@@ -768,6 +920,7 @@ function createDesktopIpcActionFollower({
       activeThreadIds.delete(threadId);
     }
     liveOwnerThreadIds.add(threadId);
+    unfollowDesktopThread(threadId);
     ownershipProbeDeadlinesByThreadId.delete(threadId);
     pendingOwnershipProbeTokensByThreadId.delete(threadId);
     desktopOwnedByProbeThreadIds.delete(threadId);
@@ -798,6 +951,7 @@ function createDesktopIpcActionFollower({
       activeThreadIds.delete(threadId);
     }
     liveOwnerThreadIds.delete(threadId);
+    unfollowDesktopThread(threadId);
     ownershipProbeDeadlinesByThreadId.delete(threadId);
     pendingOwnershipProbeTokensByThreadId.delete(threadId);
     desktopOwnedByProbeThreadIds.delete(threadId);
@@ -1012,23 +1166,30 @@ function createDesktopIpcActionFollower({
   }
 
   function syncProjectedActions(threadId, actions) {
-    const nextRequestIds = new Set(actions.map((action) => action.id));
+    const nextRequestIds = new Set(actions.map((action) => requestIdKey(action.id)));
     for (const [requestId, route] of Array.from(pendingRoutesByRequestId.entries())) {
       if (route.threadId !== threadId || nextRequestIds.has(requestId)) {
         continue;
       }
 
       pendingRoutesByRequestId.delete(requestId);
-      sendApplicationResponse(JSON.stringify(projectedResolvedNotification(threadId, requestId)));
+      sendApplicationResponse(JSON.stringify(
+        projectedResolvedNotification(threadId, route.desktopRequestId)
+      ));
     }
 
     for (const action of actions) {
-      if (pendingRoutesByRequestId.has(action.id)) {
+      const requestId = requestIdKey(action.id);
+      if (!requestId || pendingRoutesByRequestId.has(requestId)) {
         continue;
       }
 
-      pendingRoutesByRequestId.set(action.id, {
-        requestId: action.id,
+      pendingRoutesByRequestId.set(requestId, {
+        requestId,
+        // Preserve the JSON-RPC id's original scalar type. Codex Desktop uses
+        // numeric ids for real requestUserInput calls, and its follower command
+        // must receive that same number rather than the phone-facing map key.
+        desktopRequestId: action.id,
         method: action.method,
         threadId,
       });
@@ -1086,7 +1247,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 +1261,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 +1302,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 +1363,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 +1394,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 +1420,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 +1436,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 +1498,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 +1519,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 +1569,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 +1701,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,34 +1721,34 @@ function createDesktopIpcActionFollower({
       settledTurn
     )));
     announcedBackgroundTurnsByThreadId.delete(threadId);
-    clearBackgroundDisconnectTimer(threadId);
+    backgroundTurnReannouncedAtByThreadId.delete(threadId);
     return true;
   }
 
-  function scheduleBackgroundDisconnectSettlement(threadId) {
-    if (!announcedBackgroundTurnsByThreadId.has(threadId)
-      || backgroundDisconnectTimersByThreadId.has(threadId)) {
+  // Re-sends the start of runs that are still in flight, so a phone that missed
+  // the original announcement (fresh app session, reconnect after the run began)
+  // gets its sidebar badge on the next sidebar refresh instead of only when the
+  // chat is opened. The phone treats a repeated start for the same turn as a
+  // no-op, and the identity marker keeps a phone that already saw it from
+  // treating this as a second run. Only worth doing while Desktop IPC is
+  // responsive: the matching completion arrives over the same link, so this
+  // cannot keep a phantom badge alive on its own.
+  function reannounceActiveBackgroundTurns() {
+    if (announcedBackgroundTurnsByThreadId.size === 0 || !hasResponsiveDesktopIpc()) {
       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;
+    const reannouncedAt = now();
+    for (const [threadId, announcedTurn] of announcedBackgroundTurnsByThreadId) {
+      const lastReannouncedAt = backgroundTurnReannouncedAtByThreadId.get(threadId) || 0;
+      if (reannouncedAt - lastReannouncedAt < BACKGROUND_TURN_REANNOUNCE_MIN_INTERVAL_MS) {
+        continue;
+      }
+      backgroundTurnReannouncedAtByThreadId.set(threadId, reannouncedAt);
+      sendApplicationResponse(JSON.stringify(notificationWithTurnIdentityContinuity(
+        backgroundTurnLifecycleNotification("turn/started", threadId, announcedTurn)
+      )));
     }
-    clearTimeout(timer);
-    backgroundDisconnectTimersByThreadId.delete(threadId);
   }
 
   function syncThreadArchiveBroadcast(envelope) {
@@ -1584,7 +1813,7 @@ function createDesktopIpcActionFollower({
       .then(() => {
         pendingRoutesByRequestId.delete(route.requestId);
         sendApplicationResponse(JSON.stringify(
-          projectedResolvedNotification(route.threadId, route.requestId)
+          projectedResolvedNotification(route.threadId, route.desktopRequestId)
         ));
       })
       .catch((error) => {
@@ -1914,7 +2143,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 +2176,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);
@@ -1964,20 +2195,37 @@ function createDesktopIpcClient({
   onConnected,
   onDisconnect,
 }) {
+  const resolveSocketPaths = toSocketPathCandidatesResolver(socketPath);
   let socket = null;
   let clientId = "";
   let isConnecting = false;
-  let readBuffer = Buffer.alloc(0);
+  let lastActivityAt = 0;
+  let remainingSocketPaths = [];
   const pendingRequests = new Map();
   const pendingDiscoveries = new Map();
+  const frameReader = createFrameReader({
+    onFrame: (envelope) => dispatchEnvelope(envelope),
+    onOverflow: () => close(),
+  });
 
   function ensureConnected() {
     if (socket || isConnecting) {
       return;
     }
 
+    remainingSocketPaths = resolveSocketPaths();
+    connectNextSocket();
+  }
+
+  function connectNextSocket() {
+    const nextSocketPath = remainingSocketPaths.shift();
+    if (!nextSocketPath) {
+      isConnecting = false;
+      return;
+    }
+
     isConnecting = true;
-    const nextSocket = netModule.createConnection(socketPath);
+    const nextSocket = netModule.createConnection(nextSocketPath);
     socket = nextSocket;
 
     nextSocket.on("connect", () => {
@@ -1993,14 +2241,29 @@ function createDesktopIpcClient({
         });
     });
     nextSocket.on("data", handleData);
-    nextSocket.on("close", handleClose);
+    nextSocket.on("close", () => handleClose(nextSocket));
     nextSocket.on("error", (error) => {
+      if ((error?.code === "ENOENT" || error?.code === "ECONNREFUSED")
+          && remainingSocketPaths.length > 0) {
+        retryNextSocket(nextSocket);
+        return;
+      }
       if (error?.code !== "ENOENT" && error?.code !== "ECONNREFUSED") {
         console.warn(`${logPrefix} desktop IPC connection failed: ${error.message}`);
       }
     });
   }
 
+  function retryNextSocket(failedSocket) {
+    if (socket === failedSocket) {
+      socket = null;
+    }
+    isConnecting = false;
+    frameReader.reset();
+    failedSocket.destroy();
+    connectNextSocket();
+  }
+
   function sendRequest(method, params) {
     ensureConnected();
     if (!socket || socket.destroyed) {
@@ -2008,14 +2271,13 @@ function createDesktopIpcClient({
     }
 
     const requestId = `remodex-${now().toString(36)}-${Math.random().toString(16).slice(2)}`;
-    const envelope = {
-      type: "request",
+    const envelope = buildIpcRequestEnvelope({
       requestId,
-      sourceClientId: method === "initialize" ? "initializing-client" : clientId || "remodex-bridge",
-      version: METHOD_VERSION_BY_NAME.get(method) || 1,
       method,
-      params: params || {},
-    };
+      params,
+      clientId,
+      initializing: method === "initialize",
+    });
 
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -2077,25 +2339,30 @@ function createDesktopIpcClient({
     });
   }
 
-  function handleData(chunk) {
-    readBuffer = Buffer.concat([readBuffer, chunk]);
-    while (readBuffer.length >= FRAME_HEADER_BYTES) {
-      const frameLength = readBuffer.readUInt32LE(0);
-      if (frameLength > MAX_FRAME_BYTES) {
-        close();
-        return;
-      }
-      if (readBuffer.length < FRAME_HEADER_BYTES + frameLength) {
-        return;
-      }
+  function sendBroadcast(method, params, { targetClientIds } = {}) {
+    ensureConnected();
+    if (!socket || socket.destroyed || !clientId) {
+      return false;
+    }
+    const envelope = {
+      type: "broadcast",
+      method,
+      sourceClientId: clientId,
+      params: params || {},
+      version: METHOD_VERSION_BY_NAME.get(method) || 1,
+    };
+    if (Array.isArray(targetClientIds) && targetClientIds.length > 0) {
+      envelope.targetClientIds = targetClientIds;
+    }
+    writeEnvelope(envelope);
+    return true;
+  }
 
-      const payload = readBuffer.slice(FRAME_HEADER_BYTES, FRAME_HEADER_BYTES + frameLength).toString("utf8");
-      readBuffer = readBuffer.slice(FRAME_HEADER_BYTES + frameLength);
-      const envelope = safeParseJSON(payload);
-      if (envelope) {
-        dispatchEnvelope(envelope);
-      }
+  function handleData(chunk) {
+    if (chunk.length > 0) {
+      lastActivityAt = now();
     }
+    frameReader.push(chunk);
   }
 
   function dispatchEnvelope(envelope) {
@@ -2149,11 +2416,15 @@ function createDesktopIpcClient({
     onEnvelope(envelope);
   }
 
-  function handleClose() {
+  function handleClose(closedSocket) {
+    if (socket && socket !== closedSocket) {
+      return;
+    }
     socket = null;
     clientId = "";
     isConnecting = false;
-    readBuffer = Buffer.alloc(0);
+    lastActivityAt = 0;
+    frameReader.reset();
     for (const waiter of pendingRequests.values()) {
       clearTimeout(waiter.timeout);
       waiter.reject(new Error("Desktop IPC connection closed."));
@@ -2187,12 +2458,21 @@ function createDesktopIpcClient({
   }
 
   return {
+    get clientId() {
+      return clientId;
+    },
     ensureConnected,
     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,
+    sendBroadcast,
     close,
   };
 }
@@ -2213,7 +2493,7 @@ function desktopFollowerPayloadForResponse(route, responseMessage) {
       method,
       params: {
         conversationId: route.threadId,
-        requestId: route.requestId,
+        requestId: route.desktopRequestId ?? route.requestId,
         response: {
           answers,
         },
@@ -2391,7 +2671,9 @@ function projectPendingDesktopAction(threadId, request) {
   }
 
   return {
-    id: requestId,
+    // Keep the original JSON-RPC scalar for the relay request and the Desktop
+    // follower reply. requestIdKey is only an internal map/deduplication key.
+    id: request.id,
     method,
     params: {
       ...params,
@@ -2717,7 +2999,8 @@ function boundedDesktopLiveTurns(
   if (orderedTurns.length <= 1) {
     return normalizeBoundedTurnsForRuntime(
       orderedTurns.map((turn, index) => withStableProjectedTurnId(turn, index)),
-      state
+      state,
+      retainedTurnIds
     );
   }
 
@@ -2744,7 +3027,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 +3074,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 +3151,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
   ));