codex-overleaf-link 2.3.1 → 2.3.3

package/extension/styles/panel.css

@@ -177,19 +177,51 @@
   --provider-muted: #a0a59f;
   --provider-accent: #79d58a;
   --provider-danger: #ef8176;
+  --provider-text: var(--provider-panel-color, #eef0ec);
+  --provider-field-label: #dfe3dd;
+  --provider-control-bg: rgba(255, 255, 255, 0.035);
+  --provider-hover: rgba(255, 255, 255, 0.07);
+  --provider-sidebar-bg: rgba(0, 0, 0, 0.09);
+  --provider-footer-bg: rgba(0, 0, 0, 0.08);
+  --provider-select-bg: rgba(7, 12, 10, 0.58);
+  --provider-backdrop: rgba(4, 7, 5, 0.68);
+  --provider-glow: rgba(83, 177, 105, 0.13);
+  --provider-shadow: 0 28px 80px rgba(0, 0, 0, 0.48);
+  --provider-disabled-opacity: 0.5;
   position: fixed;
   inset: 0;
   z-index: 2147483600;
-  color: var(--provider-panel-color, #eef0ec);
+  color: var(--provider-text);
   font-family: "Aptos", "SF Pro Text", sans-serif;
 }
 
+.codex-provider-dialog-root[data-theme="light"] {
+  --provider-bg: #f4f6f7;
+  --provider-surface: #ffffff;
+  --provider-surface-raised: #e9edf0;
+  --provider-line: rgba(31, 35, 40, 0.16);
+  --provider-muted: #5f6873;
+  --provider-accent: #247d3b;
+  --provider-danger: #bd352f;
+  --provider-text: #252a30;
+  --provider-field-label: #343b44;
+  --provider-control-bg: #ffffff;
+  --provider-hover: rgba(31, 35, 40, 0.065);
+  --provider-sidebar-bg: #e8ebee;
+  --provider-footer-bg: #eceff1;
+  --provider-select-bg: #ffffff;
+  --provider-backdrop: rgba(31, 35, 40, 0.38);
+  --provider-glow: rgba(53, 139, 74, 0.09);
+  --provider-shadow: 0 24px 64px rgba(31, 35, 40, 0.24);
+  --provider-disabled-opacity: 0.68;
+}
+
 .codex-provider-dialog-root[hidden] { display: none !important; }
 
 .codex-provider-dialog-backdrop {
   position: absolute;
   inset: 0;
-  background: rgba(4, 7, 5, 0.68);
+  background: var(--provider-backdrop);
   backdrop-filter: blur(3px);
 }
 
@@ -207,9 +239,9 @@
   border: 1px solid var(--provider-line);
   border-radius: 16px;
   background:
-    radial-gradient(circle at 92% -8%, rgba(83, 177, 105, 0.13), transparent 34%),
+    radial-gradient(circle at 92% -8%, var(--provider-glow), transparent 34%),
     var(--provider-bg);
-  box-shadow: 0 28px 80px rgba(0, 0, 0, 0.48);
+  box-shadow: var(--provider-shadow);
 }
 
 .codex-provider-dialog-head,
@@ -259,7 +291,7 @@
   cursor: pointer;
 }
 
-.codex-provider-dialog-close:hover { background: rgba(255, 255, 255, 0.07); color: inherit; }
+.codex-provider-dialog-close:hover { background: var(--provider-hover); color: inherit; }
 
 .codex-provider-dialog-body {
   min-height: 0;
@@ -273,7 +305,7 @@
   padding: 14px 10px;
   overflow: auto;
   border-right: 1px solid var(--provider-line);
-  background: rgba(0, 0, 0, 0.09);
+  background: var(--provider-sidebar-bg);
 }
 
 .codex-provider-row,
@@ -297,7 +329,7 @@
 }
 
 .codex-provider-row:hover,
-.codex-provider-row[aria-current="true"] { background: rgba(255, 255, 255, 0.07); }
+.codex-provider-row[aria-current="true"] { background: var(--provider-hover); }
 .codex-provider-row[aria-current="true"] { box-shadow: inset 2px 0 var(--provider-accent); }
 .codex-provider-row-main { display: block; width: 100%; min-width: 0; overflow: hidden; text-overflow: ellipsis; font-size: 13px; font-weight: 650; white-space: nowrap; }
 .codex-provider-row-status { color: var(--provider-muted); font-size: 11px; }
