@makerbi/remodex 1.4.1 → 1.5.1

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@makerbi/remodex",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AndersonBY/remodex.git",
+    "directory": "phodex-bridge"
+  },
   "main": "src/index.js",
   "bin": {
     "remodex": "bin/remodex.js"

package/src/bridge.js

@@ -43,7 +43,6 @@ const { createBridgeSecureTransport } = require("./secure-transport");
 const { createRolloutLiveMirrorController } = require("./rollout-live-mirror");
 const {
   createDesktopIpcActionFollower,
-  seedConversationStateFromThreadRead,
 } = require("./desktop-ipc-action-follower");
 const { version: bridgePackageVersion = "" } = require("../package.json");
 const {
@@ -67,6 +66,24 @@ 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;
+const RELAY_TURNS_LIST_TARGET_BUDGET_MS = 5_500;
+const RELAY_TURNS_LIST_BUDGET_RESERVE_MS = 1_000;
+const RELAY_TURNS_LIST_RESULT_KEYS = ["data", "items", "turns"];
+const RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS = [
+  "nextCursor",
+  "next_cursor",
+  "cursor",
+  "hasNextCursor",
+  "has_next_cursor",
+  "hasNextPage",
+  "has_next_page",
+  "hasMore",
+  "has_more",
+  "prevCursor",
+  "prev_cursor",
+  "previousCursor",
+  "previous_cursor",
+];
 
 function buildRelayUserAgentHeader({ version = bridgePackageVersion } = {}) {
   const normalizedVersion = typeof version === "string" && version.trim()
@@ -169,6 +186,7 @@ function startBridge({
   const relaySanitizedRequestMethods = new Set([
     "thread/read",
     "thread/resume",
+    "thread/turns/list",
   ]);
   const forwardedRequestMethodTTLms = 2 * 60_000;
   const pendingAuthLogin = {
@@ -206,7 +224,6 @@ function startBridge({
   const desktopIpcActionFollower = !config.codexEndpoint
     ? createDesktopIpcActionFollower({
       sendApplicationResponse,
-      readConversationState: readDesktopConversationState,
       socketPath: config.desktopIpcSocketPath || undefined,
     })
     : null;
@@ -580,6 +597,9 @@ function startBridge({
     if (desktopIpcActionFollower?.observeInbound(rawMessage)) {
       return;
     }
+    if (handleBridgeManagedThreadTurnsListRequest(rawMessage)) {
+      return;
+    }
     rememberForwardedRequestMethod(rawMessage);
     rememberThreadFromMessage("phone", rawMessage);
     codex.send(rawMessage);
@@ -612,13 +632,33 @@ function startBridge({
     }));
   }
 
-  // Seeds the desktop IPC follower when it receives patches before a full snapshot.
-  async function readDesktopConversationState(threadId) {
-    const result = await sendCodexRequest("thread/read", {
-      threadId,
-      includeTurns: true,
-    });
-    return seedConversationStateFromThreadRead(result);
+  function handleBridgeManagedThreadTurnsListRequest(rawMessage) {
+    const request = parseAdaptiveThreadTurnsListRequest(rawMessage);
+    if (!request) {
+      return false;
+    }
+
+    rememberThreadFromMessage("phone", rawMessage);
+    (async () => {
+      try {
+        const response = await fetchAdaptiveThreadTurnsListForRelay(request, {
+          fetchPage: (params) => sendCodexRequest("thread/turns/list", params),
+        });
+        relaySanitizedResponseMethodsById.set(String(request.id), {
+          method: "thread/turns/list",
+          createdAt: Date.now(),
+        });
+        sendApplicationResponse(JSON.stringify(response));
+      } catch (error) {
+        sendApplicationResponse(createJsonRpcErrorResponse(
+          request.id,
+          error,
+          "thread_turns_list_failed"
+        ));
+      }
+    })();
+
+    return true;
   }
 
   // ─── Bridge-owned auth snapshot ─────────────────────────────
@@ -1454,81 +1494,242 @@ function normalizeNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
 
-// Shrinks `thread/read` and `thread/resume` snapshots for mobile relay delivery.
-// This elides bulky blobs and replaces oversized older history with a compact marker.
-function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
-  if (requestMethod !== "thread/read" && requestMethod !== "thread/resume") {
-    return rawMessage;
+function parseAdaptiveThreadTurnsListRequest(rawMessage) {
+  const parsed = parseBridgeJSON(rawMessage);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
   }
 
-  const parsed = parseBridgeJSON(rawMessage);
-  const thread = parsed?.result?.thread;
-  if (!thread || typeof thread !== "object" || !Array.isArray(thread.turns)) {
-    return rawMessage;
+  if (parsed.method !== "thread/turns/list") {
+    return null;
   }
 
-  let didSanitize = false;
-  const sanitizedTurns = thread.turns.map((turn) => {
-    if (!turn || typeof turn !== "object" || !Array.isArray(turn.items)) {
-      return turn;
-    }
+  if (parsed.id == null) {
+    return null;
+  }
 
-    let turnDidChange = false;
-    const threadId = normalizeNonEmptyString(thread.id)
-      || normalizeNonEmptyString(thread.threadId)
-      || normalizeNonEmptyString(thread.thread_id);
+  const params = parsed.params;
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return null;
+  }
 
-    const sanitizedItems = turn.items.map((item) => {
-      if (!item || typeof item !== "object") {
-        return item;
-      }
+  if (!Number.isInteger(params.limit) || params.limit <= 0) {
+    return null;
+  }
 
-      let itemDidChange = false;
-      let sanitizedItem = annotateImageGenerationHistoryItem(item, threadId);
-      if (sanitizedItem !== item) {
-        itemDidChange = true;
-      }
+  return parsed;
+}
 
-      if (Array.isArray(item.content)) {
-        const sanitizedContent = item.content.map((contentItem) => {
-          const sanitizedEntry = sanitizeInlineHistoryImageContentItem(contentItem);
-          if (sanitizedEntry !== contentItem) {
-            itemDidChange = true;
-          }
-          return sanitizedEntry;
-        });
+async function fetchAdaptiveThreadTurnsListForRelay(request, {
+  fetchPage,
+  now = Date.now,
+  targetBudgetMs = RELAY_TURNS_LIST_TARGET_BUDGET_MS,
+  budgetReserveMs = RELAY_TURNS_LIST_BUDGET_RESERVE_MS,
+  rawPageSoftLimitBytes = RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES,
+  payloadSoftLimitBytes = RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES,
+  sanitizeForRelay = sanitizeThreadHistoryImagesForRelay,
+} = {}) {
+  if (typeof fetchPage !== "function") {
+    throw new Error("fetchPage is required for adaptive turns-list pagination.");
+  }
+
+  const params = request?.params;
+  const requestedLimit = Number.isInteger(params?.limit) && params.limit > 0
+    ? params.limit
+    : 1;
+  const startedAt = now();
+  let nextCursor = params?.cursor;
+  let turnsKey = null;
+  let firstResult = null;
+  let lastResult = null;
+  let combinedTurns = [];
+  let response = null;
+
+  while (combinedTurns.length < requestedLimit) {
+    const remaining = requestedLimit - combinedTurns.length;
+    const pageLimit = selectAdaptiveTurnsListBatchLimit(combinedTurns.length, remaining);
+    const pageParams = buildAdaptiveTurnsListPageParams(params, pageLimit, nextCursor);
+    let page;
 
-        if (itemDidChange) {
-          sanitizedItem = {
-            ...sanitizedItem,
-            content: sanitizedContent,
-          };
-        }
+    try {
+      page = await fetchMeasuredAdaptiveTurnsListPage(fetchPage, pageParams, now);
+    } catch (error) {
+      if (response) {
+        return response;
       }
+      throw error;
+    }
 
-      const sanitizedCompactionItem = sanitizeCompactionHistoryItem(sanitizedItem);
-      if (sanitizedCompactionItem !== sanitizedItem) {
-        sanitizedItem = sanitizedCompactionItem;
-        itemDidChange = true;
+    const pageResult = page.result;
+    const pageTurnsKey = findTurnsListResultKey(pageResult);
+    if (!pageTurnsKey) {
+      if (!response) {
+        return {
+          id: request.id,
+          result: pageResult ?? null,
+        };
       }
+      return response;
+    }
 
-      if (itemDidChange) {
-        turnDidChange = true;
-      }
+    if (!turnsKey) {
+      turnsKey = pageTurnsKey;
+    }
+    if (!firstResult) {
+      firstResult = pageResult;
+    }
+    lastResult = pageResult;
 
-      return itemDidChange ? sanitizedItem : item;
-    });
+    const pageTurns = pageResult[pageTurnsKey];
+    combinedTurns = combinedTurns.concat(pageTurns);
+    response = {
+      id: request.id,
+      result: buildAdaptiveTurnsListResult(firstResult, lastResult, turnsKey, combinedTurns),
+    };
 
-    if (!turnDidChange) {
-      return turn;
+    nextCursor = readTurnsListNextCursor(pageResult);
+    if (combinedTurns.length >= requestedLimit || !hasRelayCursor(nextCursor) || pageTurns.length === 0) {
+      break;
     }
 
-    didSanitize = true;
-    return {
-      ...turn,
-      items: sanitizedItems,
-    };
-  });
+    const rawPageBytes = jsonByteLength(pageResult);
+    const sanitizedResponseBytes = measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay);
+    const elapsedMs = Math.max(0, now() - startedAt);
+    const remainingBudgetMs = Math.max(0, targetBudgetMs - elapsedMs);
+    if (
+      rawPageBytes >= rawPageSoftLimitBytes
+      || sanitizedResponseBytes >= payloadSoftLimitBytes
+      || page.elapsedMs >= Math.max(0, targetBudgetMs - budgetReserveMs)
+      || remainingBudgetMs <= budgetReserveMs
+    ) {
+      break;
+    }
+  }
+
+  return response ?? {
+    id: request.id,
+    result: {
+      data: [],
+    },
+  };
+}
+
+async function fetchMeasuredAdaptiveTurnsListPage(fetchPage, params, now) {
+  const startedAt = now();
+  const result = await fetchPage(params);
+  const elapsedMs = Math.max(0, now() - startedAt);
+  return {
+    result,
+    elapsedMs,
+  };
+}
+
+function selectAdaptiveTurnsListBatchLimit(fetchedTurnCount, remainingTurnCount) {
+  if (fetchedTurnCount <= 0) {
+    return Math.min(1, remainingTurnCount);
+  }
+  if (fetchedTurnCount <= 1) {
+    return Math.min(4, remainingTurnCount);
+  }
+  return remainingTurnCount;
+}
+
+function buildAdaptiveTurnsListPageParams(baseParams, limit, cursor) {
+  const params = {
+    ...baseParams,
+    limit,
+  };
+  if (hasRelayCursor(cursor)) {
+    params.cursor = cursor;
+  } else {
+    delete params.cursor;
+  }
+  return params;
+}
+
+function findTurnsListResultKey(result) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    return null;
+  }
+  return RELAY_TURNS_LIST_RESULT_KEYS.find((key) => Array.isArray(result[key])) || null;
+}
+
+function buildAdaptiveTurnsListResult(firstResult, lastResult, turnsKey, turns) {
+  const result = {
+    ...firstResult,
+  };
+  for (const key of RELAY_TURNS_LIST_RESULT_KEYS) {
+    delete result[key];
+  }
+  result[turnsKey] = turns;
+
+  for (const key of RELAY_TURNS_LIST_PAGINATION_RESULT_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(lastResult, key)) {
+      result[key] = lastResult[key];
+    } else {
+      delete result[key];
+    }
+  }
+
+  return result;
+}
+
+function readTurnsListNextCursor(result) {
+  if (!result || typeof result !== "object") {
+    return undefined;
+  }
+  if (hasRelayCursor(result.nextCursor)) {
+    return result.nextCursor;
+  }
+  if (hasRelayCursor(result.next_cursor)) {
+    return result.next_cursor;
+  }
+  return undefined;
+}
+
+function hasRelayCursor(cursor) {
+  return cursor !== undefined && cursor !== null && cursor !== "";
+}
+
+function jsonByteLength(value) {
+  try {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+
+function measureSanitizedTurnsListResponseBytes(response, sanitizeForRelay) {
+  try {
+    const rawResponse = JSON.stringify(response);
+    const sanitizedResponse = sanitizeForRelay(rawResponse, "thread/turns/list");
+    return Buffer.byteLength(sanitizedResponse, "utf8");
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+
+// Shrinks thread history snapshots/pages for mobile relay delivery.
+// This elides bulky blobs and replaces oversized older history with a compact marker.
+function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
+  if (requestMethod === "thread/turns/list") {
+    return sanitizeThreadTurnsListForRelay(rawMessage);
+  }
+
+  if (requestMethod !== "thread/read" && requestMethod !== "thread/resume") {
+    return rawMessage;
+  }
+
+  const parsed = parseBridgeJSON(rawMessage);
+  const thread = parsed?.result?.thread;
+  if (!thread || typeof thread !== "object" || !Array.isArray(thread.turns)) {
+    return rawMessage;
+  }
+
+  const threadId = normalizeNonEmptyString(thread.id)
+    || normalizeNonEmptyString(thread.threadId)
+    || normalizeNonEmptyString(thread.thread_id);
+  const { turns: sanitizedTurns, didSanitize } = sanitizeRelayHistoryTurns(thread.turns, threadId);
 
   if (!didSanitize) {
     const trimmedPayload = trimThreadPayloadForRelay(parsed, thread);
@@ -1549,6 +1750,108 @@ function sanitizeThreadHistoryImagesForRelay(rawMessage, requestMethod) {
   return trimThreadPayloadForRelay(parseBridgeJSON(sanitizedPayload), null) ?? sanitizedPayload;
 }
 
+function sanitizeThreadTurnsListForRelay(rawMessage) {
+  const parsed = parseBridgeJSON(rawMessage);
+  const result = parsed?.result;
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    return rawMessage;
+  }
+
+  const turnsKey = ["data", "items", "turns"].find((key) => Array.isArray(result[key]));
+  if (!turnsKey) {
+    return rawMessage;
+  }
+
+  const threadId = normalizeNonEmptyString(result.threadId)
+    || normalizeNonEmptyString(result.thread_id)
+    || normalizeNonEmptyString(result.thread?.id)
+    || normalizeNonEmptyString(result.thread?.threadId)
+    || normalizeNonEmptyString(result.thread?.thread_id);
+  const { turns: sanitizedTurns, didSanitize } = sanitizeRelayHistoryTurns(result[turnsKey], threadId);
+  const sanitizedParsed = didSanitize
+    ? {
+      ...parsed,
+      result: {
+        ...result,
+        [turnsKey]: sanitizedTurns,
+      },
+    }
+    : parsed;
+
+  return trimTurnsListPayloadForRelay(sanitizedParsed, turnsKey, didSanitize ? null : rawMessage);
+}
+
+function sanitizeRelayHistoryTurns(turns, threadId = "") {
+  let didSanitize = false;
+  const sanitizedTurns = turns.map((turn) => {
+    const sanitizedTurn = sanitizeRelayHistoryTurn(turn, threadId);
+    if (sanitizedTurn !== turn) {
+      didSanitize = true;
+    }
+    return sanitizedTurn;
+  });
+
+  return { turns: sanitizedTurns, didSanitize };
+}
+
+function sanitizeRelayHistoryTurn(turn, threadId = "") {
+  if (!turn || typeof turn !== "object" || !Array.isArray(turn.items)) {
+    return turn;
+  }
+
+  let turnDidChange = false;
+  const turnThreadId = normalizeNonEmptyString(threadId)
+    || normalizeNonEmptyString(turn.threadId)
+    || normalizeNonEmptyString(turn.thread_id);
+  const sanitizedItems = turn.items.map((item) => {
+    if (!item || typeof item !== "object") {
+      return item;
+    }
+
+    let itemDidChange = false;
+    let sanitizedItem = annotateImageGenerationHistoryItem(item, turnThreadId);
+    if (sanitizedItem !== item) {
+      itemDidChange = true;
+    }
+
+    if (Array.isArray(sanitizedItem.content)) {
+      const sanitizedContent = sanitizedItem.content.map((contentItem) => {
+        const sanitizedEntry = sanitizeInlineHistoryImageContentItem(contentItem);
+        if (sanitizedEntry !== contentItem) {
+          itemDidChange = true;
+        }
+        return sanitizedEntry;
+      });
+
+      if (itemDidChange) {
+        sanitizedItem = {
+          ...sanitizedItem,
+          content: sanitizedContent,
+        };
+      }
+    }
+
+    const sanitizedCompactionItem = sanitizeCompactionHistoryItem(sanitizedItem);
+    if (sanitizedCompactionItem !== sanitizedItem) {
+      sanitizedItem = sanitizedCompactionItem;
+      itemDidChange = true;
+    }
+
+    if (itemDidChange) {
+      turnDidChange = true;
+    }
+
+    return itemDidChange ? sanitizedItem : item;
+  });
+
+  return turnDidChange
+    ? {
+      ...turn,
+      items: sanitizedItems,
+    }
+    : turn;
+}
+
 // Annotates live image-generation notifications so the phone can render a local-file
 // preview and does not receive the bulky inline base64 result over the relay.
 function sanitizeLiveGeneratedImageMessageForRelay(rawMessage) {
@@ -1951,6 +2254,55 @@ function trimThreadPayloadForRelay(parsed, explicitThread = undefined) {
   return encodeRelayThreadPayload(parsed, candidateThread);
 }
 
+function trimTurnsListPayloadForRelay(parsed, turnsKey, originalRawMessage = null) {
+  const result = parsed?.result;
+  const turns = result?.[turnsKey];
+  if (!parsed || !result || !Array.isArray(turns)) {
+    return originalRawMessage ?? JSON.stringify(parsed);
+  }
+
+  const encoded = JSON.stringify(parsed);
+  if (Buffer.byteLength(encoded, "utf8") <= RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES) {
+    return originalRawMessage ?? encoded;
+  }
+
+  let fallbackCompactedPayload = null;
+  for (const maxChars of [
+    RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS,
+    Math.floor(RELAY_HISTORY_TEXT_TAIL_LIMIT_CHARS / 4),
+    1_000,
+    0,
+  ]) {
+    const compactedTurns = turns.map((turn) => compactTurnsListTurnForRelay(turn, maxChars));
+    const compactedPayload = JSON.stringify({
+      ...parsed,
+      result: {
+        ...result,
+        [turnsKey]: compactedTurns,
+        remodexPageCompactedForRelay: true,
+      },
+    });
+    fallbackCompactedPayload = compactedPayload;
+    if (Buffer.byteLength(compactedPayload, "utf8") <= RELAY_THREAD_PAYLOAD_SOFT_LIMIT_BYTES) {
+      return compactedPayload;
+    }
+  }
+
+  return fallbackCompactedPayload ?? (originalRawMessage ?? encoded);
+}
+
+function compactTurnsListTurnForRelay(turn, maxChars) {
+  if (!turn || typeof turn !== "object" || !Array.isArray(turn.items)) {
+    return turn;
+  }
+
+  return {
+    ...turn,
+    items: turn.items.map((item) => compactHistoryItemForRelay(item, maxChars)),
+    remodexPageCompactedForRelay: true,
+  };
+}
+
 function buildRelayHistoryCompactedThread(thread, turns, omittedTurnCount, keptTurnCount) {
   return {
     ...thread,
@@ -2078,7 +2430,7 @@ function compactHistoryItemForRelay(item, maxChars) {
     itemId: typeof item?.itemId === "string" ? item.itemId : undefined,
     relayPayloadTruncated: true,
   };
-  const tailText = firstRelayTextTail(item, maxChars);
+  const tailText = maxChars > 0 ? firstRelayTextTail(item, maxChars) : "";
   if (tailText) {
     compactItem.text = tailText;
   }
@@ -2183,6 +2535,7 @@ module.exports = {
   buildRelayAccessTokenHeaders,
   buildRelayUserAgentHeader,
   createMacOSBridgeWakeAssertion,
+  fetchAdaptiveThreadTurnsListForRelay,
   hasRelayConnectionGoneStale,
   isTerminalRelayCloseCode,
   persistBridgePreferences,

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

@@ -77,7 +77,6 @@ function createDesktopIpcActionFollower({
 
     activeThreadIds.add(threadId);
     ipc.ensureConnected();
-    recoverThreadBaseline(threadId);
     return false;
   }
 
@@ -111,6 +110,19 @@ function createDesktopIpcActionFollower({
     const nextState = applyConversationStateChange(previousState, params.change);
     if (!nextState) {
       if (isPatchChange(params.change)) {
+        const emptyState = createEmptyConversationState();
+        const speculativeState = applyConversationStateChange(emptyState, params.change);
+        const speculativeActions = projectPendingDesktopActions(threadId, speculativeState);
+        if (speculativeActions.length > 0) {
+          rawStatesByThreadId.set(threadId, speculativeState);
+          syncProjectedActions(threadId, speculativeActions);
+          return;
+        }
+
+        if (typeof readConversationState !== "function") {
+          return;
+        }
+
         queueThreadChange(threadId, params.change);
         recoverThreadBaseline(threadId);
       }
@@ -219,8 +231,7 @@ function createDesktopIpcActionFollower({
   }
 
   function recoverThreadBaseline(threadId) {
-    if (typeof readConversationState !== "function"
-      || recoveringThreadIds.has(threadId)
+    if (recoveringThreadIds.has(threadId)
       || rawStatesByThreadId.has(threadId)) {
       return;
     }
@@ -230,27 +241,39 @@ function createDesktopIpcActionFollower({
       .then(() => readConversationState(threadId))
       .then((baselineState) => {
         if (!baselineState || typeof baselineState !== "object") {
+          recoverThreadBaselineFromQueuedChanges(threadId, null);
           return;
         }
 
-        let nextState = cloneJSON(baselineState);
-        const queuedChanges = queuedChangesByThreadId.get(threadId) || [];
-        queuedChangesByThreadId.delete(threadId);
-        for (const change of queuedChanges) {
-          nextState = applyConversationStateChange(nextState, change) || nextState;
-        }
-
-        rawStatesByThreadId.set(threadId, nextState);
-        syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
+        recoverThreadBaselineFromQueuedChanges(threadId, baselineState);
       })
       .catch((error) => {
         console.warn(`${logPrefix} desktop IPC baseline recovery failed for ${threadId}: ${error.message}`);
+        recoverThreadBaselineFromQueuedChanges(threadId, null);
       })
       .finally(() => {
         recoveringThreadIds.delete(threadId);
       });
   }
 
+  function recoverThreadBaselineFromQueuedChanges(threadId, baselineState) {
+    const queuedChanges = queuedChangesByThreadId.get(threadId) || [];
+    if (queuedChanges.length === 0) {
+      return;
+    }
+
+    queuedChangesByThreadId.delete(threadId);
+    let nextState = baselineState && typeof baselineState === "object"
+      ? cloneJSON(baselineState)
+      : createEmptyConversationState();
+    for (const change of queuedChanges) {
+      nextState = applyConversationStateChange(nextState, change) || nextState;
+    }
+
+    rawStatesByThreadId.set(threadId, nextState);
+    syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
+  }
+
   return {
     observeInbound,
     stopAll,
@@ -555,6 +578,13 @@ function seedConversationStateFromThreadRead(response) {
   };
 }
 
+function createEmptyConversationState() {
+  return {
+    turns: [],
+    requests: [],
+  };
+}
+
 function applyImmerPatch(target, patch) {
   const patchPath = Array.isArray(patch?.path) ? patch.path : [];
   const op = readString(patch?.op).toLowerCase();

package/src/git-handler.js

@@ -51,7 +51,20 @@ function handleGitRequest(rawMessage, sendResponse, options = {}) {
   const id = parsed.id;
   const params = parsed.params || {};
 
-  handleGitMethod(method, params, options)
+  // Lets long-running git flows push interim progress events to the phone.
+  const sendNotification = (notificationMethod, notificationParams) => {
+    if (typeof notificationMethod !== "string" || !notificationMethod) {
+      return;
+    }
+    sendResponse(JSON.stringify({
+      method: notificationMethod,
+      params: notificationParams ?? {},
+    }));
+  };
+
+  const methodOptions = { ...options, sendNotification };
+
+  handleGitMethod(method, params, methodOptions)
     .then((result) => {
       sendResponse(JSON.stringify({ id, result }));
       if (method === "thread/name/set") {
@@ -979,8 +992,26 @@ async function gitRunStackedAction(cwd, params, options = {}) {
   const wantsCommit = action === "commit" || action === "commit_push" || action === "commit_push_pr";
   const wantsPr = action === "create_pr" || action === "commit_push_pr";
 
+  // Emits phase progress events on the same wire used by JSON-RPC responses
+  // so the iOS toast can reflect the live step (commit/push/PR) of a stacked action.
+  const progressId = typeof params.progressId === "string" && params.progressId.trim()
+    ? params.progressId.trim()
+    : null;
+  const emitPhase = (phase, status) => {
+    if (!progressId || typeof options.sendNotification !== "function") {
+      return;
+    }
+    options.sendNotification("git/stackedAction/progress", {
+      progressId,
+      phase,
+      status,
+    });
+  };
+
   if (params.featureBranch === true) {
+    emitPhase("branch", "started");
     await gitCreateFeatureBranch(cwd, params);
+    emitPhase("branch", "completed");
   }
 
   const branch = await currentBranchName(cwd);
@@ -1006,6 +1037,7 @@ async function gitRunStackedAction(cwd, params, options = {}) {
   if (wantsCommit) {
     const statusBeforeCommit = await gitStatus(cwd);
     if (statusBeforeCommit.dirty) {
+      emitPhase("commit", "started");
       const commitResult = await gitCommit(cwd, {
         message: params.commitMessage || params.message,
       });
@@ -1015,10 +1047,12 @@ async function gitRunStackedAction(cwd, params, options = {}) {
         commitSha: commitResult.hash,
         subject: firstCommitMessageLine(params.commitMessage || params.message),
       };
+      emitPhase("commit", "completed");
     } else if (action === "commit") {
       throw gitError("nothing_to_commit", "Nothing to commit.");
     } else {
       result.commit = { status: "skipped_clean" };
+      emitPhase("commit", "skipped");
     }
   }
 
@@ -1039,17 +1073,21 @@ async function gitRunStackedAction(cwd, params, options = {}) {
     if (statusBeforePush.dirty) {
       throw gitError("dirty_worktree", "Commit or stash local changes before pushing.");
     }
+    emitPhase("push", "started");
     result.push = {
       state: "pushed",
       ...(await gitPush(cwd)),
     };
+    emitPhase("push", "completed");
   }
 
   if (wantsPr) {
+    emitPhase("createPR", "started");
     result.pr = await gitCreatePullRequest(cwd, {
       ...params,
       pushBeforeCreate: false,
     }, options);
+    emitPhase("createPR", "completed");
   }
 
   result.status = await gitStatus(cwd);

package/src/macos-launch-agent.js

@@ -33,8 +33,8 @@ const DEFAULT_PAIRING_WAIT_TIMEOUT_MS = 10_000;
 const DEFAULT_PAIRING_WAIT_INTERVAL_MS = 200;
 
 // Runs the bridge inside launchd while keeping QR rendering in the foreground CLI command.
-function runMacOSBridgeService({ env = process.env } = {}) {
-  assertDarwinPlatform();
+function runMacOSBridgeService({ env = process.env, platform = process.platform } = {}) {
+  assertDarwinPlatform(platform);
   const config = readDaemonConfig({ env });
   if (!config?.relayUrl) {
     const message = "No relay URL configured for the macOS bridge service.";

package/src/rollout-watch.js

@@ -441,12 +441,12 @@ function findNewestRolloutFileForThread(root, threadId, { fsModule = fs } = {})
         continue;
       }
 
-      const stat = fsModule.statSync(fullPath);
-      if (!newestMatch || stat.mtimeMs > newestMatch.mtimeMs) {
-        newestMatch = {
-          filePath: fullPath,
-          mtimeMs: stat.mtimeMs,
-        };
+      const candidate = {
+        filePath: fullPath,
+        mtimeMs: fsModule.statSync(fullPath).mtimeMs,
+      };
+      if (!newestMatch || compareRolloutFileOrder(candidate, newestMatch) < 0) {
+        newestMatch = candidate;
       }
     }
   }
@@ -498,10 +498,20 @@ function collectRecentRolloutFiles(
     }
   }
 
-  candidates.sort((lhs, rhs) => rhs.mtimeMs - lhs.mtimeMs);
+  candidates.sort(compareRolloutFileOrder);
   return candidates.slice(0, candidateLimit);
 }
 
+// Keeps rollout selection deterministic when filesystem timestamp resolution
+// reports equal mtimes for several rollout candidates.
+function compareRolloutFileOrder(lhs, rhs) {
+  if (lhs.mtimeMs !== rhs.mtimeMs) {
+    return rhs.mtimeMs - lhs.mtimeMs;
+  }
+
+  return rhs.filePath.localeCompare(lhs.filePath);
+}
+
 function rolloutFileContainsTurnId(
   filePath,
   turnId,

package/src/secure-device-state.js

@@ -14,6 +14,7 @@ const DEFAULT_STORE_DIR = path.join(os.homedir(), ".remodex");
 const DEFAULT_STORE_FILE = path.join(DEFAULT_STORE_DIR, "device-state.json");
 const KEYCHAIN_SERVICE = "com.remodex.bridge.device-state";
 const KEYCHAIN_ACCOUNT = "default";
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 let hasLoggedKeychainMismatch = false;
 
 // Loads the canonical bridge state or bootstraps a fresh one when no trusted state exists yet.
@@ -22,8 +23,11 @@ function loadOrCreateBridgeDeviceState() {
   const keychainRecord = readKeychainStateRecord();
 
   if (fileRecord.state) {
-    reconcileLegacyKeychainMirror(fileRecord.state, keychainRecord);
-    return fileRecord.state;
+    const canonicalState = recoverBridgeDeviceIdentity(fileRecord.state, {
+      fallbackState: keychainRecord.state,
+    });
+    reconcileLegacyKeychainMirror(canonicalState, keychainRecord);
+    return canonicalState;
   }
 
   if (fileRecord.error) {
@@ -31,8 +35,9 @@ function loadOrCreateBridgeDeviceState() {
       warnOnce(
         "[remodex] Recovering the canonical device-state.json from the legacy Keychain pairing mirror."
       );
-      writeBridgeDeviceState(keychainRecord.state);
-      return keychainRecord.state;
+      const recoveredState = recoverBridgeDeviceIdentity(keychainRecord.state);
+      writeBridgeDeviceState(recoveredState);
+      return recoveredState;
     }
     throw corruptedStateError("device-state.json", fileRecord.error);
   }
@@ -47,8 +52,9 @@ function loadOrCreateBridgeDeviceState() {
   }
 
   if (keychainRecord.state) {
-    writeBridgeDeviceState(keychainRecord.state);
-    return keychainRecord.state;
+    const recoveredState = recoverBridgeDeviceIdentity(keychainRecord.state);
+    writeBridgeDeviceState(recoveredState);
+    return recoveredState;
   }
 
   const nextState = createBridgeDeviceState();
@@ -382,10 +388,32 @@ function normalizeBridgeDeviceState(rawState) {
   };
 }
 
+function recoverBridgeDeviceIdentity(state, { fallbackState = null } = {}) {
+  if (isValidBridgeDeviceId(state?.macDeviceId)) {
+    return state;
+  }
+
+  if (fallbackState && isValidBridgeDeviceId(fallbackState.macDeviceId)) {
+    warnOnce("[remodex] Recovering an invalid saved bridge device identity from the legacy Keychain mirror.");
+    writeBridgeDeviceState(fallbackState);
+    return fallbackState;
+  }
+
+  warnOnce("[remodex] Rotating an invalid saved bridge device identity; scan the fresh QR to pair again.");
+  const nextState = createBridgeDeviceState();
+  nextState.lastSeenPhoneAppVersion = state?.lastSeenPhoneAppVersion || null;
+  writeBridgeDeviceState(nextState);
+  return nextState;
+}
+
 function bridgeStatesEqual(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
+function isValidBridgeDeviceId(value) {
+  return UUID_V4_PATTERN.test(normalizeNonEmptyString(value));
+}
+
 function normalizeNonEmptyString(value) {
   if (typeof value !== "string") {
     return "";

package/src/workspace-handler.js

@@ -102,6 +102,10 @@ async function handleWorkspaceMethod(method, params) {
       return workspaceRevertPatchPreview(repoRoot, params);
     case "workspace/revertPatchApply":
       return withRepoMutationLock(repoRoot, () => workspaceRevertPatchApply(repoRoot, params));
+    case "workspace/revertPatchBatchPreview":
+      return workspaceRevertPatchBatchPreview(repoRoot, params);
+    case "workspace/revertPatchBatchApply":
+      return withRepoMutationLock(repoRoot, () => workspaceRevertPatchBatchApply(repoRoot, params));
     default:
       throw workspaceError("unknown_method", `Unknown workspace method: ${method}`);
   }
@@ -369,7 +373,7 @@ async function workspaceRevertPatchPreview(repoRoot, params) {
     };
   }
 
-  const applyCheck = await runGitApply(repoRoot, ["apply", "--reverse", "--check"], forwardPatch);
+  const applyCheck = await checkReversePatch(repoRoot, forwardPatch);
   const conflicts = applyCheck.ok
     ? []
     : parseApplyConflicts(applyCheck.stderr || applyCheck.stdout || "Patch does not apply.");
@@ -385,6 +389,7 @@ async function workspaceRevertPatchPreview(repoRoot, params) {
 
 // Reverse-applies the patch only after the same safety checks pass in the locked mutation path.
 async function workspaceRevertPatchApply(repoRoot, params) {
+  const forwardPatch = resolveForwardPatch(params);
   const preview = await workspaceRevertPatchPreview(repoRoot, params);
   if (!preview.canRevert) {
     return {
@@ -396,8 +401,10 @@ async function workspaceRevertPatchApply(repoRoot, params) {
     };
   }
 
-  const forwardPatch = resolveForwardPatch(params);
-  const applyResult = await runGitApply(repoRoot, ["apply", "--reverse"], forwardPatch);
+  const checkedPatch = await checkReversePatch(repoRoot, forwardPatch);
+  const applyResult = checkedPatch.ok
+    ? await runGitApply(repoRoot, checkedPatch.applyArgs, forwardPatch)
+    : checkedPatch;
   if (!applyResult.ok) {
     return {
       success: false,
@@ -409,6 +416,7 @@ async function workspaceRevertPatchApply(repoRoot, params) {
     };
   }
 
+  await resetTargetedFilesIndex(repoRoot, preview.affectedFiles);
   const status = await gitStatus(repoRoot).catch(() => null);
   return {
     success: true,
@@ -420,6 +428,91 @@ async function workspaceRevertPatchApply(repoRoot, params) {
   };
 }
 
+// Validates a newest-first patch batch as one reverse operation so dependent patches see the right state.
+async function workspaceRevertPatchBatchPreview(repoRoot, params) {
+  const patches = resolveForwardPatchBatch(params);
+  const analyses = patches.map((patch) => analyzeUnifiedPatch(patch.forwardPatch));
+  const affectedFiles = uniqueSorted(analyses.flatMap((analysis) => analysis.affectedFiles));
+  const unsupportedReasons = uniqueSorted(analyses.flatMap((analysis) => analysis.unsupportedReasons));
+  const stagedFiles = await findStagedTargetedFiles(repoRoot, affectedFiles);
+
+  if (unsupportedReasons.length || stagedFiles.length) {
+    return {
+      canRevert: false,
+      affectedFiles,
+      conflicts: [],
+      unsupportedReasons,
+      stagedFiles,
+      patchResults: patches.map((patch, index) => ({
+        id: patch.id,
+        canRevert: analyses[index].unsupportedReasons.length === 0,
+        unsupportedReasons: analyses[index].unsupportedReasons,
+      })),
+    };
+  }
+
+  const sequenceCheck = await previewReversePatchSequence(repoRoot, patches, affectedFiles);
+  const conflicts = sequenceCheck.ok
+    ? []
+    : parseApplyConflicts(sequenceCheck.stderr || sequenceCheck.stdout || "Patch batch does not apply.");
+
+  return {
+    canRevert: sequenceCheck.ok && conflicts.length === 0,
+    affectedFiles,
+    conflicts,
+    unsupportedReasons: [],
+    stagedFiles,
+    patchResults: patches.map((patch) => ({
+      id: patch.id,
+      canRevert: sequenceCheck.ok && conflicts.length === 0,
+    })),
+  };
+}
+
+// Applies all batch patches under one repo lock and only marks success after the full reverse patch lands.
+async function workspaceRevertPatchBatchApply(repoRoot, params) {
+  const patches = resolveForwardPatchBatch(params);
+  const preview = await workspaceRevertPatchBatchPreview(repoRoot, params);
+  if (!preview.canRevert) {
+    return {
+      success: false,
+      revertedFiles: [],
+      conflicts: preview.conflicts,
+      unsupportedReasons: preview.unsupportedReasons,
+      stagedFiles: preview.stagedFiles,
+      patchResults: preview.patchResults || [],
+    };
+  }
+
+  const applyResult = await applyReversePatchSequence(repoRoot, patches, preview.affectedFiles);
+  if (!applyResult.ok) {
+    return {
+      success: false,
+      revertedFiles: [],
+      conflicts: parseApplyConflicts(applyResult.stderr || applyResult.stdout || "Patch batch does not apply."),
+      unsupportedReasons: [],
+      stagedFiles: [],
+      patchResults: patches.map((patch) => ({
+        id: patch.id,
+        applied: applyResult.appliedPatchIds.includes(patch.id),
+      })),
+      status: await gitStatus(repoRoot).catch(() => null),
+    };
+  }
+
+  await resetTargetedFilesIndex(repoRoot, preview.affectedFiles);
+  const status = await gitStatus(repoRoot).catch(() => null);
+  return {
+    success: true,
+    revertedFiles: preview.affectedFiles,
+    conflicts: [],
+    unsupportedReasons: [],
+    stagedFiles: [],
+    patchResults: patches.map((patch) => ({ id: patch.id, applied: true })),
+    status,
+  };
+}
+
 function resolveForwardPatch(params) {
   const forwardPatch =
     typeof params.forwardPatch === "string" ? params.forwardPatch : "";
@@ -431,6 +524,32 @@ function resolveForwardPatch(params) {
   return forwardPatch.endsWith("\n") ? forwardPatch : `${forwardPatch}\n`;
 }
 
+function resolveForwardPatchBatch(params) {
+  const rawPatches = Array.isArray(params.patches) ? params.patches : [];
+  const patches = rawPatches.map((rawPatch, index) => {
+    if (typeof rawPatch === "string") {
+      return {
+        id: String(index),
+        forwardPatch: rawPatch.endsWith("\n") ? rawPatch : `${rawPatch}\n`,
+      };
+    }
+
+    const forwardPatch = rawPatch && typeof rawPatch.forwardPatch === "string"
+      ? rawPatch.forwardPatch
+      : "";
+    return {
+      id: rawPatch && typeof rawPatch.id === "string" ? rawPatch.id : String(index),
+      forwardPatch: forwardPatch.endsWith("\n") ? forwardPatch : `${forwardPatch}\n`,
+    };
+  }).filter((patch) => patch.forwardPatch.trim());
+
+  if (!patches.length) {
+    throw workspaceError("missing_patch", "The request must include at least one non-empty patch.");
+  }
+
+  return patches;
+}
+
 function analyzeUnifiedPatch(rawPatch) {
   const patch = rawPatch.trim();
   if (!patch) {
@@ -587,6 +706,188 @@ async function findStagedTargetedFiles(cwd, affectedFiles) {
   }
 }
 
+async function previewReversePatchSequence(repoRoot, patches, affectedFiles) {
+  const sandboxRoot = await createPatchSandbox(repoRoot, affectedFiles);
+
+  try {
+    for (const patch of patches) {
+      const check = await checkReversePatch(sandboxRoot, patch.forwardPatch);
+      if (!check.ok) {
+        return { ...check, failedPatchId: patch.id };
+      }
+
+      const applied = await runGitApply(sandboxRoot, check.applyArgs, patch.forwardPatch);
+      if (!applied.ok) {
+        return { ...applied, failedPatchId: patch.id };
+      }
+      await syncPatchSandboxIndex(sandboxRoot);
+    }
+
+    return { ok: true, stdout: "", stderr: "" };
+  } finally {
+    await fs.promises.rm(sandboxRoot, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+async function applyReversePatchSequence(repoRoot, patches, affectedFiles) {
+  const appliedPatchIds = [];
+  const backup = await createPatchBackup(repoRoot, affectedFiles);
+
+  try {
+    for (const patch of patches) {
+      const checkedPatch = await checkReversePatch(repoRoot, patch.forwardPatch);
+      if (!checkedPatch.ok) {
+        await restorePatchBackup(repoRoot, backup);
+        return { ...checkedPatch, appliedPatchIds, failedPatchId: patch.id };
+      }
+
+      const appliedPatch = await runGitApply(repoRoot, checkedPatch.applyArgs, patch.forwardPatch);
+      if (!appliedPatch.ok) {
+        await restorePatchBackup(repoRoot, backup);
+        return { ...appliedPatch, appliedPatchIds, failedPatchId: patch.id };
+      }
+
+      appliedPatchIds.push(patch.id);
+    }
+
+    return { ok: true, stdout: "", stderr: "", appliedPatchIds };
+  } finally {
+    await fs.promises.rm(backup.root, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+async function createPatchSandbox(repoRoot, affectedFiles) {
+  const sandboxRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), "remodex-revert-preview-"));
+
+  for (const affectedFile of affectedFiles) {
+    const sourcePath = path.resolve(repoRoot, affectedFile);
+    if (!isPathInside(sourcePath, repoRoot)) {
+      continue;
+    }
+
+    const destinationPath = path.resolve(sandboxRoot, affectedFile);
+    if (!isPathInside(destinationPath, sandboxRoot) || !fs.existsSync(sourcePath)) {
+      continue;
+    }
+
+    await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
+    await fs.promises.copyFile(sourcePath, destinationPath);
+  }
+
+  await initializePatchSandboxGitRepo(sandboxRoot);
+  return sandboxRoot;
+}
+
+async function initializePatchSandboxGitRepo(sandboxRoot) {
+  await git(sandboxRoot, "init", "-q");
+  await git(sandboxRoot, "config", "user.email", "remodex@example.local");
+  await git(sandboxRoot, "config", "user.name", "Remodex");
+  await syncPatchSandboxIndex(sandboxRoot);
+  await git(sandboxRoot, "commit", "-qm", "snapshot", "--allow-empty");
+}
+
+async function syncPatchSandboxIndex(sandboxRoot) {
+  await git(sandboxRoot, "add", "-A");
+}
+
+async function createPatchBackup(repoRoot, affectedFiles) {
+  const backupRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), "remodex-revert-backup-"));
+  const entries = [];
+
+  for (const affectedFile of affectedFiles) {
+    const sourcePath = path.resolve(repoRoot, affectedFile);
+    if (!isPathInside(sourcePath, repoRoot)) {
+      continue;
+    }
+
+    const backupPath = path.resolve(backupRoot, affectedFile);
+    if (!isPathInside(backupPath, backupRoot)) {
+      continue;
+    }
+
+    const exists = fs.existsSync(sourcePath);
+    entries.push({ relativePath: affectedFile, exists });
+    if (!exists) {
+      continue;
+    }
+
+    await fs.promises.mkdir(path.dirname(backupPath), { recursive: true });
+    await fs.promises.copyFile(sourcePath, backupPath);
+  }
+
+  return { root: backupRoot, entries };
+}
+
+async function restorePatchBackup(repoRoot, backup) {
+  for (const entry of backup.entries) {
+    const targetPath = path.resolve(repoRoot, entry.relativePath);
+    if (!isPathInside(targetPath, repoRoot)) {
+      continue;
+    }
+
+    if (!entry.exists) {
+      await fs.promises.rm(targetPath, { force: true, recursive: true }).catch(() => {});
+      continue;
+    }
+
+    const backupPath = path.resolve(backup.root, entry.relativePath);
+    if (!isPathInside(backupPath, backup.root)) {
+      continue;
+    }
+
+    await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.promises.copyFile(backupPath, targetPath);
+  }
+
+  await resetTargetedFilesIndex(repoRoot, backup.entries.map((entry) => entry.relativePath));
+}
+
+async function resetTargetedFilesIndex(cwd, affectedFiles) {
+  if (!affectedFiles.length) {
+    return;
+  }
+
+  await git(cwd, "reset", "-q", "--", ...affectedFiles);
+}
+
+async function checkReversePatch(cwd, patchText) {
+  if (isFileLifecyclePatch(patchText)) {
+    const plainCheck = await runGitApply(cwd, ["apply", "--reverse", "--check"], patchText);
+    return { ...plainCheck, applyArgs: ["apply", "--reverse"] };
+  }
+
+  const codexCheckArgs = ["apply", "--reverse", "--check", "--3way"];
+  const plainCheckArgs = ["apply", "--reverse", "--check"];
+  const codexCheck = await runGitApply(cwd, codexCheckArgs, patchText);
+
+  if (codexCheck.ok) {
+    return { ...codexCheck, applyArgs: ["apply", "--reverse", "--3way"] };
+  }
+
+  // git apply --3way requires index/worktree agreement; assistant edits are usually unstaged.
+  if (!isIndexMismatch(codexCheck)) {
+    return { ...codexCheck, applyArgs: ["apply", "--reverse", "--3way"] };
+  }
+
+  const plainCheck = await runGitApply(cwd, plainCheckArgs, patchText);
+  return { ...plainCheck, applyArgs: ["apply", "--reverse"] };
+}
+
+function isFileLifecyclePatch(patchText) {
+  return String(patchText || "")
+    .split("\n")
+    .some((line) => line === "--- /dev/null" || line === "+++ /dev/null");
+}
+
+function isIndexMismatch(result) {
+  const output = `${result.stderr || ""}\n${result.stdout || ""}`;
+  return output.includes("does not match index");
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values.filter(Boolean))].sort();
+}
+
 async function runGitApply(cwd, args, patchText) {
   const tempPatchPath = await writeTempPatchFile(patchText);