codex-overleaf-link 2.3.1 → 2.3.2

package/extension/src/page/binaryAssetUploader.js

@@ -0,0 +1,343 @@
+(function initCodexOverleafBinaryAssetUploader(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafBinaryAssetUploader = api;
+})(typeof window !== 'undefined' ? window : globalThis, function binaryAssetUploaderFactory() {
+  'use strict';
+
+  const MAX_ASSET_BYTES = 10 * 1024 * 1024;
+
+  function create(deps = {}) {
+    const windowRef = deps.window || globalThis.window;
+    const documentRef = deps.document || windowRef?.document;
+    const treeOperations = deps.treeOperations;
+    const snapshotRouter = deps.snapshotRouter;
+    const transfers = new Map();
+
+    function begin(params = {}) {
+      let transferId;
+      let projectPath;
+      try {
+        transferId = cleanTransferId(params.transferId);
+        projectPath = normalizePath(params.path);
+      } catch (error) {
+        return failure('binary_asset_path_invalid', error.message);
+      }
+      const size = Number(params.size);
+      if (!Number.isSafeInteger(size) || size < 0 || size > MAX_ASSET_BYTES) {
+        return failure('binary_asset_size_invalid', 'Asset size is invalid or exceeds 10 MiB.');
+      }
+      if (!/^[a-f0-9]{64}$/i.test(String(params.sha256 || ''))) {
+        return failure('binary_asset_hash_invalid', 'Asset SHA-256 is missing or invalid.');
+      }
+      transfers.set(transferId, {
+        id: transferId,
+        path: projectPath,
+        size,
+        sha256: String(params.sha256).toLowerCase(),
+        mimeType: String(params.mimeType || 'application/octet-stream'),
+        overwrite: params.overwrite === true,
+        chunks: [],
+        received: 0
+      });
+      return { ok: true, transferId };
+    }
+
+    function append(params = {}) {
+      const transfer = transfers.get(String(params.transferId || ''));
+      if (!transfer) return failure('binary_upload_transfer_missing', 'Asset upload transfer was not found.');
+      if (Number(params.offset) !== transfer.received) {
+        return failure('binary_upload_chunk_order_invalid', 'Asset chunks arrived out of order.');
+      }
+      let bytes;
+      try { bytes = decodeBase64(params.contentBase64, windowRef); } catch (_error) {
+        return failure('binary_upload_chunk_invalid', 'Asset chunk is not valid Base64.');
+      }
+      if (transfer.received + bytes.length > transfer.size) {
+        return failure('binary_upload_size_mismatch', 'Asset chunks exceed the declared size.');
+      }
+      transfer.chunks.push(bytes);
+      transfer.received += bytes.length;
+      return { ok: true, transferId: transfer.id, received: transfer.received };
+    }
+
+    async function commit(params = {}) {
+      const transferId = String(params.transferId || '');
+      const transfer = transfers.get(transferId);
+      if (!transfer) return failure('binary_upload_transfer_missing', 'Asset upload transfer was not found.');
+      try {
+        if (transfer.received !== transfer.size) return failure('binary_upload_incomplete', 'Asset upload is incomplete.');
+        const bytes = joinChunks(transfer.chunks, transfer.size);
+        const digest = await sha256Hex(bytes, windowRef.crypto);
+        if (digest !== transfer.sha256) {
+          return failure('binary_upload_checksum_mismatch', 'Asset checksum did not match the Native Host descriptor.');
+        }
+        const fileName = transfer.path.split('/').pop();
+        const file = new windowRef.File([bytes], fileName, { type: transfer.mimeType });
+        const attempts = [
+          // Prefer Overleaf's visible uploader. Its UI contract is more
+          // stable than the private multipart endpoint across deployments.
+          () => uploadWithDom(file, transfer),
+          () => uploadWithMultipart(file, transfer),
+          () => uploadWithLegacyManager(file, transfer)
+        ];
+        const errors = [];
+        for (const attempt of attempts) {
+          try {
+            const result = await attempt();
+            const observed = result?.ok ? await waitForPath(transfer.path, 12000) : null;
+            const hashVerified = observed ? await verifyRemoteHash(observed, transfer).catch(() => false) : false;
+            const overwriteVerified = !transfer.overwrite || hashVerified || result?.confirmedByTransport === true;
+            if (result?.ok && observed && overwriteVerified) {
+              return { ok: true, written: true, path: transfer.path, method: result.method, changedDocument: true };
+            }
+            if (result?.ok && observed && !overwriteVerified) errors.push('Overleaf did not expose enough evidence to verify the binary replacement.');
+            if (result?.reason) errors.push(result.reason);
+          } catch (error) {
+            errors.push(error.message);
+          }
+        }
+        return failure('binary_upload_unavailable', errors.filter(Boolean).join('; ') || 'No supported Overleaf asset upload path succeeded.');
+      } finally {
+        transfers.delete(transferId);
+      }
+    }
+
+    function abort(params = {}) {
+      return { ok: true, aborted: transfers.delete(String(params.transferId || '')) };
+    }
+
+    async function uploadWithMultipart(file, transfer) {
+      const projectId = treeOperations.getProjectId();
+      if (!projectId || typeof windowRef.fetch !== 'function') return { ok: false, reason: 'Project upload endpoint is unavailable.' };
+      const parentPath = transfer.path.split('/').slice(0, -1).join('/');
+      const folderId = await findFolderId(parentPath);
+      if (parentPath && !folderId) return { ok: false, reason: 'Target folder id is unavailable for direct upload.' };
+      const form = new windowRef.FormData();
+      form.append('qqfile', file, file.name);
+      form.append('name', file.name);
+      if (folderId) form.append('folder_id', folderId);
+      const csrf = findCsrfToken();
+      const headers = csrf ? { 'X-CSRF-Token': csrf } : {};
+      const query = folderId ? `?folder_id=${encodeURIComponent(folderId)}` : '';
+      const response = await windowRef.fetch(`/project/${encodeURIComponent(projectId)}/upload${query}`, {
+        method: 'POST', body: form, credentials: 'same-origin', headers
+      });
+      const responseText = await response.text();
+      if (!response.ok) throw new Error(formatUploadHttpError(response.status, responseText));
+      try {
+        const payload = responseText ? JSON.parse(responseText) : null;
+        if (payload && (payload.success === false || payload.ok === false || payload.error)) {
+          throw new Error(payload.error?.message || payload.error || payload.message || 'Overleaf rejected the asset upload.');
+        }
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          // Some Overleaf deployments return an empty or HTML success body.
+        } else {
+          throw error;
+        }
+      }
+      return { ok: true, method: 'overleaf.multipart', confirmedByTransport: true };
+    }
+
+    async function uploadWithDom(file, transfer) {
+      const parentPath = transfer.path.split('/').slice(0, -1).join('/');
+      if (parentPath) {
+        const folderNode = treeOperations.findFileTreeNode(parentPath);
+        if (!folderNode) return { ok: false, reason: `Target folder ${parentPath} is unavailable in the Overleaf file tree.` };
+        folderNode?.dispatchEvent(new windowRef.MouseEvent('click', { bubbles: true }));
+        await delay(120);
+      }
+      let input = findFileInput();
+      if (!input) {
+        const button = findUploadButton();
+        if (!button) return { ok: false, reason: 'Overleaf upload button was not found.' };
+        button.click();
+        input = await waitForFileInput(4000);
+      }
+      if (!input) return { ok: false, reason: 'Overleaf upload file input was not found.' };
+      const data = new windowRef.DataTransfer();
+      data.items.add(file);
+      assignFilesToInput(input, data.files, windowRef);
+      input.dispatchEvent(new windowRef.Event('input', { bubbles: true }));
+      input.dispatchEvent(new windowRef.Event('change', { bubbles: true }));
+      await clickReplaceIfShown();
+      return { ok: true, method: 'overleaf.file-input' };
+    }
+
+    async function uploadWithLegacyManager(file, transfer) {
+      const manager = treeOperations.findFileTreeManager();
+      if (!manager) return { ok: false, reason: 'Legacy file-tree manager is unavailable.' };
+      for (const name of ['uploadFile', 'uploadAsset', 'createBinaryFile', 'createFile', 'addFile']) {
+        if (typeof manager[name] !== 'function') continue;
+        try {
+          await manager[name](transfer.path, file);
+          return { ok: true, method: `fileTreeManager.${name}`, confirmedByTransport: true };
+        } catch (_error) { /* try the next adapter */ }
+      }
+      return { ok: false, reason: 'Legacy file-tree manager has no compatible asset method.' };
+    }
+
+    async function findFolderId(parentPath) {
+      const node = parentPath ? treeOperations.findFileTreeNode(parentPath) : null;
+      const element = node?.closest?.('[data-entity-id], [data-folder-id], [data-id]') || node;
+      const domId = element?.dataset?.entityId || element?.dataset?.folderId || element?.dataset?.id;
+      if (domId) return domId;
+      for (const root of [windowRef._ide, windowRef.Overleaf, windowRef.overleaf, windowRef.OL]) {
+        const folder = root?.project?.rootFolder?.[0] || root?.project?.rootFolder || root?.rootFolder?.[0] || root?.rootFolder;
+        if (!parentPath && (folder?._id || folder?.id)) return folder._id || folder.id;
+      }
+      try {
+        const list = await snapshotRouter?.buildProjectFileList({
+          force: true, maxAgeMs: 0, preferLightweight: true, allowZipFallback: false
+        });
+        const folder = (list?.files || []).find(item => item.path === parentPath && /folder/i.test(item.kind || item.type || ''));
+        if (folder) return folder.id || folder._id || folder.entityId || '';
+      } catch (_error) { /* DOM and legacy adapters remain available */ }
+      return '';
+    }
+
+    function findCsrfToken() {
+      return documentRef.querySelector('meta[name="ol-csrfToken"], meta[name="csrf-token"], meta[name="_csrf"]')?.content
+        || windowRef.csrfToken || windowRef._csrf || '';
+    }
+    function findFileInput() {
+      return chooseOverleafFileInput(Array.from(documentRef.querySelectorAll('input[type="file"]')));
+    }
+    function findUploadButton() {
+      return chooseOverleafUploadButton(Array.from(documentRef.querySelectorAll('button, [role="button"]')));
+    }
+    function chooseOverleafUploadButton(nodes) {
+      return nodes.filter(node => {
+        if (!node || node.disabled || isCodexOwnedNode(node)) return false;
+        const label = `${node.getAttribute('aria-label') || ''} ${node.getAttribute('title') || ''} ${node.textContent || ''}`;
+        return /upload|上传/i.test(label);
+      }).sort((left, right) => uploadButtonScore(right) - uploadButtonScore(left))[0] || null;
+    }
+    async function waitForFileInput(timeoutMs) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const input = findFileInput();
+        if (input) return input;
+        await delay(50);
+      }
+      return null;
+    }
+    async function clickReplaceIfShown() {
+      await delay(180);
+      const button = Array.from(documentRef.querySelectorAll('button')).find(node => /replace|overwrite|替换|覆盖/i.test(node.textContent || ''));
+      if (button) button.click();
+    }
+    async function waitForPath(projectPath, timeoutMs) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        if (treeOperations.projectPathExists(projectPath)) {
+          const node = treeOperations.findFileTreeNode(projectPath);
+          return {
+            path: projectPath,
+            id: node?.dataset?.entityId || node?.dataset?.fileId || node?.dataset?.id || ''
+          };
+        }
+        await delay(250);
+        try {
+          const list = await snapshotRouter?.buildProjectFileList({
+            force: true, maxAgeMs: 0, preferLightweight: true, allowZipFallback: false
+          });
+          const file = (list?.files || []).find(item => item.path === projectPath);
+          if (file) return file;
+        } catch (_error) { /* continue until the deadline */ }
+      }
+      return null;
+    }
+    async function verifyRemoteHash(observed, transfer) {
+      const fileId = observed?.id || observed?._id || observed?.entityId || observed?.fileId || '';
+      const projectId = treeOperations.getProjectId();
+      if (!fileId || !projectId || typeof windowRef.fetch !== 'function') return false;
+      const response = await windowRef.fetch(`/project/${encodeURIComponent(projectId)}/file/${encodeURIComponent(fileId)}`, {
+        credentials: 'same-origin', cache: 'no-store'
+      });
+      if (!response.ok) return false;
+      const digest = await sha256Hex(new Uint8Array(await response.arrayBuffer()), windowRef.crypto);
+      return digest === transfer.sha256;
+    }
+    function delay(ms) { return new Promise(resolve => windowRef.setTimeout(resolve, ms)); }
+    return { abort, append, begin, commit };
+  }
+
+  function normalizePath(value) {
+    const path = String(value || '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+    if (!path || path.split('/').some(part => !part || part === '.' || part === '..')) throw new Error('Asset path is invalid.');
+    return path;
+  }
+  function cleanTransferId(value) {
+    const id = String(value || '');
+    if (!/^[a-zA-Z0-9_-]{8,120}$/.test(id)) throw new Error('Asset transfer id is invalid.');
+    return id;
+  }
+  function chooseOverleafFileInput(inputs) {
+    return Array.from(inputs || [])
+      .filter(input => input && !input.disabled && !isCodexOwnedNode(input))
+      .sort((left, right) => uploadInputScore(right) - uploadInputScore(left))[0] || null;
+  }
+  function isCodexOwnedNode(node) {
+    return Boolean(node?.closest?.('#codex-overleaf-panel, [data-codex-overleaf-root], .codex-overleaf-panel'));
+  }
+  function uploadInputScore(input) {
+    let score = 0;
+    if (input?.closest?.('.uppy-Dashboard, [data-uppy-drag-drop-supported]')) score += 100;
+    if (input?.closest?.('[role="dialog"], .modal')) score += 40;
+    if (/uppy|upload/i.test(`${input?.className || ''} ${input?.getAttribute?.('data-testid') || ''}`)) score += 30;
+    if (input?.multiple) score += 10;
+    if (input?.isConnected !== false) score += 1;
+    return score;
+  }
+  function uploadButtonScore(node) {
+    let score = 0;
+    const label = `${node?.getAttribute?.('aria-label') || ''} ${node?.getAttribute?.('title') || ''} ${node?.textContent || ''}`.trim();
+    if (/^(upload|上传)$/i.test(label)) score += 50;
+    if (node?.closest?.('[data-testid*="file-tree"], .file-tree, .ide-react-file-tree')) score += 30;
+    if (node?.isConnected !== false) score += 1;
+    return score;
+  }
+  function assignFilesToInput(input, files, windowRef) {
+    const prototype = windowRef?.HTMLInputElement?.prototype;
+    const setter = prototype && Object.getOwnPropertyDescriptor(prototype, 'files')?.set;
+    if (setter) {
+      setter.call(input, files);
+      return;
+    }
+    Object.defineProperty(input, 'files', { configurable: true, value: files });
+  }
+  function formatUploadHttpError(status, responseText) {
+    const detail = summarizeUploadResponse(responseText);
+    return `Overleaf upload endpoint returned HTTP ${status}${detail ? ` (${detail})` : ''}.`;
+  }
+  function summarizeUploadResponse(value) {
+    const text = String(value || '').trim();
+    if (!text || /^\s*</.test(text)) return '';
+    let message = text;
+    try {
+      const payload = JSON.parse(text);
+      message = payload?.error?.message || payload?.error || payload?.message || text;
+    } catch (_error) { /* use the bounded plain-text response */ }
+    return String(message || '').replace(/\s+/g, ' ').slice(0, 240);
+  }
+  function decodeBase64(value, windowRef) {
+    const binary = windowRef.atob(String(value || ''));
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return bytes;
+  }
+  function joinChunks(chunks, size) {
+    const output = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) { output.set(chunk, offset); offset += chunk.length; }
+    return output;
+  }
+  async function sha256Hex(bytes, cryptoImpl) {
+    const digest = await cryptoImpl.subtle.digest('SHA-256', bytes);
+    return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
+  }
+  function failure(code, reason) { return { ok: false, code, reason, changedDocument: false }; }
+  return { chooseOverleafFileInput, create, formatUploadHttpError, joinChunks, normalizePath };
+});

