codex-overleaf-link 2.0.0 → 2.1.0

package/extension/src/content/runTimelineView.js

@@ -480,7 +480,11 @@
       existing.dataset.streamRole = event.streamRole || '';
       const text = existing.querySelector('[data-stream-text]');
       if (text) {
-        renderMarkdownInlineText(text, event.title || '');
+        if (event.streamRole === 'assistant') {
+          renderMarkdownBlockText(text, event.title || '');
+        } else {
+          renderMarkdownInlineText(text, event.title || '');
+        }
       }
       return;
     }
@@ -498,7 +502,11 @@
     const text = document.createElement('div');
     text.className = 'run-stream-text';
     text.dataset.streamText = '';
-    renderMarkdownInlineText(text, event.title || '');
+    if (event.streamRole === 'assistant') {
+      renderMarkdownBlockText(text, event.title || '');
+    } else {
+      renderMarkdownInlineText(text, event.title || '');
+    }
 
     row.append(text);
     return row;
@@ -727,9 +735,7 @@
       main.className = 'run-final-answer';
       const mainSections = [];
       if (structured.conclusion) {
-        mainSections.push(getLocale() === 'zh'
-          ? `结论：${structured.conclusion}`
-          : `Conclusion: ${structured.conclusion}`);
+        mainSections.push(formatConclusionMarkdown(structured.conclusion));
       }
       if (structured.body) {
         mainSections.push(structured.body);
@@ -764,6 +770,19 @@
     return report;
   }
 
