codex-overleaf-link 1.9.13 → 2.1.0

package/extension/src/shared/failureReasons.js

@@ -288,6 +288,81 @@
       fallbackUserMessage: 'Local Codex returned no usable final report or operations.',
       fallbackNextAction: 'Open Technical Details and resolve the local Codex error.'
     },
+    provider_revision_conflict: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: true,
+      fallbackUserMessage: 'The active model provider changed after this tab loaded it.',
+      fallbackNextAction: 'Refresh the provider configuration and retry.'
+    },
+    provider_not_found: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The active model provider no longer exists.',
+      fallbackNextAction: 'Select Built-in Codex or another provider.'
+    },
+    provider_model_not_configured: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The selected model is not configured for the active provider.',
+      fallbackNextAction: 'Add or select a model in Model Providers.'
+    },
+    provider_protocol_unverified: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: true,
+      fallbackUserMessage: 'The provider API protocol has not been verified.',
+      fallbackNextAction: 'Run Test connection, save the provider, and retry.'
+    },
+    provider_auth_rejected: {
+      stage: 'codex', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The provider rejected the configured API key.',
+      fallbackNextAction: 'Replace the API key and test the connection.'
+    },
+    provider_model_not_found: {
+      stage: 'codex', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The provider could not find the configured model.',
+      fallbackNextAction: 'Correct the model ID and test the connection.'
+    },
+    provider_protocol_incompatible: {
+      stage: 'codex', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The endpoint is incompatible with the selected API protocol.',
+      fallbackNextAction: 'Select another protocol or use Auto detection.'
+    },
+    provider_request_rejected: {
+      stage: 'codex', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The provider rejected the protocol probe request.',
+      fallbackNextAction: 'Review the model ID, reasoning controls, tool support, and request overrides.'
+    },
+    provider_rate_limited: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'The provider rate limit was reached.',
+      fallbackNextAction: 'Wait for the rate-limit window to recover and retry.'
+    },
+    provider_connection_timeout: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'The provider connection timed out.',
+      fallbackNextAction: 'Check the endpoint and network, then retry.'
+    },
+    provider_dns_failed: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'The provider hostname could not be resolved.',
+      fallbackNextAction: 'Check the Base URL and DNS, then retry.'
+    },
+    provider_tls_failed: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'TLS verification failed for the provider endpoint.',
+      fallbackNextAction: 'Check the endpoint certificate and Base URL.'
+    },
+    provider_response_invalid: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'The provider returned an incompatible or invalid response.',
+      fallbackNextAction: 'Test the connection and verify protocol compatibility.'
+    },
+    provider_store_unavailable: {
+      stage: 'storage', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'The Native Host could not access provider configuration storage.',
+      fallbackNextAction: 'Check local permissions and Native Host status.'
+    },
+    provider_store_corrupt: {
+      stage: 'storage', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'The provider configuration store is corrupt or inconsistent.',
+      fallbackNextAction: 'Repair or rebuild the local provider configuration.'
+    },
     codex_project_locked: {
       stage: 'codex', severity: 'blocked', defaultRetryable: true,
       fallbackUserMessage: 'Another Codex task is already running for this Overleaf project.',

package/extension/src/shared/i18n.js

@@ -287,6 +287,11 @@
       softwareUpdatesTitle: 'Software updates',
       softwareUpdatesHelp: 'Automatically checks signed stable releases for the Extension and Native Host.',
       checkForUpdates: 'Check for updates',
+      providerSettingsTitle: 'Model providers',
+      providerSettingsExperimental: 'Third-party experimental',
+      providerSettingsHelp: 'Configure experimental third-party model APIs. Compatibility varies by provider and gateway.',
+      providerSettingsConfigure: 'Configure',
+      providerSettingsBuiltin: 'Built-in Codex is active',
       storageUsageLoading: 'Calculating usage\u2026',
       storageClearAll: 'Clear all history\u2026',
       storageClearAllHelp: 'Removes every stored session, run and audit record for all projects. Project settings and rules are kept.',
@@ -343,10 +348,16 @@
       refreshFileList: 'Refresh file list',
       contextStatus: 'Type @ to add files, or click ＋: files, attachments (PDF/images), @compile-log.',
       contextLoadingFiles: 'Reading available @files...',
+      contextSyncTreeLoading: 'Reading the project file tree.',
+      contextSyncExactLoading: 'Available files are ready. Completing the full ZIP file list.',
+      contextSyncExactReady: 'The complete project file list is ready.',
+      contextSyncPartial: 'Available files are shown. The complete ZIP file list is unavailable; refresh to retry.',
       contextReadFailed: 'Could not read files: {message}',
       contextNoFiles: 'No usable text files were read from this Overleaf project.',
       contextSelectedFiles: 'Added {count} @file items. Future tasks will focus on them first.',
       contextDefaultWholeProject: 'Default is the whole project. Add @file; @compile-log and @current-section are available as context options.',
+      preloadProjectContextTitle: 'Preload project context',
+      preloadProjectContextDescription: 'Fetch the exact project file list in the background after an Overleaf project becomes idle.',
       contextResourceTitle: '{path} (non-text resource, shown only as project structure for now)',
       contextWholeProjectChip: 'Default: whole project',
       clearFiles: 'Clear all @file context',
@@ -762,6 +773,11 @@
       softwareUpdatesTitle: '软件更新',
       softwareUpdatesHelp: '自动检查 Extension 与 Native Host 的签名稳定版本。',
       checkForUpdates: '检查更新',
+      providerSettingsTitle: '模型服务',
+      providerSettingsExperimental: '第三方实验性',
+      providerSettingsHelp: '配置实验性第三方模型 API；兼容性取决于具体模型服务与网关。',
+      providerSettingsConfigure: '配置',
+      providerSettingsBuiltin: '当前使用内置 Codex',
       storageUsageLoading: '正在计算占用…',
       storageClearAll: '清空全部历史…',
       storageClearAllHelp: '删除所有项目已存储的全部会话、运行与审计记录。项目设置与规则会保留。',
@@ -818,10 +834,16 @@
       refreshFileList: '刷新文件列表',
       contextStatus: '输入 @ 添加文件，或点 ＋：文件、附件（PDF/图片）、@compile-log。',
       contextLoadingFiles: '正在读取可添加的 @文件...',
+      contextSyncTreeLoading: '正在读取项目文件树。',
+      contextSyncExactLoading: '可用文件已经显示，正在补齐完整 ZIP 文件列表。',
+      contextSyncExactReady: '完整项目文件列表已经就绪。',
+      contextSyncPartial: '当前已显示可用文件，完整 ZIP 文件列表暂不可用；可刷新重试。',
       contextReadFailed: '读取文件失败：{message}',
       contextNoFiles: '没有从当前 Overleaf 项目读取到可用文本文件。',
       contextSelectedFiles: '已添加 {count} 个 @file；后续任务会优先围绕它们。',
       contextDefaultWholeProject: '默认使用整个项目。可添加 @file；@compile-log 和 @current-section 将作为后续上下文能力。',
+      preloadProjectContextTitle: '预加载项目上下文',
+      preloadProjectContextDescription: 'Overleaf 项目进入空闲状态后，在后台读取精确的项目文件列表。',
       contextResourceTitle: '{path}（非文本资源，当前只作为项目结构显示）',
       contextWholeProjectChip: '默认：整个项目',
       clearFiles: '清除全部 @file',

package/extension/src/shared/models.js

@@ -63,6 +63,7 @@
       id,
       label,
       reasoningEfforts: Array.isArray(model?.reasoningEfforts) ? model.reasoningEfforts.slice() : [],
+      reasoningPresentation: typeof model?.reasoningPresentation === 'string' ? model.reasoningPresentation : '',
       speedTiers: normalizeSpeedTiers(model?.speedTiers)
     };
 

