codex-overleaf-link 2.5.0 → 2.5.1

package/extension/src/shared/sharedSessionTransfer.js

@@ -0,0 +1,140 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexOverleafModuleRegistry.define('SharedSessionTransfer', [], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : window, function () {
+  'use strict';
+  const MAX_WIRE_BYTES = 24 * 1024 * 1024;
+  // The old UTF-16 estimate admitted up to 3 UTF-8 bytes per code unit.
+  // Retain that finite Unicode window without enlarging ordinary ASCII writes.
+  const MAX_RECORD_BYTES = MAX_WIRE_BYTES * 3 / 2;
+  const MAX_RESPONSE_BYTES = MAX_RECORD_BYTES;
+  const MAX_DECODED_BYTES = 2 * MAX_RECORD_BYTES + 64 * 1024;
+  const error = (code, message) => Object.assign(new Error(message), { code });
+  const tooLarge = () => error('shared_session_too_large', 'The session batch exceeds the bounded shared storage transfer limit.');
+  const invalid = () => error('shared_session_transfer_invalid', 'The shared history transfer is invalid or incomplete.');
+  const byteLength = text => new TextEncoder().encode(text).byteLength;
+
+  function serialize(value, limit) {
+    // Count a lower bound during serialization, before a large aggregate string
+    // can be produced. The final UTF-8 check also includes commas and escaping.
+    let lowerBound = 0;
+    const text = JSON.stringify(value, function (key, item) {
+      if (key && !Array.isArray(this)) lowerBound += byteLength(JSON.stringify(key)) + 1;
+      if (typeof item === 'string') {
+        if (item.length > limit) throw tooLarge();
+        lowerBound += byteLength(JSON.stringify(item));
+      } else if (item === null) lowerBound += 4;
+      else if (typeof item === 'number') lowerBound += Number.isFinite(item) ? String(item).length : 4;
+      else if (typeof item === 'boolean') lowerBound += String(item).length;
+      else if (item && typeof item === 'object') lowerBound += 2;
+      if (lowerBound > limit) throw tooLarge();
+      return item;
+    });
+    if (typeof text !== 'string') throw invalid();
+    const bytes = byteLength(text);
+    if (bytes > limit) throw tooLarge();
+    return { text, bytes };
+  }
+
+  function validateRecord(record) {
+    const value = serialize(record, MAX_RECORD_BYTES);
+    if (value.bytes > MAX_WIRE_BYTES && value.text.length * 2 > MAX_WIRE_BYTES) throw tooLarge();
+  }
+
+  function validateResponse(records) { serialize(records, MAX_RESPONSE_BYTES); }
+
+  function validateEntries(entries) {
+    if (!Array.isArray(entries)) throw invalid();
+    for (const entry of entries) {
+      if (!entry || !entry.record || typeof entry.record !== 'object' || Array.isArray(entry.record)) throw invalid();
+      validateRecord(entry.record);
+      if (entry.base != null) {
+        if (typeof entry.base !== 'object' || Array.isArray(entry.base)) throw invalid();
+        // A previously stored merged baseline may be larger than new records;
+        // allow a bounded old base so a smaller candidate can repair it.
+        serialize(entry.base, MAX_DECODED_BYTES);
+      }
+    }
+  }
+
+  async function readLimited(stream, limit) {
+    const reader = stream.getReader(), chunks = [];
+    let length = 0;
+    try {
+      while (true) {
+        const result = await reader.read();
+        if (result.done) break;
+        length += result.value.byteLength;
+        if (length > limit) { await reader.cancel().catch(() => {}); throw tooLarge(); }
+        chunks.push(result.value);
+      }
+    } finally { reader.releaseLock(); }
+    const output = new Uint8Array(length); let offset = 0;
+    for (const chunk of chunks) { output.set(chunk, offset); offset += chunk.byteLength; }
+    return output;
+  }
+
+  function toBase64(bytes) {
+    let text = '';
+    for (let i = 0; i < bytes.length; i += 0x8000) text += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    return btoa(text);
+  }
+  function fromBase64(value) {
+    if (typeof value !== 'string' || !value.length || value.length % 4
+      || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) throw invalid();
+    const text = atob(value);
+    const bytes = new Uint8Array(text.length);
+    for (let i = 0; i < text.length; i++) bytes[i] = text.charCodeAt(i);
+    return bytes;
+  }
+
+  async function encode(entries, environment = globalThis) {
+    validateEntries(entries);
+    const raw = serialize(entries, MAX_DECODED_BYTES);
+    if (raw.bytes <= MAX_WIRE_BYTES || (raw.bytes <= MAX_RECORD_BYTES && raw.text.length * 2 <= MAX_WIRE_BYTES)) {
+      return { method: 'put', payload: { entries } };
+    }
+    if (typeof environment.CompressionStream !== 'function') {
+      throw error('shared_session_compression_unavailable',
+        'Lossless transfer compression is unavailable. History remains in memory; retry with a supported browser.');
+    }
+    const input = new Blob([raw.text]).stream();
+    const packed = await readLimited(input.pipeThrough(new environment.CompressionStream('gzip')),
+      Math.floor((MAX_WIRE_BYTES - 1024) * 3 / 4));
+    const payload = { encoding: 'gzip-base64', version: 1, decodedBytes: raw.bytes, data: toBase64(packed) };
+    serialize(payload, MAX_WIRE_BYTES);
+    // A distinct method makes an older worker reject rather than acknowledge
+    // an absent `entries` array as a successful empty write.
+    return { method: 'put-compressed', payload };
+  }
+
+  async function decode(message, environment = globalThis) {
+    if (message.method !== 'put-compressed') {
+      const entries = message.method === 'import' ? [{ record: message.record }] : message.entries || [];
+      const raw = serialize(entries, MAX_RECORD_BYTES);
+      if (raw.bytes > MAX_WIRE_BYTES && raw.text.length * 2 > MAX_WIRE_BYTES) throw tooLarge();
+      validateEntries(entries); return entries;
+    }
+    const payload = { encoding: message.encoding, version: message.version, decodedBytes: message.decodedBytes, data: message.data };
+    serialize(payload, MAX_WIRE_BYTES);
+    if (message.entries != null || payload.encoding !== 'gzip-base64' || payload.version !== 1
+      || !Number.isSafeInteger(payload.decodedBytes) || payload.decodedBytes < 1 || payload.decodedBytes > MAX_DECODED_BYTES) throw invalid();
+    if (typeof environment.DecompressionStream !== 'function') throw error('shared_session_compression_unavailable',
+      'Lossless transfer decompression is unavailable. Reload the extension and retry.');
+    let bytes;
+    try {
+      bytes = await readLimited(new Blob([fromBase64(payload.data)]).stream()
+        .pipeThrough(new environment.DecompressionStream('gzip')), MAX_DECODED_BYTES);
+    } catch (failure) {
+      if (['shared_session_too_large', 'shared_session_transfer_invalid'].includes(failure?.code)) throw failure;
+      throw invalid();
+    }
+    if (bytes.byteLength !== payload.decodedBytes) throw invalid();
+    let entries;
+    try { entries = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes)); }
+    catch (_error) { throw invalid(); }
+    validateEntries(entries);
+    return entries;
+  }
+  return { MAX_WIRE_BYTES, MAX_RECORD_BYTES, MAX_RESPONSE_BYTES, MAX_DECODED_BYTES, byteLength, validateRecord, validateResponse, encode, decode };
+});

