oh-my-codex 0.18.7 → 0.18.9

package/src/scripts/notify-hook/tmux-injection.ts

@@ -21,7 +21,7 @@ import { runProcess } from './process-runner.js';
 import { logTmuxHookEvent } from './log.js';
 import { resolveInvocationSessionId, resolveManagedCurrentPane, resolveManagedSessionContext, verifyManagedPaneTarget } from './managed-tmux.js';
 import { evaluatePaneInjectionReadiness, mapPaneInjectionReadinessReason, sendPaneInput } from './team-tmux-guard.js';
-import { listActiveSkills, readVisibleSkillActiveState } from '../../state/skill-active.js';
+import { listActiveSkills, readVisibleSkillActiveStateForStateDir } from '../../state/skill-active.js';
 import {
   normalizeTmuxHookConfig,
   pickActiveMode,
@@ -99,12 +99,14 @@ async function resolveCanonicalPaneFromPaneTarget(paneTarget: any, expectedCwd:
   return finalizeResolvedPane(healedPaneId, 'healed_hud_pane_target', expectedCwd);
 }
 
-async function resolvePreferredModePane(stateDir: string, allowedModes: string[]): Promise<{ mode: string; state: any; pane: string; stateDir: string } | null> {
-  const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir).catch(() => [stateDir]);
-  const dirs = [...scopedDirs];
-  if (!dirs.map((dir) => resolvePath(dir)).includes(resolvePath(stateDir))) {
-    dirs.push(stateDir);
-  }
+async function resolvePreferredModePane(
+  stateDir: string,
+  allowedModes: string[],
+  options: { includeRootFallback?: boolean } = {},
+): Promise<{ mode: string; state: any; pane: string; stateDir: string } | null> {
+  const dirs = await getScopedStateDirsForCurrentSession(stateDir, undefined, {
+    includeRootFallback: options.includeRootFallback !== false,
+  }).catch(() => [stateDir]);
   for (const dir of dirs) {
     for (const mode of allowedModes || []) {
       const path = join(dir, `${mode}-state.json`);
@@ -189,12 +191,18 @@ async function validateResolvedInjectionOwnership({
   return { ok: true };
 }
 
-async function readVisibleAllowedModes(
+export async function readVisibleAllowedModes(
   cwd: string,
   stateDir: string,
   payload: any,
   allowedModes: string[],
-): Promise<{ canonicalPresent: boolean; allowedSet: Set<string> | null; preferredMode: string | null }> {
+): Promise<{
+  canonicalPresent: boolean;
+  activeSkillCount: number;
+  allowedSet: Set<string> | null;
+  preferredMode: string | null;
+  sessionScoped: boolean;
+}> {
   const candidateSessionIds = [
     await readCurrentSessionId(stateDir).catch(() => undefined),
     resolveInvocationSessionId(payload),
@@ -203,41 +211,49 @@ async function readVisibleAllowedModes(
     .filter(Boolean);
 
   for (const sessionId of candidateSessionIds) {
-    const canonicalState = await readVisibleSkillActiveState(cwd, sessionId);
+    const canonicalState = await readVisibleSkillActiveStateForStateDir(stateDir, sessionId);
     if (!canonicalState) continue;
 
+    const activeSkills = listActiveSkills(canonicalState);
     const allowedSet = new Set(
-      listActiveSkills(canonicalState)
+      activeSkills
         .map((entry) => entry.skill)
         .filter((skill) => allowedModes.includes(skill)),
     );
     return {
       canonicalPresent: true,
+      activeSkillCount: activeSkills.length,
       allowedSet,
       preferredMode: pickActiveMode([...allowedSet], allowedModes),
+      sessionScoped: true,
     };
   }
 
   if (candidateSessionIds.length === 0) {
-    const rootCanonicalState = await readVisibleSkillActiveState(cwd).catch(() => null);
+    const rootCanonicalState = await readVisibleSkillActiveStateForStateDir(stateDir).catch(() => null);
     if (rootCanonicalState) {
+      const activeSkills = listActiveSkills(rootCanonicalState);
       const allowedSet = new Set(
-        listActiveSkills(rootCanonicalState)
+        activeSkills
           .map((entry) => entry.skill)
           .filter((skill) => allowedModes.includes(skill)),
       );
       return {
         canonicalPresent: true,
+        activeSkillCount: activeSkills.length,
         allowedSet,
         preferredMode: pickActiveMode([...allowedSet], allowedModes),
+        sessionScoped: false,
       };
     }
   }
 
   return {
     canonicalPresent: false,
+    activeSkillCount: 0,
     allowedSet: null,
     preferredMode: null,
+    sessionScoped: candidateSessionIds.length > 0,
   };
 }
 
@@ -415,10 +431,11 @@ export async function handleTmuxInjection({
   state.recent_keys = pruneRecentKeys(state.recent_keys, now);
   const canonicalModeState = await readVisibleAllowedModes(cwd, stateDir, payload, config.allowed_modes).catch(() => ({
     canonicalPresent: false,
+    activeSkillCount: 0,
     allowedSet: null,
     preferredMode: null,
   }));
-  if (canonicalModeState.canonicalPresent && !canonicalModeState.preferredMode) {
+  if (canonicalModeState.canonicalPresent && canonicalModeState.activeSkillCount > 0 && !canonicalModeState.preferredMode) {
     const nextState = {
       ...state,
       last_reason: 'mode_not_allowed',
@@ -468,12 +485,10 @@ export async function handleTmuxInjection({
     }
   };
   try {
-    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
+    const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir, undefined, {
+      includeRootFallback: !canonicalModeState.canonicalPresent && !canonicalModeState.sessionScoped,
+    });
     await scanActiveModeStateDirs(scopedDirs);
-
-    if (!pickActiveMode(activeModes, config.allowed_modes) && !scannedStateDirs.has(resolvePath(stateDir))) {
-      await scanActiveModeStateDirs([stateDir], true);
-    }
   } catch {
     // Non-fatal
   }
@@ -483,6 +498,7 @@ export async function handleTmuxInjection({
     canonicalModeState.canonicalPresent
       ? (canonicalModeState.preferredMode ? [canonicalModeState.preferredMode] : [])
       : config.allowed_modes,
+    { includeRootFallback: !canonicalModeState.sessionScoped },
   ).catch(() => null);
   const mode = canonicalModeState.canonicalPresent
     ? canonicalModeState.preferredMode

package/src/scripts/notify-hook.ts

@@ -262,6 +262,78 @@ function classifyIdleNotificationPhase(message: unknown): 'idle' | 'progress' |
   return 'idle';
 }
 
+
+function isExplicitAutopilotActivationText(text: string): boolean {
+  return /(?:^|[^\w])\$autopilot\b/i.test(text)
+    || /^\s*\/autopilot\b/i.test(text)
+    || /^\s*(?:please\s+)?autopilot(?:\s+(?:this|mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i.test(text)
+    || /\b(?:use|run|start|enable|launch|invoke|activate|resume|continue)\s+(?:the\s+)?autopilot(?:\s+(?:mode|workflow|skill|loop|now))?\s*[.!]?\s*$/i.test(text)
+    || /\bautopilot\s+(?:mode|workflow|skill|loop)\b/i.test(text);
+}
+
+function looksLikeAutopilotTerminalHandoff(text: string): boolean {
+  return /\bAutopilot complete\b/i.test(text)
+    || /\btask_complete\b/i.test(text)
+    || /\bautopilot\b[\s\S]{0,120}\b(?:complete|completed|finished)\b/i.test(text);
+}
+
+function isTerminalModeStateObject(value: unknown, mode: string): boolean {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const state = value as Record<string, unknown>;
+  if (safeString(state.mode).trim() !== mode) return false;
+  if (state.active === true) return false;
+  const phase = safeString(state.current_phase || state.currentPhase).trim().toLowerCase().replace(/_/g, '-');
+  if (['complete', 'completed', 'failed', 'cancelled', 'canceled', 'stopped', 'user-stopped'].includes(phase)) return true;
+  const outcome = safeString(state.run_outcome || state.outcome || state.lifecycle_outcome || state.terminal_outcome).trim().toLowerCase();
+  return ['finish', 'finished', 'complete', 'completed', 'failed', 'cancelled', 'canceled'].includes(outcome)
+    || safeString(state.completed_at || state.completedAt).trim() !== '';
+}
+
+function terminalStateMatchesNotifyTurn(state: Record<string, unknown>, payload: Record<string, unknown>): boolean {
+  const payloadTurnId = safeString(payload['turn-id'] || payload.turn_id || '').trim();
+  const stateTurnId = safeString(state.turn_id || state.turnId || '').trim();
+  const payloadThreadId = safeString(payload['thread-id'] || payload.thread_id || '').trim();
+  const stateThreadId = safeString(state.thread_id || state.threadId || '').trim();
+
+  if (payloadTurnId || stateTurnId) {
+    if (!payloadTurnId || !stateTurnId || payloadTurnId !== stateTurnId) return false;
+    return !payloadThreadId || !stateThreadId || payloadThreadId === stateThreadId;
+  }
+
+  return Boolean(payloadThreadId && stateThreadId && payloadThreadId === stateThreadId);
+}
+
+async function hasTerminalAutopilotStateForNotifyTurn(
+  stateDir: string,
+  sessionId: string,
+  payload: Record<string, unknown>,
+): Promise<boolean> {
+  const state = await readScopedJsonIfExists(
+    stateDir,
+    'autopilot-state.json',
+    sessionId || undefined,
+    null,
+    { includeRootFallback: true },
+  );
+  return isTerminalModeStateObject(state, 'autopilot')
+    && terminalStateMatchesNotifyTurn(state as Record<string, unknown>, payload);
+}
+
+async function shouldSuppressAutopilotTerminalReplayActivation(
+  stateDir: string,
+  payload: Record<string, unknown>,
+  isAutopilotActivation: boolean,
+  sessionId: string,
+): Promise<boolean> {
+  if (!isTurnCompletePayload(payload) && !isNotifyFallbackTaskCompletePayload(payload)) return false;
+  if (!isAutopilotActivation) return false;
+
+  const lastAssistantMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
+  if (!looksLikeAutopilotTerminalHandoff(lastAssistantMessage) && !isNotifyFallbackTaskCompletePayload(payload)) return false;
+
+  return hasTerminalAutopilotStateForNotifyTurn(stateDir, sessionId, payload);
+}
+
 function buildIdleNotificationFingerprint(payload: Record<string, unknown>): string {
   const lastAssistantMessage = safeString(payload['last-assistant-message'] || payload.last_assistant_message || '');
   const summary = summarizeIdleNotificationMessage(lastAssistantMessage);
@@ -641,16 +713,28 @@ async function main() {
 
   // 4.45. Skill activation tracking: update skill-active-state.json before any nudge logic.
   try {
-    const { recordSkillActivation } = await import('../hooks/keyword-detector.js');
+    const { detectKeywords, recordSkillActivation } = await import('../hooks/keyword-detector.js');
     if (latestUserInput) {
+      const activationSessionId = getEffectiveSessionId();
+      const isAutopilotActivation = detectKeywords(latestUserInput)
+        .some((match) => match.skill === 'autopilot')
+        || isExplicitAutopilotActivationText(latestUserInput);
+      const suppressTerminalReplay = await shouldSuppressAutopilotTerminalReplayActivation(
+        stateDir,
+        payload,
+        isAutopilotActivation,
+        activationSessionId,
+      );
+      if (!suppressTerminalReplay) {
         await recordSkillActivation({
           stateDir,
           sourceCwd: cwd,
           text: latestUserInput,
-          sessionId: getEffectiveSessionId(),
+          sessionId: activationSessionId,
           threadId: payloadThreadId,
           turnId: safeString(payload['turn-id'] || payload.turn_id || ''),
         });
+      }
     }
   } catch {
     // Non-fatal: keyword detector module may not be built yet
@@ -662,8 +746,11 @@ async function main() {
     // Non-fatal: lifecycle sync should not block the hook
   }
 
-  const deepInterviewStateActive = await isDeepInterviewStateActive(stateDir, getEffectiveSessionId());
-  const deepInterviewInputLockActive = await isDeepInterviewInputLockActive(stateDir, getEffectiveSessionId());
+  const effectiveSessionId = getEffectiveSessionId();
+  const deepInterviewStateActive = effectiveSessionId
+    ? await isDeepInterviewStateActive(stateDir, effectiveSessionId)
+    : await isDeepInterviewStateActive(stateDir, undefined);
+  const deepInterviewInputLockActive = await isDeepInterviewInputLockActive(stateDir, effectiveSessionId);
 
   // 4.55. Notify leader when individual worker transitions to idle (worker session only)
   if (isTeamWorker && parsedTeamWorker && !deepInterviewStateActive) {

package/src/scripts/prepare-build.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { existsSync, rmSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const requiredDistFiles = [
+  join(process.cwd(), 'dist', 'cli', 'omx.js'),
+  join(process.cwd(), 'dist', 'scripts', 'postinstall.js'),
+];
+
+if (requiredDistFiles.every((file) => existsSync(file))) {
+  process.exit(0);
+}
+
+const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const tscBin = process.platform === 'win32'
+  ? join(process.cwd(), 'node_modules', '.bin', 'tsc.cmd')
+  : join(process.cwd(), 'node_modules', '.bin', 'tsc');
+const nodeModulesDir = join(process.cwd(), 'node_modules');
+
+function runNpm(args, env = process.env) {
+  return spawnSync(npmBin, args, {
+    cwd: process.cwd(),
+    stdio: process.env.npm_config_json === 'true' ? ['inherit', 'ignore', 'inherit'] : 'inherit',
+    env,
+  });
+}
+
+function exitOnFailure(result, label) {
+  if (result.error) {
+    console.error(`omx prepare: failed to launch ${label}: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (result.status !== 0) {
+    process.exit(typeof result.status === 'number' ? result.status : 1);
+  }
+}
+
+let shouldCleanupBootstrappedDependencies = false;
+
+if (!existsSync(tscBin)) {
+  const hadNodeModules = existsSync(nodeModulesDir);
+  const installResult = runNpm(
+    [
+      'install',
+      '--global=false',
+      '--location=project',
+      '--include=dev',
+      '--ignore-scripts',
+      '--no-audit',
+      '--no-progress',
+    ],
+    {
+      ...process.env,
+      npm_config_global: 'false',
+      npm_config_location: 'project',
+    },
+  );
+  exitOnFailure(installResult, 'npm dependency bootstrap');
+  shouldCleanupBootstrappedDependencies = !hadNodeModules;
+}
+
+const pathWithLocalBins = [
+  join(process.cwd(), 'node_modules', '.bin'),
+  process.env.PATH ?? '',
+].filter(Boolean).join(delimiter);
+
+const buildResult = spawnSync(npmBin, ['run', 'build'], {
+  cwd: process.cwd(),
+  stdio: process.env.npm_config_json === 'true' ? ['inherit', 'ignore', 'inherit'] : 'inherit',
+  env: { ...process.env, PATH: pathWithLocalBins },
+});
+exitOnFailure(buildResult, 'npm build');
+
+if (shouldCleanupBootstrappedDependencies) {
+  try {
+    rmSync(nodeModulesDir, { recursive: true, force: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[omx:prepare] Warning: could not remove bootstrapped node_modules: ${message}`);
+  }
+}

package/src/scripts/run-test-files.ts

@@ -1,9 +1,10 @@
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync, type ChildProcess } from 'node:child_process';
 import { readdirSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 
 const DEFAULT_TEST_TIMEOUT_MS = 0;
 const DEFAULT_RUNNER_TIMEOUT_MS = 30 * 60 * 1_000;
+const DEFAULT_FORCE_EXIT_GRACE_MS = 30_000;
 const DEFAULT_CI_TEST_CONCURRENCY = 1;
 const RUNTIME_STATE_ENV_KEYS = [
   'OMX_ROOT',
@@ -47,6 +48,10 @@ function parseTimeoutMs(value: string | undefined, defaultTimeoutMs: number): nu
   return Math.floor(parsed);
 }
 
+function isWindows(): boolean {
+  return process.platform === 'win32';
+}
+
 function parseTestConcurrency(env: NodeJS.ProcessEnv): number | undefined {
   const rawValue = env.OMX_NODE_TEST_CONCURRENCY;
   if (rawValue) {
@@ -74,6 +79,7 @@ if (files.length === 0) {
 
 const testTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_TIMEOUT_MS, DEFAULT_TEST_TIMEOUT_MS);
 const runnerTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_RUNNER_TIMEOUT_MS, DEFAULT_RUNNER_TIMEOUT_MS);
+const forceExitGraceMs = parseTimeoutMs(process.env.OMX_NODE_TEST_FORCE_EXIT_GRACE_MS, DEFAULT_FORCE_EXIT_GRACE_MS);
 const testConcurrency = parseTestConcurrency(process.env);
 const forceExit = parseBooleanEnv(process.env.OMX_NODE_TEST_FORCE_EXIT);
 const testArgs = ['--test'];
@@ -84,7 +90,7 @@ if (testConcurrency) {
   testArgs.push(`--test-concurrency=${testConcurrency}`);
 }
 if (forceExit) {
-  testArgs.push('--test-force-exit');
+  testArgs.push('--test-force-exit', '--test-reporter=tap');
 }
 testArgs.push(...files);
 
@@ -92,7 +98,7 @@ console.error(
   `[run-test-files] running ${files.length} test file(s) from ${targets.join(', ')}${
     testTimeoutMs > 0 ? ` with per-test timeout ${testTimeoutMs}ms` : ' with per-test timeout disabled'
   }${testConcurrency ? `, test concurrency ${testConcurrency}` : ', default test concurrency'}${
-    forceExit ? ', force exit enabled' : ', force exit disabled'
+    forceExit ? `, force exit enabled with ${forceExitGraceMs}ms completion grace` : ', force exit disabled'
   }${runnerTimeoutMs > 0 ? `, and runner timeout ${runnerTimeoutMs}ms` : ', and runner timeout disabled'}`,
 );
 
@@ -105,26 +111,190 @@ if (!parseBooleanEnv(process.env.OMX_NODE_TEST_PRESERVE_RUNTIME_ENV)) {
   }
 }
 
-const result = spawnSync(process.execPath, testArgs, {
-  stdio: 'inherit',
-  env: childEnv,
-  timeout: runnerTimeoutMs > 0 ? runnerTimeoutMs : undefined,
-  killSignal: 'SIGTERM',
-});
+function reportAbnormalExit(signal: NodeJS.Signals | null, errorMessage?: string): void {
+  if (errorMessage) {
+    console.error(`[run-test-files] node --test error: ${errorMessage}`);
+  }
+  console.error(
+    `[run-test-files] node --test did not exit normally${signal ? ` (signal: ${signal})` : ''}. `
+      + `Roots: ${targets.join(', ')}. Test files: ${files.length}. `
+      + `Per-test timeout: ${testTimeoutMs > 0 ? `${testTimeoutMs}ms` : 'disabled'}. `
+      + `Test concurrency: ${testConcurrency ?? 'default'}. `
+      + `Force exit: ${forceExit ? 'enabled' : 'disabled'}. `
+      + `Runner timeout: ${runnerTimeoutMs > 0 ? `${runnerTimeoutMs}ms` : 'disabled'}.`,
+  );
+}
 
-if (typeof result.status === 'number') {
-  process.exit(result.status);
+function signalChild(child: ChildProcess, signal: NodeJS.Signals): void {
+  try {
+    if (!isWindows() && child.pid) {
+      process.kill(-child.pid, signal);
+    } else {
+      child.kill(signal);
+    }
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+      // Ignore kill races. The child might have exited between detection and termination.
+    }
+  }
 }
 
-if (result.error) {
-  console.error(`[run-test-files] node --test error: ${result.error.message}`);
+function terminateChild(child: ChildProcess): void {
+  signalChild(child, 'SIGTERM');
+  signalChild(child, 'SIGKILL');
+}
+
+function runWithCompletionForceExit(): void {
+  let finished = false;
+  let sawFailure = false;
+  let lastTapOk = 0;
+  let tapTests: number | undefined;
+  let tapPass: number | undefined;
+  let tapFail = 0;
+  let tapCancelled = 0;
+  let completedFromSummary = false;
+  let completionTimer: NodeJS.Timeout | undefined;
+  let runnerTimer: NodeJS.Timeout | undefined;
+  let stdoutRemainder = '';
+  let stderrRemainder = '';
+
+  const child = spawn(process.execPath, testArgs, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: childEnv,
+    detached: !isWindows(),
+  });
+
+  function finish(exitCode: number, reason: string): void {
+    if (finished) return;
+    finished = true;
+    if (completionTimer) clearTimeout(completionTimer);
+    if (runnerTimer) clearTimeout(runnerTimer);
+    console.error(`[run-test-files] ${reason}; exiting with status ${exitCode}`);
+    terminateChild(child);
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+    child.unref();
+    process.exit(exitCode);
+  }
+
+  function markFailure(): void {
+    sawFailure = true;
+    if (completionTimer) {
+      clearTimeout(completionTimer);
+      completionTimer = undefined;
+    }
+  }
+
+  function armCompletionTimer(reason: string): void {
+    if (sawFailure) return;
+    if (completionTimer) clearTimeout(completionTimer);
+    completionTimer = setTimeout(() => {
+      if (sawFailure) return;
+      finish(0, reason);
+    }, forceExitGraceMs);
+  }
+
+  function sawCleanTapSummary(): boolean {
+    if (tapTests === undefined || tapPass === undefined) return false;
+    return tapTests === tapPass && tapFail === 0 && tapCancelled === 0;
+  }
+
+  function parseTapLine(line: string): void {
+    if (/^(?:not ok|Bail out!)/.test(line)) {
+      markFailure();
+      return;
+    }
+
+    const summary = line.match(/^# (tests|pass|fail|cancelled) (\d+)$/);
+    if (summary) {
+      const count = Number(summary[2]);
+      if (summary[1] === 'tests') tapTests = count;
+      if (summary[1] === 'pass') tapPass = count;
+      if (summary[1] === 'fail') tapFail = count;
+      if (summary[1] === 'cancelled') tapCancelled = count;
+      if ((summary[1] === 'fail' || summary[1] === 'cancelled') && count > 0) markFailure();
+      return;
+    }
+
+    const ok = line.match(/^ok (\d+)\b/);
+    if (ok) {
+      lastTapOk = Number(ok[1]);
+      if (lastTapOk >= files.length) {
+        armCompletionTimer(`force-exit completion grace elapsed after TAP ok ${lastTapOk} with no later failures`);
+      }
+      return;
+    }
+
+    const plan = line.match(/^1\.\.(\d+)$/);
+    if (plan && Number(plan[1]) === lastTapOk && !sawFailure) {
+      armCompletionTimer(`force-exit completion grace elapsed after TAP plan ${line}`);
+      return;
+    }
+
+    if (/^# duration_ms /.test(line) && sawCleanTapSummary()) {
+      completedFromSummary = true;
+      armCompletionTimer('force-exit completion grace elapsed after clean TAP summary');
+    }
+  }
+
+  function handleOutput(chunk: Buffer, stream: NodeJS.WriteStream, isStdout: boolean): void {
+    stream.write(chunk);
+    const text = chunk.toString('utf8');
+    let combined = (isStdout ? stdoutRemainder : stderrRemainder) + text;
+    const lines = combined.split(/\r?\n/);
+    combined = lines.pop() ?? '';
+    if (isStdout) {
+      stdoutRemainder = combined;
+    } else {
+      stderrRemainder = combined;
+    }
+    for (const line of lines) parseTapLine(line);
+  }
+
+  child.stdout?.on('data', (chunk: Buffer) => handleOutput(chunk, process.stdout, true));
+  child.stderr?.on('data', (chunk: Buffer) => handleOutput(chunk, process.stderr, false));
+
+  child.on('error', (error) => {
+    reportAbnormalExit(null, error.message);
+    finish(1, 'node --test failed to spawn');
+  });
+
+  child.on('exit', (status, signal) => {
+    if (finished) return;
+    if (stdoutRemainder) parseTapLine(stdoutRemainder);
+    if (stderrRemainder) parseTapLine(stderrRemainder);
+    if (typeof status === 'number') {
+      finish(status, `node --test exited normally${completedFromSummary ? ' after clean TAP summary' : ''}`);
+      return;
+    }
+    reportAbnormalExit(signal);
+    finish(1, 'node --test exited without a numeric status');
+  });
+
+  if (runnerTimeoutMs > 0) {
+    runnerTimer = setTimeout(() => {
+      reportAbnormalExit(null);
+      finish(1, `runner timeout ${runnerTimeoutMs}ms elapsed`);
+    }, runnerTimeoutMs);
+  }
+}
+
+if (forceExit) {
+  runWithCompletionForceExit();
+} else {
+  const result = spawnSync(process.execPath, testArgs, {
+    stdio: 'inherit',
+    env: childEnv,
+    timeout: runnerTimeoutMs > 0 ? runnerTimeoutMs : undefined,
+    killSignal: 'SIGTERM',
+  });
+
+  if (typeof result.status === 'number') {
+    process.exit(result.status);
+  }
+
+  reportAbnormalExit(result.signal, result.error?.message);
+  process.exit(1);
 }
-console.error(
-  `[run-test-files] node --test did not exit normally${result.signal ? ` (signal: ${result.signal})` : ''}. `
-    + `Roots: ${targets.join(', ')}. Test files: ${files.length}. `
-    + `Per-test timeout: ${testTimeoutMs > 0 ? `${testTimeoutMs}ms` : 'disabled'}. `
-    + `Test concurrency: ${testConcurrency ?? 'default'}. `
-    + `Force exit: ${forceExit ? 'enabled' : 'disabled'}. `
-    + `Runner timeout: ${runnerTimeoutMs > 0 ? `${runnerTimeoutMs}ms` : 'disabled'}.`,
-);
-process.exit(1);