package/extension/src/shared/providerProfiles.js

@@ -0,0 +1,283 @@
+(function initCodexOverleafProviderProfiles(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafProviderProfiles = factory();
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function providerProfilesFactory() {
+  'use strict';
+
+  const BUILTIN_PROVIDER_ID = 'builtin';
+
+  function normalizeCatalog(value = {}) {
+    const providers = Array.isArray(value.providers)
+      ? value.providers.map(normalizeProvider).filter(Boolean)
+      : [];
+    if (!providers.some(provider => provider.id === BUILTIN_PROVIDER_ID)) {
+      providers.unshift(buildBuiltinProvider());
+    }
+    const requestedActiveId = normalizeText(value.activeProviderId);
+    const activeProviderId = providers.some(provider => provider.id === requestedActiveId)
+      ? requestedActiveId
+      : BUILTIN_PROVIDER_ID;
+    return {
+      activeProviderId,
+      providers,
+      storeRevision: normalizeInteger(value.storeRevision)
+    };
+  }
+
+  function normalizeProvider(value) {
+    if (!value || typeof value !== 'object') {
+      return null;
+    }
+    const id = normalizeText(value.id);
+    if (!id) {
+      return null;
+    }
+    if (id === BUILTIN_PROVIDER_ID || value.kind === 'builtin') {
+      return buildBuiltinProvider();
+    }
+    const models = normalizeModels(value.models);
+    const defaultModelId = normalizeText(value.defaultModelId) || models[0]?.id || '';
+    return {
+      id,
+      kind: 'custom',
+      revision: normalizeInteger(value.revision),
+      name: normalizeText(value.name) || 'Custom provider',
+      baseUrl: normalizeText(value.baseUrl),
+      wireApiPreference: normalizeWireApi(value.wireApiPreference, true),
+      resolvedWireApi: normalizeWireApi(value.resolvedWireApi, false),
+      models,
+      defaultModelId,
+      requestTimeoutMs: normalizeInteger(value.requestTimeoutMs) || 30000,
+      reasoningAdapter: normalizeReasoningAdapter(value.reasoningAdapter),
+      reasoningCapability: normalizeReasoningCapability(value.reasoningCapability),
+      authMode: normalizeAuthMode(value.authMode),
+      apiKeyHeaderName: normalizeText(value.apiKeyHeaderName),
+      fullEndpoint: value.fullEndpoint === true,
+      customHeaders: normalizeRecord(value.customHeaders),
+      queryParams: normalizeRecord(value.queryParams),
+      bodyOverrides: normalizeRecord(value.bodyOverrides),
+      contextWindow: normalizeInteger(value.contextWindow) || 262144,
+      supportsParallelToolCalls: value.supportsParallelToolCalls === true,
+      supportsStreamOptions: value.supportsStreamOptions === true,
+      inputModalities: normalizeInputModalities(value.inputModalities),
+      anthropicVersion: normalizeText(value.anthropicVersion) || '2023-06-01',
+      anthropicBeta: normalizeText(value.anthropicBeta),
+      anthropicThinkingMode: normalizeAnthropicThinkingMode(value.anthropicThinkingMode),
+      anthropicPromptCaching: value.anthropicPromptCaching === true,
+      impersonateClaudeCode: value.impersonateClaudeCode === true,
+      maxOutputTokens: normalizeMaxOutputTokens(value.maxOutputTokens),
+      hasSecret: value.hasSecret === true,
+      secretUpdatedAt: normalizeInteger(value.secretUpdatedAt),
+      endpointDisclosureHost: normalizeText(value.endpointDisclosureHost),
+      endpointDisclosureBaseUrl: normalizeText(value.endpointDisclosureBaseUrl),
+      endpointDisclosureAcceptedAt: normalizeInteger(value.endpointDisclosureAcceptedAt),
+      modelDiagnostics: normalizeModelDiagnostics(value.modelDiagnostics),
+      lastVerified: value.lastVerified && typeof value.lastVerified === 'object'
+        ? {
+            revision: normalizeInteger(value.lastVerified.revision),
+            at: normalizeInteger(value.lastVerified.at),
+            modelId: normalizeText(value.lastVerified.modelId),
+            wireApi: normalizeWireApi(value.lastVerified.wireApi, false),
+            upstreamResponseMode: normalizeUpstreamResponseMode(value.lastVerified.upstreamResponseMode, false)
+          }
+        : null,
+      createdAt: normalizeInteger(value.createdAt),
+      updatedAt: normalizeInteger(value.updatedAt)
+    };
+  }
+
+  function normalizeModels(models) {
+    if (!Array.isArray(models)) {
+      return [];
+    }
+    const seen = new Set();
+    const result = [];
+    for (const value of models) {
+      const id = normalizeText(typeof value === 'string' ? value : value?.id);
+      if (!id || seen.has(id)) {
+        continue;
+      }
+      seen.add(id);
+      result.push({
+        id,
+        label: normalizeText(value?.label) || id,
+        reasoningEfforts: Array.isArray(value?.reasoningEfforts)
+          ? value.reasoningEfforts.map(normalizeText).filter(Boolean)
+          : [],
+        upstreamResponseMode: normalizeUpstreamResponseMode(value?.upstreamResponseMode, true),
+        resolvedUpstreamResponseMode: normalizeUpstreamResponseMode(value?.resolvedUpstreamResponseMode, false),
+        contextWindow: normalizeInteger(value?.contextWindow) || 262144,
+        supportsParallelToolCalls: value?.supportsParallelToolCalls === true,
+        inputModalities: normalizeInputModalities(value?.inputModalities),
+        baseInstructions: normalizeText(value?.baseInstructions)
+      });
+    }
+    return result;
+  }
+
+  function buildBuiltinProvider() {
+    return {
+      id: BUILTIN_PROVIDER_ID,
+      kind: 'builtin',
+      revision: 0,
+      name: 'Built-in Codex',
+      editable: false,
+      deletable: false,
+      models: []
+    };
+  }
+
+  function buildEmptyDraft() {
+    return {
+      id: '',
+      kind: 'custom',
+      revision: 0,
+      name: 'Custom provider',
+      baseUrl: '',
+      wireApiPreference: 'auto',
+      resolvedWireApi: '',
+      models: [],
+      defaultModelId: '',
+      requestTimeoutMs: 30000,
+      reasoningAdapter: 'auto',
+      reasoningCapability: 'auto',
+      authMode: 'bearer',
+      apiKeyHeaderName: '',
+      fullEndpoint: false,
+      customHeaders: {},
+      queryParams: {},
+      bodyOverrides: {},
+      contextWindow: 262144,
+      supportsParallelToolCalls: false,
+      supportsStreamOptions: false,
+      inputModalities: ['text'],
+      anthropicVersion: '2023-06-01',
+      anthropicBeta: '',
+      anthropicThinkingMode: 'budget',
+      anthropicPromptCaching: false,
+      impersonateClaudeCode: false,
+      maxOutputTokens: 32768,
+      hasSecret: false,
+      secretUpdatedAt: 0,
+      endpointDisclosureHost: '',
+      endpointDisclosureBaseUrl: '',
+      modelDiagnostics: {},
+      lastVerified: null
+    };
+  }
+
+  function getActiveProvider(catalog = {}) {
+    const normalized = normalizeCatalog(catalog);
+    return normalized.providers.find(provider => provider.id === normalized.activeProviderId)
+      || buildBuiltinProvider();
+  }
+
+  function buildRunSelection(catalog = {}) {
+    const active = getActiveProvider(catalog);
+    return {
+      providerId: active.id,
+      providerRevision: active.revision || 0
+    };
+  }
+
+  function normalizeWireApi(value, allowAuto) {
+    const normalized = normalizeText(value).toLowerCase();
+    if (normalized === 'responses' || normalized === 'chat' || normalized === 'anthropic') {
+      return normalized;
+    }
+    return allowAuto ? 'auto' : '';
+  }
+
+  function normalizeReasoningAdapter(value) {
+    const normalized = normalizeText(value).toLowerCase();
+    return ['auto', 'none', 'deepseek', 'anthropic', 'reasoning_effort', 'openrouter', 'enable_thinking', 'thinking', 'reasoning_split'].includes(normalized)
+      ? normalized
+      : 'auto';
+  }
+
+  function normalizeReasoningCapability(value) {
+    const normalized = normalizeText(value).toLowerCase();
+    return ['auto', 'none', 'toggle', 'effort'].includes(normalized) ? normalized : 'auto';
+  }
+
+  function normalizeUpstreamResponseMode(value, allowAuto) {
+    const normalized = normalizeText(value).toLowerCase();
+    if (normalized === 'streaming' || normalized === 'buffered' || (allowAuto && normalized === 'auto')) {
+      return normalized;
+    }
+    return allowAuto ? 'auto' : '';
+  }
+
+  function normalizeAuthMode(value) {
+    const normalized = normalizeText(value).toLowerCase();
+    return ['bearer', 'x-api-key', 'api-key', 'custom', 'none'].includes(normalized)
+      ? normalized
+      : 'bearer';
+  }
+
+  function normalizeRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : {};
+  }
+
+  function normalizeModelDiagnostics(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return {};
+    }
+    const result = {};
+    for (const [rawModelId, rawDiagnostic] of Object.entries(value).slice(0, 32)) {
+      const modelId = normalizeText(rawModelId);
+      if (!modelId || !rawDiagnostic || typeof rawDiagnostic !== 'object') {
+        continue;
+      }
+      const status = normalizeText(rawDiagnostic.status).toLowerCase();
+      result[modelId] = {
+        modelId,
+        status: status === 'failed' ? 'failed' : 'tested',
+        at: normalizeInteger(rawDiagnostic.at),
+        wireApi: normalizeWireApi(rawDiagnostic.wireApi, false),
+        upstreamResponseMode: normalizeUpstreamResponseMode(rawDiagnostic.upstreamResponseMode, false),
+        durationMs: normalizeInteger(rawDiagnostic.durationMs),
+        errorCode: normalizeText(rawDiagnostic.errorCode)
+      };
+    }
+    return result;
+  }
+
+  function normalizeInputModalities(value) {
+    const values = Array.isArray(value) ? value : ['text'];
+    const result = Array.from(new Set(values.map(normalizeText).filter(item => item === 'text' || item === 'image')));
+    return result.includes('text') ? result : ['text', ...result];
+  }
+
+  function normalizeAnthropicThinkingMode(value) {
+    const normalized = normalizeText(value).toLowerCase();
+    return ['budget', 'adaptive', 'none'].includes(normalized) ? normalized : 'budget';
+  }
+
+  function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+  }
+
+  function normalizeInteger(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number >= 0 ? Math.floor(number) : 0;
+  }
+
+  function normalizeMaxOutputTokens(value) {
+    const number = normalizeInteger(value);
+    return !number || number === 8192 ? 32768 : number;
+  }
+
+  return {
+    BUILTIN_PROVIDER_ID,
+    buildBuiltinProvider,
+    buildEmptyDraft,
+    buildRunSelection,
+    getActiveProvider,
+    normalizeCatalog,
+    normalizeProvider
+  };
+});

