codex-overleaf-link 2.2.0 → 2.3.0

package/extension/src/content/scopedPersistenceDetachedCommit.js

@@ -0,0 +1,47 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafScopedPersistenceDetachedCommit = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function create(options) {
+    options = options || {};
+    var Transaction = options.Transaction;
+    if (!Transaction
+      || typeof Transaction.createBrowserAdapter !== 'function'
+      || typeof Transaction.createCoordinator !== 'function') {
+      return null;
+    }
+    var adapter = Transaction.createBrowserAdapter({ chromeApi: options.chromeApi });
+    return async function commitDetached(projectId, accountScopeId, commitOptions, action) {
+      var nextScope = {
+        accountScopeId: String(accountScopeId || '').trim(),
+        projectId: String(projectId || '').trim()
+      };
+      if (!nextScope.accountScopeId) {
+        return { ok: false, reason: 'account_scope_unavailable' };
+      }
+      if (!nextScope.projectId) {
+        return { ok: false, reason: 'project_scope_unavailable' };
+      }
+      var coordinator = Transaction.createCoordinator({
+        adapter: adapter,
+        writerId: options.writerId
+      });
+      var hydration = await coordinator.beginHydration(nextScope);
+      if (!coordinator.isCurrent(hydration)) {
+        return { ok: false, reason: 'stale_view' };
+      }
+      var view = await coordinator.captureCommitView(nextScope, { detached: true });
+      return coordinator.commit(view, action, {
+        rebase: !commitOptions || commitOptions.rebase !== false,
+        queueMutation: commitOptions && commitOptions.queueMutation,
+        queueMutations: commitOptions && commitOptions.queueMutations,
+        sessionTombstones: commitOptions && commitOptions.sessionTombstones
+      });
+    };
+  }
+
+  return Object.freeze({ create: create });
+});

package/extension/src/content/scopedPersistencePanelState.js

