codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/shared/runExecutionSnapshot.js

@@ -132,6 +132,18 @@
     };
   }
 
+  // Commit the explicit preflight decision to both live and durable run consumers.
+  // The originally captured (possibly queued) snapshot stays immutable.
+  function applyUntrackedDecision(view, record, choice) {
+    if (!['continue', 'disable'].includes(choice) || !view?.recordId || record?.id !== view.recordId) {
+      throw Codec.snapshotError('invalid_reviewing_decision', 'An explicit decision for the current run is required.');
+    }
+    const snapshot = create({ ...snapshotOf(view), requireReviewing: false });
+    view.executionSnapshot = cloneSnapshot(snapshot);
+    Object.assign(record, toRunCompatibilityTuple(snapshot));
+    return snapshot;
+  }
+
   function projectForDisplay(value = {}) {
     const snapshot = snapshotOf(value);
     return {
@@ -174,6 +186,7 @@
     SCHEMA_VERSION: Codec.SCHEMA_VERSION,
     TUPLE_FIELDS: Codec.TUPLE_FIELDS,
     applyToState,
+    applyUntrackedDecision,
     capture,
     captureRawQueueTuple,
     cloneSnapshot,

package/extension/src/shared/runInputQueue.js

@@ -11,6 +11,7 @@
   const MAX_TEXT_CHARS = 12000;
   const MAX_QUEUE_BYTES = 128 * 1024;
   const MAX_PERSISTED_QUEUE_BYTES = 512 * 1024;
+  const MAX_CUSTOM_INSTRUCTIONS_CHARS = 12000;
   const ACTIVE_STATUSES = new Set(['claimed', 'executing', 'steering']);
   const VALID_STATUSES = new Set(['queued', 'paused', ...ACTIVE_STATUSES]);
 
@@ -41,7 +42,7 @@
         claimToken: status === 'claimed' || status === 'executing' ? String(raw.claimToken || '') : '',
         pauseReason: status === 'paused' ? String(raw.pauseReason || '') : '',
         executionSnapshot: RunExecutionSnapshot.cloneSnapshot(executionSnapshot),
-        payload: RunExecutionSnapshot.toQueuePayload(executionSnapshot)
+        payload: buildPayload(executionSnapshot, raw.payload?.submissionContext)
       });
       if (normalized.length >= MAX_ITEMS) {
         break;
@@ -79,7 +80,7 @@
       claimToken: '',
       pauseReason: input.status === 'paused' ? String(input.pauseReason || '') : '',
       executionSnapshot: RunExecutionSnapshot.cloneSnapshot(executionSnapshot),
-      payload: RunExecutionSnapshot.toQueuePayload(executionSnapshot)
+      payload: buildPayload(executionSnapshot, input.payload?.submissionContext)
     };
     const next = [...queue, item];
     if (estimateLegacyBytes(next) > MAX_QUEUE_BYTES || estimateBytes(next) > MAX_PERSISTED_QUEUE_BYTES) {
@@ -137,7 +138,7 @@
       item = {
         ...item,
         executionSnapshot: RunExecutionSnapshot.cloneSnapshot(snapshot),
-        payload: RunExecutionSnapshot.toQueuePayload(snapshot)
+        payload: buildPayload(snapshot, item.payload?.submissionContext)
       };
     } catch (error) {
       return {
@@ -199,6 +200,46 @@
     );
   }
 
