codex-overleaf-link 2.5.0 → 2.5.1

package/extension/src/shared/undoOperations.js

@@ -1,10 +1,10 @@
 (function initUndoOperations(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('./staleGuard'));
   } else {
-    root.CodexOverleafUndoOperations = factory();
+    root.CodexOverleafUndoOperations = factory(root.CodexOverleafStaleGuard);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function undoOperationsFactory() {
+})(typeof globalThis !== 'undefined' ? globalThis : window, function undoOperationsFactory(StaleGuard) {
   'use strict';
 
   function buildUndoOperations(project, appliedOperations) {
@@ -15,6 +15,7 @@
       }
     }
 
+    const sourceFilesByPath = new Map(workingFilesByPath);
     const undo = [];
     const fullRestoreEditPaths = new Set();
 
@@ -29,7 +30,8 @@
         }
         const currentBeforeEdit = workingFilesByPath.get(operation.path);
         if (!fullRestoreEditPaths.has(operation.path)) {
-          const inversePatches = buildInverseTextPatches(currentBeforeEdit, operation.patches);
+          const inversePatches = buildInverseTextPatches(sourceFilesByPath.get(operation.path), operation.patches,
+            operation.verifiedContent, operation.path);
           if (inversePatches.length) {
             undo.push(normalizeUndoOperation({
               type: 'edit',
@@ -70,10 +72,13 @@
         if (!operation.path || !operation.to) {
           continue;
         }
+        if (operation.moveProof && !operation.moveProof.targetEntityId) continue;
         undo.push(normalizeUndoOperation({
           type: 'move',
           path: operation.to,
           to: operation.path,
+          ...(operation.moveProof ? { moveProof: { ...operation.moveProof,
+            sourceEntityId: operation.moveProof.targetEntityId, targetEntityId: operation.moveProof.sourceEntityId } } : {}),
           reason: 'Undo move'
         }));
       } else if (operation.type === 'delete') {
@@ -89,12 +94,13 @@
       }
 
       applyOperationToFiles(workingFilesByPath, operation);
+      applyOperationToFiles(sourceFilesByPath, { ...operation, verifiedContent: undefined });
     }
 
     return undo.reverse();
   }
 
-  function buildInverseTextPatches(textBeforeEdit, patches) {
+  function buildInverseTextPatches(textBeforeEdit, patches, verifiedContent, path) {
     if (!Array.isArray(patches) || !patches.length) {
       return [];
     }
@@ -108,7 +114,7 @@
     }
 
     let offset = 0;
-    return normalized.patches.map(patch => {
+    const inverse = normalized.patches.map(patch => {
       const from = patch.from + offset;
       const to = from + patch.insert.length;
       offset += patch.insert.length - (patch.to - patch.from);
@@ -119,6 +125,41 @@
         insert: patch.expected
       };
     });
+    if (typeof verifiedContent !== 'string' || verifiedContent === applied.text) return inverse;
+    // The stored checkpoint uses the verified editor post-image. Its inverse
+    // must use those same offsets, while Native patches retain their source
+    // representation for later operations in the batch.
+    const prepared = StaleGuard.prepareOperationPatches({ type: 'edit', path, patches: inverse }, verifiedContent,
+      StaleGuard.buildBaseFileLookup([{ path, content: applied.text }]));
+    return prepared.ok && applyTextPatches(verifiedContent, prepared.patches).ok ? prepared.patches : [];
+  }
+
+  function selectExpectedFilesForTrackedUndo(project, operations = [], trackedChanges = [], previousExpectedFiles = []) {
+    const paths = new Set();
+    for (const change of trackedChanges || []) if (change?.path) paths.add(change.path);
+    for (const operation of operations || []) {
+      if (operation?.path) paths.add(operation.path);
+      if (operation?.to) paths.add(operation.to);
+    }
+    const expectedByPath = new Map();
+    for (const file of previousExpectedFiles || []) {
+      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
+        expectedByPath.set(file.path, { path: file.path, content: file.content });
+      }
+    }
+    // Reconstruct the pre-image with the same inverse patches as plain Undo.
+    // This preserves the editor's unchanged line endings and collaborator
+    // content, including when the ZIP baseline used a different representation.
+    const hasVerifiedPatches = operations.some(operation => typeof operation?.verifiedContent === 'string'
+      && Array.isArray(operation.patches) && operation.patches.length);
+    const checkpoint = hasVerifiedPatches ? buildUndoCheckpoint(project, operations) : null;
+    const restored = checkpoint ? buildExpectedFilesAfterOperations({ files: checkpoint.undoBaseFiles }, checkpoint.undoOperations) : new Map();
+    for (const file of project?.files || []) {
+      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
+        expectedByPath.set(file.path, { path: file.path, content: restored.get(file.path) ?? file.content });
+      }
+    }
+    return Array.from(expectedByPath.values());
   }
 
   function buildUndoCheckpoint(project, appliedOperations) {
@@ -140,9 +181,9 @@
       const proof = operation?.undoCreatedFile;
       if (operation?.type !== 'delete' || proof?.v !== 1) continue;
       if (proof.kind === 'text' && priorFiles.has(operation.path)) {
-        created.set(operation.path, { kind: 'text', content: priorFiles.get(operation.path) });
+        created.set(operation.path, { kind: 'text', content: priorFiles.get(operation.path), createdDirectories: proof.createdDirectories });
       } else if (proof.kind === 'binary' && /^[a-f0-9]{64}$/i.test(proof.sha256 || '')) {
-        created.set(operation.path, { kind: 'binary', sha256: proof.sha256.toLowerCase() });
+        created.set(operation.path, { kind: 'binary', sha256: proof.sha256.toLowerCase(), createdDirectories: proof.createdDirectories });
       }
     }
     for (const operation of appliedOperations || []) {
@@ -152,17 +193,17 @@
         if (originalPaths.has(path) && !created.has(path)) continue;
         if (operation.type === 'create' && typeof operation.content === 'string') {
           created.set(path, { kind: 'text', content: typeof operation.verifiedContent === 'string'
-            ? operation.verifiedContent : operation.content });
+            ? operation.verifiedContent : operation.content, createdDirectories: operation.createdDirectories });
         } else {
           const hash = operation.sha256 || operation.assetRef?.sha256;
           if (operation.previousExists !== true && /^[a-f0-9]{64}$/i.test(hash || '')) {
-            created.set(path, { kind: 'binary', sha256: hash.toLowerCase() });
+            created.set(path, { kind: 'binary', sha256: hash.toLowerCase(), createdDirectories: operation.createdDirectories });
           }
         }
       } else if (operation.type === 'edit' && created.get(path)?.kind === 'text') {
         const files = new Map([[path, created.get(path).content]]);
         applyOperationToFiles(files, operation);
-        created.set(path, { kind: 'text', content: files.get(path) });
+        created.set(path, { ...created.get(path), kind: 'text', content: files.get(path) });
       } else if (['delete', 'rename', 'move', 'overwrite-binary'].includes(operation.type)) {
         // Existing rename/overwrite recovery retains ownership of these cases.
         created.delete(path);
@@ -173,17 +214,78 @@
     for (const [path, proof] of Array.from(created).reverse()) {
       const undoCreatedFile = proof.kind === 'binary'
         ? { v: 1, kind: 'binary', sha256: proof.sha256 } : { v: 1, kind: 'text' };
+      if (Array.isArray(proof.createdDirectories) && proof.createdDirectories.length) {
+        undoCreatedFile.createdDirectories = proof.createdDirectories.map(item => ({ ...item }));
+      }
       undoOperations.push({ ...normalizeUndoOperation({ type: 'delete', path, reason: 'Undo create' }), undoCreatedFile });
       if (proof.kind === 'text') undoBaseFiles.push({ path, content: proof.content });
     }
+    // Reviewing has no text insertion/deletion refs for a native metadata move.
+    // Keep its identity-bound inverse with the other file-level proofs.
+    undoOperations.push(...buildUndoOperations(project, appliedOperations).filter(operation => operation.type === 'move' && operation.moveProof));
     return { undoOperations, undoBaseFiles };
   }
 
