codex-overleaf-link 2.3.4 → 2.3.6

package/extension/src/content/generated/content.bundle.meta.json

@@ -2,9 +2,9 @@
   "schemaVersion": 1,
   "entry": "extension/entries/content-entry.mjs",
   "output": "extension/src/content/generated/content.bundle.js",
-  "sourceDigest": "48e7ba193b0723f8e135c4b52e3af1416b1fe35b3cb780207fb0600e7e0f8019",
-  "outputDigest": "866811d95e8bd58d369e0790bf2af5becc93946eb8ad987b80f0be0f80fa965f",
-  "byteLength": 2321914,
+  "sourceDigest": "15c3e103532c84dea57aeac33e02ec665fbf7518543e14daac2459c434b3e5d5",
+  "outputDigest": "5e1dba4bfcf4c595835312deabefa5ecdd2ee7c6d98f29d1b2bd9711ad5b195c",
+  "byteLength": 2375784,
   "inputs": [
     "extension/entries/content-entry.mjs",
     "extension/src/content/activeTurnControl.js",
@@ -17,6 +17,7 @@
     "extension/src/content/diagnosticsController.js",
     "extension/src/content/diagnosticsPanel.js",
     "extension/src/content/diffReviewPanel.js",
+    "extension/src/content/globalPreferencesController.js",
     "extension/src/content/legacyGlobalRegistry.js",
     "extension/src/content/localSkillsPanel.js",
     "extension/src/content/markdownDomRenderer.js",
@@ -43,10 +44,12 @@
     "extension/src/content/recentProjects.js",
     "extension/src/content/reviewHunks.js",
     "extension/src/content/runController.js",
+    "extension/src/content/runFailureNotice.js",
     "extension/src/content/runGuidanceController.js",
     "extension/src/content/runGuidanceView.js",
     "extension/src/content/runQueueScheduler.js",
     "extension/src/content/runResultActions.js",
+    "extension/src/content/runScrollLayout.js",
     "extension/src/content/runSettlementPersistence.js",
     "extension/src/content/runTimelineView.js",
     "extension/src/content/scopedPersistenceCoordinator.js",
@@ -68,6 +71,7 @@
     "extension/src/shared/compatibility.js",
     "extension/src/shared/compileAdapter.js",
     "extension/src/shared/failureReasons.js",
+    "extension/src/shared/globalPreferences.js",
     "extension/src/shared/governanceRules.js",
     "extension/src/shared/i18n.js",
     "extension/src/shared/lineReferences.js",
@@ -88,6 +92,7 @@
     "extension/src/shared/scopedPersistenceTransaction.js",
     "extension/src/shared/sensitiveScan.js",
     "extension/src/shared/sessionState.js",
+    "extension/src/shared/sessionTitle.js",
     "extension/src/shared/settlementFacts.js",
     "extension/src/shared/staleGuard.js",
     "extension/src/shared/storageDb.js",

package/extension/src/content/globalPreferencesController.js

@@ -0,0 +1,125 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory(require('../shared/globalPreferences'));
+  else root.CodexOverleafModuleRegistry.define('GlobalPreferencesController', ['GlobalPreferences'], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (Preferences) {
+  'use strict';
+
+  const CONTROLS = Object.freeze({ theme: '[data-theme-select]', locale: '[data-language-select]',
+    preloadProjectContext: '[data-preload-project-context]', loadCodexLocalSkills: '[data-load-codex-local-skills]',
+    loadCodexOverleafSkills: '[data-load-codex-overleaf-skills]' });
+
+  function create(options) {
+    const chromeApi = options.chromeApi;
+    const fallback = Preferences.pick(options.getState?.() || {});
+    let snapshot = null;
+    let loading = null;
+    let subscribed = false;
+    let disposed = false;
+    let lastError = null;
+    let tail = Promise.resolve();
+    const pending = [];
+
+    function view() {
+      return pending.reduce((values, operation) => Preferences.applyPatch(values, operation.patch), snapshot?.values || fallback);
+    }
+
+    function render(force = false) {
+      if (disposed) return;
+      const previous = options.getState?.() || {};
+      const values = view();
+      const changed = Preferences.changedKeys(Preferences.pick(previous), values);
+      options.setState?.({ ...previous, ...values });
+      const panel = options.getPanel?.();
+      if (!panel) return;
+      for (const [field, selector] of Object.entries(CONTROLS)) {
+        const control = panel.querySelector(selector);
+        if (!control) continue;
+        if (typeof values[field] === 'boolean') control.checked = values[field];
+        else if (control.value !== values[field]) control.value = values[field];
+      }
+      if (force || changed.includes('theme')) options.applyTheme?.(values.theme);
+      if (changed.includes('locale')) options.applyLocale?.();
+      if (force || changed.includes('preloadProjectContext')) options.onPreloadChange?.(values.preloadProjectContext);
+      if (changed.some(key => key === 'codexOverleafSkillEnabled' || key.startsWith('loadCodex'))) options.onSkillsChange?.();
+    }
+
+    function accept(value) {
+      const next = Preferences.validateSnapshot(value);
+      lastError = null;
+      if (!snapshot || next.revision > snapshot.revision) {
+        snapshot = next;
+        render();
+      }
+      return snapshot;
+    }
+
+    async function request(type, patch) {
+      const response = await chromeApi.runtime.sendMessage({ type, ...(patch ? { patch } : {}) });
+      if (!response?.ok) throw new Error(response?.error?.message || 'Global preferences are unavailable.');
+      return response.result;
+    }
+
+    function onStorageChange(changes, area) {
+      if (disposed || area !== 'local' || !changes[Preferences.STORAGE_KEY]?.newValue) return;
+      try { accept(changes[Preferences.STORAGE_KEY].newValue); } catch (error) { reportError(error); }
+    }
+
+    function reportError(error) {
+      lastError = error;
+      options.onError?.(error);
+    }
+
+    async function initialize() {
+      if (!subscribed) {
+        chromeApi.storage.onChanged.addListener(onStorageChange);
+        subscribed = true;
+      }
+      if (snapshot) return snapshot;
+      if (!loading) {
+        loading = request(Preferences.READ_MESSAGE).then(accept).catch(error => {
+          reportError(error);
+          return null;
+        }).finally(() => { loading = null; });
+      }
+      return loading;
+    }
+
+    function update(input) {
+      const patch = Preferences.validatePatch(input);
+      if (!Preferences.changedKeys(view(), Preferences.applyPatch(view(), patch)).length) return pending.length ? tail : Promise.resolve(snapshot);
+      const operation = { patch };
+      pending.push(operation);
+      render();
+      const result = tail.catch(() => {}).then(() => request(Preferences.PATCH_MESSAGE, patch)).then(Preferences.validateSnapshot).then(value => {
+        accept(value);
+        pending.splice(pending.indexOf(operation), 1);
+        render();
+        return snapshot;
+      }, error => {
+        pending.splice(pending.indexOf(operation), 1);
+        render();
+        reportError(error);
+        throw error;
+      });
+      tail = result;
+      return result;
+    }
+
+    function handleInput(event) {
+      const field = Object.keys(CONTROLS).find(key => event?.target?.matches?.(CONTROLS[key]));
+      if (!field) return null;
+      return update({ [field]: ['theme', 'locale'].includes(field) ? event.target.value : Boolean(event.target.checked) });
+    }
+
+    return Object.freeze({ initialize, update, handleInput,
+      overlay: state => snapshot || pending.length ? { ...state, ...view() } : state,
+      refreshView: () => { if (snapshot) render(true); if (lastError) options.onError?.(lastError); },
+      destroy() {
+        disposed = true;
+        if (subscribed) chromeApi.storage.onChanged.removeListener(onStorageChange);
+      }
+    });
+  }
+
+  return Object.freeze({ create });
+});

package/extension/src/content/legacyGlobalRegistry.js

@@ -27,6 +27,8 @@
     'DiffReviewPanel',
     'FailureReasons',
     'GovernanceRules',
+    'GlobalPreferences',
+    'GlobalPreferencesController',
     'I18n',
     'LineReferences',
     'LocalSkillsPanel',
@@ -55,6 +57,8 @@
     'RunInputQueue',
     'RunQueueScheduler',
     'RunResultActions',
+    'RunScrollLayout',
+    'RunFailureNotice',
     'RunSettlementPersistence',
     'RunTimelineView',
     'ScopedPersistenceCoordinator',

package/extension/src/content/otWarmMirror.js

@@ -50,6 +50,7 @@
     } = deps;
 
   let currentOtStatus = 'off';