package/extension/src/shared/staleGuard.js

@@ -17,7 +17,9 @@
       if (typeof file?.path === 'string') {
         const path = normalizePath(file.path);
         if (path) {
-          lookup.set(path, normalizeText(file.content));
+          // Patch offsets refer to this exact UTF-16 string. Normalize only
+          // for comparisons, never discard the source coordinate system.
+          lookup.set(path, String(file.content ?? ''));
         }
       }
     }
@@ -40,13 +42,7 @@
       };
     }
 
-    const baseContent = baseFileLookup.get(filePath);
-    if (!baseContent || baseContent.trim().length === 0) {
-      if (typeof console !== 'undefined') {
-        console.warn('[codex-overleaf] staleGuard: base empty for', filePath, '→ skipping check');
-      }
-      return { ok: true };
-    }
+    const baseContent = normalizeText(baseFileLookup.get(filePath));
     const current = normalizeText(currentContent);
     if (current !== baseContent) {
       if (typeof console !== 'undefined') {
@@ -55,7 +51,7 @@
           'base[0..80]:', JSON.stringify(baseContent.slice(0, 80)),
           'current[0..80]:', JSON.stringify(current.slice(0, 80)));
       }
-      const patchRangeFreshness = checkPatchRangeFreshness(operation, current);
+      const patchRangeFreshness = checkPatchRangeFreshness(operation, currentContent, baseFileLookup);
       if (patchRangeFreshness) {
         return patchRangeFreshness;
       }
