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

package/dist/subagents/src/navigator.js

@@ -2,11 +2,10 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { copyToClipboard, getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { Editor, truncateToWidth } from "@earendil-works/pi-tui";
-import { agentActionLabels, deepFreeze, errorText, formatAgentDetail, jsonValue, loadingRegistry, navigatorAttentionSortByState, openWorkflowArtifact, themeWorkflowProgressStyles, visibleStandaloneAgentAttemptActions, workflowPromptArtifact, workflowResultArtifact } 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 } from "../../src/index.js";
 import { normalizeSubagentRunRequest } from "./contracts.js";
 import { attemptValue, statusValue } from "./decode.js";
 const MAX_DETAIL_TEXT = 4000;
-const MAX_DETAIL_TOOL_CALLS = 32;
 function objectValue(value) { return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined; }
 function isFileNotFound(error) { return objectValue(error)?.code === "ENOENT"; }
 function safeRunId(id) { return id !== "." && id !== ".." && /^[A-Za-z0-9._-]+$/.test(id); }
@@ -15,8 +14,9 @@ function inspectionValue(value) {
     const status = statusValue(value);
     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, waitForForeground = true, includeAttemptMetadata = false) {
-    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, id) {
     if (!safeRunId(id))
@@ -60,7 +60,6 @@ async function inspectEntry(manager, storageDirectory, entry, context) {
         entry: { status: inspected.status, ...(request.request === undefined ? {} : { request: request.request }), ...(request.error === undefined ? {} : { requestError: request.error }) },
     };
 }
