codex-overleaf-link 2.3.0 → 2.3.2

package/extension/src/shared/sessionState.js

@@ -24,7 +24,7 @@
   'use strict';
 
   const DEFAULT_PANEL_STATE = {
-    mode: 'confirm',
+    mode: 'ask',
     providerId: 'builtin',
     model: 'gpt-5.4',
     reasoningEffort: 'high',
@@ -47,13 +47,13 @@
     customInstructionsByProject: {}
   };
 
-  const VALID_MODES = new Set(['ask', 'confirm', 'auto']);
+  const VALID_MODES = new Set(['ask', 'auto']);
   // Keep the persisted/session-level contract aligned with the model picker
   // and native provider bridge. Custom providers can explicitly disable
   // reasoning (`none`) or expose the lightest Codex tier (`minimal`). Dropping
   // either value here silently restores the global `high` default after the
   // user has selected it in the composer.
-  const VALID_REASONING = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
+  const VALID_REASONING = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
   const VALID_SPEED_TIERS = new Set(['standard', 'fast']);
   const VALID_LOCALES = new Set(['en', 'zh']);
   const VALID_EVENT_STATUSES = new Set(['info', 'running', 'completed', 'failed', 'warning', 'blocked', 'skipped', 'pending']);
@@ -127,12 +127,8 @@
       ...input
     };
 
-    if (!VALID_MODES.has(state.mode)) {
-      state.mode = DEFAULT_PANEL_STATE.mode;
-    }
-    if (!VALID_REASONING.has(state.reasoningEffort)) {
-      state.reasoningEffort = DEFAULT_PANEL_STATE.reasoningEffort;
-    }
+    state.mode = normalizeMode(state.mode);
+    state.reasoningEffort = normalizeReasoning(state.reasoningEffort);
     if (!VALID_SPEED_TIERS.has(state.speedTier)) {
       state.speedTier = DEFAULT_PANEL_STATE.speedTier;
     }
@@ -221,7 +217,7 @@
       history,
       runs,
       task: sanitizeAssistantVisibleText(session.task),
-      mode: VALID_MODES.has(session.mode) ? session.mode : fallbackState.mode,
+      mode: normalizeMode(session.mode, fallbackState.mode),
       providerId: typeof session.providerId === 'string' && session.providerId.trim()
         ? session.providerId.trim()
         : (fallbackState.providerId || 'builtin'),
@@ -234,7 +230,10 @@
         : fallbackState.speedTier,
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
+      forkedFromSessionId: typeof session.forkedFromSessionId === 'string' ? session.forkedFromSessionId : '',
+      forkedFromRunId: typeof session.forkedFromRunId === 'string' ? session.forkedFromRunId : '',
       pendingInputs: normalizePendingInputs(
         session.pendingInputs,
         options.restoreRunningRuns === true,
@@ -311,13 +310,14 @@
       id: active.id,
       history: Array.isArray(active.history) ? active.history.slice(-10) : [],
       focusFiles: normalizeFocusFiles(active.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(active.projectReferenceFiles),
       codexThreadId: active.codexThreadId || '',
       providerId: state.providerId || 'builtin'
     };
     state.runs = Array.isArray(active.runs) ? active.runs : [];
     state.task = typeof active.task === 'string' ? active.task : '';
     state.focusFiles = normalizeFocusFiles(active.focusFiles);
-    state.mode = VALID_MODES.has(active.mode) ? active.mode : DEFAULT_PANEL_STATE.mode;
+    state.mode = normalizeMode(active.mode);
     state.requireReviewing = active.requireReviewing !== false;
 
     return state;
@@ -339,7 +339,7 @@
       history: normalizeHistoryEntries(overrides.history),
       runs,
       task: sanitizeAssistantVisibleText(overrides.task),
-      mode: VALID_MODES.has(overrides.mode) ? overrides.mode : DEFAULT_PANEL_STATE.mode,
+      mode: normalizeMode(overrides.mode),
       providerId: typeof overrides.providerId === 'string' && overrides.providerId.trim()
         ? overrides.providerId.trim()
         : 'builtin',
@@ -352,7 +352,10 @@
         : DEFAULT_PANEL_STATE.speedTier,
       requireReviewing: overrides.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(overrides.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(overrides.projectReferenceFiles),
       codexThreadId: typeof overrides.codexThreadId === 'string' ? overrides.codexThreadId : '',
+      forkedFromSessionId: typeof overrides.forkedFromSessionId === 'string' ? overrides.forkedFromSessionId : '',
+      forkedFromRunId: typeof overrides.forkedFromRunId === 'string' ? overrides.forkedFromRunId : '',
       pendingInputs: normalizePendingInputs(overrides.pendingInputs)
     };
   }