+  let otTogglePending = false;
   let otSyncRequestId = 0;
   let otWarmMirrorProjectId = '';
   let lastExperimentalOtProjectId = '';
@@ -61,7 +62,10 @@
     patchQueue: [],
     lastStatus: 'off',
     lastPatchAt: 0,
-    lastErrorCode: ''
+    lastErrorCode: '',
+    failureActive: false,
+    lastFailure: null,
+    suspended: false
   };
   let mirrorPrefetchState = {
     inFlight: null,
@@ -159,14 +163,14 @@
   }
 
   async function handleExperimentalOtToggleClick(event) {
-    // The handler is bound to the visible checkbox: by the time click fires,
-    // pre-click activation has ALREADY flipped .checked — that flipped value
-    // is the user's intended target. preventDefault then rolls the visual
-    // state back (synchronously, when dispatch completes), and the confirm
-    // flow applies the target only after approval.
+    // Capture the pre-activated target, then let cancelled click dispatch
+    // restore the old checkbox value before projecting the approved state.
     const clicked = event?.currentTarget || event?.target;
     const targetEnabled = clicked && typeof clicked.checked === 'boolean' ? clicked.checked : undefined;
+    const projectId = getCurrentProjectId();
     event.preventDefault();
+    await new Promise(resolve => window.setTimeout(resolve, 0));
+    if (projectId !== getCurrentProjectId()) return;
     await toggleExperimentalOtCheckbox(targetEnabled);
   }
 
