@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/tui/render.js

@@ -2,13 +2,14 @@ import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { getMarkdownTheme, keyText } from "@duckmind/dm-coding-agent";
 import { Container, Markdown, Spacer, Text, visibleWidth } from "@duckmind/dm-tui";
+import { unresolvedChildWatchdogBlockers } from "../watchdog/child-status.js";
 import {
   MAX_WIDGET_JOBS,
   WIDGET_ANIMATION_INTERVAL_MS,
   WIDGET_KEY
 } from "../shared/types.js";
 import { previewDisplayText, sanitizeDisplayText, truncateDisplayText } from "../shared/display-text.js";
-import { FLEET_OPEN_SHORTCUT, formatShortcutLabel } from "../shared/shortcuts.js";
+import { formatShortcutLabel } from "../shared/shortcuts.js";
 import { formatContextUsage, formatTokens, formatUsage, formatDuration, formatModelThinking, formatToolCall, formatTokenUsage, shortenPath } from "../shared/formatters.js";
 import { getDisplayItems, getSingleResultOutput, PROMPT_REDACTED } from "../shared/utils.js";
 import { flatToLogicalStepIndex } from "../runs/background/parallel-groups.js";
@@ -22,6 +23,7 @@ import { encodeAsyncStatusSnapshotWidget } from "../runs/background/async-status
 import { projectAsyncWorkflowRows } from "../runs/shared/async-status-projection.js";
 import { hostStepReportName, hostStepVerdictLabel } from "../runs/shared/host-step-status.js";
 import { workflowGraphStageNodes } from "../runs/shared/workflow-graph.js";