+  function formatConclusionMarkdown(value) {
+    const conclusion = String(value || '');
+    const label = getLocale() === 'zh' ? '结论：' : 'Conclusion:';
+    return hasLeadingMarkdownBlock(conclusion)
+      ? `${label}\n${conclusion}`
+      : `${label} ${conclusion}`;
+  }
+
+  function hasLeadingMarkdownBlock(value) {
+    const firstLine = String(value || '').trimStart().split(/\r?\n/, 1)[0];
+    return /^(?:#{1,6}\s+\S|```|~~~|(?:[-+*]|\d+[.)])\s+\S|\*\*[^*]+\*\*:?\s*$)/.test(firstLine);
+  }
+
   // For failure codes that have an actionable recovery path the user can
   // invoke directly from the run card, append a button inside the completion
   // report. Today's only consumer is codex_project_locked → "Force-release

package/extension/src/content/settingsPanel.js

@@ -147,12 +147,29 @@
               <p class="codex-set-row-help" data-i18n="languageHelp">Panel display language.</p>
             </div>
           </details>
+          <details class="codex-set-group" data-set-group="providers" open>
+            <summary class="codex-set-group-head">
+              <span class="codex-set-group-title">${codexSetIcon('bolt')}<span data-i18n="providerSettingsTitle">Model providers</span><span class="codex-provider-experimental-badge" data-i18n="providerSettingsExperimental">Third-party experimental</span></span>
+            </summary>
+            <div class="codex-set-card codex-provider-settings-entry">
+              <div class="codex-provider-settings-entry-copy">
+                <p class="codex-set-row-help" data-i18n="providerSettingsHelp">Configure experimental third-party model APIs. Compatibility varies by provider and gateway.</p>
+                <p class="codex-provider-settings-summary" data-provider-settings-summary data-tone="ok" data-i18n="providerSettingsBuiltin">Built-in Codex is active</p>
+              </div>
+              <button type="button" class="codex-set-btn" data-provider-settings-open data-i18n="providerSettingsConfigure">Configure</button>
+            </div>
+          </details>
           <details class="codex-set-group" data-set-group="updates" open>
             <summary class="codex-set-group-head">
               <span class="codex-set-group-title">${codexSetIcon('software')}<span data-i18n="softwareUpdatesTitle">Software updates</span></span>
             </summary>
             <div class="codex-set-card" data-update-settings>
               <div class="codex-set-row">
+                <label class="codex-project-settings-row codex-project-settings-row--switch">
+                  <span class="codex-project-settings-row-label" data-i18n="preloadProjectContextTitle">Preload project context</span>
+                  <input type="checkbox" class="codex-switch" data-preload-project-context>
+                </label>
+                <p class="codex-set-row-help" data-i18n="preloadProjectContextDescription">Fetch the exact project file list in the background after an Overleaf project becomes idle.</p>
                 <p class="codex-set-row-help" data-update-settings-summary data-i18n="softwareUpdatesHelp">Automatically checks signed stable releases for the Extension and Native Host.</p>
                 <p class="codex-set-note" data-update-settings-state aria-live="polite" hidden></p>
                 <button type="button" class="codex-set-btn" data-check-updates data-i18n="checkForUpdates">Check for updates</button>
@@ -211,6 +228,7 @@
     container.querySelector('[data-settings-back]')?.addEventListener('click', () => instance.callbacks.onBack?.());
     container.querySelector('[data-skills-back]')?.addEventListener('click', () => instance.callbacks.onSkillsBack?.());
     container.querySelector('[data-skills-entry]')?.addEventListener('click', () => instance.callbacks.onSkillsOpen?.());
+    container.querySelector('[data-provider-settings-open]')?.addEventListener('click', () => instance.callbacks.onProvidersOpen?.());
     container.querySelector('[data-clear-all-history]')?.addEventListener('click', () => instance.callbacks.onClearAllHistory?.());
     container.querySelector('[data-history-card]')?.addEventListener('toggle', event => {
       if (event.target.open) {
@@ -230,7 +248,7 @@
       flashSaved(instance, event);
     });
     // Governance and skill fields: auto-save on change and input for immediate response.
-    for (const selector of ['[data-governance-readonly-patterns]', '[data-governance-writable-patterns]', '[data-sensitive-check-enabled]', '[data-sensitive-confirm-allowed]', '[data-load-codex-local-skills]', '[data-load-codex-overleaf-skills]', '[data-theme-select]', '[data-language-select]']) {
+    for (const selector of ['[data-governance-readonly-patterns]', '[data-governance-writable-patterns]', '[data-sensitive-check-enabled]', '[data-sensitive-confirm-allowed]', '[data-preload-project-context]', '[data-load-codex-local-skills]', '[data-load-codex-overleaf-skills]', '[data-theme-select]', '[data-language-select]']) {
       const element = container.querySelector(selector);
       element?.addEventListener?.('change', event => {
         instance.callbacks.onInputChange?.(event);
@@ -254,6 +272,7 @@
       setStatus: (text, status) => setStatus(instance, text, status),
       clearStatus: () => clearStatus(instance),
       setSkillsSummary: text => setSkillsSummary(instance, text),
+      setProviderSummary: summary => setProviderSummary(instance, summary),
       refreshNotes: () => updateGovernanceNotes(instance),
       destroy: () => destroy(instance),
       _instance: instance
@@ -328,6 +347,7 @@
       // shared container, so query that instead of a single screen root.
       const scope = instance?.container || root;
       const toggles = state.skillToggles || {};
+      setChecked(scope, '[data-preload-project-context]', toggles.preloadProjectContext !== false);
       setChecked(scope, '[data-load-codex-local-skills]', toggles.loadCodexLocalSkills !== false);
       setChecked(scope, '[data-load-codex-overleaf-skills]', toggles.loadCodexOverleafSkills !== false);
       setValue(scope, '[data-theme-select]', state.theme || 'dark');
@@ -349,6 +369,7 @@
         sensitiveConfirmAllowed: root?.querySelector('[data-sensitive-confirm-allowed]')?.checked === true
       },
       skillToggles: {
+        preloadProjectContext: scope?.querySelector('[data-preload-project-context]')?.checked !== false,
         loadCodexLocalSkills: scope?.querySelector('[data-load-codex-local-skills]')?.checked !== false,
         loadCodexOverleafSkills: scope?.querySelector('[data-load-codex-overleaf-skills]')?.checked !== false
       },
@@ -467,6 +488,15 @@
     }
   }
 
+  function setProviderSummary(instance, value = {}) {
+    const element = instance?.container?.querySelector('[data-provider-settings-summary]');
+    if (!element) {
+      return;
+    }
+    element.textContent = typeof value === 'string' ? value : value.summary || '';
+    element.dataset.tone = typeof value === 'object' && value.tone ? value.tone : 'ok';
+  }
+
   // Collapse memory: card open/closed state persists per browser profile.
   const GROUP_STORE_KEY = 'codexOverleafSettingsGroups';
 
@@ -535,6 +565,7 @@
     isVisible,
     setStatus,
     clearStatus,
-    setSkillsSummary
+    setSkillsSummary,
+    setProviderSummary
   };
 })();

