@makerbi/remodex 3.1.0 → 3.3.0

package/src/desktop-ipc-live-owner.js

@@ -5,11 +5,19 @@
 // Depends on: net, ./desktop-ipc-conversation-adapter, ./desktop-ipc-owner-transport, ./desktop-ipc-state-patches, ./desktop-ipc-shared
 
 const net = require("net");
+const {
+  applyRuntimeSettingsToConversation,
+  createThreadMutationQueue,
+  hasOwn,
+  normalizeThreadSettingsUpdate,
+  threadSettingsFromRuntimeSettings,
+} = require("./codex-runtime-settings");
 
 const {
   CLIENT_STATUS_CHANGED,
   DESKTOP_IPC_METHOD_VERSIONS: METHOD_VERSION_BY_NAME,
   buildCompleteThreadReadParams,
+  buildThreadReadStateContext,
   cloneJSON,
   conversationSnapshotShowsActiveTurn,
   isPlainJSONObject,
@@ -27,6 +35,7 @@ const {
   buildConversationStateFromThread,
   createEmptyConversationState,
   readThreadIdFromParams,
+  synchronizeDesktopConversationCompatibility,
 } = require("./desktop-ipc-conversation-adapter");
 const {
   DEFAULT_MAX_PATCH_BYTES,
@@ -65,6 +74,7 @@ const THREAD_QUEUED_FOLLOWUPS_CHANGED = "thread-queued-followups-changed";
 const REMODEX_LIVE_OWNER_SOURCE = "desktop-ipc-live-owner";
 
 const SUPPORTED_FOLLOWER_REQUEST_METHODS = new Set([
+  "thread-owner-discovery",
   "thread-follower-start-turn",
   "thread-follower-load-complete-history",
   "thread-follower-update-thread-settings",
@@ -94,20 +104,33 @@ const OWNER_INBOUND_METHODS = new Set([
 
 const THREAD_READ_METHODS = new Set(["thread/read", "thread/resume"]);
 
-const ALLOWED_TURN_START_PARAM_KEYS = new Set([
+// Current app-server v2 TurnStartParams fields. Desktop's adjacent turnStart.context
+// is presentation state, not part of this RPC shape, so it stays outside the request.
+const APP_SERVER_TURN_START_PARAM_KEYS = new Set([
   "threadId",
   "input",
+  "additionalContext",
   "cwd",
   "approvalPolicy",
   "approvalsReviewer",
   "sandboxPolicy",
   "model",
   "serviceTier",
+  "serviceTierForTurn",
   "effort",
   "summary",
   "personality",
   "outputSchema",
   "collaborationMode",
+  "clientUserMessageId",
+  "cyberAccessProgram",
+  "environments",
+  "multiAgentMode",
+  "permissions",
+  "responsesapiClientMetadata",
+  "runtimeWorkspaceRoots",
+  "toolOutput",
+  "turnTrigger",
 ]);
 
 function createDesktopIpcLiveOwner({
@@ -127,6 +150,7 @@ function createDesktopIpcLiveOwner({
   maxPatchBytes = DEFAULT_MAX_PATCH_BYTES,
   requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
   reconnectMs = DEFAULT_RECONNECT_MS,
+  startRouterWhenMissing = false,
   initialHistoryRetryMs = DEFAULT_INITIAL_HISTORY_RETRY_MS,
   initialHistoryMaxAttempts = DEFAULT_INITIAL_HISTORY_MAX_ATTEMPTS,
   liveOwnershipFreshnessMs = DEFAULT_LIVE_OWNERSHIP_FRESHNESS_MS,
@@ -170,6 +194,7 @@ function createDesktopIpcLiveOwner({
   // until the first user item and turn completion prove the rollout was written.
   const pendingSidebarMaterializationThreadIds = new Set();
   const replayedSidebarMaterializationThreadIds = new Set();
+  const enqueueMutation = createThreadMutationQueue();
   const pendingTurnStartParamsByThreadId = new Map();
   const pendingTurnStartEntriesByRequestId = new Map();
   const followerRuntimeOverridesByThreadId = new Map();
@@ -178,6 +203,7 @@ function createDesktopIpcLiveOwner({
   const queuedFollowUpsByThreadId = new Map();
   const runningQueuedFollowUpThreadIds = new Set();
   const announcedReadStateThreadIds = new Set();
+  const pendingReadStateByThreadId = new Map();
   const pendingThreadArchiveMetadataByThreadId = new Map();
   const dirtyThreadIds = new Set();
   let snapshotTimer = null;
@@ -190,6 +216,10 @@ function createDesktopIpcLiveOwner({
     requestTimeoutMs,
     reconnectMs,
     logPrefix,
+    // Let Desktop/VSCode own its bus. Restarting a bridge-owned router forces
+    // concurrent Desktop clients to re-elect routers and can split their sockets.
+    // Phone history remains local while Desktop is closed; reconnect replays it.
+    startRouterWhenMissing,
     onConnected() {
       flushPendingThreadArchiveMetadataBroadcasts();
       requestFollowerStatusForAllOwnedThreads();
@@ -288,7 +318,24 @@ function createDesktopIpcLiveOwner({
     if (!message || typeof message !== "object") {
       return;
     }
-
+    if (message.method === "account/updated") {
+      announcedReadStateThreadIds.clear();
+      pendingReadStateByThreadId.clear();
+    }
+
+    if (message.method === "thread/settings/updated") {
+      const threadId = readThreadIdFromParams(message.params);
+      const settings = message.params?.threadSettings;
+      if (threadId && settings && ownedThreadIds.has(threadId)) {
+        followerRuntimeOverridesByThreadId.set(threadId, {
+          ...(followerRuntimeOverridesByThreadId.get(threadId) || {}),
+          ...normalizeThreadSettingsUpdate(settings, { authoritative: true }),
+        });
+        applyRuntimeSettingsToConversation(conversations.get(threadId), settings, { authoritative: true });
+        runtimeSettingsStore?.observe?.(threadId, settings);
+        scheduleSnapshot(threadId);
+      }
+    }
     const responseId = message.id == null ? "" : String(message.id);
     if (responseId && !message.method) {
       resolvePendingTurnStartResponse(responseId, message);
@@ -337,6 +384,11 @@ function createDesktopIpcLiveOwner({
       refreshOptimisticFallbackForThread(update.threadId);
       scheduleSnapshot(update.threadId);
       replaySidebarAnnouncementAfterMaterialization(message, update.threadId);
+      if (message.method === "thread/name/updated") {
+        // Unopened Desktop threads ignore stream snapshots. Refresh their catalog
+        // metadata after the name is persisted, even if the first turn has ended.
+        broadcastThreadUnarchived(update.threadId);
+      }
     }
 
     if (readString(message.method) === "turn/completed") {
@@ -390,6 +442,7 @@ function createDesktopIpcLiveOwner({
     queuedFollowUpsByThreadId.clear();
     runningQueuedFollowUpThreadIds.clear();
     announcedReadStateThreadIds.clear();
+    pendingReadStateByThreadId.clear();
     ownedThreadIds.clear();
     conversations.clear();
     ipc.close();
@@ -409,16 +462,44 @@ function createDesktopIpcLiveOwner({
     if (hadUnread) {
       conversation.hasUnreadTurn = false;
       conversation.unreadMessageCount = 0;
+      announcedReadStateThreadIds.delete(normalizedThreadId);
       scheduleSnapshot(normalizedThreadId);
     } else if (announcedReadStateThreadIds.has(normalizedThreadId)) {
       return;
     }
-    if (ipc.sendBroadcast(THREAD_READ_STATE_CHANGED, {
-      conversationId: normalizedThreadId,
-      hasUnreadTurn: false,
-    })) {
-      announcedReadStateThreadIds.add(normalizedThreadId);
+    if (pendingReadStateByThreadId.has(normalizedThreadId)) {
+      return;
     }
+    const request = Symbol();
+    pendingReadStateByThreadId.set(normalizedThreadId, request);
+    Promise.resolve()
+      .then(() => sendCodexRequest("getAuthStatus", { includeToken: true, refreshToken: false }))
+      .then((authStatus) => {
+        if (pendingReadStateByThreadId.get(normalizedThreadId) !== request
+          || !ownedThreadIds.has(normalizedThreadId)) {
+          return;
+        }
+        const current = conversations.get(normalizedThreadId);
+        if (current?.hasUnreadTurn || current?.unreadMessageCount > 0) {
+          return;
+        }
+        const context = buildThreadReadStateContext(authStatus, hostId);
+        if (context && ipc.sendBroadcast(THREAD_READ_STATE_CHANGED, {
+          conversationId: normalizedThreadId,
+          hostId,
+          hasUnreadTurn: false,
+          context,
+        })) {
+          announcedReadStateThreadIds.add(normalizedThreadId);
+        }
+      })
+      // A failed identity lookup leaves the next phone read free to retry.
+      .catch(() => {})
+      .finally(() => {
+        if (pendingReadStateByThreadId.get(normalizedThreadId) === request) {
+          pendingReadStateByThreadId.delete(normalizedThreadId);
+        }
+      });
   }
 
   // Snappier Stop UX on Desktop: flip the active turn to interrupted right away;
@@ -465,7 +546,7 @@ function createDesktopIpcLiveOwner({
     }
     const sanitizedParams = sanitizeTurnStartParams(cloneJSON(params));
     sanitizedParams.input = normalizeInputEntriesForDesktop(sanitizedParams.input);
-    const entry = { params: sanitizedParams, requestId: normalizedRequestId || null };
+    const entry = { params: sanitizedParams, requestId: normalizedRequestId || null, runtimeSettingsRevision: runtimeSettingsStore?.get?.(normalizedThreadId)?.revision ?? 0 };
     const queue = pendingTurnStartParamsByThreadId.get(normalizedThreadId) || [];
     queue.push(entry);
     pendingTurnStartParamsByThreadId.set(normalizedThreadId, queue);
@@ -525,7 +606,8 @@ function createDesktopIpcLiveOwner({
       pending.threadId,
       pending.entry?.params,
       "phone",
-      readTurnIdFromResult(message.result)
+      readTurnIdFromResult(message.result),
+      pending.entry?.runtimeSettingsRevision
     );
     scheduleSnapshot(pending.threadId);
   }
@@ -697,6 +779,7 @@ function createDesktopIpcLiveOwner({
     }
     runningQueuedFollowUpThreadIds.delete(normalizedThreadId);
     announcedReadStateThreadIds.delete(normalizedThreadId);
+    pendingReadStateByThreadId.delete(normalizedThreadId);
     cancelSidebarAnnouncement(normalizedThreadId);
     announcedSidebarThreadIds.delete(normalizedThreadId);
     pendingSidebarMaterializationThreadIds.delete(normalizedThreadId);
@@ -1104,6 +1187,7 @@ function createDesktopIpcLiveOwner({
       return true;
     }
     runtimeSettingsStore?.attachToConversation?.(threadId, conversationState);
+    synchronizeDesktopConversationCompatibility(conversationState);
     if (shouldDelayInitialSnapshotForHistory(threadId)) {
       return false;
     }
@@ -1284,6 +1368,13 @@ function createDesktopIpcLiveOwner({
     if (!SUPPORTED_FOLLOWER_REQUEST_METHODS.has(method)) {
       return false;
     }
+    const requestedHostId = readString(params.hostId || envelope.request?.hostId || envelope.hostId);
+    if (method === "thread-owner-discovery" && !requestedHostId) {
+      return false;
+    }
+    if (requestedHostId && requestedHostId !== hostId) {
+      return false;
+    }
     const threadId = readConversationIdFromFollowerParams(params);
     return Boolean(threadId && ownedThreadIds.has(threadId));
   }
@@ -1292,11 +1383,14 @@ function createDesktopIpcLiveOwner({
     const method = readString(envelope?.method);
     const params = envelope?.params && typeof envelope.params === "object" ? envelope.params : {};
     const conversationId = readConversationIdFromFollowerParams(params);
-    if (!conversationId || !ownedThreadIds.has(conversationId)) {
+    if (!conversationId || !canHandleFollowerRequest(envelope)) {
       throw new Error("conversation-not-owned");
     }
 
     switch (method) {
+      case "thread-owner-discovery":
+        // Remodex cannot yet inject Desktop's untrusted app response items.
+        return { supportsUntrustedAppInput: false };
       case "thread-follower-start-turn":
         return await handleFollowerStartTurn(conversationId, params);
       case "thread-follower-load-complete-history":
@@ -1366,11 +1460,16 @@ function createDesktopIpcLiveOwner({
     return { revision };
   }
 
-  async function handleFollowerStartTurn(conversationId, params) {
-    const rawTurnStartParams = params.turnStartParams
-      || params.turn_start_params
-      || params.turnStart
-      || params;
+  function handleFollowerStartTurn(conversationId, params) {
+    return enqueueMutation(conversationId, () => startFollowerTurn(conversationId, params));
+  }
+
+  async function startFollowerTurn(conversationId, params) {
+    if (params.turnStart?.context?.responseItems?.length > 0) {
+      throw new Error("Remodex does not support untrusted app input yet.");
+    }
+    const revisionBefore = runtimeSettingsStore?.get?.(conversationId)?.revision ?? 0;
+    const rawTurnStartParams = readFollowerTurnStartParams(params);
     const codexParams = mergeFollowerRuntimeOverrides(conversationId, sanitizeTurnStartParams({
       ...rawTurnStartParams,
       threadId: conversationId,
@@ -1380,7 +1479,9 @@ function createDesktopIpcLiveOwner({
       ? normalizedParams
       : codexParams;
     markOwnedThread(conversationId);
-    const senderRequestId = params.senderRequestId || params.sender_request_id;
+    const senderRequestId = params.senderRequestId
+      || params.sender_request_id
+      || rawTurnStartParams.clientUserMessageId;
     const isKnownHeldPhoneStart = Boolean(
       requestIdKey(senderRequestId)
       && pendingTurnStartEntriesByRequestId.has(requestIdKey(senderRequestId))
@@ -1400,7 +1501,8 @@ function createDesktopIpcLiveOwner({
         conversationId,
         nextCodexParams,
         isKnownHeldPhoneStart ? "phone" : "desktop",
-        readTurnIdFromResult(turnStartResult)
+        readTurnIdFromResult(turnStartResult),
+        revisionBefore
       );
       scheduleSnapshot(conversationId);
       if (!isKnownHeldPhoneStart) {
@@ -1417,6 +1519,17 @@ function createDesktopIpcLiveOwner({
     }
   }
 
+  function readFollowerTurnStartParams(params) {
+    const turnStart = isPlainJSONObject(params.turnStart) ? params.turnStart : null;
+    if (isPlainJSONObject(turnStart?.request)) {
+      return turnStart.request;
+    }
+    return params.turnStartParams
+      || params.turn_start_params
+      || params.turnStart
+      || params;
+  }
+
   function mirrorFollowerUserPromptToPhone(threadId, turnStartParams, turnStartResult = null) {
     const text = visibleUserPromptFromInputEntries(turnStartParams?.input);
     if (!text) {
@@ -1453,24 +1566,60 @@ function createDesktopIpcLiveOwner({
     if (!expectedTurnId) {
       throw new Error("Missing expectedTurnId for follower steer request.");
     }
-    return await sendCodexRequest("turn/steer", {
+    const result = await sendCodexRequest("turn/steer", {
       threadId: conversationId,
       input: Array.isArray(rawSteerParams.input) ? rawSteerParams.input : [],
       expectedTurnId,
+      ...Object.fromEntries(["clientUserMessageId", "additionalContext", "toolOutput"].filter((key) => hasOwn(rawSteerParams, key)).map((key) => [key, cloneJSON(rawSteerParams[key])])),
     });
+    return { result };
   }
 
   async function handleFollowerInterruptTurn(conversationId, params) {
-    const turnId = readString(params.turnId)
-      || readString(params.turn_id)
-      || activeTurnIdForConversation(conversationId);
+    const requestedTurnId = readString(params.expectedTurnId)
+      || readString(params.expected_turn_id)
+      || readString(params.turnId)
+      || readString(params.turn_id);
+    const activeTurnId = activeTurnIdForConversation(conversationId);
+    if (requestedTurnId && requestedTurnId !== activeTurnId) {
+      return {
+        interruptedTurnId: null,
+        ok: true,
+      };
+    }
+
+    const goalPauseError = await pauseActiveGoalForUserStop(
+      conversationId,
+      params.mode,
+      Boolean(requestedTurnId)
+    );
+    const turnId = requestedTurnId || activeTurnId;
     if (!turnId) {
-      throw new Error("Missing turnId for follower interrupt request.");
+      return followerInterruptResult(null, goalPauseError);
     }
-    return await sendCodexRequest("turn/interrupt", {
+    await sendCodexRequest("turn/interrupt", {
       threadId: conversationId,
       turnId,
     });
+    return followerInterruptResult(turnId, goalPauseError);
+  }
+
+  async function pauseActiveGoalForUserStop(conversationId, mode, hasRequestedTurnId) {
+    if (mode !== "user-stop" || hasRequestedTurnId) {
+      return "";
+    }
+    if (conversations.get(conversationId)?.threadGoal?.status !== "active") {
+      return "";
+    }
+    try {
+      await sendCodexRequest("thread/goal/set", {
+        threadId: conversationId,
+        status: "paused",
+      });
+      return "";
+    } catch (error) {
+      return error?.message || "Failed to pause thread goal.";
+    }
   }
 
   // Desktop follower approvals only carry decision-style payloads, but app-server
@@ -1510,100 +1659,49 @@ function createDesktopIpcLiveOwner({
     return { ok: true };
   }
 
-  // Desktop runtime option changes are persisted as per-thread overrides and
-  // merged into later Desktop-origin turn starts, so acknowledging them is honest
-  // instead of a cosmetic broadcast-only update.
+  // Legacy IPC verbs enter the same acknowledged settings path.
   function applyFollowerModelAndReasoning(conversationId, params) {
-    const overrides = followerRuntimeOverridesByThreadId.get(conversationId) || {};
-    const conversation = conversations.get(conversationId);
-    if (Object.prototype.hasOwnProperty.call(params, "model")) {
-      overrides.model = readString(params.model);
-      if (conversation) {
-        conversation.latestModel = overrides.model;
-      }
-    }
-    if (Object.prototype.hasOwnProperty.call(params, "reasoningEffort")) {
-      overrides.effort = params.reasoningEffort || null;
-      if (conversation) {
-        conversation.latestReasoningEffort = overrides.effort;
-      }
-    }
-    if (Object.prototype.hasOwnProperty.call(params, "serviceTier")) {
-      overrides.serviceTier = readString(params.serviceTier) || null;
-      if (conversation) {
-        conversation.latestServiceTier = overrides.serviceTier;
-      }
-    }
-    followerRuntimeOverridesByThreadId.set(conversationId, overrides);
-    if (conversation) {
-      scheduleSnapshot(conversationId);
-    }
-    return { ok: true };
+    const settings = normalizeThreadSettingsUpdate(params);
+    if (hasOwn(params, "reasoningEffort")) settings.effort = params.reasoningEffort;
+    return applyFollowerThreadSettings(conversationId, settings);
   }
 
   function applyFollowerCollaborationMode(conversationId, params) {
-    if (!params.collaborationMode) {
-      return { ok: true };
-    }
-    const overrides = followerRuntimeOverridesByThreadId.get(conversationId) || {};
-    overrides.collaborationMode = cloneJSON(params.collaborationMode);
-    followerRuntimeOverridesByThreadId.set(conversationId, overrides);
-    const conversation = conversations.get(conversationId);
-    if (conversation) {
-      conversation.latestCollaborationMode = cloneJSON(params.collaborationMode);
-      scheduleSnapshot(conversationId);
-    }
-    return { ok: true };
+    return applyFollowerThreadSettings(conversationId, { collaborationMode: params.collaborationMode });
   }
 
-  // Current Desktop sends the whole thread-settings object; persist it so the
-  // composer fields stay accurate and future Desktop-origin turns pick it up.
-  function applyFollowerThreadSettings(conversationId, threadSettings) {
-    if (!threadSettings || typeof threadSettings !== "object" || Array.isArray(threadSettings)) {
-      return { ok: true };
-    }
-    const overrides = followerRuntimeOverridesByThreadId.get(conversationId) || {};
-    const model = readString(threadSettings.model)
-      || readString(threadSettings.collaborationMode?.settings?.model);
-    const effort = threadSettings.effort;
-    const hasServiceTier = Object.prototype.hasOwnProperty.call(threadSettings, "serviceTier");
-    if (model) {
-      overrides.model = model;
-    }
-    if (effort !== undefined) {
-      overrides.effort = effort ?? null;
-    }
-    if (hasServiceTier) {
-      overrides.serviceTier = readString(threadSettings.serviceTier) || null;
-    }
-    if (threadSettings.collaborationMode && typeof threadSettings.collaborationMode === "object") {
-      overrides.collaborationMode = cloneJSON(threadSettings.collaborationMode);
-    }
-    followerRuntimeOverridesByThreadId.set(conversationId, overrides);
-
-    const conversation = conversations.get(conversationId);
-    if (conversation) {
-      conversation.latestThreadSettings = {
-        ...(conversation.latestThreadSettings && typeof conversation.latestThreadSettings === "object"
-          ? conversation.latestThreadSettings
-          : {}),
-        ...cloneJSON(threadSettings),
-      };
-      if (model) {
-        conversation.latestModel = model;
-      }
-      if (effort !== undefined) {
-        conversation.latestReasoningEffort = effort ?? null;
+  // Settings are acknowledged by the app-server before they become composer
+  // state. Updating a mirror alone never changes the executing runtime.
+  function applyFollowerThreadSettings(conversationId, threadSettings, source = "desktop") {
+    return enqueueMutation(conversationId, async () => {
+      if (!threadSettings || typeof threadSettings !== "object" || Array.isArray(threadSettings)) {
+        throw new Error("Missing thread settings.");
       }
-      if (hasServiceTier) {
-        conversation.latestServiceTier = overrides.serviceTier;
-      }
-      if (overrides.collaborationMode) {
-        conversation.latestCollaborationMode = cloneJSON(overrides.collaborationMode);
+      const revisionBefore = runtimeSettingsStore?.get?.(conversationId)?.revision;
+      const settings = normalizeThreadSettingsUpdate(threadSettings);
+      await sendCodexRequest("thread/settings/update", { threadId: conversationId, ...settings });
+      if (!ownedThreadIds.has(conversationId)) {
+        // A successful settings mutation proves the local runtime has this task
+        // loaded. Announce ownership only after that acknowledgement and hydrate
+        // complete history before publishing the first Desktop snapshot.
+        markOwnedThread(conversationId);
+        threadsAwaitingInitialHistoryByThreadId.add(conversationId);
+        seedOwnedConversation(conversationId);
+        requestInitialHistoryBaselineIfDue(conversationId);
       }
+      const current = runtimeSettingsStore?.get?.(conversationId);
+      const confirmed = current && current.revision !== revisionBefore
+        ? current
+        : runtimeSettingsStore?.commit?.(conversationId, settings, { source });
+      const applied = confirmed ? {
+        ...settings, ...threadSettingsFromRuntimeSettings(confirmed),
+      } : settings;
+      const overrides = followerRuntimeOverridesByThreadId.get(conversationId) || {};
+      followerRuntimeOverridesByThreadId.set(conversationId, { ...overrides, ...applied });
+      applyRuntimeSettingsToConversation(conversations.get(conversationId), applied, { authoritative: !!confirmed });
       scheduleSnapshot(conversationId);
-    }
-    return { ok: true };
+      return { ok: true, runtimeSettings: confirmed || null };
+    });
   }
 
   // Desktop followers hand the owner the full queue map and expect it to run
@@ -1641,72 +1739,58 @@ function createDesktopIpcLiveOwner({
     if (!Array.isArray(queue) || queue.length === 0 || runningQueuedFollowUpThreadIds.has(threadId)) {
       return;
     }
-    const entry = queue[0];
-    if (entry?.pausedReason) {
-      return;
-    }
-    const text = readString(entry?.context?.text)
-      || readString(entry?.text)
-      || readString(entry?.prompt);
-    if (!text) {
-      // Unrecognized entry shape: pause it visibly instead of discarding the
-      // user's draft. The queue stays blocked (matching Desktop's first-entry
-      // semantics) and the user can edit or resend it from any window.
-      if (!entry || typeof entry !== "object") {
-        queue.shift();
-        if (queue.length === 0) {
-          queuedFollowUpsByThreadId.delete(threadId);
-        }
+    runningQueuedFollowUpThreadIds.add(threadId);
+    let retryChangedQueue = false;
+    enqueueMutation(threadId, async () => {
+      // Desktop replaces queue arrays on refresh. Resolve the current entry only
+      // after settings settle, and retry if another refresh changes it while
+      // request normalization is awaiting context.
+      const entry = queuedFollowUpsByThreadId.get(threadId)?.[0];
+      const canRun = () => ownedThreadIds.has(threadId) && !activeTurnIdForConversation(threadId);
+      if (!entry || entry.pausedReason || !canRun()) return;
+      const text = readString(entry.context?.text) || readString(entry.text) || readString(entry.prompt);
+      if (!text) {
+        if (typeof entry === "object") entry.pausedReason = "remodex-unsupported-entry";
+        else queuedFollowUpsByThreadId.get(threadId)?.shift();
         broadcastQueuedFollowUps(threadId);
         return;
       }
-      console.warn(`${logPrefix} desktop queued follow-up entry has no extractable text; pausing it for ${threadId}`);
-      entry.pausedReason = "remodex-unsupported-entry";
-      broadcastQueuedFollowUps(threadId);
-      return;
-    }
-
-    runningQueuedFollowUpThreadIds.add(threadId);
-    const conversation = conversations.get(threadId);
-    const startParams = mergeFollowerRuntimeOverrides(threadId, sanitizeTurnStartParams({
-      threadId,
-      input: [{ type: "text", text }],
-      cwd: readString(entry?.cwd) || readString(conversation?.cwd) || undefined,
-    }));
-    let queuedTurnParams = startParams;
-    Promise.resolve()
-      .then(() => normalizeTurnStartParams(cloneJSON(startParams)))
-      .then((normalized) => {
-        const params = normalized && typeof normalized === "object" && !Array.isArray(normalized)
-          ? normalized
-          : startParams;
-        queuedTurnParams = params;
-        const pendingEntry = rememberPendingTurnStart(threadId, params);
-        if (pendingEntry) {
-          insertOptimisticPendingTurn(threadId, pendingEntry);
-          scheduleSnapshot(threadId);
-        }
-        return sendCodexRequest("turn/start", params);
-      })
-      .then((turnStartResult) => {
-        commitAcceptedRuntimeSettings(
-          threadId,
-          queuedTurnParams,
-          "desktop",
-          readTurnIdFromResult(turnStartResult)
-        );
+      const revisionBefore = runtimeSettingsStore?.get?.(threadId)?.revision ?? 0;
+      const conversation = conversations.get(threadId);
+      const startParams = mergeFollowerRuntimeOverrides(threadId, sanitizeTurnStartParams({
+        threadId,
+        input: [{ type: "text", text }],
+        cwd: readString(entry?.cwd) || readString(conversation?.cwd) || undefined,
+      }));
+      const normalized = await normalizeTurnStartParams(cloneJSON(startParams));
+      if (queuedFollowUpsByThreadId.get(threadId)?.[0] !== entry) {
+        retryChangedQueue = true;
+        return;
+      }
+      if (!canRun() || entry.pausedReason) return;
+      const params = normalized && typeof normalized === "object" && !Array.isArray(normalized)
+        ? normalized : startParams;
+      const pendingEntry = rememberPendingTurnStart(threadId, params);
+      if (pendingEntry) {
+        insertOptimisticPendingTurn(threadId, pendingEntry);
         scheduleSnapshot(threadId);
-        queue.shift();
-        if (queue.length === 0) {
-          queuedFollowUpsByThreadId.delete(threadId);
-        }
-        broadcastQueuedFollowUps(threadId);
-      })
+      }
+      const turnStartResult = await sendCodexRequest("turn/start", params);
+      commitAcceptedRuntimeSettings(threadId, params, "desktop", readTurnIdFromResult(turnStartResult), revisionBefore);
+      scheduleSnapshot(threadId);
+      const currentQueue = queuedFollowUpsByThreadId.get(threadId);
+      const sentIndex = currentQueue?.findIndex((candidate) => candidate === entry
+        || (readString(entry.id) && candidate.id === entry.id)) ?? -1;
+      if (sentIndex >= 0) currentQueue.splice(sentIndex, 1);
+      if (currentQueue?.length === 0) queuedFollowUpsByThreadId.delete(threadId);
+      broadcastQueuedFollowUps(threadId);
+    })
       .catch((error) => {
         console.warn(`${logPrefix} desktop queued follow-up failed for ${threadId}: ${error?.message || "unknown error"}`);
       })
       .finally(() => {
         runningQueuedFollowUpThreadIds.delete(threadId);
+        if (retryChangedQueue) runNextQueuedFollowUp(threadId);
       });
   }
 
@@ -1714,11 +1798,7 @@ function createDesktopIpcLiveOwner({
   // the request itself does not specify them. Phone-origin turns are untouched.
   function mergeFollowerRuntimeOverrides(conversationId, params) {
     const persisted = runtimeSettingsStore?.get?.(conversationId) || null;
-    const persistedOverrides = persisted ? {
-      model: persisted.model,
-      effort: persisted.reasoningEffort,
-      serviceTier: persisted.serviceTier,
-    } : null;
+    const persistedOverrides = persisted ? threadSettingsFromRuntimeSettings(persisted) : null;
     const liveOverrides = followerRuntimeOverridesByThreadId.get(conversationId) || null;
     const overrides = persistedOverrides || liveOverrides
       ? { ...(persistedOverrides || {}), ...(liveOverrides || {}) }
@@ -1730,11 +1810,11 @@ function createDesktopIpcLiveOwner({
     if (overrides.model && !readString(merged.model)) {
       merged.model = overrides.model;
     }
-    if (overrides.effort != null && merged.effort == null) {
+    if (hasOwn(overrides, "effort") && !hasOwn(merged, "effort")) {
       merged.effort = overrides.effort;
     }
-    if (overrides.serviceTier && merged.serviceTier == null) {
-      merged.serviceTier = overrides.serviceTier;
+    if (hasOwn(overrides, "serviceTier") && !hasOwn(merged, "serviceTier")) {
+      merged.serviceTier = overrides.serviceTier || "default";
     }
     if (overrides.collaborationMode && merged.collaborationMode == null) {
       merged.collaborationMode = cloneJSON(overrides.collaborationMode);
@@ -1742,11 +1822,14 @@ function createDesktopIpcLiveOwner({
     return merged;
   }
 
-  function commitAcceptedRuntimeSettings(threadId, params, source, turnId) {
+  function commitAcceptedRuntimeSettings(threadId, params, source, turnId, revisionBefore) {
     try {
-      const settings = runtimeSettingsStore?.commit?.(threadId, params, { source, turnId });
+      const current = runtimeSettingsStore?.get?.(threadId);
+      const settings = current && revisionBefore != null && current.revision !== revisionBefore
+        ? current : runtimeSettingsStore?.commit?.(threadId, params, { source, turnId });
       const conversation = conversations.get(threadId);
       if (settings && conversation) {
+        applyRuntimeSettingsToConversation(conversation, threadSettingsFromRuntimeSettings(settings), { authoritative: true });
         runtimeSettingsStore.attachToConversation(threadId, conversation);
       }
       return settings;
@@ -1786,11 +1869,11 @@ function createDesktopIpcLiveOwner({
         return turnId;
       }
     }
-    const latestTurn = turns[turns.length - 1];
-    return readString(latestTurn?.turnId) || readString(latestTurn?.id);
+    return "";
   }
 
   return {
+    updateThreadSettings: (threadId, params) => applyFollowerThreadSettings(threadId, params, "phone"),
     observeInbound,
     observeOutbound,
     stopAll,
@@ -1881,7 +1964,7 @@ function normalizeInputEntriesForDesktop(input) {
 function sanitizeTurnStartParams(params) {
   const sanitized = {};
   for (const [key, value] of Object.entries(params || {})) {
-    if (ALLOWED_TURN_START_PARAM_KEYS.has(key)) {
+    if (APP_SERVER_TURN_START_PARAM_KEYS.has(key)) {
       sanitized[key] = value;
     }
   }
@@ -1891,6 +1974,14 @@ function sanitizeTurnStartParams(params) {
   return sanitized;
 }
 
+function followerInterruptResult(interruptedTurnId, goalPauseError) {
+  return {
+    interruptedTurnId,
+    ...(goalPauseError ? { goalPauseError } : {}),
+    ok: true,
+  };
+}
+
 function readThreadFromResponse(message) {
   const result = message?.result || message?.payload || {};
   return readThreadFromPayload(result);