pi-harness-delegate 0.3.0 → 0.4.1

package/README.md

@@ -45,7 +45,7 @@ The `delegate` tool takes: `harness`, `task`, `mode`, `scope` (`diff` = git diff
 
 ### Fan out to multiple harnesses
 
-`harness` also accepts `all` or a comma-separated list — the same task runs on every harness, sequentially, and comes back as one comparison report instead of one report per harness:
+`harness` also accepts `all` or a comma-separated list — the same task runs on every harness **concurrently**, up to `maxConcurrent`, and comes back as one comparison report instead of one report per harness:
 
 ```bash
 /delegate all review the auth flow                 # every *detected* harness
@@ -54,10 +54,21 @@ delegate({ harness: "all", mode: "review", scope: "diff" })   # tool call form
 ```
 
 - `all` resolves to whatever's actually installed (`detectAll()`) — an uninstalled harness is skipped and named in the report, it doesn't fail the run. An explicit list is validated the same way; an unknown name is also reported rather than aborting the rest.
-- Each harness's run goes through the same `delegate()` engine as a single-harness call and writes its own transcript to its own `~/.pi/agent/delegate/outputs/<harness>/`; a fan-out costs roughly N× a single run (respects `maxBudgetUsd` per run) and always runs sequentially, respecting `maxConcurrent`.
-- The synthesized report groups each harness's metrics + output and a total spend line (unknown-cost runs called out separately, same as `/delegate status`) — it's assembled mechanically, not by asking a model to summarize.
-- A single-harness call (`harness: "claude"`, or omitted) behaves exactly as before — fan-out is opt-in by typing `all`/a list.
+- Each harness's run goes through the same `delegate()` engine as a single-harness call and writes its own transcript to its own `~/.pi/agent/delegate/outputs/<harness>/`. Runs are launched together and execute in parallel, bounded by `maxConcurrent` (default `4`, one slot per supported harness) — a run beyond the cap queues for a free slot instead of failing, and the cap is enforced across pi processes, not just this one. **This means fan-out spend is genuinely simultaneous**: with the default cap, a 4-harness fan-out can bill all four at once instead of one after another — budget accordingly (`maxBudgetUsd` still applies per run).
+- The synthesized report is always ordered by the resolved harness list (e.g. `claude, codex, opencode`), regardless of which harness actually finishes first — it groups each harness's metrics + output and a total spend line (unknown-cost runs called out separately, same as `/delegate status`), assembled mechanically, not by asking a model to summarize.
+- A single-harness call (`harness: "claude"`, or omitted) behaves exactly as before, including the concurrency guard: it still fails fast with "another delegate run is already in progress" at capacity rather than queueing. Fan-out is opt-in by typing `all`/a list.
 - `/delegate all …` batches successful completions into one notification instead of one per harness; a failure is never delayed or folded into the batch — it surfaces immediately.
+- In the TUI, a fan-out shows **one overlay for the whole run** — a compact row per harness (spinner/✓/✗, elapsed, current tool activity) — rather than one popup per harness or an interleaved feed you can't attribute to a harness:
+  ```
+  ╭─ ⠋ delegate all · review · 1/4 · ⏱ 0:42──────────────────╮
+  │ ✓ claude   0:38  done                                    │
+  │ ⠹ codex    0:41  ▶ Bash: bun test                        │
+  │ ⠹ opencode 0:12  ✍ Looking at the auth middleware next…  │
+  │ … amp      queued                                        │
+  │ esc cancel all · m minimize                               │
+  ╰────────────────────────────────────────────────────────────╯
+  ```
+  Double-ESC cancels every in-flight (and still-queued) run at once; `m` minimizes; the status bar chip shows aggregate state across every status plus elapsed and spend so far (e.g. `● 1✓ 1✗ 1▶ 1… · ⏱ 0:42 · $0.175` — done, failed, running, queued; zero status counts are omitted, so it reads `● 4▶ · ⏱ 0:05` while all four are in flight; the spend segment itself only appears once a run has actually reported a cost). A harness that fails keeps its failure reason on its row rather than blanking, so the overlay still says *why*. Once every row is done or failed, the overlay lingers ~3s on the finished board before closing (Esc or `m` dismisses it immediately) so glancing back after a fan-out still shows the final state instead of an empty screen. Single-harness runs keep the original one-run overlay unchanged, including its live activity feed showing a `+N earlier` marker instead of silently dropping older entries once the feed outgrows the visible window.
 
 ## Harnesses
 
@@ -148,7 +159,7 @@ In `~/.pi/agent/settings.json`:
     "maxBudgetUsd": 3,
     "autoDelegateHints": false,
     "modelAliases": { "economy": "haiku", "balanced": "sonnet", "max": "opus" },
-    "maxConcurrent": 1,
+    "maxConcurrent": 4,
     "maxTranscripts": 100,
     "harnesses": {
       "claude": { "model": "sonnet" },
@@ -162,7 +173,7 @@ In `~/.pi/agent/settings.json`:
 Legacy `claudeDelegate` is auto-migrated into `delegate.harnesses.claude` (deprecated).
 
 - `modelAliases` — templates may use `economy|balanced|max` or any alias; resolution: call → template → harness → global.
-- `maxConcurrent` — cap overlapping runs (default 1 global; may be `{global:1, perHarness:{claude:1}}`). Enforced across pi processes, not just the current one — a file-based registry under `~/.pi/agent/delegate/runs/` tracks active runs.
+- `maxConcurrent` — cap overlapping runs (default **`4`**, one slot per supported harness; may be `{global:4, perHarness:{claude:1}}`). Enforced across pi processes, not just the current one — a file-based registry under `~/.pi/agent/delegate/runs/` tracks active runs, so the slots available to you also depend on any other pi session running `delegate`. This is a **genuinely parallel** spend cap now, not just a "don't overlap" guard: a single-harness `/delegate` call still fails fast (`another delegate run is already in progress`) the moment it's at capacity, but `/delegate all …` fan-out queues for a free slot instead and can run up to `maxConcurrent` harnesses at once — meaning up to that many harnesses billing simultaneously. Lower it if you want fan-out to stay sequential/cheaper (`"maxConcurrent": 1` restores the old one-at-a-time behavior for everything, single runs included).
 - `maxTranscripts` — oldest transcripts pruned beyond this count per harness (`0` disables).
 
 `autoDelegateHints` is off by default — no system-prompt bias. When `true`, explicit markers (`@harness`, `with codex`, `delegate … to claude`) and imperative review/plan phrasing append a hint.

package/extensions/activity.ts

@@ -205,6 +205,17 @@ export interface FanoutRunSummary {
   verify?: VerifyResult;
 }
 
+/**
+ * Order fan-out results by the originally resolved harness list rather than completion order.
+ * Concurrent fan-out runs finish in whatever order their harnesses happen to complete; this keeps
+ * `buildFanoutReport`'s output deterministic regardless of which one lands first. Entries with a
+ * harness not present in `order` are dropped (shouldn't happen — every result comes from `order`).
+ */
+export function orderFanoutResults<T extends { harness: string }>(order: readonly string[], results: T[]): T[] {
+  const byHarness = new Map(results.map(r => [r.harness, r]));
+  return order.map(h => byHarness.get(h)).filter((r): r is T => r !== undefined);
+}
+
 /**
  * Mechanically assemble one comparison report across all fan-out runs — no second model call.
  * Groups per-harness metrics/output and rolls up total spend via `aggregateSpend`/`formatSpend`.

package/extensions/concurrency.ts

@@ -0,0 +1,106 @@
+/**
+ * The `delegate()` concurrency guard, factored out of index.ts so it's usable — and testable —
+ * independent of the TUI.
+ *
+ * Combines the file-based cross-process registry (`run-registry.ts`) with an in-process counter
+ * fallback (registry I/O failures never block a delegation). `acquireSlot()` is the single choke
+ * point: `wait: false` preserves the original fail-fast behavior for ad-hoc single-harness runs
+ * (throws immediately at capacity); `wait: true` polls until a slot frees, which is what turns a
+ * fan-out into a bounded pool without a separate worker-pool abstraction — callers just kick off
+ * all the harnesses at once and let `acquireSlot` serialize the ones that don't fit yet.
+ */
+
+import { type DelegateConfig, getMaxConcurrent } from './config.ts';
+import { acquireRun, countActiveRuns, releaseRun } from './run-registry.ts';
+
+const activeRuns = new Map<string, number>();
+let globalActiveRuns = 0;
+
+/** In-process active-run count (optionally filtered to one harness). Exposed for `/delegate status`. */
+export function inProcessActiveCount(harness?: string): number {
+  return harness ? (activeRuns.get(harness) ?? 0) : globalActiveRuns;
+}
+
+/** Active-run count combining the in-process counter with the cross-process registry (the max of
+ *  the two — registry I/O failures fall back to the in-process view). */
+export function activeCount(harness?: string): number {
+  return Math.max(inProcessActiveCount(harness), countActiveRuns(harness));
+}
+
+/** Thrown by `acquireSlot({wait: false})` when at capacity. */
+export class ConcurrencyLimitError extends Error {}
+
+export interface AcquireSlotOptions {
+  harness: string;
+  mode: string;
+  config: DelegateConfig;
+  /** false (default): throw immediately at capacity. true: poll until a slot frees. */
+  wait: boolean;
+  /** Aborts a `wait: true` poll early. */
+  signal?: AbortSignal;
+  pollIntervalMs?: number;
+}
+
+function abortError(): Error {
+  const err = new Error('aborted');
+  err.name = 'AbortError';
+  return err;
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError());
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+/**
+ * Acquire a concurrency slot for one delegate() run. Resolves with a release function (idempotent,
+ * never throws) once a slot is held; the caller must call it exactly once when the run finishes.
+ *
+ * Checks the global limit before the per-harness limit — same precedence and error text as the
+ * original inline guard, so single-run (`wait: false`) callers see unchanged behavior.
+ */
+export async function acquireSlot(opts: AcquireSlotOptions): Promise<() => void> {
+  const { harness, mode, config, wait, signal, pollIntervalMs = 200 } = opts;
+  for (;;) {
+    if (signal?.aborted) throw abortError();
+    const maxGlobal = getMaxConcurrent(config);
+    const globalCount = activeCount();
+    if (maxGlobal > 0 && globalCount >= maxGlobal) {
+      if (!wait) throw new ConcurrencyLimitError('another delegate run is already in progress (global limit)');
+      await sleep(pollIntervalMs, signal);
+      continue;
+    }
+    const perHarnessLimit = getMaxConcurrent(config, harness);
+    const perHarnessCount = activeCount(harness);
+    if (perHarnessLimit > 0 && perHarnessCount >= perHarnessLimit) {
+      if (!wait) throw new ConcurrencyLimitError(`another ${harness} run is already in progress`);
+      await sleep(pollIntervalMs, signal);
+      continue;
+    }
+
+    activeRuns.set(harness, perHarnessCount + 1);
+    globalActiveRuns++;
+    const runHandle = acquireRun(harness, mode);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      activeRuns.set(harness, Math.max(0, (activeRuns.get(harness) ?? 1) - 1));
+      globalActiveRuns = Math.max(0, globalActiveRuns - 1);
+      releaseRun(runHandle);
+    };
+  }
+}

package/extensions/config.ts

@@ -47,7 +47,7 @@ export function loadConfig(): DelegateConfig {
     inspectThinking: false,
     autoDelegateHints: false,
     modelAliases: { economy: 'haiku', balanced: 'sonnet', max: 'opus' },
-    maxConcurrent: 1,
+    maxConcurrent: 4,
     maxTranscripts: 100,
     harnesses: {},
   };

package/extensions/index.ts

@@ -40,6 +40,7 @@ import {
   formatMetrics,
   formatSpend,
   formatToolUse,
+  orderFanoutResults,
   parseTranscriptMeta,
   pruneOutputs,
   resolveVerifyPlan,
@@ -49,6 +50,7 @@ import {
   type VerifyResult,
 } from './activity.ts';
 import { isFanoutSpec, parseDelegateCommand, resolveDefaults, resolveHarnessList } from './command.ts';
+import { acquireSlot, activeCount } from './concurrency.ts';
 import {
   type DelegateConfig,
   outputsDir as getOutputsDir,
@@ -69,7 +71,7 @@ import type { ActivityEvent, NormalizedPermission } from './harnesses/types.ts';
 import { delegationHint, stripMarker } from './hint.ts';
 import { NotifyBatcher } from './notify.ts';
 import { type FeedEntry, progressWindow } from './progress.ts';
-import { acquireRun, countActiveRuns, releaseRun } from './run-registry.ts';
+import { formatFanoutChip, multiProgressWindow, type RunRow } from './progress-multi.ts';
 import { runHarness } from './runner.ts';
 import { type DelegateTemplate, loadTemplates } from './templates.ts';
 import { mapClaudeUsage } from './usage.ts';
@@ -98,10 +100,19 @@ interface DelegateOptions {
   onStream?: (text: string) => void;
   onActivity?: (ev: ActivityEvent) => void;
   signal?: AbortSignal;
+  /** Queue for a concurrency slot instead of failing fast when at capacity — fan-out only, see
+   *  `acquireSlot` in concurrency.ts. Single-harness runs leave this false (the default). */
+  waitForSlot?: boolean;
+  /** Called once this run has acquired its concurrency slot and is about to actually start —
+   *  fan-out uses it to flip a row from "queued" to "running". */
+  onAcquired?: () => void;
 }
 
 /** Verify commands run on the host after the harness exits — bounded independent of harness timeoutMs. */
 const VERIFY_TIMEOUT_MS = 5 * 60_000;
+/** How long the fan-out overlay lingers on the finished board after the last run resolves, so a
+ *  user who looked away still catches the final state instead of it clearing instantly. */
+const FANOUT_LINGER_MS = 3000;
 
 /**
  * Run a verify command in-process on the host (never delegated to the harness). Report-only —
@@ -134,18 +145,6 @@ async function runVerify(pi: ExtensionAPI, cwd: string, command: string): Promis
   }
 }
 
-const activeRuns = new Map<string, number>();
-let globalActiveRuns = 0;
-
-function getMaxConcurrentGlobal(): number {
-  const cfg = loadConfig();
-  if (typeof cfg.maxConcurrent === 'number') return cfg.maxConcurrent;
-  // SAFETY: maxConcurrent is validated to be number or object with global/perHarness in loadConfig
-  const mc = cfg.maxConcurrent as unknown as { global?: number }; // SAFETY: maxConcurrent validated in loadConfig
-  if (typeof mc.global === 'number') return mc.global;
-  return 1;
-}
-
 async function closeWhenMounted(getClose: () => (() => void) | null, capMs: number): Promise<void> {
   const close = getClose();
   if (close) {
@@ -419,7 +418,7 @@ async function showStatus(ctx: ExtensionContext, harnessFilter?: string): Promis
       templates = loadTemplates(ctx.cwd, h).size;
     } catch {}
     // cross-process count via the file registry, combined with the in-process counter as a fallback
-    const active = Math.max(activeRuns.get(h) ?? 0, countActiveRuns(h));
+    const active = activeCount(h);
     const hint = !det.ok && det.hint ? `  ← ${det.hint}` : '';
     lines.push(
       `${h.padEnd(20)} ${bin.padEnd(8)} ${ok.padEnd(3)} ${ver.padEnd(20)} ${String(outputs).padEnd(8)} ${String(templates).padEnd(10)} ${active}${hint}`,
@@ -437,7 +436,7 @@ async function showStatus(ctx: ExtensionContext, harnessFilter?: string): Promis
   if (!harnessFilter) {
     lines.push('');
     lines.push(
-      `global active: ${Math.max(globalActiveRuns, countActiveRuns())} · aliases: ${
+      `global active: ${activeCount()} · aliases: ${
         Object.entries(ALIASES)
           .map(([k, v]) => `${k}→${v}`)
           .join(', ') || '—'
@@ -524,32 +523,16 @@ async function delegate(
   const task = opts.task || template.defaultTask;
   if (!task) throw new Error(`delegate mode "${mode}" requires a task`);
 
-  // concurrency guard — combines the file-based cross-process registry with the in-process
-  // counters as a fallback, so registry I/O failures never block a delegation.
-  const maxGlobal = getMaxConcurrentGlobal();
-  const perHarnessCount = Math.max(activeRuns.get(harnessName) ?? 0, countActiveRuns(harnessName));
-  const globalCount = Math.max(globalActiveRuns, countActiveRuns());
-  if (maxGlobal > 0 && globalCount >= maxGlobal)
-    throw new Error('another delegate run is already in progress (global limit)');
-  // per-harness limit if configured as object
-  const perHarnessLimit = (() => {
-    const mc = config.maxConcurrent as unknown as { perHarness?: Record<string, number> };
-    if (mc && typeof mc === 'object' && mc.perHarness && typeof mc.perHarness[harnessName] === 'number') {
-      const v = mc.perHarness[harnessName];
-      if (typeof v === 'number') return v;
-    }
-    return maxGlobal;
-  })();
-  if (perHarnessLimit > 0 && perHarnessCount >= perHarnessLimit)
-    throw new Error(`another ${harnessName} run is already in progress`);
-  activeRuns.set(harnessName, perHarnessCount + 1);
-  globalActiveRuns++;
-  const runHandle = acquireRun(harnessName, mode);
-  const release = () => {
-    activeRuns.set(harnessName, Math.max(0, (activeRuns.get(harnessName) ?? 1) - 1));
-    globalActiveRuns = Math.max(0, globalActiveRuns - 1);
-    releaseRun(runHandle);
-  };
+  // concurrency guard — see concurrency.ts. Single runs (waitForSlot unset) fail fast at capacity,
+  // exactly as before; fan-out passes waitForSlot:true to queue instead.
+  const release = await acquireSlot({
+    harness: harnessName,
+    mode,
+    config,
+    wait: opts.waitForSlot ?? false,
+    signal: opts.signal,
+  });
+  opts.onAcquired?.();
 
   let scopeText: string | null = opts.scope ?? null;
   if (opts.scope === 'diff') {
@@ -851,8 +834,9 @@ async function runDelegateForTool(
 }
 
 /** `delegate({harness:"all"|"a,b"})` — resolve the requested harnesses to detected installs, run the
- *  existing `delegate()` engine once per harness sequentially (respects `maxConcurrent`), and
- *  mechanically synthesize one comparison report. No second model call. */
+ *  existing `delegate()` engine concurrently across all of them (bounded by `maxConcurrent` via
+ *  `acquireSlot({wait:true})` — see concurrency.ts), and mechanically synthesize one comparison
+ *  report ordered by the resolved harness list regardless of completion order. No second model call. */
 async function runFanoutTool(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
@@ -875,16 +859,12 @@ async function runFanoutTool(
   }
 
   const mode = params.mode ?? config.defaultMode;
-  const runs: FanoutRunSummary[] = [];
-  let sumInput = 0;
-  let sumOutput = 0;
-  let sumCacheCreate = 0;
-  let sumCacheRead = 0;
-  let sumCost = 0;
-  let anyCostKnown = false;
 
-  for (const h of resolved) {
-    onUpdate?.({ content: [{ type: 'text', text: `[${h}] running…` }], details: { progress: 0.5 } });
+  type TaskResult = FanoutRunSummary & {
+    usage?: import('./harnesses/types.ts').StreamedUsage | null;
+  };
+  const tasks = resolved.map(async (h): Promise<TaskResult> => {
+    onUpdate?.({ content: [{ type: 'text', text: `[${h}] queued…` }], details: { progress: 0.5 } });
     try {
       const run = await runDelegateForTool(
         pi,
@@ -901,13 +881,16 @@ async function runFanoutTool(
           sessionId: params.sessionId,
           pr: params.pr,
           // no verify: intentionally not model-settable — see DelegateToolParams
+          waitForSlot: true,
+          onAcquired: () =>
+            onUpdate?.({ content: [{ type: 'text', text: `[${h}] running…` }], details: { progress: 0.5 } }),
         },
         signal,
         onUpdate,
         `[${h}] `,
       );
       const summary = summarize(run.content);
-      runs.push({
+      return {
         harness: h,
         ok: !run.result.isError,
         metrics: formatMetrics({
@@ -922,19 +905,32 @@ async function runFanoutTool(
         file: (run.details.file as string) ?? undefined,
         sessionId: (run.details.sessionId as string) ?? undefined,
         verify: run.verify,
-      });
-      if (run.result.usage) {
-        sumInput += run.result.usage.inputTokens;
-        sumOutput += run.result.usage.outputTokens;
-        sumCacheCreate += run.result.usage.cacheCreationInputTokens;
-        sumCacheRead += run.result.usage.cacheReadInputTokens;
-      }
-      if (run.result.totalCostUsd !== null) {
-        sumCost += run.result.totalCostUsd;
-        anyCostKnown = true;
-      }
+        usage: run.result.usage,
+      };
     } catch (err) {
-      runs.push({ harness: h, ok: false, cost: null, error: err instanceof Error ? err.message : String(err) });
+      return { harness: h, ok: false, cost: null, error: err instanceof Error ? err.message : String(err) };
+    }
+  });
+
+  const settled = await Promise.all(tasks);
+  const runs = orderFanoutResults(resolved, settled);
+
+  let sumInput = 0;
+  let sumOutput = 0;
+  let sumCacheCreate = 0;
+  let sumCacheRead = 0;
+  let sumCost = 0;
+  let anyCostKnown = false;
+  for (const r of runs) {
+    if (r.usage) {
+      sumInput += r.usage.inputTokens;
+      sumOutput += r.usage.outputTokens;
+      sumCacheCreate += r.usage.cacheCreationInputTokens;
+      sumCacheRead += r.usage.cacheReadInputTokens;
+    }
+    if (r.cost !== null) {
+      sumCost += r.cost;
+      anyCostKnown = true;
     }
   }
 
@@ -1308,9 +1304,187 @@ export default function (pi: ExtensionAPI) {
     return { result: failed ? null : result, error: runState.error, cancelled };
   };
 
-  /** `/delegate all …` / `/delegate a,b …` — resolve to detected harnesses, run each sequentially
-   *  through `runOneDelegation` (respects `maxConcurrent`), batch success notifications, and inject
-   *  one synthesized comparison report instead of one report per harness. */
+  interface FanoutSpec {
+    harnessName: string;
+    task: string;
+    scope?: string;
+    model?: string;
+    budget?: number;
+    sessionId?: string;
+    pr?: string;
+    verify?: string;
+    isDanger: boolean;
+  }
+  interface FanoutOutcome {
+    harnessName: string;
+    result: Awaited<ReturnType<typeof delegate>> | null;
+    error: Error | null;
+    cancelled: boolean;
+  }
+
+  /** Run `delegate()` concurrently across every spec in one multi-run overlay — the fan-out
+   *  counterpart to `runOneDelegation`. Concurrency is bounded by `maxConcurrent`: every run passes
+   *  `waitForSlot:true`, so `acquireSlot` (concurrency.ts) queues the ones that don't fit instead of
+   *  failing them, and a fan-out never exceeds the configured cap just because it's a fan-out.
+   *  Double-ESC cancel aborts every in-flight (and still-queued) run via one shared AbortController. */
+  const runFanoutConcurrent = async (ctx: ExtensionContext, mode: string | undefined, specs: FanoutSpec[]) => {
+    const ac = new AbortController();
+    let cancelledAll = false;
+    const runId = ++activeRunId;
+    const clearActive = () => {
+      if (activeOverlay?.runId === runId) activeOverlay = null;
+    };
+    const modeForDisplay = mode ?? 'general';
+    const anyDanger = specs.some(s => s.isDanger);
+    const overallStart = Date.now();
+    const rows: RunRow[] = specs.map(s => ({
+      harness: s.harnessName,
+      startedAt: null,
+      status: 'queued',
+      activity: '',
+      costUsd: null,
+    }));
+    let requestRender: (() => void) | null = null;
+
+    let chipLastPush = 0;
+    const pushChip = () => {
+      if (!ctx.hasUI) return;
+      const now = Date.now();
+      if (now - chipLastPush < 500) return;
+      chipLastPush = now;
+      const theme = ctx.ui.theme;
+      ctx.ui.setStatus(
+        'delegate',
+        theme.fg('accent', '●') + theme.fg('dim', ` ${formatFanoutChip(rows, now - overallStart)}`),
+      );
+    };
+
+    const runOne = async (spec: FanoutSpec, idx: number): Promise<FanoutOutcome> => {
+      const setRow = (patch: Partial<RunRow>) => {
+        rows[idx] = { ...rows[idx], ...patch };
+        requestRender?.();
+        pushChip();
+      };
+      let liveTail = '';
+      const onActivity = (ev: ActivityEvent) => {
+        if (ev.kind === 'tool_input') setRow({ activity: `▶ ${formatToolUse(ev.name, ev.input)}` });
+        else if (ev.kind === 'tool_result')
+          setRow({
+            activity: rows[idx].activity ? `${rows[idx].activity}${ev.isError ? ' ✗' : ' ✓'}` : rows[idx].activity,
+          });
+        else if (ev.kind === 'thinking') setRow({ activity: '💭 thinking…' });
+      };
+      const runState: { error: Error | null } = { error: null };
+      const run = delegate(pi, ctx, {
+        harness: spec.harnessName,
+        task: spec.task,
+        mode,
+        scope: spec.scope,
+        model: spec.model,
+        maxBudgetUsd: spec.budget,
+        sessionId: spec.sessionId,
+        pr: spec.pr,
+        verify: spec.verify,
+        signal: ac.signal,
+        waitForSlot: true,
+        onAcquired: () => setRow({ status: 'running', startedAt: Date.now() }),
+        onStream: t => {
+          liveTail = (liveTail + t).slice(-200);
+          setRow({ activity: `✍ ${liveTail}` });
+        },
+        onActivity,
+      }).catch((err: unknown) => {
+        runState.error = err instanceof Error ? err : new Error(String(err));
+        return null;
+      });
+      const result = await run;
+      const failed = cancelledAll || !result;
+      // On failure keep context on the row: the reason if we have one, else whatever the run was
+      // last doing. Blanking it here would drop the only on-screen hint at *why* it failed.
+      const reason = runState.error ? runState.error.message.split('\n')[0].slice(0, 60) : '';
+      setRow({
+        status: failed ? 'failed' : 'done',
+        activity: failed ? reason || rows[idx].activity : '',
+        costUsd: !failed && result ? result.result.totalCostUsd : null,
+      });
+      return {
+        harnessName: spec.harnessName,
+        result: failed ? null : result,
+        error: runState.error,
+        cancelled: cancelledAll,
+      };
+    };
+
+    const allSettled = Promise.all(specs.map((spec, idx) => runOne(spec, idx)));
+
+    let closeWindow: (() => void) | null = null;
+    let outcomes: FanoutOutcome[];
+    if (ctx.hasUI) {
+      let overlayHandle: OverlayHandle | null = null;
+      let resolveDismiss = (): void => {};
+      const dismissed = new Promise<void>(resolve => {
+        resolveDismiss = () => resolve();
+      });
+      const uiPromise = ctx.ui
+        .custom(
+          (tui, theme, _kb, done) => {
+            requestRender = () => tui.requestRender();
+            closeWindow = () => done(undefined);
+            return multiProgressWindow(tui, theme, {
+              mode: modeForDisplay,
+              startedAt: overallStart,
+              getRows: () => rows,
+              dangerous: anyDanger,
+              onCancel: () => {
+                cancelledAll = true;
+                ac.abort();
+              },
+              onMinimize: () => {
+                overlayHandle?.setHidden(true);
+                overlayHandle?.unfocus();
+              },
+              onDismiss: () => resolveDismiss(),
+            });
+          },
+          {
+            overlay: true,
+            overlayOptions: { width: '70%', maxHeight: '60%', anchor: 'top-center' },
+            onHandle: h => {
+              overlayHandle = h;
+              activeOverlay = { show: () => h.setHidden(false), focus: () => h.focus(), runId };
+              h.focus();
+            },
+          },
+        )
+        .catch(() => {});
+      outcomes = await allSettled;
+      // Cancelling already means "I'm done watching" — skip the linger so the overlay closes
+      // right away instead of sitting on a cancelled board for FANOUT_LINGER_MS.
+      if (cancelledAll) resolveDismiss();
+      // Tear the overlay down after a short linger (or immediately on Esc/m/cancel) — in the
+      // background, so this doesn't delay the outcomes we're about to return (and thus the
+      // injected report). `activeOverlay` stays valid for `/delegate watch` until this settles.
+      void (async () => {
+        const timer = setTimeout(() => resolveDismiss(), FANOUT_LINGER_MS);
+        timer.unref?.();
+        await dismissed;
+        clearTimeout(timer);
+        await closeWhenMounted(() => closeWindow, 2000);
+        await uiPromise;
+        clearActive();
+        ctx.ui.setStatus('delegate', undefined);
+      })();
+    } else {
+      outcomes = await allSettled;
+      clearActive();
+    }
+    return outcomes;
+  };
+
+  /** `/delegate all …` / `/delegate a,b …` — resolve to detected harnesses, run `delegate()`
+   *  concurrently across all of them in one multi-run overlay (see `runFanoutConcurrent`), batch
+   *  success notifications, and inject one synthesized comparison report ordered by the resolved
+   *  harness list regardless of completion order. */
   const runFanoutCommand = async (ctx: ExtensionContext, parsed: ReturnType<typeof parseDelegateCommand>) => {
     const harnessSpec = parsed.harness as string;
     const detection = await detectAll();
@@ -1328,19 +1502,23 @@ export default function (pi: ExtensionAPI) {
     }
 
     const modeForReport = parsed.mode ?? loadConfig().defaultMode;
-    const runs: FanoutRunSummary[] = [];
     const batcher = new NotifyBatcher((text, level) => {
       if (ctx.hasUI) ctx.ui.notify(text, level);
       else process.stdout.write(`${text}\n`);
     });
 
+    // Resolve each harness's task/scope/danger flag up front — cheap and synchronous — so a
+    // harness that can't even start (e.g. mode needs a prompt) fails immediately instead of
+    // occupying a concurrency slot.
+    const specs: FanoutSpec[] = [];
+    const immediateFailures: FanoutRunSummary[] = [];
     for (const h of resolved) {
       const templates = loadTemplates(ctx.cwd, h);
       const resolvedTaskScope = resolveDefaults(parsed, templates);
       const template = parsed.mode ? templates.get(parsed.mode) : undefined;
       if (!resolvedTaskScope) {
         const message = `mode "${parsed.mode ?? 'general'}" needs a prompt`;
-        runs.push({ harness: h, ok: false, cost: null, error: message });
+        immediateFailures.push({ harness: h, ok: false, cost: null, error: message });
         batcher.failure(`${h}: ${message}`);
         continue;
       }
@@ -1349,9 +1527,8 @@ export default function (pi: ExtensionAPI) {
         (template?.nativePermission
           ? ['bypassPermissions', 'danger-full-access', 'danger'].includes(template.nativePermission)
           : false);
-      const outcome = await runOneDelegation(ctx, {
+      specs.push({
         harnessName: h,
-        mode: parsed.mode,
         task: resolvedTaskScope.task,
         scope: resolvedTaskScope.scope,
         model: parsed.model,
@@ -1359,15 +1536,16 @@ export default function (pi: ExtensionAPI) {
         sessionId: parsed.sessionId,
         pr: parsed.pr,
         verify: parsed.verify,
-        template,
         isDanger,
       });
+    }
+
+    const outcomes = specs.length > 0 ? await runFanoutConcurrent(ctx, parsed.mode, specs) : [];
+    const completed: FanoutRunSummary[] = outcomes.map(outcome => {
       if (outcome.cancelled || !outcome.result) {
         const message = outcome.error ? outcome.error.message : outcome.cancelled ? 'cancelled' : 'delegation failed';
-        runs.push({ harness: h, ok: false, cost: null, error: message });
-        batcher.failure(`${h}: ${outcome.cancelled ? 'cancelled' : 'failed'} — ${message}`);
-        if (outcome.cancelled) break; // user cancelled — stop the rest of the fan-out
-        continue;
+        batcher.failure(`${outcome.harnessName}: ${outcome.cancelled ? 'cancelled' : 'failed'} — ${message}`);
+        return { harness: outcome.harnessName, ok: false, cost: null, error: message };
       }
       const { content, details, result, verify } = outcome.result;
       const summary = summarize(content);
@@ -1378,8 +1556,9 @@ export default function (pi: ExtensionAPI) {
         contextPercent: typeof details.contextPercent === 'number' ? details.contextPercent : null,
         durationMs: typeof details.durationMs === 'number' ? details.durationMs : null,
       });
-      runs.push({
-        harness: h,
+      batcher.success(`${outcome.harnessName} ${parsed.mode ?? 'general'} — ${metrics}`);
+      return {
+        harness: outcome.harnessName,
         ok: !result.isError,
         metrics,
         cost: result.totalCostUsd,
@@ -1387,10 +1566,10 @@ export default function (pi: ExtensionAPI) {
         file: (details.file as string) ?? undefined,
         sessionId: (details.sessionId as string) ?? undefined,
         verify,
-      });
-      batcher.success(`${h} ${parsed.mode ?? 'general'} — ${metrics}`);
-    }
+      };
+    });
 
+    const runs = orderFanoutResults(resolved, [...immediateFailures, ...completed]);
     const okCount = runs.filter(r => r.ok).length;
     const report = buildFanoutReport({ runs, skipped, unknown });
     injectReport(ctx, {

package/extensions/progress-multi.ts

@@ -0,0 +1,216 @@
+/**
+ * Live progress window for a concurrent multi-harness `/delegate all` fan-out — one overlay
+ * showing every run as a compact row (harness, elapsed, current activity, done/failed marker)
+ * instead of N stacked overlays or one feed with interleaved lines from different harnesses.
+ *
+ * Single-harness runs keep using `progressWindow` in progress.ts unchanged — this is only
+ * mounted for a fan-out. Shares `fmtElapsed` with it; deliberately not merged into one generic
+ * layout framework since the two views render fundamentally different things (one live feed vs
+ * N row summaries).
+ *
+ * Controls: same as progressWindow — ESC twice to cancel (aborts every in-flight run), `m` to
+ * minimize. Once every row is terminal, a single Esc or `m` instead dismisses immediately (see
+ * `isFanoutComplete`) rather than arming/minimizing, since there's nothing left to cancel.
+ */
+
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type Component, Key, matchesKey, type TUI, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { fmtElapsed } from './progress.ts';
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPIN_INTERVAL_MS = 100;
+
+export type RunStatus = 'queued' | 'running' | 'done' | 'failed';
+
+export interface RunRow {
+  harness: string;
+  /** Set once the run has acquired its concurrency slot and started executing; null while queued. */
+  startedAt: number | null;
+  status: RunStatus;
+  /**
+   * Short current-activity text (tool call, "thinking…", or a text tail). Empty when queued or
+   * done; on a failed run it holds the failure reason (or the last activity seen), so the row
+   * still says *why* rather than going blank at the moment that matters most.
+   */
+  activity: string;
+  /** Cost reported once the run completes successfully; null while queued/running/failed, or when
+   *  the harness didn't report one. Feeds the chip's aggregate spend figure. */
+  costUsd: number | null;
+}
+
+export interface MultiProgressWindowOptions {
+  /** Mode name shown in the title bar (e.g. "review"). */
+  mode: string;
+  /** Epoch ms when the fan-out started — drives the overall elapsed timer. */
+  startedAt: number;
+  /** Live per-harness row state. */
+  getRows: () => RunRow[];
+  /** Show an "unrestricted permissions" warning banner. */
+  dangerous?: boolean;
+  /** Called when the user confirms cancel — must abort every in-flight run. */
+  onCancel: () => void;
+  /** Called when the user presses `m` (minimize — runs continue in the background). */
+  onMinimize: () => void;
+  /**
+   * Called when the user presses Esc or `m` while every row is already terminal — i.e. during the
+   * post-completion linger, before the caller tears the overlay down on its own timer. Lets a user
+   * who's still watching dismiss the finished board immediately instead of waiting it out. Optional
+   * so existing callers/tests that don't care about the linger keep working.
+   */
+  onDismiss?: () => void;
+}
+
+/** True once every row has reached a terminal state — the fan-out is fully done. Pure — testable
+ *  without a TUI. Used to gate the post-completion dismiss-on-any-key behavior. */
+export function isFanoutComplete(rows: RunRow[]): boolean {
+  return rows.length > 0 && rows.every(r => r.status === 'done' || r.status === 'failed');
+}
+
+/** Per-status glyphs, matching the row markers in the overlay so the chip and the window read alike. */
+const CHIP_GLYPHS: ReadonlyArray<readonly [RunStatus, string]> = [
+  ['done', '✓'],
+  ['failed', '✗'],
+  ['running', '▶'],
+  ['queued', '…'],
+];
+
+/**
+ * Compact fan-out status-bar summary, e.g. `1✓ 1✗ 1▶ 1… · ⏱ 0:42 · $0.123`. Zero status counts are
+ * omitted, so the common cases stay short (`4▶`, then `4✓`); the aggregate spend segment is
+ * likewise omitted until at least one run has actually reported a cost. Counting only `running` —
+ * as the first cut did — renders `0/4 running`, which reads as idle when runs have actually failed
+ * or are queued behind the cap. `elapsedMs` is passed in (rather than read via `Date.now()`
+ * internally) so this stays pure and testable without a TUI.
+ */
+export function formatFanoutChip(rows: RunRow[], elapsedMs: number): string {
+  const parts = CHIP_GLYPHS.map(([status, glyph]) => {
+    const n = rows.filter(r => r.status === status).length;
+    return n > 0 ? `${n}${glyph}` : null;
+  }).filter((s): s is string => s !== null);
+  const statusText = parts.length > 0 ? parts.join(' ') : `${rows.length}…`;
+
+  const costs = rows.map(r => r.costUsd).filter((c): c is number => typeof c === 'number');
+  const totalCost = costs.length > 0 ? costs.reduce((sum, c) => sum + c, 0) : null;
+
+  const segments = [statusText, `⏱ ${fmtElapsed(elapsedMs)}`];
+  if (totalCost !== null) segments.push(`$${totalCost.toFixed(3)}`);
+  return segments.join(' · ');
+}
+
+/** One row's marker + label, e.g. "✓ claude" / "✗ codex" / "⠋ opencode" / "… amp". Pure — testable
+ *  without a TUI/theme. */
+export function renderRowLabel(row: RunRow, frame: number): string {
+  const mark =
+    row.status === 'done'
+      ? '✓'
+      : row.status === 'failed'
+        ? '✗'
+        : row.status === 'running'
+          ? SPINNER[frame % SPINNER.length]
+          : '…';
+  return `${mark} ${row.harness}`;
+}
+
+/** Create the multi-run overlay component; disposes the spinner timer. */
+export function multiProgressWindow(
+  tui: TUI,
+  theme: Theme,
+  opts: MultiProgressWindowOptions,
+): Component & { dispose(): void } {
+  let frame = 0;
+  let armed = false;
+  let armTimer: ReturnType<typeof setTimeout> | null = null;
+  const timer = setInterval(() => {
+    frame++;
+    tui.requestRender();
+  }, SPIN_INTERVAL_MS);
+
+  const disarm = () => {
+    armed = false;
+    if (armTimer) {
+      clearTimeout(armTimer);
+      armTimer = null;
+    }
+  };
+
+  return {
+    render(width: number): string[] {
+      const inner = Math.max(10, width - 4);
+      const padTo = (s: string, w: number) => `${s}${' '.repeat(Math.max(1, w - visibleWidth(s)))}`;
+      const out: string[] = [];
+      const rows = opts.getRows();
+
+      const done = rows.filter(r => r.status === 'done' || r.status === 'failed').length;
+      const title = `${SPINNER[frame % SPINNER.length]} delegate all · ${opts.mode} · ${done}/${rows.length}`;
+      const status = `⏱ ${fmtElapsed(Date.now() - opts.startedAt)}`;
+      const titleStr = `${title} · ${status}`;
+      const dash = '─'.repeat(Math.max(1, inner - visibleWidth(titleStr) - 2));
+      out.push(theme.fg('accent', `╭─ ${titleStr} ${dash}─╮`));
+
+      if (opts.dangerous) {
+        const banner = theme.fg('error', '⚠ danger — unrestricted access');
+        out.push(`│ ${padTo(banner, inner)} │`);
+      }
+
+      for (const row of rows) {
+        const label = renderRowLabel(row, frame);
+        const styledLabel =
+          row.status === 'done'
+            ? theme.fg('success', label)
+            : row.status === 'failed'
+              ? theme.fg('error', label)
+              : theme.fg('accent', label);
+        const elapsed = row.startedAt !== null ? fmtElapsed(Date.now() - row.startedAt) : 'queued';
+        const activity = row.activity ? ` ${theme.fg('muted', row.activity)}` : '';
+        const line = `${styledLabel} ${theme.fg('dim', elapsed)}${activity}`;
+        out.push(`│ ${padTo(truncateToWidth(line, inner), inner)} │`);
+      }
+
+      const hint = isFanoutComplete(rows)
+        ? theme.fg('dim', 'esc/m dismiss')
+        : armed
+          ? theme.fg('warning', 'press esc again to cancel all') + theme.fg('dim', ' · m minimize')
+          : theme.fg('dim', 'esc cancel all') + theme.fg('dim', ' · m minimize');
+      out.push(`│ ${padTo(hint, inner)} │`);
+
+      out.push(theme.fg('accent', `╰${'─'.repeat(Math.max(1, width - 2))}╯`));
+      return out;
+    },
+    handleInput(data: string): void {
+      // Once every run has reached a terminal state, the overlay is just lingering on the
+      // finished board before the caller closes it on a timer — any Esc/m here dismisses it right
+      // away instead of making a user who's still watching wait out the linger.
+      if (isFanoutComplete(opts.getRows()) && opts.onDismiss) {
+        if (matchesKey(data, Key.escape) || data === 'm') {
+          disarm();
+          opts.onDismiss();
+        }
+        return;
+      }
+      if (matchesKey(data, Key.escape)) {
+        if (armed) {
+          disarm();
+          opts.onCancel();
+        } else {
+          armed = true;
+          armTimer = setTimeout(() => {
+            armed = false;
+            armTimer = null;
+            tui.requestRender();
+          }, 1500);
+          tui.requestRender();
+        }
+      } else if (data === 'm') {
+        disarm();
+        opts.onMinimize();
+      }
+    },
+    invalidate(): void {
+      // stateless render — nothing to clear
+    },
+    dispose(): void {
+      clearInterval(timer);
+      disarm();
+    },
+  };
+}

package/extensions/progress.ts

@@ -46,6 +46,15 @@ export function fmtElapsed(ms: number): string {
   return m > 0 ? `${m}:${String(s).padStart(2, '0')}` : `0:${String(s).padStart(2, '0')}`;
 }
 
+/**
+ * Slice a feed down to its last `max` entries, reporting how many were dropped so the caller can
+ * show a "+N earlier" marker instead of silently truncating with no hint older entries existed.
+ * Pure — testable without a TUI.
+ */
+export function truncateFeed<T>(entries: T[], max: number): { visible: T[]; hiddenCount: number } {
+  return { visible: entries.slice(-max), hiddenCount: Math.max(0, entries.length - max) };
+}
+
 /** Style one feed entry; the returned string may contain ANSI colors. */
 export function renderEntry(entry: FeedEntry, theme: Theme): string {
   switch (entry.kind) {
@@ -98,8 +107,13 @@ export function progressWindow(tui: TUI, theme: Theme, opts: ProgressWindowOptio
         out.push(`│ ${padTo(banner, inner)} │`);
       }
 
-      // feed
-      for (const entry of opts.getEntries().slice(-MAX_VISIBLE_ENTRIES)) {
+      // feed — "+N earlier" marker when older entries were dropped, instead of truncating silently
+      const { visible, hiddenCount } = truncateFeed(opts.getEntries(), MAX_VISIBLE_ENTRIES);
+      if (hiddenCount > 0) {
+        const marker = theme.fg('dim', `+${hiddenCount} earlier`);
+        out.push(`│ ${padTo(truncateToWidth(marker, inner), inner)} │`);
+      }
+      for (const entry of visible) {
         out.push(`│ ${padTo(truncateToWidth(renderEntry(entry, theme), inner), inner)} │`);
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-delegate",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Delegate work to any harness (Claude Code, Muse, OpenCode, Amp) from the pi coding agent \u2014 code reviews, plans, implementation, security audits, docs, or your own custom templates.",
   "type": "module",
   "packageManager": "bun@1.3.14",