package/extension/src/shared/sessionState.js

@@ -19,6 +19,7 @@
     locale: 'en',
     requireReviewing: true,
     autoOpen: true,
+    preloadProjectContext: true,
     loadCodexLocalSkills: true,
     loadCodexOverleafSkills: true,
     codexOverleafSkillEnabled: {},
@@ -34,7 +35,12 @@
   };
 
   const VALID_MODES = new Set(['ask', 'confirm', 'auto']);
-  const VALID_REASONING = new Set(['low', 'medium', 'high', 'xhigh']);
+  // Keep the persisted/session-level contract aligned with the model picker
+  // and native provider bridge. Custom providers can explicitly disable
+  // 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_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']);
@@ -63,7 +69,10 @@
     maxUndoRunsPerSession: 2,
     maxUndoBytesPerRun: 320 * 1024,
     targetBytes: 4 * 1024 * 1024,
-    titleChars: 6000,
+    // Stream events carry accumulated assistant/reasoning text in `title`.
+    // Keep one provider-sized response intact; the 4 MiB state target below
+    // remains the aggregate history guard and prunes older events when needed.
+    titleChars: 128 * 1024,
     detailChars: 3000,
     reportDetailChars: 64000,
     historyChars: 1800,
@@ -945,6 +954,7 @@
       locale: normalizeLocale(source.locale),
       requireReviewing: active ? active.requireReviewing !== false : source.requireReviewing !== false,
       autoOpen: source.autoOpen !== false,
