fix(wait): honor the shared deadline for queued members and hint only resumable runs

Author: Andy00L

src/commands/test.test.ts

@@ -2791,6 +2791,7 @@ describe('runTestWaitMany', () => {
       return { body: terminalRun('run_ok', 'passed') };
     });
     const out: string[] = [];
+    const errs: string[] = [];
     const rejection = await runTestWaitMany(
       {
         profile: 'default',
@@ -2800,7 +2801,12 @@ describe('runTestWaitMany', () => {
         timeoutSeconds: 30,
         maxConcurrency: 2,
       },
-      { credentialsPath, fetchImpl, stdout: line => out.push(line) },
+      {
+        credentialsPath,
+        fetchImpl,
+        stdout: line => out.push(line),
+        stderr: line => errs.push(line),
+      },
     ).catch((error: unknown) => error);
     expect(rejection).toMatchObject({ exitCode: 7 });
     const payload = JSON.parse(out.join('')) as {
@@ -2809,6 +2815,36 @@ describe('runTestWaitMany', () => {
     // The failing member did not abort the pool: the passed verdict survived.
     expect(payload.results[0]).toMatchObject({ runId: 'run_ok', status: 'passed' });
     expect(payload.results[1]!.status).toBe('error:NOT_FOUND');
+    // The re-attach hint names the errored member (resumable) but NOT the
+    // already-terminal passed one.
+    const hint = errs.find(line => line.includes('Re-attach with:'));
+    expect(hint).toContain('run_gone');
+    expect(hint).not.toContain('run_ok');
+  });
+
+  it('members dequeued after the shared deadline are not granted extra poll time', async () => {
+    const { credentialsPath } = makeCreds();
+    let fetches = 0;
+    const fetchImpl = makeFetch(() => {
+      fetches += 1;
+      return { body: terminalRun('run_any', 'passed') };
+    });
+    // timeoutSeconds 0: the shared deadline is already in the past when the
+    // pool starts, so every member must resolve to timeout WITHOUT polling
+    // (previously each dequeued member was granted a fresh 1s minimum).
+    const rejection = await runTestWaitMany(
+      {
+        profile: 'default',
+        output: 'json',
+        debug: false,
+        runIds: ['run_a', 'run_b', 'run_c'],
+        timeoutSeconds: 0,
+        maxConcurrency: 1,
+      },
+      { credentialsPath, fetchImpl, stdout: () => undefined, stderr: () => undefined },
+    ).catch((error: unknown) => error);
+    expect(rejection).toMatchObject({ exitCode: 7 });
+    expect(fetches).toBe(0);
   });
 
   it('an auth error escalates the exit code to 3', async () => {

src/commands/test.ts

@@ -4984,6 +4984,11 @@ export async function runTestWaitMany(
     | { kind: 'error'; code: string; exitCode: number };
 
   const pollOne = async (runId: string): Promise<WaitOutcome> => {
+    // A member dequeued AFTER the shared deadline has passed must not be
+    // granted a fresh minimum poll window (with --max-concurrency 1 that
+    // would extend the invocation by ~1s per queued run past --timeout).
+    const remainingSeconds = Math.ceil((deadlineMs - Date.now()) / 1000);
+    if (remainingSeconds <= 0) return { kind: 'timeout' };
     const resolveAlternate = makeBackendWaitFallback({
       client,
       resolveTestId: run => run.testId,
@@ -4992,7 +4997,7 @@ export async function runTestWaitMany(
     });
     try {
       const run = await pollRunUntilTerminal(client, runId, {
-        timeoutSeconds: Math.max(1, Math.ceil((deadlineMs - Date.now()) / 1000)),
+        timeoutSeconds: remainingSeconds,
         sleep: deps.sleep,
         onTransition: opts.verbose ? (msg: string) => stderrFn(`[verbose] ${msg}`) : undefined,
         onTick: (run, elapsedMs) => {
@@ -5036,14 +5041,27 @@ export async function runTestWaitMany(
   } catch (fanOutErr) {
     if (fanOutErr instanceof RequestTimeoutError) {
       // Same contract as the batch pollers: leave stdout parseable before
-      // exiting 7 — every dispatched id is re-attachable in one command.
+      // exiting 7. Members that already settled keep their real status; only
+      // the still-unfinished ids are marked running and named in the hint
+      // (re-attaching to an already-terminal run would be a wasted command).
       ticker.finalize('Multi-run wait — request timed out');
       const partial = {
-        results: opts.runIds.map(runId => ({ runId, status: 'running' })),
+        results: opts.runIds.map((runId): CliMultiWaitResult => {
+          const outcome = outcomes.get(runId);
+          if (outcome === undefined) return { runId, status: 'running' };
+          if (outcome.kind === 'timeout') return { runId, status: 'timeout' };
+          if (outcome.kind === 'error') return { runId, status: `error:${outcome.code}` };
+          return { runId, status: outcome.run.status, testId: outcome.run.testId };
+        }),
         summary: { total: opts.runIds.length },
       };
-      out.print(partial, () => partial.results.map(r => `${r.runId}  running`).join('\n'));
-      stderrFn(`Re-attach with: testsprite test wait ${opts.runIds.join(' ')}`);
+      out.print(partial, () => partial.results.map(r => `${r.runId}  ${r.status}`).join('\n'));
+      const unfinished = partial.results
+        .filter(r => r.status === 'running' || r.status === 'timeout')
+        .map(r => r.runId);
+      if (unfinished.length > 0) {
+        stderrFn(`Re-attach with: testsprite test wait ${unfinished.join(' ')}`);
+      }
     }
     throw fanOutErr;
   }
@@ -5071,9 +5089,14 @@ export async function runTestWaitMany(
     ].join('\n'),
   );
 
-  const timedOutIds = results.filter(r => r.status === 'timeout').map(r => r.runId);
-  if (timedOutIds.length > 0) {
-    stderrFn(`Re-attach with: testsprite test wait ${timedOutIds.join(' ')}`);
+  // Every member that did not reach a terminal verdict is re-attachable:
+  // timeouts (still running server-side) and poll errors (e.g. a transient
+  // transport failure) both belong in the hint; terminal runs do not.
+  const unfinishedIds = results
+    .filter(r => r.status === 'timeout' || r.status.startsWith('error:'))
+    .map(r => r.runId);
+  if (unfinishedIds.length > 0) {
+    stderrFn(`Re-attach with: testsprite test wait ${unfinishedIds.join(' ')}`);
   }
 
   // Worst-status exit: auth escalates (a rejected key fails every member the
@@ -7708,8 +7731,9 @@ export function createTestCommand(deps: TestDeps = {}): Command {
         '  0  passed\n' +
         '  1  failed / blocked / cancelled\n' +
         '  3  auth error\n' +
-        '  4  run not found\n' +
-        '  7  timeout — resume with: testsprite test wait <run-id...>\n' +
+        '  4  run not found (single run-id; with several ids a per-member poll error\n' +
+        '     is recorded as error:<CODE> in its row and folded into exit 7)\n' +
+        '  7  timeout or per-member poll error — resume with: testsprite test wait <run-id...>\n' +
         ' 10  transport/network failure (UNAVAILABLE) — retry the command\n' +
         '\nOn failure/blocked/cancelled, run: testsprite test artifact get <run-id>',
     )

test/__snapshots__/help.snapshot.test.ts.snap

@@ -248,8 +248,9 @@ Commands:
     0  passed
     1  failed / blocked / cancelled
     3  auth error
-    4  run not found
-    7  timeout — resume with: testsprite test wait <run-id...>
+    4  run not found (single run-id; with several ids a per-member poll error
+       is recorded as error:<CODE> in its row and folded into exit 7)
+    7  timeout or per-member poll error — resume with: testsprite test wait <run-id...>
    10  transport/network failure (UNAVAILABLE) — retry the command
   
   On failure/blocked/cancelled, run: testsprite test artifact get <run-id>