codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/shared/sessionState.js

@@ -4,14 +4,20 @@
       require('./i18n'),
       require('./settlementFacts'),
       require('./runInputQueue'),
+      require('./selectionContext'),
       require('./lineReferences'),
       require('./pathRedaction'),
-      require('./sessionTitle')
+      require('./sessionTitle'),
+      require('./runActivityModel'),
+      require('./subagentActivityModel'),
+      require('./writebackIntent'),
+      require('./directoryCleanupProof'),
+      require('./undoOperations')
     );
   } else {
     root.CodexOverleafModuleRegistry.define(
       'SessionState',
-      ['I18n', 'SettlementFacts', 'RunInputQueue', 'LineReferences', 'PathRedaction', 'SessionTitle'],
+      ['I18n', 'SettlementFacts', 'RunInputQueue', 'SelectionContext', 'LineReferences', 'PathRedaction', 'SessionTitle', 'RunActivityModel', 'SubagentActivityModel', 'WritebackIntent', 'DirectoryCleanupProof', 'UndoOperations'],
       factory
     );
   }
@@ -19,9 +25,15 @@
   i18n,
   SettlementFacts,
   RunInputQueue,
+  SelectionContext,
   LineReferences,
   PathRedaction,
-  SessionTitle
+  SessionTitle,
+  RunActivityModel,
+  SubagentActivityModel,
+  WritebackIntent,
+  DirectoryCleanupProof,
+  UndoOperations
 ) {
   'use strict';
 
@@ -38,6 +50,7 @@
     loadCodexLocalSkills: true,
     loadCodexOverleafSkills: true,
     codexOverleafSkillEnabled: {},
+    codexLocalSkillEnabled: {},
     theme: 'dark',
     panelWidth: 380,
     task: '',
@@ -112,7 +125,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,
@@ -145,6 +157,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 : '';
@@ -205,6 +218,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);
@@ -232,6 +247,7 @@
         : fallbackState.speedTier,
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      selectionContext: SelectionContext.normalize(session.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
       forkedFromSessionId: typeof session.forkedFromSessionId === 'string' ? session.forkedFromSessionId : '',
@@ -319,6 +335,7 @@
     state.runs = Array.isArray(active.runs) ? active.runs : [];
     state.task = typeof active.task === 'string' ? active.task : '';
     state.focusFiles = normalizeFocusFiles(active.focusFiles);
+    state.selectionContext = SelectionContext.normalize(active.selectionContext);
     state.mode = normalizeMode(active.mode);
     state.requireReviewing = active.requireReviewing !== false;
 
@@ -354,6 +371,7 @@
         : DEFAULT_PANEL_STATE.speedTier,
       requireReviewing: overrides.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(overrides.focusFiles),
+      selectionContext: SelectionContext.normalize(overrides.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(overrides.projectReferenceFiles),
       codexThreadId: typeof overrides.codexThreadId === 'string' ? overrides.codexThreadId : '',
       forkedFromSessionId: typeof overrides.forkedFromSessionId === 'string' ? overrides.forkedFromSessionId : '',
@@ -592,7 +610,64 @@
       .slice(-20);
   }
 
+  function recordedRunFailure(run) {
+    const event = [...(Array.isArray(run?.events) ? run.events : [])].reverse()
+      .find(item => item && item.kind !== 'technical' && item.subagent !== true);
+    if (!event || event.status !== 'failed' || (event.kind && event.kind !== 'activity')
+      || event.streamRole || event.streamKey || event.guidanceId) return null;
+    if (!['Codex returned a result, but local post-processing of this run failed.',
+      'Codex 已经返回了结果，但本地处理这一轮时出错了。'].includes(event.title)) return null;
+    const meta = RunActivityModel.capture(event);
+    // Capture encodes even an unscoped local event as [threadId, turnId].
+    const scoped = meta?.scope && meta.scope !== JSON.stringify(['', '']);
+    if (meta?.kind !== 'notice' || meta.state !== 'failed' || meta.id || scoped || meta.noticeSource) return null;
+    const ended = Date.parse(event.timestamp), started = Date.parse(run.startedAt);
+    if (!Number.isFinite(ended) || (Number.isFinite(started) && ended < started)) return null;
+    return event;
+  }
+
+  // On restore only: a run that already finished (finishedAt plus a terminal
+  // report as its last visible event) but was persisted as running by a stale
+  // status write. Live retries also carry an old finishedAt, so never in memory.
+  function recoverSettledRunningRun(run) {
+    if (run?.status !== 'running' || !Number.isFinite(Date.parse(run.finishedAt))) return run;
+    const last = [...(Array.isArray(run.events) ? run.events : [])].reverse()
+      .find(item => item && item.kind !== 'technical' && item.subagent !== true);
+    if (last?.kind !== 'report' || !['completed', 'failed'].includes(last.status)
+      || Date.parse(last.timestamp) > Date.parse(run.finishedAt)) return run;
+    return { ...run, status: last.status };
+  }
+
+  function recoverRecordedRunFailure(run, locale = i18n.DEFAULT_LOCALE) {
+    if (run?.status !== 'running') return run;
+    const event = recordedRunFailure(run);
+    if (!event) return run;
+    // This acknowledgement is emitted only by the parent's terminal catch.
+    // It survives a render failure that prevented the old owner from settling.
+    return { ...run, status: 'failed',
+      statusText: i18n.t(locale, 'processedFailed', { elapsed: '' }).trim(),
+      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 } : {}) } : {}) };
+  }
+
   function normalizeRun(run, options = {}) {
+    if (options.restoreRunningRuns === true || options.recoverSettledRuns === true) run = recoverSettledRunningRun(run);
+    run = recoverRecordedRunFailure(run, options.locale);
     const shouldStopRestoredRun = options.restoreRunningRuns === true && run.status === 'running';
     const locale = options.locale || i18n.DEFAULT_LOCALE;
     const events = normalizeRunEvents(run.events);
@@ -622,19 +697,23 @@
       model: typeof run.model === 'string' ? run.model : '',
       reasoningEffort: typeof run.reasoningEffort === 'string' ? run.reasoningEffort : '',
       speedTier: typeof run.speedTier === 'string' ? run.speedTier : '',
-      status: shouldStopRestoredRun ? 'interrupted' : normalizeRunStatus(run.status),
+      status: shouldStopRestoredRun ? 'interrupted' : normalizeRunStatus(run.status, run),
       statusText: shouldStopRestoredRun ? i18n.t(locale, 'restoredRunStoppedStatus') : sanitizeAssistantVisibleText(run.statusText),
       runProjectId: normalizeProjectPrefKey(run.runProjectId),
       startedAt: typeof run.startedAt === 'string' ? run.startedAt : '',
       finishedAt: shouldStopRestoredRun ? new Date().toISOString() : typeof run.finishedAt === 'string' ? run.finishedAt : '',
       events: events.slice(-MAX_RUN_EVENTS),
+      ...(run.subagents?.length ? { subagents: SubagentActivityModel.normalize(run.subagents, sanitizeAssistantVisibleText) } : {}),
       attachments: normalizeRunAttachments(run.attachments, STORAGE_DEFAULT_LIMITS),
       appliedOperations: Array.isArray(run.appliedOperations) ? run.appliedOperations : [],
       undoOperations: Array.isArray(run.undoOperations) ? run.undoOperations : [],
       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),
       codexThreadId: sanitizeAssistantVisibleText(run.codexThreadId), codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
       forkSnapshot: run.forkSnapshot === true,
