codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/content/scopedPersistencePanelState.js

@@ -15,11 +15,56 @@
     return JSON.parse(JSON.stringify(value));
   }
 
-  async function applyReviewTransition({ getState, runId, transition, persist }) {
+  // 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 || [])
     ])).filter(run => run.id === runId);
+    assertCurrent?.();
+    const capturedState = getState(), capturedSessionId = capturedState.activeSessionId;
     const records = targets();
     const sessions = (getState().sessions || []).filter(session =>
       (session.runs || []).some(run => run.id === runId));
@@ -31,15 +76,31 @@
         (Date.parse(session.lastActivityAt) || 0) + 1)).toISOString();
       session.lastActivityAt = session.updatedAt;
     }
+    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] });
+      await persist({ preserveRunActionPayload: true, reviewRunIds: [runId], requireDurable: true });
+      assertCurrent?.();
+      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 targets()) {
-        Object.assign(record, cloneSnapshot(previous), { trackedChangeStatus: 'needs_review' });
-        for (const field of ['settlement', 'settlementFacts']) {
-          if (!Object.prototype.hasOwnProperty.call(previous, field)) delete record[field];
-        }
+        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;
     }
@@ -51,6 +112,28 @@
     });
   }
 
+  function verifyRecoveredRuns(recoveredRuns, proposed, written) {
+    for (var target of recoveredRuns || []) {
+      var expectedSession = proposed.find(session => session.id === target.sessionId);
+      var storedSession = (written || []).find(session => session.id === target.sessionId
+        && session.projectId === expectedSession?.projectId
+        && session.accountScopeId === expectedSession?.accountScopeId);
+      var expected = expectedSession?.runs?.find(run => run.id === target.runId);
+      var stored = storedSession?.runs?.find(run => run.id === target.runId);
+      var retained = expected && stored
+        && expected.runProjectId === target.projectId && stored.runProjectId === target.projectId
+        && Number(stored.nativeEventSeq || 0) >= Number(expected.nativeEventSeq || 0)
+        && stored.codexThreadId === expected.codexThreadId
+        && stored.codexTurnId === expected.codexTurnId
+        && JSON.stringify(stored.interruptedDraft) === JSON.stringify(expected.interruptedDraft)
+        && (expected.events || []).every(event => (stored.events || [])
+          .some(saved => JSON.stringify(saved) === JSON.stringify(event)));
+      if (!retained) throw Object.assign(new Error('Recovered run was not durably saved; its replay journal is retained.'), {
+        code: 'recovery_state_not_persisted'
+      });
+    }
+  }
+
   async function persistPanelState(input) {
     var state = cloneSnapshot(input.state || {});
     var compactState = cloneSnapshot(input.compactState || {});
@@ -71,6 +154,12 @@
         code: 'stale_view'
       });
     }
+    if ((input.recoveryRuns || []).some(target => target.projectId !== projectId
+      || target.accountScopeId !== accountScopeId)) {
+      throw Object.assign(new Error('Journal recovery scope changed before persistence.'), {
+        code: 'recovery_scope_changed'
+      });
+    }
     var reviewRuns = (input.reviewRunIds || []).map(id =>
       (state.sessions || []).flatMap(session => session.runs || []).find(run => run.id === id));
     if (reviewRuns.some(run => !run)) throw reviewPersistenceError();
@@ -92,6 +181,8 @@
       latestPrefs && latestPrefs.experimentalOtByProject || {},
       { [projectId]: input.normalizeExperimentalOtByProject(state.experimentalOtByProject)[projectId] === true }
     );
+    prefs.reviewingAvailabilityByProject = Object.assign({}, latestPrefs?.reviewingAvailabilityByProject || {},
+      state.reviewingAvailabilityByProject || {});
     prefs.governanceRulesByProject = Object.assign(
       {},
       latestPrefs && latestPrefs.governanceRulesByProject || {},
@@ -129,25 +220,48 @@
         focusFiles: Array.isArray(session.focusFiles) ? session.focusFiles : [],
         createdAt: session.createdAt,
         updatedAt: session.updatedAt,
-        pendingInputs: (Array.isArray(session.pendingInputs) ? session.pendingInputs : [])
+      pendingInputs: (Array.isArray(session.pendingInputs) ? session.pendingInputs : [])
           .filter(function (item) { return !queueTombstones[item?.id]; })
       }), { preserveRunActionPayload: true });
     });
