codex-overleaf-link 2.3.5 → 2.4.0

package/extension/src/shared/sessionState.js

@@ -5,12 +5,13 @@
       require('./settlementFacts'),
       require('./runInputQueue'),
       require('./lineReferences'),
-      require('./pathRedaction')
+      require('./pathRedaction'),
+      require('./sessionTitle')
     );
   } else {
     root.CodexOverleafModuleRegistry.define(
       'SessionState',
-      ['I18n', 'SettlementFacts', 'RunInputQueue', 'LineReferences', 'PathRedaction'],
+      ['I18n', 'SettlementFacts', 'RunInputQueue', 'LineReferences', 'PathRedaction', 'SessionTitle'],
       factory
     );
   }
@@ -19,7 +20,8 @@
   SettlementFacts,
   RunInputQueue,
   LineReferences,
-  PathRedaction
+  PathRedaction,
+  SessionTitle
 ) {
   'use strict';
 
@@ -402,6 +404,12 @@
       ) {
         next.title = session.title;
         next.titleSource = 'manual';
+      } else if (session.titleSource === 'auto' && patch.titleSource !== 'manual'
+        && typeof patch.title === 'string' && patch.title.trim() && session.runs?.length
+        && SessionTitle.isGeneric(sanitizeAutoTitle(patch.title))
+        && !SessionTitle.isGeneric(sanitizeAutoTitle(session.title))) {
+        next.title = session.title;
+        next.titleSource = 'auto';
       }
       return normalizeSession({
         ...next
@@ -472,12 +480,7 @@
   }
 
   function deriveSessionTitle(runs, task) {
-    const taskTitle = sanitizeAutoTitle(task);
-    if (taskTitle) {
-      return taskTitle;
-    }
-    const firstRunTask = Array.isArray(runs) && runs.length ? runs[0]?.task : '';
-    return sanitizeAutoTitle(firstRunTask);
+    return SessionTitle.derive(runs, task, { sanitize: sanitizeAssistantVisibleText, maxChars: SESSION_AUTO_TITLE_CHARS });
   }
 
   // Rename a session with the placeholder/derived-title ghost guard (mirrors
@@ -519,21 +522,14 @@
     if (titleSource === 'manual') {
       return normalizeTextField(rawTitle === LEGACY_DEFAULT_SESSION_TITLE ? '' : rawTitle, STORAGE_DEFAULT_LIMITS.sessionTitleChars);
     }
-    return sanitizeAutoTitle(rawTitle === LEGACY_DEFAULT_SESSION_TITLE ? '' : rawTitle) || derivedTitle || '';
+    const current = sanitizeAutoTitle(rawTitle === LEGACY_DEFAULT_SESSION_TITLE ? '' : rawTitle);
+    if (!current || SessionTitle.isGeneric(current)) return derivedTitle || current || '';
+    if (current.endsWith('…') && derivedTitle.startsWith(current.slice(0, -1))) return derivedTitle;
+    return current;
   }
 
   function sanitizeAutoTitle(value) {
-    const title = sanitizeAssistantVisibleText(value)
-      .replace(/@file:[^\s]+/g, ' ')
-      .replace(/@(context|compile-log)\b/g, ' ')
-      .replace(/\s+/g, ' ')
-      .trim();
-    if (!title) {
-      return '';
-    }
-    return title.length > SESSION_AUTO_TITLE_CHARS
-      ? `${title.slice(0, SESSION_AUTO_TITLE_CHARS - 1)}…`
-      : title;
+    return SessionTitle.fromPrompt(value, { sanitize: sanitizeAssistantVisibleText, maxChars: SESSION_AUTO_TITLE_CHARS });
   }
 
   function isDisplayableSession(session) {
@@ -640,7 +636,7 @@
       undoExpectedFiles: normalizeRunFiles(run.undoExpectedFiles),
       undoStatus: sanitizeAssistantVisibleText(run.undoStatus),
       nativeRequestId: sanitizeAssistantVisibleText(run.nativeRequestId),
-      codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
+      codexThreadId: sanitizeAssistantVisibleText(run.codexThreadId), codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
       forkSnapshot: run.forkSnapshot === true,
       forkSourceRunId: sanitizeAssistantVisibleText(run.forkSourceRunId),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
@@ -660,6 +656,9 @@
     if (run.changedDocument === true) {
       normalized.changedDocument = true;
     }
+    if (Array.isArray(run.trackedChangeCaptures) && run.trackedChangeCaptures.length && !run.forkSnapshot) {
+      normalized.trackedChangeCaptures = sanitizeAssistantVisibleValue(run.trackedChangeCaptures);
+    }
     applyTrackedChangeStatus(normalized, run.trackedChangeStatus);
 
     return normalized;
@@ -1219,7 +1218,7 @@
       undoExpectedFiles: undoPayload.undoExpectedFiles,
       undoStatus: summarizeTextForStorage(run.undoStatus, 'undo status'),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
-      codexTurnId: normalizeTextField(run.codexTurnId, 160),
+      codexThreadId: normalizeTextField(run.codexThreadId, 160), codexTurnId: normalizeTextField(run.codexTurnId, 160),
       forkSnapshot: run.forkSnapshot === true,
       forkSourceRunId: normalizeTextField(run.forkSourceRunId, 160),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
@@ -1631,6 +1630,7 @@
     setActiveSession,
     updateActiveSession,
     normalizeRuns,
+    normalizeProjectReferenceFiles,
     prepareStateForStorage,
     estimateJsonBytes,
     computeSafeTaskSummary

package/extension/src/shared/sessionTitle.js

@@ -0,0 +1,120 @@
+(function initSessionTitle(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafModuleRegistry.define('SessionTitle', [], factory);
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function sessionTitleFactory() {
+  'use strict';
+
+  const INPUT_LIMIT = 12000;
+  const STORAGE_LIMIT = 80;
+  const segmenter = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' }) : null;
+  const FILE_TOKEN = /@file:(?:"([^"]+)"|'([^']+)'|([^\s]+))/g;
+
+  function derive(runs, task, options = {}) {
+    let fallback = '';
+    for (const run of Array.isArray(runs) ? runs : []) {
+      const candidate = fromPrompt(run?.task, options);
+      fallback ||= candidate;
+      if (candidate && !isGeneric(candidate)) return candidate;
+    }
+    const draft = fromPrompt(task, options);
+    return draft && !isGeneric(draft) ? draft : fallback || draft;
+  }
+
+  function fromPrompt(value, { sanitize = text => text, maxChars = 24 } = {}) {
+    if (typeof value !== 'string' || !value.trim()) return '';
+    const source = String(sanitize(value.slice(0, INPUT_LIMIT)) || '');
+    let fence = null;
+    let fallback = '';
+    for (const rawLine of source.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      const marker = /^(`{3,}|~{3,})(.*)$/.exec(line);
+      if (marker) {
+        if (!fence) {
+          fence = marker[1];
+          const language = marker[2].trim().match(/^[A-Za-z0-9_+-]{1,24}\b/)?.[0] || 'code';
+          fallback ||= `${language} snippet`;
+        } else if (marker[1][0] === fence[0] && marker[1].length >= fence.length && !marker[2].trim()) {
+          fence = null;
+        }
+        continue;
+      }
+      if (fence || !line || /^>/.test(line)) continue;
+      const withoutContext = line.replace(FILE_TOKEN, ' ').replace(/@(context|compile-log)\b/g, ' ').trim();
+      const cleaned = cleanLine(line);
+      if (!withoutContext || /^https?:\/\/\S+$/i.test(line)) {
+        fallback ||= cleaned;
+        continue;
+      }
+      for (const sentence of cleaned.split(/[\u3002\uff01\uff1f]+/u)) {
+        const candidate = sentence.trim().replace(/[,;:\uff0c\uff1b\uff1a]+$/u, '').trim();
+        if (!/[\p{L}\p{N}]/u.test(candidate) || isScaffolding(candidate)) continue;
+        fallback ||= candidate;
+        if (!isGeneric(candidate)) return shorten(candidate, maxChars);
+      }
+    }
+    return shorten(fallback, maxChars);
+  }
+
+  function cleanLine(value) {
+    return value
+      .replace(/^#{1,6}\s+/, '')
+      .replace(/^(?:[-*+]\s+|\d+\.\s+|\d+[)\u3001]\s*)/, '')
+      .replace(FILE_TOKEN, (_match, quoted, singleQuoted, bare) =>
+        String(quoted || singleQuoted || bare || '').replace(/\\/g, '/').split('/').pop())
+      .replace(/@(context|compile-log)\b/g, ' ')
+      .replace(/!?\[([^\]]*)\]\([^\n)]*\)/g, '$1')
+      .replace(/`([^`]+)`/g, '$1')
+      .replace(/\*\*([^*]+)\*\*/g, '$1')
+      .replace(/https?:\/\/\S+/gi, address => {
+        try { return new URL(address).hostname; } catch (_error) { return ''; }
+      })
+      .replace(/\[(?:REDACTED_SECRET|local path(?::\d+)?)\]/gi, ' ')
+      .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '')
+      .replace(/\s+/g, ' ').trim()
+      .replace(/^(?:\u8bf7(?:\u4f60)?\u5e2e\u6211|\u8bf7\u4f60|\u5e2e\u6211|\u9ebb\u70e6\u4f60(?:\u5e2e\u6211)?|\u9ebb\u70e6\u5e2e\u6211|please\s+)\s*/i, '');
+  }
+
+  function isScaffolding(value) {
+    return /^(?:my request(?: for [^:]+)?|request|task|context|files(?: mentioned by [^:]+)?|attachments|\u6211\u7684\u8bf7\u6c42|\u9700\u6c42|\u4efb\u52a1|\u4e0a\u4e0b\u6587|\u9644\u4ef6|\u6587\u4ef6)$/i.test(value);
+  }
+
+  function isGeneric(value) {
+    const text = String(value || '').trim().replace(/[\s.!?\u3002\uff1f\uff01\u2026]+$/u, '');
+    if (!text || Array.from(text).length < 2) return true;
+    return /^(?:ok(?:ay)?|yes|no|go|done|continue|proceed|thanks?|thank you|hello|hi|test|new task|untitled task|\u597d(?:\u7684)?|\u53ef\u4ee5|\u7ee7\u7eed|\u786e\u8ba4|\u786e\u5b9a|\u6536\u5230|\u8c22\u8c22|\u6d4b\u8bd5|\u6267\u884c|\u662f\u7684|\u4f60\u597d)$/i.test(text)
+      || /^[A-Za-z0-9_+-]{1,24} snippet$/i.test(text)
+      || /^[^\s]+\.(?:tex|bib|md|txt|pdf|svg|png|jpe?g|webp)(?::\d+)?$/i.test(text)
+      || /^(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}$/i.test(text);
+  }
+
+  function shorten(value, maxChars) {
+    const title = String(value || '').trim();
+    if (!title) return '';
+    const chars = Number.isFinite(maxChars) && maxChars > 0 ? Math.min(40, Math.floor(maxChars)) : 24;
+    const maxUnits = chars * 2;
+    const glyphs = segmenter
+      ? Array.from(segmenter.segment(title), item => item.segment) : Array.from(title);
+    const width = glyph => /[^\u0000-\u00ff]/u.test(glyph) ? 2 : 1;
+    if (title.length <= STORAGE_LIMIT && glyphs.reduce((total, glyph) => total + width(glyph), 0) <= maxUnits) return title;
+    let prefix = '';
+    let units = 0;
+    let index = 0;
+    for (; index < glyphs.length; index++) {
+      const glyph = glyphs[index];
+      if (units + width(glyph) > maxUnits - 2 || prefix.length + glyph.length > STORAGE_LIMIT - 1) break;
+      prefix += glyph;
+      units += width(glyph);
+    }
+    const boundary = prefix.lastIndexOf(' ');
+    if (/[A-Za-z0-9]$/.test(prefix) && /^[A-Za-z0-9]/.test(glyphs[index] || '') && boundary >= prefix.length * 0.6) {
+      prefix = prefix.slice(0, boundary);
+    }
+    return prefix.trimEnd().replace(/[,;:\uff0c\uff1b\uff1a]+$/u, '') + '\u2026';
+  }
+
+  return Object.freeze({ derive, fromPrompt, isGeneric });
+});

package/extension/src/shared/storageDb.js

@@ -1,18 +1,19 @@
 (function initStorageDb(root, factory) {
   if (typeof module === 'object' && module.exports) {
     module.exports = factory(require('./storageRunActions'), require('./runInputQueue'),
-      require('./settlementFacts'), require('./storageSessionClaims'));
+      require('./settlementFacts'), require('./storageSessionClaims'), require('./sessionState'));
   } else {
     root.CodexOverleafModuleRegistry.define('StorageDb', [
       'StorageRunActions',
       'RunInputQueue',
       'SettlementFacts',
-      'StorageSessionClaims'
+      'StorageSessionClaims',
+      'SessionState'
     ], factory);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims) {
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims, SessionState) {
   'use strict';
-  if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage || !SettlementFacts?.compactSettlementFacts || !StorageSessionClaims?.createSessionClaimer) {
+  if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactRunExecutionSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage || !SettlementFacts?.compactSettlementFacts || !StorageSessionClaims?.createSessionClaimer) {
     throw new Error('Codex Overleaf storage run-action helpers are unavailable.');
   }
   // IndexedDB versions are monotonic; v2.0 RC profiles have already opened v3.
@@ -279,6 +280,7 @@
       codexThreadId: typeof input.codexThreadId === 'string' ? input.codexThreadId : '',
       status: typeof input.status === 'string' && input.status ? input.status : 'active',
       focusFiles: normalizePathList(input.focusFiles),
+      projectReferenceFiles: SessionState.normalizeProjectReferenceFiles(input.projectReferenceFiles),
       pendingInputs: RunInputQueue.compactForStorage(input.pendingInputs, {
         normalizeField: normalizeTextField,
         normalizeDisplay: normalizeDisplayTextForStorage,
@@ -650,20 +652,15 @@
   }
 
   function compactRunsForStorage(runs, options) {
-    return StorageRunActions.compactRunsForStorage(
-      runs,
-      options,
-      SESSION_STORAGE_LIMITS.maxRunsPerSession,
-      compactRunForStorage
-    );
+    return StorageRunActions.compactRunsForStorage(runs, options, SESSION_STORAGE_LIMITS.maxRunsPerSession, compactRunForStorage);
   }
-
   function compactRunForStorage(run, keepActionPayload) {
     var actionPayload = StorageRunActions.compactRunActionPayload(run, keepActionPayload);
     var compact = {
       id: run.id,
       task: normalizeDisplayTextForStorage(run.task || 'untitled task', SESSION_STORAGE_LIMITS.taskChars),
       mode: typeof run.mode === 'string' ? redactSecretLikeText(run.mode) : '', ...StorageRunActions.compactProviderSnapshot(run),
+      ...StorageRunActions.compactRunExecutionSnapshot(run, function (text) { return normalizeTextField(text, 4096); }),
       model: normalizeTextField(run.model, 80),
       reasoningEffort: typeof run.reasoningEffort === 'string' ? redactSecretLikeText(run.reasoningEffort) : '',
       speedTier: typeof run.speedTier === 'string' ? redactSecretLikeText(run.speedTier) : '',
@@ -679,9 +676,10 @@
       undoBaseFiles: actionPayload.undoBaseFiles,
       undoTrackedChanges: actionPayload.undoTrackedChanges,
       undoExpectedFiles: actionPayload.undoExpectedFiles,
+      ...(actionPayload.trackedChangeCaptures ? { trackedChangeCaptures: actionPayload.trackedChangeCaptures } : {}),
       undoStatus: normalizeDisplayTextForStorage(run.undoStatus, SESSION_STORAGE_LIMITS.statusTextChars),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
-      codexTurnId: normalizeTextField(run.codexTurnId, 160),
+      codexThreadId: normalizeTextField(run.codexThreadId, 160), codexTurnId: normalizeTextField(run.codexTurnId, 160),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
       queueItemId: normalizeTextField(run.queueItemId, 160)
     };

package/extension/src/shared/storageRunActions.js

@@ -70,7 +70,13 @@
     } catch (_error) {
       return empty;
     }
-    return getUtf8ByteLength(serialized) <= MAX_PERSISTED_ACTION_BYTES_PER_RUN ? payload : empty;
+    if (getUtf8ByteLength(serialized) > MAX_PERSISTED_ACTION_BYTES_PER_RUN) return empty;
+    const captures = cloneSerializableArray(run.trackedChangeCaptures);
+    if (captures.length) {
+      const extended = { ...payload, trackedChangeCaptures: captures };
+      if (getUtf8ByteLength(JSON.stringify(extended)) <= MAX_PERSISTED_ACTION_BYTES_PER_RUN) return extended;
+    }
+    return payload; // Optional capture evidence must never evict a mature Undo payload.
   }
 
   function emptyActionPayload() {
@@ -102,6 +108,27 @@
     return value.length * 2;
   }
 
+  // Persist only execution metadata; never infer a missing historical setting.
+  function compactRunExecutionSnapshot(run, normalizeString) {
+    var snapshot = run && run.executionSnapshot;
+    if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot)) return {};
+    var normalize = typeof normalizeString === 'function' ? normalizeString : String;
+    var compact = {};
+    var fields = ['schemaVersion', 'mode', 'providerId', 'providerRevision', 'model',
+      'reasoningEffort', 'speedTier', 'autoRecompile', 'requireReviewing', 'capturedAt', 'source'];
+    for (var key of fields) {
+      if (!Object.prototype.hasOwnProperty.call(snapshot, key)) continue;
+      var value = snapshot[key];
+      if (typeof value === 'string') compact[key] = normalize(value);
+      else if (value === null || typeof value === 'number' || typeof value === 'boolean') compact[key] = value;
+    }
+    if (Array.isArray(snapshot.focusFiles)) {
+      compact.focusFiles = snapshot.focusFiles.slice(0, 100)
+        .filter(function (value) { return typeof value === 'string'; }).map(normalize);
+    }
+    return { executionSnapshot: compact };
+  }
+
   function compactProviderSnapshot(value) {
     return {
       providerId: typeof value.providerId === 'string' && value.providerId ? value.providerId : 'builtin',
@@ -147,6 +174,7 @@
     compactRunsForStorage: compactRunsForStorage,
     compactRunActionPayload: compactRunActionPayload,
     compactProviderSnapshot: compactProviderSnapshot,
+    compactRunExecutionSnapshot: compactRunExecutionSnapshot,
     hashString: hashString
   };
 });

package/extension/src/shared/updateRuntimeIdentity.js

@@ -0,0 +1,32 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafUpdateRuntimeIdentity = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function version(value) { return /^\d+\.\d+\.\d+$/.test(String(value || '')) ? String(value) : ''; }
+  function compare(left, right) {
+    const a = left.split('.').map(Number);
+    const b = right.split('.').map(Number);
+    return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+  }
+
+  function inspectInstalledRuntime(status = {}, options = {}) {
+    const result = { installedVersion: version(status.activeVersion), nativeVersion: version(status.runtimeVersion),
+      extensionVersion: version(options.extensionVersion), runtimeVersion: version(options.runtimeVersion), state: 'unknown' };
+    if (!status.managed || !result.installedVersion || !result.nativeVersion ||
+        !result.extensionVersion || !result.runtimeVersion) return result;
+    if (['authorized', 'bound'].includes(status.authorization?.state) ||
+        ['staged', 'activation_pending', 'applying', 'awaiting_health'].includes(status.transaction?.state)) {
+      return { ...result, state: 'transaction_active' };
+    }
+    if (status.installedAligned !== true) return { ...result, state: 'repair_required' };
+    const loaded = [result.nativeVersion, result.extensionVersion, result.runtimeVersion];
+    if (loaded.every(value => value === result.installedVersion)) return { ...result, state: 'aligned' };
+    return { ...result, state: loaded.every(value => compare(result.installedVersion, value) >= 0)
+      ? 'reload_required' : 'repair_required' };
+  }
+
+  return Object.freeze({ inspectInstalledRuntime });
+});

