shariq-pi-extensions 0.2.26 → 0.2.27

package/docs/ARCHITECTURE.md

@@ -17,7 +17,7 @@ docs/                            package-level maintenance documentation
 scripts/                         repository validation helpers
 ```
 
-Extension entrypoints register tools, commands, providers, events, or UI. Shared code stays in `extensions/shared` only when more than one extension owns the behavior. Provider-specific protocol and authentication code remains inside its provider directory. The background-terminal, orchestration, and subagent skills ship beside their extensions so a new machine receives the required lifecycle guidance with the tools.
+Extension entrypoints register tools, commands, providers, events, or UI. Shared code stays in `extensions/shared` only when more than one extension owns the behavior. The shared activity dock combines active Task List, terminal, subagent, and orchestration rows under one bounded widget; shared tool cards keep lifecycle operations compact in the timeline while preserving expanded output. Provider-specific protocol and authentication code remains inside its provider directory. The background-terminal, orchestration, and subagent skills ship beside their extensions so a new machine receives the required lifecycle guidance with the tools.
 
 ## Dependency model
 

package/docs/EXTENSIONS.md

@@ -44,13 +44,13 @@ State is stored in Pi session entries and reconstructed on resume, reload, and t
 
 The subagent extension runs flat Pi child agents with profiles, capability policies, continuation, result delivery, optional worktrees, pre-warmed task dispatch, instant cascading cancellation, cross-session persistence, and a dashboard. Configuration lives in `<agent-dir>/subagents.json`; trusted projects may override it through their Pi config directory. The configured concurrency ceiling is 50.
 
-The extension supplies tools including `spawn_agent`, `task`, `check_agent`, `list_agents`, `wait_agent`, `send_message`, `close_agent`, `reply_question`, and `apply_agent_changes`. All completed subagent snapshots and transcripts persist across Pi restarts (`<agent-dir>/subagents/runs/`), allowing `resume_from` to resume completed workers at any point. Interruption immediately cascades across all child fibers in `<10ms`. Child settlement stays in a private extension queue while the parent is active, then starts one custom-result turn at Pi's safe idle edge with the summary guaranteed in model context and never rendered as user-authored or follow-up input; status tools are for explicit inspection, not waiting.
+The extension supplies tools including `spawn_agent`, `task`, `check_agent`, `list_agents`, `wait_agent`, `send_message`, `close_agent`, `reply_question`, and `apply_agent_changes`. These lifecycle operations render as compact expandable main-chat cards; running children share the bounded Active work dock and completed counts no longer occupy footer space after settlement. All completed subagent snapshots and transcripts persist across Pi restarts (`<agent-dir>/subagents/runs/`), allowing `resume_from` to resume completed workers at any point. Interruption immediately cascades across all child fibers in `<10ms`. Child settlement stays in a private extension queue while the parent is active, then starts one custom-result turn at Pi's safe idle edge with the summary guaranteed in model context and never rendered as user-authored or follow-up input; status tools are for explicit inspection, not waiting.
 
 ### [Orchestration](../extensions/orchestration/README.md)
 
 The Orchestration extension coordinates explicitly requested large tasks through a dedicated orchestrator plus configurable explorer, frontend, backend, general-worker, and reviewer models. `/orchestration` opens the dashboard and `/orchestration settings` configures global role models. It reuses the canonical Subagents runtime, maintains a 10-worker pool per project, isolates Git writers in task worktrees, resumes the original worker for substantial review fixes, and applies final reviewed changes without committing or pushing.
 
-The model-facing `create_orchestration` tool starts planning only after an explicit orchestration request. `get_orchestration` reports status without advancing work. Interrupted runs recover paused under `<agent-dir>/orchestration/`.
+The model-facing `create_orchestration` tool starts planning only after an explicit orchestration request. `get_orchestration` reports status without advancing work. Both use compact expandable timeline cards, active runs share the Active work dock, and footer states distinguish plan-ready, blocked, running, and paused work. Dashboard editors and confirmations run outside the live overlay to avoid nested-input stalls. Interrupted runs recover paused under `<agent-dir>/orchestration/`.
 
 ### [Smart Compaction](../extensions/smart-compaction/README.md)
 
@@ -71,7 +71,7 @@ Key capabilities include:
 
 Managed PTYs support servers, watchers, long builds, downloads, and interactive processes. The extension tracks up to eight concurrent terminals, retains bounded output, stores full logs in restrictive temporary directories, and stops process groups during shutdown or reload.
 
-Its tools are `start_terminal`, `read_terminal`, `write_terminal`, `list_terminals`, and `stop_terminal`. A model-started terminal keeps completion or failure in a private extension queue while the parent is active, then starts one custom-result turn at Pi's safe idle edge with bounded output guaranteed in model context and never rendered as user-authored or follow-up input. Reading a terminal does not suppress that delivery; agents should inspect only for explicit progress requests or immediate interaction.
+Its tools are `start_terminal`, `read_terminal`, `write_terminal`, `list_terminals`, and `stop_terminal`. All use compact expandable main-chat cards, while running PTYs share the bounded Active work dock with elapsed time and a latest-output preview. A model-started terminal keeps completion or failure in a private extension queue while the parent is active, then starts one custom-result turn at Pi's safe idle edge with bounded output guaranteed in model context and never rendered as user-authored or follow-up input. Reading a terminal does not suppress that delivery; agents should inspect only for explicit progress requests or immediate interaction.
 
 ## Web access
 
@@ -91,7 +91,7 @@ Displays the estimated prompt and session contribution to the active context win
 
 ### [Performance status](../extensions/performance-status/README.md)
 
-Adds a responsive footer-area status row for each assistant message. Live TPS/output are marked as estimates; final TPS uses conventional decode throughput from first streamed token to message completion. TTFT and total elapsed time separately expose provider latency, prefill, and hidden reasoning; output tokens and active tools remain separate.
+Adds a responsive footer-area status row while each assistant message is active and for an eight-second completion linger, then clears it to avoid permanent footer noise. Live TPS/output are marked as estimates; final TPS uses conventional decode throughput from first streamed token to message completion. TTFT and total elapsed time separately expose provider latency, prefill, and hidden reasoning; output tokens and active tools remain separate.
 
 ### [Git info](../extensions/git-info/README.md)
 

package/extensions/background-terminals/README.md

@@ -10,7 +10,7 @@ Session-scoped background pseudo-terminals for Pi. The extension combines Codex-
 - `list_terminals` — list running and settled terminals.
 - `stop_terminal` — stop complete process groups with TERM-to-KILL escalation.
 
-Each output response carries a byte cursor. Pass it to the next read/write operation to avoid repeating output. Long or uncertain commands should use `start_terminal` instead of a large blocking `bash` timeout. Settlement stays in a private extension queue while the parent is active, then starts one custom-result turn at Pi's safe idle edge with bounded output guaranteed in model context and never rendered as user-authored or follow-up input, so the parent can continue other work or end its turn rather than poll.
+Each output response carries a byte cursor. Pass it to the next read/write operation to avoid repeating output. Terminal lifecycle tools render as compact main-chat cards with expandable output, and running terminals appear in the shared bounded **Active work** dock with elapsed time and the latest output line. Long or uncertain commands should use `start_terminal` instead of a large blocking `bash` timeout. Settlement stays in a private extension queue while the parent is active, then starts one custom-result turn at Pi's safe idle edge with bounded output guaranteed in model context and never rendered as user-authored or follow-up input, so the parent can continue other work or end its turn rather than poll.
 
 ## User interface
 

package/extensions/background-terminals/index.ts

@@ -3,23 +3,27 @@ import * as path from "node:path";
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
+  ExtensionContext,
   ExtensionUIContext,
 } from "@earendil-works/pi-coding-agent";
-import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { formatSize, getMarkdownTheme } from "@earendil-works/pi-coding-agent";
 import { Markdown, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { clearActivitySource, setActivitySource } from "../shared/activity-dock.ts";
 import { settlementDelivery } from "../shared/settlement-delivery.ts";
-import { oneLine, sanitizeTerminalText, stateLabel } from "../shared/tui-dashboard.ts";
+import { toolCallCard, toolResultCard } from "../shared/tool-card.ts";
+import { formatDurationMs, oneLine, sanitizeTerminalText, stateLabel } from "../shared/tui-dashboard.ts";
 import { TerminalManager, MAX_RUNNING_TERMINALS } from "./src/manager.ts";
 import {
   formatCompletion,
   formatReadResult,
   formatTerminal,
 } from "./src/presentation.ts";
-import type { TerminalReadResult, TerminalSnapshot } from "./src/types.ts";
+import { terminalElapsedMs, type TerminalReadResult, type TerminalSnapshot } from "./src/types.ts";
 import { openTerminalDashboard } from "./src/ui.ts";
 
 const STATUS_KEY = "background-terminals";
+const ACTIVITY_SOURCE = "background-terminals";
 
 function titleFrom(command: string, title?: string): string {
   const requested = oneLine(title ?? "").slice(0, 100);
@@ -39,6 +43,7 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
   const deliverSettlement = settlementDelivery(pi);
   let manager: TerminalManager | undefined;
   let ui: ExtensionUIContext | undefined;
+  let activityContext: ExtensionContext | undefined;
   let unsubscribe: (() => void) | undefined;
   let lastStatus = "";
   const pendingResults = new Map<string, TerminalSnapshot>();
@@ -79,6 +84,21 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
     const next = running > 0
       ? `${running} background terminal${running === 1 ? "" : "s"} · /term`
       : "";
+    if (activityContext) {
+      setActivitySource(activityContext, ACTIVITY_SOURCE, terminals
+        .filter((terminal) => terminal.status === "running")
+        .map((terminal) => {
+          const latest = sanitizeTerminalText(terminal.output.text).split(/\r?\n/).filter(Boolean).at(-1);
+          return {
+            id: terminal.id,
+            label: "Terminal",
+            title: terminal.title,
+            detail: `${formatDurationMs(terminalElapsedMs(terminal))}${latest ? ` · ${oneLine(latest)}` : ""}`,
+            state: "active" as const,
+            priority: 50,
+          };
+        }));
+    }
     if (next === lastStatus) return;
     lastStatus = next;
     if (!next) ui.setStatus(STATUS_KEY, undefined);
@@ -108,7 +128,11 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
   }
 
   pi.on("session_start", (_event, ctx) => {
-    if (ctx.hasUI) ui = ctx.ui;
+    if (ctx.hasUI) {
+      ui = ctx.ui;
+      activityContext = ctx;
+      updateStatus();
+    }
   });
 
   pi.on("session_shutdown", async () => {
@@ -118,6 +142,8 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
     unsubscribe?.();
     unsubscribe = undefined;
     ui?.setStatus(STATUS_KEY, undefined);
+    if (activityContext) clearActivitySource(activityContext, ACTIVITY_SOURCE);
+    activityContext = undefined;
     ui = undefined;
     lastStatus = "";
     const closing = manager;
@@ -236,6 +262,15 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
         },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "terminal read", args.id, `cursor ${args.cursor ?? "tail"}`), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Reading terminal…"), 0, 0);
+      const details = result.details as { id?: string; status?: string; cursor?: number; omittedBytes?: number } | undefined;
+      const state = details?.status === "failed" ? "error" : details?.status === "running" ? "active" : "success";
+      return new Text(toolResultCard(result, expanded, theme, state, details?.id ?? "terminal", `${details?.status ?? "unknown"} · cursor ${details?.cursor ?? "?"}${details?.omittedBytes ? ` · ${formatSize(details.omittedBytes)} omitted` : ""}`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -273,6 +308,16 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
         },
       };
     },
+    renderCall(args, theme) {
+      const input = args.input === "\u0003" ? "Ctrl+C" : `${Array.from(args.input ?? "").length} chars${args.press_enter === false ? "" : " + Enter"}`;
+      return new Text(toolCallCard(theme, "terminal input", args.id, input), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Sending terminal input…"), 0, 0);
+      const details = result.details as { id?: string; status?: string; cursor?: number } | undefined;
+      const state = details?.status === "failed" ? "error" : details?.status === "running" ? "active" : "success";
+      return new Text(toolResultCard(result, expanded, theme, state, details?.id ?? "terminal", `${details?.status ?? "unknown"} · cursor ${details?.cursor ?? "?"}`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -287,6 +332,15 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
         details: { terminals: terminals.map((terminal) => ({ id: terminal.id, title: terminal.title, status: terminal.status, pid: terminal.pid })) },
       };
     },
+    renderCall(_args, theme) {
+      return new Text(toolCallCard(theme, "terminals", "list managed PTYs"), 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { terminals?: Array<{ status?: string }> } | undefined;
+      const terminals = details?.terminals ?? [];
+      const running = terminals.filter((terminal) => terminal.status === "running").length;
+      return new Text(toolResultCard(result, expanded, theme, running ? "active" : "muted", "terminals", `${terminals.length} tracked · ${running} running`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -305,6 +359,16 @@ export default function backgroundTerminals(pi: ExtensionAPI) {
         details: { terminals: terminals.map((terminal) => ({ id: terminal.id, status: terminal.status, exitCode: terminal.exitCode })) },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "terminal stop", `${args.ids?.length ?? 0} terminal${args.ids?.length === 1 ? "" : "s"}`, (args.ids ?? []).join(", ")), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Stopping terminals…"), 0, 0);
+      const details = result.details as { terminals?: Array<{ status?: string }> } | undefined;
+      const terminals = details?.terminals ?? [];
+      const failed = terminals.some((terminal) => terminal.status === "failed");
+      return new Text(toolResultCard(result, expanded, theme, failed ? "error" : "success", "terminals stopped", `${terminals.length} terminal${terminals.length === 1 ? "" : "s"}`), 0, 0);
+    },
   });
 
   pi.registerMessageRenderer(

package/extensions/git-info/index.ts

@@ -18,15 +18,13 @@ const REFRESH_DEBOUNCE_MS = 150;
 function statusText(ui: ExtensionUIContext, summary: GitSummary): string | undefined {
   if (!summary.isRepository || !summary.branch) return undefined;
   const changed = summary.changedFiles === 0
-    ? ui.theme.fg("muted", "clean")
-    : ui.theme.fg(
-        "warning",
-        `${summary.changedFiles} changed ${summary.changedFiles === 1 ? "file" : "files"}`,
-      );
+    ? ui.theme.fg("muted", "✓")
+    : ui.theme.fg("warning", `+${summary.changedFiles}`);
   const pr = summary.pullRequest
     ? ` · ${ui.theme.fg("accent", `PR #${summary.pullRequest.number}${summary.pullRequest.draft ? " draft" : ""}`)}`
     : "";
-  return `${ui.theme.fg("muted", "git")} ${ui.theme.fg("accent", summary.branch)} · ${changed}${pr} · ${ui.theme.fg("dim", "/lg")}`;
+  const command = summary.changedFiles > 0 || summary.pullRequest ? ` · ${ui.theme.fg("dim", "/lg")}` : "";
+  return `${ui.theme.fg("muted", "git")} ${ui.theme.fg("accent", summary.branch)} ${changed}${pr}${command}`;
 }
 
 export default function gitInfoExtension(pi: ExtensionAPI) {

package/extensions/orchestration/README.md

@@ -31,7 +31,7 @@ Each project has up to 10 concurrent worker, explorer, or reviewer sessions. The
 
 ## Dashboard
 
-`/orchestration` opens the full-screen operations dashboard.
+Orchestration creation and inspection render as compact main-chat cards with expandable detail. Active runs appear in the shared bounded **Active work** dock; plan-ready and blocked runs are prioritized as attention states. `/orchestration` opens the full-screen operations dashboard. Dashboard actions close the overlay before opening editors, settings, or confirmation prompts, then return to the live dashboard so nested UI cannot stall.
 
 - `j` / `k`: select a run
 - `Enter`: inspect tasks and reviews
@@ -40,7 +40,7 @@ Each project has up to 10 concurrent worker, explorer, or reviewer sessions. The
 - `a`: approve the initial plan
 - `f`: give plan feedback
 - `p`: pause, resume, or recover
-- `x`: cancel while preserving artifacts
+- `x`: leave the dashboard and confirm cancellation while preserving artifacts
 - `Esc`: go back or close
 
 Interrupted runs recover in a paused state and require explicit resume. Run state is machine-local under Pi's active agent directory at `orchestration/runs/<run-id>/`.

package/extensions/orchestration/dashboard.ts

@@ -12,81 +12,96 @@ import {
 import type { OrchestrationEngine } from "./engine.ts";
 import type { OrchestrationRun } from "./types.ts";
 
-interface DashboardActions {
-  create(): void;
-  settings(): void;
-  feedback(run: OrchestrationRun): void;
-  approve(run: OrchestrationRun): void;
-  togglePause(run: OrchestrationRun): void;
-  cancel(run: OrchestrationRun): void;
-}
+export type OrchestrationDashboardAction =
+  | { kind: "close" }
+  | { kind: "create" }
+  | { kind: "settings" }
+  | { kind: "feedback"; id: string }
+  | { kind: "approve"; id: string }
+  | { kind: "toggle-pause"; id: string }
+  | { kind: "cancel"; id: string };
 
 type Theme = ExtensionContext["ui"]["theme"];
 
 class OrchestrationDashboard {
   private selected = 0;
+  private selectedId?: string;
   private detail = false;
   private unsubscribe: () => void;
   private readonly tui: TUI;
   private readonly theme: Theme;
   private readonly keys: KeybindingsManager;
   private readonly engine: OrchestrationEngine;
-  private readonly actions: DashboardActions;
-  private readonly close: () => void;
+  private readonly done: (action: OrchestrationDashboardAction) => void;
+  private closed = false;
 
   constructor(
     tui: TUI,
     theme: Theme,
     keys: KeybindingsManager,
     engine: OrchestrationEngine,
-    actions: DashboardActions,
-    close: () => void,
+    done: (action: OrchestrationDashboardAction) => void,
   ) {
     this.tui = tui;
     this.theme = theme;
     this.keys = keys;
     this.engine = engine;
-    this.actions = actions;
-    this.close = close;
+    this.done = done;
     this.unsubscribe = engineChangeSubscription(engine, () => tui.requestRender());
   }
 
-  dispose() {
+  private close(action: OrchestrationDashboardAction) {
+    if (this.closed) return;
+    this.closed = true;
     this.unsubscribe();
+    this.done(action);
+  }
+
+  dispose() {
+    if (!this.closed) this.unsubscribe();
+    this.closed = true;
   }
 
   invalidate() {}
 
+  private reconcileSelection(runs: OrchestrationRun[]) {
+    const stable = this.selectedId ? runs.findIndex((run) => run.id === this.selectedId) : -1;
+    this.selected = stable >= 0 ? stable : Math.min(this.selected, Math.max(0, runs.length - 1));
+    this.selectedId = runs[this.selected]?.id;
+  }
+
   handleInput(data: string) {
     const runs = this.engine.list();
+    this.reconcileSelection(runs);
     if (matchesKey(data, Key.escape)) {
       if (this.detail) this.detail = false;
       else {
-        this.dispose();
-        this.close();
+        this.close({ kind: "close" });
         return;
       }
     } else if (!this.detail && (this.keys.matches(data, "tui.select.up") || data === "k")) {
       this.selected = Math.max(0, this.selected - 1);
+      this.selectedId = runs[this.selected]?.id;
     } else if (!this.detail && (this.keys.matches(data, "tui.select.down") || data === "j")) {
       this.selected = Math.min(Math.max(0, runs.length - 1), this.selected + 1);
+      this.selectedId = runs[this.selected]?.id;
     } else if (!this.detail && this.keys.matches(data, "tui.select.confirm") && runs[this.selected]) {
       this.detail = true;
-    } else if (data === "n") this.actions.create();
-    else if (data === "s") this.actions.settings();
+    } else if (data === "n") this.close({ kind: "create" });
+    else if (data === "s") this.close({ kind: "settings" });
     else if (this.detail && runs[this.selected]) {
       const run = runs[this.selected];
-      if (data === "a" && run.status === "awaiting-approval") this.actions.approve(run);
-      else if (data === "f" && run.status === "awaiting-approval") this.actions.feedback(run);
-      else if (data === "p") this.actions.togglePause(run);
-      else if (data === "x") this.actions.cancel(run);
+      if (data === "a" && run.status === "awaiting-approval") this.close({ kind: "approve", id: run.id });
+      else if (data === "f" && run.status === "awaiting-approval") this.close({ kind: "feedback", id: run.id });
+      else if (data === "p") this.close({ kind: "toggle-pause", id: run.id });
+      else if (data === "x") this.close({ kind: "cancel", id: run.id });
     }
     this.tui.requestRender();
   }
 
   render(width: number) {
     const runs = this.engine.list();
-    this.selected = Math.min(this.selected, Math.max(0, runs.length - 1));
+    this.reconcileSelection(runs);
     const lines = this.detail && runs[this.selected]
       ? this.renderDetail(runs[this.selected], width)
       : this.renderList(runs, width);
@@ -109,7 +124,12 @@ class OrchestrationDashboard {
       this.theme.fg("borderMuted", "─".repeat(Math.max(0, width))),
     ];
     if (!runs.length) lines.push(this.theme.fg("muted", "No runs yet. Press n to create one."));
-    for (const [index, run] of runs.entries()) {
+    const rows = this.tui.terminal.rows || 30;
+    const visibleCount = Math.max(1, Math.floor((rows - 5) / 2));
+    const start = Math.min(Math.max(0, this.selected - Math.floor(visibleCount / 2)), Math.max(0, runs.length - visibleCount));
+    const visible = runs.slice(start, start + visibleCount);
+    for (const [offset, run] of visible.entries()) {
+      const index = start + offset;
       const marker = index === this.selected ? this.theme.fg("accent", "❯") : " ";
       const complete = run.tasks.filter((task) => task.status === "completed").length;
       const color = run.status === "completed" ? "success" : run.status === "blocked" ? "error" : run.status === "running" ? "warning" : "muted";
@@ -122,8 +142,13 @@ class OrchestrationDashboard {
       );
       lines.push(`    ${this.theme.fg("dim", `${run.id} · ${run.cwd}`)}`);
     }
+    if (start > 0) lines.splice(2, 0, this.theme.fg("dim", `  ↑ ${start} more`));
+    const below = runs.length - start - visible.length;
+    if (below > 0) lines.push(this.theme.fg("dim", `  ↓ ${below} more`));
     lines.push("", this.theme.fg("dim", "j/k select · enter open · n new · s settings · esc close"));
-    return lines;
+    const maxRows = Math.max(8, rows);
+    if (lines.length <= maxRows) return lines;
+    return [...lines.slice(0, maxRows - 2), this.theme.fg("dim", "… more runs"), lines.at(-1)!];
   }
 
   private renderDetail(run: OrchestrationRun, width: number) {
@@ -161,7 +186,9 @@ class OrchestrationDashboard {
       "esc back",
     ].filter(Boolean).join(" · ");
     lines.push("", this.theme.fg("dim", controls));
-    return lines;
+    const maxRows = Math.max(8, (this.tui.terminal.rows || 30) - 2);
+    if (lines.length <= maxRows) return lines;
+    return [...lines.slice(0, maxRows - 2), this.theme.fg("dim", "… more tasks in run state"), lines.at(-1)!];
   }
 }
 
@@ -179,11 +206,10 @@ function engineChangeSubscription(engine: OrchestrationEngine, listener: () => v
 export async function openOrchestrationDashboard(
   ctx: ExtensionContext,
   engine: OrchestrationEngine,
-  actions: DashboardActions,
 ) {
-  await ctx.ui.custom<void>(
+  return ctx.ui.custom<OrchestrationDashboardAction>(
     (tui, theme, keys, done) =>
-      new OrchestrationDashboard(tui, theme, keys, engine, actions, () => done(undefined)),
+      new OrchestrationDashboard(tui, theme, keys, engine, done),
     {
       overlay: true,
       overlayOptions: { anchor: "center", width: "100%", maxHeight: "100%" },

package/extensions/orchestration/index.ts

@@ -3,7 +3,11 @@ import type {
   ExtensionContext,
   ExtensionUIContext,
 } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { clearActivitySource, setActivitySource } from "../shared/activity-dock.ts";
+import { toolCallCard, toolResultCard } from "../shared/tool-card.ts";
+import { oneLine, stateLabel } from "../shared/tui-dashboard.ts";
 import {
   requestSubagentCoordinator,
   type SubagentCoordinator,
@@ -33,16 +37,36 @@ export default function orchestration(pi: ExtensionAPI) {
   const updateStatus = () => {
     if (!ui || !engine) return;
     const active = engine.list().filter((run) => !["completed", "cancelled"].includes(run.status));
+    if (context) {
+      setActivitySource(context, "orchestration", active.map((run) => {
+        const done = run.tasks.filter((task) => task.status === "completed").length;
+        const attention = run.status === "awaiting-approval";
+        return {
+          id: run.id,
+          label: "Orchestration",
+          title: run.objective,
+          detail: `${attention ? "plan ready for review" : run.status} · ${done}/${run.tasks.length}`,
+          state: run.status === "blocked" ? "error" as const : attention ? "warning" as const : ["planning", "running"].includes(run.status) ? "active" as const : "muted" as const,
+          priority: attention ? 120 : run.status === "blocked" ? 110 : 45,
+        };
+      }));
+    }
     if (!active.length) {
       ui.setStatus("orchestration", undefined);
       return;
     }
-    const running = active.filter((run) => run.status === "running" || run.status === "planning").length;
+    const awaiting = active.filter((run) => run.status === "awaiting-approval").length;
     const blocked = active.filter((run) => run.status === "blocked").length;
-    ui.setStatus(
-      "orchestration",
-      `${ui.theme.fg(blocked ? "error" : running ? "warning" : "muted", "■")} orchestration ${running} running${blocked ? ` · ${blocked} blocked` : ""}`,
-    );
+    const running = active.filter((run) => run.status === "running" || run.status === "planning").length;
+    const paused = active.filter((run) => ["paused", "interrupted"].includes(run.status)).length;
+    const text = awaiting
+      ? `${awaiting} plan${awaiting === 1 ? "" : "s"} ready · /orchestration`
+      : blocked
+        ? `${blocked} blocked · /orchestration`
+        : running
+          ? `${running} running · /orchestration`
+          : `${paused} paused · /orchestration`;
+    ui.setStatus("orchestration", stateLabel(ui.theme, awaiting || blocked ? "warning" : running ? "active" : "muted", `Orchestration ${text}`));
   };
 
   const requireEngine = () => {
@@ -81,38 +105,41 @@ export default function orchestration(pi: ExtensionAPI) {
     }
   };
 
-  const runAction = (operation: () => Promise<unknown>) => {
-    void operation().catch((error) =>
-      ui?.notify(error instanceof Error ? error.message : String(error), "error"),
-    );
-  };
-
   const openDashboard = async (ctx: ExtensionContext) => {
     const current = requireEngine();
-    await openOrchestrationDashboard(ctx, current, {
-      create: () => runAction(() => createFromUi(ctx)),
-      settings: () => runAction(() => openOrchestrationSettings(ctx)),
-      feedback: (run) =>
-        runAction(async () => {
+    while (true) {
+      const action = await openOrchestrationDashboard(ctx, current);
+      if (action.kind === "close") return;
+      try {
+        if (action.kind === "create") {
+          await createFromUi(ctx);
+          continue;
+        }
+        if (action.kind === "settings") {
+          await openOrchestrationSettings(ctx);
+          continue;
+        }
+        const run = current.get(action.id);
+        if (!run) {
+          ctx.ui.notify(`Orchestration ${action.id} is no longer available.`, "warning");
+          continue;
+        }
+        if (action.kind === "feedback") {
           const feedback = await ctx.ui.editor("Plan feedback", "Tell the orchestrator what to change…");
           if (feedback?.trim()) await current.feedback(run.id, feedback);
-        }),
-      approve: (run) => runAction(() => current.approve(run.id)),
-      togglePause: (run) =>
-        runAction(() =>
-          ["paused", "interrupted", "blocked"].includes(run.status)
-            ? current.resume(run.id)
-            : current.pause(run.id),
-        ),
-      cancel: (run) =>
-        runAction(async () => {
-          const confirmed = await ctx.ui.confirm(
-            "Cancel orchestration?",
-            `Stop ${run.id} and preserve its run artifacts?`,
-          );
+        } else if (action.kind === "approve") {
+          await current.approve(run.id);
+        } else if (action.kind === "toggle-pause") {
+          if (["paused", "interrupted", "blocked"].includes(run.status)) await current.resume(run.id);
+          else await current.pause(run.id);
+        } else if (action.kind === "cancel") {
+          const confirmed = await ctx.ui.confirm("Cancel orchestration?", `Stop ${run.id} and preserve its run artifacts?`);
           if (confirmed) await current.cancel(run.id);
-        }),
-    });
+        }
+      } catch (error) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      }
+    }
   };
 
   pi.on("session_start", async (_event, ctx) => {
@@ -150,8 +177,9 @@ export default function orchestration(pi: ExtensionAPI) {
     engine?.stop();
     engine = undefined;
     coordinator = undefined;
-    context = undefined;
     ui?.setStatus("orchestration", undefined);
+    if (context) clearActivitySource(context, "orchestration");
+    context = undefined;
     ui = undefined;
   });
 
@@ -209,6 +237,14 @@ export default function orchestration(pi: ExtensionAPI) {
         details: { id: run.id, status: run.status, cwd: run.cwd },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "orchestration create", oneLine(args.objective).slice(0, 100), args.cwd ?? "current workspace"), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Starting orchestration…"), 0, 0);
+      const details = result.details as { id?: string; status?: string; cwd?: string } | undefined;
+      return new Text(toolResultCard(result, expanded, theme, "active", details?.id ?? "orchestration", `${details?.status ?? "planning"} · ${details?.cwd ?? "workspace"} · /orchestration`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -239,5 +275,16 @@ export default function orchestration(pi: ExtensionAPI) {
         details: { runs },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "orchestration inspect", args.id ?? "all runs"), 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { runs?: Array<{ status?: string; tasks?: Array<{ status?: string }> }> } | undefined;
+      const runs = details?.runs ?? [];
+      const attention = runs.filter((run) => run.status === "awaiting-approval" || run.status === "blocked").length;
+      const done = runs.reduce((total, run) => total + (run.tasks?.filter((task) => task.status === "completed").length ?? 0), 0);
+      const total = runs.reduce((count, run) => count + (run.tasks?.length ?? 0), 0);
+      return new Text(toolResultCard(result, expanded, theme, attention ? "warning" : runs.some((run) => run.status === "running" || run.status === "planning") ? "active" : "muted", "orchestration", `${runs.length} run${runs.length === 1 ? "" : "s"} · ${done}/${total} tasks${attention ? ` · ${attention} need attention` : ""}`), 0, 0);
+    },
   });
 }

package/extensions/performance-status/index.ts

@@ -15,6 +15,7 @@ interface GenerationMetrics {
 
 const STATUS_ID = "generation-performance";
 const RENDER_INTERVAL_MS = 100;
+const DONE_LINGER_MS = 8_000;
 
 function duration(seconds: number) {
   if (!Number.isFinite(seconds) || seconds < 0) return "—";
@@ -86,8 +87,24 @@ export function formatPerformanceStatus(
 export default function performanceStatus(pi: ExtensionAPI) {
   const metrics: GenerationMetrics = { streamedChars: 0, phase: "idle" };
   let renderTimer: ReturnType<typeof setTimeout> | undefined;
+  let doneTimer: ReturnType<typeof setTimeout> | undefined;
   let lastRenderAt = 0;
 
+  const cancelDoneTimer = () => {
+    if (!doneTimer) return;
+    clearTimeout(doneTimer);
+    doneTimer = undefined;
+  };
+
+  const scheduleDoneHide = (ctx: ExtensionContext) => {
+    cancelDoneTimer();
+    doneTimer = setTimeout(() => {
+      doneTimer = undefined;
+      if (metrics.phase === "done" && ctx.hasUI) ctx.ui.setStatus(STATUS_ID, undefined);
+    }, DONE_LINGER_MS);
+    doneTimer.unref?.();
+  };
+
   const render = (ctx: ExtensionContext, immediate = false) => {
     if (!ctx.hasUI || metrics.phase === "idle") return;
     const now = Date.now();
@@ -110,6 +127,7 @@ export default function performanceStatus(pi: ExtensionAPI) {
   };
 
   pi.on("turn_start", (_event, ctx) => {
+    cancelDoneTimer();
     metrics.requestStartedAt = Date.now();
     metrics.firstTokenAt = undefined;
     metrics.completedAt = undefined;
@@ -136,6 +154,7 @@ export default function performanceStatus(pi: ExtensionAPI) {
       metrics.exactOutputTokens = update.message.usage.output;
       metrics.phase = "done";
       render(ctx, true);
+      scheduleDoneHide(ctx);
     }
   });
 
@@ -145,9 +164,11 @@ export default function performanceStatus(pi: ExtensionAPI) {
     metrics.exactOutputTokens = event.message.usage.output;
     metrics.phase = "done";
     render(ctx, true);
+    scheduleDoneHide(ctx);
   });
 
   pi.on("tool_execution_start", (event, ctx) => {
+    cancelDoneTimer();
     metrics.activeTool = event.toolName;
     metrics.phase = "tool";
     render(ctx, true);
@@ -157,6 +178,7 @@ export default function performanceStatus(pi: ExtensionAPI) {
     metrics.activeTool = undefined;
     metrics.phase = metrics.completedAt ? "done" : "generating";
     render(ctx, true);
+    if (metrics.phase === "done") scheduleDoneHide(ctx);
   });
 
   pi.on("session_start", (_event, ctx) => {
@@ -166,6 +188,7 @@ export default function performanceStatus(pi: ExtensionAPI) {
   pi.on("session_shutdown", (_event, ctx) => {
     if (renderTimer) clearTimeout(renderTimer);
     renderTimer = undefined;
+    cancelDoneTimer();
     if (ctx.hasUI) ctx.ui.setStatus(STATUS_ID, undefined);
   });
 }

package/extensions/pi-memory/index.ts

@@ -288,7 +288,7 @@ export default function piMemory(pi: ExtensionAPI) {
       return;
     }
     service.initialize(ctx.cwd);
-    ctx.ui.setStatus("pi-memory", `memory ${service.status().memories}`);
+    ctx.ui.setStatus("pi-memory", undefined);
     void service.processPending(ctx, 1);
   });
 
@@ -307,9 +307,7 @@ export default function piMemory(pi: ExtensionAPI) {
   pi.on("agent_settled", async (_event, ctx) => {
     if (!active(ctx)) return;
     service.enqueueCurrentSession(ctx, projectFor(ctx));
-    void service.processPending(ctx, 1).then(() => {
-      if (ctx.hasUI) ctx.ui.setStatus("pi-memory", `memory ${service.status().memories}`);
-    });
+    void service.processPending(ctx, 1);
   });
 
   pi.on("session_before_compact", async (_event, ctx) => {

package/extensions/shared/README.md

@@ -4,12 +4,14 @@ Internal runtime utilities used by more than one extension. This directory is no
 
 ## Modules
 
+- `activity-dock.ts` aggregates bounded urgency-ordered live rows from Task List, Background Terminals, Subagents, and Orchestration into one automatic widget.
 - `activity-status.ts` formats compact running/completed/failed status counts.
 - `child-session.ts` owns trust-aware child resources and bounded session shutdown.
 - `context-utilization.ts` formats model-context usage and capacity.
 - `dashboard-state.ts` keeps list selection stable as live rows change.
 - `settlement-delivery.ts` coordinates asynchronous output in a private package-wide queue and starts one custom-result turn at Pi's safe idle edge, guaranteeing model-visible context without user-authored or follow-up rendering.
 - `tool-call-timeout.ts` applies cancellation-aware execution limits to registered tools.
+- `tool-card.ts` provides compact lifecycle call/result cards with expandable tool output.
 - `tui-dashboard.ts` provides bounded, sanitized terminal-dashboard rendering helpers.
 
 Keep extension-specific behavior in its owning `extensions/<name>` directory. Move code here only when multiple extensions genuinely share the same runtime contract.

package/extensions/shared/activity-dock.ts

@@ -0,0 +1,100 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { oneLine } from "./tui-dashboard.ts";
+
+const WIDGET_ID = "active-work";
+const MAX_VISIBLE_ITEMS = 5;
+
+export type ActivityState = "active" | "success" | "warning" | "error" | "muted";
+
+export type ActivityItem = {
+  id: string;
+  label: string;
+  title: string;
+  detail?: string;
+  state: ActivityState;
+  priority?: number;
+};
+
+let activeUi: ExtensionContext["ui"] | undefined;
+const sources = new Map<string, ActivityItem[]>();
+
+function color(state: ActivityState): "accent" | "success" | "warning" | "error" | "muted" {
+  if (state === "active") return "accent";
+  return state;
+}
+
+function glyph(state: ActivityState) {
+  if (state === "active") return "◆";
+  if (state === "success") return "✓";
+  if (state === "warning") return "!";
+  if (state === "error") return "×";
+  return "○";
+}
+
+function bind(ctx: ExtensionContext) {
+  if (activeUi === ctx.ui) return;
+  activeUi?.setWidget(WIDGET_ID, undefined);
+  activeUi = ctx.ui;
+  sources.clear();
+}
+
+function allItems() {
+  return [...sources.entries()]
+    .flatMap(([source, items]) => items.map((item, index) => ({ source, index, item })))
+    .sort((left, right) =>
+      (right.item.priority ?? 0) - (left.item.priority ?? 0) ||
+      left.source.localeCompare(right.source) ||
+      left.index - right.index,
+    )
+    .map(({ item }) => item);
+}
+
+function publish(ctx: ExtensionContext) {
+  bind(ctx);
+  const items = allItems();
+  if (!ctx.hasUI || items.length === 0) {
+    ctx.ui.setWidget(WIDGET_ID, undefined);
+    return;
+  }
+  ctx.ui.setWidget(WIDGET_ID, (_tui, theme) => ({
+    render(width: number) {
+      const current = allItems();
+      const shown = current.slice(0, MAX_VISIBLE_ITEMS);
+      const lines = [truncateToWidth(
+        `${theme.fg("accent", theme.bold("Active work"))} ${theme.fg("muted", `${current.length}`)}`,
+        width,
+      )];
+      for (const item of shown) {
+        const tone = color(item.state);
+        const detail = item.detail ? theme.fg("dim", ` · ${oneLine(item.detail)}`) : "";
+        lines.push(truncateToWidth(
+          `${theme.fg(tone, glyph(item.state))} ${theme.fg("muted", item.label)} ${theme.fg(tone === "muted" ? "muted" : "text", oneLine(item.title))}${detail}`,
+          width,
+        ));
+      }
+      if (current.length > shown.length) {
+        lines.push(truncateToWidth(theme.fg("dim", `… +${current.length - shown.length} more · open the relevant dashboard`), width));
+      }
+      return lines;
+    },
+    invalidate() {},
+  }));
+}
+
+export function setActivitySource(ctx: ExtensionContext, source: string, items: ActivityItem[]) {
+  bind(ctx);
+  if (items.length) sources.set(source, items.map((item) => ({ ...item })));
+  else sources.delete(source);
+  publish(ctx);
+}
+
+export function clearActivitySource(ctx: ExtensionContext, source: string) {
+  bind(ctx);
+  sources.delete(source);
+  publish(ctx);
+}
+
+export function activityDockSnapshot() {
+  return allItems().map((item) => ({ ...item }));
+}

package/extensions/shared/tool-card.ts

@@ -0,0 +1,39 @@
+import { oneLine, stateLabel } from "./tui-dashboard.ts";
+
+export type ToolCardState = "active" | "success" | "warning" | "error" | "muted";
+
+type ThemeLike = {
+  fg(color: string, text: string): string;
+  bold(text: string): string;
+};
+
+type ToolResultLike = {
+  content?: Array<{ type?: string; text?: string }>;
+};
+
+export function toolCallCard(
+  theme: ThemeLike,
+  label: string,
+  title: string,
+  detail?: string,
+) {
+  return `${theme.fg("toolTitle", theme.bold(label))} ${theme.fg("accent", oneLine(title))}${detail ? `\n${theme.fg("dim", oneLine(detail))}` : ""}`;
+}
+
+export function toolResultCard(
+  result: ToolResultLike,
+  expanded: boolean,
+  theme: ThemeLike,
+  state: ToolCardState,
+  label: string,
+  summary: string,
+) {
+  const header = `${stateLabel(theme as never, state, label)} ${theme.fg("muted", oneLine(summary))}`;
+  if (!expanded) return `${header}\n${theme.fg("dim", "ctrl+o to expand")}`;
+  const body = result.content
+    ?.filter((item) => item.type === "text" && item.text)
+    .map((item) => item.text ?? "")
+    .join("\n")
+    .trim();
+  return body ? `${header}\n${theme.fg("toolOutput", body)}` : header;
+}

package/extensions/smart-compaction/index.ts

@@ -25,11 +25,11 @@ export function createSmartCompactionExtension(options: SmartCompactionExtension
 
     const updateStatus = () => {
       if (!ui) return;
-      if (!config.enabled) {
+      if (!config.enabled || config.model === "inherit") {
         ui.setStatus(STATUS_KEY, undefined);
         return;
       }
-      const modelLabel = config.model === "inherit" ? "inherit" : config.model.split("/").pop() ?? config.model;
+      const modelLabel = config.model.split("/").pop() ?? config.model;
       ui.setStatus(STATUS_KEY, `compact: ${modelLabel}`);
     };
 
@@ -43,6 +43,7 @@ export function createSmartCompactionExtension(options: SmartCompactionExtension
         return undefined;
       }
 
+      if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, "compacting…");
       try {
         const compaction = await runSmartCompaction({
           event,
@@ -57,6 +58,8 @@ export function createSmartCompactionExtension(options: SmartCompactionExtension
         const message = error instanceof Error ? error.message : String(error);
         ctx.ui?.notify(`Smart Compaction failed: ${message}. Falling back to default compactor.`, "warning");
         return undefined;
+      } finally {
+        updateStatus();
       }
     });
 

package/extensions/subagents/README.md

@@ -80,7 +80,7 @@ Children share the requested workspace by default. Use `isolation: "worktree"` o
 
 ## UI
 
-`/subagents` or `/subagents agents` opens the live operations dashboard and takeover UI. `/btw <question>` starts a read-only, context-aware side investigation owned by the user; it opens directly in takeover view and records its answer without waking the parent model. Wide terminals use a split-pane agent list and selected-agent inspector with running/completed/failed counts, model/profile/access metadata, a context meter, current tool activity, queue state, elapsed time, turns, cwd, and latest output. The takeover view adds a live transcript, context meter, active-tool state, scrolling, child interruption, and follow-up input. `/subagents peers` shows the persistent peer-message audit trail. `/subagents profiles` browses profiles and personas, and `/subagents config` edits validated configuration.
+Subagent lifecycle tools render as compact main-chat cards with expandable detail. Running children appear in the shared bounded **Active work** dock with elapsed time and their current tool, then disappear when settled because the result card becomes the durable timeline record. `/subagents` or `/subagents agents` opens the live operations dashboard and takeover UI. `/btw <question>` starts a read-only, context-aware side investigation owned by the user; it opens directly in takeover view and records its answer without waking the parent model. Wide terminals use a split-pane agent list and selected-agent inspector with running/completed/failed counts, model/profile/access metadata, a context meter, current tool activity, queue state, elapsed time, turns, cwd, and latest output. Aborting a running child from the dashboard requires pressing `x` twice; Escape or navigation cancels an armed abort. The takeover view adds a live transcript, context meter, active-tool state, scrolling, child interruption, and follow-up input. `/subagents peers` shows the persistent peer-message audit trail. `/subagents profiles` browses profiles and personas, and `/subagents config` edits validated configuration.
 
 ## Architecture
 

package/extensions/subagents/index.ts

@@ -26,7 +26,10 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Markdown, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { clearActivitySource, setActivitySource } from "../shared/activity-dock.ts";
 import { settlementDelivery } from "../shared/settlement-delivery.ts";
+import { toolCallCard, toolResultCard } from "../shared/tool-card.ts";
+import { oneLine } from "../shared/tui-dashboard.ts";
 import {
   formatElapsed,
   latestText,
@@ -199,6 +202,7 @@ export default function (pi: ExtensionAPI) {
   let runtime: SubagentRuntime | undefined;
   let managerPromise: Promise<SubagentManagerShape> | undefined;
   let ui: ExtensionUIContext | undefined;
+  let activityContext: ExtensionContext | undefined;
   let unsubStatus: (() => void) | undefined;
   const archived = new Map<string, ArchivedSubagent>();
   const peerHistory: PeerMessage[] = [];
@@ -509,16 +513,28 @@ export default function (pi: ExtensionAPI) {
   const updateStatus = (manager: SubagentManagerShape) => {
     if (!ui) return;
     const subs = manager.view.list();
-    if (subs.length === 0) {
+    const runningSnapshots = subs.filter((snap) => snap.status === "running");
+    const failed = subs.filter((snap) => snap.status === "error").length;
+    if (activityContext) {
+      setActivitySource(activityContext, "subagents", runningSnapshots.map((snap) => {
+        const activeTool = snap.liveTools.find((tool) => !tool.done)?.name;
+        return {
+          id: snap.id,
+          label: "Subagent",
+          title: snap.title,
+          detail: activeTool ? `${activeTool} · ${formatElapsed(snap)}` : `thinking · ${formatElapsed(snap)}`,
+          state: "active" as const,
+          priority: 55,
+        };
+      }));
+    }
+    if (runningSnapshots.length === 0 && failed === 0) {
       ui.setStatus("subagents", undefined);
       return;
     }
-    const running = subs.filter((snap) => snap.status === "running").length;
-    const failed = subs.filter((snap) => snap.status === "error").length;
-    const done = subs.length - running - failed;
     ui.setStatus(
       "subagents",
-      formatActivityStatus(ui.theme, { running, done, failed }),
+      formatActivityStatus(ui.theme, { running: runningSnapshots.length, done: 0, failed }),
     );
   };
 
@@ -640,7 +656,11 @@ export default function (pi: ExtensionAPI) {
       }
     }
     if (peerHistory.length > 256) peerHistory.splice(0, peerHistory.length - 256);
-    if (ctx.hasUI) ui = ctx.ui;
+    if (ctx.hasUI) {
+      ui = ctx.ui;
+      activityContext = ctx;
+      if (managerPromise) void managerPromise.then((manager) => updateStatus(manager));
+    }
   });
 
   pi.on("session_shutdown", async () => {
@@ -652,6 +672,8 @@ export default function (pi: ExtensionAPI) {
     unsubStatus?.();
     unsubStatus = undefined;
     ui?.setStatus("subagents", undefined);
+    if (activityContext) clearActivitySource(activityContext, "subagents");
+    activityContext = undefined;
     const closing = runtime;
     runtime = undefined;
     managerPromise = undefined;
@@ -764,6 +786,14 @@ export default function (pi: ExtensionAPI) {
         },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, args.resume_from ? "subagent resume" : "subagent spawn", args.task_name ?? oneLine(args.message).slice(0, 72), `${args.agent_type ?? "general-purpose"} · ${args.capability ?? (args.readonly ? "read-only" : "all")} · ${args.isolation ?? "shared"}`), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Starting subagent…"), 0, 0);
+      const details = result.details as { id?: string; title?: string; model?: string; capability?: string; isolation?: string } | undefined;
+      return new Text(toolResultCard(result, expanded, theme, "active", details?.id ?? "subagent", `${details?.title ?? "started"} · ${details?.model ?? "inherit"} · ${details?.capability ?? "all"} · ${details?.isolation ?? "shared"}`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -859,6 +889,18 @@ export default function (pi: ExtensionAPI) {
         }),
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "subagent collect", args.ids?.length ? `${args.ids.length} selected` : "available results", args.ids?.join(", ")), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Collecting subagent results…"), 0, 0);
+      const details = result.details as { results?: Array<{ status?: string }>; pending?: string[]; pendingQuestions?: string[] } | undefined;
+      const results = details?.results ?? [];
+      const failed = results.filter((item) => item.status === "error").length;
+      const pending = details?.pending?.length ?? 0;
+      const questions = details?.pendingQuestions?.length ?? 0;
+      return new Text(toolResultCard(result, expanded, theme, failed ? "error" : questions ? "warning" : pending ? "active" : "success", "subagents", `${results.length} result${results.length === 1 ? "" : "s"} · ${pending} running${questions ? ` · ${questions} need guidance` : ""}`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -903,6 +945,14 @@ export default function (pi: ExtensionAPI) {
         },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "subagent close", `${args.ids?.length ?? 0} agent${args.ids?.length === 1 ? "" : "s"}`, args.ids?.join(", ")), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Closing subagents…"), 0, 0);
+      const details = result.details as { results?: unknown[] } | undefined;
+      return new Text(toolResultCard(result, expanded, theme, "success", "subagents closed", `${details?.results?.length ?? 0} processed`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -941,6 +991,14 @@ export default function (pi: ExtensionAPI) {
         details: { id: snap.id, status: snap.status, turns: snap.turns },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "subagent inspect", args.id), 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { id?: string; status?: string; turns?: number } | undefined;
+      const state = details?.status === "error" ? "error" : details?.status === "running" ? "active" : "success";
+      return new Text(toolResultCard(result, expanded, theme, state, details?.id ?? "subagent", `${details?.status ?? "unknown"} · ${details?.turns ?? 0} turns`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -965,6 +1023,13 @@ export default function (pi: ExtensionAPI) {
         details: { maxConcurrent: config.maxConcurrent, profiles: config.profiles, personas: config.personas },
       };
     },
+    renderCall(_args, theme) {
+      return new Text(toolCallCard(theme, "subagent profiles", "available roles and policies"), 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { maxConcurrent?: number; profiles?: object; personas?: object } | undefined;
+      return new Text(toolResultCard(result, expanded, theme, "muted", "subagent profiles", `${Object.keys(details?.profiles ?? {}).length} profiles · ${Object.keys(details?.personas ?? {}).length} personas · max ${details?.maxConcurrent ?? "?"}`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -989,6 +1054,16 @@ export default function (pi: ExtensionAPI) {
         },
       };
     },
+    renderCall(_args, theme) {
+      return new Text(toolCallCard(theme, "subagents", "list tracked agents"), 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { subagents?: Array<{ status?: string }> } | undefined;
+      const agents = details?.subagents ?? [];
+      const running = agents.filter((agent) => agent.status === "running").length;
+      const failed = agents.filter((agent) => agent.status === "error").length;
+      return new Text(toolResultCard(result, expanded, theme, failed ? "error" : running ? "active" : "muted", "subagents", `${agents.length} tracked · ${running} running · ${failed} failed`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -1009,6 +1084,14 @@ export default function (pi: ExtensionAPI) {
         details: { id: params.id, status: manager.view.get(params.id)?.status },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "subagent message", args.id, oneLine(args.message).slice(0, 100)), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Messaging subagent…"), 0, 0);
+      const details = result.details as { id?: string; status?: string } | undefined;
+      return new Text(toolResultCard(result, expanded, theme, details?.status === "error" ? "error" : "success", details?.id ?? "subagent", `message delivered · ${details?.status ?? "unknown"}`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -1068,6 +1151,15 @@ export default function (pi: ExtensionAPI) {
             : `${params.id} has no changes to ${action}.`;
       return { content: [{ type: "text", text }], details: { id: params.id, ...result, worktree } };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "subagent changes", args.id, args.action ?? "patch"), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Managing subagent changes…"), 0, 0);
+      const details = result.details as { id?: string; action?: string; changed?: boolean; discarded?: boolean; files?: string[] } | undefined;
+      const summary = details?.discarded ? "worktree discarded" : `${details?.action ?? "inspect"} · ${details?.files?.length ?? 0} files${details?.changed ? " changed" : ""}`;
+      return new Text(toolResultCard(result, expanded, theme, details?.changed || details?.discarded ? "success" : "muted", details?.id ?? "subagent", summary), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -1090,6 +1182,13 @@ export default function (pi: ExtensionAPI) {
         details: { questionId: id, title: pending.title },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "subagent reply", args.question_id ?? "pending question", oneLine(args.reply).slice(0, 100)), 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { title?: string; questionId?: string } | undefined;
+      return new Text(toolResultCard(result, expanded, theme, "success", "reply delivered", `${details?.title ?? "subagent"} · ${details?.questionId ?? "question"}`), 0, 0);
+    },
   });
 
   pi.registerTool({
@@ -1173,6 +1272,15 @@ export default function (pi: ExtensionAPI) {
         },
       };
     },
+    renderCall(args, theme) {
+      return new Text(toolCallCard(theme, "subagent batch", `${args.tasks?.length ?? 0} task${args.tasks?.length === 1 ? "" : "s"}`, (args.tasks ?? []).slice(0, 3).map((task: { task_name?: string; message?: string }) => task.task_name ?? oneLine(task.message ?? "").slice(0, 40)).join(" · ")), 0, 0);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new Text(theme.fg("warning", "Starting subagent batch…"), 0, 0);
+      const details = result.details as { agents?: Array<{ status?: string }> } | undefined;
+      const agents = details?.agents ?? [];
+      return new Text(toolResultCard(result, expanded, theme, "active", "subagent batch", `${agents.length} started · ${agents.filter((agent) => agent.status === "running").length} running`), 0, 0);
+    },
   });
 
   // --- Result message rendering ------------------------------------------

package/extensions/subagents/src/ui/takeover.ts

@@ -190,6 +190,7 @@ export class SubagentDashboard implements Component {
   private done: (value: string | null) => void;
 
   private closed = false;
+  private abortArmed?: string;
   private ticker: ReturnType<typeof setInterval>;
   private unsubChange: () => void;
 
@@ -238,6 +239,11 @@ export class SubagentDashboard implements Component {
     reconcileDashboardSelection(this.selection, subs);
 
     if (this.keybindings.matches(data, "tui.select.cancel")) {
+      if (this.abortArmed) {
+        this.abortArmed = undefined;
+        this.tui.requestRender();
+        return;
+      }
       this.close(null);
       return;
     }
@@ -251,6 +257,7 @@ export class SubagentDashboard implements Component {
         this.selection.index =
           (this.selection.index - 1 + subs.length) % subs.length;
         this.selection.id = subs[this.selection.index]?.id;
+        this.abortArmed = undefined;
         this.tui.requestRender();
       }
       return;
@@ -259,13 +266,21 @@ export class SubagentDashboard implements Component {
       if (subs.length > 0) {
         this.selection.index = (this.selection.index + 1) % subs.length;
         this.selection.id = subs[this.selection.index]?.id;
+        this.abortArmed = undefined;
         this.tui.requestRender();
       }
       return;
     }
     if (data === "x") {
       const snap = subs[this.selection.index];
-      if (snap && snap.status === "running") this.view.requestAbort(snap.id);
+      if (!snap || snap.status !== "running") return;
+      if (this.abortArmed === snap.id) {
+        this.abortArmed = undefined;
+        this.view.requestAbort(snap.id);
+      } else {
+        this.abortArmed = snap.id;
+      }
+      this.tui.requestRender();
       return;
     }
   }
@@ -346,7 +361,7 @@ export class SubagentDashboard implements Component {
       truncateToWidth(
         theme.fg(
           "dim",
-          `  ${configuredKeys(this.keybindings, "tui.select.up")}/${configuredKeys(this.keybindings, "tui.select.down")}/jk select · ${configuredKeys(this.keybindings, "tui.select.confirm")} take over · x abort running · ${configuredKeys(this.keybindings, "tui.select.cancel")} close`,
+          `  ${configuredKeys(this.keybindings, "tui.select.up")}/${configuredKeys(this.keybindings, "tui.select.down")}/jk select · ${configuredKeys(this.keybindings, "tui.select.confirm")} take over · ${this.abortArmed ? "x again to abort · esc cancel" : "x abort (confirm)"} · ${configuredKeys(this.keybindings, "tui.select.cancel")} close`,
         ),
         width,
       ),

package/extensions/task-list/README.md

@@ -64,7 +64,7 @@ Run:
 /tasks
 ```
 