@@ -71,13 +67,17 @@
     return { ok: true };
   }
 
-  function checkPatchRangeFreshness(operation, currentContent) {
-    const patches = Array.isArray(operation?.patches) ? operation.patches : [];
+  function checkPatchRangeFreshness(operation, currentContent, baseFileLookup) {
+    const prepared = prepareOperationPatches(operation, currentContent, baseFileLookup);
+    if (!prepared.ok) {
+      return { ...prepared, code: 'stale_patch_range', reasonKey: 'stalePatchConflict' };
+    }
+    const patches = prepared.patches;
     if (!patches.length) {
       return null;
     }
 
-    const current = normalizeText(currentContent);
+    const current = String(currentContent ?? '');
     for (const rawPatch of patches) {
       const from = Number(rawPatch?.from);
       const to = Number(rawPatch?.to);
@@ -107,12 +107,116 @@
     };
   }
 
+  // Bridge the raw Native baseline to the editor's line-ending representation.
+  // Logical LF offsets are only an intermediate coordinate system: both the
+  // range check and the eventual editor dispatch use the same raw patches.
+  function prepareOperationPatches(operation, currentContent, baseFileLookup) {
+    const patches = Array.isArray(operation?.patches) ? operation.patches : [];
+    const current = String(currentContent ?? '');
+    const path = normalizePath(operation?.path);
+    const base = baseFileLookup?.get(path);
+    if (!patches.length || typeof base !== 'string' || base === current) {
+      return { ok: true, patches };
+    }
+    const baseMap = lineEndingMap(base);
+    const currentMap = lineEndingMap(current);
+    // With no CRLF on either side, retain the existing raw range semantics.
+    if (!baseMap.removed.length && !currentMap.removed.length) return { ok: true, patches };
+
+    const groups = [];
+    let previousTo = 0;
+    for (const patch of patches) {
+      const from = Number(patch?.from), to = Number(patch?.to);
+      if (!Number.isInteger(from) || !Number.isInteger(to) || from < previousTo || to < from || to > base.length) {
+        return patchMappingFailure('invalid_patch');
+      }
+      if (base.slice(from, to) !== String(patch.expected ?? '')) return patchMappingFailure('stale_patch');
+      previousTo = to;
+      // Expand only a split CRLF or a new pair formed across an edit edge.
+      // Other neighbouring newlines belong to the editor and stay untouched.
+      let start = from, end = to;
+      const insert = String(patch.insert ?? '');
+      if (base[from - 1] === '\r' && (base[from] === '\n' || insert.startsWith('\n') || (!insert && base[to] === '\n'))) start -= 1;
+      if (base[to] === '\n' && (base[to - 1] === '\r' || insert.endsWith('\r') || (!insert && base[from - 1] === '\r'))) end += 1;
+      const previous = groups[groups.length - 1];
+      if (previous && start <= previous.end) {
+        previous.end = Math.max(previous.end, end);
+        previous.patches.push({ ...patch, from, to });
+      } else groups.push({ start, end, patches: [{ ...patch, from, to }] });
+    }
+
+    const mapped = [], sourceChanges = [];
+    for (const group of groups) {
+      const logicalFrom = baseMap.toLogical(group.start), logicalTo = baseMap.toLogical(group.end);
+      if (logicalTo > currentMap.length) return patchMappingFailure('invalid_patch');
+      const from = currentMap.toRaw(logicalFrom), to = currentMap.toRaw(logicalTo);
+      const expected = current.slice(from, to);
+      if (normalizeText(expected) !== normalizeText(base.slice(group.start, group.end))) {
+        return patchMappingFailure('stale_patch');
+      }
+      let insert = base.slice(group.start, group.end);
+      for (const patch of group.patches.slice().sort((left, right) => right.from - left.from)) {
+        if (insert.slice(patch.from - group.start, patch.to - group.start) !== String(patch.expected ?? '')) {
+          return patchMappingFailure('stale_patch');
+        }
+        insert = insert.slice(0, patch.from - group.start) + String(patch.insert ?? '') + insert.slice(patch.to - group.start);
+      }
+      sourceChanges.push({ from: group.start, to: group.end, insert });
+      const sourceEnding = nearestLineEnding(base, group.start);
+      const editorEnding = nearestLineEnding(current, from);
+      if (sourceEnding && editorEnding && sourceEnding !== editorEnding) {
+        insert = normalizeText(insert).replace(/\n/g, editorEnding);
+      }
+      // Leave equal surrounding text out of the dispatch/Track range.
+      let prefix = 0, oldEnd = expected.length, newEnd = insert.length;
+      while (prefix < oldEnd && prefix < newEnd && expected[prefix] === insert[prefix]) prefix += 1;
+      while (oldEnd > prefix && newEnd > prefix && expected[oldEnd - 1] === insert[newEnd - 1]) { oldEnd -= 1; newEnd -= 1; }
+      mapped.push({ from: from + prefix, to: from + oldEnd, expected: expected.slice(prefix, oldEnd), insert: insert.slice(prefix, newEnd) });
+    }
+    // A later operation in the same batch still addresses the original
+    // representation, so advance its baseline separately from editor text.
+    let sourceContent = base;
+    for (const patch of sourceChanges.reverse()) {
+      sourceContent = sourceContent.slice(0, patch.from) + patch.insert + sourceContent.slice(patch.to);
+    }
+    return { ok: true, patches: mapped, sourceContent };
+  }
+
+  function patchMappingFailure(code) {
+    return { ok: false, code, reason: 'Codex 要修改的位置已经无法和当前 Overleaf 内容对齐，所以没有写入。请重新运行任务。' };
+  }
+
+  function lineEndingMap(text) {
+    const removed = [];
+    for (let index = 0; index < text.length - 1; index += 1) {
+      if (text[index] === '\r' && text[index + 1] === '\n') removed.push(index);
+    }
+    function countBefore(offset, logical) {
+      let low = 0, high = removed.length;
+      while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (removed[middle] - (logical ? middle : 0) < offset) low = middle + 1;
+        else high = middle;
+      }
+      return low;
+    }
+    return { removed, length: text.length - removed.length,
+      toLogical: offset => offset - countBefore(offset, false),
+      toRaw: offset => offset + countBefore(offset, true) };
+  }
+
+  function nearestLineEnding(text, offset) {
+    let newline = text.indexOf('\n', offset);
+    if (newline < 0) newline = text.lastIndexOf('\n', offset - 1);
+    return newline < 0 ? '' : text[newline - 1] === '\r' ? '\r\n' : '\n';
+  }
+
   function updateExpectedFileContent(baseFileLookup, filePath, content) {
     const path = normalizePath(filePath);
     if (!baseFileLookup || !path) {
       return;
     }
-    baseFileLookup.set(path, normalizeText(content));
+    baseFileLookup.set(path, String(content ?? ''));
   }
 
   function removeExpectedFile(baseFileLookup, filePath) {
@@ -152,6 +256,7 @@
   return {
     buildBaseFileLookup,
     checkOperationFreshness,
+    prepareOperationPatches,
     updateExpectedFileContent,
     removeExpectedFile,
     moveExpectedFile,

package/extension/src/shared/storageDb.js

@@ -1,7 +1,7 @@
 (function initStorageDb(root, factory) {
   if (typeof module === 'object' && module.exports) {
     module.exports = factory(require('./storageRunActions'), require('./runInputQueue'),
-      require('./settlementFacts'), require('./storageSessionClaims'), require('./sessionState'), require('./runActivityModel'), require('./sharedSessionBridge'), require('./subagentActivityModel'), require('./storageValuePruning'));
+      require('./settlementFacts'), require('./storageSessionClaims'), require('./sessionState'), require('./runActivityModel'), require('./sharedSessionBridge'), require('./subagentActivityModel'), require('./storageValuePruning'), require('./composerAttachmentDraft'), require('./sharedSessionTransfer'));
   } else {
     root.CodexOverleafModuleRegistry.define('StorageDb', [
       'StorageRunActions',
@@ -12,10 +12,12 @@
       'RunActivityModel',
       'SharedSessionBridge',
       'SubagentActivityModel',
-      'StorageValuePruning'
+      'StorageValuePruning',
+      'ComposerAttachmentDraft',
+      'SharedSessionTransfer'
     ], factory);
   }
-})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims, SessionState, RunActivityModel, SharedSessionBridge, SubagentActivityModel, StorageValuePruning) {
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageDbFactory(StorageRunActions, RunInputQueue, SettlementFacts, StorageSessionClaims, SessionState, RunActivityModel, SharedSessionBridge, SubagentActivityModel, StorageValuePruning, ComposerAttachmentDraft, SharedSessionTransfer) {
   'use strict';
   const { removeEmptySummaryFields, removeEmptyFields } = StorageValuePruning;
   if (!StorageRunActions?.compactRunsForStorage || !StorageRunActions?.compactRunActionPayload || !StorageRunActions?.compactProviderSnapshot || !StorageRunActions?.compactRunExecutionSnapshot || !StorageRunActions?.compactStructuredEventValue || !StorageRunActions?.hashString || !RunInputQueue?.compactForStorage || !SettlementFacts?.compactSettlementFacts || !StorageSessionClaims?.createSessionClaimer) {
@@ -140,6 +142,7 @@
     });
   }
   var claimSessionsForAccount = StorageSessionClaims.createSessionClaimer(openDb, function () { return IDBKeyRange; });