+  // Queue inputs persist only these submitted extras. Attachments stay unsupported,
+  // and older items must not acquire a later draft's one-turn context on promotion.
+  function normalizeSubmissionContext(value = {}, helpers = {}) {
+    const input = value && typeof value === 'object' ? value : {};
+    const normalizeText = (value, maxChars) => {
+      const text = typeof value === 'string' ? value : '';
+      return String(helpers.normalizeDisplay ? helpers.normalizeDisplay(text, maxChars) : text).slice(0, maxChars);
+    };
+    const safeId = value => typeof value === 'string'
+      && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(value) && !value.includes('..')
+      && !['__proto__', 'prototype', 'constructor'].includes(value);
+    const rawSkill = input.skillInvocation;
+    const installer = rawSkill?.id === 'skill-installer' && (rawSkill.scope == null || rawSkill.scope === 'builtin');
+    const skillInvocation = safeId(rawSkill?.id)
+      && (installer || ['codex-overleaf', 'codex-local'].includes(rawSkill.scope))
+      ? { id: rawSkill.id, title: normalizeText(rawSkill.title || rawSkill.id, 80),
+          ...(installer ? {} : { scope: rawSkill.scope }) }
+      : null;
+    return {
+      customInstructions: normalizeText(input.customInstructions, MAX_CUSTOM_INSTRUCTIONS_CHARS),
+      skillLoadingSettings: {
+        loadCodexLocalSkills: input.skillLoadingSettings?.loadCodexLocalSkills === true,
+        loadCodexOverleafSkills: input.skillLoadingSettings?.loadCodexOverleafSkills === true
+      },
+      skillInvocation,
+      ...(Array.isArray(input.enabledCodexLocalSkillIds) ? {
+        enabledCodexLocalSkillIds: [...new Set(input.enabledCodexLocalSkillIds.filter(safeId))]
+      } : {}),
+      enabledCodexOverleafSkillIds: [...new Set((Array.isArray(input.enabledCodexOverleafSkillIds)
+        ? input.enabledCodexOverleafSkillIds : []).filter(safeId))]
+    };
+  }
+
+  function buildPayload(snapshot, submissionContext, helpers) {
+    const payload = RunExecutionSnapshot.toQueuePayload(snapshot);
+    // Keep legacy absence compact; safe defaults are applied only at execution.
+    if (submissionContext == null) return payload;
+    return { ...payload, submissionContext: normalizeSubmissionContext(submissionContext, helpers) };
+  }
+
   function normalizeTimestamp(value) {
     return typeof value === 'string' && value ? value : new Date().toISOString();
   }
@@ -237,7 +278,8 @@
               speedTier: item.payload.speedTier,
               autoRecompile: item.payload.autoRecompile,
               requireReviewing: item.payload.requireReviewing,
-              focusFiles: item.payload.focusFiles
+              focusFiles: item.payload.focusFiles,
+              submissionContext: item.payload.submissionContext
             }
           : {}
       };
@@ -269,7 +311,7 @@
           claimToken: normalizeField(item?.claimToken, 160),
           pauseReason: normalizeField(item?.pauseReason, 160),
           executionSnapshot: compactSnapshot,
-          payload: RunExecutionSnapshot.toQueuePayload(compactSnapshot)
+          payload: buildPayload(compactSnapshot, payload.submissionContext, { normalizeDisplay })
         };
       })
       .filter(item => item.id && item.text);
@@ -292,6 +334,7 @@
     markExecuting,
     markSteering,
     normalizeQueue,
+    normalizeSubmissionContext,
     pauseAll,
     remove,
     resumeAll,

package/extension/src/shared/selectionContext.js

