@marcoscale98/pi-extensible-workflows 5.14.1-fork.1 → 5.19.1-fork.1

package/subagents/src/navigator.ts

@@ -1,12 +1,11 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { copyToClipboard, getAgentDir, SettingsManager, type ExtensionAPI, type ExtensionCommandContext, type Theme } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, getAgentDir, SettingsManager, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { Editor, truncateToWidth, type EditorTheme } from "@earendil-works/pi-tui";
-import { agentActionLabels, deepFreeze, errorText, formatAgentDetail, jsonValue, loadingRegistry, navigatorAttentionSortByState, openWorkflowArtifact, themeWorkflowProgressStyles, visibleStandaloneAgentAttemptActions, workflowPromptArtifact, workflowResultArtifact, type AgentAttemptSummary, type AgentDetailPresentation, type StandaloneAgentAttemptActionContext, type WorkflowArtifact } from "../../src/index.js";
+import { agentActionLabels, createInlineConfirm, deepFreeze, errorText, formatAgentDetail, formatAgentError, formatCost, formatNavigatorColumns, formatWorkflowRuntime, jsonValue, loadingRegistry, navigatorAttentionSortByState, openWorkflowArtifact, PLAIN_WORKFLOW_PROGRESS_STYLES, progressStyleForState, runStateGlyph, themeWorkflowProgressStyles, visibleStandaloneAgentAttemptActions, workflowKeyLabel, workflowKeyMatches, workflowPromptArtifact, workflowResultArtifact, type AgentAttemptSummary, type AgentDetailPresentation, type StandaloneAgentAttemptActionContext, type WorkflowArtifact, type WorkflowProgressStyles } from "../../src/index.js";
 import { normalizeSubagentRunRequest, type SubagentManager, type SubagentManagerContext, type SubagentProgress, type SubagentRunRequest, type SubagentStatus } from "./contracts.js";
 import { attemptValue, statusValue } from "./decode.js";
 const MAX_DETAIL_TEXT = 4000;