+  var composerDraftStore = ComposerAttachmentDraft.createStore(openDb);
 
   function putRecord(storeName, record) {
     return openDb().then(function (db) {
@@ -237,17 +240,7 @@
   }
 
   function clearAllStores() {
-    return openDb().then(function (db) {
-      var storeNames = Object.keys(STORES);
-      return new Promise(function (resolve, reject) {
-        var tx = db.transaction(storeNames, 'readwrite');
-        for (var i = 0; i < storeNames.length; i++) {
-          tx.objectStore(storeNames[i]).clear();
-        }
-        tx.oncomplete = function () { resolve(); };
-        tx.onerror = function (event) { reject(event.target.error); };
-      });
-    });
+    return composerDraftStore.clear(Object.keys(STORES));
   }
 
   // --- Record builders ---
@@ -277,12 +270,14 @@
     var lastActivityAt = typeof input.lastActivityAt === 'string' && input.lastActivityAt
       ? input.lastActivityAt
       : updatedAt;
-    return {
+    var record = {
       id: input.id || generateId('ses'),
       projectId: input.projectId || '',
       title: normalizeSessionTitleForStorage(input.title, titleSource),
       titleSource: titleSource,
       codexThreadId: typeof input.codexThreadId === 'string' ? input.codexThreadId : '',
+      forkedFromSessionId: normalizeTextField(input.forkedFromSessionId, 160),
+      forkedFromRunId: normalizeTextField(input.forkedFromRunId, 160),
       status: typeof input.status === 'string' && input.status ? input.status : 'active',
       focusFiles: normalizePathList(input.focusFiles),
       selectionContext: SessionState.normalizeSelectionContext(input.selectionContext),
@@ -293,7 +288,8 @@
         normalizePaths: normalizePathList
       }),
       history: compactHistoryForStorage(input.history),
-      runs: compactRunsForStorage(input.runs, options),
+      runs: compactRunsForStorage(input.runs, { preserveRunActionPayload: false,
+        deferDirectoryCleanup: options.preserveRunActionPayload === true || options.deferDirectoryCleanup === true }),
       task: normalizeDisplayTextForStorage(input.task, SESSION_STORAGE_LIMITS.taskChars),
       mode: normalizeCurrentMode(input.mode), providerId: typeof input.providerId === 'string' && input.providerId ? input.providerId : 'builtin',
       model: typeof input.model === 'string' ? input.model : '',
@@ -307,6 +303,23 @@
       accountScopeUnavailable: accountScopeUnavailable,
       safeTaskSummary: safeTaskSummary
     };
+    if (options.preserveRunActionPayload === true) {
+      // Count the real display record before allocating recovery space. Adding
+      // older checkpoints must not make an otherwise valid history unwritable.
+      var metadataText = JSON.stringify(record), metadataBytes = SharedSessionTransfer.byteLength(metadataText);
+      record.runs = compactRunsForStorage(input.runs, { ...options,
+        canRetainActionPayload: function (bytes, chars) {
+          var totalBytes = metadataBytes + bytes + 4096, totalChars = metadataText.length + chars + 4096;
+          return totalBytes <= SharedSessionTransfer.MAX_WIRE_BYTES
+            || (totalBytes <= SharedSessionTransfer.MAX_RECORD_BYTES && totalChars * 2 <= SharedSessionTransfer.MAX_WIRE_BYTES);
+        } });
+    }
+    for (var run of record.runs) SessionState.pruneRunRecoveryScope(run, record);
+    return record;
+  }
+
+  function compactSessionBatchActions(records, options) {
+    return StorageRunActions.compactSessionBatchActions(records, options, buildSessionRecord, SharedSessionTransfer);
   }
 
   function resolveAccountScopeId(input) {
@@ -417,6 +430,7 @@
     var now = new Date().toISOString();
     return {
       id: input.id || generateId('aud'),
+      accountScopeId: typeof input.accountScopeId === 'string' ? input.accountScopeId : '',
       projectId: typeof input.projectId === 'string' ? input.projectId : '',
       sessionId: typeof input.sessionId === 'string' ? input.sessionId : '',
       turnId: typeof input.turnId === 'string' ? input.turnId : '',
@@ -466,7 +480,8 @@
       customInstructionsByProject: normalizeStringMap(state.customInstructionsByProject),
       governanceRulesByProject: normalizeGovernanceRulesMap(state.governanceRulesByProject),
       selectedLocalSkillIdsByProject: normalizeStringListMap(state.selectedLocalSkillIdsByProject),
-      codexOverleafSkillEnabled: normalizeCodexOverleafSkillEnabledMap(state.codexOverleafSkillEnabled)
+      codexOverleafSkillEnabled: normalizeCodexOverleafSkillEnabledMap(state.codexOverleafSkillEnabled),
+      codexLocalSkillEnabled: SessionState.normalizeCodexLocalSkillEnabled(state.codexLocalSkillEnabled)
     };
     return prefs;
   }