@@ -659,7 +738,11 @@
     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));
 
     return normalized;
   }
@@ -670,6 +753,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
@@ -686,12 +770,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;
     }
 
@@ -708,7 +791,7 @@
 
     if (status !== undefined) {
       run.trackedChangeStatus = status;
-    }
+    } else delete run.trackedChangeStatus;
   }
 
   // Welcome-panel + write-guard: the run lifecycle now
@@ -722,13 +805,20 @@
     'running',
     'completed',
     'failed',
+    'cancelled',
     'interrupted',
     'background_completed',
     'needs_review_after_navigation',
     'abandoned_after_navigation'
   ]);
 
-  function normalizeRunStatus(status) {
+  function normalizeRunStatus(status, run = {}) {
+    if (status === 'running' && recordedRunFailure(run)) return 'failed';
+    if (status === 'rejected') return 'cancelled';
+    // Older normalizers rewrote cancelled runs to pending or completed.
+    // Recover only with a terminal timestamp and an explicit plugin event.
+    if (['pending', 'completed'].includes(status) && Number.isFinite(Date.parse(run.finishedAt))
+      && Array.isArray(run.events) && run.events.some(RunActivityModel.isRoutineCancellationEvent)) return 'cancelled';
     if (VALID_RUN_STATUS.has(status)) return status;
     // Legacy persisted runs without an explicit status fall back to `completed`
     // (the historical default for the recovery branch); unknown values land on
@@ -753,6 +843,9 @@
           timestamp: typeof event.timestamp === 'string' ? event.timestamp : '',
           kind: typeof event.kind === 'string' ? event.kind : 'activity',
           technicalDetail: sanitizeAssistantVisibleValue(event.technicalDetail),
+          activity: RunActivityModel.capture(event, sanitizeAssistantVisibleText),
+          streamPhase: RunActivityModel.normalizePhase(event.streamPhase),
+          subagent: event.subagent === true ? true : undefined,
           guidanceId: sanitizeAssistantVisibleText(event.guidanceId),
           streamKey: sanitizeAssistantVisibleText(event.streamKey),
           streamRole: sanitizeAssistantVisibleText(event.streamRole)
@@ -970,6 +1063,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) {
@@ -1041,6 +1145,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'),
@@ -1123,6 +1228,7 @@
       speedTier: normalizeSpeedTier(session.speedTier || fallbackState.speedTier),
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      selectionContext: SelectionContext.normalize(session.selectionContext),
       projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
       forkedFromSessionId: normalizeTextField(session.forkedFromSessionId, 160),
@@ -1196,6 +1302,7 @@
   }
 
   function compactRunForStorage(run, limits, keepUndoPayload, settlementFacts = null) {
+    run = recoverRecordedRunFailure(run);
     const undoPayload = compactUndoPayload(run, limits, keepUndoPayload);
     const compact = {
       id: run.id,
@@ -1204,19 +1311,26 @@
       model: normalizeTextField(run.model, 80),
       reasoningEffort: typeof run.reasoningEffort === 'string' ? run.reasoningEffort : '',
       speedTier: typeof run.speedTier === 'string' ? run.speedTier : '',
-      status: normalizeRunStatus(run.status),
+      status: normalizeRunStatus(run.status, run),
       statusText: summarizeTextForStorage(run.statusText, 'status text'),
       runProjectId: normalizeProjectPrefKey(run.runProjectId),
       startedAt: typeof run.startedAt === 'string' ? run.startedAt : '',
       finishedAt: typeof run.finishedAt === 'string' ? run.finishedAt : '',
       events: compactRunEvents(run.events, limits),
+      ...(run.subagents?.length ? { subagents: SubagentActivityModel.normalize(run.subagents, sanitizeAssistantVisibleText) } : {}),
       attachments: compactRunAttachmentsForStorage(run.attachments, limits),
       appliedOperations: [],
       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),
       codexThreadId: normalizeTextField(run.codexThreadId, 160), codexTurnId: normalizeTextField(run.codexTurnId, 160),
       forkSnapshot: run.forkSnapshot === true,
@@ -1224,6 +1338,11 @@
       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);
     }
