shariq-pi-extensions 0.2.26 → 0.2.28

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; only active manager entries contribute to the footer and bounded Active work dock, so persisted history never inflates live failure counts. Cancellation and reload interruption use a distinct `cancelled` state rather than `error`. All completed and cancelled production 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);
+    },
   });
 }