@@ -6,20 +6,29 @@
   const MAX_TEXT = 20000;
   function normalize(value) {
     if (!value || typeof value !== 'object') return null;
-    const path = typeof value.path === 'string' ? value.path.replace(/\\/g, '/') : '';
-    if (!path || path.startsWith('/') || /^[A-Za-z]:/.test(path)
+    const path = typeof value.path === 'string' ? value.path : '';
+    if (!path || path.length > 2048 || path.trim() !== path || path.includes('\\')
+      || /[\u0000-\u001f\u007f]/.test(path) || path.startsWith('/') || /^[A-Za-z]:/.test(path)
       || path.split('/').some(part => !part || part === '.' || part === '..')) return null;
     if (typeof value.projectId !== 'string' || !value.projectId
       || typeof value.text !== 'string' || !value.text.length || value.text.length > MAX_TEXT
+      || /[\uD800-\uDFFF]/u.test(value.text)
       || !Number.isSafeInteger(value.from) || !Number.isSafeInteger(value.to)
       || value.from < 0 || value.to <= value.from || value.to - value.from !== value.text.length
       || !/^[a-f0-9]{64}$/i.test(value.documentHash || '')) return null;
+    const proof = value.rebaseEvidence;
+    const rebaseEvidence = proof?.v === 1 && Number.isSafeInteger(proof.documentLength)
+      && proof.documentLength >= value.to && /^[a-f0-9]{64}$/i.test(proof.prefixHash || '')
+      && /^[a-f0-9]{64}$/i.test(proof.suffixHash || '')
+      ? Object.freeze({ v: 1, documentLength: proof.documentLength,
+          prefixHash: proof.prefixHash.toLowerCase(), suffixHash: proof.suffixHash.toLowerCase() }) : null;
     return Object.freeze({
-      projectId: value.projectId.slice(0, 160), path: path.slice(0, 320),
+      projectId: value.projectId.slice(0, 160), path,
       from: value.from, to: value.to, text: value.text,
       lineStart: Number.isSafeInteger(value.lineStart) && value.lineStart > 0 ? value.lineStart : 1,
       lineEnd: Number.isSafeInteger(value.lineEnd) && value.lineEnd > 0 ? value.lineEnd : 1,
       documentHash: value.documentHash.toLowerCase(),
+      ...(rebaseEvidence ? { rebaseEvidence } : {}),
       mode: value.mode === 'edit' ? 'edit' : 'reference',
       capturedAt: typeof value.capturedAt === 'string' ? value.capturedAt.slice(0, 64) : ''
     });

package/extension/src/shared/sessionState.js

@@ -10,12 +10,15 @@
       require('./sessionTitle'),
       require('./runActivityModel'),
       require('./subagentActivityModel'),
-      require('./writebackIntent')
+      require('./writebackIntent'),
+      require('./directoryCleanupProof'),
+      require('./undoOperations'),
+      require('./contextUsage')
     );
   } else {
     root.CodexOverleafModuleRegistry.define(
       'SessionState',
-      ['I18n', 'SettlementFacts', 'RunInputQueue', 'SelectionContext', 'LineReferences', 'PathRedaction', 'SessionTitle', 'RunActivityModel', 'SubagentActivityModel', 'WritebackIntent'],
+      ['I18n', 'SettlementFacts', 'RunInputQueue', 'SelectionContext', 'LineReferences', 'PathRedaction', 'SessionTitle', 'RunActivityModel', 'SubagentActivityModel', 'WritebackIntent', 'DirectoryCleanupProof', 'UndoOperations', 'ContextUsage'],
       factory
     );
   }
@@ -29,7 +32,10 @@
   SessionTitle,
   RunActivityModel,
   SubagentActivityModel,
-  WritebackIntent
+  WritebackIntent,
+  DirectoryCleanupProof,
+  UndoOperations,
+  ContextUsage
 ) {
   'use strict';
 
@@ -46,6 +52,7 @@
     loadCodexLocalSkills: true,
     loadCodexOverleafSkills: true,
     codexOverleafSkillEnabled: {},
+    codexLocalSkillEnabled: {},
     theme: 'dark',
     panelWidth: 380,
     task: '',
@@ -120,7 +127,6 @@
     statusTextChars: 400,
     attachmentPreviewChars: 160 * 1024
   };