@@ -638,6 +641,8 @@
       undoStatus: sanitizeAssistantVisibleText(run.undoStatus),
       nativeRequestId: sanitizeAssistantVisibleText(run.nativeRequestId),
       codexTurnId: sanitizeAssistantVisibleText(run.codexTurnId),
+      forkSnapshot: run.forkSnapshot === true,
+      forkSourceRunId: sanitizeAssistantVisibleText(run.forkSourceRunId),
       nativeEventSeq: Number.isFinite(Number(run.nativeEventSeq)) ? Number(run.nativeEventSeq) : 0,
       queueItemId: sanitizeAssistantVisibleText(run.queueItemId),
       interruptedDraft: run.interruptedDraft ? sanitizeAssistantVisibleValue(run.interruptedDraft) : undefined
@@ -904,6 +909,33 @@
     return files.slice(0, 5);
   }
 
+  function normalizeProjectReferenceFiles(value) {
+    const seen = new Set();
+    const files = [];
+    for (const item of Array.isArray(value) ? value : []) {
+      const rawPath = typeof item === 'string' ? item : item?.path;
+      if (typeof rawPath !== 'string' || !rawPath.trim() || rawPath.length > 512) {
+        continue;
+      }
+      if (/^(?:[A-Za-z]:|[\\/])/.test(rawPath) || rawPath.includes('\0')) {
+        continue;
+      }
+      const path = rawPath.replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\.\//, '').trim();
+      if (!path || path.split('/').some(segment => !segment || segment === '.' || segment === '..') || seen.has(path)) {
+        continue;
+      }
+      seen.add(path);
+      files.push({
+        path,
+        kind: item?.kind === 'binary' ? 'binary' : 'text'
+      });
+      if (files.length >= 5000) {
+        break;
+      }
+    }
+    return files;
+  }
+
   function normalizeCustomInstructionsByProject(value) {
     const result = {};
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -994,7 +1026,7 @@
       // Skills page was reopened.
       codexOverleafSkills: compactCodexOverleafSkillsForStorage(source.codexOverleafSkills),
       composerAttachments: normalizeComposerAttachmentsForPersistence(source.composerAttachments),
-      mode: VALID_MODES.has(active?.mode) ? active.mode : normalizeMode(source.mode),
+      mode: normalizeMode(active?.mode, source.mode),
       providerId: typeof source.providerId === 'string' && source.providerId.trim()
         ? source.providerId.trim()
         : 'builtin',
@@ -1092,7 +1124,10 @@
       speedTier: normalizeSpeedTier(session.speedTier || fallbackState.speedTier),
       requireReviewing: session.requireReviewing !== false,
       focusFiles: normalizeFocusFiles(session.focusFiles),
+      projectReferenceFiles: normalizeProjectReferenceFiles(session.projectReferenceFiles),
       codexThreadId: typeof session.codexThreadId === 'string' ? session.codexThreadId : '',
+      forkedFromSessionId: normalizeTextField(session.forkedFromSessionId, 160),
+      forkedFromRunId: normalizeTextField(session.forkedFromRunId, 160),
       pendingInputs: normalizePendingInputs(session.pendingInputs)
     };
     // Welcome-panel + write-guard: preserve the four
@@ -1185,6 +1220,8 @@
       undoStatus: summarizeTextForStorage(run.undoStatus, 'undo status'),
       nativeRequestId: normalizeTextField(run.nativeRequestId, 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,
       queueItemId: normalizeTextField(run.queueItemId, 160)
     };
@@ -1339,8 +1376,14 @@
     };
   }
 
