codex-overleaf-link 2.3.6 → 2.4.1

package/extension/src/shared/sessionState.js

@@ -636,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,
@@ -656,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;
@@ -1215,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,
@@ -1627,6 +1630,7 @@
     setActiveSession,
     updateActiveSession,
     normalizeRuns,
+    normalizeProjectReferenceFiles,
     prepareStateForStorage,
     estimateJsonBytes,
     computeSafeTaskSummary

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)
     };
@@ -1345,6 +1343,7 @@
     clearStore: clearStore,
     clearAllStores: clearAllStores,
     buildSessionRecord: buildSessionRecord,
+    mergeSessionReviewState: StorageRunActions.mergeSessionReviewState,
     buildTurnRecord: buildTurnRecord,
     buildEventRecord: buildEventRecord,
     buildArtifactRecord: buildArtifactRecord,

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',
@@ -132,6 +159,49 @@
     return out;
   }
 
+  // Review terminal states are monotonic even when a later session snapshot is stale.
+  function mergeSessionReviewState(incoming, existing, reviewRunIds) {
+    if (!existing || incoming.id !== existing.id || incoming.projectId !== existing.projectId
+      || !incoming.accountScopeId || incoming.accountScopeId !== existing.accountScopeId) return incoming;
+    var terminal = run => ['accepted', 'rejected'].includes(run?.trackedChangeStatus);
+    var incomingRuns = new Map((incoming.runs || []).map(run => [run.id, run]));
+    var existingRuns = new Map((existing.runs || []).map(run => [run.id, run]));
+    var requestedIds = new Set(reviewRunIds || []);
+    var explicitReview = Array.from(requestedIds).some(id =>
+      ['accepted', 'rejected', 'needs_review'].includes(incomingRuns.get(id)?.trackedChangeStatus));
+    var newer = (Date.parse(incoming.updatedAt) || 0) >= (Date.parse(existing.updatedAt) || 0);
+    if (!newer && !explicitReview) return incoming;
+    var base = newer ? incoming : existing;
+    var fields = ['trackedChangeStatus', 'undoStatus', 'undoTrackedChanges', 'undoExpectedFiles',
+      'undoOperations', 'undoBaseFiles', 'appliedOperations', 'trackedChangeCaptures', 'settlement', 'settlementFacts'];
+    var changed = false;
+    var runs = (base.runs || []).map(function (run) {
+      var previous = existingRuns.get(run.id), candidate = incomingRuns.get(run.id);
+      // Never revive a removed run or change the first durably recorded review decision.
+      var source = terminal(previous) ? previous
+        : explicitReview && requestedIds.has(run.id) ? candidate : null;
+      if (!source || source === run) return run;
+      if (source.runProjectId && source.runProjectId !== incoming.projectId) return run;
+      var merged = { ...run };
+      for (var field of fields) {
+        if (Object.prototype.hasOwnProperty.call(source, field)) {
+          merged[field] = JSON.parse(JSON.stringify(source[field]));
+        } else {
+          delete merged[field];
+        }
+      }
+      changed = true;
+      return merged;
+    });
+    if (!changed) return base;
+    var merged = { ...base, runs };
+    if (explicitReview && !newer) {
+      merged.updatedAt = new Date(Math.max(Date.now(), Date.parse(existing.updatedAt) || 0,
+        Date.parse(incoming.updatedAt) || 0) + 1).toISOString();
+    }
+    return merged;
+  }
+
   function hashString(value) {
     var hash = 2166136261;
     var text = String(value || '');
@@ -144,9 +214,11 @@
 
   return {
     compactStructuredEventValue: compactStructuredEventValue,
+    mergeSessionReviewState: mergeSessionReviewState,
     compactRunsForStorage: compactRunsForStorage,
     compactRunActionPayload: compactRunActionPayload,
     compactProviderSnapshot: compactProviderSnapshot,
+    compactRunExecutionSnapshot: compactRunExecutionSnapshot,
     hashString: hashString
   };
 });

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;
   }