-  const REDACTED_SECRET = '[REDACTED_SECRET]';
   const SECRET_REDACTION_PATTERNS = [
     /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
     /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi,
@@ -153,6 +159,7 @@
     state.loadCodexLocalSkills = state.loadCodexLocalSkills !== false;
     state.loadCodexOverleafSkills = state.loadCodexOverleafSkills !== false;
     state.codexOverleafSkillEnabled = normalizeCodexOverleafSkillEnabled(state.codexOverleafSkillEnabled);
+    state.codexLocalSkillEnabled = normalizeCodexLocalSkillEnabled(state.codexLocalSkillEnabled);
     state.theme = ['dark', 'light', 'auto'].includes(state.theme) ? state.theme : 'dark';
     state.panelWidth = normalizePanelWidth(state.panelWidth);
     state.task = typeof state.task === 'string' ? state.task : '';
@@ -213,6 +220,8 @@
     const history = normalizeHistoryEntries(session.history);
     const normalizedRuns = normalizeRuns(session.runs, options);
     const runs = normalizedRuns.length ? normalizedRuns : recoverRunsFromHistory(session, history);
+    for (const run of runs) pruneRunRecoveryScope(run, session);
+
     const rawTitle = typeof session.title === 'string' ? session.title.trim() : '';
     const derivedTitle = deriveSessionTitle(runs, session.task);
     const titleSource = normalizeTitleSource(session.titleSource, rawTitle, derivedTitle);
@@ -243,6 +252,7 @@
       selectionContext: SelectionContext.normalize(session.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
+      contextUsage: ContextUsage.normalize(session.contextUsage),
       forkedFromSessionId: typeof session.forkedFromSessionId === 'string' ? session.forkedFromSessionId : '',
       forkedFromRunId: typeof session.forkedFromRunId === 'string' ? session.forkedFromRunId : '',
       pendingInputs: normalizePendingInputs(
@@ -323,6 +333,7 @@
       focusFiles: normalizeFocusFiles(active.focusFiles),
       projectReferenceFiles: normalizeProjectReferenceFiles(active.projectReferenceFiles),
       codexThreadId: active.codexThreadId || '',
+      contextUsage: ContextUsage.normalize(active.contextUsage),
       providerId: state.providerId || 'builtin'
     };
     state.runs = Array.isArray(active.runs) ? active.runs : [];
@@ -367,6 +378,7 @@
       selectionContext: SelectionContext.normalize(overrides.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(overrides.projectReferenceFiles),
       codexThreadId: typeof overrides.codexThreadId === 'string' ? overrides.codexThreadId : '',
+      contextUsage: ContextUsage.normalize(overrides.contextUsage),
       forkedFromSessionId: typeof overrides.forkedFromSessionId === 'string' ? overrides.forkedFromSessionId : '',
       forkedFromRunId: typeof overrides.forkedFromRunId === 'string' ? overrides.forkedFromRunId : '',
       pendingInputs: normalizePendingInputs(overrides.pendingInputs)
@@ -432,6 +444,34 @@
     });
   }
 
+  // Composer input changes only the draft on an already normalized state.
+  // Keep live run/event objects intact so typing cannot detach their writers.
+  function updateActiveSessionDraft(state, task) {
+    const active = getActiveSession(state);
+    if (!active) {
+      return mirrorActiveSession({ ...state });
+    }
+    const draft = sanitizeAssistantVisibleText(task);
+    if (draft === active.task && draft === state.task) {
+      return state;
+    }
+    const rawTitle = typeof active.title === 'string' ? active.title.trim() : '';
+    const derivedTitle = deriveSessionTitle(active.runs, task);
+    const titleSource = normalizeTitleSource(active.titleSource, rawTitle, derivedTitle);
+    const next = {
+      ...active,
+      task: draft,
+      updatedAt: new Date().toISOString(),
+      title: normalizeSessionTitle(rawTitle, derivedTitle, titleSource),
+      titleSource
+    };
+    return {
+      ...state,
+      sessions: state.sessions.map(session => session === active ? next : session),
+      task: next.task
+    };
+  }
+
   function setActiveSession(state, sessionId) {
     if (!(state.sessions || []).some(session => session.id === sessionId)) {
       return mirrorActiveSession(state);
@@ -642,7 +682,33 @@
       finishedAt: Number.isFinite(Date.parse(run.finishedAt)) ? run.finishedAt : event.timestamp };
   }
 