+      preloadProjectContext: source.preloadProjectContext !== false,
       loadCodexLocalSkills: source.loadCodexLocalSkills !== false,
       loadCodexOverleafSkills: source.loadCodexOverleafSkills !== false,
       codexOverleafSkillEnabled: normalizeCodexOverleafSkillEnabled(source.codexOverleafSkillEnabled),

package/extension/src/shared/storageDb.js

@@ -1,13 +1,17 @@
 (function initStorageDb(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('./storageRunActions'));
   } else {
-    root.CodexOverleafStorageDb = factory();
+    root.CodexOverleafStorageDb = factory(root.CodexOverleafStorageRunActions);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory() {
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions) {
   'use strict';
-
-  var TARGET_SCHEMA_VERSION = 2;
+  if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload) {
+    throw new Error('Codex Overleaf storage run-action helpers are unavailable.');
+  }
+  // IndexedDB versions are monotonic; v2.0 RC profiles have already opened v3.
+  // Lowering it hides otherwise-intact session history behind fallback state.
+  var TARGET_SCHEMA_VERSION = 3;
   var DB_NAME = 'codex-overleaf';
   var CUSTOM_INSTRUCTIONS_MAX_CHARS = 12000;
   var PROJECT_PREF_KEY_MAX_CHARS = 160;
@@ -22,7 +26,7 @@
     taskChars: 12000,
     historyTaskChars: 300,
     historyResultChars: 1800,
-    eventTitleChars: 6000,
+    eventTitleChars: 128 * 1024,
     statusTextChars: 800,
     detailChars: 3000,
     reportDetailChars: 64000,
@@ -235,7 +239,8 @@
 
   // --- Record builders ---
 
-  function buildSessionRecord(input) {
+  function buildSessionRecord(input, options) {
+    options = options || {};
     var now = new Date().toISOString();
     var titleSource = input.titleSource === 'manual' ? 'manual' : 'auto';
     var updatedAt = typeof input.updatedAt === 'string' ? input.updatedAt : now;
@@ -268,7 +273,7 @@
       status: typeof input.status === 'string' && input.status ? input.status : 'active',
       focusFiles: normalizePathList(input.focusFiles),
       history: compactHistoryForStorage(input.history),
-      runs: compactRunsForStorage(input.runs),
+      runs: compactRunsForStorage(input.runs, options),
       task: normalizeDisplayTextForStorage(input.task, SESSION_STORAGE_LIMITS.taskChars),
       mode: typeof input.mode === 'string' ? input.mode : '',
       model: typeof input.model === 'string' ? input.model : '',
@@ -628,14 +633,17 @@
       });
   }
 
