codex-overleaf-link 2.5.1 → 2.6.5

package/extension/src/content/scopedPersistencePanelState.js

@@ -15,7 +15,50 @@
     return JSON.parse(JSON.stringify(value));
   }
 
-  async function applyReviewTransition({ getState, runId, transition, persist, legacyUndo = false, assertCurrent }) {
+  // Review owns recovery progress and its settlement decision. Log events,
+  // compilation/mirror evidence, and later draft/display data have other writers.
+  const REVIEW_FIELDS = ['appliedOperations', 'undoOperations', 'undoBaseFiles', 'undoTrackedChanges',
+    'undoExpectedFiles', 'undoStatus', 'trackedChangeStatus', 'trackedChangeCaptures', 'interruptedDraft',
+    'retryWriteback', 'saveCheck'];
+  const REVIEW_FACT_FIELDS = ['documentEffect', 'fileSettlements', 'failures', 'recoveryAvailability', 'recoveryDisposition'];
+  const AUXILIARY_EVIDENCE = ['mirrored', 'compiled'];
+  const REVIEW_SOURCE_FIELDS = ['id', 'runProjectId', 'runAccountScopeId', 'startedAt', 'nativeEventSeq',
+    'codexThreadId', 'codexTurnId', 'executionSnapshot', 'forkSnapshot'];
+  const factsOf = record => record?.settlement || record?.settlementFacts || {};
+  function reviewSnapshot(record, SessionState) {
+    const normalized = SessionState?.normalizeRuns?.([record])?.[0] || record;
+    const facts = factsOf(normalized);
+    return JSON.stringify([
+      [...REVIEW_SOURCE_FIELDS, ...REVIEW_FIELDS].map(key => normalized[key]),
+      REVIEW_FACT_FIELDS.map(key => facts[key]),
+      Object.entries(facts.evidence || {}).filter(([key]) => !AUXILIARY_EVIDENCE.includes(key)).sort(([a], [b]) => a.localeCompare(b))
+    ]);
+  }
+  function restoreReviewFields(record, previous, staged, legacyUndo) {
+    for (const key of REVIEW_FIELDS) {
+      if (Object.hasOwn(previous, key)) record[key] = cloneSnapshot(previous[key]);
+      else delete record[key];
+    }
+    Object.assign(record, legacyUndo ? { undoStatus: 'partial' } : { trackedChangeStatus: 'needs_review' });
+    const currentFacts = factsOf(record), stagedFacts = factsOf(staged);
+    const restored = cloneSnapshot(factsOf(previous));
+    const preserveLateFields = (target, current, initial, excluded) => {
+      for (const key of new Set([...Object.keys(current), ...Object.keys(initial)])) {
+        if (excluded.includes(key) || JSON.stringify(current[key]) === JSON.stringify(initial[key])) continue;
+        if (Object.hasOwn(current, key)) target[key] = cloneSnapshot(current[key]); else delete target[key];
+      }
+    };
+    preserveLateFields(restored, currentFacts, stagedFacts, [...REVIEW_FACT_FIELDS, 'evidence']);
+    const evidence = { ...(restored.evidence || {}) };
+    const currentEvidence = currentFacts.evidence || {}, stagedEvidence = stagedFacts.evidence || {};
+    preserveLateFields(evidence, currentEvidence, stagedEvidence,
+      [...Object.keys(currentEvidence), ...Object.keys(stagedEvidence)].filter(key => !AUXILIARY_EVIDENCE.includes(key)));
+    if (Object.keys(evidence).length) restored.evidence = evidence; else delete restored.evidence;
+    delete record.settlementFacts;
+    if (Object.keys(restored).length) record.settlement = restored; else delete record.settlement;
+  }
+
+  async function applyReviewTransition({ getState, runId, transition, persist, legacyUndo = false, assertCurrent, SessionState }) {
     const targets = () => Array.from(new Set([
       ...(getState().runs || []),
       ...(getState().sessions || []).flatMap(session => session.runs || [])
@@ -33,22 +76,31 @@
         (Date.parse(session.lastActivityAt) || 0) + 1)).toISOString();
       session.lastActivityAt = session.updatedAt;
     }
-    const staged = records.map(record => JSON.stringify(record));
+    const snapshot = record => reviewSnapshot(record, SessionState);
+    const stagedRecords = records.map(cloneSnapshot), staged = records.map(snapshot);
+    const sameRecord = (original, record) => original === record
+      || (assertCurrent && SessionState?.sameRunIdentity?.(original, record));
+    const stillStaged = record => records.some((original, index) =>
+      sameRecord(original, record) && snapshot(record) === staged[index]);
+    const sameView = () => getState().activeSessionId === capturedSessionId
+      && (getState() === capturedState || (assertCurrent && SessionState?.sameRunIdentity));
     try {
       await persist({ preserveRunActionPayload: true, reviewRunIds: [runId], requireDurable: true });
       assertCurrent?.();
-      if (getState() !== capturedState || getState().activeSessionId !== capturedSessionId
-        || records.some(record => !targets().includes(record))) throw reviewPersistenceError();
+      const current = targets();
+      if (!sameView() || !current.length || current.some(record => !stillStaged(record))
+        || records.some(original => !current.some(record => sameRecord(original, record))))
+        throw reviewPersistenceError();
     } catch (error) {
       try { assertCurrent?.(); } catch (_stale) { throw error; }
+      // The envelope still failed closed, but an exact run-scoped readback
+      // already acknowledges this outcome. Keep the error/notice, not a false retry.
+      if (error.code === 'shared_session_conflict' && error.durableReviewRunIds?.includes(runId)) throw error;
       // The remote action may have succeeded. Keep its recovery data and expose uncertainty.
-      for (const record of records) {
-        if (getState() !== capturedState || !targets().includes(record)
-          || JSON.stringify(record) !== staged[records.indexOf(record)]) continue;
-        Object.assign(record, cloneSnapshot(previous), legacyUndo ? { undoStatus: 'partial' } : { trackedChangeStatus: 'needs_review' });
-        for (const field of ['settlement', 'settlementFacts']) {
-          if (!Object.prototype.hasOwnProperty.call(previous, field)) delete record[field];
-        }
+      for (const record of targets()) {
+        if (!sameView() || !stillStaged(record)) continue;
+        const index = records.findIndex((original, index) => sameRecord(original, record) && snapshot(record) === staged[index]);
+        restoreReviewFields(record, previous, stagedRecords[index], legacyUndo);
       }
       throw error;
     }
@@ -82,6 +134,19 @@
     }
   }
 
+  function projectPreferenceValues(input, prefs, projectId) {
+    return {
+      experimentalOtByProject: input.normalizeExperimentalOtByProject(prefs.experimentalOtByProject)[projectId] === true,
+      reviewingAvailabilityByProject: prefs.reviewingAvailabilityByProject?.[projectId],
+      governanceRulesByProject: input.normalizeGovernanceRulesByProject({
+        [projectId]: prefs.governanceRulesByProject?.[projectId] || {}
+      })[projectId],
+      customInstructionsByProject: input.normalizeCustomInstructionsByProject({
+        [projectId]: prefs.customInstructionsByProject?.[projectId] || ''
+      })[projectId]
+    };
+  }
+
   async function persistPanelState(input) {
     var state = cloneSnapshot(input.state || {});
     var compactState = cloneSnapshot(input.compactState || {});
@@ -111,6 +176,11 @@
     var reviewRuns = (input.reviewRunIds || []).map(id =>
       (state.sessions || []).flatMap(session => session.runs || []).find(run => run.id === id));
     if (reviewRuns.some(run => !run)) throw reviewPersistenceError();
+    var preferenceBaseline = input.projectPreferenceBaseline
+      || Migration.getProjectPreferenceBaseline?.(accountScopeId, projectId);
+    var preferenceWrite = input.projectPreferenceWrite || Migration.captureProjectPreferenceWrite?.({
+      ...input, state: state, baseline: preferenceBaseline, accountScopeId: accountScopeId, projectId: projectId
+    });
     var latestPrefs = typeof Migration.loadPrefs === 'function'
       ? await Migration.loadPrefs(accountScopeId, projectId)
       : {};
@@ -124,30 +194,23 @@
       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]
-          : '';
+    var currentPreferences = projectPreferenceValues(input, state, projectId);
+    if (preferenceWrite) {
+      Object.assign(prefs, Migration.projectPreferencePatch(preferenceWrite, accountScopeId, projectId));
+    } else {
+      var baselinePreferences = projectPreferenceValues(input, preferenceBaseline || latestPrefs || {}, projectId);
+      for (var name of Object.keys(currentPreferences)) {
+        prefs[name] = JSON.stringify(currentPreferences[name]) === JSON.stringify(baselinePreferences[name])
+          ? {} : { [projectId]: currentPreferences[name] };
+      }
+    }
+    var savedPrefs = await Migration.savePrefs(prefs, accountScopeId, projectId);
+    if (savedPrefs) {
+      var fields = preferenceWrite ? Migration.completeProjectPreferenceWrite(preferenceWrite, savedPrefs)
+        : Object.keys(currentPreferences);
+      var applied = input.applyProjectPreferences?.(savedPrefs, state, fields);
+      if (!preferenceWrite && applied !== false) Migration.adoptProjectPreferenceBaseline?.(savedPrefs, accountScopeId, projectId);
     }
-    await Migration.savePrefs(prefs, accountScopeId, projectId);
     var persistenceMeta = input.persistenceContext?.nextMeta || {};
     var queueTombstones = persistenceMeta.queueTombstones || {};
     var sessionTombstones = persistenceMeta.sessionTombstones || {};
@@ -171,18 +234,33 @@
       }), { preserveRunActionPayload: true });
     });
     sessionRecords = StorageDb.compactSessionBatchActions?.(sessionRecords, { activeSessionId: state.activeSessionId }) || sessionRecords;