@@ -341,7 +373,7 @@
   display: flex;
   flex-direction: column;
   gap: 7px;
-  color: #dfe3dd;
+  color: var(--provider-field-label);
   font-size: 12px;
   font-weight: 650;
 }
@@ -358,7 +390,7 @@
   border: 1px solid var(--provider-line);
   border-radius: 8px;
   outline: 0;
-  background: rgba(255, 255, 255, 0.035);
+  background: var(--provider-control-bg);
   color: inherit;
   font: inherit;
   font-weight: 450;
@@ -438,7 +470,7 @@
   border-radius: 9px;
   appearance: none;
   -webkit-appearance: none;
-  background: rgba(7, 12, 10, 0.58);
+  background: var(--provider-select-bg);
   color: var(--provider-text);
   color-scheme: dark;
   font: inherit;
@@ -506,7 +538,7 @@
   padding-bottom: 14px;
   border-top: 1px solid var(--provider-line);
   border-bottom: 0;
-  background: rgba(0, 0, 0, 0.08);
+  background: var(--provider-footer-bg);
 }
 
 .codex-provider-operation-status { min-width: 0; color: var(--provider-muted); font-size: 11px; }
@@ -524,7 +556,7 @@
   padding: 0 13px;
   border: 1px solid var(--provider-line);
   border-radius: 8px;
-  background: rgba(255, 255, 255, 0.04);
+  background: var(--provider-control-bg);
   color: inherit;
   font: inherit;
   font-size: 12px;
@@ -544,7 +576,7 @@
 }
 .codex-provider-secondary-button[data-provider-action="save"]:disabled {
   border-color: var(--provider-line);
-  background: rgba(255, 255, 255, 0.04);
+  background: var(--provider-control-bg);
   color: var(--provider-muted);
   box-shadow: none;
 }
@@ -553,7 +585,22 @@
 .codex-provider-dialog-root button:disabled,
 .codex-provider-dialog-root input:disabled,
 .codex-provider-dialog-root select:disabled,
-.codex-provider-dialog-root textarea:disabled { cursor: not-allowed; opacity: 0.5; }
+.codex-provider-dialog-root textarea:disabled { cursor: not-allowed; opacity: var(--provider-disabled-opacity); }
+
+.codex-provider-dialog-root[data-theme="light"] .codex-provider-experimental-badge {
+  border-color: rgba(148, 102, 8, 0.34);
+  background: rgba(148, 102, 8, 0.08);
+  color: #855d09;
+}
+
+.codex-provider-dialog-root[data-theme="light"] .codex-provider-test-select-shell select {
+  color-scheme: light;
+}
+
+.codex-provider-dialog-root[data-theme="light"] .codex-provider-disclosure {
+  background: rgba(148, 102, 8, 0.08);
+  color: #72500b;
+}
 
 .codex-provider-builtin { max-width: 430px; padding-top: 34px; }
 .codex-provider-builtin-mark { display: grid; place-items: center; width: 48px; height: 48px; margin-bottom: 18px; border-radius: 14px; background: linear-gradient(145deg, #3f8d51, #255932); color: #fff; font-size: 21px; font-weight: 800; }
@@ -2359,6 +2406,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;
@@ -2888,6 +2996,62 @@
   font-weight: 600;
 }
 
+#codex-overleaf-panel .run-final-answer .run-system-label {
+  color: var(--tl-accent);
+  font-weight: 650;
+  letter-spacing: 0.01em;
+}
+
+#codex-overleaf-panel .run-completion-report[data-status="failed"] .run-system-label[data-system-label="conclusion"] {
+  color: var(--tl-fail);
+}
+
+#codex-overleaf-panel .run-final-answer .run-change-summary {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin: 7px 0 8px;
+  color: var(--tl-ok);
+  font-size: 12px;
+}
+
+#codex-overleaf-panel .run-final-answer .run-change-summary__check {
+  font-weight: 650;
+}
+
+#codex-overleaf-panel .run-final-answer .run-change-receipts {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px 13px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+#codex-overleaf-panel .run-final-answer .run-change-receipt {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.32em;
+  margin: 0;
+  min-width: 0;
+}
+
+#codex-overleaf-panel .run-final-answer .run-change-receipt + .run-change-receipt {
+  margin-top: 0;
+}
+
+#codex-overleaf-panel .run-final-answer .run-change-receipt__file {
+  color: var(--tl-fg-1);
+  font: 600 0.94em/1.4 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  overflow-wrap: anywhere;
+}
+
+#codex-overleaf-panel .run-final-answer .run-change-receipt__operation {
+  color: var(--tl-fg-3);
+  font-size: 0.88em;
+}
+
 #codex-overleaf-panel .run-final-answer p + p,
 #codex-overleaf-panel .run-final-answer p + ul,
 #codex-overleaf-panel .run-final-answer p + ol,