@@ -180,9 +184,12 @@
 
   async function toggleExperimentalOtCheckbox(targetEnabled) {
     const checkbox = getPanel()?.querySelector('[data-experimental-ot]');
-    if (!checkbox) {
+    if (!checkbox || otTogglePending) {
       return;
     }
+    const projectId = getCurrentProjectId();
+    otTogglePending = true;
+    try {
     // Explicit target from the click interceptor wins; the keyboard/legacy
     // path (no argument, un-flipped checkbox) falls back to inversion.
     const nextEnabled = typeof targetEnabled === 'boolean' ? targetEnabled : !checkbox.checked;
@@ -200,11 +207,15 @@
     } else {
       closeDiagnosticsMenu();
     }
+    if (projectId !== getCurrentProjectId() || checkbox !== getPanel()?.querySelector('[data-experimental-ot]')) return;
     checkbox.checked = nextEnabled;
     handleExperimentalOtToggleChange({ currentTarget: checkbox });
     if (nextEnabled) {
       showPluginToast(tr('experimentalOtEnabledToast'), { status: 'info' });
     }
+    } finally {
+      otTogglePending = false;
+    }
   }
 
   function handleExperimentalOtToggleChange(event) {
@@ -213,6 +224,7 @@
       return;
     }
     const projectId = getCurrentProjectId();
+    otWarmMirrorState.failureActive = false;
     lastExperimentalOtProjectId = projectId;
     setExperimentalOtEnabledForProject(projectId, checkbox.checked);
     updateExperimentalOtToggleControl(checkbox.checked);
