@d3ara1n/pi-subagent 0.10.0 → 0.10.2

package/src/utils.test.ts

@@ -5,8 +5,8 @@
  *   node --test packages/pi-subagent/src/utils.test.ts
  *
  * These guard the bug fixes introduced during the improvement rounds:
- * path-injection (sanitizeFilename), concurrency/abort/negative-active
- * (AsyncSemaphore), provider-error word list (isProviderError), unknown-tool
+ * path-injection (sanitizeFilename), concurrency/abort/negative-active/unlimited
+ * semantics (AsyncSemaphore), provider-error word list (isProviderError), unknown-tool
  * formatting (previewArgs), output truncation fallback (truncateOutput).
  */
 
@@ -146,6 +146,40 @@ describe("AsyncSemaphore", () => {
     await assert.rejects(p);
     assert.equal((s as any).waiters.length, 0);
   });
+  test("unlimited max (0) never queues or reports capacity", async () => {
+    const s = new AsyncSemaphore(0);
+    assert.equal(s.isLimited, false);
+    assert.equal(s.isAtCapacity, false);
+
+    let acquired = 0;
+    await Promise.all(
+      Array.from({ length: 10 }, () =>
+        s.acquire().then(() => {
+          acquired++;
+        }),
+      ),
+    );
+
+    assert.equal(acquired, 10);
+    assert.equal((s as any).waiters.length, 0);
+    assert.equal(s.isAtCapacity, false);
+  });
+  test("positive max reports capacity and retains FIFO queueing", async () => {
+    const s = new AsyncSemaphore(1);
+    await s.acquire();
+    assert.equal(s.isAtCapacity, true);
+
+    const order: number[] = [];
+    const p1 = s.acquire().then(() => order.push(1));
+    const p2 = s.acquire().then(() => order.push(2));
+    assert.equal((s as any).waiters.length, 2);
+
+    s.release();
+    await p1;
+    s.release();
+    await p2;
+    assert.deepEqual(order, [1, 2]);
+  });
   test("releases queued waiters in FIFO order", async () => {
     const s = new AsyncSemaphore(1);
     await s.acquire();
@@ -214,17 +248,18 @@ describe("effectiveTimeout", () => {
       timeout,
     }) as unknown as SubagentRole;
 
-  test("non-delegate role uses base timeout", () => {
-    assert.equal(effectiveTimeout(role(["read", "grep"]), 600), 600);
+  test("role without timeout is unlimited", () => {
+    assert.equal(effectiveTimeout(role(["read", "grep"])), 0);
   });
-  test("delegate role uses base timeout (no widening — active-time clock pauses for nested delegate)", () => {
-    assert.equal(effectiveTimeout(role(["read", "delegate"]), 600), 600);
+  test("delegate-capable role without timeout is also unlimited", () => {
+    assert.equal(effectiveTimeout(role(["read", "delegate"])), 0);
   });
-  test("explicit roleDef.timeout is always honored (no widening)", () => {
-    assert.equal(effectiveTimeout(role(["read", "delegate"], 300), 600), 300);
+  test("explicit role timeout is honored", () => {
+    assert.equal(effectiveTimeout(role(["read", "delegate"], 300)), 300);
   });
-  test("explicit timeout on non-delegate also honored", () => {
-    assert.equal(effectiveTimeout(role(["read"]), 600), 600);
+  test("negative and non-finite values normalize to unlimited", () => {
+    assert.equal(effectiveTimeout(role(["read"], -1)), 0);
+    assert.equal(effectiveTimeout(role(["read"], Number.POSITIVE_INFINITY)), 0);
   });
 });
 

package/src/utils.ts

@@ -219,11 +219,24 @@ export function previewArgs(args: Record<string, unknown>): string {
   return argsStr.length > 50 ? argsStr.slice(0, 50) + "..." : argsStr;
 }
 
+// ── Numeric configuration ─────────────────────────────────────
+
+/** Normalize a finite numeric limit: invalid values use the default; negatives become 0 (unlimited). */
+export function normalizeNonNegativeNumber(value: unknown, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(0, value);
+}
+
+/** Normalize a count limit to a non-negative integer. */
+export function normalizeNonNegativeInteger(value: unknown, fallback: number): number {
+  return Math.floor(normalizeNonNegativeNumber(value, fallback));
+}
+
 // ── Concurrency gate ───────────────────────────────────────────────
 
 /**
  * Promise-based semaphore capping concurrent subagent spawns.
- * acquire() resolves immediately while under the limit, otherwise queues.
+ * A max of 0 means unlimited concurrency, so acquire() never queues.
  * Pass an AbortSignal to cancel while waiting (rejects and removes the waiter).
  */
 export class AsyncSemaphore {
@@ -231,10 +244,16 @@ export class AsyncSemaphore {
   private waiters: Array<() => void> = [];
   private max: number;
   constructor(max: number) {
-    this.max = max;
+    this.max = normalizeNonNegativeInteger(max, 0);
+  }
+  get isLimited(): boolean {
+    return this.max > 0;
+  }
+  get isAtCapacity(): boolean {
+    return this.isLimited && this.active >= this.max;
   }
   async acquire(signal?: AbortSignal): Promise<void> {
-    if (this.active < this.max) {
+    if (!this.isAtCapacity) {
       this.active++;
       return;
     }
@@ -262,6 +281,7 @@ export class AsyncSemaphore {
   }
   release(): void {
     this.active = Math.max(0, this.active - 1);
+    if (!this.isLimited) return;
     const next = this.waiters.shift();
     if (next) next();
   }
@@ -271,12 +291,10 @@ export class AsyncSemaphore {
 
 /**
  * Effective per-role timeout in SECONDS (convert to ms at the spawn boundary).
- * No widening for delegate-capable roles: the parent's active-time clock
- * pauses while the child is inside a nested `delegate` call, so the base
- * budget is already enough. An explicit roleDef.timeout always wins.
+ * `0` or unset means unlimited; non-finite and negative values normalize to 0.
  */
-export function effectiveTimeout(roleDef: SubagentRole, baseTimeoutSec: number): number {
-  return roleDef.timeout ?? baseTimeoutSec;
+export function effectiveTimeout(roleDef: SubagentRole): number {
+  return normalizeNonNegativeNumber(roleDef.timeout, 0);
 }
 
 // ── Output truncation ────────────────────────────────────────