+  function isFileUndoOperation(operation) {
+    return operation?.undoCreatedFile?.v === 1
+      || (operation?.type === 'move' && operation.moveProof?.v === 1)
+      || (operation?.type === 'create' && typeof operation.content === 'string');
+  }
+
+  // A deleted original has no editor post-image. Its inverse is a guarded
+  // file creation, backed by both the forward delete and the captured original.
+  // This also recovers older Track-on records that omitted that inverse.
+  function getFileUndoOperations(run = {}) {
+    const operations = (run.undoOperations || []).filter(isFileUndoOperation);
+    const before = filesListToMap(run.undoExpectedFiles);
+    const after = buildExpectedFilesAfterOperations({ files: run.undoExpectedFiles }, run.appliedOperations);
+    const deleted = new Set((run.appliedOperations || []).filter(operation => operation?.type === 'delete'
+      && before.has(operation.path) && !after.has(operation.path)).map(operation => operation.path));
+    return [...operations.filter(operation => !deleted.has(operation.path)), ...Array.from(deleted, path =>
+      normalizeUndoOperation({ type: 'create', path, content: before.get(path), reason: 'Undo delete' }))];
+  }
+
+  function prepareRunUndo(run = {}) {
+    const files = getFileUndoOperations(run);
+    const restored = new Set(files.filter(operation => operation.type === 'create').map(operation => operation.path));
+    const pending = [...files], operations = [];
+    for (const operation of run.undoOperations || []) {
+      if (isFileUndoOperation(operation)) {
+        const index = pending.findIndex(file => file.path === operation.path && file.type === operation.type);
+        if (index >= 0) operations.push(...pending.splice(index, 1));
+      } else if (!restored.has(operation.path)) operations.push(operation);
+    }
+    return { ...run, undoOperations: [...operations, ...pending] };
+  }
+
+  function textUndoRun(run = {}) {
+    const restored = new Set(getFileUndoOperations(run).flatMap(operation => operation.type === 'create' ? [operation.path]
+      : operation.type === 'move' ? [operation.path, operation.to] : []));
+    return { ...run,
+      undoExpectedFiles: (run.undoExpectedFiles || []).filter(file => !restored.has(file.path)),
+      undoTrackedChanges: (run.undoTrackedChanges || []).filter(ref => !restored.has(ref.path))
+    };
+  }
+
+  function mergeFileUndoResult(textResult, fileResult, operations) {
+    const applied = [...(textResult.applied || []), ...(fileResult.applied || [])];
+    const skipped = [...(textResult.skipped || []), ...(fileResult.skipped || [])];
+    for (const operation of operations) {
+      if (!(fileResult.applied || []).some(entry => entry.operation?.path === operation.path
+        && entry.operation?.type === operation.type && entry.result?.ok === true && entry.result?.verified === true
+        && entry.result.verification === 'overleaf-zip')
+        && !(fileResult.skipped || []).some(entry => entry.operation?.path === operation.path)) {
+        skipped.push({ operation, result: { ok: false, code: 'undo_operation_failed',
+          reason: 'The file restoration has no verified server receipt.' } });
+      }
+    }
+    return { ...textResult, ok: textResult.ok !== false && fileResult.ok !== false && !skipped.length, applied, skipped };
+  }
+
   // Consume only independently verified rollback receipts. Forward writes
   // remain audit evidence; recovery arrays describe only unfinished work.
   function advanceUndoCheckpoint(run = {}, result = {}, verifyText = () => false) {
     const operations = Array.isArray(run?.undoOperations) ? run.undoOperations : [];
-    if (!operations.some(operation => operation?.undoCreatedFile?.v === 1)) return run;
     const applied = Array.isArray(result.applied) ? result.applied : [];
     const skipped = Array.isArray(result.skipped) ? result.skipped : [];
     const failed = path => skipped.some(entry => {
@@ -201,8 +303,22 @@
         && JSON.stringify(entry.operation.undoCreatedFile) === JSON.stringify(operation.undoCreatedFile)
         && entry.result?.ok === true && entry.result.verified === true
         && entry.result.verification === 'overleaf-zip')).map(operation => operation.path));