-    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 || ''
-    });
+    sessionRecords = StorageDb.compactSessionBatchActions?.(sessionRecords, { activeSessionId: state.activeSessionId }) || sessionRecords;
+    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 && run.trackedChangeStatus === reviewRun.trackedChangeStatus
+      run.id === reviewRun.id
+      && (!reviewRun.trackedChangeStatus && ['applied', 'partial'].includes(reviewRun.undoStatus)
+        ? run.undoStatus === reviewRun.undoStatus && (reviewRun.undoStatus === 'applied'
+          || ['undoOperations', 'undoBaseFiles', 'undoExpectedFiles', 'undoTrackedChanges']
+            .every(field => JSON.stringify(run[field] || []) === JSON.stringify(reviewRun[field] || [])))
+        : run.trackedChangeStatus === reviewRun.trackedChangeStatus)
     )))) throw reviewPersistenceError();
+    verifyRecoveredRuns(input.recoveryRuns, sessionRecords, written);
+    return written;
   }
 
   return Object.freeze({ persistPanelState: persistPanelState, applyReviewTransition: applyReviewTransition });

package/extension/src/content/selectionContextView.js

@@ -293,7 +293,7 @@
       toolbar = null;
     }
 
-    return { attach, capture, clear, render, start, destroy };
+    return { attach, capture, clear, render, start, destroy, getRevision: () => generation };
   }
 
   return { create, buildChip, renderSent };

package/extension/src/content/sensitivePreflight.js

@@ -0,0 +1,153 @@
+(function initCodexOverleafSensitivePreflight(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafSensitivePreflight = factory();
+  }
+})(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
+  }) {
+    async function runSensitivePreflight(options) {
+      options = options || {};
+      const { task, project, rules, useExistingMirror = false, guidance = false } = options;
+      const normalizedRules = normalizeGovernanceRules(rules);
+      if (normalizedRules.sensitiveCheckEnabled === false) {
+        return { blocked: false, findings: [] };
+      }
+      if (!SensitiveScan?.scanSensitiveInputs && !useExistingMirror) {
+        return { blocked: false, findings: [] };
+      }
+      let findings = SensitiveScan?.scanSensitiveInputs
+        ? SensitiveScan.scanSensitiveInputs({
+          task,
+          files: guidance ? [] : (project?.files || []).filter(isTextSnapshotFile)
+        })
+        : [];
+      if (useExistingMirror && !guidance) {
+        findings = dedupeSensitiveFindings([
+          ...findings,
+          ...await scanNativeMirrorSensitiveFindings()
+        ]);
+      }
+      if (!findings.length) {
+        return { blocked: false, findings: [] };
+      }
+      options.assertCurrent?.();
+      appendRunEvent({
+        title: tx(
+          `Sensitive content check found ${findings.length} item(s).`,
+          `敏感内容检查发现 ${findings.length} 项。`
+        ),
+        status: 'failed',
+        detail: findings.slice(0, 8).map(finding => ({
+          [tr('detailFile')]: finding.path || finding.source || 'task',
+          [tr('detailReason')]: finding.detectorId,
+          [tx('Preview', '预览')]: finding.preview || '[REDACTED]'
+        }))
+      });
+      if (normalizedRules.sensitiveConfirmAllowed === true) {
+        const approved = await showPluginConfirm({
+          title: tr('sensitiveConfirmTitle'),
+          message: formatSensitiveConfirmMessage(findings),
+          confirmLabel: guidance ? tx('Send guidance', '发送指导') : tr('sensitiveConfirmRun'),
+          cancelLabel: tr('confirmDefaultCancel'),
+          destructive: true
+        });
+        options.assertCurrent?.();
+        return { blocked: !approved, findings };
+      }
+      // Blocking an extra message must not finish the task already in progress.
+      if (guidance) return { blocked: true, findings };
+      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(
+          'Remove the sensitive content, narrow @context, or enable explicit sensitive confirmation in Project Settings.',
+          '请移除敏感内容、缩小 @context，或在项目设置里允许敏感内容显式确认。'
+        )
+      });
+      return { blocked: true, findings };
+    }
+
+    function formatSensitiveConfirmMessage(findings = []) {
+      const visible = findings.slice(0, 8).map(finding => {
+        const path = finding.path || finding.source || 'task';
+        return `${path}: ${finding.detectorId || 'sensitive'} (${finding.preview || '[REDACTED]'})`;
+      });
+      return [
+        tr('sensitiveConfirmMessage'),
+        '',
+        ...visible,
+        findings.length > visible.length ? tx(`${findings.length - visible.length} more finding(s).`, `另有 ${findings.length - visible.length} 项。`) : ''
+      ].filter(Boolean).join('\n');
+    }
+
+    async function scanNativeMirrorSensitiveFindings() {
+      try {
+        const response = await sendBackgroundNative({
+          method: 'mirror.scanSensitive',
+          params: { projectId: getCurrentProjectId() }
+        });
+        if (response?.ok) {
+          return Array.isArray(response.result?.findings) ? response.result.findings : [];
+        }
+        return [{
+          detectorId: 'mirror-sensitive-scan-unavailable',
+          source: 'local-mirror',
+          preview: response?.error?.message || 'Could not scan the local mirror before Codex runs.'
+        }];
+      } catch (error) {
+        return [{
+          detectorId: 'mirror-sensitive-scan-unavailable',
+          source: 'local-mirror',
+          preview: error?.message || 'Could not scan the local mirror before Codex runs.'
+        }];
+      }
+    }
+
+    function dedupeSensitiveFindings(findings = []) {
+      const seen = new Set();
+      const deduped = [];
+      for (const finding of findings || []) {
+        const key = [
+          finding?.detectorId || '',
+          finding?.source || '',
+          finding?.path || '',
+          finding?.preview || ''
+        ].join('\u0000');
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        deduped.push(finding);
+      }
+      return deduped;
+    }
+
+    return { run: runSensitivePreflight };
+  }
+
+  return { create };
+});