-  function compactRunsForStorage(runs) {
-    return (Array.isArray(runs) ? runs : [])
-      .filter(function (run) { return run && typeof run.id === 'string'; })
-      .slice(-SESSION_STORAGE_LIMITS.maxRunsPerSession)
-      .map(compactRunForStorage);
+  function compactRunsForStorage(runs, options) {
+    return StorageRunActions.compactRunsForStorage(
+      runs,
+      options,
+      SESSION_STORAGE_LIMITS.maxRunsPerSession,
+      compactRunForStorage
+    );
   }
 
-  function compactRunForStorage(run) {
+  function compactRunForStorage(run, keepActionPayload) {
+    var actionPayload = StorageRunActions.compactRunActionPayload(run, keepActionPayload);
     var compact = {
       id: run.id,
       task: normalizeDisplayTextForStorage(run.task || 'untitled task', SESSION_STORAGE_LIMITS.taskChars),
@@ -650,11 +658,11 @@
       finishedAt: typeof run.finishedAt === 'string' ? redactSecretLikeText(run.finishedAt) : '',
       events: compactRunEventsForStorage(run.events),
       attachments: compactRunAttachmentsForStorage(run.attachments),
-      appliedOperations: [],
-      undoOperations: [],
-      undoBaseFiles: [],
-      undoTrackedChanges: [],
-      undoExpectedFiles: [],
+      appliedOperations: actionPayload.appliedOperations,
+      undoOperations: actionPayload.undoOperations,
+      undoBaseFiles: actionPayload.undoBaseFiles,
+      undoTrackedChanges: actionPayload.undoTrackedChanges,
+      undoExpectedFiles: actionPayload.undoExpectedFiles,
       undoStatus: normalizeDisplayTextForStorage(run.undoStatus, SESSION_STORAGE_LIMITS.statusTextChars)
     };
     if (VALID_TRACKED_CHANGE_STATUSES[run.trackedChangeStatus] === true) {

package/extension/src/shared/storageRunActions.js

@@ -0,0 +1,99 @@
+(function initStorageRunActions(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafStorageRunActions = factory();
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageRunActionsFactory() {
+  'use strict';
+
+  var MAX_PERSISTED_ACTION_RUNS_PER_SESSION = 2;
+  var MAX_PERSISTED_ACTION_BYTES_PER_RUN = 320 * 1024;
+
+  function compactRunsForStorage(runs, options, maxRuns, compactRun) {
+    if (typeof compactRun !== 'function') {
+      throw new TypeError('compactRun must be a function.');
+    }
+    var selectedRuns = (Array.isArray(runs) ? runs : [])
+      .filter(function (run) { return run && typeof run.id === 'string'; })
+      .slice(-Math.max(0, Number(maxRuns) || 0));
+    var actionRunIds = new Set();
+    if (options && options.preserveRunActionPayload === true) {
+      for (var index = selectedRuns.length - 1;
+        index >= 0 && actionRunIds.size < MAX_PERSISTED_ACTION_RUNS_PER_SESSION;
+        index -= 1) {
+        if (hasReloadableRunActionPayload(selectedRuns[index])) {
+          actionRunIds.add(selectedRuns[index].id);
+        }
+      }
+    }
+    return selectedRuns.map(function (run) {
+      return compactRun(run, actionRunIds.has(run.id));
+    });
+  }
+
+  function hasReloadableRunActionPayload(run) {
+    var trackedStatus = run && run.trackedChangeStatus;
+    var trackedLifecycle = (trackedStatus === 'pending' || trackedStatus === 'needs_review')
+      && Array.isArray(run.undoTrackedChanges) && run.undoTrackedChanges.length > 0
+      && 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;
+  }
+
+  function compactRunActionPayload(run, keepActionPayload) {
+    var empty = emptyActionPayload();
+    if (!keepActionPayload || !hasReloadableRunActionPayload(run)) {
+      return empty;
+    }
+    var payload = {
+      appliedOperations: cloneSerializableArray(run.appliedOperations),
+      undoOperations: cloneSerializableArray(run.undoOperations),
+      undoBaseFiles: cloneSerializableArray(run.undoBaseFiles),
+      undoTrackedChanges: cloneSerializableArray(run.undoTrackedChanges),
+      undoExpectedFiles: cloneSerializableArray(run.undoExpectedFiles)
+    };
+    var serialized;
+    try {
+      serialized = JSON.stringify(payload);
+    } catch (_error) {
+      return empty;
+    }
+    return getUtf8ByteLength(serialized) <= MAX_PERSISTED_ACTION_BYTES_PER_RUN ? payload : empty;
+  }
+
+  function emptyActionPayload() {
+    return {
+      appliedOperations: [],
+      undoOperations: [],
+      undoBaseFiles: [],
+      undoTrackedChanges: [],
+      undoExpectedFiles: []
+    };
+  }
+
+  function cloneSerializableArray(value) {
+    if (!Array.isArray(value)) {
+      return [];
+    }
+    try {
+      var clone = JSON.parse(JSON.stringify(value));
+      return Array.isArray(clone) ? clone : [];
+    } catch (_error) {
+      return [];
+    }
+  }
+
+  function getUtf8ByteLength(value) {
+    if (typeof TextEncoder === 'function') {
+      return new TextEncoder().encode(value).byteLength;
+    }
+    return value.length * 2;
+  }
+
+  return {
+    compactRunsForStorage: compactRunsForStorage,
+    compactRunActionPayload: compactRunActionPayload
+  };
+});