codex-overleaf-link 2.4.1 → 2.5.0

package/extension/src/shared/sessionState.js

@@ -4,14 +4,18 @@
       require('./i18n'),
       require('./settlementFacts'),
       require('./runInputQueue'),
+      require('./selectionContext'),
       require('./lineReferences'),
       require('./pathRedaction'),
-      require('./sessionTitle')
+      require('./sessionTitle'),
+      require('./runActivityModel'),
+      require('./subagentActivityModel'),
+      require('./writebackIntent')
     );
   } else {
     root.CodexOverleafModuleRegistry.define(
       'SessionState',
-      ['I18n', 'SettlementFacts', 'RunInputQueue', 'LineReferences', 'PathRedaction', 'SessionTitle'],
+      ['I18n', 'SettlementFacts', 'RunInputQueue', 'SelectionContext', 'LineReferences', 'PathRedaction', 'SessionTitle', 'RunActivityModel', 'SubagentActivityModel', 'WritebackIntent'],
       factory
     );
   }
@@ -19,9 +23,13 @@
   i18n,
   SettlementFacts,
   RunInputQueue,
+  SelectionContext,
   LineReferences,
   PathRedaction,
-  SessionTitle
+  SessionTitle,
+  RunActivityModel,
+  SubagentActivityModel,
+  WritebackIntent
 ) {
   'use strict';
 
@@ -232,6 +240,7 @@
         : fallbackState.speedTier,
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      selectionContext: SelectionContext.normalize(session.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
       forkedFromSessionId: typeof session.forkedFromSessionId === 'string' ? session.forkedFromSessionId : '',
@@ -319,6 +328,7 @@
     state.runs = Array.isArray(active.runs) ? active.runs : [];
     state.task = typeof active.task === 'string' ? active.task : '';
     state.focusFiles = normalizeFocusFiles(active.focusFiles);
+    state.selectionContext = SelectionContext.normalize(active.selectionContext);
     state.mode = normalizeMode(active.mode);
     state.requireReviewing = active.requireReviewing !== false;
 
@@ -354,6 +364,7 @@
         : DEFAULT_PANEL_STATE.speedTier,
       requireReviewing: overrides.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(overrides.focusFiles),
+      selectionContext: SelectionContext.normalize(overrides.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(overrides.projectReferenceFiles),
       codexThreadId: typeof overrides.codexThreadId === 'string' ? overrides.codexThreadId : '',
       forkedFromSessionId: typeof overrides.forkedFromSessionId === 'string' ? overrides.forkedFromSessionId : '',
@@ -592,7 +603,48 @@
       .slice(-20);
   }
 
+  function recordedRunFailure(run) {
+    const event = [...(Array.isArray(run?.events) ? run.events : [])].reverse()
+      .find(item => item && item.kind !== 'technical' && item.subagent !== true);
+    if (!event || event.status !== 'failed' || (event.kind && event.kind !== 'activity')
+      || event.streamRole || event.streamKey || event.guidanceId) return null;
+    if (!['Codex returned a result, but local post-processing of this run failed.',
+      'Codex 已经返回了结果，但本地处理这一轮时出错了。'].includes(event.title)) return null;
+    const meta = RunActivityModel.capture(event);
+    // Capture encodes even an unscoped local event as [threadId, turnId].
+    const scoped = meta?.scope && meta.scope !== JSON.stringify(['', '']);
+    if (meta?.kind !== 'notice' || meta.state !== 'failed' || meta.id || scoped || meta.noticeSource) return null;
+    const ended = Date.parse(event.timestamp), started = Date.parse(run.startedAt);
+    if (!Number.isFinite(ended) || (Number.isFinite(started) && ended < started)) return null;
+    return event;
+  }
+
+  // On restore only: a run that already finished (finishedAt plus a terminal
+  // report as its last visible event) but was persisted as running by a stale
+  // status write. Live retries also carry an old finishedAt, so never in memory.
+  function recoverSettledRunningRun(run) {
+    if (run?.status !== 'running' || !Number.isFinite(Date.parse(run.finishedAt))) return run;
+    const last = [...(Array.isArray(run.events) ? run.events : [])].reverse()
+      .find(item => item && item.kind !== 'technical' && item.subagent !== true);
+    if (last?.kind !== 'report' || !['completed', 'failed'].includes(last.status)
+      || Date.parse(last.timestamp) > Date.parse(run.finishedAt)) return run;
+    return { ...run, status: last.status };
+  }
+
+  function recoverRecordedRunFailure(run, locale = i18n.DEFAULT_LOCALE) {
+    if (run?.status !== 'running') return run;
+    const event = recordedRunFailure(run);
+    if (!event) return run;
+    // This acknowledgement is emitted only by the parent's terminal catch.
+    // It survives a render failure that prevented the old owner from settling.
+    return { ...run, status: 'failed',
+      statusText: i18n.t(locale, 'processedFailed', { elapsed: '' }).trim(),
+      finishedAt: Number.isFinite(Date.parse(run.finishedAt)) ? run.finishedAt : event.timestamp };
+  }
+
   function normalizeRun(run, options = {}) {
+    if (options.restoreRunningRuns === true || options.recoverSettledRuns === true) run = recoverSettledRunningRun(run);
+    run = recoverRecordedRunFailure(run, options.locale);
     const shouldStopRestoredRun = options.restoreRunningRuns === true && run.status === 'running';
     const locale = options.locale || i18n.DEFAULT_LOCALE;
     const events = normalizeRunEvents(run.events);
@@ -622,12 +674,13 @@
       model: typeof run.model === 'string' ? run.model : '',
       reasoningEffort: typeof run.reasoningEffort === 'string' ? run.reasoningEffort : '',
       speedTier: typeof run.speedTier === 'string' ? run.speedTier : '',
-      status: shouldStopRestoredRun ? 'interrupted' : normalizeRunStatus(run.status),
+      status: shouldStopRestoredRun ? 'interrupted' : normalizeRunStatus(run.status, run),
       statusText: shouldStopRestoredRun ? i18n.t(locale, 'restoredRunStoppedStatus') : sanitizeAssistantVisibleText(run.statusText),
       runProjectId: normalizeProjectPrefKey(run.runProjectId),
       startedAt: typeof run.startedAt === 'string' ? run.startedAt : '',
       finishedAt: shouldStopRestoredRun ? new Date().toISOString() : typeof run.finishedAt === 'string' ? run.finishedAt : '',
       events: events.slice(-MAX_RUN_EVENTS),
+      ...(run.subagents?.length ? { subagents: SubagentActivityModel.normalize(run.subagents, sanitizeAssistantVisibleText) } : {}),
       attachments: normalizeRunAttachments(run.attachments, STORAGE_DEFAULT_LIMITS),
       appliedOperations: Array.isArray(run.appliedOperations) ? run.appliedOperations : [],
       undoOperations: Array.isArray(run.undoOperations) ? run.undoOperations : [],
@@ -660,6 +713,7 @@
       normalized.trackedChangeCaptures = sanitizeAssistantVisibleValue(run.trackedChangeCaptures);
     }
     applyTrackedChangeStatus(normalized, run.trackedChangeStatus);
+    Object.assign(normalized, pickWritebackRecovery(run));
 
     return normalized;
   }
@@ -722,13 +776,20 @@
     'running',
     'completed',
     'failed',
+    'cancelled',
     'interrupted',
     'background_completed',
     'needs_review_after_navigation',
     'abandoned_after_navigation'
   ]);
 
