fix(concurrency-gate): clamp non-finite max to 1 instead of deadlocking (#4580)

createConcurrencyGate(max) fed `max` straight into Math.max(1, max). If
max is NaN or Infinity (e.g. an unguarded env parse like
Number(process.env.DECOPILOT_MAX_CONCURRENT_SUBAGENTS) with a malformed
value), Math.max(1, NaN) is NaN, and `active < NaN` is always false --
every acquire() parks forever, deadlocking all subagent fan-out on that
pod. hosted-run-concurrency.ts already guards its env parse against
this; the shared gate factory itself did not.

Author: pedrofrxncx

apps/mesh/src/harnesses/decopilot/built-in-tools/subagent-concurrency.test.ts

@@ -96,6 +96,16 @@ describe("createConcurrencyGate", () => {
     expect(gate.active).toBe(0);
   });
 
+  it("coerces a non-finite max (e.g. an unparsed env value) up to 1 instead of deadlocking", async () => {
+    const gate = createConcurrencyGate(Number("not-a-number"));
+    await gate.acquire();
+    expect(gate.active).toBe(1);
+    let admitted = false;
+    void gate.acquire().then(() => (admitted = true));
+    await Promise.resolve();
+    expect(admitted).toBe(false);
+  });
+
   it("coerces a sub-1 max up to 1", async () => {
     const gate = createConcurrencyGate(0);
     await gate.acquire();

apps/mesh/src/harnesses/decopilot/built-in-tools/subagent-concurrency.ts

@@ -28,7 +28,11 @@ export interface ConcurrencyGate {
 }
 
 export function createConcurrencyGate(max: number): ConcurrencyGate {
-  const limit = Math.max(1, max);
+  // A NaN/Infinity `max` (e.g. from an unguarded env parse) must not reach
+  // `Math.max` here: Math.max(1, NaN) is NaN, and `active < NaN` is always
+  // false, so every acquire() would park forever — a total deadlock instead
+  // of the intended cap.
+  const limit = Number.isFinite(max) ? Math.max(1, max) : 1;
   let active = 0;
   const waiters: Array<() => void> = [];