codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/background.js

@@ -26,6 +26,8 @@ if (!globalThis.CodexOverleafStorageRunActions) {
   // registry and shared-module imports do not exist in this context.
   const storageDependencies = [
     ['CodexOverleafModuleRegistry', 'content/moduleRegistryKernel.js'],
+    ['CodexOverleafProjectFiles', 'shared/projectFiles.js'],
+    ['CodexOverleafDirectoryCleanupProof', 'shared/directoryCleanupProof.js'],
     ['CodexOverleafUndoOperations', 'shared/undoOperations.js'],
     ['CodexOverleafSelectionContext', 'shared/selectionContext.js'],
     ['CodexOverleafWritebackIntent', 'shared/writebackIntent.js'],
@@ -38,6 +40,10 @@ if (!globalThis.CodexOverleafStorageRunActions) {
     }
   }
 }
+if (!globalThis.CodexOverleafSharedSessionTransfer) {
+  const runtimeBase = String(globalThis.__CODEX_OVERLEAF_RUNTIME_BASE__ || '');
+  importScripts(runtimeBase ? chrome.runtime.getURL(`${runtimeBase}/src/shared/sharedSessionTransfer.js`) : 'shared/sharedSessionTransfer.js');
+}
 if (!globalThis.CodexOverleafSharedSessionsBackground) {
   const runtimeBase = String(globalThis.__CODEX_OVERLEAF_RUNTIME_BASE__ || '');
   importScripts(runtimeBase ? chrome.runtime.getURL(`${runtimeBase}/src/backgroundSharedSessions.js`) : 'backgroundSharedSessions.js');
@@ -47,6 +53,14 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
   const runtimeBase = String(globalThis.__CODEX_OVERLEAF_RUNTIME_BASE__ || '');
   importScripts(runtimeBase ? chrome.runtime.getURL(`${runtimeBase}/src/shared/updateRuntimeIdentity.js`) : 'shared/updateRuntimeIdentity.js');
 }