package/extension/src/shared/writebackSettlement.js

@@ -397,7 +397,7 @@
     if (!result || typeof result !== 'object' || result.ok === false) return result;
     if (Array.isArray(result.skipped) && result.skipped.length > 0) return result;
     const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
-    if (!expectedFiles.length || isUndoVerifiedContentMatching(run, result)) return result;
+    if (!expectedFiles.length || isUndoVerifiedContentMatching(run, result, options)) return result;
     const path = expectedFiles.find(entry => typeof entry?.path === 'string')?.path || '';
     appendSyntheticFailure(result, options.buildFailure?.('undo_not_verified', { path, type: 'undo' }, {
       changedDocument: true,
@@ -407,15 +407,18 @@
     return result;
   }
 
-  function isUndoVerifiedContentMatching(run, result) {
+  function isUndoVerifiedContentMatching(run, result, options = {}) {
     const expectedByPath = new Map((run?.undoExpectedFiles || [])
       .filter(file => typeof file?.path === 'string' && typeof file?.content === 'string')
       .map(file => [normalizeSettlementPath(file.path), file.content])
       .filter(([path]) => path));
     if (!expectedByPath.size) return true;
+    const postByPath = new Map((Array.isArray(options?.postFiles) ? options.postFiles : [])
+      .filter(file => typeof file?.path === 'string' && typeof file?.content === 'string')
+      .map(file => [normalizeSettlementPath(file.path), file.content]));
     const applied = Array.isArray(result?.applied) ? result.applied : [];
     return Array.from(expectedByPath).every(([path, expected]) =>
-      applied.some(entry => isVerifiedUndoEntryForPath(entry, path, expected))
+      applied.some(entry => isVerifiedUndoEntryForPath(entry, path, expected, postByPath.get(path)))
     );
   }
 
@@ -438,7 +441,7 @@
     ));
   }
 