@@ -519,7 +534,7 @@
         continue;
       }
       result[key] = typeof value[rawKey] === 'string'
-        ? normalizeTextField(value[rawKey], CUSTOM_INSTRUCTIONS_MAX_CHARS)
+        ? normalizeDisplayTextForStorage(value[rawKey], CUSTOM_INSTRUCTIONS_MAX_CHARS)
         : '';
     }
     return result;
@@ -640,9 +655,9 @@
   function normalizeSessionTitleForStorage(value, titleSource) {
     var title = typeof value === 'string' ? value.trim() : '';
     if (titleSource === 'manual') {
-      return normalizeTextField(title === LEGACY_DEFAULT_SESSION_TITLE ? '' : title, SESSION_STORAGE_LIMITS.sessionTitleChars);
+      return normalizeDisplayTextForStorage(title === LEGACY_DEFAULT_SESSION_TITLE ? '' : title, SESSION_STORAGE_LIMITS.sessionTitleChars);
     }
-    return normalizeTextField(title === LEGACY_DEFAULT_SESSION_TITLE ? '' : title, SESSION_STORAGE_LIMITS.sessionTitleChars);
+    return normalizeDisplayTextForStorage(title === LEGACY_DEFAULT_SESSION_TITLE ? '' : title, SESSION_STORAGE_LIMITS.sessionTitleChars);
   }
 
   function compactHistoryForStorage(history) {
@@ -660,12 +675,14 @@
   function compactRunsForStorage(runs, options) {
     return StorageRunActions.compactRunsForStorage(runs, options, SESSION_STORAGE_LIMITS.maxRunsPerSession, compactRunForStorage);
   }
-  function compactRunForStorage(run, keepActionPayload) {
+  function compactRunForStorage(run, keepActionPayload, preparedActionPayload) {
     run = SessionState.recoverRecordedRunFailure(run);
-    var actionPayload = StorageRunActions.compactRunActionPayload(run, keepActionPayload);
+    var actionPayload = preparedActionPayload || StorageRunActions.compactRunActionPayload(run, keepActionPayload);
     var compact = {
       ...SessionState.pickWritebackRecovery(run),
       id: run.id,
+      forkSnapshot: run.forkSnapshot === true,
+      forkSourceRunId: normalizeTextField(run.forkSourceRunId, 160),
       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); }),
@@ -686,7 +703,10 @@
       undoTrackedChanges: actionPayload.undoTrackedChanges,
       undoExpectedFiles: actionPayload.undoExpectedFiles,
       ...(actionPayload.trackedChangeCaptures ? { trackedChangeCaptures: actionPayload.trackedChangeCaptures } : {}),
+      ...(actionPayload.pendingDirectoryCleanup ? { pendingDirectoryCleanup: actionPayload.pendingDirectoryCleanup } : {}),
+      ...(actionPayload.recoveryRetention ? { recoveryRetention: SessionState.normalizeRecoveryRetention(actionPayload.recoveryRetention) } : {}),
       undoStatus: normalizeDisplayTextForStorage(run.undoStatus, SESSION_STORAGE_LIMITS.statusTextChars),
+      ...(run.undoOwnerProtocol === 1 ? { undoOwnerProtocol: 1 } : {}),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
       codexThreadId: normalizeTextField(run.codexThreadId, 160), codexTurnId: normalizeTextField(run.codexTurnId, 160),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
@@ -725,6 +745,7 @@
           status: normalizeEventStatus(event.status),
           timestamp: typeof event.timestamp === 'string' ? redactSecretLikeText(event.timestamp) : '',
           kind: typeof event.kind === 'string' ? redactSecretLikeText(event.kind) : 'activity',
+          guidanceId: normalizeTextField(event.guidanceId, 160),
           streamKey: typeof event.streamKey === 'string' ? redactSecretLikeText(event.streamKey) : '',
           streamRole: typeof event.streamRole === 'string' ? redactSecretLikeText(event.streamRole) : ''
         };