-While work is active, a compact widget above the editor shows progress and the current items. A finished list lingers for four seconds so the final checkmark is visible, then clears from the live chrome while remaining available in session history.
+While work is active, the shared bounded **Active work** dock above the editor shows progress and current items alongside any live terminals, subagents, or orchestration runs without stacking separate widgets. A finished list lingers for four seconds so the final checkmark is visible, then clears from the live chrome while remaining available in session history.
 
 `/tasks` opens the full-width interactive dashboard:
 

package/extensions/task-list/index.ts

@@ -5,8 +5,9 @@ import type {
   ExtensionCommandContext,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { clearActivitySource, setActivitySource, type ActivityState } from "../shared/activity-dock.ts";
 import { oneLine } from "../shared/tui-dashboard.ts";
 import {
   TASK_LIST_ENTRY,
@@ -34,7 +35,7 @@ import type {
 import { TASK_PRIORITIES, TASK_STATUSES } from "./types.ts";
 import { openTaskDashboard, taskGlyph } from "./ui.ts";
 
-const WIDGET_ID = "task-list";
+const ACTIVITY_SOURCE = "task-list";
 const FINISHED_LINGER_MS = 4_000;
 const WORK_TOOL_EXCLUSIONS = new Set([
   TASK_LIST_TOOL,
@@ -110,49 +111,39 @@ export default function taskListExtension(pi: ExtensionAPI) {
     lastCtx = ctx;
     cancelFinishedTimer();
     if (!ctx.hasUI || state.tasks.length === 0) {
-      ctx.ui.setWidget(WIDGET_ID, undefined);
-      ctx.ui.setStatus(WIDGET_ID, undefined);
+      clearActivitySource(ctx, ACTIVITY_SOURCE);
+      ctx.ui.setStatus(ACTIVITY_SOURCE, undefined);
       return;
     }
 
     const counts = taskCounts(state.tasks);
     const active = hasActiveTasks(state);
-    const renderWidget = (_tui: unknown, theme: ExtensionContext["ui"]["theme"]) => ({
-      render(width: number): string[] {
-        const current = state.tasks.filter((task) => !terminal(task.status));
-        const finished = counts.completed + counts.cancelled;
-        const header = truncateToWidth(
-          `${theme.fg(active ? "accent" : "success", theme.bold("Tasks"))} ${theme.fg("muted", `${finished}/${counts.total}`)}${counts.blocked ? theme.fg("warning", ` · ${counts.blocked} blocked`) : ""}`,
-          width,
-        );
-        const source = active ? current : state.tasks;
-        const shown = (active ? source.slice(0, 5) : source.slice(-3));
-        const lines = shown.map((task) => {
-          const color = statusColor(task.status);
-          const label = `${theme.fg(color, taskGlyph(task.status))} ${theme.fg(terminal(task.status) ? "muted" : "text", oneLine(task.content))}`;
-          return truncateToWidth(label, width);
-        });
-        const hidden = source.length - shown.length;
-        if (hidden > 0) lines.push(truncateToWidth(theme.fg("dim", `… +${hidden} more · /tasks`), width));
-        return [header, ...lines];
-      },
-      invalidate() {},
-    });
-    ctx.ui.setWidget(WIDGET_ID, renderWidget);
+    const finished = counts.completed + counts.cancelled;
+    const visible = (active
+      ? state.tasks.filter((task) => !terminal(task.status))
+      : state.tasks.slice(-3));
+    setActivitySource(ctx, ACTIVITY_SOURCE, visible.map((task) => ({
+      id: task.id,
+      label: `Tasks ${finished}/${counts.total}`,
+      title: task.content,
+      detail: task.status.replaceAll("_", " "),
+      state: (task.status === "in_progress" ? "active" : task.status === "completed" ? "success" : task.status === "blocked" ? "error" : "muted") as ActivityState,
+      priority: task.status === "blocked" ? 100 : task.status === "in_progress" ? 60 : 10,
+    })));
     if (active) {
       const status = counts.blocked > 0
         ? `Tasks ${counts.completed}/${counts.total} · ${counts.blocked} blocked`
         : `Tasks ${counts.completed}/${counts.total} · ${counts.inProgress} active`;
-      ctx.ui.setStatus(WIDGET_ID, ctx.ui.theme.fg(counts.blocked > 0 ? "warning" : "accent", status));
+      ctx.ui.setStatus(ACTIVITY_SOURCE, ctx.ui.theme.fg(counts.blocked > 0 ? "warning" : "accent", status));
       return;
     }
 
-    ctx.ui.setStatus(WIDGET_ID, ctx.ui.theme.fg("success", `Tasks complete ${counts.completed}/${counts.total}`));
+    ctx.ui.setStatus(ACTIVITY_SOURCE, ctx.ui.theme.fg("success", `Tasks complete ${counts.completed}/${counts.total}`));
     finishedTimer = setTimeout(() => {
       finishedTimer = undefined;
       if (lastCtx !== ctx || hasActiveTasks(state)) return;
-      ctx.ui.setWidget(WIDGET_ID, undefined);
-      ctx.ui.setStatus(WIDGET_ID, undefined);
+      clearActivitySource(ctx, ACTIVITY_SOURCE);
+      ctx.ui.setStatus(ACTIVITY_SOURCE, undefined);
     }, FINISHED_LINGER_MS);
     finishedTimer.unref?.();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shariq-pi-extensions",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "Cross-platform extension suite for the Pi coding agent.",
   "license": "MIT",
   "author": "Shariq Riaz",