pi-harness-delegate 0.4.0 → 0.4.1

package/README.md

@@ -68,7 +68,7 @@ delegate({ harness: "all", mode: "review", scope: "diff" })   # tool call form
   │ 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 (e.g. `● 1✓ 1✗ 1▶ 1…` — done, failed, running, queued; zero counts are omitted, so it reads `● 4▶` while all four are in flight). A harness that fails keeps its failure reason on its row rather than blanking, so the overlay still says *why*. Single-harness runs keep the original one-run overlay unchanged.
+  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
 

package/extensions/index.ts

@@ -110,6 +110,9 @@ interface DelegateOptions {
 
 /** 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 —
@@ -1339,6 +1342,7 @@ export default function (pi: ExtensionAPI) {
       startedAt: null,
       status: 'queued',
       activity: '',
+      costUsd: null,
     }));
     let requestRender: (() => void) | null = null;
 
@@ -1349,7 +1353,10 @@ export default function (pi: ExtensionAPI) {
       if (now - chipLastPush < 500) return;
       chipLastPush = now;
       const theme = ctx.ui.theme;
-      ctx.ui.setStatus('delegate', theme.fg('accent', '●') + theme.fg('dim', ` ${formatFanoutChip(rows)}`));
+      ctx.ui.setStatus(
+        'delegate',
+        theme.fg('accent', '●') + theme.fg('dim', ` ${formatFanoutChip(rows, now - overallStart)}`),
+      );
     };
 
     const runOne = async (spec: FanoutSpec, idx: number): Promise<FanoutOutcome> => {
@@ -1398,6 +1405,7 @@ export default function (pi: ExtensionAPI) {
       setRow({
         status: failed ? 'failed' : 'done',
         activity: failed ? reason || rows[idx].activity : '',
+        costUsd: !failed && result ? result.result.totalCostUsd : null,
       });
       return {
         harnessName: spec.harnessName,
@@ -1413,6 +1421,10 @@ export default function (pi: ExtensionAPI) {
     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) => {
@@ -1431,6 +1443,7 @@ export default function (pi: ExtensionAPI) {
                 overlayHandle?.setHidden(true);
                 overlayHandle?.unfocus();
               },
+              onDismiss: () => resolveDismiss(),
             });
           },
           {
@@ -1445,13 +1458,26 @@ export default function (pi: ExtensionAPI) {
         )
         .catch(() => {});
       outcomes = await allSettled;
-      await closeWhenMounted(() => closeWindow, 2000);
-      await uiPromise;
+      // 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();
     }
-    clearActive();
-    if (ctx.hasUI) ctx.ui.setStatus('delegate', undefined);
     return outcomes;
   };
 

package/extensions/progress-multi.ts

@@ -9,7 +9,8 @@
  * N row summaries).
  *
  * Controls: same as progressWindow — ESC twice to cancel (aborts every in-flight run), `m` to
- * minimize.
+ * 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';
@@ -32,6 +33,9 @@ export interface RunRow {
    * 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 {
@@ -47,6 +51,19 @@ export interface MultiProgressWindowOptions {
   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. */
@@ -58,17 +75,26 @@ const CHIP_GLYPHS: ReadonlyArray<readonly [RunStatus, string]> = [
 ];
 
 /**
- * Compact fan-out status-bar summary, e.g. `1✓ 1✗ 1▶ 1…`. Zero counts are omitted, so the common
- * cases stay short (`4▶`, then `4✓`). 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.
- * Pure — testable without a TUI.
+ * 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[]): string {
+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);
-  return parts.length > 0 ? parts.join(' ') : `${rows.length}…`;
+  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
@@ -140,15 +166,27 @@ export function multiProgressWindow(
         out.push(`│ ${padTo(truncateToWidth(line, inner), inner)} │`);
       }
 
-      const hint = 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');
+      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();

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.4.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",