-const MAX_DETAIL_TOOL_CALLS = 32;
 
 type NavigatorEntry = {
   readonly status: SubagentStatus;
@@ -27,8 +26,9 @@ function inspectionValue(value: unknown): { status: SubagentStatus; record: Reco
   return record && status ? { status, record } : undefined;
 }
 
+// Detail inspections only feed this UI, so they carry the live activity that tool results leave out.
 function managerContext(context: ExtensionCommandContext, waitForForeground = true, includeAttemptMetadata = false): SubagentManagerContext {
-  return { toolCallId: "subagents-command", signal: undefined, onUpdate: undefined, ...(waitForForeground ? {} : { waitForForeground: false }), ...(includeAttemptMetadata ? { includeAttemptMetadata: true } : {}), extensionContext: context };
+  return { toolCallId: "subagents-command", signal: undefined, onUpdate: undefined, ...(waitForForeground ? {} : { waitForForeground: false }), ...(includeAttemptMetadata ? { includeAttemptMetadata: true, includeActivity: true } : {}), extensionContext: context };
 }
 
 async function loadRequest(storageDirectory: string, id: string): Promise<{ request?: SubagentRunRequest; error?: string }> {
@@ -71,7 +71,6 @@ async function inspectEntry(manager: SubagentManager, storageDirectory: string,
   };
 }
 
-function requestLabel(request: SubagentRunRequest | undefined): string { return request?.label?.trim() || "none"; }
 function requestRole(request: SubagentRunRequest | undefined): string {
   const role: unknown = request?.role;
   if (typeof role === "string" && role.trim()) return role.trim();
@@ -79,17 +78,33 @@ function requestRole(request: SubagentRunRequest | undefined): string {
   return typeof override?.name === "string" && override.name.trim() ? override.name.trim() : "none";
 }
 function shortId(id: string): string { return id.length > 12 ? id.slice(0, 8) : id; }
-function pickerLabel(entry: NavigatorEntry, index: number): string { return `${String(index + 1)}. label=${boundedText(requestLabel(entry.request), 256)} role=${boundedText(requestRole(entry.request), 256)} [${entry.status.state}] ${shortId(entry.status.id)}`; }
+function entryName(entry: NavigatorEntry): string {
+  const role = requestRole(entry.request);
+  return boundedText(entry.request?.label?.trim() || (role === "none" ? shortId(entry.status.id) : role), 256);
+}
+/** Names for a list of runs; a repeated name carries its short ID, as in the `/workflow` picker, so every row stays unique. */
+function listNames(entries: readonly NavigatorEntry[]): string[] {
+  const names = entries.map(entryName);
+  return entries.map(({ status }, index) => {
+    const name = names[index] ?? "";
+    return names.indexOf(name) === names.lastIndexOf(name) ? name : `${name} ${shortId(status.id)}`;
+  });
+}
+/** Picker rows in the `/workflow` style. */
+function pickerLabels(entries: readonly NavigatorEntry[]): string[] {
+  const names = listNames(entries);
+  return entries.map(({ status }, index) => {
+    const name = names[index] ?? "";
+    const model = status.progress?.state?.model;
+    const cost = formatCost(status.progress?.accounting.cost);
+    const runtime = status.startedAt === undefined ? "" : ` runtime=${formatWorkflowRuntime((status.finishedAt ?? Date.now()) - status.startedAt)}`;
+    return `${runStateGlyph(status.state, "⠦")} ${name}  ${status.state}${model ? `  ${boundedText(model.model, 256)}${model.thinking ? `:${model.thinking}` : ""}` : ""}${cost ? ` ${cost}` : ""}${runtime}`;
+  });
+}
 function boundedText(value: unknown, limit = MAX_DETAIL_TEXT): string {
-  const text = typeof value === "string" ? value : (() => { try { const serialized: unknown = JSON.stringify(value); return typeof serialized === "string" ? serialized : String(value); } catch { return String(value); } })();
+  const text = typeof value === "string" ? value : (() => { try { const serialized: unknown = JSON.stringify(value, null, 2); return typeof serialized === "string" ? serialized : String(value); } catch { return String(value); } })();
   return text.length > limit ? `${text.slice(0, limit)}…` : text;
 }
-function timestamp(value: unknown): string | undefined { return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : undefined; }
-
-function appendValue(lines: string[], title: string, value: unknown): void {
-  lines.push(`${title}:`);
-  for (const line of boundedText(value).split("\n")) lines.push(`  ${line}`);
-}
 
 function latestAttempt(status: SubagentStatus): AgentAttemptSummary | undefined {
   return [...(status.attemptDetails ?? [])].sort((left, right) => right.attempt - left.attempt)[0];
@@ -123,29 +138,32 @@ function detailPresentation(inspection: Inspection): AgentDetailPresentation {
     ...(error === undefined ? {} : { error: { code: boundedText(error.code, 256), message: boundedText(error.message) } }),
   };
 }
-function detailLines(inspection: Inspection, theme?: Theme): string[] {
-  const { entry, record } = inspection;
-  const { status, request } = entry;
-  const styles = theme === undefined ? undefined : themeWorkflowProgressStyles(theme);
-  const lines = [
-    theme?.bold(theme.fg("accent", `Subagent ${boundedText(status.id, 256)}`)) ?? `Subagent ${boundedText(status.id, 256)}`,
-    `label=${boundedText(requestLabel(request), 256)} role=${boundedText(requestRole(request), 256)}`,
-    ...formatAgentDetail(detailPresentation(inspection), styles, status.finishedAt ?? Date.now()),
+type DetailMenu = "hint" | { readonly options: readonly string[]; readonly index: number } | undefined;
+/** Details of the selected run in the order of a /workflow agent: fields, hint, error, then the action menu. The prompt and result open in the editor. */
+function detailRows(inspection: Inspection, styles: WorkflowProgressStyles, menu?: DetailMenu): string[] {
+  const { entry } = inspection;
+  const presentation = detailPresentation(inspection);
+  return [
+    styles.bold(`Selected subagent: ${entryName(entry)}`),
+    `ID: ${boundedText(entry.status.id, 256)}`,
+    ...formatAgentDetail(presentation, styles, entry.status.finishedAt ?? Date.now(), { includeError: false }),
+    ...(entry.requestError === undefined ? [] : [styles.warning(`Request unavailable: ${boundedText(entry.requestError)}`)]),
+    ...(menu === "hint" ? [styles.muted("enter agent actions")] : []),
+    ...(presentation.error === undefined ? [] : [formatAgentError(presentation.error, styles)]),
+    ...(typeof menu === "object" ? [styles.bold("Agent actions"), ...menu.options.map((option, index) => index === menu.index ? `→ ${styles.accent(option)}` : `  ${option}`)] : []),
   ];
-  const startedAt = timestamp(status.startedAt);
-  const finishedAt = timestamp(status.finishedAt);
-  if (startedAt) lines.push(`startedAt=${startedAt}`);
-  if (finishedAt) lines.push(`finishedAt=${finishedAt}`);
-  if (request?.prompt) appendValue(lines, "prompt", request.prompt);
-  if (entry.requestError) lines.push(`request=unavailable: ${boundedText(entry.requestError)}`);
-  if (status.worktree) lines.push(`worktree=${boundedText(status.worktree.path)} branch=${boundedText(status.worktree.branch)}`);
-  const toolCalls = status.progress?.toolCalls;
-  if (toolCalls?.length) {
-    lines.push(`toolCalls=${String(toolCalls.length)}`);
-    for (const call of toolCalls.slice(-MAX_DETAIL_TOOL_CALLS)) lines.push(`  ${boundedText(call.name, 256)} [${call.state}]`);
-  }
-  if (Object.prototype.hasOwnProperty.call(record, "value")) appendValue(lines, "value", record.value);
-  return lines;
+}
+function listRows(entries: readonly NavigatorEntry[], selectedId: string, styles: WorkflowProgressStyles): string[] {
+  const names = listNames(entries);
+  return [styles.bold("Runs"), ...entries.map((entry, index) => `${entry.status.id === selectedId ? "→" : " "} • ${names[index] ?? ""} · ${progressStyleForState(entry.status.state, styles)(runStateGlyph(entry.status.state, "⠦"))}`)];
+}
+function headerRows(entries: readonly NavigatorEntry[], styles: WorkflowProgressStyles): string[] {
+  const counts = (["running", "failed", "stopped", "completed"] as const).flatMap((state) => {
+    const count = entries.filter((entry) => entry.status.state === state).length;
+    return count ? [`${String(count)} ${state}`] : [];
+  });
+  const cost = formatCost(entries.reduce((sum, entry) => sum + (entry.status.progress?.accounting.cost ?? 0), 0));
+  return [styles.bold(styles.accent("Subagents")), [...counts, ...(cost ? [cost] : [])].join(" · ")];
 }
 
 function tuiRows(tui: { terminal?: { rows?: number } }): number { return typeof tui.terminal?.rows === "number" && Number.isFinite(tui.terminal.rows) ? tui.terminal.rows : 24; }
@@ -156,7 +174,9 @@ function unrefTimer(timer: ReturnType<typeof setInterval>): void {
 }
 
 type NavigatorTui = Parameters<typeof openWorkflowArtifact>[0];
-type DetailResult = { readonly kind: "steer"; readonly message: string } | "retry" | undefined;
+type DashboardResult = { readonly entry: NavigatorEntry; readonly message: string } | undefined;
+// Pi keeps its footer below a custom component; the dashboard leaves room for it as /workflow does.
+const DASHBOARD_FOOTER_ROWS = 2;
 function standaloneActionContext(manager: SubagentManager, inspection: Inspection, context: ExtensionCommandContext): StandaloneAgentAttemptActionContext | undefined {
   const status = inspection.entry.status;
   const request = inspection.entry.request;
@@ -189,11 +209,19 @@ function standaloneActionContext(manager: SubagentManager, inspection: Inspectio
 function liveSystemPrompt(manager: SubagentManager, status: SubagentStatus): string | undefined {
   return manager.getAttemptActionData?.(status.id)?.prepared?.systemPrompt;
 }
-function actionOptions(manager: SubagentManager, inspection: Inspection, context: ExtensionCommandContext): string[] {
+type BulkDeleteState = "completed" | "failed";
+const BULK_DELETE: Readonly<Record<string, BulkDeleteState>> = { "Delete all completed": "completed", "Delete all failed": "failed" };
+/** The /workflow picker's bulk deletions, offered for the states present in the list. */
+function bulkDeleteLabels(manager: SubagentManager, entries: readonly NavigatorEntry[]): string[] {
+  if (manager.delete === undefined) return [];
+  return Object.entries(BULK_DELETE).filter(([, state]) => entries.some((entry) => entry.status.state === state)).map(([label]) => label);
+}
+/** Agent actions plus the /workflow run actions that apply to a standalone run: Delete and Copy run path, before Copy agent ID. */
+function actionOptions(manager: SubagentManager, inspection: Inspection, context: ExtensionCommandContext, bulk: readonly string[] = []): string[] {
   const actionContext = standaloneActionContext(manager, inspection, context);
   const extensionLabels = actionContext === undefined ? [] : visibleStandaloneAgentAttemptActions(loadingRegistry().agentAttemptActions(), actionContext).map(([, action]) => action.label);
   const value = inspection.record.value;
-  return agentActionLabels({
+  const labels = agentActionLabels({
     extensionLabels,
     hasWorktree: inspection.entry.status.worktree !== undefined,
     openPrompt: context.mode === "tui" && inspection.entry.request?.prompt !== undefined,
@@ -201,6 +229,27 @@ function actionOptions(manager: SubagentManager, inspection: Inspection, context
     openResult: context.mode === "tui" && Object.prototype.hasOwnProperty.call(inspection.record, "value") && jsonValue(value),
     standaloneState: inspection.entry.status.state,
   });
+  const runActions = [...(manager.delete !== undefined && inspection.entry.status.state !== "running" ? ["Delete"] : []), ...bulk, ...(context.mode === "tui" ? ["Copy run path"] : [])];
+  labels.splice(labels.indexOf("Copy agent ID"), 0, ...runActions);
+  return labels;
+}
+type Confirm = (title: string, message: string) => Promise<boolean>;
+async function deleteAll(manager: SubagentManager, storageDirectory: string, context: ExtensionCommandContext, state: BulkDeleteState, confirm: Confirm): Promise<boolean> {
+  if (!await confirm(`Delete ${state} runs?`, `Delete all ${state} subagent runs and their records? This cannot be undone.`)) return false;
+  const skipped: string[] = [];
+  let deleted = 0;
+  for (const entry of await loadEntries(manager, storageDirectory, context)) {
+    if (entry.status.state !== state) continue;
+    try {
+      await manager.delete?.({ id: entry.status.id }, managerContext(context));
+      deleted += 1;
+    } catch (error) {
+      skipped.push(`${entry.status.id} (${errorText(error)})`);
+    }
+  }
+  if (skipped.length) context.ui.notify(`Skipped ${state} runs: ${skipped.join(", ")}.`, "warning");
+  if (deleted) context.ui.notify(`Deleted ${String(deleted)} ${state} subagent run(s).`, "info");
+  return true;
 }
 function retryResult(value: unknown): { readonly id: string; readonly state: "running" } | undefined {
   const record = objectValue(value);
@@ -218,7 +267,9 @@ async function steerSubagent(manager: SubagentManager, storageDirectory: string,
   await manager.steer({ id: entry.status.id, message }, managerContext(context));
   context.ui.notify(`Steered subagent ${entry.status.id}.`, "info");
 }
-async function performAction(manager: SubagentManager, storageDirectory: string, entry: NavigatorEntry, action: string, context: ExtensionCommandContext, tui: NavigatorTui | undefined, clipboard: (value: string) => Promise<void>): Promise<"stay" | "retry"> {
+/** `unchanged` leaves the menu where it was, as /workflow does after an editor or copy action: the user declined, or the action does not touch the run. */
+type ActionOutcome = "stay" | "unchanged" | "deleted" | { readonly retryId: string };
+async function performAction(manager: SubagentManager, storageDirectory: string, entry: NavigatorEntry, action: string, context: ExtensionCommandContext, tui: NavigatorTui | undefined, clipboard: (value: string) => Promise<void>, confirm: Confirm): Promise<ActionOutcome> {
   const fresh = await inspectEntry(manager, storageDirectory, entry, context);
   const available = actionOptions(manager, fresh, context);
   if (!available.includes(action)) throw new Error(`Action ${action} is no longer available`);
@@ -229,19 +280,27 @@ async function performAction(manager: SubagentManager, storageDirectory: string,
     await registered[1].runStandalone(actionContext);
     return "stay";
   }
-  if (action === "Copy agent ID") { await clipboard(fresh.entry.status.id); context.ui.notify("Copied agent ID.", "info"); return "stay"; }
-  if (action === "Copy branch" && fresh.entry.status.worktree) { await clipboard(fresh.entry.status.worktree.branch); context.ui.notify("Copied branch.", "info"); return "stay"; }
-  if (action === "Copy worktree path" && fresh.entry.status.worktree) { await clipboard(fresh.entry.status.worktree.path); context.ui.notify("Copied worktree path.", "info"); return "stay"; }
-  if (action === "Open prompt in editor" && tui && fresh.entry.request?.prompt !== undefined) { await openNavigatorArtifact(context, tui, workflowPromptArtifact(fresh.entry.request.prompt), "agent prompt"); return "stay"; }
-  if (action === "Open system prompt in editor" && tui) { const systemPrompt = liveSystemPrompt(manager, fresh.entry.status); if (systemPrompt !== undefined) { await openNavigatorArtifact(context, tui, workflowPromptArtifact(systemPrompt), "agent system prompt"); return "stay"; } }
-  if (action === "Open result in editor" && tui && Object.prototype.hasOwnProperty.call(fresh.record, "value") && jsonValue(fresh.record.value)) { await openNavigatorArtifact(context, tui, workflowResultArtifact(fresh.record.value), "agent result"); return "stay"; }
+  if (action === "Copy agent ID") { await clipboard(fresh.entry.status.id); context.ui.notify("Copied agent ID.", "info"); return "unchanged"; }
+  if (action === "Copy run path") { await clipboard(join(storageDirectory, fresh.entry.status.id)); context.ui.notify("Copied run path.", "info"); return "unchanged"; }
+  if (action === "Delete" && manager.delete !== undefined) {
+    if (!await confirm("Delete subagent?", `Delete ${entryName(fresh.entry)} (${fresh.entry.status.id}) and its record? This cannot be undone.`)) return "unchanged";
+    await manager.delete({ id: fresh.entry.status.id }, managerContext(context));
+    context.ui.notify(`Deleted subagent ${fresh.entry.status.id}.`, "info");
+    return "deleted";
+  }
+  if (action === "Copy branch" && fresh.entry.status.worktree) { await clipboard(fresh.entry.status.worktree.branch); context.ui.notify("Copied branch.", "info"); return "unchanged"; }
+  if (action === "Copy worktree path" && fresh.entry.status.worktree) { await clipboard(fresh.entry.status.worktree.path); context.ui.notify("Copied worktree path.", "info"); return "unchanged"; }
+  if (action === "Open prompt in editor" && tui && fresh.entry.request?.prompt !== undefined) { await openNavigatorArtifact(context, tui, workflowPromptArtifact(fresh.entry.request.prompt), "agent prompt"); return "unchanged"; }
+  if (action === "Open system prompt in editor" && tui) { const systemPrompt = liveSystemPrompt(manager, fresh.entry.status); if (systemPrompt !== undefined) { await openNavigatorArtifact(context, tui, workflowPromptArtifact(systemPrompt), "agent system prompt"); return "unchanged"; } }
+  if (action === "Open result in editor" && tui && Object.prototype.hasOwnProperty.call(fresh.record, "value") && jsonValue(fresh.record.value)) { await openNavigatorArtifact(context, tui, workflowResultArtifact(fresh.record.value), "agent result"); return "unchanged"; }
   if (action === "Steer") {
     const message = await context.ui.input("Steer subagent", "Message for the running subagent");
-    if (message === undefined) return "stay";
+    if (message === undefined) return "unchanged";
     await steerSubagent(manager, storageDirectory, entry, context, message);
     return "stay";
   }
   if (action === "Stop") {
+    if (!await confirm("Stop subagent?", `Stop subagent ${entryName(fresh.entry)} (${fresh.entry.status.id})? This cannot be undone.`)) return "unchanged";
     const current = await inspectEntry(manager, storageDirectory, entry, context);
     if (current.entry.status.state !== "running") throw new Error(`Subagent ${entry.status.id} is no longer running`);
     await manager.stop({ id: entry.status.id }, managerContext(context));
@@ -254,31 +313,37 @@ async function performAction(manager: SubagentManager, storageDirectory: string,
     const result = retryResult(await manager.retry({ id: entry.status.id }, managerContext(context, false)));
     if (!result) throw new Error("Retry returned an invalid subagent result");
     context.ui.notify(`Retried subagent ${entry.status.id} as ${result.id}.`, "info");
-    return "retry";
+    return { retryId: result.id };
   }
   return "stay";
 }
-async function showDetail(manager: SubagentManager, storageDirectory: string, entry: NavigatorEntry, context: ExtensionCommandContext, clipboard: (value: string) => Promise<void>): Promise<"exit" | undefined> {
+async function showDetail(manager: SubagentManager, storageDirectory: string, entry: NavigatorEntry, context: ExtensionCommandContext, clipboard: (value: string) => Promise<void>): Promise<void> {
   let inspection = await inspectEntry(manager, storageDirectory, entry, context);
-  if (context.mode !== "tui") {
-    for (;;) {
-      const action = await context.ui.select(detailLines(inspection).join("\n"), actionOptions(manager, inspection, context));
-      if (!action || action === "Back") return;
-      try {
-        if (await performAction(manager, storageDirectory, entry, action, context, undefined, clipboard) === "retry") return;
-        inspection = await inspectEntry(manager, storageDirectory, entry, context);
-      } catch (error) {
-        context.ui.notify(`Cannot ${action.toLowerCase()}: ${errorText(error)}`, "warning");
-      }
+  for (;;) {
+    const action = await context.ui.select(detailRows(inspection, PLAIN_WORKFLOW_PROGRESS_STYLES).join("\n"), actionOptions(manager, inspection, context));
+    if (!action || action === "Back") return;
+    try {
+      const outcome = await performAction(manager, storageDirectory, entry, action, context, undefined, clipboard, (title, message) => context.ui.confirm(title, message));
+      if (outcome === "deleted" || typeof outcome === "object") return;
+      inspection = await inspectEntry(manager, storageDirectory, entry, context);
+    } catch (error) {
+      context.ui.notify(`Cannot ${action.toLowerCase()}: ${errorText(error)}`, "warning");
     }
   }
-  const result = await context.ui.custom<DetailResult>((tui, theme, keybindings, done) => {
-    let offset = 0;
-    let actionMode = false;
-    let actionIndex = 0;
-    let actionRunning = false;
-    let disposed = false;
-    let steerMode = false;
+}
+
+/** The `/workflow` dashboard layout for standalone runs: the run list beside the selected run's details. */
+async function showDashboard(manager: SubagentManager, storageDirectory: string, initial: readonly NavigatorEntry[], context: ExtensionCommandContext, clipboard: (value: string) => Promise<void>): Promise<void> {
+  const first = initial[0];
+  if (first === undefined) return;
+  let initialInspection: Inspection;
+  try { initialInspection = await inspectEntry(manager, storageDirectory, first, context); }
+  catch (error) {
+    context.ui.notify(`Cannot inspect subagent ${first.status.id}: ${errorText(error)}`, "warning");
+    initialInspection = { entry: first, record: {} };
+  }
+  const result = await context.ui.custom<DashboardResult>((tui, theme, keybindings, done) => {
+    const styles = themeWorkflowProgressStyles(theme);
     const editorTheme: EditorTheme = {
       borderColor: (text) => theme.fg("accent", text),
       selectList: {
@@ -290,160 +355,241 @@ async function showDetail(manager: SubagentManager, storageDirectory: string, en
       },
     };
     const steerEditor = new Editor(tui, editorTheme);
-    let refreshTimer: ReturnType<typeof setInterval> | undefined;
+    let entries = initial;
+    let inspection = initialInspection;
+    let offset = 0;
+    let detailsMode = false;
+    let actionMode = false;
+    let actionIndex = 0;
+    let steerMode = false;
+    const inlineConfirm = createInlineConfirm(() => { if (!disposed) tui.requestRender(); });
+    const confirmInline: Confirm = (title, message) => inlineConfirm.ask(title, message);
+    let actionRunning = false;
     let refreshing = false;
-    let refreshGeneration = 0;
-    const requestRender = (): void => {
-      if (!disposed) tui.requestRender();
-    };
-    const stopRefresh = (): void => {
-      if (refreshTimer !== undefined) {
-        clearInterval(refreshTimer);
-        refreshTimer = undefined;
-      }
-      refreshGeneration += 1;
+    let disposed = false;
+    let generation = 0;
+    let renderedWidth = 80;
+    let selectionNeedsScroll = true;
+    let timer: ReturnType<typeof setInterval> | undefined;
+    const keyLabel = (binding: string, fallback: string): string => workflowKeyLabel(keybindings, binding, fallback);
+    const matches = (data: string, binding: string): boolean => workflowKeyMatches(keybindings, data, binding);
+    const requestRender = (): void => { if (!disposed) tui.requestRender(); };
+    const options = (): string[] => actionOptions(manager, inspection, context, bulkDeleteLabels(manager, entries));
+    const warn = (message: string): void => {
+      if (disposed) return;
+      try { context.ui.notify(message, "warning"); } catch { /* The session UI may already be closing. */ }
     };
-    const buildActionRows = (detail: readonly string[], options: readonly string[]): string[] => [
-      ...detail,
-      "",
-      theme.bold("Agent actions"),
-      ...options.map((option, index) => `${index === actionIndex ? "→ " : "  "}${index === actionIndex ? theme.fg("accent", option) : option}`),
-    ];
-    const viewportRows = (): number => Math.max(1, tuiRows(tui) - 1);
-    const maxOffsetFor = (rows: readonly string[]): number => Math.max(0, rows.length - viewportRows());
-    const clampOffset = (rows: readonly string[]): void => {
-      offset = Math.max(0, Math.min(maxOffsetFor(rows), offset));
+    const stopTimer = (): void => {
+      if (timer === undefined) return;
+      clearInterval(timer);
+      timer = undefined;
     };
-    const actionView = (): { readonly detail: string[]; readonly options: string[]; readonly rows: string[] } => {
-      const detail = detailLines(inspection, theme);
-      const options = actionOptions(manager, inspection, context);
-      return { detail, options, rows: buildActionRows(detail, options) };
+    // Refresh while anything runs; a settled list has nothing left to change.
+    const syncTimer = (): void => {
+      if (!entries.some((entry) => entry.status.state === "running") && inspection.entry.status.state !== "running") stopTimer();
+      else if (timer === undefined && !disposed) {
+        timer = setInterval(() => { if (timer !== undefined) void refresh(); }, 1000);
+        unrefTimer(timer);
+      }
     };
-    const scrollActionIntoView = (view = actionView()): void => {
-      const { options, rows } = view;
-      if (actionIndex >= options.length) { clampOffset(rows); return; }
-      const viewport = viewportRows();
-      const actionRow = rows.length - options.length + actionIndex;
-      if (actionRow < offset) offset = actionRow;
-      else if (actionRow >= offset + viewport) offset = actionRow - viewport + 1;
-      clampOffset(rows);
+    const apply = (nextEntries: readonly NavigatorEntry[], next: Inspection): void => {
+      const selectedAction = actionMode ? options()[actionIndex] : undefined;
+      const position = (list: readonly NavigatorEntry[]): number => list.findIndex((entry) => entry.status.id === next.entry.status.id);
+      if (position(entries) !== position(nextEntries)) selectionNeedsScroll = true;
+      entries = nextEntries;
+      inspection = next;
+      if (selectedAction !== undefined) {
+        const nextOptions = options();
+        const kept = nextOptions.indexOf(selectedAction);
+        actionIndex = kept >= 0 ? kept : Math.min(actionIndex, Math.max(0, nextOptions.length - 1));
+      }
+      syncTimer();
+      requestRender();
     };
-    const reportRefreshError = (error: unknown): void => {
-      if (disposed) return;
-      try { context.ui.notify(`Cannot refresh subagent ${entry.status.id}: ${errorText(error)}`, "warning"); } catch { /* The session UI may already be closing. */ }
+    const reload = async (id = inspection.entry.status.id): Promise<void> => {
+      const current = ++generation;
+      const nextEntries = await loadEntries(manager, storageDirectory, context);
+      if (current !== generation) return;
+      const selected = nextEntries.find((entry) => entry.status.id === id) ?? nextEntries[0];
+      if (selected === undefined) {
+        context.ui.notify("No durable subagent runs in this session.", "info");
+        close(undefined);
+        return;
+      }
+      let next: Inspection;
+      try { next = await inspectEntry(manager, storageDirectory, selected, context); }
+      catch (error: unknown) {
+        // The fresh list still shows, with the row's own data as when moving the selection.
+        if (current === generation) apply(nextEntries, { entry: selected, record: {} });
+        throw error;
+      }
+      if (current === generation) apply(nextEntries, next);
     };
-    const refreshInspection = async (): Promise<void> => {
-      if (disposed || actionRunning || refreshing || inspection.entry.status.state !== "running") return;
+    // A tick re-reads only the active runs and the selection; the full list is read on open and after an action.
+    // A failed read keeps the last known row, as the /workflow refresh does, so one unreadable run cannot hold back the rest.
+    // Moving the selection bumps the generation, so a tick that survives it still has the selection it read.
+    //NOTE: a running run whose files vanish keeps the timer alive until the dashboard closes.
+    const refresh = async (): Promise<void> => {
+      if (disposed || actionRunning || refreshing) return;
       refreshing = true;
-      const generation = ++refreshGeneration;
-      const actionIndexBeforeRefresh = actionIndex;
-      const viewBeforeRefresh = actionMode ? actionView() : undefined;
-      const actionRowBeforeRefresh = viewBeforeRefresh === undefined ? -1 : viewBeforeRefresh.rows.length - viewBeforeRefresh.options.length + actionIndex;
-      const wasVisible = actionRowBeforeRefresh >= offset && actionRowBeforeRefresh < offset + viewportRows();
+      const current = generation;
+      const selectedId = inspection.entry.status.id;
       try {
-        const next = await inspectEntry(manager, storageDirectory, entry, context);
-        if (generation !== refreshGeneration) return;
-        inspection = next;
-        if (inspection.entry.status.state !== "running") stopRefresh();
-        if (actionMode) {
-          const options = actionOptions(manager, inspection, context);
-          actionIndex = Math.min(actionIndex, Math.max(0, options.length - 1));
-          const view = actionView();
-          if (wasVisible || actionIndex !== actionIndexBeforeRefresh) scrollActionIntoView(view);
-          else clampOffset(view.rows);
-        }
-        requestRender();
-      } catch (error: unknown) {
-        if (generation === refreshGeneration) reportRefreshError(error);
+        const stale = entries.filter((entry) => entry.status.state === "running" || entry.status.id === selectedId);
+        const results = await Promise.allSettled(stale.map((entry) => inspectEntry(manager, storageDirectory, entry, context)));
+        if (current !== generation) return;
+        const fresh = new Map(results.flatMap((result) => result.status === "fulfilled" ? [[result.value.entry.status.id, result.value] as const] : []));
+        apply(attentionSort(entries.map((entry) => fresh.get(entry.status.id)?.entry ?? entry)), fresh.get(selectedId) ?? inspection);
       } finally {
         refreshing = false;
       }
     };
-    const close = (value: DetailResult): void => {
-      if (disposed) return;
+    const select = (delta: number): void => {
+      const index = Math.max(0, entries.findIndex((entry) => entry.status.id === inspection.entry.status.id));
+      const entry = entries[(index + delta + entries.length) % entries.length];
+      if (entry === undefined || entry.status.id === inspection.entry.status.id) return;
+      // The list row already holds the state; the full inspection adds the result and attempt details.
+      inspection = { entry, record: {} };
+      selectionNeedsScroll = true;
+      const current = ++generation;
+      void inspectEntry(manager, storageDirectory, entry, context).then((next) => {
+        if (current === generation) apply(entries, next);
+      }, (error: unknown) => { if (current === generation) warn(`Cannot inspect subagent ${entry.status.id}: ${errorText(error)}`); });
+    };
+    // Reads still in flight check the generation, so closing invalidates them.
+    const shutDown = (): void => {
       disposed = true;
-      stopRefresh();
+      generation += 1;
+      stopTimer();
+      inlineConfirm.cancel();
+    };
+    const close = (value: DashboardResult): void => {
+      if (disposed) return;
+      shutDown();
       done(value);
     };
     steerEditor.onSubmit = (value) => {
       const message = value.trim();
-      if (message) close({ kind: "steer", message });
+      if (message) close({ entry: inspection.entry, message });
     };
-    const isDisposed = (): boolean => disposed;
-    const renderLines = (width: number): string[] => {
-      if (disposed) return [];
-      const renderWidth = Math.max(1, width);
-      const action = actionMode ? actionView() : undefined;
-      const detail = (action?.detail ?? detailLines(inspection, theme)).map((line) => truncateToWidth(line, renderWidth, "…"));
-      const rows = steerMode ? [...detail, "", theme.bold("Steer subagent"), ...steerEditor.render(renderWidth)] : action?.rows ?? detail;
-      const viewport = viewportRows();
-      const maxOffset = maxOffsetFor(rows);
-      const visibleOffset = steerMode ? maxOffset : Math.max(0, Math.min(maxOffset, offset));
-      const hint = theme.fg("dim", steerMode ? "enter submit · esc back" : actionMode ? "↑/↓ actions · enter run · esc back" : "↑/↓ scroll · a actions · enter actions · esc back");
-      return [...rows.slice(visibleOffset, visibleOffset + viewport), hint].map((line) => truncateToWidth(line, renderWidth, "…"));
+    const reloadAfterAction = async (id?: string): Promise<void> => {
+      try { await reload(id); }
+      catch (error: unknown) { warn(`Cannot refresh subagents: ${errorText(error)}`); }
     };
     const runAction = (action: string): void => {
-      if (disposed) return;
       actionRunning = true;
       requestRender();
-      void performAction(manager, storageDirectory, entry, action, context, tui, clipboard).then(async (outcome) => {
-        if (disposed) return;
-        if (outcome === "retry") { close("retry"); return; }
-        const next = await inspectEntry(manager, storageDirectory, entry, context);
-        if (isDisposed()) return;
-        inspection = next;
-        if (inspection.entry.status.state !== "running") stopRefresh();
+      const bulk = BULK_DELETE[action];
+      const pending = bulk === undefined ? performAction(manager, storageDirectory, inspection.entry, action, context, tui, clipboard, confirmInline) : deleteAll(manager, storageDirectory, context, bulk, confirmInline).then((done): ActionOutcome => done ? "stay" : "unchanged");
+      void pending.then(async (outcome) => {
+        if (disposed || outcome === "unchanged") return;
+        // The action already happened: a failed reload must not read as a failed action that invites a second retry.
+        await reloadAfterAction(typeof outcome === "object" ? outcome.retryId : undefined);
         actionMode = false;
         actionIndex = 0;
         offset = 0;
-      }).catch((error: unknown) => {
-        if (!disposed) context.ui.notify(`Cannot ${action.toLowerCase()}: ${errorText(error)}`, "warning");
+        selectionNeedsScroll = true;
+      }, async (error: unknown) => {
+        warn(`Cannot ${action.toLowerCase()}: ${errorText(error)}`);
+        // The menu stays open on fresh options: a failed Stop usually means the run has already settled.
+        if (!disposed) await reloadAfterAction();
       }).finally(() => {
         actionRunning = false;
-        if (!disposed) requestRender();
+        requestRender();
       });
     };
-    if (inspection.entry.status.state === "running") {
-      refreshTimer = setInterval(() => { void refreshInspection().catch(reportRefreshError); }, 1000);
-      unrefTimer(refreshTimer);
-    }
+    syncTimer();
     return {
-      render: renderLines,
+      render(width: number): string[] {
+        if (disposed) return [];
+        renderedWidth = width;
+        const narrow = width < 80;
+        const actions = actionMode ? options() : [];
+        const menu: DetailMenu = actionMode ? { options: actions, index: actionIndex } : steerMode ? undefined : "hint";
+        const layout = narrow ? detailsMode || actionMode || steerMode ? { detailsOnly: true } : { treeOnly: true } : {};
+        const content = [...headerRows(entries, styles), ...formatNavigatorColumns(listRows(entries, inspection.entry.status.id, styles), detailRows(inspection, styles, menu), width, layout)];
+        const footer = steerMode ? [styles.bold("Steer subagent"), ...steerEditor.render(width)] : inlineConfirm.rows(width, styles);
+        const rows = Math.max(1, tuiRows(tui) - DASHBOARD_FOOTER_ROWS);
+        const hintRows = rows >= 3 ? 1 : 0;
+        const viewport = Math.max(1, rows - hintRows - footer.length);
+        const keepVisible = (row: number): void => {
+          if (row < 0) return;
+          if (row < offset) offset = row;
+          else if (row >= offset + viewport) offset = row - viewport + 1;
+        };
+        // The selected action is the first arrow in the details column: it precedes the prompt and result.
+        if (actionMode) keepVisible(content.findIndex((line) => narrow ? line.startsWith("→ ") : line.includes(" | → ")));
+        else if (selectionNeedsScroll && !(narrow && detailsMode)) {
+          keepVisible(content.findIndex((line) => line.startsWith("→")));
+          selectionNeedsScroll = false;
+        }
+        offset = Math.max(0, Math.min(Math.max(0, content.length - viewport), offset));
+        const up = keyLabel("tui.select.up", "↑");
+        const down = keyLabel("tui.select.down", "↓");
+        const enter = keyLabel("tui.select.confirm", "enter");
+        const esc = keyLabel("tui.select.cancel", "esc");
+        const scroll = content.length > viewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : "";
+        const refreshHint = timer === undefined ? "" : " · auto-refresh 1s";
+        const back = narrow && detailsMode ? "details" : "list";
+        const hint = steerMode ? "enter submit · esc back"
+          : inlineConfirm.active() ? inlineConfirm.hint(keybindings)
+          : actionMode ? `${up}/${down} actions · ${enter} run · ${keyLabel("tui.editor.cursorLeft", "←")} ${back} · ${esc} ${back}`
+            : narrow && detailsMode ? `${up}/${down} scroll · ${enter} actions · a actions · ${esc} list${scroll}${refreshHint}`
+              : `${up}/${down} select · ${enter} ${narrow ? "details" : "actions"} · a actions · ${esc} close${scroll}${refreshHint}`;
+        return [...content.slice(offset, offset + viewport), ...footer, ...(hintRows ? [styles.dim(hint)] : [])].map((line) => truncateToWidth(line, Math.max(1, width), "…"));
+      },
       invalidate() {},
       handleInput(data: string) {
-        if (disposed || actionRunning) return;
+        if (disposed) return;
+        if (inlineConfirm.active()) { inlineConfirm.handleInput(keybindings, data); return; }
+        if (actionRunning) return;
         if (steerMode) {
-          if (keybindings.matches(data, "tui.select.cancel")) { steerMode = false; actionMode = true; steerEditor.setText(""); offset = 0; scrollActionIntoView(); }
+          if (keybindings.matches(data, "tui.select.cancel")) { steerMode = false; actionMode = true; steerEditor.setText(""); }
           else steerEditor.handleInput(data);
           requestRender();
           return;
         }
-        if (!actionMode && data === "a") { actionMode = true; actionIndex = 0; offset = 0; scrollActionIntoView(); requestRender(); return; }
-        if (keybindings.matches(data, "tui.select.cancel")) {
-          if (actionMode) { actionMode = false; actionIndex = 0; offset = 0; requestRender(); } else close(undefined);
-          return;
-        }
-        if (!actionMode) {
-          if (keybindings.matches(data, "tui.select.confirm")) { actionMode = true; actionIndex = 0; offset = 0; scrollActionIntoView(); requestRender(); }
-          else if (keybindings.matches(data, "tui.select.up")) { offset = Math.max(0, offset - 1); clampOffset(detailLines(inspection, theme)); requestRender(); }
-          else if (keybindings.matches(data, "tui.select.down")) { offset += 1; clampOffset(detailLines(inspection, theme)); requestRender(); }
-          return;
+        const narrow = renderedWidth < 80;
+        const page = Math.max(1, tuiRows(tui) - DASHBOARD_FOOTER_ROWS - 1);
+        if (matches(data, "tui.select.pageUp")) offset = Math.max(0, offset - page);
+        else if (matches(data, "tui.select.pageDown")) offset += page;
+        else if (actionMode) {
+          const actions = options();
+          if (matches(data, "tui.select.cancel") || matches(data, "tui.editor.cursorLeft")) { actionMode = false; offset = 0; selectionNeedsScroll = true; }
+          else if (matches(data, "tui.select.up")) actionIndex = (actionIndex + actions.length - 1) % actions.length;
+          else if (matches(data, "tui.select.down")) actionIndex = (actionIndex + 1) % actions.length;
+          else if (matches(data, "tui.select.confirm")) {
+            const action = actions[actionIndex];
+            if (action === "Steer") { steerMode = true; actionMode = false; steerEditor.setText(""); }
+            else if (action && action !== "Back") runAction(action);
+            else { actionMode = false; offset = 0; selectionNeedsScroll = true; }
+          }
+        } else if (data === "a" || data === "A") { actionMode = true; actionIndex = 0; offset = 0; }
+        else if (matches(data, "tui.select.cancel")) {
+          if (!narrow || !detailsMode) { close(undefined); return; }
+          detailsMode = false;
+          offset = 0;
+          selectionNeedsScroll = true;
+        } else if (narrow && detailsMode) {
+          if (matches(data, "tui.select.up")) offset = Math.max(0, offset - 1);
+          else if (matches(data, "tui.select.down")) offset += 1;
+          else if (matches(data, "tui.select.confirm")) { actionMode = true; actionIndex = 0; offset = 0; }
+        } else if (matches(data, "tui.select.up")) select(-1);
+        else if (matches(data, "tui.select.down")) select(1);
+        else if (matches(data, "tui.select.confirm")) {
+          if (narrow) detailsMode = true;
+          else actionMode = true;
+          actionIndex = 0;
+          offset = 0;
         }
-        const options = actionOptions(manager, inspection, context);
-        if (keybindings.matches(data, "tui.select.up")) { actionIndex = (actionIndex + options.length - 1) % options.length; scrollActionIntoView(); }
-        else if (keybindings.matches(data, "tui.select.down")) { actionIndex = (actionIndex + 1) % options.length; scrollActionIntoView(); }
-        else if (keybindings.matches(data, "tui.select.confirm")) { const action = options[actionIndex]; if (action === "Steer") { steerMode = true; actionMode = false; steerEditor.setText(""); offset = 0; } else if (action && action !== "Back") runAction(action); else actionMode = false; }
-        else if (keybindings.matches(data, "tui.select.pageUp")) { offset = Math.max(0, offset - viewportRows()); clampOffset(actionView().rows); }
-        else if (keybindings.matches(data, "tui.select.pageDown")) { offset += viewportRows(); clampOffset(actionView().rows); }
         requestRender();
       },
-      dispose() { if (!disposed) { disposed = true; stopRefresh(); } },
+      dispose() { shutDown(); },
     };
   });
-  if (!result || result === "retry") return;
-  try { await steerSubagent(manager, storageDirectory, entry, context, result.message); }
+  if (result === undefined) return;
+  try { await steerSubagent(manager, storageDirectory, result.entry, context, result.message); }
   catch (error) { context.ui.notify(`Cannot steer: ${errorText(error)}`, "warning"); }
-  return "exit";
 }
 
 async function runNavigator(manager: SubagentManager, storageDirectory: string, args: string, context: ExtensionCommandContext, clipboard: (value: string) => Promise<void>): Promise<void> {
@@ -457,17 +603,27 @@ async function runNavigator(manager: SubagentManager, storageDirectory: string,
       context.ui.notify("No durable subagent runs in this session.", "info");
       return;
     }
+    const labels = pickerLabels(entries);
     if (!context.hasUI) {
-      context.ui.notify(entries.map((entry, index) => pickerLabel(entry, index)).join("\n"), "info");
+      context.ui.notify(labels.join("\n"), "info");
+      return;
+    }
+    if (context.mode === "tui") {
+      await showDashboard(manager, storageDirectory, entries, context, clipboard);
       return;
     }
-    const labels = entries.map(pickerLabel);
-    const choice = await context.ui.select("Subagents\n", [...labels, "Close"]);
+    const choice = await context.ui.select("Subagents\n", [...labels, "Close", ...bulkDeleteLabels(manager, entries)]);
     if (!choice || choice === "Close") return;
+    const bulk = BULK_DELETE[choice];
+    if (bulk !== undefined) {
+      try { await deleteAll(manager, storageDirectory, context, bulk, (title, message) => context.ui.confirm(title, message)); }
+      catch (error) { context.ui.notify(`Cannot delete ${bulk} runs: ${errorText(error)}`, "warning"); }
+      continue;
+    }
     const selected = entries[labels.indexOf(choice)];
     if (!selected) return;
     try {
-      if (await showDetail(manager, storageDirectory, selected, context, clipboard) === "exit") return;
+      await showDetail(manager, storageDirectory, selected, context, clipboard);
     } catch (error) {
       context.ui.notify(`Cannot inspect subagent ${selected.status.id}: ${errorText(error)}`, "warning");
     }