codex-overleaf-link 2.3.0 → 2.3.1

package/extension/src/shared/scopedPersistenceQueuePolicy.js

@@ -35,8 +35,27 @@
   }
 
   function normalizeMeta(value) {
+    var revision = normalizeRevision(value && value.revision);
+    var hasDurableRevision = Boolean(value
+      && Object.prototype.hasOwnProperty.call(value, 'durableRevision'));
+    var durableRevision = hasDurableRevision
+      ? Math.min(normalizeRevision(value.durableRevision), revision)
+      : revision;
+    var pendingValue = value && value.pendingCommit;
+    var pendingRevision = normalizeRevision(pendingValue && pendingValue.revision);
+    var pendingCommit = pendingValue && typeof pendingValue === 'object'
+      && pendingRevision > durableRevision
+      && pendingRevision <= revision
+      ? {
+          revision: pendingRevision,
+          writerId: cleanPart(pendingValue.writerId),
+          startedAt: cleanPart(pendingValue.startedAt)
+        }
+      : null;
     return {
-      revision: normalizeRevision(value && value.revision),
+      revision: revision,
+      durableRevision: durableRevision,
+      pendingCommit: pendingCommit,
       queueRevision: normalizeRevision(value && value.queueRevision),
       writerId: cleanPart(value && value.writerId),
       updatedAt: cleanPart(value && value.updatedAt),

package/extension/src/shared/scopedPersistenceReceipt.js

@@ -0,0 +1,60 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafModuleRegistry.define('ScopedPersistenceReceipt', [], factory);
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function createFenceMeta(meta, currentMeta, writerId) {
+    var startedAt = new Date().toISOString();
+    var revision = currentMeta.revision + 1;
+    return {
+      ...meta,
+      revision: revision,
+      durableRevision: currentMeta.durableRevision,
+      pendingCommit: { revision: revision, writerId: writerId, startedAt: startedAt },
+      writerId: writerId,
+      updatedAt: startedAt
+    };
+  }
+
+  function createCommittedMeta(fenceMeta) {
+    return {
+      ...fenceMeta,
+      durableRevision: fenceMeta.revision,
+      pendingCommit: null,
+      updatedAt: new Date().toISOString()
+    };
+  }
+
+  function createRecoveredMeta(currentMeta, fenceMeta, writerId) {
+    var revision = fenceMeta.revision + 1;
+    return {
+      ...currentMeta,
+      revision: revision,
+      durableRevision: revision,
+      pendingCommit: null,
+      queueRevision: fenceMeta.queueRevision + 1,
+      writerId: writerId,
+      updatedAt: new Date().toISOString()
+    };
+  }
+
+  function decorateReceiptError(error, revision) {
+    if (error && typeof error === 'object') {
+      error.code = error.code || 'persistence_receipt_write_failed';
+      error.persistenceActionCommitted = true;
+      error.persistenceRevision = revision;
+    }
+    return error;
+  }
+
+  return Object.freeze({
+    createFenceMeta: createFenceMeta,
+    createCommittedMeta: createCommittedMeta,
+    createRecoveredMeta: createRecoveredMeta,
+    decorateReceiptError: decorateReceiptError
+  });
+});

package/extension/src/shared/scopedPersistenceTransaction.js

