codex-overleaf-link 2.6.0 → 2.6.5

package/extension/src/page/writebackRouter.js

@@ -115,7 +115,7 @@
     }
 
     function readActiveEditorText() {
-      return deps.readActiveEditorText?.() || '';
+      return deps.readActiveEditorText?.();
     }
 
     function waitForActiveEditorText(filePath, timeoutMs, options = {}) {
@@ -152,12 +152,12 @@
       };
     }
 
-    function replaceActiveEditorText(text) {
-      return deps.replaceActiveEditorText?.(text) || { ok: false, reason: 'Editor adapter is unavailable' };
+    function replaceActiveEditorText(text, options) {
+      return deps.replaceActiveEditorText?.(text, options) || { ok: false, reason: 'Editor adapter is unavailable' };
     }
 
-    function replaceActiveEditorPatches(patches, nextContent) {
-      return deps.replaceActiveEditorPatches?.(patches, nextContent) || { ok: false, reason: 'Editor adapter is unavailable' };
+    function replaceActiveEditorPatches(patches, nextContent, options) {
+      return deps.replaceActiveEditorPatches?.(patches, nextContent, options) || { ok: false, reason: 'Editor adapter is unavailable' };
     }
 
     function collectElements(selector, limit) {
@@ -266,6 +266,11 @@
         fallbackUserMessage: 'The file changed while Codex was working.',
         fallbackNextAction: 'Review the current file, then rerun the task.'
       },
+      document_identity_mismatch: {
+        stage: 'preflight', severity: 'blocked', defaultRetryable: true,
+        fallbackUserMessage: 'Codex could not confirm that the editor content belongs to the target file, so it was not used.',
+        fallbackNextAction: 'Wait for the target file to open and settle, then retry. Reload Overleaf if this continues.'
+      },
       patch_anchor_not_found: {
         stage: 'preflight', severity: 'blocked', defaultRetryable: true,
         fallbackUserMessage: 'The edit anchor no longer matches current Overleaf content.',
@@ -451,6 +456,10 @@
     const trackedChangeCaptures = [];
     const safeBaseFiles = normalizeBaseFilesForSafety(options.baseFiles);
     const baseFileLookup = window.CodexOverleafStaleGuard?.buildBaseFileLookup(safeBaseFiles);
+    // Binary and unread entries are not independent empty-text references.
+    const provenanceReferences = new Map((Array.isArray(safeBaseFiles) ? safeBaseFiles : [])
+      .filter(file => file.kind !== 'binary' && typeof file.content === 'string')
+      .map(file => [file.path, file.content]));
     const baseBinaryFileLookup = buildBaseBinaryFileLookup(safeBaseFiles);
     // Recheck project identity between awaited operations and before each write.
     const runProjectId = typeof options.runProjectId === 'string' ? options.runProjectId : '';
@@ -490,8 +499,16 @@
     const deadlineFailure = () => Number.isFinite(options.deadlineAt) && now() >= options.deadlineAt
       ? { ok: false, code: 'writeback_deadline_exceeded', changedDocument: false,
         reason: 'The undo time budget expired before this operation could start.' } : null;
-    const editOptions = () => ({ baseFileLookup, runProjectId, deadlineAt: options.deadlineAt,
+    const editOptions = () => ({ baseFileLookup, provenanceReferences, runProjectId, deadlineAt: options.deadlineAt,
       reviewGuard: options.reviewGuard, reviewAwait: options.reviewAwait,
+      recheckEditDispatch: () => {
+        if (readWriteCancellationSequence() !== cancelBaselineSequence) return cancelledSkipResult;
+        if (!writeGuardSurface) return { ok: false, code: 'editor_project_id_unavailable', changedDocument: false };
+        const editorProjectId = writeGuardSurface.getEditorProjectIdPageSide(runProjectId);
+        const code = !runProjectId || !editorProjectId ? 'editor_project_id_unavailable'
+          : editorProjectId !== runProjectId ? 'aborted_project_changed' : '';
+        return code ? writeGuardSurface.abortDispatchResult(code, runProjectId || null, editorProjectId).skipped[0].result : null;
+      },
       recheckWriteProject: writeGuardSurface ? () => {
         const expired = options.reviewGuard?.() || deadlineFailure();
         return expired ? { applied: [], skipped: [{ operation: {}, result: expired }] }
@@ -611,11 +628,54 @@
   const isUntouchedOpenFailure = result => result?.ok === false && result.failure?.code === 'target_file_open_failed'
     && result.failure.changedDocument === false;
 
+  function documentIdentityContext(filePath, projectId = treeOperations.getProjectId?.()) {
+    const target = (deps.resolveTargetDocument || treeOperations.resolveTargetDocument)?.(filePath, { projectId });
+    return { projectId, targetDocumentId: target?.status === 'known' ? target.documentId : '' };
+  }
+
+  function documentProvenance(filePath, text, references, context = documentIdentityContext(filePath)) {
+    const capture = (deps.captureEditorDocument || treeOperations.captureEditorDocument)?.({ path: filePath, projectId: context.projectId });
+    const target = (deps.resolveTargetDocument || treeOperations.resolveTargetDocument)?.(filePath, { projectId: context.projectId });
+    if ((target?.status === 'known' && context.targetDocumentId && target.documentId !== context.targetDocumentId)
+      || (context.projectId && treeOperations.getProjectId?.() !== context.projectId))
+      return { ok: false, code: 'document_identity_mismatch', identityState: 'mismatch' };
+    if (capture?.identityState === 'mismatch' || capture?.reason === 'navigation_conflict') return capture;
+    if (capture?.ok) {
+      const id = capture.documentIdentity.documentId;
+      if (context.targetDocumentId && context.targetDocumentId !== id)
+        return { ok: false, code: 'document_identity_mismatch', identityState: 'mismatch' };
+      context.targetDocumentId = id;
+      return { ok: true, identityState: 'match', capture };
+    }
+    if (typeof text !== 'string') return { ok: false, code: 'document_identity_mismatch', identityState: 'fallback' };
+    return window.CodexOverleafStaleGuard?.assessDocumentProvenance?.({ path: filePath, text, references })
+      || { ok: true, identityState: 'fallback' };
+  }
+
+  async function settleDocumentProvenance(filePath, references, context, deadlineAt = Infinity) {
+    const deadline = Math.min(deadlineAt, Date.now() + TreeOperations.ACTIVE_EDITOR_STABILITY_MS);
+    let result;
+    do {
+      result = documentProvenance(filePath, readActiveEditorText(), references, context);
+      if (result.identityState === 'match' || result.identityState === 'mismatch' || Date.now() >= deadline) return result;
+      await delay(Math.min(50, deadline - Date.now()));
+    } while (Date.now() <= deadline);
+    return result;
+  }
+
+  function documentMismatchResult(filePath, provenance) {
+    const failure = buildPageFailure('document_identity_mismatch', { file: filePath,
+      operationType: 'edit', changedDocument: false,
+      evidence: { matchedPath: provenance.matchedPath, writeStarted: false } });
+    return { ...provenance, reason: failure.userMessage, failure };
+  }
+
   async function applyEditOperation(operation, options = {}) {
     const reviewBlock = options.reviewGuard?.();
     if (reviewBlock) return reviewBlock;
     const currentPath = getActiveFilePath();
-    const editorReady = await awaitReview(options, () => ensureEditorReadyForOperation(operation, options.baseFileLookup, currentPath));
+    const identityContext = documentIdentityContext(operation.path, options.runProjectId);
+    const editorReady = await awaitReview(options, () => ensureEditorReadyForOperation(operation, options.baseFileLookup, currentPath, options.provenanceReferences, identityContext, options.deadlineAt));
     if (!editorReady.ok) {
       return editorReady;
     }
@@ -639,7 +699,7 @@
       options.baseFileLookup
     ) || { ok: true };
     if (!freshness.ok) {
-      const ready = await awaitReview(options, () => waitForFreshEditorTextForOperation(operation, options.baseFileLookup, 1500));
+      const ready = await awaitReview(options, () => waitForFreshEditorTextForOperation(operation, options.baseFileLookup, 1500, identityContext, options.provenanceReferences));
       if (options.reviewGuard?.()) return options.reviewGuard();
       if (!ready.ok) {
         const decorated = attachWritebackDebug(freshness, 'stale_guard', operation, options.baseFileLookup, current, {
@@ -728,6 +788,7 @@
       };
     }
 
+    await awaitReview(options, () => settleDocumentProvenance(operation.path, options.provenanceReferences, identityContext, options.deadlineAt));
     if (options.noTraceUndo === true) {
       const blocked = typeof options.recheckWriteProject === 'function'
         ? await options.recheckWriteProject()
@@ -743,24 +804,40 @@
 
     const finalReviewBlock = options.reviewGuard?.();
     if (finalReviewBlock) return finalReviewBlock;
+    if (Number.isFinite(options.deadlineAt) && now() >= options.deadlineAt)
+      return { ok: false, code: 'writeback_deadline_exceeded', changedDocument: false };
+    if (options.noTraceUndo !== true) {
+      const dispatchBlock = options.recheckEditDispatch?.();
+      if (dispatchBlock) return dispatchBlock;
+      const reviewing = getReviewingState({});
+      if (trackReviewingChanges && !isReviewingConfirmedForWrite(reviewing))
+        return buildReviewingRequiredBlockedResult([operation], reviewing).skipped[0].result;
+      if (!trackReviewingChanges && !isEditingConfirmedForNoTraceUndo(reviewing))
+        return buildEditingRequiredBlockedResult([operation], reviewing).skipped[0].result;
+    }
     // Read and dispatch synchronously against the same document. Navigation,
     // freshness polling and Undo mode/project checks can all have awaited.
-    if (getActiveFilePath() !== operation.path || readActiveEditorText() !== current) {
+    const observedText = readActiveEditorText();
+    const provenance = documentProvenance(operation.path, observedText, options.provenanceReferences, identityContext);
+    const dispatchText = provenance.capture?.text ?? observedText;
+    if (!provenance.ok) return documentMismatchResult(operation.path, provenance);
+    if (getActiveFilePath() !== operation.path || dispatchText !== current) {
       const reason = 'The editor changed before the edit could be applied; the document was not overwritten.';
       return { ok: false, code: 'stale_source_changed', reason,
         failure: buildPageFailure('stale_source_changed', { file: operation.path,
           operationType: options.noTraceUndo ? 'undo' : 'edit', changedDocument: false, userMessage: reason }) };
     }
     const result = Array.isArray(operation.patches) && operation.patches.length
-      ? replaceActiveEditorPatches(preparedPatches.patches, nextContent)
-      : replaceActiveEditorText(nextContent);
+      ? replaceActiveEditorPatches(preparedPatches.patches, nextContent, { expectedCapture: provenance.capture })
+      : replaceActiveEditorText(nextContent, { expectedCapture: provenance.capture });
     if (!result.ok) {
       return result;
     }
 
     const verifyWaitMs = Math.min(deps.writeVerifyWaitMs ?? 2500, Number.isFinite(options.deadlineAt)
       ? Math.max(0, options.deadlineAt - now()) : Infinity);
-    const verified = await verifyActiveEditorText(nextContent, operation.path, verifyWaitMs, current);
+    const verified = await verifyActiveEditorText(nextContent, operation.path, verifyWaitMs, current,
+      { ...identityContext, requireIdentity: provenance.identityState === 'match', references: options.provenanceReferences });
     if (!verified.ok) {
       const decorated = attachWritebackDebug(verified, 'write_verification', operation, options.baseFileLookup, readActiveEditorText(), {
         initialActivePath: currentPath,
@@ -849,17 +926,19 @@
     };
   }
 
-  async function verifyActiveEditorText(expected, filePath, waitMs = 1000, before) {
+  async function verifyActiveEditorText(expected, filePath, waitMs = 1000, before, identityContext = documentIdentityContext(filePath)) {
     const deadline = Date.now() + waitMs;
-    let actual = readActiveEditorText();
-    while (actual !== expected && Date.now() < deadline) {
-      await delay(50);
+    const fallbackAt = Math.min(deadline, Date.now() + TreeOperations.ACTIVE_EDITOR_STABILITY_MS);
+    let actual, provenance, identityConfirmed = false;
+    while (true) {
       actual = readActiveEditorText();
-    }
-    if (actual === expected) {
-      return {
-        ok: true
-      };
+      provenance = documentProvenance(filePath, actual, identityContext.references, identityContext);
+      actual = provenance.capture?.text ?? actual;
+      identityConfirmed = provenance.ok && getActiveFilePath() === filePath
+        && (provenance.identityState === 'match' || (!identityContext.requireIdentity && Date.now() >= fallbackAt));
+      if (identityConfirmed && actual === expected) return { ok: true };
+      if (Date.now() >= deadline) break;
+      await delay(Math.min(50, deadline - Date.now()));
     }
     return {
       ok: false,
@@ -867,7 +946,8 @@
       reason: `${filePath || '当前文件'} 写入后读回内容和 Codex 预期不一致，已停止把这次操作标记为成功。请刷新 Overleaf 后重试。`,
       expectedLength: String(expected || '').length,
       actualLength: String(actual || '').length,
-      evidence: describeReadbackMismatch(expected, actual, before, filePath)
+      evidence: { ...describeReadbackMismatch(expected, actual, before, filePath),
+        activeMatchesTarget: identityConfirmed, identityState: provenance.identityState }
     };
   }
 
@@ -897,7 +977,8 @@
     return hash.toString(16).padStart(8, '0');
   }
 
-  async function ensureEditorReadyForOperation(operation, baseFileLookup, initialActivePath) {
+  async function ensureEditorReadyForOperation(operation, baseFileLookup, initialActivePath, provenanceReferences,
+    identityContext = documentIdentityContext(operation.path), deadlineAt = Infinity) {
     if (!operation?.path) {
       return {
         ok: true,
@@ -912,6 +993,7 @@
     const currentText = readActiveEditorText();
     const previousEditorIdentity = getActiveEditorIdentity();
     const previousSignature = contentSignature(currentText);
+    const initialProvenance = documentProvenance(filePath, currentText, provenanceReferences, identityContext);
 
     const opened = await openFileByPath(filePath, { force: initialActivePath === filePath });
     if (!opened.ok) {
@@ -956,7 +1038,11 @@
     }
 
     return waitForEditorContentForPath(filePath, previousEditorIdentity, baseFileLookup, 9000, {
+      identityContext,
+      deadlineAt,
       initialActivePath,
+      initialProvenance,
+      provenanceReferences,
       previousSignature,
       forceSettledOpen: true,
       openedMethod: opened.method || ''
@@ -964,11 +1050,13 @@
   }
 
   async function waitForEditorContentForPath(filePath, previousEditorIdentity, baseFileLookup, timeoutMs, options = {}) {
-    const deadline = Date.now() + timeoutMs;
+    const deadline = Math.min(options.deadlineAt ?? Infinity, Date.now() + timeoutMs);
     const startedAt = Date.now();
+    const identityDeadline = Math.min(deadline, startedAt + Math.min(1500, writebackOpenSettleMs || TreeOperations.ACTIVE_EDITOR_STABILITY_MS));
     const minSettleMs = options.forceSettledOpen ? writebackOpenSettleMs : 0;
     let lastText = readActiveEditorText();
     let lastActivePath = getActiveFilePath();
+    let mismatch = null;
     while (Date.now() < deadline) {
       lastActivePath = getActiveFilePath();
       lastText = readActiveEditorText();
@@ -977,21 +1065,28 @@
       const settledLongEnough = Date.now() - startedAt >= minSettleMs;
       const contentChangedFromPrevious = !options.previousSignature
         || contentSignature(lastText) !== options.previousSignature;
+      const provenance = documentProvenance(filePath, lastText, options.provenanceReferences, options.identityContext);
+      lastText = provenance.capture?.text ?? lastText;
+      mismatch = provenance.ok ? null : provenance;
       // Confirm navigation independently of source freshness. A stale target
       // can be correctly open; identical baseline bytes alone cannot prove a
       // switch. Content movement remains the fallback for editor lifecycles
       // whose document identity cannot be observed reliably.
-      const switchConfirmed = identityChanged
-        || options.initialActivePath === filePath
+      const switchConfirmed = provenance.identityState === 'match' || identityChanged
+        || (options.initialActivePath === filePath && Boolean(previousEditorIdentity)
+          && options.initialProvenance?.ok === true && provenance.ok)
         || (contentChangedFromPrevious && settledLongEnough);
-      if (activeFileMatches && switchConfirmed && settledLongEnough) {
+      if (activeFileMatches && switchConfirmed && settledLongEnough && provenance.ok
+        && (provenance.identityState === 'match' || Date.now() >= identityDeadline)) {
         return {
           ok: true,
-          text: lastText
+          text: lastText,
+          capture: provenance.capture
         };
       }
-      await delay(100);
+      await delay(Math.max(0, Math.min(100, deadline - Date.now())));
     }
+    if (mismatch) return documentMismatchResult(filePath, mismatch);
     // §9.1: if the active file ended up on a different document, this is
     // target_file_not_active; if the file did become active but the editor
     // document never settled, this is target_editor_not_ready.
@@ -1036,21 +1131,30 @@
     const minSettleMs = options.forceSettledOpen ? writebackOpenSettleMs : 0;
     let lastText = readActiveEditorText();
     let lastActivePath = getActiveFilePath();
+    const identityContext = options.identityContext || documentIdentityContext(filePath);
+    let mismatch = null;
     while (Date.now() < deadline) {
       lastActivePath = getActiveFilePath();
       lastText = readActiveEditorText();
+      const provenance = documentProvenance(filePath, lastText, options.references, identityContext);
+      lastText = provenance.capture?.text ?? lastText;
+      mismatch = provenance.ok ? null : provenance;
       const activeFileMatches = lastActivePath === filePath;
       const identityChanged = Boolean(previousEditorIdentity) && activeEditorIdentityChanged(previousEditorIdentity);
       const settledLongEnough = Date.now() - startedAt >= minSettleMs;
       const sameFileReopenSettled = options.initialActivePath === filePath && settledLongEnough;
-      if (activeFileMatches && settledLongEnough && (identityChanged || sameFileReopenSettled)) {
+      if (activeFileMatches && settledLongEnough && provenance.ok
+        && (provenance.identityState === 'match' || Date.now() - startedAt >= TreeOperations.ACTIVE_EDITOR_STABILITY_MS)
+        && (provenance.identityState === 'match' || identityChanged || sameFileReopenSettled)) {
         return {
           ok: true,
-          text: lastText
+          text: lastText,
+          capture: provenance.capture
         };
       }
-      await delay(100);
+      await delay(Math.max(0, Math.min(100, deadline - Date.now())));
     }
+    if (mismatch) return documentMismatchResult(filePath, mismatch);
     return {
       ok: false,
       code: 'editor_document_not_switched',
@@ -1065,24 +1169,27 @@
     return normalized.trim().length === 0 ? '' : normalized;
   }
 
-  async function waitForFreshEditorTextForOperation(operation, baseFileLookup, waitMs = 1500) {
+  async function waitForFreshEditorTextForOperation(operation, baseFileLookup, waitMs = 1500, identityContext, references) {
     const deadline = Date.now() + Math.max(0, Number(waitMs) || 0);
     while (Date.now() < deadline) {
       if (operation?.path && getActiveFilePath() !== operation.path) {
         await delay(60);
         continue;
       }
-      const text = readActiveEditorText();
+      const observed = readActiveEditorText();
+      const provenance = documentProvenance(operation.path, observed, references, identityContext);
+      const text = provenance.capture?.text ?? observed;
       const freshness = window.CodexOverleafStaleGuard?.checkOperationFreshness(
         operation,
         text,
         baseFileLookup
       ) || { ok: true };
-      if (freshness.ok) {
+      if (freshness.ok && provenance.ok) {
         return {
           ok: true,
           text,
-          freshness
+          freshness,
+          capture: provenance.capture
         };
       }
       await delay(60);
@@ -1431,6 +1538,7 @@
     const expected = options.baseFileLookup?.get(operation.path);
     const text = proof?.v === 1 && proof.kind === 'text' && typeof expected === 'string';
     const binary = proof?.v === 1 && proof.kind === 'binary' && /^[a-f0-9]{64}$/i.test(proof.sha256 || '');
+    const identityContext = documentIdentityContext(operation.path, projectId);
     const isCurrent = () => Boolean(projectId) && projectId === options.runProjectId
       && treeOperations.getProjectId?.() === projectId && readWriteCancellationSequence() === cancellation && !options.reviewGuard?.();
     if (!isCurrent() || (!text && !binary) || typeof deps.deleteTextFile !== 'function') {
@@ -1438,7 +1546,7 @@
         reason: 'Verified created-file deletion is unavailable for this run.' };
     }
     if (text && projectPathExists(operation.path)) {
-      const current = await readCurrentTextFileForFreshness(operation.path);
+      const current = await readCurrentTextFileForFreshness(operation.path, options.baseFileLookup);
       if (!current.ok || current.text !== expected || !isCurrent()) {
         return { ok: false, code: 'undo_operation_failed', changedDocument: false,
           reason: 'The created file changed after this run and was left untouched.' };
@@ -1447,9 +1555,10 @@
     const result = await deps.deleteTextFile(operation, {
       isCurrent, undoCreatedFile: true, deadlineAt: options.deadlineAt,
       expectedContent: text ? expected : undefined,
-      prepareTextPreimage: text ? () => readCurrentTextFileForFreshness(operation.path) : undefined,
+      prepareTextPreimage: text ? () => readCurrentTextFileForFreshness(operation.path, options.baseFileLookup) : undefined,
       expectedSha256: binary ? proof.sha256.toLowerCase() : undefined,
       canDelete: () => isCurrent() && (binary || (treeOperations.getActiveFilePath?.() === operation.path
+        && documentProvenance(operation.path, readActiveEditorText(), options.baseFileLookup, identityContext).ok
         && readActiveEditorText() === expected))
     });
     if (!result.ok) return result;
@@ -1552,7 +1661,7 @@
       };
     }
 
-    const current = await readCurrentTextFileForFreshness(operation.path);
+    const current = await readCurrentTextFileForFreshness(operation.path, baseFileLookup);
     if (!current.ok) {
       return current;
     }
@@ -1579,13 +1688,14 @@
     return { ok: true };
   }
 
-  async function readCurrentTextFileForFreshness(filePath) {
+  async function readCurrentTextFileForFreshness(filePath, references) {
     const normalizedPath = normalizeSafeProjectPath(filePath);
     if (!normalizedPath) {
       return invalidProjectPathResult('freshness path');
     }
     const currentPath = getActiveFilePath();
     const previousEditorIdentity = getActiveEditorIdentity();
+    const identityContext = documentIdentityContext(normalizedPath);
     const opened = await openFileByPath(normalizedPath, { force: true });
     if (!opened.ok) {
       return {
@@ -1595,6 +1705,8 @@
       };
     }
     const ready = await waitForEditorDocumentForPath(normalizedPath, previousEditorIdentity, 9000, {
+      identityContext,
+      references,
       initialActivePath: currentPath,
       forceSettledOpen: true
     });

package/extension/src/pageBridge.js

@@ -58,6 +58,8 @@
     document,
     getActiveFilePathFromEditorStore,
     getActiveEditorIdentity,
+    getCodeMirrorEditorView,
+    getCodeMirrorEditorViews: () => codeMirrorEditorViewCandidates().map(([, view]) => view).filter(isCodeMirrorEditorView),
     normalizePath: normalizeSafeProjectPath,
     readActiveEditorText,
     window
@@ -97,6 +99,11 @@
   projectSnapshotBridge = window.CodexOverleafProjectSnapshot.create({
     buildProjectFileList: snapshotRouter.buildProjectFileList,
     buildProjectSnapshot: snapshotRouter.buildProjectSnapshot,
+    getSnapshotEditorCaptures: snapshotRouter.getSnapshotEditorCaptures,
+    captureEditorDocument: treeOperations.captureEditorDocument,
+    isCaptureCurrent: treeOperations.isCaptureCurrent,
+    getActiveFilePath,
+    getActiveEditorIdentity,
     getProjectId,
     normalizePath: normalizeSafeProjectPath,
     window
@@ -1675,21 +1682,21 @@
     return editorAdapter.readActiveEditorText();
   }
 
-  function replaceActiveEditorText(text) {
-    return editorAdapter.replaceActiveEditorText(text);
+  function replaceActiveEditorText(text, options) {
+    return editorAdapter.replaceActiveEditorText(text, options);
   }
 
-  function replaceActiveEditorPatches(patches, nextContent) {
-    return editorAdapter.replaceActiveEditorPatches(patches, nextContent);
+  function replaceActiveEditorPatches(patches, nextContent, options) {
+    return editorAdapter.replaceActiveEditorPatches(patches, nextContent, options);
   }
 
   function getCodeMirrorEditorView() {
     return findCodeMirrorEditorView()?.view || null;
   }
 
-  function findCodeMirrorEditorView() {
+  function codeMirrorEditorViewCandidates() {
     const store = getOverleafUnstableStore();
-    const candidates = [
+    return [
       ['store:editor.view', readStoreValue(store, 'editor.view')],
       ['store:editor.view.camel', readStoreValue(store, 'editor.view.camel')],
       ['store:editor', readStoreValue(store, 'editor').view],
@@ -1698,7 +1705,10 @@
       ['window._ide.editorView', window._ide?.editorView]
     ];
 
-    for (const [source, candidate] of candidates) {
+  }
+
+  function findCodeMirrorEditorView() {
+    for (const [source, candidate] of codeMirrorEditorViewCandidates()) {
       if (isCodeMirrorEditorView(candidate)) {
         return {
           view: candidate,

package/extension/src/shared/agentTranscript.js

@@ -166,6 +166,9 @@
     "timeout": {
       "message": "timed out"
     },
+    "native_request_timeout": {
+      "code": "native_request_timeout"
+    },
     "output_limit": {
       "message": "output limit exceeded"
     },
@@ -182,7 +185,7 @@
       "message": "unsupported_parameter reasoning.summary"
     },
     "storage_quota": {
-      "message": "quota"
+      "message": "storage quota"
     },
     "checkpoint": {
       "message": "checkpoint"
@@ -220,6 +223,9 @@
     "provider_rate_limited": {
       "message": "provider_rate_limited"
     },
+    "provider_quota_exceeded": {
+      "message": "provider_quota_exceeded"
+    },
     "provider_connection_timeout": {
       "message": "provider_connection_timeout"
     },
@@ -865,6 +871,14 @@
         nextEn: 'Switch between Responses and Chat Completions, or test again with Auto detection.',
         code: 'provider_protocol_incompatible'
       },
+      {
+        pattern: /provider_quota_exceeded|insufficient_quota|exceeded your current quota|(?:billing|usage|spend(?:ing)?|credit)[_ -]?(?:hard[_ -]?)?limit[_ -]?(?:reached|exceeded)|(?:billing|plan).{0,40}(?:quota|limit|exhausted)|(?:quota|credits?).{0,40}(?:billing|plan|exhausted|insufficient)/i,
+        conclusionZh: '模型服务的配额或账单限额已达到。',
+        conclusionEn: 'The model provider quota or billing limit was reached.',
+        nextZh: '请检查模型服务账户和套餐，或切换模型或模型服务后重试。',
+        nextEn: 'Check the provider account and plan, or switch model or provider before retrying.',
+        code: 'provider_quota_exceeded'
+      },
       {
         pattern: /provider_rate_limited|rate limit was reached/i,
         conclusionZh: '这轮没有完成：第三方模型服务触发了限流。',
@@ -951,6 +965,13 @@
     // failure data alongside the human-readable text. The string text is kept
     // verbatim because it has mode-aware nuance (e.g. "No files were written"
     // vs "This run did not start") the catalog's fallback strings don't capture.
+    if (context.code === 'native_request_timeout' || /native_request_timeout/i.test(text)) {
+      return {
+        conclusion: textFor(locale, '本机服务没有响应。', 'The local service did not respond.'),
+        nextStep: textFor(locale, '请重试，或打开「诊断」检查本机连接。', 'Retry, or open Diagnostics to check the local connection.'),
+        failureCode: 'native_request_timeout'
+      };
+    }
     if (context.code === 'codex_local_skill_unavailable' || /(?:The )?selected local Codex skill is unavailable/i.test(text)) {
       return {
         conclusion: textFor(locale, '所选 Codex 本地技能不可用或已关闭，本轮没有启动。', 'The selected local Codex skill is unavailable or disabled. This run did not start.'),
@@ -1044,7 +1065,7 @@
         failureCode: 'native_protocol_incompatible'
       };
     }
-    if (/quota|kQuotaBytes|QUOTA_BYTES/i.test(text)) {
+    if (/kQuotaBytes|QUOTA_BYTES|QuotaExceededError|storage quota/i.test(text)) {
       return {
         conclusion: textFor(locale, 'Codex 结果已经生成，但本地会话记录超出 Chrome 存储配额。', 'Codex produced a result, but local session history exceeded Chrome storage quota.'),
         nextStep: textFor(locale, '请删除一些旧 session，或刷新扩展后重试；这不是论文分析本身失败。', 'Delete older sessions or reload the extension and retry. The paper analysis itself did not fail.'),

package/extension/src/shared/auditRecords.js

@@ -261,6 +261,7 @@
   }
 
   function summarizeMirror(mirror = {}) {
+    mirror = mirror ?? { status: 'unavailable' };
     const files = Array.isArray(mirror.files) ? mirror.files : [];
     const skippedFiles = Array.isArray(mirror.skippedFiles) ? mirror.skippedFiles : [];
     return removeEmptySummaryFields({

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.6.0';
+  const BUILD_TARGET_VERSION = '2.6.5';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',

package/extension/src/shared/composerAttachmentDraft.js

@@ -5,6 +5,13 @@
   'use strict';
   const EPOCH_KEY = 'composer-attachment-draft:clear-epoch';
   const normalize = value => SessionState.normalizeComposerAttachmentsForPersistence(value);
+  function normalizeOmitted(value) {
+    const names = (Array.isArray(value?.names) ? value.names : [])
+      .filter(name => typeof name === 'string')
+      .map(name => name.replace(/\0/g, '').trim().slice(0, 180))
+      .filter(Boolean).slice(0, 8);
+    return { count: names.length, names };
+  }
   const scopeKey = scope => JSON.stringify([scope?.accountScopeId || '', scope?.projectId || '']);
   function checkedScope(scope) {
     const accountScopeId = String(scope?.accountScopeId || '').trim();
@@ -42,25 +49,28 @@
                 throw failure('account_scope_unavailable');
               }
               const revision = Number(previous?.revision) || 0;
-              result = { epoch, clearedAt, revision, attachments: normalize(previous?.attachments) };
+              result = { epoch, clearedAt, revision, attachments: normalize(previous?.attachments), omittedAttachments: normalizeOmitted(previous?.omittedAttachments) };
               if (!value) return;
               const attachments = normalize(value.attachments);
+              const omittedAttachments = normalizeOmitted(value.omittedAttachments);
+              const hasDraft = attachments.length || omittedAttachments.count;
               if (value.epoch !== epoch) {
                 // A clear performed by this page also invalidates its old base.
                 // Its empty draft needs no write; an old nonempty draft cannot return.
-                if (!attachments.length) return;
+                if (!hasDraft) return;
                 throw failure('composer_draft_cleared');
               }
               if (value.revision !== revision) {
                 // Writing what another tab already stored changes nothing (for example
                 // both tabs clearing an empty draft on send); only a real edit conflicts.
-                if (JSON.stringify(attachments) === JSON.stringify(result.attachments)) return;
+                if (JSON.stringify(attachments) === JSON.stringify(result.attachments)
+                  && JSON.stringify(omittedAttachments) === JSON.stringify(result.omittedAttachments)) return;
                 throw failure('composer_draft_conflict');
               }
-              if (attachments.length && value.unbased && clearedAt && value.changedAt <= clearedAt) {
+              if (hasDraft && value.unbased && clearedAt && value.changedAt <= clearedAt) {
                 throw failure('composer_draft_cleared');
               }
-              result = { epoch, clearedAt, revision: revision + 1, attachments };
+              result = { epoch, clearedAt, revision: revision + 1, attachments, omittedAttachments };
               store.put({ id, type: 'composer-attachment-draft', ...scope, ...result });
             } catch (caught) { error = caught; tx.abort(); }
           };
@@ -120,7 +130,11 @@
       syncScope();
       if (hydrated) return;
       // Loading is allowed to finish after a local add/remove. Local edits win.
-      if (!changedVersion && !options.getAttachments().length) options.restore(normalize(attachments));
+      if (!changedVersion && !options.getAttachments().length) {
+        options.restore(normalize(attachments));
+        const omitted = normalizeOmitted(base?.omittedAttachments);
+        if (omitted.count) options.onRestoreOmittedAttachments?.(omitted);
+      }
       hydrated = true; publish();
     }
     function changed() {
@@ -138,10 +152,11 @@
         if (captured !== generation || scopeKey(options.getScope()) !== key || changedVersion === savedVersion) return;
         const version = changedVersion;
         const attachments = normalize(options.getAttachments());
+        const omittedAttachments = normalizeOmitted({ names: options.getOmittedAttachmentNames?.() });
         const unbased = dirtyUnbased, changedAt = dirtySince;
         if (!base) await load(scope);
         if (captured !== generation || scopeKey(options.getScope()) !== key) return;
-        const written = await options.write(checkedScope(scope), { ...base, attachments, unbased, changedAt });
+        const written = await options.write(checkedScope(scope), { ...base, attachments, omittedAttachments, unbased, changedAt });
         if (captured !== generation) return;
         base = written; savedVersion = version;
         if (changedVersion === version) { dirtySince = 0; dirtyUnbased = false; }