codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/page/trackedChangesLifecycle.js

@@ -1,20 +1,18 @@
 (function initCodexOverleafTrackedChangesLifecycle(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('./trackedChangeReplay'), require('./reviewContext'));
   } else {
-    root.CodexOverleafTrackedChangesLifecycle = factory();
+    root.CodexOverleafTrackedChangesLifecycle = factory(root.CodexOverleafTrackedChangeReplay, root.CodexOverleafReviewContext);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function trackedChangesLifecycleFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function trackedChangesLifecycleFactory(Replay, ReviewContext) {
   'use strict';
-
-  // Tracked-changes lifecycle — carved out of writebackRouter.js in v1.8.0
-  // (structural-debt phase 7, #117): the accept/reject flows, the
-  // accept-replay + editor-undo recovery machinery, the reviewing/editing
-  // blocked-result builders, and the DOM collectors for Overleaf's
-  // tracked-change widgets. Code moved verbatim (original indentation kept);
-  // page-side collaborators are factory-injected by writebackRouter, which
-  // remains the only consumer and the owner of applyOperations itself.
   function create(deps = {}) {
+    const base = createCore(deps);
+    const run = (method, params) => ReviewContext.create(deps, params).run((scoped, input) => createCore(scoped)[method](input));
+    return { ...base, rejectTrackedChanges: params => run('rejectTrackedChanges', params),
+      acceptTrackedChanges: params => run('acceptTrackedChanges', params) };
+  }
+  function createCore(deps = {}) {
     const {
       window,
       checkWritebackRunProjectId,
@@ -41,7 +39,7 @@
       normalizeOperationPaths,
       normalizeReviewingSignalText,
       normalizeSafeProjectPath,
-      openFileByPath,
+      openFileByPath: openReviewFileByPath,
       readActiveEditorText,
       readNodeSignalText,
       setReviewingEnabled,
@@ -49,10 +47,19 @@
       verifyActiveEditorText,
       collectElements,
     } = deps;
+    const { buildAcceptReplayOperations, rebaseCheckpointPair, prepareSnapshotUndoCheckpoints, buildSnapshotUndoResult } = Replay.create({
+      normalizeSafeProjectPath, applyTextPatches
+    });
+  function openFileByPath(path, ...options) {
+    if (path !== getActiveFilePath()) rememberTrackedChangeNodeContext(getActiveFilePath());
+    return openReviewFileByPath(path, ...options);
+  }
 
   function nativeReviewBlocked(path, code, applied = [], requestStarted = false) {
     const reason = requestStarted
       ? 'The native review request could not be fully verified; some target changes may already be accepted. No text replay was attempted. Check Overleaf Review before retrying.'
+      : code === 'native_untracked_undo_pending_changes'
+      ? 'This file has unresolved tracked changes. Undo without track changes was stopped to preserve them; no document changes were made.'
       : 'The native tracked-change scope could not be safely isolated. No review mutation was attempted. Use Overleaf Review to handle the changes individually.';
     return { ok: false, applied, skipped: [{ trackedChange: { path }, result: {
       ok: false, code, reason, failure: {
@@ -65,14 +72,15 @@
     } }] };
   }
 
-  async function waitForNativeReview(path, refs, untracked = false) {
+  async function waitForNativeReview(path, refs, untracked = false, checkpointReady = () => true) {
     const prepare = () => untracked ? prepareUntrackedUndo(path) : prepareTrackedChangeReview(path, refs);
     for (let attempt = 0; attempt < 16; attempt++) {
       const scope = prepare();
-      if (scope.ok) return scope;
+      if (scope.ok && checkpointReady(scope)) return scope;
       await delay(150);
     }
-    return prepare();
+    const scope = prepare();
+    return scope.ok && !checkpointReady(scope) ? { ...scope, ok: false } : scope;
   }
 
   async function prepareNativeReview(params, allowUntrackedUndo = false) {
@@ -96,7 +104,7 @@
       ...checkpoints.map(file => normalizeSafeProjectPath(file?.path))])];
     if ((!refs.length && !untracked) || refs.some(ref => ref.invalidProjectPath || !ref.path) || paths.some(path => !path))
       return nativeReviewBlocked('', 'native_review_identity_unavailable');
-    const files = [], deadline = Date.now() + 90000;
+    const files = [], deadline = Math.min(Date.now() + 90000, deps.reviewDeadlineAt ?? Infinity);
     for (const path of paths) {
       if (Date.now() >= deadline || checkWritebackRunProjectId(params))
         return nativeReviewBlocked(path, 'native_review_context_changed');
@@ -104,13 +112,121 @@
         return nativeReviewBlocked(path, 'native_review_file_unavailable');
       const scope = await waitForNativeReview(path, refs, untracked);
       if (!scope.ok) return nativeReviewBlocked(path, scope.reason || 'native_review_unavailable');
+      if (scope.merged) {
+        const before = (params.expectedFiles || []).filter(file => file.path === path);
+        const post = (params.postFiles || []).filter(file => file.path === path);
+        if (scope.merged.runProjectId !== params.runProjectId || before.length !== 1 || post.length !== 1
+          || before[0].content !== scope.merged.preContent || post[0].content !== scope.merged.postContent)
+          return nativeReviewBlocked(path, 'native_merged_review_checkpoint_mismatch');
+      }
       files.push({ path, nativeDocId: scope.nativeDocId, scope });
     }
     return { ok: true, files, refs, deadline };
   }
 
+  function mergedReviewContextMatches(params, file, content) {
+    const projectId = typeof deps.getProjectId === 'function' ? deps.getProjectId()
+      : /\/project\/([^/?#]+)/.exec(window?.location?.pathname || '')?.[1];
+    return Boolean(params.runProjectId && projectId === params.runProjectId
+      && !checkWritebackRunProjectId(params) && getActiveFilePath() === file.path
+      && readActiveEditorText() === content);
+  }
+
+  async function reviewMergedInsertion(params, file, action) {
+    const path = file.path, accepting = action === 'accept';
+    let scope = prepareTrackedChangeReview(path, file.scope.targets);
+    if (!scope.ok || !scope.merged || scope.nativeDocId !== file.nativeDocId
+      || !mergedReviewContextMatches(params, file, scope.merged.postContent))
+      return nativeReviewBlocked(path, 'native_merged_review_scope_changed');
+    const before = (params.expectedFiles || []).filter(item => item.path === path);
+    const post = (params.postFiles || []).filter(item => item.path === path);
+    if (before.length !== 1 || post.length !== 1
+      || before[0].content !== scope.merged.preContent || post[0].content !== scope.merged.postContent)
+      return nativeReviewBlocked(path, 'native_merged_review_checkpoint_mismatch');
+    const view = deps.getCodeMirrorEditorView?.();
+    if (typeof view?.dispatch !== 'function' || view.state?.doc?.toString() !== post[0].content)
+      return nativeReviewBlocked(path, 'native_merged_review_editor_unavailable');
+
+    const editing = await forceEditingForAcceptReplay();
+    if (!editing.ok) return nativeReviewBlocked(path, 'native_merged_review_editing_unavailable');
+    let attempted = false;
+    try {
+      const stable = await waitForStableEditingForAcceptReplay({ waitMs: 1400, intervalMs: 160 });
+      scope = prepareTrackedChangeReview(path, file.scope.targets);
+      if (!stable.ok || !scope.ok || !scope.merged || scope.nativeDocId !== file.nativeDocId
+        || !mergedReviewContextMatches(params, file, post[0].content)
+        || deps.getCodeMirrorEditorView?.() !== view || view.state.doc.toString() !== post[0].content)
+        return nativeReviewBlocked(path, 'native_merged_review_scope_changed');
+
+      // A same-text replacement is deliberate: plain Editing removes tracking
+      // only from these exact inserted slices, without a transient text rollback.
+      // Never send a merged parent's ID to the whole-change Accept endpoint.
+      const changes = scope.merged.ranges.map(range => ({
+        from: range.start, to: range.end,
+        insert: accepting ? post[0].content.slice(range.start, range.end) : ''
+      }));
+      const expectedText = accepting ? post[0].content : before[0].content;
+      const expectedKeys = accepting ? scope.merged.preservedKeys : scope.merged.beforeKeys;
+      if (deps.reviewGuard?.()) return nativeReviewBlocked(path, 'native_review_context_changed');
+      attempted = true;
+      view.dispatch({ changes });
+      compileBridge.markSourceEdited();
+
+      const until = Math.min(file.deadline || Date.now() + 8000, Date.now() + 8000);
+      let matchingSince = null;
+      while (Date.now() <= until) {
+        if (!mergedReviewContextMatches(params, file, expectedText))
+          return nativeReviewBlocked(path, 'native_merged_review_content_or_context_changed', [], true);
+        const after = prepareTrackedChangeCapture(path);
+        const matches = after.ready && after.source === 'native' && after.nativeDocId === file.nativeDocId
+          && JSON.stringify(after.refs.map(ref => ref.key).sort()) === JSON.stringify(expectedKeys);
+        if (matches) {
+          if (matchingSince === null) matchingSince = Date.now();
+          if (Date.now() - matchingSince >= 500) {
+            return { ok: true, verified: true, applied: scope.targets.map(trackedChange => ({
+              trackedChange, result: { ok: true, verified: true, verifiedContent: expectedText,
+                method: accepting ? 'overleaf-accept-untracked-replay' : 'overleaf-merged-insertion-undo',
+                preservedTrackedChanges: true }
+            })), skipped: [] };
+          }
+        } else matchingSince = null;
+        await delay(150);
+      }
+      return nativeReviewBlocked(path, 'native_merged_review_not_verified', [], true);
+    } catch (_error) {
+      return nativeReviewBlocked(path, 'native_merged_review_interrupted', [], attempted);
+    } finally {
+      // Match the existing no-trace Accept policy: do not re-enable tracking
+      // while an untracked operation can still be awaiting its server flush.
+      if (!attempted && editing.activated) await setReviewingEnabled(true, { waitMs: 1800 });
+    }
+  }
+
+  async function rejectPlanWithMergedInsertions(params, plan) {
+    const mixed = plan.files.find(file => !file.scope.merged && file.scope.unrelated.length);
+    if (mixed) return nativeReviewBlocked(mixed.path, 'native_reject_mixed_changes');
+    const applied = deps.createReviewApplied?.() || [];
+    for (const file of plan.files) {
+      if (Date.now() >= plan.deadline || checkWritebackRunProjectId(params))
+        return nativeReviewBlocked(file.path, 'native_review_context_changed', applied, applied.length > 0);
+      if (getActiveFilePath() !== file.path && !(await openFileByPath(file.path)).ok)
+        return nativeReviewBlocked(file.path, 'native_review_file_unavailable', applied, applied.length > 0);
+      const scoped = { ...params,
+        trackedChanges: plan.refs.filter(ref => ref.path === file.path),
+        expectedFiles: (params.expectedFiles || []).filter(item => item.path === file.path),
+        postFiles: (params.postFiles || []).filter(item => item.path === file.path)
+      };
+      const result = file.scope.merged
+        ? await reviewMergedInsertion(scoped, { ...file, deadline: plan.deadline }, 'reject')
+        : await rejectTrackedChanges(scoped);
+      applied.push(...(result.applied || []));
+      if (!result.ok) return { ...result, applied };
+    }
+    return { ok: true, applied, skipped: [] };
+  }
+
   async function acceptNativeReview(params, plan) {
-    const applied = [];
+    const applied = deps.createReviewApplied?.() || [];
     let token = window?.document?.querySelector?.('meta[name="ol-csrfToken"]')?.getAttribute('content');
     try { token = JSON.parse(token); } catch (_error) { /* Older pages expose plain text. */ }
     if (typeof token !== 'string' || !token || token.length > 4096
@@ -126,6 +242,12 @@
         return nativeReviewBlocked(path, 'native_review_context_changed', applied, applied.length > 0);
       if (getActiveFilePath() !== path && !(await openFileByPath(path)).ok)
         return nativeReviewBlocked(path, 'native_review_file_unavailable', applied, applied.length > 0);
+      if (file.scope.merged) {
+        const result = await reviewMergedInsertion(params, { ...file, deadline: plan.deadline }, 'accept');
+        applied.push(...(result.applied || []));
+        if (!result.ok) return { ...result, applied };
+        continue;
+      }
       await waitForNativeReview(path, plan.refs);
       const scope = prepareTrackedChangeReview(path, plan.refs), text = readActiveEditorText();
       if (!scope.ok || !scope.acceptByIdSupported || scope.nativeDocId !== file.nativeDocId
@@ -135,6 +257,7 @@
       const controller = new window.AbortController();
       const timer = window.setTimeout(() => controller.abort(), Math.min(12000, Math.max(1, plan.deadline - Date.now())));
       try {
+        if (deps.reviewGuard?.()) return nativeReviewBlocked(path, 'native_review_context_changed', applied, applied.length > 0);
         // Same ID-scoped endpoint and CSRF header used by Overleaf's RangesProvider.
         const response = await window.fetch('/project/' + encodeURIComponent(params.runProjectId)
           + '/doc/' + encodeURIComponent(scope.nativeDocId) + '/changes/accept', {
@@ -142,6 +265,7 @@
           headers: { 'Content-Type': 'application/json', Accept: 'application/json', 'X-Csrf-Token': token },
           body: JSON.stringify({ change_ids: scope.ids })
         });
+        if (deps.reviewGuard?.()) return nativeReviewBlocked(path, 'native_review_context_changed', applied, true);
         if (!response.ok) return nativeReviewBlocked(path, 'native_accept_http_' + response.status, applied, true);
       } catch (_error) {
         return nativeReviewBlocked(path, 'native_accept_request_unconfirmed', applied, true);
@@ -166,19 +290,15 @@
     return { ok: true, verified: true, applied, skipped: [] };
   }
 
+  let nativeRejectPlan = null;
   async function rejectTrackedChanges(params = {}) {
-    // Welcome-panel + write-guard: defense-in-depth.
-    // The pageBridge wrapper already runs the runProjectId guard, but a
-    // future caller could reach the router directly. A missing or empty
-    // `runProjectId` blocks the reject with the same shape the page-side
-    // guard uses. Existing tests that target individual reject behaviors set
-    // `runProjectId` on params; tests that intentionally omit it land here.
+    // Direct router callers also require the original run project identity.
     const writeGuardBlock = checkWritebackRunProjectId(params);
     if (writeGuardBlock) return writeGuardBlock;
     const trackedChanges = normalizeTrackedChangeRefs(params.trackedChanges || []);
     const expectedFiles = Array.isArray(params.expectedFiles) ? params.expectedFiles : [];
     const postFiles = Array.isArray(params.postFiles) ? params.postFiles : [];
-    const applied = [];
+    const applied = deps.createReviewApplied?.() || [];
     const skipped = [];
     const appliedPaths = new Set();
     const invalidTrackedChange = trackedChanges.find(trackedChange => trackedChange.invalidProjectPath);
@@ -194,9 +314,26 @@
     }
 
     const nativeReview = await prepareNativeReview(params, true);
+    nativeRejectPlan = nativeReview;
     if (nativeReview && !nativeReview.ok) return nativeReview;
+    if (nativeReview?.files.some(file => file.scope.merged))
+      return rejectPlanWithMergedInsertions(params, nativeReview);
     const mixedFile = nativeReview?.files.find(file => file.scope.unrelated.length);
     if (mixedFile) return nativeReviewBlocked(mixedFile.path, 'native_reject_mixed_changes');
+    if (params.untrackedUndo === true && !trackedChanges.length) {
+      if (!nativeReview) return nativeReviewBlocked('', 'native_review_unavailable');
+      // An ordinary write has no owned editor-history entry. Restore its
+      // checkpoint directly; global Undo may belong to an earlier user edit.
+      const restored = await restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles, {
+        runProjectId: params.runProjectId, untrackedPlan: nativeReview
+      });
+      if (restored.applied.some(entry => entry.result?.changedDocument !== false)) compileBridge.markSourceEdited();
+      return { ...restored, ok: restored.attempted && restored.ok,
+        skipped: restored.attempted ? restored.skipped : [{ trackedChange: { path: restored.file || '' }, result: {
+          ok: false, file: restored.file || '', code: restored.code || 'snapshot_undo_unavailable',
+          reason: restored.reason || 'The saved checkpoint is unavailable for this undo.'
+        } }] };
+    }
     const editorUndo = await rejectTrackedChangesViaEditorUndo(expectedFiles, postFiles, applied);
     if (editorUndo.ok) {
       if (applied.length > 0) {
@@ -295,7 +432,7 @@
         continue;
       }
 
-      const rejectControl = findRejectControlForTrackedChangeNode(node);
+      const rejectControl = isTrackedChangeNodeInNativeScope(node, trackedChange.path || getActiveFilePath()) ? findRejectControlForTrackedChangeNode(node) : null;
       if (!rejectControl) {
         if (expectedFiles.length || trackedChange.path) {
           continue;
@@ -345,7 +482,7 @@
       const completion = await rejectRemainingTrackedChangesForExpectedFiles(expectedFiles, applied);
       if (!completion.ok) {
         skipped.push({
-          trackedChange: null,
+          trackedChange: completion.file ? { path: completion.file } : null,
           result: completion
         });
       }
@@ -353,7 +490,7 @@
       const completion = await rejectRemainingTrackedChangesForTrackedPaths(trackedChanges, applied);
       if (!completion.ok) {
         skipped.push({
-          trackedChange: null,
+          trackedChange: completion.file ? { path: completion.file } : null,
           result: completion
         });
       }
@@ -373,18 +510,15 @@
   // Native-ledger browsers accept exact IDs without changing document text.
   // The original undo/replay flow remains only for legacy adapter callers.
   async function acceptTrackedChanges(params = {}) {
-    // Welcome-panel + write-guard: defense-in-depth.
-    // The pageBridge wrapper already runs the runProjectId guard, but a
-    // future caller could reach the router directly. A missing or empty
-    // `runProjectId` blocks the accept with the same shape the page-side
-    // guard uses.
+    // Direct router callers also require the original run project identity.
     const writeGuardBlock = checkWritebackRunProjectId(params);
     if (writeGuardBlock) return writeGuardBlock;
+    if (params.verifyManualReview === true) return nativeReviewBlocked('', 'native_accept_protocol_unsupported');
     const nativeReview = await prepareNativeReview(params);
     if (nativeReview) return nativeReview.ok ? acceptNativeReview(params, nativeReview) : nativeReview;
     const expectedFiles = Array.isArray(params.expectedFiles) ? params.expectedFiles : [];
     const postFiles = Array.isArray(params.postFiles) ? params.postFiles : [];
-    const applied = [];
+    const applied = deps.createReviewApplied?.() || [];
     const skipped = [];
     // diagnostics: a per-step trace returned to the caller so the run card can
     // surface exactly what happened on each Accept All step. Each entry is
@@ -427,12 +561,8 @@
     const editorUndo = await rejectTrackedChangesViaEditorUndo(expectedFiles, postFiles, applied);
     let undoReady = editorUndo.ok === true;
     let snapshotUndo = null;
-    // A page refresh preserves the run checkpoint but clears CodeMirror's
-    // in-memory undo history. When the native editor undo made no progress,
-    // reuse Undo's guarded snapshot path: it first verifies that every file is
-    // still exactly at this run's post-write content, then restores the
-    // persisted pre-write content with Track Changes disabled. The normal
-    // Accept replay below can then apply the post-write patch untracked.
+    // After a refresh clears native history, guarded snapshot rollback can
+    // restore exact checkpoints in Editing before the legacy Accept replay.
     if (!undoReady && applied.length === appliedBeforeUndo) {
       snapshotUndo = await restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles, {
         runProjectId: params.runProjectId
@@ -498,10 +628,8 @@
       reason: editingSwitch.reason || ''
     });
     if (!editingSwitch.ok) {
-      // The undo already reverted the writeback; without a *confirmed* Editing
-      // mode the replay would itself be tracked. Bail rather than re-introduce
-      // tracked changes. The structured failure from forceEditingForAcceptReplay
-      // (editing_not_confirmed, changedDocument:true) is preserved verbatim.
+      // Undo already changed the document. Preserve that evidence and stop
+      // when Editing cannot be confirmed for an untracked replay.
       return {
         ok: false,
         applied: [],
@@ -544,12 +672,8 @@
       };
     }
 
-    // Step 3: re-apply each file's changed fragments as a plain edit. With
-    // tracking off these land as permanent, untracked text. The replay must
-    // write only the minimal changed fragments via the `patches` path of
-    // applyOperationsCore — never a whole-file replaceAll, which would clobber
-    // any unrelated content and produce one giant tracked change if anything
-    // about the mode switch were imperfect.
+    // Replay only the changed fragments in Editing; whole-file replacement
+    // would overwrite unrelated text or create one large tracked change.
     const operationsResult = buildAcceptReplayOperations(
       paths,
       expectedByPath,
@@ -571,18 +695,9 @@
       };
     }
     const operations = operationsResult.operations;
-    // Per-op replay loop with sticky-Editing re-confirm and a short stable
-    // window before every actual CodeMirror write.
-    //
-    // Bug C: even after forceEditingForAcceptReplay confirmed Editing once,
-    // Overleaf has been observed flipping back to Reviewing between the
-    // confirm and the next CodeMirror write (Overleaf-side override, per-user
-    // "Track Changes for me" setting, or a positive-confirm false-positive
-    // window). The fix: re-verify Editing immediately BEFORE every single
-    // operation, and if Reviewing has slipped back on, force the toggle off
-    // again and positively re-confirm before writing. If Editing still cannot
-    // be positively confirmed after the re-toggle, bail the rest of the loop
-    // so we never land a tracked write.
+    // Overleaf may return to Reviewing between confirmation and a write.
+    // Reconfirm stable Editing before every operation, force it off again
+    // if needed, and stop the tail whenever confirmation fails.
     let bailedReason = null;
     for (const operation of operations) {
       const opPath = operation?.path || '';
@@ -736,12 +851,8 @@
       }
     }
 
-    // Step 4 intentionally does NOT restore Reviewing. Accept replay is a
-    // no-trace write transaction: restoring Track Changes immediately after the
-    // CodeMirror dispatch can race with Overleaf's collaboration/reviewing
-    // settlement and cause the replay itself to land as fresh tracked changes.
-    // Leave the editor in Editing after a successful replay; the user can turn
-    // Reviewing back on manually after Overleaf has saved the accepted text.
+    // Leave Editing active: restoring Reviewing before collaboration settles
+    // can turn the untracked Accept replay into fresh tracked changes.
     if (weToggledOff) {
       pushDiagnostic('restoreReviewing', {
         ok: true,
@@ -763,12 +874,8 @@
     };
   }
 
-  // Summarizes a reviewing state for the per-step diagnostics. Surfaces
-  // exactly the bits the user needs to diagnose a sticky-Editing slip: the
-  // reviewing detector's verdict (ok/status/source), a compact controls
-  // summary, and the two strict gates (isReviewingPositivelyOn /
-  // isEditingPositivelyConfirmed). Self-contained — the run card can render
-  // this verbatim without re-reading any page state.
+  // Capture the detector signals and strict gates for self-contained
+  // diagnostics; rendering must not reread mutable page state.
   function summarizeReviewingStateForDiagnostics(state = {}) {
     const reviewing = state.reviewing || {};
     const controls = (state.signals?.controls || []).slice(0, 6).map(control => {
@@ -794,10 +901,8 @@
     };
   }
 
-  // Track Changes is positively confirmed OFF only when Editing is positively
-  // detected AND Reviewing is NOT positively confirmed on. This is the strict
-  // gate the Accept replay needs: it must never replay while tracked, so
-  // anything short of a positive "Editing on / Reviewing off" is rejected.
+  // Accept replay requires positively detected Editing and no positively
+  // confirmed Reviewing; every weaker observation must stop the replay.
   function isEditingPositivelyConfirmed(state = {}) {
     return isEditingConfirmedForNoTraceUndo(state) && !isReviewingConfirmedForWrite(state);
   }
@@ -856,42 +961,20 @@
     };
   }
 
-  // Robustly switch Overleaf to Editing (Track Changes OFF) for the Accept
-  // replay.
-  //
-  // Bug B root cause: the accept flow used ensureEditing, which short-circuits
-  // on isEditingConfirmedForNoTraceUndo. That detector is negation-based — it
-  // returns true whenever Reviewing is not *positively* confirmed-for-write
-  // (which requires an active aria attribute the real Overleaf reviewing
-  // control does not always carry) AND a control loosely matches an Editing
-  // pattern. So while Track Changes was actually ON, it false-positived
-  // "already Editing", ensureEditing returned activated:false without toggling,
-  // and the replay landed as tracked changes.
-  //
-  // The fix here does NOT trust that lenient short-circuit: it reads the
-  // reviewing state explicitly and treats Editing as confirmed only when it is
-  // *positively* confirmed (Editing detected AND Reviewing not confirmed on).
-  // Whenever that strict gate is not met it forces setReviewingEnabled(false),
-  // then positively re-confirms Editing before returning ok; if it still cannot
-  // confirm Editing it returns not-ok so the caller bails instead of replaying
-  // while tracked.
+  // Accept replay requires positively confirmed Editing. The legacy detector
+  // can misclassify Reviewing controls without aria state; force the toggle
+  // and recheck before replaying untracked text.
   async function forceEditingForAcceptReplay() {
     const initial = getReviewingState({});
     if (isEditingPositivelyConfirmed(initial)) {
-      // Positively confirmed already in Editing — no toggle needed.
       return { ok: true, activated: false };
     }
 
-    // Reviewing is on, or Editing is not positively confirmed off. Force the
-    // toggle rather than trusting ensureEditing's lenient detection.
+    // Force the toggle whenever Editing is not positively confirmed.
     const switched = await setReviewingEnabled(false, { waitMs: 1800 });
     if (!switched.ok) {
-      // §9.4 editing_not_confirmed: the document is at pre-write state after
-      // the editor-undo succeeded; the mode toggle failed. The Accept replay
-      // was rolled back so the user-visible doc state has moved from the
-      // post-write tracked state back to pre-write — set changedDocument:true
-      // per the design spec's "is there text the user might want to inspect"
-      // contract for accept-side failures after a rollback.
+      // Native Undo already changed the document; a failed mode switch must
+      // preserve changedDocument evidence even though replay never started.
       return {
         ok: false,
         code: switched.code || 'accept_editing_not_confirmed',
@@ -933,126 +1016,6 @@
     return { ok: true, activated: true };
   }
 
-  // Builds the minimal replay operations for Accept All. The replay must write
-  // only the changed fragments, never a whole-file replaceAll.
-  //
-  // Preferred source: the run's own original forward writeback operations
-  // (carrying their `patches`). After the editor-undo the document is back at
-  // the pre-write content, so those patches' `expected` slices match and
-  // re-apply cleanly.
-  //
-  // Fallback: when a path has no usable original patch operation, compute a
-  // minimal pre->post diff (trim the common prefix/suffix to a single targeted
-  // {from,to,insert} patch).
-  function buildAcceptReplayOperations(paths, expectedByPath, postByPath, appliedOperations) {
-    const patchesByPath = collectAppliedEditPatchesByPath(appliedOperations);
-    const operations = [];
-    for (const path of paths) {
-      const preContent = expectedByPath.get(path);
-      const postContent = postByPath.get(path);
-      if (typeof preContent !== 'string' || typeof postContent !== 'string') {
-        return {
-          ok: false,
-          code: 'accept_missing_run_content',
-          reason: `${path} 缺少写入前/写入后内容；Codex 没有重放本轮改动。`
-        };
-      }
-
-      // Preferred: re-apply the run's original forward patches verbatim.
-      const originalPatches = patchesByPath.get(path);
-      if (originalPatches && originalPatches.length && patchesApplyCleanly(preContent, originalPatches)) {
-        operations.push({
-          type: 'edit',
-          path,
-          patches: originalPatches,
-          reason: 'Accept tracked edit (replay untracked)'
-        });
-        continue;
-      }
-
-      // Fallback: minimal pre->post diff trimmed to a single targeted patch.
-      const diffPatch = buildMinimalDiffPatch(preContent, postContent);
-      if (!diffPatch) {
-        // pre === post: nothing to replay for this file.
-        continue;
-      }
-      operations.push({
-        type: 'edit',
-        path,
-        patches: [diffPatch],
-        reason: 'Accept tracked edit (replay untracked)'
-      });
-    }
-    return { ok: true, operations };
-  }
-
-  // Collects the per-path `patches` arrays from the run's applied edit
-  // operations. Only edit operations that actually carried `patches` are
-  // usable; whole-file replaceAll / verifiedContent operations are skipped so
-  // the replay never falls back to a whole-file write.
-  function collectAppliedEditPatchesByPath(appliedOperations) {
-    const patchesByPath = new Map();
-    for (const rawOperation of Array.isArray(appliedOperations) ? appliedOperations : []) {
-      if (!rawOperation || rawOperation.type !== 'edit') {
-        continue;
-      }
-      const path = typeof rawOperation.path === 'string'
-        ? normalizeSafeProjectPath(rawOperation.path)
-        : '';
-      if (!path || !Array.isArray(rawOperation.patches) || !rawOperation.patches.length) {
-        continue;
-      }
-      const normalized = rawOperation.patches.map(patch => ({
-        from: Number(patch?.from),
-        to: Number(patch?.to),
-        expected: String(patch?.expected ?? ''),
-        insert: String(patch?.insert ?? '')
-      }));
-      const existing = patchesByPath.get(path) || [];
-      patchesByPath.set(path, existing.concat(normalized));
-    }
-    return patchesByPath;
-  }
-
-  // Confirms a patch set re-applies cleanly against the given (pre-write) text:
-  // every patch range is valid and its `expected` slice matches.
-  function patchesApplyCleanly(text, patches) {
-    const applied = applyTextPatches(text, patches);
-    return applied.ok === true;
-  }
-
-  // Computes a single targeted {from,to,insert} patch describing the pre->post
-  // change by trimming the common prefix and suffix. Returns null when the two
-  // strings are identical.
-  function buildMinimalDiffPatch(preContent, postContent) {
-    if (preContent === postContent) {
-      return null;
-    }
-    const preLen = preContent.length;
-    const postLen = postContent.length;
-    let prefix = 0;
-    const maxPrefix = Math.min(preLen, postLen);
-    while (prefix < maxPrefix && preContent[prefix] === postContent[prefix]) {
-      prefix += 1;
-    }
-    let suffix = 0;
-    const maxSuffix = Math.min(preLen, postLen) - prefix;
-    while (
-      suffix < maxSuffix
-      && preContent[preLen - 1 - suffix] === postContent[postLen - 1 - suffix]
-    ) {
-      suffix += 1;
-    }
-    const from = prefix;
-    const to = preLen - suffix;
-    return {
-      from,
-      to,
-      expected: preContent.slice(from, to),
-      insert: postContent.slice(from, postLen - suffix)
-    };
-  }
-
   async function rejectTrackedChangesViaEditorUndo(expectedFiles, postFiles, applied) {
     const expectedByPath = new Map((expectedFiles || [])
       .filter(file => file?.path && typeof file.content === 'string')
@@ -1071,10 +1034,8 @@
       const postContent = postByPath.get(path);
       const activePathMatches = getActiveFilePath() === path;
       const activeContentMatches = readActiveEditorText() === postContent;
-      // Overleaf can update the selected tree path before CodeMirror swaps its
-      // document. In that state getActiveFilePath() already names `path`, while
-      // readActiveEditorText() still belongs to the previously viewed file.
-      // Force-reopen the target whenever either identity signal disagrees.
+      // Tree selection can precede the editor swap. Reopen when either
+      // the target path or its exact postimage is not yet active.
       if (path && (!activePathMatches || !activeContentMatches)) {
         const opened = await openFileByPath(path, { force: true });
         if (!opened.ok) {
@@ -1125,18 +1086,23 @@
   }
 
   async function restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles, options = {}) {
-    const expectedByPath = new Map((expectedFiles || [])
-      .filter(file => file?.path && typeof file.content === 'string')
-      .map(file => [normalizeSafeProjectPath(file.path), file.content])
-      .filter(([path]) => path));
-    const postByPath = new Map((postFiles || [])
-      .filter(file => file?.path && typeof file.content === 'string')
-      .map(file => [normalizeSafeProjectPath(file.path), file.content])
-      .filter(([path]) => path));
-    const paths = Array.from(expectedByPath.keys()).filter(path => postByPath.has(path));
+    const { expectedByPath, postByPath, paths } = prepareSnapshotUndoCheckpoints(expectedFiles, postFiles);
     const rebasedExpectedByPath = new Map();
     const rebasedPostByPath = new Map();
     const undoRebaseProofs = new Map();
+    // Only the ordinary, native-ledger-checked Undo route may recognize a
+    // lost receipt's exact pre-image. This consumes an existing checkpoint;
+    // it grants no native review, file creation or move ownership.
+    const untrackedByPath = new Map((options.untrackedPlan?.files || []).map(file => [file.path, file]));
+    const alreadyRestored = new Set();
+    const mismatch = path => ({ ok: false, file: path, changedDocument: false, code: 'snapshot_undo_current_mismatch',
+      reason: `${path} 当前内容或文档身份与本轮撤销检查点不一致；Codex 保留恢复材料并停止撤销。` });
+    async function verifyAlreadyRestored(path) {
+      if (getActiveFilePath() !== path && !(await openFileByPath(path)).ok) return false;
+      return (await waitForNativeReview(path, [], true, scope => Boolean(scope.nativeDocId)
+        && scope.nativeDocId === untrackedByPath.get(path)?.nativeDocId
+        && getActiveFilePath() === path && readActiveEditorText() === expectedByPath.get(path))).ok === true;
+    }
     if (!paths.length) {
       return {
         ok: false,
@@ -1157,7 +1123,7 @@
             attempted: false,
             applied: [],
             skipped: [],
-            code: 'snapshot_undo_open_failed',
+            code: 'snapshot_undo_open_failed', file: path,
             reason: `无法打开 ${path} 来执行快照撤销。`
           };
         }
@@ -1166,7 +1132,8 @@
         path,
         expectedByPath.get(path),
         postByPath.get(path),
-        1500
+        1500,
+        untrackedByPath.has(path)
       );
       if (!ready.ok) {
         return {
@@ -1176,10 +1143,14 @@
           skipped: [],
           rebasedExpectedFiles: [],
           rebasedPostFiles: [],
-          code: 'snapshot_undo_current_mismatch',
+          code: 'snapshot_undo_current_mismatch', file: path,
           reason: `${path} 当前内容已经不是本轮写入后的内容；为避免覆盖你的后续修改，Codex 不执行快照撤销。`
         };
       }
+      if (ready.alreadyRestored) {
+        if (!(await verifyAlreadyRestored(path))) return { ...mismatch(path), attempted: false, applied: [], skipped: [] };
+        alreadyRestored.add(path);
+      }
       rebasedExpectedByPath.set(path, ready.expectedContent);
       rebasedPostByPath.set(path, ready.postContent);
       if (ready.prefixLength || ready.suffixLength) {
@@ -1187,55 +1158,49 @@
       }
     }
 
-    const operations = paths.map(path => ({
+    // Re-check observations after other preflight awaits before starting the
+    // unfinished tail. They are checked again after writes before settlement.
+    for (const path of alreadyRestored) {
+      if (!(await verifyAlreadyRestored(path))) return { ...mismatch(path), attempted: false, applied: [], skipped: [] };
+    }
+    const operations = paths.filter(path => !alreadyRestored.has(path)).map(path => ({
       type: 'edit',
       path,
       replaceAll: rebasedExpectedByPath.get(path),
       reason: 'Undo tracked edit'
     }));
-    const result = await applyOperationsWithNoTraceUndo(operations, {
+    const result = operations.length ? await applyOperationsWithNoTraceUndo(operations, {
       baseFiles: paths.map(path => ({
         path,
         content: rebasedPostByPath.get(path)
       })),
       runProjectId: typeof options.runProjectId === 'string' ? options.runProjectId : ''
-    });
-    const toTrackedResult = item => ({
-      trackedChange: {
-        key: `snapshot-undo:${item.operation?.path || ''}`,
-        id: '',
-        path: item.operation?.path || '',
-        label: 'No-trace snapshot undo'
-      },
-      result: item.result?.ok !== false && item.result?.verified === true
-        && undoRebaseProofs.has(item.operation?.path)
-        && item.result.verifiedContent === rebasedExpectedByPath.get(item.operation?.path)
-        ? { ...item.result, undoRebaseProof: undoRebaseProofs.get(item.operation.path) }
-        : item.result
-    });
-    return {
-      ok: !(result.skipped || []).length,
-      attempted: true,
-      applied: (result.applied || []).map(toTrackedResult),
-      skipped: (result.skipped || []).map(toTrackedResult),
-      rebasedExpectedFiles: paths.map(path => ({
-        path,
-        content: rebasedExpectedByPath.get(path)
-      })),
-      rebasedPostFiles: paths.map(path => ({
-        path,
-        content: rebasedPostByPath.get(path)
-      }))
-    };
+    }) : { applied: [], skipped: [] };
+    const converted = buildSnapshotUndoResult(result, rebasedExpectedByPath, rebasedPostByPath, undoRebaseProofs);
+    const applied = deps.createReviewApplied?.() || [];
+    applied.push(...converted.applied);
+    const skipped = converted.skipped;
+    for (const path of alreadyRestored) {
+      const verified = await verifyAlreadyRestored(path);
+      const entry = { trackedChange: { key: `snapshot-undo:${path}`, id: '', path,
+        label: 'Already restored checkpoint' }, result: verified
+        ? { ok: true, verified: true, verifiedContent: expectedByPath.get(path), changedDocument: false, idempotent: true }
+        : mismatch(path) };
+      (verified ? applied : skipped).push(entry);
+    }
+    return { ...converted, ok: !skipped.length, applied, skipped };
   }
 
-  async function waitForActiveEditorCheckpoint(filePath, expectedContent, postContent, timeoutMs) {
+  async function waitForActiveEditorCheckpoint(filePath, expectedContent, postContent, timeoutMs, allowAlreadyRestored = false) {
     const deadline = Date.now() + Math.max(0, Number(timeoutMs) || 0);
     let actual = readActiveEditorText();
     while (Date.now() < deadline) {
       const activeFileMatches = !filePath || getActiveFilePath() === filePath;
       actual = readActiveEditorText();
       if (activeFileMatches) {
+        if (allowAlreadyRestored && actual === expectedContent) {
+          return { ok: true, alreadyRestored: true, expectedContent, postContent, prefixLength: 0, suffixLength: 0 };
+        }
         const rebased = rebaseCheckpointPair(actual, expectedContent, postContent);
         if (rebased.ok) {
           return rebased;
@@ -1249,37 +1214,6 @@
     };
   }
 
-  function rebaseCheckpointPair(actualContent, expectedContent, postContent) {
-    const actual = String(actualContent ?? '');
-    const expected = String(expectedContent ?? '');
-    const post = String(postContent ?? '');
-    if (actual === post) {
-      return {
-        ok: true,
-        expectedContent: expected,
-        postContent: post,
-        prefixLength: 0,
-        suffixLength: 0
-      };
-    }
-    if (!post) {
-      return { ok: false };
-    }
-    const matchIndex = actual.indexOf(post);
-    if (matchIndex < 0 || actual.indexOf(post, matchIndex + 1) >= 0) {
-      return { ok: false };
-    }
-    const prefix = actual.slice(0, matchIndex);
-    const suffix = actual.slice(matchIndex + post.length);
-    return {
-      ok: true,
-      expectedContent: prefix + expected + suffix,
-      postContent: actual,
-      prefixLength: prefix.length,
-      suffixLength: suffix.length
-    };
-  }
-
   async function waitForActiveEditorExpectedText(filePath, expectedContent, timeoutMs) {
     const deadline = Date.now() + Math.max(0, Number(timeoutMs) || 0);
     let actual = readActiveEditorText();
@@ -1306,34 +1240,36 @@
     const maxClicks = 200;
     for (let clicks = 0; clicks <= maxClicks; clicks += 1) {
       if (readActiveEditorText() === expectedContent) {
-        return {
-          ok: true,
-          attempted: clicks > 0,
-          clicks
-        };
+        return { ok: true, attempted: clicks > 0, clicks };
       }
       if (clicks === maxClicks) {
         break;
       }
 
-      const undoControl = findEditorUndoControl();
+      const beforeText = readActiveEditorText();
+      let undoControl = findEditorUndoControl();
       if (!undoControl) {
-        return {
-          ok: false,
-          attempted: clicks > 0,
-          code: 'editor_undo_control_not_found',
+        // Text and the native ledger can be ready before the toolbar updates.
+        // Wait only before dispatch, keeping this click's scope fixed.
+        const assertStable = await createReviewScopeGuard(path, beforeText), until = Date.now() + 1500;
+        while (!undoControl && Date.now() < until) {
+          assertStable();
+          await delay(Math.min(60, until - Date.now()));
+          assertStable();
+          undoControl = findEditorUndoControl();
+        }
+        assertStable();
+      }
+      if (!undoControl) {
+        return { ok: false, attempted: clicks > 0, code: 'editor_undo_control_not_found',
           reason: `没有找到 Overleaf 编辑器自己的 Undo/撤销按钮，无法一次性撤销 ${path} 的本轮留痕。`
         };
       }
 
-      const beforeText = readActiveEditorText();
       clickNode(undoControl);
       await waitForEditorTextProgress(beforeText, expectedContent, 1000);
       if (readActiveEditorText() === beforeText) {
-        return {
-          ok: false,
-          attempted: clicks > 0,
-          code: 'editor_undo_no_progress',
+        return { ok: false, attempted: clicks > 0, code: 'editor_undo_no_progress',
           reason: `Codex 点击了 Overleaf Undo/撤销，但 ${path} 内容没有变化。`
         };
       }
@@ -1366,7 +1302,9 @@
       }
       const result = await rejectRemainingTrackedChangesForExpectedFile(file, applied);
       if (!result.ok) {
-        return result;
+        // The sweep knows its target even when no DOM review node remains.
+        // Keep that scope so independently verified files can leave recovery.
+        return { ...result, file: file.path };
       }
     }
     return { ok: true };
@@ -1387,7 +1325,7 @@
     for (const path of paths) {
       const result = await rejectRemainingTrackedChangesForPath(path, applied);
       if (!result.ok) {
-        return result;
+        return { ...result, file: path };
       }
     }
     return { ok: true };
@@ -1408,7 +1346,9 @@
     const appliedCountBefore = applied.length;
     const maxAttempts = 200;
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-      const node = findLastTrackedChangeNodeForPath(path);
+      const selection = await waitForRejectableTrackedChange(path);
+      selection.assertStable();
+      const node = selection.node;
       if (!node) {
         if (applied.length > appliedCountBefore) {
           return { ok: true };
@@ -1420,7 +1360,7 @@
         };
       }
 
-      const rejectControl = findRejectControlForTrackedChangeNode(node);
+      const rejectControl = isTrackedChangeNodeInNativeScope(node, path) ? findRejectControlForTrackedChangeNode(node) : null;
       if (!rejectControl) {
         return {
           ok: false,
@@ -1431,6 +1371,7 @@
 
       const trackedChange = trackedChangeRefFromNode(node, path);
       const beforeText = readActiveEditorText();
+      selection.assertStable();
       clickNode(rejectControl);
       await waitForTrackedChangeRejectProgress(trackedChange, path, beforeText, 1200);
       applied.push({
@@ -1461,6 +1402,17 @@
     };
   }
 
+  async function verifyReviewFileContent(file, applied) {
+    const verified = await verifyActiveEditorText(file.content, file.path, 800);
+    if (getActiveFilePath() !== file.path) verified.ok = false;
+    if (verified.ok) for (const entry of applied) {
+      if (entry.trackedChange?.path === file.path && entry.result?.ok === true
+        && ['overleaf-review-reject', 'overleaf-review-reject-sweep'].includes(entry.result.method))
+        Object.assign(entry.result, { verified: true, verifiedContent: file.content });
+    }
+    return verified;
+  }
+
   async function rejectRemainingTrackedChangesForExpectedFile(file, applied) {
     const opened = await openFileByPath(file.path);
     if (!opened.ok) {
@@ -1474,12 +1426,16 @@
     const appliedCountBefore = applied.length;
     const maxAttempts = 200;
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-      const node = findLastTrackedChangeNodeForPath(file.path);
+      if (applied.some(entry => entry.trackedChange?.path === file.path
+        && ['overleaf-review-reject', 'overleaf-review-reject-sweep'].includes(entry.result?.method))
+        && getActiveFilePath() === file.path && readActiveEditorText() === file.content
+        && (await verifyReviewFileContent(file, applied)).ok) return { ok: true };
+      const selection = await waitForRejectableTrackedChange(file.path);
+      selection.assertStable();
+      const node = selection.node;
       if (!node) {
-        const verified = await verifyActiveEditorText(file.content, file.path, 800);
-        if (verified.ok) {
-          return { ok: true };
-        }
+        const verified = await verifyReviewFileContent(file, applied);
+        if (verified.ok) return { ok: true };
         const rejectedAnyForFile = applied.length > appliedCountBefore;
         return {
           ...verified,
@@ -1490,7 +1446,7 @@
         };
       }
 
-      const rejectControl = findRejectControlForTrackedChangeNode(node);
+      const rejectControl = isTrackedChangeNodeInNativeScope(node, file.path) ? findRejectControlForTrackedChangeNode(node) : null;
       if (!rejectControl) {
         return {
           ok: false,
@@ -1501,6 +1457,7 @@
 
       const trackedChange = trackedChangeRefFromNode(node, file.path);
       const beforeText = readActiveEditorText();
+      selection.assertStable();
       clickNode(rejectControl);
       await waitForTrackedChangeRejectProgress(trackedChange, file.path, beforeText, 1200);
       applied.push({
@@ -1546,13 +1503,10 @@
     return false;
   }
 
-
-
-
   const captureModule = window?.CodexOverleafTrackedChangeCapture
     || (typeof module === 'object' && module.exports ? require('./trackedChangeCapture.js') : null);
   const { collectTrackedChangeNodes, trackedChangeRefFromNode, collectTrackedChangeRefsForPaths,
-    waitForTrackedChangeDiff, prepareTrackedChangeCapture, prepareTrackedChangeReview, prepareUntrackedUndo, getTrackedChangeCaptureStatus,
+    waitForTrackedChangeDiff, prepareTrackedChangeCapture, prepareTrackedChangeReview, prepareUntrackedUndo, getTrackedChangeCaptureStatus, isTrackedChangeNodeInNativeScope, rememberTrackedChangeNodeContext,
     captureTrackedWrite, reconcileTrackedChangeCapture } = captureModule.create(deps);
 
   function orderTrackedChangesForReviewAction(refs = []) {
@@ -1575,9 +1529,56 @@
     return nodes[0] || null;
   }
 
-  function findLastTrackedChangeNodeForPath(path) {
-    const nodes = findTrackedChangeNodesForPath(path);
-    return nodes[nodes.length - 1] || null;
+  async function createReviewScopeGuard(path, expectedText) {
+    const owner = nativeRejectPlan?.files?.find(file => file.path === path);
+    const changed = () => {
+      const failure = nativeReviewBlocked(path, 'native_review_scope_changed').skipped[0].result;
+      throw Object.assign(new Error(failure.reason), { reviewFailure: failure });
+    };
+    let snapshot = prepareTrackedChangeCapture(path);
+    const until = Date.now() + 1500;
+    while ((owner || snapshot.source === 'native') && (snapshot.source !== 'native' || !snapshot.ready) && Date.now() < until) {
+      if (getActiveFilePath() !== path || (expectedText !== undefined && readActiveEditorText() !== expectedText)) changed();
+      await delay(Math.min(60, until - Date.now()));
+      snapshot = prepareTrackedChangeCapture(path);
+    }
+    if (owner || snapshot.source === 'native') {
+      const owned = (owner?.scope.refs || []).map(ref => JSON.stringify([ref.id, ref.kind, ref.textHash]));
+      if (!snapshot.ready || !snapshot.refs.length || !owner || snapshot.nativeDocId !== owner.nativeDocId || snapshot.refs.some(ref => {
+        const index = owned.indexOf(JSON.stringify([ref.id, ref.kind, ref.textHash]));
+        if (index < 0) return true;
+        owned.splice(index, 1); return false;
+      })) changed();
+    }
+    const beforeText = expectedText ?? readActiveEditorText();
+    const key = value => value.source !== 'native' ? '' : !value.ready ? null
+      : JSON.stringify([value.nativeDocId, value.refs.map(ref => ref.key).sort()]);
+    const beforeScope = key(snapshot);
+    return () => {
+      if (getActiveFilePath() !== path || readActiveEditorText() !== beforeText
+        || key(prepareTrackedChangeCapture(path)) !== beforeScope) changed();
+    };
+  }
+  async function waitForRejectableTrackedChange(path) {
+    const until = Date.now() + 1500;
+    const select = () => {
+      const nodes = findTrackedChangeNodesForPath(path).reverse();
+      for (const node of nodes) {
+        if (!isTrackedChangeNodeInNativeScope(node, path)) continue;
+        const control = findRejectControlForTrackedChangeNode(node);
+        if (control) return { node, control };
+      }
+      return { node: nodes[0] || null, control: null };
+    };
+    let selection = select();
+    if (!selection.node) return { ...selection, assertStable() {} };
+    const assertStable = await createReviewScopeGuard(path);
+    selection = select();
+    while (!selection.control && Date.now() < until) {
+      assertStable(); await delay(Math.min(60, until - Date.now())); assertStable();
+      selection = select();
+    }
+    return { ...selection, assertStable };
   }
 
   function findTrackedChangeNodesForPath(path) {
@@ -1590,6 +1591,7 @@
   }
 
   function findRejectControlForTrackedChangeNode(node) {
+    if (!node || node.isConnected === false) return null;
     const scopes = [];
     let current = node;
     for (let index = 0; current && index < 6; index += 1) {
@@ -1616,17 +1618,19 @@
   }
 
   function isRejectTrackedChangeControl(node) {
-    if (!node || node.disabled) {
+    if (!node || node.disabled || node.isConnected === false) {
       return false;
     }
     if (/^(true|disabled)$/i.test(node.getAttribute?.('aria-disabled') || '')) {
       return false;
     }
-    const signal = normalizeReviewingSignalText(readNodeSignalText(node));
-    if (/\b(?:accept|approve|apply|resolve|接受|批准|应用)\b/i.test(signal)) {
+    const signal = normalizeReviewingSignalText([readNodeSignalText(node),
+      ...Array.from(node.querySelectorAll?.('.visually-hidden') || [])
+        .map(label => label.textContent || '')].join(' '));
+    if (/\b(?:accept|approve|apply|resolve)\b|接受|批准|应用/i.test(signal)) {
       return false;
     }
-    return /\b(?:reject|decline|discard|revert|拒绝|丢弃|还原)\b/i.test(signal);
+    return /\b(?:reject|decline|discard|revert)\b|拒绝|丢弃|还原/i.test(signal);
   }
     return {
       acceptTrackedChanges,