@makerbi/remodex 1.5.1 → 1.5.2

package/src/bridge.js

@@ -5,7 +5,7 @@
 // Depends on: ws, crypto, os, ./codex-home, ./qr, ./codex-desktop-refresher, ./codex-transport, ./rollout-watch, ./voice-handler, ./ios-app-compatibility
 
 const WebSocket = require("ws");
-const { randomBytes } = require("crypto");
+const { randomBytes, randomUUID } = require("crypto");
 const { execFile, spawn } = require("child_process");
 const path = require("path");
 const os = require("os");
@@ -15,7 +15,11 @@ const {
   readBridgeConfig,
 } = require("./codex-desktop-refresher");
 const { createCodexTransport } = require("./codex-transport");
-const { createThreadRolloutActivityWatcher } = require("./rollout-watch");
+const {
+  createThreadRolloutActivityWatcher,
+  findRecentRolloutFileForContextRead,
+  resolveSessionsRoot,
+} = require("./rollout-watch");
 const { printQR } = require("./qr");
 const { rememberActiveThread } = require("./session-state");
 const { handleDesktopRequest } = require("./desktop-handler");
@@ -52,6 +56,9 @@ const {
   normalizeVersionString,
 } = require("./ios-app-compatibility");
 const { createShortPairingCode, SHORT_PAIRING_CODE_LENGTH } = require("./qr");
+const {
+  readThreadTurnsListPageFromSessionJsonl,
+} = require("./session-jsonl-history");
 
 const execFileAsync = promisify(execFile);
 const RELAY_WATCHDOG_PING_INTERVAL_MS = 10_000;
@@ -68,6 +75,8 @@ const RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS = 24_000;
 const RELAY_HISTORY_RECENT_TURN_TARGET = 40;
 const RELAY_TURNS_LIST_TARGET_BUDGET_MS = 5_500;
 const RELAY_TURNS_LIST_BUDGET_RESERVE_MS = 1_000;