+if (!globalThis.CodexOverleafBootstrapMigration) {
+  const runtimeBase = String(globalThis.__CODEX_OVERLEAF_RUNTIME_BASE__ || '');
+  importScripts(runtimeBase ? chrome.runtime.getURL(`${runtimeBase}/src/backgroundBootstrapMigration.js`) : 'backgroundBootstrapMigration.js');
+}
+if (!globalThis.CodexOverleafBackgroundUpdateSafety) {
+  const runtimeBase = String(globalThis.__CODEX_OVERLEAF_RUNTIME_BASE__ || '');
+  importScripts(runtimeBase ? chrome.runtime.getURL(`${runtimeBase}/src/backgroundUpdateSafety.js`) : 'backgroundUpdateSafety.js');
+}
 
 (function initBackground() {
   'use strict';
@@ -83,7 +97,12 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
     'codex.providers.delete',
     'skills.list',
     'skills.install',
-    'skills.remove'
+    'skills.remove',
+    'writing-style.get',
+    'writing-style.set',
+    'codex.thread.fork',
+    'asset.readChunk',
+    'asset.release'
   ]);
   const RECOVERABLE_COMPATIBILITY_METHODS = new Set([
     'bridge.ping',
@@ -99,12 +118,38 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
   const pending = new Map();
   const runJournals = new Map();
   const journalWrites = new Map();
+  const journalLoads = new Map();
   const ownerBindings = new Map();
   const ownerCancelTimers = new Map();
   const RUN_JOURNAL_PREFIX = 'codex-overleaf:run-journal:';
   const RUN_JOURNAL_MAX_EVENTS = 300;
   const RUN_JOURNAL_MAX_BYTES = 512 * 1024;
   const managedBootstrapRuntime = isManagedBootstrapRuntime();
+  const migrationSafety = globalThis.CodexOverleafBackgroundUpdateSafety.create({
+    request: payload => sendNativeRequest(payload, null, { skipCompatibility: true }),
+    isExecutionLocked: () => managedBootstrapRuntime && managedUpdateExecutionLocked
+  });
+  let extensionInstallIdentity = { managed: managedBootstrapRuntime };
+  let installIdentityRead;
+  function readExtensionInstallIdentity() {
+    if (!managedBootstrapRuntime) return Promise.resolve(extensionInstallIdentity);
+    if (!installIdentityRead) installIdentityRead = (async () => {
+      try {
+        const response = await fetch(chrome.runtime.getURL('.codex-overleaf-managed-extension.json'));
+        const marker = response.ok ? await response.json() : null;
+        if (marker?.managedBy === 'codex-overleaf-link' && marker.kind === 'extension'
+          && marker.installIdentity?.extensionId === getCurrentExtensionId())
+          extensionInstallIdentity = { ...marker.installIdentity, managed: true };
+      } catch (_) { /* Old or missing marker: never guess the installation root. */ }
+      return extensionInstallIdentity;
+    })();
+    return installIdentityRead;
+  }
+  async function withExtensionInstallIdentity(request, response) {
+    return request?.method === 'bridge.ping'
+      ? { ...response, extensionInstallIdentity: await readExtensionInstallIdentity() } : response;
+  }
+
   globalThis.CodexOverleafNativeBridge = Object.freeze({
     requestInternal: payload => requestManagedInternal(payload),
     getPendingState: () => ({
@@ -114,6 +159,14 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
   });
 
   if (managedBootstrapRuntime) {
+    globalThis.CodexOverleafBootstrapMigration.init({
+      request: payload => sendNativeRequest(payload, null, { skipCompatibility: true }),
+      verifySafety: verifyManagedUpdateSafety,
+      protectReloadTabs: transaction => migrationSafety.protectReloadTabs(transaction),
+      releaseReloadTabs: (transaction, state) => migrationSafety.releaseReloadTabs(transaction, state),
+      hasReplacedReloadDocument: transaction => migrationSafety.hasReplacedReloadDocument(transaction),
+      setExecutionLocked: value => { managedUpdateExecutionLocked = value; }
+    });
     chrome.storage?.onChanged?.addListener((changes, area) => {
       if (area !== 'local' || !changes[MANAGED_UPDATE_STATE_KEY]?.newValue) {
         return;
@@ -136,6 +189,17 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
         .catch(error => sendResponse({ ok: false, journals: [], error: getErrorMessage(error, 'Journal read failed.') }));
       return true;
     }
+    if (message?.type === 'codex-overleaf/run-journal/known') {
+      if (!isAllowedOverleafSender(sender)) {
+        sendResponse({ ok: false, known: [] });
+        return undefined;
+      }
+      knownRunJournals(Array.isArray(message.requestIds) ? message.requestIds.map(String).slice(0, 64) : [],
+        Array.isArray(message.owners) ? message.owners.slice(0, 64) : [])
+        .then(result => sendResponse({ ok: true, ...result }))
+        .catch(error => sendResponse({ ok: false, known: [], error: getErrorMessage(error, 'Journal read failed.') }));
+      return true;
+    }
     if (message?.type === 'codex-overleaf/run-journal/ack') {
       if (!isAllowedOverleafSender(sender)) {
         sendResponse({ ok: false });
@@ -193,13 +257,11 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
     }
 
     sendNativeRequest(message.payload, sender)
+      .then(result => withExtensionInstallIdentity(message.payload, result))
       .then(result => sendResponse(result))
       .catch(error => {
         const userFacingError = toUserFacingNativeError(error);
-        sendResponse({
-          ok: false,
-          error: userFacingError
-        });
+        withExtensionInstallIdentity(message.payload, { ok: false, error: userFacingError }).then(sendResponse);
       });
 
     return true;
@@ -215,25 +277,50 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
         return;
       }
       if (message.type === 'release') {
+        const current = ownerBindings.get(portConnection);
+        if (!current || ['requestId', 'projectKey', 'clientRunId', 'sessionId'].some(key => current[key] !== message[key])
+          || (current.browserOnly && current.ownerToken !== message.ownerToken)) return;
         ownerBindings.delete(portConnection);
         clearTimeout(ownerCancelTimers.get(requestId));
         ownerCancelTimers.delete(requestId);
         return;
       }
       if (message.type === 'bind') {
-        ownerBindings.set(portConnection, {
+        const binding = {
           requestId,
           projectKey: String(message.projectKey || ''),
-          documentId: String(portConnection.sender?.documentId || '')
-        });
-        clearTimeout(ownerCancelTimers.get(requestId));
-        ownerCancelTimers.delete(requestId);
+          documentId: String(portConnection.sender?.documentId || ''),
+          tabId: portConnection.sender?.tab?.id,
+          clientRunId: String(message.clientRunId || ''),
+          sessionId: String(message.sessionId || ''),
+          browserOnly: message.browserOnly === true,
+          ownerToken: String(message.ownerToken || '')
+        };
+        if (binding.browserOnly && (!binding.projectKey || !binding.clientRunId || !binding.sessionId || !binding.ownerToken)) return;
+        if (binding.browserOnly && managedUpdateExecutionLocked) {
+          try { portConnection.postMessage?.({ type: 'bound', ...binding, ok: false }); } catch (_error) { /* port disconnected */ }
+          return;
+        }
+        ownerBindings.set(portConnection, binding);
+        if (binding.browserOnly) {
+          try { portConnection.postMessage?.({ type: 'bound', ...binding }); } catch (_error) { /* port disconnected */ }
+          return;
+        }
+        restoreRunJournal(binding).then(journal => {
+          if (ownerBindings.get(portConnection) !== binding || !journal || runJournals.get(requestId) !== journal) return;
+          clearTimeout(ownerCancelTimers.get(requestId));
+          ownerCancelTimers.delete(requestId);
+          if (!journal.ownerLost) return;
+          journal.ownerLost = false;
+          journal.updatedAt = new Date().toISOString();
+          return queueJournalWrite(requestId);
+        }).catch(() => {});
       }
     });
     portConnection.onDisconnect.addListener(() => {
       const binding = ownerBindings.get(portConnection);
       ownerBindings.delete(portConnection);
-      if (!binding?.requestId) {
+      if (!binding?.requestId || binding.browserOnly) {
         return;
       }
       const timer = setTimeout(() => interruptOwnerlessRun(binding), 150);
@@ -306,6 +393,7 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
         resolve,
         reject,
         tabId: sender?.tab?.id,
+        documentId: String(sender?.documentId || ''),
         request,
         method: request.method,
         retryClass: getNativeRetryClass(request.method),
@@ -328,7 +416,12 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
   }
 
   async function requestManagedInternal(payload) {
-    if (managedBootstrapRuntime && payload?.method === 'update.apply') {
+    if (managedBootstrapRuntime && ['update.status', 'update.confirm'].includes(payload?.method)) {
+      payload = { ...payload, params: { ...payload.params,
+        bootstrapRevision: String(globalThis.__CODEX_OVERLEAF_BOOTSTRAP_REVISION__ || '') } };
+    }
+    if (managedBootstrapRuntime && (payload?.method === 'update.apply'
+      || (payload?.method === 'update.rollback' && payload?.params?.reasonCode === 'update_user_rollback'))) {
       const gate = await verifyManagedUpdateSafety();
       if (!gate.ok) {
         return gate;
@@ -345,15 +438,25 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
         throw error;
       }
     }
-    return sendNativeRequest(payload, null, { skipCompatibility: true });
+    const response = await sendNativeRequest(payload, null, { skipCompatibility: true });
+    if (payload?.method === 'update.confirm') {
+      globalThis.CodexOverleafBootstrapMigration.observeConfirmation(payload.params, response);
+    }
+    return response;
   }
 
-  async function verifyManagedUpdateSafety() {
-    const tabs = await chrome.tabs.query({ url: MANAGED_OVERLEAF_MATCHES }).catch(() => []);
-    const editorTabs = tabs.filter(tab => (
+  async function verifyManagedUpdateSafety(migrationOwner) {
+    const tabs = await chrome.tabs.query({ url: MANAGED_OVERLEAF_MATCHES }).catch(() => null);
+    const editorTabs = (Array.isArray(tabs) ? tabs : []).filter(tab => (
       isManagedEditorTab(tab) && !tab.discarded && tab.status !== 'unloaded'
     ));
-    const probes = await Promise.all(editorTabs.map(tab => probeManagedUpdateTab(tab.id)));
+    const probes = await Promise.all(editorTabs.map(async tab => {
+      const result = await probeManagedUpdateTab(tab.id);
+      return migrationOwner && result?.blockers?.includes('tab_probe_unavailable')
+        ? migrationSafety.probe(tab, migrationOwner) : result;
+    }));
+    // An unknown inventory cannot establish an idle safe point, even when Native is idle.
+    if (!Array.isArray(tabs)) probes.push({ idle: false, blockers: ['tab_inventory_unavailable'] });
     const nativeGate = await sendNativeRequest({
       id: crypto.randomUUID(),
       method: 'update.canApply',
@@ -365,8 +468,15 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
         message: getErrorMessage(error, 'Native Host update safety check failed.')
       }
     }));
+    if (migrationOwner) {
+      const after = await chrome.tabs.query({ url: MANAGED_OVERLEAF_MATCHES }).catch(() => null);
+      const inventory = values => JSON.stringify((values || []).map(tab => [tab.id, tab.url, tab.discarded, tab.status]).sort());
+      if (!after || inventory(after) !== inventory(tabs)) probes.push({ idle: false, blockers: ['tab_probe_unavailable'] });
+      else if (!await migrationSafety.revalidate(editorTabs, migrationOwner)) probes.push({ idle: false, blockers: ['tab_probe_unavailable'] });
+    }
     const pendingState = globalThis.CodexOverleafNativeBridge?.getPendingState?.() || {};
     const backgroundBlockers = Number(pendingState.executionRequests || 0) > 0
+      || Array.from(ownerBindings.values()).some(binding => binding.browserOnly)
       ? ['background_execution_pending']
       : [];
     const blockers = [
@@ -391,13 +501,15 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
       return { idle: false, blockers: ['tab_unavailable'] };
     }
     try {
-      return await Promise.race([
+      const response = await Promise.race([
         chrome.tabs.sendMessage(tabId, { type: 'codex-overleaf/update-idle-probe' }),
         new Promise(resolve => setTimeout(() => resolve({
           idle: false,
           blockers: ['tab_probe_timeout']
         }), 3500))
       ]);
+      return typeof response?.idle === 'boolean' ? response
+        : { idle: false, blockers: ['tab_probe_unavailable'] };
     } catch (_error) {
       return { idle: false, blockers: ['tab_probe_unavailable'] };
     }
@@ -434,6 +546,11 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
   }
 
   async function reconcileManagedUpdateTransaction() {
+    const migration = await globalThis.CodexOverleafBootstrapMigration.ready();
+    if (!migration.continueInitialization) return;
+    await globalThis.__CODEX_OVERLEAF_BOOTSTRAP_READY__;
+    const coordinator = globalThis.CodexOverleafUpdateCoordinator;
+    const recoveryOwner = await coordinator?.captureRecoveryOwner?.();
     const response = await sendNativeRequest({
       id: crypto.randomUUID(),
       method: 'update.status',
@@ -445,22 +562,7 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
 
     const transaction = response.result?.transaction || null;
     if (transaction?.state === 'superseded') {
-      const activeVersion = response.result?.activeVersion || chrome.runtime.getManifest().version;
-      await chrome.storage.local.remove([
-        MANAGED_UPDATE_CONSENT_KEY,
-        MANAGED_UPDATE_TABS_KEY
-      ]);
-      await setManagedUpdateState({
-        state: 'idle',
-        managed: true,
-        currentVersion: activeVersion,
-        latestVersion: activeVersion,
-        transactionId: '',
-        blocker: '',
-        blockers: [],
-        code: '',
-        message: ''
-      });
+      await coordinator?.settleSupersededTransaction?.(response.result, recoveryOwner);
       return;
     }
     const state = await getManagedUpdateState();
@@ -521,6 +623,16 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
       return null;
     }
 
+    const params = request.params || {};
+    if (request.method === 'codex.run' && params.focusFilesAreLiteral === true
+      && (params.restrictToFocusFiles === true || (Array.isArray(params.focusFiles) && params.focusFiles.length))
+      && evidence?.native?.capabilities?.literalProjectPaths !== true) {
+      return { ...createNativeUpdateRequiredBlock(request.method, {
+        ...evidence, status: 'native_capability_missing', classification: 'incompatible'
+      }), message: 'This Native Host does not support literal project paths. Reload the extension after installing the coordinated build.',
+      missingCapabilities: ['literalProjectPaths'] };
+    }
+
     if (isNativeMethodAllowedByCompatibility(request.method, evidence)) {
       return null;
     }
@@ -621,12 +733,13 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
     const command = CodexOverleafCompatibility?.buildInstallCommand?.(
       getNativeRecommendedVersion(evidence),
       evidence.native?.platform || evidence.platform,
-      getCurrentExtensionId()
+      getCurrentExtensionId(),
+      extensionInstallIdentity
     );
     if (command) {
       return command;
     }
-    return evidence.updateCommand || evidence.installCommand;
+    return managedBootstrapRuntime ? '' : evidence.updateCommand || evidence.installCommand;
   }
 
   function getCurrentExtensionId() {
@@ -909,8 +1022,13 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
       clientRunId: String(params.clientRunId || ''),
       sessionId: String(params.clientSessionId || ''),
       task: sanitizeJournalString(params.task).slice(0, 12000),
+      ...(params.operation === 'compact' ? {
+        operation: 'compact', threadId: String(params.threadId || '').slice(0, 160)
+      } : {}),
       mode: String(params.mode || ''),
       model: String(params.model || ''),
+      ownerTabId: pendingRequest.tabId,
+      ownerDocumentId: pendingRequest.documentId,
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       terminal: false,
@@ -918,6 +1036,7 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
       nextSequence: 1,
       events: []
     };
+    invalidateJournalLoad(id);
     runJournals.set(id, journal);
     pruneInMemoryRunJournals();
     return queueJournalWrite(id);
@@ -982,9 +1101,9 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
   }
 
   function sanitizeJournalString(value) {
+    // Journal replay is conversation recovery. Credential configuration is not
+    // copied by createRunJournal; quoted values in model events stay intact.
     return String(value || '')
-      .replace(/\b(?:sk|hf|glpat|npm|ghp|github_pat|AKIA|AIza)[_-]?[A-Za-z0-9_-]{12,}\b/g, '[REDACTED]')
-      .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, '[REDACTED]')
       .replace(/(?:file:\/\/)?\/(?:Users|home|private|var|opt|Library)\/[^\s"'<>]+/g, '[local path]')
       .slice(0, 131072);
   }
@@ -994,11 +1113,15 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
     if (!storage || !runJournals.has(id)) {
       return Promise.resolve();
     }
+    const journal = runJournals.get(id);
+    const snapshot = JSON.parse(JSON.stringify(journal));
+    return queueJournalStorage(id, () => runJournals.get(id) === journal
+      ? storage.set({ [RUN_JOURNAL_PREFIX + id]: snapshot }) : undefined);
+  }
+
+  function queueJournalStorage(id, operation) {
     const previous = journalWrites.get(id) || Promise.resolve();
-    const snapshot = JSON.parse(JSON.stringify(runJournals.get(id)));
-    const next = previous.catch(() => {}).then(() => storage.set({
-      [RUN_JOURNAL_PREFIX + id]: snapshot
-    }));
+    const next = previous.catch(() => {}).then(operation);
     journalWrites.set(id, next);
     return next.finally(() => {
       if (journalWrites.get(id) === next) {
@@ -1007,7 +1130,67 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
     });
   }
 
+  function invalidateJournalLoad(id) {
+    const load = journalLoads.get(id);
+    if (load) load.cancelled = true;
+    journalLoads.delete(id);
+  }
+
+  function journalMatchesBinding(journal, binding) {
+    return journal?.requestId === binding.requestId && Boolean(binding.projectKey)
+      && journal.projectKey === binding.projectKey
+      && (!Number.isInteger(journal.ownerTabId) || journal.ownerTabId === binding.tabId)
+      && (!journal.ownerDocumentId || journal.ownerDocumentId === binding.documentId)
+      && (!binding.clientRunId || journal.clientRunId === binding.clientRunId)
+      && (!binding.sessionId || journal.sessionId === binding.sessionId);
+  }
+
+  function hasRunOwner(binding) {
+    return Array.from(ownerBindings.values()).some(owner => owner.requestId === binding.requestId
+      && owner.projectKey === binding.projectKey && owner.tabId === binding.tabId
+      && owner.documentId === binding.documentId && owner.clientRunId === binding.clientRunId
+      && owner.sessionId === binding.sessionId);
+  }
+
+  async function restoreRunJournal(binding) {
+    const id = binding.requestId;
+    if (runJournals.has(id)) {
+      const journal = runJournals.get(id);
+      return journalMatchesBinding(journal, binding) ? journal : null;
+    }
+    if (!chrome.storage?.session || !binding.projectKey) return null;
+    let load = journalLoads.get(id);
+    if (!load) {
+      load = { cancelled: false };
+      load.promise = (async () => {
+        await (journalWrites.get(id) || Promise.resolve()).catch(() => {});
+        if (load.cancelled) return null;
+        const values = await chrome.storage.session.get(RUN_JOURNAL_PREFIX + id);
+        const stored = values?.[RUN_JOURNAL_PREFIX + id];
+        if (load.cancelled || !journalMatchesBinding(stored, binding) || !Array.isArray(stored.events)) return null;
+        const journal = runJournals.get(id) || stored;
+        trimRunJournal(journal);
+        runJournals.set(id, journal);
+        return journal;
+      })().finally(() => {
+        if (journalLoads.get(id) === load) journalLoads.delete(id);
+      });
+      journalLoads.set(id, load);
+    }
+    const journal = await load.promise;
+    return journalMatchesBinding(journal, binding) ? journal : null;
+  }
+
+  function removeRunJournal(id) {
+    invalidateJournalLoad(id);
+    runJournals.delete(id);
+    // Retain the chain until removal completes; old queued writes cannot follow it.
+    return queueJournalStorage(id, () => !runJournals.has(id)
+      ? chrome.storage?.session?.remove?.(RUN_JOURNAL_PREFIX + id) : undefined);
+  }
+
   async function listRunJournals(projectKey) {
+    await Promise.allSettled(Array.from(journalLoads.values(), load => load.promise));
     await Promise.allSettled(Array.from(journalWrites.values()));
     const storage = chrome.storage?.session;
     if (!storage) {
@@ -1017,11 +1200,57 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
     const entries = Object.entries(values || {})
       .filter(([key, value]) => key.startsWith(RUN_JOURNAL_PREFIX)
         && (!projectKey || value?.projectKey === projectKey)
-        && (value?.terminal || value?.ownerLost))
+        && (value?.terminal || value?.ownerLost)
+        && !Array.from(ownerBindings.values()).some(binding => journalMatchesBinding(value, binding)))
       .sort((a, b) => String(a[1]?.createdAt || '').localeCompare(String(b[1]?.createdAt || '')));
     return entries.slice(-16).map(([_key, value]) => value);
   }
 
+  // Browser-only retries outlive their original Native journal. Protect only
+  // a live port whose request/project/session/run matches the queried record.
+  async function knownRunJournals(requestIds, owners = []) {
+    await Promise.allSettled(Array.from(journalLoads.values(), load => load.promise));
+    await Promise.allSettled(Array.from(journalWrites.values()));
+    const storage = chrome.storage?.session;
+    if (!storage) throw new Error('Run journal storage is unavailable.');
+    const values = requestIds.length ? await storage.get(requestIds.map(id => RUN_JOURNAL_PREFIX + id)) : {};
+    // A persisted startup snapshot may lag behind its owner's Native dispatch.
+    // Keep that same project/session/run alive through the request-id transition.
+    const matches = (candidate, binding) => (candidate?.preDispatch === true
+      ? ['projectKey', 'clientRunId', 'sessionId'] : ['requestId', 'projectKey', 'clientRunId', 'sessionId'])
+      .every(key => Boolean(candidate?.[key]) && candidate[key] === binding?.[key]);
+    const known = requestIds.filter(id => runJournals.has(id) || Boolean(values?.[RUN_JOURNAL_PREFIX + id])
+      || owners.some(candidate => candidate?.requestId === id && Array.from(ownerBindings.values()).some(binding => matches(candidate, binding))));
+    const missing = owners.filter(candidate => requestIds.includes(candidate?.requestId) && !known.includes(candidate.requestId));
+    if (!missing.length) return { known, ownersChecked: true, preDispatchChecked: true };
+    // A worker restart drops ports before hidden pages can process reconnect
+    // timers. The page's existing health receiver can still report its binding.
+    const unknown = () => ({ known, ownersChecked: false, preDispatchChecked: false, retryAfterMs: 1000 });
+    const tabs = await chrome.tabs.query({ url: MANAGED_OVERLEAF_MATCHES }).catch(() => null);
+    if (!Array.isArray(tabs)) return unknown();
+    const projects = new Set(missing.map(candidate => candidate.projectKey));
+    const relevant = tabs.filter(tab => isManagedEditorTab(tab) && !tab.discarded && tab.status !== 'unloaded'
+      && projects.has(new URL(tab.url).pathname.split('/')[2]));
+    const responses = await Promise.all(relevant.map(async tab => {
+      let timer;
+      try {
+        return await Promise.race([
+          chrome.tabs.sendMessage(tab.id, { type: 'codex-overleaf/runtime-health-probe' }, { frameId: 0 }),
+          new Promise(resolve => { timer = setTimeout(() => resolve(null), 1500); })
+        ]);
+      } catch (_error) { return null; }
+      finally { clearTimeout(timer); }
+    }));
+    const needsStartupInventory = missing.some(candidate => candidate.preDispatch === true);
+    if (responses.some(response => response?.ok !== true || ![1, 2].includes(response.runOwnerProtocol)
+      || (needsStartupInventory && response.runOwnerProtocol !== 2) || !Array.isArray(response.runOwners))) return unknown();
+    for (const candidate of missing) {
+      if (responses.some(response => response.runOwners.some(binding => matches(candidate, binding)))
+        || Array.from(ownerBindings.values()).some(binding => matches(candidate, binding))) known.push(candidate.requestId);
+    }
+    return { known, ownersChecked: true, preDispatchChecked: true };
+  }
+
   function pruneInMemoryRunJournals() {
     if (runJournals.size <= 16) {
       return;
@@ -1031,9 +1260,7 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
       .sort((a, b) => String(a.createdAt || '').localeCompare(String(b.createdAt || '')))
       .slice(0, runJournals.size - 16);
     for (const journal of oldest) {
-      runJournals.delete(journal.requestId);
-      journalWrites.delete(journal.requestId);
-      chrome.storage?.session?.remove?.(RUN_JOURNAL_PREFIX + journal.requestId).catch?.(() => {});
+      removeRunJournal(journal.requestId).catch(() => {});
     }
   }
 
@@ -1041,27 +1268,26 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
     if (!id) {
       return;
     }
-    await (journalWrites.get(id) || Promise.resolve()).catch(() => {});
-    runJournals.delete(id);
-    journalWrites.delete(id);
-    await chrome.storage?.session?.remove?.(RUN_JOURNAL_PREFIX + id);
+    await removeRunJournal(id);
   }
 
   async function interruptOwnerlessRun(binding) {
     ownerCancelTimers.delete(binding.requestId);
-    if (Array.from(ownerBindings.values()).some(value => value.requestId === binding.requestId)) {
+    if (hasRunOwner(binding)) {
       return;
     }
-    const journal = runJournals.get(binding.requestId);
+    const journal = await restoreRunJournal(binding).catch(() => null);
+    if (hasRunOwner(binding)) return;
+    if (journal && runJournals.get(binding.requestId) !== journal) return;
     if (journal) {
       journal.ownerLost = true;
       journal.updatedAt = new Date().toISOString();
       await queueJournalWrite(binding.requestId).catch(() => {});
     }
-    if (!pending.has(binding.requestId)) {
-      return;
-    }
+    if (hasRunOwner(binding)) return;
+    if (journal && runJournals.get(binding.requestId) !== journal) return;
     try {
+      if (!pending.has(binding.requestId) || !journalMatchesBinding(journal, binding)) return;
       sendNativeCancel({
         method: 'codex.cancel',
         params: {
@@ -1071,6 +1297,8 @@ if (!globalThis.CodexOverleafUpdateRuntimeIdentity) {
       });
     } catch (_error) {
       // The original request disconnect path will settle the journal.
+    } finally {
+      pruneInMemoryRunJournals();
     }
   }
 })();