+  function pruneRunRecoveryScope(run, session = {}) {
+    const wrongAccount = proof => Object.prototype.hasOwnProperty.call(session, 'accountScopeId')
+      && proof.accountScopeId !== session.accountScopeId;
+    const wrongProject = value => Boolean(session.projectId && value !== session.projectId);
+    if (run.pendingDirectoryCleanup && (run.pendingDirectoryCleanup.sessionId !== session.id
+      || wrongAccount(run.pendingDirectoryCleanup) || wrongProject(run.pendingDirectoryCleanup.projectId))) delete run.pendingDirectoryCleanup;
+    applyTrackedChangeStatus(run, run.trackedChangeStatus);
+  }
+
+  function normalizeRecoveryRetention(value) {
+    if (value?.state !== 'omitted') return undefined;
+    return { state: 'omitted', reason: ['run-budget', 'session-budget', 'fallback', 'invalid'].includes(value.reason)
+      ? value.reason : 'invalid', bytes: Number.isSafeInteger(value.bytes) && value.bytes >= 0 ? value.bytes : 0,
+      ...(value.directoryCleanup === true ? { directoryCleanup: true, ...(value.coreRetained === true ? { coreRetained: true } : {}) } : {}) };
+  }
+
+  // Normalization makes UI copies of the same record. This identity is page-local:
+  // it never travels through JSON/storage and is never shared by a replacement run.
+  const runIdentities = new WeakMap();
+  function sameRunIdentity(left, right) {
+    return Boolean(left && right && (left === right
+      || (runIdentities.has(left) && runIdentities.get(left) === runIdentities.get(right))));
+  }
+
   function normalizeRun(run, options = {}) {
+    const sourceRun = run;
+
     if (options.restoreRunningRuns === true || options.recoverSettledRuns === true) run = recoverSettledRunningRun(run);
     run = recoverRecordedRunFailure(run, options.locale);
     const shouldStopRestoredRun = options.restoreRunningRuns === true && run.status === 'running';
@@ -658,6 +724,12 @@
         status: 'failed',
         kind: 'report',
         detail: i18n.t(locale, 'restoredRunStoppedDetail'),
+        detailStructured: {
+          conclusion: i18n.t(locale, 'restoredRunStoppedDetail'),
+          conclusionSource: { origin: 'product', key: 'reload_interrupted' },
+          // Ask forbids writeback; an interrupted Auto run has no zero-write proof.
+          meta: run.mode === 'ask' ? [{ key: 'writeResult', value: 'wrote 0 items, skipped 0 items' }] : []
+        },
         failure: { code: 'native_request_failed', source: 'panel_reload' },
         timestamp: new Date().toISOString()
       });
@@ -687,9 +759,14 @@
       undoBaseFiles: normalizeRunFiles(run.undoBaseFiles),
       undoTrackedChanges: normalizeRunTrackedChanges(run.undoTrackedChanges),
       undoExpectedFiles: normalizeRunFiles(run.undoExpectedFiles),
+      ...(normalizeRecoveryRetention(run.recoveryRetention) && !run.forkSnapshot
+        ? { recoveryRetention: normalizeRecoveryRetention(run.recoveryRetention) } : {}),
       undoStatus: sanitizeAssistantVisibleText(run.undoStatus),
+      ...(run.undoOwnerProtocol === 1 ? { undoOwnerProtocol: 1 } : {}),
       nativeRequestId: sanitizeAssistantVisibleText(run.nativeRequestId),
+      ...(run.operation === 'compact' ? { operation: 'compact' } : {}),
       codexThreadId: sanitizeAssistantVisibleText(run.codexThreadId), codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
+      contextUsage: run.forkSnapshot === true ? null : ContextUsage.normalize(run.contextUsage),
       forkSnapshot: run.forkSnapshot === true,
       forkSourceRunId: sanitizeAssistantVisibleText(run.forkSourceRunId),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
@@ -712,9 +789,15 @@
     if (Array.isArray(run.trackedChangeCaptures) && run.trackedChangeCaptures.length && !run.forkSnapshot) {
       normalized.trackedChangeCaptures = sanitizeAssistantVisibleValue(run.trackedChangeCaptures);
     }