-  function normalizeMode(mode) {
-    return VALID_MODES.has(mode) ? mode : DEFAULT_PANEL_STATE.mode;
+  function normalizeMode(mode, fallback = DEFAULT_PANEL_STATE.mode) {
+    if (mode === 'confirm') {
+      return 'ask';
+    }
+    if (VALID_MODES.has(mode)) {
+      return mode;
+    }
+    return VALID_MODES.has(fallback) ? fallback : DEFAULT_PANEL_STATE.mode;
   }
 
   function normalizeReasoning(reasoningEffort) {

package/extension/src/shared/storageDb.js

@@ -287,7 +287,7 @@
       history: compactHistoryForStorage(input.history),
       runs: compactRunsForStorage(input.runs, options),
       task: normalizeDisplayTextForStorage(input.task, SESSION_STORAGE_LIMITS.taskChars),
-      mode: typeof input.mode === 'string' ? input.mode : '', providerId: typeof input.providerId === 'string' && input.providerId ? input.providerId : 'builtin',
+      mode: normalizeCurrentMode(input.mode), providerId: typeof input.providerId === 'string' && input.providerId ? input.providerId : 'builtin',
       model: typeof input.model === 'string' ? input.model : '',
       reasoningEffort: typeof input.reasoningEffort === 'string' ? input.reasoningEffort : '',
       speedTier: typeof input.speedTier === 'string' ? input.speedTier : '',
@@ -435,6 +435,9 @@
   }
 
   // --- Helpers ---
+  function normalizeCurrentMode(mode) {
+    return mode === 'auto' ? 'auto' : 'ask';
+  }
 
   function extractLightweightPrefs(state, projectId) {
     var prefs = {
@@ -442,8 +445,9 @@
       model: typeof state.model === 'string' ? state.model : '',
       reasoningEffort: typeof state.reasoningEffort === 'string' ? state.reasoningEffort : '',
       speedTier: typeof state.speedTier === 'string' ? state.speedTier : '',
-      mode: typeof state.mode === 'string' ? state.mode : '',
+      mode: normalizeCurrentMode(state.mode),
       locale: typeof state.locale === 'string' ? state.locale : '',
+      theme: state.theme === 'light' || state.theme === 'auto' ? state.theme : 'dark',
       requireReviewing: state.requireReviewing !== false,
       autoRecompile: state.autoRecompile !== false,
       loadCodexLocalSkills: state.loadCodexLocalSkills !== false,
@@ -1314,11 +1318,9 @@
   }
 
   // --- Utilities ---
-
   function generateId(prefix) {
     return prefix + '_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8);
   }
-
   function safeJsonStringify(value) {
     try {
       return JSON.stringify(value) || '';
@@ -1326,7 +1328,6 @@
       return '[unserializable]';
     }
   }
-
   var hashString = StorageRunActions.hashString;
 
   return {

package/extension/src/shared/storageRunActions.js

@@ -38,8 +38,18 @@
       && Array.isArray(run.undoTrackedChanges) && run.undoTrackedChanges.length > 0
       && Array.isArray(run.undoExpectedFiles) && run.undoExpectedFiles.length > 0
       && Array.isArray(run.appliedOperations) && run.appliedOperations.length > 0;
+    // Overleaf can expose a working native editor-undo checkpoint before its
+    // Reviewing DOM markers are discoverable. Preserve that checkpoint too so
+    // a reload does not erase the only safe rollback path while the document
+    // still contains an unresolved tracked change.
+    var reviewingEditorUndo = trackedStatus !== 'accepted'
+      && trackedStatus !== 'rejected'
+      && run && run.undoStatus !== 'applied'
+      && run.executionSnapshot && run.executionSnapshot.requireReviewing === true
+      && Array.isArray(run.undoExpectedFiles) && run.undoExpectedFiles.length > 0
+      && Array.isArray(run.appliedOperations) && run.appliedOperations.length > 0;
     var legacyUndo = Array.isArray(run && run.undoOperations) && run.undoOperations.length > 0;
-    return trackedLifecycle || legacyUndo;
+    return trackedLifecycle || reviewingEditorUndo || legacyUndo;
   }
 
   function compactRunActionPayload(run, keepActionPayload) {

package/extension/src/shared/writebackOperationEvidence.js

@@ -114,12 +114,22 @@
   }
 
   function normalizeTrackedChanges(value) {
-    return (Array.isArray(value) ? value : []).map(item => ({
-      key: normalizeText(item?.key),
-      id: normalizeText(item?.id),
-      path: normalizeText(item?.path),
-      label: normalizeText(item?.label)
-    })).filter(item => item.key || item.id || item.path);
+    const normalized = [];
+    const seen = new Set();
+    for (const item of Array.isArray(value) ? value : []) {
+      const change = {
+        key: normalizeText(item?.key),
+        id: normalizeText(item?.id),
+        path: normalizeText(item?.path),
+        label: normalizeText(item?.label)
+      };
+      if (!change.key && !change.id && !change.path) continue;
+      const identity = `${change.path}\u0000${change.key || change.id || 'path-only'}`;
+      if (seen.has(identity)) continue;
+      seen.add(identity);
+      normalized.push(change);
+    }
+    return normalized;
   }
 
   function normalizeStringArray(value) {

package/extension/src/shared/writebackSettlement.js

@@ -270,9 +270,17 @@
     }
     const successful = isSuccessfulTrackedChangeSettlement(input.result);
     const reviewCodes = kind === 'accept' ? ACCEPT_NEEDS_REVIEW_CODES : REJECT_NEEDS_REVIEW_CODES;
-    const needsReview = !successful && failures.some(failure =>
+    // Reject/Undo is an all-target recovery transaction. A successful entry
+    // only proves that one tracked target was restored; any failed/skipped
+    // sibling can still leave this run's content in another file. Keep that
+    // recovery actionable instead of collapsing a partial multi-file reject
+    // into the terminal `rejected` state. Accept retains its established
+    // best-effort terminal policy.
+    const incompleteReject = kind === 'reject'
+      && collectRunResultSkipped(input.result).length > 0;
+    const needsReview = incompleteReject || (!successful && failures.some(failure =>
       failure.terminalState === 'needs_review' || reviewCodes.has(failure.code)
-    );
+    ));
     const status = needsReview ? 'needs_review' : kind === 'accept' ? 'accepted' : 'rejected';
     return {
       decision: status,
@@ -595,7 +603,12 @@
       : operation;
   }
 
-  function selectExpectedFilesForTrackedUndo(project, operations = [], trackedChanges = []) {
+  function selectExpectedFilesForTrackedUndo(
+    project,
+    operations = [],
+    trackedChanges = [],
+    previousExpectedFiles = []
+  ) {
     const paths = new Set();
     for (const change of trackedChanges || []) {
       if (change?.path) paths.add(change.path);
@@ -604,9 +617,18 @@
       if (operation?.path) paths.add(operation.path);
       if (operation?.to) paths.add(operation.to);
     }
-    return (project?.files || [])
-      .filter(file => paths.has(file.path) && typeof file.content === 'string')
-      .map(file => ({ path: file.path, content: file.content }));
+    const expectedByPath = new Map();
+    for (const file of previousExpectedFiles || []) {
+      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
+        expectedByPath.set(file.path, { path: file.path, content: file.content });
+      }
+    }
+    for (const file of project?.files || []) {
+      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
+        expectedByPath.set(file.path, { path: file.path, content: file.content });
+      }
+    }
+    return Array.from(expectedByPath.values());
   }
 
   function acceptDiagnosticStatus(step, info) {

package/extension/styles/panel.css

@@ -2359,6 +2359,67 @@
   margin-left: auto;
 }
 
+#codex-overleaf-panel .run-result-actions {
+  display: flex;
+  justify-content: flex-start;
+  align-items: center;
+  gap: 2px;
+  min-height: 30px;
+  margin: 10px 0 0;
+}
+
+#codex-overleaf-panel .run-result-actions[hidden] { display: none; }
+
+#codex-overleaf-panel .run-copy-action,
+#codex-overleaf-panel .run-fork-action {
+  display: inline-grid;
+  place-items: center;
+  width: 30px;
+  height: 30px;
+  border: 0;
+  border-radius: 999px;
+  background: transparent;
+  color: var(--tl-fg-4);
+  opacity: 1;
+  transition: color 120ms ease, background 120ms ease, opacity 120ms ease;
+}
+
+#codex-overleaf-panel .run-copy-action:hover:not(:disabled),
+#codex-overleaf-panel .run-fork-action:hover:not(:disabled) {
+  background: var(--tl-hover);
+  color: var(--tl-accent);
+}
+
+#codex-overleaf-panel .run-copy-action:disabled,
+#codex-overleaf-panel .run-fork-action:disabled {
+  cursor: not-allowed;
+  opacity: 0.38;
+}
+
+#codex-overleaf-panel .run-copy-action svg,
+#codex-overleaf-panel .run-fork-action svg {
+  width: 16px;
+  height: 16px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.7;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
+#codex-overleaf-panel .run-copy-action[hidden],
+#codex-overleaf-panel .run-fork-action[hidden] { display: none; }
+
+#codex-overleaf-panel .run-completed-time {
+  margin-left: 5px;
+  color: var(--tl-fg-4);
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+  line-height: 30px;
+}
+
+#codex-overleaf-panel .run-completed-time[hidden] { display: none; }
+
 /* When Accept All is hidden, the Undo button takes the right-aligned slot. */
 #codex-overleaf-panel .run-turn-meta [data-run-accept][hidden] + [data-run-undo] {
   margin-left: auto;
