remote-codex 0.11.54 → 0.11.55

package/apps/supervisor-api/dist/index.js

@@ -8934,13 +8934,16 @@ function deferLargeHistoryItemDetails(turn, deferredDetails) {
   };
 }
 function visibleRuntimeTurnItems(items) {
-  const hasFinalAgentMessage = items.some(
+  const nonEmptyItems = items.filter(
+    (item) => !((item.kind === "agentMessage" || item.kind === "reasoning") && item.text.trim().length === 0)
+  );
+  const hasFinalAgentMessage = nonEmptyItems.some(
     (item) => item.kind === "agentMessage" && !isTransientAgentHistoryItem(item)
   );
   if (!hasFinalAgentMessage) {
-    return items;
+    return nonEmptyItems;
   }
-  return items.filter(
+  return nonEmptyItems.filter(
     (item) => !(item.kind === "agentMessage" && isTransientAgentHistoryItem(item))
   );
 }
@@ -21500,6 +21503,50 @@ function reasoningOptions(configOptions) {
     defaultEffort: normalizeAcpEffort(option.currentValue)
   };
 }
+function legacyModelsFromResponse(response) {
+  if (!response || typeof response !== "object") {
+    return null;
+  }
+  const models = response.models;
+  if (!models || typeof models !== "object") {
+    return null;
+  }
+  const availableModels = models.availableModels;
+  return Array.isArray(availableModels) ? models : null;
+}
+function legacyModelOptions(models) {
+  const currentModelId = models.currentModelId ?? null;
+  return (models.availableModels ?? []).flatMap((model, index) => {
+    if (!model.modelId) {
+      return [];
+    }
+    const efforts = (model._meta?.reasoningEfforts ?? []).flatMap((entry) => {
+      const reasoningEffort = normalizeAcpEffort(entry.value ?? entry.id);
+      return reasoningEffort ? [{
+        reasoningEffort,
+        description: entry.description ?? entry.label ?? ""
+      }] : [];
+    });
+    const declaredDefault = model._meta?.reasoningEfforts?.find(
+      (entry) => entry.default
+    );
+    return [{
+      id: model.modelId,
+      model: model.modelId,
+      displayName: model.name ?? model.modelId,
+      description: model.description ?? "",
+      isDefault: model.modelId === currentModelId || !currentModelId && index === 0,
+      hidden: false,
+      supportedReasoningEfforts: efforts,
+      defaultReasoningEffort: normalizeAcpEffort(model._meta?.reasoningEffort) ?? normalizeAcpEffort(declaredDefault?.value ?? declaredDefault?.id),
+      selectionKind: "model"
+    }];
+  });
+}
+function selectedLegacyModel(state) {
+  const models = state.legacyModels?.availableModels ?? [];
+  return models.find((model) => model.modelId === state.model) ?? models[0] ?? null;
+}
 function permissionOptions(params) {
   return params.options.map((option) => ({
     id: option.optionId,
@@ -21792,7 +21839,32 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
   async inspectModelOptions(cwd) {
     const sessionCapabilities = this.initializeResponse?.agentCapabilities?.sessionCapabilities;
     if (!sessionCapabilities?.delete) {
-      return this.listModels();
+      const normalizedCwd = path16.resolve(cwd);
+      const loadedSession = [...this.sessions.values()].find(
+        (session) => session.cwd === normalizedCwd && (session.configOptions.length > 0 || session.legacyModels !== null)
+      );
+      if (!loadedSession) {
+        return this.listModels();
+      }
+      if (loadedSession.legacyModels) {
+        return legacyModelOptions(loadedSession.legacyModels);
+      }
+      const reasoning = reasoningOptions(loadedSession.configOptions);
+      const supportsPerformanceMode2 = loadedSession.configOptions.some(
+        (option) => option.id === "fast-mode" || option.category === "model_config"
+      );
+      return [{
+        id: "default",
+        model: "default",
+        displayName: "Agent default",
+        description: "Use the model configured by the ACP agent.",
+        isDefault: true,
+        hidden: false,
+        supportsPerformanceMode: supportsPerformanceMode2,
+        supportedReasoningEfforts: reasoning.efforts,
+        defaultReasoningEffort: reasoning.defaultEffort,
+        selectionKind: "model"
+      }];
     }
     const context = await this.requireContext();
     const response = await context.request(methods.agent.session.new, {
@@ -21806,6 +21878,10 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
       (option) => option.id === "fast-mode" || option.category === "model_config"
     );
     try {
+      const legacyModels = legacyModelsFromResponse(response);
+      if (legacyModels) {
+        return legacyModelOptions(legacyModels);
+      }
       const modelOption = configOptionByCategory(configOptions, "model");
       if (!modelOption || modelOption.type !== "select") {
         const reasoning = reasoningOptions(configOptions);
@@ -21991,6 +22067,7 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
     }
     forked.modes = response.modes ?? forked.modes;
     forked.configOptions = response.configOptions ?? forked.configOptions;
+    forked.legacyModels = legacyModelsFromResponse(response) ?? forked.legacyModels;
     this.syncStateFromConfigOptions(forked);
     return sessionDetail(forked);
   }
@@ -22052,7 +22129,8 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
       cwd: path16.resolve(input.cwd),
       mcpServers: [],
       _meta: {
-        yoloMode: input.approvalMode === "yolo"
+        yoloMode: input.approvalMode === "yolo",
+        ...input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}
       }
     });
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -22070,6 +22148,7 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
       activeMapper: null,
       modes: response.modes ?? null,
       configOptions: response.configOptions ?? [],
+      legacyModels: legacyModelsFromResponse(response),
       availableCommands: [],
       hydrationCoverage: null,
       goal: null
@@ -22285,6 +22364,7 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
       activeMapper: null,
       modes: null,
       configOptions: [],
+      legacyModels: null,
       availableCommands: [],
       hydrationCoverage: null,
       goal: null
@@ -22303,6 +22383,7 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
           });
           state.modes = response.modes ?? null;
           state.configOptions = response.configOptions ?? [];
+          state.legacyModels = legacyModelsFromResponse(response);
           state.turns = hydrator.complete();
           state.hydrationCoverage = hydrator.coverage();
           this.syncStateFromConfigOptions(state);
@@ -22317,6 +22398,7 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
         });
         state.modes = response.modes ?? null;
         state.configOptions = response.configOptions ?? [];