@@ -760,7 +781,7 @@
 
   // Deep-copies a known-safe structured event value (the completion-report
   // {conclusion, body, meta[]} payload, or a FailureReason object) preserving
-  // its shape while redacting + truncating every string field. Bounded depth +
+  // its shape while applying display-path rules and string limits. Bounded depth +
   // breadth so a pathological value can't blow up the stored record.
   function compactStructuredEventValueForStorage(value, depth) {
     return StorageRunActions.compactStructuredEventValue(value, {
@@ -803,7 +824,11 @@
   }
 
   function normalizeDisplayTextForStorage(value, maxChars) {
-    return normalizeTextField(value, maxChars);
+    var text = sanitizeAssistantVisibleText(value);
+    if (!Number.isFinite(maxChars) || maxChars <= 0 || text.length <= maxChars) {
+      return text;
+    }
+    return text.slice(0, Math.max(0, maxChars - 1)) + '…';
   }
 
   function summarizeStructuredValueForStorage(value, maxChars) {
@@ -1013,7 +1038,7 @@
   }
 
   function normalizeTextField(value, maxChars) {
-    var text = sanitizeAssistantVisibleText(value);
+    var text = sanitizeAssistantVisibleText(redactSecretLikeText(value));
     if (!Number.isFinite(maxChars) || maxChars <= 0 || text.length <= maxChars) {
       return text;
     }
@@ -1024,7 +1049,8 @@
     if (typeof value !== 'string' || !value) {
       return '';
     }
-    var text = redactSecretLikeText(value);
+    // Preserve conversation examples and quotations through save/reload.
+    var text = value;
     if (!mightContainLocalReferenceText(text)) {
       return text;
     }
@@ -1309,7 +1335,13 @@
     deleteByIndex: deleteByIndex,
     clearStore: clearStore,
     clearAllStores: clearAllStores,
+    clearAuxiliaryStores: function () { return composerDraftStore.clear(Object.keys(STORES).filter(name => name !== 'sessions')); },
+    readComposerAttachmentDraft: composerDraftStore.read,
+    writeComposerAttachmentDraft: composerDraftStore.write,
     buildSessionRecord: buildSessionRecord,
+    compactSessionBatchActions: compactSessionBatchActions,
+    projectRetentionWarnings: StorageRunActions.projectRetentionWarnings,
+    projectRetentionUpdates: StorageRunActions.projectRetentionUpdates,
     mergeSessionReviewState: StorageRunActions.mergeSessionReviewState,
     buildTurnRecord: buildTurnRecord,
     buildEventRecord: buildEventRecord,