@@ -3728,8 +3892,10 @@
 
 #codex-overleaf-panel .codex-pending-inputs {
   display: grid;
-  gap: 6px;
-  padding: 0 6px 7px;
+  gap: 0;
+  margin: 0 6px 7px;
+  padding: 7px 4px 0;
+  border-top: 1px solid var(--tl-border);
 }
 
 #codex-overleaf-panel .codex-pending-inputs[hidden] {
@@ -3738,38 +3904,56 @@
 
 #codex-overleaf-panel .codex-pending-input {
   display: grid;
-  grid-template-columns: minmax(0, 1fr) auto;
+  grid-template-columns: 20px minmax(0, 1fr) auto;
   align-items: center;
-  gap: 8px;
+  gap: 7px;
   min-width: 0;
-  padding: 8px 9px;
-  border: 1px solid var(--tl-border);
-  border-radius: 9px;
-  background: color-mix(in srgb, var(--tl-surface-1) 86%, var(--tl-accent) 14%);
+  padding: 8px 5px;
+  border-top: 1px solid var(--tl-border);
+  background: transparent;
+}
+
+#codex-overleaf-panel .codex-pending-input:first-of-type {
+  border-top: 0;
+}
+
+#codex-overleaf-panel .codex-pending-input:hover,
+#codex-overleaf-panel .codex-pending-input:focus-within {
+  border-radius: 8px;
+  background: var(--tl-hover);
+}
+
+#codex-overleaf-panel .codex-pending-input-marker {
+  display: inline-grid;
+  place-items: center;
+  color: var(--tl-fg-3);
+}
+
+#codex-overleaf-panel .codex-pending-input[data-status="paused"] .codex-pending-input-marker {
+  color: var(--tl-warn);
 }
 
-#codex-overleaf-panel .codex-pending-input[data-status="paused"] {
-  background: color-mix(in srgb, var(--tl-surface-1) 90%, var(--tl-warn) 10%);
+#codex-overleaf-panel .codex-pending-input[data-status="steering"] .codex-pending-input-marker,
+#codex-overleaf-panel .codex-pending-input[data-status="executing"] .codex-pending-input-marker {
+  color: var(--tl-accent);
 }
 
 #codex-overleaf-panel .codex-pending-input-copy {
   display: grid;
   min-width: 0;
-  gap: 2px;
+  gap: 3px;
 }
 
 #codex-overleaf-panel .codex-pending-input-status {
   color: var(--tl-fg-3);
-  font-size: 10px;
-  font-weight: 700;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
+  font-size: 10.5px;
+  font-weight: 500;
 }
 
 #codex-overleaf-panel .codex-pending-input-text {
   color: var(--tl-fg-1);
-  font-size: 12px;
-  line-height: 1.35;
+  font-size: 13px;
+  line-height: 1.4;
   overflow-wrap: anywhere;
   white-space: pre-wrap;
 }
@@ -3777,6 +3961,13 @@
 #codex-overleaf-panel .codex-pending-input-actions {
   display: inline-flex;
   gap: 4px;
+  color: var(--tl-fg-3);
+  opacity: 0.72;
+}
+
+#codex-overleaf-panel .codex-pending-input:hover .codex-pending-input-actions,
+#codex-overleaf-panel .codex-pending-input:focus-within .codex-pending-input-actions {
+  opacity: 1;
 }
 
 #codex-overleaf-panel .codex-pending-input-actions button {
@@ -3818,6 +4009,16 @@
   stroke-linejoin: round;
 }
 
+#codex-overleaf-panel .codex-pending-input-marker svg {
+  width: 15px;
+  height: 15px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.55;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
 #codex-overleaf-panel .codex-pending-input-icon[data-action="guide"]:hover {
   color: var(--tl-accent);
 }

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/codexRuntimeIdentity.js

