perf(tests): cut remaining dominant waits from the slowest files

Author: Gustav-Simonsson

scripts/ci-timings.json

@@ -15,16 +15,16 @@ function processAlive(pid: number): boolean {
 }
 
 // These probes are `bun -e` one-liners, so they never import project modules
-// and finish in seconds. The tick test keeps a ~0.9s stall window: under the
+// and finish in seconds. The tick test keeps a ~0.7s stall window: under the
 // `--parallel` load this runner exists to enable, a delayed output tick can
 // look like a stall against a tighter window, so the window keeps several
 // ticks of scheduling headroom while a broken never-resetting timer still
 // fires mid-run (the tick test's total runtime exceeds the window). The
 // remaining tests drive children that never emit output, so their stall is
 // declared deterministically on the watchdog's first tick; they use a short
 // window so the suite does not pay the tick test's headroom in wall clock.
-const TEST_STALL_MS = 900;
-const SILENT_CHILD_STALL_MS = 400;
+const TEST_STALL_MS = 700;
+const SILENT_CHILD_STALL_MS = 250;
 
 describe("runWithWatchdog", () => {
   test("passes through a successful run without retrying", async () => {
@@ -56,13 +56,13 @@ describe("runWithWatchdog", () => {
   });
 
   test("output resets the stall timer", async () => {
-    // Prints every 150ms for ~1.2s against a 0.9s stall window: a broken
+    // Prints every 120ms for ~1s against a 0.7s stall window: a broken
     // timer that never reset would fire mid-run.
     const result = await runWithWatchdog({
       command: process.execPath,
       args: [
         "-e",
-        "for (let i = 0; i < 8; i++) { console.log('tick', i); await new Promise(r => setTimeout(r, 150)); }",
+        "for (let i = 0; i < 8; i++) { console.log('tick', i); await new Promise(r => setTimeout(r, 120)); }",
       ],
       stallMs: TEST_STALL_MS,
     });
@@ -104,7 +104,7 @@ describe("runWithWatchdog", () => {
       command: process.execPath,
       args: [
         "-e",
-        'process.on("SIGTERM", () => {}); setTimeout(() => process.exit(3), 800);',
+        'process.on("SIGTERM", () => {}); setTimeout(() => process.exit(3), 600);',
       ],
       stallMs: SILENT_CHILD_STALL_MS,
       onStall: () => {

scripts/test-parallel.test.ts

@@ -0,0 +1,82 @@
+import { getLogger } from "@intx/log";
+
+import { LOG_NAMESPACE_ROOT } from "../branding.js";
+import { awaitCloseWithoutHidingLeftover } from "../subagent/dispose.js";
+import type { SubAgentSessionStore } from "../subagent/index.js";
+
+const logger = getLogger([LOG_NAMESPACE_ROOT, "exec"]);
+
+/** Normalize unknown catch values for structured warn/error logs. */
+export function formatCaughtError(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+/**
+ * Headless analogue of TUI `runtime-shutdown`: dispose the toolset (posix
+ * process-group reap) before waiting on agent.close so a hung close cannot
+ * skip killing detached run_shell children. `cancelAll` is awaited so a
+ * leftover-child throw is visible. Once-only per runtime object so the send
+ * path, `finally`, and signal host cannot double-dispose.
+ *
+ * Lives in its own module (not exec/runner.ts, whose import graph costs
+ * ~0.4s in a fresh process) so the exec-shutdown-reap fixture can exercise
+ * the real dispose path without paying that in every subprocess it spawns.
+ */
+const execDisposeInFlight = new WeakMap<object, Promise<void>>();
+
+function rethrowExecDisposeFailures(failures: unknown[]): void {
+  const first = failures[0];
+  if (first === undefined) return;
+  if (failures.length === 1) throw first;
+  throw new AggregateError(failures, "exec runtime dispose failed");
+}
+
+export function disposeExecRuntime(args: {
+  agent: { close: () => Promise<unknown> } | null;
+  toolset: { dispose: () => Promise<unknown> } | null;
+  subAgentSessions: Pick<SubAgentSessionStore, "cancelAll"> | null;
+}): Promise<void> {
+  const key = args.toolset ?? args.agent ?? args.subAgentSessions;
+  if (key !== null) {
+    const existing = execDisposeInFlight.get(key);
+    if (existing !== undefined) return existing;
+  }
+
+  const run = runExecDispose(args);
+  if (key !== null) execDisposeInFlight.set(key, run);
+  return run;
+}
+
+async function runExecDispose(args: {
+  agent: { close: () => Promise<unknown> } | null;
+  toolset: { dispose: () => Promise<unknown> } | null;
+  subAgentSessions: Pick<SubAgentSessionStore, "cancelAll"> | null;
+}): Promise<void> {
+  const failures: unknown[] = [];
+  if (args.toolset !== null) {
+    try {
+      await args.toolset.dispose();
+    } catch (err: unknown) {
+      logger.debug("toolset.dispose during exec finally failed: {error}", {
+        error: formatCaughtError(err),
+      });
+      failures.push(err);
+    }
+  }
+  try {
+    await args.subAgentSessions?.cancelAll("Session closed");
+  } catch (err) {
+    failures.push(err);
+  }
+  if (args.agent !== null) {
+    try {
+      await awaitCloseWithoutHidingLeftover(args.agent.close(), failures[0]);
+    } catch (err: unknown) {
+      logger.debug("agent.close during exec finally failed: {error}", {
+        error: formatCaughtError(err),
+      });
+      failures.push(err);
+    }
+  }
+  rethrowExecDisposeFailures(failures);
+}

src/exec/dispose.ts

@@ -44,7 +44,7 @@ import {
   type SubAgentSessionStore,
 } from "../subagent/index.js";
 import { getProcessAdmissionQueue } from "../subagent/admission.js";
-import { awaitCloseWithoutHidingLeftover } from "../subagent/dispose.js";
+import { disposeExecRuntime, formatCaughtError } from "./dispose.js";
 import type {
   ContextStore,
   InferenceSource,
@@ -143,11 +143,6 @@ import { WorkflowHost } from "../workflows/host.js";
 
 const logger = getLogger([LOG_NAMESPACE_ROOT, "exec"]);
 
-/** Normalize unknown catch values for structured warn/error logs. */
-export function formatCaughtError(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-
 const SELECTED_PROVIDER_FAILURE = "SelectedProviderFailure";
 
 export async function refreshSelectedProviderCredential<T>(
@@ -195,72 +190,6 @@ export function execUserFailureMessage(
   return formatCaughtError(err);
 }
 
-/**
- * Headless analogue of TUI `runtime-shutdown`: dispose the toolset (posix
- * process-group reap) before waiting on agent.close so a hung close cannot
- * skip killing detached run_shell children. `cancelAll` is awaited so a
- * leftover-child throw is visible. Once-only per runtime object so the send
- * path, `finally`, and signal host cannot double-dispose.
- */
-const execDisposeInFlight = new WeakMap<object, Promise<void>>();
-
-function rethrowExecDisposeFailures(failures: unknown[]): void {
-  const first = failures[0];
-  if (first === undefined) return;
-  if (failures.length === 1) throw first;
-  throw new AggregateError(failures, "exec runtime dispose failed");
-}
-
-export function disposeExecRuntime(args: {
-  agent: { close: () => Promise<unknown> } | null;
-  toolset: { dispose: () => Promise<unknown> } | null;
-  subAgentSessions: Pick<SubAgentSessionStore, "cancelAll"> | null;
-}): Promise<void> {
-  const key = args.toolset ?? args.agent ?? args.subAgentSessions;
-  if (key !== null) {
-    const existing = execDisposeInFlight.get(key);
-    if (existing !== undefined) return existing;
-  }
-
-  const run = runExecDispose(args);
-  if (key !== null) execDisposeInFlight.set(key, run);
-  return run;
-}
-
-async function runExecDispose(args: {
-  agent: { close: () => Promise<unknown> } | null;
-  toolset: { dispose: () => Promise<unknown> } | null;
-  subAgentSessions: Pick<SubAgentSessionStore, "cancelAll"> | null;
-}): Promise<void> {
-  const failures: unknown[] = [];
-  if (args.toolset !== null) {
-    try {
-      await args.toolset.dispose();
-    } catch (err: unknown) {
-      logger.debug("toolset.dispose during exec finally failed: {error}", {
-        error: formatCaughtError(err),
-      });
-      failures.push(err);
-    }
-  }
-  try {
-    await args.subAgentSessions?.cancelAll("Session closed");
-  } catch (err) {
-    failures.push(err);
-  }
-  if (args.agent !== null) {
-    try {
-      await awaitCloseWithoutHidingLeftover(args.agent.close(), failures[0]);
-    } catch (err: unknown) {
-      logger.debug("agent.close during exec finally failed: {error}", {
-        error: formatCaughtError(err),
-      });
-      failures.push(err);
-    }
-  }
-  rethrowExecDisposeFailures(failures);
-}
-
 /**
  * Exec-primary director overlay. Omit / skywalker keep the product default
  * (`loadSessionChatPrompt` + advertised session tools). Any other closed-fleet