@@ -2686,13 +2747,23 @@
 }
 
 #codex-overleaf-panel .run-math--fallback {
-  border-radius: 4px;
-  background: var(--tl-surface-2);
-  color: var(--tl-review);
-  padding: 1px 4px;
+  border-bottom: 1px dotted var(--tl-fg-4);
+  border-radius: 0;
+  background: transparent;
+  color: inherit;
+  padding: 0 2px;
   white-space: pre-wrap;
   overflow-wrap: anywhere;
-  font: 0.96em/1.4 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font: inherit;
+}
+
+#codex-overleaf-panel .run-math--display.run-math--fallback {
+  border: 1px solid var(--tl-border);
+  border-left: 3px solid var(--tl-fg-4);
+  border-radius: 6px;
+  background: var(--tl-surface-2);
+  padding: 8px 10px;
+  text-align: left;
 }
 
 #codex-overleaf-panel .run-stream[data-stream-role="reasoning"] .run-stream-text {
@@ -3173,12 +3244,12 @@
   white-space: nowrap;
 }
 
-/* Mode switch (Ask/Suggest/Auto) — a real segmented control: a bordered track
-   holding three choices. Inactive choices are muted; hover is a light fill
+/* Mode switch (Ask/Auto) — a real segmented control: a bordered track
+   holding two choices. Inactive choices are muted; hover is a light fill
    (distinct from the active accent-wash fill) so hover never reads as active. */
 #codex-overleaf-panel .codex-mode-switch {
   display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