@@ -2,15 +2,17 @@
   if (typeof module === 'object' && module.exports) {
     module.exports = factory(
       require('./scopedPersistenceQueuePolicy'),
-      require('./scopedPersistenceBrowserAdapter')
+      require('./scopedPersistenceBrowserAdapter'),
+      require('./scopedPersistenceReceipt')
     );
   } else {
     root.CodexOverleafModuleRegistry.define('ScopedPersistenceTransaction', [
       'ScopedPersistenceQueuePolicy',
-      'ScopedPersistenceBrowserAdapter'
+      'ScopedPersistenceBrowserAdapter',
+      'ScopedPersistenceReceipt'
     ], factory);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : this, function (QueuePolicy, BrowserAdapter) {
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (QueuePolicy, BrowserAdapter, Receipt) {
   'use strict';
 
   var applyQueueMutations = QueuePolicy.applyQueueMutations;
@@ -43,9 +45,9 @@
       var scope = normalizeScope(inputScope);
       generation += 1;
       var tokenGeneration = generation;
-      active = makeToken(scope, tokenGeneration, 0, false, 0);
+      active = tokenFromMeta(scope, tokenGeneration, false, {});
       var meta = await strictRead(adapter, scope);
-      var token = makeToken(scope, tokenGeneration, meta.revision, false, meta.queueRevision);
+      var token = tokenFromMeta(scope, tokenGeneration, false, meta);
       if (active && active.generation === tokenGeneration && sameScope(active, token)) active = token;
       return token;
     }
@@ -60,10 +62,10 @@
         });
       }
       if (!detached && active && sameScope(active, scope)) {
-        return makeToken(scope, active.generation, active.revision, false, active.queueRevision);
+        return tokenFromMeta(scope, active.generation, false, active);
       }
       var meta = await strictRead(adapter, scope);
