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

package/src/host-navigator.ts

@@ -6,7 +6,7 @@ import { type WorkflowRegistryApi } from "./registry.js";
 import { deepFreeze, errorText, object, resolveModelReference, validateModelAliases } from "./utils.js";
 import { saveModelAliases, resolveWorkflowSettings, workflowProjectSettingsPath, workflowSettingsPath } from "./validation.js";
 import { openWorkflowArtifact, workflowPromptArtifact, workflowResultArtifact, workflowScriptArtifact, type WorkflowArtifact } from "./workflow-artifacts.js";
-import { agentActionLabels, agentBreadcrumb, formatCheckpointReview, formatNavigatorRun, formatWorkflowPhaseDashboard, navigatorAttentionSort, navigatorRunLabels, SETTLED_AGENT_STATES, themeWorkflowProgressStyles, visibleAgentAttemptActions as visibleRegisteredAgentAttemptActions } from "./host-view.js";
+import { agentActionLabels, agentBreadcrumb, formatCheckpointReview, formatNavigatorRun, formatWorkflowPhaseDashboard, navigatorAttentionSort, navigatorRunLabels, SETTLED_AGENT_STATES, themeWorkflowProgressStyles, visibleAgentAttemptActions as visibleRegisteredAgentAttemptActions, type WorkflowProgressStyles } from "./host-view.js";
 import { buildWorkflowPhaseModel, buildWorkflowPhaseTree, navigateWorkflowPhaseTree, preserveWorkflowPhaseTreeSelection, workflowPhaseTreeInitialExpanded } from "./host-phases.js";
 import { type WorkflowRecoveryContext, type createWorkflowRecovery } from "./host-recovery.js";
 import { runDependencyIds } from "./retention.js";
@@ -115,14 +115,52 @@ function keybindingKeys(keybindings: unknown, name: string): readonly string[] |
 }
 type WorkflowKeybindings = { matches(data: string, binding: string): boolean };
 const WORKFLOW_VIM_KEYS: Readonly<Record<string, string>> = { "tui.select.up": "k", "tui.select.down": "j", "tui.editor.cursorLeft": "h", "tui.editor.cursorRight": "l" };
-function workflowKeyMatches(keybindings: WorkflowKeybindings, data: string, binding: string): boolean { return keybindings.matches(data, binding) || WORKFLOW_VIM_KEYS[binding] === data; }
-function workflowKeyLabel(keybindings: unknown, binding: string, fallback: string, labels: Readonly<Record<string, string>>): string {
+export function workflowKeyMatches(keybindings: WorkflowKeybindings, data: string, binding: string): boolean { return keybindings.matches(data, binding) || WORKFLOW_VIM_KEYS[binding] === data; }
+const WORKFLOW_KEY_LABELS: Readonly<Record<string, string>> = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
+export function workflowKeyLabel(keybindings: unknown, binding: string, fallback: string, labels: Readonly<Record<string, string>> = WORKFLOW_KEY_LABELS): string {
   const keys = keybindingKeys(keybindings, binding);
   const configured = keys?.length ? keys.map((key) => labels[key] ?? key) : [fallback];
   const vim = WORKFLOW_VIM_KEYS[binding];
   return [...new Set(vim ? [...configured, vim] : configured)].join("/");
 }
 
+/**
+ * A yes/no question drawn inside a navigator dashboard. Pi's confirm dialog replaces a custom component and afterwards
+ * restores the editor rather than the component, which leaves the dashboard's promise pending and the session waiting on it.
+ */
+export function createInlineConfirm(requestRender: () => void) {
+  let pending: { readonly title: string; readonly message: string; yes: boolean; readonly resolve: (value: boolean) => void } | undefined;
+  const answer = (value: boolean): void => {
+    const current = pending;
+    pending = undefined;
+    current?.resolve(value);
+    requestRender();
+  };
+  return {
+    ask(title: string, message: string): Promise<boolean> {
+      answer(false);
+      return new Promise<boolean>((resolve) => { pending = { title, message, yes: true, resolve }; requestRender(); });
+    },
+    active(): boolean { return pending !== undefined; },
+    rows(width: number, styles: WorkflowProgressStyles): string[] {
+      if (!pending) return [];
+      const yes = pending.yes;
+      const message = truncateToVisualLines(pending.message, Number.MAX_SAFE_INTEGER, Math.max(1, width), 0).visualLines.map((line) => line.trimEnd());
+      return [styles.bold(pending.title), ...message, ...["Yes", "No"].map((option) => (option === "Yes") === yes ? `→ ${styles.accent(option)}` : `  ${option}`)];
+    },
+    hint(keybindings: unknown): string {
+      return `${workflowKeyLabel(keybindings, "tui.select.up", "↑")}/${workflowKeyLabel(keybindings, "tui.select.down", "↓")} select · ${workflowKeyLabel(keybindings, "tui.select.confirm", "enter")} confirm · ${workflowKeyLabel(keybindings, "tui.select.cancel", "esc")} cancel`;
+    },
+    handleInput(keybindings: WorkflowKeybindings, data: string): void {
+      if (!pending) return;
+      if (workflowKeyMatches(keybindings, data, "tui.select.up") || workflowKeyMatches(keybindings, data, "tui.select.down")) { pending.yes = !pending.yes; requestRender(); }
+      else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) answer(pending.yes);
+      else if (workflowKeyMatches(keybindings, data, "tui.select.cancel")) answer(false);
+    },
+    cancel(): void { answer(false); },
+  };
+}
+
 export type WorkflowNavigatorDependencies = {
   pi: Pick<ExtensionAPI, "registerCommand">;
   home: string | undefined;
@@ -189,7 +227,7 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
         const setStatus = uiHostCapabilities(ctx.ui)?.setStatus;
         setStatus?.call(ctx.ui, "workflow-stop", text);
       };
