@makerbi/remodex 3.2.0 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makerbi/remodex",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
   "repository": {
     "type": "git",

package/src/bridge.js

@@ -68,6 +68,13 @@ const {
 } = require("./desktop-ipc-action-follower");
 const { createDesktopIpcLiveOwner } = require("./desktop-ipc-live-owner");
 const { createThreadRuntimeSettingsStore } = require("./thread-runtime-settings-store");
+const { normalizeServiceTier, hasOwn } = require("./codex-runtime-settings");
+const {
+  APP_SERVER_SOURCE,
+  DESKTOP_IPC_SOURCE,
+  createThreadActivityProjector,
+} = require("./thread-activity-projector");
+const { createThreadActivityStore } = require("./thread-activity-store");
 const { createThreadListProvenanceEnricher } = require("./thread-list-provenance");
 const { createWorktreeOriginEnricher } = require("./worktree-origin");
 const { forEachThreadRowInResponse } = require("./thread-row-enrichment");
@@ -600,6 +607,7 @@ function annotateTurnStateProbeWithMirrorActiveTurn(request, response, getMirror
 
 function canonicalThreadTurnsListRequest(request) {
   const params = { ...(request?.params || {}) };
+  params.itemsView ??= params.remodexTurnStateOnly === true ? "summary" : "full";
   delete params.remodexRequireCanonical;
   delete params.remodexTurnStateOnly;
   if (params.cursor === JSONL_OLDER_HANDOFF_CURSOR || threadTurnsListHandoffDescriptor(params.cursor)) {
@@ -761,9 +769,8 @@ function startBridge({
   const relaySessionUrl = `${relayBaseUrl}/${sessionId}`;
   const notificationSecret = randomBytes(24).toString("hex");
   const desktopRefresher = new CodexDesktopRefresher({
-    // IPC snapshots are accepted only after Codex mounts the route and
-    // announces itself as a follower. Auto-follow performs that one-time
-    // activation; refreshEnabled still controls the legacy reload workaround.
+    // Opening a thread manually establishes its IPC subscription. Automatic
+    // navigation and the legacy refresh workaround both require an opt-in.
     enabled: config.refreshEnabled || config.desktopAutoFollowEnabled === true,
     // With IPC live sync streaming content, deep-link refreshes are only needed
     // to navigate Desktop onto the phone-driven thread, not to reload content.
@@ -806,9 +813,23 @@ function startBridge({
   const jsonlTurnsListRolloutCacheByThread = new Map();
   const jsonlTurnsListRolloutMissCacheByThread = new Map();
   const threadTurnsListFastPageCoordinator = createThreadTurnsListFastPageCoordinator();
-  const threadRuntimeSettingsStore = createThreadRuntimeSettingsStore();
+  const threadRuntimeSettingsStore = createThreadRuntimeSettingsStore({
+    onChange(threadId, runtimeSettings) {
+      sendApplicationResponse(JSON.stringify({
+        method: "remodex/runtimeSettings/updated",
+        params: { threadId, runtimeSettings },
+      }));
+    },
+  });
   const threadListProvenanceEnricher = createThreadListProvenanceEnricher();
   const worktreeOriginEnricher = createWorktreeOriginEnricher();
+  const activityProjector = createThreadActivityProjector();
+  const activityStore = createThreadActivityStore({
+    sendApplicationResponse,
+    onEvict(threadId, source) {
+      activityProjector.forget(threadId, source);
+    },
+  });
   const trackedForwardedRequestMethods = new Set([
     "account/login/start",
     "account/login/cancel",
@@ -838,6 +859,7 @@ function startBridge({
       sendRelayRegistrationUpdate(nextDeviceState);
     },
     onSecureSessionReady(session) {
+      activityStore.resetSubscriber();
       activePhoneSummary = buildActivePhoneSummary(session, deviceState);
       const lastPublishedBridgeStatus = bridgeStatusPublisher.latest();
       if (lastPublishedBridgeStatus) {
@@ -864,9 +886,10 @@ function startBridge({
       // 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(
+      shouldSuppressThread: (threadId, context) => shouldSuppressRolloutMirrorForThread(
         threadId,
-        { desktopIpcActionFollower, desktopIpcLiveOwner }
+        { desktopIpcActionFollower, desktopIpcLiveOwner },
+        context
       ),
     })
     : null;
@@ -877,6 +900,7 @@ function startBridge({
         await sendCodexRequest("thread/read", buildCompleteThreadReadParams(threadId))
       ),
       forwardToLocalCodex: (rawMessage) => {
+        if (handleLocalRuntimeSettingsRequest(parseBridgeMessage(rawMessage))) return;
         observeDesktopIpcLiveOwnerInbound(rawMessage);
         forwardInboundRequestToCodex(rawMessage);
       },
@@ -890,6 +914,7 @@ function startBridge({
       onFollowerStateChanged(threadId, following) {
         desktopRefresher.handleFollowerStateChanged(threadId, following);
       },
+      onActivityObservation: handleDesktopActivityObservation,
     })
     : null;
   const desktopIpcLiveOwner = !config.codexEndpoint
@@ -1003,6 +1028,7 @@ function startBridge({
     bridgeStatusPublisher.stopHeartbeat();
     runtimeProviderRouter.shutdown();
     stopContextUsageWatcher();
+    activityStore.dispose();
     rolloutLiveMirror?.stopAll();
     desktopIpcActionFollower?.stopAll();
     desktopIpcLiveOwner?.stopAll();
@@ -1196,6 +1222,14 @@ function startBridge({
     // 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 (parsedMessage?.result && forwardedInitializeRequestIds.has(String(parsedMessage.id))) {
+      parsedMessage.result.remodexRuntimeSettingsVersion = 2;
+      message = JSON.stringify(parsedMessage);
+    }
+    if (parsedMessage?.method === "thread/settings/updated"
+      && parsedMessage.params?.threadSettings) {
+      threadRuntimeSettingsStore.observe(parsedMessage.params.threadId, parsedMessage.params.threadSettings);
+    }
     if (handleBridgeManagedCodexResponse(message, parsedMessage)) {
       return;
     }
@@ -1203,6 +1237,7 @@ function startBridge({
     trackCodexHandshakeState(message, parsedMessage);
     desktopRefresher.handleOutbound(message, parsedMessage);
     desktopIpcLiveOwner?.observeOutbound(message, parsedMessage);
+    observeAppServerActivity(parsedMessage);
     pushNotificationTracker.handleOutbound(message, parsedMessage);
     rememberThreadFromMessage("codex", message, parsedMessage);
     secureTransport.queueOutboundApplicationMessage(
@@ -1212,6 +1247,7 @@ function startBridge({
   });
 
   codex.onClose(() => {
+    activityStore.markSourceStale(APP_SERVER_SOURCE);
     const wasShuttingDown = isShuttingDown;
     clearRelayWatchdog();
     bridgeStatusPublisher.stopHeartbeat();
@@ -1243,7 +1279,11 @@ function startBridge({
 
   // Routes decrypted app payloads through the same bridge handlers as before.
   function handleApplicationMessage(rawMessage) {
+    rawMessage = normalizePhoneRuntimeRequest(rawMessage);
     const parsedMessage = parseBridgeMessage(rawMessage);
+    if (activityStore.handleRequest(parsedMessage)) {
+      return;
+    }
     if (handleBridgeManagedHandshakeMessage(rawMessage, sendApplicationResponse, parsedMessage)) {
       return;
     }
@@ -1277,9 +1317,17 @@ function startBridge({
     })) {
       return;
     }
+    // Provider-owned renames must reach their runtime instead of the Codex-only
+    // catalog persistence path in the local git/thread handler.
+    if (parsedMessage?.method === "thread/name/set"
+      && runtimeProviderRouter.handleApplicationMessage(rawMessage, {
+        sendResponse: sendApplicationResponse,
+      })) {
+      return;
+    }
     if (handleGitRequest(rawMessage, sendApplicationResponse, {
       codexAppPath: config.codexAppPath,
-      onThreadNameSet: sendThreadNameUpdatedNotification,
+      sendCodexRequest,
     })) {
       return;
     }
@@ -1298,6 +1346,7 @@ function startBridge({
     })) {
       return;
     }
+    if (handleLocalRuntimeSettingsRequest(parsedMessage)) return;
     observeDesktopIpcLiveOwnerInbound(rawMessage, parsedMessage);
     if (handleBridgeManagedThreadTurnsListRequest(rawMessage, sendApplicationResponse)) {
       return;
@@ -1305,6 +1354,24 @@ function startBridge({
     forwardInboundRequestToCodex(rawMessage);
   }
 
+  function handleLocalRuntimeSettingsRequest(parsedMessage) {
+    if (parsedMessage?.method === "thread/settings/update" && parsedMessage.id != null) {
+      const { threadId, ...settings } = parsedMessage.params || {};
+      const update = desktopIpcLiveOwner?.updateThreadSettings
+        ? desktopIpcLiveOwner.updateThreadSettings(threadId, settings)
+        : sendCodexRequest("thread/settings/update", { threadId, ...settings }).then(() => ({
+          runtimeSettings: threadRuntimeSettingsStore.commit(threadId, settings, { source: "phone" }),
+        }));
+      Promise.resolve(update).then((result) => {
+        sendApplicationResponse(JSON.stringify({ id: parsedMessage.id, result }));
+      }).catch((error) => {
+        sendApplicationResponse(createJsonRpcErrorResponse(parsedMessage.id, error, "runtime_settings_update_failed"));
+      });
+      return true;
+    }
+    return false;
+  }
+
   function forwardInboundRequestToCodex(rawMessage) {
     const codexRequest = stripRuntimeProviderFieldsForCodex(
       normalizeTurnStartForCodex(rawMessage)
@@ -1358,6 +1425,58 @@ function startBridge({
     }
   }
 
+  function observeAppServerActivity(message) {
+    if (isShuttingDown) {
+      return;
+    }
+    const projection = activityProjector.observeAppServer(message);
+    if (projection?.entry) {
+      const entry = projection.entry;
+      const previous = activityStore.get(entry.threadId);
+      if (previous?.source === DESKTOP_IPC_SOURCE
+          && !desktopIpcLiveOwner?.isThreadOwned(entry.threadId)) {
+        // Catalog changes do not transfer runtime ownership to this app-server.
+        if (message.method === "thread/name/updated" || message.method === "thread/started") {
+          activityStore.upsert({
+            ...previous,
+            ...(entry.title ? { title: entry.title } : {}),
+            ...(entry.cwd ? { cwd: entry.cwd } : {}),
+          });
+        }
+        return;
+      }
+      activityStore.upsert({
+        ...(previous?.title ? { title: previous.title } : {}),
+        ...(previous?.cwd ? { cwd: previous.cwd } : {}),
+        ...entry,
+      });
+    } else if (projection?.removedThreadId) {
+      activityStore.remove(projection.removedThreadId);
+    }
+  }
+
+  function handleDesktopActivityObservation(observation) {
+    if (isShuttingDown) {
+      return;
+    }
+    if (observation?.type === "state") {
+      const entry = activityProjector.projectDesktopState(
+        observation.threadId,
+        observation.state,
+        observation.sourceGeneration
+      );
+      activityStore.upsert(entry);
+      return;
+    }
+    if (observation?.type === "disconnected") {
+      activityStore.markSourceStale(DESKTOP_IPC_SOURCE, observation.sourceGeneration);
+      return;
+    }
+    if (observation?.type === "removed") {
+      activityStore.remove(observation.threadId, { source: DESKTOP_IPC_SOURCE });
+    }
+  }
+
   // Encrypts bridge-generated responses instead of letting the relay see plaintext.
   function sendApplicationResponse(rawMessage) {
     secureTransport.queueOutboundApplicationMessage(
@@ -1374,25 +1493,6 @@ function startBridge({
     sendApplicationResponse(rawMessage);
   }
 
-  // Mirrors accepted local renames back to the phone using the existing push-event shape.
-  function sendThreadNameUpdatedNotification(result) {
-    const threadId = readString(result?.threadId || result?.thread_id);
-    const name = readString(result?.name || result?.title);
-    if (!threadId || !name) {
-      return;
-    }
-
-    sendApplicationResponse(JSON.stringify({
-      method: "thread/name/updated",
-      params: {
-        threadId,
-        thread_id: threadId,
-        name,
-        title: name,
-      },
-    }));
-  }
-
   function handleBridgeManagedThreadTurnsListRequest(rawMessage, sendResponse = sendApplicationResponse) {
     const request = parseAdaptiveThreadTurnsListRequest(rawMessage);
     if (!request) {
@@ -1713,6 +1813,10 @@ function startBridge({
     if (relaySanitizedRequestMethods.has(method)) {
       const trackedRequest = {
         method,
+        isActiveThreadCatalog: method === "thread/list"
+          && parsed.params?.archived !== true
+          && !parsed.params?.cursor,
+        threadListLimit: method === "thread/list" ? parsed.params?.limit : undefined,
         threadId: method === "thread/turns/list" || method === "thread/read" || method === "thread/resume"
           ? threadIdFromRequestParams(parsed.params)
           : "",
@@ -1771,6 +1875,9 @@ function startBridge({
         worktreeOriginEnricher.attachToThread(thread);
       });
       normalizedMessage = JSON.stringify(parsed);
+      if (trackedRequest.isActiveThreadCatalog) {
+        desktopIpcActionFollower?.observeThreadListResponse(parsed.result, { limit: trackedRequest.threadListLimit });
+      }
     }
 
     return sanitizeThreadHistoryImagesForRelay(normalizedMessage, trackedRequest.method, trackedRequest);
@@ -1997,6 +2104,7 @@ function startBridge({
         id: parsed.id,
         result: {
           bridgeManaged: true,
+          remodexRuntimeSettingsVersion: 2,
         },
       }));
       return true;
@@ -2107,8 +2215,10 @@ function startBridge({
 
   // Runs bridge-private JSON-RPC calls against the local app-server so token-bearing responses
   // can power bridge features like transcription without ever reaching the phone.
-  function sendCodexRequest(method, params) {
-    const requestId = `bridge-managed-${randomBytes(12).toString("hex")}`;
+  function sendCodexRequest(method, params, callerRequestId = null) {
+    const requestId = callerRequestId == null
+      ? `bridge-managed-${randomBytes(12).toString("hex")}`
+      : String(callerRequestId);
     const payload = JSON.stringify({
       id: requestId,
       method,
@@ -2510,6 +2620,25 @@ function disableUnsupportedReasoningSummaryForTurnStart(rawMessage) {
   });
 }
 
+// Upgrade the old phone wire convention once at ingress. Internally an omitted
+// speed always inherits; modern clients distinguish that from explicit Standard.
+function normalizePhoneRuntimeRequest(rawMessage) {
+  const parsed = parseBridgeJSON(rawMessage);
+  if (!parsed || !["turn/start", "thread/start", "thread/settings/update"].includes(parsed.method)
+    || !parsed.params || typeof parsed.params !== "object") return rawMessage;
+  const params = { ...parsed.params };
+  if (parsed.method === "turn/start" && params.remodexRuntimeSettingsVersion !== 2
+    && !hasOwn(params, "serviceTier") && !hasOwn(params, "service_tier")) {
+    params.serviceTier = "default";
+  }
+  delete params.remodexRuntimeSettingsVersion;
+  if (hasOwn(params, "serviceTier") && params.serviceTier != null) {
+    params.serviceTier = normalizeServiceTier(params.serviceTier)
+      ?? (parsed.method === "thread/settings/update" ? null : "default");
+  }
+  return JSON.stringify({ ...parsed, params });
+}
+
 function normalizeTurnStartParamsForCodex(params) {
   const normalizedRawMessage = normalizeTurnStartForCodex(JSON.stringify({
     method: "turn/start",
@@ -5113,12 +5242,12 @@ function persistBridgePreferences(
 function shouldSuppressRolloutMirrorForThread(
   threadId,
   { desktopIpcActionFollower = null, desktopIpcLiveOwner = null } = {},
-  { fallbackActivityAt = 0 } = {}
+  context = {}
 ) {
   // 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.hasFreshLiveThreadState(threadId, context)
     : desktopIpcActionFollower?.hasLiveThreadState(threadId);
   const ownerIsFresh = typeof desktopIpcLiveOwner?.isFreshThreadOwned === "function"
     ? desktopIpcLiveOwner.isFreshThreadOwned(threadId)
@@ -5141,6 +5270,7 @@ module.exports = {
   isContextualUserItemNotification,
   maybeMergeLatestJsonlTurnIntoTurnsListResponse,
   normalizeTurnStartForCodex,
+  normalizePhoneRuntimeRequest,
   normalizeRelayBoundJsonRpcMessage,
   persistBridgePreferences,
   resolveJsonlTurnsListRolloutPathForFallback,

package/src/codex-desktop-refresher.js

@@ -101,6 +101,9 @@ class CodexDesktopRefresher {
   }
 
   handleInbound(rawMessage, parsedMessage = null) {
+    if (!this.canRefresh()) {
+      return;
+    }
     const parsed = parsedMessage ?? safeParseJSON(rawMessage);
     if (!parsed) {
       return;
@@ -147,6 +150,9 @@ class CodexDesktopRefresher {
   }
 
   handleOutbound(rawMessage, parsedMessage = null) {
+    if (!this.canRefresh()) {
+      return;
+    }
     const parsed = parsedMessage ?? safeParseJSON(rawMessage);
     if (!parsed) {
       return;
@@ -744,11 +750,6 @@ function readBridgeConfig({
   const desktopIpcLiveSyncEnabled = explicitDesktopIpcLiveSyncEnabled == null
     ? true
     : explicitDesktopIpcLiveSyncEnabled;
-  const defaultDesktopAutoFollowEnabled = (
-    platform === "darwin"
-    && !codexEndpoint
-    && desktopIpcLiveSyncEnabled
-  );
   return {
     relayUrl,
     relayAccessToken,
@@ -774,9 +775,8 @@ function readBridgeConfig({
     codexEndpoint,
     desktopIpcSocketPath: readFirstDefinedEnv(["REMODEX_DESKTOP_IPC_SOCKET"], "", env),
     desktopIpcLiveSyncEnabled,
-    desktopAutoFollowEnabled: explicitDesktopAutoFollowEnabled == null
-      ? defaultDesktopAutoFollowEnabled
-      : explicitDesktopAutoFollowEnabled,
+    // Live sync must not navigate or activate Desktop without an explicit opt-in.
+    desktopAutoFollowEnabled: explicitDesktopAutoFollowEnabled === true,
     desktopIpcSnapshotDebounceMs: parseIntegerEnv(
       readFirstDefinedEnv(["REMODEX_DESKTOP_IPC_SNAPSHOT_DEBOUNCE_MS"], "75", env),
       75

package/src/codex-runtime-settings.js

@@ -0,0 +1,113 @@
+// Canonical runtime settings shared by the app-server and Desktop IPC adapters.
+// Missing fields inherit; null clears speed, while null effort inherits unless
+// supplied in collaboration settings or an authoritative snapshot. Turn-only overrides
+// are deliberately excluded from the persistent next-turn settings.
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value || {}, key);
+const string = (value) => typeof value === "string" ? value.trim() : "";
+const THREAD_SETTINGS_UPDATE_KEYS = [
+  "approvalPolicy", "approvalsReviewer", "collaborationMode", "cwd", "effort", "model",
+  "multiAgentMode", "permissions", "personality", "sandboxPolicy", "serviceTier", "summary",
+];
+
+function normalizeThreadSettingsUpdate(params, options = {}) {
+  const settings = Object.fromEntries(THREAD_SETTINGS_UPDATE_KEYS.filter((key) => hasOwn(params, key))
+    .map((key) => [key, structuredClone(params[key])]));
+  const patch = runtimeSettingsPatch(params, options);
+  if (settings.effort == null && !options.authoritative) delete settings.effort;
+  if (hasOwn(patch, "serviceTier")) settings.serviceTier = patch.serviceTier;
+  if (settings.collaborationMode?.settings) {
+    if (patch.model) settings.collaborationMode.settings.model = patch.model;
+    if (hasOwn(patch, "reasoningEffort")) settings.collaborationMode.settings.reasoning_effort = patch.reasoningEffort;
+  }
+  return settings;
+}
+
+// Confirmations may be partial (for example the first edit only selects Fast).
+// Preserve omission instead of manufacturing resets for unknown fields.
+function threadSettingsFromRuntimeSettings(settings) {
+  const patch = runtimeSettingsPatch(settings);
+  const result = { ...patch };
+  if (hasOwn(patch, "reasoningEffort")) {
+    result.effort = patch.reasoningEffort;
+    delete result.reasoningEffort;
+  }
+  return result;
+}
+
+function normalizeServiceTier(value) {
+  const tier = string(value);
+  if (!tier || tier === "default") return null;
+  return tier === "fast" ? "priority" : tier;
+}
+
+function runtimeSettingsPatch(params = {}, { authoritative = false } = {}) {
+  const nested = params.collaborationMode?.settings || params.collaboration_mode?.settings || {};
+  const patch = {};
+  if (string(params.model) || string(nested.model)) patch.model = string(params.model) || string(nested.model);
+  for (const [object, key] of [[params, "effort"], [params, "reasoningEffort"], [nested, "reasoning_effort"], [nested, "reasoningEffort"]]) {
+    if (hasOwn(object, key) && (key !== "effort" || object[key] != null || authoritative)) {
+      patch.reasoningEffort = string(object[key]) || null;
+      break;
+    }
+  }
+  if (hasOwn(params, "serviceTier") || hasOwn(params, "service_tier")) {
+    patch.serviceTier = normalizeServiceTier(hasOwn(params, "serviceTier") ? params.serviceTier : params.service_tier);
+  }
+  return patch;
+}
+
+function runtimeSettingsFromConversation(conversation = {}) {
+  const settings = conversation.latestThreadSettings || {};
+  const fallback = {};
+  if (string(conversation.latestModel)) fallback.model = conversation.latestModel;
+  if (hasOwn(conversation, "latestReasoningEffort")) fallback.reasoningEffort = conversation.latestReasoningEffort;
+  if (hasOwn(conversation, "latestServiceTier")) fallback.serviceTier = conversation.latestServiceTier;
+  return { ...runtimeSettingsPatch(fallback), ...runtimeSettingsPatch(settings, { authoritative: true }) };
+}
+
+function applyRuntimeSettingsToConversation(conversation, params, options = {}) {
+  if (!conversation) return;
+  const patch = runtimeSettingsPatch(params, options);
+  const settings = { ...(conversation.latestThreadSettings || {}), ...normalizeThreadSettingsUpdate(params, options) };
+  if (hasOwn(patch, "model")) conversation.latestModel = settings.model = patch.model;
+  if (hasOwn(patch, "reasoningEffort")) conversation.latestReasoningEffort = settings.effort = patch.reasoningEffort;
+  if (hasOwn(patch, "serviceTier")) conversation.latestServiceTier = settings.serviceTier = patch.serviceTier;
+  const mode = params.collaborationMode || conversation.latestCollaborationMode;
+  if (mode || patch.model) {
+    conversation.latestCollaborationMode = {
+      ...(mode || { mode: "default" }),
+      settings: {
+        developer_instructions: null,
+        ...(mode?.settings || {}),
+        ...(patch.model ? { model: patch.model } : {}),
+        ...(hasOwn(patch, "reasoningEffort") ? { reasoning_effort: patch.reasoningEffort } : {}),
+      },
+    };
+    settings.collaborationMode = conversation.latestCollaborationMode;
+  }
+  conversation.latestThreadSettings = settings;
+}
+
+// Ordering is scoped to one runtime owner and task. Failures don't poison the
+// queue, and the next mutation always waits for the preceding acknowledgement.
+function createThreadMutationQueue() {
+  const pending = new Map();
+  return function enqueue(threadId, operation) {
+    const result = (pending.get(threadId) || Promise.resolve()).catch(() => {}).then(operation);
+    pending.set(threadId, result);
+    result.finally(() => { if (pending.get(threadId) === result) pending.delete(threadId); }).catch(() => {});
+    return result;
+  };
+}
+
+module.exports = {
+  applyRuntimeSettingsToConversation,
+  createThreadMutationQueue,
+  hasOwn,
+  normalizeServiceTier,
+  normalizeThreadSettingsUpdate,
+  THREAD_SETTINGS_UPDATE_KEYS,
+  threadSettingsFromRuntimeSettings,
+  runtimeSettingsFromConversation,
+  runtimeSettingsPatch,
+};