-    var written = await input.SessionPersistence.writeSessions({
-      Migration: Migration,
-      StorageDb: StorageDb,
-      projectId: projectId,
-      accountScopeId: accountScopeId,
-      deletedSessionIds: deletedSessionIds,
-      sessionRecords: sessionRecords,
-      reviewRunIds: input.reviewRunIds,
-      queueClaims: persistenceMeta.queueClaims || {},
-      queueTombstones: queueTombstones,
-      writerId: input.persistenceContext?.writerId || ''
-    });
+    var written;
+    try {
+      written = await input.SessionPersistence.writeSessions({
+        Migration: Migration,
+        StorageDb: StorageDb,
+        projectId: projectId,
+        accountScopeId: accountScopeId,
+        deletedSessionIds: deletedSessionIds,
+        sessionRecords: sessionRecords,
+        reviewRunIds: input.reviewRunIds,
+        queueClaims: persistenceMeta.queueClaims || {},
+        queueTombstones: queueTombstones,
+        writerId: input.persistenceContext?.writerId || ''
+      });
+    } catch (error) {
+      if (error.code === 'shared_session_conflict' && error.reviewReceipts && StorageDb.reviewStateSnapshot) {
+        error.durableReviewRunIds = (input.reviewRunIds || []).filter(id => sessionRecords.some(expected => {
+          const proposed = expected.runs?.find(run => run.id === id);
+          const saved = error.reviewReceipts.find(record => record.id === expected.id
+            && record.accountScopeId === expected.accountScopeId && record.projectId === expected.projectId)
+            ?.runs?.find(run => run.id === id);
+          return proposed && saved && StorageDb.reviewStateSnapshot(proposed) === StorageDb.reviewStateSnapshot(saved);
+        }));
+        delete error.reviewReceipts;
+      }
+      throw error;
+    }
     if (!reviewRuns.every(reviewRun => (written || []).some(session => (session.runs || []).some(run =>
       run.id === reviewRun.id
       && (!reviewRun.trackedChangeStatus && ['applied', 'partial'].includes(reviewRun.undoStatus)

package/extension/src/content/selectionContextView.js

@@ -133,6 +133,28 @@
       }
     }
 
+    async function attachInstruction(action, selected) {
+      const selection = await attach('edit', selected);
+      if (!selection) return;
+      const task = deps.getPanel()?.querySelector('[data-task]');
+      if (!task) return;
+      if (task.value.trim()) {
+        deps.toast?.(tx('Kept your draft. The selection is attached for editing.', '已保留你的草稿，选区已附上，仅编辑此处。'));
+        return;
+      }
+      const instructions = {
+        polish: tx('Polish the selected passage for clarity and flow. Keep the meaning, citations, labels and math unchanged.',
+          '润色选中段落，让表达更清晰流畅，保持原意以及引用、标签、公式不变。'),
+        shorten: tx('Shorten the selected passage by about 20%. Keep citations, labels, math and the main claim unchanged.',
+          '将选中段落精简约 20%，保留引用、标签、公式和核心论点不变。'),
+        translate: tx('Translate the selected passage into English. Keep LaTeX commands, citations, labels and math unchanged.',
+          '将选中段落翻译成英文，保留 LaTeX 命令、引用、标签和公式不变。')
+      };
+      task.value = instructions[action];
+      task.setSelectionRange(task.value.length, task.value.length);
+      task.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+
     function editorFor(node) {
       const element = node?.nodeType === 1 ? node : node?.parentElement;
       const editor = element?.closest?.('.cm-editor');
@@ -164,6 +186,9 @@
       toolbar.setAttribute('aria-label', tx('Selected text actions', '选区操作'));
       toolbar.querySelector('[data-selection-action="reference"]').textContent = tx('Add to Chat', '加入对话');
       toolbar.querySelector('[data-selection-action="edit"]').textContent = tx('Edit Selection', '仅编辑此处');
+      toolbar.querySelector('[data-selection-action="polish"]').textContent = tx('Polish', '润色');
+      toolbar.querySelector('[data-selection-action="shorten"]').textContent = tx('Shorten', '精简');
+      toolbar.querySelector('[data-selection-action="translate"]').textContent = tx('Translate', '翻译');
     }
 
     function ensureToolbar() {
@@ -174,8 +199,8 @@
       toolbar.setAttribute('role', 'toolbar');
       toolbar.hidden = true;
       if (typeof toolbar.showPopover === 'function') toolbar.setAttribute('popover', 'manual');
-      for (const mode of ['reference', 'edit']) {
-        if (mode === 'edit') {
+      for (const mode of ['reference', 'edit', 'polish', 'shorten', 'translate']) {
+        if (mode === 'edit' || mode === 'polish') {
           const divider = document.createElement('span');
           divider.className = 'codex-selection-action-divider';
           divider.setAttribute('aria-hidden', 'true');
@@ -186,7 +211,9 @@
         button.dataset.selectionAction = mode;
         button.addEventListener('click', () => {
           const selected = candidate;
-          if (selected) void attach(mode, selected);
+          if (!selected) return;
+          if (mode === 'reference' || mode === 'edit') void attach(mode, selected);
+          else void attachInstruction(mode, selected);
         });
         toolbar.append(button);
       }

package/extension/src/content/sensitivePreflight.js

@@ -7,6 +7,10 @@
 })(typeof window !== 'undefined' ? window : globalThis, function sensitivePreflightFactory() {
   'use strict';
 
+  // Report evidence admits detector identities only, never matched text or previews.
+  const REPORT_DETECTOR_IDS = new Set(['private-key', 'bearer-token', 'api-token', 'aws-access-key',
+    'google-api-key', 'huggingface-token', 'gitlab-token', 'stripe-live-secret', 'jwt-token', 'secret-assignment']);
+
   function create({
     SensitiveScan, normalizeGovernanceRules, isTextSnapshotFile, sendBackgroundNative,
     getCurrentProjectId, appendRunEvent, appendCompletionReport, showPluginConfirm, tr, tx
@@ -62,12 +66,21 @@
       }
       // Blocking an extra message must not finish the task already in progress.
       if (guidance) return { blocked: true, findings };
-      appendCompletionReport({
+      const detectorIds = [...new Set(findings.map(finding => finding?.detectorId))];
+      appendCompletionReport({ conclusionKey: 'sensitive_blocked',
         conclusion: tx(
           'This run was blocked before Codex received project context because sensitive content was detected.',
           '检测到敏感内容，本轮已在向 Codex 发送项目上下文前阻止。'
         ),
         status: 'blocked',
+        unchangedReason: tx('Sensitive content was found before sending.', '发送前发现了敏感内容。'),
+        failure: { code: 'sensitive_content_blocked', stage: 'preflight', severity: 'blocked',
+          retryable: false, changedDocument: false,
+          evidence: {
+            // An unknown type makes the cause generic, even alongside one known type.
+            detectorIds: detectorIds.every(id => REPORT_DETECTOR_IDS.has(id)) ? detectorIds.slice(0, 5) : [],
+            findingCount: findings.length
+          } },
         operations: [],
         applyResults: [],
         nextStep: tx(

package/extension/src/content/sessionManager.js

@@ -11,7 +11,8 @@
     const {
       SessionPanel,
       SessionState,
-      SessionMenuView
+      SessionMenuView,
+      PanelIcons
     } = deps;
     const {
       createSession,
@@ -30,6 +31,9 @@
       saveState,
       saveStateSoon,
       readPanelInputs,
+      flushComposerDraft,
+      setSessionTransition,
+      getDraftScope,
       applyStateToPanel,
       syncSessionProvider,
       getPanel,
@@ -47,6 +51,7 @@
       getActiveSession,
       getPanel,
       getSessionDisplayTitle,
+      icons: PanelIcons,
       getState,
       isDisplayableSession,
       isSessionRunning,
@@ -60,7 +65,31 @@
       closeSessionMenu
     } = sessionMenuView;
 
-  async function startNewSession() {
+  let transitionToken = null;
+
+  async function withSessionTransition(change) {
+    if (transitionToken) return;
+    const token = {};
+    transitionToken = token;
+    const scope = getDraftScope?.();
+    try {
+      // Lock before the first wait, including an outstanding IME commit.
+      await setSessionTransition?.(true);
+      if (getDraftScope?.() !== scope) return;
+      return await change(scope);
+    } finally {
+      if (transitionToken === token) {
+        transitionToken = null;
+        setSessionTransition?.(false);
+      }
+    }
+  }
+
+  function startNewSession() {
+    return withSessionTransition(createNewSession);
+  }
+
+  async function createNewSession(draftScope) {
     // Leaving a still-running session is allowed but never silent: the run
     // keeps going in the background and lands in its own session.
     const runningActive = getActiveSession(getState());
@@ -74,7 +103,10 @@
         return;
       }
     }
+    if (getDraftScope?.() !== draftScope) return;
     readPanelInputs();
+    await flushComposerDraft?.();
+    if (getDraftScope?.() !== draftScope) return;
     // Reuse an already-empty, idle active session instead of minting a ghost.
     // Empty sessions are invisible in the list yet still consume the storage cap
     // (slice(-20) / maxSessions), so spamming "New Session" could silently evict
@@ -99,6 +131,7 @@
       if (!evictionApproved) {
         return;
       }
+      if (getDraftScope?.() !== draftScope) return;
     }
     const session = createSession({
       mode: getState().mode,
@@ -114,15 +147,22 @@
       activeSessionId: session.id
     }));
     applyStateToPanel();
+    const destinationScope = getDraftScope?.();
     await syncSessionProvider?.();
+    if (getDraftScope?.() !== destinationScope) return;
     await saveState();
+    if (getDraftScope?.() !== destinationScope) return;
     getPanel().querySelector('[data-task]')?.focus();
   }
 
-  async function switchSession(sessionId) {
+  function switchSession(sessionId) {
     if (sessionId === getState().activeSessionId) {
       return;
     }
+    return withSessionTransition(scope => switchToSession(sessionId, scope));
+  }
+
+  async function switchToSession(sessionId, draftScope) {
     const runningActive = getActiveSession(getState());
     if (runningActive && isSessionRunning(runningActive)) {
       const approved = await showPluginConfirm({
@@ -134,10 +174,15 @@
         return;
       }
     }
+    if (getDraftScope?.() !== draftScope) return;
     readPanelInputs();
+    await flushComposerDraft?.();
+    if (getDraftScope?.() !== draftScope) return;
     setState(setActiveSession(getState(), sessionId));
     applyStateToPanel();
+    const destinationScope = getDraftScope?.();
     await syncSessionProvider?.();
+    if (getDraftScope?.() !== destinationScope) return;
     await saveState();
   }
 
@@ -295,6 +340,7 @@
       bindActiveSessionHeader,
       startNewSession,
       switchSession,
+      isTransitioning: () => transitionToken !== null,
       deleteSessionWithConfirm,
       renderSessionList,
       commitSessionRename,

package/extension/src/content/sessionMenuView.js

@@ -11,6 +11,7 @@
       getPanel,
       getSessionDisplayTitle,
       getState,
+      icons = null,
       isDisplayableSession,
       isSessionRunning,
       startNewSession,
@@ -20,19 +21,20 @@
 
     function applySessionLabel() {
       const trigger = getPanel().querySelector('[data-session-menu-trigger]');
-      if (trigger) {
-        trigger.title = tr('sessionMenuOpen');
-        trigger.setAttribute('aria-label', tr('sessionMenuOpen'));
-      }
       const textNode = getPanel().querySelector('[data-session-label-text]');
       const deleteButton = getPanel().querySelector('[data-session-delete]');
       const renameButton = getPanel().querySelector('[data-session-rename]');
       const renameInput = getPanel().querySelector('[data-session-rename-input]');
       const active = getActiveSession(getState());
+      const label = active && isDisplayableSession(active)
+        ? getSessionDisplayTitle(active)
+        : tr('newSessionFallback');
       if (textNode) {
-        textNode.textContent = active && isDisplayableSession(active)
-          ? getSessionDisplayTitle(active)
-          : tr('newSessionFallback');
+        textNode.textContent = label;
+      }
+      if (trigger) {
+        trigger.title = `${label} · ${tr('sessionMenuOpen')}`;
+        trigger.setAttribute('aria-label', `${tr('sessionMenuOpen')}: ${label}`);
       }
       if (deleteButton) {
         const running = active ? isSessionRunning(active) : false;
@@ -111,11 +113,15 @@
         .slice()
         .sort((a, b) => String(b.updatedAt || b.createdAt || '').localeCompare(String(a.updatedAt || a.createdAt || '')));
       for (const session of sessions) {
-        const row = document.createElement('button');
-        row.type = 'button';
+        const row = document.createElement('div');
         row.className = 'codex-session-menu-item';
+        row.setAttribute('role', 'none');
         row.dataset.active = session.id === state?.activeSessionId ? 'true' : 'false';
         row.dataset.running = isSessionRunning(session) ? 'true' : 'false';
+        const switchButton = document.createElement('button');
+        switchButton.type = 'button';
+        switchButton.className = 'codex-session-menu-switch';
+        switchButton.setAttribute('role', 'menuitem');
         const title = document.createElement('span');
         title.className = 'codex-session-menu-item-title';
         title.textContent = getSessionDisplayTitle(session);
@@ -127,26 +133,56 @@
         if (absoluteTs) {
           time.title = new Date(absoluteTs).toLocaleString();
         }
-        row.append(title, time);
-        row.addEventListener('click', event => {
+        switchButton.append(title, time);
+        switchButton.addEventListener('click', event => {
           event.stopPropagation();
           closeSessionMenu();
           if (session.id !== getState()?.activeSessionId) {
             switchSession(session.id);
           }
         });
+        const deleteButton = menuAction('codex-session-menu-item-delete', 'close', '',
+          row.dataset.running === 'true' ? tr('deleteRunningSession') : tr('deleteSession'),
+          () => deleteSessionWithConfirm(session.id));
+        deleteButton.setAttribute('role', 'menuitem');
+        deleteButton.disabled = row.dataset.running === 'true';
+        row.append(switchButton, deleteButton);
         menu.append(row);
       }
-      const createButton = document.createElement('button');
-      createButton.type = 'button';
-      createButton.className = 'codex-session-menu-new';
-      createButton.textContent = `+ ${tr('newSession')}`;
-      createButton.addEventListener('click', event => {
+      const footer = document.createElement('div');
+      footer.className = 'codex-session-menu-footer';
+      const active = getActiveSession(state);
+      const running = active ? isSessionRunning(active) : false;
+      const soleEmpty = Boolean(active) && !isDisplayableSession(active) && (state?.sessions || []).length <= 1;
+      const createButton = menuAction('codex-session-menu-new', 'plus', tr('sessionMenuNewShort'), tr('newSession'), () => startNewSession());
+      const renameButton = menuAction('codex-session-menu-rename', 'pencil', tr('sessionMenuRenameShort'), tr('renameSession'), () => beginActiveSessionRename());
+      renameButton.disabled = !active;
+      const deleteButton = menuAction('codex-session-menu-delete', 'close', tr('sessionMenuDeleteShort'),
+        running ? tr('deleteRunningSession') : tr('deleteSession'), () => {
+          if (getState()?.activeSessionId) deleteSessionWithConfirm(getState().activeSessionId);
+        });
+      deleteButton.disabled = !active || running || soleEmpty;
+      footer.append(createButton, renameButton, deleteButton);
+      menu.append(footer);
+    }
+
+    function menuAction(className, iconName, label, description, onSelect) {
+      const button = document.createElement('button');
+      button.type = 'button';
+      button.className = className;
+      button.title = description;
+      button.setAttribute('aria-label', description);
+      const glyph = icons?.svg?.(iconName);
+      if (glyph) button.insertAdjacentHTML('beforeend', glyph);
+      const text = document.createElement('span');
+      text.textContent = label;
+      button.append(text);
+      button.addEventListener('click', event => {
         event.stopPropagation();
         closeSessionMenu();
-        startNewSession();
+        onSelect();
       });
-      menu.append(createButton);
+      return button;
     }
 
     function beginActiveSessionRename() {

package/extension/src/content/sessionPersistence.js

@@ -74,20 +74,40 @@
       .filter(record => !deleted.has(record.id))
       .map(record => [record.id, record]));
     const mergedRecords = sessionRecords.map(record => StorageDb.mergeSessionReviewState?.(
-      record, existingById.get(record.id), options.reviewRunIds
+      record, existingById.get(record.id), options.reviewRunIds, { shared: StorageDb.sharedSessionsEnabled?.() === true }
     ) || record);
+    const reviewRunIds = new Set(options.reviewRunIds || []);
+    // Shared storage merges local edits and explicitly requested Undo markers
+    // against the page baseline. Legacy and ordinary stale saves keep the age guard.
     const writable = mergedRecords.filter(record => {
       const existing = existingById.get(record.id);
       if (!existing) return true;
-      return (Date.parse(record.updatedAt || '') || 0) >= (Date.parse(existing.updatedAt || '') || 0);
+      return (Date.parse(record.updatedAt || '') || 0) >= (Date.parse(existing.updatedAt || '') || 0)
+        || (StorageDb.sharedSessionsEnabled?.() === true
+          && (StorageDb.hasUnpersistedSharedSession?.(record) === true
+            || (record.runs || []).some(run => reviewRunIds.has(run.id) && run.undoOwnerProtocol === 1)));
     });
     const cleanedExisting = existingSessions.filter((record, index) =>
       record !== rawExistingSessions[index] && !writable.some(item => item.id === record.id)
     );
     if (cleanedExisting.length || writable.length) {
-      const written = await StorageDb.putRecords('sessions', [...cleanedExisting, ...writable], {
-        reviewRunIds: options.reviewRunIds
-      });
+      const reviewReceipts = [];
+      if (StorageDb.sharedSessionsEnabled?.() === true && reviewRunIds.size) {
+        for (const record of writable) {
+          const ids = (record.runs || []).filter(run => reviewRunIds.has(run.id)).map(run => run.id);
+          if (ids.length) reviewReceipts.push(await StorageDb.putSessionReviewState(record, ids));
+        }
+      }
+      let written;
+      try {
+        written = await StorageDb.putRecords('sessions', [...cleanedExisting, ...writable], {
+          reviewRunIds: options.reviewRunIds, reviewReceipts
+        });
+      } catch (error) {
+        if (error.code === 'shared_session_conflict' && reviewReceipts.length)
+          Object.defineProperty(error, 'reviewReceipts', { value: reviewReceipts, configurable: true });
+        throw error;
+      }
       // Check the actual durable result, including a decision already saved
       // from another origin, instead of acknowledging only the proposed view.
       return written.filter(record => writable.some(candidate => candidate.id === record.id));