@makerbi/remodex 2.0.1 → 2.3.0

package/src/bridge.js

@@ -5,7 +5,8 @@
 // Depends on: ws, crypto, os, ./bridge-status, ./codex-desktop-refresher, ./codex-transport, ./rollout-watch, ./voice-handler
 
 const WebSocket = require("ws");
-const { createHash, randomBytes, randomUUID } = require("crypto");
+const { constants: bufferConstants } = require("buffer");
+const { createHash, randomBytes } = require("crypto");
 const { execFile, spawn } = require("child_process");
 const fs = require("fs");
 const path = require("path");
@@ -52,10 +53,19 @@ const {
 } = require("./secure-device-state");
 const { createBridgeSecureTransport } = require("./secure-transport");
 const { createRolloutLiveMirrorController } = require("./rollout-live-mirror");
+const {
+  isContextualUserText,
+  isUserRoleItem,
+  readUserItemText,
+  sanitizeUserRoleItem,
+  visibleUserPromptText,
+} = require("./desktop-ipc-shared");
 const {
   createDesktopIpcActionFollower,
   seedConversationStateFromThreadRead,
 } = require("./desktop-ipc-action-follower");
+const { createDesktopIpcLiveOwner } = require("./desktop-ipc-live-owner");
+const { createThreadRuntimeSettingsStore } = require("./thread-runtime-settings-store");
 const { version: bridgePackageVersion = "" } = require("../package.json");
 const {
   MINIMUM_SUPPORTED_IOS_APP_VERSION,
@@ -65,21 +75,29 @@ const {
 } = require("./ios-app-compatibility");
 const { createShortPairingCode, SHORT_PAIRING_CODE_LENGTH } = require("./qr");
 const {
-  parseSessionJsonlMetadata,
+  JSONL_OLDER_HANDOFF_CURSOR,
   parseSessionJsonlTurns,
+  readRecentSessionJsonlTurns,
+  readSessionJsonlMetadataFromFile,
   readThreadTurnsListPageFromSessionJsonl,
 } = require("./session-jsonl-history");
 const { buildApplyPatchFileChangeItem } = require("./apply-patch-changes");
+const {
+  createRuntimeProviderRouter,
+  stripRuntimeProviderFieldsForCodex,
+} = require("./runtime-provider-router");
+const { createProjectRegistry } = require("./project-registry");
 
 const execFileAsync = promisify(execFile);
 const RELAY_WATCHDOG_PING_INTERVAL_MS = 10_000;
-const CLOSE_CODE_INVALID_RELAY_REQUEST = 4000;
-const CLOSE_CODE_REPLACED_BY_NEW_MAC = 4001;
-const CLOSE_CODE_MAC_UNAUTHORIZED = 4005;
 const RELAY_HISTORY_IMAGE_REFERENCE_URL = "remodex://history-image-elided";
 const RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES = 4 * 1024 * 1024;
 const RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS = 24_000;
-const RELAY_HISTORY_RECENT_TURN_TARGET = 40;
+// Recent-turn window used only when a thread/read payload already exceeds the
+// relay soft budget: heavy threads first paint with this many newest turns and
+// older history arrives via thread/turns/list pagination. Normal threads are
+// never trimmed.
+const RELAY_HISTORY_RECENT_TURN_TARGET = 16;
 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;
@@ -87,7 +105,22 @@ 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";
+// Session cwd is stable for a rollout file, but the same thread can later get a
+// newer rollout with a different cwd; cache entries are validated against file identity.
+const RELAY_JSONL_THREAD_CWD_CACHE_TTL_MS = 5 * 60_000;
+const RELAY_JSONL_THREAD_EMPTY_CWD_CACHE_TTL_MS = 30_000;
+const RELAY_JSONL_FAST_FIRST_PAGE_WAIT_MS = 1_500;
+// The phone may be backgrounded between the provisional JSONL page and its
+// canonical reconciliation. Keep the handoff long enough that a normal
+// foreground/reconnect does not turn a coherent first page into a dead cursor.
+const RELAY_JSONL_CANONICAL_HANDOFF_TTL_MS = 10 * 60_000;
+const RELAY_JSONL_CANONICAL_HANDOFF_MAX_ENTRIES = 32;
+const JSONL_CANONICAL_HANDOFF_CURSOR_PREFIX = "remodex-jsonl-handoff-v1:";
+const RELAY_JSONL_FULL_ARTIFACT_FALLBACK_MAX_BYTES = Math.max(
+  0,
+  bufferConstants.MAX_STRING_LENGTH - (8 * 1024 * 1024)
+);
+const BRIDGE_PACKAGE_UPDATE_COMMAND = "npm install -g 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([
@@ -109,28 +142,17 @@ const RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS = [
   "previousCursor",
   "previous_cursor",
 ];
+const RELAY_TURNS_LIST_PREVIOUS_PAGINATION_RESULT_KEYS = new Set([
+  "prevCursor",
+  "prev_cursor",
+  "previousCursor",
+  "previous_cursor",
+]);
 const jsonlArtifactItemsCacheByThread = new Map();
+const jsonlThreadCwdCacheByThread = 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()
-    ? version.trim().replace(/\s+/g, "-")
-    : "dev";
-  return `RemodexBridge/${normalizedVersion}`;
-}
-
-function buildRelayAccessTokenHeaders(config = {}, env = process.env) {
-  const token = normalizeNonEmptyString(
-    config.relayAccessToken
-      || env.REMODEX_RELAY_ACCESS_TOKEN
-      || env.PHODEX_RELAY_ACCESS_TOKEN
-  );
-  return token
-    ? { "x-remodex-relay-token": token }
-    : {};
-}
-
 function evictOldestEntries(map, maxSize) {
   if (map.size <= maxSize) {
     return;
@@ -143,6 +165,540 @@ function evictOldestEntries(map, maxSize) {
   }
 }
 
+function createThreadTurnsListFastPageCoordinator({
+  waitMs = RELAY_JSONL_FAST_FIRST_PAGE_WAIT_MS,
+  handoffTTLms = RELAY_JSONL_CANONICAL_HANDOFF_TTL_MS,
+  maxHandoffs = RELAY_JSONL_CANONICAL_HANDOFF_MAX_ENTRIES,
+  payloadSoftLimitBytes = RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES,
+  sanitizeForRelay = sanitizeThreadHistoryImagesForRelay,
+  now = Date.now,
+  setTimeoutImpl = setTimeout,
+  clearTimeoutImpl = clearTimeout,
+  createToken = () => randomBytes(12).toString("hex"),
+} = {}) {
+  const handoffsByToken = new Map();
+  const latestHandoffTokenByThread = new Map();
+  const canonicalFirstPageByKey = new Map();
+
+  function pruneHandoffs() {
+    const cutoff = now() - handoffTTLms;
+    for (const [token, entry] of handoffsByToken) {
+      if (entry.createdAt >= cutoff) {
+        continue;
+      }
+      handoffsByToken.delete(token);
+      if (latestHandoffTokenByThread.get(entry.threadId) === token) {
+        latestHandoffTokenByThread.delete(entry.threadId);
+      }
+    }
+    for (const [cacheKey, entry] of canonicalFirstPageByKey) {
+      if (entry.createdAt < cutoff) {
+        canonicalFirstPageByKey.delete(cacheKey);
+      }
+    }
+    while (handoffsByToken.size > maxHandoffs) {
+      const oldestToken = handoffsByToken.keys().next().value;
+      const oldest = handoffsByToken.get(oldestToken);
+      handoffsByToken.delete(oldestToken);
+      if (oldest && latestHandoffTokenByThread.get(oldest.threadId) === oldestToken) {
+        latestHandoffTokenByThread.delete(oldest.threadId);
+      }
+    }
+  }
+
+  function rememberHandoff(threadId, canonicalOutcomePromise, jsonlFallback) {
+    pruneHandoffs();
+    const token = createToken();
+    const entry = {
+      token,
+      threadId,
+      canonicalOutcomePromise,
+      hadNonEmptyJsonl: Boolean(jsonlFallback?.response),
+      anchorTurnId: firstTurnsListTurnId(jsonlFallback?.response),
+      createdAt: now(),
+    };
+    handoffsByToken.set(token, entry);
+    latestHandoffTokenByThread.set(threadId, token);
+    pruneHandoffs();
+    return token;
+  }
+
+  function consumeHandoff(entry) {
+    if (!entry?.token) {
+      return;
+    }
+    handoffsByToken.delete(entry.token);
+    if (latestHandoffTokenByThread.get(entry.threadId) === entry.token) {
+      latestHandoffTokenByThread.delete(entry.threadId);
+    }
+  }
+
+  function canonicalFirstPageOutcome(cacheKey, canonicalRequest, fetchCanonical) {
+    pruneHandoffs();
+    const existing = canonicalFirstPageByKey.get(cacheKey);
+    if (existing) {
+      return existing.canonicalOutcomePromise;
+    }
+    const canonicalOutcomePromise = settleThreadTurnsListCanonicalOutcome(
+      fetchCanonical(canonicalRequest)
+    );
+    canonicalFirstPageByKey.set(cacheKey, {
+      canonicalOutcomePromise,
+      createdAt: now(),
+    });
+    canonicalOutcomePromise.then(() => {
+      forgetCanonicalFirstPage(cacheKey, canonicalOutcomePromise);
+    });
+    return canonicalOutcomePromise;
+  }
+
+  function forgetCanonicalFirstPage(cacheKey, canonicalOutcomePromise) {
+    const existing = canonicalFirstPageByKey.get(cacheKey);
+    if (existing?.canonicalOutcomePromise === canonicalOutcomePromise) {
+      canonicalFirstPageByKey.delete(cacheKey);
+    }
+  }
+
+  function readHandoffEntry(request) {
+    pruneHandoffs();
+    const threadId = threadIdFromRequestParams(request?.params);
+    const cursor = request?.params?.cursor;
+    const token = threadTurnsListHandoffDescriptor(cursor)?.token
+      || latestHandoffTokenByThread.get(threadId)
+      || "";
+    const entry = token ? handoffsByToken.get(token) : null;
+    return entry?.threadId === threadId ? entry : null;
+  }
+
+  async function awaitCanonicalOutcome(canonicalOutcomePromise) {
+    const outcome = await canonicalOutcomePromise;
+    if (!outcome.ok) {
+      throw outcome.error;
+    }
+    return outcome.response;
+  }
+
+  async function extendCanonicalResponseThroughAnchor(
+    response,
+    canonicalRequest,
+    anchorTurnId,
+    fetchCanonical,
+    maxPages = 12
+  ) {
+    if (threadTurnsListResponseContainsAnchor(response, anchorTurnId)) {
+      return response;
+    }
+    const firstResult = response?.result;
+    const turnsKey = findTurnsListResultKey(firstResult);
+    if (!turnsKey) {
+      return null;
+    }
+
+    let lastResult = firstResult;
+    let combinedTurns = [...firstResult[turnsKey]];
+    let cursor = readTurnsListNextCursor(firstResult);
+    const seenCursors = new Set();
+    for (let pageIndex = 0; pageIndex < maxPages && hasRelayCursor(cursor); pageIndex += 1) {
+      const cursorKey = JSON.stringify(cursor);
+      if (seenCursors.has(cursorKey)) {
+        break;
+      }
+      seenCursors.add(cursorKey);
+      const nextRequest = {
+        ...canonicalRequest,
+        params: buildAdaptiveTurnsListPageParams(
+          canonicalRequest.params,
+          RELAY_TURNS_LIST_SAFE_RETRY_LIMIT,
+          cursor
+        ),
+      };
+      const nextResponse = await awaitCanonicalOutcome(
+        settleThreadTurnsListCanonicalOutcome(fetchCanonical(nextRequest))
+      );
+      const nextResult = nextResponse?.result;
+      const nextTurnsKey = findTurnsListResultKey(nextResult);
+      if (!nextTurnsKey) {
+        break;
+      }
+      for (const turn of nextResult[nextTurnsKey]) {
+        const turnId = turnListTurnIdentifier(turn);
+        if (!turnId || !combinedTurns.some((existing) => turnListTurnIdentifier(existing) === turnId)) {
+          combinedTurns.push(turn);
+        }
+      }
+      lastResult = nextResult;
+      const combinedResponse = buildSafeTurnsListResponse(
+        canonicalRequest.id,
+        firstResult,
+        lastResult,
+        turnsKey,
+        combinedTurns
+      );
+      if (threadTurnsListResponseContainsAnchor(combinedResponse, anchorTurnId)) {
+        // The cursor belongs after every turn through the anchor. Keep that
+        // complete boundary intact, compacting items if needed; never slice
+        // turns and accidentally make the omitted range unreachable.
+        return buildCompactedCompleteTurnsListResponse({
+          requestId: canonicalRequest.id,
+          firstResult,
+          lastResult,
+          turnsKey,
+          turns: combinedTurns,
+          sanitizeForRelay,
+          sanitizeContext: buildThreadTurnsListRelaySanitizeContext(canonicalRequest),
+          payloadSoftLimitBytes,
+        });
+      }
+      const nextCursor = readTurnsListNextCursor(nextResult);
+      if (nextResult[nextTurnsKey].length === 0 || !hasRelayCursor(nextCursor)) {
+        break;
+      }
+      cursor = nextCursor;
+    }
+    return null;
+  }
+
+  async function resolveCanonicalRequest(request, fetchCanonical, existingEntry = null, {
+    alignToHandoffAnchor = false,
+    validateHandoffAnchor = false,
+    handoffAnchorTurnId = "",
+  } = {}) {
+    const canonicalRequest = canonicalThreadTurnsListRequest(request);
+    let entry = existingEntry;
+    let response = null;
+    const anchorTurnId = entry?.anchorTurnId || handoffAnchorTurnId;
+    const canMatchCanonicalAnchor = anchorTurnId
+      && !isSyntheticJsonlHistoryTurnId(anchorTurnId);
+    if (entry) {
+      const observedOutcomePromise = entry.canonicalOutcomePromise;
+      const firstOutcome = await observedOutcomePromise;
+      const firstResponseIsUsable = firstOutcome.ok
+        && !isEmptyTurnsListResponse(firstOutcome.response);
+      if (firstResponseIsUsable) {
+        response = firstOutcome.response;
+      } else {
+        if (entry.canonicalOutcomePromise === observedOutcomePromise) {
+          entry.canonicalOutcomePromise = settleThreadTurnsListCanonicalOutcome(
+            fetchCanonical(canonicalRequest)
+          );
+          entry.createdAt = now();
+        }
+      }
+    }
+
+    response = response || await awaitCanonicalOutcome(
+      entry?.canonicalOutcomePromise
+        || settleThreadTurnsListCanonicalOutcome(fetchCanonical(canonicalRequest))
+    );
+    if (entry?.hadNonEmptyJsonl && isEmptyTurnsListResponse(response)) {
+      throw new Error("Canonical thread history was empty after a non-empty JSONL first page.");
+    }
+    if (validateHandoffAnchor
+        && canMatchCanonicalAnchor
+        && !threadTurnsListResponseContainsAnchor(response, anchorTurnId)) {
+      response = await extendCanonicalResponseThroughAnchor(
+        response,
+        canonicalRequest,
+        anchorTurnId,
+        fetchCanonical
+      );
+      if (!response) {
+        throw new Error("Canonical history does not contain the JSONL handoff anchor yet.");
+      }
+    }
+    const rebound = rebindThreadTurnsListResponseId(response, request.id);
+    if (!alignToHandoffAnchor || !canMatchCanonicalAnchor) {
+      return rebound;
+    }
+    const aligned = alignThreadTurnsListResponseToAnchor(rebound, anchorTurnId);
+    if (!aligned) {
+      throw new Error("Canonical history no longer contains the JSONL handoff anchor.");
+    }
+    return aligned;
+  }
+
+  async function resolve(request, { fetchCanonical, readJsonl }) {
+    const params = request?.params || {};
+    const cursor = params.cursor;
+    const handoffDescriptor = threadTurnsListHandoffDescriptor(cursor);
+    const isHandoffRequest = cursor === JSONL_OLDER_HANDOFF_CURSOR
+      || Boolean(handoffDescriptor);
+    const requiresCanonical = params.remodexRequireCanonical === true;
+    const hasOrdinaryCursor = hasRelayCursor(cursor) && !isHandoffRequest;
+
+    if (hasOrdinaryCursor) {
+      return {
+        source: "canonical",
+        response: await resolveCanonicalRequest(request, fetchCanonical),
+        usesJsonl: false,
+      };
+    }
+
+    if (isHandoffRequest || requiresCanonical) {
+      const handoffEntry = readHandoffEntry(request);
+      const response = await resolveCanonicalRequest(request, fetchCanonical, handoffEntry, {
+        alignToHandoffAnchor: isHandoffRequest,
+        validateHandoffAnchor: true,
+        handoffAnchorTurnId: handoffDescriptor?.anchorTurnId || "",
+      });
+      consumeHandoff(handoffEntry);
+      return {
+        source: "canonical",
+        response,
+        usesJsonl: false,
+      };
+    }
+
+    const canonicalRequest = canonicalThreadTurnsListRequest(request);
+    const threadId = threadIdFromRequestParams(params);
+    const canonicalFirstPageCacheKey = canonicalThreadTurnsListRequestShapeKey(canonicalRequest);
+    const canonicalOutcomePromise = canonicalFirstPageOutcome(
+      canonicalFirstPageCacheKey,
+      canonicalRequest,
+      fetchCanonical
+    );
+    let jsonlFallback = null;
+    try {
+      jsonlFallback = await readJsonl(request);
+    } catch {
+      jsonlFallback = null;
+    }
+    // A rollout tail is a useful emergency baseline only when it contains a
+    // whole turn package. Never let a bare tail (for example a file-change or
+    // final assistant fragment) win the race with canonical history: iOS would
+    // render it as a complete conversation and then merge the real opener in
+    // later, which is exactly how orphan cards and duplicate rows appeared.
+    if (jsonlFallback?.response && !isCoherentJsonlFirstPageResponse(jsonlFallback.response)) {
+      jsonlFallback = null;
+    }
+    if (!jsonlFallback?.response) {
+      const response = await awaitCanonicalOutcome(canonicalOutcomePromise);
+      forgetCanonicalFirstPage(canonicalFirstPageCacheKey, canonicalOutcomePromise);
+      return {
+        source: "canonical",
+        response: rebindThreadTurnsListResponseId(response, request.id),
+        usesJsonl: false,
+      };
+    }
+
+    let timeoutId = null;
+    const deadline = new Promise((resolveDeadline) => {
+      timeoutId = setTimeoutImpl(() => resolveDeadline({ deadline: true }), waitMs);
+    });
+    const first = await Promise.race([canonicalOutcomePromise, deadline]);
+    if (timeoutId != null) {
+      clearTimeoutImpl(timeoutId);
+    }
+
+    if (first?.ok && !isEmptyTurnsListResponse(first.response)) {
+      if (shouldPreferJsonlFirstPage(first.response, jsonlFallback.response)) {
+        const token = rememberHandoff(threadId, canonicalOutcomePromise, jsonlFallback);
+        return {
+          source: "jsonl",
+          response: buildJsonlCanonicalHandoffResponse(
+            jsonlFallback.response,
+            request.id,
+            token,
+            firstTurnsListTurnId(jsonlFallback.response)
+          ),
+          usesJsonl: true,
+        };
+      }
+      forgetCanonicalFirstPage(canonicalFirstPageCacheKey, canonicalOutcomePromise);
+      return {
+        source: "canonical",
+        response: rebindThreadTurnsListResponseId(first.response, request.id),
+        usesJsonl: false,
+        jsonlFallback,
+      };
+    }
+
+    const token = rememberHandoff(threadId, canonicalOutcomePromise, jsonlFallback);
+    return {
+      source: "jsonl",
+      response: buildJsonlCanonicalHandoffResponse(
+        jsonlFallback.response,
+        request.id,
+        token,
+        firstTurnsListTurnId(jsonlFallback.response)
+      ),
+      usesJsonl: true,
+    };
+  }
+
+  return { resolve };
+}
+
+function settleThreadTurnsListCanonicalOutcome(promise) {
+  return Promise.resolve(promise).then(
+    (response) => ({ ok: true, response }),
+    (error) => ({ ok: false, error })
+  );
+}
+
+function threadTurnsListHandoffDescriptor(cursor) {
+  if (typeof cursor !== "string" || !cursor.startsWith(JSONL_CANONICAL_HANDOFF_CURSOR_PREFIX)) {
+    return null;
+  }
+  const raw = cursor.slice(JSONL_CANONICAL_HANDOFF_CURSOR_PREFIX.length);
+  const separatorIndex = raw.lastIndexOf(":");
+  if (separatorIndex < 0) {
+    return raw ? { anchorTurnId: "", token: raw } : null;
+  }
+  const token = raw.slice(separatorIndex + 1);
+  if (!token) {
+    return null;
+  }
+  let anchorTurnId = "";
+  try {
+    anchorTurnId = decodeURIComponent(raw.slice(0, separatorIndex));
+  } catch {
+    return null;
+  }
+  return { anchorTurnId, token };
+}
+
+function canonicalThreadTurnsListRequest(request) {
+  const params = { ...(request?.params || {}) };
+  delete params.remodexRequireCanonical;
+  delete params.remodexTurnStateOnly;
+  if (params.cursor === JSONL_OLDER_HANDOFF_CURSOR || threadTurnsListHandoffDescriptor(params.cursor)) {
+    delete params.cursor;
+  }
+  return { ...request, params };
+}
+
+function canonicalThreadTurnsListRequestShapeKey(canonicalRequest) {
+  const params = canonicalRequest?.params || {};
+  return JSON.stringify(sortJsonValueForCacheKey({
+    threadId: threadIdFromRequestParams(params),
+    params,
+  }));
+}
+
+function sortJsonValueForCacheKey(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValueForCacheKey);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.keys(value)
+      .sort()
+      .map((key) => [key, sortJsonValueForCacheKey(value[key])])
+  );
+}
+
+function rebindThreadTurnsListResponseId(response, requestId) {
+  return response && typeof response === "object"
+    ? { ...response, id: requestId }
+    : response;
+}
+
+function buildJsonlCanonicalHandoffResponse(response, requestId, token, anchorTurnId = "") {
+  const result = response?.result;
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    return response;
+  }
+  return {
+    ...response,
+    id: requestId,
+    result: {
+      ...result,
+      nextCursor: `${JSONL_CANONICAL_HANDOFF_CURSOR_PREFIX}${encodeURIComponent(anchorTurnId)}:${token}`,
+      remodexJsonlFallback: true,
+      remodexCanonicalHandoff: true,
+    },
+  };
+}
+
+function shouldPreferJsonlFirstPage(canonicalResponse, jsonlResponse) {
+  const canonicalResult = canonicalResponse?.result;
+  const jsonlResult = jsonlResponse?.result;
+  const canonicalTurnsKey = findTurnsListResultKey(canonicalResult);
+  const jsonlTurnsKey = findTurnsListResultKey(jsonlResult);
+  if (!canonicalTurnsKey || !jsonlTurnsKey) {
+    return false;
+  }
+  const jsonlTurn = jsonlResult[jsonlTurnsKey]?.[0];
+  const jsonlTurnId = turnListTurnIdentifier(jsonlTurn);
+  return Boolean(jsonlTurnId)
+    && !canonicalResult[canonicalTurnsKey].some((turn) => turnListTurnIdentifier(turn) === jsonlTurnId)
+    && shouldMergeLatestJsonlTurn(jsonlTurn);
+}
+
+function firstTurnsListTurnId(response) {
+  const result = response?.result;
+  const turnsKey = findTurnsListResultKey(result);
+  return turnsKey ? turnListTurnIdentifier(result[turnsKey]?.[0]) : "";
+}
+
+function isCoherentJsonlFirstPageResponse(response) {
+  const result = response?.result;
+  const turnsKey = findTurnsListResultKey(result);
+  const turns = turnsKey ? result[turnsKey] : null;
+  if (!Array.isArray(turns) || turns.length === 0) {
+    return false;
+  }
+  // A running turn must contain its materialized user opener. Otherwise an
+  // orphan file card or assistant tail can win the fast-page race and later
+  // be mistaken for a complete conversation. Explicit terminal turns are
+  // allowed without a user item because older compacted/system turns can be
+  // legitimately item-only.
+  const newestTurn = turns[0];
+  const items = Array.isArray(newestTurn?.items) ? newestTurn.items : null;
+  if (!items) {
+    return false;
+  }
+  if (items.length === 0) {
+    return false;
+  }
+  const status = String(newestTurn?.status || "").replace(/[_-]/g, "").toLowerCase();
+  const isExplicitTerminal = new Set(["completed", "failed", "aborted", "cancelled", "canceled", "interrupted"])
+    .has(status);
+  if (isExplicitTerminal) {
+    return true;
+  }
+  return items.some((item) => {
+    const role = String(item?.role || "").toLowerCase();
+    const type = String(item?.type || "").replace(/[_-]/g, "").toLowerCase();
+    return role === "user" || type === "usermessage";
+  });
+}
+
+function threadTurnsListResponseContainsAnchor(response, anchorTurnId) {
+  const result = response?.result;
+  const turnsKey = findTurnsListResultKey(result);
+  return Boolean(turnsKey) && result[turnsKey].some((turn) => (
+    turnListTurnIdentifier(turn) === anchorTurnId
+  ));
+}
+
+function alignThreadTurnsListResponseToAnchor(response, anchorTurnId) {
+  const result = response?.result;
+  const turnsKey = findTurnsListResultKey(result);
+  if (!turnsKey) {
+    return null;
+  }
+  const anchorIndex = result[turnsKey].findIndex((turn) => (
+    turnListTurnIdentifier(turn) === anchorTurnId
+  ));
+  if (anchorIndex < 0) {
+    return null;
+  }
+  if (anchorIndex === 0) {
+    return response;
+  }
+  return {
+    ...response,
+    result: {
+      ...result,
+      [turnsKey]: result[turnsKey].slice(anchorIndex),
+    },
+  };
+}
+
 function startBridge({
   config: explicitConfig = null,
   printPairingQr = true,
@@ -181,6 +737,9 @@ function startBridge({
   const notificationSecret = randomBytes(24).toString("hex");
   const desktopRefresher = new CodexDesktopRefresher({
     enabled: config.refreshEnabled,
+    // With IPC live sync streaming content, deep-link refreshes are only needed
+    // to navigate Desktop onto the phone-driven thread, not to reload content.
+    navigationOnly: config.desktopIpcLiveSyncEnabled,
     debounceMs: config.refreshDebounceMs,
     refreshCommand: config.refreshCommand,
     bundleId: config.codexBundleId,
@@ -209,18 +768,17 @@ function startBridge({
   let relayWatchdogTimer = null;
   let lastRelayActivityAt = 0;
   let lastConnectionStatus = null;
-  let lastConnectionError = "";
   let codexLaunchState = config.codexEndpoint ? "connected" : "starting";
   let codexHandshakeState = config.codexEndpoint ? "warm" : "cold";
   const forwardedInitializeRequestIds = new Set();
   const bridgeManagedCodexRequestWaiters = new Map();
   const forwardedRequestMethodsById = new Map();
   const relaySanitizedResponseMethodsById = new Map();
-  const relayChannels = [];
-  const codexResponseRoutesById = new Map();
-  const extraRelaySessionCount = readExtraRelaySessionCount(process.env);
+  const desktopIpcLiveOwnerObservedInboundKeys = new Set();
   const jsonlTurnsListRolloutCacheByThread = new Map();
   const jsonlTurnsListRolloutMissCacheByThread = new Map();
+  const threadTurnsListFastPageCoordinator = createThreadTurnsListFastPageCoordinator();
+  const threadRuntimeSettingsStore = createThreadRuntimeSettingsStore();
   const trackedForwardedRequestMethods = new Set([
     "account/login/start",
     "account/login/cancel",
@@ -257,7 +815,6 @@ function startBridge({
       }
     },
   });
-  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) {
@@ -273,6 +830,14 @@ function startBridge({
   const rolloutLiveMirror = !config.codexEndpoint
     ? createRolloutLiveMirrorController({
       sendApplicationResponse,
+      // One live source per thread. The follower keeps fresh/idle Desktop state
+      // authoritative, but yields an active cache that stopped broadcasting;
+      // a later Desktop snapshot is announced as a new source epoch so the
+      // phone performs canonical repair instead of mixing both mirrors.
+      shouldSuppressThread: (threadId) => shouldSuppressRolloutMirrorForThread(
+        threadId,
+        { desktopIpcActionFollower, desktopIpcLiveOwner }
+      ),
     })
     : null;
   const desktopIpcActionFollower = !config.codexEndpoint
@@ -281,7 +846,29 @@ function startBridge({
       readConversationState: async (threadId) => seedConversationStateFromThreadRead(
         await sendCodexRequest("thread/read", { threadId })
       ),
+      forwardToLocalCodex: (rawMessage) => {
+        observeDesktopIpcLiveOwnerInbound(rawMessage);
+        forwardInboundRequestToCodex(rawMessage);
+      },
+      // Threads streamed by the bridge's own app-server must never be held,
+      // served from Desktop echoes, or routed over the IPC bus.
+      isLocallyOwnedThread: (threadId) => Boolean(desktopIpcLiveOwner?.isThreadOwned(threadId)),
+      normalizeTurnStartParams: normalizeTurnStartParamsForCodex,
+      runtimeSettingsStore: threadRuntimeSettingsStore,
       socketPath: config.desktopIpcSocketPath || undefined,
+      snapshotDebounceMs: config.desktopIpcSnapshotDebounceMs,
+    })
+    : null;
+  const desktopIpcLiveOwner = !config.codexEndpoint
+    ? createDesktopIpcLiveOwner({
+      enabled: config.desktopIpcLiveSyncEnabled !== false,
+      sendApplicationResponse,
+      sendCodexRequest,
+      sendRawCodexMessage: (rawMessage) => codex.send(rawMessage),
+      normalizeTurnStartParams: normalizeTurnStartParamsForCodex,
+      runtimeSettingsStore: threadRuntimeSettingsStore,
+      socketPath: config.desktopIpcSocketPath || undefined,
+      snapshotDebounceMs: config.desktopIpcSnapshotDebounceMs,
     })
     : null;
   let contextUsageWatcher = null;
@@ -293,6 +880,14 @@ function startBridge({
     appPath: config.codexAppPath,
     logPrefix: "[remodex]",
   });
+  const projectRegistry = createProjectRegistry();
+  const runtimeProviderRouter = createRuntimeProviderRouter({
+    sendApplicationResponse,
+    sendCodexRequest,
+    sendRuntimeMessage: sendRuntimeApplicationMessage,
+    projectRegistry,
+    logPrefix: "[remodex]",
+  });
   const voiceHandler = createVoiceHandler({
     sendCodexRequest,
     logPrefix: "[remodex]",
@@ -370,9 +965,11 @@ function startBridge({
     clearReconnectTimer();
     clearRelayWatchdog();
     bridgeStatusPublisher.stopHeartbeat();
+    runtimeProviderRouter.shutdown();
     stopContextUsageWatcher();
     rolloutLiveMirror?.stopAll();
     desktopIpcActionFollower?.stopAll();
+    desktopIpcLiveOwner?.stopAll();
   }
 
   function stopBridge() {
@@ -422,13 +1019,12 @@ function startBridge({
   }
 
   // Keeps npm start output compact by emitting only high-signal connection states.
-  function logConnectionStatus(status, lastError = "") {
-    if (lastConnectionStatus === status && lastConnectionError === lastError) {
+  function logConnectionStatus(status) {
+    if (lastConnectionStatus === status) {
       return;
     }
 
     lastConnectionStatus = status;
-    lastConnectionError = lastError;
     if (status !== "connected") {
       activePhoneSummary = null;
     }
@@ -436,16 +1032,13 @@ function startBridge({
       state: "running",
       connectionStatus: status,
       pid: process.pid,
-      lastError,
+      lastError: "",
     });
     console.log(`[remodex] ${status}`);
-    if (lastError) {
-      console.error(`[remodex] ${lastError}`);
-    }
   }
 
   // Retries the relay socket while preserving the active Codex process and session id.
-  function scheduleRelayReconnect(closeCode, closeReason = "") {
+  function scheduleRelayReconnect(closeCode) {
     if (isShuttingDown) {
       return;
     }
@@ -485,10 +1078,8 @@ function startBridge({
       },
       // The relay uses this per-session secret to authenticate the first push registration.
       headers: {
-        "User-Agent": buildRelayUserAgentHeader(),
         "x-role": "mac",
         "x-notification-secret": notificationSecret,
-        ...buildRelayAccessTokenHeaders(config),
         ...buildMacRegistrationHeaders(deviceState, pairingSession),
       },
     });
@@ -514,7 +1105,7 @@ function startBridge({
           }
         },
         onApplicationMessage(plaintextMessage) {
-          handleApplicationMessage(plaintextMessage, primaryRelayChannel);
+          handleApplicationMessage(plaintextMessage);
         },
       })) {
         return;
@@ -529,12 +1120,11 @@ function startBridge({
       markRelayActivity();
     });
 
-    nextSocket.on("close", (code, reason) => {
-      const closeReason = normalizeWebSocketCloseReason(reason);
+    nextSocket.on("close", (code) => {
       if (socket === nextSocket) {
         clearRelayWatchdog();
       }
-      logConnectionStatus("disconnected", buildRelayCloseStatusError(code, closeReason));
+      logConnectionStatus("disconnected");
       if (socket === nextSocket) {
         socket = null;
       }
@@ -542,7 +1132,7 @@ function startBridge({
       // 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);
+      scheduleRelayReconnect(code);
     });
 
     nextSocket.on("error", () => {
@@ -553,191 +1143,45 @@ 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: {
-          "User-Agent": buildRelayUserAgentHeader(),
-          "x-role": "mac",
-          "x-notification-secret": notificationSecret,
-          ...buildRelayAccessTokenHeaders(config),
-          ...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)) {
+    // Streaming deltas make this the hottest path in the bridge: parse the
+    // envelope once and share the read-only object with every observer.
+    const parsedMessage = parseBridgeMessage(message);
+    if (handleBridgeManagedCodexResponse(message, parsedMessage)) {
       return;
     }
-    updatePendingAuthLoginFromCodexMessage(message);
-    trackCodexHandshakeState(message);
-    desktopRefresher.handleOutbound(message);
-    pushNotificationTracker.handleOutbound(message);
-    rememberThreadFromMessage("codex", message);
-    sendCodexOutboundToMobile(message);
+    updatePendingAuthLoginFromCodexMessage(message, parsedMessage);
+    trackCodexHandshakeState(message, parsedMessage);
+    desktopRefresher.handleOutbound(message, parsedMessage);
+    desktopIpcLiveOwner?.observeOutbound(message, parsedMessage);
+    pushNotificationTracker.handleOutbound(message, parsedMessage);
+    rememberThreadFromMessage("codex", message, parsedMessage);
+    secureTransport.queueOutboundApplicationMessage(
+      sanitizeRelayBoundCodexMessage(message, parsedMessage),
+      sendRelayWireMessage
+    );
   });
 
   codex.onClose(() => {
     const wasShuttingDown = isShuttingDown;
     clearRelayWatchdog();
     bridgeStatusPublisher.stopHeartbeat();
+    logConnectionStatus("disconnected");
     const lastError = wasShuttingDown
       ? ""
-      : (lastConnectionError || "Codex transport closed unexpectedly.");
-    logConnectionStatus("disconnected", lastError);
+      : "Codex transport closed unexpectedly.";
     publishBridgeStatus({
       state: wasShuttingDown ? "stopped" : "error",
       connectionStatus: "disconnected",
@@ -752,44 +1196,42 @@ 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, prepareBridgeShutdown));
   process.on("SIGTERM", () => shutdown(codex, () => socket, prepareBridgeShutdown));
 
   // Routes decrypted app payloads through the same bridge handlers as before.
-  function handleApplicationMessage(rawMessage, relayChannel = primaryRelayChannel) {
-    const sendResponse = (responseMessage) => sendApplicationResponseToChannel(responseMessage, relayChannel);
-    if (handleBridgeManagedHandshakeMessage(rawMessage, sendResponse)) {
+  function handleApplicationMessage(rawMessage) {
+    const parsedMessage = parseBridgeMessage(rawMessage);
+    if (handleBridgeManagedHandshakeMessage(rawMessage, sendApplicationResponse, parsedMessage)) {
       return;
     }
-    if (handleBridgeManagedAccountRequest(rawMessage, sendResponse)) {
+    if (handleBridgeManagedAccountRequest(rawMessage, sendApplicationResponse, parsedMessage)) {
       return;
     }
-    if (voiceHandler.handleVoiceRequest(rawMessage, sendResponse)) {
+    if (voiceHandler.handleVoiceRequest(rawMessage, sendApplicationResponse, parsedMessage)) {
       return;
     }
-    if (handleThreadContextRequest(rawMessage, sendResponse)) {
+    if (handleThreadContextRequest(rawMessage, sendApplicationResponse, parsedMessage)) {
       return;
     }
-    if (handleWorkspaceRequest(rawMessage, sendResponse)) {
+    if (handleWorkspaceRequest(rawMessage, sendApplicationResponse)) {
       return;
     }
-    if (handleProjectRequest(rawMessage, sendResponse)) {
+    if (handleProjectRequest(rawMessage, sendApplicationResponse, { projectRegistry })) {
       return;
     }
-    if (handlePetRequest(rawMessage, sendResponse)) {
+    if (handlePetRequest(rawMessage, sendApplicationResponse)) {
       return;
     }
-    if (notificationsHandler.handleNotificationsRequest(rawMessage, sendResponse)) {
+    if (notificationsHandler.handleNotificationsRequest(rawMessage, sendApplicationResponse)) {
       return;
     }
-    if (handleDesktopRequest(rawMessage, sendResponse, {
+    if (handleDesktopRequest(rawMessage, sendApplicationResponse, {
       bundleId: config.codexBundleId,
       appPath: config.codexAppPath,
       readBridgePreferences,
@@ -797,200 +1239,102 @@ function startBridge({
       updateBridgePackageAndRestart,
     })) {
       return;
-    }
-    if (handleGitRequest(rawMessage, sendResponse, {
-      codexAppPath: config.codexAppPath,
-      onThreadNameSet: sendThreadNameUpdatedNotification,
-    })) {
-      return;
-    }
-    desktopRefresher.handleInbound(rawMessage);
-    rolloutLiveMirror?.observeInbound(rawMessage);
-    if (desktopIpcActionFollower?.observeInbound(rawMessage)) {
-      return;
-    }
-    if (handleBridgeManagedThreadTurnsListRequest(rawMessage, sendResponse)) {
-      return;
-    }
-    const codexRequest = disableUnsupportedReasoningSummaryForTurnStart(rawMessage);
-    const codexMessage = prepareCodexForwardMessage(codexRequest, relayChannel);
-    rememberForwardedRequestMethod(codexMessage);
-    rememberThreadFromMessage("phone", codexMessage);
-    mirrorUserMessageToPeerDevices(rawMessage, relayChannel);
-    codex.send(codexMessage);
-  }
-
-  // Encrypts bridge-generated responses instead of letting the relay see plaintext.
-  function sendApplicationResponse(rawMessage) {
-    sendApplicationResponseToChannels(rawMessage, relayChannels);
-  }
-
-  function sendApplicationResponseToChannel(rawMessage, relayChannel = primaryRelayChannel) {
-    sendApplicationResponseToChannels(rawMessage, [relayChannel]);
-  }
-
-  function sendApplicationResponseToChannels(rawMessage, channels) {
-    const normalizedChannels = channels.filter(Boolean);
-    if (normalizedChannels.length === 0) {
+    }
+    if (handleGitRequest(rawMessage, sendApplicationResponse, {
+      codexAppPath: config.codexAppPath,
+      onThreadNameSet: sendThreadNameUpdatedNotification,
+    })) {
       return;
     }
-
-    const sanitizedMessage = sanitizeRelayBoundCodexMessage(rawMessage);
-    for (const relayChannel of normalizedChannels) {
-      queueSanitizedApplicationMessageToChannel(sanitizedMessage, relayChannel);
+    desktopRefresher.handleInbound(rawMessage, parsedMessage);
+    rolloutLiveMirror?.observeInbound(rawMessage, parsedMessage);
+    // Track the request method BEFORE follower interception: responses the
+    // follower serves from projected Desktop state must hit the same relay
+    // sanitize/trim budget as app-server responses, or heavy threads ship as
+    // one oversized frame and kill the phone's websocket (EMSGSIZE).
+    rememberForwardedRequestMethod(rawMessage);
+    if (desktopIpcActionFollower?.observeInbound(rawMessage, parsedMessage)) {
+      return;
     }
-  }
-
-  function queueSanitizedApplicationMessageToChannel(sanitizedMessage, relayChannel) {
-    if (!relayChannel) {
+    if (runtimeProviderRouter.handleApplicationMessage(rawMessage, {
+      sendResponse: sendApplicationResponse,
+    })) {
+      return;
+    }
+    observeDesktopIpcLiveOwnerInbound(rawMessage, parsedMessage);
+    if (handleBridgeManagedThreadTurnsListRequest(rawMessage, sendApplicationResponse)) {
       return;
     }
+    forwardInboundRequestToCodex(rawMessage);
+  }
 
-    relayChannel.secureTransport.queueOutboundApplicationMessage(
-      sanitizedMessage,
-      relayChannel.sendWireMessage
+  function forwardInboundRequestToCodex(rawMessage) {
+    const codexRequest = stripRuntimeProviderFieldsForCodex(
+      normalizeTurnStartForCodex(rawMessage)
     );
+    rememberKnownProjectFromRequest("codex-request", codexRequest);
+    rememberForwardedRequestMethod(rawMessage);
+    rememberThreadFromMessage("phone", codexRequest);
+    codex.send(codexRequest);
   }
 
-  // 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));
+  // Held Desktop-ownership probes can later fall back locally, so observe each
+  // phone request at most once in the live owner even if it passes both paths.
+  function observeDesktopIpcLiveOwnerInbound(rawMessage, parsedMessage = null) {
+    if (!desktopIpcLiveOwner) {
+      return;
     }
-    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);
+    const inboundKey = desktopIpcLiveOwnerInboundKey(rawMessage, parsedMessage);
+    if (inboundKey) {
+      if (desktopIpcLiveOwnerObservedInboundKeys.has(inboundKey)) {
         return;
       }
+      desktopIpcLiveOwnerObservedInboundKeys.add(inboundKey);
+      evictOldestEntries(desktopIpcLiveOwnerObservedInboundKeys, FORWARDED_REQUEST_METHODS_MAX_SIZE);
     }
-
-    sendApplicationResponse(rawMessage);
-  }
-
-  function pruneExpiredCodexResponseRoutes() {
-    const cutoff = Date.now() - forwardedRequestMethodTTLms;
-    for (const [requestId, route] of codexResponseRoutesById.entries()) {
-      if (!route || route.createdAt < cutoff) {
-        codexResponseRoutesById.delete(requestId);
-      }
-    }
+    desktopIpcLiveOwner.observeInbound(rawMessage, parsedMessage);
   }
 
-  // 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;
+  function desktopIpcLiveOwnerInboundKey(rawMessage, parsedMessage = null) {
+    const parsed = parsedMessage ?? safeParseJSON(rawMessage);
+    const method = typeof parsed?.method === "string" ? parsed.method : "";
+    if (!method || parsed?.id == null) {
+      return "";
     }
-
-    sendApplicationResponseToChannels(JSON.stringify(mirrorNotification), peerChannels);
+    // extractThreadId only understands turn/thread start and completion params;
+    // archive, steer, interrupt, and compact requests need the generic fields so
+    // same-id requests for different threads never share a dedupe key.
+    const threadId = extractThreadId(method, parsed.params)
+      || readString(parsed?.params?.threadId)
+      || readString(parsed?.params?.thread_id)
+      || readString(parsed?.params?.conversationId)
+      || readString(parsed?.params?.conversation_id)
+      || "";
+    return `${method}:${threadId}:${String(parsed.id)}`;
   }
 
-  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) {
+  function parseBridgeMessage(rawMessage) {
+    try {
+      return JSON.parse(rawMessage);
+    } catch {
       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);
+  // Encrypts bridge-generated responses instead of letting the relay see plaintext.
+  function sendApplicationResponse(rawMessage) {
+    secureTransport.queueOutboundApplicationMessage(
+      sanitizeRelayBoundCodexMessage(rawMessage),
+      sendRelayWireMessage
+    );
   }
 
-  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"));
+  // Provider output keeps the same desktop refresh, push, and secure relay side effects as Codex output.
+  function sendRuntimeApplicationMessage(provider, rawMessage) {
+    desktopRefresher.handleOutbound(rawMessage);
+    pushNotificationTracker.handleOutbound(rawMessage);
+    rememberThreadFromMessage(provider, rawMessage);
+    sendApplicationResponse(rawMessage);
   }
 
   // Mirrors accepted local renames back to the phone using the existing push-event shape.
@@ -1020,25 +1364,41 @@ function startBridge({
 
     rememberThreadFromMessage("phone", rawMessage);
     (async () => {
+      let didRespond = false;
+      const respondOnce = (payload) => {
+        if (didRespond) {
+          return;
+        }
+        didRespond = true;
+        sendResponse(payload);
+      };
       try {
-        const response = await fetchAdaptiveThreadTurnsListForRelay(request, {
-          fetchPage: (params) => sendCodexRequest("thread/turns/list", params),
+        const selection = await threadTurnsListFastPageCoordinator.resolve(request, {
+          fetchCanonical: (canonicalRequest) => fetchAdaptiveThreadTurnsListForRelay(canonicalRequest, {
+            fetchPage: (params) => sendCodexRequest("thread/turns/list", params),
+          }),
+          readJsonl: (jsonlRequest) => maybeBuildJsonlThreadTurnsListFallback(jsonlRequest, null),
         });
-        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(),
+        let responsePayload = selection.response;
+        if (selection.source === "canonical" && selection.jsonlFallback?.response?.result) {
+          responsePayload = maybeMergeLatestJsonlTurnIntoTurnsListResponse(
+            request,
+            selection.response,
+            selection.jsonlFallback.response.result
+          ) || selection.response;
+        }
+        sendBridgeManagedThreadTurnsListResponse(request, responsePayload, respondOnce, {
+          skipJsonlArtifactAugmentation: selection.usesJsonl,
         });
-        sendResponse(sanitizeThreadHistoryImagesForRelay(
-          JSON.stringify(responsePayload),
-          "thread/turns/list",
-          finalSanitizeContext
-        ));
       } catch (error) {
-        sendResponse(createJsonRpcErrorResponse(
+        const jsonlFallback = maybeBuildJsonlThreadTurnsListFallback(request, null);
+        if (jsonlFallback?.response && isCoherentJsonlFirstPageResponse(jsonlFallback.response)) {
+          sendBridgeManagedThreadTurnsListResponse(request, jsonlFallback.response, respondOnce, {
+            skipJsonlArtifactAugmentation: true,
+          });
+          return;
+        }
+        respondOnce(createJsonRpcErrorResponse(
           request.id,
           error,
           "thread_turns_list_failed"
@@ -1049,16 +1409,34 @@ function startBridge({
     return true;
   }
 
+  function sendBridgeManagedThreadTurnsListResponse(request, response, sendResponse, {
+    skipJsonlArtifactAugmentation = false,
+  } = {}) {
+    const finalSanitizeContext = buildThreadTurnsListRelaySanitizeContext(request, {
+      skipJsonlArtifactAugmentation,
+    });
+    relaySanitizedResponseMethodsById.set(String(request.id), {
+      method: "thread/turns/list",
+      ...finalSanitizeContext,
+      createdAt: Date.now(),
+    });
+    sendResponse(sanitizeThreadHistoryImagesForRelay(
+      JSON.stringify(response),
+      "thread/turns/list",
+      finalSanitizeContext
+    ));
+  }
+
   function maybeBuildJsonlThreadTurnsListFallback(request, response) {
     const params = request?.params || {};
     const threadId = normalizeNonEmptyString(params.threadId)
       || normalizeNonEmptyString(params.thread_id);
-    if (!threadId || hasRelayCursor(params.cursor)) {
+    if (!threadId || hasRelayCursor(params.cursor) || params.remodexRequireCanonical === true) {
       return null;
     }
 
     try {
-      const responseIsEmpty = isEmptyTurnsListResponse(response);
+      const responseIsEmpty = response == null || isEmptyTurnsListResponse(response);
       const rolloutPath = resolveJsonlTurnsListRolloutPathForFallback({
         threadId,
         responseIsEmpty,
@@ -1069,10 +1447,20 @@ function startBridge({
         return null;
       }
 
+      // A first page is the local baseline for a newly opened thread. Honor a
+      // caller's larger request, but never manufacture the old one-turn tail:
+      // it has no room to preserve surrounding history while canonical data is
+      // still catching up.
+      const requestedLimit = Number.isInteger(params.limit) && params.limit > 0
+        ? params.limit
+        : RELAY_TURNS_LIST_MAX_INITIAL_LIMIT;
+      const firstPageLimit = params.cursor == null
+        ? Math.max(requestedLimit, RELAY_TURNS_LIST_MAX_INITIAL_LIMIT)
+        : requestedLimit;
       const result = readThreadTurnsListPageFromSessionJsonl(rolloutPath, {
         threadId,
-        limit: params.limit,
-        maxLimit: 1,
+        limit: firstPageLimit,
+        maxLimit: RELAY_TURNS_LIST_MAX_INITIAL_LIMIT,
         cursor: params.cursor,
       });
       const turnsKey = findTurnsListResultKey(result);
@@ -1081,7 +1469,7 @@ function startBridge({
       }
 
       if (!responseIsEmpty) {
-        const mergedResponse = maybeMergeLatestJsonlTurnIntoTurnsListResponse(request, response, result, params);
+        const mergedResponse = maybeMergeLatestJsonlTurnIntoTurnsListResponse(request, response, result);
         return mergedResponse ? { response: mergedResponse, usesJsonl: true } : null;
       }
 
@@ -1147,11 +1535,9 @@ function startBridge({
 
   // Handles the bridge-owned auth status wrappers without exposing tokens to the phone.
   // This dispatcher stays synchronous so non-account messages can continue down the normal routing chain.
-  function handleBridgeManagedAccountRequest(rawMessage, sendResponse) {
-    let parsed = null;
-    try {
-      parsed = JSON.parse(rawMessage);
-    } catch {
+  function handleBridgeManagedAccountRequest(rawMessage, sendResponse, parsedMessage = null) {
+    const parsed = parsedMessage || parseBridgeMessage(rawMessage);
+    if (!parsed) {
       return false;
     }
 
@@ -1306,16 +1692,30 @@ function startBridge({
   }
 
   // Replaces huge inline desktop-history images with lightweight references before relay encryption.
-  function sanitizeRelayBoundCodexMessage(rawMessage) {
+  function sanitizeRelayBoundCodexMessage(rawMessage, parsedMessage = null) {
     pruneExpiredForwardedRequestMethods();
-    const normalizedMessage = normalizeRelayBoundJsonRpcMessage(rawMessage, {
+    let normalizedMessage = normalizeRelayBoundJsonRpcMessage(rawMessage, {
       pendingRequestMethodsById: relaySanitizedResponseMethodsById,
+      parsedMessage,
     });
     if (!normalizedMessage) {
       return null;
     }
 
-    const parsed = safeParseJSON(normalizedMessage);
+    // Streaming deltas hit this path dozens of times per second; when the
+    // envelope passed through normalization untouched, reuse the parse the
+    // caller already paid for instead of re-parsing the same bytes.
+    let parsed = normalizedMessage === rawMessage && parsedMessage
+      ? parsedMessage
+      : safeParseJSON(normalizedMessage);
+    const sanitizedLiveMessage = sanitizeLiveUserNotification(parsed);
+    if (!sanitizedLiveMessage) {
+      return null;
+    }
+    if (sanitizedLiveMessage !== parsed) {
+      parsed = sanitizedLiveMessage;
+      normalizedMessage = JSON.stringify(parsed);
+    }
     const responseId = parsed?.id;
     if (responseId == null) {
       return sanitizeLiveGeneratedImageMessageForRelay(normalizedMessage);
@@ -1327,12 +1727,19 @@ function startBridge({
     }
     relaySanitizedResponseMethodsById.delete(String(responseId));
 
+    if (trackedRequest.method === "thread/list"
+      || trackedRequest.method === "thread/read"
+      || trackedRequest.method === "thread/resume") {
+      threadRuntimeSettingsStore.enrichResponse(trackedRequest.method, parsed);
+      normalizedMessage = JSON.stringify(parsed);
+    }
+
     return sanitizeThreadHistoryImagesForRelay(normalizedMessage, trackedRequest.method, trackedRequest);
   }
 
-  function updatePendingAuthLoginFromCodexMessage(rawMessage) {
+  function updatePendingAuthLoginFromCodexMessage(rawMessage, parsedMessage = null) {
     pruneExpiredForwardedRequestMethods();
-    const parsed = safeParseJSON(rawMessage);
+    const parsed = parsedMessage ?? safeParseJSON(rawMessage);
     const responseId = parsed?.id;
     if (responseId != null) {
       const trackedRequest = forwardedRequestMethodsById.get(String(responseId));
@@ -1405,6 +1812,7 @@ function startBridge({
     evictOldestEntries(jsonlArtifactItemsCacheByThread, RELAY_JSONL_ARTIFACT_CACHE_MAX_ENTRIES);
     evictOldestEntries(jsonlTurnsListRolloutCacheByThread, JSONL_ROLLOUT_PATH_CACHE_MAX_SIZE);
     evictOldestEntries(jsonlTurnsListRolloutMissCacheByThread, JSONL_ROLLOUT_PATH_CACHE_MAX_SIZE);
+    evictOldestEntries(jsonlThreadCwdCacheByThread, JSONL_ROLLOUT_PATH_CACHE_MAX_SIZE);
   }
 
   function safeParseJSON(value) {
@@ -1415,8 +1823,8 @@ function startBridge({
     }
   }
 
-  function rememberThreadFromMessage(source, rawMessage) {
-    const context = extractBridgeMessageContext(rawMessage);
+  function rememberThreadFromMessage(source, rawMessage, parsedMessage = null) {
+    const context = extractBridgeMessageContext(rawMessage, parsedMessage);
     if (!context.threadId) {
       return;
     }
@@ -1427,6 +1835,33 @@ function startBridge({
     }
   }
 
+  // Captures explicit cwd selections before Codex creates the first thread, so
+  // provider-neutral pickers do not depend on a later provider-specific message.
+  function rememberKnownProjectFromRequest(source, rawMessage) {
+    const parsed = safeParseJSON(rawMessage);
+    const method = typeof parsed?.method === "string" ? parsed.method.trim() : "";
+    if (method !== "thread/start" && method !== "turn/start") {
+      return;
+    }
+
+    const params = parsed?.params || {};
+    const cwd = normalizeNonEmptyString(
+      params.cwd || params.current_working_directory || params.working_directory
+    );
+    if (!cwd) {
+      return;
+    }
+
+    try {
+      projectRegistry.rememberProjectPath(cwd, {
+        source,
+        provider: "codex",
+      });
+    } catch {
+      // Registry persistence is best-effort; thread creation must keep flowing.
+    }
+  }
+
   // Mirrors CodexMonitor's persisted token_count fallback so the phone keeps
   // receiving context-window usage even when the runtime omits live thread usage.
   function ensureContextUsageWatcher({ threadId, turnId }) {
@@ -1493,11 +1928,9 @@ 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, sendResponse = sendApplicationResponse) {
-    let parsed = null;
-    try {
-      parsed = JSON.parse(rawMessage);
-    } catch {
+  function handleBridgeManagedHandshakeMessage(rawMessage, sendResponse = sendApplicationResponse, parsedMessage = null) {
+    const parsed = parsedMessage || parseBridgeMessage(rawMessage);
+    if (!parsed) {
       return false;
     }
 
@@ -1602,11 +2035,9 @@ function startBridge({
   }
 
   // Learns whether the underlying Codex transport has already completed its own MCP handshake.
-  function trackCodexHandshakeState(rawMessage) {
-    let parsed = null;
-    try {
-      parsed = JSON.parse(rawMessage);
-    } catch {
+  function trackCodexHandshakeState(rawMessage, parsedMessage = null) {
+    const parsed = parsedMessage ?? safeParseJSON(rawMessage);
+    if (!parsed) {
       return;
     }
 
@@ -1670,11 +2101,9 @@ function startBridge({
 
   // Intercepts responses for bridge-private requests so only user-visible app-server traffic
   // is forwarded back through secure transport.
-  function handleBridgeManagedCodexResponse(rawMessage) {
-    let parsed = null;
-    try {
-      parsed = JSON.parse(rawMessage);
-    } catch {
+  function handleBridgeManagedCodexResponse(rawMessage, parsedMessage = null) {
+    const parsed = parsedMessage ?? safeParseJSON(rawMessage);
+    if (!parsed) {
       return false;
     }
 
@@ -1734,11 +2163,6 @@ function startBridge({
   function sendRelayRegistrationUpdate(nextDeviceState) {
     deviceState = nextDeviceState;
     if (socket?.readyState !== WebSocket.OPEN) {
-      for (const relayChannel of relayChannels) {
-        if (relayChannel !== primaryRelayChannel) {
-          sendExtraRelayRegistrationUpdate(relayChannel, nextDeviceState);
-        }
-      }
       return;
     }
 
@@ -1746,11 +2170,6 @@ function startBridge({
       kind: "relayMacRegistration",
       registration: buildMacRegistration(nextDeviceState, pairingSession),
     }));
-    for (const relayChannel of relayChannels) {
-      if (relayChannel !== primaryRelayChannel) {
-        sendExtraRelayRegistrationUpdate(relayChannel, nextDeviceState);
-      }
-    }
   }
 
   function readBridgePreferences() {
@@ -1832,6 +2251,9 @@ function startBridge({
         stdio: "ignore",
         env: process.env,
       });
+      child.on?.("error", (error) => {
+        console.warn(`[remodex] Failed to schedule the post-update bridge restart: ${error?.message || error}`);
+      });
       child.unref?.();
     }, BRIDGE_RESTART_AFTER_UPDATE_DELAY_MS);
     restartTimer.unref?.();
@@ -1932,7 +2354,7 @@ function createMacOSBridgeWakeAssertion({
   };
 }
 
-// Registers the canonical Mac identity; legacy relay headers can expose one trusted device for auto-resolve.
+// Registers the canonical Mac identity and the one trusted phone allowed for auto-resolve.
 function buildMacRegistrationHeaders(deviceState, pairingSession) {
   const registration = buildMacRegistration(deviceState, pairingSession);
   const headers = {
@@ -1950,20 +2372,6 @@ 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 {
@@ -2021,7 +2429,7 @@ function shortFingerprint(value) {
   return createHash("sha256").update(normalized).digest("hex").slice(0, 8);
 }
 
-function shutdown(codex, getSocket, beforeExit = () => {}, { exitCode = 0 } = {}) {
+function shutdown(codex, getSocket, beforeExit = () => {}) {
   beforeExit();
 
   const socket = getSocket();
@@ -2031,41 +2439,7 @@ function shutdown(codex, getSocket, beforeExit = () => {}, { exitCode = 0 } = {}
 
   codex.shutdown();
 
-  setTimeout(() => process.exit(exitCode), 100);
-}
-
-function isTerminalRelayCloseCode(closeCode) {
-  return closeCode === CLOSE_CODE_INVALID_RELAY_REQUEST
-    || closeCode === CLOSE_CODE_REPLACED_BY_NEW_MAC
-    || closeCode === CLOSE_CODE_MAC_UNAUTHORIZED;
-}
-
-function normalizeWebSocketCloseReason(reason) {
-  if (typeof reason === "string") {
-    return reason.trim();
-  }
-
-  if (Buffer.isBuffer(reason)) {
-    return reason.toString("utf8").trim();
-  }
-
-  return "";
-}
-
-function buildRelayCloseStatusError(closeCode, closeReason = "") {
-  if (!Number.isInteger(closeCode) || closeCode === 1000 || closeCode === 1005) {
-    return "";
-  }
-
-  const normalizedReason = normalizeNonEmptyString(closeReason);
-  if (closeCode === CLOSE_CODE_MAC_UNAUTHORIZED) {
-    return normalizedReason
-      || "Relay authorization failed. Set REMODEX_RELAY_ACCESS_TOKEN or use a relay that does not require a Mac access token.";
-  }
-
-  return normalizedReason
-    ? `Relay closed the connection (${closeCode}): ${normalizedReason}`
-    : `Relay closed the connection (${closeCode}).`;
+  setTimeout(() => process.exit(0), 100);
 }
 
 // Forces app-server summary generation off for models whose Responses API calls
@@ -2097,17 +2471,86 @@ function disableUnsupportedReasoningSummaryForTurnStart(rawMessage) {
   });
 }
 
+function normalizeTurnStartParamsForCodex(params) {
+  const normalizedRawMessage = normalizeTurnStartForCodex(JSON.stringify({
+    method: "turn/start",
+    params,
+  }));
+  const parsed = parseBridgeJSON(normalizedRawMessage);
+  return parsed?.params && typeof parsed.params === "object" && !Array.isArray(parsed.params)
+    ? parsed.params
+    : params;
+}
+
+// A turn/start can carry the same runtime choice twice: in the legacy top-level
+// model/effort fields and in collaborationMode.settings. Codex treats the nested
+// collaboration settings as authoritative, so a stale Desktop value there can
+// silently override the model selected on the phone. Keep both representations
+// aligned before either direct app-server forwarding or Desktop-follower routing.
+function normalizeTurnStartForCodex(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) {
+    return rawMessage;
+  }
+
+  const model = normalizeNonEmptyString(params.model);
+  const effort = normalizeNonEmptyString(params.effort);
+  let changed = false;
+  let nextParams = params;
+
+  for (const collaborationKey of ["collaborationMode", "collaboration_mode"]) {
+    const collaborationMode = nextParams[collaborationKey];
+    const settings = collaborationMode?.settings;
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+      continue;
+    }
+
+    const nextSettings = { ...settings };
+    let settingsChanged = false;
+    if (model && normalizeNonEmptyString(settings.model) !== model) {
+      nextSettings.model = model;
+      settingsChanged = true;
+    }
+    if (effort && normalizeNonEmptyString(settings.reasoning_effort) !== effort) {
+      nextSettings.reasoning_effort = effort;
+      settingsChanged = true;
+    }
+    if (!settingsChanged) {
+      continue;
+    }
+
+    nextParams = {
+      ...nextParams,
+      [collaborationKey]: {
+        ...collaborationMode,
+        settings: nextSettings,
+      },
+    };
+    changed = true;
+  }
+
+  const alignedRawMessage = changed
+    ? JSON.stringify({ ...parsed, params: nextParams })
+    : rawMessage;
+  return disableUnsupportedReasoningSummaryForTurnStart(alignedRawMessage);
+}
+
 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 {
-    parsed = JSON.parse(rawMessage);
-  } catch {
+function extractBridgeMessageContext(rawMessage, parsedMessage = null) {
+  const parsed = parsedMessage ?? parseBridgeJSON(rawMessage);
+  if (!parsed) {
     return { method: "", threadId: null, turnId: null };
   }
 
@@ -2269,6 +2712,7 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
     const remaining = requestedLimit - combinedTurns.length;
     const pageLimit = selectAdaptiveTurnsListBatchLimit(combinedTurns.length, remaining);
     const pageParams = buildAdaptiveTurnsListPageParams(params, pageLimit, nextCursor);
+    const responseBeforePage = response;
     let page;
 
     try {
@@ -2314,7 +2758,31 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
     response = buildSafeTurnsListResponse(request.id, firstResult, lastResult, turnsKey, combinedTurns);
 
     if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, sanitizeContext) >= payloadSoftLimitBytes) {
-      response = buildLargestSafeTurnsListResponse({
+      if (responseBeforePage) {
+        // The server cursor belongs after the entire oversized batch. Return
+        // the previous complete cursor boundary instead of slicing turns out
+        // of this batch and making them unreachable.
+        response = responseBeforePage;
+        break;
+      }
+      if (pageTurns.length > pageLimit) {
+        const completeResponse = buildCompactedCompleteTurnsListResponse({
+          requestId: request.id,
+          firstResult,
+          lastResult,
+          turnsKey,
+          turns: pageTurns,
+          sanitizeForRelay,
+          sanitizeContext,
+          payloadSoftLimitBytes,
+        });
+        if (!completeResponse) {
+          throw new Error("thread/turns/list returned an oversized batch without a safe cursor boundary.");
+        }
+        response = completeResponse;
+        break;
+      }
+      const boundedResponse = buildLargestSafeTurnsListResponse({
         requestId: request.id,
         firstResult,
         lastResult,
@@ -2324,7 +2792,11 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
         sanitizeForRelay,
         sanitizeContext,
         payloadSoftLimitBytes,
-      }) ?? buildEmptyTurnsListResponse(request);
+      });
+      if (!boundedResponse) {
+        throw new Error("The newest chat turn is too large to relay safely.");
+      }
+      response = boundedResponse;
       break;
     }
 
@@ -2347,22 +2819,10 @@ async function fetchAdaptiveThreadTurnsListForRelay(request, {
     }
   }
 
-  return response ?? {
-    id: request.id,
-    result: {
-      data: [],
-    },
-  };
-}
-
-function buildEmptyTurnsListResponse(request) {
-  return {
-    id: request.id,
-    result: {
-      data: [],
-      nextCursor: null,
-    },
-  };
+  if (!response) {
+    throw new Error("thread/turns/list completed without a relayable page.");
+  }
+  return response;
 }
 
 function isEmptyTurnsListResponse(response) {
@@ -2391,7 +2851,7 @@ function resolveJsonlTurnsListRolloutPathForFallback({
     : findAndCachePath(threadId);
 }
 
-function maybeMergeLatestJsonlTurnIntoTurnsListResponse(request, response, jsonlResult, params = {}) {
+function maybeMergeLatestJsonlTurnIntoTurnsListResponse(request, response, jsonlResult) {
   const responseResult = response?.result;
   const responseTurnsKey = findTurnsListResultKey(responseResult);
   const jsonlTurnsKey = findTurnsListResultKey(jsonlResult);
@@ -2410,16 +2870,17 @@ function maybeMergeLatestJsonlTurnIntoTurnsListResponse(request, response, jsonl
     return null;
   }
 
-  const requestedLimit = Number.isInteger(params?.limit) && params.limit > 0
-    ? params.limit
-    : responseTurns.length + 1;
-  const mergedTurns = [jsonlTurn, ...responseTurns].slice(0, requestedLimit);
+  // Keep the canonical page intact. Slicing this back to the requested limit
+  // can retain the newer JSONL turn while dropping the canonical cursor anchor,
+  // making that canonical turn permanently unreachable.
+  const mergedTurns = [jsonlTurn, ...responseTurns];
   return {
     id: request.id,
     result: {
       ...responseResult,
       [responseTurnsKey]: mergedTurns,
       remodexJsonlMergedLatest: true,
+      remodexJsonlFallback: true,
     },
   };
 }
@@ -2446,6 +2907,10 @@ function turnListTurnIdentifier(turn) {
     || normalizeNonEmptyString(turn?.turn_id);
 }
 
+function isSyntheticJsonlHistoryTurnId(turnId) {
+  return normalizeNonEmptyString(turnId).startsWith("turn-line-");
+}
+
 async function fetchSafeThreadTurnsListFallback(request, {
   fetchPage,
   now,
@@ -2460,35 +2925,29 @@ async function fetchSafeThreadTurnsListFallback(request, {
   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,
-      sanitizeContext,
-      payloadSoftLimitBytes,
-    });
-    if (response) {
-      return response;
-    }
-  } catch {
-    // Fall through to a valid empty page: the phone can keep the thread open instead of crashing.
+  const page = await fetchMeasuredAdaptiveTurnsListPage(fetchPage, safeParams, now);
+  const pageResult = unwrapAppServerPayloadResult(page.result);
+  const turnsKey = findTurnsListResultKey(pageResult);
+  if (!turnsKey) {
+    throw new Error("thread/turns/list returned no turns array.");
   }
 
-  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 = buildCompactedCompleteTurnsListResponse({
+    requestId: request.id,
+    firstResult: pageResult,
+    lastResult: pageResult,
+    turnsKey,
+    turns: pageResult[turnsKey],
+    sanitizeForRelay,
+    sanitizeContext,
+    payloadSoftLimitBytes,
+  });
+  if (response) {
+    return response;
+  }
+  throw new Error("thread/turns/list returned a page that is too large to relay safely.");
 }
 
 async function fetchMeasuredAdaptiveTurnsListPage(fetchPage, params, now) {
@@ -2538,6 +2997,48 @@ function buildSafeTurnsListResponse(requestId, firstResult, lastResult, turnsKey
   };
 }
 
+function buildCompactedCompleteTurnsListResponse({
+  requestId,
+  firstResult,
+  lastResult,
+  turnsKey,
+  turns,
+  sanitizeForRelay,
+  sanitizeContext = {},
+  payloadSoftLimitBytes,
+}) {
+  const response = buildSafeTurnsListResponse(
+    requestId,
+    firstResult,
+    lastResult,
+    turnsKey,
+    turns
+  );
+  if (measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, sanitizeContext) < payloadSoftLimitBytes) {
+    return response;
+  }
+
+  for (const maxChars of [
+    RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS,
+    Math.floor(RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS / 4),
+    1_000,
+    0,
+  ]) {
+    const compacted = buildSafeTurnsListResponse(
+      requestId,
+      firstResult,
+      lastResult,
+      turnsKey,
+      turns.map((turn) => compactTurnsListTurnForRelay(turn, maxChars))
+    );
+    compacted.result.remodexPageCompactedForRelay = true;
+    if (measureSanitizedTurnsListResponseBytes(compacted, sanitizeForRelay, sanitizeContext) < payloadSoftLimitBytes) {
+      return compacted;
+    }
+  }
+  return null;
+}
+
 // Trims oversized history pages progressively: normal page -> 5 turns -> ... -> 1 turn.
 function buildLargestSafeTurnsListResponse({
   requestId,
@@ -2639,19 +3140,47 @@ function compactEmergencySingleTurnForRelay(turn, maxChars, maxItems) {
   }
 
   const items = Array.isArray(turn.items) ? turn.items : [];
-  safeTurn.items = items.slice(-maxItems).map((item) => compactHistoryItemForRelay(item, maxChars));
+  safeTurn.items = selectEmergencyHistoryItemsForRelay(items, maxItems)
+    .map((item) => compactHistoryItemForRelay(item, maxChars));
   safeTurn.remodexEmergencySingleTurnForRelay = true;
   safeTurn.remodexPageCompactedForRelay = true;
   return safeTurn;
 }
 
+function selectEmergencyHistoryItemsForRelay(items, maxItems) {
+  if (!Array.isArray(items) || items.length <= maxItems) {
+    return Array.isArray(items) ? items : [];
+  }
+
+  const selectedIndices = new Set();
+  const firstUserIndex = items.findIndex((item) => isUserRoleItem(item));
+  if (firstUserIndex >= 0) {
+    selectedIndices.add(firstUserIndex);
+  }
+  for (let index = items.length - 1; index >= 0 && selectedIndices.size < maxItems; index -= 1) {
+    const type = normalizeHistoryItemToken(items[index]?.type);
+    if (type === "plan" || type === "filechange") {
+      selectedIndices.add(index);
+    }
+  }
+  for (let index = items.length - 1; index >= 0 && selectedIndices.size < maxItems; index -= 1) {
+    selectedIndices.add(index);
+  }
+  return [...selectedIndices]
+    .sort((left, right) => left - right)
+    .map((index) => items[index]);
+}
+
 function buildAdaptiveTurnsListResult(firstResult, lastResult, turnsKey, turns) {
   const result = {};
   result[turnsKey] = turns;
 
   for (const key of RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS) {
-    if (Object.prototype.hasOwnProperty.call(lastResult, key)) {
-      result[key] = lastResult[key];
+    const sourceResult = RELAY_TURNS_LIST_PREVIOUS_PAGINATION_RESULT_KEYS.has(key)
+      ? firstResult
+      : lastResult;
+    if (Object.prototype.hasOwnProperty.call(sourceResult, key)) {
+      result[key] = sourceResult[key];
     } else {
       delete result[key];
     }
@@ -2698,8 +3227,10 @@ function measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay, requ
 // Keeps app-server responses in the JSON-RPC shape that the App Store iOS client decodes.
 function normalizeRelayBoundJsonRpcMessage(rawMessage, {
   pendingRequestMethodsById = null,
+  // Optional pre-parsed envelope shared by the caller; treated as read-only.
+  parsedMessage = null,
 } = {}) {
-  const parsed = parseBridgeJSON(rawMessage);
+  const parsed = parsedMessage ?? parseBridgeJSON(rawMessage);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     return null;
   }
@@ -2818,11 +3349,32 @@ function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod, requestC
     || 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 && !didAugment && !didAugmentThreadMetadata) {
+  // Oversized histories get their turn window trimmed before the per-turn sanitize
+  // and augment passes so full-history work is not spent on turns the payload
+  // budget discards anyway. The byte-budget trim below still enforces the cap.
+  const didPreTrimTurnWindow = Buffer.byteLength(rawMessage, "utf8") > RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES
+    && thread.turns.length > RELAY_HISTORY_RECENT_TURN_TARGET;
+  const workingTurns = didPreTrimTurnWindow
+    ? thread.turns.slice(-RELAY_HISTORY_RECENT_TURN_TARGET)
+    : thread.turns;
+  const workingThread = didPreTrimTurnWindow ? { ...thread, turns: workingTurns } : thread;
+  const trimOptions = didPreTrimTurnWindow
+    ? {
+      preOmittedTurnCount: thread.turns.length - workingTurns.length,
+      compactionIdSource: thread.turns[0],
+    }
+    : {};
+
+  const { turns: sanitizedTurns, didSanitize } = sanitizeRelayHistoryTurns(workingTurns, threadId);
+  const { thread: threadWithJsonlMetadata, didAugment: didAugmentThreadMetadata } = augmentRelayThreadWithJsonlMetadata(workingThread, threadId);
+  const { turns: augmentedTurns, didAugment } = augmentRelayHistoryTurnsWithJsonlArtifacts(
+    sanitizedTurns,
+    threadId,
+    { includeHistoryItems: true }
+  );
+
+  if (!didSanitize && !didAugment && !didAugmentThreadMetadata && !didPreTrimTurnWindow) {
     const trimmedPayload = trimThreadPayloadForRelay(parsed, thread);
     return trimmedPayload == null ? rawMessage : trimmedPayload;
   }
@@ -2838,7 +3390,7 @@ function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod, requestC
     },
   });
 
-  return trimThreadPayloadForRelay(parseBridgeJSON(sanitizedPayload), null) ?? sanitizedPayload;
+  return trimThreadPayloadForRelay(parseBridgeJSON(sanitizedPayload), null, trimOptions) ?? sanitizedPayload;
 }
 
 function sanitizeThreadTurnsListForRelay(rawMessage, requestContext = {}) {
@@ -2906,27 +3458,104 @@ function readJsonlThreadCwd(threadId) {
     return "";
   }
 
+  const sessionsRoot = resolveSessionsRoot();
+  const cacheKey = buildJsonlThreadCacheKey(sessionsRoot, normalizedThreadId);
+
   try {
-    const rolloutPath = findRecentRolloutFileForContextRead(resolveSessionsRoot(), { threadId: normalizedThreadId });
+    const rolloutPath = findRecentRolloutFileForContextRead(sessionsRoot, { threadId: normalizedThreadId });
     if (!rolloutPath) {
       return "";
     }
 
-    const metadata = parseSessionJsonlMetadata(fs.readFileSync(rolloutPath, "utf8"));
-    const cwd = normalizeNonEmptyString(metadata?.cwd);
-    return cwd && path.isAbsolute(cwd) ? cwd : "";
+    const cached = readCachedJsonlThreadCwd(cacheKey, rolloutPath);
+    if (cached) {
+      return cached.cwd;
+    }
+
+    return readAndCacheJsonlThreadCwd(cacheKey, rolloutPath);
   } catch {
     return "";
   }
 }
 
-function augmentRelayHistoryTurnsWithJsonlArtifacts(turns, threadId = "") {
+function readCachedJsonlThreadCwd(cacheKey, rolloutPath) {
+  const cached = jsonlThreadCwdCacheByThread.get(cacheKey);
+  if (!cached || cached.rolloutPath !== rolloutPath) {
+    return null;
+  }
+
+  const stat = statJsonlRollout(rolloutPath);
+  if (!stat) {
+    jsonlThreadCwdCacheByThread.delete(cacheKey);
+    return null;
+  }
+
+  if (stat.mtimeMs !== cached.mtimeMs || stat.size !== cached.size) {
+    return null;
+  }
+
+  const ttl = cached.cwd ? RELAY_JSONL_THREAD_CWD_CACHE_TTL_MS : RELAY_JSONL_THREAD_EMPTY_CWD_CACHE_TTL_MS;
+  if (Date.now() - cached.checkedAt > ttl) {
+    return null;
+  }
+
+  return { cwd: cached.cwd };
+}
+
+function readAndCacheJsonlThreadCwd(cacheKey, rolloutPath, stat = null) {
+  const rolloutStat = stat || statJsonlRollout(rolloutPath);
+  if (!rolloutStat) {
+    jsonlThreadCwdCacheByThread.delete(cacheKey);
+    return "";
+  }
+
+  let cwd = "";
+  try {
+    const metadata = readSessionJsonlMetadataFromFile(rolloutPath);
+    const parsedCwd = normalizeNonEmptyString(metadata?.cwd);
+    cwd = parsedCwd && path.isAbsolute(parsedCwd) ? parsedCwd : "";
+  } catch {
+    cwd = "";
+  }
+
+  rememberJsonlThreadCwdCache(cacheKey, {
+    rolloutPath,
+    cwd,
+    mtimeMs: rolloutStat.mtimeMs,
+    size: rolloutStat.size,
+    checkedAt: Date.now(),
+  });
+  return cwd;
+}
+
+function rememberJsonlThreadCwdCache(cacheKey, entry) {
+  jsonlThreadCwdCacheByThread.set(cacheKey, entry);
+  while (jsonlThreadCwdCacheByThread.size > JSONL_ROLLOUT_PATH_CACHE_MAX_SIZE) {
+    const oldestKey = jsonlThreadCwdCacheByThread.keys().next().value;
+    if (oldestKey == null) {
+      break;
+    }
+    jsonlThreadCwdCacheByThread.delete(oldestKey);
+  }
+}
+
+function augmentRelayHistoryTurnsWithJsonlArtifacts(turns, threadId = "", {
+  includeHistoryItems = false,
+} = {}) {
   const normalizedThreadId = normalizeNonEmptyString(threadId);
   if (!normalizedThreadId || !Array.isArray(turns) || turns.length === 0) {
     return { turns, didAugment: false };
   }
 
-  const jsonlArtifactsByTurnId = readJsonlArtifactItemsByTurnId(normalizedThreadId);
+  const requestedTurnIds = new Set(turns.map((turn) => (
+    normalizeNonEmptyString(turn?.id)
+      || normalizeNonEmptyString(turn?.turnId)
+      || normalizeNonEmptyString(turn?.turn_id)
+  )).filter(Boolean));
+  const jsonlArtifactsByTurnId = readJsonlArtifactItemsByTurnId(
+    normalizedThreadId,
+    requestedTurnIds
+  );
   if (jsonlArtifactsByTurnId.size === 0) {
     return { turns, didAugment: false };
   }
@@ -2942,22 +3571,17 @@ function augmentRelayHistoryTurnsWithJsonlArtifacts(turns, threadId = "") {
     }
 
     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;
+    const merged = mergeRelayHistoryItemsWithJsonlItems(
+      items,
+      artifacts.timelineItems,
+      normalizedThreadId,
+      {
+        includeJsonlItem: includeHistoryItems
+          ? () => true
+          : isJsonlHistoryArtifactItem,
       }
-      nextItems = nextItems === items ? [...items] : nextItems;
-      nextItems.push(imageViewItem);
-    }
-    if (artifacts.progressPlanItem && !hasEquivalentProgressPlanItem(nextItems, artifacts.progressPlanItem)) {
-      nextItems = nextItems === items ? [...items] : nextItems;
-      nextItems.push(artifacts.progressPlanItem);
-    }
+    );
+    const nextItems = merged.items;
 
     if (nextItems === items) {
       return turn;
@@ -2973,7 +3597,7 @@ function augmentRelayHistoryTurnsWithJsonlArtifacts(turns, threadId = "") {
   return { turns: didAugment ? augmentedTurns : turns, didAugment };
 }
 
-function readJsonlArtifactItemsByTurnId(threadId) {
+function readJsonlArtifactItemsByTurnId(threadId, requestedTurnIds = new Set()) {
   const emptyArtifactsByTurnId = new Map();
   const normalizedThreadId = normalizeNonEmptyString(threadId);
   if (!normalizedThreadId) {
@@ -2982,7 +3606,11 @@ function readJsonlArtifactItemsByTurnId(threadId) {
 
   const sessionsRoot = resolveSessionsRoot();
   const cacheKey = buildJsonlArtifactItemsCacheKey(sessionsRoot, normalizedThreadId);
-  const cachedArtifacts = readCachedJsonlArtifactItems(cacheKey, normalizedThreadId);
+  const cachedArtifacts = readCachedJsonlArtifactItems(
+    cacheKey,
+    normalizedThreadId,
+    requestedTurnIds
+  );
   if (cachedArtifacts) {
     return cachedArtifacts;
   }
@@ -2994,7 +3622,13 @@ function readJsonlArtifactItemsByTurnId(threadId) {
       return emptyArtifactsByTurnId;
     }
 
-    return readAndCacheJsonlArtifactItems(cacheKey, rolloutPath, normalizedThreadId);
+    return readAndCacheJsonlArtifactItems(
+      cacheKey,
+      rolloutPath,
+      normalizedThreadId,
+      null,
+      requestedTurnIds
+    );
   } catch (error) {
     jsonlArtifactItemsCacheByThread.delete(cacheKey);
     console.warn(`[remodex] history jsonl artifact augmentation failed for ${normalizedThreadId}: ${error.message}`);
@@ -3004,16 +3638,20 @@ function readJsonlArtifactItemsByTurnId(threadId) {
 }
 
 function buildJsonlArtifactItemsCacheKey(sessionsRoot, threadId) {
+  return buildJsonlThreadCacheKey(sessionsRoot, threadId);
+}
+
+function buildJsonlThreadCacheKey(sessionsRoot, threadId) {
   return `${sessionsRoot}\0${threadId}`;
 }
 
-function readCachedJsonlArtifactItems(cacheKey, threadId) {
+function readCachedJsonlArtifactItems(cacheKey, threadId, requestedTurnIds = new Set()) {
   const cached = jsonlArtifactItemsCacheByThread.get(cacheKey);
   if (!cached) {
     return null;
   }
 
-  const stat = statJsonlArtifactRollout(cached.rolloutPath);
+  const stat = statJsonlRollout(cached.rolloutPath);
   if (!stat) {
     jsonlArtifactItemsCacheByThread.delete(cacheKey);
     return null;
@@ -3021,7 +3659,13 @@ function readCachedJsonlArtifactItems(cacheKey, threadId) {
 
   if (stat.mtimeMs !== cached.mtimeMs || stat.size !== cached.size) {
     try {
-      return readAndCacheJsonlArtifactItems(cacheKey, cached.rolloutPath, threadId, stat);
+      return readAndCacheJsonlArtifactItems(
+        cacheKey,
+        cached.rolloutPath,
+        threadId,
+        stat,
+        requestedTurnIds
+      );
     } catch (error) {
       jsonlArtifactItemsCacheByThread.delete(cacheKey);
       console.warn(`[remodex] history jsonl artifact cache refresh failed for ${threadId}: ${error.message}`);
@@ -3030,6 +3674,11 @@ function readCachedJsonlArtifactItems(cacheKey, threadId) {
   }
 
   const now = Date.now();
+  const coversRequestedTurns = cached.coversEntireRollout
+    || [...requestedTurnIds].every((turnId) => cached.coveredTurnIds?.has(turnId));
+  if (!coversRequestedTurns) {
+    return null;
+  }
   if (now - cached.checkedAt <= RELAY_JSONL_ARTIFACT_CACHE_TTL_MS) {
     return cached.artifactsByTurnId;
   }
@@ -3038,11 +3687,37 @@ function readCachedJsonlArtifactItems(cacheKey, threadId) {
   return null;
 }
 
-function readAndCacheJsonlArtifactItems(cacheKey, rolloutPath, threadId, stat = null) {
+function readAndCacheJsonlArtifactItems(
+  cacheKey,
+  rolloutPath,
+  threadId,
+  stat = null,
+  requestedTurnIds = new Set()
+) {
   const rolloutStat = stat || fs.statSync(rolloutPath);
   const artifactsByTurnId = new Map();
+  let coveredTurnIds = new Set();
+  let coversEntireRollout = false;
   try {
-    const turns = parseSessionJsonlTurns(fs.readFileSync(rolloutPath, "utf8"), { threadId });
+    const recent = readRecentSessionJsonlTurns(rolloutPath, {
+      threadId,
+      limit: RELAY_TURNS_LIST_SAFE_RETRY_LIMIT,
+    });
+    let turns = recent?.turns || [];
+    coversEntireRollout = recent ? !recent.hasOlderTurns : false;
+    coveredTurnIds = new Set(turns.map((turn) => normalizeNonEmptyString(turn?.id)).filter(Boolean));
+    const missesRequestedTurn = [...requestedTurnIds].some((turnId) => !coveredTurnIds.has(turnId));
+
+    // Preserve the old exact artifact behavior for files V8 can safely decode,
+    // but only pay that cost when an older cursor page actually asks for a turn
+    // outside the fast tail. Multi-gigabyte files never enter this path.
+    if (!coversEntireRollout
+        && missesRequestedTurn
+        && rolloutStat.size <= RELAY_JSONL_FULL_ARTIFACT_FALLBACK_MAX_BYTES) {
+      turns = parseSessionJsonlTurns(fs.readFileSync(rolloutPath, "utf8"), { threadId });
+      coversEntireRollout = true;
+      coveredTurnIds = new Set(turns.map((turn) => normalizeNonEmptyString(turn?.id)).filter(Boolean));
+    }
     for (const turn of turns) {
       const turnId = normalizeNonEmptyString(turn?.id);
       const turnItems = Array.isArray(turn?.items) ? turn.items : [];
@@ -3050,47 +3725,9 @@ function readAndCacheJsonlArtifactItems(cacheKey, rolloutPath, threadId, stat =
         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);
+      const timelineItems = buildOrderedJsonlTimelineItems(turnItems, turnId);
+      if (timelineItems.length > 0) {
+        artifactsByTurnId.set(turnId, { timelineItems });
       }
     }
   } catch (error) {
@@ -3104,11 +3741,13 @@ function readAndCacheJsonlArtifactItems(cacheKey, rolloutPath, threadId, stat =
     size: rolloutStat.size,
     checkedAt: Date.now(),
     artifactsByTurnId,
+    coveredTurnIds,
+    coversEntireRollout,
   });
   return artifactsByTurnId;
 }
 
-function statJsonlArtifactRollout(rolloutPath) {
+function statJsonlRollout(rolloutPath) {
   try {
     return fs.statSync(rolloutPath);
   } catch {
@@ -3127,57 +3766,406 @@ function rememberJsonlArtifactItemsCache(cacheKey, entry) {
   }
 }
 
-function hasEquivalentFileChangeItem(items, incomingItem) {
-  const incomingId = normalizeNonEmptyString(incomingItem?.id);
-  const incomingPaths = fileChangePathSet(incomingItem);
-  return items.some((item) => {
-    if (normalizeHistoryItemToken(item?.type) !== "filechange") {
-      return false;
+// Keeps JSONL-only rows in rollout order while treating app-server rows as the
+// authoritative spine. Matching anchors let us place missing rows without ever
+// moving server-only findings, messages, or richer tool records to the tail.
+function mergeRelayHistoryItemsWithJsonlItems(existingItems, jsonlItems, threadId = "", {
+  includeJsonlItem = () => true,
+} = {}) {
+  if (!Array.isArray(existingItems) || !Array.isArray(jsonlItems) || jsonlItems.length === 0) {
+    return { items: existingItems, didMerge: false };
+  }
+
+  const sanitizedJsonlItems = jsonlItems
+    .map((item) => sanitizeJsonlHistoryItemForRelayMerge(item, threadId))
+    .filter(Boolean);
+  if (sanitizedJsonlItems.length === 0) {
+    return { items: existingItems, didMerge: false };
+  }
+
+  if (existingItems.length === 0) {
+    const insertedItems = sanitizedJsonlItems.filter(includeJsonlItem);
+    return insertedItems.length > 0
+      ? { items: insertedItems, didMerge: true }
+      : { items: existingItems, didMerge: false };
+  }
+
+  const usedExistingIndices = new Set();
+  const resolvedExistingItems = existingItems.slice();
+  const insertionsBefore = new Map();
+  const insertionsAfter = new Map();
+  let pendingItems = [];
+  let previousMatchedIndex = null;
+  let matchedAnchorCount = 0;
+  let didReplaceMatchedItem = false;
+
+  // The rollout's turn+text alias is the only identity shared across the
+  // live-owner (item_N) and rollout (msg_...) views of one assistant reply.
+  // Carrying it onto the matched server row lets the phone join this item
+  // with its other-source representations instead of duplicating it.
+  const adoptJsonlSourceAlias = (index, jsonlItem) => {
+    const sourceKey = normalizeNonEmptyString(jsonlItem?.remodexSourceItemKey);
+    const existing = resolvedExistingItems[index];
+    if (!sourceKey || !existing || typeof existing !== "object"
+      || normalizeNonEmptyString(existing.remodexSourceItemKey)) {
+      return;
     }
-    if (incomingId && normalizeNonEmptyString(item.id) === incomingId) {
-      return true;
+    resolvedExistingItems[index] = { ...existing, remodexSourceItemKey: sourceKey };
+    didReplaceMatchedItem = true;
+  };
+
+  const placePendingItems = () => {
+    if (pendingItems.length === 0) {
+      return;
     }
-    if (item.remodexJsonlFileChangeAggregate === true) {
-      return true;
+    if (previousMatchedIndex == null) {
+      insertionsBefore.set(0, pendingItems);
+    } else {
+      const existing = insertionsAfter.get(previousMatchedIndex) || [];
+      insertionsAfter.set(previousMatchedIndex, existing.concat(pendingItems));
     }
+    pendingItems = [];
+  };
 
-    const existingPaths = fileChangePathSet(item);
-    if (incomingPaths.size === 0 || existingPaths.size === 0) {
-      return false;
-    }
-    for (const pathKey of incomingPaths) {
-      if (!existingPaths.has(pathKey)) {
-        return false;
+  for (const jsonlItem of sanitizedJsonlItems) {
+    const unusedMatch = (candidate, index) => !usedExistingIndices.has(index);
+    const eligibleMatch = (candidate, index) => (
+      (previousMatchedIndex == null || index > previousMatchedIndex)
+      && unusedMatch(candidate, index)
+    );
+    let existingIndex = findRelayHistoryExactMatchIndex(existingItems, jsonlItem, eligibleMatch);
+    if (existingIndex === -1) {
+      // Exact identity remains authoritative even when server and rollout order
+      // disagree. Consume that occurrence before considering a later semantic
+      // lookalike, otherwise repeated rows can bind to the wrong server item.
+      const representedExactIndex = findRelayHistoryExactMatchIndex(
+        existingItems,
+        jsonlItem,
+        unusedMatch
+      );
+      if (representedExactIndex !== -1) {
+        usedExistingIndices.add(representedExactIndex);
+        if (isProgressPlanItem(jsonlItem)) {
+          resolvedExistingItems[representedExactIndex] = resolvedProgressPlanHistoryItem(
+            existingItems[representedExactIndex],
+            jsonlItem
+          );
+          didReplaceMatchedItem = true;
+        }
+        adoptJsonlSourceAlias(representedExactIndex, jsonlItem);
+        continue;
+      }
+      existingIndex = findRelayHistorySemanticMatchIndex(existingItems, jsonlItem, eligibleMatch);
+    }
+    if (existingIndex === -1) {
+      // The row can already exist before the monotonic placement frontier when
+      // server and rollout order disagree. Consume each represented occurrence
+      // once; an extra identical JSONL occurrence must remain visible instead
+      // of repeatedly matching the same server row and disappearing.
+      const representedIndex = findRelayHistorySemanticMatchIndex(
+        existingItems,
+        jsonlItem,
+        unusedMatch
+      );
+      if (representedIndex !== -1) {
+        usedExistingIndices.add(representedIndex);
+        if (isProgressPlanItem(jsonlItem)) {
+          resolvedExistingItems[representedIndex] = resolvedProgressPlanHistoryItem(
+            existingItems[representedIndex],
+            jsonlItem
+          );
+          didReplaceMatchedItem = true;
+        }
+        adoptJsonlSourceAlias(representedIndex, jsonlItem);
+        continue;
       }
+      if (includeJsonlItem(jsonlItem)) {
+        pendingItems.push(jsonlItem);
+      }
+      continue;
     }
-    return true;
-  });
+
+    placePendingItems();
+    usedExistingIndices.add(existingIndex);
+    if (isProgressPlanItem(jsonlItem)) {
+      resolvedExistingItems[existingIndex] = resolvedProgressPlanHistoryItem(
+        existingItems[existingIndex],
+        jsonlItem
+      );
+      didReplaceMatchedItem = true;
+    }
+    adoptJsonlSourceAlias(existingIndex, jsonlItem);
+    previousMatchedIndex = existingIndex;
+    matchedAnchorCount += 1;
+  }
+
+  if (matchedAnchorCount === 0) {
+    const unanchoredArtifacts = sanitizedJsonlItems.filter((item) => (
+      includeJsonlItem(item) && isJsonlHistoryArtifactItem(item)
+    ));
+    if (unanchoredArtifacts.length === 0) {
+      return { items: existingItems, didMerge: false };
+    }
+    const firstAssistantIndex = existingItems.findIndex(isRelayAssistantHistoryItem);
+    const insertionIndex = firstAssistantIndex === -1 ? existingItems.length : firstAssistantIndex;
+    return {
+      items: existingItems.slice(0, insertionIndex)
+        .concat(unanchoredArtifacts, existingItems.slice(insertionIndex)),
+      didMerge: true,
+    };
+  }
+  if (pendingItems.length > 0 && previousMatchedIndex != null) {
+    const existing = insertionsAfter.get(previousMatchedIndex) || [];
+    insertionsAfter.set(previousMatchedIndex, existing.concat(pendingItems));
+  }
+
+  if (insertionsBefore.size === 0 && insertionsAfter.size === 0 && !didReplaceMatchedItem) {
+    return { items: existingItems, didMerge: false };
+  }
+
+  const mergedItems = [];
+  for (const [index, item] of resolvedExistingItems.entries()) {
+    mergedItems.push(...(insertionsBefore.get(index) || []));
+    mergedItems.push(item);
+    mergedItems.push(...(insertionsAfter.get(index) || []));
+  }
+  return { items: mergedItems, didMerge: true };
 }
 
-function hasEquivalentProgressPlanItem(items, incomingItem) {
-  const incomingId = normalizeNonEmptyString(incomingItem?.id);
-  return items.some((item) => {
-    if (normalizeHistoryItemToken(item?.type) !== "plan") {
-      return false;
+function buildOrderedJsonlTimelineItems(turnItems, turnId) {
+  if (!Array.isArray(turnItems) || turnItems.length === 0) {
+    return [];
+  }
+
+  let latestProgressPlanIndex = -1;
+  for (const [index, item] of turnItems.entries()) {
+    if (isProgressPlanItem(item)) {
+      latestProgressPlanIndex = index;
+    }
+  }
+
+  let imageViewIndex = 0;
+  return turnItems.flatMap((item, index) => {
+    if (!shouldIncludeJsonlTimelineItem(item)) {
+      return [];
+    }
+    if (isProgressPlanItem(item) && index !== latestProgressPlanIndex) {
+      return [];
+    }
+
+    const itemType = normalizeHistoryItemToken(item?.type);
+    if (isProgressPlanItem(item)) {
+      return [{
+        ...item,
+        id: normalizeNonEmptyString(item?.id) || `remodex-jsonl-progress-plan-${turnId}`,
+        remodexProgressPlan: true,
+        remodexJsonlProgressPlan: true,
+      }];
     }
-    return item.remodexJsonlProgressPlan === true
-      || (incomingId && normalizeNonEmptyString(item.id) === incomingId);
+    if (itemType === "imageview") {
+      imageViewIndex += 1;
+      return [{
+        ...item,
+        id: normalizeNonEmptyString(item?.id)
+          || `remodex-jsonl-image-view-${turnId}-${imageViewIndex}`,
+      }];
+    }
+    return [item];
   });
 }
 
-function hasEquivalentImageViewItem(items, incomingItem) {
-  const incomingId = normalizeNonEmptyString(incomingItem?.id);
-  const incomingPath = normalizeImageViewPathKey(incomingItem);
-  return items.some((item) => {
-    if (normalizeHistoryItemToken(item?.type) !== "imageview") {
-      return false;
+function shouldIncludeJsonlTimelineItem(item) {
+  const itemType = normalizeHistoryItemToken(item?.type);
+  return Boolean(itemType)
+    && itemType !== "toolcalloutput"
+    && itemType !== "functioncalloutput"
+    && itemType !== "customtoolcalloutput";
+}
+
+function isJsonlHistoryArtifactItem(item) {
+  const itemType = normalizeHistoryItemToken(item?.type);
+  return itemType === "filechange"
+    || itemType === "imageview"
+    || isProgressPlanItem(item);
+}
+
+function isProgressPlanItem(item) {
+  const itemType = normalizeHistoryItemToken(item?.type);
+  return (itemType === "plan" || itemType === "todolist")
+    && (item?.remodexJsonlProgressPlan === true || item?.remodexProgressPlan === true);
+}
+
+function resolvedProgressPlanHistoryItem(existingItem, jsonlItem) {
+  return {
+    ...existingItem,
+    text: jsonlItem.text,
+    explanation: jsonlItem.explanation,
+    plan: jsonlItem.plan,
+    remodexProgressPlan: true,
+    remodexJsonlProgressPlan: true,
+  };
+}
+
+function findRelayHistoryExactMatchIndex(items, incomingItem, predicate = () => true) {
+  return items.findIndex((candidate, index) => (
+    predicate(candidate, index) && relayHistoryItemsHaveExactIdentity(candidate, incomingItem)
+  ));
+}
+
+function findRelayHistorySemanticMatchIndex(items, incomingItem, predicate = () => true) {
+  return items.findIndex((candidate, index) => (
+    predicate(candidate, index) && areEquivalentRelayHistoryItems(candidate, incomingItem)
+  ));
+}
+
+function relayHistoryItemsHaveExactIdentity(first, second) {
+  const firstIdentity = relayHistoryItemIdentity(first);
+  const secondIdentity = relayHistoryItemIdentity(second);
+  if (firstIdentity && secondIdentity && firstIdentity === secondIdentity) {
+    return true;
+  }
+  const firstCallId = relayHistoryItemCallId(first);
+  const secondCallId = relayHistoryItemCallId(second);
+  return Boolean(firstCallId && secondCallId && firstCallId === secondCallId);
+}
+
+function isRelayAssistantHistoryItem(item) {
+  const role = normalizeNonEmptyString(item?.role).toLowerCase();
+  const itemType = normalizeHistoryItemToken(item?.type);
+  return role === "assistant"
+    || itemType === "assistantmessage"
+    || itemType === "agentmessage"
+    || (itemType === "message" && role !== "user");
+}
+
+function sanitizeJsonlHistoryItemForRelayMerge(item, threadId) {
+  const sanitizedTurn = sanitizeRelayHistoryTurn({ items: [item] }, threadId);
+  return sanitizedTurn?.items?.[0] || item;
+}
+
+function areEquivalentRelayHistoryItems(first, second) {
+  const firstIdentity = relayHistoryItemIdentity(first);
+  const secondIdentity = relayHistoryItemIdentity(second);
+  if (firstIdentity && secondIdentity && firstIdentity === secondIdentity) {
+    return true;
+  }
+
+  const firstCallId = relayHistoryItemCallId(first);
+  const secondCallId = relayHistoryItemCallId(second);
+  if (firstCallId && secondCallId && firstCallId === secondCallId) {
+    return true;
+  }
+
+  if (isProgressPlanItem(first) && isProgressPlanItem(second)) {
+    return true;
+  }
+
+  // JSONL line ids are source-local fallbacks, not provider identities. They
+  // may reconcile semantically with a real app-server id; occurrence tracking
+  // in the merge keeps intentional repeated rows distinct. Assistant messages
+  // are exempt from the two-stable-ids refusal: the live-owner state keys them
+  // by app-server event id (item_N) while the rollout records the provider id
+  // (msg_...), so the same reply legitimately carries two stable identities.
+  if (relayHistoryIdentityIsStable(firstIdentity)
+    && relayHistoryIdentityIsStable(secondIdentity)
+    && !(isRelayAssistantHistoryItem(first) && isRelayAssistantHistoryItem(second))) {
+    return false;
+  }
+  if (relayHistoryIdentityIsStable(firstCallId)
+    && relayHistoryIdentityIsStable(secondCallId)) {
+    return false;
+  }
+
+  const firstType = normalizeHistoryItemToken(first?.type);
+  const secondType = normalizeHistoryItemToken(second?.type);
+  if (firstType === "imageview" && secondType === "imageview") {
+    const firstPath = normalizeImageViewPathKey(first);
+    const secondPath = normalizeImageViewPathKey(second);
+    if (firstPath && firstPath === secondPath) {
+      return true;
     }
-    const itemId = normalizeNonEmptyString(item.id);
-    if (incomingId && itemId === incomingId) {
+  }
+  if (firstType === "filechange" && secondType === "filechange") {
+    const firstPaths = fileChangePathSet(first);
+    const secondPaths = fileChangePathSet(second);
+    if (firstPaths.size > 0
+      && firstPaths.size === secondPaths.size
+      && Array.from(firstPaths).every((pathKey) => secondPaths.has(pathKey))) {
       return true;
     }
-    return incomingPath && normalizeImageViewPathKey(item) === incomingPath;
-  });
+  }
+
+  const firstText = relayHistoryItemText(first);
+  const secondText = relayHistoryItemText(second);
+  if (!firstText || !secondText || firstText !== secondText) {
+    return false;
+  }
+
+  return relayHistoryItemKindsCompatible(first, second);
+}
+
+function relayHistoryItemKindsCompatible(first, second) {
+  const firstType = normalizeHistoryItemToken(first?.type);
+  const secondType = normalizeHistoryItemToken(second?.type);
+  if (firstType && secondType && firstType === secondType) {
+    return true;
+  }
+
+  const firstRole = normalizeNonEmptyString(first?.role).toLowerCase();
+  const secondRole = normalizeNonEmptyString(second?.role).toLowerCase();
+  if (firstRole && secondRole && firstRole === secondRole) {
+    return true;
+  }
+
+  return isRelayMessageLikeHistoryType(firstType) && isRelayMessageLikeHistoryType(secondType);
+}
+
+function isRelayMessageLikeHistoryType(itemType) {
+  return itemType === "message"
+    || itemType === "assistantmessage"
+    || itemType === "agentmessage"
+    || itemType === "usermessage";
+}
+
+function relayHistoryItemIdentity(item) {
+  return normalizeNonEmptyString(item?.id)
+    || normalizeNonEmptyString(item?.itemId)
+    || normalizeNonEmptyString(item?.item_id);
+}
+
+function relayHistoryIdentityIsStable(identity) {
+  const normalizedIdentity = normalizeNonEmptyString(identity);
+  if (!normalizedIdentity) {
+    return false;
+  }
+  return !/^(?:user-message-line|response-item-line|apply-patch-line)-\d+$/.test(normalizedIdentity);
+}
+
+function relayHistoryItemCallId(item) {
+  return normalizeNonEmptyString(item?.call_id)
+    || normalizeNonEmptyString(item?.callId);
+}
+
+function relayHistoryItemText(item) {
+  if (!item || typeof item !== "object" || Array.isArray(item)) {
+    return "";
+  }
+
+  for (const key of ["text", "message", "summary", "output", "outputText", "output_text", "command"]) {
+    const value = normalizeNonEmptyString(item[key]);
+    if (value) {
+      return value;
+    }
+  }
+
+  if (Array.isArray(item.content)) {
+    return item.content
+      .map(relayHistoryItemText)
+      .filter(Boolean)
+      .join("\n");
+  }
+
+  return "";
 }
 
 function normalizeImageViewPathKey(item) {
@@ -3249,7 +4237,16 @@ function sanitizeRelayHistoryTurn(turn, threadId = "") {
     }
 
     let itemDidChange = false;
-    let sanitizedItem = convertApplyPatchHistoryItem(item) || item;
+    let sanitizedItem = sanitizeUserRoleItem(item);
+    if (!sanitizedItem) {
+      turnDidChange = true;
+      return null;
+    }
+    if (sanitizedItem !== item) {
+      itemDidChange = true;
+    }
+
+    sanitizedItem = convertApplyPatchHistoryItem(sanitizedItem) || sanitizedItem;
     if (sanitizedItem !== item) {
       itemDidChange = true;
     }
@@ -3287,7 +4284,7 @@ function sanitizeRelayHistoryTurn(turn, threadId = "") {
     }
 
     return itemDidChange ? sanitizedItem : item;
-  });
+  }).filter(Boolean);
 
   return turnDidChange
     ? {
@@ -3297,6 +4294,67 @@ function sanitizeRelayHistoryTurn(turn, threadId = "") {
     : turn;
 }
 
+// Compatibility predicate for callers that only need a drop/no-drop decision.
+// The full sanitizer below also rewrites mixed items without losing attachments.
+const LIVE_ITEM_LIFECYCLE_METHODS = new Set([
+  "item/started",
+  "item/updated",
+  "item/completed",
+]);
+
+function isContextualUserItemNotification(parsed) {
+  const method = typeof parsed?.method === "string" ? parsed.method : "";
+  if (!LIVE_ITEM_LIFECYCLE_METHODS.has(method)) {
+    return false;
+  }
+  const item = parsed?.params?.item;
+  if (!isUserRoleItem(item)) {
+    return false;
+  }
+  return isContextualUserText(readUserItemText(item));
+}
+
+// Sanitizes both raw app-server item events and fallback user_message events
+// before they can become mobile bubbles. Structured attachments stay intact.
+function sanitizeLiveUserNotification(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    return parsed;
+  }
+  const method = typeof parsed.method === "string" ? parsed.method : "";
+  if (LIVE_ITEM_LIFECYCLE_METHODS.has(method)) {
+    const item = parsed?.params?.item;
+    if (!isUserRoleItem(item)) {
+      return parsed;
+    }
+    const sanitizedItem = sanitizeUserRoleItem(item);
+    if (!sanitizedItem) {
+      return null;
+    }
+    return sanitizedItem === item ? parsed : {
+      ...parsed,
+      params: { ...parsed.params, item: sanitizedItem },
+    };
+  }
+
+  if (method !== "codex/event/user_message") {
+    return parsed;
+  }
+  const key = typeof parsed?.params?.message === "string"
+    ? "message"
+    : (typeof parsed?.params?.text === "string" ? "text" : "");
+  if (!key) {
+    return parsed;
+  }
+  const visible = visibleUserPromptText(parsed.params[key]);
+  if (!visible) {
+    return null;
+  }
+  return visible === parsed.params[key] ? parsed : {
+    ...parsed,
+    params: { ...parsed.params, [key]: visible },
+  };
+}
+
 function convertApplyPatchHistoryItem(item) {
   const itemType = normalizeHistoryItemToken(item?.type);
   const toolName = normalizeNonEmptyString(item?.name);
@@ -3608,12 +4666,17 @@ function parseBridgeJSON(value) {
   }
 }
 
-function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
+function trimThreadPayloadForRelay(parsed, explicitThread = undefined, options = {}) {
   const thread = explicitThread ?? parsed?.result?.thread;
   if (!parsed || !thread || typeof thread !== "object" || !Array.isArray(thread.turns)) {
     return null;
   }
 
+  // Callers that pre-trimmed the turn window pass the dropped count and the original
+  // first turn here so compaction markers keep reporting whole-thread numbers.
+  const preOmittedTurnCount = Math.max(0, options.preOmittedTurnCount ?? 0);
+  const compactionIdSource = options.compactionIdSource ?? null;
+
   let workingThread = thread;
   let encoded = encodeRelayThreadPayload(parsed, workingThread);
   if (encoded == null) {
@@ -3621,7 +4684,16 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
   }
 
   if (Buffer.byteLength(encoded, "utf8") <= RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES) {
-    return explicitThread === undefined ? null : encoded;
+    if (preOmittedTurnCount <= 0) {
+      return explicitThread === undefined ? null : encoded;
+    }
+    const compactedThread = buildRelayHistoryCompactedThread(
+      thread,
+      buildRelayCompactedHistoryTurns(thread.turns, thread.turns, preOmittedTurnCount, compactionIdSource),
+      preOmittedTurnCount,
+      thread.turns.length
+    );
+    return encodeRelayThreadPayload(parsed, compactedThread) ?? encoded;
   }
 
   const turns = thread.turns;
@@ -3634,8 +4706,8 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
     }
     const candidateThread = buildRelayHistoryCompactedThread(
       thread,
-      buildRelayCompactedHistoryTurns(turns, trimmedTurns),
-      Math.max(0, turns.length - trimmedTurns.length),
+      buildRelayCompactedHistoryTurns(turns, trimmedTurns, preOmittedTurnCount, compactionIdSource),
+      preOmittedTurnCount + Math.max(0, turns.length - trimmedTurns.length),
       trimmedTurns.length
     );
     encoded = encodeRelayThreadPayload(parsed, candidateThread);
@@ -3655,9 +4727,9 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
   while (trimmedItems.length > 1) {
     trimmedItems = trimmedItems.slice(1);
     const compactedTurnPrefix = buildRelayHistoryCompactionTurn(
-      Math.max(0, turns.length - 1),
+      preOmittedTurnCount + Math.max(0, turns.length - 1),
       1,
-      thread
+      compactionIdSource ?? thread
     );
     const candidateThread = buildRelayHistoryCompactedThread(
       thread,
@@ -3668,7 +4740,7 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
         ...newestTurn,
         items: trimmedItems,
       }],
-      Math.max(0, turns.length - 1),
+      preOmittedTurnCount + Math.max(0, turns.length - 1),
       1
     );
     encoded = encodeRelayThreadPayload(parsed, candidateThread);
@@ -3690,13 +4762,13 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
   let candidateThread = buildRelayHistoryCompactedThread(
     thread,
     [
-      ...buildRelayCompactedHistoryTurns(turns, [newestTurn]).slice(0, -1),
+      ...buildRelayCompactedHistoryTurns(turns, [newestTurn], preOmittedTurnCount, compactionIdSource).slice(0, -1),
       {
         ...newestTurn,
         items: [truncatedItem],
       },
     ],
-    Math.max(0, turns.length - 1),
+    preOmittedTurnCount + Math.max(0, turns.length - 1),
     1
   );
   encoded = encodeRelayThreadPayload(parsed, candidateThread);
@@ -3707,13 +4779,13 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
   candidateThread = buildRelayHistoryCompactedThread(
     thread,
     [
-      ...buildRelayCompactedHistoryTurns(turns, [newestTurn]).slice(0, -1),
+      ...buildRelayCompactedHistoryTurns(turns, [newestTurn], preOmittedTurnCount, compactionIdSource).slice(0, -1),
       {
         ...newestTurn,
         items: [compactHistoryItemForRelay(mostRecentItem, RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS)],
       },
     ],
-    Math.max(0, turns.length - 1),
+    preOmittedTurnCount + Math.max(0, turns.length - 1),
     1
   );
   return encodeRelayThreadPayload(parsed, candidateThread);
@@ -3753,6 +4825,32 @@ function trimTurnsListPayloadForRelay(parsed, turnsKey, originalRawMessage = nul
     }
   }
 
+  // A bounded JSONL first page can still describe one exceptionally large
+  // turn with many small items. Keep that provisional response relay-safe while
+  // preserving its handoff flags/cursor; the canonical background page will
+  // replace it with the authoritative history.
+  if (result.remodexJsonlFallback === true) {
+    for (const maxItems of [64, 16, 4, 1]) {
+      for (const maxChars of [1_000, 0]) {
+        const emergencyTurns = turns.map((turn) => (
+          compactEmergencySingleTurnForRelay(turn, maxChars, maxItems)
+        ));
+        const emergencyPayload = JSON.stringify({
+          ...parsed,
+          result: {
+            ...result,
+            [turnsKey]: emergencyTurns,
+            remodexPageCompactedForRelay: true,
+            remodexEmergencyJsonlPageForRelay: true,
+          },
+        });
+        if (Buffer.byteLength(emergencyPayload, "utf8") <= RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES) {
+          return emergencyPayload;
+        }
+      }
+    }
+  }
+
   return fallbackCompactedPayload ?? (originalRawMessage ?? encoded);
 }
 
@@ -3779,12 +4877,12 @@ function buildRelayHistoryCompactedThread(thread, turns, omittedTurnCount, keptT
   };
 }
 
-function buildRelayCompactedHistoryTurns(allTurns, keptTurns) {
-  const omittedTurnCount = Math.max(0, allTurns.length - keptTurns.length);
+function buildRelayCompactedHistoryTurns(allTurns, keptTurns, preOmittedTurnCount = 0, idSourceOverride = null) {
+  const omittedTurnCount = preOmittedTurnCount + Math.max(0, allTurns.length - keptTurns.length);
   const compactionTurn = buildRelayHistoryCompactionTurn(
     omittedTurnCount,
     keptTurns.length,
-    allTurns[0]
+    idSourceOverride ?? allTurns[0]
   );
   return compactionTurn ? [compactionTurn, ...keptTurns] : keptTurns;
 }
@@ -3808,6 +4906,9 @@ function buildRelayHistoryCompactionTurn(omittedTurnCount, keptTurnCount, idSour
 
   return {
     id: `remodex-history-compacted-${baseId}`,
+    // A status-less turn reads as interruptible/running to the phone's
+    // turn-state snapshot, flagging idle heavy threads as "thinking".
+    status: "completed",
     remodexSynthetic: true,
     remodexHistoryCompacted: true,
     remodexOmittedTurnCount: omittedTurnCount,
@@ -3970,21 +5071,40 @@ function persistBridgePreferences(
   });
 }
 
+function shouldSuppressRolloutMirrorForThread(
+  threadId,
+  { desktopIpcActionFollower = null, desktopIpcLiveOwner = null } = {},
+  { fallbackActivityAt = 0 } = {}
+) {
+  // Desktop ownership is an expiring live lease, not a permanent boolean. A
+  // stale IPC snapshot used to mute an actively growing rollout forever.
+  const followerIsFresh = typeof desktopIpcActionFollower?.hasFreshLiveThreadState === "function"
+    ? desktopIpcActionFollower.hasFreshLiveThreadState(threadId, { fallbackActivityAt })
+    : desktopIpcActionFollower?.hasLiveThreadState(threadId);
+  const ownerIsFresh = typeof desktopIpcLiveOwner?.isFreshThreadOwned === "function"
+    ? desktopIpcLiveOwner.isFreshThreadOwned(threadId)
+    : false;
+  return Boolean(followerIsFresh) || Boolean(ownerIsFresh);
+}
+
 module.exports = {
   buildThreadTurnsListRelaySanitizeContext,
   buildHeartbeatBridgeStatus,
-  buildRelayCloseStatusError,
-  buildRelayAccessTokenHeaders,
-  buildRelayUserAgentHeader,
+  canonicalThreadTurnsListRequest,
   createMacOSBridgeWakeAssertion,
+  createThreadTurnsListFastPageCoordinator,
   disableUnsupportedReasoningSummaryForTurnStart,
   fetchAdaptiveThreadTurnsListForRelay,
   hasRelayConnectionGoneStale,
-  isTerminalRelayCloseCode,
+  isContextualUserItemNotification,
+  maybeMergeLatestJsonlTurnIntoTurnsListResponse,
+  normalizeTurnStartForCodex,
   normalizeRelayBoundJsonRpcMessage,
   persistBridgePreferences,
   resolveJsonlTurnsListRolloutPathForFallback,
   sanitizeLiveGeneratedImageMessageForRelay,
+  sanitizeLiveUserNotification,
   sanitizeThreadHistoryImagesForRelay,
+  shouldSuppressRolloutMirrorForThread,
   startBridge,
 };