codex-overleaf-link 2.5.0 → 2.5.1

package/native-host/src/codexSessionRunner.js

@@ -7,10 +7,12 @@ const { version: PACKAGE_VERSION } = require('../../package.json');
 const { SUBAGENT_QUEUE_DIR, collectMirrorChangesDetailed, getProjectMirror, markMirrorDirty, syncOverleafToMirror } = require('./mirrorWorkspace');
 const { computeLineDiff } = require('./diffEngine');
 const { prepareSelectionScope, filterSelectionChanges } = require('./selectionScope');
+const { normalizeSafeProjectPath } = require('../../extension/src/shared/projectFiles');
 const WritingStyleRuntime = require('./writingStyleRuntime');
 const { createRecoveringStyleRunner } = require('./codexModelRecovery');
 const { computeTextPatches } = require('./textPatch');
 const { buildCodexHomeEnv } = require('./codexHome');
+const { applyCodexSkillIsolation } = require('./codexSkillIsolation');
 const { buildCodexSpeedArgs } = require('./codexArgs');
 const { truncateText } = require('./debugLog');
 const {
@@ -31,6 +33,7 @@ const { applyProviderEnvironment, buildProviderConfigArgs, prepareProviderLaunch
 const { buildReadProgressRules, createReadProgressController, createRunEventScope } = require('./readProgressGuard');
 const {
   createCodexIdleWatchdog,
+  createProcessStopIdentity,
   createOptionalTimeout,
   getAbortReason,
   parseOptionalPositiveInteger,
@@ -43,13 +46,13 @@ const PARALLEL_SUBAGENTS_SKILL_ID = 'parallel-subagents';
 
 const { materializeTurnAttachments } = require('./turnAttachments');
 
-async function runCodexSession({ params = {}, env = process.env, emit = () => {}, rootDir, executeCodex, providerLaunch, signal, onControlReady, onStopUnconfirmed } = {}) {
+async function runCodexSession({ params = {}, env = process.env, emit = () => {}, rootDir, executeCodex, providerLaunch, signal, onControlReady, onStopUnconfirmed, onProcessStarted } = {}) {
   throwIfAborted(signal);
   if (params.writingStyleBuild) {
     return WritingStyleRuntime.build({
       params, env, signal, providerLaunch, onControlReady, onStopUnconfirmed,
       execute: createRecoveringStyleRunner({
-        execute: executeCodex || runCodexAppServerSession,
+        execute: input => (executeCodex || runCodexAppServerSession)({ ...input, onProcessStarted }),
         env, emit, locale: params.locale
       })
     });
@@ -81,15 +84,20 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
     });
     throwIfAborted(signal);
 
-    emitCodexEvent(emit, 'overleaf.sync.completed', 'Overleaf project synced to local workspace', {
+    emitCodexEvent(emit, 'overleaf.sync.completed', mirror.skippedFiles?.length
+      ? 'Readable Overleaf files synced; some asset contents are unavailable'
+      : 'Overleaf project synced to local workspace', {
       projectId: mirror.projectKey,
       workspacePath: mirror.workspacePath,
-      fileCount: mirror.fileCount
+      fileCount: mirror.fileCount,
+      contentComplete: mirror.contentComplete !== false,
+      skippedFiles: mirror.skippedFiles || []
     }, 'completed');
   }
-
   if (skillInstallTurn && params.selectionContext) throw new Error('Remove the selected text before installing skills.');
   const selectionScope = prepareSelectionScope(params.selectionContext, mirror.workspacePath, projectId);
+  if (selectionScope?.rebased) emitCodexEvent(emit, 'overleaf.selection.rebased', 'The unchanged selection was mapped to the current document.',
+    { path: selectionScope.selection.path, from: selectionScope.selection.from, to: selectionScope.selection.to, original: selectionScope.original }, 'info');
   const projectLocalSkills = loadProjectLocalSkillsContext(params, mirror);
   if (projectLocalSkills.missing.length) {
     emitCodexEvent(emit, 'codex.local_skills.missing', 'Selected project-local skills were missing', {
@@ -99,12 +107,15 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
   const turnAttachments = materializeTurnAttachments(params.attachments, mirror.workspacePath);
   const settings = buildCodexSettings(params);
   const skillLoading = normalizeSkillLoadingSettings(params);
-  const codexSkillInvocationContext = loadCodexSkillInvocationContext({
+  const codexSkillInvocationContext = await loadCodexSkillInvocationContext({
     skillInvocation,
+    loadCodexLocalSkills: skillLoading.loadCodexLocalSkills,
+    enabledCodexLocalSkillIds: params.enabledCodexLocalSkillIds,
     loadCodexOverleafSkills: skillLoading.loadCodexOverleafSkills,
     enabledCodexOverleafSkillIds: params.enabledCodexOverleafSkillIds,
     env,
-    emit
+    emit,
+    signal
   });
   const effectiveSkillInvocation = getEffectiveSkillInvocation(codexSkillInvocationContext);
   const runnerWorkspacePath = skillInstallTurn
@@ -116,7 +127,7 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
   const execute = executeCodex || runCodexAppServerSession;
   let unconfirmedStopError = null;
   const runner = async input => {
-    try { return await execute(input); }
+    try { return await execute({ ...input, onProcessStarted }); }
     catch (error) {
       if (error?.code === 'codex_process_stop_unconfirmed') {
         unconfirmedStopError = error;
@@ -125,11 +136,12 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
       throw error;
     }
   };
-  // Parallel-subagents broker (v1.6): activated solely by the official skill
-  // being enabled for this run. Workers are sibling Codex runs spawned by the
+  // The file broker is available only to writable runs with the official
+  // skill enabled. Ask keeps its existing read-only sandbox. Workers are sibling Codex runs spawned by the
   // host (fresh sandbox — never nested), confined to the same mirror; the
   // broker enforces file ownership and wall-clock deadlines (spec §5-§7).
   const subagentBroker = !skillInstallTurn
+    && settings.sandboxMode === 'workspace-write'
     && skillLoading.loadCodexOverleafSkills !== false
     && Array.isArray(params.enabledCodexOverleafSkillIds)
     && params.enabledCodexOverleafSkillIds.includes(PARALLEL_SUBAGENTS_SKILL_ID)
@@ -150,6 +162,8 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
         speedTier: normalizeSpeedTier(params.speedTier),
         loadCodexLocalSkills: skillLoading.loadCodexLocalSkills,
         loadCodexOverleafSkills: skillLoading.loadCodexOverleafSkills,
+        enabledCodexOverleafSkillIds: params.enabledCodexOverleafSkillIds,
+        enabledCodexLocalSkillIds: params.enabledCodexLocalSkillIds,
         skillInvocation: null,
         installCodexOverleafSkillsTarget: false,
         projectLocalSkills: null,
@@ -195,6 +209,8 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
       speedTier: normalizeSpeedTier(params.speedTier),
       loadCodexLocalSkills: skillLoading.loadCodexLocalSkills,
       loadCodexOverleafSkills: skillLoading.loadCodexOverleafSkills,
+      enabledCodexOverleafSkillIds: params.enabledCodexOverleafSkillIds,
+      enabledCodexLocalSkillIds: params.enabledCodexLocalSkillIds,
       skillInvocation: effectiveSkillInvocation,
       installCodexOverleafSkillsTarget: skillInstallTurn,
       projectLocalSkills: null,
@@ -243,6 +259,7 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
   const filteredChanges = filterSyncChangesForFocus({
     changes: selectionChanges.changes,
     focusFiles: params.focusFiles || params.session?.focusFiles,
+    focusFilesAreLiteral: params.focusFilesAreLiteral === true,
     restrictToFocusFiles: params.restrictToFocusFiles
   });
   let rawSyncChanges = filteredChanges.changes;
@@ -257,13 +274,14 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
   // syncChanges would write directly.
   const subagentViolationPaths = subagentBroker ? subagentBroker.getViolationPaths() : null;
   if (subagentViolationPaths && subagentViolationPaths.size) {
-    const blocked = rawSyncChanges.filter(change => subagentViolationPaths.has(change.path));
-    rawSyncChanges = rawSyncChanges.filter(change => !subagentViolationPaths.has(change.path));
+    const violatedPath = change => [change.path, change.to].find(file => file && subagentViolationPaths.has(file));
+    const blocked = rawSyncChanges.filter(change => violatedPath(change));
+    rawSyncChanges = rawSyncChanges.filter(change => !violatedPath(change));
     for (const change of blocked) {
       unsupportedChanges.push({
         type: 'unsupported-local-file',
         path: change.path,
-        reason: subagentBroker.getBlockedReason(change.path)
+        reason: subagentBroker.getBlockedReason(violatedPath(change))
       });
     }
   }
@@ -324,7 +342,7 @@ async function runCodexSession({ params = {}, env = process.env, emit = () => {}
     files: response.syncChanges.map(change => change.path),
     unsupportedCount: response.unsupportedChanges.length,
     unsupportedFiles: response.unsupportedChanges.map(change => change.path)
-  }, 'completed');
+  }, response.unsupportedChanges.length ? 'warning' : 'completed');
 
   return response;
 }
@@ -344,11 +362,11 @@ function buildCodexTurnPrompt(params = {}, mirror = {}, projectLocalSkills, turn
 
 
 
-function normalizeFocusFiles(value) {
+function normalizeFocusFiles(value, literal = false) {
   const seen = new Set();
   const files = [];
   for (const item of Array.isArray(value) ? value : []) {
-    const filePath = normalizeProjectPath(item);
+    const filePath = literal ? normalizeSafeProjectPath(item) : normalizeProjectPath(item);
     if (!filePath || seen.has(filePath)) {
       continue;
     }
@@ -360,20 +378,20 @@ function normalizeFocusFiles(value) {
   }
   return files;
 }
-
-function filterSyncChangesForFocus({ changes = [], focusFiles = [], restrictToFocusFiles = false } = {}) {
+function filterSyncChangesForFocus({ changes = [], focusFiles = [], restrictToFocusFiles = false, focusFilesAreLiteral = false } = {}) {
   if (!restrictToFocusFiles) {
     return { changes, unsupportedChanges: [] };
   }
-  const focusSet = new Set(normalizeFocusFiles(focusFiles));
-  if (!focusSet.size) {
+  const focusSet = new Set(normalizeFocusFiles(focusFiles, focusFilesAreLiteral === true));
+  if (!focusSet.size && focusFilesAreLiteral !== true) {
     return { changes, unsupportedChanges: [] };
   }
 
   const accepted = [];
   const rejected = [];
   for (const change of changes || []) {
-    if (focusSet.has(normalizeProjectPath(change?.path))) {
+    if (focusSet.has(normalizeSafeProjectPath(change?.path))
+      && (!change?.to || focusSet.has(normalizeSafeProjectPath(change.to)))) {
       accepted.push(change);
     } else if (change?.path) {
       rejected.push({
@@ -388,7 +406,6 @@ function filterSyncChangesForFocus({ changes = [], focusFiles = [], restrictToFo
     unsupportedChanges: rejected
   };
 }
-
 function normalizeProjectPath(value) {
   return String(value || '')
     .replace(/^@file:/i, '')
@@ -418,12 +435,15 @@ function normalizeSkillLoadingSettings(params = {}) {
   };
 }
 
-function loadCodexSkillInvocationContext({
+async function loadCodexSkillInvocationContext({
   skillInvocation,
+  loadCodexLocalSkills = true,
+  enabledCodexLocalSkillIds,
   loadCodexOverleafSkills = true,
   enabledCodexOverleafSkillIds,
   env = process.env,
-  emit = () => {}
+  emit = () => {},
+  signal
 } = {}) {
   const invocation = normalizeSkillInvocation(skillInvocation);
   if (!invocation) {
@@ -433,19 +453,37 @@ function loadCodexSkillInvocationContext({
     return { invocation, skill: null, missing: [], ignored: [] };
   }
 
-  const result = loadSelectedCodexOverleafSkill({
+  const local = invocation.scope === 'codex-local';
+  const result = local ? await require('./codexLocalSkills').loadSelectedCodexLocalSkill({
+    skillId: invocation.id,
+    loadCodexLocalSkills,
+    enabledCodexLocalSkillIds,
+    env,
+    signal
+  }).catch(error => {
+    if (signal?.aborted || (!String(error?.code || '').startsWith('codex_local_skills_')
+      && error?.code !== 'codex_not_found')) throw error;
+    throw Object.assign(new Error('The selected local Codex skill is unavailable. Refresh the skill list and select it again.'),
+      { code: 'codex_local_skill_unavailable', cause: error });
+  }) : loadSelectedCodexOverleafSkill({
     skillId: invocation.id,
     loadCodexOverleafSkills,
     enabledCodexOverleafSkillIds,
     env
   });
+  if (local && !result.skill) {
+    throw Object.assign(new Error('The selected local Codex skill is unavailable. Refresh the skill list and select it again.'),
+      { code: 'codex_local_skill_unavailable' });
+  }
   if (result.missing.length) {
-    emitCodexEvent(emit, 'codex.overleaf_skills.missing', 'Selected Codex Overleaf skill was missing', {
+    emitCodexEvent(emit, local ? 'codex.local_skills.missing' : 'codex.overleaf_skills.missing',
+      local ? 'Selected local Codex skill was missing' : 'Selected Codex Overleaf skill was missing', {
       missingSkillIds: result.missing
     }, 'failed');
   }
   if (result.ignored.length) {
-    emitCodexEvent(emit, 'codex.overleaf_skill_invocation.ignored', 'Selected Codex Overleaf skill was ignored', {
+    emitCodexEvent(emit, local ? 'codex.local_skill_invocation.ignored' : 'codex.overleaf_skill_invocation.ignored',
+      local ? 'Selected local Codex skill was ignored' : 'Selected Codex Overleaf skill was ignored', {
       ignoredSkillIds: result.ignored.map(item => item.id),
       reason: result.ignored[0]?.reason || 'ignored'
     }, 'warning');
@@ -476,17 +514,18 @@ function normalizeSkillInvocation(value) {
     return null;
   }
   const title = String(value?.title || 'Skill Installer').trim().slice(0, 80) || 'Skill Installer';
-  if (id === 'skill-installer') {
+  if (id === 'skill-installer' && (!value?.scope || value.scope === 'builtin')) {
     return { id, title };
   }
-  if (value?.scope !== 'codex-overleaf') {
+  if (!['codex-overleaf', 'codex-local'].includes(value?.scope)) {
     return null;
   }
-  return { id, title, scope: 'codex-overleaf' };
+  return { id, title, scope: value.scope };
 }
 
 function isSkillInstallerInvocation(value) {
-  return normalizeSkillInvocation(value)?.id === 'skill-installer';
+  const invocation = normalizeSkillInvocation(value);
+  return invocation?.id === 'skill-installer' && !invocation.scope;
 }
 
 function isSafeSkillId(id) {
@@ -551,146 +590,6 @@ function buildCodexAppServerArgs(input = {}) {
   ];
 }
 
-async function applyCodexSkillIsolation({ input = {}, childEnv = process.env, request, emit = () => {} } = {}) {
-  if (input.loadCodexLocalSkills !== false) {
-    return { disabled: [] };
-  }
-  if (typeof request !== 'function') {
-    throw new Error('Codex skill isolation requires an app-server request function');
-  }
-
-  const listResult = await request('skills/list', {
-    cwd: input.workspacePath,
-    includeDisabled: true
-  });
-  const skills = flattenCodexSkillsList(listResult);
-  const disabled = [];
-  for (const skill of skills) {
-    if (skill?.enabled === false || !shouldDisableCodexSkillForIsolation(skill, input, childEnv)) {
-      continue;
-    }
-    const params = buildSkillDisableParams(skill);
-    if (!params) {
-      continue;
-    }
-    await request('skills/config/write', params);
-    disabled.push(String(skill.name || skill.path || '').trim());
-  }
-  if (disabled.length) {
-    emitCodexEvent(emit, 'codex.skill_isolation.applied', 'Disabled non-Overleaf Codex skills for this turn', {
-      disabledSkillNames: disabled.filter(Boolean)
-    }, 'completed');
-  }
-  return { disabled };
-}
-
-// Recursion guard (spec S6): disable specific Codex-Overleaf skills for one
-// app-server child process — used to strip `parallel-subagents` from worker
-// runs so an inheriting worker cannot discover the queue and fan out again.
-// Skill directories are named by skill id (<root>/<id>/SKILL.md).
-async function applyWorkerSkillStrip({ input = {}, request } = {}) {
-  const ids = Array.isArray(input.disableCodexOverleafSkillIds)
-    ? input.disableCodexOverleafSkillIds.filter(Boolean)
-    : [];
-  if (!ids.length || typeof request !== 'function') {
-    return { disabled: [] };
-  }
-  const listResult = await request('skills/list', {
-    cwd: input.workspacePath,
-    includeDisabled: true
-  });
-  const disabled = [];
-  for (const skill of flattenCodexSkillsList(listResult)) {
-    if (skill?.enabled === false) {
-      continue;
-    }
-    const skillDirName = path.basename(path.dirname(String(skill?.path || '')));
-    if (!ids.includes(skillDirName)) {
-      continue;
-    }
-    const params = buildSkillDisableParams(skill);
-    if (!params) {
-      continue;
-    }
-    await request('skills/config/write', params);
-    disabled.push(skillDirName);
-  }
-  return { disabled };
-}
-
-function flattenCodexSkillsList(listResult = {}) {
-  const data = Array.isArray(listResult?.data) ? listResult.data : [];
-  return data.flatMap(entry => Array.isArray(entry?.skills) ? entry.skills : []);
-}
-
-function shouldDisableCodexSkillForIsolation(skill = {}, input = {}, childEnv = process.env) {
-  if (isCodexSystemSkill(skill)) {
-    return !isAllowedSystemSkillForIsolation(skill, input);
-  }
-  return !isAllowedCodexOverleafSkillPath(skill.path, input, childEnv);
-}
-
-function isCodexSystemSkill(skill = {}) {
-  return String(skill.scope || '') === 'system' || isSystemSkillPath(skill.path);
-}
-
-function isAllowedSystemSkillForIsolation(skill = {}, input = {}) {
-  return input.installCodexOverleafSkillsTarget === true && String(skill.name || '') === 'skill-installer';
-}
-
-function isAllowedCodexOverleafSkillPath(skillPath, input = {}, childEnv = process.env) {
-  if (input.loadCodexOverleafSkills === false && input.installCodexOverleafSkillsTarget !== true) {
-    return false;
-  }
-  const pathText = String(skillPath || '');
-  if (!pathText || !path.isAbsolute(pathText) || isSystemSkillPath(pathText)) {
-    return false;
-  }
-  const roots = [
-    path.join(String(childEnv.CODEX_HOME || ''), 'skills'),
-    getCodexOverleafSkillsRoot({ env: childEnv })
-  ].filter(Boolean);
-  return roots.some(root => isInsideOrSamePath(pathText, root));
-}
-
-function isSystemSkillPath(skillPath) {
-  return String(skillPath || '').split(path.sep).includes('.system');
-}
-
-function buildSkillDisableParams(skill = {}) {
-  const name = String(skill.name || '').trim();
-  if (isCodexSystemSkill(skill) && name) {
-    return { name, enabled: false };
-  }
-  const skillPath = String(skill.path || '').trim();
-  if (path.isAbsolute(skillPath)) {
-    return { path: skillPath, enabled: false };
-  }
-  if (name) {
-    return { name, enabled: false };
-  }
-  return null;
-}
-
-function isInsideOrSamePath(target, root) {
-  const targetPaths = comparablePaths(target);
-  const rootPaths = comparablePaths(root);
-  return targetPaths.some(targetPath => rootPaths.some(rootPath => (
-    targetPath === rootPath || targetPath.startsWith(rootPath + path.sep)
-  )));
-}
-
-function comparablePaths(value) {
-  const resolved = path.resolve(String(value || ''));
-  const candidates = [resolved];
-  try {
-    candidates.push(fs.realpathSync.native(resolved));
-  } catch (_) {
-    // Fall back to the lexical path when the file is not present yet.
-  }
-  return Array.from(new Set(candidates));
-}
-
 function buildTurnStartParams(input = {}, threadId = input.threadId || '') {
   const params = {
     threadId,
@@ -731,6 +630,10 @@ function runCodexAppServerProcess(input) {
       return;
     }
     const childEnv = applyProviderEnvironment(buildCodexHomeEnv(input.env || process.env, {
+      isolateRuntimeHome: true,
+      enabledCodexOverleafSkillIds: input.enabledCodexOverleafSkillIds,
+      enabledCodexLocalSkillIds: input.enabledCodexLocalSkillIds,
+      disableCodexOverleafSkillIds: input.disableCodexOverleafSkillIds,
       loadCodexLocalSkills: input.loadCodexLocalSkills !== false,
       loadCodexOverleafSkills: input.loadCodexOverleafSkills !== false,
       installCodexOverleafSkillsTarget: input.installCodexOverleafSkillsTarget === true,
@@ -824,6 +727,8 @@ function runCodexAppServerProcess(input) {
       fail(new Error(stderr || `codex app-server exited before turn completed with code ${code}`));
     });
 
+    try { input.onProcessStarted?.(createProcessStopIdentity(child, { processGroup: process.platform !== 'win32' })); }
+    catch (error) { fail(error); return; }
     start().catch(fail);
 
     async function start() {
@@ -841,10 +746,6 @@ function runCodexAppServerProcess(input) {
         request,
         emit: input.emit
       });
-      await applyWorkerSkillStrip({
-        input,
-        request
-      });
 
       if (input.threadId) {
         try {
@@ -934,7 +835,9 @@ function runCodexAppServerProcess(input) {
         }
         pending.delete(message.id);
         if (message.error) {
-          pendingRequest.reject(new Error(message.error.message || JSON.stringify(message.error)));
+          const error = new Error(message.error.message || JSON.stringify(message.error));
+          if (typeof message.error.code === 'number' || typeof message.error.code === 'string') error.code = message.error.code;
+          pendingRequest.reject(error);
         } else {
           if (pendingRequest.method === 'thread/start' || pendingRequest.method === 'thread/resume') {
             activeThreadId = message.result?.thread?.id || message.result?.threadId || pendingRequest.params?.threadId || activeThreadId;
@@ -974,7 +877,10 @@ function runCodexAppServerProcess(input) {
         if (message.method === 'item/completed' && eventScope.owns(message.params) &&
           !readProgressController.observe(message.params?.item || {})) return;
         if (message.method === 'turn/completed' && activeTurnId && (message.params?.turn?.id === activeTurnId || message.params?.turnId === activeTurnId)) {
-          succeed(message.params?.turn || {});
+          const turn = message.params?.turn || {};
+          const terminalError = getTurnCompletionError(turn);
+          if (terminalError) fail(terminalError);
+          else succeed(turn);
         }
         if (message.method === 'error' && isTransientCodexAppServerError(message.params)) {
           return;
@@ -1083,17 +989,23 @@ function runCodexAppServerProcess(input) {
       if (settled || stopping) {
         return;
       }
-      settled = true;
+      stopping = true;
       const turnEndedError = new Error('Codex turn ended before the pending app-server request completed.');
       turnEndedError.code = 'codex_turn_ended';
       rejectPendingRequests(pending, turnEndedError);
       cleanup();
-      child.kill('SIGTERM');
-      resolve({
+      const result = {
         assistantMessage: buildFinalAssistantMessage(assistantMessages, assistantMessageOrder, {
           turnCompleted: turn.status === undefined || turn.status === 'completed'
         }),
         threadId: activeThreadId
+      };
+      return stopCodexAppServer(child, { processGroup: process.platform !== 'win32' }).then(() => {
+        settled = true;
+        resolve(result);
+      }, error => {
+        settled = true;
+        reject(error);
       });
     }
 
@@ -1404,6 +1316,10 @@ function emitCodexEvent(emit, type, title, detail = {}, status = 'running') {
 }
 
 function inferNotificationStatus(message) {
+  if (message.method === 'turn/completed') {
+    const error = getTurnCompletionError(message.params?.turn || {});
+    if (error) return error.code === 'codex_cancelled' ? 'cancelled' : 'failed';
+  }
   if (message.method === 'error' && isTransientCodexAppServerError(message.params)) {
     return 'warning';
   }
@@ -1413,6 +1329,19 @@ function inferNotificationStatus(message) {
   return 'running';
 }
 
+function getTurnCompletionError(turn) {
+  const status = turn.status;
+  // Older peers omit status; explicit error evidence still prevents success.
+  if ((status === undefined || status === 'completed') && turn.error == null) return null;
+  const interrupted = status === 'interrupted';
+  const invalid = status !== undefined && !['completed', 'failed', 'interrupted'].includes(status);
+  const error = new Error(extractCodexAppServerErrorMessage(turn) || (interrupted
+    ? 'Codex turn was interrupted.' : invalid ? 'Codex turn ended with an invalid terminal status.' : 'Codex turn failed.'));
+  error.code = interrupted ? 'codex_cancelled' : invalid ? 'codex_turn_status_invalid' : 'codex_turn_failed';
+  error.turnStatus = status;
+  return error;
+}
+
 function isTransientCodexAppServerError(params = {}) {
   const message = extractCodexAppServerErrorMessage(params);
   return /^Reconnecting(?:\.\.\.|…)?\s+\d+\s*\/\s*\d+\.?$/i.test(message);
@@ -1446,9 +1375,7 @@ function isUnsupportedReasoningSummaryError(error) {
   return /unsupported_parameter/i.test(message) && /reasoning\.summary|summary/i.test(message);
 }
 
-function cleanAssistantMessage(value) {
-  return String(value || '').trim();
-}
+const cleanAssistantMessage = value => String(value || '').trim();
 
 module.exports = {
   applyCodexSkillIsolation,

package/native-host/src/codexSessionTiming.js

@@ -41,20 +41,25 @@ function rejectPendingRequests(pending, error) {
   pending.clear();
 }
 
-async function stopCodexAppServer(child, {
-  interrupt, reason, processGroup = false, platform = process.platform,
-  interruptTimeoutMs = 1500, terminateTimeoutMs = 500, forceTimeoutMs = 1500,
-  kill = process.kill.bind(process), taskkill = defaultTaskkill
-} = {}) {
+function createProcessStopIdentity(child, { processGroup = false, platform = process.platform, kill = process.kill.bind(process) } = {}) {
   const pid = Number(child?.pid);
-  if (!Number.isInteger(pid) || pid <= 0) return;
   const grouped = processGroup && platform !== 'win32';
   const exited = () => child.exitCode != null || child.signalCode != null;
   const groupGone = () => {
     if (!grouped) return true;
     try { kill(-pid, 0); return false; } catch (error) { return error?.code === 'ESRCH'; }
   };
-  const stopped = () => exited() && groupGone();
+  return { processId: pid, processGroup: grouped, isStopped: () => exited() && groupGone() };
+}
+
+async function stopCodexAppServer(child, {
+  interrupt, reason, processGroup = false, platform = process.platform,
+  interruptTimeoutMs = 1500, terminateTimeoutMs = 500, forceTimeoutMs = 1500,
+  kill = process.kill.bind(process), taskkill = defaultTaskkill
+} = {}) {
+  const { processId: pid, processGroup: grouped, isStopped: stopped } = createProcessStopIdentity(child, { processGroup, platform, kill });
+  if (!Number.isInteger(pid) || pid <= 0) return;
+  const exited = () => child.exitCode != null || child.signalCode != null;
   const waitForStop = async timeoutMs => {
     const deadline = Date.now() + timeoutMs;
     while (!stopped() && Date.now() < deadline) {
@@ -99,13 +104,18 @@ async function stopCodexAppServer(child, {
 }
 
 function defaultTaskkill(pid, timeout) {
+  const path = require('node:path');
+  const systemRoot = process.env.SystemRoot || process.env.SYSTEMROOT || process.env.windir || process.env.WINDIR;
+  const command = systemRoot && path.win32.isAbsolute(systemRoot)
+    ? path.win32.join(systemRoot, 'System32', 'taskkill.exe') : 'taskkill';
   return new Promise((resolve, reject) => {
-    require('node:child_process').execFile('taskkill', ['/pid', String(pid), '/t', '/f'],
+    require('node:child_process').execFile(command, ['/pid', String(pid), '/t', '/f'],
       { windowsHide: true, timeout }, error => error ? reject(error) : resolve());
   });
 }
 
 module.exports = {
+  createProcessStopIdentity,
   createCodexIdleWatchdog,
   createOptionalTimeout,
   getAbortReason,