@@ -230,7 +242,7 @@
     updateOtStatusDisplay(checkbox.checked ? (currentOtStatus === 'off' ? 'starting' : currentOtStatus) : 'off');
     syncOtWarmMirrorController().catch(error => {
       updateOtStatusDisplay('unavailable');
-      appendPlainLog(tx(`Experimental OT warm mirror unavailable: ${error.message}`, `实验性 OT 预热镜像不可用：${error.message}`));
+      appendPlainLog(tx(`OT warm mirror unavailable: ${error.message}`, `OT 预热镜像不可用：${error.message}`));
     });
     saveStateSoon();
   }
@@ -252,6 +264,7 @@
     otWarmMirrorProjectId = projectId;
     ensureOtWarmMirrorStateProject(projectId);
     if (enabled) {
+      otWarmMirrorState.suspended = false;
       const pause = otWarmMirrorController?.shouldPauseOtWarmMirror?.({ running: Boolean(getCurrentRunView()) }) || { pause: false };
       if (pause.pause) {
         clearOtEventPolling({ clearPatchQueue: true });
@@ -263,9 +276,12 @@
     } else {
       clearOtEventPolling({ clearPatchQueue: true });
     }
-    const response = enabled
-      ? await callPageBridge('startOtObserver', { projectId })
-      : await callPageBridge('stopOtObserver', {});
+    let response;
+    try {
+      response = enabled ? await callPageBridge('startOtObserver', { projectId }) : await callPageBridge('stopOtObserver', {});
+    } catch (error) {
+      response = { ok: false, error: otWarmMirrorController.normalizeFailureCode(error?.code || error?.message, 'ot_bridge_unavailable') };
+    }
     if (!isCurrentOtSync(requestId, projectId) || getCurrentProjectId() !== projectId) {
       if (enabled) {
         await handleStaleOtStartResponse(projectId, requestId);
@@ -282,7 +298,7 @@
     }
     const status = readOtBridgeStatus(response);
     if (!isSuccessfulOtBridgeResponse(response) || status === 'unavailable') {
-      handleFailedOtStart(projectId, requestId);
+      await handleFailedOtStart(projectId, requestId, response);
       return response;
     }
     const pauseAfterStart = otWarmMirrorController?.shouldPauseOtWarmMirror?.({ running: Boolean(getCurrentRunView()) }) || { pause: false };
@@ -290,6 +306,7 @@
       await pauseOtWarmMirror(pauseAfterStart.reason || 'paused');
       return response;
     }
+    otWarmMirrorState.failureActive = false;
     updateOtStatusDisplay(status);
     scheduleOtEventPolling(projectId, { immediate: true });
     return response;
@@ -314,11 +331,13 @@
     }
   }
 
-  function handleFailedOtStart(projectId, requestId) {
+  async function handleFailedOtStart(projectId, requestId, response) {
     if (!isCurrentOtSync(requestId, projectId) || getCurrentProjectId() !== projectId) {
       return;
     }
     clearOtEventPolling({ clearPatchQueue: true });
+    recordOtFailure(readOtBridgeErrorCode(response, 'ot_start_failed'), 'start');
+    otWarmMirrorState.suspended = true;
     setExperimentalOtEnabledForProject(projectId, false);
     const experimentalOtCheckbox = getPanel()?.querySelector('[data-experimental-ot]');
     if (experimentalOtCheckbox) {
@@ -326,13 +345,14 @@
     }
     updateOtStatusDisplay('unavailable');
     saveStateSoon();
+    try { await callPageBridge('stopOtObserver', { projectId }); } catch (_error) { /* preserve the original failure */ }
   }
 
   function readOtBridgeStatus(response) {
     if (!response || response.ok === false) {
       return 'unavailable';
     }
-    return response.getState() || response.status || response.result?.getState() || response.result?.status || 'unavailable';
+    return response.state || response.status || response.result?.state || response.result?.status || 'unavailable';
   }
 
   function ensureOtWarmMirrorStateProject(projectId) {
@@ -343,6 +363,9 @@
     otWarmMirrorState.projectId = projectId;
     otWarmMirrorState.lastPatchAt = 0;
     otWarmMirrorState.lastErrorCode = '';
+    otWarmMirrorState.failureActive = false;
+    otWarmMirrorState.lastFailure = null;
+    otWarmMirrorState.suspended = false;
     otWarmMirrorState.lastStatus = currentOtStatus;
   }
 
@@ -386,7 +409,8 @@
       && otWarmMirrorController?.buildPatchFilesRequest
       && isExperimentalOtEnabledForProject(projectId)
       && otWarmMirrorProjectId === projectId
-      && getCurrentProjectId() === projectId);
+      && getCurrentProjectId() === projectId
+      && !otWarmMirrorState.suspended);
   }
 
   async function pollOtEvents(projectId = otWarmMirrorState.projectId || getCurrentProjectId()) {
@@ -409,11 +433,12 @@
         return { ok: false, skipped: true, reason: 'project_changed' };
       }
       if (!isSuccessfulOtBridgeResponse(statusResponse)) {
-        otWarmMirrorState.lastErrorCode = readOtBridgeErrorCode(statusResponse, 'get_ot_status_failed');
+        recordOtFailure(readOtBridgeErrorCode(statusResponse, 'get_ot_status_failed'), 'observe');
         updateOtStatusDisplay('unavailable');
         return statusResponse;
       }
       const status = readOtBridgeStatus(statusResponse);