@@ -22,24 +22,99 @@ function buildCodexRuntimeIdentity(options = {}) {
   const candidatePaths = selectedPath
     ? [selectedPath, ...discovered.filter(candidate => !sameExecutablePath(candidate, selectedPath, platform))]
     : discovered;
-  const candidates = candidatePaths.slice(0, MAX_CODEX_CANDIDATES).map((candidatePath, index) => ({
+  const candidates = candidatePaths.slice(0, MAX_CODEX_CANDIDATES).map(candidatePath => ({
     path: candidatePath,
     displayPath: compactHomePath(candidatePath, env, platform),
     version: readCodexVersion(candidatePath, { env, platform }),
     source: classifyCodexSource(candidatePath),
-    selected: index === 0 && Boolean(selectedPath)
+    selected: false
   }));
-  const selected = candidates.find(candidate => candidate.selected) || null;
+  const selectedIndex = selectCodexCandidateIndex(candidates, {
+    selectedPath,
+    selectionPolicy: options.selectionPolicy,
+    platform
+  });
+  if (selectedIndex >= 0) {
+    candidates[selectedIndex].selected = true;
+  }
+  const selected = selectedIndex >= 0 ? candidates[selectedIndex] : null;
 
   return {
     schemaVersion: 1,
     selected,
     candidates,
     multipleInstallations: candidates.length > 1,
-    selectedBy: selected ? 'path-order' : 'not-found'
+    selectedBy: selected
+      ? options.selectionPolicy === 'newest-version' ? 'newest-version' : options.selectionPolicy === 'explicit-path' ? 'explicit-path' : 'path-order'
+      : 'not-found'
   };
 }
 
+function selectCodexCandidateIndex(candidates, options = {}) {
+  if (!candidates.length) return -1;
+  if (options.selectionPolicy !== 'newest-version') {
+    if (!options.selectedPath) return -1;
+    return candidates.findIndex(candidate => sameExecutablePath(
+      candidate.path,
+      options.selectedPath,
+      options.platform
+    ));
+  }
+
+  let selectedIndex = 0;
+  for (let index = 1; index < candidates.length; index += 1) {
+    if (compareCodexVersions(candidates[index].version, candidates[selectedIndex].version) > 0) {
+      selectedIndex = index;
+    }
+  }
+  return selectedIndex;
+}
+
+function compareCodexVersions(left, right) {
+  const leftVersion = parseCodexVersion(left);
+  const rightVersion = parseCodexVersion(right);
+  if (!leftVersion && !rightVersion) return 0;
+  if (!leftVersion) return -1;
+  if (!rightVersion) return 1;
+
+  for (let index = 0; index < 3; index += 1) {
+    if (leftVersion.core[index] !== rightVersion.core[index]) {
+      return leftVersion.core[index] - rightVersion.core[index];
+    }
+  }
+  if (!leftVersion.prerelease && rightVersion.prerelease) return 1;
+  if (leftVersion.prerelease && !rightVersion.prerelease) return -1;
+  if (!leftVersion.prerelease && !rightVersion.prerelease) return 0;
+  return comparePrerelease(leftVersion.prerelease, rightVersion.prerelease);
+}
+
+function parseCodexVersion(value) {
+  const match = String(value || '').trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?/);
+  if (!match) return null;
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4] || ''
+  };
+}
+
+function comparePrerelease(left, right) {
+  const leftParts = left.split('.');
+  const rightParts = right.split('.');
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    if (leftParts[index] === undefined) return -1;
+    if (rightParts[index] === undefined) return 1;
+    if (leftParts[index] === rightParts[index]) continue;
+    const leftNumber = /^\d+$/.test(leftParts[index]) ? Number(leftParts[index]) : null;
+    const rightNumber = /^\d+$/.test(rightParts[index]) ? Number(rightParts[index]) : null;
+    if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber;
+    if (leftNumber !== null) return -1;
+    if (rightNumber !== null) return 1;
+    return leftParts[index].localeCompare(rightParts[index]);
+  }
+  return 0;
+}
+
 function discoverCodexCandidates(pathValue, options = {}) {
   const platform = options.platform || process.platform;
   const delimiter = options.delimiter || (platform === 'win32' ? ';' : path.delimiter);

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