-      const runAction = async (actionCommand: string, status: (text: string | undefined) => void = setWorkflowStatus): Promise<"dashboard" | "picker" | "stopped"> => {
+      const runAction = async (actionCommand: string, status: (text: string | undefined) => void = setWorkflowStatus, confirm: (title: string, message: string) => Promise<boolean> = (title, message) => confirmWithBlocked(ctx.ui, reportBlocked, title, message)): Promise<"dashboard" | "picker" | "stopped"> => {
         const [action, runId, ...rest] = actionCommand.split(/\s+/);
         try {
           const run = runId ? runs.get(runId) : undefined;
@@ -263,7 +301,7 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
           }
           if (action === "stop" && run) {
             const workflowName = stored?.loaded.run.workflowName ?? run.metadata.name;
-            if (!await confirmWithBlocked(ctx.ui, reportBlocked, "Stop workflow?", `Stop workflow ${workflowName} (${run.store.runId})? This cannot be undone.`)) return "dashboard";
+            if (!await confirm("Stop workflow?", `Stop workflow ${workflowName} (${run.store.runId})? This cannot be undone.`)) return "dashboard";
             status(`Stopping workflow ${workflowName}...`);
             await stopWorkflowRun(run.store.runId);
             status(`Workflow ${run.store.runId} stopped.`);
@@ -554,8 +592,13 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
                   let selectedNodeId = tree.nodes[0]?.id;
                   let expandedNodeIds = new Set(workflowPhaseTreeInitialExpanded(tree));
                   const terminalRows = () => Math.max(1, tuiRows(tui) - WORKFLOW_PANEL_FOOTER_ROWS);
-                  const keyLabels: Record<string, string> = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
-                  const keyLabel = (binding: string, fallback: string) => workflowKeyLabel(keybindings, binding, fallback, keyLabels);
+                  const keyLabel = (binding: string, fallback: string) => workflowKeyLabel(keybindings, binding, fallback);
+                  const inlineConfirm = createInlineConfirm(() => { if (!disposed) tui.requestRender(); });
+                  const confirmInDashboard = async (title: string, message: string): Promise<boolean> => {
+                    reportBlocked?.(true, title);
+                    try { return await inlineConfirm.ask(title, message); }
+                    finally { reportBlocked?.(false); }
+                  };
                   const progressNow = () => {
                     const now = Date.now();
                     if (hardTerminalRunStates.has(view.run.state)) {
@@ -629,7 +672,7 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
                       stopStatus = status;
                       setWorkflowStatus(status);
                       if (!disposed) tui.requestRender();
-                    }).then(async (outcome) => {
+                    }, confirmInDashboard).then(async (outcome) => {
                       if (outcome === "stopped") { done("__stopped__"); return; }
                       await updateDashboard();
                     }).catch((error: unknown) => {
@@ -662,7 +705,8 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
                       const content = [...statusLines, ...phaseLines];
                       const rows = terminalRows();
                       const hintRows = rows >= 3 ? 1 : 0;
-                      const viewport = Math.max(1, rows - hintRows);
+                      const confirmRows = inlineConfirm.rows(width, styles);
+                      const viewport = Math.max(1, rows - hintRows - confirmRows.length);
                       const maxOffset = Math.max(0, content.length - viewport);
                       dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
                       if (actionMode) {
@@ -683,11 +727,12 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
                       dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
                       const selectedNode = selectedNodeId ? tree.byId.get(selectedNodeId) : undefined;
                       const enterAction = selectedNode?.kind === "workflow" ? "run actions" : selectedNode?.kind === "agent" ? "agent actions" : selectedNode?.children.length ? "expand/collapse" : narrow ? "inspect" : "focus details";
-                      const hint = truncateToVisualLines(theme.fg("dim", actionMode ? `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.select.confirm", "enter")} run · ${keyLabel("tui.editor.cursorLeft", "←")} tree · ${keyLabel("tui.select.cancel", "esc")} tree` : `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} tree · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} collapse/expand · ${keyLabel("tui.select.confirm", "enter")} ${enterAction} · a actions · ${keyLabel("tui.select.cancel", "esc")} ${narrow && detailsMode ? "tree" : "back"}${content.length > viewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
-                      return [...content.slice(dashboardOffset, dashboardOffset + viewport), ...(hintRows ? [hint] : [])];
+                      const hint = truncateToVisualLines(theme.fg("dim", inlineConfirm.active() ? inlineConfirm.hint(keybindings) : actionMode ? `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.select.confirm", "enter")} run · ${keyLabel("tui.editor.cursorLeft", "←")} tree · ${keyLabel("tui.select.cancel", "esc")} tree` : `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} tree · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} collapse/expand · ${keyLabel("tui.select.confirm", "enter")} ${enterAction} · a actions · ${keyLabel("tui.select.cancel", "esc")} ${narrow && detailsMode ? "tree" : "back"}${content.length > viewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
+                      return [...content.slice(dashboardOffset, dashboardOffset + viewport), ...confirmRows, ...(hintRows ? [hint] : [])];
                     },
                     invalidate() {},
                     handleInput(data: string) {
+                      if (inlineConfirm.active()) { inlineConfirm.handleInput(keybindings, data); return; }
                       if (stopRequested || editorRunning) return;
                       const narrow = renderedWidth < 80;
                       if (!actionMode && (data === "a" || data === "A")) { actionMode = true; actionIndex = 0; dashboardOffset = 0; tui.requestRender(); return; }
@@ -776,7 +821,7 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
                       }
                       tui.requestRender();
                     },
-                    dispose() { disposed = true; stopTimer(); setWorkflowStatus(undefined); },
+                    dispose() { disposed = true; stopTimer(); setWorkflowStatus(undefined); inlineConfirm.cancel(); },
                   };
                 })
               : await ctx.ui.select(view.dashboard, [...view.actions.keys(), "Back"]);
@@ -816,8 +861,7 @@ export function registerWorkflowNavigator(deps: WorkflowNavigatorDependencies):
                     const currentLayout = layout();
                     const maxOffset = Math.max(0, renderedLines.length - currentLayout.contentViewport);
                     offset = Math.min(offset, maxOffset);
-                    const keyLabels: Record<string, string> = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
-                    const keyLabel = (binding: string, fallback: string) => workflowKeyLabel(keybindings, binding, fallback, keyLabels);
+                    const keyLabel = (binding: string, fallback: string) => workflowKeyLabel(keybindings, binding, fallback);
                     const hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")}/pgup/pgdn scroll · enter select · esc cancel`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
                     const controls = currentLayout.compactControls
                       ? [options.map((option, index) => `${index === selectedIndex ? "[" : " "}${option}${index === selectedIndex ? "]" : " "}`).join(" ")]

package/src/host-view.ts

@@ -1,9 +1,9 @@
 import { keyHint, truncateToVisualLines, type Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { type AwaitingCheckpoint, type PersistedRun, type RunStore, type WorktreeReference } from "./persistence.js";
 import { budgetUsage } from "./budget.js";
 import { formatCost, formatTokens } from "./background-widget.js";
-import { BUDGET_DIMENSIONS, HARD_TERMINAL_RUN_STATES, SETTLED_AGENT_STATES, WORKFLOW_AGENT_STALL_THRESHOLD_MS, sumAccounting, type AgentAccounting, type AgentAttemptAction, type AgentAttemptActionContext, type AgentRecord, type LaunchSnapshot, type StandaloneAgentAttemptActionContext, type WorkflowCatalogFunction, type WorkflowCatalogIndex } from "./types.js";
+import { BUDGET_DIMENSIONS, HARD_TERMINAL_RUN_STATES, SETTLED_AGENT_STATES, WORKFLOW_AGENT_STALL_THRESHOLD_MS, sumAccounting, zeroAccounting, type AgentAccounting, type AgentAttemptAction, type AgentAttemptActionContext, type AgentRecord, type LaunchSnapshot, type StandaloneAgentAttemptActionContext, type WorkflowCatalogFunction, type WorkflowCatalogIndex } from "./types.js";
 import { object, sanitizeDisplayText } from "./utils.js";
 import {
   WORKFLOW_PHASE_STATES,
@@ -28,7 +28,7 @@ export interface WorkflowProgressStyles {
   dim(text: string): string;
   bold(text: string): string;
 }
-const PLAIN_WORKFLOW_PROGRESS_STYLES: WorkflowProgressStyles = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
+export const PLAIN_WORKFLOW_PROGRESS_STYLES: WorkflowProgressStyles = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
 type AgentGroup = { label: string; entries: readonly { agent: AgentRecord; index: number; depth: number }[] };
 function agentGroupKey(agent: AgentRecord): string { return JSON.stringify([agent.structuralPath ?? [], agent.parentBreadcrumb ?? null]); }
 function agentGroupLabel(agents: readonly AgentRecord[]): string {
@@ -60,7 +60,7 @@ function renderGroupedAgents(agents: readonly AgentRecord[], render: (entry: { a
 }
 const RUN_STATE_GLYPH: Record<string, string> = { "not started": "○", queued: "○", pausing: "⏸", paused: "⏸", completed: "✓", failed: "✗", stopped: "✗", interrupted: "↯", budget_exhausted: "!", awaiting_input: "?" };
 const AGENT_STATE_GLYPH: Record<string, string> = { queued: "○", waiting_for_child: "…", paused: "⏸", retrying: "↻", completed: "✓", failed: "✗", cancelled: "✗" };
-function runStateGlyph(state: string, running: string): string { return state === "running" ? running : RUN_STATE_GLYPH[state] ?? "◆"; }
+export function runStateGlyph(state: string, running: string): string { return state === "running" ? running : RUN_STATE_GLYPH[state] ?? "◆"; }
 function agentStateGlyph(state: string, running: string): string { return state === "running" ? running : AGENT_STATE_GLYPH[state] ?? "○"; }
 type ProgressStyleKey = "success" | "error" | "warning" | "accent" | "muted";
 const PROGRESS_STATE_STYLE: Record<string, ProgressStyleKey> = { completed: "success", failed: "error", cancelled: "error", running: "accent", paused: "warning", pausing: "warning", interrupted: "warning", retrying: "accent", budget_exhausted: "warning", awaiting_input: "warning" };
@@ -70,10 +70,10 @@ function styleForState(map: Record<string, ProgressStyleKey>, state: string, sty
   const key = map[state] ?? "muted";
   return (text) => styles[key](text);
 }
-function progressStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(PROGRESS_STATE_STYLE, state, styles); }
+export function progressStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(PROGRESS_STATE_STYLE, state, styles); }
 function workflowIconStyle(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(WORKFLOW_ICON_STYLE, state, styles); }
 function phaseStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(PHASE_STATE_STYLE, state, styles); }
-function formatWorkflowRuntime(durationMs: number): string {
+export function formatWorkflowRuntime(durationMs: number): string {
   const seconds = Math.max(0, Math.floor(durationMs / 1000));
   if (seconds < 60) return `${String(seconds)}s`;
   const minutes = Math.floor(seconds / 60);
@@ -96,7 +96,7 @@ function formatLogTimestamp(timestamp: number | undefined): string {
   if (Number.isNaN(date.getTime())) return "--:--:--";
   return [date.getHours(), date.getMinutes(), date.getSeconds()].map((part) => String(part).padStart(2, "0")).join(":");
 }
-function workflowLogLines(run: PersistedRun, styles: WorkflowProgressStyles, expanded: boolean, width?: number, showHint = false): string[] {
+function workflowLogLines(run: PersistedRun, styles: WorkflowProgressStyles, expanded: boolean, width?: number, showHint = false, tail = 5): string[] {
   const events = (run.events ?? []).filter((event) => event.type === "log");
   if (!events.length) return [];
   const indent = " ".repeat(11);
@@ -106,12 +106,48 @@ function workflowLogLines(run: PersistedRun, styles: WorkflowProgressStyles, exp
     const chunks = truncateToVisualLines(message, Number.MAX_SAFE_INTEGER, Math.max(1, width - 11), 0).visualLines;
     return chunks.map((chunk, chunkIndex) => `${chunkIndex === 0 ? prefix : indent}${chunk}`);
   }));
-  const visible = expanded ? visualLines : visualLines.slice(-5);
+  const visible = expanded ? visualLines : visualLines.slice(-tail);
   let hint = "";
   if (!expanded && showHint) { try { hint = ` (${keyHint("app.tools.expand", "to expand")})`; } catch { /* Theme is unavailable in non-interactive render tests. */ } }
   return [expanded ? `  ${styles.muted("Logs")}` : `  ${styles.muted(`Logs${hint}`)}`, ...visible];
 }
-export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now(), expanded = false, width?: number, showHint = false): string {
+const ACTIVE_AGENT_STATES: ReadonlySet<string> = new Set(["running", "waiting_for_child", "retrying", "paused"]);
+const COMPACT_RECENT_SETTLED = 3;
+const COMPACT_LOG_LINES = 3;
+function expandHint(): string { try { return ` (${keyHint("app.tools.expand", "to expand")})`; } catch { return ""; } }
+function agentEnd(agent: AgentRecord): number { return (agent.startedAt ?? 0) + (agent.durationMs ?? 0); }
+/** One line for a finished phase: outcome counts, wall time across its agents, tokens, and cost. */
+function phaseSummary(agents: readonly AgentRecord[], styles: WorkflowProgressStyles): string {
+  const count = (state: string) => agents.filter((agent) => agent.state === state).length;
+  const starts = agents.map((agent) => agent.startedAt).filter((value): value is number => value !== undefined);
+  const span = starts.length ? Math.max(...agents.map(agentEnd)) - Math.min(...starts) : 0;
+  const accounting = sumAccounting(agents.map((agent) => agent.accounting ?? zeroAccounting()));
+  const failed = count("failed");
+  const parts = [`${String(count("completed"))} done`, ...(failed ? [styles.error(`${String(failed)} failed`)] : []), ...(count("cancelled") ? [`${String(count("cancelled"))} cancelled`] : []), ...(span > 0 ? [formatWorkflowRuntime(span)] : []), formatTokens(accounting.input + accounting.output), formatCost(accounting.cost)].filter(Boolean);
+  return styles.muted(parts.join(" · "));
+}
+/**
+ * Renders the run; with `maxLines`, a view taller than that limit switches to a compact one so the live block stays on screen.
+ * A block taller than the terminal pushes its changing header above the viewport, and pi-tui then clears and redraws the whole
+ * scrollback on every update, which snaps the reader back to the bottom.
+ */
+export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now(), expanded = false, width?: number, showHint = false, maxLines?: number): string {
+  const full = workflowProgressLines(run, spinner, styles, now, expanded, width, showHint);
+  if (expanded || maxLines === undefined || full.length <= maxLines) return full.join("\n");
+  // Finished phases collapse to a summary line; the current one keeps failed, active, and the latest settled agents, in that priority.
+  const phases = run.phaseHistory?.length ? run.phaseHistory : run.phase ? [{ phase: run.phase, afterAgent: 0 }] : [];
+  const currentStart = Math.min(run.agents.length, phases.at(-1)?.afterAgent ?? 0);
+  const current = run.agents.slice(currentStart);
+  const recent = current.filter((agent) => SETTLED_AGENT_STATES.has(agent.state) && agent.state !== "failed").sort((left, right) => agentEnd(right) - agentEnd(left)).slice(0, COMPACT_RECENT_SETTLED);
+  const candidates = [...current.filter((agent) => agent.state === "failed"), ...current.filter((agent) => ACTIVE_AGENT_STATES.has(agent.state)), ...recent];
+  const render = (count: number) => workflowProgressLines(run, spinner, styles, now, false, width, showHint, new Set(candidates.slice(0, count)));
+  let low = 0;
+  let high = candidates.length;
+  while (low < high) { const middle = Math.ceil((low + high) / 2); if (render(middle).length <= maxLines) low = middle; else high = middle - 1; }
+  // NOTE: failures in finished phases always stay listed, so a run with more of them than maxLines still overflows.
+  return render(low).join("\n");
+}
+function workflowProgressLines(run: PersistedRun, spinner: string, styles: WorkflowProgressStyles, now: number, expanded: boolean, width: number | undefined, showHint: boolean, shown?: ReadonlySet<AgentRecord>): string[] {
   const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
   const workflowIcon = runStateGlyph(run.state, spinner);
   const iconStyle = workflowIconStyle(run.state, styles);
@@ -126,14 +162,15 @@ export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", style
   const shellActivity = scopedShells ? undefined : formatShellActivity(run.activeShells, run.activeShellStartedAt, spinner, styles, now);
   if (shellActivity) lines.push(`  ${shellActivity}`);
   const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
-  const renderAgents = (agents: readonly AgentRecord[], offset: number, nested: boolean) => renderGroupedAgents(agents, ({ agent, index, depth }, grouped) => {
+  const position = new Map(run.agents.map((agent, index) => [agent, index]));
+  const renderAgents = (agents: readonly AgentRecord[], nested: boolean) => renderGroupedAgents(agents, ({ agent, depth }, grouped) => {
     const icon = agentStateGlyph(agent.state, spinner);
     const indent = "  ".repeat((grouped ? 2 : 1) + depth);
     const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : formatAgentActivity(agent, spinner, styles, now);
     const name = grouped ? agent.label ?? agent.name : styledAgentBreadcrumb(agent, byId, styles);
     const state = progressStyleForState(agent.state, styles);
     const detail = expanded ? formatWorkflowAgentDetail(agent, now) : "";
-    return `${indent}#${String(offset + index + 1)} ${state(icon)} ${name} ${state(`[${agent.state}]`)}${activity ? ` ${activity}` : ""}${detail ? ` ${detail}` : ""}`;
+    return `${indent}#${String((position.get(agent) ?? 0) + 1)} ${state(icon)} ${name} ${state(`[${agent.state}]`)}${activity ? ` ${activity}` : ""}${detail ? ` ${detail}` : ""}`;
   }, run.agents, (label) => styles.muted(label)).map((line) => nested ? `  ${line}` : line);
   const phases = run.phaseHistory?.length ? run.phaseHistory : run.phase ? [{ phase: run.phase, afterAgent: 0 }] : [];
   if (scopedShells) {
@@ -146,10 +183,23 @@ export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", style
   }
   let renderedAgents = 0;
   let nested = false;
+  // In compact mode (`shown` set) earlier segments list only their failures, and the current one only the shown agents plus a count of the rest.
+  const segment = (agents: readonly AgentRecord[], closed: boolean) => {
+    if (!shown) return renderAgents(agents, nested);
+    const listed = agents.filter((agent) => closed ? agent.state === "failed" : shown.has(agent));
+    const hidden = closed ? [] : agents.filter((agent) => !shown.has(agent));
+    const counts = [["queued", hidden.filter((agent) => !SETTLED_AGENT_STATES.has(agent.state) && !ACTIVE_AGENT_STATES.has(agent.state)).length], ["running", hidden.filter((agent) => ACTIVE_AGENT_STATES.has(agent.state)).length], ["done", hidden.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length]] as const;
+    const summary = counts.filter(([, count]) => count > 0).map(([label, count]) => `+${String(count)} ${label}`).join(" · ");
+    return [...renderAgents(listed, nested), ...(summary ? [`${nested ? "    " : "  "}${styles.muted(`… ${summary}${showHint ? expandHint() : ""}`)}`] : [])];
+  };
   for (const [phaseIndex, phase] of phases.entries()) {
     const boundary = Math.max(renderedAgents, Math.min(run.agents.length, phase.afterAgent));
-    lines.push(...renderAgents(run.agents.slice(renderedAgents, boundary), renderedAgents, nested));
-    lines.push(`  ${styles.muted(`[Phase: ${phase.phase}]`)}`);
+    const before = run.agents.slice(renderedAgents, boundary);
+    if (shown && !nested && before.length) lines.push(`  ${phaseSummary(before, styles)}`);
+    lines.push(...segment(before, true));
+    const next = phases[phaseIndex + 1];
+    const phaseAgents = next ? run.agents.slice(boundary, Math.max(boundary, Math.min(run.agents.length, next.afterAgent))) : [];
+    lines.push(`  ${styles.muted(`[Phase: ${phase.phase}]`)}${shown && next ? ` ${phaseSummary(phaseAgents, styles)}` : ""}`);
     const phaseShell = scopedShells ? shellActivityFor(run, phaseIndex) : undefined;
     if (phaseShell) {
       const rendered = formatShellActivity(phaseShell.active, phaseShell.startedAt, spinner, styles, now);
@@ -158,9 +208,9 @@ export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", style
     renderedAgents = boundary;
     nested = true;
   }
-  lines.push(...renderAgents(run.agents.slice(renderedAgents), renderedAgents, nested));
-  lines.push(...workflowLogLines(run, styles, expanded, width, showHint));
-  return lines.join("\n");
+  lines.push(...segment(run.agents.slice(renderedAgents), false));
+  lines.push(...workflowLogLines(run, styles, expanded, width, showHint, shown ? COMPACT_LOG_LINES : 5));
+  return lines;
 }
 
 const workflowSpinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -408,7 +458,11 @@ export function workflowProgressBlock(run: PersistedRun, theme: Theme, progress?
       }
       previousState = displayed.state;
       const frame = displayed.state === "running" ? workflowSpinner[Math.floor(now / 80) % workflowSpinner.length] ?? "◇" : "◇";
-      const progressText = formatWorkflowProgress(displayed, frame, styles, now, expanded, width, true);
+      // pi-tui only patches rows that are still on screen; leave room below the block for the editor and footer.
+      // A finished or frozen block no longer changes, so it keeps the full list.
+      const rows = freezeAt === undefined && !terminal ? process.stdout.rows : undefined;
+      const maxLines = rows ? Math.max(6, rows - 10) - (prefix ? prefix.split("\n").length + 1 : 0) : undefined;
+      const progressText = formatWorkflowProgress(displayed, frame, styles, now, expanded, width, true, maxLines);
       return truncateWorkflowProgress(prefix ? `${prefix}\n\n${progressText}` : progressText, width);
     },
     setExpanded(value: boolean) { expanded = value; },
@@ -582,7 +636,7 @@ export interface AgentDetailPresentation {
   readonly accounting?: AgentAccounting;
   readonly error?: { readonly code: string; readonly message: string };
 }
-function formatAgentError(error: NonNullable<AgentDetailPresentation["error"]>, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string {
+export function formatAgentError(error: NonNullable<AgentDetailPresentation["error"]>, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string {
   return styles.error(`Error: ${error.code}: ${error.message}`);
 }
 
@@ -731,11 +785,7 @@ export function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readon
   const model = buildWorkflowPhaseModel(run, snapshot);
   const tree = buildWorkflowPhaseTree(model);
   const expanded = selection.expandedNodeIds === undefined ? workflowPhaseTreeInitialExpanded(tree) : new Set(selection.expandedNodeIds);
-  const wrap = (text: string, limit = safeWidth): string[] => truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, limit), 0).visualLines.map((line) => line.trimEnd());
-  // ponytail: ANSI-only width, good enough for the ASCII labels the tree renders
-  const ansiPattern = new RegExp(ANSI_SGR_SOURCE, "g");
-  const visibleLength = (text: string): number => text.replace(ansiPattern, "").length;
-  const padTo = (text: string, limit: number): string => `${text}${" ".repeat(Math.max(0, limit - visibleLength(text)))}`;
+  const wrap = (text: string): string[] => wrapNavigatorLine(text, safeWidth);
   const phaseStyle = (state: string): ((text: string) => string) => phaseStyleForState(state, styles);
   const phase = selection.phaseId ? model.phases.find((candidate) => candidate.id === selection.phaseId) : undefined;
   const selectedByAgent = selection.agentId ? tree.nodes.find((node) => node.kind === "agent" && node.agentId === selection.agentId && (!selection.phaseId || node.phaseId === selection.phaseId)) : undefined;
@@ -799,28 +849,34 @@ export function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readon
   const scopedShells = (run.activeShellsByPhase?.length ?? 0) > 0;
   const shellActivity = scopedShells ? undefined : formatShellActivity(run.activeShells, run.activeShellStartedAt, "⠦", styles, now);
   if (shellActivity) lines.push(`  ${shellActivity}`);
-  const renderTree = (limit: number): string[] => [styles.bold("Tree"), ...(visibleNodes.length ? visibleNodes.flatMap((node) => wrap(treeLine(node), limit)) : [styles.muted("(empty)")])];
   const actionRows = (): string[] => {
     const actions = selection.actions;
     if (!actions) return [];
     return ["", styles.bold(actions.title), ...actions.options.map((option, index) => `${index === actions.index ? "→ " : "  "}${index === actions.index ? styles.accent(option) : option}`)];
   };
-  const detailRows = (): string[] => [...details(selectedNode), ...actionRows()];
+  const treeRows = [styles.bold("Tree"), ...(visibleNodes.length ? visibleNodes.map(treeLine) : [styles.muted("(empty)")])];
+  lines.push(...formatNavigatorColumns(treeRows, [...details(selectedNode), ...actionRows()], safeWidth, selection));
+  if (model.unassignedAgents?.length && !tree.nodes.some((node) => node.phaseId === "unassigned")) lines.push(...wrap(styles.muted(`Unassigned agents: ${String(model.unassignedAgents.length)}`)));
+  return lines.flatMap((line) => wrap(line));
+}
+function wrapNavigatorLine(text: string, width: number): string[] {
+  return truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, width), 0).visualLines.map((line) => line.trimEnd());
+}
+/** The navigator layout: a sidebar beside details at 80 columns or wider, otherwise one of them (or both stacked). */
+export function formatNavigatorColumns(sidebar: readonly string[], detail: readonly string[], width: number, layout: Readonly<{ treeOnly?: boolean | undefined; detailsOnly?: boolean | undefined }> = {}): string[] {
+  const safeWidth = Math.max(1, width);
   if (safeWidth >= 80) {
     const sidebarWidth = Math.min(42, Math.max(24, Math.floor((safeWidth - 3) * 0.38)));
-    const detailWidth = Math.max(1, safeWidth - sidebarWidth - 3);
-    const sidebar = renderTree(sidebarWidth).flatMap((line) => wrap(line, sidebarWidth));
-    const detail = detailRows().flatMap((line) => wrap(line, detailWidth));
-    const rows = Math.max(sidebar.length, detail.length);
-    for (let index = 0; index < rows; index += 1) lines.push(`${padTo(sidebar[index] ?? "", sidebarWidth)} | ${detail[index] ?? ""}`);
-  } else if (selection.detailsOnly) {
-    lines.push(...detailRows().flatMap((line) => wrap(line)));
-  } else {
-    lines.push(...renderTree(safeWidth));
-    if (!selection.treeOnly) lines.push("", ...detailRows().flatMap((line) => wrap(line)));
+    const left = sidebar.flatMap((line) => wrapNavigatorLine(line, sidebarWidth));
+    const right = detail.flatMap((line) => wrapNavigatorLine(line, safeWidth - sidebarWidth - 3));
+    return Array.from({ length: Math.max(left.length, right.length) }, (_, index) => {
+      const cell = left[index] ?? "";
+      return `${cell}${" ".repeat(Math.max(0, sidebarWidth - visibleWidth(cell)))} | ${right[index] ?? ""}`;
+    });
   }
-  if (model.unassignedAgents?.length && !tree.nodes.some((node) => node.phaseId === "unassigned")) lines.push(...wrap(styles.muted(`Unassigned agents: ${String(model.unassignedAgents.length)}`)));
-  return lines.flatMap((line) => wrap(line));
+  if (layout.detailsOnly) return detail.flatMap((line) => wrapNavigatorLine(line, safeWidth));
+  const left = sidebar.flatMap((line) => wrapNavigatorLine(line, safeWidth));
+  return layout.treeOnly ? left : [...left, ...detail.flatMap((line) => wrapNavigatorLine(line, safeWidth))];
 }
 export function formatCheckpointReview(checkpoint: AwaitingCheckpoint): string {
   const context = JSON.stringify(checkpoint.context, null, 2);

package/src/host.ts

@@ -14,7 +14,8 @@ import { retainTerminalRuns } from "./retention.js";
 import type { PersistedRun, WorktreeReference } from "./persistence.js";
 import { validateBudget, WorkflowBudgetRuntime } from "./budget.js";
 import { SerialLane, asWorkflowError, createLaunchSnapshot, errorCode, errorText, fail, isNodeError, jsonValue, mergeWorkflowExtensionSettings, modelAliasErrorName, modelCapability, object, parseModelReference, positiveInteger, sanitizeDisplayText, validateModelAliases } from "./utils.js";
-import { loadAgentDefinitions, loadProjectAgentDefinitions, loadSettings, preflight, resolveAgentResourcePolicy, resolveWorkflowSettings, validateCheckpoint, validateModelAliasAvailability, validateWorkflowLaunchWithRegistry, workflowProjectSettingsPath, workflowSettingsPath } from "./validation.js";
+import { loadSettings, preflight, resolveAgentResourcePolicy, resolveWorkflowSettings, validateCheckpoint, validateModelAliasAvailability, validateWorkflowLaunchWithRegistry, workflowProjectSettingsPath, workflowSettingsPath } from "./validation.js";
+import { loadAgentDefinitions, loadProjectAgentDefinitions } from "./roles.js";
 import { beginWorkflowExtensionLoading, loadingRegistry, resetWorkflowRegistryIfIdle, retainWorkflowRegistry, type WorkflowRegistryApi } from "./registry.js";
 import { agentHandleTurnPath, agentIdentityPath, agentWorktree, encoded, executeShellCommand, persistActiveAgentAttempt, persistAgentAttempts, readShellResult, runWorkflow, shellIdentityPath } from "./execution.js";
 import backgroundWidget, { type BackgroundWidgetAPI } from "./background-widget.js";
@@ -34,7 +35,6 @@ import {
   workflowControlCall,
   workflowControlResult,
   workflowProgressBlock,
-  formatWorkflowProgress,
   type WorkflowProgressRenderState,
 } from "./host-view.js";
 import {
@@ -176,7 +176,9 @@ export const WORKFLOW_STATUS_PARAMETERS = Type.Object({ runId: Type.String({ des
 export const WORKFLOW_RETRY_PARAMETERS = Type.Object({ runId: Type.String({ description: "Explicit failed workflow run ID" }), expectedState: Type.Optional(Type.String({ description: "Persisted source state observed before recovery" })), foreground: Type.Optional(Type.Boolean({ description: "Override the source launch mode for this recovery" })) });
 
 function workflowToolUpdate(run: PersistedRun): WorkflowToolUpdate {
-  return { content: [{ type: "text", text: formatWorkflowProgress(run) }], details: { runId: run.id, run } };
+  //NOTE: renderers read details.run; the partial text stays O(1) so high-frequency updates never format the whole tree.
+  const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
+  return { content: [{ type: "text", text: `Workflow: ${run.workflowName} (${String(done)}/${String(run.agents.length)} done) [${run.state}]` }], details: { runId: run.id, run } };
 }
 function agentWithProgress(agent: AgentRecord, progress: AgentProgress): AgentRecord {
   const next = { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls };
@@ -200,6 +202,7 @@ function deliver(pi: WorkflowExtensionAPI, content: string): void {
   pi.sendMessage({ customType: "workflow", content, display: true }, { deliverAs: "followUp", triggerTurn: true });
 }
 const WORKFLOW_WARNING_ENTRY = "workflow-warning";
+const PROGRESS_COALESCE_MS = 100;
 interface WorkflowWarningEntry { message: string }
 function deliverWarning(pi: WorkflowExtensionAPI, content: string): void {
   pi.appendEntry<WorkflowWarningEntry>(WORKFLOW_WARNING_ENTRY, { message: content });
@@ -415,7 +418,6 @@ export default function workflowExtension(pi: WorkflowExtensionAPI, home?: strin
     const trusted = projectTrusted(context);
     const settings = resolveWorkflowSettings(cwd, trusted, workflowSettingsPath(extensionAgentDir)).effective.extensionSettings?.trajectory;
     const port = settings?.port;
-    const themes = settings?.themes ?? false;
     const loadRuns = createTrajectoryRunLoader(cwd, sessionId, home, overlayLiveRun);
     const loadSubagents = createTrajectorySubagentLoader(cwd, sessionId, extensionAgentDir, overlayLiveSubagent);
     const loadRunsMetadata = createTrajectoryRunMetadataLoader(cwd, sessionId, home, overlayLiveRun);
@@ -424,7 +426,7 @@ export default function workflowExtension(pi: WorkflowExtensionAPI, home?: strin
       const live = liveSubagents.get(subagentId);
       return live?.status.sessionId === sessionId ? live.status.attemptDetails?.at(-1)?.session : undefined;
     });
-    return { cwd, sessionId, ...(port === undefined ? {} : { port }), themes, loadRuns, loadSubagents, loadMetadata: async () => ({ runs: await loadRunsMetadata(), subagents: await loadSubagentsMetadata() }), loadTranscript, handleAction: (request: Readonly<TrajectoryActionRequest>) => trajectoryAction(request, context) };
+    return { cwd, sessionId, ...(port === undefined ? {} : { port }), loadRuns, loadSubagents, loadMetadata: async () => ({ runs: await loadRunsMetadata(), subagents: await loadSubagentsMetadata() }), loadTranscript, handleAction: (request: Readonly<TrajectoryActionRequest>) => trajectoryAction(request, context) };
   };
   const withLiveActivities = (run: PersistedRun): PersistedRun => liveAgents.overlay(run);
   /** Overlays the in-memory lifecycle state and budget usage of an active run onto its persisted record. */
@@ -586,22 +588,49 @@ export default function workflowExtension(pi: WorkflowExtensionAPI, home?: strin
   const scheduler = new FairAgentScheduler(async ({ id, runId, tuiIndex, parentId, prompt, options, signal, setSteer }) => {
     const run = runs.get(runId);
     if (!run) throw new WorkflowError("INTERNAL_ERROR", `Unknown production run: ${runId}`);
+    const applyProgress = async (progress: AgentProgress) => {
+      let runState: PersistedRun;
+      if (progress.persist) {
+        runState = await persistRunState(run.store, run.metadata, (current) => current.agents.some((agent) => agent.id === id) ? { ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? agentWithProgress(agent, progress) : agent) } : current);
+      } else {
+        const loaded = await run.store.loadStatus();
+        if (!loaded.agents.some((agent) => agent.id === id)) return;
+        runState = { ...loaded, ...run.budget.snapshot(), agents: loaded.agents.map((agent) => agent.id === id ? agentWithProgress(agent, progress) : agent) };
+      }
+      if (!runState.agents.some((agent) => agent.id === id)) return;
+      liveAgents.setActivity(runId, id, progress.activity);
+      liveAgents.setEventTime(runId, id, progress.lastEventAt);
+      run.update?.(workflowToolUpdate(withLiveActivities(runState)));
+    };
+    // Display-only progress bursts coalesce to one trailing apply per window; persisted progress always applies immediately.
+    let deferred: AgentProgress | undefined;
+    let deferredTimer: NodeJS.Timeout | undefined;
+    let appliedAt = 0;
+    const cancelDeferredProgress = () => {
+      if (deferredTimer) clearTimeout(deferredTimer);
+      deferredTimer = undefined;
+      deferred = undefined;
+    };
+    const onProgress = async (progress: AgentProgress) => {
+      const now = Date.now();
+      if (progress.persist || (!deferredTimer && now - appliedAt >= PROGRESS_COALESCE_MS)) {
+        cancelDeferredProgress();
+        appliedAt = now;
+        await applyProgress(progress);
+        return;
+      }
+      deferred = progress;
+      deferredTimer ??= setTimeout(() => {
+        deferredTimer = undefined;
+        const next = deferred;
+        deferred = undefined;
+        if (!next) return;
+        appliedAt = Date.now();
+        void applyProgress(next).catch(() => undefined);
+      }, Math.max(0, PROGRESS_COALESCE_MS - (now - appliedAt))).unref();
+    };
     try {
       const budget = run.budget.forAgent(id);
-      const onProgress = async (progress: AgentProgress) => {
-        let runState: PersistedRun;
-        if (progress.persist) {
-          runState = await persistRunState(run.store, run.metadata, (current) => current.agents.some((agent) => agent.id === id) ? { ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? agentWithProgress(agent, progress) : agent) } : current);
-        } else {
-          const loaded = await run.store.load();
-          if (!loaded.run.agents.some((agent) => agent.id === id)) return;
-          runState = { ...loaded.run, ...run.budget.snapshot(), agents: loaded.run.agents.map((agent) => agent.id === id ? agentWithProgress(agent, progress) : agent) };
-        }
-        if (!runState.agents.some((agent) => agent.id === id)) return;
-        liveAgents.setActivity(runId, id, progress.activity);
-        liveAgents.setEventTime(runId, id, progress.lastEventAt);
-        run.update?.(workflowToolUpdate(withLiveActivities(runState)));
-      };
       const onAttempt = async (attempt: AgentAttempt) => {
         liveAgents.setSession(runId, id, attempt.liveSession);
         liveAgents.setHandoff(runId, id, attempt);
@@ -618,6 +647,7 @@ export default function workflowExtension(pi: WorkflowExtensionAPI, home?: strin
         run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
       };
       const result = await run.executor.execute(prompt, { label: options.label, workflowName: run.metadata.name, tuiIndex, tuiLabel: options.requestedLabel ?? options.label, agentNodeId: id, ...(options.extensionSettings === undefined ? {} : { inheritedExtensionSettings: options.extensionSettings }), onProgress, onAttempt, budget, ...(run.providerErrorRecovery ? { providerErrorRecovery: run.providerErrorRecovery } : {}), ...(parentId ? { parent: parentId, cwd: options.cwd, ...(options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}) } : options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}), ...(options.model ? { model: options.model } : {}), ...(options.role ? { role: options.role } : {}), ...(options.contextFiles ? { contextFiles: options.contextFiles } : {}), tools: options.tools, ...(options.skills ? { skills: options.skills } : {}), ...(options.extensions ? { extensions: options.extensions } : {}), effectiveTools: options.tools, ...(options.schema ? { schema: options.schema } : {}), ...(options.retries === undefined ? {} : { retries: options.retries }), ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }), ...(options.sessionPath ? { sessionPath: options.sessionPath } : {}), ...(options.agentOptions ? { agentOptions: options.agentOptions } : {}), ...(options.agentIdentity ? { agentIdentity: options.agentIdentity } : {}) }, signal, scheduler.toolsFor(id, (role, tools, model, inheritedTools, skills, extensions) => run.executor.resolve({ label: "child", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(role ? { role } : {}), ...(tools !== undefined ? { tools } : {}), ...(skills !== undefined ? { skills } : {}), ...(extensions !== undefined ? { extensions } : {}) }, inheritedTools).tools), setSteer, () => { scheduler.cancelChildren(id); scheduler.retry(id); });
+      cancelDeferredProgress();
       const before = (await run.store.load()).run;
       await persistAgentAttempts(run.store, id, result.attempts);
       const completed = (await run.store.load()).run;
@@ -628,6 +658,7 @@ export default function workflowExtension(pi: WorkflowExtensionAPI, home?: strin
       run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
       return result.value;
     } catch (error) {
+      cancelDeferredProgress();
       liveAgents.setSession(runId, id);
       const attempts = getAgentAttempts(error);
       if (attempts?.length) {
@@ -1365,8 +1396,7 @@ export default function workflowExtension(pi: WorkflowExtensionAPI, home?: strin
           state.workflowProgressComponent = workflowProgressBlock(currentProgress?.run ?? incoming, theme, currentProgress, async () => {
             const active = runs.get(incoming.id);
             const store = active?.store ?? new RunStore(incoming.cwd, incoming.sessionId, incoming.id, home);
-            const loaded = await store.load();
-            return withLiveActivities(loaded.run);
+            return withLiveActivities(await store.loadStatus());
           }, () => { if (state.workflowProgress === currentProgress) requestRender(); }, undefined, state.workflowProgressFrozenAt);
         }
         state.workflowProgressComponent.setExpanded(expanded);

package/src/index.ts

@@ -6,12 +6,14 @@ export * from "./utils.js";
 export { canonicalPath, sameFilesystemPath } from "./paths.js";
 export * from "./budget.js";
 export * from "./validation.js";
+export * from "./roles.js";
 export * from "./registry.js";
 export * from "./execution.js";
 export * from "./host.js";
 export * from "./workflow-artifacts.js";
 export { formatCost } from "./background-widget.js";
-export { agentActionLabels, formatAgentDetail, navigatorAttentionSortByState, themeWorkflowProgressStyles, visibleStandaloneAgentAttemptActions } from "./host-view.js";
+export { agentActionLabels, formatAgentDetail, formatAgentError, formatNavigatorColumns, formatWorkflowRuntime, navigatorAttentionSortByState, PLAIN_WORKFLOW_PROGRESS_STYLES, progressStyleForState, runStateGlyph, themeWorkflowProgressStyles, visibleStandaloneAgentAttemptActions } from "./host-view.js";
+export { createInlineConfirm, workflowKeyLabel, workflowKeyMatches } from "./host-navigator.js";
 export type { AgentDetailPresentation, WorkflowProgressStyles } from "./host-view.js";
 export { default } from "./host.js";
 export { acquireSessionLease, hasLiveSessionLease, listPersistedSessionIds, projectSessionsDirectory, projectStorageKey, RunStore, runsDirectory, SessionLease, structuralPath } from "./persistence.js";

package/src/registry.ts

@@ -5,7 +5,8 @@ import { Value } from "typebox/value";
 import type { AgentAttemptAction, JsonSchema, JsonValue, RegisteredAgentSetupHook, WorkflowCatalog, WorkflowCatalogContext, WorkflowCatalogError, WorkflowCatalogFunction, WorkflowCatalogIndex, WorkflowCatalogModelAlias, WorkflowExtension, WorkflowExtensionSettings, WorkflowExtensionSettingsValidatorContext, WorkflowFunction, WorkflowFunctionContext, WorkflowFunctionSource, WorkflowJournal, WorkflowModelAlias, WorkflowModelAliasResolverContext, WorkflowRoleDirectoryRegistration } from "./types.js";
 import type { SubagentRunRequest, SubagentStatus } from "../subagents/src/contracts.js";
 import { byPriorityThenName, deepFreeze, errorCode, errorText, fail, jsonValue, MODEL_ALIAS_NAME, object, validWorkflowExtensionNamespace } from "./utils.js";
-import { loadSettings, resolveWorkflowSettings, validateSchema } from "./validation.js";
+import { loadSettings, resolveWorkflowSettings } from "./settings.js";
+import { validateSchema } from "./utils.js";
 import { canonicalPath } from "./paths.js";
 import { isCorePackageName } from "./package-identity.js";