+      if (['unavailable', 'inconsistent'].includes(status)) recordOtFailure(readOtBridgeErrorCode(statusResponse, 'ot_observer_unavailable'), 'observe');
       if (status) {
         updateOtStatusDisplay(status);
       }
@@ -423,7 +448,7 @@
         return { ok: false, skipped: true, reason: 'project_changed' };
       }
       if (!isSuccessfulOtBridgeResponse(drainResponse)) {
-        otWarmMirrorState.lastErrorCode = readOtBridgeErrorCode(drainResponse, 'drain_ot_events_failed');
+        recordOtFailure(readOtBridgeErrorCode(drainResponse, 'drain_ot_events_failed'), 'observe');
         updateOtStatusDisplay('unavailable');
         return drainResponse;
       }
@@ -433,7 +458,8 @@
       }
       return drainResponse;
     } catch (error) {
-      otWarmMirrorState.lastErrorCode = error?.code || error?.message || 'ot_poll_failed';
+      if (!canPollOtWarmMirror(projectId)) return { ok: false, skipped: true, reason: 'project_changed' };
+      recordOtFailure(error?.code || error?.message || 'ot_poll_failed', 'observe');
       updateOtStatusDisplay('unavailable');
       return { ok: false, error };
     } finally {
@@ -465,12 +491,28 @@
     return typeof value === 'string' ? value : fallback;
   }
 
+  function recordOtFailure(code, phase) {
+    code = otWarmMirrorController.normalizeFailureCode(code);
+    otWarmMirrorState.lastErrorCode = code;
+    otWarmMirrorState.failureActive = true;
+    otWarmMirrorState.lastFailure = { code, phase, at: Date.now() };
+  }
+
   function queueOtPatchEvents(events, projectId = getCurrentProjectId()) {
     if (!Array.isArray(events) || !events.length || !canPollOtWarmMirror(projectId)) {
       return;
     }
     ensureOtWarmMirrorStateProject(projectId);
-    otWarmMirrorState.patchQueue.push(...events);
+    const queued = otWarmMirrorController.queuePatchEvents(otWarmMirrorState.patchQueue, events);
+    if (!queued.ok) {
+      recordOtFailure(queued.reason, 'queue');
+      clearOtEventPolling({ clearPatchQueue: true });
+      otWarmMirrorState.suspended = true;
+      updateOtStatusDisplay('inconsistent');
+      void callPageBridge('stopOtObserver', { projectId }).catch(() => {});
+      return;
+    }
+    otWarmMirrorState.patchQueue = queued.queue;
     scheduleOtPatchFlush(projectId);
   }
 
@@ -510,11 +552,18 @@
       return { ok: false, skipped: true, reason: pause.reason || 'paused' };
     }
 