package/extension/src/content/sessionForkController.js

@@ -7,15 +7,32 @@
 
   function create(deps = {}) {
     const {
-      SessionState, getState, setState, sendBackgroundNative, saveState,
+      SessionState, getState, setState, getScope, sendBackgroundNative, saveState,
       applyStateToPanel, showPluginToast, tr
     } = deps;
 
     async function forkRunFromNode(runId) {
       const previousState = getState();
+      const skillPreferences = {
+        loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
+        loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false,
+        codexLocalSkillEnabled: { ...previousState.codexLocalSkillEnabled }
+      };
       const source = findSource(previousState, runId);
       if (!source) return failFork('session_fork_source_missing', tr('forkRunUnavailable'));
-      const { session, run, runIndex } = source;
+      const scope = getScope ? { ...getScope() } : null;
+      const requestedActiveId = previousState.activeSessionId;
+      // The Native request and copied history must describe the same origin,
+      // even when the source session is edited while the request is pending.
+      const { session, run, runIndex } = JSON.parse(JSON.stringify(source));
+      const sameScope = () => {
+        const current = getScope?.();
+        return !scope || ['accountScopeId', 'projectId', 'generation'].every(key => current?.[key] === scope[key]);
+      };
+      const currentSource = () => {
+        const current = findSource(getState(), runId);
+        return current?.session.id === session.id && current.run.codexTurnId === run.codexTurnId;
+      };
       const draftThreadId = run.codexTurnId && run.interruptedDraft?.turnId === run.codexTurnId
         ? run.interruptedDraft.threadId : '';
       // Provider switches replace the session thread, not the selected node's origin.
@@ -25,25 +42,39 @@
       }
       let response;
       try {
+        const resolveLocalSkills = deps.captureLocalSkillIdsForFork || deps.getEnabledCodexLocalSkillIds;
+        const enabledCodexLocalSkillIds = skillPreferences.loadCodexLocalSkills
+          ? captureLocalSkillIds(await resolveLocalSkills?.(skillPreferences)) : [];
+        if (!sameScope() || !currentSource()) return null;
+        if (resolveLocalSkills && !Array.isArray(enabledCodexLocalSkillIds)) {
+          throw codedError('codex_local_skill_unavailable', tr('forkRunFailed'));
+        }
         response = await sendBackgroundNative({
           method: 'codex.thread.fork',
           params: {
             threadId: sourceThreadId,
             lastTurnId: run.codexTurnId,
             speedTier: session.speedTier,
-            loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
-            loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
+            loadCodexLocalSkills: skillPreferences.loadCodexLocalSkills,
+            loadCodexOverleafSkills: skillPreferences.loadCodexOverleafSkills,
+            enabledCodexLocalSkillIds
           }
         });
       } catch (error) {
+        if (!sameScope() || !currentSource()) return null;
         return failFork(error?.code || 'session_fork_failed', error?.message || tr('forkRunFailed'));
       }
+      if (!sameScope() || !currentSource()) {
+        if (response?.ok && response.result?.threadId) await clearFork(response.result.threadId);
+        return null;
+      }
       if (!response?.ok || !response.result?.threadId) {
         return failFork(response?.error?.code || 'session_fork_failed', response?.error?.message || tr('forkRunFailed'));
       }
       const copiedRuns = session.runs.slice(0, runIndex + 1).map(copyRunSnapshot);
       const titleBase = String(session.title || copiedRuns[0]?.task || tr('newSessionFallback')).trim();
-      const forkTitle = buildUniqueForkTitle(previousState.sessions, titleBase);
+      const mergeBase = getState();
+      const forkTitle = buildUniqueForkTitle(mergeBase.sessions, titleBase);
       const forked = SessionState.createSession({
         title: forkTitle,
         titleSource: 'manual',
@@ -62,27 +93,55 @@
         forkedFromSessionId: session.id,
         forkedFromRunId: run.id
       });
-      setState(SessionState.normalizePanelState({
-        ...previousState,
-        sessions: [...(previousState.sessions || []), forked],
-        activeSessionId: forked.id
-      }));
+      const activeId = mergeBase.activeSessionId === requestedActiveId
+        ? forked.id : mergeBase.activeSessionId;
+      const installed = SessionState.setActiveSession({
+        ...mergeBase, sessions: [...(mergeBase.sessions || []), forked]
+      }, activeId);
+      const installedSnapshot = JSON.stringify(installed);
+      const forkSnapshot = JSON.stringify(forked);
+      setState(installed);
       try {
+        // Keep the visible composer and active-session owner aligned during save.
+        applyStateToPanel();
         await saveState();
       } catch (error) {
-        setState(previousState);
-        await sendBackgroundNative({
-          method: 'codex.history.clearPlugin',
-          params: { sessionId: forked.id, threadId: response.result.threadId }
-        }).catch(() => null);
-        showPluginToast(error.message || tr('forkRunFailed'), { status: 'failed', sticky: true });
+        if (sameScope()) {
+          const current = getState();
+          const currentFork = current.sessions?.find(item => item.id === forked.id);
+          // Never erase work entered into the fork after its optimistic insert.
+          if (!currentFork || JSON.stringify(currentFork) === forkSnapshot) {
+            if (currentFork) {
+              if (current === installed && JSON.stringify(current) === installedSnapshot) {
+                setState(mergeBase);
+              } else {
+                const remaining = current.sessions.filter(item => item.id !== forked.id);
+                const fallbackId = remaining.some(item => item.id === mergeBase.activeSessionId)
+                  ? mergeBase.activeSessionId : remaining[remaining.length - 1]?.id;
+                setState(SessionState.setActiveSession({ ...current, sessions: remaining },
+                  current.activeSessionId === forked.id ? fallbackId : current.activeSessionId));
+              }
+              try { applyStateToPanel(); } catch (_renderError) { /* Preserve the original failure and finish cleanup. */ }
+            }
+            await clearFork(response.result.threadId, forked.id);
+          }
+          if (sameScope()) showPluginToast(error.message || tr('forkRunFailed'), { status: 'failed', sticky: true });
+        }
         throw error;
       }
-      applyStateToPanel();
+      // Persistence owns its captured scope. A late result cannot render a new
+      // view or delete a thread that may already have been saved in the old one.
+      if (!sameScope() || !getState().sessions?.some(item => item.id === forked.id)) return null;
       showPluginToast(tr('forkRunDone'), { status: 'completed' });
       return forked;
     }
 