-      return makeToken(scope, detached ? 0 : generation, meta.revision, detached, meta.queueRevision);
+      return tokenFromMeta(scope, detached ? 0 : generation, detached, meta);
     }
 
     function isCurrent(token) {
@@ -94,13 +96,7 @@
         if (queueMutations.length
           && currentMeta.queueRevision !== normalizeRevision(token.queueRevision)) {
           if (!token.detached && isCurrent(token)) {
-            active = makeToken(
-              scope,
-              token.generation,
-              currentMeta.revision,
-              false,
-              currentMeta.queueRevision
-            );
+            active = tokenFromMeta(scope, token.generation, false, currentMeta);
           }
           return {
             ok: false,
@@ -112,33 +108,26 @@
         }
         var projected = applyQueueMutations(currentMeta, queueMutations, writerId);
         if (!projected.ok) return projected;
-        var nextMeta = {
+        var nextMeta = Receipt.createFenceMeta({
           ...projected.meta,
-          revision: currentMeta.revision + 1,
-          writerId: writerId,
-          updatedAt: new Date().toISOString(),
           sessionTombstones: mergeTombstones(
             projected.meta.sessionTombstones,
             commitOptions && commitOptions.sessionTombstones,
             200
           )
-        };
+        }, currentMeta, writerId);
         await adapter.write(scope, nextMeta);
         if (!token.detached && isCurrent(token)) {
-          active = makeToken(
-            scope,
-            token.generation,
-            nextMeta.revision,
-            false,
-            nextMeta.queueRevision
-          );
+          active = tokenFromMeta(scope, token.generation, false, nextMeta);
         }
         var value;
         try {
           value = await action({
             scope: scope,
             baseRevision: currentMeta.revision,
+            durableRevision: currentMeta.durableRevision,
             conflict: conflict,
+            previousCommitIncomplete: Boolean(currentMeta.pendingCommit),
             writerId: writerId,
             currentMeta: currentMeta,
             nextMeta: nextMeta
@@ -147,23 +136,11 @@
           if (queueMutations.some(function (mutation) {
             return ['remove', 'release', 'restore'].includes(cleanPart(mutation.type));
           })) {
-            var recoveredMeta = {
-              ...currentMeta,
-              revision: nextMeta.revision + 1,
-              queueRevision: nextMeta.queueRevision + 1,
-              writerId: writerId,
-              updatedAt: new Date().toISOString()
-            };
+            var recoveredMeta = Receipt.createRecoveredMeta(currentMeta, nextMeta, writerId);
             try {
               await adapter.write(scope, recoveredMeta);
               if (!token.detached && isCurrent(token)) {
-                active = makeToken(
-                  scope,
-                  token.generation,
-                  recoveredMeta.revision,
-                  false,
-                  recoveredMeta.queueRevision
-                );
+                active = tokenFromMeta(scope, token.generation, false, recoveredMeta);
               }
             } catch (recoveryError) {
               if (error && typeof error === 'object') {
@@ -173,13 +150,24 @@
           }
           throw error;
         }
+        var committedMeta = Receipt.createCommittedMeta(nextMeta);
+        try {
+          await adapter.write(scope, committedMeta);
+        } catch (error) {
+          throw Receipt.decorateReceiptError(error, nextMeta.revision);
+        }
+        if (!token.detached && isCurrent(token)) {
+          active = tokenFromMeta(scope, token.generation, false, committedMeta);
+        }
         return {
           ok: true,
           value: value,
-          revision: nextMeta.revision,
-          queueRevision: nextMeta.queueRevision,
-          queueClaims: nextMeta.queueClaims,
+          revision: committedMeta.revision,
+          durableRevision: committedMeta.durableRevision,
+          queueRevision: committedMeta.queueRevision,
+          queueClaims: committedMeta.queueClaims,
           rebased: conflict,
+          recoveredIncompleteCommit: Boolean(currentMeta.pendingCommit),
           superseded: !token.detached && !isCurrent(token)
         };
       });
@@ -190,9 +178,7 @@
       captureCommitView: captureCommitView,
       commit: commit,
       getActiveView: function () {
-        return active
-          ? makeToken(active, active.generation, active.revision, false, active.queueRevision)
-          : null;
+        return active ? tokenFromMeta(active, active.generation, false, active) : null;
       },
       getWriterId: function () { return writerId; },
       invalidate: function () {
@@ -203,17 +189,34 @@
     });
   }
 
-  function makeToken(scope, tokenGeneration, revision, detached, queueRevision) {
+  function makeToken(
+    scope,
+    tokenGeneration,
+    revision,
+    detached,
+    queueRevision,
+    durableRevision,
+    pendingCommit
+  ) {
     return Object.freeze({
       accountScopeId: scope.accountScopeId,
       projectId: scope.projectId,
       generation: normalizeRevision(tokenGeneration),
       revision: normalizeRevision(revision),
+      durableRevision: normalizeRevision(durableRevision),
+      pendingCommit: pendingCommit && typeof pendingCommit === 'object'
+        ? Object.freeze({ ...pendingCommit })
+        : null,
       queueRevision: normalizeRevision(queueRevision),
       detached: detached === true
     });
   }
 
+  function tokenFromMeta(scope, tokenGeneration, detached, meta) {
+    return makeToken(scope, tokenGeneration, meta.revision, detached, meta.queueRevision,
+      meta.durableRevision, meta.pendingCommit);
+  }
+
   async function strictRead(adapter, scope) {
     return normalizeMeta(await adapter.read(scope));
   }

package/extension/src/shared/sessionState.js

@@ -24,7 +24,7 @@
   'use strict';
 
   const DEFAULT_PANEL_STATE = {
-    mode: 'confirm',
+    mode: 'ask',
     providerId: 'builtin',
     model: 'gpt-5.4',
     reasoningEffort: 'high',
@@ -47,7 +47,7 @@
     customInstructionsByProject: {}
   };
 
-  const VALID_MODES = new Set(['ask', 'confirm', 'auto']);
+  const VALID_MODES = new Set(['ask', 'auto']);
   // 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
@@ -127,9 +127,7 @@
       ...input
     };
 
-    if (!VALID_MODES.has(state.mode)) {
-      state.mode = DEFAULT_PANEL_STATE.mode;
-    }
+    state.mode = normalizeMode(state.mode);
     if (!VALID_REASONING.has(state.reasoningEffort)) {
       state.reasoningEffort = DEFAULT_PANEL_STATE.reasoningEffort;
     }
@@ -221,7 +219,7 @@
       history,
       runs,
       task: sanitizeAssistantVisibleText(session.task),
-      mode: VALID_MODES.has(session.mode) ? session.mode : fallbackState.mode,
+      mode: normalizeMode(session.mode, fallbackState.mode),
       providerId: typeof session.providerId === 'string' && session.providerId.trim()
         ? session.providerId.trim()
         : (fallbackState.providerId || 'builtin'),
@@ -234,6 +232,7 @@
         : fallbackState.speedTier,
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
       pendingInputs: normalizePendingInputs(
         session.pendingInputs,
@@ -311,13 +310,14 @@
       id: active.id,
       history: Array.isArray(active.history) ? active.history.slice(-10) : [],
       focusFiles: normalizeFocusFiles(active.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(active.projectReferenceFiles),
       codexThreadId: active.codexThreadId || '',
       providerId: state.providerId || 'builtin'
     };
     state.runs = Array.isArray(active.runs) ? active.runs : [];
     state.task = typeof active.task === 'string' ? active.task : '';
     state.focusFiles = normalizeFocusFiles(active.focusFiles);
-    state.mode = VALID_MODES.has(active.mode) ? active.mode : DEFAULT_PANEL_STATE.mode;
+    state.mode = normalizeMode(active.mode);
     state.requireReviewing = active.requireReviewing !== false;
 
     return state;
@@ -339,7 +339,7 @@
       history: normalizeHistoryEntries(overrides.history),
       runs,
       task: sanitizeAssistantVisibleText(overrides.task),
-      mode: VALID_MODES.has(overrides.mode) ? overrides.mode : DEFAULT_PANEL_STATE.mode,
+      mode: normalizeMode(overrides.mode),
       providerId: typeof overrides.providerId === 'string' && overrides.providerId.trim()
         ? overrides.providerId.trim()
         : 'builtin',
@@ -352,6 +352,7 @@
         : DEFAULT_PANEL_STATE.speedTier,
       requireReviewing: overrides.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(overrides.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(overrides.projectReferenceFiles),
       codexThreadId: typeof overrides.codexThreadId === 'string' ? overrides.codexThreadId : '',
       pendingInputs: normalizePendingInputs(overrides.pendingInputs)
     };
@@ -904,6 +905,33 @@
     return files.slice(0, 5);
   }
 
+  function normalizeProjectReferenceFiles(value) {
+    const seen = new Set();
+    const files = [];
+    for (const item of Array.isArray(value) ? value : []) {
+      const rawPath = typeof item === 'string' ? item : item?.path;
+      if (typeof rawPath !== 'string' || !rawPath.trim() || rawPath.length > 512) {
+        continue;
+      }
+      if (/^(?:[A-Za-z]:|[\\/])/.test(rawPath) || rawPath.includes('\0')) {
+        continue;
+      }
+      const path = rawPath.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\.\//, '').trim();
+      if (!path || path.split('/').some(segment => !segment || segment === '.' || segment === '..') || seen.has(path)) {
+        continue;
+      }
+      seen.add(path);
+      files.push({
+        path,
+        kind: item?.kind === 'binary' ? 'binary' : 'text'
+      });
+      if (files.length >= 5000) {
+        break;
+      }
+    }
+    return files;
+  }
+
   function normalizeCustomInstructionsByProject(value) {
     const result = {};
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -994,7 +1022,7 @@
       // Skills page was reopened.
       codexOverleafSkills: compactCodexOverleafSkillsForStorage(source.codexOverleafSkills),
       composerAttachments: normalizeComposerAttachmentsForPersistence(source.composerAttachments),
-      mode: VALID_MODES.has(active?.mode) ? active.mode : normalizeMode(source.mode),
+      mode: normalizeMode(active?.mode, source.mode),
       providerId: typeof source.providerId === 'string' && source.providerId.trim()
         ? source.providerId.trim()
         : 'builtin',
@@ -1092,6 +1120,7 @@
       speedTier: normalizeSpeedTier(session.speedTier || fallbackState.speedTier),
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
       pendingInputs: normalizePendingInputs(session.pendingInputs)
     };
@@ -1339,8 +1368,14 @@
     };
   }
 