+import { formatWorkflowChecklistBottleneck, formatWorkflowChecklistPhase, formatWorkflowChecklistSummary, projectWorkflowChecklist } from "../workflows/workflow-checklist.js";
 function resolveMainWindowRenderLayout(config) {
   return {
     horizontalSpacing: config?.horizontalSpacing ?? 2,
@@ -42,18 +44,22 @@ function capCompactMainWindowResult(component, layout, theme, enabled) {
       return lines;
     const visibleRows = maxLines === 1 ? 1 : maxLines - 1;
     const hiddenCount = lines.length - visibleRows;
-    const hint = theme.fg("accent", `… ${hiddenCount} rows hidden · ${liveDetailKeyText()} expands`);
+    const hint = theme.fg("accent", `… ${hiddenCount} rows hidden · ${expandKeyHint("to expand", "to view them")}`);
     if (maxLines === 1)
       return [truncLine(`${lines[0] ?? ""} ${hint}`, width)];
     return [...lines.slice(0, visibleRows), truncLine(hint, width)];
   };
   return capped;
 }
-function liveDetailKeyText() {
-  return keyText("app.tools.expand");
+function expandKeyHint(action, unconfiguredAction = action) {
+  const shortcut = keyText("app.tools.expand");
+  return shortcut ? `Press ${shortcut} ${action}` : `Configure the expand key ${unconfiguredAction}`;
 }
 export function liveDetailHintText() {
-  return `Press ${liveDetailKeyText()} for live detail · ${formatShortcutLabel(FLEET_OPEN_SHORTCUT)} Fleet`;
+  return expandKeyHint("for live detail");
+}
+function workflowDetailHintText() {
+  return expandKeyHint("for details");
 }
 function foregroundSingleHintText(shortcut) {
   if (!shortcut)
@@ -153,8 +159,7 @@ function runningSeed(...values) {
 function runningGlyph(seed) {
   if (seed === undefined)
     return STATIC_RUNNING_GLYPH;
-  const clock = Math.floor(Date.now() / 125);
-  return RUNNING_FRAMES[Math.abs(seed + clock) % RUNNING_FRAMES.length];
+  return RUNNING_FRAMES[Math.abs(seed) % RUNNING_FRAMES.length];
 }
 function animatedSeed(seed, frame) {
   if (frame === undefined)
@@ -258,7 +263,7 @@ function workflowStepPriority(step, currentNodeId) {
   if (step.status === "running" || isCurrent && step.status !== "complete" && step.status !== "completed")
     return 0;
   const gate = laneGate(step);
-  if (step.status === "failed" || step.status === "partial" || step.status === "paused" || step.status === "stopped" || step.status === "rejected" || step.toolBudgetBlocked === true || step.turnBudgetExceeded === true || step.activityState === "needs_attention" || step.watchdog?.phase === "stale" || gate !== undefined)
+  if (step.status === "failed" || step.status === "partial" || step.status === "paused" || step.status === "stopped" || step.status === "rejected" || step.toolBudgetBlocked === true || step.turnBudgetExceeded === true || step.activityState === "needs_attention" || step.watchdog?.phase === "stale" || unresolvedChildWatchdogBlockers(step.watchdog).length > 0 || gate !== undefined)
     return 1;
   if (step.status === "pending")
     return 2;
@@ -340,24 +345,47 @@ function workflowStageProgress(job, stages = job.mode === "workflow" ? workflowG
     return { total: stages.length, current: stages.length - 1 };
   return { total: stages.length };
 }
-function buildWorkflowWidgetProjection(job) {
+function buildWorkflowWidgetProjection(job, now = Date.now()) {
   const stages = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph) : [];
   const stageProgress = workflowStageProgress(job, stages);
-  const steps = workflowWidgetSteps(job, stages);
-  const projection = { stages, steps };
+  const clock = job.status === "running" ? now : job.updatedAt;
+  const loadedSteps = workflowWidgetSteps(job, stages);
+  const steps = job.mode === "workflow" ? loadedSteps.map((step) => step.status === "running" && step.startedAt !== undefined && clock !== undefined ? { ...step, durationMs: Math.max(0, clock - step.startedAt) } : step) : loadedSteps;
+  const projection = { stages, steps, now };
   if (stageProgress)
     projection.stageProgress = stageProgress;
   if (stages.length)
     projection.plannedKeys = new Set(stages.map((node) => node.id));
+  if (job.mode === "workflow") {
+    const checklist = projectWorkflowChecklist({
+      graph: job.workflowGraph,
+      steps: job.steps,
+      hostSteps: job.hostSteps,
+      preflight: job.preflight,
+      trace: job.workflow?.trace,
+      now: clock
+    });
+    if (checklist.total > 0)
+      projection.checklist = checklist;
+  }
   return projection;
 }
-function workflowWidgetProjectionLookup() {
+function workflowWidgetProjectionLookup(now = Date.now(), childrenByParent = new Map) {
   const projections = new WeakMap;
   return (job) => {
     const cached = projections.get(job);
     if (cached)
       return cached;
-    const projection = buildWorkflowWidgetProjection(job);
+    const projection = buildWorkflowWidgetProjection(job, now);
+    const children = childrenByParent.get(job.asyncId);
+    if (children?.length) {
+      projection.children = children;
+      projection.materializedKeys = new Set(children.flatMap((child) => [child.asyncId, ...child.workflowKey ? [child.workflowKey] : []]));
+      for (const step of projection.steps) {
+        if (step.runId && projection.materializedKeys.has(step.runId) && step.workflowKey)
+          projection.materializedKeys.add(step.workflowKey);
+      }
+    }
     projections.set(job, projection);
     return projection;
   };
@@ -401,6 +429,8 @@ function laneGate(step) {
   return;
 }
 function laneNextAction(state, step, output, gate) {
+  if (unresolvedChildWatchdogBlockers(step?.watchdog).length > 0)
+    return "resolve watchdog blockers";
   if (step?.watchdog?.phase === "stale")
     return "inspect stale state";
   if (step?.toolBudgetBlocked === true || step?.turnBudgetExceeded === true)
@@ -446,6 +476,7 @@ export function projectAsyncLane(job, ...args) {
     selectedStep?.activityState === "active_long_running" ? "long-running" : undefined,
     selectedStep?.activityState === "needs_attention" ? "attention" : undefined,
     selectedStep?.watchdog?.phase === "stale" ? "stale" : undefined,
+    unresolvedChildWatchdogBlockers(selectedStep?.watchdog).length > 0 ? `wd:${unresolvedChildWatchdogBlockers(selectedStep?.watchdog).length}` : undefined,
     selectedStep?.toolBudgetBlocked === true || selectedStep?.turnBudgetExceeded === true ? "blocked" : undefined
   ].filter((chip) => Boolean(chip));
   const state = isTerminalLaneState(job.status) ? job.status : selectedStep?.status ?? job.status;
@@ -508,16 +539,9 @@ function widgetLaneDetailLines(job, theme, projection) {
   const lane = projectAsyncLane(job, selectedStep);
   return lane ? formatLaneProjectionLines(lane, theme, "  ") : [];
 }
-function workflowPreflightLines(job, expanded = false) {
+function workflowPreflightLines(job) {
   if (job.mode !== "workflow" || !job.preflight)
     return [];
-  if (!expanded) {
-    const warning = formatWorkflowPreflightWarningSummary(job.workflow?.preflightWarnings, { indent: "  ", hint: "expand for debug" });
-    return [
-      formatWorkflowPreflightPlanSummary(job.preflight, { indent: "  " }),
-      ...warning ? [warning] : []
-    ];
-  }
   return [
     ...formatWorkflowPreflight(job.preflight, { indent: "  " }).split(`
 `),
@@ -865,6 +889,7 @@ function widgetStepRenderKey(step, index, expanded = false) {
     step.execution?.stopped,
     step.execution?.detached,
     step.watchdog?.phase,
+    unresolvedChildWatchdogBlockers(step.watchdog).length,
     step.error,
     expanded ? expandedStepActivityRenderKey(step) : undefined,
     nestedRenderKey(step.children, expanded)
@@ -910,10 +935,13 @@ function hostStepRenderKey(row) {
   ];
 }
 export function widgetRenderKey(job, expanded = false) {
-  const projection = buildWorkflowWidgetProjection(job);
+  const projection = buildWorkflowWidgetProjection(job, job.updatedAt ?? 0);
   return JSON.stringify({
     asyncDir: job.asyncDir,
+    parentWorkflowRunId: job.parentWorkflowRunId,
+    workflowKey: job.workflowKey,
     status: job.status,
+    description: job.mode === "workflow" ? job.description : undefined,
     activityState: job.activityState,
     lastActivityAt: job.lastActivityAt,
     currentTool: job.currentTool,
@@ -931,8 +959,17 @@ export function widgetRenderKey(job, expanded = false) {
       currentNodeId: job.workflowGraph.currentNodeId,
       stages: projection.stages.map((node) => [node.id, node.status, node.agent, node.phase, node.label, node.flatIndex, node.outputName, node.structured, node.error])
     } : undefined,
-    preflight: expanded ? job.preflight : job.preflight ? formatWorkflowPreflightPlanSummary(job.preflight) : undefined,
-    preflightWarnings: expanded ? job.workflow?.preflightWarnings : job.workflow?.preflightWarnings?.length || undefined,
+    preflight: expanded ? job.preflight : job.preflight?.lanes.map((lane) => [lane.key, lane.mode, lane.decision, lane.claims, lane.expectedOutput]),
+    preflightWarnings: expanded ? job.workflow?.preflightWarnings : undefined,
+    checklist: projection.checklist ? {
+      total: projection.checklist.total,
+      done: projection.checklist.done,
+      running: projection.checklist.running,
+      queued: projection.checklist.queued,
+      blocked: projection.checklist.blocked,
+      failed: projection.checklist.failed,
+      phases: projection.checklist.phases.map((phase) => [phase.key, phase.state, phase.done, phase.total, phase.running, phase.queued, phase.blocked, phase.failed, phase.paused, phase.stopped, phase.items.map((item) => [item.key, item.label, item.agent, item.state, item.preflight?.key, item.preflight?.mode, item.preflight?.decision, item.preflight?.claims, item.preflight?.expectedOutput, item.currentTool, item.currentPath, item.durationMs, item.toolCount, item.error])])
+    } : undefined,
     steps: job.steps?.map((step, index) => widgetStepRenderKey(step, index, expanded)),
     nestedChildren: nestedRenderKey(job.nestedChildren, expanded),
     lane: laneRenderKey(job, projection),
@@ -1088,6 +1125,284 @@ function widgetStepStatus(status, theme) {
     return theme.fg("warning", "stopped");
   return theme.fg("dim", status);
 }
+function workflowChecklistStateLabel(state) {
+  if (state === "running")
+    return "running";
+  if (state === "complete")
+    return "complete";
+  return state;
+}
+function workflowChecklistGlyph(item, theme, frame) {
+  if (item.state === "running")
+    return theme.fg("accent", runningGlyph(animatedSeed(runningSeed(item.startedAt, item.durationMs, item.toolCount, item.currentToolStartedAt), frame)));
+  if (item.state === "complete")
+    return theme.fg("success", "✓");
+  if (item.state === "blocked")
+    return theme.fg("error", "!");
+  if (item.state === "failed")
+    return theme.fg("error", "✗");
+  if (item.state === "paused" || item.state === "stopped")
+    return theme.fg("warning", "■");
+  return theme.fg("muted", "◦");
+}
+function workflowChecklistItemPriority(state) {
+  if (state === "blocked")
+    return 0;
+  if (state === "failed")
+    return 1;
+  if (state === "running")
+    return 2;
+  if (state === "paused")
+    return 3;
+  if (state === "stopped")
+    return 4;
+  if (state === "queued")
+    return 5;
+  return 6;
+}
+function workflowChecklistItemLine(item, theme, indent, frame, includeError) {
+  const identity = [item.label, item.agent && item.agent !== item.label ? item.agent : undefined].filter(Boolean).join(" · ");
+  const context = contextModeBadge(theme, item.context);
+  const state = item.state === "complete" ? "" : ` ${theme.fg("dim", `· ${workflowChecklistStateLabel(item.state)}`)}`;
+  const details = [
+    item.currentTool ? `${item.currentTool}${item.durationMs !== undefined ? ` ${formatDuration(item.durationMs)}` : ""}` : undefined,
+    !item.currentTool && item.currentPath ? shortenPath(item.currentPath) : undefined,
+    !item.currentTool && item.durationMs !== undefined ? formatDuration(item.durationMs) : undefined,
+    item.toolCount !== undefined ? `${item.toolCount} tools` : undefined,
+    item.outputName ? `out:${item.outputName}` : undefined,
+    includeError && item.error ? `error:${oneLine(item.error)}` : undefined
+  ].filter(Boolean).join(" · ");
+  return `${indent}${workflowChecklistGlyph(item, theme, frame)} ${theme.bold(identity || item.key)}${context}${state}${details ? ` ${theme.fg("dim", `· ${details}`)}` : ""}`;
+}
+const COLLAPSED_WORKFLOW_PHASE_LIMIT = 4;
+function workflowChecklistWidgetLines(checklist, theme, indent, expanded, frame, options = {}) {
+  if (!checklist?.total)
+    return [];
+  const includeSummary = options.includeSummary ?? true;
+  const limitPhases = options.limitPhases ?? !expanded;
+  const includeBottleneckOutput = options.includeBottleneckOutput ?? expanded;
+  const includeItemErrors = options.includeItemErrors ?? true;
+  const lines = includeSummary ? [`${indent}${theme.fg("dim", `Checklist ${formatWorkflowChecklistSummary(checklist)}`)}`] : [];
+  const phases = !limitPhases || checklist.phases.length <= COLLAPSED_WORKFLOW_PHASE_LIMIT ? checklist.phases : checklist.phases.map((phase, index) => ({ phase, index })).sort((left, right) => Number(left.phase.state !== "running") - Number(right.phase.state !== "running") || Number(left.phase.state === "complete") - Number(right.phase.state === "complete") || left.index - right.index).slice(0, COLLAPSED_WORKFLOW_PHASE_LIMIT).sort((left, right) => left.index - right.index).map(({ phase }) => phase);
+  for (const phase of phases) {
+    const phaseItem = phase.items.find((item) => item.state === "running") ?? phase.items[0];
+    const glyph = workflowChecklistGlyph({
+      state: phase.state,
+      startedAt: phaseItem?.startedAt,
+      durationMs: phaseItem?.durationMs,
+      toolCount: phaseItem?.toolCount,
+      currentToolStartedAt: phaseItem?.currentToolStartedAt
+    }, theme, frame);
+    lines.push(`${indent}${glyph} ${theme.bold(formatWorkflowChecklistPhase(phase))}`);
+    if (expanded) {
+      for (const item of [...phase.items].sort((left, right) => workflowChecklistItemPriority(left.state) - workflowChecklistItemPriority(right.state))) {
+        lines.push(workflowChecklistItemLine(item, theme, `${indent}  `, frame, includeItemErrors || item.kind === "host"));
+      }
+    }
+  }
+  const bottleneck = formatWorkflowChecklistBottleneck(checklist.bottleneck, { includeOutput: includeBottleneckOutput, includeError: !expanded });
+  if (bottleneck) {
+    const tone = checklist.bottleneck?.state === "blocked" || checklist.bottleneck?.state === "failed" ? "error" : checklist.bottleneck?.state === "running" ? "accent" : "warning";
+    lines.push(`${indent}${theme.fg(tone, `bottleneck · ${bottleneck}`)}`);
+  }
+  return lines;
+}
+function compactWorkflowLaneState(items) {
+  let state;
+  for (const item of items) {
+    if (state === undefined || workflowChecklistItemPriority(item.state) < workflowChecklistItemPriority(state))
+      state = item.state;
+  }
+  return state ?? "queued";
+}
+function compactWorkflowLaneOwner(items) {
+  const owners = [...new Set(items.map((item) => item.agent ?? item.role).filter((value) => Boolean(value?.trim())))];
+  if (owners.length === 0)
+    return;
+  return boundedLaneValue(owners.length > 2 ? `${owners.slice(0, 2).join(", ")} +${owners.length - 2}` : owners.join(", "), 32);
+}
+function compactWorkflowLaneLabel(items, key) {
+  const labels = [...new Set(items.map((item) => item.label).filter((value) => Boolean(value?.trim() && value.trim() !== key)))];
+  if (labels.length === 0)
+    return;
+  return boundedLaneValue(labels.length > 1 ? `${labels[0]} +${labels.length - 1}` : labels[0], 48);
+}
+function compactWorkflowLaneRow(key, items, lane = items.find((item) => item.preflight)?.preflight, fallbackState = "queued") {
+  const state = items.length ? compactWorkflowLaneState(items) : fallbackState;
+  const toolCounts = items.map((item) => item.toolCount).filter((value) => value !== undefined);
+  const durations = items.map((item) => item.durationMs).filter((value) => value !== undefined);
+  const label = compactWorkflowLaneLabel(items, key);
+  return {
+    key: boundedLaneValue(key, 40) ?? key,
+    state,
+    agent: compactWorkflowLaneOwner(items),
+    ...lane?.mode ? { mode: lane.mode } : {},
+    ...lane?.decision ? { decision: boundedLaneValue(lane.decision, 56) } : {},
+    ...lane?.claims?.length ? { claims: boundedLaneValue(lane.claims.join(", "), 56) } : {},
+    ...lane?.expectedOutput ? { expectedOutput: boundedLaneValue(lane.expectedOutput, 56) } : {},
+    ...label ? { label } : {},
+    ...toolCounts.length ? { toolUses: toolCounts.reduce((sum, value) => sum + value, 0) } : {},
+    ...durations.length ? { durationMs: Math.max(...durations) } : {}
+  };
+}
+function compactWorkflowFallbackState(job) {
+  if (job.activityState === "needs_attention" || job.timedOut || job.toolBudgetBlocked || job.turnBudgetExceeded)
+    return "blocked";
+  switch (job.status) {
+    case "complete":
+      return "complete";
+    case "failed":
+      return "failed";
+    case "paused":
+      return "paused";
+    case "stopped":
+      return "stopped";
+    case "partial":
+    case "rejected":
+      return "blocked";
+    default:
+      return "queued";
+  }
+}
+function compactWorkflowLaneRows(job, checklist) {
+  const groups = new Map;
+  for (const item of checklist?.phases.flatMap((phase) => phase.items) ?? []) {
+    const key = item.preflight?.key ?? item.key;
+    const group = groups.get(key);
+    if (group)
+      group.push(item);
+    else
+      groups.set(key, [item]);
+  }
+  const rows = [];
+  const preflightKeys = new Set(job.preflight?.lanes.map((lane) => lane.key) ?? []);
+  if (job.preflight?.lanes.length) {
+    for (const lane of job.preflight.lanes) {
+      rows.push(compactWorkflowLaneRow(lane.key, groups.get(lane.key) ?? [], lane, compactWorkflowFallbackState(job)));
+    }
+  }
+  for (const [key, items] of groups) {
+    if (preflightKeys.has(key))
+      continue;
+    rows.push(compactWorkflowLaneRow(key, items));
+  }
+  return rows;
+}
+function compactWorkflowLaneCounts(rows) {
+  const counts = { total: rows.length, done: 0, active: 0, queued: 0, blocked: 0, failed: 0, paused: 0, stopped: 0 };
+  for (const row of rows) {
+    switch (row.state) {
+      case "complete":
+        counts.done++;
+        break;
+      case "running":
+        counts.active++;
+        break;
+      case "queued":
+        counts.queued++;
+        break;
+      case "blocked":
+        counts.blocked++;
+        break;
+      case "failed":
+        counts.failed++;
+        break;
+      case "paused":
+        counts.paused++;
+        break;
+      case "stopped":
+        counts.stopped++;
+        break;
+    }
+  }
+  return counts;
+}
+function compactWorkflowLaneLine(row, theme, indent, frame) {
+  const owner = row.agent && row.mode ? `${row.agent}/${row.mode}` : row.agent ?? row.mode;
+  const state = row.state === "complete" ? undefined : row.state === "running" ? "active" : row.state;
+  const intent = [
+    row.decision,
+    row.claims,
+    row.expectedOutput,
+    !row.mode && row.label ? row.label : undefined
+  ].filter((value) => Boolean(value));
+  return `${indent}${workflowChecklistGlyph({ state: row.state, durationMs: row.durationMs, toolCount: row.toolUses }, theme, frame)} ${theme.bold(row.key)}${owner ? ` ${theme.fg("dim", `· ${owner}`)}` : ""}${state ? ` ${theme.fg("dim", `· ${state}`)}` : ""}${intent.length ? ` ${theme.fg("dim", `· ${intent.join(" · ")}`)}` : ""}`;
+}
+function compactWorkflowShortId(job) {
+  return job.asyncId.slice(0, 8);
+}
+function compactWorkflowDisplayLabel(job) {
+  return boundedLaneValue(job.description, 64) ?? compactWorkflowShortId(job);
+}
+function compactWorkflowStats(job, rows, theme, projection) {
+  const counts = compactWorkflowLaneCounts(rows);
+  const total = counts.total || projection.stageProgress?.total || job.stepsTotal || job.agents?.length || 0;
+  const progress = [
+    total > 0 ? `${counts.done}/${total} done` : undefined,
+    counts.active ? `${counts.active} active` : undefined,
+    counts.queued ? `${counts.queued} queued` : undefined,
+    counts.blocked ? `${counts.blocked} blocked` : undefined,
+    counts.failed ? `${counts.failed} failed` : undefined,
+    counts.paused ? `${counts.paused} paused` : undefined,
+    counts.stopped ? `${counts.stopped} stopped` : undefined
+  ].filter((value) => Boolean(value));
+  const rowToolUses = rows.map((row) => row.toolUses).filter((value) => value !== undefined);
+  const toolUses = job.toolCount ?? (rowToolUses.length ? rowToolUses.reduce((sum, value) => sum + value, 0) : undefined);
+  const rowDuration = rows.map((row) => row.durationMs).filter((value) => value !== undefined);
+  const end = job.status === "running" ? projection.now : job.updatedAt;
+  const durationMs = job.status !== "queued" && job.startedAt !== undefined && end !== undefined ? Math.max(0, end - job.startedAt) : job.status !== "queued" && rowDuration.length ? Math.max(...rowDuration) : undefined;
+  return statJoin(theme, [
+    `id: ${compactWorkflowShortId(job)}`,
+    ...progress,
+    toolUses !== undefined ? formatToolUseStat(toolUses) : undefined,
+    durationMs !== undefined ? formatDuration(durationMs) : undefined
+  ].filter((value) => Boolean(value)));
+}
+function compactWorkflowBottleneck(rows, job) {
+  let row;
+  for (const candidate of rows) {
+    if (candidate.state !== "blocked" && candidate.state !== "failed" && candidate.state !== "paused" && candidate.state !== "stopped")
+      continue;
+    if (!row || workflowChecklistItemPriority(candidate.state) < workflowChecklistItemPriority(row.state))
+      row = candidate;
+  }
+  if (row)
+    return { text: `${row.key} · ${row.state}`, tone: row.state === "blocked" || row.state === "failed" ? "error" : "warning" };
+  if (job.activityState === "needs_attention" || job.timedOut || job.toolBudgetBlocked || job.turnBudgetExceeded)
+    return { text: `workflow · ${job.activityState === "needs_attention" ? "needs attention" : "blocked"}`, tone: job.activityState === "needs_attention" ? "warning" : "error" };
+  if (job.status === "failed" || job.status === "partial" || job.status === "rejected")
+    return { text: `workflow · ${job.status}`, tone: "error" };
+  if (job.status === "paused" || job.status === "stopped")
+    return { text: `workflow · ${job.status}`, tone: "warning" };
+  return;
+}
+function compactWorkflowHeaderLine(job, theme, width) {
+  const label = compactWorkflowDisplayLabel(job);
+  const full = `${theme.fg("toolTitle", themeBold(theme, `async workflow: ${label}`))} ${theme.fg("dim", "─ background")}`;
+  if (width === undefined || visibleWidth(full) <= width)
+    return full;
+  return `${theme.fg("toolTitle", themeBold(theme, `async workflow ${label}`))} ${theme.fg("dim", "· background")}`;
+}
+function compactWorkflowWidgetBodyLines(job, theme, frame, projection) {
+  const rows = compactWorkflowLaneRows(job, projection.checklist);
+  const lines = [`  ${compactWorkflowStats(job, rows, theme, projection)}`];
+  if (projection.inlineFleetCovered)
+    return [...lines, `  ${theme.fg("dim", "Workflow children shown in Fleet roster")}`];
+  if (rows.length) {
+    for (const row of rows) {
+      if (!projection.materializedKeys?.has(row.key))
+        lines.push(compactWorkflowLaneLine(row, theme, "  ", frame));
+    }
+  } else {
+    lines.push(`  ${theme.fg("dim", "◦ waiting for workflow lanes")}`);
+  }
+  const bottleneck = compactWorkflowBottleneck(rows, job);
+  if (bottleneck)
+    lines.push(`  ${theme.fg(bottleneck.tone, `bottleneck · ${bottleneck.text}`)}`);
+  if (job.status === "running" || rows.some((row) => row.state === "running"))
+    lines.push(`  ${theme.fg("accent", workflowDetailHintText())}`);
+  return lines;
+}
 function widgetStepActivity(step, snapshotNow) {
   const facts = [];
   if (step.currentTool && step.currentToolStartedAt !== undefined && snapshotNow !== undefined)
@@ -1496,12 +1811,15 @@ function buildForegroundResultEntries(details, label, displayStart, displayEnd,
   });
   return label.itemTitle === "Agent" ? withDuplicateForegroundLabels(entries, label.totalCount) : entries;
 }
-function widgetStats(job, theme, projection = buildWorkflowWidgetProjection(job)) {
+function widgetStats(job, theme, projection = buildWorkflowWidgetProjection(job), collapsed = false) {
   const parts = [];
   const { stageProgress } = projection;
   const stepsTotal = stageProgress?.total ?? job.stepsTotal ?? (job.agents?.length ?? 1);
   const isSingleChild = isSingleChildAsyncJob(job);
-  if (stageProgress) {
+  const checklistPrimary = collapsed && job.mode === "workflow" && projection.checklist !== undefined;
+  if (checklistPrimary) {
+    parts.push(formatWorkflowChecklistSummary(projection.checklist));
+  } else if (stageProgress) {
     const currentStage = stageProgress.current !== undefined ? projection.stages[stageProgress.current] : undefined;
     const focus = currentStage ? [compactTaskText(undefined, currentStage.label) ?? boundedLaneValue(currentStage.id), currentStage.agent ? boundedLaneValue(currentStage.agent) : "", workflowNodeStatusLabel(currentStage.status)].filter(Boolean) : [];
     parts.push(["staged lane", stageProgress.current !== undefined ? `stage ${stageProgress.current + 1}/${stageProgress.total}` : `${stageProgress.total} stages`, ...focus].join(" · "));
@@ -1532,20 +1850,25 @@ function widgetStats(job, theme, projection = buildWorkflowWidgetProjection(job)
   } else if (stepsTotal > 1) {
     parts.push(`steps ${stepsTotal}`);
   }
+  if (projection.checklist && !checklistPrimary)
+    parts.push(formatWorkflowChecklistSummary(projection.checklist));
   if (job.toolCount !== undefined)
     parts.push(formatToolUseStat(job.toolCount));
   if (job.totalTokens?.total)
     parts.push(formatTokenUsage(job.totalTokens, "token"));
-  if (job.startedAt !== undefined && job.updatedAt !== undefined)
-    parts.push(formatDuration(Math.max(0, job.updatedAt - job.startedAt)));
+  const end = job.status === "running" && (job.mode === "workflow" || job.parentWorkflowRunId) ? projection.now : job.updatedAt;
+  if (job.status !== "queued" && job.startedAt !== undefined && end !== undefined)
+    parts.push(formatDuration(Math.max(0, end - job.startedAt)));
   return statJoin(theme, parts);
 }
-function widgetStepStats(theme, step) {
+function widgetStepStats(theme, step, snapshotNow = Date.now()) {
+  const externalElapsed = step.runner?.type === "external-cli" && step.externalProcess ? step.externalProcess.durationMs ?? Math.max(0, (step.externalProcess.endedAt ?? snapshotNow) - step.externalProcess.startedAt) : undefined;
   return statJoin(theme, [
+    step.runner?.type === "external-cli" ? "external-cli" : "",
     step.turnCount !== undefined ? `${step.turnCount} turns` : "",
     step.toolCount !== undefined ? formatToolUseStat(step.toolCount) : "",
     step.tokens ? step.contextLimit !== undefined ? formatContextUsage(step.tokens, step.contextLimit) ?? formatTokenUsage(step.tokens, "token") : step.tokens.total ? formatTokenUsage(step.tokens, "token") : "" : "",
-    step.durationMs !== undefined ? formatDuration(step.durationMs) : ""
+    externalElapsed !== undefined ? formatDuration(externalElapsed) : step.durationMs !== undefined ? formatDuration(step.durationMs) : ""
   ]);
 }
 function modelThinkingBadge(theme, model, thinking) {
@@ -1742,7 +2065,7 @@ function foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index, tota
   const rowIndent = options?.rowIndent ?? "  ";
   const detailIndent = options?.detailIndent ?? "    ";
   const status = widgetStepStatus(step.status, theme);
-  const stats = widgetStepStats(theme, step);
+  const stats = widgetStepStats(theme, step, job.updatedAt);
   const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking);
   const collapseDetails = shouldCollapseSingleChildDetails(job, step);
   const displayName = collapseDetails ? singleChildAgentName(job, step) : childDisplayName(step);
@@ -1812,11 +2135,16 @@ function hostStepWidgetLines(job, theme, indent) {
   return lines;
 }
 function foregroundStyleWidgetDetails(job, theme, expanded, width, frame, projection = buildWorkflowWidgetProjection(job)) {
-  const { steps } = projection;
+  const steps = projection.steps.filter((step) => !projection.materializedKeys?.has(step.workflowKey ?? "") && !projection.materializedKeys?.has(step.runId ?? ""));
+  const checklist = widgetChecklistWithoutMaterializedChildren(projection);
+  if (!expanded && job.mode === "workflow") {
+    return compactWorkflowWidgetBodyLines(job, theme, frame, projection);
+  }
   if (!steps.length) {
     const lane = projectAsyncLane(job, laneStepForJob(job, steps));
     return [
-      ...workflowPreflightLines(job, expanded),
+      ...expanded ? workflowPreflightLines(job) : [],
+      ...workflowChecklistWidgetLines(checklist, theme, "  ", expanded, frame),
       ...lane ? formatLaneProjectionLines(lane, theme, "  ") : [],
       ...hostStepWidgetLines(job, theme, "  "),
       `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
@@ -1825,7 +2153,10 @@ function foregroundStyleWidgetDetails(job, theme, expanded, width, frame, projec
   }
   if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length)
     return widgetChainDetails(job, theme, expanded, width, frame);
-  const lines = workflowPreflightLines(job, expanded);
+  const lines = [
+    ...expanded ? workflowPreflightLines(job) : [],
+    ...workflowChecklistWidgetLines(checklist, theme, "  ", expanded, frame, { includeItemErrors: !expanded })
+  ];
   const group = activeParallelWidgetGroup(job);
   if (group) {
     lines.push(...parallelWidgetGroupDetails(job, theme, group, expanded, width, frame, Boolean(job.activeParallelGroup)));
@@ -1852,11 +2183,14 @@ function foregroundStyleWidgetDetails(job, theme, expanded, width, frame, projec
   return lines;
 }
 function buildSingleWidgetLines(job, theme, width, expanded, frame, projection = buildWorkflowWidgetProjection(job)) {
-  const stats = widgetStats(job, theme, projection);
-  const count = job.mode === "chain" ? job.chainStepCount : projection.stageProgress?.total ?? job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
+  if ((!expanded || projection.inlineFleetCovered) && job.mode === "workflow")
+    return [compactWorkflowHeaderLine(job, theme, width), ...compactWorkflowWidgetBodyLines(job, theme, frame, projection)].map((line) => truncLine(line, width));
+  const stats = widgetStats(job, theme, projection, !expanded);
+  const count = job.mode === "workflow" ? projection.checklist?.total ?? projection.stageProgress?.total ?? job.stepsTotal ?? job.agents?.length ?? job.steps?.length : job.mode === "chain" ? job.chainStepCount : projection.stageProgress?.total ?? job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
   const mode = widgetJobName(job);
   const title = isSingleChildAsyncJob(job) ? "async subagent" : `async subagent ${mode}${count && count > 1 ? ` (${count})` : ""}`;
-  const collapseDetails = job.steps?.length === 1 && shouldCollapseSingleChildDetails(job, job.steps[0]);
+  const checklistPrimary = !expanded && job.mode === "workflow" && projection.checklist !== undefined;
+  const collapseDetails = !checklistPrimary && job.steps?.length === 1 && shouldCollapseSingleChildDetails(job, job.steps[0]);
   const summary = `${widgetStatusGlyph(job, theme, frame)} ${themeBold(theme, mode)}${contextModeBadge(theme, job.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`;
   return [
     `${theme.fg("toolTitle", themeBold(theme, title))} ${theme.fg("dim", "· background")}`,
@@ -1878,7 +2212,7 @@ function compactSingleWidgetLines(job, theme, width, frame, projection = buildWo
     const step = row.step;
     const status = widgetStepStatus(step.status, theme);
     const activity = widgetStepActivityLine(step, width, false, job.updatedAt);
-    const stepStats = widgetStepStats(theme, step);
+    const stepStats = widgetStepStats(theme, step, job.updatedAt);
     const activitySuffix = activity ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", activity)}` : "";
     const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking);
     const task = compactTaskText(step.description, step.label);
@@ -1939,6 +2273,11 @@ function buildSingleLineWidgetLines(jobs, theme, width, frame) {
     parts.push(`${counts.stopped.length} stopped`);
   if (counts.paused.length > 0)
     parts.push(`${counts.paused.length} paused`);
+  for (const status of ["partial", "rejected"]) {
+    const count = jobs.filter((job) => job.status === status).length;
+    if (count > 0)
+      parts.push(`${count} ${status}`);
+  }
   if (!hasActive && counts.complete.length > 0)
     parts.push(`${counts.complete.length}/${jobs.length} done`);
   return [truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "subagents")} (${parts.join(", ") || `${jobs.length} total`})`, width)];
@@ -2020,7 +2359,14 @@ function progressiveHeaderLine(jobs, theme, width, frame) {
   return truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(", ") || `${jobs.length} total`)}`, width);
 }
 function progressiveJobLine(job, theme, width, frame, projection = buildWorkflowWidgetProjection(job)) {
-  const stats = widgetStats(job, theme, projection);
+  const compactWorkflow = job.mode === "workflow";
+  const compactRows = compactWorkflow ? compactWorkflowLaneRows(job, projection.checklist) : undefined;
+  const stats = compactWorkflow ? compactWorkflowStats(job, compactRows ?? [], theme, projection) : widgetStats(job, theme, projection, true);
+  if (compactWorkflow) {
+    const bottleneck = compactWorkflowBottleneck(compactRows ?? [], job);
+    const suffix = [stats, bottleneck ? theme.fg(bottleneck.tone, `bottleneck · ${bottleneck.text}`) : undefined].filter((value) => Boolean(value)).join(` ${theme.fg("dim", "·")} `);
+    return truncLine(`  ${widgetStatusGlyph(job, theme, frame)} ${compactWorkflowHeaderLine(job, theme, Math.max(0, width - 4))}${suffix ? ` ${theme.fg("dim", "·")} ${suffix}` : ""}`, width);
+  }
   const activity = widgetActivity(job);
   const status = job.status === "complete" ? "done" : job.status;
   const lane = projectAsyncLane(job, laneStepForJob(job, projection.steps));
@@ -2089,7 +2435,7 @@ function fitWidgetLineBudget(lines, theme, width, expanded) {
     return lines;
   const visibleLines = Math.max(1, budget - 1);
   const hiddenCount = lines.length - visibleLines;
-  const hint = expanded ? `… ${hiddenCount} live-detail lines hidden` : `… ${hiddenCount} lines hidden · ${liveDetailKeyText()} expands`;
+  const hint = expanded ? `… ${hiddenCount} live-detail lines hidden` : `… ${hiddenCount} lines hidden · ${expandKeyHint("to expand", "to view them")}`;
   return [...lines.slice(0, visibleLines), truncLine(theme.fg("dim", hint), width)];
 }
 function fitAdaptiveWidgetLines(jobs, buildLines, theme, width, expanded, frame, projectionFor) {
@@ -2127,35 +2473,186 @@ function fitAdaptiveWidgetLines(jobs, buildLines, theme, width, expanded, frame,
   widgetLayoutSession = { expanded, rows, columns, tier: "progressive", lockedRows, visibleJobKeys: rendered.visibleJobKeys };
   return rendered.lines;
 }
-function buildWidgetComponent(jobs, isExpanded) {
-  return (_tui, theme) => {
+const asyncWidgetUpdates = new WeakMap;
+const inlineWorkflowCoverage = new WeakMap;
+const asyncWidgetInvalidations = new WeakMap;
+function inlineWorkflowDescendantShape(children) {
+  return children?.map((child) => [child.id, child.agent, inlineWorkflowDescendantShape(child.children)]);
+}
+function inlineWorkflowRowShape(job) {
+  return [
+    job.asyncId,
+    job.parentWorkflowRunId,
+    job.workflowKey,
+    job.mode,
+    job.currentStep,
+    job.activeParallelGroup,
+    job.status,
+    job.context,
+    job.agents,
+    job.steps?.map((step, index) => [
+      step.index ?? index,
+      step.workflowKey,
+      step.agent,
+      step.status,
+      Boolean(step.runner),
+      inlineWorkflowDescendantShape(step.children)
+    ]),
+    inlineWorkflowDescendantShape(job.nestedChildren),
+    job.hostSteps?.map((row) => [row.id, row.monitorKind, row.label]),
+    Boolean(job.workflowGraph)
+  ];
+}
+export function inlineWorkflowRenderKey(job, children) {
+  return JSON.stringify([inlineWorkflowRowShape(job), children.map(inlineWorkflowRowShape)]);
+}
+export function setInlineWorkflowCoverage(ui, coverage) {
+  const previous = inlineWorkflowCoverage.get(ui);
+  if ((previous?.size ?? 0) === coverage.size && [...coverage].every(([id, key]) => previous?.get(id) === key))
+    return;
+  if (coverage.size)
+    inlineWorkflowCoverage.set(ui, coverage);
+  else
+    inlineWorkflowCoverage.delete(ui);
+  asyncWidgetInvalidations.get(ui)?.();
+}
+function widgetJobTree(jobs, now) {
+  const parents = new Map(jobs.filter((job) => job.mode === "workflow").map((job) => [job.asyncId, job]));
+  const childrenByParent = new Map;
+  const roots = [];
+  for (const job of jobs) {
+    const parent = job.parentWorkflowRunId ? parents.get(job.parentWorkflowRunId) : undefined;
+    const keepLiveRoot = isProgressiveActiveJob(job) && parent?.status !== "running";
+    if (parent && parent.asyncId !== job.asyncId && !keepLiveRoot) {
+      const children = childrenByParent.get(parent.asyncId) ?? [];
+      children.push(job);
+      childrenByParent.set(parent.asyncId, children);
+    } else
+      roots.push(job);
+  }
+  return { roots, projectionFor: workflowWidgetProjectionLookup(now, childrenByParent) };
+}
+function widgetChecklistWithoutMaterializedChildren(projection) {
+  const { checklist, materializedKeys } = projection;
+  if (!checklist || !materializedKeys)
+    return checklist;
+  return { ...checklist, phases: checklist.phases.map((phase) => ({ ...phase, items: phase.items.filter((item) => !materializedKeys.has(item.key)) })) };
+}
+function materializedWidgetChildLines(job, theme, width, expanded, frame, projectionFor) {
+  const { children, inlineFleetCovered } = projectionFor(job);
+  if (inlineFleetCovered || !children?.length)
+    return [];
+  const lines = [];
+  const shown = orderedWidgetJobs(children).slice(0, MAX_WIDGET_JOBS);
+  for (const [index, child] of shown.entries()) {
+    const projection = projectionFor(child);
+    const last = index === children.length - 1;
+    const identity = child.workflowKey ?? child.asyncId;
+    const stats = widgetStats(child, theme, projection, !expanded);
+    lines.push(`  ${last ? "└─" : "├─"} ${theme.bold(identity)} ${widgetStatusGlyph(child, theme, frame)} ${themeBold(theme, widgetJobName(child))}${contextModeBadge(theme, child.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`);
+    for (const detail of foregroundStyleWidgetDetails(child, theme, expanded, Math.max(0, width - 6), frame, projection))
+      lines.push(`  ${last ? "  " : "│ "}${detail}`);
+    for (const detail of materializedWidgetChildLines(child, theme, Math.max(0, width - 4), expanded, frame, projectionFor))
+      lines.push(`    ${detail}`);
+  }
+  if (shown.length < children.length)
+    lines.push(`  +${children.length - shown.length} more workflow children`);
+  return lines;
+}
+function buildWidgetComponent(jobs, ui) {
+  return (tui, theme) => {
     const container = new Container;
     let cachedRenderWidth;
     let cachedFrame;
     let cachedExpanded;
     let cachedLines;
+    let cachedCoverage = "[]";
+    let collapsed = false;
+    const invalidate = () => {
+      cachedLines = undefined;
+      resetWidgetLayoutSession();
+      tui.requestRender();
+    };
+    const invalidateCoverage = () => {
+      cachedLines = undefined;
+      tui.requestRender();
+    };
+    asyncWidgetInvalidations.set(ui, invalidateCoverage);
+    const update = (nextJobs) => {
+      jobs = nextJobs;
+      cachedLines = undefined;
+      tui.requestRender();
+    };
+    asyncWidgetUpdates.set(ui, update);
+    const component = Object.assign(container, {
+      handleMouse(event) {
+        if (event.type !== "click" || event.button !== "left" || event.y !== 0)
+          return;
+        if (event.shift || event.alt || event.ctrl)
+          return;
+        collapsed = !collapsed;
+        invalidate();
+        return { handled: true };
+      },
+      dispose() {
+        if (asyncWidgetUpdates.get(ui) === update)
+          asyncWidgetUpdates.delete(ui);
+        if (asyncWidgetInvalidations.get(ui) === invalidateCoverage)
+          asyncWidgetInvalidations.delete(ui);
+      }
+    });
     container.render = (renderWidth) => {
-      const frame = Math.floor(Date.now() / WIDGET_ANIMATION_INTERVAL_MS);
-      const expanded = isExpanded();
-      if (cachedLines && cachedRenderWidth === renderWidth && cachedFrame === frame && cachedExpanded === expanded)
+      const now = Date.now();
+      const frame = Math.floor(now / WIDGET_ANIMATION_INTERVAL_MS);
+      const expanded = ui.getToolsExpanded?.() ?? false;
+      const coverage = inlineWorkflowCoverage.get(ui);
+      const covered = new Set;
+      if (coverage?.size) {
+        const childrenByParent = new Map;
+        for (const child of jobs) {
+          if (!child.parentWorkflowRunId)
+            continue;
+          const children = childrenByParent.get(child.parentWorkflowRunId) ?? [];
+          children.push(child);
+          childrenByParent.set(child.parentWorkflowRunId, children);
+        }
+        for (const job of jobs) {
+          const snapshot = coverage.get(job.asyncId);
+          if (snapshot === undefined)
+            continue;
+          const children = childrenByParent.get(job.asyncId) ?? [];
+          if (!children.some((child) => childrenByParent.has(child.asyncId)) && snapshot === inlineWorkflowRenderKey(job, children))
+            covered.add(job.asyncId);
+        }
+      }
+      const coverageKey = JSON.stringify([...covered]);
+      if (cachedLines && cachedRenderWidth === renderWidth && cachedFrame === frame && cachedExpanded === expanded && cachedCoverage === coverageKey)
         return cachedLines;
+      if (cachedCoverage !== coverageKey)
+        resetWidgetLayoutSession();
+      cachedCoverage = coverageKey;
       const width = Math.max(0, renderWidth - 2);
-      const projectionFor = workflowWidgetProjectionLookup();
-      const buildLines = () => expanded ? buildWidgetLinesWithProjection(jobs, theme, width, true, frame, projectionFor) : jobs.length === 1 ? compactSingleWidgetLines(jobs[0], theme, width, frame, projectionFor(jobs[0])) : buildWidgetLinesWithProjection(jobs, theme, width, false, frame, projectionFor);
+      const { roots, projectionFor } = widgetJobTree(jobs, now);
+      for (const job of roots)
+        projectionFor(job).inlineFleetCovered = covered.has(job.asyncId);
+      const buildLines = () => expanded ? buildWidgetLinesWithProjection(roots, theme, width, true, frame, projectionFor) : roots.length === 1 && !projectionFor(roots[0]).children?.length ? compactSingleWidgetLines(roots[0], theme, width, frame, projectionFor(roots[0])) : buildWidgetLinesWithProjection(roots, theme, width, false, frame, projectionFor);
       cachedRenderWidth = renderWidth;
       cachedFrame = frame;
       cachedExpanded = expanded;
-      cachedLines = fitAdaptiveWidgetLines(jobs, buildLines, theme, width, expanded, frame, projectionFor).map((line) => paddedWidgetLine(line, renderWidth));
+      cachedLines = (collapsed ? buildSingleLineWidgetLines(jobs, theme, width, frame) : fitAdaptiveWidgetLines(roots, buildLines, theme, width, expanded, frame, projectionFor)).map((line) => paddedWidgetLine(line, renderWidth));
       return cachedLines;
     };
-    return container;
+    return component;
   };
 }
 function buildWidgetLinesWithProjection(jobs, theme, width = getTermWidth(), expanded = false, frame, projectionFor = workflowWidgetProjectionLookup()) {
   if (jobs.length === 0)
     return [];
   if (jobs.length === 1)
-    return buildSingleWidgetLines(jobs[0], theme, width, expanded, frame, projectionFor(jobs[0]));
+    return [
+      ...buildSingleWidgetLines(jobs[0], theme, width, expanded, frame, projectionFor(jobs[0])),
+      ...materializedWidgetChildLines(jobs[0], theme, width, expanded, frame, projectionFor).map((line) => truncLine(line, width))
+    ];
   const running = jobs.filter((job) => job.status === "running");
   const queued = jobs.filter((job) => job.status === "queued");
   const finished = jobs.filter((job) => job.status !== "running" && job.status !== "queued");
@@ -2170,12 +2667,20 @@ function buildWidgetLinesWithProjection(jobs, theme, width = getTermWidth(), exp
   let slots = MAX_WIDGET_JOBS;
   const appendJob = (job) => {
     const projection = projectionFor(job);
-    const stats = widgetStats(job, theme, projection);
-    items.push([
-      `${widgetStatusGlyph(job, theme, frame)} ${themeBold(theme, widgetJobName(job))}${contextModeBadge(theme, job.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+    const compactWorkflow = (!expanded || projection.inlineFleetCovered) && job.mode === "workflow";
+    const stats = compactWorkflow ? "" : widgetStats(job, theme, projection, !expanded);
+    const details = compactWorkflow ? [
+      ...compactWorkflowWidgetBodyLines(job, theme, frame, projection)
+    ] : [
       `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
       ...widgetLaneDetailLines(job, theme, projection),
+      ...workflowChecklistWidgetLines(widgetChecklistWithoutMaterializedChildren(projection), theme, "  ", expanded, frame, { includeItemErrors: !expanded || !job.steps?.length }),
       ...widgetParallelAgentDetails(job, theme, expanded, width, frame)
+    ];
+    items.push([
+      compactWorkflow ? compactWorkflowHeaderLine(job, theme, width) : `${widgetStatusGlyph(job, theme, frame)} ${themeBold(theme, widgetJobName(job))}${contextModeBadge(theme, job.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+      ...details,
+      ...materializedWidgetChildLines(job, theme, width, expanded, frame, projectionFor)
     ]);
   };
   for (const job of running) {
@@ -2224,11 +2729,13 @@ function buildWidgetLinesWithProjection(jobs, theme, width = getTermWidth(), exp
   return lines;
 }
 export function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = false, frame) {
-  return buildWidgetLinesWithProjection(jobs, theme, width, expanded, frame);
+  const { roots, projectionFor } = widgetJobTree(jobs, Date.now());
+  return buildWidgetLinesWithProjection(roots, theme, width, expanded, frame, projectionFor);
 }
 export function renderWidget(ctx, jobs) {
   if (jobs.length === 0) {
     resetWidgetLayoutSession();
+    asyncWidgetUpdates.delete(ctx.ui);
     if (ctx.hasUI)
       ctx.ui.setWidget(WIDGET_KEY, undefined);
     return;
@@ -2239,7 +2746,11 @@ export function renderWidget(ctx, jobs) {
     ctx.ui.setWidget(WIDGET_KEY, encodeAsyncStatusSnapshotWidget(jobs));
     return;
   }
-  ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, () => ctx.ui.getToolsExpanded?.() ?? false));
+  const update = asyncWidgetUpdates.get(ctx.ui);
+  if (update)
+    update(jobs);
+  else
+    ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, ctx.ui));
 }
 function renderSingleCompact(d, r, theme, layout, frame, foregroundDetachShortcut) {
   const output = r.truncation?.text || getSingleResultOutput(r);
@@ -2324,6 +2835,53 @@ function workflowOverallState(rows, hasTerminalValue, isError) {
     return "complete";
   return "running";
 }
+function foregroundWorkflowChecklist(details) {
+  if (details.mode !== "workflow")
+    return;
+  const stageNodes = details.workflowGraph ? workflowGraphStageNodes(details.workflowGraph) : [];
+  const steps = details.results.flatMap((result, resultIndex) => {
+    const stableIndex = foregroundResultIndex(details, resultIndex);
+    const workflowKey = result.workflowKey;
+    if (details.workflowGraph && typeof workflowKey !== "string")
+      return [];
+    const node = typeof workflowKey === "string" ? stageNodes.find((candidate) => candidate.id === workflowKey) : undefined;
+    const progress = foregroundProgressForResult(details, resultIndex);
+    const status = isResultRunning(result) || progress?.status === "running" ? "running" : result.detached ? "paused" : result.stopped ? "stopped" : result.exitCode === 0 ? "complete" : "failed";
+    return [{
+      key: node?.id ?? (typeof workflowKey === "string" ? workflowKey : `result-${resultIndex + 1}`),
+      label: node?.label ?? workflowLabelForResult(details, resultIndex) ?? result.task ?? result.agent,
+      phase: node?.phase,
+      agent: result.agent,
+      status,
+      context: result.context,
+      activityState: progress?.activityState,
+      startedAt: progress?.lastActivityAt !== undefined && progress.durationMs !== undefined ? progress.lastActivityAt - progress.durationMs : undefined,
+      durationMs: progress?.durationMs,
+      currentTool: progress?.currentTool,
+      currentToolStartedAt: progress?.currentToolStartedAt,
+      currentPath: progress?.currentPath,
+      turnCount: progress?.turnCount,
+      toolCount: progress?.toolCount ?? result.progressSummary?.toolCount,
+      error: result.error,
+      toolBudgetBlocked: result.toolBudgetBlocked,
+      turnBudgetExceeded: result.turnBudgetExceeded,
+      timedOut: result.timedOut,
+      stopped: result.stopped,
+      acceptance: result.acceptance ? { status: result.acceptance.status, reviewResult: result.acceptance.reviewResult ? { status: result.acceptance.reviewResult.status } : undefined } : undefined,
+      review: result.review ? { status: result.review.status } : undefined,
+      watchdog: result.watchdog
+    }];
+  });
+  const checklist = projectWorkflowChecklist({
+    graph: details.workflowGraph,
+    steps,
+    hostSteps: details.workflow?.receipt?.hostSteps,
+    preflight: details.preflight,
+    trace: details.workflow?.trace,
+    now: Date.now()
+  });
+  return checklist.total > 0 ? checklist : undefined;
+}
 function renderWorkflowChatProgress(d, result, theme, layout, frame, expanded = false) {
   const workflow = d.workflow;
   const rows = workflow ? buildWorkflowChatProgressRows(workflow.trace, d.preflight) : d.preflight ? buildWorkflowChatProgressRows([], d.preflight) : [];
@@ -2341,6 +2899,10 @@ function renderWorkflowChatProgress(d, result, theme, layout, frame, expanded =
     c.addChild(new Text(truncLine(theme.fg("dim", formatWorkflowPreflightPlanSummary(d.preflight, { indent: rowIndent })), width), 0, 0));
   if (phase)
     c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}Phase  ${phase}`), width), 0, 0));
+  const checklist = projectWorkflowChecklist({ hostSteps: workflow?.receipt?.hostSteps, preflight: d.preflight, trace: workflow?.trace, now: Date.now() });
+  for (const line of workflowChecklistWidgetLines(checklist, theme, rowIndent, false, frame, { limitPhases: !expanded, includeBottleneckOutput: expanded })) {
+    c.addChild(new Text(truncLine(line, width), 0, 0));
+  }
   if (rows.length === 0) {
     c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}◦ waiting for workflow child launches`), width), 0, 0));
     return c;
@@ -2398,7 +2960,9 @@ function renderMultiCompact(d, theme, layout, frame) {
   }
   const multiLabel = buildMultiProgressLabel(d, hasRunning);
   const itemTitle = multiLabel.itemTitle;
-  const stats = statJoin(theme, [multiLabel.headerLabel, formatProgressStats(theme, totalSummary), formatTotalCostStat(d.totalCost)]);
+  const workflowChecklist = foregroundWorkflowChecklist(d);
+  const checklistPrimary = d.mode === "workflow" && workflowChecklist !== undefined;
+  const stats = statJoin(theme, [checklistPrimary ? formatWorkflowChecklistSummary(workflowChecklist) : multiLabel.headerLabel, formatProgressStats(theme, totalSummary), formatTotalCostStat(d.totalCost)]);
   const aggregatePresentation = semanticResultPresentation({
     running: hasRunning,
     detached,
@@ -2416,6 +2980,17 @@ function renderMultiCompact(d, theme, layout, frame) {
   const rowIndent = mainWindowIndent(layout, 1);
   const detailIndent = mainWindowIndent(layout, 2);
   c.addChild(new Text(truncLine(`${glyph} ${theme.fg("toolTitle", theme.bold(d.mode))}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
+  if (checklistPrimary) {
+    for (const line of workflowChecklistWidgetLines(workflowChecklist, theme, rowIndent, false, frame, { includeSummary: false })) {
+      c.addChild(new Text(truncLine(line, width), 0, 0));
+    }
+    if (hasRunning || workflowChecklist.running > 0)
+      c.addChild(new Text(truncLine(theme.fg("accent", `${rowIndent}${liveDetailHintText()}`), width), 0, 0));
+    return c;
+  }
+  for (const line of workflowChecklistWidgetLines(workflowChecklist, theme, rowIndent, false, frame)) {
+    c.addChild(new Text(truncLine(line, width), 0, 0));
+  }
   const useResultsDirectly = multiLabel.hasParallelInChain || !d.chainAgents?.length;
   const displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0;
   const displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : useResultsDirectly ? d.results.length : d.chainAgents.length;
@@ -2523,7 +3098,7 @@ export function renderSubagentResult(result, options, theme, frame, rendererConf
       const c = new Container;
       const detailIndent = mainWindowIndent(layout, 1);
       c.addChild(new Text(truncLine(`${contextPrefix}${compactLine} · ${lines.length} lines`, width), 0, 0));
-      c.addChild(new Text(truncLine(theme.fg("accent", `${detailIndent}Press ${liveDetailKeyText()} for full output`), width), 0, 0));
+      c.addChild(new Text(truncLine(theme.fg("accent", `${detailIndent}${expandKeyHint("for full output")}`), width), 0, 0));
       return compact(c);
     }
     const c = new Container;
@@ -2610,9 +3185,6 @@ export function renderSubagentResult(result, options, theme, frame, rendererConf
     if (r.skillsWarning) {
       c.addChild(new Text(fit(theme.fg("warning", `Warning: ${r.skillsWarning}`)), 0, 0));
     }
-    if (r.attemptedModels && r.attemptedModels.length > 1) {
-      c.addChild(new Text(fit(theme.fg("dim", `Fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
-    }
     c.addChild(new Text(fit(theme.fg("dim", formatUsage(r.usage, r.model))), 0, 0));
     if (r.sessionFile) {
       c.addChild(new Text(fit(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`)), 0, 0));
@@ -2675,6 +3247,10 @@ export function renderSubagentResult(result, options, theme, frame, rendererConf
   if (chainVis) {
     c.addChild(new Text(fit(`  ${chainVis}`), 0, 0));
   }
+  const workflowChecklist = foregroundWorkflowChecklist(d);
+  for (const line of workflowChecklistWidgetLines(workflowChecklist, theme, "  ", true, frame, { includeItemErrors: false })) {
+    c.addChild(new Text(fit(line), 0, 0));
+  }
   const useResultsDirectly = multiLabel.hasParallelInChain || !d.chainAgents?.length;
   const displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0;
   const displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : useResultsDirectly ? d.results.length : d.chainAgents.length;
@@ -2733,9 +3309,6 @@ export function renderSubagentResult(result, options, theme, frame, rendererConf
     if (r.skillsWarning) {
       c.addChild(new Text(fit(theme.fg("warning", `    Warning: ${r.skillsWarning}`)), 0, 0));
     }
-    if (r.attemptedModels && r.attemptedModels.length > 1) {
-      c.addChild(new Text(fit(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" → ")}`)), 0, 0));
-    }
     if (rRunning && rProg) {
       if (rProg.skills?.length) {
         c.addChild(new Text(fit(theme.fg("accent", `    skills: ${rProg.skills.join(", ")}`)), 0, 0));