+        state.legacyModels = legacyModelsFromResponse(response);
         this.syncStateFromConfigOptions(state);
       } else {
         throw new Error("ACP agent does not support session/load or session/resume.");
@@ -22338,7 +22420,7 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
     if (model && model !== "default") {
       state.model = await this.setConfigOption(state, "model", model);
     }
-    if (reasoningEffort) {
+    if (reasoningEffort && normalizeAcpEffort(reasoningEffort) !== state.reasoningEffort) {
       const applied = await this.setConfigOption(
         state,
         "thought_level",
@@ -22368,17 +22450,39 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
     }
   }
   async setConfigOption(state, category, value) {
-    const option = state.configOptions.find(
-      (candidate) => candidate.category === category || candidate.id.toLowerCase().includes(category === "model" ? "model" : "thought")
-    );
+    const option = configOptionByCategory(state.configOptions, category);
     if ((!option || option.type !== "select") && category === "model") {
       const context2 = await this.requireContext();
       await context2.request("session/set_model", {
         sessionId: state.providerSessionId,
         modelId: value
       });
+      if (state.legacyModels) {
+        state.legacyModels.currentModelId = value;
+      }
       return value;
     }
+    if ((!option || option.type !== "select") && category === "thought_level") {
+      const legacyModel = selectedLegacyModel(state);
+      const selected2 = legacyModel?._meta?.reasoningEfforts?.find(
+        (entry) => normalizeAcpEffort(entry.value ?? entry.id) === normalizeAcpEffort(value)
+      );
+      const modeId = selected2?.value ?? selected2?.id;
+      if (modeId) {
+        const context2 = await this.requireContext();
+        const response2 = await context2.request(methods.agent.session.load, {
+          sessionId: state.providerSessionId,
+          cwd: state.cwd,
+          mcpServers: [],
+          _meta: { reasoningEffort: modeId }
+        });
+        state.modes = response2.modes ?? state.modes;
+        state.configOptions = response2.configOptions ?? state.configOptions;
+        state.legacyModels = legacyModelsFromResponse(response2) ?? state.legacyModels;
+        this.syncStateFromConfigOptions(state);
+        return state.reasoningEffort ?? modeId;
+      }
+    }
     if (!option || option.type !== "select") {
       throw new AgentRuntimeError(
         `ACP agent does not expose a ${category} config option.`,
@@ -22421,6 +22525,16 @@ var AcpRuntimeAdapter = class extends EventEmitter8 {
     if (thoughtOption?.type === "select") {
       state.reasoningEffort = normalizeAcpEffort(thoughtOption.currentValue);
     }
+    if (!modelOption && state.legacyModels) {
+      state.model = state.legacyModels.currentModelId ?? state.legacyModels.availableModels?.[0]?.modelId ?? null;
+    }
+    if (!thoughtOption) {
+      const legacyModel = selectedLegacyModel(state);
+      const declaredDefault = legacyModel?._meta?.reasoningEfforts?.find(
+        (entry) => entry.default
+      );
+      state.reasoningEffort = normalizeAcpEffort(legacyModel?._meta?.reasoningEffort) ?? normalizeAcpEffort(declaredDefault?.value ?? declaredDefault?.id);
+    }
   }
   updateCapabilitiesFromConfigOptions(configOptions) {
     this.capabilities.management.models ||= Boolean(
@@ -23832,7 +23946,13 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter9 {
       if (models.length === 1 && models[0]?.model === "default") {
         const commandModels = await this.catalog.listCommandModels(agentId);
         if (commandModels.length > 0) {
-          models = commandModels;
+          const discoveredDefaults = models[0];
+          models = commandModels.map((model) => ({
+            ...model,
+            supportsPerformanceMode: model.supportsPerformanceMode ?? discoveredDefaults.supportsPerformanceMode ?? false,
+            supportedReasoningEfforts: model.supportedReasoningEfforts.length > 0 ? model.supportedReasoningEfforts : discoveredDefaults.supportedReasoningEfforts,
+            defaultReasoningEffort: model.defaultReasoningEffort ?? discoveredDefaults.defaultReasoningEffort
+          }));
         }
       }
       this.modelCache.set(cacheKey, { at: Date.now(), models });
@@ -23933,6 +24053,7 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter9 {
     const probedDefaultModel = this.modelCache.get(`${agentId}\0${input.cwd}`)?.models.find((model) => model.isDefault)?.model ?? null;
     const resolvedModel = response.model && response.model !== "default" ? response.model : input.model !== "default" ? input.model : probedDefaultModel ?? input.model;
     this.refreshAgentSessionCapabilities(agentId, agent);
+    this.modelCache.clear();
     const session = scopedSession(agentId, response.session);
     return {
       ...response,
@@ -23958,6 +24079,7 @@ var AcpCatalogRuntimeAdapter = class extends EventEmitter9 {
       throw error;
     }
     this.refreshAgentSessionCapabilities(owner.agentId, agent);
+    this.modelCache.clear();
     const session = scopedSession(owner.agentId, response.session);
     return {
       ...response,
@@ -25906,6 +26028,19 @@ function mergeHistoryItemsBySequence(items, missingItems) {
   return sortTurnItemsByRecordedSequence(mergedItems);
 }
 function shouldAppendPersistedMissingItem(turn, item) {
+  if (item.kind === "userMessage" || item.kind === "reasoning") {
+    const persistedText = item.text.replace(/\s+/g, " ").trim();
+    const duplicate = turn.items.some((turnItem) => {
+      if (turnItem.kind !== item.kind) {
+        return false;
+      }
+      const turnText = turnItem.text.replace(/\s+/g, " ").trim();
+      return turnText === persistedText || Math.min(turnText.length, persistedText.length) >= 8 && (turnText.includes(persistedText) || persistedText.includes(turnText));
+    });
+    if (duplicate) {
+      return false;
+    }
+  }
   if (item.kind !== "agentMessage") {
     return true;
   }
@@ -25940,6 +26075,7 @@ function mergePersistedHistoryItemsIntoTurns(turns, persistedItemsByTurnId, defe
       }
       const persistedItemWithTranscriptOrder = {
         ...persistedItem,
+        ...turn.status === "completed" && persistedItem.status === "running" ? { status: "completed" } : {},
         transcriptOrder: transcriptIndex
       };
       if (shouldUsePersistedUserMessageText(item, persistedItemWithTranscriptOrder)) {
@@ -26023,6 +26159,7 @@ var ThreadLiveStateStore = class {
   threadLivePlans = /* @__PURE__ */ new Map();
   threadLiveItems = /* @__PURE__ */ new Map();
   threadTurnItemOrder = /* @__PURE__ */ new Map();
+  threadTurnItemCreatedAt = /* @__PURE__ */ new Map();
   threadNextTurnItemSequence = /* @__PURE__ */ new Map();
   threadMaterializedAgentMessageCounts = /* @__PURE__ */ new Map();
   threadAgentMessageOrderingHints = /* @__PURE__ */ new Map();
@@ -26092,11 +26229,13 @@ var ThreadLiveStateStore = class {
   }
   resetRecordedTurnItemOrder(localThreadId, turnId) {
     this.threadTurnItemOrder.get(localThreadId)?.delete(turnId);
+    this.threadTurnItemCreatedAt.get(localThreadId)?.delete(turnId);
     this.threadNextTurnItemSequence.get(localThreadId)?.delete(turnId);
     this.threadAgentMessageOrderingHints.get(localThreadId)?.delete(turnId);
   }
   clearRecordedTurnItemOrders(localThreadId) {
     this.threadTurnItemOrder.delete(localThreadId);
+    this.threadTurnItemCreatedAt.delete(localThreadId);
     this.threadNextTurnItemSequence.delete(localThreadId);
     this.threadAgentMessageOrderingHints.delete(localThreadId);
   }
@@ -26125,6 +26264,24 @@ var ThreadLiveStateStore = class {
     turnOrder.set(itemId, sequence);
     return sequence;
   }
+  recordTurnItemCreatedAt(localThreadId, turnId, itemId, createdAt) {
+    let threadTimestamps = this.threadTurnItemCreatedAt.get(localThreadId);
+    if (!threadTimestamps) {
+      threadTimestamps = /* @__PURE__ */ new Map();
+      this.threadTurnItemCreatedAt.set(localThreadId, threadTimestamps);
+    }
+    let turnTimestamps = threadTimestamps.get(turnId);
+    if (!turnTimestamps) {
+      turnTimestamps = /* @__PURE__ */ new Map();
+      threadTimestamps.set(turnId, turnTimestamps);
+    }
+    const existing = turnTimestamps.get(itemId);
+    if (existing) {
+      return existing;
+    }
+    turnTimestamps.set(itemId, createdAt);
+    return createdAt;
+  }
   turnItemOrderSnapshot(localThreadId) {
     return this.threadTurnItemOrder.get(localThreadId) ?? /* @__PURE__ */ new Map();
   }
@@ -26243,7 +26400,19 @@ var ThreadLiveStateStore = class {
   appendLiveAgentMessageDelta(input) {
     const current = this.threadLiveItems.get(input.localThreadId);
     const currentItems = current?.turnId === input.turnId ? current.items : [];
-    const existing = currentItems.find((entry) => entry.id === input.itemId);
+    const currentExisting = currentItems.find(
+      (entry) => entry.id === input.itemId
+    );
+    const existing = currentExisting ?? (() => {
+      const hint = this.threadAgentMessageOrderingHints.get(input.localThreadId)?.get(input.turnId)?.get(input.itemId);
+      return hint ? {
+        id: hint.id,
+        kind: "agentMessage",
+        text: hint.text,
+        sequence: hint.sequence,
+        ...hint.createdAt ? { createdAt: hint.createdAt } : {}
+      } : void 0;
+    })();
     const nextItem = existing?.kind === "agentMessage" ? {
       ...existing,
       text: `${existing.text}${input.delta}`,
@@ -26264,7 +26433,7 @@ var ThreadLiveStateStore = class {
     this.setLiveItems(input.localThreadId, {
       turnId: input.turnId,
       items: sortHistoryItemsBySequence(
-        existing ? currentItems.map(
+        currentExisting ? currentItems.map(
           (entry) => entry.id === input.itemId ? nextItem : entry
         ) : [...currentItems, nextItem]
       ),
@@ -26974,8 +27143,17 @@ var ThreadRuntimeEventProjector = class {
           event.item.id
         );
         const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const stableCreatedAt = liveState.recordTurnItemCreatedAt(
+          record2.id,
+          displayTurnId,
+          event.item.id,
+          event.item.createdAt ?? eventTimestamp
+        );
         const orderedLiveItem = {
-          ...withHistoryItemCreatedAt2(event.item, eventTimestamp),
+          ...withHistoryItemCreatedAt2(
+            event.item,
+            stableCreatedAt
+          ),
           sequence
         };
         const transportLiveItem = deferHistoryItemDetailForTransport(orderedLiveItem);
@@ -27027,7 +27205,12 @@ var ThreadRuntimeEventProjector = class {
           displayTurnId,
           event.itemId
         );
-        const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+        const createdAt = liveState.recordTurnItemCreatedAt(
+          record2.id,
+          displayTurnId,
+          event.itemId,
+          (/* @__PURE__ */ new Date()).toISOString()
+        );
         callbacks.appendLiveAgentMessageDelta({
           localThreadId: record2.id,
           turnId: displayTurnId,
@@ -27922,7 +28105,7 @@ function conversationMatchScore(turn, persistedItems) {
   if (!remoteUser || !persistedUser) {
     return 0;
   }
-  const userScore = remoteUser === persistedUser ? 2 : Math.min(remoteUser.length, persistedUser.length) >= 16 && (remoteUser.includes(persistedUser) || persistedUser.includes(remoteUser)) ? 1 : 0;
+  const userScore = remoteUser === persistedUser ? 2 : Math.min(remoteUser.length, persistedUser.length) >= 8 && (remoteUser.includes(persistedUser) || persistedUser.includes(remoteUser)) ? 1 : 0;
   if (userScore === 0) {
     return 0;
   }
@@ -27954,7 +28137,7 @@ function historyItemMatchScore(remote, persisted) {
   if (remoteText === persistedText) {
     return 50;
   }
-  if ((remote.kind === "agentMessage" || remote.kind === "reasoning") && (remoteText.includes(persistedText) || persistedText.includes(remoteText))) {
+  if ((remote.kind === "userMessage" || remote.kind === "agentMessage" || remote.kind === "reasoning") && Math.min(remoteText.length, persistedText.length) >= 8 && (remoteText.includes(persistedText) || persistedText.includes(remoteText))) {
     return 40;
   }
   return 0;
@@ -27966,7 +28149,7 @@ function alignHydratedItems(remoteItems, persistedItems, turnId) {
       persisted,
       index,
       score: historyItemMatchScore(remote, persisted)
-    })).filter((candidate) => candidate.score > 0).sort((left, right) => right.score - left.score || left.index - right.index)[0];
+    })).filter((candidate) => candidate.score > 0).sort((left, right) => Number(left.persisted.id.startsWith("acp-hydrated:")) - Number(right.persisted.id.startsWith("acp-hydrated:")) || right.score - left.score || left.index - right.index)[0];
     if (!match) {
       return remote.sourceTurnId ? { ...remote, sourceTurnId: turnId } : remote;
     }
@@ -27974,6 +28157,12 @@ function alignHydratedItems(remoteItems, persistedItems, turnId) {
     return {
       ...remote,
       id: match.persisted.id,
+      ...match.persisted.createdAt ? { createdAt: match.persisted.createdAt } : {},
+      ...match.persisted.sequence !== void 0 ? { sequence: match.persisted.sequence } : {},
+      ...remote.kind === "userMessage" ? {
+        text: match.persisted.text,
+        ...match.persisted.detailText !== void 0 ? { detailText: match.persisted.detailText } : {}
+      } : {},
       ...remote.sourceTurnId || remote.kind === "agentMessage" ? { sourceTurnId: turnId } : {}
     };
   });
@@ -27993,14 +28182,16 @@ function alignHydratedAcpTurnsWithPersistedHistory(turns, persistedItemsByTurnId
       items,
       index,
       score: conversationMatchScore(turn, items)
-    })).filter((candidate) => candidate.score > 0).sort((left, right) => right.score - left.score || left.index - right.index)[0];
+    })).filter((candidate) => candidate.score > 0).sort((left, right) => Number(left.turnId.startsWith("acp-hydrated:")) - Number(right.turnId.startsWith("acp-hydrated:")) || right.score - left.score || left.index - right.index)[0];
     if (!match) {
       return turn;
     }
     used.add(match.turnId);
+    const persistedStartedAt = earliestItemCreatedAt(match.items);
     return {
       ...turn,
       providerTurnId: match.turnId,
+      ...persistedStartedAt ? { startedAt: persistedStartedAt } : {},
       items: alignHydratedItems(turn.items, match.items, match.turnId)
     };
   });
@@ -28015,6 +28206,20 @@ function appendPersistedTurnsIfMissing(turns, persistedItemsByTurnId, metadataBy
     if (existingTurnIds.has(turnId)) {
       continue;
     }
+    if (turns.some(
+      (turn) => conversationMatchScore(
+        {
+          providerTurnId: turn.id,
+          startedAt: turn.startedAt,
+          status: turn.status,
+          error: turn.error ? { message: turn.error } : null,
+          items: turn.items
+        },
+        items
+      ) > 0
+    )) {
+      continue;
+    }
     const status = persistedAcpTurnStatus(items);
     const error = status === "failed" ? persistedTurnError(items) : null;
     missingTurns.push({
@@ -29120,8 +29325,13 @@ var ThreadSessionCoordinator = class {
       return { status: "bootstrap_unavailable", error };
     }
     const effectiveModel = input.resumeInput.model ?? input.currentModel ?? response.model ?? null;
+    const resumedModelRecords = await this.listSessionModels({
+      provider: input.provider,
+      agentId: input.agentId,
+      workspacePath: input.workspacePath
+    }).catch(() => modelRecords);
     const resumedReasoning = this.providerRuntime.normalizeReasoningForModel(
-      modelRecords,
+      resumedModelRecords,
       effectiveModel,
       normalizeReasoningEffort2(input.currentReasoningEffort) ?? normalizeReasoningEffort2(response.reasoningEffort)
     );
@@ -29468,6 +29678,9 @@ var ThreadHistoryPersistenceCoordinator = class {
     }
   }
   persistHydratedTurns(localThreadId, turns) {
+    const existingItemsByTurnId = this.listPersistedHistoryItemsByTurnId(
+      localThreadId
+    );
     for (const turn of turns) {
       if (turn.startedAt) {
         upsertThreadTurnMetadata(this.db, {
@@ -29480,14 +29693,15 @@ var ThreadHistoryPersistenceCoordinator = class {
         if (!shouldPersistRuntimeFinalHistoryItem(item)) {
           return;
         }
-        const createdAt = item.createdAt ?? turn.startedAt;
+        const existingItem = existingItemsByTurnId.get(turn.providerTurnId)?.find((candidate) => candidate.id === item.id);
+        const createdAt = existingItem?.createdAt ?? item.createdAt ?? turn.startedAt;
         this.persistProjectedHistoryItem(
           localThreadId,
           turn.providerTurnId,
           {
             ...item,
             ...createdAt ? { createdAt } : {},
-            sequence: item.sequence ?? index,
+            sequence: existingItem?.sequence ?? item.sequence ?? index,
             ...item.kind === "agentMessage" && !item.sourceTurnId ? { sourceTurnId: turn.providerTurnId } : {}
           }
         );
@@ -31420,6 +31634,30 @@ function canUseRuntimePagedTurns(cachedDetail, enrichedTurns, options) {
   }
   return cachedDetail.totalTurnCount > enrichedTurns.length;
 }
+function latestTurnItemTimestamp(turn) {
+  return turn.items.map((item) => item.createdAt).filter((value) => Boolean(value)).sort().at(-1) ?? turn.startedAt ?? null;
+}
+function localImportThreadStatusPatch(record2, turns) {
+  const latestTurn = turns.at(-1);
+  if (!latestTurn) {
+    return null;
+  }
+  const status = latestTurn.status === "inProgress" ? "running" : latestTurn.status === "completed" ? "idle" : latestTurn.status;
+  const providerTurnId = latestTurn.status === "inProgress" ? latestTurn.id : null;
+  const lastError = latestTurn.status === "failed" ? latestTurn.error : null;
+  const lastTurnStartedAt = latestTurn.startedAt ?? record2.lastTurnStartedAt ?? null;
+  const lastTurnCompletedAt = latestTurn.status === "inProgress" ? null : latestTurnItemTimestamp(latestTurn) ?? record2.lastTurnCompletedAt ?? null;
+  if (record2.status === status && record2.providerTurnId === providerTurnId && record2.lastError === lastError && record2.lastTurnStartedAt === lastTurnStartedAt && record2.lastTurnCompletedAt === lastTurnCompletedAt) {
+    return null;
+  }
+  return {
+    status,
+    providerTurnId,
+    lastError,
+    lastTurnStartedAt,
+    lastTurnCompletedAt
+  };
+}
 var ThreadService = class {
   constructor(db, agentRuntimes, eventBus, localSessionStore, workspaceRoot, providerManagement, pluginService, config) {
     this.db = db;
@@ -31786,6 +32024,9 @@ var ThreadService = class {
       if (!local) {
         continue;
       }
+      if (local.source === "local_codex_import" && local.isConnected === false) {
+        continue;
+      }
       updateThreadRecord(
         this.db,
         local.id,
@@ -31861,6 +32102,12 @@ var ThreadService = class {
       turnMetadataById,
       options
     });
+    if (record2.source === "local_codex_import" && record2.isConnected === false) {
+      const statusPatch = localImportThreadStatusPatch(record2, cachedDetail.turns);
+      if (statusPatch) {
+        updateThreadRecord(this.db, record2.id, statusPatch);
+      }
+    }
     const updated = getThreadRecordById(this.db, record2.id);
     const enrichedTurns = this.pluginService?.enrichTurnsWithArtifacts({
       threadId: updated.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remote-codex",
-  "version": "0.11.54",
+  "version": "0.11.55",
   "description": "Local web supervisor for Codex workspaces and threads.",
   "license": "MIT",
   "type": "module",

package/packages/acp/src/catalog-runtime.test.ts

@@ -168,6 +168,62 @@ describe('AcpCatalogRuntimeAdapter', () => {
     expect(forked.agentId).toBe('fixture-agent');
   }, 15_000);
 
+  it('refreshes command models with reasoning options from a close-only session', async () => {
+    const fixture = path.resolve('src/test/fixtures/fake-acp-agent.mjs');
+    vi.stubEnv('REMOTE_CODEX_FAKE_ACP_NO_SESSION_DELETE', '1');
+    const runtime = new AcpCatalogRuntimeAdapter({
+      catalog: new AcpAgentCatalog({
+        definitions: [{
+          id: 'grok-fixture',
+          displayName: 'Grok fixture',
+          description: 'Close-only ACP fixture',
+          transport: 'native',
+          baseCommand: process.execPath,
+          baseProbeCommand: `"${process.execPath}" --version`,
+          serverCommand: `"${process.execPath}" "${fixture}"`,
+          serverProbeCommand: `"${process.execPath}" --version`,
+          installCommand: null,
+          modelListCommand: `"${process.execPath}" -e "console.log('Default model: fixture-model\\nAvailable models:\\n * fixture-model (default)\\n - fixture-fast')"`,
+        }],
+      }),
+      startupTimeoutMs: 5_000,
+    });
+    runtimes.push(runtime);
+    await runtime.start();
+
+    expect(await runtime.listModelsForAgent('grok-fixture', process.cwd())).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          model: 'fixture-model',
+          supportedReasoningEfforts: [],
+        }),
+      ]),
+    );
+
+    await runtime.startSession({
+      cwd: process.cwd(),
+      agentId: 'grok-fixture',
+      model: 'fixture-model',
+      reasoningEffort: 'high',
+      approvalMode: 'yolo',
+    });
+
+    expect(await runtime.listModelsForAgent('grok-fixture', process.cwd())).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          model: 'fixture-model',
+          supportedReasoningEfforts: [
+            expect.objectContaining({ reasoningEffort: 'low' }),
+            expect.objectContaining({ reasoningEffort: 'medium' }),
+            expect.objectContaining({ reasoningEffort: 'high' }),
+          ],
+          defaultReasoningEffort: 'high',
+        }),
+        expect.objectContaining({ model: 'fixture-fast' }),
+      ]),
+    );
+  });
+
   it('delegates Codex child controls while preserving scoped goal identity', async () => {
     const fixture = path.resolve('src/test/fixtures/fake-acp-agent.mjs');
     vi.stubEnv('REMOTE_CODEX_FAKE_ACP_AGENT_KIND', 'codex');

package/packages/acp/src/catalog-runtime.ts

@@ -255,7 +255,21 @@ export class AcpCatalogRuntimeAdapter extends EventEmitter implements AgentRunti
       if (models.length === 1 && models[0]?.model === 'default') {
         const commandModels = await this.catalog.listCommandModels(agentId);
         if (commandModels.length > 0) {
-          models = commandModels;
+          const discoveredDefaults = models[0];
+          models = commandModels.map((model) => ({
+            ...model,
+            supportsPerformanceMode:
+              model.supportsPerformanceMode ??
+              discoveredDefaults.supportsPerformanceMode ??
+              false,
+            supportedReasoningEfforts:
+              model.supportedReasoningEfforts.length > 0
+                ? model.supportedReasoningEfforts
+                : discoveredDefaults.supportedReasoningEfforts,
+            defaultReasoningEffort:
+              model.defaultReasoningEffort ??
+              discoveredDefaults.defaultReasoningEffort,
+          }));
         }
       }
       this.modelCache.set(cacheKey, { at: Date.now(), models });
@@ -381,6 +395,7 @@ export class AcpCatalogRuntimeAdapter extends EventEmitter implements AgentRunti
         ? input.model
         : probedDefaultModel ?? input.model;
     this.refreshAgentSessionCapabilities(agentId, agent);
+    this.modelCache.clear();
     const session = scopedSession(agentId, response.session);
     return {
       ...response,
@@ -407,6 +422,7 @@ export class AcpCatalogRuntimeAdapter extends EventEmitter implements AgentRunti
       throw error;
     }
     this.refreshAgentSessionCapabilities(owner.agentId, agent);
+    this.modelCache.clear();
     const session = scopedSession(owner.agentId, response.session);
     return {
       ...response,

package/packages/acp/src/runtimeAdapter.test.ts

@@ -350,6 +350,112 @@ describe('AcpRuntimeAdapter', () => {
     await expect(adapter.listSessions()).resolves.toEqual([]);
   });
 
+  it('reads reasoning options from a loaded close-only agent session', async () => {
+    const adapter = new AcpRuntimeAdapter({
+      command: `"${process.execPath}" "${fixture}"`,
+      env: { REMOTE_CODEX_FAKE_ACP_NO_SESSION_DELETE: '1' },
+      startupTimeoutMs: 5_000,
+    });
+    adapters.push(adapter);
+    await adapter.start();
+
+    const started = await adapter.startSession({
+      cwd: process.cwd(),
+      model: 'fixture-model',
+      reasoningEffort: 'high',
+      approvalMode: 'yolo',
+    });
+
+    await expect(adapter.inspectModelOptions(process.cwd())).resolves.toEqual([
+      expect.objectContaining({
+        model: 'default',
+        supportedReasoningEfforts: [
+          expect.objectContaining({ reasoningEffort: 'low' }),
+          expect.objectContaining({ reasoningEffort: 'medium' }),
+          expect.objectContaining({ reasoningEffort: 'high' }),
+        ],
+        defaultReasoningEffort: 'high',
+      }),
+    ]);
+    await expect(adapter.listSessions()).resolves.toEqual([
+      expect.objectContaining({ providerSessionId: started.providerSessionId }),
+    ]);
+  });
+
+  it('maps and writes Grok-style legacy model reasoning metadata', async () => {
+    const adapter = new AcpRuntimeAdapter({
+      command: `"${process.execPath}" "${fixture}"`,
+      env: {
+        REMOTE_CODEX_FAKE_ACP_NO_SESSION_DELETE: '1',
+        REMOTE_CODEX_FAKE_ACP_LEGACY_MODELS: '1',
+        REMOTE_CODEX_FAKE_ACP_SKIP_PERMISSION: '1',
+      },
+      startupTimeoutMs: 5_000,
+    });
+    adapters.push(adapter);
+    await adapter.start();
+
+    const started = await adapter.startSession({
+      cwd: process.cwd(),
+      model: 'fixture-fast',
+      reasoningEffort: 'low',
+      approvalMode: 'yolo',
+    });
+
+    expect(started).toMatchObject({
+      model: 'fixture-fast',
+      reasoningEffort: 'low',
+      rawSession: {
+        models: {
+          availableModels: [
+            expect.objectContaining({
+              _meta: expect.objectContaining({ reasoningEffort: 'low' }),
+            }),
+            expect.anything(),
+          ],
+        },
+      },
+    });
+    await expect(adapter.inspectModelOptions(process.cwd())).resolves.toEqual([
+      expect.objectContaining({
+        model: 'fixture-model',
+        supportedReasoningEfforts: [
+          expect.objectContaining({ reasoningEffort: 'high' }),
+          expect.objectContaining({ reasoningEffort: 'medium' }),
+          expect.objectContaining({ reasoningEffort: 'low' }),
+        ],
+      }),
+      expect.objectContaining({
+        model: 'fixture-fast',
+        defaultReasoningEffort: 'low',
+        supportedReasoningEfforts: [
+          expect.objectContaining({ reasoningEffort: 'high' }),
+          expect.objectContaining({ reasoningEffort: 'low' }),
+        ],
+      }),
+    ]);
+
+    const completed = new Promise<void>((resolve) => {
+      adapter.on('event', (event: AgentRuntimeEvent) => {
+        if (event.type === 'turn.completed') resolve();
+      });
+    });
+    await adapter.startTurn({
+      providerSessionId: started.providerSessionId,
+      prompt: 'Verify changed effort.',
+      reasoningEffort: 'high',
+    });
+    await completed;
+    await expect(adapter.inspectModelOptions(process.cwd())).resolves.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          model: 'fixture-fast',
+          defaultReasoningEffort: 'high',
+        }),
+      ]),
+    );
+  });
+
   it('deletes temporary model-probe sessions', async () => {
     const adapter = new AcpRuntimeAdapter({
       command: `"${process.execPath}" "${fixture}"`,

package/packages/acp/src/runtimeAdapter.ts

@@ -79,11 +79,33 @@ interface AcpSessionState {
   activeMapper: AcpTurnItemMapper | null;
   modes: acp.SessionModeState | null;
   configOptions: acp.SessionConfigOption[];
+  legacyModels: AcpLegacyModelState | null;
   availableCommands: acp.AvailableCommand[];
   hydrationCoverage: AgentSessionHistoryCoverage | null;
   goal: AgentGoal | null;
 }
 
+interface AcpLegacyModelState {
+  currentModelId?: string;
+  availableModels?: AcpLegacyModelInfo[];
+}
+
+interface AcpLegacyModelInfo {
+  modelId: string;
+  name?: string;
+  description?: string;
+  _meta?: {
+    reasoningEffort?: string;
+    reasoningEfforts?: Array<{
+      id?: string;
+      value?: string;
+      label?: string;
+      description?: string;
+      default?: boolean;
+    }>;
+  };
+}
+
 interface PendingPermission {
   params: acp.RequestPermissionRequest;
   resolve: (response: acp.RequestPermissionResponse) => void;
@@ -239,6 +261,60 @@ function reasoningOptions(configOptions: acp.SessionConfigOption[]) {
   };
 }
 
+function legacyModelsFromResponse(response: unknown): AcpLegacyModelState | null {
+  if (!response || typeof response !== 'object') {
+    return null;
+  }
+  const models = (response as { models?: unknown }).models;
+  if (!models || typeof models !== 'object') {
+    return null;
+  }
+  const availableModels = (models as { availableModels?: unknown }).availableModels;
+  return Array.isArray(availableModels)
+    ? models as AcpLegacyModelState
+    : null;
+}
+
+function legacyModelOptions(models: AcpLegacyModelState): AgentModel[] {
+  const currentModelId = models.currentModelId ?? null;
+  return (models.availableModels ?? []).flatMap((model, index) => {
+    if (!model.modelId) {
+      return [];
+    }
+    const efforts = (model._meta?.reasoningEfforts ?? []).flatMap((entry) => {
+      const reasoningEffort = normalizeAcpEffort(entry.value ?? entry.id);
+      return reasoningEffort
+        ? [{
+            reasoningEffort,
+            description: entry.description ?? entry.label ?? '',
+          }]
+        : [];
+    });
+    const declaredDefault = model._meta?.reasoningEfforts?.find(
+      (entry) => entry.default,
+    );
+    return [{
+      id: model.modelId,
+      model: model.modelId,
+      displayName: model.name ?? model.modelId,
+      description: model.description ?? '',
+      isDefault:
+        model.modelId === currentModelId || (!currentModelId && index === 0),
+      hidden: false,
+      supportedReasoningEfforts: efforts,
+      defaultReasoningEffort:
+        normalizeAcpEffort(model._meta?.reasoningEffort) ??
+        normalizeAcpEffort(declaredDefault?.value ?? declaredDefault?.id),
+      selectionKind: 'model',
+    }];
+  });
+}
+
+function selectedLegacyModel(state: AcpSessionState) {
+  const models = state.legacyModels?.availableModels ?? [];
+  return models.find((model) => model.modelId === state.model) ?? models[0] ?? null;
+}
+
 function permissionOptions(params: acp.RequestPermissionRequest) {
   return params.options.map((option) => ({
     id: option.optionId,
@@ -578,7 +654,34 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
     const sessionCapabilities =
       this.initializeResponse?.agentCapabilities?.sessionCapabilities;
     if (!sessionCapabilities?.delete) {
-      return this.listModels();
+      const normalizedCwd = path.resolve(cwd);
+      const loadedSession = [...this.sessions.values()].find(
+        (session) =>
+          session.cwd === normalizedCwd &&
+          (session.configOptions.length > 0 || session.legacyModels !== null),
+      );
+      if (!loadedSession) {
+        return this.listModels();
+      }
+      if (loadedSession.legacyModels) {
+        return legacyModelOptions(loadedSession.legacyModels);
+      }
+      const reasoning = reasoningOptions(loadedSession.configOptions);
+      const supportsPerformanceMode = loadedSession.configOptions.some(
+        (option) => option.id === 'fast-mode' || option.category === 'model_config',
+      );
+      return [{
+        id: 'default',
+        model: 'default',
+        displayName: 'Agent default',
+        description: 'Use the model configured by the ACP agent.',
+        isDefault: true,
+        hidden: false,
+        supportsPerformanceMode,
+        supportedReasoningEfforts: reasoning.efforts,
+        defaultReasoningEffort: reasoning.defaultEffort,
+        selectionKind: 'model',
+      }];
     }
     const context = await this.requireContext();
     const response = await context.request(acp.methods.agent.session.new, {
@@ -592,6 +695,10 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
       (option) => option.id === 'fast-mode' || option.category === 'model_config',
     );
     try {
+      const legacyModels = legacyModelsFromResponse(response);
+      if (legacyModels) {
+        return legacyModelOptions(legacyModels);
+      }
       const modelOption = configOptionByCategory(configOptions, 'model');
       if (!modelOption || modelOption.type !== 'select') {
         const reasoning = reasoningOptions(configOptions);
@@ -792,6 +899,7 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
     }
     forked.modes = response.modes ?? forked.modes;
     forked.configOptions = response.configOptions ?? forked.configOptions;
+    forked.legacyModels = legacyModelsFromResponse(response) ?? forked.legacyModels;
     this.syncStateFromConfigOptions(forked);
     return sessionDetail(forked);
   }
@@ -880,6 +988,9 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
       mcpServers: [],
       _meta: {
         yoloMode: input.approvalMode === 'yolo',
+        ...(input.reasoningEffort
+          ? { reasoningEffort: input.reasoningEffort }
+          : {}),
       },
     });
     const now = new Date().toISOString();
@@ -897,6 +1008,7 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
       activeMapper: null,
       modes: response.modes ?? null,
       configOptions: response.configOptions ?? [],
+      legacyModels: legacyModelsFromResponse(response),
       availableCommands: [],
       hydrationCoverage: null,
       goal: null,
@@ -1134,6 +1246,7 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
       activeMapper: null,
       modes: null,
       configOptions: [],
+      legacyModels: null,
       availableCommands: [],
       hydrationCoverage: null,
       goal: null,
@@ -1152,6 +1265,7 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
           });
           state.modes = response.modes ?? null;
           state.configOptions = response.configOptions ?? [];
+          state.legacyModels = legacyModelsFromResponse(response);
           state.turns = hydrator.complete();
           state.hydrationCoverage = hydrator.coverage();
           this.syncStateFromConfigOptions(state);
@@ -1166,6 +1280,7 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
         });
         state.modes = response.modes ?? null;
         state.configOptions = response.configOptions ?? [];
+        state.legacyModels = legacyModelsFromResponse(response);
         this.syncStateFromConfigOptions(state);
       } else {
         throw new Error('ACP agent does not support session/load or session/resume.');
@@ -1195,7 +1310,10 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
     if (model && model !== 'default') {
       state.model = await this.setConfigOption(state, 'model', model);
     }
-    if (reasoningEffort) {
+    if (
+      reasoningEffort &&
+      normalizeAcpEffort(reasoningEffort) !== state.reasoningEffort
+    ) {
       const applied = await this.setConfigOption(
         state,
         'thought_level',
@@ -1239,17 +1357,42 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
     category: 'model' | 'thought_level',
     value: string,
   ) {
-    const option = state.configOptions.find((candidate) =>
-      candidate.category === category || candidate.id.toLowerCase().includes(category === 'model' ? 'model' : 'thought'),
-    );
+    const option = configOptionByCategory(state.configOptions, category);
     if ((!option || option.type !== 'select') && category === 'model') {
       const context = await this.requireContext();
       await context.request('session/set_model', {
         sessionId: state.providerSessionId,
         modelId: value,
       });
+      if (state.legacyModels) {
+        state.legacyModels.currentModelId = value;
+      }
       return value;
     }
+    if ((!option || option.type !== 'select') && category === 'thought_level') {
+      const legacyModel = selectedLegacyModel(state);
+      const selected = legacyModel?._meta?.reasoningEfforts?.find(
+        (entry) =>
+          normalizeAcpEffort(entry.value ?? entry.id) ===
+          normalizeAcpEffort(value),
+      );
+      const modeId = selected?.value ?? selected?.id;
+      if (modeId) {
+        const context = await this.requireContext();
+        const response = await context.request(acp.methods.agent.session.load, {
+          sessionId: state.providerSessionId,
+          cwd: state.cwd,
+          mcpServers: [],
+          _meta: { reasoningEffort: modeId },
+        });
+        state.modes = response.modes ?? state.modes;
+        state.configOptions = response.configOptions ?? state.configOptions;
+        state.legacyModels =
+          legacyModelsFromResponse(response) ?? state.legacyModels;
+        this.syncStateFromConfigOptions(state);
+        return state.reasoningEffort ?? modeId;
+      }
+    }
     if (!option || option.type !== 'select') {
       throw new AgentRuntimeError(
         `ACP agent does not expose a ${category} config option.`,
@@ -1293,6 +1436,20 @@ export class AcpRuntimeAdapter extends EventEmitter implements AgentRuntime {
     if (thoughtOption?.type === 'select') {
       state.reasoningEffort = normalizeAcpEffort(thoughtOption.currentValue);
     }
+    if (!modelOption && state.legacyModels) {
+      state.model = state.legacyModels.currentModelId ??
+        state.legacyModels.availableModels?.[0]?.modelId ??
+        null;
+    }
+    if (!thoughtOption) {
+      const legacyModel = selectedLegacyModel(state);
+      const declaredDefault = legacyModel?._meta?.reasoningEfforts?.find(
+        (entry) => entry.default,
+      );
+      state.reasoningEffort =
+        normalizeAcpEffort(legacyModel?._meta?.reasoningEffort) ??
+        normalizeAcpEffort(declaredDefault?.value ?? declaredDefault?.id);
+    }
   }
 
   private updateCapabilitiesFromConfigOptions(

package/packages/acp/src/test/fixtures/fake-acp-agent.mjs

@@ -25,6 +25,7 @@ const agentKind = process.env.REMOTE_CODEX_FAKE_ACP_AGENT_KIND ?? 'fixture';
 const supportsFork = process.env.REMOTE_CODEX_FAKE_ACP_FORK === '1';
 const noSessionCleanup = process.env.REMOTE_CODEX_FAKE_ACP_NO_SESSION_CLEANUP === '1';
 const noSessionDelete = process.env.REMOTE_CODEX_FAKE_ACP_NO_SESSION_DELETE === '1';
+const legacyModels = process.env.REMOTE_CODEX_FAKE_ACP_LEGACY_MODELS === '1';
 const goalVersion = process.env.REMOTE_CODEX_FAKE_ACP_GOAL_VERSION ?? '1';
 const goalActions = (process.env.REMOTE_CODEX_FAKE_ACP_GOAL_ACTIONS ?? 'get,set,clear')
   .split(',')
@@ -90,6 +91,38 @@ function modes(session) {
 }
 
 function responseState(session) {
+  if (legacyModels) {
+    return {
+      models: {
+        currentModelId: session.config.model,
+        availableModels: [
+          {
+            modelId: 'fixture-model',
+            name: 'Fixture model',
+            _meta: {
+              reasoningEffort: session.config.thought,
+              reasoningEfforts: [
+                { id: 'high', value: 'high', label: 'High', default: true },
+                { id: 'medium', value: 'medium', label: 'Medium' },
+                { id: 'low', value: 'low', label: 'Low' },
+              ],
+            },
+          },
+          {
+            modelId: 'fixture-fast',
+            name: 'Fixture fast model',
+            _meta: {
+              reasoningEffort: session.config.thought,
+              reasoningEfforts: [
+                { id: 'high', value: 'high', label: 'High', default: true },
+                { id: 'low', value: 'low', label: 'Low' },
+              ],
+            },
+          },
+        ],
+      },
+    };
+  }
   return {
     modes: modes(session),
     configOptions: configOptions(session),
@@ -290,13 +323,20 @@ acp.agent({ name: 'remote-codex-fake-acp-agent' })
   }))
   .onRequest(acp.methods.agent.session.new, async (context) => {
     const now = new Date().toISOString();
+    const config = defaultConfig();
+    if (
+      legacyModels &&
+      typeof context.params._meta?.reasoningEffort === 'string'
+    ) {
+      config.thought = context.params._meta.reasoningEffort;
+    }
     const session = {
       sessionId: randomUUID(),
       cwd: path.resolve(context.params.cwd),
       title: 'Fixture session',
       createdAt: now,
       updatedAt: now,
-      config: defaultConfig(),
+      config,
       turns: [],
       pendingPrompt: null,
     };
@@ -315,6 +355,12 @@ acp.agent({ name: 'remote-codex-fake-acp-agent' })
   }))
   .onRequest(acp.methods.agent.session.load, async (context) => {
     const session = requireSession(context.params.sessionId);
+    if (
+      legacyModels &&
+      typeof context.params._meta?.reasoningEffort === 'string'
+    ) {
+      session.config.thought = context.params._meta.reasoningEffort;
+    }
     await replaySession(context.client, session);
     return responseState(session);
   })
@@ -348,7 +394,15 @@ acp.agent({ name: 'remote-codex-fake-acp-agent' })
   })
   .onRequest(acp.methods.agent.session.setMode, async (context) => {
     const session = requireSession(context.params.sessionId);
-    session.config.mode = context.params.modeId;
+    if (legacyModels) session.config.thought = context.params.modeId;
+    else session.config.mode = context.params.modeId;
+    session.updatedAt = new Date().toISOString();
+    await saveState();
+    return {};
+  })
+  .onRequest('session/set_model', (params) => params, async (context) => {
+    const session = requireSession(context.params.sessionId);
+    session.config.model = context.params.modelId;
     session.updatedAt = new Date().toISOString();
     await saveState();
     return {};

package/packages/codex/src/historyItems.test.ts

@@ -55,6 +55,27 @@ describe('codex history item persistence policy', () => {
     ).toEqual([{ ...finalMessage, transcriptOrder: 0 }]);
   });
 
+  it('omits empty assistant and reasoning rows from runtime history', () => {
+    const finalMessage: AgentHistoryItem = {
+      id: 'agent-final-1',
+      kind: 'agentMessage',
+      text: 'Final answer',
+    };
+
+    expect(
+      agentTurnToThreadTurnDto({
+        providerTurnId: 'turn-1',
+        status: 'completed',
+        error: null,
+        items: [
+          { id: 'reasoning-empty', kind: 'reasoning', text: '  \n' },
+          { id: 'agent-empty', kind: 'agentMessage', text: '' },
+          finalMessage,
+        ],
+      }).items,
+    ).toEqual([{ ...finalMessage, transcriptOrder: 0 }]);
+  });
+
   it('maps Codex collab agent tool calls to dedicated agent tool call items', () => {
     const turn = codexTurnToAgentTurn({
       id: 'turn-1',

package/packages/codex/src/historyItems.ts

@@ -541,14 +541,21 @@ export function shouldPersistRuntimeFinalHistoryItem(
 }
 
 function visibleRuntimeTurnItems(items: ThreadHistoryItemDto[]) {
-  const hasFinalAgentMessage = items.some(
+  const nonEmptyItems = items.filter(
+    (item) =>
+      !(
+        (item.kind === 'agentMessage' || item.kind === 'reasoning') &&
+        item.text.trim().length === 0
+      ),
+  );
+  const hasFinalAgentMessage = nonEmptyItems.some(
     (item) => item.kind === 'agentMessage' && !isTransientAgentHistoryItem(item),
   );
   if (!hasFinalAgentMessage) {
-    return items;
+    return nonEmptyItems;
   }
 
-  return items.filter(
+  return nonEmptyItems.filter(
     (item) => !(item.kind === 'agentMessage' && isTransientAgentHistoryItem(item)),
   );
 }