package/extension/src/content/writebackOrchestrator.js

@@ -544,7 +544,9 @@
       status: 'running'
     });
 
-    await callPageBridge('invalidateProjectSnapshot', {});
+    await callPageBridge('invalidateProjectSnapshot', {
+      invalidateFileList: true
+    });
     const freshProject = sanitizeRunProjectSnapshot(await callPageBridge('getProjectSnapshot', {
       force: true,
       maxAgeMs: 0,

package/extension/src/page/overleafProjectSnapshot.js

@@ -14,7 +14,7 @@
   function create(deps = {}) {
     const pageWindow = deps.window || window;
     const snapshotCache = createKeyedCache();
-    const fileListCache = createCache();
+    const fileListCache = createKeyedCache();
 
     async function getProjectSnapshot(params = {}) {
       const cacheKey = getSnapshotCacheKey(params);
@@ -62,41 +62,53 @@
       const cacheKey = getProjectFileListCacheKey(params);
       const maxAgeMs = normalizeFileListMaxAge(params.maxAgeMs);
       const now = Date.now();
+      const cacheEntry = fileListCache.entries.get(cacheKey);
 
-      if (fileListCache.key === cacheKey && fileListCache.pending) {
-        return fileListCache.pending;
+      if (cacheEntry?.pending) {
+        return cacheEntry.pending;
       }
 
-      if (!params.force && fileListCache.key === cacheKey && fileListCache.value && now - fileListCache.capturedAt <= maxAgeMs) {
-        return withFileListCacheMetadata(fileListCache.value, 'memory', fileListCache.capturedAt);
+      if (!params.force && cacheEntry?.value && now - cacheEntry.capturedAt <= maxAgeMs) {
+        return withFileListCacheMetadata(cacheEntry.value, 'memory', cacheEntry.capturedAt);
       }
 
       const pending = deps.buildProjectFileList(params)
         .then(fileList => {
           const capturedAt = Date.now();
-          if (shouldCacheProjectFileList(fileList, params)) {
-            fileListCache.key = cacheKey;
-            fileListCache.value = fileList;
-            fileListCache.capturedAt = capturedAt;
-          } else if (fileListCache.key === cacheKey) {
-            fileListCache.value = null;
-            fileListCache.capturedAt = 0;
+          const currentEntry = fileListCache.entries.get(cacheKey);
+          if (currentEntry?.pending === pending) {
+            if (shouldCacheProjectFileList(fileList, params)) {
+              fileListCache.entries.set(cacheKey, {
+                value: fileList,
+                capturedAt,
+                pending: null
+              });
+            } else {
+              fileListCache.entries.delete(cacheKey);
+            }
           }
           return withFileListCacheMetadata(fileList, 'fresh', capturedAt);
         })
         .finally(() => {
-          if (fileListCache.pending === pending) {
-            fileListCache.pending = null;
+          const currentEntry = fileListCache.entries.get(cacheKey);
+          if (currentEntry?.pending === pending) {
+            currentEntry.pending = null;
           }
         });
 
-      fileListCache.key = cacheKey;
-      fileListCache.pending = pending;
+      fileListCache.entries.set(cacheKey, {
+        value: cacheEntry?.value || null,
+        capturedAt: cacheEntry?.capturedAt || 0,
+        pending
+      });
       return pending;
     }
 
-    function invalidateProjectSnapshot() {
+    function invalidateProjectSnapshot(options = {}) {
       resetKeyedCache(snapshotCache);
+      if (options.invalidateFileList === true) {
+        resetKeyedCache(fileListCache);
+      }
     }
 
     function getSnapshotCacheKey(params = {}) {
@@ -143,15 +155,6 @@
     return fileList?.capabilities?.method === 'overleaf-zip-file-list';
   }
 
-  function createCache() {
-    return {
-      key: '',
-      capturedAt: 0,
-      value: null,
-      pending: null
-    };
-  }
-
   function createKeyedCache() {
     return {
       entries: new Map()
@@ -162,13 +165,6 @@
     cache.entries.clear();
   }
 
-  function resetCache(cache) {
-    cache.key = '';
-    cache.capturedAt = 0;
-    cache.value = null;
-    cache.pending = null;
-  }
-
   function normalizeSnapshotMaxAge(value) {
     if (value === 0) {
       return 0;

package/extension/src/page/snapshotRouter.js

@@ -21,6 +21,7 @@
       ? deps.readActiveEditorText
       : () => '';
     let invalidatedAt = 0;
+    let preferredZipEndpoint = '';
 
     function getProjectId() {
       return treeOperations.getProjectId?.() || null;
@@ -100,6 +101,7 @@
             skipped: [],
             diagnostics: {
               zipEndpoint: zipSnapshot.endpoint,
+              zipTiming: zipSnapshot.diagnostics,
               docRecordCount: internalDocRecords.length,
               docRecords: internalDocRecords.slice(0, 8)
             },
@@ -123,6 +125,7 @@
               reason: zipSnapshot.reason || 'Overleaf source ZIP was unavailable'
             }],
             diagnostics: {
+              zipTiming: zipSnapshot.diagnostics,
               docRecordCount: internalDocRecords.length,
               docRecords: internalDocRecords.slice(0, 8)
             },
@@ -257,6 +260,7 @@
           skipped: zipSnapshot.skipped || [],
           diagnostics: {
             zipEndpoint: zipSnapshot.endpoint,
+            zipTiming: zipSnapshot.diagnostics,
             docRecordCount: internalDocRecords.length,
             docRecords: internalDocRecords.slice(0, 8)
           },
@@ -460,6 +464,7 @@
           skipped: zipSnapshot.skipped || [],
           diagnostics: {
             zipEndpoint: zipSnapshot.endpoint,
+            zipTiming: zipSnapshot.diagnostics,
             docRecordCount: 0,
             docRecords: []
           },
@@ -640,24 +645,60 @@
       `${window.location.origin}/project/${encodeURIComponent(projectId)}/download/zip`,
       `${window.location.origin}/download/project/${encodeURIComponent(projectId)}`
     ];
+    const orderedEndpoints = preferredZipEndpoint && endpoints.includes(preferredZipEndpoint)
+      ? [preferredZipEndpoint, ...endpoints.filter(endpoint => endpoint !== preferredZipEndpoint)]
+      : endpoints;
 
+    const startedAt = Date.now();
+    const deadline = startedAt + timeoutMs;
     const errors = [];
-    for (const endpoint of endpoints) {
+    const attempts = [];
+    for (const endpoint of orderedEndpoints) {
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        errors.push(`Overleaf ZIP download exhausted its ${timeoutMs}ms total timeout budget`);
+        break;
+      }
+      const attemptStartedAt = Date.now();
       try {
-        const { response, contentType, buffer } = await fetchZipEndpoint(endpoint, timeoutMs);
+        const { response, contentType, buffer, timing } = await fetchZipEndpoint(endpoint, remainingMs);
         if (!response.ok) {
+          attempts.push({
+            endpoint,
+            status: response.status,
+            elapsedMs: Date.now() - attemptStartedAt
+          });
           errors.push(`${endpoint} returned ${response.status}`);
           continue;
         }
+        const extractStartedAt = Date.now();
         const extracted = await extractFilesFromZip(buffer, {
           includeBinaryFiles: Boolean(params.includeBinaryFiles),
           includeContent: params.includeContent !== false
         });
+        const extractMs = Date.now() - extractStartedAt;
         const files = extracted.files || [];
         if (!files.length) {
+          attempts.push({
+            endpoint,
+            status: response.status,
+            elapsedMs: Date.now() - attemptStartedAt,
+            downloadMs: timing.totalMs,
+            extractMs
+          });
           errors.push(`${endpoint} returned no text files (${contentType || 'unknown content type'})`);
           continue;
         }
+        preferredZipEndpoint = endpoint;
+        attempts.push({
+          endpoint,
+          status: response.status,
+          elapsedMs: Date.now() - attemptStartedAt,
+          timeToHeadersMs: timing.timeToHeadersMs,
+          downloadMs: timing.totalMs,
+          extractMs,
+          bytes: buffer?.byteLength || 0
+        });
         return {
           ok: true,
           endpoint,
@@ -665,22 +706,42 @@
           files: files.map(file => ({
             ...file,
             source: 'overleaf-zip'
-          }))
+          })),
+          diagnostics: {
+            totalMs: Date.now() - startedAt,
+            timeoutBudgetMs: timeoutMs,
+            attempts
+          }
         };
       } catch (error) {
+        attempts.push({
+          endpoint,
+          error: error.message,
+          elapsedMs: Date.now() - attemptStartedAt
+        });
         errors.push(`${endpoint} failed: ${error.message}`);
+        if (error?.code === 'zip_timeout') {
+          errors.push(`Overleaf ZIP download exhausted its ${timeoutMs}ms total timeout budget`);
+          break;
+        }
       }
     }
 
     return {
       ok: false,
-      reason: errors.join('; ') || 'Overleaf source ZIP was unavailable'
+      reason: errors.join('; ') || 'Overleaf source ZIP was unavailable',
+      diagnostics: {
+        totalMs: Date.now() - startedAt,
+        timeoutBudgetMs: timeoutMs,
+        attempts
+      }
     };
   }
 
   function fetchZipEndpoint(endpoint, timeoutMs) {
     const controller = typeof AbortController === 'function' ? new AbortController() : null;
     const request = (async () => {
+      const startedAt = Date.now();
       const response = await fetch(endpoint, {
         credentials: 'include',
         headers: {
@@ -688,12 +749,17 @@
         },
         ...(controller ? { signal: controller.signal } : {})
       });
+      const headersAt = Date.now();
       const contentType = response.headers.get('content-type') || '';
       const buffer = response.ok ? await response.arrayBuffer() : null;
       return {
         response,
         contentType,
-        buffer
+        buffer,
+        timing: {
+          timeToHeadersMs: headersAt - startedAt,
+          totalMs: Date.now() - startedAt
+        }
       };
     })();
 
@@ -706,11 +772,12 @@
     let timeoutId = null;
     const timeout = new Promise((_resolve, reject) => {
       timeoutId = window.setTimeout(() => {
+        const timeoutError = new Error(message);
+        timeoutError.code = 'zip_timeout';
+        reject(timeoutError);
         try {
           onTimeout?.();
-        } finally {
-          reject(new Error(message));
-        }
+        } catch (_error) {}
       }, timeoutMs);
     });
 

package/extension/src/page/writebackRouter.js

@@ -879,55 +879,42 @@
     const previousEditorIdentity = getActiveEditorIdentity();
     const previousSignature = contentSignature(currentText);
 
-    // §9.1 target_file_not_found: if the target path is not visible in the
-    // Overleaf project file tree, refuse the write before attempting to open.
-    // openFileByPath itself would fail anyway, but emitting the canonical
-    // path-not-found code (rather than a generic open failure) gives the run
-    // card / final report a more actionable presentation per §17.3.1.
-    // Only fires when the tree-operations layer actually exposes a
-    // projectPathExists hook; older harnesses without the hook fall through
-    // to the openFileByPath path and surface a generic open failure.
-    if (operation?.type === 'edit' && hasProjectPathExistsHook() && !projectPathExists(filePath)) {
-      return {
-        ok: false,
-        code: 'path_not_found',
-        reason: `Cannot edit ${filePath}; the path is not in the Overleaf project file tree.`,
-        failure: buildPageFailure('target_file_not_found', {
-          file: filePath,
-          activeFile: initialActivePath || '',
-          operationType: operation?.type || 'edit',
-          changedDocument: false,
-          userMessage: `Codex could not find ${filePath} in this Overleaf project.`,
-          evidence: {
-            originalCode: 'path_not_found',
-            initialActivePath: initialActivePath || '',
-            writeStarted: false
-          }
-        })
-      };
-    }
-
     const opened = await openFileByPath(filePath, { force: initialActivePath === filePath });
     if (!opened.ok) {
-      const reasonText = `Cannot edit ${filePath}; active file is ${initialActivePath || 'unknown'}; ${opened.reason}`;
+      // A collapsed folder can make a real nested file temporarily invisible
+      // to projectPathExists(). openFileByPath() owns the side-effecting
+      // expand-and-open attempt, so only classify the path as missing after
+      // that attempt has failed and the path still cannot be observed.
+      const pathMissing = operation?.type === 'edit'
+        && hasProjectPathExistsHook()
+        && !projectPathExists(filePath);
+      const resultCode = pathMissing ? 'path_not_found' : 'file_open_failed';
+      const failureCode = pathMissing ? 'target_file_not_found' : 'target_file_open_failed';
+      const reasonText = pathMissing
+        ? `Cannot edit ${filePath}; the path was not found after Overleaf tried to open it.`
+        : `Cannot edit ${filePath}; active file is ${initialActivePath || 'unknown'}; ${opened.reason}`;
       return {
         ok: false,
-        code: 'file_open_failed',
-        debug: buildWritebackDebug('open_file_failed', operation, baseFileLookup, currentText, {
+        code: resultCode,
+        debug: buildWritebackDebug(pathMissing ? 'open_file_path_not_found' : 'open_file_failed', operation, baseFileLookup, currentText, {
           initialActivePath,
           opened
         }),
         reason: reasonText,
-        failure: buildPageFailure('target_file_open_failed', {
+        failure: buildPageFailure(failureCode, {
           file: filePath,
           activeFile: initialActivePath || '',
           operationType: operation?.type || 'edit',
           changedDocument: false,
-          userMessage: `Codex could not open ${filePath} in Overleaf.`,
+          userMessage: pathMissing
+            ? `Codex could not find ${filePath} in this Overleaf project.`
+            : `Codex could not open ${filePath} in Overleaf.`,
           technicalMessage: opened.reason || '',
           evidence: {
+            originalCode: resultCode,
             initialActivePath: initialActivePath || '',
             openMethod: opened.method || '',
+            openAttempted: true,
             writeStarted: false
           }
         })

package/extension/src/pageBridge.js

@@ -202,7 +202,7 @@
       return projectSnapshotBridge.getProjectFileList(params);
     }
     if (method === 'invalidateProjectSnapshot') {
-      projectSnapshotBridge.invalidateProjectSnapshot();
+      projectSnapshotBridge.invalidateProjectSnapshot(params);
       return { ok: true };
     }
     if (method === 'createCheckpoint') {