+    async function clearFork(threadId, sessionId) {
+      try {
+        await sendBackgroundNative({ method: 'codex.history.clearPlugin', params: { sessionId, threadId } });
+      } catch (_error) { /* Best-effort cleanup must not restore a stale view. */ }
+    }
+
     function failFork(code, message) {
       showPluginToast(message, { status: 'failed', sticky: true });
       throw codedError(code, message);
@@ -91,6 +150,10 @@
     return { forkRunFromNode };
   }
 
+  function captureLocalSkillIds(value) {
+    return Array.isArray(value) ? [...value] : undefined;
+  }
+
   function buildUniqueForkTitle(sessions = [], sourceTitle = '') {
     const fallback = String(sourceTitle || 'New Session').trim() || 'New Session';
     const baseTitle = fallback

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();
   }
 
@@ -201,7 +246,7 @@
         }
       });
       if (!response?.ok) {
-        showPluginToast(tr('deleteSessionHistoryFailedToast', { message: response?.error?.message || 'native host did not return success' }), { status: 'warning', sticky: true });
+        showPluginToast(tr('deleteSessionHistoryFailedToast', { message: response?.error?.message || tr('deleteSessionNativeFailureDetail') }), { status: 'warning', sticky: true });
       } else if (response.result?.skipped) {
         showPluginToast(tr('deleteSessionNoThreadToast'), { status: 'info' });
       } else {
@@ -295,6 +340,7 @@
       bindActiveSessionHeader,
       startNewSession,
       switchSession,
+      isTransitioning: () => transitionToken !== null,
       deleteSessionWithConfirm,
       renderSessionList,
       commitSessionRename,