fix(evals): make completion-harness withTimeout actually race the deadline

The sync finally cleared the timer before Promise.race settled, so RunStatus timeout was unreachable and --timeout-ms was a no-op. Await the race so the timer clears on settle, export withTimeout for testing, and guard main() with import.meta.main. Adds scripts/eval-completion.test.ts proving a hung run rejects after the timeout. Baseline re-run still 50.0% (4/8).

Author: TheGreatAxios

scripts/eval-completion.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { withTimeout } from "./eval-completion.js";
+
+describe("withTimeout", () => {
+  test("rejects a hung run after the timeout", async () => {
+    const hung = new Promise<never>(() => undefined);
+    const start = Date.now();
+    const error = await withTimeout(hung, 50, "task stall-read").catch(
+      (err: unknown) => err,
+    );
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toBe(
+      "task stall-read timed out after 50ms",
+    );
+    // Fires near the deadline instead of hanging (bun test's own 5s
+    // timeout would fail this test if withTimeout never settled).
+    expect(Date.now() - start).toBeLessThan(2000);
+  });
+
+  test("resolves the inner value before the timeout", async () => {
+    await expect(
+      withTimeout(Promise.resolve("done"), 50, "task"),
+    ).resolves.toBe("done");
+  });
+
+  test("propagates an inner rejection that wins the race", async () => {
+    await expect(
+      withTimeout(Promise.reject(new Error("boom")), 1000, "task"),
+    ).rejects.toThrow("boom");
+  });
+});

scripts/eval-completion.ts

@@ -113,14 +113,17 @@ function commitSha(): string {
   return result.stdout.trim();
 }
 
-function withTimeout<T>(
+export async function withTimeout<T>(
   promise: Promise<T>,
   ms: number,
   label: string,
 ): Promise<T> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
-    return Promise.race([
+    // Await the race so the finally below runs on settle, not synchronously
+    // on return: clearing the timer before Promise.race settles would make
+    // the timeout unreachable and a hung run would hang the harness.
+    return await Promise.race([
       promise,
       new Promise<never>((_, reject) => {
         timer = setTimeout(
@@ -370,4 +373,6 @@ async function main(): Promise<void> {
   }
 }
 
-await main();
+if (import.meta.main) {
+  await main();
+}