+    const restoredPaths = new Set(operations.filter(operation => operation?.type === 'create'
+      && !failed(operation.path) && applied.some(entry => entry?.operation?.type === 'create'
+        && entry.operation.path === operation.path && entry.operation.content === operation.content
+        && entry.result?.ok === true && entry.result.verified === true
+        && entry.result.verification === 'overleaf-zip')).map(operation => operation.path));
+    const movedPaths = new Set(operations.filter(operation => operation?.type === 'move' && operation.moveProof?.v === 1
+      && !failed(operation.path) && applied.some(entry => entry?.operation?.type === 'move'
+        && entry.operation.path === operation.path && entry.operation.to === operation.to
+        && JSON.stringify(entry.operation.moveProof) === JSON.stringify(operation.moveProof)
+        && entry.result?.ok === true && entry.result.verified === true && entry.result.verification === 'overleaf-zip'))
+      .flatMap(operation => [operation.path, operation.to]));
+    for (const path of restoredPaths) textPaths.add(path);
+    for (const path of movedPaths) textPaths.add(path);
     if (!textPaths.size && !deletedPaths.size) return run;
-    const pending = operations.filter(operation => !(operation?.type === 'edit' && textPaths.has(operation.path))
+    const pending = operations.filter(operation => !restoredPaths.has(operation.path) && !(operation?.type === 'edit' && textPaths.has(operation.path))
+      && !(operation?.type === 'move' && movedPaths.has(operation.path))
       && !(operation?.type === 'delete' && operation.undoCreatedFile?.v === 1 && deletedPaths.has(operation.path)));
     const needed = new Set(pending.flatMap(operation => [operation?.path, operation?.to]).filter(Boolean));
     return { ...run,
@@ -396,6 +512,7 @@
         insert: String(patch.insert ?? '')
       }));
     }
