test(action-ledger): make cleanup-stuck projection tests robust under host load (#709)

* test(action-ledger): make cleanup-stuck projection tests robust under host load

The scoped-rejection test gave the independent root a 1000ms CrabFleet
timeout, which also bounds projection queue wait. On a loaded host the
5ms polling loops can consume more than 1s of wall clock before the test
frees a slot, so the queued independent projection settled with 'queue
timed out after 1000ms' and could never start. Raise it to 30s and widen
the 500ms poll deadlines to 5s.

On failure the test also leaked its stuck cleanup resolvers, permanently
holding 3 of 4 global projection slots and cascading into the next test
('hold slots until response cleanup settles' saw started 1 !== 4).
Release the resolvers in a finally block so a failure stays scoped.

* test(action-ledger): release late-registered cleanup resolvers in failure teardown

Autoreview: after the finally block drains the resolver array, a queued
blocked post can still start and register a new stuck cleanup on a later
microtask, hanging the flush. Gate the mock on a release flag so any
cancel after teardown begins resolves immediately.

Author: steipete

test/action-ledger-runtime.test.ts

@@ -3254,18 +3254,22 @@ test("cleanup-stuck projection rejection is scoped to the affected spool root",
   const independentEnv = workflowEnv({
     CLAWSWEEPER_CRABFLEET_AGENT_TOKEN: "agent-token",
     CLAWSWEEPER_CRABFLEET_SESSION_ID: "session-1",
-    CLAWSWEEPER_CRABFLEET_TIMEOUT_MS: "1000",
+    // Also bounds queue wait; must outlast the polling below on a loaded host.
+    CLAWSWEEPER_CRABFLEET_TIMEOUT_MS: "30000",
   });
   const cleanupResolvers: Array<() => void> = [];
+  let releaseCleanups = false;
   const blockedFetch = (async () =>
     ({
       ok: true,
       status: 204,
       body: {
         cancel: () =>
-          new Promise<void>((resolve) => {
-            cleanupResolvers.push(resolve);
-          }),
+          releaseCleanups
+            ? Promise.resolve()
+            : new Promise<void>((resolve) => {
+                cleanupResolvers.push(resolve);
+              }),
       },
     }) as unknown as Response) as typeof fetch;
   for (let index = 0; index < CRABFLEET_PROJECTION_LIMITS.maxConcurrent + 1; index += 1) {
@@ -3279,26 +3283,32 @@ test("cleanup-stuck projection rejection is scoped to the affected spool root",
     }) as typeof fetch),
   );
 
-  const blockedDeadline = Date.now() + 500;
-  while (cleanupResolvers.length < CRABFLEET_PROJECTION_LIMITS.maxConcurrent) {
-    if (Date.now() >= blockedDeadline) {
-      throw new Error("blocked root did not enter response cleanup");
+  try {
+    const blockedDeadline = Date.now() + 5000;
+    while (cleanupResolvers.length < CRABFLEET_PROJECTION_LIMITS.maxConcurrent) {
+      if (Date.now() >= blockedDeadline) {
+        throw new Error("blocked root did not enter response cleanup");
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5));
     }
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-  await new Promise((resolve) => setTimeout(resolve, 20));
-  assert.equal(independentStarted, 0);
-
-  cleanupResolvers.shift()!();
-  const independentDeadline = Date.now() + 500;
-  while (independentStarted === 0) {
-    if (Date.now() >= independentDeadline) {
-      throw new Error("independent root did not start after a projection slot recovered");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.equal(independentStarted, 0);
+
+    cleanupResolvers.shift()!();
+    const independentDeadline = Date.now() + 5000;
+    while (independentStarted === 0) {
+      if (Date.now() >= independentDeadline) {
+        throw new Error("independent root did not start after a projection slot recovered");
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5));
     }
-    await new Promise((resolve) => setTimeout(resolve, 5));
+  } finally {
+    // Release held slots even on failure so later tests do not inherit a starved pool.
+    // The flag makes any cleanup registered after this point resolve immediately.
+    releaseCleanups = true;
+    while (cleanupResolvers.length > 0) cleanupResolvers.shift()!();
+    await flushPendingCrabFleetPosts();
   }
-  for (const resolve of cleanupResolvers) resolve();
-  await flushPendingCrabFleetPosts();
   assert.equal(independentStarted, 1);
 });