package/extension/src/page/trackedChangesLifecycle.js

@@ -1498,6 +1498,8 @@
       '[data-track-change-id]',
       '[data-ol-change-id]',
       '[data-path][class*="change" i]',
+      '.ol-cm-change',
+      '.review-panel-entry-change',
       '[class*="track-change" i]',
       '[class*="review-change" i]',
       '[class*="suggest" i]',

package/extension/src/pageBridge.js

@@ -22,6 +22,7 @@
   let projectSnapshotBridge = null;
   let writebackRouter = null;
   let writeGuard = null;
+  let binaryAssetUploader = null;
   const saveState = requirePageModule('CodexOverleafSaveState').create({
     delay,
     detectEditor,
@@ -66,6 +67,12 @@
     treeOperations,
     window
   });
+  binaryAssetUploader = requirePageModule('CodexOverleafBinaryAssetUploader').create({
+    document,
+    snapshotRouter,
+    treeOperations,
+    window
+  });
   writeGuard = requirePageModule('CodexOverleafWriteGuard').create({
     document,
     treeOperations,
@@ -207,6 +214,10 @@
         requireEditing: params.requireEditing === true,
         runProjectId: typeof params.runProjectId === 'string' ? params.runProjectId : ''
       }),
+    binaryUploadBegin: params => binaryAssetUploader.begin(params),
+    binaryUploadAppend: params => binaryAssetUploader.append(params),
+    binaryUploadCommit: params => binaryAssetUploader.commit(params),
+    binaryUploadAbort: params => binaryAssetUploader.abort(params),
     jumpToPosition,
     rejectTrackedChanges,
     acceptTrackedChanges,