-    const maxBatch = Math.max(1, Number(otWarmMirrorController?.OT_MAX_PATCH_BATCH) || 25);
-    const batch = otWarmMirrorState.patchQueue.splice(0, maxBatch);
+    let batch = otWarmMirrorController.takePatchBatch(otWarmMirrorState.patchQueue);
     if (!batch.length) {
       return { ok: true, skipped: true, reason: 'empty_batch' };
     }
+    const fresh = otWarmMirrorController.queuePatchEvents([], batch);
+    if (!fresh.ok) {
+      recordOtFailure(fresh.reason, 'queue');
+      clearOtEventPolling({ clearPatchQueue: true });
+      updateOtStatusDisplay('inconsistent');
+      return { ok: false, skipped: true, reason: fresh.reason };
+    }
+    batch = fresh.queue;
 
     otWarmMirrorState.flushing = true;
     try {
@@ -530,46 +579,37 @@
       }
 
       const response = await sendBackgroundNative(request);
+      if (!canPollOtWarmMirror(projectId)) return { ok: false, skipped: true, reason: 'project_changed' };
       if (!response?.ok) {
-        otWarmMirrorState.lastErrorCode = response?.error?.code || response?.error?.message || 'mirror_patch_failed';
+        recordOtFailure(response?.error?.code || 'mirror_patch_failed', 'flush');
         updateOtStatusDisplay('inconsistent');
         return response;
       }
 