+  grid-template-columns: repeat(2, minmax(0, 1fr));
   gap: 2px;
   min-width: 0;
   padding: 2px;

package/native-host/src/codexModels.js

@@ -181,7 +181,7 @@ function buildModelEntry({
   defaultSpeedTier = 'standard'
 }) {
   const normalizedEfforts = normalizeReasoningEfforts(reasoningEfforts);
-  const normalizedDefault = getString(defaultReasoningEffort) || 'medium';
+  const normalizedDefault = normalizeReasoningEffort(defaultReasoningEffort) || 'medium';
   const normalizedSpeedTiers = normalizeSpeedTiers(speedTiers);
   const normalizedDefaultSpeedTier = getString(defaultSpeedTier) || 'standard';
   return {
@@ -202,7 +202,7 @@ function normalizeReasoningEfforts(rawEfforts) {
   const seen = new Set();
   const result = [];
   for (const rawEffort of rawEfforts) {
-    const effort = getString(typeof rawEffort === 'string' ? rawEffort : rawEffort?.effort);
+    const effort = normalizeReasoningEffort(typeof rawEffort === 'string' ? rawEffort : rawEffort?.effort);
     if (!effort || seen.has(effort)) {
       continue;
     }
@@ -212,6 +212,10 @@ function normalizeReasoningEfforts(rawEfforts) {
   return result;
 }
 
+function normalizeReasoningEffort(rawEffort) {
+  return getString(rawEffort);
+}
+
 function normalizeSpeedTiers(rawTiers) {
   const tiers = ['standard'];
   if (!Array.isArray(rawTiers)) {

package/native-host/src/codexPromptAssembly.js

@@ -64,7 +64,7 @@ function buildCodexTurnPrompt(options = {}) {
     'Mode for this turn:',
     `- ${context.mode}`,
     '- ask: inspect and explain only; do not edit files.',
-    '- confirm/auto: edit the local workspace directly when the request calls for changes. The browser bridge handles review, confirmation, deletion approval, and syncing back to Overleaf.',
+    '- auto: edit the local workspace directly when the request calls for changes. The browser bridge handles authorization, deletion approval, and syncing back to Overleaf.',
     '',
     'Write expectation for this turn:',
     formatWriteExpectation({

package/native-host/src/codexSessionRunner.js

@@ -22,6 +22,7 @@ const {
   loadSelectedProjectSkills
 } = require('./localSkills');
 const { createSubagentBroker } = require('./subagentBroker');
+const { prepareBinaryAssetChanges } = require('./nativeAssetTransfer');
 const { resolveCodexCommand, shouldUseShellForCommand } = require('./codexCommand');
 const { applyProviderEnvironment, buildProviderConfigArgs, prepareProviderLaunch } = require('./codexProviderLaunch');
 const { buildReadProgressRules, createReadProgressController } = require('./readProgressGuard');
@@ -259,6 +260,9 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
     });
   }
 
+  const preparedAssets = prepareBinaryAssetChanges({ projectId, rootDir, changes: rawSyncChanges });
+  rawSyncChanges = preparedAssets.changes;
+  unsupportedChanges.push(...preparedAssets.unsupportedChanges);
   const syncChanges = rawSyncChanges.map(change => {
     if (change.type === 'write' && typeof change.previousContent === 'string') {
       return {
@@ -1461,7 +1465,7 @@ function extractCodexAppServerErrorMessage(params = {}) {
 }
 
 function normalizeReasoningEffort(value) {
-  return ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'].includes(value) ? value : null;
+  return ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(value) ? value : null;
 }
 
 function normalizeSpeedTier(value) {

package/native-host/src/codexThreadFork.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const { version: PACKAGE_VERSION } = require('../../package.json');
+const { buildCodexHomeEnv } = require('./codexHome');
+const { resolveCodexCommand, shouldUseShellForCommand } = require('./codexCommand');
+const { buildCodexAppServerArgs } = require('./codexSessionRunner');
+
+function forkCodexThread(params = {}, env = process.env) {
+  const threadId = cleanId(params.threadId, 'threadId');
+  const lastTurnId = cleanId(params.lastTurnId, 'lastTurnId');
+  const childEnv = buildCodexHomeEnv(env, {
+    loadCodexLocalSkills: params.loadCodexLocalSkills !== false,
+    loadCodexOverleafSkills: params.loadCodexOverleafSkills !== false
+  });
+  const command = resolveCodexCommand(childEnv);
+  if (!command) return Promise.reject(codedError('codex_not_found', 'Codex CLI was not found.'));
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, buildCodexAppServerArgs({
+      speedTier: params.speedTier || 'standard',
+      loadCodexLocalSkills: params.loadCodexLocalSkills !== false
+    }), {
+      env: childEnv,
+      shell: shouldUseShellForCommand(command, childEnv),
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const pending = new Map();
+    let nextId = 1;
+    let buffer = '';
+    let stderr = '';
+    let settled = false;
+    const timeout = setTimeout(() => finish(codedError('codex_thread_fork_timeout', 'Codex thread fork timed out.')), 30000);
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => {
+      buffer += chunk;
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || '';
+      for (const line of lines) if (line.trim()) handleMessage(line);
+    });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('error', finish);
+    child.on('close', code => {
+      if (!settled) finish(codedError('codex_thread_fork_failed', stderr || `Codex app-server exited with code ${code}.`));
+    });
+
+    (async () => {
+      await request('initialize', {
+        clientInfo: { name: 'codex-overleaf-link', version: PACKAGE_VERSION },
+        capabilities: null
+      });
+      notify('initialized');
+      const result = await request('thread/fork', { threadId, lastTurnId });
+      const forkedThreadId = result?.thread?.id || result?.threadId || '';
+      if (!forkedThreadId || forkedThreadId === threadId) {
+        throw codedError('codex_thread_fork_invalid_response', 'Codex app-server did not return a new thread id.');
+      }
+      finish(null, { threadId: forkedThreadId, sourceThreadId: threadId, lastTurnId });
+    })().catch(finish);
+
+    function request(method, requestParams) {
+      const id = nextId++;
+      child.stdin.write(`${JSON.stringify({ id, method, params: requestParams })}\n`);
+      return new Promise((resolveRequest, rejectRequest) => pending.set(id, { resolve: resolveRequest, reject: rejectRequest }));
+    }
+    function notify(method, requestParams) {
+      child.stdin.write(`${JSON.stringify({ method, params: requestParams })}\n`);
+    }
+    function handleMessage(line) {
+      let message;
+      try { message = JSON.parse(line); } catch (_error) { return; }
+      if (Object.prototype.hasOwnProperty.call(message, 'id') && (message.result !== undefined || message.error)) {
+        const waiter = pending.get(message.id);
+        if (!waiter) return;
+        pending.delete(message.id);
+        if (message.error) waiter.reject(codedError('codex_thread_fork_failed', message.error.message || JSON.stringify(message.error)));
+        else waiter.resolve(message.result);
+      } else if (Object.prototype.hasOwnProperty.call(message, 'id') && message.method) {
+        child.stdin.write(`${JSON.stringify({ id: message.id, error: { code: -32601, message: 'Unsupported during thread fork' } })}\n`);
+      }
+    }
+    function finish(error, result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      for (const waiter of pending.values()) waiter.reject(error || codedError('codex_thread_fork_closed', 'Fork process closed.'));
+      pending.clear();
+      try { child.stdin.end(); } catch (_error) { /* best effort */ }
+      try { child.kill(); } catch (_error) { /* best effort */ }
+      if (error) reject(error); else resolve(result);
+    }
+  });
+}
+
+function cleanId(value, field) {
+  const id = String(value || '').trim();
+  if (!id || id.length > 160) throw codedError('codex_thread_fork_invalid', `${field} is required.`);
+  return id;
+}
+function codedError(code, message) { const error = new Error(message); error.code = code; return error; }
+module.exports = { forkCodexThread };

package/native-host/src/mirrorWorkspace.js

@@ -152,34 +152,19 @@ async function collectMirrorChangesDetailed({ projectId, rootDir }) {
         if (hashBytes(bytes) === previous.hash) {
           continue;
         }
-        if (stat.size > SAFE_INLINE_BINARY_CHANGE_BYTES) {
-          unsupportedChanges.push(buildOversizedBinaryPayloadChange({
-            filePath,
-            size: stat.size,
-            previous
-          }));
-          continue;
-        }
         currentByPath.set(filePath, {
           binary: true,
-          bytes,
+          sha256: hashBytes(bytes),
           size: stat.size,
           previous
         });
         continue;
       }
       if (!previous) {
-        if (stat.size > SAFE_INLINE_BINARY_CHANGE_BYTES) {
-          unsupportedChanges.push(buildOversizedBinaryPayloadChange({
-            filePath,
-            size: stat.size,
-            previous
-          }));
-          continue;
-        }
+        const bytes = fs.readFileSync(target);
         currentByPath.set(filePath, {
           binary: true,
-          bytes: fs.readFileSync(target),
+          sha256: hashBytes(bytes),
           size: stat.size,
           previous
         });
@@ -218,7 +203,8 @@ async function collectMirrorChangesDetailed({ projectId, rootDir }) {
       changes.push({
         type: previous ? 'overwrite-binary' : 'binary-create',
         path: filePath,
-        contentBase64: contentOrBinary.bytes.toString('base64'),
+        assetSourcePath: filePath,
+        sha256: contentOrBinary.sha256,
         previousExists: Boolean(previous),
         previousKind: previous?.kind || '',
         previousSize: previous?.size,