perf(tests): cut remaining fixed waits from slowest test files

Author: Gustav-Simonsson

scripts/ci-timings.json

@@ -15,15 +15,15 @@ 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 ~1.5s stall window: under the
+// and finish in seconds. The tick test keeps a ~0.9s 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 = 1_500;
+const TEST_STALL_MS = 900;
 const SILENT_CHILD_STALL_MS = 400;
 
 describe("runWithWatchdog", () => {
@@ -56,13 +56,13 @@ describe("runWithWatchdog", () => {
   });
 
   test("output resets the stall timer", async () => {
-    // Prints every 250ms for ~2.5s against a 1.5s stall window: a broken
+    // Prints every 150ms for ~1.2s against a 0.9s 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 < 10; i++) { console.log('tick', i); await new Promise(r => setTimeout(r, 200)); }",
+        "for (let i = 0; i < 8; i++) { console.log('tick', i); await new Promise(r => setTimeout(r, 150)); }",
       ],
       stallMs: TEST_STALL_MS,
     });
@@ -104,7 +104,7 @@ describe("runWithWatchdog", () => {
       command: process.execPath,
       args: [
         "-e",
-        'process.on("SIGTERM", () => {}); setTimeout(() => process.exit(3), 1_500);',
+        'process.on("SIGTERM", () => {}); setTimeout(() => process.exit(3), 800);',
       ],
       stallMs: SILENT_CHILD_STALL_MS,
       onStall: () => {

scripts/test-parallel.test.ts

@@ -333,6 +333,9 @@ describe("createToolSearchTool", () => {
         new Promise<number>(() => {
           // Never settles: simulates a hung authorization handshake.
         }),
+      // The production bound is 1s; a short override exercises the same
+      // bounded-wait contract without paying that in wall clock.
+      pendingWaitMs: 50,
     });
     const out = await call(tool, { query: "linear" });
     expect(out).toContain("No tools matched");

src/agent/tool-search.test.ts

@@ -287,6 +287,10 @@ export interface ToolSearchDeps {
   // below so even a stuck dependency can never hang the call. Omitted callers
   // (tests, ad-hoc indexes) have no pending handshakes to wait for.
   awaitPendingConnections?: (timeoutMs?: number) => Promise<number>;
+  // Bounded wait before answering a miss with late-mounting tools, in ms.
+  // Defaults to TOOL_SEARCH_PENDING_WAIT_MS; tests override this so the
+  // bounded-wait contract is exercised without paying the production 1s.
+  pendingWaitMs?: number;
 }
 
 // Brief bound a tool_search miss waits for in-flight MCP handshakes before
@@ -319,16 +323,14 @@ function indent(text: string, pad: string): string {
 // Resolves undefined when this race itself times out.
 async function racePendingCount(
   awaitPending: (timeoutMs?: number) => Promise<number>,
+  waitMs: number,
 ): Promise<number | undefined> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     return await Promise.race([
-      awaitPending(TOOL_SEARCH_PENDING_WAIT_MS),
+      awaitPending(waitMs),
       new Promise<undefined>((resolve) => {
-        timer = setTimeout(
-          () => resolve(undefined),
-          TOOL_SEARCH_PENDING_WAIT_MS,
-        );
+        timer = setTimeout(() => resolve(undefined), waitMs);
       }),
     ]);
   } finally {
@@ -354,6 +356,7 @@ export function createToolSearchTool(deps: ToolSearchDeps): AgentTool {
         // (hung OAuth) — undefined means the wait itself timed out.
         const stillPending = await racePendingCount(
           deps.awaitPendingConnections,
+          deps.pendingWaitMs ?? TOOL_SEARCH_PENDING_WAIT_MS,
         );
         names = deps.search(query);
         if (names.length === 0 && (stillPending ?? 1) > 0) {

src/agent/tool-search.ts

@@ -286,7 +286,7 @@ describe("background run_shell (shellGuardPlugin)", () => {
     const result = await runWith(registry, {
       id: "bg1",
       name: "run_shell",
-      arguments: { command: "sleep 0.5; echo finished", background: true },
+      arguments: { command: "sleep 0.2; echo finished", background: true },
     });
     expect(result.isError).toBeUndefined();
     const parsed = JSON.parse(String(result.content)) as {

src/plugins/shell-guard-plugin.test.ts

@@ -25,7 +25,7 @@ describe("background shell registry", () => {
   test("start returns a handle immediately while the process runs", async () => {
     const registry = createBackgroundShellRegistry();
     const started = registry.start({
-      command: "sleep 0.5; echo done",
+      command: "sleep 0.2; echo done",
       cwd: tmpCwd,
     });
     if ("error" in started) throw new Error(started.error);

src/shell/background-shell.test.ts

@@ -296,6 +296,10 @@ export interface CreateTelemetryOptions {
   host?: string;
   apiKey?: string;
   batch?: BatchTuning;
+  // Upper bound on how long flush() may hold up process exit, in ms.
+  // Defaults to FLUSH_DEADLINE_MS; tests override this so the give-up
+  // contract is exercised without paying the production 500ms.
+  flushDeadlineMs?: number;
 }
 
 interface QueuedEvent {
@@ -373,6 +377,7 @@ export function createTelemetry(options: CreateTelemetryOptions): Telemetry {
   const batchSize = options.batch?.size ?? DEFAULT_BATCH_SIZE;
   const batchIntervalMs =
     options.batch?.intervalMs ?? DEFAULT_BATCH_INTERVAL_MS;
+  const flushDeadlineMs = options.flushDeadlineMs ?? FLUSH_DEADLINE_MS;
   const queueLimit = options.batch?.queueLimit ?? DEFAULT_QUEUE_LIMIT;
 
   const queue: QueuedEvent[] = [];
@@ -502,7 +507,7 @@ export function createTelemetry(options: CreateTelemetryOptions): Telemetry {
     await Promise.race([
       drain(),
       new Promise<void>((resolve) => {
-        const deadline = setTimeout(resolve, FLUSH_DEADLINE_MS);
+        const deadline = setTimeout(resolve, flushDeadlineMs);
         deadline.unref?.();
       }),
     ]);

src/telemetry/index.ts

@@ -12,7 +12,10 @@ process.stdin.resume();
 process.stdin.on("data", (chunk: Buffer) => {
   if (chunk.includes(0x03)) process.stdout.write("GOT_CTRL_C_BYTE\n");
 });
+// A SIGINT, if the kernel delivered one, would arrive synchronously with the
+// keypress, so a short grace after GOT_CTRL_C_BYTE still proves none is
+// delivered without paying a fixed 3s in wall clock.
 setTimeout(() => {
   process.stdout.write("NO_SIGINT_ON_CTRL_C\n");
   process.exit(0);
-}, 3000);
+}, 800);

tests/fixtures/rawmode-sigint/probe.ts

@@ -16,11 +16,11 @@ def main() -> int:
         os.execvp("bun", ["bun", "run", probe_path])
         os._exit(127)
 
-    time.sleep(1)
+    time.sleep(0.4)
     os.write(fd, b"\x03")
 
     out = b""
-    deadline = time.time() + 4
+    deadline = time.time() + 2.5
     while time.time() < deadline:
         ready, _, _ = select.select([fd], [], [], 0.5)
         if fd not in ready:

tests/fixtures/rawmode-sigint/pty_probe.py

@@ -357,6 +357,9 @@ test("flush gives up after its deadline when a request never settles", async ()
     env: {},
     fetchFn: impl,
     apiKey: "test-key",
+    // The production deadline is 500ms; a short override exercises the same
+    // give-up contract without paying that in wall clock.
+    flushDeadlineMs: 30,
   });
   telemetry.capture("cli_start");
   const start = Date.now();