-  function isVerifiedUndoEntryForPath(entry, path, expectedContent) {
+  function isVerifiedUndoEntryForPath(entry, path, expectedContent, postContent) {
     const inner = entry?.result || {};
     if (inner.ok === false) return false;
     const normalizedPath = normalizeSettlementPath(path);
@@ -456,7 +459,18 @@
         && inner.verifiedContent === expectedContent;
     }
     if (key === `snapshot-undo:${normalizedPath}`) {
-      return inner.verifiedContent === expectedContent;
+      if (inner.verifiedContent === expectedContent) return true;
+      const proof = inner.undoRebaseProof, before = proof?.beforeUndoContent;
+      if (inner.verified !== true || proof?.version !== 1
+        || normalizeSettlementPath(proof.path) !== normalizedPath
+        || typeof before !== 'string' || typeof postContent !== 'string' || !postContent
+        || typeof inner.verifiedContent !== 'string') return false;
+      // The page observed prefix + post + suffix before Undo. Prove that only
+      // this run's post-image became its pre-image, preserving both envelopes.
+      const start = before.indexOf(postContent);
+      if (start < 0 || before.indexOf(postContent, start + 1) >= 0) return false;
+      return inner.verifiedContent === before.slice(0, start) + expectedContent
+        + before.slice(start + postContent.length);
     }
     return false;
   }