+    if (operation.type === 'move' && operation.moveProof?.v === 1) normalized.moveProof = JSON.parse(JSON.stringify(operation.moveProof));
     return normalized;
   }
 
@@ -454,11 +571,17 @@
   }
 
   return {
+    isFileUndoOperation,
+    getFileUndoOperations,
+    prepareRunUndo,
+    textUndoRun,
+    mergeFileUndoResult,
     buildUndoCheckpoint,
     buildCreatedFileUndoCheckpoint,
     advanceUndoCheckpoint,
     buildExpectedFilesAfterOperations,
     buildUndoOperations,
+    selectExpectedFilesForTrackedUndo,
     buildSnapshotRestoreUndo
   };
 });

package/extension/src/shared/updateConsent.js

@@ -78,6 +78,7 @@
       deadlineAt: finiteNumber(value.deadlineAt),
       heartbeatAt: finiteNumber(value.heartbeatAt),
       postponeUntil: finiteNumber(value.postponeUntil),
+      cooldownUntil: finiteNumber(value.cooldownUntil),
       code: safeToken(value.code),
       message: String(value.message || '').replace(/\s+/g, ' ').trim().slice(0, 300),
       manualReason: normalizeManualReason(value.manualReason)
@@ -118,9 +119,6 @@
     const state = normalizeUpdateState(updateValue, options.currentVersion);
     const consent = normalizeConsentState(consentValue);
     const newer = compareStableVersions(state.latestVersion, state.currentVersion) > 0;
-    const snoozed = newer &&
-      consent.snoozedVersion === state.latestVersion &&
-      consent.snoozedUntil > now;
     const execution = EXECUTION_STATES.has(state.state);
     const available = state.state === 'update_available' && newer;
     // A newer release that only a reinstall can apply. It is shown even after
@@ -129,7 +127,11 @@
     // still names the old one, and the notice must clear by itself.
     const runningVersion = safeVersion(options.currentVersion) || state.currentVersion;
     const manualInstall = state.state === 'manual_install_required'
-      && compareStableVersions(state.latestVersion, runningVersion) > 0;
+      && (compareStableVersions(state.latestVersion, runningVersion) > 0
+        || (state.code === 'prerelease_promotion_requires_manual_update'
+          && state.latestVersion === runningVersion));
+    const snoozed = (newer || manualInstall) &&
+      consent.snoozedVersion === state.latestVersion && consent.snoozedUntil > now;
     const progress = getProgressModel(state);
     const quietFailure = state.state === 'failed' &&
       state.initiatedBy !== 'manual' &&