@@ -0,0 +1,111 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafScopedPersistencePanelState = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function cloneSnapshot(value) {
+    if (!value || typeof value !== 'object') {
+      return value;
+    }
+    if (typeof structuredClone === 'function') {
+      return structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value));
+  }
+
+  async function persistPanelState(input) {
+    var state = cloneSnapshot(input.state || {});
+    var compactState = cloneSnapshot(input.compactState || {});
+    var projectId = input.projectId;
+    var Migration = input.Migration;
+    var StorageDb = input.StorageDb;
+    var scope = input.persistenceContext?.scope || {};
+    var accountScopeId = typeof scope.accountScopeId === 'string'
+      ? scope.accountScopeId.trim()
+      : '';
+    if (!accountScopeId) {
+      throw Object.assign(new Error('Scoped persistence requires an account identity.'), {
+        code: 'account_scope_unavailable'
+      });
+    }
+    if (scope.projectId !== projectId) {
+      throw Object.assign(new Error('Scoped persistence project changed before commit.'), {
+        code: 'stale_view'
+      });
+    }
+    var latestPrefs = typeof Migration.loadPrefs === 'function'
+      ? await Migration.loadPrefs(accountScopeId, projectId)
+      : {};
+    var prefs = Object.assign(
+      {},
+      latestPrefs && typeof latestPrefs === 'object' ? latestPrefs : {},
+      StorageDb.extractLightweightPrefs(compactState, projectId)
+    );
+    prefs.activeSessionByProject = StorageDb.buildActiveSessionByProject(
+      latestPrefs && latestPrefs.activeSessionByProject || {},
+      projectId,
+      compactState.activeSessionId || state.activeSessionId || ''
+    );
+    prefs.experimentalOtByProject = Object.assign(
+      {},
+      latestPrefs && latestPrefs.experimentalOtByProject || {},
+      { [projectId]: input.normalizeExperimentalOtByProject(state.experimentalOtByProject)[projectId] === true }
+    );
+    prefs.governanceRulesByProject = Object.assign(
+      {},
+      latestPrefs && latestPrefs.governanceRulesByProject || {},
+      input.normalizeGovernanceRulesByProject(state.governanceRulesByProject)
+    );
+    var normalizedCustomProject = input.normalizeCustomInstructionsByProject({ [projectId]: '' });
+    var customProjectId = Object.keys(normalizedCustomProject)[0] || '';
+    var currentCustom = input.normalizeCustomInstructionsByProject(state.customInstructionsByProject);
+    prefs.customInstructionsByProject = Object.assign(
+      {},
+      latestPrefs && latestPrefs.customInstructionsByProject || {}
+    );
+    if (customProjectId) {
+      prefs.customInstructionsByProject[customProjectId] =
+        Object.prototype.hasOwnProperty.call(currentCustom, customProjectId)
+          ? currentCustom[customProjectId]
+          : '';
+    }
+    await Migration.savePrefs(prefs, accountScopeId, projectId);
+    var persistenceMeta = input.persistenceContext?.nextMeta || {};
+    var queueTombstones = persistenceMeta.queueTombstones || {};
+    var sessionTombstones = persistenceMeta.sessionTombstones || {};
+    var deletedSessionIds = Array.from(new Set([
+      ...(Array.isArray(input.deletedSessionIds) ? input.deletedSessionIds : []),
+      ...Object.keys(sessionTombstones)
+    ]));
+    var sessionRecords = (state.sessions || []).map(function (session) {
+      return StorageDb.buildSessionRecord(Object.assign({}, session, {
+        projectId: projectId,
+        accountScopeId: accountScopeId,
+        title: session.title || '',
+        titleSource: session.titleSource || 'auto',
+        codexThreadId: session.codexThreadId || '',
+        status: 'active',
+        focusFiles: Array.isArray(session.focusFiles) ? session.focusFiles : [],
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        pendingInputs: (Array.isArray(session.pendingInputs) ? session.pendingInputs : [])
+          .filter(function (item) { return !queueTombstones[item?.id]; })
+      }), { preserveRunActionPayload: true });
+    });
+    await input.SessionPersistence.writeSessions({
+      Migration: Migration,
+      StorageDb: StorageDb,
+      projectId: projectId,
+      accountScopeId: accountScopeId,
+      deletedSessionIds: deletedSessionIds,
+      sessionRecords: sessionRecords,
+      queueClaims: persistenceMeta.queueClaims || {},
+      queueTombstones: queueTombstones,
+      writerId: input.persistenceContext?.writerId || ''
+    });
+  }
+
+  return Object.freeze({ persistPanelState: persistPanelState });
+});

package/extension/src/content/sessionManager.js