@@ -613,7 +624,7 @@
       return range;
     }
 
-    const focused = editorAdapter.focusActiveEditorRange(range.from, range.to);
+    let focused = editorAdapter.focusActiveEditorRange(range.from, range.to);
     if (!focused.ok) {
       return {
         ...focused,
@@ -621,6 +632,24 @@
       };
     }
 
+    if (params.line !== undefined) {
+      // Overleaf can publish the new file path and text before its unstable
+      // store swaps in the final CodeMirror view. Re-resolve the editor after
+      // two short settlement windows so a first dispatch to the retiring view
+      // cannot leave the visible cursor at its old line. Repeating an already
+      // successful selection is idempotent.
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        await delay(120);
+        if (getActiveFilePath() !== filePath) {
+          break;
+        }
+        const settled = editorAdapter.focusActiveEditorRange(range.from, range.to);
+        if (settled.ok) {
+          focused = settled;
+        }
+      }
+    }
+
     return {
       ok: true,
       method: focused.method,

package/extension/src/shared/compatibility.js

@@ -12,7 +12,7 @@
   const MIN_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_EXTENSION_VERSION = '1.0.0';
-  const BUILD_TARGET_VERSION = '2.3.1';
+  const BUILD_TARGET_VERSION = '2.3.2';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',
@@ -26,7 +26,9 @@
     'historyClearPlugin',
     'localSkills',
     'mirrorSensitiveScan',
-    'providerProfiles'
+    'providerProfiles',
+    'assetTransfer',
+    'threadFork'
   ]);
   const UPDATE_AVAILABLE_CAPABILITIES = Object.freeze([
     'bridgePing',

package/extension/src/shared/i18n.js

@@ -94,6 +94,14 @@
       deleteSessionHistoryFailedToast: 'Deleted this plugin session, but the matching plugin-local Codex thread history was not fully cleared: {message}',
       deleteSessionNoThreadToast: 'Deleted this plugin session. This old session had no identifiable local Codex thread history, so no local history was cleared.',
       deleteSessionDoneToast: 'Deleted this plugin session.',
+      forkRunTitle: 'Fork a new conversation from this turn',
+      forkRunUnavailable: 'This turn cannot be forked because its Codex thread position is unavailable.',
+      forkRunFailed: 'Could not fork this conversation.',
+      forkRunDone: 'Forked conversation created.',
+      forkSessionTitle: '{title} (fork)',
+      copyConclusionTitle: 'Copy conclusion',
+      copyConclusionDone: 'Conclusion copied',
+      copyConclusionFailed: 'Could not copy conclusion',
       modeSwitchFailedToast: 'Could not switch mode: {message}',
       diffAccepted: 'Accepted',
       diffRejected: 'Rejected',
@@ -606,6 +614,14 @@
       deleteSessionHistoryFailedToast: '已删除这个插件会话，但对应的插件本地 Codex 线程历史没有清理完成：{message}',
       deleteSessionNoThreadToast: '已删除这个插件会话；这个旧会话没有可识别的本地 Codex 线程历史，未清理本地历史。',
       deleteSessionDoneToast: '已删除这个插件会话。',
+      forkRunTitle: '从此轮分叉一个新对话',
+      forkRunUnavailable: '该轮缺少可定位的 Codex thread 节点，无法分叉。',
+      forkRunFailed: '无法分叉此对话。',
+      forkRunDone: '已创建分叉对话。',
+      forkSessionTitle: '{title}（分叉）',
+      copyConclusionTitle: '复制结论',
+      copyConclusionDone: '已复制结论',
+      copyConclusionFailed: '无法复制结论',
       modeSwitchFailedToast: '切换模式失败：{message}',
       diffAccepted: '已接受',
       diffRejected: '已拒绝',

package/extension/src/shared/models.js

@@ -62,13 +62,13 @@
     const normalized = {
       id,
       label,
-      reasoningEfforts: Array.isArray(model?.reasoningEfforts) ? model.reasoningEfforts.slice() : [],
+      reasoningEfforts: normalizeReasoningEfforts(model?.reasoningEfforts),
       reasoningPresentation: typeof model?.reasoningPresentation === 'string' ? model.reasoningPresentation : '',
       speedTiers: normalizeSpeedTiers(model?.speedTiers)
     };
 
     if (Object.prototype.hasOwnProperty.call(Object(model), 'defaultReasoningEffort')) {
-      normalized.defaultReasoningEffort = model.defaultReasoningEffort;
+      normalized.defaultReasoningEffort = normalizeReasoningEffort(model.defaultReasoningEffort);
     }
     if (Object.prototype.hasOwnProperty.call(Object(model), 'defaultSpeedTier')) {
       normalized.defaultSpeedTier = model.defaultSpeedTier;
@@ -77,6 +77,17 @@
     return normalized;
   }
 
+  function normalizeReasoningEfforts(reasoningEfforts) {
+    if (!Array.isArray(reasoningEfforts)) {
+      return [];
+    }
+    return Array.from(new Set(reasoningEfforts.map(normalizeReasoningEffort).filter(Boolean)));
+  }
+
+  function normalizeReasoningEffort(reasoningEffort) {
+    return normalizeModelId(reasoningEffort);
+  }
+
   function normalizeSpeedTiers(speedTiers) {
     if (!Array.isArray(speedTiers)) {
       return ['standard'];

package/extension/src/shared/pageRpcContract.js

@@ -5,7 +5,7 @@
 })(typeof window !== 'undefined' ? window : (typeof globalThis !== 'undefined' ? globalThis : this), function () {
   'use strict';
 
-  var REVISION = '2026-07-31-page-rpc-contract-v14';
+  var REVISION = '2026-08-04-page-rpc-contract-v15';
   var METHODS = freezeCatalog({
     initializeCapability: entry('bridge.initialize', 'control', 'none', 'default', false, 'none'),
     probe: entry('bridge.probe', 'read', 'none', 'default', false, 'safe'),
@@ -17,6 +17,10 @@
     ensureReviewing: entry('reviewing.enable', 'page_state', 'optional', 'default', true, 'idempotent'),
     ensureEditing: entry('reviewing.disable', 'page_state', 'optional', 'default', true, 'idempotent'),
     applyOperations: entry('document.write', 'document', 'required', 'writeback', true, 'no_retry'),
+    binaryUploadBegin: entry('asset.stage', 'cache', 'required', 'default', false, 'no_retry'),
+    binaryUploadAppend: entry('asset.stage', 'cache', 'none', 'writeback', true, 'no_retry'),
+    binaryUploadCommit: entry('asset.write', 'document', 'required', 'writeback', true, 'no_retry'),
+    binaryUploadAbort: entry('asset.stage', 'cache', 'none', 'default', false, 'idempotent'),
     jumpToPosition: entry('editor.navigate', 'navigation', 'required', 'default', false, 'idempotent'),
     rejectTrackedChanges: entry('tracked_changes.reject', 'document', 'required', 'lifecycle', true, 'no_retry'),
     acceptTrackedChanges: entry('tracked_changes.accept', 'document', 'required', 'lifecycle', true, 'no_retry'),

package/extension/src/shared/sessionState.js

@@ -53,7 +53,7 @@
   // reasoning (`none`) or expose the lightest Codex tier (`minimal`). Dropping
   // either value here silently restores the global `high` default after the
   // user has selected it in the composer.
-  const VALID_REASONING = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
+  const VALID_REASONING = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
   const VALID_SPEED_TIERS = new Set(['standard', 'fast']);
   const VALID_LOCALES = new Set(['en', 'zh']);
   const VALID_EVENT_STATUSES = new Set(['info', 'running', 'completed', 'failed', 'warning', 'blocked', 'skipped', 'pending']);
@@ -128,9 +128,7 @@
     };
 
     state.mode = normalizeMode(state.mode);
-    if (!VALID_REASONING.has(state.reasoningEffort)) {
-      state.reasoningEffort = DEFAULT_PANEL_STATE.reasoningEffort;
-    }
+    state.reasoningEffort = normalizeReasoning(state.reasoningEffort);
     if (!VALID_SPEED_TIERS.has(state.speedTier)) {
       state.speedTier = DEFAULT_PANEL_STATE.speedTier;
     }
@@ -234,6 +232,8 @@
       focusFiles: normalizeFocusFiles(session.focusFiles),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
+      forkedFromSessionId: typeof session.forkedFromSessionId === 'string' ? session.forkedFromSessionId : '',
+      forkedFromRunId: typeof session.forkedFromRunId === 'string' ? session.forkedFromRunId : '',
       pendingInputs: normalizePendingInputs(
         session.pendingInputs,
         options.restoreRunningRuns === true,
@@ -354,6 +354,8 @@
       focusFiles: normalizeFocusFiles(overrides.focusFiles),
       projectReferenceFiles: normalizeProjectReferenceFiles(overrides.projectReferenceFiles),
       codexThreadId: typeof overrides.codexThreadId === 'string' ? overrides.codexThreadId : '',
+      forkedFromSessionId: typeof overrides.forkedFromSessionId === 'string' ? overrides.forkedFromSessionId : '',
+      forkedFromRunId: typeof overrides.forkedFromRunId === 'string' ? overrides.forkedFromRunId : '',
       pendingInputs: normalizePendingInputs(overrides.pendingInputs)
     };
   }
@@ -639,6 +641,8 @@
       undoStatus: sanitizeAssistantVisibleText(run.undoStatus),
       nativeRequestId: sanitizeAssistantVisibleText(run.nativeRequestId),
       codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
+      forkSnapshot: run.forkSnapshot === true,
+      forkSourceRunId: sanitizeAssistantVisibleText(run.forkSourceRunId),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
       queueItemId: sanitizeAssistantVisibleText(run.queueItemId),
       interruptedDraft: run.interruptedDraft ? sanitizeAssistantVisibleValue(run.interruptedDraft) : undefined
@@ -1122,6 +1126,8 @@
       focusFiles: normalizeFocusFiles(session.focusFiles),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
+      forkedFromSessionId: normalizeTextField(session.forkedFromSessionId, 160),
+      forkedFromRunId: normalizeTextField(session.forkedFromRunId, 160),
       pendingInputs: normalizePendingInputs(session.pendingInputs)
     };
     // Welcome-panel + write-guard: preserve the four
@@ -1214,6 +1220,8 @@
       undoStatus: summarizeTextForStorage(run.undoStatus, 'undo status'),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
       codexTurnId: normalizeTextField(run.codexTurnId, 160),
+      forkSnapshot: run.forkSnapshot === true,
+      forkSourceRunId: normalizeTextField(run.forkSourceRunId, 160),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
       queueItemId: normalizeTextField(run.queueItemId, 160)
     };

package/extension/src/shared/storageDb.js

@@ -435,7 +435,6 @@
   }
 
   // --- Helpers ---
-
   function normalizeCurrentMode(mode) {
     return mode === 'auto' ? 'auto' : 'ask';
   }
@@ -448,6 +447,7 @@
       speedTier: typeof state.speedTier === 'string' ? state.speedTier : '',
       mode: normalizeCurrentMode(state.mode),
       locale: typeof state.locale === 'string' ? state.locale : '',
+      theme: state.theme === 'light' || state.theme === 'auto' ? state.theme : 'dark',
       requireReviewing: state.requireReviewing !== false,
       autoRecompile: state.autoRecompile !== false,
       loadCodexLocalSkills: state.loadCodexLocalSkills !== false,

package/extension/src/shared/storageRunActions.js

@@ -38,8 +38,18 @@
       && Array.isArray(run.undoTrackedChanges) && run.undoTrackedChanges.length > 0
       && Array.isArray(run.undoExpectedFiles) && run.undoExpectedFiles.length > 0
       && Array.isArray(run.appliedOperations) && run.appliedOperations.length > 0;
+    // Overleaf can expose a working native editor-undo checkpoint before its
+    // Reviewing DOM markers are discoverable. Preserve that checkpoint too so
+    // a reload does not erase the only safe rollback path while the document
+    // still contains an unresolved tracked change.
+    var reviewingEditorUndo = trackedStatus !== 'accepted'
+      && trackedStatus !== 'rejected'
+      && run && run.undoStatus !== 'applied'
+      && run.executionSnapshot && run.executionSnapshot.requireReviewing === true
+      && Array.isArray(run.undoExpectedFiles) && run.undoExpectedFiles.length > 0
+      && Array.isArray(run.appliedOperations) && run.appliedOperations.length > 0;
     var legacyUndo = Array.isArray(run && run.undoOperations) && run.undoOperations.length > 0;
-    return trackedLifecycle || legacyUndo;
+    return trackedLifecycle || reviewingEditorUndo || legacyUndo;
   }
 
   function compactRunActionPayload(run, keepActionPayload) {