@@ -1236,6 +1355,7 @@
     if (run.interruptedDraft) {
       compact.interruptedDraft = sanitizeAssistantVisibleValue(run.interruptedDraft);
     }
+    Object.assign(compact, pickWritebackRecovery(run));
     if (VALID_TRACKED_CHANGE_STATUS.has(run.trackedChangeStatus)) {
       compact.trackedChangeStatus = run.trackedChangeStatus;
     }
@@ -1256,6 +1376,8 @@
           streamKey: typeof event.streamKey === 'string' ? event.streamKey : '',
           streamRole: typeof event.streamRole === 'string' ? event.streamRole : ''
         };
+        compact.activity = RunActivityModel.capture(event, sanitizeAssistantVisibleText);
+        compact.streamPhase = RunActivityModel.normalizePhase(event.streamPhase);
         if (event.subagent === true) {
           compact.subagent = true;
         }
@@ -1507,21 +1629,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) {
@@ -1549,18 +1672,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 => {
@@ -1616,7 +1727,26 @@
     return new Blob([serialized]).size;
   }
 
+  function pickWritebackRecovery(run = {}) {
+    if (run.forkSnapshot === true || run.undoStatus === 'applied' || run.trackedChangeStatus === 'rejected') return {};
+    const result = {};
+    const retry = WritebackIntent.normalize(run.retryWriteback);
+    if (retry && retry.runId === run.id && retry.projectId === normalizeProjectPrefKey(run.runProjectId)
+      && retry.operations.every(op => (op.type === 'create' && typeof op.content === 'string')
+        || (op.type === 'edit' && (op.patches?.length || typeof op.replaceAll === 'string')
+          && retry.baseFiles.some(file => file.path === op.path))
+        || (op.type === 'delete' && retry.baseFiles.some(file => file.path === op.path)))
+      && !containsSecretLikeText(retry)) result.retryWriteback = retry;
+    const check = WritebackIntent.normalizeSaveCheck(run.saveCheck);
+    if (check && check.runId === run.id && check.projectId === normalizeProjectPrefKey(run.runProjectId)) result.saveCheck = check;
+    if (typeof run.saveConfirmedAt === 'string' && Number.isFinite(Date.parse(run.saveConfirmedAt))) result.saveConfirmedAt = run.saveConfirmedAt;
+    return result;
+  }
+
   return {
+    normalizeRecoveryRetention,
+    pruneRunRecoveryScope,
+    pickWritebackRecovery,
     DEFAULT_PANEL_STATE,
     createSession,
     deleteSession,
@@ -1630,7 +1760,13 @@
     setActiveSession,
     updateActiveSession,
     normalizeRuns,
+    normalizeRunStatus,
+    recoverRecordedRunFailure,
+    recoverSettledRunningRun,
+    normalizeCodexLocalSkillEnabled,
     normalizeProjectReferenceFiles,
+    normalizeComposerAttachmentsForPersistence,
+    normalizeSelectionContext: SelectionContext.normalize,
     prepareStateForStorage,
     estimateJsonBytes,
     computeSafeTaskSummary

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