-  function normalizeRunStatus(status) {
+  function normalizeRunStatus(status, run = {}) {
+    if (status === 'running' && recordedRunFailure(run)) return 'failed';
+    if (status === 'rejected') return 'cancelled';
+    // Older normalizers rewrote cancelled runs to pending or completed.
+    // Recover only with a terminal timestamp and an explicit plugin event.
+    if (['pending', 'completed'].includes(status) && Number.isFinite(Date.parse(run.finishedAt))
+      && Array.isArray(run.events) && run.events.some(RunActivityModel.isRoutineCancellationEvent)) return 'cancelled';
     if (VALID_RUN_STATUS.has(status)) return status;
     // Legacy persisted runs without an explicit status fall back to `completed`
     // (the historical default for the recovery branch); unknown values land on
@@ -753,6 +814,9 @@
           timestamp: typeof event.timestamp === 'string' ? event.timestamp : '',
           kind: typeof event.kind === 'string' ? event.kind : 'activity',
           technicalDetail: sanitizeAssistantVisibleValue(event.technicalDetail),
+          activity: RunActivityModel.capture(event, sanitizeAssistantVisibleText),
+          streamPhase: RunActivityModel.normalizePhase(event.streamPhase),
+          subagent: event.subagent === true ? true : undefined,
           guidanceId: sanitizeAssistantVisibleText(event.guidanceId),
           streamKey: sanitizeAssistantVisibleText(event.streamKey),
           streamRole: sanitizeAssistantVisibleText(event.streamRole)
@@ -1123,6 +1187,7 @@
       speedTier: normalizeSpeedTier(session.speedTier || fallbackState.speedTier),
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      selectionContext: SelectionContext.normalize(session.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
       forkedFromSessionId: normalizeTextField(session.forkedFromSessionId, 160),
@@ -1196,6 +1261,7 @@
   }
 
   function compactRunForStorage(run, limits, keepUndoPayload, settlementFacts = null) {
+    run = recoverRecordedRunFailure(run);
     const undoPayload = compactUndoPayload(run, limits, keepUndoPayload);
     const compact = {
       id: run.id,
@@ -1204,12 +1270,13 @@
       model: normalizeTextField(run.model, 80),
       reasoningEffort: typeof run.reasoningEffort === 'string' ? run.reasoningEffort : '',
       speedTier: typeof run.speedTier === 'string' ? run.speedTier : '',
-      status: normalizeRunStatus(run.status),
+      status: normalizeRunStatus(run.status, run),
       statusText: summarizeTextForStorage(run.statusText, 'status text'),
       runProjectId: normalizeProjectPrefKey(run.runProjectId),
       startedAt: typeof run.startedAt === 'string' ? run.startedAt : '',
       finishedAt: typeof run.finishedAt === 'string' ? run.finishedAt : '',
       events: compactRunEvents(run.events, limits),
+      ...(run.subagents?.length ? { subagents: SubagentActivityModel.normalize(run.subagents, sanitizeAssistantVisibleText) } : {}),
       attachments: compactRunAttachmentsForStorage(run.attachments, limits),
       appliedOperations: [],
       undoOperations: undoPayload.undoOperations,
@@ -1236,6 +1303,7 @@
     if (run.interruptedDraft) {
       compact.interruptedDraft = sanitizeAssistantVisibleValue(run.interruptedDraft);
     }
+    Object.assign(compact, pickWritebackRecovery(run));
     if (VALID_TRACKED_CHANGE_STATUS.has(run.trackedChangeStatus)) {
       compact.trackedChangeStatus = run.trackedChangeStatus;
     }
@@ -1256,6 +1324,8 @@
           streamKey: typeof event.streamKey === 'string' ? event.streamKey : '',
           streamRole: typeof event.streamRole === 'string' ? event.streamRole : ''
         };
+        compact.activity = RunActivityModel.capture(event, sanitizeAssistantVisibleText);
+        compact.streamPhase = RunActivityModel.normalizePhase(event.streamPhase);
         if (event.subagent === true) {
           compact.subagent = true;
         }
@@ -1616,7 +1686,24 @@
     return new Blob([serialized]).size;
   }
 
+  function pickWritebackRecovery(run = {}) {
+    if (run.forkSnapshot === true || run.undoStatus === 'applied' || run.trackedChangeStatus === 'rejected') return {};
+    const result = {};
+    const retry = WritebackIntent.normalize(run.retryWriteback);
+    if (retry && retry.runId === run.id && retry.projectId === normalizeProjectPrefKey(run.runProjectId)
+      && retry.operations.every(op => (op.type === 'create' && typeof op.content === 'string')
+        || (op.type === 'edit' && (op.patches?.length || typeof op.replaceAll === 'string')
+          && retry.baseFiles.some(file => file.path === op.path))
+        || (op.type === 'delete' && retry.baseFiles.some(file => file.path === op.path)))
+      && !containsSecretLikeText(retry)) result.retryWriteback = retry;
+    const check = WritebackIntent.normalizeSaveCheck(run.saveCheck);
+    if (check && check.runId === run.id && check.projectId === normalizeProjectPrefKey(run.runProjectId)) result.saveCheck = check;
+    if (typeof run.saveConfirmedAt === 'string' && Number.isFinite(Date.parse(run.saveConfirmedAt))) result.saveConfirmedAt = run.saveConfirmedAt;
+    return result;
+  }
+
   return {
+    pickWritebackRecovery,
     DEFAULT_PANEL_STATE,
     createSession,
     deleteSession,
@@ -1630,7 +1717,11 @@
     setActiveSession,
     updateActiveSession,
     normalizeRuns,
+    normalizeRunStatus,
+    recoverRecordedRunFailure,
+    recoverSettledRunningRun,
     normalizeProjectReferenceFiles,
+    normalizeSelectionContext: SelectionContext.normalize,
     prepareStateForStorage,
     estimateJsonBytes,
     computeSafeTaskSummary

package/extension/src/shared/sharedSessionBridge.js

@@ -0,0 +1,288 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexOverleafModuleRegistry.define('SharedSessionBridge', [], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+  const MESSAGE = 'codex-overleaf/shared-sessions-v1';
+  const LOCK_PORT = 'codex-overleaf/shared-session-lock-v1';
+  const CHANGE_KEY = 'codex-overleaf-shared-sessions-changed-v1';
+  const BASE = Symbol('shared-session-base');
+  const failure = (code, message) => Object.assign(new Error(message), { code });
+  const clone = value => value == null ? value : JSON.parse(JSON.stringify(value));
+  const clean = record => {
+    const result = clone(record);
+    if (result) delete result.sharedRevision;
+    return result;
+  };
+
+  function createBridge(environment = globalThis) {
+    const chromeApi = environment.chrome;
+    const clientId = environment.crypto?.randomUUID?.() || 'page-' + Date.now() + '-' + Math.random();
+    const migrations = new Map(), baselines = new Map(), heldLocks = new Map();
+    let legacy, wrapped;
+    function enabled() {
+      return Boolean(chromeApi?.runtime?.sendMessage && chromeApi?.runtime?.connect
+        && environment.location?.protocol === 'https:'
+        && ['overleaf.com', 'www.overleaf.com', 'cn.overleaf.com'].includes(environment.location?.hostname)
+        && /^\/project(?:\/|$)/.test(environment.location?.pathname || ''));
+    }
+    function capture(projectId = '', accountScopeId) {
+      const current = environment.codexOverleafDeriveAccountScopeId?.();
+      if (!current || (accountScopeId && current !== accountScopeId))
+        throw failure('account_scope_unavailable', 'A stable matching Overleaf account is required for shared history.');
+      return { accountScopeId: current, projectId };
+    }
+    function assertScope(value) { capture(value.projectId, value.accountScopeId); }
+    const cacheKey = (value, id) => value.accountScopeId + ':' + id;
+    const lockKey = (kind, value) => kind === 'preferences' ? 'preferences' : 'state:' + value.accountScopeId;
+    async function request(method, value, args = {}) {
+      assertScope(value);
+      const lock = heldLocks.get(lockKey('state', value));
+      if (lock?.lost) throw failure('storage_lock_lost', 'The background storage connection was lost.');
+      const response = await chromeApi.runtime.sendMessage({
+        ...args, type: MESSAGE, method, scope: value, clientId, lockToken: lock?.token || ''
+      });
+      assertScope(value);
+      if (!response?.ok)
+        throw failure(response?.error?.code || 'shared_store_unavailable',
+          response?.error?.message || 'Shared history is unavailable. Reload the extension and this page.');
+      return response.result;
+    }
+
+    // Live ports own the locks. Worker/page termination releases them without
+    // allowing a stale client to silently fall back to an origin-local lock.
+    async function acquire(kind, value, work) {
+      assertScope(value);
+      const key = lockKey(kind, value), port = chromeApi.runtime.connect({ name: LOCK_PORT });
+      let timer, heartbeat, released = false, lock = null, rejectGrant;
+      const granted = new Promise((resolve, reject) => {
+        rejectGrant = reject;
+        port.onMessage.addListener(message => {
+          if (message?.type !== 'granted' || lock || released) return;
+          clearTimeout(timer);
+          lock = { token: message.token, lost: false };
+          heldLocks.set(key, lock);
+          resolve();
+        });
+        port.onDisconnect.addListener(() => {
+          // Read lastError to consume the runtime's disconnected-port warning.
+          void chromeApi.runtime.lastError;
+          if (lock) lock.lost = true;
+          if (!released) reject(failure('storage_lock_lost', 'The shared history lock disconnected.'));
+        });
+        timer = environment.setTimeout(() => reject(failure('storage_lock_timeout',
+          'Another page is saving history. Retry after it finishes.')), 20000);
+      });
+      try {
+        heartbeat = environment.setInterval(() => {
+          try { port.postMessage({ type: 'ping' }); }
+          catch (_error) {
+            if (lock) lock.lost = true;
+            rejectGrant(failure('storage_lock_lost', 'The shared history lock disconnected.'));
+          }
+        }, 15000);
+        port.postMessage({ type: 'acquire', kind, scope: value });
+        await granted;
+        assertScope(value);
+        const result = await work();
+        assertScope(value);
+        if (lock.lost) throw failure('storage_lock_lost', 'The shared history lock was lost before completion.');
+        return result;
+      } finally {
+        released = true;
+        environment.clearTimeout(timer);
+        environment.clearInterval(heartbeat);
+        if (heldLocks.get(key) === lock) heldLocks.delete(key);
+        port.disconnect();
+      }
+    }
+    async function migrate(value) {
+      const account = value.accountScopeId;
+      if (!migrations.has(account)) {
+        const pending = (async () => {
+          const status = await request('migration-status', value);
+          if (status.complete) return;
+          if (!legacy) throw failure('shared_store_unavailable', 'Legacy history storage is not ready.');
+          // Read the original site DB once. Only explicitly owned records may
+          // cross origins. Unknown-account rows remain untouched for recovery.
+          const records = (await legacy.getAllSessions())
+            .filter(record => record?.accountScopeId === account && record.projectId && record.id);
+          await acquire('state', value, async () => {
+            for (const record of records) {
+              const recordScope = capture(record.projectId, account);
+              await request('import', recordScope, {
+                record: legacy.buildSessionRecord(record, { preserveRunActionPayload: true })
+              });
+            }
+            await request('migration-complete', value);
+          });
+        })();
+        migrations.set(account, pending);
+        pending.catch(() => { if (migrations.get(account) === pending) migrations.delete(account); });
+      }
+      await migrations.get(account);
+      assertScope(value);
+    }
+    async function withLock(kind, input, work) {
+      const value = capture(input.projectId, input.accountScopeId);
+      await migrate(value); // Before acquiring either lock: no migration/lock cycle.
+      return acquire(kind, value, work);
+    }
+    async function withWrite(value, work) {
+      await migrate(value);
+      const held = heldLocks.get(lockKey('state', value));
+      if (held) {
+        if (held.lost) throw failure('storage_lock_lost', 'The shared history lock was lost.');
+        return work();
+      }
+      return acquire('state', value, work);
+    }
+    function tag(record, value, adopt) {
+      if (!record) return record;
+      const base = clean(record);
+      if (adopt) baselines.set(cacheKey(value, record.id), base);
+      Object.defineProperty(record, BASE, { value: base, enumerable: true });
+      return record;
+    }
+    async function list(projectId = '', adopt = true) {
+      const value = capture(projectId);
+      await migrate(value);
+      const result = []; let after = '';
+      do {
+        const page = await request('list', value, { after });
+        for (const record of page.records) {
+          result.push(tag(record, value, adopt && !heldLocks.has(lockKey('state', value))));
+        }
+        after = page.next;
+      } while (after);
+      return result;
+    }
+    function adopt(records) {
+      const value = capture();
+      for (const record of records) {
+        if (record.accountScopeId === value.accountScopeId)
+          baselines.set(cacheKey(value, record.id), clean(record));
+      }
+    }
+    function hasLocalChanges(session) {
+      const base = baselines.get(cacheKey(capture(), session.id));
+      return Boolean(base && (session.updatedAt !== base.updatedAt || session.task !== base.task));
+    }
+    function wasStored(id) { return baselines.has(cacheKey(capture(), id)); }
+    async function put(records, options = {}) {
+      if (!records.length) return [];
+      const value = capture(records[0].projectId, records[0].accountScopeId);
+      if (records.some(record => record.projectId !== value.projectId || record.accountScopeId !== value.accountScopeId))
+        throw failure('shared_store_scope_mismatch', 'A session batch must belong to one account and project.');
+      return withWrite(value, async () => {
+        const entries = records.map(record => ({
+          record: clean(record),
+          base: record[BASE] || baselines.get(cacheKey(value, record.id)) || null
+        }));
+        const written = await request('put', value, { entries, reviewRunIds: options.reviewRunIds || [] });
+        // Keep the caller's submitted view as its merge baseline. A merged
+        // remote change has not necessarily been applied to the visible UI.
+        for (const entry of entries) baselines.set(cacheKey(value, entry.record.id), clean(entry.record));
+        return written;
+      });
+    }
+    async function get(id) {
+      const value = capture();
+      await migrate(value);
+      const record = await request('get', value, { id });
+      return tag(record, value, !heldLocks.has(lockKey('state', value)));
+    }
+    async function erase(method, projectId = '', id) {
+      const value = capture(projectId);
+      return withWrite(value, () => request(method, value, { id }));
+    }
+    function decorate(api) {
+      legacy = api;
+      wrapped = { ...api };
+      const route = (name, shared) => {
+        wrapped[name] = function (...args) {
+          return enabled() ? shared(...args) : api[name](...args);
+        };
+      };
+      route('buildSessionRecord', (input, options) => {
+        const record = api.buildSessionRecord(input, options);
+        const base = input[BASE] || baselines.get(cacheKey({ accountScopeId: record.accountScopeId }, record.id));
+        if (base) Object.defineProperty(record, BASE, { value: clone(base), enumerable: true });
+        return record;
+      });
+      route('getAllSessions', () => list());
+      route('getRecord', (store, id) => store === 'sessions' ? get(id) : api.getRecord(store, id));
+      route('getAllByIndex', async (store, index, value) => {
+        if (store !== 'sessions') return api.getAllByIndex(store, index, value);
+        const records = await list(index === 'projectId' ? value : '');
+        return records.filter(record => record[index] === value);
+      });
+      route('claimSessionsForAccount', async (projectId, accountScopeId, deleted = []) => {
+        capture(projectId, accountScopeId);
+        return (await list(projectId)).filter(record => !deleted.includes(record.id));
+      });
+      route('putRecord', async (store, record) =>
+        store === 'sessions' ? (await put([record]))[0] : api.putRecord(store, record));
+      route('putRecords', (store, records, options) =>
+        store === 'sessions' ? put(records, options) : api.putRecords(store, records));
+      route('deleteRecord', (store, id) =>
+        store === 'sessions' ? erase('delete', '', id) : api.deleteRecord(store, id));
+      route('deleteByIndex', async (store, index, value) => {
+        if (store !== 'sessions') return api.deleteByIndex(store, index, value);
+        if (index === 'projectId') return erase('clear-project', value);
+        for (const record of (await list()).filter(record => record[index] === value))
+          await erase('delete', record.projectId, record.id);
+      });
+      route('clearStore', store =>
+        store === 'sessions' ? erase('clear-account') : api.clearStore(store));
+      route('clearAllStores', async () => {
+        const value = capture();
+        await erase('clear-account');
+        // Preserve other accounts' legacy backups. Auxiliary stores remain
+        // site-local and retain their existing explicit clear-all semantics.
+        for (const record of await api.getAllSessions()) {
+          if (record.accountScopeId === value.accountScopeId) await api.deleteRecord('sessions', record.id);
+        }
+        for (const store of Object.keys(api.STORES)) if (store !== 'sessions') await api.clearStore(store);
+        baselines.clear();
+      });
+      route('listRecentProjectsAcrossAccount', async options => {
+        if (!options?.accountScopeId) return [];
+        capture('', options.accountScopeId);
+        return api.filterRecentProjectsAcrossAccount(await list(), options);
+      });
+      Object.assign(wrapped, {
+        sharedSessionsEnabled: enabled,
+        withSharedLock: withLock,
+        readSharedProjectSnapshot: projectId => list(projectId, false),
+        adoptSharedSessionBaseline: adopt,
+        hasUnpersistedSharedSession: hasLocalChanges,
+        wasSharedSessionStored: wasStored
+      });
+      return wrapped;
+    }
+    function subscribe(listener) {
+      if (!enabled() || !chromeApi.storage?.onChanged) return () => {};
+      const onChange = (changes, area) => {
+        const change = changes[CHANGE_KEY]?.newValue;
+        if (area !== 'local' || !change || change.clientId === clientId) return;
+        const account = environment.codexOverleafDeriveAccountScopeId?.();
+        if (account && change.accountScopeId === account) listener(change);
+      };
+      chromeApi.storage.onChanged.addListener(onChange);
+      return () => chromeApi.storage.onChanged.removeListener(onChange);
+    }
+    return { enabled, decorate, withLock, subscribe,
+      async readMeta(input) {
+        const value = capture(input.projectId, input.accountScopeId);
+        await migrate(value);
+        return request('meta-read', value);
+      },
+      async writeMeta(input, meta) {
+        const value = capture(input.projectId, input.accountScopeId);
+        return request('meta-write', value, { meta });
+      }
+    };
+  }
+  return { createBridge, ...createBridge() };
+});