codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/content/nativeCompatibilityController.js

@@ -12,27 +12,46 @@
     const tx = options.tx;
     const tr = options.tr;
 
+    let installIdentity = options.getExtensionCompatibilityMetadata?.()?.installIdentity || {};
+    function resolveInstallCommand(compatibility = {}) {
+      const metadata = options.getExtensionCompatibilityMetadata?.() || {};
+      installIdentity = { ...installIdentity, ...(metadata.installIdentity || {}), ...(compatibility.installIdentity || {}) };
+      if (installIdentity.managed) return Compatibility?.buildInstallCommand?.(
+        compatibility.recommendedVersion || Compatibility?.BUILD_TARGET_VERSION,
+        compatibility.native?.platform || compatibility.platform || installIdentity.platform,
+        metadata.extensionId, installIdentity
+      ) || '';
+      return compatibility.updateCommand || compatibility.installCommand || options.installCommand || '';
+    }
+
     function sendNative(payload) {
       return dispatch(payload, 'sendNative');
     }
 
-    function sendBackgroundNative(payload) {
-      return dispatch(payload, 'sendBackgroundNative');
+    function sendBackgroundNative(payload, context = {}) {
+      return dispatch(payload, 'sendBackgroundNative', context);
     }
 
-    async function dispatch(payload, channelMethod) {
-      const compatibilityGate = await ensureForMethod(payload?.method);
-      if (!compatibilityGate.ok) return compatibilityGate.response;
-      // Post-Undo cache bookkeeping must survive the ended run's cancellation.
-      if (gatedMethods.has(payload?.method) && payload.method !== 'mirror.invalidate') {
-        options.throwIfCancellationRequested?.();
+    async function dispatch(payload, channelMethod, context = {}) {
+      let compatibilityGate;
+      try {
+        compatibilityGate = await ensureForMethod(payload?.method, context);
+        if (!compatibilityGate.ok) return compatibilityGate.response;
+        // Post-Undo cache bookkeeping must survive the ended run's cancellation.
+        if (gatedMethods.has(payload?.method) && payload.method !== 'mirror.invalidate') {
+          options.throwIfCancellationRequested?.();
+        }
+        context.assertCurrent?.();
+      } catch (error) {
+        if (context.assertCurrent && error && typeof error === 'object') error.requestDispatched = false;
+        throw error;
       }
       return nativeChannel[channelMethod](
         attachEvidence(payload, compatibilityGate.compatibility)
       );
     }
 
-    async function ensureForMethod(method) {
+    async function ensureForMethod(method, { assertCurrent } = {}) {
       const metadata = options.getExtensionCompatibilityMetadata?.() || {};
       const params = Compatibility?.buildBridgePingParams
         ? Compatibility.buildBridgePingParams(metadata)
@@ -41,9 +60,12 @@
         method: 'bridge.ping',
         params
       });
+      // A retired run must not publish even a compatibility failure into a successor.
+      assertCurrent?.();
       const compatibility = Compatibility?.evaluateNativeCompatibility
         ? Compatibility.evaluateNativeCompatibility(response, metadata)
         : options.fallbackNativeCompatibility(response);
+      const installCommand = resolveInstallCommand(compatibility);
       const allowed = !gatedMethods.has(method) ||
         (Compatibility?.isNativeMethodAllowed
           ? Compatibility.isNativeMethodAllowed(method, compatibility)
@@ -51,14 +73,14 @@
       if (allowed) return { ok: true, compatibility };
 
       const message = formatBlockedMessage(method, compatibility);
-      const installCommand = options.installCommand;
       const error = {
         code: 'native_update_required',
         message,
         status: compatibility.status || 'unknown_native',
         classification: options.getNativeCompatibilityClassification(compatibility),
-        installCommand: compatibility.installCommand || installCommand,
-        updateCommand: compatibility.updateCommand || compatibility.installCommand || installCommand,
+        installIdentity,
+        installCommand,
+        updateCommand: installCommand,
         currentNativeVersion: compatibility.currentNativeVersion
           || compatibility.nativeVersion
           || compatibility.native?.version
@@ -66,7 +88,7 @@
         requiredVersion: compatibility.requiredVersion || Compatibility?.BUILD_TARGET_VERSION || '',
         releaseUrl: compatibility.releaseUrl || ''
       };
-      notifyBlocked(error, compatibility);
+      notifyBlocked(error, compatibility, method);
       return { ok: false, compatibility, response: { ok: false, error } };
     }
 
@@ -81,7 +103,7 @@
       };
     }
 
-    function notifyBlocked(error, compatibility = {}) {
+    function notifyBlocked(error, compatibility = {}, method) {
       const message = error?.message || String(error || '');
       if (options.getCurrentRunView?.()) {
         options.appendRunEvent?.({ title: message, status: 'failed' });
@@ -89,7 +111,17 @@
         return;
       }
       showUpdateGuidance(compatibility);
-      options.showPluginToast?.(message, { status: 'failed', sticky: true });
+      const missing = compatibility.status === 'native_missing';
+      options.showPluginToast?.(missing ? tr('nativeCompatibilityMissingGuidance') : message, {
+        status: 'failed',
+        sticky: true,
+        ...(missing ? {
+          title: tr('nativeCompatibilityMissingTitle'),
+          groupKey: 'native-missing',
+          groupItem: method || 'native request',
+          groupSummary: count => tr('nativeCompatibilityUnavailableFeatures', { count })
+        } : {})
+      });
     }
 
     async function refreshBadge() {
@@ -102,6 +134,7 @@
           : {};
         const response = await sendBackgroundNative({ method: 'bridge.ping', params });
         const compatibility = Compatibility.evaluateNativeCompatibility(response, metadata);
+        resolveInstallCommand(compatibility);
         const classification = options.getNativeCompatibilityClassification(compatibility);
         if (classification === 'compatible') {
           options.setBadge?.(renderer.headerEl, { type: 'none' });
@@ -158,9 +191,7 @@
         || compatibility.nativeVersion
         || native.version
         || tx('missing', '未安装');
-      const command = compatibility.updateCommand
-        || compatibility.installCommand
-        || options.installCommand;
+      const command = resolveInstallCommand(compatibility);
       const releaseUrl = compatibility.releaseUrl || '';
       const overlay = options.document.createElement('div');
       overlay.className = 'codex-plugin-confirm';
@@ -176,11 +207,24 @@
       );
       const card = options.document.createElement('section');
       card.className = 'codex-plugin-confirm-card';
+      const head = options.document.createElement('div');
+      head.className = 'codex-plugin-confirm-head';
+      const icon = options.document.createElement('img');
+      icon.className = 'codex-plugin-confirm-icon';
+      icon.alt = '';
+      icon.setAttribute('aria-hidden', 'true');
+      icon.src = options.getIconUrl?.() || '';
+      const titleWrap = options.document.createElement('div');
+      const brand = options.document.createElement('div');
+      brand.className = 'codex-plugin-confirm-brand';
+      brand.textContent = 'Codex Overleaf Link';
       const title = options.document.createElement('div');
       title.className = 'codex-plugin-confirm-title';
       title.textContent = nativeMissing
         ? tx('One step left: install the native host', '还差一步：安装 Native host')
         : tx('Native host update available', 'Native host 可更新');
+      titleWrap.append(brand, title);
+      head.append(icon, titleWrap);
       const body = options.document.createElement('div');
       body.className = 'codex-plugin-confirm-body';
       body.textContent = [
@@ -193,26 +237,24 @@
             `Extension v${extensionVersion} / Native v${nativeVersion}`,
             `扩展 v${extensionVersion} / Native v${nativeVersion}`
           ),
-        tx(
-          'Run the platform-specific command below, reload the extension, then refresh Overleaf.',
-          '运行下面的平台命令，重新加载扩展，然后刷新 Overleaf。'
-        )
+        !command && installIdentity.managed
+          ? tx('Repair Managed using the original managed root, browser and extension ID with install-managed.',
+            '请使用原管理根目录、浏览器及扩展 ID，通过 install-managed 修复托管安装。')
+          : tx('Run the command below, reload the extension, then refresh Overleaf.', '运行下面的命令，重新加载扩展，然后刷新 Overleaf。')
+            + (installIdentity.managed && (native.platform || installIdentity.platform) === 'win32'
+              ? tx(' Use PowerShell.', ' 请使用 PowerShell。') : '')
       ].join('\n\n');
       const commandCode = options.document.createElement('code');
+      commandCode.className = 'codex-native-guidance-command';
       commandCode.textContent = command;
-      Object.assign(commandCode.style, {
-        display: 'block',
-        whiteSpace: 'pre-wrap',
-        marginTop: '0.75rem'
-      });
       body.append(commandCode);
       if (releaseUrl) {
         const link = options.document.createElement('a');
+        link.className = 'codex-native-guidance-link';
         link.href = releaseUrl;
         link.target = '_blank';
         link.rel = 'noopener noreferrer';
         link.textContent = tx('Open GitHub Release', '打开 GitHub Release');
-        Object.assign(link.style, { display: 'block', marginTop: '0.75rem' });
         body.append(link);
       }
       const actions = options.document.createElement('div');
@@ -221,7 +263,9 @@
       copy.type = 'button';
       copy.className = 'codex-plugin-confirm-confirm';
       copy.textContent = tx('Copy command', '复制命令');
+      copy.disabled = !command;
       copy.addEventListener('click', async () => {
+        if (!command) return;
         await options.navigator.clipboard.writeText(command);
         copy.textContent = tx('Copied', '已复制');
       });
@@ -231,13 +275,13 @@
       close.textContent = tx('Close', '关闭');
       close.addEventListener('click', () => overlay.remove());
       actions.append(close, copy);
-      card.append(title, body, actions);
+      card.append(head, body, actions);
       overlay.append(card);
       overlay.addEventListener('click', event => {
         if (event.target === overlay) overlay.remove();
       });
       panel.append(overlay);
-      copy.focus();
+      (command ? copy : close).focus();
     }
 
     function scheduleFirstUseOnboardingTip() {

package/extension/src/content/otWarmMirror.js

@@ -833,7 +833,7 @@
     if (getCurrentProjectId() !== projectId) return { useExistingMirror: false, reason: 'project_changed' };
     const otWarmStart = otWarmMirrorController.canUseOtWarmStart({
       enabled: isExperimentalOtEnabled() && !otWarmMirrorState.failureActive,
-      focusFiles,
+      focusFiles, focusFilesAreLiteral: true,
       mirrorStatus
     });
     if (!mirrorStatus?.exists || (!otWarmStart.ok && !isMirrorReusable(mirrorStatus))) {
@@ -858,10 +858,9 @@
       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 };
-    }
+    const fileOverlays = buildSnapshotFileOverlays(overlayProject, focusFiles).filter(file =>
+      !otWarmStart.ok || focusFiles.some(path => normalizeSnapshotPath(path) === normalizeSnapshotPath(file.path)));
+    if (!fileOverlays.length) return { useExistingMirror: false, reason: 'missing_current_overlay', mirrorStatus };
     if (focusFiles.length && !focusFiles.every(path => {
       const normalized = normalizeSnapshotPath(path);
       return fileOverlays.some(file => normalizeSnapshotPath(file.path) === normalized);
@@ -896,7 +895,7 @@
         appendLog(tx(`Cannot continue: ${formatProjectSnapshotWarning(warning)}`, `无法继续：${formatProjectSnapshotWarning(warning)}`));
       }
       appendCompletionReport({
-        conclusion: tr('warmMirrorStaleBlockedConclusion'),
+        conclusion: tr('warmMirrorStaleBlockedConclusion'), conclusionKey: 'warm_mirror_stale',
         status: 'blocked',
         operations: [],
         applyResults: [],

package/extension/src/content/otWarmMirrorController.js

@@ -1,10 +1,10 @@
 (function initCodexOverleafOtWarmMirrorController(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('../shared/projectFiles'));
   } else {
-    root.CodexOverleafOtWarmMirrorController = factory();
+    root.CodexOverleafModuleRegistry.define('OtWarmMirrorController', ['ProjectFiles'], factory);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function otWarmMirrorControllerFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function otWarmMirrorControllerFactory(projectFiles) {
   'use strict';
 
   const OT_POLL_INTERVAL_MS = 1000;
@@ -17,6 +17,7 @@
   const OT_MAX_BATCH_BYTES = 2 * 1024 * 1024;
   const encoder = typeof TextEncoder === 'function' ? new TextEncoder() : null;
   const PAUSE_STATES = new Set(['running', 'writing', 'undoing', 'compiling']);
+  const normalizeLiteralPath = projectFiles.normalizeSafeProjectPath;
 
   function buildPatchFilesRequest({ projectId, events, nativeCompatibility } = {}) {
     const files = [];
@@ -24,8 +25,8 @@
       if (files.length >= OT_MAX_PATCH_BATCH) {
         break;
       }
-      const filePath = normalizePath(event?.path);
-      if (!isSafeRelativePath(filePath) || typeof event?.baseHash !== 'string') {
+      const filePath = normalizeLiteralPath(event?.path);
+      if (!filePath || typeof event?.baseHash !== 'string') {
         continue;
       }
       const baseHash = event.baseHash.trim();
@@ -73,7 +74,7 @@
     return { pause: false };
   }
 
-  function canUseOtWarmStart({ enabled, focusFiles, mirrorStatus, now = Date.now() } = {}) {
+  function canUseOtWarmStart({ enabled, focusFiles, focusFilesAreLiteral = false, mirrorStatus, now = Date.now() } = {}) {
     if (!enabled) {
       return { ok: false, reason: 'disabled' };
     }
@@ -82,7 +83,10 @@
     }
     if (mirrorStatus.dirty === true) return { ok: false, reason: 'mirror_dirty' };
 
-    const normalizedFocusFiles = normalizePaths(focusFiles);
+    if (focusFilesAreLiteral === true && Array.isArray(focusFiles) && focusFiles.some(path => !normalizeLiteralPath(path))) {
+      return { ok: false, reason: 'invalid_focus_paths' };
+    }
+    const normalizedFocusFiles = normalizePaths(focusFiles, focusFilesAreLiteral === true);
     if (!normalizedFocusFiles.length) {
       return { ok: false, reason: 'no_focus_files' };
     }
@@ -94,7 +98,7 @@
       }
       const age = now - Date.parse(file.observedAt ?? file.lastPatchAt ?? '');
       if (!Number.isFinite(age) || age < 0 || age > OT_FRESHNESS_MAX_AGE_MS) continue;
-      const filePath = normalizePath(file.path);
+      const filePath = normalizeLiteralPath(file.path);
       if (filePath) {
         freshFiles.add(filePath);
       }
@@ -124,9 +128,9 @@
     let bytes = next.reduce((sum, event) => sum + patchBytes(event), 0);
     if (next.length > OT_MAX_PENDING_EVENTS || bytes > OT_MAX_PENDING_BYTES) return { ok: false, reason: 'ot_queue_limit' };
     for (const input of events) {
-      const path = normalizePath(input?.path);
+      const path = normalizeLiteralPath(input?.path);
       const time = typeof input?.observedAt === 'number' ? input.observedAt : Date.parse(input?.observedAt || '');
-      if (!isSafeRelativePath(path) || path.length > 1024 || typeof input?.nextContent !== 'string' ||
+      if (!path || path.length > 1024 || typeof input?.nextContent !== 'string' ||
           typeof input.baseHash !== 'string' || !input.baseHash || input.baseHash.length > 128) {
         return { ok: false, reason: 'ot_event_invalid' };
       }
@@ -165,7 +169,7 @@
     }
     if (!events.length || Number(result.appliedCount) !== events.length || !Array.isArray(result.appliedFiles) ||
         result.appliedFiles.length !== events.length || !result.appliedFiles.every((file, index) =>
-          normalizePath(file?.path) === events[index].path && (!events[index].nextHash || file.hash === events[index].nextHash))) {
+          normalizeLiteralPath(file?.path) === events[index].path && (!events[index].nextHash || file.hash === events[index].nextHash))) {
       return { ok: false, reason: 'mirror_patch_invalid_result' };
     }
     if (events.some(event => { const time = Date.parse(event.observedAt);
@@ -220,11 +224,11 @@
       .replace(/^\/+/, '');
   }
 
-  function normalizePaths(value) {
+  function normalizePaths(value, literal = false) {
     const seen = new Set();
     const paths = [];
     for (const item of Array.isArray(value) ? value : []) {
-      const filePath = normalizePath(item);
+      const filePath = literal ? normalizeLiteralPath(item) : normalizePath(item);
       if (!filePath || seen.has(filePath)) {
         continue;
       }
@@ -234,13 +238,6 @@
     return paths;
   }
 
-  function isSafeRelativePath(filePath) {
-    if (!filePath) {
-      return false;
-    }
-    return !filePath.split('/').some(part => part === '.' || part === '..');
-  }
-
   function isPrimitiveMetadata(value) {
     return ['string', 'number', 'boolean'].includes(typeof value);
   }

package/extension/src/content/pageBridgeClient.js

@@ -6,7 +6,7 @@
   'use strict';
 
   const PAGE_WORLD_SCRIPTS = Object.freeze([
-    ['src/shared/reviewing.js', 'codex-overleaf-reviewing-script'],
+    ['src/shared/reviewing.js', 'codex-overleaf-reviewing-script', true],
     ['src/shared/projectFiles.js', 'codex-overleaf-project-files-script'],
     ['src/shared/compatibility.js', 'codex-overleaf-compatibility-page-script'],
     ['src/shared/pageRpcContract.js', 'codex-overleaf-page-rpc-contract-script', true],
@@ -15,20 +15,23 @@
     ['src/shared/sensitiveScan.js', 'codex-overleaf-sensitive-scan-script'],
     ['src/shared/auditRecords.js', 'codex-overleaf-audit-records-script'],
     ['src/page/saveState.js', 'codex-overleaf-save-state-script', true],
-    ['src/page/overleafCapabilities.js', 'codex-overleaf-capabilities-script'],
+    ['src/page/overleafCapabilities.js', 'codex-overleaf-capabilities-script', true],
     ['src/page/compileBridge.js', 'codex-overleaf-compile-bridge-script'],
     ['src/page/overleafEditor.js', 'codex-overleaf-editor-script'],
     ['src/page/overleafProjectSnapshot.js', 'codex-overleaf-project-snapshot-script'],
     ['src/page/pageBridgeCapability.js', 'codex-overleaf-page-bridge-capability-script'],
     ['src/page/treeOperations.js', 'codex-overleaf-tree-operations-script', true],
+    ['src/page/ownedDirectoryCleanup.js', 'codex-overleaf-owned-directory-cleanup-script', true],
     ['src/page/textFileCreator.js', 'codex-overleaf-text-file-creator-script', true],
     ['src/page/binaryAssetUploader.js', 'codex-overleaf-binary-asset-uploader-script', true],
     ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
     ['src/page/referenceProjects.js', 'codex-overleaf-reference-projects-script', true],
+    ['src/page/fileMover.js', 'codex-overleaf-file-mover-script', true],
     ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
     ['src/page/trackedChangeOwnership.js', 'codex-overleaf-tracked-change-ownership-script', true],
     ['src/page/trackedChangeCapture.js', 'codex-overleaf-tracked-change-capture-script', true],
     ['src/page/trackedChangeReplay.js', 'codex-overleaf-tracked-change-replay-script', true],
+    ['src/page/reviewContext.js', 'codex-overleaf-review-context-script', true],
     ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],
     ['src/page/writebackRouter.js', 'codex-overleaf-writeback-router-script', true],
     ['src/page/writebackReceiptJournal.js', 'codex-overleaf-writeback-receipt-script', true],
@@ -75,6 +78,11 @@
         const requestTimeoutMs = Number.isFinite(Number(policy.timeoutMs))
           ? Number(policy.timeoutMs)
           : Contract.resolveTimeoutMs(method, timeoutOverrides);
+        // Review preparation and its nested writes share the transport budget.
+        if (Contract.getMethod(method)?.timeoutClass === 'lifecycle') {
+          params = { ...params, deadlineAt: params?.deadlineAt == null ? now() + requestTimeoutMs
+            : Number.isFinite(params.deadlineAt) ? Math.min(params.deadlineAt, now() + requestTimeoutMs) : params.deadlineAt };
+        }
         const remainingMs = params?.deadlineAt == null ? Infinity
           : Number.isFinite(params.deadlineAt) ? params.deadlineAt - now() : 0;
         if (remainingMs <= 0) {
@@ -84,7 +92,7 @@
         }
         const timeoutMs = Math.min(requestTimeoutMs, remainingMs);
         const cancellable = policy.cancellation === 'content_abort';
-        let settled = false;
+        let settled = false, dispatched = false;
         let timeout = null;
         function cleanup() {
           if (timeout !== null) windowRef.clearTimeout(timeout);
@@ -107,8 +115,13 @@
           const error = new Error('Codex run was cancelled by the user');
           error.code = 'codex_cancelled';
           error.cancelled = true;
+          error.requestDispatched = dispatched;
+          error.changedDocument = dispatched && Contract.getMethod(method)?.mutation === 'document';
+          if (dispatched && method === 'applyOperations') { error.requestId = id; error.rpcMethod = method; }
           rejectOnce(error);
         }
+        // Cancellation stops new requests; receipt settlement has its own non-cancellable policy.
+        if (cancellable && options.isCancellationRequested?.()) { cancelRequest(); return; }
         timeout = windowRef.setTimeout(() => {
           resolveOnce({ ok: false, error: 'Page bridge timed out',
             ...(method === 'applyOperations' ? { code: 'page_bridge_timeout', rpcMethod: method, requestId: id } : {}) });
@@ -126,11 +139,11 @@
         }
         if (cancellable) {
           activeCancellationHandlers.set(id, cancelRequest);
-          if (options.isCancellationRequested?.()) windowRef.queueMicrotask(cancelRequest);
         }
         windowRef.addEventListener('message', onMessage);
         // Every low-level request remains one attempt. Higher layers must opt
         // into replay so a document mutation is never duplicated implicitly.
+        dispatched = true;
         windowRef.postMessage({
           source: 'codex-overleaf/content',
           id,

package/extension/src/content/panelMaintenance.js

@@ -24,6 +24,7 @@
       openCustomInstructionsSettings,
       onHistoryRowJump,
       resetProjectNameCache,
+      clearHistoryComposer,
       getPanel,
       getState,
       setState,
@@ -110,27 +111,54 @@
     if (!confirmed) {
       return;
     }
+    if (getCurrentRunView()) {
+      showPluginToast(tx('A run started while confirmation was open. Finish or cancel it before clearing history.', '确认期间有任务开始运行，请先完成或取消任务后再清理历史。'));
+      return;
+    }
+    let historyClearedAt;
     try {
-      await StorageDb?.clearAllStores?.();
+      await StorageDb.clearAllStores();
+      historyClearedAt = Date.now();
       historyView.invalidate();
-      // v1.8.1: the dashboard's project-name cache lives in
-      // chrome.storage.local, outside the IndexedDB stores — clear it too so
-      // no (potentially sensitive) project titles outlive the wipe.
-      await resetProjectNameCache?.();
     } catch (error) {
       showPluginToast(tx(`Could not clear history: ${error.message}`, `清空历史失败：${error.message}`));
       return;
     }
-    // Reset the in-getPanel() getState() to match the emptied store and re-render
-    // EXPLICITLY. startNewSession() is unusable here: its empty-session reuse
-    // guard matches the fresh session that normalization mints and returns
-    // before applyStateToPanel(), leaving the deleted cards on screen.
-    setState(normalizePanelState({ ...getState(), sessions: [], runs: [], activeSessionId: '' }));
-    await saveState();
+    const cleanupErrors = [];
+    try {
+      // Project names live outside the history store. Failure here must not
+      // leave deleted history in memory for a later autosave to replay.
+      await resetProjectNameCache?.();
+    } catch (error) {
+      cleanupErrors.push(error.message);
+    }
+    // Clear the compatibility mirror as well as the session list; otherwise
+    // normalization can reconstruct old summary runs and the Native thread.
+    const clearedState = normalizePanelState({
+      ...getState(), session: null, sessions: [], runs: [], activeSessionId: '',
+      task: '', focusFiles: [], selectionContext: null, composerAttachments: []
+    });
+    const freshSession = clearedState.sessions[0];
+    // The shared store rejects createdAt <= its clear marker. A new session
+    // in the same millisecond needs the next tick, at most 1 ms ahead of now.
+    freshSession.createdAt = freshSession.updatedAt = new Date(Math.max(Date.now(), historyClearedAt + 1)).toISOString();
+    setState(clearedState);
+    try {
+      clearHistoryComposer?.();
+      if (await saveState({ requireDurable: true }) !== true) {
+        throw new Error(tx('The blank session save was not confirmed.', '空白会话的保存结果尚未确认。'));
+      }
+    } catch (error) {
+      cleanupErrors.push(error.message);
+    }
+    // The store has already been cleared, including when the fresh-session
+    // save fails. Always remove old cards and draft inputs from the panel.
     applyStateToPanel();
     refreshStorageUsageSummary();
     void renderAuditHistoryPanel();
-    showPluginToast(tx('Local history cleared. Overleaf files are unchanged.', '本地历史已清理，Overleaf 文件保持不变。'));
+    showPluginToast(cleanupErrors.length
+      ? tx(`Saved history was removed, but cleanup or blank-session saving needs attention: ${cleanupErrors.join('; ')}`, `已删除保存的历史，但清理或空白会话保存仍有问题：${cleanupErrors.join('；')}`)
+      : tx('Local history cleared. Overleaf files are unchanged.', '本地历史已清理，Overleaf 文件保持不变。'));
     getPanel()?.querySelector('[data-task]')?.focus();
   }
 
@@ -153,6 +181,7 @@
   // the failed task usually needs a tweak before it is worth resending.
   function refillComposerForRetry(run, textOverride) {
     const input = getPanel()?.querySelector('[data-task]');
+    if (input?.readOnly) return;
     const task = typeof textOverride === 'string' && textOverride.trim()
       ? textOverride
       : String(run?.task || '');
@@ -282,7 +311,9 @@
   // Settings history card, expanded and loaded.
   function openChangeHistory() {
     openCustomInstructionsSettings();
-    const card = getSettingsPanelInstance()?.container?.querySelector('[data-history-card]');
+    // The workbench shows one page at a time; switch to the page holding the card.
+    const card = getSettingsPanelInstance()?.revealGroup?.('history')
+      || getSettingsPanelInstance()?.container?.querySelector('[data-history-card]');
     if (card) {
       if (!card.open) {
         card.open = true;
@@ -294,7 +325,8 @@
 
   function openStorageSettings() {
     openCustomInstructionsSettings();
-    const card = getPanel()?.querySelector('[data-storage-card]');
+    const card = getSettingsPanelInstance()?.revealGroup?.('storage')
+      || getPanel()?.querySelector('[data-storage-card]');
     if (card) {
       card.open = true;
       card.scrollIntoView({ block: 'center' });