package/extension/src/shared/updateRuntimeIdentity.js

@@ -18,7 +18,7 @@
     if (!status.managed || !result.installedVersion || !result.nativeVersion ||
         !result.extensionVersion || !result.runtimeVersion) return result;
     if (['authorized', 'bound'].includes(status.authorization?.state) ||
-        ['staged', 'activation_pending', 'applying', 'awaiting_health'].includes(status.transaction?.state)) {
+        ['staged', 'activation_pending', 'applying', 'bootstrap_pending', 'bootstrap_rolling_back', 'awaiting_health', 'rolling_back'].includes(status.transaction?.state)) {
       return { ...result, state: 'transaction_active' };
     }
     if (status.installedAligned !== true) return { ...result, state: 'repair_required' };

package/extension/src/shared/writebackIntent.js

@@ -18,6 +18,22 @@
         if (typeof input[key] === 'string') op[key] = input[key];
       }
       if (Number.isSafeInteger(input.size)) op.size = input.size;
+      if (input.moveProof !== undefined) {
+        const proof = input.moveProof;
+        if (input.type !== 'move' || proof?.v !== 1 || !['text', 'binary'].includes(proof.kind)
+          || !/^[a-f0-9]{64}$/i.test(proof.sha256 || '')) return null;
+        op.moveProof = { v: 1, kind: proof.kind, sha256: proof.sha256.toLowerCase() };
+        if (proof.entityType !== undefined) {
+          if (!['doc', 'file'].includes(proof.entityType)) return null;
+          op.moveProof.entityType = proof.entityType;
+        }
+        for (const key of ['sourceEntityId', 'targetEntityId']) {
+          if (proof[key] !== undefined) {
+            if (typeof proof[key] !== 'string' || !proof[key] || proof[key].length > 160 || /[\0\r\n]/.test(proof[key])) return null;
+            op.moveProof[key] = proof[key];
+          }
+        }
+      }
       if (Array.isArray(input.patches)) {
         if (input.patches.length > 1000) return null;
         op.patches = input.patches.map(p => ({ from: p.from, to: p.to, expected: String(p.expected ?? ''), insert: String(p.insert ?? '') }));

package/extension/src/shared/writebackOperationEvidence.js

@@ -1,10 +1,10 @@
 (function initCodexOverleafWritebackOperationEvidence(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('./failureReasons'));
   } else {
-    root.CodexOverleafModuleRegistry.define('WritebackOperationEvidence', [], factory);
+    root.CodexOverleafModuleRegistry.define('WritebackOperationEvidence', ['FailureReasons'], factory);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function writebackOperationEvidenceFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function writebackOperationEvidenceFactory(FailureReasons) {
   'use strict';
 
   function normalizeOperationEvidence(operations = [], applyResult = {}) {
@@ -99,18 +99,7 @@
   }
 
   function normalizeFailure(result, operation) {
-    if (result?.failure && typeof result.failure === 'object') return cloneValue(result.failure);
-    if (!result?.code) return null;
-    return {
-      code: result.code,
-      stage: result.stage || 'write',
-      severity: result.severity || 'error',
-      userMessage: result.reason || result.message || result.code,
-      retryable: result.retryable === true,
-      file: operation?.path || operation?.to || '',
-      changedDocument: result.changedDocument === true,
-      terminalState: result.terminalState || ''
-    };
+    return FailureReasons.normalizeWritebackFailure(result, operation);
   }
 
   function normalizeTrackedChanges(value) {

package/extension/src/shared/writebackSettlement.js

@@ -4,21 +4,24 @@
       require('./failureReasons'),
       require('./settlementFacts'),
       require('./writebackEvidenceProjection'),
-      require('./writebackOperationEvidence')
+      require('./writebackOperationEvidence'),
+      require('./undoOperations')
     );
   } else {
     root.CodexOverleafModuleRegistry.define('WritebackSettlement', [
       'FailureReasons',
       'SettlementFacts',
       'WritebackEvidenceProjection',
-      'WritebackOperationEvidence'
+      'WritebackOperationEvidence',
+      'UndoOperations'
     ], factory);
   }
 })(typeof window !== 'undefined' ? window : globalThis, function writebackSettlementFactory(
   DefaultFailureReasons,
   SettlementFacts,
   EvidenceProjection,
-  OperationEvidence
+  OperationEvidence,
+  UndoOperations
 ) {
   'use strict';
 
@@ -212,7 +215,7 @@
   }
 
   function deriveSettledEvidence(primaryFailure, fileSettlements = []) {
-    if (primaryFailure?.terminalState === 'needs_review'
+    if (primaryFailure?.terminalState === 'needs_review' || DefaultFailureReasons.isUnconfirmedWriteFailure?.(primaryFailure)
       || fileSettlements.some(file => file.readBack === 'mismatch')) {
       return 'needs-review';
     }
@@ -336,7 +339,8 @@
   }
 
   function settleLegacyUndo(input = {}) {
-    const status = input.status === 'applied' ? 'applied' : 'partial';
+    const status = input.status === 'applied'
+      && isUndoResultEffectivelyApplied(input.run, input.result, input.run?.undoOperations) ? 'applied' : 'partial';
     const recovery = preserveRecovery();
     return {
       statePatch: { undoStatus: status },
@@ -441,7 +445,8 @@
   }
 
   function isUndoResultEffectivelyApplied(run, result, undoOperations = []) {
-    if (!result?.skipped?.length) return true;
+    if (result?.saveVerification?.ok === false || result?.receiptUnconfirmed === true) return false;
+    if (!result?.skipped?.length) return result?.ok === true;
     const expectedByPath = new Map((run?.undoExpectedFiles || [])
       .filter(file => file?.path && typeof file.content === 'string')
       .map(file => [normalizeSettlementPath(file.path), file.content])
@@ -467,10 +472,12 @@
     if (entry?.operation?.type === 'edit' && operationPath === normalizedPath) {
       return inner.verifiedContent === expectedContent;
     }
-
     const trackedPath = normalizeSettlementPath(entry?.trackedChange?.path);
     if (trackedPath !== normalizedPath) return false;
     const key = String(entry?.trackedChange?.key || '');
+    if (['overleaf-review-reject', 'overleaf-review-reject-sweep'].includes(inner.method))
+      return /^(?:id:|pos:|sig:)/.test(key) && inner.verified === true
+        && inner.verifiedContent === expectedContent;
     if (key === `editor-undo:${normalizedPath}`) {
       return inner.method === 'overleaf-editor-undo'
         && inner.verified === true
@@ -492,14 +499,12 @@
     }
     return false;
   }
-
   function normalizeSettlementPath(value) {
     return String(value || '')
       .replace(/\\/g, '/')
       .replace(/\/+/g, '/')
       .replace(/^\/+|\/+$/g, '');
   }
-
   function attachAcceptNotVerifiedFailure(run, result, options = {}) {
     if (!result || typeof result !== 'object' || result.ok === false) return result;
     if (Array.isArray(result.skipped) && result.skipped.length > 0) return result;
@@ -580,8 +585,9 @@
       const inner = entry?.result || entry;
       if (!inner || inner.ok === true) continue;
       const operation = entry?.operation || (entry?.trackedChange ? { path: entry.trackedChange.path } : undefined);
-      failures.push(failureReasons?.normalizeFailureReason instanceof Function
-        ? failureReasons.normalizeFailureReason(inner, operation)
+      const normalize = failureReasons?.normalizeWritebackFailure || failureReasons?.normalizeFailureReason;
+      failures.push(normalize instanceof Function
+        ? normalize(inner, operation)
         : normalizeFailure(inner, operation));
     }
     return failures.filter(Boolean);
@@ -630,9 +636,22 @@
 
   function attachVerifiedContentToOperation(operation, result) {
     if (!operation || typeof operation !== 'object') return operation;
-    return operation.type === 'edit' && typeof result?.verifiedContent === 'string'
-      ? { ...operation, verifiedContent: result.verifiedContent }
-      : operation;
+    const createdDirectories = (Array.isArray(result?.createdDirectories) ? result.createdDirectories
+      : Array.isArray(result?.moveProof?.createdDirectories) ? result.moveProof.createdDirectories : [])
+      .filter(proof => proof?.v === 1 && typeof proof.projectId === 'string' && proof.projectId
+        && typeof proof.path === 'string' && proof.path && !proof.path.split('/').some(part => !part || part === '.' || part === '..')
+        && typeof proof.nativeFolderId === 'string')
+      .map(proof => ({ v: 1, projectId: proof.projectId, path: proof.path, nativeFolderId: proof.nativeFolderId,
+        ownershipConfirmed: false, observedAfterCreate: proof.observedAfterCreate === true }));
+    const rawMove = result?.moveProof;
+    const moveProof = rawMove?.v === 1 && ['text', 'binary'].includes(rawMove.kind) && /^[a-f0-9]{64}$/i.test(rawMove.sha256 || '')
+      && typeof rawMove.sourceEntityId === 'string' && rawMove.sourceEntityId
+      && typeof rawMove.targetEntityId === 'string' && rawMove.targetEntityId
+      ? { v: 1, kind: rawMove.kind, sha256: rawMove.sha256.toLowerCase(), sourceEntityId: rawMove.sourceEntityId,
+        targetEntityId: rawMove.targetEntityId, ...(['doc', 'file'].includes(rawMove.entityType) ? { entityType: rawMove.entityType } : {}), ...(createdDirectories.length ? { createdDirectories } : {}) } : null;
+    if (!(operation.type === 'edit' && typeof result?.verifiedContent === 'string') && !createdDirectories.length && !moveProof) return operation;
+    return { ...operation, ...(operation.type === 'edit' && typeof result?.verifiedContent === 'string' ? { verifiedContent: result.verifiedContent } : {}),
+      ...(createdDirectories.length ? { createdDirectories } : {}), ...(moveProof ? { moveProof } : {}) };
   }
 
   function selectExpectedFilesForTrackedUndo(
@@ -641,26 +660,7 @@
     trackedChanges = [],
     previousExpectedFiles = []
   ) {
-    const paths = new Set();
-    for (const change of trackedChanges || []) {
-      if (change?.path) paths.add(change.path);
-    }
-    for (const operation of operations || []) {
-      if (operation?.path) paths.add(operation.path);
-      if (operation?.to) paths.add(operation.to);
-    }
-    const expectedByPath = new Map();
-    for (const file of previousExpectedFiles || []) {
-      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
-        expectedByPath.set(file.path, { path: file.path, content: file.content });
-      }
-    }
-    for (const file of project?.files || []) {
-      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
-        expectedByPath.set(file.path, { path: file.path, content: file.content });
-      }
-    }
-    return Array.from(expectedByPath.values());
+    return UndoOperations.selectExpectedFilesForTrackedUndo(project, operations, trackedChanges, previousExpectedFiles);
   }
 
   function acceptDiagnosticStatus(step, info) {
@@ -674,10 +674,9 @@
     return 'info';
   }
 
-  function selectPrimaryFailure(failures, failureReasons) {
-    return failureReasons?.selectPrimaryFailure instanceof Function
-      ? failureReasons.selectPrimaryFailure(failures)
-      : failures[0] || null;
+  function selectPrimaryFailure(failures, failureReasons = DefaultFailureReasons) {
+    const select = failureReasons?.selectPrimaryWritebackFailure || failureReasons?.selectPrimaryFailure;
+    return select instanceof Function ? select(failures) : failures[0] || null;
   }
 
   function appendSyntheticFailure(result, failure, path, code, type) {
@@ -749,6 +748,7 @@
     normalizeOperationEvidence,
     normalizeSaveEvidence,
     projectRunSettlement,
+    selectPrimaryFailure,
     selectExpectedFilesForTrackedUndo,
     settle,
     settleLegacyUndo,

package/extension/styles/panel.css

@@ -3420,7 +3420,6 @@
 
 #codex-overleaf-panel .run-guidance-message {
   display: block;
-  border-top: 2px solid var(--tl-accent, #55b9f3);
   margin: 7px 0 4px auto;
   animation: tl-slide-in 140ms ease-out;
 }
@@ -3432,6 +3431,13 @@
   overflow-wrap: anywhere;
 }
 
+#codex-overleaf-panel .run-guidance-label {
+  margin-top: 3px;
+  color: var(--tl-fg-3);
+  font-size: 10px;
+  line-height: 1.4;
+}
+
 /* A right-aligned toolbar: buttons sit together at the end of the row. Each
    button used to claim margin-left:auto, so two visible buttons split the free
    space and Undo drifted into the middle. */
@@ -4037,9 +4043,8 @@
 }
 #codex-overleaf-panel .run-presentation-workflow .run-process:not([open]) + .run-activity-list { display: grid; }
 #codex-overleaf-panel .run-workflow-list { gap: 0; margin-top: 5px; }
-#codex-overleaf-panel .run-workflow-list[data-expanded="false"] > .run-work-block:not([data-kind="guidance"]) { display: none; }
-#codex-overleaf-panel .run-presentation-workflow .run-guidance-list:empty,
-#codex-overleaf-panel .run-workflow-guidance:empty { display: none; }
+#codex-overleaf-panel .run-workflow-list[data-expanded="false"] > .run-work-block { display: none; }
+#codex-overleaf-panel .run-presentation-workflow .run-guidance-list:empty { display: none; }
 #codex-overleaf-panel .run-workflow-message {
   color: var(--tl-fg-1);
   font-size: 13px;
@@ -4133,7 +4138,6 @@
 #codex-overleaf-panel .run-workflow-thought-full > :first-child { margin-top: 0; }
 #codex-overleaf-panel .run-workflow-thought-full > :last-child { margin-bottom: 0; }
 #codex-overleaf-panel .run-workflow-message > :last-child { margin-bottom: 0; }
-#codex-overleaf-panel .run-workflow-guidance { margin: 15px 0; min-width: 0; }
 #codex-overleaf-panel .run-workflow-tool { min-width: 0; max-width: 100%; margin: 3px 0; }
 #codex-overleaf-panel .run-workflow-tool-summary {
   display: flex;
@@ -4538,7 +4542,14 @@
   bottom: calc(100% + 6px);
   z-index: 2147483647;
   display: grid;
+  grid-auto-rows: max-content;
+  align-content: start;
   gap: 2px;
+  box-sizing: border-box;
+  max-height: min(360px, var(--codex-slash-menu-space, 50vh));
+  overflow-y: auto;
+  overflow-x: hidden;
+  overscroll-behavior: contain;
   border: 1px solid var(--tl-border-strong);
   border-radius: 8px;
   background: var(--tl-surface-2);
@@ -4554,12 +4565,15 @@
   display: grid;
   gap: 2px;
   width: 100%;
+  min-width: 0;
   border: 0;
   border-radius: 6px;
   background: transparent;
   color: var(--tl-fg-1);
   padding: 7px 8px;
   text-align: left;
+  white-space: normal;
+  overflow-wrap: anywhere;
 }
 
 #codex-overleaf-panel .codex-slash-menu button[data-active="true"],

package/native-host/src/anthropicBridgeRequest.js

@@ -34,7 +34,7 @@ function buildAnthropicRequest({ requestBody = {}, launch = {}, historyMessages
     model,
     max_tokens: maxTokens,
     messages,
-    stream: requestBody.stream !== false
+    stream: requestBody.stream !== false && launch.upstreamResponseMode !== 'buffered'
   };
   if (systemParts.length) {
     body.system = launch.anthropicPromptCaching
@@ -218,8 +218,10 @@ function rectifyAnthropicRequestForRetry(body, errorText) {
     return changed;
   }
   if (/budget_tokens|thinking budget|must be less than max_tokens|at least 1024/i.test(message)) {
+    // Keep this existing compatibility retry only when its budget fits the
+    // caller's maximum. Otherwise expose the original upstream rejection.
+    if (!Number.isFinite(Number(body.max_tokens)) || Number(body.max_tokens) < 64000) return false;
     body.thinking = { type: 'enabled', budget_tokens: 32000 };
-    body.max_tokens = Math.max(Number(body.max_tokens) || 0, 64000);
     delete body.output_config;
     return true;
   }