@ferris1225/pi-subagents 4.1.8 → 4.1.11

package/src/background.ts

@@ -27,15 +27,21 @@ interface PendingTask {
 	onError?: (error: unknown) => void | Promise<void>;
 }
 
-/** How many sub-agent processes may run at once, and how many tasks one
- * parallel `subagent` call may contain. Fixed by design: the queue sheds load
- * by waiting, so the knob bought nothing worth its maintenance. */
+/** How many sub-agent processes may run at once. This paces execution only —
+ * it never rejects work, so a wider parallel `subagent` call simply queues.
+ * Fixed by design: the queue sheds load by waiting, so the knob bought nothing
+ * worth its maintenance. Only manually dispatched top-level generations hold
+ * slots; runtime-initiated managed continuations (gate reviews, documentation
+ * sync) suspend their task's slot so they never starve manual dispatches. */
 export const MAX_CONCURRENT_SUBAGENTS = 4;
 
 export class BackgroundTaskQueue {
 	private concurrency: number;
 	private readonly pending: PendingTask[] = [];
 	private readonly active = new Set<AbortController>();
+	/** Active tasks that no longer count toward the concurrency limit. They keep
+	 * every other guarantee: abortable, awaited by waitForTask/waitForIdle. */
+	private readonly suspended = new Set<AbortController>();
 	private readonly completions = new WeakMap<AbortController, Promise<void>>();
 	private readonly idleWaiters = new Set<() => void>();
 	private stopped = false;
@@ -71,6 +77,16 @@ export class BackgroundTaskQueue {
 		return this.completions.get(controller) ?? Promise.resolve();
 	}
 
+	/** Stop counting a running task toward the concurrency limit. Its body keeps
+	 * running under the same abort signal; completion still releases everything
+	 * waitForTask/waitForIdle promise. Frees a slot for queued work immediately. */
+	suspend(controller: AbortController | undefined): void {
+		if (!controller || this.stopped) return;
+		if (!this.active.delete(controller)) return;
+		this.suspended.add(controller);
+		this.drain();
+	}
+
 	/** Cancel one queued/running task. Queued entries are removed immediately;
 	 * active entries resolve waitForTask only after their body and error handler
 	 * have quiesced and the concurrency slot has been released. */
@@ -89,7 +105,7 @@ export class BackgroundTaskQueue {
 
 	/** Resolve once no queued or running task remains. */
 	waitForIdle(): Promise<void> {
-		if (this.pending.length === 0 && this.active.size === 0) return Promise.resolve();
+		if (this.pending.length === 0 && this.active.size === 0 && this.suspended.size === 0) return Promise.resolve();
 		return new Promise<void>((resolve) => this.idleWaiters.add(resolve));
 	}
 
@@ -104,6 +120,7 @@ export class BackgroundTaskQueue {
 			entry.complete();
 		}
 		for (const controller of this.active) controller.abort();
+		for (const controller of this.suspended) controller.abort();
 		this.resolveIdleWaiters();
 	}
 
@@ -145,6 +162,7 @@ export class BackgroundTaskQueue {
 				})
 				.finally(() => {
 					this.active.delete(entry.controller);
+					this.suspended.delete(entry.controller);
 					entry.complete();
 					this.drain();
 					this.resolveIdleWaiters();
@@ -153,7 +171,7 @@ export class BackgroundTaskQueue {
 	}
 
 	private resolveIdleWaiters(): void {
-		if (this.pending.length > 0 || this.active.size > 0) return;
+		if (this.pending.length > 0 || this.active.size > 0 || this.suspended.size > 0) return;
 		for (const resolve of this.idleWaiters) resolve();
 		this.idleWaiters.clear();
 	}

package/src/config.ts

@@ -26,8 +26,10 @@ export const THINKING_LEVEL_VALUES = ["off", "minimal", "low", "medium", "high",
 export type ThinkingLevel = (typeof THINKING_LEVEL_VALUES)[number];
 export const DEFAULT_THINKING_LEVEL: ThinkingLevel = "high";
 
-/** How many lines of a sub-agent result the completion message may carry. Default: 80. */
-export const DEFAULT_MAX_RESULT_LINES = 80;
+/** How many lines of a sub-agent result the completion message may carry.
+ * Default: 40 — wide fan-outs multiply completion blocks, so deliveries stay
+ * compact and the full text lives in the on-disk result artifact. */
+export const DEFAULT_MAX_RESULT_LINES = 40;
 /** Upper bound accepted for maxResultLines (defensive clamp). */
 export const MAX_RESULT_LINES_LIMIT = 2000;