-  function normalizeMode(mode) {
-    return VALID_MODES.has(mode) ? mode : DEFAULT_PANEL_STATE.mode;
+  function normalizeMode(mode, fallback = DEFAULT_PANEL_STATE.mode) {
+    if (mode === 'confirm') {
+      return 'ask';
+    }
+    if (VALID_MODES.has(mode)) {
+      return mode;
+    }
+    return VALID_MODES.has(fallback) ? fallback : DEFAULT_PANEL_STATE.mode;
   }
 
   function normalizeReasoning(reasoningEffort) {

package/extension/src/shared/storageDb.js

@@ -287,7 +287,7 @@
       history: compactHistoryForStorage(input.history),
       runs: compactRunsForStorage(input.runs, options),
       task: normalizeDisplayTextForStorage(input.task, SESSION_STORAGE_LIMITS.taskChars),
-      mode: typeof input.mode === 'string' ? input.mode : '', providerId: typeof input.providerId === 'string' && input.providerId ? input.providerId : 'builtin',
+      mode: normalizeCurrentMode(input.mode), providerId: typeof input.providerId === 'string' && input.providerId ? input.providerId : 'builtin',
       model: typeof input.model === 'string' ? input.model : '',
       reasoningEffort: typeof input.reasoningEffort === 'string' ? input.reasoningEffort : '',
       speedTier: typeof input.speedTier === 'string' ? input.speedTier : '',
@@ -436,13 +436,17 @@
 
   // --- Helpers ---
 
+  function normalizeCurrentMode(mode) {
+    return mode === 'auto' ? 'auto' : 'ask';
+  }
+
   function extractLightweightPrefs(state, projectId) {
     var prefs = {
       storageSchemaVersion: TARGET_SCHEMA_VERSION, providerId: typeof state.providerId === 'string' && state.providerId ? state.providerId : 'builtin',
       model: typeof state.model === 'string' ? state.model : '',
       reasoningEffort: typeof state.reasoningEffort === 'string' ? state.reasoningEffort : '',
       speedTier: typeof state.speedTier === 'string' ? state.speedTier : '',
-      mode: typeof state.mode === 'string' ? state.mode : '',
+      mode: normalizeCurrentMode(state.mode),
       locale: typeof state.locale === 'string' ? state.locale : '',
       requireReviewing: state.requireReviewing !== false,
       autoRecompile: state.autoRecompile !== false,
@@ -1314,11 +1318,9 @@
   }
 
   // --- Utilities ---
-
   function generateId(prefix) {
     return prefix + '_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8);
   }
-
   function safeJsonStringify(value) {
     try {
       return JSON.stringify(value) || '';
@@ -1326,7 +1328,6 @@
       return '[unserializable]';
     }
   }
-
   var hashString = StorageRunActions.hashString;
 
   return {

package/extension/src/shared/writebackOperationEvidence.js

@@ -114,12 +114,22 @@
   }
 
   function normalizeTrackedChanges(value) {
-    return (Array.isArray(value) ? value : []).map(item => ({
-      key: normalizeText(item?.key),
-      id: normalizeText(item?.id),
-      path: normalizeText(item?.path),
-      label: normalizeText(item?.label)
-    })).filter(item => item.key || item.id || item.path);
+    const normalized = [];
+    const seen = new Set();
+    for (const item of Array.isArray(value) ? value : []) {
+      const change = {
+        key: normalizeText(item?.key),
+        id: normalizeText(item?.id),
+        path: normalizeText(item?.path),
+        label: normalizeText(item?.label)
+      };
+      if (!change.key && !change.id && !change.path) continue;
+      const identity = `${change.path}\u0000${change.key || change.id || 'path-only'}`;
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      normalized.push(change);
+    }
+    return normalized;
   }
 
   function normalizeStringArray(value) {

package/extension/src/shared/writebackSettlement.js

@@ -270,9 +270,17 @@
     }
     const successful = isSuccessfulTrackedChangeSettlement(input.result);
     const reviewCodes = kind === 'accept' ? ACCEPT_NEEDS_REVIEW_CODES : REJECT_NEEDS_REVIEW_CODES;
-    const needsReview = !successful && failures.some(failure =>
+    // Reject/Undo is an all-target recovery transaction. A successful entry
+    // only proves that one tracked target was restored; any failed/skipped
+    // sibling can still leave this run's content in another file. Keep that
+    // recovery actionable instead of collapsing a partial multi-file reject
+    // into the terminal `rejected` state. Accept retains its established
+    // best-effort terminal policy.
+    const incompleteReject = kind === 'reject'
+      && collectRunResultSkipped(input.result).length > 0;
+    const needsReview = incompleteReject || (!successful && failures.some(failure =>
       failure.terminalState === 'needs_review' || reviewCodes.has(failure.code)
-    );
+    ));
     const status = needsReview ? 'needs_review' : kind === 'accept' ? 'accepted' : 'rejected';
     return {
       decision: status,
@@ -595,7 +603,12 @@
       : operation;
   }
 
-  function selectExpectedFilesForTrackedUndo(project, operations = [], trackedChanges = []) {
+  function selectExpectedFilesForTrackedUndo(
+    project,
+    operations = [],
+    trackedChanges = [],
+    previousExpectedFiles = []
+  ) {
     const paths = new Set();
     for (const change of trackedChanges || []) {
       if (change?.path) paths.add(change.path);
@@ -604,9 +617,18 @@
       if (operation?.path) paths.add(operation.path);
       if (operation?.to) paths.add(operation.to);
     }
-    return (project?.files || [])
-      .filter(file => paths.has(file.path) && typeof file.content === 'string')
-      .map(file => ({ path: file.path, content: file.content }));
+    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());
   }
 
   function acceptDiagnosticStatus(step, info) {

package/extension/styles/panel.css

@@ -2686,13 +2686,23 @@
 }
 
 #codex-overleaf-panel .run-math--fallback {
-  border-radius: 4px;
-  background: var(--tl-surface-2);
-  color: var(--tl-review);
-  padding: 1px 4px;
+  border-bottom: 1px dotted var(--tl-fg-4);
+  border-radius: 0;
+  background: transparent;
+  color: inherit;
+  padding: 0 2px;
   white-space: pre-wrap;
   overflow-wrap: anywhere;
-  font: 0.96em/1.4 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font: inherit;
+}
+
+#codex-overleaf-panel .run-math--display.run-math--fallback {
+  border: 1px solid var(--tl-border);
+  border-left: 3px solid var(--tl-fg-4);
+  border-radius: 6px;
+  background: var(--tl-surface-2);
+  padding: 8px 10px;
+  text-align: left;
 }
 
 #codex-overleaf-panel .run-stream[data-stream-role="reasoning"] .run-stream-text {
@@ -3173,12 +3183,12 @@
   white-space: nowrap;
 }
 
-/* Mode switch (Ask/Suggest/Auto) — a real segmented control: a bordered track
-   holding three choices. Inactive choices are muted; hover is a light fill
+/* Mode switch (Ask/Auto) — a real segmented control: a bordered track
+   holding two choices. Inactive choices are muted; hover is a light fill
    (distinct from the active accent-wash fill) so hover never reads as active. */
 #codex-overleaf-panel .codex-mode-switch {
   display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
+  grid-template-columns: repeat(2, minmax(0, 1fr));
   gap: 2px;
   min-width: 0;
   padding: 2px;

package/native-host/src/codexPromptAssembly.js

@@ -64,7 +64,7 @@ function buildCodexTurnPrompt(options = {}) {
     'Mode for this turn:',
     `- ${context.mode}`,
     '- ask: inspect and explain only; do not edit files.',
-    '- confirm/auto: edit the local workspace directly when the request calls for changes. The browser bridge handles review, confirmation, deletion approval, and syncing back to Overleaf.',
+    '- auto: edit the local workspace directly when the request calls for changes. The browser bridge handles authorization, deletion approval, and syncing back to Overleaf.',
     '',
     'Write expectation for this turn:',
     formatWriteExpectation({