-function requestLabel(request) { return request?.label?.trim() || "none"; }
 function requestRole(request) {
     const role = request?.role;
     if (typeof role === "string" && role.trim())
@@ -69,10 +68,32 @@ function requestRole(request) {
     return typeof override?.name === "string" && override.name.trim() ? override.name.trim() : "none";
 }
 function shortId(id) { return id.length > 12 ? id.slice(0, 8) : id; }
-function pickerLabel(entry, index) { 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) {
+    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) {
+    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) {
+    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, limit = MAX_DETAIL_TEXT) {
     const text = typeof value === "string" ? value : (() => { try {
-        const serialized = JSON.stringify(value);
+        const serialized = JSON.stringify(value, null, 2);
         return typeof serialized === "string" ? serialized : String(value);
     }
     catch {
@@ -80,12 +101,6 @@ function boundedText(value, limit = MAX_DETAIL_TEXT) {
     } })();
     return text.length > limit ? `${text.slice(0, limit)}…` : text;
 }
-function timestamp(value) { return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : undefined; }
-function appendValue(lines, title, value) {
-    lines.push(`${title}:`);
-    for (const line of boundedText(value).split("\n"))
-        lines.push(`  ${line}`);
-}
 function latestAttempt(status) {
     return [...(status.attemptDetails ?? [])].sort((left, right) => right.attempt - left.attempt)[0];
 }
@@ -118,36 +133,31 @@ function detailPresentation(inspection) {
         ...(error === undefined ? {} : { error: { code: boundedText(error.code, 256), message: boundedText(error.message) } }),
     };
 }
-function detailLines(inspection, theme) {
-    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()),
+/** 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, styles, menu) {
+    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, selectedId, styles) {
+    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, styles) {
+    const counts = ["running", "failed", "stopped", "completed"].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) { return typeof tui.terminal?.rows === "number" && Number.isFinite(tui.terminal.rows) ? tui.terminal.rows : 24; }
 function unrefTimer(timer) {
@@ -156,6 +166,8 @@ function unrefTimer(timer) {
         return;
     Reflect.apply(value.unref, value, []);
 }
+// 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, inspection, context) {
     const status = inspection.entry.status;
     const request = inspection.entry.request;
@@ -189,11 +201,19 @@ function standaloneActionContext(manager, inspection, context) {
 function liveSystemPrompt(manager, status) {
     return manager.getAttemptActionData?.(status.id)?.prepared?.systemPrompt;
 }
-function actionOptions(manager, inspection, context) {
+const BULK_DELETE = { "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, entries) {
+    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, inspection, context, bulk = []) {
     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 +221,31 @@ function actionOptions(manager, 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;
+}
+async function deleteAll(manager, storageDirectory, context, state, confirm) {
+    if (!await confirm(`Delete ${state} runs?`, `Delete all ${state} subagent runs and their records? This cannot be undone.`))
+        return false;
+    const skipped = [];
+    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) {
     const record = objectValue(value);
@@ -223,7 +268,7 @@ async function steerSubagent(manager, storageDirectory, entry, context, message)
     await manager.steer({ id: entry.status.id, message }, managerContext(context));
     context.ui.notify(`Steered subagent ${entry.status.id}.`, "info");
 }
-async function performAction(manager, storageDirectory, entry, action, context, tui, clipboard) {
+async function performAction(manager, storageDirectory, entry, action, context, tui, clipboard, confirm) {
     const fresh = await inspectEntry(manager, storageDirectory, entry, context);
     const available = actionOptions(manager, fresh, context);
     if (!available.includes(action))
@@ -239,41 +284,55 @@ async function performAction(manager, storageDirectory, entry, action, context,
     if (action === "Copy agent ID") {
         await clipboard(fresh.entry.status.id);
         context.ui.notify("Copied agent ID.", "info");
-        return "stay";
+        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 "stay";
+        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 "stay";
+        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 "stay";
+        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 "stay";
+            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 "stay";
+        return "unchanged";
     }
     if (action === "Steer") {
         const message = await context.ui.input("Steer subagent", "Message for the running subagent");
         if (message === undefined)
-            return "stay";
+            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`);
@@ -289,34 +348,42 @@ async function performAction(manager, storageDirectory, entry, action, context,
         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, storageDirectory, entry, context, clipboard) {
     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")
+    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;
-            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");
-            }
+            inspection = await inspectEntry(manager, storageDirectory, entry, context);
+        }
+        catch (error) {
+            context.ui.notify(`Cannot ${action.toLowerCase()}: ${errorText(error)}`, "warning");
         }
     }
+}
+/** The `/workflow` dashboard layout for standalone runs: the run list beside the selected run's details. */
+async function showDashboard(manager, storageDirectory, initial, context, clipboard) {
+    const first = initial[0];
+    if (first === undefined)
+        return;
+    let initialInspection;
+    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((tui, theme, keybindings, done) => {
-        let offset = 0;
-        let actionMode = false;
-        let actionIndex = 0;
-        let actionRunning = false;
-        let disposed = false;
-        let steerMode = false;
+        const styles = themeWorkflowProgressStyles(theme);
         const editorTheme = {
             borderColor: (text) => theme.fg("accent", text),
             selectList: {
@@ -328,258 +395,327 @@ async function showDetail(manager, storageDirectory, entry, context, clipboard)
             },
         };
         const steerEditor = new Editor(tui, editorTheme);
-        let refreshTimer;
+        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 = (title, message) => inlineConfirm.ask(title, message);
+        let actionRunning = false;
         let refreshing = false;
-        let refreshGeneration = 0;
-        const requestRender = () => {
-            if (!disposed)
-                tui.requestRender();
-        };
-        const stopRefresh = () => {
-            if (refreshTimer !== undefined) {
-                clearInterval(refreshTimer);
-                refreshTimer = undefined;
+        let disposed = false;
+        let generation = 0;
+        let renderedWidth = 80;
+        let selectionNeedsScroll = true;
+        let timer;
+        const keyLabel = (binding, fallback) => workflowKeyLabel(keybindings, binding, fallback);
+        const matches = (data, binding) => workflowKeyMatches(keybindings, data, binding);
+        const requestRender = () => { if (!disposed)
+            tui.requestRender(); };
+        const options = () => actionOptions(manager, inspection, context, bulkDeleteLabels(manager, entries));
+        const warn = (message) => {
+            if (disposed)
+                return;
+            try {
+                context.ui.notify(message, "warning");
             }
-            refreshGeneration += 1;
+            catch { /* The session UI may already be closing. */ }
         };
-        const buildActionRows = (detail, options) => [
-            ...detail,
-            "",
-            theme.bold("Agent actions"),
-            ...options.map((option, index) => `${index === actionIndex ? "→ " : "  "}${index === actionIndex ? theme.fg("accent", option) : option}`),
-        ];
-        const viewportRows = () => Math.max(1, tuiRows(tui) - 1);
-        const maxOffsetFor = (rows) => Math.max(0, rows.length - viewportRows());
-        const clampOffset = (rows) => {
-            offset = Math.max(0, Math.min(maxOffsetFor(rows), offset));
+        const stopTimer = () => {
+            if (timer === undefined)
+                return;
+            clearInterval(timer);
+            timer = undefined;
         };
-        const actionView = () => {
-            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 = () => {
+            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()) => {
-            const { options, rows } = view;
-            if (actionIndex >= options.length) {
-                clampOffset(rows);
-                return;
+        const apply = (nextEntries, next) => {
+            const selectedAction = actionMode ? options()[actionIndex] : undefined;
+            const position = (list) => 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));
             }
-            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);
+            syncTimer();
+            requestRender();
         };
-        const reportRefreshError = (error) => {
-            if (disposed)
+        const reload = async (id = inspection.entry.status.id) => {
+            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;
             try {
-                context.ui.notify(`Cannot refresh subagent ${entry.status.id}: ${errorText(error)}`, "warning");
+                next = await inspectEntry(manager, storageDirectory, selected, context);
             }
-            catch { /* The session UI may already be closing. */ }
+            catch (error) {
+                // 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 () => {
-            if (disposed || actionRunning || refreshing || inspection.entry.status.state !== "running")
+        // 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 () => {
+            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)
+                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;
-                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) {
-                if (generation === refreshGeneration)
-                    reportRefreshError(error);
+                const fresh = new Map(results.flatMap((result) => result.status === "fulfilled" ? [[result.value.entry.status.id, result.value]] : []));
+                apply(attentionSort(entries.map((entry) => fresh.get(entry.status.id)?.entry ?? entry)), fresh.get(selectedId) ?? inspection);
             }
             finally {
                 refreshing = false;
             }
         };
+        const select = (delta) => {
+            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) => { 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 = () => {
+            disposed = true;
+            generation += 1;
+            stopTimer();
+            inlineConfirm.cancel();
+        };
         const close = (value) => {
             if (disposed)
                 return;
-            disposed = true;
-            stopRefresh();
+            shutDown();
             done(value);
         };
         steerEditor.onSubmit = (value) => {
             const message = value.trim();
             if (message)
-                close({ kind: "steer", message });
+                close({ entry: inspection.entry, message });
         };
-        const isDisposed = () => disposed;
-        const renderLines = (width) => {
-            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) => {
+            try {
+                await reload(id);
+            }
+            catch (error) {
+                warn(`Cannot refresh subagents: ${errorText(error)}`);
+            }
         };
         const runAction = (action) => {
-            if (disposed)
-                return;
             actionRunning = true;
             requestRender();
-            void performAction(manager, storageDirectory, entry, action, context, tui, clipboard).then(async (outcome) => {
-                if (disposed)
+            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) => done ? "stay" : "unchanged");
+            void pending.then(async (outcome) => {
+                if (disposed || outcome === "unchanged")
                     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();
+                // 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) => {
+                selectionNeedsScroll = true;
+            }, async (error) => {
+                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)
-                    context.ui.notify(`Cannot ${action.toLowerCase()}: ${errorText(error)}`, "warning");
+                    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) {
+                if (disposed)
+                    return [];
+                renderedWidth = width;
+                const narrow = width < 80;
+                const actions = actionMode ? options() : [];
+                const menu = 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) => {
+                    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) {
-                if (disposed || actionRunning)
+                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();
                     }
                     else
                         steerEditor.handleInput(data);
                     requestRender();
                     return;
                 }
-                if (!actionMode && data === "a") {
+                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;
-                    scrollActionIntoView();
-                    requestRender();
-                    return;
                 }
-                if (keybindings.matches(data, "tui.select.cancel")) {
-                    if (actionMode) {
-                        actionMode = false;
-                        actionIndex = 0;
-                        offset = 0;
-                        requestRender();
-                    }
-                    else
+                else if (matches(data, "tui.select.cancel")) {
+                    if (!narrow || !detailsMode) {
                         close(undefined);
-                    return;
+                        return;
+                    }
+                    detailsMode = false;
+                    offset = 0;
+                    selectionNeedsScroll = true;
                 }
-                if (!actionMode) {
-                    if (keybindings.matches(data, "tui.select.confirm")) {
+                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;
-                        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 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 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 = 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);
+                        actionMode = true;
+                    actionIndex = 0;
+                    offset = 0;
                 }
                 requestRender();
             },
-            dispose() { if (!disposed) {
-                disposed = true;
-                stopRefresh();
-            } },
+            dispose() { shutDown(); },
         };
     });
-    if (!result || result === "retry")
+    if (result === undefined)
         return;
     try {
-        await steerSubagent(manager, storageDirectory, entry, context, result.message);
+        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, storageDirectory, args, context, clipboard) {
     if (args.trim()) {
@@ -592,20 +728,33 @@ async function runNavigator(manager, storageDirectory, args, context, clipboard)
             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;
         }
-        const labels = entries.map(pickerLabel);
-        const choice = await context.ui.select("Subagents\n", [...labels, "Close"]);
+        if (context.mode === "tui") {
+            await showDashboard(manager, storageDirectory, entries, context, clipboard);
+            return;
+        }
+        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");