+    const directories = DirectoryCleanupProof.normalize(run.pendingDirectoryCleanup);
+    if (directories && directories.runId === normalized.id && directories.projectId === normalized.runProjectId
+      && !run.forkSnapshot) normalized.pendingDirectoryCleanup = directories;
     applyTrackedChangeStatus(normalized, run.trackedChangeStatus);
     Object.assign(normalized, pickWritebackRecovery(run));
 
+    const identity = runIdentities.get(sourceRun) || {};
+    runIdentities.set(sourceRun, identity);
+    runIdentities.set(normalized, identity);
     return normalized;
   }
 
@@ -724,6 +807,7 @@
   // output yields the same result.
   function applyTrackedChangeStatus(run, rawStatus) {
     const hasRefs = run.undoTrackedChanges.length > 0;
+    const hasFileUndo = (run.undoOperations || []).some(UndoOperations.isFileUndoOperation);
     const hasRawStatus = rawStatus !== undefined && rawStatus !== null && rawStatus !== '';
 
     // Step 1 — value recovery. Keep a stable value; recover any other present
@@ -740,12 +824,11 @@
     }
 
     // Step 1 — reload reconciliation. A non-terminal status (`pending`) with no
-    // refs is the post-reload state of an un-acted tracked-change run: the heavy refs are
-    // never persisted, so without them there is nothing to act on. Drop it so
-    // the run returns to the legacy-undo world. A terminal status with no refs
+    // refs can result from an old record or a storage-budget omission. Drop
+    // pending and let actual legacy Undo material decide the action. A terminal status with no refs
     // is kept — step 3 already empties terminal payloads and the label stays
     // meaningful.
-    if (!hasRefs && status === 'pending') {
+    if (!hasRefs && !hasFileUndo && status === 'pending') {
       status = undefined;
     }
 
@@ -762,7 +845,7 @@
 
     if (status !== undefined) {
       run.trackedChangeStatus = status;
-    }
+    } else delete run.trackedChangeStatus;
   }
 
   // Welcome-panel + write-guard: the run lifecycle now
@@ -1034,6 +1117,17 @@
     return result;
   }
 
