@makerbi/remodex 1.5.3 → 1.5.8

package/src/bridge.js

@@ -2,11 +2,12 @@
 // Purpose: Runs Codex locally, bridges relay traffic, and coordinates desktop refreshes for Codex.app.
 // Layer: CLI service
 // Exports: startBridge
-// Depends on: ws, crypto, os, ./codex-home, ./qr, ./codex-desktop-refresher, ./codex-transport, ./rollout-watch, ./voice-handler, ./ios-app-compatibility
+// Depends on: ws, crypto, os, ./bridge-status, ./codex-desktop-refresher, ./codex-transport, ./rollout-watch, ./voice-handler
 
 const WebSocket = require("ws");
 const { randomBytes, randomUUID } = require("crypto");
 const { execFile, spawn } = require("child_process");
+const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const { promisify } = require("util");
@@ -14,6 +15,11 @@ const {
   CodexDesktopRefresher,
   readBridgeConfig,
 } = require("./codex-desktop-refresher");
+const {
+  buildHeartbeatBridgeStatus,
+  createBridgeStatusPublisher,
+  hasRelayConnectionGoneStale,
+} = require("./bridge-status");
 const { createCodexTransport } = require("./codex-transport");
 const {
   createThreadRolloutActivityWatcher,
@@ -47,6 +53,7 @@ const { createBridgeSecureTransport } = require("./secure-transport");
 const { createRolloutLiveMirrorController } = require("./rollout-live-mirror");
 const {
   createDesktopIpcActionFollower,
+  seedConversationStateFromThreadRead,
 } = require("./desktop-ipc-action-follower");
 const { version: bridgePackageVersion = "" } = require("../package.json");
 const {
@@ -57,15 +64,14 @@ const {
 } = require("./ios-app-compatibility");
 const { createShortPairingCode, SHORT_PAIRING_CODE_LENGTH } = require("./qr");
 const {
+  parseSessionJsonlMetadata,
+  parseSessionJsonlTurns,
   readThreadTurnsListPageFromSessionJsonl,
 } = require("./session-jsonl-history");
+const { buildApplyPatchFileChangeItem } = require("./apply-patch-changes");
 
 const execFileAsync = promisify(execFile);
 const RELAY_WATCHDOG_PING_INTERVAL_MS = 10_000;
-// Keep the watchdog above the relay heartbeat cadence so quiet healthy sockets survive idle gaps.
-const RELAY_WATCHDOG_STALE_AFTER_MS = 70_000;
-const BRIDGE_STATUS_HEARTBEAT_INTERVAL_MS = 5_000;
-const STALE_RELAY_STATUS_MESSAGE = "Relay heartbeat stalled; reconnect pending.";
 const CLOSE_CODE_INVALID_RELAY_REQUEST = 4000;
 const CLOSE_CODE_REPLACED_BY_NEW_MAC = 4001;
 const CLOSE_CODE_MAC_UNAUTHORIZED = 4005;
@@ -77,6 +83,15 @@ 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_JSONL_TURNS_LIST_CACHE_TTL_MS = 30_000;
+const RELAY_JSONL_ARTIFACT_CACHE_TTL_MS = 2_000;
+const RELAY_JSONL_ARTIFACT_CACHE_MAX_ENTRIES = 128;
+const BRIDGE_PACKAGE_UPDATE_COMMAND = "npm install -g @makerbi/remodex@latest";
+const BRIDGE_PACKAGE_UPDATE_TIMEOUT_MS = 180_000;
+const BRIDGE_RESTART_AFTER_UPDATE_DELAY_MS = 750;
+const MODELS_WITHOUT_REASONING_SUMMARY = new Set([
+  "gpt-5.3-codex-spark",
+]);
 const RELAY_TURNS_LIST_RESULT_KEYS = ["data", "items", "turns"];
 const RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS = [
   "nextCursor",
@@ -93,6 +108,9 @@ const RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS = [
   "previousCursor",
   "previous_cursor",
 ];
+const jsonlArtifactItemsCacheByThread = new Map();
+const FORWARDED_REQUEST_METHODS_MAX_SIZE = 500;
+const JSONL_ROLLOUT_PATH_CACHE_MAX_SIZE = 200;
 
 function buildRelayUserAgentHeader({ version = bridgePackageVersion } = {}) {
   const normalizedVersion = typeof version === "string" && version.trim()
@@ -112,6 +130,18 @@ function buildRelayAccessTokenHeaders(config = {}, env = process.env) {
     : {};
 }
 
+function evictOldestEntries(map, maxSize) {
+  if (map.size <= maxSize) {
+    return;
+  }
+  const excess = map.size - maxSize;
+  const iterator = map.keys();
+  for (let i = 0; i < excess; i += 1) {
+    const key = iterator.next().value;
+    map.delete(key);
+  }
+}
+
 function startBridge({
   config: explicitConfig = null,
   printPairingQr = true,
@@ -176,9 +206,7 @@ function startBridge({
   let reconnectAttempt = 0;
   let reconnectTimer = null;
   let relayWatchdogTimer = null;
-  let statusHeartbeatTimer = null;
   let lastRelayActivityAt = 0;
-  let lastPublishedBridgeStatus = null;
   let lastConnectionStatus = null;
   let lastConnectionError = "";
   let codexLaunchState = config.codexEndpoint ? "connected" : "starting";
@@ -190,6 +218,8 @@ function startBridge({
   const relayChannels = [];
   const codexResponseRoutesById = new Map();
   const extraRelaySessionCount = readExtraRelaySessionCount(process.env);
+  const jsonlTurnsListRolloutCacheByThread = new Map();
+  const jsonlTurnsListRolloutMissCacheByThread = new Map();
   const trackedForwardedRequestMethods = new Set([
     "account/login/start",
     "account/login/cancel",
@@ -212,6 +242,7 @@ function startBridge({
     sessionId,
     relayUrl: relayBaseUrl,
     deviceState,
+    displayName: os.hostname(),
     onTrustedPhoneUpdate(nextDeviceState) {
       deviceState = nextDeviceState;
       sendRelayRegistrationUpdate(nextDeviceState);
@@ -238,6 +269,9 @@ function startBridge({
   const desktopIpcActionFollower = !config.codexEndpoint
     ? createDesktopIpcActionFollower({
       sendApplicationResponse,
+      readConversationState: async (threadId) => seedConversationStateFromThreadRead(
+        await sendCodexRequest("thread/read", { threadId })
+      ),
       socketPath: config.desktopIpcSocketPath || undefined,
     })
     : null;
@@ -254,7 +288,14 @@ function startBridge({
     sendCodexRequest,
     logPrefix: "[remodex]",
   });
-  startBridgeStatusHeartbeat();
+  const bridgeStatusPublisher = createBridgeStatusPublisher({
+    onBridgeStatus,
+    getCodexLaunchState: () => codexLaunchState,
+  });
+  bridgeStatusPublisher.startHeartbeat({
+    shouldPublish: () => !isShuttingDown,
+    getLastRelayActivityAt: () => lastRelayActivityAt,
+  });
   publishBridgeStatus({
     state: "starting",
     connectionStatus: "starting",
@@ -275,7 +316,7 @@ function startBridge({
     } else {
       console.error("[remodex] Failed to start `codex app-server`.");
       console.error(`[remodex] Launch command: ${codex.describe()}`);
-      console.error("[remodex] Make sure the Codex CLI is installed and that the launcher works on this OS.");
+      console.error("[remodex] Make sure the Codex CLI is installed, authenticated, and launchable on this OS.");
     }
     console.error(error.message);
     process.exit(1);
@@ -283,6 +324,7 @@ function startBridge({
   // Marks the local Codex runtime as launchable before relay/network recovery updates.
   codex.onStarted(() => {
     codexLaunchState = "connected";
+    const lastPublishedBridgeStatus = bridgeStatusPublisher.latest();
     if (!lastPublishedBridgeStatus) {
       return;
     }
@@ -299,31 +341,6 @@ function startBridge({
     reconnectTimer = null;
   }
 
-  // Periodically rewrites the latest bridge snapshot so CLI status does not stay frozen.
-  function startBridgeStatusHeartbeat() {
-    if (statusHeartbeatTimer) {
-      return;
-    }
-
-    statusHeartbeatTimer = setInterval(() => {
-      if (!lastPublishedBridgeStatus || isShuttingDown) {
-        return;
-      }
-
-      onBridgeStatus?.(buildHeartbeatBridgeStatus(lastPublishedBridgeStatus, lastRelayActivityAt));
-    }, BRIDGE_STATUS_HEARTBEAT_INTERVAL_MS);
-    statusHeartbeatTimer.unref?.();
-  }
-
-  function clearBridgeStatusHeartbeat() {
-    if (!statusHeartbeatTimer) {
-      return;
-    }
-
-    clearInterval(statusHeartbeatTimer);
-    statusHeartbeatTimer = null;
-  }
-
   // Tracks relay liveness locally so sleep/wake zombie sockets can be force-reconnected.
   function markRelayActivity() {
     lastRelayActivityAt = Date.now();
@@ -338,6 +355,33 @@ function startBridge({
     relayWatchdogTimer = null;
   }
 
+  function prepareBridgeShutdown() {
+    isShuttingDown = true;
+    bridgeWakeAssertion.stop();
+    clearReconnectTimer();
+    clearRelayWatchdog();
+    bridgeStatusPublisher.stopHeartbeat();
+    stopContextUsageWatcher();
+    rolloutLiveMirror?.stopAll();
+    desktopIpcActionFollower?.stopAll();
+  }
+
+  function stopBridge() {
+    if (isShuttingDown) {
+      return;
+    }
+
+    prepareBridgeShutdown();
+    desktopRefresher.handleTransportReset();
+    failBridgeManagedCodexRequests(new Error("Bridge stopped before the request completed."));
+    forwardedRequestMethodsById.clear();
+
+    if (socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) {
+      socket.close();
+    }
+    codex.shutdown();
+  }
+
   function startRelayWatchdog(trackedSocket) {
     clearRelayWatchdog();
     markRelayActivity();
@@ -394,18 +438,9 @@ function startBridge({
       return;
     }
 
-    if (isTerminalRelayCloseCode(closeCode)) {
-      const lastError = buildRelayCloseStatusError(closeCode, closeReason);
-      logConnectionStatus("disconnected", lastError);
-      shutdown(codex, () => socket, () => {
-        isShuttingDown = true;
-        bridgeWakeAssertion.stop();
-        clearReconnectTimer();
-        clearRelayWatchdog();
-        clearBridgeStatusHeartbeat();
-      }, {
-        exitCode: closeCode === CLOSE_CODE_MAC_UNAUTHORIZED ? 1 : 0,
-      });
+    if (closeCode === 4000 || closeCode === 4001) {
+      logConnectionStatus("disconnected");
+      shutdown(codex, () => socket, prepareBridgeShutdown);
       return;
     }
 
@@ -414,7 +449,9 @@ function startBridge({
     }
 
     reconnectAttempt += 1;
-    const delayMs = Math.min(1_000 * reconnectAttempt, 5_000);
+    const baseDelayMs = Math.min(1_000 * reconnectAttempt, 5_000);
+    const jitterMs = Math.floor(Math.random() * Math.min(baseDelayMs, 2_000));
+    const delayMs = baseDelayMs + jitterMs;
     logConnectionStatus("connecting");
     reconnectTimer = setTimeout(() => {
       reconnectTimer = null;
@@ -429,6 +466,11 @@ function startBridge({
 
     logConnectionStatus("connecting");
     const nextSocket = new WebSocket(relaySessionUrl, {
+      perMessageDeflate: {
+        zlibDeflateOptions: { level: 6 },
+        threshold: 256,
+        concurrencyLimit: 4,
+      },
       // The relay uses this per-session secret to authenticate the first push registration.
       headers: {
         "User-Agent": buildRelayUserAgentHeader(),
@@ -485,8 +527,8 @@ function startBridge({
         socket = null;
       }
       stopContextUsageWatcher();
-      rolloutLiveMirror?.stopAll();
-      desktopIpcActionFollower?.stopAll();
+      // Relay reconnects are transport-only: keep local live observers running
+      // so their output can enter secure replay and catch up on the next resume.
       desktopRefresher.handleTransportReset();
       scheduleRelayReconnect(code, closeReason);
     });
@@ -582,8 +624,10 @@ function startBridge({
 
       const nextSocket = new WebSocket(extraRelaySessionUrl, {
         headers: {
+          "User-Agent": buildRelayUserAgentHeader(),
           "x-role": "mac",
           "x-notification-secret": notificationSecret,
+          ...buildRelayAccessTokenHeaders(config),
           ...buildMacRegistrationHeaders(deviceState, extraPairingSession),
         },
       });
@@ -675,22 +719,24 @@ function startBridge({
   });
 
   codex.onClose(() => {
+    const wasShuttingDown = isShuttingDown;
     clearRelayWatchdog();
-    clearBridgeStatusHeartbeat();
-    const lastError = lastConnectionError || "";
+    bridgeStatusPublisher.stopHeartbeat();
+    const lastError = wasShuttingDown
+      ? ""
+      : (lastConnectionError || "Codex transport closed unexpectedly.");
     logConnectionStatus("disconnected", lastError);
     publishBridgeStatus({
-      state: "stopped",
+      state: wasShuttingDown ? "stopped" : "error",
       connectionStatus: "disconnected",
       pid: process.pid,
       lastError,
     });
-    isShuttingDown = true;
-    bridgeWakeAssertion.stop();
-    clearReconnectTimer();
-    stopContextUsageWatcher();
-    rolloutLiveMirror?.stopAll();
-    desktopIpcActionFollower?.stopAll();
+    if (!wasShuttingDown) {
+      console.error(`[remodex] ${lastError}`);
+      process.exitCode = 1;
+    }
+    prepareBridgeShutdown();
     desktopRefresher.handleTransportReset();
     failBridgeManagedCodexRequests(new Error("Codex transport closed before the bridge request completed."));
     forwardedRequestMethodsById.clear();
@@ -701,22 +747,8 @@ function startBridge({
     closeExtraRelayChannels();
   });
 
-  process.on("SIGINT", () => shutdown(codex, () => socket, () => {
-    isShuttingDown = true;
-    bridgeWakeAssertion.stop();
-    clearReconnectTimer();
-    clearRelayWatchdog();
-    clearBridgeStatusHeartbeat();
-    closeExtraRelayChannels();
-  }));
-  process.on("SIGTERM", () => shutdown(codex, () => socket, () => {
-    isShuttingDown = true;
-    bridgeWakeAssertion.stop();
-    clearReconnectTimer();
-    clearRelayWatchdog();
-    clearBridgeStatusHeartbeat();
-    closeExtraRelayChannels();
-  }));
+  process.on("SIGINT", () => shutdown(codex, () => socket, prepareBridgeShutdown));
+  process.on("SIGTERM", () => shutdown(codex, () => socket, prepareBridgeShutdown));
 
   // Routes decrypted app payloads through the same bridge handlers as before.
   function handleApplicationMessage(rawMessage, relayChannel = primaryRelayChannel) {
@@ -750,6 +782,7 @@ function startBridge({
       appPath: config.codexAppPath,
       readBridgePreferences,
       updateBridgePreferences,
+      updateBridgePackageAndRestart,
     })) {
       return;
     }
@@ -767,9 +800,10 @@ function startBridge({
     if (handleBridgeManagedThreadTurnsListRequest(rawMessage, sendResponse)) {
       return;
     }
-    const codexMessage = prepareCodexForwardMessage(rawMessage, relayChannel);
+    const codexRequest = disableUnsupportedReasoningSummaryForTurnStart(rawMessage);
+    const codexMessage = prepareCodexForwardMessage(codexRequest, relayChannel);
     rememberForwardedRequestMethod(codexMessage);
-    rememberThreadFromMessage("phone", rawMessage);
+    rememberThreadFromMessage("phone", codexMessage);
     mirrorUserMessageToPeerDevices(rawMessage, relayChannel);
     codex.send(codexMessage);
   }
@@ -978,12 +1012,19 @@ function startBridge({
         const response = await fetchAdaptiveThreadTurnsListForRelay(request, {
           fetchPage: (params) => sendCodexRequest("thread/turns/list", params),
         });
-        const fallbackResponse = maybeBuildJsonlThreadTurnsListFallback(request, response);
+        const jsonlFallback = maybeBuildJsonlThreadTurnsListFallback(request, response);
+        const responsePayload = jsonlFallback?.response ?? response;
+        const finalSanitizeContext = buildThreadTurnsListRelaySanitizeContext(request);
         relaySanitizedResponseMethodsById.set(String(request.id), {
           method: "thread/turns/list",
+          ...finalSanitizeContext,
           createdAt: Date.now(),
         });
-        sendResponse(JSON.stringify(fallbackResponse ?? response));
+        sendResponse(sanitizeThreadHistoryImagesForRelay(
+          JSON.stringify(responsePayload),
+          "thread/turns/list",
+          finalSanitizeContext
+        ));
       } catch (error) {
         sendResponse(createJsonRpcErrorResponse(
           request.id,
@@ -997,10 +1038,6 @@ function startBridge({
   }
 
   function maybeBuildJsonlThreadTurnsListFallback(request, response) {
-    if (!isEmptyTurnsListResponse(response)) {
-      return null;
-    }
-
     const params = request?.params || {};
     const threadId = normalizeNonEmptyString(params.threadId)
       || normalizeNonEmptyString(params.thread_id);
@@ -1009,10 +1046,17 @@ function startBridge({
     }
 
     try {
-      const rolloutPath = findRecentRolloutFileForContextRead(resolveSessionsRoot(), { threadId });
+      const responseIsEmpty = isEmptyTurnsListResponse(response);
+      const rolloutPath = resolveJsonlTurnsListRolloutPathForFallback({
+        threadId,
+        responseIsEmpty,
+        readCachedPath: readCachedJsonlTurnsListRolloutPath,
+        findAndCachePath: findAndCacheJsonlTurnsListRolloutPath,
+      });
       if (!rolloutPath) {
         return null;
       }
+
       const result = readThreadTurnsListPageFromSessionJsonl(rolloutPath, {
         threadId,
         limit: params.limit,
@@ -1024,16 +1068,69 @@ function startBridge({
         return null;
       }
 
+      if (!responseIsEmpty) {
+        const mergedResponse = maybeMergeLatestJsonlTurnIntoTurnsListResponse(request, response, result, params);
+        return mergedResponse ? { response: mergedResponse, usesJsonl: true } : null;
+      }
+
       return {
-        id: request.id,
-        result,
+        response: {
+          id: request.id,
+          result,
+        },
+        usesJsonl: true,
       };
     } catch (error) {
+      jsonlTurnsListRolloutCacheByThread.delete(threadId);
       console.warn(`[remodex] thread/turns/list jsonl fallback failed: ${error.message}`);
       return null;
     }
   }
 
+  function findAndCacheJsonlTurnsListRolloutPath(threadId) {
+    if (hasFreshJsonlTurnsListRolloutMiss(threadId)) {
+      return "";
+    }
+
+    const rolloutPath = findRecentRolloutFileForContextRead(resolveSessionsRoot(), { threadId });
+    if (rolloutPath) {
+      jsonlTurnsListRolloutMissCacheByThread.delete(threadId);
+      jsonlTurnsListRolloutCacheByThread.set(threadId, {
+        rolloutPath,
+        cachedAt: Date.now(),
+      });
+    } else {
+      jsonlTurnsListRolloutMissCacheByThread.set(threadId, Date.now());
+    }
+    return rolloutPath;
+  }
+
+  function readCachedJsonlTurnsListRolloutPath(threadId) {
+    const cached = jsonlTurnsListRolloutCacheByThread.get(threadId);
+    if (!cached) {
+      return "";
+    }
+    if (Date.now() - cached.cachedAt > RELAY_JSONL_TURNS_LIST_CACHE_TTL_MS) {
+      jsonlTurnsListRolloutCacheByThread.delete(threadId);
+      return "";
+    }
+    // Non-empty app-server pages only consult this positive cache to avoid
+    // walking the sessions tree during ordinary pagination.
+    return cached.rolloutPath;
+  }
+
+  function hasFreshJsonlTurnsListRolloutMiss(threadId) {
+    const missedAt = jsonlTurnsListRolloutMissCacheByThread.get(threadId);
+    if (!missedAt) {
+      return false;
+    }
+    if (Date.now() - missedAt <= RELAY_JSONL_TURNS_LIST_CACHE_TTL_MS) {
+      return true;
+    }
+    jsonlTurnsListRolloutMissCacheByThread.delete(threadId);
+    return false;
+  }
+
   // ─── Bridge-owned auth snapshot ─────────────────────────────
 
   // Handles the bridge-owned auth status wrappers without exposing tokens to the phone.
@@ -1182,10 +1279,17 @@ function startBridge({
       });
     }
     if (relaySanitizedRequestMethods.has(method)) {
-      relaySanitizedResponseMethodsById.set(String(requestId), {
+      const trackedRequest = {
         method,
+        threadId: method === "thread/turns/list" || method === "thread/read" || method === "thread/resume"
+          ? threadIdFromRequestParams(parsed.params)
+          : "",
         createdAt: Date.now(),
-      });
+      };
+      if (method === "thread/turns/list") {
+        trackedRequest.skipJsonlArtifactAugmentation = false;
+      }
+      relaySanitizedResponseMethodsById.set(String(requestId), trackedRequest);
     }
   }
 
@@ -1211,7 +1315,7 @@ function startBridge({
     }
     relaySanitizedResponseMethodsById.delete(String(responseId));
 
-    return sanitizeThreadHistoryImagesForRelay(normalizedMessage, trackedRequest.method);
+    return sanitizeThreadHistoryImagesForRelay(normalizedMessage, trackedRequest.method, trackedRequest);
   }
 
   function updatePendingAuthLoginFromCodexMessage(rawMessage) {
@@ -1264,16 +1368,31 @@ function startBridge({
   }
 
   function pruneExpiredForwardedRequestMethods(now = Date.now()) {
+    const expiredForwarded = [];
     for (const [requestId, trackedRequest] of forwardedRequestMethodsById.entries()) {
       if (!trackedRequest || (now - trackedRequest.createdAt) >= forwardedRequestMethodTTLms) {
-        forwardedRequestMethodsById.delete(requestId);
+        expiredForwarded.push(requestId);
       }
     }
+    for (const id of expiredForwarded) {
+      forwardedRequestMethodsById.delete(id);
+    }
+
+    const expiredSanitized = [];
     for (const [requestId, trackedRequest] of relaySanitizedResponseMethodsById.entries()) {
       if (!trackedRequest || (now - trackedRequest.createdAt) >= forwardedRequestMethodTTLms) {
-        relaySanitizedResponseMethodsById.delete(requestId);
+        expiredSanitized.push(requestId);
       }
     }
+    for (const id of expiredSanitized) {
+      relaySanitizedResponseMethodsById.delete(id);
+    }
+
+    evictOldestEntries(forwardedRequestMethodsById, FORWARDED_REQUEST_METHODS_MAX_SIZE);
+    evictOldestEntries(relaySanitizedResponseMethodsById, FORWARDED_REQUEST_METHODS_MAX_SIZE);
+    evictOldestEntries(jsonlArtifactItemsCacheByThread, RELAY_JSONL_ARTIFACT_CACHE_MAX_ENTRIES);
+    evictOldestEntries(jsonlTurnsListRolloutCacheByThread, JSONL_ROLLOUT_PATH_CACHE_MAX_SIZE);
+    evictOldestEntries(jsonlTurnsListRolloutMissCacheByThread, JSONL_ROLLOUT_PATH_CACHE_MAX_SIZE);
   }
 
   function safeParseJSON(value) {
@@ -1578,12 +1697,7 @@ function startBridge({
   }
 
   function publishBridgeStatus(status) {
-    const nextStatus = {
-      ...status,
-      codexLaunchState,
-    };
-    lastPublishedBridgeStatus = nextStatus;
-    onBridgeStatus?.(nextStatus);
+    bridgeStatusPublisher.publish(status);
   }
 
   // Refreshes the relay's trusted-mac index after the QR bootstrap locks in a phone identity.
@@ -1638,6 +1752,64 @@ function startBridge({
 
     return readBridgePreferences();
   }
+
+  async function updateBridgePackageAndRestart() {
+    if (process.platform !== "darwin") {
+      const error = new Error("Bridge self-update is available only for the macOS bridge service.");
+      error.errorCode = "unsupported_platform";
+      error.userMessage = error.message;
+      throw error;
+    }
+
+    try {
+      await execFileAsync("/bin/zsh", [
+        "-lc",
+        [
+          "export TERM=dumb",
+          "source ~/.zshrc >/dev/null 2>/dev/null || true",
+          BRIDGE_PACKAGE_UPDATE_COMMAND,
+        ].join("; "),
+      ], {
+        timeout: BRIDGE_PACKAGE_UPDATE_TIMEOUT_MS,
+        maxBuffer: 2 * 1024 * 1024,
+      });
+    } catch (error) {
+      const nextError = new Error(
+        truncateCommandOutput(error?.stderr || error?.stdout || error?.message)
+          || "Could not update the Remodex bridge package on this Mac."
+      );
+      nextError.errorCode = "bridge_update_failed";
+      nextError.userMessage = nextError.message;
+      nextError.cause = error;
+      throw nextError;
+    }
+
+    scheduleBridgeServiceRestartAfterUpdate();
+    return {
+      success: true,
+      command: BRIDGE_PACKAGE_UPDATE_COMMAND,
+      restartScheduled: true,
+      restartDelayMs: BRIDGE_RESTART_AFTER_UPDATE_DELAY_MS,
+    };
+  }
+
+  // Restarts after the RPC response has crossed the encrypted phone channel.
+  function scheduleBridgeServiceRestartAfterUpdate() {
+    const restartTimer = setTimeout(() => {
+      const cliPath = path.join(__dirname, "..", "bin", "remodex.js");
+      const child = spawn(process.execPath, [cliPath, "restart"], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+      });
+      child.unref?.();
+    }, BRIDGE_RESTART_AFTER_UPDATE_DELAY_MS);
+    restartTimer.unref?.();
+  }
+
+  return {
+    stop: stopBridge,
+  };
 }
 
 // Holds a single macOS idle-sleep assertion for as long as the bridge process stays alive.
@@ -1825,6 +1997,41 @@ function buildRelayCloseStatusError(closeCode, closeReason = "") {
     : `Relay closed the connection (${closeCode}).`;
 }
 
+// Forces app-server summary generation off for models whose Responses API calls
+// reject reasoning.summary, while leaving the phone-facing runtime choice intact.
+function disableUnsupportedReasoningSummaryForTurnStart(rawMessage) {
+  const parsed = parseBridgeJSON(rawMessage);
+  if (!parsed || parsed.method !== "turn/start") {
+    return rawMessage;
+  }
+
+  const params = parsed.params && typeof parsed.params === "object" && !Array.isArray(parsed.params)
+    ? parsed.params
+    : null;
+  if (!params || params.summary === "none") {
+    return rawMessage;
+  }
+
+  const model = readTurnStartModel(params);
+  if (!MODELS_WITHOUT_REASONING_SUMMARY.has(model)) {
+    return rawMessage;
+  }
+
+  return JSON.stringify({
+    ...parsed,
+    params: {
+      ...params,
+      summary: "none",
+    },
+  });
+}
+
+function readTurnStartModel(params) {
+  return normalizeNonEmptyString(params?.model).toLowerCase()
+    || normalizeNonEmptyString(params?.collaborationMode?.settings?.model).toLowerCase()
+    || normalizeNonEmptyString(params?.collaboration_mode?.settings?.model).toLowerCase();
+}
+
 function extractBridgeMessageContext(rawMessage) {
   let parsed = null;
   try {
@@ -1909,6 +2116,14 @@ function normalizeNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
 
+function truncateCommandOutput(value, maxChars = 1_200) {
+  const normalized = normalizeNonEmptyString(value);
+  if (!normalized || normalized.length <= maxChars) {
+    return normalized;
+  }
+  return `...${normalized.slice(-maxChars)}`;
+}
+
 function parseAdaptiveThreadTurnsListRequest(rawMessage) {
   const parsed = parseBridgeJSON(rawMessage);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -1935,6 +2150,22 @@ function parseAdaptiveThreadTurnsListRequest(rawMessage) {
   return parsed;
 }
 
+function threadIdFromRequestParams(params) {
+  return normalizeNonEmptyString(params?.threadId)
+    || normalizeNonEmptyString(params?.thread_id)
+    || normalizeNonEmptyString(params?.id)
+    || "";
+}
+
+function buildThreadTurnsListRelaySanitizeContext(request, {
+  skipJsonlArtifactAugmentation = false,
+} = {}) {
+  return {
+    threadId: threadIdFromRequestParams(request?.params || {}),
+    skipJsonlArtifactAugmentation,
+  };
+}
+
 async function fetchAdaptiveThreadTurnsListForRelay(request, {
   fetchPage,
   now = Date.now,
@@ -1952,6 +2183,9 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
   const requestedLimit = Number.isInteger(params?.limit) && params.limit > 0
     ? Math.min(params.limit, RELAY_TURNS_LIST_MAX_INITIAL_LIMIT)
     : 1;
+  const sanitizeContext = buildThreadTurnsListRelaySanitizeContext(request, {
+    skipJsonlArtifactAugmentation: true,
+  });
   const startedAt = now();
   let nextCursor = params?.cursor;
   let turnsKey = null;
@@ -1976,6 +2210,7 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
         fetchPage,
         now,
         sanitizeForRelay,
+        sanitizeContext,
         payloadSoftLimitBytes,
       });
     }
@@ -1988,6 +2223,7 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
           fetchPage,
           now,
           sanitizeForRelay,
+          sanitizeContext,
           payloadSoftLimitBytes,
         });
       }
@@ -2006,7 +2242,7 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
     combinedTurns = combinedTurns.concat(pageTurns);
     response = buildSafeTurnsListResponse(request.id, firstResult, lastResult, turnsKey, combinedTurns);
 
-    if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) >= payloadSoftLimitBytes) {
+    if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, sanitizeContext) >= payloadSoftLimitBytes) {
       response = buildLargestSafeTurnsListResponse({
         requestId: request.id,
         firstResult,
@@ -2015,6 +2251,7 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
         turns: combinedTurns,
         maxTurns: RELAY_TURNS_LIST_SAFE_RETRY_LIMIT,
         sanitizeForRelay,
+        sanitizeContext,
         payloadSoftLimitBytes,
       }) ?? buildEmptyTurnsListResponse(request);
       break;
@@ -2026,7 +2263,7 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
     }
 
     const rawPageBytes = jsonByteLength(pageResult);
-    const sanitizedResponseBytes = measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay);
+    const sanitizedResponseBytes = measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, sanitizeContext);
     const elapsedMs = Math.max(0, now() - startedAt);
     const remainingBudgetMs = Math.max(0, targetBudgetMs - elapsedMs);
     if (
@@ -2062,10 +2299,87 @@ function isEmptyTurnsListResponse(response) {
   return Boolean(turnsKey) && response.result[turnsKey].length === 0;
 }
 
+// Non-empty app-server pages can be stale for Mac-started runs, so the first page
+// still gets one JSONL lookup when the positive rollout cache is cold.
+function resolveJsonlTurnsListRolloutPathForFallback({
+  threadId,
+  responseIsEmpty,
+  readCachedPath,
+  findAndCachePath,
+}) {
+  if (!threadId || typeof findAndCachePath !== "function") {
+    return "";
+  }
+
+  if (responseIsEmpty) {
+    return findAndCachePath(threadId);
+  }
+
+  return typeof readCachedPath === "function"
+    ? readCachedPath(threadId) || findAndCachePath(threadId)
+    : findAndCachePath(threadId);
+}
+
+function maybeMergeLatestJsonlTurnIntoTurnsListResponse(request, response, jsonlResult, params = {}) {
+  const responseResult = response?.result;
+  const responseTurnsKey = findTurnsListResultKey(responseResult);
+  const jsonlTurnsKey = findTurnsListResultKey(jsonlResult);
+  if (!responseTurnsKey || !jsonlTurnsKey) {
+    return null;
+  }
+
+  const responseTurns = responseResult[responseTurnsKey];
+  const jsonlTurn = jsonlResult[jsonlTurnsKey]?.[0];
+  const jsonlTurnId = turnListTurnIdentifier(jsonlTurn);
+  if (!jsonlTurnId || responseTurns.some((turn) => turnListTurnIdentifier(turn) === jsonlTurnId)) {
+    return null;
+  }
+
+  if (!shouldMergeLatestJsonlTurn(jsonlTurn)) {
+    return null;
+  }
+
+  const requestedLimit = Number.isInteger(params?.limit) && params.limit > 0
+    ? params.limit
+    : responseTurns.length + 1;
+  const mergedTurns = [jsonlTurn, ...responseTurns].slice(0, requestedLimit);
+  return {
+    id: request.id,
+    result: {
+      ...responseResult,
+      [responseTurnsKey]: mergedTurns,
+      remodexJsonlMergedLatest: true,
+    },
+  };
+}
+
+function shouldMergeLatestJsonlTurn(turn) {
+  if (!turn || typeof turn !== "object") {
+    return false;
+  }
+
+  const status = normalizeHistoryItemToken(turn.status);
+  if (status === "running" || status === "inprogress" || status === "active") {
+    return true;
+  }
+
+  return Array.isArray(turn.items) && turn.items.some((item) => {
+    const type = normalizeHistoryItemToken(item?.type);
+    return type === "plan" || type === "filechange";
+  });
+}
+
+function turnListTurnIdentifier(turn) {
+  return normalizeNonEmptyString(turn?.id)
+    || normalizeNonEmptyString(turn?.turnId)
+    || normalizeNonEmptyString(turn?.turn_id);
+}
+
 async function fetchSafeThreadTurnsListFallback(request, {
   fetchPage,
   now,
   sanitizeForRelay,
+  sanitizeContext = {},
   payloadSoftLimitBytes,
 }) {
   const params = request?.params;
@@ -2093,6 +2407,7 @@ async function fetchSafeThreadTurnsListFallback(request, {
       turns: pageResult[turnsKey],
       maxTurns: safeLimit,
       sanitizeForRelay,
+      sanitizeContext,
       payloadSoftLimitBytes,
     });
     if (response) {
@@ -2161,6 +2476,7 @@ function buildLargestSafeTurnsListResponse({
   turns,
   maxTurns,
   sanitizeForRelay,
+  sanitizeContext = {},
   payloadSoftLimitBytes,
 }) {
   const sliceLimit = Math.min(turns.length, maxTurns);
@@ -2172,7 +2488,7 @@ function buildLargestSafeTurnsListResponse({
       turnsKey,
       turns.slice(0, count)
     );
-    if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) < payloadSoftLimitBytes) {
+    if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, sanitizeContext) < payloadSoftLimitBytes) {
       return response;
     }
   }
@@ -2182,6 +2498,7 @@ function buildLargestSafeTurnsListResponse({
     turnsKey,
     turn: turns[0],
     sanitizeForRelay,
+    sanitizeContext,
     payloadSoftLimitBytes,
   });
 }
@@ -2192,6 +2509,7 @@ function buildEmergencySingleTurnResponse({
   turnsKey,
   turn,
   sanitizeForRelay,
+  sanitizeContext = {},
   payloadSoftLimitBytes,
 }) {
   if (!turn || typeof turn !== "object" || Array.isArray(turn)) {
@@ -2214,7 +2532,7 @@ function buildEmergencySingleTurnResponse({
           remodexEmergencySingleTurnForRelay: true,
         },
       };
-      if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) < payloadSoftLimitBytes) {
+      if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, sanitizeContext) < payloadSoftLimitBytes) {
         return response;
       }
     }
@@ -2292,10 +2610,10 @@ function jsonByteLength(value) {
   }
 }
 
-function measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) {
+function measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, requestContext = {}) {
   try {
     const rawResponse = JSON.stringify(response);
-    const sanitizedResponse = sanitizeForRelay(rawResponse, "thread/turns/list");
+    const sanitizedResponse = sanitizeForRelay(rawResponse, "thread/turns/list", requestContext);
     return Buffer.byteLength(sanitizedResponse, "utf8");
   } catch {
     return Number.POSITIVE_INFINITY;
@@ -2406,9 +2724,9 @@ function isRelayBoundServerRequestMethod(method) {
 
 // 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) {
+function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod, requestContext = {}) {
   if (requestMethod === "thread/turns/list") {
-    return sanitizeThreadTurnsListForRelay(rawMessage);
+    return sanitizeThreadTurnsListForRelay(rawMessage, requestContext);
   }
 
   if (requestMethod !== "thread/read" && requestMethod !== "thread/resume") {
@@ -2421,12 +2739,15 @@ function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
     return rawMessage;
   }
 
-  const threadId = normalizeNonEmptyString(thread.id)
+  const threadId = normalizeNonEmptyString(requestContext?.threadId)
+    || normalizeNonEmptyString(thread.id)
     || normalizeNonEmptyString(thread.threadId)
     || normalizeNonEmptyString(thread.thread_id);
   const { turns: sanitizedTurns, didSanitize } = sanitizeRelayHistoryTurns(thread.turns, threadId);
+  const { thread: threadWithJsonlMetadata, didAugment: didAugmentThreadMetadata } = augmentRelayThreadWithJsonlMetadata(thread, threadId);
+  const { turns: augmentedTurns, didAugment } = augmentRelayHistoryTurnsWithJsonlArtifacts(sanitizedTurns, threadId);
 
-  if (!didSanitize) {
+  if (!didSanitize && !didAugment && !didAugmentThreadMetadata) {
     const trimmedPayload = trimThreadPayloadForRelay(parsed, thread);
     return trimmedPayload == null ? rawMessage : trimmedPayload;
   }
@@ -2436,8 +2757,8 @@ function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
     result: {
       ...parsed.result,
       thread: {
-        ...thread,
-        turns: sanitizedTurns,
+        ...threadWithJsonlMetadata,
+        turns: augmentedTurns,
       },
     },
   });
@@ -2445,7 +2766,7 @@ function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
   return trimThreadPayloadForRelay(parseBridgeJSON(sanitizedPayload), null) ?? sanitizedPayload;
 }
 
-function sanitizeThreadTurnsListForRelay(rawMessage) {
+function sanitizeThreadTurnsListForRelay(rawMessage, requestContext = {}) {
   const parsed = parseBridgeJSON(rawMessage);
   const result = parsed?.result;
   if (!result || typeof result !== "object" || Array.isArray(result)) {
@@ -2457,23 +2778,372 @@ function sanitizeThreadTurnsListForRelay(rawMessage) {
     return rawMessage;
   }
 
-  const threadId = normalizeNonEmptyString(result.threadId)
+  const threadId = normalizeNonEmptyString(requestContext?.threadId)
+    || normalizeNonEmptyString(result.threadId)
     || normalizeNonEmptyString(result.thread_id)
     || normalizeNonEmptyString(result.thread?.id)
     || normalizeNonEmptyString(result.thread?.threadId)
-    || normalizeNonEmptyString(result.thread?.thread_id);
+    || normalizeNonEmptyString(result.thread?.thread_id)
+    || inferThreadIdFromTurns(result[turnsKey]);
   const { turns: sanitizedTurns, didSanitize } = sanitizeRelayHistoryTurns(result[turnsKey], threadId);
-  const sanitizedParsed = didSanitize
+  const shouldAugmentJsonlArtifacts = requestContext?.skipJsonlArtifactAugmentation !== true;
+  const { turns: augmentedTurns, didAugment } = shouldAugmentJsonlArtifacts
+    ? augmentRelayHistoryTurnsWithJsonlArtifacts(sanitizedTurns, threadId)
+    : { turns: sanitizedTurns, didAugment: false };
+  const didChange = didSanitize || didAugment;
+  const sanitizedParsed = didChange
     ? {
       ...parsed,
       result: {
         ...result,
-        [turnsKey]: sanitizedTurns,
+        [turnsKey]: augmentedTurns,
       },
     }
     : parsed;
 
-  return trimTurnsListPayloadForRelay(sanitizedParsed, turnsKey, didSanitize ? null : rawMessage);
+  return trimTurnsListPayloadForRelay(sanitizedParsed, turnsKey, didChange ? null : rawMessage);
+}
+
+function augmentRelayThreadWithJsonlMetadata(thread, threadId = "") {
+  const cwd = readJsonlThreadCwd(threadId);
+  if (!cwd || !thread || typeof thread !== "object") {
+    return { thread, didAugment: false };
+  }
+
+  if (normalizeNonEmptyString(thread.cwd) === cwd
+    && normalizeNonEmptyString(thread.current_working_directory) === cwd) {
+    return { thread, didAugment: false };
+  }
+
+  return {
+    thread: {
+      ...thread,
+      cwd,
+      current_working_directory: cwd,
+    },
+    didAugment: true,
+  };
+}
+
+function readJsonlThreadCwd(threadId) {
+  const normalizedThreadId = normalizeNonEmptyString(threadId);
+  if (!normalizedThreadId) {
+    return "";
+  }
+
+  try {
+    const rolloutPath = findRecentRolloutFileForContextRead(resolveSessionsRoot(), { threadId: normalizedThreadId });
+    if (!rolloutPath) {
+      return "";
+    }
+
+    const metadata = parseSessionJsonlMetadata(fs.readFileSync(rolloutPath, "utf8"));
+    const cwd = normalizeNonEmptyString(metadata?.cwd);
+    return cwd && path.isAbsolute(cwd) ? cwd : "";
+  } catch {
+    return "";
+  }
+}
+
+function augmentRelayHistoryTurnsWithJsonlArtifacts(turns, threadId = "") {
+  const normalizedThreadId = normalizeNonEmptyString(threadId);
+  if (!normalizedThreadId || !Array.isArray(turns) || turns.length === 0) {
+    return { turns, didAugment: false };
+  }
+
+  const jsonlArtifactsByTurnId = readJsonlArtifactItemsByTurnId(normalizedThreadId);
+  if (jsonlArtifactsByTurnId.size === 0) {
+    return { turns, didAugment: false };
+  }
+
+  let didAugment = false;
+  const augmentedTurns = turns.map((turn) => {
+    const turnId = normalizeNonEmptyString(turn?.id)
+      || normalizeNonEmptyString(turn?.turnId)
+      || normalizeNonEmptyString(turn?.turn_id);
+    const artifacts = turnId ? jsonlArtifactsByTurnId.get(turnId) : null;
+    if (!artifacts || !turn || typeof turn !== "object") {
+      return turn;
+    }
+
+    const items = Array.isArray(turn.items) ? turn.items : [];
+    let nextItems = items;
+    if (artifacts.fileChangeItem && !hasEquivalentFileChangeItem(nextItems, artifacts.fileChangeItem)) {
+      nextItems = nextItems === items ? [...items] : nextItems;
+      nextItems.push(artifacts.fileChangeItem);
+    }
+    for (const imageViewItem of artifacts.imageViewItems || []) {
+      if (hasEquivalentImageViewItem(nextItems, imageViewItem)) {
+        continue;
+      }
+      nextItems = nextItems === items ? [...items] : nextItems;
+      nextItems.push(imageViewItem);
+    }
+    if (artifacts.progressPlanItem && !hasEquivalentProgressPlanItem(nextItems, artifacts.progressPlanItem)) {
+      nextItems = nextItems === items ? [...items] : nextItems;
+      nextItems.push(artifacts.progressPlanItem);
+    }
+
+    if (nextItems === items) {
+      return turn;
+    }
+
+    didAugment = true;
+    return {
+      ...turn,
+      items: nextItems,
+    };
+  });
+
+  return { turns: didAugment ? augmentedTurns : turns, didAugment };
+}
+
+function readJsonlArtifactItemsByTurnId(threadId) {
+  const emptyArtifactsByTurnId = new Map();
+  const normalizedThreadId = normalizeNonEmptyString(threadId);
+  if (!normalizedThreadId) {
+    return emptyArtifactsByTurnId;
+  }
+
+  const sessionsRoot = resolveSessionsRoot();
+  const cacheKey = buildJsonlArtifactItemsCacheKey(sessionsRoot, normalizedThreadId);
+  const cachedArtifacts = readCachedJsonlArtifactItems(cacheKey, normalizedThreadId);
+  if (cachedArtifacts) {
+    return cachedArtifacts;
+  }
+
+  try {
+    const rolloutPath = findRecentRolloutFileForContextRead(sessionsRoot, { threadId: normalizedThreadId });
+    if (!rolloutPath) {
+      jsonlArtifactItemsCacheByThread.delete(cacheKey);
+      return emptyArtifactsByTurnId;
+    }
+
+    return readAndCacheJsonlArtifactItems(cacheKey, rolloutPath, normalizedThreadId);
+  } catch (error) {
+    jsonlArtifactItemsCacheByThread.delete(cacheKey);
+    console.warn(`[remodex] history jsonl artifact augmentation failed for ${normalizedThreadId}: ${error.message}`);
+  }
+
+  return emptyArtifactsByTurnId;
+}
+
+function buildJsonlArtifactItemsCacheKey(sessionsRoot, threadId) {
+  return `${sessionsRoot}\0${threadId}`;
+}
+
+function readCachedJsonlArtifactItems(cacheKey, threadId) {
+  const cached = jsonlArtifactItemsCacheByThread.get(cacheKey);
+  if (!cached) {
+    return null;
+  }
+
+  const stat = statJsonlArtifactRollout(cached.rolloutPath);
+  if (!stat) {
+    jsonlArtifactItemsCacheByThread.delete(cacheKey);
+    return null;
+  }
+
+  if (stat.mtimeMs !== cached.mtimeMs || stat.size !== cached.size) {
+    try {
+      return readAndCacheJsonlArtifactItems(cacheKey, cached.rolloutPath, threadId, stat);
+    } catch (error) {
+      jsonlArtifactItemsCacheByThread.delete(cacheKey);
+      console.warn(`[remodex] history jsonl artifact cache refresh failed for ${threadId}: ${error.message}`);
+      return null;
+    }
+  }
+
+  const now = Date.now();
+  if (now - cached.checkedAt <= RELAY_JSONL_ARTIFACT_CACHE_TTL_MS) {
+    return cached.artifactsByTurnId;
+  }
+
+  cached.checkedAt = now;
+  return null;
+}
+
+function readAndCacheJsonlArtifactItems(cacheKey, rolloutPath, threadId, stat = null) {
+  const rolloutStat = stat || fs.statSync(rolloutPath);
+  const artifactsByTurnId = new Map();
+  try {
+    const turns = parseSessionJsonlTurns(fs.readFileSync(rolloutPath, "utf8"), { threadId });
+    for (const turn of turns) {
+      const turnId = normalizeNonEmptyString(turn?.id);
+      const turnItems = Array.isArray(turn?.items) ? turn.items : [];
+      if (!turnId || turnItems.length === 0) {
+        continue;
+      }
+
+      const fileChanges = turnItems.filter((item) => normalizeHistoryItemToken(item?.type) === "filechange");
+      const progressPlan = turnItems.find((item) => (
+        normalizeHistoryItemToken(item?.type) === "plan"
+          && item?.remodexJsonlProgressPlan === true
+      ));
+      const artifacts = {
+        fileChangeItem: null,
+        imageViewItems: [],
+        progressPlanItem: null,
+      };
+
+      const changes = [];
+      for (const item of fileChanges) {
+        if (Array.isArray(item.changes)) {
+          changes.push(...item.changes);
+        }
+      }
+      if (changes.length > 0) {
+        artifacts.fileChangeItem = {
+          id: `remodex-jsonl-file-change-${turnId}`,
+          type: "fileChange",
+          status: "completed",
+          changes,
+          remodexJsonlFileChangeAggregate: true,
+        };
+      }
+      if (progressPlan) {
+        artifacts.progressPlanItem = {
+          ...progressPlan,
+          id: normalizeNonEmptyString(progressPlan.id) || `remodex-jsonl-progress-plan-${turnId}`,
+        };
+      }
+      artifacts.imageViewItems = turnItems
+        .filter((item) => normalizeHistoryItemToken(item?.type) === "imageview")
+        .map((item, index) => ({
+          ...item,
+          id: normalizeNonEmptyString(item.id) || `remodex-jsonl-image-view-${turnId}-${index + 1}`,
+        }));
+
+      if (artifacts.fileChangeItem || artifacts.progressPlanItem || artifacts.imageViewItems.length > 0) {
+        artifactsByTurnId.set(turnId, artifacts);
+      }
+    }
+  } catch (error) {
+    jsonlArtifactItemsCacheByThread.delete(cacheKey);
+    throw error;
+  }
+
+  rememberJsonlArtifactItemsCache(cacheKey, {
+    rolloutPath,
+    mtimeMs: rolloutStat.mtimeMs,
+    size: rolloutStat.size,
+    checkedAt: Date.now(),
+    artifactsByTurnId,
+  });
+  return artifactsByTurnId;
+}
+
+function statJsonlArtifactRollout(rolloutPath) {
+  try {
+    return fs.statSync(rolloutPath);
+  } catch {
+    return null;
+  }
+}
+
+function rememberJsonlArtifactItemsCache(cacheKey, entry) {
+  jsonlArtifactItemsCacheByThread.set(cacheKey, entry);
+  while (jsonlArtifactItemsCacheByThread.size > RELAY_JSONL_ARTIFACT_CACHE_MAX_ENTRIES) {
+    const oldestKey = jsonlArtifactItemsCacheByThread.keys().next().value;
+    if (oldestKey == null) {
+      break;
+    }
+    jsonlArtifactItemsCacheByThread.delete(oldestKey);
+  }
+}
+
+function hasEquivalentFileChangeItem(items, incomingItem) {
+  const incomingId = normalizeNonEmptyString(incomingItem?.id);
+  const incomingPaths = fileChangePathSet(incomingItem);
+  return items.some((item) => {
+    if (normalizeHistoryItemToken(item?.type) !== "filechange") {
+      return false;
+    }
+    if (incomingId && normalizeNonEmptyString(item.id) === incomingId) {
+      return true;
+    }
+    if (item.remodexJsonlFileChangeAggregate === true) {
+      return true;
+    }
+
+    const existingPaths = fileChangePathSet(item);
+    if (incomingPaths.size === 0 || existingPaths.size === 0) {
+      return false;
+    }
+    for (const pathKey of incomingPaths) {
+      if (!existingPaths.has(pathKey)) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+function hasEquivalentProgressPlanItem(items, incomingItem) {
+  const incomingId = normalizeNonEmptyString(incomingItem?.id);
+  return items.some((item) => {
+    if (normalizeHistoryItemToken(item?.type) !== "plan") {
+      return false;
+    }
+    return item.remodexJsonlProgressPlan === true
+      || (incomingId && normalizeNonEmptyString(item.id) === incomingId);
+  });
+}
+
+function hasEquivalentImageViewItem(items, incomingItem) {
+  const incomingId = normalizeNonEmptyString(incomingItem?.id);
+  const incomingPath = normalizeImageViewPathKey(incomingItem);
+  return items.some((item) => {
+    if (normalizeHistoryItemToken(item?.type) !== "imageview") {
+      return false;
+    }
+    const itemId = normalizeNonEmptyString(item.id);
+    if (incomingId && itemId === incomingId) {
+      return true;
+    }
+    return incomingPath && normalizeImageViewPathKey(item) === incomingPath;
+  });
+}
+
+function normalizeImageViewPathKey(item) {
+  return normalizeNonEmptyString(item?.path)
+    || normalizeNonEmptyString(item?.saved_path)
+    || normalizeNonEmptyString(item?.savedPath)
+    || normalizeNonEmptyString(item?.file_path)
+    || normalizeNonEmptyString(item?.filePath);
+}
+
+function fileChangePathSet(item) {
+  const paths = new Set();
+  const changes = Array.isArray(item?.changes) ? item.changes : [];
+  for (const change of changes) {
+    const pathKey = normalizeFileChangePathKey(change?.path || change?.file || change?.filePath || change?.file_path);
+    if (pathKey) {
+      paths.add(pathKey);
+    }
+  }
+  return paths;
+}
+
+function normalizeFileChangePathKey(value) {
+  return normalizeNonEmptyString(value).replace(/\\/g, "/").replace(/^\/+/, "").toLowerCase();
+}
+
+function inferThreadIdFromTurns(turns) {
+  if (!Array.isArray(turns)) {
+    return "";
+  }
+  for (const turn of turns) {
+    const threadId = normalizeNonEmptyString(turn?.threadId)
+      || normalizeNonEmptyString(turn?.thread_id)
+      || normalizeNonEmptyString(turn?.thread?.id)
+      || normalizeNonEmptyString(turn?.thread?.threadId)
+      || normalizeNonEmptyString(turn?.thread?.thread_id);
+    if (threadId) {
+      return threadId;
+    }
+  }
+  return "";
 }
 
 function sanitizeRelayHistoryTurns(turns, threadId = "") {
@@ -2504,7 +3174,12 @@ function sanitizeRelayHistoryTurn(turn, threadId = "") {
     }
 
     let itemDidChange = false;
-    let sanitizedItem = annotateImageGenerationHistoryItem(item, turnThreadId);
+    let sanitizedItem = convertApplyPatchHistoryItem(item) || item;
+    if (sanitizedItem !== item) {
+      itemDidChange = true;
+    }
+
+    sanitizedItem = annotateImageGenerationHistoryItem(sanitizedItem, turnThreadId);
     if (sanitizedItem !== item) {
       itemDidChange = true;
     }
@@ -2547,6 +3222,26 @@ function sanitizeRelayHistoryTurn(turn, threadId = "") {
     : turn;
 }
 
+function convertApplyPatchHistoryItem(item) {
+  const itemType = normalizeHistoryItemToken(item?.type);
+  const toolName = normalizeNonEmptyString(item?.name);
+  if (toolName !== "apply_patch" || itemType !== "customtoolcall") {
+    return null;
+  }
+
+  const fileChangeItem = buildApplyPatchFileChangeItem({
+    callId: normalizeNonEmptyString(item.call_id) || normalizeNonEmptyString(item.callId) || normalizeNonEmptyString(item.id),
+    patch: normalizeNonEmptyString(item.input),
+    status: normalizeNonEmptyString(item.status) || "completed",
+    idFallback: normalizeNonEmptyString(item.id) || "history-apply-patch-file-change",
+  });
+  return fileChangeItem ? { ...item, ...fileChangeItem } : null;
+}
+
+function normalizeHistoryItemToken(value) {
+  return normalizeNonEmptyString(value).toLowerCase().replace(/[\s_-]+/g, "");
+}
+
 // Annotates live image-generation notifications so the phone can render a local-file
 // preview and does not receive the bulky inline base64 result over the relay.
 function sanitizeLiveGeneratedImageMessageForRelay(rawMessage) {
@@ -3123,6 +3818,12 @@ function compactHistoryItemForRelay(item, maxChars) {
     type: typeof item?.type === "string" ? item.type : "relay_truncated_item",
     role: typeof item?.role === "string" ? item.role : undefined,
     itemId: typeof item?.itemId === "string" ? item.itemId : undefined,
+    turnId: typeof item?.turnId === "string" ? item.turnId : undefined,
+    turn_id: typeof item?.turn_id === "string" ? item.turn_id : undefined,
+    createdAt: relayScalarHistoryMetadata(item?.createdAt),
+    created_at: relayScalarHistoryMetadata(item?.created_at),
+    timestamp: relayScalarHistoryMetadata(item?.timestamp),
+    time: relayScalarHistoryMetadata(item?.time),
     relayPayloadTruncated: true,
   };
   const tailText = maxChars > 0 ? firstRelayTextTail(item, maxChars) : "";
@@ -3135,6 +3836,10 @@ function compactHistoryItemForRelay(item, maxChars) {
   );
 }
 
+function relayScalarHistoryMetadata(value) {
+  return typeof value === "string" || typeof value === "number" ? value : undefined;
+}
+
 function firstRelayTextTail(value, maxChars) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return "";
@@ -3167,48 +3872,6 @@ function truncateRelayTextTail(value, maxChars) {
   return `…\n${tail}`;
 }
 
-// Treats silent relay sockets as stale so the daemon can self-heal after sleep/wake.
-function hasRelayConnectionGoneStale(
-  lastActivityAt,
-  {
-    now = Date.now(),
-    staleAfterMs = RELAY_WATCHDOG_STALE_AFTER_MS,
-  } = {}
-) {
-  return Number.isFinite(lastActivityAt)
-    && Number.isFinite(now)
-    && now - lastActivityAt >= staleAfterMs;
-}
-
-// Keeps persisted daemon status honest by downgrading stale "connected" snapshots.
-function buildHeartbeatBridgeStatus(
-  status,
-  lastActivityAt,
-  {
-    now = Date.now(),
-    staleAfterMs = RELAY_WATCHDOG_STALE_AFTER_MS,
-    staleMessage = STALE_RELAY_STATUS_MESSAGE,
-  } = {}
-) {
-  if (!status || typeof status !== "object") {
-    return status;
-  }
-
-  if (status.connectionStatus !== "connected") {
-    return status;
-  }
-
-  if (!hasRelayConnectionGoneStale(lastActivityAt, { now, staleAfterMs })) {
-    return status;
-  }
-
-  return {
-    ...status,
-    connectionStatus: "disconnected",
-    lastError: staleMessage,
-  };
-}
-
 function persistBridgePreferences(
   {
     keepMacAwakeEnabled,
@@ -3225,16 +3888,19 @@ function persistBridgePreferences(
 }
 
 module.exports = {
+  buildThreadTurnsListRelaySanitizeContext,
   buildHeartbeatBridgeStatus,
   buildRelayCloseStatusError,
   buildRelayAccessTokenHeaders,
   buildRelayUserAgentHeader,
   createMacOSBridgeWakeAssertion,
+  disableUnsupportedReasoningSummaryForTurnStart,
   fetchAdaptiveThreadTurnsListForRelay,
   hasRelayConnectionGoneStale,
   isTerminalRelayCloseCode,
   normalizeRelayBoundJsonRpcMessage,
   persistBridgePreferences,
+  resolveJsonlTurnsListRolloutPathForFallback,
   sanitizeLiveGeneratedImageMessageForRelay,
   sanitizeThreadHistoryImagesForRelay,
   startBridge,