+const RELAY_TURNS_LIST_MAX_INITIAL_LIMIT = 5;
+const RELAY_TURNS_LIST_SAFE_RETRY_LIMIT = 5;
 const RELAY_TURNS_LIST_RESULT_KEYS = ["data", "items", "turns"];
 const RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS = [
   "nextCursor",
@@ -178,12 +187,16 @@ function startBridge({
   const bridgeManagedCodexRequestWaiters = new Map();
   const forwardedRequestMethodsById = new Map();
   const relaySanitizedResponseMethodsById = new Map();
+  const relayChannels = [];
+  const codexResponseRoutesById = new Map();
+  const extraRelaySessionCount = readExtraRelaySessionCount(process.env);
   const trackedForwardedRequestMethods = new Set([
     "account/login/start",
     "account/login/cancel",
     "account/logout",
   ]);
   const relaySanitizedRequestMethods = new Set([
+    "thread/list",
     "thread/read",
     "thread/resume",
     "thread/turns/list",
@@ -204,6 +217,7 @@ function startBridge({
       sendRelayRegistrationUpdate(nextDeviceState);
     },
   });
+  let primaryRelayChannel = null;
   // Keeps one stable sender identity across reconnects so buffered replay state
   // reflects what actually made it onto the current relay socket.
   function sendRelayWireMessage(wireMessage) {
@@ -446,7 +460,7 @@ function startBridge({
           }
         },
         onApplicationMessage(plaintextMessage) {
-          handleApplicationMessage(plaintextMessage);
+          handleApplicationMessage(plaintextMessage, primaryRelayChannel);
         },
       })) {
         return;
@@ -485,17 +499,168 @@ function startBridge({
     });
   }
 
+  // Optional draft path: one bridge process can expose extra one-mobile relay sessions without changing relay behavior.
+  function startExtraRelayChannels() {
+    for (let index = 1; index <= extraRelaySessionCount; index += 1) {
+      startExtraRelayChannel(index);
+    }
+  }
+
+  function startExtraRelayChannel(index) {
+    const extraSessionId = randomUUID();
+    const extraRelaySessionUrl = `${relayBaseUrl}/${extraSessionId}`;
+    let reconnectTimerForChannel = null;
+    let reconnectAttemptForChannel = 0;
+    const extraSecureTransport = createBridgeSecureTransport({
+      sessionId: extraSessionId,
+      relayUrl: relayBaseUrl,
+      deviceState,
+      onTrustedPhoneUpdate(nextDeviceState) {
+        deviceState = nextDeviceState;
+        sendRelayRegistrationUpdate(nextDeviceState);
+        sendExtraRelayRegistrationUpdate(extraRelayChannel, nextDeviceState);
+      },
+    });
+    const extraPairingSession = {
+      pairingPayload: extraSecureTransport.createPairingPayload(),
+      pairingCode: createShortPairingCode({ length: SHORT_PAIRING_CODE_LENGTH }),
+    };
+    const extraRelayChannel = {
+      label: `extra-${index}`,
+      pairingSession: extraPairingSession,
+      secureTransport: extraSecureTransport,
+      socket: null,
+      closing: false,
+      sendWireMessage(wireMessage) {
+        if (extraRelayChannel.socket?.readyState !== WebSocket.OPEN) {
+          return false;
+        }
+
+        extraRelayChannel.socket.send(wireMessage);
+        return true;
+      },
+      close() {
+        extraRelayChannel.closing = true;
+        if (reconnectTimerForChannel) {
+          clearTimeout(reconnectTimerForChannel);
+          reconnectTimerForChannel = null;
+        }
+        if (
+          extraRelayChannel.socket?.readyState === WebSocket.OPEN
+          || extraRelayChannel.socket?.readyState === WebSocket.CONNECTING
+        ) {
+          extraRelayChannel.socket.close();
+        }
+      },
+    };
+    relayChannels.push(extraRelayChannel);
+
+    if (printPairingQr) {
+      console.error(`[remodex] Pair device ${index + 1}: scan this QR from your other device.`);
+      printQR(extraPairingSession);
+    }
+
+    connectExtraRelay();
+
+    function scheduleExtraReconnect() {
+      if (isShuttingDown || extraRelayChannel.closing || reconnectTimerForChannel) {
+        return;
+      }
+
+      reconnectAttemptForChannel += 1;
+      const delayMs = Math.min(1_000 * reconnectAttemptForChannel, 5_000);
+      reconnectTimerForChannel = setTimeout(() => {
+        reconnectTimerForChannel = null;
+        connectExtraRelay();
+      }, delayMs);
+    }
+
+    function connectExtraRelay() {
+      if (isShuttingDown || extraRelayChannel.closing) {
+        return;
+      }
+
+      const nextSocket = new WebSocket(extraRelaySessionUrl, {
+        headers: {
+          "x-role": "mac",
+          "x-notification-secret": notificationSecret,
+          ...buildMacRegistrationHeaders(deviceState, extraPairingSession),
+        },
+      });
+      extraRelayChannel.socket = nextSocket;
+
+      nextSocket.on("open", () => {
+        reconnectAttemptForChannel = 0;
+        extraSecureTransport.bindLiveSendWireMessage(extraRelayChannel.sendWireMessage);
+        sendExtraRelayRegistrationUpdate(extraRelayChannel, deviceState);
+      });
+
+      nextSocket.on("message", (data) => {
+        const message = typeof data === "string" ? data : data.toString("utf8");
+        extraSecureTransport.handleIncomingWireMessage(message, {
+          sendControlMessage(controlMessage) {
+            if (nextSocket.readyState === WebSocket.OPEN) {
+              nextSocket.send(JSON.stringify(controlMessage));
+            }
+          },
+          onApplicationMessage(plaintextMessage) {
+            handleApplicationMessage(plaintextMessage, extraRelayChannel);
+          },
+        });
+      });
+
+      nextSocket.on("close", () => {
+        if (extraRelayChannel.socket === nextSocket) {
+          extraRelayChannel.socket = null;
+        }
+        scheduleExtraReconnect();
+      });
+
+      nextSocket.on("error", () => {});
+    }
+  }
+
+  function closeExtraRelayChannels() {
+    for (const relayChannel of relayChannels) {
+      if (relayChannel !== primaryRelayChannel && typeof relayChannel.close === "function") {
+        relayChannel.close();
+      }
+    }
+  }
+
+  function sendExtraRelayRegistrationUpdate(relayChannel, nextDeviceState) {
+    if (!relayChannel?.socket || relayChannel.socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    relayChannel.socket.send(JSON.stringify({
+      kind: "relayMacRegistration",
+      registration: buildMacRegistration(nextDeviceState, relayChannel.pairingSession),
+    }));
+  }
+
   const pairingPayload = secureTransport.createPairingPayload();
   const pairingSession = {
     pairingPayload,
     pairingCode: createShortPairingCode({ length: SHORT_PAIRING_CODE_LENGTH }),
   };
+  primaryRelayChannel = {
+    label: "primary",
+    pairingSession,
+    secureTransport,
+    sendWireMessage: sendRelayWireMessage,
+  };
+  relayChannels.push(primaryRelayChannel);
   onPairingSession?.(pairingSession);
   if (printPairingQr) {
+    if (extraRelaySessionCount > 0) {
+      console.error("[remodex] Pair device 1: scan this QR from your first device.");
+    }
     printQR(pairingSession);
   }
   pushServiceClient.logUnavailable();
   connectRelay();
+  startExtraRelayChannels();
 
   codex.onMessage((message) => {
     if (handleBridgeManagedCodexResponse(message)) {
@@ -506,10 +671,7 @@ function startBridge({
     desktopRefresher.handleOutbound(message);
     pushNotificationTracker.handleOutbound(message);
     rememberThreadFromMessage("codex", message);
-    secureTransport.queueOutboundApplicationMessage(
-      sanitizeRelayBoundCodexMessage(message),
-      sendRelayWireMessage
-    );
+    sendCodexOutboundToMobile(message);
   });
 
   codex.onClose(() => {
@@ -532,9 +694,11 @@ function startBridge({
     desktopRefresher.handleTransportReset();
     failBridgeManagedCodexRequests(new Error("Codex transport closed before the bridge request completed."));
     forwardedRequestMethodsById.clear();
+    codexResponseRoutesById.clear();
     if (socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) {
       socket.close();
     }
+    closeExtraRelayChannels();
   });
 
   process.on("SIGINT", () => shutdown(codex, () => socket, () => {
@@ -543,6 +707,7 @@ function startBridge({
     clearReconnectTimer();
     clearRelayWatchdog();
     clearBridgeStatusHeartbeat();
+    closeExtraRelayChannels();
   }));
   process.on("SIGTERM", () => shutdown(codex, () => socket, () => {
     isShuttingDown = true;
@@ -550,35 +715,37 @@ function startBridge({
     clearReconnectTimer();
     clearRelayWatchdog();
     clearBridgeStatusHeartbeat();
+    closeExtraRelayChannels();
   }));
 
   // Routes decrypted app payloads through the same bridge handlers as before.
-  function handleApplicationMessage(rawMessage) {
-    if (handleBridgeManagedHandshakeMessage(rawMessage)) {
+  function handleApplicationMessage(rawMessage, relayChannel = primaryRelayChannel) {
+    const sendResponse = (responseMessage) => sendApplicationResponseToChannel(responseMessage, relayChannel);
+    if (handleBridgeManagedHandshakeMessage(rawMessage, sendResponse)) {
       return;
     }
-    if (handleBridgeManagedAccountRequest(rawMessage, sendApplicationResponse)) {
+    if (handleBridgeManagedAccountRequest(rawMessage, sendResponse)) {
       return;
     }
-    if (voiceHandler.handleVoiceRequest(rawMessage, sendApplicationResponse)) {
+    if (voiceHandler.handleVoiceRequest(rawMessage, sendResponse)) {
       return;
     }
-    if (handleThreadContextRequest(rawMessage, sendApplicationResponse)) {
+    if (handleThreadContextRequest(rawMessage, sendResponse)) {
       return;
     }
-    if (handleWorkspaceRequest(rawMessage, sendApplicationResponse)) {
+    if (handleWorkspaceRequest(rawMessage, sendResponse)) {
       return;
     }
-    if (handleProjectRequest(rawMessage, sendApplicationResponse)) {
+    if (handleProjectRequest(rawMessage, sendResponse)) {
       return;
     }
-    if (handlePetRequest(rawMessage, sendApplicationResponse)) {
+    if (handlePetRequest(rawMessage, sendResponse)) {
       return;
     }
-    if (notificationsHandler.handleNotificationsRequest(rawMessage, sendApplicationResponse)) {
+    if (notificationsHandler.handleNotificationsRequest(rawMessage, sendResponse)) {
       return;
     }
-    if (handleDesktopRequest(rawMessage, sendApplicationResponse, {
+    if (handleDesktopRequest(rawMessage, sendResponse, {
       bundleId: config.codexBundleId,
       appPath: config.codexAppPath,
       readBridgePreferences,
@@ -586,7 +753,7 @@ function startBridge({
     })) {
       return;
     }
-    if (handleGitRequest(rawMessage, sendApplicationResponse, {
+    if (handleGitRequest(rawMessage, sendResponse, {
       codexAppPath: config.codexAppPath,
       onThreadNameSet: sendThreadNameUpdatedNotification,
     })) {
@@ -597,22 +764,189 @@ function startBridge({
     if (desktopIpcActionFollower?.observeInbound(rawMessage)) {
       return;
     }
-    if (handleBridgeManagedThreadTurnsListRequest(rawMessage)) {
+    if (handleBridgeManagedThreadTurnsListRequest(rawMessage, sendResponse)) {
       return;
     }
-    rememberForwardedRequestMethod(rawMessage);
+    const codexMessage = prepareCodexForwardMessage(rawMessage, relayChannel);
+    rememberForwardedRequestMethod(codexMessage);
     rememberThreadFromMessage("phone", rawMessage);
-    codex.send(rawMessage);
+    mirrorUserMessageToPeerDevices(rawMessage, relayChannel);
+    codex.send(codexMessage);
   }
 
   // Encrypts bridge-generated responses instead of letting the relay see plaintext.
   function sendApplicationResponse(rawMessage) {
-    secureTransport.queueOutboundApplicationMessage(
-      sanitizeRelayBoundCodexMessage(rawMessage),
-      sendRelayWireMessage
+    sendApplicationResponseToChannels(rawMessage, relayChannels);
+  }
+
+  function sendApplicationResponseToChannel(rawMessage, relayChannel = primaryRelayChannel) {
+    sendApplicationResponseToChannels(rawMessage, [relayChannel]);
+  }
+
+  function sendApplicationResponseToChannels(rawMessage, channels) {
+    const normalizedChannels = channels.filter(Boolean);
+    if (normalizedChannels.length === 0) {
+      return;
+    }
+
+    const sanitizedMessage = sanitizeRelayBoundCodexMessage(rawMessage);
+    for (const relayChannel of normalizedChannels) {
+      queueSanitizedApplicationMessageToChannel(sanitizedMessage, relayChannel);
+    }
+  }
+
+  function queueSanitizedApplicationMessageToChannel(sanitizedMessage, relayChannel) {
+    if (!relayChannel) {
+      return;
+    }
+
+    relayChannel.secureTransport.queueOutboundApplicationMessage(
+      sanitizedMessage,
+      relayChannel.sendWireMessage
     );
   }
 
+  // Rewrites mobile request ids per relay channel so iPhone/iPad can use overlapping JSON-RPC ids safely.
+  function prepareCodexForwardMessage(rawMessage, relayChannel = primaryRelayChannel) {
+    const parsed = safeParseJSON(rawMessage);
+    if (!parsed || parsed.id == null || !relayChannel?.label) {
+      return rawMessage;
+    }
+
+    pruneExpiredCodexResponseRoutes();
+    const originalId = parsed.id;
+    const forwardedId = `mobile:${relayChannel.label}:${randomBytes(8).toString("hex")}`;
+    if (parsed.method === "initialize") {
+      forwardedInitializeRequestIds.delete(String(originalId));
+      forwardedInitializeRequestIds.add(String(forwardedId));
+    }
+    parsed.id = forwardedId;
+    codexResponseRoutesById.set(String(forwardedId), {
+      relayChannel,
+      originalId,
+      createdAt: Date.now(),
+    });
+    return JSON.stringify(parsed);
+  }
+
+  function sendCodexOutboundToMobile(rawMessage) {
+    pruneExpiredCodexResponseRoutes();
+    const parsed = safeParseJSON(rawMessage);
+    const responseId = parsed?.id;
+    if (responseId != null) {
+      const route = codexResponseRoutesById.get(String(responseId));
+      if (route) {
+        codexResponseRoutesById.delete(String(responseId));
+        const sanitizedMessage = sanitizeRelayBoundCodexMessage(rawMessage);
+        const sanitizedParsed = safeParseJSON(sanitizedMessage);
+        if (sanitizedParsed && typeof sanitizedParsed === "object") {
+          sanitizedParsed.id = route.originalId;
+          queueSanitizedApplicationMessageToChannel(JSON.stringify(sanitizedParsed), route.relayChannel);
+          return;
+        }
+        queueSanitizedApplicationMessageToChannel(sanitizedMessage, route.relayChannel);
+        return;
+      }
+    }
+
+    sendApplicationResponse(rawMessage);
+  }
+
+  function pruneExpiredCodexResponseRoutes() {
+    const cutoff = Date.now() - forwardedRequestMethodTTLms;
+    for (const [requestId, route] of codexResponseRoutesById.entries()) {
+      if (!route || route.createdAt < cutoff) {
+        codexResponseRoutesById.delete(requestId);
+      }
+    }
+  }
+
+  // Keeps secondary devices' timelines ordered by echoing the user's prompt before assistant deltas arrive.
+  function mirrorUserMessageToPeerDevices(rawMessage, originRelayChannel) {
+    const mirrorNotification = buildPeerUserMessageNotification(rawMessage);
+    if (!mirrorNotification) {
+      return;
+    }
+
+    const peerChannels = relayChannels.filter((relayChannel) => relayChannel !== originRelayChannel);
+    if (peerChannels.length === 0) {
+      return;
+    }
+
+    sendApplicationResponseToChannels(JSON.stringify(mirrorNotification), peerChannels);
+  }
+
+  function buildPeerUserMessageNotification(rawMessage) {
+    const parsed = safeParseJSON(rawMessage);
+    const method = typeof parsed?.method === "string" ? parsed.method.trim() : "";
+    if (method !== "turn/start" && method !== "turn/steer") {
+      return null;
+    }
+
+    const params = parsed?.params && typeof parsed.params === "object" ? parsed.params : null;
+    const threadId = readString(params?.threadId || params?.thread_id);
+    const text = extractTextFromTurnPayload(params);
+    if (!threadId || !text) {
+      return null;
+    }
+
+    const turnId = readString(params?.turnId || params?.turn_id || params?.expectedTurnId || params?.expected_turn_id);
+    return {
+      method: "codex/event/user_message",
+      params: {
+        threadId,
+        thread_id: threadId,
+        turnId: turnId || undefined,
+        turn_id: turnId || undefined,
+        message: text,
+        text,
+        source: "peer-mobile",
+      },
+    };
+  }
+
+  function extractTextFromTurnPayload(params) {
+    const directText = readString(params?.message || params?.text || params?.prompt);
+    if (directText) {
+      return directText;
+    }
+
+    return extractTextFromTurnInput(params?.input);
+  }
+
+  function extractTextFromTurnInput(input) {
+    if (typeof input === "string") {
+      return readString(input);
+    }
+
+    if (input && typeof input === "object" && !Array.isArray(input)) {
+      const directText = readString(input.text || input.message || input.content);
+      if (directText) {
+        return directText;
+      }
+    }
+
+    const inputItems = Array.isArray(input)
+      ? input
+      : Array.isArray(input?.items)
+        ? input.items
+        : [];
+    const textParts = [];
+    for (const item of inputItems) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+
+      const itemType = readString(item.type).toLowerCase();
+      const itemText = readString(item.text || item.message || item.content);
+      if ((itemType === "text" || itemType === "input_text" || itemType === "message") && itemText) {
+        textParts.push(itemText);
+      }
+    }
+
+    return readString(textParts.join("\n\n"));
+  }
+
   // Mirrors accepted local renames back to the phone using the existing push-event shape.
   function sendThreadNameUpdatedNotification(result) {
     const threadId = readString(result?.threadId || result?.thread_id);
@@ -632,7 +966,7 @@ function startBridge({
     }));
   }
 
-  function handleBridgeManagedThreadTurnsListRequest(rawMessage) {
+  function handleBridgeManagedThreadTurnsListRequest(rawMessage, sendResponse = sendApplicationResponse) {
     const request = parseAdaptiveThreadTurnsListRequest(rawMessage);
     if (!request) {
       return false;
@@ -644,13 +978,14 @@ function startBridge({
         const response = await fetchAdaptiveThreadTurnsListForRelay(request, {
           fetchPage: (params) => sendCodexRequest("thread/turns/list", params),
         });
+        const fallbackResponse = maybeBuildJsonlThreadTurnsListFallback(request, response);
         relaySanitizedResponseMethodsById.set(String(request.id), {
           method: "thread/turns/list",
           createdAt: Date.now(),
         });
-        sendApplicationResponse(JSON.stringify(response));
+        sendResponse(JSON.stringify(fallbackResponse ?? response));
       } catch (error) {
-        sendApplicationResponse(createJsonRpcErrorResponse(
+        sendResponse(createJsonRpcErrorResponse(
           request.id,
           error,
           "thread_turns_list_failed"
@@ -661,6 +996,44 @@ function startBridge({
     return true;
   }
 
+  function maybeBuildJsonlThreadTurnsListFallback(request, response) {
+    if (!isEmptyTurnsListResponse(response)) {
+      return null;
+    }
+
+    const params = request?.params || {};
+    const threadId = normalizeNonEmptyString(params.threadId)
+      || normalizeNonEmptyString(params.thread_id);
+    if (!threadId || hasRelayCursor(params.cursor)) {
+      return null;
+    }
+
+    try {
+      const rolloutPath = findRecentRolloutFileForContextRead(resolveSessionsRoot(), { threadId });
+      if (!rolloutPath) {
+        return null;
+      }
+      const result = readThreadTurnsListPageFromSessionJsonl(rolloutPath, {
+        threadId,
+        limit: params.limit,
+        maxLimit: 1,
+        cursor: params.cursor,
+      });
+      const turnsKey = findTurnsListResultKey(result);
+      if (!turnsKey || result[turnsKey].length === 0) {
+        return null;
+      }
+
+      return {
+        id: request.id,
+        result,
+      };
+    } catch (error) {
+      console.warn(`[remodex] thread/turns/list jsonl fallback failed: ${error.message}`);
+      return null;
+    }
+  }
+
   // ─── Bridge-owned auth snapshot ─────────────────────────────
 
   // Handles the bridge-owned auth status wrappers without exposing tokens to the phone.
@@ -819,19 +1192,26 @@ function startBridge({
   // Replaces huge inline desktop-history images with lightweight references before relay encryption.
   function sanitizeRelayBoundCodexMessage(rawMessage) {
     pruneExpiredForwardedRequestMethods();
-    const parsed = safeParseJSON(rawMessage);
+    const normalizedMessage = normalizeRelayBoundJsonRpcMessage(rawMessage, {
+      pendingRequestMethodsById: relaySanitizedResponseMethodsById,
+    });
+    if (!normalizedMessage) {
+      return null;
+    }
+
+    const parsed = safeParseJSON(normalizedMessage);
     const responseId = parsed?.id;
     if (responseId == null) {
-      return sanitizeLiveGeneratedImageMessageForRelay(rawMessage);
+      return sanitizeLiveGeneratedImageMessageForRelay(normalizedMessage);
     }
 
     const trackedRequest = relaySanitizedResponseMethodsById.get(String(responseId));
     if (!trackedRequest) {
-      return rawMessage;
+      return normalizedMessage;
     }
     relaySanitizedResponseMethodsById.delete(String(responseId));
 
-    return sanitizeThreadHistoryImagesForRelay(rawMessage, trackedRequest.method);
+    return sanitizeThreadHistoryImagesForRelay(normalizedMessage, trackedRequest.method);
   }
 
   function updatePendingAuthLoginFromCodexMessage(rawMessage) {
@@ -982,7 +1362,7 @@ function startBridge({
   // The spawned/shared Codex app-server stays warm across phone reconnects.
   // When iPhone reconnects it sends initialize again, but forwarding that to the
   // already-initialized Codex transport only produces "Already initialized".
-  function handleBridgeManagedHandshakeMessage(rawMessage) {
+  function handleBridgeManagedHandshakeMessage(rawMessage, sendResponse = sendApplicationResponse) {
     let parsed = null;
     try {
       parsed = JSON.parse(rawMessage);
@@ -998,7 +1378,7 @@ function startBridge({
     if (method === "initialize" && parsed.id != null) {
       const compatibilityError = bridgeManagedInitializeCompatibilityError(parsed.params || {});
       if (compatibilityError) {
-        sendApplicationResponse(JSON.stringify({
+        sendResponse(JSON.stringify({
           id: parsed.id,
           error: compatibilityError,
         }));
@@ -1010,7 +1390,7 @@ function startBridge({
         return false;
       }
 
-      sendApplicationResponse(JSON.stringify({
+      sendResponse(JSON.stringify({
         id: parsed.id,
         result: {
           bridgeManaged: true,
@@ -1174,10 +1554,21 @@ function startBridge({
       return true;
     }
 
-    waiter.resolve(parsed.result ?? null);
+    waiter.resolve(readBridgeManagedSuccessPayload(parsed));
     return true;
   }
 
+  // Normalizes private app-server responses before the bridge re-wraps them for iOS.
+  function readBridgeManagedSuccessPayload(parsed) {
+    if (Object.prototype.hasOwnProperty.call(parsed, "result")) {
+      return parsed.result ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(parsed, "payload")) {
+      return parsed.payload ?? null;
+    }
+    return null;
+  }
+
   function failBridgeManagedCodexRequests(error) {
     for (const waiter of bridgeManagedCodexRequestWaiters.values()) {
       clearTimeout(waiter.timeout);
@@ -1199,6 +1590,11 @@ function startBridge({
   function sendRelayRegistrationUpdate(nextDeviceState) {
     deviceState = nextDeviceState;
     if (socket?.readyState !== WebSocket.OPEN) {
+      for (const relayChannel of relayChannels) {
+        if (relayChannel !== primaryRelayChannel) {
+          sendExtraRelayRegistrationUpdate(relayChannel, nextDeviceState);
+        }
+      }
       return;
     }
 
@@ -1206,6 +1602,11 @@ function startBridge({
       kind: "relayMacRegistration",
       registration: buildMacRegistration(nextDeviceState, pairingSession),
     }));
+    for (const relayChannel of relayChannels) {
+      if (relayChannel !== primaryRelayChannel) {
+        sendExtraRelayRegistrationUpdate(relayChannel, nextDeviceState);
+      }
+    }
   }
 
   function readBridgePreferences() {
@@ -1329,7 +1730,7 @@ function createMacOSBridgeWakeAssertion({
   };
 }
 
-// Registers the canonical Mac identity and the one trusted iPhone allowed for auto-resolve.
+// Registers the canonical Mac identity; legacy relay headers can expose one trusted device for auto-resolve.
 function buildMacRegistrationHeaders(deviceState, pairingSession) {
   const registration = buildMacRegistration(deviceState, pairingSession);
   const headers = {
@@ -1347,6 +1748,20 @@ function buildMacRegistrationHeaders(deviceState, pairingSession) {
   return headers;
 }
 
+function readExtraRelaySessionCount(env = process.env) {
+  const rawValue = readString(env.REMODEX_EXTRA_RELAY_SESSIONS || env.PHODEX_EXTRA_RELAY_SESSIONS);
+  if (!rawValue) {
+    return 0;
+  }
+
+  const parsed = Number.parseInt(rawValue, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return 0;
+  }
+
+  return Math.min(parsed, 3);
+}
+
 function buildMacRegistration(deviceState, pairingSession) {
   const trustedPhoneEntry = Object.entries(deviceState?.trustedPhones || {})[0] || null;
   return {
@@ -1535,7 +1950,7 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
 
   const params = request?.params;
   const requestedLimit = Number.isInteger(params?.limit) && params.limit > 0
-    ? params.limit
+    ? Math.min(params.limit, RELAY_TURNS_LIST_MAX_INITIAL_LIMIT)
     : 1;
   const startedAt = now();
   let nextCursor = params?.cursor;
@@ -1557,17 +1972,24 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
       if (response) {
         return response;
       }
-      throw error;
+      return await fetchSafeThreadTurnsListFallback(request, {
+        fetchPage,
+        now,
+        sanitizeForRelay,
+        payloadSoftLimitBytes,
+      });
     }
 
-    const pageResult = page.result;
+    const pageResult = unwrapAppServerPayloadResult(page.result);
     const pageTurnsKey = findTurnsListResultKey(pageResult);
     if (!pageTurnsKey) {
       if (!response) {
-        return {
-          id: request.id,
-          result: pageResult ?? null,
-        };
+        return await fetchSafeThreadTurnsListFallback(request, {
+          fetchPage,
+          now,
+          sanitizeForRelay,
+          payloadSoftLimitBytes,
+        });
       }
       return response;
     }
@@ -1582,10 +2004,21 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
 
     const pageTurns = pageResult[pageTurnsKey];
     combinedTurns = combinedTurns.concat(pageTurns);
-    response = {
-      id: request.id,
-      result: buildAdaptiveTurnsListResult(firstResult, lastResult, turnsKey, combinedTurns),
-    };
+    response = buildSafeTurnsListResponse(request.id, firstResult, lastResult, turnsKey, combinedTurns);
+
+    if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) >= payloadSoftLimitBytes) {
+      response = buildLargestSafeTurnsListResponse({
+        requestId: request.id,
+        firstResult,
+        lastResult,
+        turnsKey,
+        turns: combinedTurns,
+        maxTurns: RELAY_TURNS_LIST_SAFE_RETRY_LIMIT,
+        sanitizeForRelay,
+        payloadSoftLimitBytes,
+      }) ?? buildEmptyTurnsListResponse(request);
+      break;
+    }
 
     nextCursor = readTurnsListNextCursor(pageResult);
     if (combinedTurns.length >= requestedLimit || !hasRelayCursor(nextCursor) || pageTurns.length === 0) {
@@ -1614,6 +2047,64 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
   };
 }
 
+function buildEmptyTurnsListResponse(request) {
+  return {
+    id: request.id,
+    result: {
+      data: [],
+      nextCursor: null,
+    },
+  };
+}
+
+function isEmptyTurnsListResponse(response) {
+  const turnsKey = findTurnsListResultKey(response?.result);
+  return Boolean(turnsKey) && response.result[turnsKey].length === 0;
+}
+
+async function fetchSafeThreadTurnsListFallback(request, {
+  fetchPage,
+  now,
+  sanitizeForRelay,
+  payloadSoftLimitBytes,
+}) {
+  const params = request?.params;
+  const requestedLimit = Number.isInteger(params?.limit) && params.limit > 0
+    ? params.limit
+    : RELAY_TURNS_LIST_SAFE_RETRY_LIMIT;
+  const safeLimit = Math.min(requestedLimit, RELAY_TURNS_LIST_SAFE_RETRY_LIMIT);
+  const safeParams = buildAdaptiveTurnsListPageParams(params, safeLimit, params?.cursor);
+
+  try {
+    const page = await fetchMeasuredAdaptiveTurnsListPage(fetchPage, safeParams, now);
+    const pageResult = unwrapAppServerPayloadResult(page.result);
+    const turnsKey = findTurnsListResultKey(pageResult);
+    if (!turnsKey) {
+      return buildEmptyTurnsListResponse(request);
+    }
+
+    // If the normal pagination path returns a bad first page, retry once with a small page.
+    // The retry response is intentionally minimal so Swift does not decode stale server metadata.
+    const response = buildLargestSafeTurnsListResponse({
+      requestId: request.id,
+      firstResult: pageResult,
+      lastResult: pageResult,
+      turnsKey,
+      turns: pageResult[turnsKey],
+      maxTurns: safeLimit,
+      sanitizeForRelay,
+      payloadSoftLimitBytes,
+    });
+    if (response) {
+      return response;
+    }
+  } catch {
+    // Fall through to a valid empty page: the phone can keep the thread open instead of crashing.
+  }
+
+  return buildEmptyTurnsListResponse(request);
+}
+
 async function fetchMeasuredAdaptiveTurnsListPage(fetchPage, params, now) {
   const startedAt = now();
   const result = await fetchPage(params);
@@ -1654,13 +2145,115 @@ function findTurnsListResultKey(result) {
   return RELAY_TURNS_LIST_RESULT_KEYS.find((key) => Array.isArray(result[key])) || null;
 }
 
-function buildAdaptiveTurnsListResult(firstResult, lastResult, turnsKey, turns) {
-  const result = {
-    ...firstResult,
+function buildSafeTurnsListResponse(requestId, firstResult, lastResult, turnsKey, turns) {
+  return {
+    id: requestId,
+    result: buildAdaptiveTurnsListResult(firstResult, lastResult, turnsKey, turns),
   };
-  for (const key of RELAY_TURNS_LIST_RESULT_KEYS) {
-    delete result[key];
+}
+
+// Trims oversized history pages progressively: normal page -> 5 turns -> ... -> 1 turn.
+function buildLargestSafeTurnsListResponse({
+  requestId,
+  firstResult,
+  lastResult,
+  turnsKey,
+  turns,
+  maxTurns,
+  sanitizeForRelay,
+  payloadSoftLimitBytes,
+}) {
+  const sliceLimit = Math.min(turns.length, maxTurns);
+  for (let count = sliceLimit; count > 0; count -= 1) {
+    const response = buildSafeTurnsListResponse(
+      requestId,
+      firstResult,
+      lastResult,
+      turnsKey,
+      turns.slice(0, count)
+    );
+    if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) < payloadSoftLimitBytes) {
+      return response;
+    }
   }
+  return buildEmergencySingleTurnResponse({
+    requestId,
+    lastResult,
+    turnsKey,
+    turn: turns[0],
+    sanitizeForRelay,
+    payloadSoftLimitBytes,
+  });
+}
+
+function buildEmergencySingleTurnResponse({
+  requestId,
+  lastResult,
+  turnsKey,
+  turn,
+  sanitizeForRelay,
+  payloadSoftLimitBytes,
+}) {
+  if (!turn || typeof turn !== "object" || Array.isArray(turn)) {
+    return null;
+  }
+
+  for (const maxItems of [16, 4, 1]) {
+    for (const maxChars of [
+      RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS,
+      Math.floor(RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS / 4),
+      1_000,
+      0,
+    ]) {
+      const response = {
+        id: requestId,
+        result: {
+          ...buildAdaptiveTurnsListResult({}, lastResult, turnsKey, [
+            compactEmergencySingleTurnForRelay(turn, maxChars, maxItems),
+          ]),
+          remodexEmergencySingleTurnForRelay: true,
+        },
+      };
+      if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) < payloadSoftLimitBytes) {
+        return response;
+      }
+    }
+  }
+
+  return null;
+}
+
+function compactEmergencySingleTurnForRelay(turn, maxChars, maxItems) {
+  const safeTurn = {};
+  for (const key of [
+    "id",
+    "turnId",
+    "turn_id",
+    "threadId",
+    "thread_id",
+    "createdAt",
+    "created_at",
+    "completedAt",
+    "completed_at",
+    "status",
+    "role",
+    "kind",
+  ]) {
+    const value = turn[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      safeTurn[key] = value;
+    }
+  }
+
+  const items = Array.isArray(turn.items) ? turn.items : [];
+  safeTurn.items = items.slice(-maxItems).map((item) => compactHistoryItemForRelay(item, maxChars));
+  safeTurn.remodexEmergencySingleTurnForRelay = true;
+  safeTurn.remodexPageCompactedForRelay = true;
+  return safeTurn;
+}
+
+function buildAdaptiveTurnsListResult(firstResult, lastResult, turnsKey, turns) {
+  const result = {};
   result[turnsKey] = turns;
 
   for (const key of RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS) {
@@ -1709,6 +2302,108 @@ function measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) {
   }
 }
 
+// Keeps app-server responses in the JSON-RPC shape that the App Store iOS client decodes.
+function normalizeRelayBoundJsonRpcMessage(rawMessage, {
+  pendingRequestMethodsById = null,
+} = {}) {
+  const parsed = parseBridgeJSON(rawMessage);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+
+  const hasMethod = typeof parsed.method === "string" && parsed.method.length > 0;
+  const hasResponseId = parsed.id !== undefined && parsed.id !== null;
+  const hasResult = Object.prototype.hasOwnProperty.call(parsed, "result");
+  const hasError = Object.prototype.hasOwnProperty.call(parsed, "error");
+  const hasPayload = Object.prototype.hasOwnProperty.call(parsed, "payload");
+  if (hasResponseId && !hasMethod && !hasResult && !hasError && hasPayload) {
+    const { payload, ...rest } = parsed;
+    return JSON.stringify({
+      ...rest,
+      result: payload ?? null,
+    });
+  }
+
+  if (hasResponseId && !hasMethod && hasResult && !hasError) {
+    const unwrappedResult = unwrapAppServerPayloadResult(parsed.result);
+    if (unwrappedResult !== parsed.result) {
+      return JSON.stringify({
+        ...parsed,
+        result: unwrappedResult,
+      });
+    }
+  }
+
+  if (hasMethod && hasResponseId && !isRelayBoundServerRequestMethod(parsed.method)) {
+    const trackedRequest = pendingRequestMethodsById?.get(String(parsed.id));
+    const isTrackedResponse = trackedRequest?.method === parsed.method
+      && (hasResult || hasError || hasPayload);
+    if (isTrackedResponse) {
+      const { method, payload, ...rest } = parsed;
+      if (!hasResult && !hasError && hasPayload) {
+        return JSON.stringify({
+          ...rest,
+          result: payload ?? null,
+        });
+      }
+      if (hasResult && !hasError) {
+        return JSON.stringify({
+          ...rest,
+          result: unwrapAppServerPayloadResult(rest.result),
+        });
+      }
+      return JSON.stringify(rest);
+    }
+
+    return null;
+  }
+
+  if (!hasMethod && !hasResponseId) {
+    return null;
+  }
+
+  return rawMessage;
+}
+
+function unwrapAppServerPayloadResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  if (!Object.prototype.hasOwnProperty.call(value, "payload")) {
+    return value;
+  }
+
+  const payload = value.payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return value;
+  }
+
+  const directPayloadKeys = [
+    "data",
+    "items",
+    "threads",
+    "turns",
+    "thread",
+  ];
+  const hasDirectResultPayload = directPayloadKeys.some((key) => (
+    Object.prototype.hasOwnProperty.call(payload, key)
+  ));
+  if (!hasDirectResultPayload) {
+    return value;
+  }
+
+  return {
+    ...value,
+    ...payload,
+  };
+}
+
+function isRelayBoundServerRequestMethod(method) {
+  return method === "item/tool/requestUserInput"
+    || method === "tool/requestUserInput"
+    || method.endsWith("requestApproval");
+}
+
 // Shrinks thread history snapshots/pages for mobile relay delivery.
 // This elides bulky blobs and replaces oversized older history with a compact marker.
 function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
@@ -2538,6 +3233,7 @@ module.exports = {
   fetchAdaptiveThreadTurnsListForRelay,
   hasRelayConnectionGoneStale,
   isTerminalRelayCloseCode,
+  normalizeRelayBoundJsonRpcMessage,
   persistBridgePreferences,
   sanitizeLiveGeneratedImageMessageForRelay,
   sanitizeThreadHistoryImagesForRelay,