@@ -1,17 +1,6 @@
 (function initCodexOverleafSessionManager() {
   'use strict';
 
-  const SessionPanel = window.CodexOverleafSessionPanel;
-  const {
-    createSession,
-    deleteSession,
-    setActiveSession,
-    getActiveSession,
-    isDisplayableSession,
-    normalizePanelState,
-    deriveSessionTitle
-  } = window.CodexOverleafSessionState;
-
   // Session manager — the session lifecycle + list/delete surface
   // carved out of contentRuntime.js (v1.4.7 structural-debt phase 3). Code
   // moved verbatim except that mutable runtime state is read through
@@ -19,6 +8,20 @@
   // setState() (sessions are immutable-update: every mutation rebuilds state
   // via the shared sessionState helpers and hands it back to the runtime).
   function create(deps = {}) {
+    const {
+      SessionPanel,
+      SessionState,
+      SessionMenuView
+    } = deps;
+    const {
+      createSession,
+      deleteSession,
+      setActiveSession,
+      getActiveSession,
+      isDisplayableSession,
+      normalizePanelState,
+      deriveSessionTitle
+    } = SessionState;
     const {
       tr,
       showPluginConfirm,
@@ -36,7 +39,7 @@
       formatSessionTime
     } = deps;
 
-    const sessionMenuView = window.CodexOverleafSessionMenuView.create({
+    const sessionMenuView = SessionMenuView.create({
       commitSessionRename,
       deleteSessionWithConfirm,
       document,

package/extension/src/content/sessionPersistence.js

@@ -1,8 +1,14 @@
-(function initCodexOverleafSessionPersistence() {
+(function initCodexOverleafSessionPersistence(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('../shared/storageMigration'));
+  } else {
+    root.CodexOverleafModuleRegistry.define('SessionPersistence', ['StorageMigration'], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function sessionPersistenceFactory(Migration) {
   'use strict';
 
   function migration() {
-    return window.CodexOverleafStorageMigration;
+    return Migration;
   }
 
   async function loadTombstones() {
@@ -21,11 +27,20 @@
   function isVisibleRecord(record, deletedIds, accountScopeId) {
     return Boolean(record)
       && !(deletedIds || []).includes(record.id)
-      && (!accountScopeId || record.accountScopeId === accountScopeId);
+      && Boolean(accountScopeId)
+      && record.accountScopeId === accountScopeId;
   }
 
   async function writeSessions(options = {}) {
     const { StorageDb, projectId } = options;
+    const accountScopeId = typeof options.accountScopeId === 'string'
+      ? options.accountScopeId.trim()
+      : '';
+    if (!accountScopeId) {
+      throw Object.assign(new Error('Session persistence requires an account identity.'), {
+        code: 'account_scope_unavailable'
+      });
+    }
     const Migration = options.Migration || migration();
     const requested = (Array.isArray(options.deletedSessionIds) ? options.deletedSessionIds : [])
       .filter(id => typeof id === 'string' && id);
@@ -34,8 +49,23 @@
       : await Migration?.loadSessionTombstones?.() || {};
     const deleted = new Set(requested);
     for (const id of Migration?.getDeletedSessionIds?.(tombstones, projectId) || []) deleted.add(id);
-    const sessionRecords = (options.sessionRecords || []).filter(record => !deleted.has(record.id));
-    const existingSessions = await StorageDb.getAllByIndex('sessions', 'projectId', projectId);
+    const queueTombstones = options.queueTombstones && typeof options.queueTombstones === 'object'
+      ? options.queueTombstones
+      : {};
+    const rawSessionRecords = (options.sessionRecords || [])
+      .filter(record => !deleted.has(record.id) && record.accountScopeId === accountScopeId);
+    const rawExistingSessions = (await StorageDb.getAllByIndex('sessions', 'projectId', projectId))
+      .filter(record => record?.accountScopeId === accountScopeId);
+    const rawExistingById = new Map(rawExistingSessions.map(record => [record.id, record]));
+    const sessionRecords = rawSessionRecords
+      .map(record => applyQueuePolicy(
+        record,
+        rawExistingById.get(record.id),
+        options,
+        queueTombstones
+      ));
+    const existingSessions = rawExistingSessions
+      .map(record => applyQueuePolicy(record, record, options, queueTombstones));
     const deletedExisting = existingSessions.filter(record => deleted.has(record.id));
     if (deletedExisting.length) {
       await Promise.all(deletedExisting.map(record => StorageDb.deleteRecord('sessions', record.id)));
@@ -48,15 +78,44 @@
       if (!existing) return true;
       return (Date.parse(record.updatedAt || '') || 0) >= (Date.parse(existing.updatedAt || '') || 0);
     });
-    if (writable.length) await StorageDb.putRecords('sessions', writable);
+    const cleanedExisting = existingSessions.filter((record, index) =>
+      record !== rawExistingSessions[index] && !writable.some(item => item.id === record.id)
+    );
+    if (cleanedExisting.length || writable.length) {
+      await StorageDb.putRecords('sessions', [...cleanedExisting, ...writable]);
+    }
     return writable;
   }
 
-  window.CodexOverleafSessionPersistence = {
+  function applyQueuePolicy(record, existingRecord, options, queueTombstones) {
+    const original = Array.isArray(record?.pendingInputs) ? record.pendingInputs : [];
+    let pendingInputs = original.filter(item => item?.id && !queueTombstones[item.id]);
+    const existingById = new Map(
+      (Array.isArray(existingRecord?.pendingInputs) ? existingRecord.pendingInputs : [])
+        .filter(item => item?.id && !queueTombstones[item.id])
+        .map(item => [item.id, item])
+    );
+    const claims = options.queueClaims && typeof options.queueClaims === 'object'
+      ? options.queueClaims
+      : {};
+    for (const claim of Object.values(claims)) {
+      if (!claim?.itemId || claim.ownerId === options.writerId) continue;
+      const index = pendingInputs.findIndex(item => item.id === claim.itemId);
+      const authoritative = existingById.get(claim.itemId);
+      if (authoritative && index >= 0) pendingInputs[index] = authoritative;
+      else if (authoritative) pendingInputs.push(authoritative);
+      else if (index >= 0) pendingInputs.splice(index, 1);
+    }
+    const unchanged = pendingInputs.length === original.length
+      && pendingInputs.every((item, index) => item === original[index]);
+    return unchanged ? record : { ...record, pendingInputs };
+  }
+
+  return {
     loadTombstones,
     getDeletedSessionIds,
     addTombstones,
     isVisibleRecord,
     writeSessions
   };
-})();
+});

package/extension/src/content/updateNotice.js

@@ -1,4 +1,10 @@
-(function initCodexOverleafUpdateNotice(root) {
+(function initCodexOverleafUpdateNotice(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('../shared/managedUpdateProjection'));
+  } else {
+    root.CodexOverleafModuleRegistry.define('UpdateNotice', ['ManagedUpdateProjection'], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function updateNoticeFactory(UpdateProjection) {
   'use strict';
 
   let notice = null;
@@ -11,7 +17,7 @@
   let settingsActionInFlight = false;
   let restartWatchdog = null;
   let manualCommandCopied = false;
-  const ACTIVE_UPDATE_STATES = new Set(['downloading', 'staged', 'waiting_for_idle', 'applying', 'awaiting_health']);
+  const ACTIVE_UPDATE_STATES = new Set(UpdateProjection.activePhases('panel'));
   const RESTART_WATCHDOG_MS = 30 * 1000;
 
   function mount(panelLike, options = {}) {
@@ -467,5 +473,5 @@
     return /^zh\b/i.test(locale) ? chinese : english;
   }
 
-  root.CodexOverleafUpdateNotice = Object.freeze({ mount });
-})(window);
+  return Object.freeze({ mount });
+});

package/extension/src/content/writebackOrchestrator.js

@@ -53,11 +53,21 @@
   let buildReviewingBlockedApplyResult;
   let ensureReviewingBeforeWrite;
   let confirmBinaryOperations;
+  let compileAdapter;
   let filterSyncChangesByOperations;
   let writebackController;
   let RUN_SNAPSHOT_ZIP_TIMEOUT_MS;
   let getState;
   let getCurrentRunView;
+  let onMirrorRefreshSettled;
+  let writebackSettlement;
+  let injectedWritebackSettlement;
+
+  function buildSettlement(input = {}) {
+    return writebackSettlement?.settle instanceof Function
+      ? writebackSettlement.settle(input)
+      : null;
+  }
 
   async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options = {}) {
     const runMode = options.mode || getState().mode;
@@ -93,6 +103,10 @@
       return {
         summaryLine: assistantMessage || tx('Ask mode completed without Overleaf changes', 'Ask 模式已完成，未修改 Overleaf'),
         hasSkippedOperations: false,
+        settlement: buildSettlement({
+          operations: [],
+          applyResult: { ok: true, applied: [], skipped: [] }
+        }),
         audit: buildAuditSummaryFromApply({
           operations: [],
           resultStatus: 'ask_ignored_local_changes',
@@ -138,16 +152,23 @@
         conclusion: assistantMessage || tx('Codex finished locally. There are no changes to sync back to Overleaf.', 'Codex 已完成本地处理，没有需要同步回 Overleaf 的改动。'),
         status: runMode === 'ask' ? tr('modeAsk') : 'completed',
         operations: [],
-        applyResults: [],
-        unchangedReason: assistantMessage
-          ? tx('No file changes need to sync back to Overleaf.', '没有产生需要同步回 Overleaf 的文件改动。')
-          : formatUnsupportedLocalChangeSummary(unsupportedChanges),
+        applyResults: additionalSkippedEntries.length ? [{ ok: false, applied: [], skipped: additionalSkippedEntries }] : [],
+        unchangedReason: additionalSkippedEntries.find(item => item?.result?.reason)?.result.reason
+          || (assistantMessage ? tx('No file changes need to sync back to Overleaf.', '没有产生需要同步回 Overleaf 的文件改动。') : formatUnsupportedLocalChangeSummary(unsupportedChanges)),
         mode: runMode,
-        nextStep: tx('You can continue the conversation, or adjust @context and run again.', '可以继续追问，或调整 @context 后重新运行。')
+        nextStep: additionalSkippedEntries.length ? formatWritebackSkippedNextStep({ ok: false, applied: [], skipped: additionalSkippedEntries }) : tx('You can continue the conversation, or adjust @context and run again.', '可以继续追问，或调整 @context 后重新运行。')
       });
       return {
         summaryLine: assistantMessage || tx('No changes to sync', '没有需要同步的改动'),
         hasSkippedOperations: additionalSkippedEntries.length > 0,
+        settlement: buildSettlement({
+          operations: buildSyncApplyOperations(syncChanges, project),
+          applyResult: {
+            ok: additionalSkippedEntries.length === 0,
+            applied: [],
+            skipped: additionalSkippedEntries
+          }
+        }),
         audit: buildAuditSummaryFromApply({
           operations: buildSyncApplyOperations(syncChanges, project),
           applyResults: additionalSkippedEntries.length ? [{ ok: false, applied: [], skipped: additionalSkippedEntries }] : [],
@@ -182,6 +203,10 @@
         return {
           summaryLine: tx('Sync cancelled', '已取消同步'),
           hasSkippedOperations: additionalSkippedEntries.length > 0,
+          settlement: buildSettlement({
+            operations,
+            applyResult: { ok: false, applied: [], skipped: additionalSkippedEntries }
+          }),
           audit: buildAuditSummaryFromApply({
             operations,
             applyResults: additionalSkippedEntries.length ? [{ ok: false, applied: [], skipped: additionalSkippedEntries }] : [],
@@ -239,14 +264,23 @@
         conclusion: assistantMessage || tx('No approved changes were written back to Overleaf.', '没有已确认的改动写回 Overleaf。'),
         status: runMode === 'ask' ? tr('modeAsk') : 'completed',
         operations: [],
-        applyResults: [],
-        unchangedReason: tx('No approved file changes remain to sync back to Overleaf.', '没有剩余已确认的文件改动需要同步回 Overleaf。'),
+        applyResults: additionalSkippedEntries.length ? [{ ok: false, applied: [], skipped: additionalSkippedEntries }] : [],
+        unchangedReason: additionalSkippedEntries.find(item => item?.result?.reason)?.result.reason
+          || tx('No approved file changes remain to sync back to Overleaf.', '没有剩余已确认的文件改动需要同步回 Overleaf。'),
         mode: runMode,
-        nextStep: tx('You can continue the conversation, or adjust @context and run again.', '可以继续追问，或调整 @context 后重新运行。')
+        nextStep: additionalSkippedEntries.length ? formatWritebackSkippedNextStep({ ok: false, applied: [], skipped: additionalSkippedEntries }) : tx('You can continue the conversation, or adjust @context and run again.', '可以继续追问，或调整 @context 后重新运行。')
       });
       return {
         summaryLine: tx('No changes applied', '没有应用改动'),
         hasSkippedOperations: additionalSkippedEntries.length > 0,
+        settlement: buildSettlement({
+          operations: buildSyncApplyOperations(syncChanges, project),
+          applyResult: {
+            ok: additionalSkippedEntries.length === 0,
+            applied: [],
+            skipped: additionalSkippedEntries
+          }
+        }),
         audit: buildAuditSummaryFromApply({
           operations: buildSyncApplyOperations(syncChanges, project),
           applyResults: additionalSkippedEntries.length ? [{ ok: false, applied: [], skipped: additionalSkippedEntries }] : [],
@@ -283,6 +317,7 @@
           '已阻止写入：未确认 Overleaf Reviewing/Track Changes'
         ),
         hasSkippedOperations: true,
+        settlement: buildSettlement({ operations, applyResult: blocked }),
         audit: buildAuditSummaryFromApply({
           operations,
           applyResults: [blocked],
@@ -342,6 +377,7 @@
     // pending promise is exposed so undoRun and the next runTask barrier on
     // it — a mirror.sync landing AFTER an undo would otherwise push the
     // pre-undo snapshot as the local baseline.
+    const mirrorSettlementTarget = getCurrentRunView?.();
     pendingMirrorRefresh = refreshProjectMirrorAfterWriteback(project, applied, saveVerification)
       .catch(error => {
         appendRunEvent({
@@ -351,12 +387,25 @@
           ),
           status: 'failed'
         });
+        return 'failed';
+      })
+      .then(state => {
+        if (typeof onMirrorRefreshSettled !== 'function') return;
+        return onMirrorRefreshSettled({
+          recordId: mirrorSettlementTarget?.recordId || '',
+          sessionId: mirrorSettlementTarget?.sessionId || '',
+          runProjectId: mirrorSettlementTarget?.runProjectId || '',
+          state: state || 'not-attempted'
+        });
       })
       .finally(() => {
         pendingMirrorRefresh = null;
       });
     const compileSummary = appliedPaths.length
-      ? await autoRecompileAfterWriteback(appliedPaths, saveVerification).catch(error => {
+      ? await autoRecompileAfterWriteback(appliedPaths, saveVerification, {
+        autoRecompile: options.autoRecompile,
+        mode: runMode
+      }).catch(error => {
         appendRunEvent({
           title: tx(`Post-write compile failed: ${error.message}`, `写后编译出错：${error.message}`),
           status: 'failed'
@@ -419,6 +468,17 @@
       // Existing call sites that only read `summaryLine` / `hasSkippedOperations`
       // / `audit` are unaffected.
       applied,
+      settlement: buildSettlement({
+        operations,
+        applyResult: applied,
+        saveVerification,
+        mirror: {
+          state: appliedPaths.length && saveVerification?.state === 'verified_saved'
+            ? 'pending'
+            : 'not_started'
+        },
+        compile: compileSummary
+      }),
       audit: buildAuditSummaryFromApply({
         operations,
         applyResults: [applied],
@@ -447,8 +507,8 @@
       if (result?.ok === true && !result?.state) {
         return {
           ...result,
-          ok: true,
-          state: 'verified_saved'
+          ok: false,
+          state: 'verified_quiet'
         };
       }
       if (result?.state === 'unknown_timeout' || result?.state === 'unavailable') {
@@ -522,10 +582,10 @@
 
   async function refreshProjectMirrorAfterWriteback(project = {}, applied = {}, saveVerification = {}) {
     if (saveVerification?.state !== 'verified_saved') {
-      return;
+      return 'not-attempted';
     }
     if (!Array.isArray(applied?.applied) || !applied.applied.length) {
-      return;
+      return 'not-attempted';
     }
 
     if (await tryConfirmMirrorWriteback(applied)) {
@@ -536,7 +596,7 @@
         ),
         status: 'completed'
       });
-      return;
+      return 'complete';
     }
 
     appendRunEvent({
@@ -567,7 +627,7 @@
         ),
         status: 'failed'
       });
-      return;
+      return 'failed';
     }
 
     const syncedProject = mergeVerifiedAppliedFiles(freshProject, project, applied);
@@ -584,7 +644,7 @@
         title: tx('Local Codex workspace refreshed. The next run will start from the latest Overleaf content.', '已刷新本地 Codex workspace，下一轮会从最新 Overleaf 内容开始。'),
         status: 'completed'
       });
-      return;
+      return 'complete';
     }
 
     const message = response?.error?.message || tx('native host did not respond', 'native host 没有响应');
@@ -595,6 +655,7 @@
       ),
       status: 'failed'
     });
+    return 'failed';
   }
 
   function mergeVerifiedAppliedFiles(freshProject = {}, originalProject = {}, applied = {}) {
@@ -615,11 +676,12 @@
     return writebackController.formatUnsupportedLocalChangeSummary(changes, getLocale());
   }
 
-  async function autoRecompileAfterWriteback(writtenPaths = [], saveVerification = {}) {
-    if (getState().autoRecompile === false) return null;
-    if (getState().mode === 'ask') return null;
+  async function autoRecompileAfterWriteback(writtenPaths = [], saveVerification = {}, options = {}) {
+    if (options.autoRecompile === false
+      || (options.autoRecompile === undefined && getState().autoRecompile === false)) return null;
+    if ((options.mode || getState().mode) === 'ask') return null;
 
-    const CompileAdapter = window.CodexOverleafCompileAdapter;
+    const CompileAdapter = compileAdapter;
     if (!CompileAdapter) return null;
 
     const hasCompilableFile = writtenPaths.some(filePath => CompileAdapter.isCompilableFile(filePath));
@@ -642,7 +704,8 @@
       const result = await callPageBridge('triggerCompile', {
         preferUiClick: true,
         waitForSaveMs: 5000,
-        requireVerifiedSave: saveVerification?.state === 'verified_saved'
+        requireVerifiedSave: saveVerification?.state === 'verified_saved',
+        runProjectId: getCurrentRunView()?.runProjectId || getCurrentProjectId()
       });
       if (result?.ok) {
         let logResult = null;
@@ -650,7 +713,8 @@
           logResult = await callPageBridge('getCompileLog', {
             triggerIfStale: false,
             maxAgeMs: 30000,
-            waitForSaveMs: 0
+            waitForSaveMs: 0,
+            runProjectId: getCurrentRunView()?.runProjectId || getCurrentProjectId()
           });
         } catch (_error) {
           logResult = null;
@@ -775,7 +839,8 @@
       const result = await callPageBridge('getCompileLog', {
         triggerIfStale: true,
         maxAgeMs: 30000,
-        waitForSaveMs: 5000
+        waitForSaveMs: 5000,
+        runProjectId: getCurrentRunView()?.runProjectId || getCurrentProjectId()
       });
 
       if (!result?.ok) {
@@ -841,6 +906,9 @@
       getState,
       getCurrentRunView,
     } = deps);
+    onMirrorRefreshSettled = deps.onMirrorRefreshSettled;
+    writebackSettlement = deps.writebackSettlement;
+    compileAdapter = deps.compileAdapter;
     return {
       applySyncChangesToOverleaf,
       resolveCompileLogContext,

package/extension/src/contentScript.js

@@ -4,5 +4,9 @@
   if (!window.CodexOverleafContentRuntime || typeof window.CodexOverleafContentRuntime.init !== 'function') {
     throw new Error('Codex Overleaf content runtime did not load.');
   }
-  window.CodexOverleafContentRuntime.init();
+  const registry = window.CodexOverleafLegacyGlobalRegistry;
+  if (!registry || typeof registry.create !== 'function') {
+    throw new Error('Codex Overleaf dependency registry did not load.');
+  }
+  window.CodexOverleafContentRuntime.init(registry.create(window));
 })();

package/extension/src/page/trackedChangesLifecycle.js

@@ -1008,7 +1008,12 @@
         result: {
           ok: true,
           method: 'overleaf-editor-undo',
-          undoClicks: result.clicks
+          undoClicks: result.clicks,
+          // undoEditorHistoryUntilContent returns ok only after the active
+          // editor exactly matches this run's pre-write checkpoint. Preserve
+          // that proof for the content-side lifecycle settlement.
+          verified: true,
+          verifiedContent: expectedByPath.get(path)
         }
       });
     }