+  function normalizeCodexLocalSkillEnabled(value) {
+    const result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return result;
+    for (const [id, enabled] of Object.entries(value)) {
+      if (/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(id) && !id.includes('..')
+        && !['__proto__', 'prototype', 'constructor'].includes(id) && typeof enabled === 'boolean') result[id] = enabled;
+    }
+    if (Object.keys(result).length > 200) throw new Error('Too many skill preferences.');
+    return result;
+  }
+
   function normalizeProjectPrefKey(value) {
     const key = typeof value === 'string' ? value.trim() : '';
     if (!key) {
@@ -1105,6 +1199,7 @@
       loadCodexLocalSkills: source.loadCodexLocalSkills !== false,
       loadCodexOverleafSkills: source.loadCodexOverleafSkills !== false,
       codexOverleafSkillEnabled: normalizeCodexOverleafSkillEnabled(source.codexOverleafSkillEnabled),
+      codexLocalSkillEnabled: normalizeCodexLocalSkillEnabled(source.codexLocalSkillEnabled),
       theme: ['dark', 'light', 'auto'].includes(source.theme) ? source.theme : 'dark',
       panelWidth: normalizePanelWidth(source.panelWidth),
       task: summarizeTextForStorage(active?.task || source.task || '', 'task'),
@@ -1190,6 +1285,7 @@
       selectionContext: SelectionContext.normalize(session.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
+      contextUsage: ContextUsage.normalize(session.contextUsage),
       forkedFromSessionId: normalizeTextField(session.forkedFromSessionId, 160),
       forkedFromRunId: normalizeTextField(session.forkedFromRunId, 160),
       pendingInputs: normalizePendingInputs(session.pendingInputs)
@@ -1278,19 +1374,32 @@
       events: compactRunEvents(run.events, limits),
       ...(run.subagents?.length ? { subagents: SubagentActivityModel.normalize(run.subagents, sanitizeAssistantVisibleText) } : {}),
       attachments: compactRunAttachmentsForStorage(run.attachments, limits),
-      appliedOperations: [],
+      appliedOperations: UndoOperations.compactUnavailableUndoOperations(run),
       undoOperations: undoPayload.undoOperations,
       undoBaseFiles: undoPayload.undoBaseFiles,
       undoTrackedChanges: undoPayload.undoTrackedChanges,
       undoExpectedFiles: undoPayload.undoExpectedFiles,
+      ...(!run.forkSnapshot && (run.pendingDirectoryCleanup || run.recoveryRetention?.directoryCleanup === true || (run.undoStatus !== 'applied' && !['accepted', 'rejected'].includes(run.trackedChangeStatus)))
+        && (run.pendingDirectoryCleanup || run.recoveryRetention?.state === 'omitted' || ['appliedOperations', 'undoOperations', 'undoTrackedChanges', 'undoExpectedFiles']
+          .some(key => Array.isArray(run[key]) && run[key].length))
+        ? { recoveryRetention: normalizeRecoveryRetention(run.recoveryRetention)
+          || { state: 'omitted', reason: 'fallback', bytes: 0, ...(run.pendingDirectoryCleanup ? { directoryCleanup: true } : {}) } } : {}),
       undoStatus: summarizeTextForStorage(run.undoStatus, 'undo status'),
+      ...(run.undoOwnerProtocol === 1 ? { undoOwnerProtocol: 1 } : {}),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 160),
+      ...(run.operation === 'compact' ? { operation: 'compact' } : {}),
       codexThreadId: normalizeTextField(run.codexThreadId, 160), codexTurnId: normalizeTextField(run.codexTurnId, 160),
+      contextUsage: run.forkSnapshot === true ? null : ContextUsage.normalize(run.contextUsage),
       forkSnapshot: run.forkSnapshot === true,
       forkSourceRunId: normalizeTextField(run.forkSourceRunId, 160),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
       queueItemId: normalizeTextField(run.queueItemId, 160)
     };
+    if (compact.recoveryRetention?.coreRetained === true && run.undoStatus !== 'applied'
+      && !TERMINAL_TRACKED_CHANGE_STATUS.has(run.trackedChangeStatus)
+      && ['appliedOperations', 'undoOperations', 'undoTrackedChanges', 'undoExpectedFiles'].some(key => run[key]?.length)) {
+      delete compact.recoveryRetention.coreRetained;
+    }
     if (run.executionSnapshot && typeof run.executionSnapshot === 'object') {
       compact.executionSnapshot = sanitizeAssistantVisibleValue(run.executionSnapshot);
     }
@@ -1577,21 +1686,22 @@
     if (typeof value !== 'string' || !value) {
       return '';
     }
-    const secretRedacted = redactSecretLikeText(value);
-    if (!mightContainLocalReferenceText(secretRedacted)) {
-      return secretRedacted;
+    // Conversation text is user/model content, not a credential field. Keep
+    // examples and quoted values intact; local-reference display rules remain.
+    if (!mightContainLocalReferenceText(value)) {
+      return value;
     }
     if (LineReferences?.sanitizeLocalReferences) {
       try {
-        return LineReferences.sanitizeLocalReferences(secretRedacted, {
+        return LineReferences.sanitizeLocalReferences(value, {
           projectFiles: [],
           context: 'persist'
         });
       } catch (_error) {
-        return fallbackSanitizeLocalReferences(secretRedacted);
+        return fallbackSanitizeLocalReferences(value);
       }
     }
-    return fallbackSanitizeLocalReferences(secretRedacted);
+    return fallbackSanitizeLocalReferences(value);
   }
 
   function mightContainLocalReferenceText(value) {
@@ -1619,18 +1729,6 @@
     });
   }
 
-  function redactSecretLikeText(value) {
-    if (typeof value !== 'string') {
-      return '';
-    }
-    let redacted = value;
-    for (const pattern of SECRET_REDACTION_PATTERNS) {
-      pattern.lastIndex = 0;
-      redacted = redacted.replace(pattern, REDACTED_SECRET);
-    }
-    return redacted;
-  }
-
   function containsSecretLikeText(value) {
     if (typeof value === 'string') {
       return SECRET_REDACTION_PATTERNS.some(pattern => {
@@ -1703,6 +1801,9 @@
   }
 
   return {
+    sameRunIdentity,
+    normalizeRecoveryRetention,
+    pruneRunRecoveryScope,
     pickWritebackRecovery,
     DEFAULT_PANEL_STATE,
     createSession,
@@ -1716,11 +1817,14 @@
     selectVisibleSessionsForList,
     setActiveSession,
     updateActiveSession,
+    updateActiveSessionDraft,
     normalizeRuns,
     normalizeRunStatus,
     recoverRecordedRunFailure,
     recoverSettledRunningRun,
+    normalizeCodexLocalSkillEnabled,
     normalizeProjectReferenceFiles,
+    normalizeComposerAttachmentsForPersistence,
     normalizeSelectionContext: SelectionContext.normalize,
     prepareStateForStorage,
     estimateJsonBytes,

package/extension/src/shared/sessionTitle.js

@@ -25,6 +25,19 @@
   }
 
   function fromPrompt(value, { sanitize = text => text, maxChars = 24 } = {}) {
+    let title = projectPrompt(value, { sanitize, maxChars });
+    // Display titles pass through normalization again on unrelated callbacks.
+    // Finish removing nested formatting/prefixes now, before acknowledging a title.
+    // The bound guards against an input that never settles.
+    for (let pass = 0; pass < 8; pass += 1) {
+      const next = projectPrompt(title, { sanitize, maxChars });
+      if (next === title) return title;
+      title = next;
+    }
+    return title;
+  }
+
+  function projectPrompt(value, { sanitize, maxChars }) {
     if (typeof value !== 'string' || !value.trim()) return '';
     const source = String(sanitize(value.slice(0, INPUT_LIMIT)) || '');
     let fence = null;
@@ -75,7 +88,7 @@
       .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, '');
+      .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) {

package/extension/src/shared/settlementFacts.js

@@ -157,6 +157,9 @@
       canAccept,
       canUndo,
       canRetry: Boolean(primaryFailure?.retryable),
+      requiresWriteReview: Boolean(facts && (facts.documentEffect === 'possibly-changed'
+        || facts.evidence?.settled === 'needs-review'
+        || facts.failures.some(failure => DefaultFailureReasons.isUnconfirmedWriteFailure?.(failure)))),
       terminalState: failureTerminalState || '',
       actions: { accept: canAccept, undo: canUndo }
     };
@@ -209,6 +212,10 @@
         file: safePath(item.file),
         operationType: text(item.operationType).slice(0, 80),
         changedDocument: item.changedDocument === true,
+        ...(item.mayHaveMutated === true ? { mayHaveMutated: true } : {}),
+        ...(item.evidence?.originalCode === 'native_untracked_undo_pending_changes'
+          && item.changedDocument !== true && item.mayHaveMutated !== true && item.evidence.writeStarted !== true
+          ? { evidence: { originalCode: 'native_untracked_undo_pending_changes' } } : {}),
         terminalState: normalizeTerminalState(item.terminalState)
       }));
   }
@@ -287,8 +294,9 @@
   }
 
   function selectPrimaryFailure(failures) {
-    return DefaultFailureReasons?.selectPrimaryFailure instanceof Function
-      ? DefaultFailureReasons.selectPrimaryFailure(failures)
+    const select = DefaultFailureReasons?.selectPrimaryWritebackFailure || DefaultFailureReasons?.selectPrimaryFailure;
+    return select instanceof Function
+      ? select(failures)
       : failures[0] || null;
   }