-      const result = response.result || {};
-      const skippedFiles = Array.isArray(result?.skippedFiles) ? result.skippedFiles : [];
-      const skippedCount = Number.isFinite(Number(result?.skippedCount))
-        ? Number(result.skippedCount)
-        : skippedFiles.length;
-      if (skippedFiles.length || skippedCount > 0) {
-        otWarmMirrorState.lastErrorCode = 'mirror_patch_skipped';
-        updateOtStatusDisplay('inconsistent');
-        return response;
-      }
-      const appliedFiles = Array.isArray(result?.appliedFiles) ? result.appliedFiles : null;
-      const appliedCount = Number.isFinite(Number(result?.appliedCount))
-        ? Number(result.appliedCount)
-        : NaN;
-      if (!appliedFiles || !Number.isFinite(appliedCount) || appliedCount <= 0 || appliedFiles.length !== appliedCount) {
-        otWarmMirrorState.lastErrorCode = 'mirror_patch_invalid_result';
+      const receipt = otWarmMirrorController.validatePatchReceipt(batch, response.result);
+      if (!receipt.ok) {
+        recordOtFailure(receipt.reason, 'flush');
         updateOtStatusDisplay('inconsistent');
         return response;
       }
 
       otWarmMirrorState.lastPatchAt = Date.now();
       otWarmMirrorState.lastErrorCode = '';
-      if (canPollOtWarmMirror(projectId)) {
+      otWarmMirrorState.failureActive = false;
+      if (canPollOtWarmMirror(projectId) && !getCurrentRunView()) {
         updateOtStatusDisplay('observing');
       }
       return response;
     } catch (error) {
-      otWarmMirrorState.lastErrorCode = error?.code || error?.message || 'mirror_patch_failed';
+      if (!canPollOtWarmMirror(projectId)) return { ok: false, skipped: true, reason: 'project_changed' };
+      recordOtFailure(error?.code || 'mirror_patch_failed', 'flush');
       updateOtStatusDisplay('inconsistent');
       return { ok: false, error };
     } finally {
       otWarmMirrorState.flushing = false;
-      if (otWarmMirrorState.patchQueue.length && canPollOtWarmMirror(projectId) && !getCurrentRunView()) {
-        scheduleOtPatchFlush(projectId, { immediate: true });
+      const nextProjectId = otWarmMirrorState.projectId;
+      if (otWarmMirrorState.patchQueue.length && canPollOtWarmMirror(nextProjectId) && !getCurrentRunView()) {
+        scheduleOtPatchFlush(nextProjectId, { immediate: true });
       }
     }
   }
@@ -612,12 +652,13 @@
   }
 
   function updateOtStatusDisplay(status = currentOtStatus) {
-    const normalized = normalizeOtStatus(status);
+    const normalized = otWarmMirrorState.failureActive && status === 'observing' ? 'inconsistent' : normalizeOtStatus(status);
     currentOtStatus = normalized;
     otWarmMirrorState.lastStatus = normalized;
     const statusElement = getPanel()?.querySelector('[data-ot-status]');
     if (statusElement) {
-      const label = formatOtStatusLabel(normalized);
+      const label = formatOtStatusLabel(normalized) + (otWarmMirrorState.failureActive
+        ? ': ' + tr(otWarmMirrorController.getFailureMessageKey(otWarmMirrorState.lastErrorCode)) : '');
       statusElement.textContent = formatOtToggleStatusText(label);
       statusElement.dataset.otStatus = normalized;
       statusElement.title = formatOtToggleStatusText(label);
@@ -781,38 +822,24 @@
   }
 
   async function resolveWarmRunStart(taskContext = {}) {
+    const projectId = getCurrentProjectId();
     const focusFiles = taskContext.focusFiles || [];
     const mode = taskContext.mode || getState()?.mode;
     const mirrorStatus = await getMirrorFreshness();
+    if (getCurrentProjectId() !== projectId) return { useExistingMirror: false, reason: 'project_changed' };
     const otWarmStart = otWarmMirrorController.canUseOtWarmStart({
-      enabled: isExperimentalOtEnabled(),
+      enabled: isExperimentalOtEnabled() && !otWarmMirrorState.failureActive,
       focusFiles,
       mirrorStatus
     });
-    if (otWarmStart.ok) {
-      return {
-        useExistingMirror: true,
-        warmStart: true,
-        otWarmStart: true,
-        reason: 'ot_focus_fresh',
-        mirrorStatus,
-        focusFiles: otWarmStart.focusFiles,
-        project: {
-          capabilities: {
-            fullProjectSnapshot: false,
-            method: 'ot-warm-mirror'
-          },
-          files: []
-        }
-      };
-    }
-    if (!mirrorStatus?.exists || !isMirrorReusable(mirrorStatus)) {
+    if (!mirrorStatus?.exists || (!otWarmStart.ok && !isMirrorReusable(mirrorStatus))) {
       return { useExistingMirror: false, reason: 'mirror_not_fresh', mirrorStatus };
     }
 
     let overlayProject = null;
     try {
       overlayProject = await callPageBridge('getProjectSnapshot', {
+        projectId,
         force: true,
         maxAgeMs: 0,
         preferLightweight: true,
@@ -826,6 +853,7 @@
     } catch (error) {
       return { useExistingMirror: false, reason: 'overlay_probe_failed', mirrorStatus };
     }
+    if (getCurrentProjectId() !== projectId) return { useExistingMirror: false, reason: 'project_changed' };
     const fileOverlays = buildSnapshotFileOverlays(overlayProject, focusFiles);
     if (!fileOverlays.length) {
       return { useExistingMirror: false, reason: 'missing_current_overlay', mirrorStatus };
@@ -840,7 +868,9 @@
     return {
       useExistingMirror: true,
       warmStart: true,
-      reason: mode === 'ask' ? 'warm_whole_project_ask' : 'warm_whole_project',
+      otWarmStart: otWarmStart.ok,
+      focusFiles,
+      reason: otWarmStart.ok ? 'ot_focus_fresh' : mode === 'ask' ? 'warm_whole_project_ask' : 'warm_whole_project',
       mirrorStatus,
       fileOverlays,
       project: overlayProject
@@ -928,7 +958,7 @@
       return syncOtWarmMirrorController();
     }).catch(error => {
       updateOtStatusDisplay('unavailable');
-      appendPlainLog(tx(`Experimental OT warm mirror unavailable: ${error.message}`, `实验性 OT 预热镜像不可用：${error.message}`));
+      appendPlainLog(tx(`OT warm mirror unavailable: ${error.message}`, `OT 预热镜像不可用：${error.message}`));
     });
   }