@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -1,26 +1,74 @@
 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 {
   MAX_WIDGET_JOBS,
+  WIDGET_ANIMATION_INTERVAL_MS,
   WIDGET_KEY
 } from "../shared/types.js";
-import { formatTokens, formatUsage, formatDuration, formatModelThinking, formatToolCall, shortenPath } from "../shared/formatters.js";
-import { getDisplayItems, getSingleResultOutput } from "../shared/utils.js";
+import { previewDisplayText, sanitizeDisplayText, truncateDisplayText } from "../shared/display-text.js";
+import { FLEET_OPEN_SHORTCUT, 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";
 import { formatNestedAggregate } from "../runs/shared/nested-render.js";
 import { aggregateStepStatus, formatActivityLabel, formatAgentRunningLabel, formatParallelOutcome } from "../shared/status-format.js";
+import { contextModeBadge, contextModePrefix } from "../runs/shared/context-mode.js";
+import { shouldSuppressSingleStep, stripRepeatedAgentPrefix, withDuplicateLabelDiscriminators } from "./render-helpers.js";
+import { buildWorkflowChatProgressRows } from "../workflows/chat-progress.js";
+import { formatWorkflowPreflight, formatWorkflowPreflightPlanSummary, formatWorkflowPreflightWarningSummary, formatWorkflowPreflightWarnings } from "../workflows/workflow-preflight.js";
+import { encodeAsyncStatusSnapshotWidget } from "../runs/background/async-status-snapshot.js";
+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";
+function resolveMainWindowRenderLayout(config) {
+  return {
+    horizontalSpacing: config?.horizontalSpacing ?? 2,
+    ...config?.compactResultMaxLines !== undefined ? { compactResultMaxLines: config.compactResultMaxLines } : {}
+  };
+}
+function mainWindowIndent(layout, level) {
+  return " ".repeat(Math.max(0, layout.horizontalSpacing * level));
+}
+function capCompactMainWindowResult(component, layout, theme, enabled) {
+  const maxLines = layout.compactResultMaxLines;
+  if (!enabled || maxLines === undefined)
+    return component;
+  const capped = new Container;
+  capped.render = (width) => {
+    const lines = component.render(width);
+    if (lines.length <= maxLines)
+      return lines;
+    const visibleRows = maxLines === 1 ? 1 : maxLines - 1;
+    const hiddenCount = lines.length - visibleRows;
+    const hint = theme.fg("accent", `… ${hiddenCount} rows hidden · ${liveDetailKeyText()} expands`);
+    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 liveDetailHintText() {
-  return `Press ${liveDetailKeyText()} for live detail`;
+export function liveDetailHintText() {
+  return `Press ${liveDetailKeyText()} for live detail · ${formatShortcutLabel(FLEET_OPEN_SHORTCUT)} Fleet`;
+}
+function foregroundSingleHintText(shortcut) {
+  if (!shortcut)
+    return liveDetailHintText();
+  const label = formatShortcutLabel(shortcut);
+  return `${liveDetailHintText()} · ${label} to run in background`;
 }
 function getTermWidth() {
   return process.stdout.columns || 120;
 }
 const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-function truncLine(text, maxWidth) {
+const ansiStylePattern = /\x1b\[[0-9;]*m/y;
+export function truncLine(text, maxWidth) {
+  if (maxWidth <= 0)
+    return "";
   if (visibleWidth(text) <= maxWidth)
     return text;
   const targetWidth = maxWidth - 1;
@@ -29,7 +77,8 @@ function truncLine(text, maxWidth) {
   let activeStyles = [];
   let i = 0;
   while (i < text.length) {
-    const ansiMatch = text.slice(i).match(/^\x1b\[[0-9;]*m/);
+    ansiStylePattern.lastIndex = i;
+    const ansiMatch = ansiStylePattern.exec(text);
     if (ansiMatch) {
       const code = ansiMatch[0];
       result += code;
@@ -41,14 +90,15 @@ function truncLine(text, maxWidth) {
       i += code.length;
       continue;
     }
-    let end = i;
-    while (end < text.length && !text.slice(end).match(/^\x1b\[[0-9;]*m/)) {
-      end++;
-    }
+    let end = text.indexOf("\x1B[", i);
+    if (end === i)
+      end = text.indexOf("\x1B[", i + 2);
+    if (end === -1)
+      end = text.length;
     const textPortion = text.slice(i, end);
     for (const seg of segmenter.segment(textPortion)) {
       const grapheme = seg.segment;
-      const graphemeWidth = visibleWidth(grapheme);
+      const graphemeWidth = grapheme === "\x1B" ? 0 : visibleWidth(grapheme);
       if (currentWidth + graphemeWidth > targetWidth) {
         return result + activeStyles.join("") + "…";
       }
@@ -74,6 +124,8 @@ function wrapPlainText(text, maxWidth) {
     for (const seg of segmenter.segment(rawLine)) {
       const grapheme = seg.segment;
       const graphemeWidth = visibleWidth(grapheme);
+      if (graphemeWidth > maxWidth)
+        continue;
       if (currentWidth > 0 && currentWidth + graphemeWidth > maxWidth) {
         lines.push(current);
         current = grapheme;
@@ -101,7 +153,13 @@ function runningSeed(...values) {
 function runningGlyph(seed) {
   if (seed === undefined)
     return STATIC_RUNNING_GLYPH;
-  return RUNNING_FRAMES[Math.abs(seed) % RUNNING_FRAMES.length];
+  const clock = Math.floor(Date.now() / 125);
+  return RUNNING_FRAMES[Math.abs(seed + clock) % RUNNING_FRAMES.length];
+}
+function animatedSeed(seed, frame) {
+  if (frame === undefined)
+    return seed;
+  return (seed ?? 0) + frame;
 }
 function progressRunningSeed(progress) {
   if (!progress)
@@ -138,16 +196,487 @@ function getToolCallLines(result, expanded) {
   }
   return result.toolCalls?.map((toolCall) => expanded ? toolCall.expandedText : toolCall.text) ?? [];
 }
+const ansiEscapePattern = /\x1b\[[0-9;]*m/g;
+const noisyStatusPatterns = [
+  /^(?:i|we)\s+(?:will|need|can|should|am|are)\b/i,
+  /^i(?:'m|’m| am)\b/i,
+  /\bso i (?:will|need|can)\b/i,
+  /^(?:checking|fetching|reading|inspecting|verifying|collecting|confirming|polling)\b/i,
+  /^(?:async\s+subagent\s+)?[\w.-]+\s*·\s*(?:step|agent)\s+\d+\/\d+\s*·/i,
+  /^(?:Step|Agent)\s+\d+\/\d+:\s+[\w.-]+\s*·\s*(?:running|queued|pending|complete|completed)\b/i,
+  /^(?:async\s+subagent\s+)?[\w.-]+(?:\s+\[(?:fresh|fork|mixed)\])?\s*·\s*(?:running|queued|pending|complete|completed|done)\b/i,
+  /^Press\s+\S+\s+for\s+live\s+detail$/i,
+  /^output:\s+.+\/async-subagent-runs\//i
+];
+const liveOutputWordSignalPattern = /\b(?:access denied|denied|error|exception|fail(?:ed|ure)?|fatal|panic|rejected|timeout|timed out|unable|warning)\b/i;
+const liveOutputCodeSignalPattern = /\bE[A-Z0-9_]{2,}\b/;
+function oneLine(text) {
+  return text.replace(ansiEscapePattern, "").replace(/\s+/g, " ").trim();
+}
+const COMPACT_TASK_MAX_CHARS = 96;
+function childDisplayName(result, fallback = "subagent") {
+  return result?.sessionName?.trim() || result?.agent || fallback;
+}
+export function compactTaskText(task, label) {
+  const taskText = task?.trim();
+  const labelText = label?.trim();
+  const normalizedTask = taskText && taskText !== PROMPT_REDACTED ? oneLine(taskText) : "";
+  const normalizedLabel = labelText && labelText !== PROMPT_REDACTED ? oneLine(labelText) : "";
+  const normalized = normalizedLabel && normalizedTask && normalizedLabel !== normalizedTask ? `${normalizedLabel} — ${normalizedTask}` : normalizedLabel || normalizedTask;
+  if (!normalized)
+    return;
+  return previewDisplayText(normalized, COMPACT_TASK_MAX_CHARS);
+}
+const LANE_VALUE_MAX_CHARS = 48;
+function boundedLaneValue(value, maxChars = LANE_VALUE_MAX_CHARS) {
+  if (!value?.trim() || value.trim() === PROMPT_REDACTED)
+    return;
+  return previewDisplayText(oneLine(value), maxChars);
+}
+function workflowNodeStepStatus(status) {
+  switch (status) {
+    case "completed":
+      return "completed";
+    case "detached":
+      return "paused";
+    default:
+      return status;
+  }
+}
+function workflowNodeStatusLabel(status) {
+  switch (status) {
+    case "completed":
+      return "complete";
+    case "detached":
+      return "paused";
+    default:
+      return status;
+  }
+}
+function workflowStepPriority(step, currentNodeId) {
+  const isCurrent = step.workflowKey === 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)
+    return 1;
+  if (step.status === "pending")
+    return 2;
+  return 3;
+}
+function workflowWidgetSteps(job, planned = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph) : []) {
+  const loaded = job.steps ?? [];
+  if (planned.length === 0)
+    return loaded;
+  const loadedIndexesByKey = new Map;
+  for (const [index, step] of loaded.entries()) {
+    if (!step.workflowKey)
+      continue;
+    const indexes = loadedIndexesByKey.get(step.workflowKey) ?? [];
+    indexes.push(index);
+    loadedIndexesByKey.set(step.workflowKey, indexes);
+  }
+  const consumed = new Set;
+  const entries = [];
+  for (const [order, node] of planned.entries()) {
+    const loadedIndex = loadedIndexesByKey.get(node.id)?.find((index) => !consumed.has(index));
+    if (loadedIndex !== undefined) {
+      consumed.add(loadedIndex);
+      const loadedStep = loaded[loadedIndex];
+      entries.push({
+        step: {
+          ...loadedStep,
+          index: node.flatIndex ?? loadedStep.index ?? order,
+          agent: loadedStep.agent || node.agent || job.agents?.[0] || "workflow",
+          phase: loadedStep.phase ?? node.phase,
+          label: loadedStep.label ?? node.label,
+          workflowKey: loadedStep.workflowKey ?? node.id,
+          ...loadedStep.outputName === undefined && node.outputName !== undefined ? { outputName: node.outputName } : {},
+          ...loadedStep.structured === undefined && node.structured !== undefined ? { structured: node.structured } : {},
+          ...loadedStep.error === undefined && node.error !== undefined ? { error: node.error } : {}
+        },
+        order
+      });
+      continue;
+    }
+    entries.push({
+      step: {
+        index: node.flatIndex ?? order,
+        agent: node.agent ?? job.agents?.[0] ?? "workflow",
+        status: workflowNodeStepStatus(node.status),
+        workflowKey: node.id,
+        label: node.label,
+        ...node.phase ? { phase: node.phase } : {},
+        ...node.outputName ? { outputName: node.outputName } : {},
+        ...node.structured !== undefined ? { structured: node.structured } : {},
+        ...node.error ? { error: node.error } : {}
+      },
+      order
+    });
+  }
+  for (const [index, step] of loaded.entries()) {
+    if (!consumed.has(index))
+      entries.push({ step, order: planned.length + index });
+  }
+  entries.sort((left, right) => workflowStepPriority(left.step, job.workflowGraph?.currentNodeId) - workflowStepPriority(right.step, job.workflowGraph?.currentNodeId) || left.order - right.order);
+  return entries.map(({ step }) => step);
+}
+function workflowStageProgress(job, stages = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph) : []) {
+  if (job.mode !== "workflow")
+    return;
+  if (stages.length === 0)
+    return;
+  const currentId = job.workflowGraph?.currentNodeId;
+  const currentIndex = currentId ? stages.findIndex((stage) => stage.id === currentId) : -1;
+  if (currentIndex >= 0 && stages[currentIndex]?.status !== "completed")
+    return { total: stages.length, current: currentIndex };
+  const runningIndex = stages.findIndex((stage) => stage.status === "running");
+  if (runningIndex >= 0)
+    return { total: stages.length, current: runningIndex };
+  const indexedStage = job.currentStep !== undefined && job.currentStep >= 0 ? stages[job.currentStep] : undefined;
+  if (indexedStage && indexedStage.status !== "completed")
+    return { total: stages.length, current: job.currentStep };
+  if (stages.every((stage) => stage.status === "completed"))
+    return { total: stages.length, current: stages.length - 1 };
+  return { total: stages.length };
+}
+function buildWorkflowWidgetProjection(job) {
+  const stages = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph) : [];
+  const stageProgress = workflowStageProgress(job, stages);
+  const steps = workflowWidgetSteps(job, stages);
+  const projection = { stages, steps };
+  if (stageProgress)
+    projection.stageProgress = stageProgress;
+  if (stages.length)
+    projection.plannedKeys = new Set(stages.map((node) => node.id));
+  return projection;
+}
+function workflowWidgetProjectionLookup() {
+  const projections = new WeakMap;
+  return (job) => {
+    const cached = projections.get(job);
+    if (cached)
+      return cached;
+    const projection = buildWorkflowWidgetProjection(job);
+    projections.set(job, projection);
+    return projection;
+  };
+}
+function laneStepForJob(job, steps = workflowWidgetSteps(job)) {
+  if (steps.length === 0)
+    return;
+  const graphCurrent = job.workflowGraph?.currentNodeId;
+  if (graphCurrent) {
+    const current = steps.find((step) => step.workflowKey === graphCurrent);
+    if (current)
+      return current;
+  }
+  if (job.currentStep !== undefined) {
+    const current = steps[job.currentStep];
+    if (current && (current.index === undefined || current.index === job.currentStep))
+      return current;
+    const indexedCurrent = steps.find((step) => step.index === job.currentStep);
+    if (indexedCurrent)
+      return indexedCurrent;
+    return steps[0];
+  }
+  return steps.find((step) => step.status === "running") ?? steps.find((step) => step.status === "pending") ?? steps.at(-1);
+}
+function laneTraceForJob(job) {
+  return Array.isArray(job.workflow?.trace) ? job.workflow.trace.at(-1) : undefined;
+}
+function laneGate(step) {
+  const review = step?.review?.status ?? step?.acceptance?.reviewResult?.status;
+  if (review === "blockers")
+    return "review blockers";
+  if (review === "review-required")
+    return "review required";
+  if (review === "reviewed")
+    return "reviewed";
+  const acceptance = step?.acceptance?.status;
+  if (acceptance === "review-required")
+    return "acceptance review";
+  if (acceptance === "checked" || acceptance === "verified" || acceptance === "accepted")
+    return "acceptance";
+  return;
+}
+function laneNextAction(state, step, output, gate) {
+  if (step?.watchdog?.phase === "stale")
+    return "inspect stale state";
+  if (step?.toolBudgetBlocked === true || step?.turnBudgetExceeded === true)
+    return "inspect blocked state";
+  if (gate === "review blockers")
+    return "resolve review blockers";
+  if (gate === "review required" || gate === "acceptance review")
+    return "review output";
+  if (step?.activityState === "needs_attention")
+    return "inspect attention";
+  if (state === "queued" || state === "pending")
+    return "await launch";
+  if (state === "failed" || state === "rejected")
+    return "inspect failure";
+  if (state === "partial")
+    return "inspect partial state";
+  if (state === "paused")
+    return "inspect paused state";
+  if (state === "stopped")
+    return "inspect stopped state";
+  if ((state === "complete" || state === "completed") && gate === "reviewed")
+    return "ready";
+  if ((state === "complete" || state === "completed") && output)
+    return "inspect output";
+  return;
+}
+function isTerminalLaneState(state) {
+  return state !== "queued" && state !== "running";
+}
+export function projectAsyncLane(job, ...args) {
+  const selectedStep = args.length === 0 ? laneStepForJob(job) : args[0];
+  const trace = laneTraceForJob(job);
+  const workspace = job.cwd ? boundedLaneValue(shortenPath(job.cwd)) : undefined;
+  const label = compactTaskText(selectedStep?.description, selectedStep?.label) ?? boundedLaneValue(trace?.label) ?? (workspace ? undefined : boundedLaneValue(selectedStep?.workflowKey ?? job.workflowKey));
+  const role = boundedLaneValue(selectedStep?.agent ?? trace?.agent ?? job.agents?.[0] ?? widgetJobName(job), 32) ?? "subagent";
+  const phase = boundedLaneValue(selectedStep?.phase ?? trace?.phase);
+  const gate = laneGate(selectedStep);
+  const output = boundedLaneValue(selectedStep?.outputName);
+  const ref = boundedLaneValue(selectedStep?.workflowKey ?? job.workflowKey ?? job.asyncId.slice(0, 8), 24) ?? job.asyncId.slice(0, 8);
+  const chips = [
+    selectedStep?.context,
+    selectedStep?.structured ? "structured" : undefined,
+    selectedStep?.activityState === "active_long_running" ? "long-running" : undefined,
+    selectedStep?.activityState === "needs_attention" ? "attention" : undefined,
+    selectedStep?.watchdog?.phase === "stale" ? "stale" : undefined,
+    selectedStep?.toolBudgetBlocked === true || selectedStep?.turnBudgetExceeded === true ? "blocked" : undefined
+  ].filter((chip) => Boolean(chip));
+  const state = isTerminalLaneState(job.status) ? job.status : selectedStep?.status ?? job.status;
+  const next = laneNextAction(state, selectedStep, output, gate);
+  if (!label && !phase && !gate && !output && !selectedStep?.workflowKey && !job.workflowKey && !trace?.label && !trace?.phase)
+    return;
+  return { ...label ? { label } : {}, role, ...phase ? { phase } : {}, state, ...gate ? { gate } : {}, ...next ? { next } : {}, ...output ? { output } : {}, ...workspace ? { workspace } : {}, ref, chips };
+}
+function laneStateLabel(state, theme) {
+  if (state === "running")
+    return theme.fg("accent", "running");
+  if (state === "queued" || state === "pending")
+    return theme.fg("muted", state);
+  if (state === "complete" || state === "completed")
+    return theme.fg("success", "complete");
+  if (state === "failed" || state === "rejected")
+    return theme.fg("error", state === "rejected" ? "rejected" : "failed");
+  return theme.fg("warning", state);
+}
+function formatLaneProjection(lane, theme) {
+  const label = boundedLaneValue(lane.label, 56);
+  const identity = [label, lane.role ? `role:${lane.role}` : undefined].filter(Boolean).join(" · ");
+  return `${identity ? theme.bold(identity) : theme.bold(lane.role)} · ${laneStateLabel(lane.state, theme)}`;
+}
+function formatLaneChip(chip, theme) {
+  const text = `[${chip}]`;
+  if (chip === "blocked")
+    return theme.fg("error", text);
+  if (chip === "stale")
+    return theme.fg("warning", text);
+  return text;
+}
+function formatLaneProjectionDetails(lane, theme) {
+  const details = [
+    lane.phase ? `phase:${lane.phase}` : undefined,
+    lane.gate ? `gate:${lane.gate}` : undefined,
+    lane.next ? `next:${lane.next}` : undefined,
+    lane.output ? `out:${lane.output}` : undefined,
+    lane.workspace ? `workspace:${lane.workspace}` : lane.ref ? `ref:${lane.ref}` : undefined
+  ].filter(Boolean);
+  const chips = lane.chips.map((chip) => formatLaneChip(chip, theme));
+  return [...details.length ? [theme.fg("dim", details.join(" · "))] : [], ...chips].join(" · ") || undefined;
+}
+function formatLaneProjectionLines(lane, theme, indent) {
+  const details = formatLaneProjectionDetails(lane, theme);
+  return [
+    `${indent}${formatLaneProjection(lane, theme)}`,
+    ...details ? [`${indent}  ${details}`] : []
+  ];
+}
+function laneRenderKey(job, projection) {
+  const selectedStep = projection ? laneStepForJob(job, projection.steps) : laneStepForJob(job);
+  const lane = projectAsyncLane(job, selectedStep);
+  return lane ? [lane.label, lane.role, lane.phase, lane.state, lane.gate, lane.next, lane.output, lane.workspace, lane.ref, lane.chips] : undefined;
+}
+function widgetLaneDetailLines(job, theme, projection) {
+  if (job.steps?.length && (job.mode === "parallel" || job.mode === "chain"))
+    return [];
+  const selectedStep = projection ? laneStepForJob(job, projection.steps) : laneStepForJob(job);
+  const lane = projectAsyncLane(job, selectedStep);
+  return lane ? formatLaneProjectionLines(lane, theme, "  ") : [];
+}
+function workflowPreflightLines(job, expanded = false) {
+  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(`
+`),
+    ...job.workflow?.preflightWarnings ? formatWorkflowPreflightWarnings(job.workflow.preflightWarnings, { indent: "  " }).split(`
+`) : []
+  ];
+}
+function workflowLabelForResult(details, resultIndex) {
+  const flatIndex = foregroundResultIndex(details, resultIndex);
+  const visit = (nodes) => {
+    for (const node of nodes) {
+      if (node.flatIndex === flatIndex && node.label.trim())
+        return node.label;
+      const nested = node.children ? visit(node.children) : undefined;
+      if (nested)
+        return nested;
+    }
+    return;
+  };
+  return details.workflowGraph ? visit(details.workflowGraph.nodes) : undefined;
+}
+function foregroundProgressForResult(details, resultIndex) {
+  const result = details.results[resultIndex];
+  if (result?.progress)
+    return result.progress;
+  const index = result?.index ?? resultIndex;
+  const indexed = details.progress?.find((progress) => progress.index === index);
+  if (indexed)
+    return indexed;
+  return result?.agent ? details.progress?.find((progress) => progress.agent === result.agent && progress.status === "running") : undefined;
+}
+function foregroundResultIndex(details, resultIndex) {
+  const result = details.results[resultIndex];
+  if (typeof result?.index === "number")
+    return result.index;
+  return foregroundProgressForResult(details, resultIndex)?.index ?? resultIndex;
+}
+function foregroundResultDisplayName(details, resultIndex, result, fallback) {
+  const progress = foregroundProgressForResult(details, resultIndex);
+  const agent = normalizedParallelDisplayText(result?.agent) ?? normalizedParallelDisplayText(progress?.agent);
+  const workflowLabel = normalizedParallelDisplayText(workflowLabelForResult(details, resultIndex));
+  if (workflowLabel)
+    return compactTaskText(undefined, workflowLabel) ?? workflowLabel;
+  const sessionName = normalizedParallelDisplayText(result?.sessionName) ?? normalizedParallelDisplayText(progress?.sessionName);
+  if (sessionName) {
+    const sessionTask = stripRepeatedAgentPrefix(sessionName, agent);
+    if (sessionTask && sessionTask !== PROMPT_REDACTED && sessionTask.toLowerCase() !== agent?.toLowerCase()) {
+      return compactTaskText(sessionTask) ?? sessionTask;
+    }
+  }
+  return compactTaskText(result?.task) ?? compactTaskText(progress?.task) ?? agent ?? fallback;
+}
+function foregroundSingleDisplayName(result) {
+  return normalizedParallelDisplayText(result?.agent) ?? normalizedParallelDisplayText(result?.sessionName) ?? compactTaskText(result?.task) ?? "subagent";
+}
+function hasLiveOutputSignal(line) {
+  const clean = oneLine(line);
+  return liveOutputWordSignalPattern.test(clean) || liveOutputCodeSignalPattern.test(clean);
+}
+function isNoisyStatusLine(line) {
+  const clean = oneLine(line);
+  return clean.length > 0 && clean.length <= 240 && !hasLiveOutputSignal(clean) && noisyStatusPatterns.some((pattern) => pattern.test(clean));
+}
+function latestActivityText(line) {
+  return oneLine(line).replace(/^i (?:will|can|need to|am going to)\s+/i, "").replace(/^i(?:'m|’m| am)\s+/i, "");
+}
+function progressUpdateSummary(lines) {
+  const counts = new Map;
+  for (const line of lines)
+    counts.set(line.toLowerCase(), (counts.get(line.toLowerCase()) ?? 0) + 1);
+  const exactRepeatCount = Math.max(...counts.values());
+  const latest = latestActivityText(lines[lines.length - 1]);
+  const repeat = exactRepeatCount > 1 ? ` · repeated ${exactRepeatCount}×` : "";
+  return `↻ ${lines.length} progress updates${repeat} · latest: ${latest}`;
+}
+function compactRecentOutputLines(recentOutput) {
+  const lines = [];
+  const noisyLines = [];
+  const otherLines = [];
+  for (const rawLine of recentOutput ?? []) {
+    const line = oneLine(rawLine);
+    if (!line || line === "(running...)")
+      continue;
+    lines.push(line);
+    (isNoisyStatusLine(line) ? noisyLines : otherLines).push(line);
+  }
+  if (noisyLines.length >= 4 && !otherLines.some(hasLiveOutputSignal)) {
+    if (otherLines.length === 0) {
+      return [
+        progressUpdateSummary(noisyLines),
+        "pattern: repeated short status lines"
+      ];
+    }
+    const visibleTail = otherLines.slice(-3);
+    const hiddenSignals = otherLines.slice(0, -3).filter(hasLiveOutputSignal);
+    return [
+      progressUpdateSummary(noisyLines),
+      ...hiddenSignals.length > 0 ? [`… ${hiddenSignals.length} older signal ${hiddenSignals.length === 1 ? "line" : "lines"}: ${hiddenSignals.at(-1)}`] : [],
+      ...visibleTail
+    ].slice(0, 5);
+  }
+  if (lines.length <= 5)
+    return lines;
+  const tail = lines.slice(-5);
+  const hiddenSignals = lines.slice(0, -5).filter(hasLiveOutputSignal);
+  if (hiddenSignals.length === 0)
+    return tail;
+  return [
+    `… ${hiddenSignals.length} older signal ${hiddenSignals.length === 1 ? "line" : "lines"}: ${hiddenSignals.at(-1)}`,
+    ...lines.slice(-4)
+  ];
+}
+function compactWorkflowError(error) {
+  const outputMatch = error.match(/(?:^|\n)Output:\s*([\s\S]+)/);
+  if (!outputMatch)
+    return oneLine(error);
+  const prefix = oneLine(error.slice(0, outputMatch.index)).replace(/:$/, "") || "Failed";
+  const outputLines = outputMatch[1].split(/\r?\n/).map(oneLine).filter(Boolean);
+  const allOutputLinesAreNoisy = outputLines.length > 0 && outputLines.every(isNoisyStatusLine);
+  const latest = outputLines.at(-1);
+  return allOutputLinesAreNoisy && latest ? `${prefix} · latest: ${latestActivityText(latest)}` : `${prefix} · ${oneLine(outputMatch[1] ?? "")}`;
+}
+const WORKFLOW_LIVE_ROW_LIMIT = 8;
+function visibleWorkflowRows(rows) {
+  if (rows.length <= WORKFLOW_LIVE_ROW_LIMIT)
+    return { rows, hiddenRows: 0 };
+  const selected = new Set;
+  const add = (row) => {
+    if (selected.size >= WORKFLOW_LIVE_ROW_LIMIT || selected.has(row.key))
+      return;
+    selected.add(row.key);
+  };
+  for (const row of [...rows].reverse()) {
+    if (row.state === "failed" || row.state === "detached")
+      add(row);
+  }
+  for (const row of [...rows].reverse())
+    add(row);
+  return {
+    rows: rows.filter((row) => selected.has(row.key)),
+    hiddenRows: rows.length - selected.size
+  };
+}
 function snapshotNowForProgress(progress) {
   if (progress.currentToolStartedAt !== undefined && progress.durationMs !== undefined)
     return progress.currentToolStartedAt + progress.durationMs;
   return progress.lastActivityAt;
 }
+function renderToolArgsPreview(value, maxLength, expanded) {
+  const normalized = sanitizeDisplayText(value);
+  if (expanded || normalized.length <= maxLength)
+    return normalized;
+  return `${truncateDisplayText(normalized, maxLength)}...`;
+}
 function formatCurrentToolLine(progress, availableWidth, expanded, snapshotNow) {
   if (!progress.currentTool)
     return;
   const maxToolArgsLen = Math.max(50, availableWidth - 20);
-  const toolArgsPreview = progress.currentToolArgs ? expanded || progress.currentToolArgs.length <= maxToolArgsLen ? progress.currentToolArgs : `${progress.currentToolArgs.slice(0, maxToolArgsLen)}...` : "";
+  const toolArgsPreview = progress.currentToolArgs ? renderToolArgsPreview(progress.currentToolArgs, maxToolArgsLen, expanded) : "";
   const durationSuffix = progress.currentToolStartedAt !== undefined && snapshotNow !== undefined ? ` | ${formatDuration(Math.max(0, snapshotNow - progress.currentToolStartedAt))}` : "";
   return toolArgsPreview ? `${progress.currentTool}: ${toolArgsPreview}${durationSuffix}` : `${progress.currentTool}${durationSuffix}`;
 }
@@ -205,6 +734,8 @@ function firstOutputLine(text) {
 function resultStatusLine(result, output) {
   if (result.detached)
     return result.detachedReason ? `Detached: ${result.detachedReason}` : "Detached";
+  if (result.stopped)
+    return "Stopped";
   if (result.interrupted)
     return "Paused";
   if (result.exitCode !== 0)
@@ -215,27 +746,171 @@ function resultStatusLine(result, output) {
     return "Done (no text output)";
   return "Done";
 }
-function resultGlyph(result, output, theme, running = result.progress?.status === "running", seed = progressRunningSeed(result.progress ?? result.progressSummary), frame) {
-  if (running) {
-    if (frame !== undefined)
-      return theme.fg("accent", runningGlyph((seed ?? 0) + frame));
-    return theme.fg("accent", runningGlyph(seed));
+function semanticResultPresentation(input) {
+  if (input.running) {
+    const glyph = input.frame !== undefined ? runningGlyph((input.seed ?? 0) + input.frame) : runningGlyph(input.seed);
+    return { glyph, label: "running", tone: "accent" };
   }
-  if (result.detached)
-    return theme.fg("warning", "■");
-  if (result.interrupted)
-    return theme.fg("warning", "■");
-  if (result.exitCode !== 0)
-    return theme.fg("error", "✗");
-  if (hasEmptyTextOutputWithoutOutputTarget(result.task, output))
-    return theme.fg("warning", "✓");
-  return theme.fg("success", "✓");
+  if (input.detached)
+    return { glyph: "■", label: "detached", tone: "warning" };
+  if (input.stopped)
+    return { glyph: "■", label: "stopped", tone: "warning" };
+  if (input.interrupted)
+    return { glyph: "■", label: "paused", tone: "warning" };
+  if (input.failed)
+    return { glyph: "✗", label: "failed", tone: "error" };
+  if (input.partial)
+    return { glyph: "■", label: "partial", tone: "warning" };
+  return { glyph: "✓", label: "completed", tone: input.completedWithoutOutput ? "warning" : "success" };
+}
+function hasTerminalResultFlag(result) {
+  return Boolean(result.detached || result.stopped || result.interrupted);
+}
+function hasTerminalResult(result) {
+  if (hasTerminalResultFlag(result))
+    return true;
+  const status = result.progress?.status;
+  if (status === "running" || status === "pending")
+    return false;
+  return result.exitCode !== undefined;
+}
+function isResultRunning(result, status = result.progress?.status) {
+  return status === "running" && !hasTerminalResultFlag(result);
+}
+function detailsHaveRunningResult(details) {
+  return details.progress?.some((progress) => {
+    if (progress.status !== "running")
+      return false;
+    const result = details.results.find((entry) => entry.progress?.index === progress.index) ?? details.results[progress.index];
+    return !result || !hasTerminalResultFlag(result);
+  }) || details.results.some((result) => isResultRunning(result)) || workflowGraphHasStatus(details, ["running"]);
+}
+function resultPresentation(result, output, running = isResultRunning(result), seed = progressRunningSeed(result.progress ?? result.progressSummary), frame) {
+  return semanticResultPresentation({
+    running,
+    detached: result.detached,
+    stopped: result.stopped,
+    interrupted: result.interrupted,
+    failed: result.exitCode !== 0,
+    completedWithoutOutput: hasEmptyTextOutputWithoutOutputTarget(result.task, output),
+    seed,
+    frame
+  });
+}
+function resultGlyph(result, output, theme, running = isResultRunning(result), seed = progressRunningSeed(result.progress ?? result.progressSummary), frame) {
+  const presentation = resultPresentation(result, output, running, seed, frame);
+  return theme.fg(presentation.tone, presentation.glyph);
+}
+function styledResultPresentation(presentation, theme) {
+  return {
+    glyph: theme.fg(presentation.tone, presentation.glyph),
+    label: theme.fg(presentation.tone, presentation.label)
+  };
 }
 function compactCurrentActivity(progress) {
   const snapshotNow = snapshotNowForProgress(progress);
   return formatCurrentToolLine(progress, getTermWidth() - 4, false, snapshotNow) ?? buildLiveStatusLine(progress, snapshotNow) ?? "thinking…";
 }
-export function widgetRenderKey(job) {
+function textDigest(text) {
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function displayTextRenderKey(text) {
+  const normalized = sanitizeDisplayText(text);
+  return [normalized.length, textDigest(normalized)];
+}
+function expandedStepActivityRenderKey(step) {
+  return [
+    step.recentTools?.slice(-3).map((tool) => [tool.tool, displayTextRenderKey(tool.args), tool.endMs]),
+    compactRecentOutputLines(step.recentOutput).map(displayTextRenderKey)
+  ];
+}
+function widgetStepRenderKey(step, index, expanded = false) {
+  return [
+    step.index ?? index,
+    step.agent,
+    step.sessionName,
+    step.workflowKey,
+    step.phase,
+    step.label,
+    step.status,
+    step.activityState,
+    step.lastActivityAt,
+    step.currentTool,
+    step.currentToolArgs,
+    step.currentToolStartedAt,
+    step.currentPath,
+    step.turnCount,
+    step.toolCount,
+    step.startedAt,
+    step.endedAt,
+    step.durationMs,
+    step.tokens?.total,
+    step.model,
+    step.thinking,
+    step.context,
+    step.description,
+    step.outputName,
+    step.structured,
+    step.acceptance?.status,
+    step.acceptance?.reviewResult?.status,
+    step.review?.status,
+    step.toolBudgetBlocked,
+    step.turnBudgetExceeded,
+    step.timedOut,
+    step.stopped,
+    step.execution?.status,
+    step.execution?.error,
+    step.execution?.timedOut,
+    step.execution?.interrupted,
+    step.execution?.stopped,
+    step.execution?.detached,
+    step.watchdog?.phase,
+    step.error,
+    expanded ? expandedStepActivityRenderKey(step) : undefined,
+    nestedRenderKey(step.children, expanded)
+  ];
+}
+function nestedRenderKey(children, expanded = false) {
+  return (children ?? []).map((child) => [
+    child.id,
+    child.state,
+    child.agent,
+    child.sessionName,
+    child.model,
+    child.thinking,
+    child.activityState,
+    child.lastActivityAt,
+    child.currentTool,
+    child.currentToolStartedAt,
+    child.currentPath,
+    child.turnCount,
+    child.toolCount,
+    child.startedAt,
+    child.endedAt,
+    child.lastUpdate,
+    child.error,
+    child.totalTokens?.total,
+    child.steps?.map((step, index) => widgetStepRenderKey({ ...step, agent: step.agent, status: step.status }, index, expanded)),
+    nestedRenderKey(child.children, expanded)
+  ]);
+}
+function hostStepRenderKey(row) {
+  return [
+    row.kind,
+    row.name,
+    row.state,
+    row.provider,
+    row.role,
+    row.verdict,
+    row.reasonCode,
+    row.detail,
+    row.target,
+    row.freshness,
+    row.reportPath
+  ];
+}
+export function widgetRenderKey(job, expanded = false) {
+  const projection = buildWorkflowWidgetProjection(job);
   return JSON.stringify({
     asyncDir: job.asyncDir,
     status: job.status,
@@ -251,14 +926,24 @@ export function widgetRenderKey(job) {
     currentStep: job.currentStep,
     chainStepCount: job.chainStepCount,
     parallelGroups: job.parallelGroups,
-    steps: job.steps,
-    nestedChildren: job.nestedChildren,
+    workflowHostSteps: projectAsyncWorkflowRows([], job.hostSteps).map(hostStepRenderKey),
+    workflowGraph: job.mode === "workflow" && job.workflowGraph ? {
+      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,
+    steps: job.steps?.map((step, index) => widgetStepRenderKey(step, index, expanded)),
+    nestedChildren: nestedRenderKey(job.nestedChildren, expanded),
+    lane: laneRenderKey(job, projection),
     stepsTotal: job.stepsTotal,
     runningSteps: job.runningSteps,
     completedSteps: job.completedSteps,
     activeParallelGroup: job.activeParallelGroup,
     startedAt: job.startedAt,
     updatedAt: job.updatedAt,
+    timedOut: job.timedOut,
+    stopped: job.stopped,
     totalTokens: job.totalTokens
   });
 }
@@ -281,6 +966,38 @@ function widgetJobName(job) {
     return formatWidgetAgents(job.agents);
   return job.mode ?? "subagent";
 }
+function isSingleChildAsyncJob(job) {
+  return job.mode === "single" && job.steps?.length === 1 && shouldSuppressSingleStep(job.chainStepCount, job.stepsTotal);
+}
+function isCompletedWidgetStepStatus(status) {
+  return status === "complete" || status === "completed";
+}
+function singleChildAgentName(job, step) {
+  return job.agents?.length === 1 ? job.agents[0] : step.agent || widgetJobName(job);
+}
+function hasSingleChildDetailEvidence(job, step) {
+  return Boolean(step.error?.trim() || step.execution?.error?.trim() || step.phase?.trim() || step.label?.trim() || step.workflowKey?.trim() || step.outputName?.trim() || step.lane || job.workflowKey?.trim() || job.lane || laneTraceForJob(job)?.phase?.trim() || laneTraceForJob(job)?.label?.trim() || step.timedOut || step.stopped || step.execution?.timedOut || step.execution?.interrupted || step.execution?.stopped || step.execution?.detached || job.timedOut || job.stopped || ["failed", "partial", "paused", "stopped", "detached"].includes(step.execution?.status ?? "") || step.acceptance?.status === "rejected" || step.acceptance?.reviewResult?.status === "blockers" || step.review?.status === "blockers");
+}
+function shouldCollapseSingleChildDetails(job, step) {
+  if (!isSingleChildAsyncJob(job) || hasSingleChildDetailEvidence(job, step))
+    return false;
+  if (job.status === "running")
+    return step.status === "running";
+  if (job.status === "complete")
+    return isCompletedWidgetStepStatus(step.status);
+  return false;
+}
+function singleChildTask(job, step) {
+  const task = compactTaskText(step.description, step.label);
+  if (task)
+    return task;
+  const sessionName = step.sessionName?.trim();
+  if (!sessionName)
+    return;
+  const agentName = singleChildAgentName(job, step);
+  const sessionTask = stripRepeatedAgentPrefix(sessionName, agentName);
+  return sessionTask === agentName ? undefined : compactTaskText(sessionTask);
+}
 function widgetActivity(job) {
   const facts = [];
   if (job.currentTool && job.currentToolStartedAt !== undefined && job.updatedAt !== undefined)
@@ -306,6 +1023,10 @@ function widgetActivity(job) {
     return "queued…";
   if (job.status === "paused")
     return "Paused";
+  if (job.status === "stopped")
+    return "Stopped";
+  if (job.status === "partial")
+    return "Partial";
   if (job.status === "failed")
     return "Failed";
   return "Done";
@@ -328,26 +1049,30 @@ function widgetJobsRunningSeed(jobs) {
     seed = runningSeed(seed, widgetJobRunningSeed(job));
   return seed;
 }
-function widgetStatusGlyph(job, theme) {
+function widgetStatusGlyph(job, theme, frame) {
   if (job.status === "running")
-    return theme.fg("accent", runningGlyph(widgetJobRunningSeed(job)));
+    return theme.fg("accent", runningGlyph(animatedSeed(widgetJobRunningSeed(job), frame)));
   if (job.status === "queued")
     return theme.fg("muted", "◦");
   if (job.status === "complete")
     return theme.fg("success", "✓");
   if (job.status === "paused")
     return theme.fg("warning", "■");
+  if (job.status === "stopped")
+    return theme.fg("warning", "■");
   return theme.fg("error", "✗");
 }
-function widgetStepGlyph(status, theme, seed) {
+function widgetStepGlyph(status, theme, seed, frame) {
   if (status === "running")
-    return theme.fg("accent", runningGlyph(seed));
+    return theme.fg("accent", runningGlyph(animatedSeed(seed, frame)));
   if (status === "complete" || status === "completed")
     return theme.fg("success", "✓");
   if (status === "failed")
     return theme.fg("error", "✗");
   if (status === "paused")
     return theme.fg("warning", "■");
+  if (status === "stopped")
+    return theme.fg("warning", "■");
   return theme.fg("muted", "◦");
 }
 function widgetStepStatus(status, theme) {
@@ -359,6 +1084,8 @@ function widgetStepStatus(status, theme) {
     return theme.fg("error", "failed");
   if (status === "paused")
     return theme.fg("warning", "paused");
+  if (status === "stopped")
+    return theme.fg("warning", "stopped");
   return theme.fg("dim", status);
 }
 function widgetStepActivity(step, snapshotNow) {
@@ -374,7 +1101,7 @@ function widgetStepActivity(step, snapshotNow) {
   if (step.toolCount !== undefined)
     facts.push(`${step.toolCount} tools`);
   if (step.tokens?.total)
-    facts.push(formatTokenStat(step.tokens.total));
+    facts.push(formatTokenUsage(step.tokens, "token"));
   const activity = buildLiveStatusLine(step, snapshotNow);
   if (activity && facts.length)
     return `${activity} · ${facts.join(" · ")}`;
@@ -382,7 +1109,7 @@ function widgetStepActivity(step, snapshotNow) {
     return activity;
   return facts.join(" · ");
 }
-function widgetChainDetails(job, theme, expanded = false, width = getTermWidth()) {
+function widgetChainDetails(job, theme, expanded = false, width = getTermWidth(), frame) {
   if (!job.steps?.length)
     return [];
   const total = job.chainStepCount ?? job.steps.length;
@@ -390,8 +1117,7 @@ function widgetChainDetails(job, theme, expanded = false, width = getTermWidth()
   for (const span of buildAsyncChainStepSpans(total, job.steps.length, job.parallelGroups)) {
     const steps = job.steps.slice(span.start, span.start + span.count);
     if (span.isParallel) {
-      const status = aggregateStepStatus(steps);
-      lines.push(`  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(steps))} Step ${span.stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(steps, span.count))}`);
+      lines.push(...parallelWidgetGroupDetails(job, theme, { steps, total: span.count, stepIndex: span.stepIndex, chainTotal: total }, expanded, width, frame, false));
       continue;
     }
     const step = steps[0];
@@ -399,17 +1125,20 @@ function widgetChainDetails(job, theme, expanded = false, width = getTermWidth()
       lines.push(`  ${theme.fg("dim", `◦ Step ${span.stepIndex + 1}/${total}: pending`)}`);
       continue;
     }
-    lines.push(...foregroundStyleWidgetStepLines(job, theme, step, "Step", span.stepIndex + 1, total, expanded, width));
+    lines.push(...foregroundStyleWidgetStepLines(job, theme, step, "Step", span.stepIndex + 1, total, expanded, width, frame));
   }
   return lines;
 }
-function widgetParallelAgentDetails(job, theme, expanded = false, width = getTermWidth()) {
+function widgetParallelAgentDetails(job, theme, expanded = false, width = getTermWidth(), frame) {
   if (!job.steps?.length)
     return [];
   if (job.mode !== "parallel" && job.mode !== "chain")
     return [];
   if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length)
-    return widgetChainDetails(job, theme, expanded, width);
+    return widgetChainDetails(job, theme, expanded, width, frame);
+  const group = activeParallelWidgetGroup(job);
+  if (group)
+    return parallelWidgetGroupDetails(job, theme, group, expanded, width, frame, Boolean(job.activeParallelGroup));
   const total = job.stepsTotal ?? job.steps.length;
   const lines = [];
   for (const [index, step] of job.steps.entries()) {
@@ -417,8 +1146,13 @@ function widgetParallelAgentDetails(job, theme, expanded = false, width = getTer
     const activity = widgetStepActivity(step, job.updatedAt);
     const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
     const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking);
-    lines.push(`  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index))} ${itemTitle} ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${modelDisplay}${activity ? ` · ${activity}` : ""}`)}`);
-    for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, expanded ? 8 : 1))
+    const label = compactTaskText(step.description, step.label);
+    const display = step.sessionName?.trim() || (label ? `${label} (${step.agent})` : step.agent);
+    lines.push(`  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index), frame)} ${itemTitle} ${index + 1}/${total}: ${display} · ${widgetStepStatus(step.status, theme)}${modelDisplay}${activity ? ` · ${activity}` : ""}`)}`);
+    const lane = projectAsyncLane(job, step);
+    if (lane)
+      lines.push(...formatLaneProjectionLines(lane, theme, "    "));
+    for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, expanded ? 8 : 6))
       lines.push(`    ${nestedLine}`);
   }
   return lines;
@@ -466,18 +1200,16 @@ function buildChainStepSpans(details) {
   }
   return spans;
 }
-function isChainParallelGroupActive(details) {
-  if (details.mode !== "chain")
-    return false;
-  if (details.currentStepIndex === undefined)
-    return false;
-  return buildChainStepSpans(details).some((span) => span.stepIndex === details.currentStepIndex && span.isParallel);
-}
 function buildAsyncChainStepSpans(total, stepCount, parallelGroups = []) {
+  const groupsByStep = new Map;
+  for (const group of parallelGroups) {
+    if (!groupsByStep.has(group.stepIndex))
+      groupsByStep.set(group.stepIndex, group);
+  }
   const spans = [];
   let flatIndex = 0;
   for (let stepIndex = 0;stepIndex < total; stepIndex++) {
-    const group = parallelGroups.find((candidate) => candidate.stepIndex === stepIndex);
+    const group = groupsByStep.get(stepIndex);
     if (group) {
       spans.push({ stepIndex, start: group.start, count: group.count, isParallel: true });
       flatIndex = Math.max(flatIndex, group.start + group.count);
@@ -488,6 +1220,93 @@ function buildAsyncChainStepSpans(total, stepCount, parallelGroups = []) {
   }
   return spans;
 }
+function normalizedParallelDisplayText(value) {
+  if (!value?.trim())
+    return;
+  const normalized = oneLine(value);
+  return normalized && normalized !== PROMPT_REDACTED ? normalized : undefined;
+}
+function parallelWidgetStepDisplayName(step) {
+  const agent = normalizedParallelDisplayText(step.agent);
+  const explicitLabel = normalizedParallelDisplayText(step.label);
+  if (explicitLabel) {
+    const label = compactTaskText(step.description, explicitLabel) ?? explicitLabel;
+    return agent ? `${label} (${agent})` : label;
+  }
+  const sessionName = normalizedParallelDisplayText(step.sessionName);
+  if (sessionName) {
+    const sessionTask = stripRepeatedAgentPrefix(sessionName, agent);
+    if (sessionTask && sessionTask !== PROMPT_REDACTED && sessionTask.toLowerCase() !== agent?.toLowerCase())
+      return sessionTask;
+  }
+  return compactTaskText(step.description) ?? agent ?? "subagent";
+}
+function parallelWidgetStepPriority(step) {
+  if (step.status === "running" || step.activityState === "needs_attention")
+    return 0;
+  switch (step.status) {
+    case "failed":
+    case "rejected":
+    case "partial":
+    case "stopped":
+    case "paused":
+      return 1;
+    case "complete":
+    case "completed":
+      return 2;
+    default:
+      return 3;
+  }
+}
+function parallelWidgetStepRows(steps, total, prioritizeActive) {
+  const indexed = steps.map((step, index) => ({ step, index, displayName: parallelWidgetStepDisplayName(step) }));
+  if (prioritizeActive)
+    indexed.sort((left, right) => parallelWidgetStepPriority(left.step) - parallelWidgetStepPriority(right.step) || left.index - right.index);
+  return withDuplicateLabelDiscriminators(indexed, total).map(({ displayName, ...row }) => row);
+}
+function activeParallelWidgetGroup(job) {
+  const steps = job.steps ?? [];
+  if (!steps.length)
+    return;
+  if (job.mode === "parallel")
+    return { steps, total: job.stepsTotal ?? steps.length };
+  if (job.mode !== "chain" || !job.activeParallelGroup)
+    return;
+  const chainTotal = job.chainStepCount ?? job.stepsTotal ?? steps.length;
+  const spans = buildAsyncChainStepSpans(chainTotal, steps.length, job.parallelGroups);
+  const currentStep = job.currentStep;
+  const activeSpan = currentStep === undefined ? spans.find((span) => span.isParallel) : spans.find((span) => span.isParallel && currentStep >= span.start && currentStep < span.start + span.count);
+  return {
+    steps,
+    total: activeSpan?.count ?? job.stepsTotal ?? steps.length,
+    stepIndex: activeSpan?.stepIndex,
+    chainTotal
+  };
+}
+function parallelWidgetGroupHeader(group, theme, frame) {
+  const status = aggregateStepStatus(group.steps);
+  const label = group.stepIndex !== undefined && group.chainTotal !== undefined ? `Step ${group.stepIndex + 1}/${group.chainTotal}: parallel group` : "parallel group";
+  return `  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(group.steps), frame)} ${themeBold(theme, label)} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(group.steps, group.total))}`;
+}
+function parallelWidgetGroupDetails(job, theme, group, expanded, width, frame, prioritizeActive) {
+  const lines = [parallelWidgetGroupHeader(group, theme, frame)];
+  const rows = parallelWidgetStepRows(group.steps, group.total, prioritizeActive);
+  for (const [rowIndex, row] of rows.entries()) {
+    const marker = rowIndex === rows.length - 1 && rows.length >= group.total ? "└─" : "├─";
+    lines.push(...foregroundStyleWidgetStepLines(job, theme, row.step, "Agent", row.index + 1, group.total, expanded, width, frame, {
+      rowLabel: row.rowLabel,
+      rowIndent: "    ",
+      detailIndent: "      ",
+      rowMarker: marker,
+      includeCurrentPath: true
+    }));
+  }
+  for (let index = rows.length;index < group.total; index++) {
+    const marker = index === group.total - 1 ? "└─" : "├─";
+    lines.push(`    ${marker} ${theme.fg("muted", "◦")} ${theme.fg("dim", "pending")}`);
+  }
+  return lines;
+}
 function isDoneResult(result) {
   const status = result.progress?.status;
   if (status === "completed")
@@ -501,28 +1320,71 @@ function isDoneResult(result) {
 function workflowGraphHasStatus(details, statuses) {
   return details.workflowGraph?.nodes.some((node) => statuses.includes(node.status)) ?? false;
 }
+function chainSpanStatus(details, span) {
+  if (span.status)
+    return span.status;
+  const results = details.results.slice(span.start, span.start + span.count);
+  if (results.some((result) => isResultRunning(result)))
+    return "running";
+  if (results.some((result) => !hasTerminalResultFlag(result) && (result.progress?.status === "failed" || result.exitCode !== 0) && !isResultRunning(result)))
+    return "failed";
+  if (results.some((result) => result.stopped))
+    return "stopped";
+  if (results.some((result) => result.interrupted))
+    return "paused";
+  if (results.some((result) => result.detached || result.progress?.status === "detached"))
+    return "detached";
+  if (results.length < span.count)
+    return "pending";
+  if (results.length > 0 && results.every(isDoneResult))
+    return "completed";
+  return "pending";
+}
+function withDuplicateForegroundLabels(entries, total) {
+  return withDuplicateLabelDiscriminators(entries.map((entry) => ({ ...entry, index: entry.displayIndex, displayName: entry.agentName })), total).map(({ displayName, rowLabel, ...entry }) => ({
+    ...entry,
+    rowLabel: rowLabel === displayName ? undefined : rowLabel.slice(0, -(displayName.length + 2))
+  }));
+}
 function buildChainRenderEntries(details, label) {
   if (details.mode !== "chain" || !label.hasParallelInChain || label.showActiveGroupOnly)
     return;
   const entries = [];
   for (const span of buildChainStepSpans(details)) {
-    if (span.isParallel && span.count === 0) {
+    if (span.isParallel) {
       entries.push({
-        kind: "placeholder",
-        rowNumber: span.stepIndex + 1,
-        stepLabel: `Step ${span.stepIndex + 1}`,
-        agentName: span.label ?? details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`,
-        status: span.status ?? "pending",
+        kind: "group",
+        stepLabel: `Step ${span.stepIndex + 1}/${label.logicalStepCount}: parallel group`,
+        groupLabel: span.label?.trim() || undefined,
+        status: chainSpanStatus(details, span),
         error: span.error
       });
+      const groupEntries = [];
+      for (let index = span.start;index < span.start + span.count; index++) {
+        const result = details.results[index];
+        const localIndex = foregroundResultIndex(details, index);
+        const displayIndex = localIndex >= span.start && localIndex < span.start + span.count ? localIndex - span.start : index - span.start;
+        groupEntries.push({
+          kind: "result",
+          resultIndex: index,
+          rowNumber: index - span.start + 1,
+          agentName: foregroundResultDisplayName(details, index, result, `agent-${displayIndex + 1}`),
+          displayIndex,
+          isParallel: true
+        });
+      }
+      entries.push(...withDuplicateForegroundLabels(groupEntries, span.count));
       continue;
     }
     for (let index = span.start;index < span.start + span.count; index++) {
+      const result = details.results[index];
       entries.push({
         kind: "result",
         resultIndex: index,
-        rowNumber: index + 1,
-        agentName: details.results[index]?.agent ?? details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`
+        rowNumber: span.stepIndex + 1,
+        rowLabel: resultRowLabel(label, span.stepIndex + 1),
+        agentName: foregroundResultDisplayName(details, index, result, details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`),
+        displayIndex: foregroundResultIndex(details, index)
       });
     }
   }
@@ -531,7 +1393,7 @@ function buildChainRenderEntries(details, label) {
 function buildMultiProgressLabel(details, hasRunning) {
   const stepSpans = buildChainStepSpans(details);
   const hasParallelInChain = details.mode === "chain" && stepSpans.some((span) => span.isParallel);
-  const activeParallelGroup = isChainParallelGroupActive(details);
+  const activeParallelGroup = details.mode === "chain" && details.currentStepIndex !== undefined && stepSpans.some((span) => span.stepIndex === details.currentStepIndex && span.isParallel);
   const itemTitle = details.mode === "parallel" || activeParallelGroup ? "Agent" : "Step";
   if (details.mode === "parallel") {
     const totalCount = details.totalSteps ?? details.results.length;
@@ -546,13 +1408,13 @@ function buildMultiProgressLabel(details, hasRunning) {
       const index = result.progress?.index ?? progressFromArray?.index ?? i;
       if (index < 0 || index >= totalCount)
         continue;
-      const status = result.progress?.status ?? (result.interrupted || result.detached ? "detached" : result.exitCode === 0 ? "completed" : "failed");
+      const status = result.stopped ? "stopped" : result.interrupted || result.detached ? "detached" : result.progress?.status ?? (result.exitCode === 0 ? "completed" : "failed");
       statuses[index] = status;
     }
     const running = statuses.filter((status) => status === "running").length;
     const done = statuses.filter((status) => status === "completed").length;
     const headerLabel = hasRunning ? `${formatAgentRunningLabel(running)} · ${done}/${totalCount} done` : `${done}/${totalCount} done`;
-    return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: totalCount, showActiveGroupOnly: false };
+    return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: totalCount, showActiveGroupOnly: false, logicalStepCount: totalCount };
   }
   if (activeParallelGroup) {
     const currentStepIndex = details.currentStepIndex;
@@ -564,8 +1426,8 @@ function buildMultiProgressLabel(details, hasRunning) {
     let done = 0;
     for (let index = groupStart;index < groupEnd; index++) {
       const progressEntry = details.progress?.find((progress) => progress.index === index);
-      const resultEntry = details.results.find((result) => result.progress?.index === index);
-      if (progressEntry?.status === "running") {
+      const resultEntry = details.results.find((result) => result.progress?.index === index) ?? details.results[index];
+      if (progressEntry?.status === "running" && (!resultEntry || !hasTerminalResultFlag(resultEntry))) {
         running++;
         continue;
       }
@@ -578,7 +1440,7 @@ function buildMultiProgressLabel(details, hasRunning) {
     }
     const totalSteps = details.totalSteps ?? details.chainAgents?.length ?? 1;
     const headerLabel = hasRunning ? `step ${currentStepIndex + 1}/${totalSteps} · parallel group: ${formatAgentRunningLabel(running)} · ${done}/${groupSize} done` : `step ${currentStepIndex + 1}/${totalSteps} · parallel group: ${done}/${groupSize} done`;
-    return { headerLabel, itemTitle, totalCount: groupSize, hasParallelInChain, activeParallelGroup, groupStartIndex: groupStart, groupEndIndex: groupEnd, showActiveGroupOnly: true };
+    return { headerLabel, itemTitle, totalCount: groupSize, hasParallelInChain, activeParallelGroup, groupStartIndex: groupStart, groupEndIndex: groupEnd, showActiveGroupOnly: true, logicalStepCount: totalSteps };
   }
   if (details.mode === "chain" && details.chainAgents?.length) {
     const totalCount = details.totalSteps ?? details.chainAgents.length;
@@ -599,32 +1461,51 @@ function buildMultiProgressLabel(details, hasRunning) {
     }).length;
     const currentStep = details.currentStepIndex !== undefined ? details.currentStepIndex + 1 : Math.min(totalCount, doneLogical + (hasRunning ? 1 : 0));
     const headerLabel = hasRunning ? `step ${currentStep}/${totalCount}` : `step ${doneLogical}/${totalCount}`;
-    return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false };
+    return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false, logicalStepCount: totalCount };
   }
   const totalCount = details.totalSteps ?? details.results.length;
   const currentStep = details.currentStepIndex !== undefined ? details.currentStepIndex + 1 : Math.min(totalCount, details.results.filter(isDoneResult).length + (hasRunning ? 1 : 0));
   const done = details.results.filter(isDoneResult).length;
   const headerLabel = hasRunning ? `step ${currentStep}/${totalCount}` : `step ${done}/${totalCount}`;
-  return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false };
+  return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false, logicalStepCount: totalCount };
 }
-function resultRowLabel(details, label, resultIndex, stepNumber) {
-  if (details.mode === "chain" && label.hasParallelInChain) {
-    const span = buildChainStepSpans(details).find((candidate) => resultIndex >= candidate.start && resultIndex < candidate.start + candidate.count);
-    if (span?.isParallel)
-      return `Agent ${resultIndex - span.start + 1}/${span.count}`;
-    if (span)
-      return `Step ${span.stepIndex + 1}`;
-  }
-  if (label.itemTitle === "Agent") {
-    const localStepNumber = label.activeParallelGroup ? Math.max(1, stepNumber - label.groupStartIndex) : stepNumber;
-    return `Agent ${localStepNumber}/${label.totalCount}`;
-  }
-  return `Step ${stepNumber}`;
+function resultRowLabel(label, stepNumber) {
+  if (label.itemTitle === "Agent")
+    return;
+  if (shouldSuppressSingleStep(label.logicalStepCount))
+    return;
+  return `Step ${stepNumber}/${label.logicalStepCount}`;
+}
+function buildForegroundResultEntries(details, label, displayStart, displayEnd, useResultsDirectly) {
+  const fallbackLabel = label.itemTitle.toLowerCase();
+  const entries = Array.from({ length: displayEnd - displayStart }, (_, offset) => {
+    const index = displayStart + offset;
+    const result = details.results[index];
+    const stableIndex = foregroundResultIndex(details, index);
+    const rowNumber = label.showActiveGroupOnly ? index - label.groupStartIndex + 1 : stableIndex + 1;
+    const fallbackAgent = useResultsDirectly ? result?.agent || `${fallbackLabel}-${rowNumber}` : details.chainAgents[index] || result?.agent || `${fallbackLabel}-${rowNumber}`;
+    const displayIndex = label.activeParallelGroup && stableIndex >= label.groupStartIndex && stableIndex < label.groupEndIndex ? stableIndex - label.groupStartIndex : label.activeParallelGroup ? index - label.groupStartIndex : stableIndex;
+    return {
+      kind: "result",
+      resultIndex: index,
+      rowNumber,
+      rowLabel: resultRowLabel(label, rowNumber),
+      agentName: foregroundResultDisplayName(details, index, result, fallbackAgent),
+      displayIndex
+    };
+  });
+  return label.itemTitle === "Agent" ? withDuplicateForegroundLabels(entries, label.totalCount) : entries;
 }
-function widgetStats(job, theme) {
+function widgetStats(job, theme, projection = buildWorkflowWidgetProjection(job)) {
   const parts = [];
-  const stepsTotal = job.stepsTotal ?? (job.agents?.length ?? 1);
-  if (job.activeParallelGroup) {
+  const { stageProgress } = projection;
+  const stepsTotal = stageProgress?.total ?? job.stepsTotal ?? (job.agents?.length ?? 1);
+  const isSingleChild = isSingleChildAsyncJob(job);
+  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(" · "));
+  } else if (job.activeParallelGroup) {
     const running = job.runningSteps ?? (job.status === "running" ? 1 : 0);
     const done = job.completedSteps ?? (job.status === "complete" ? stepsTotal : 0);
     if (job.mode === "parallel") {
@@ -642,10 +1523,10 @@ function widgetStats(job, theme) {
       parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupParts.join(" · ")}`);
     }
   } else if (job.currentStep !== undefined) {
-    if (job.mode === "chain" && job.parallelGroups?.length) {
+    if (job.mode === "chain") {
       const total = job.chainStepCount ?? stepsTotal;
-      parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups) + 1}/${total}`);
-    } else {
+      parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups ?? []) + 1}/${total}`);
+    } else if (!isSingleChild) {
       parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
     }
   } else if (stepsTotal > 1) {
@@ -654,7 +1535,7 @@ function widgetStats(job, theme) {
   if (job.toolCount !== undefined)
     parts.push(formatToolUseStat(job.toolCount));
   if (job.totalTokens?.total)
-    parts.push(formatTokenStat(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)));
   return statJoin(theme, parts);
@@ -663,7 +1544,7 @@ function widgetStepStats(theme, step) {
   return statJoin(theme, [
     step.turnCount !== undefined ? `${step.turnCount} turns` : "",
     step.toolCount !== undefined ? formatToolUseStat(step.toolCount) : "",
-    step.tokens?.total ? formatTokenStat(step.tokens.total) : "",
+    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) : ""
   ]);
 }
@@ -688,6 +1569,8 @@ function widgetOutputPath(job, step) {
   return path.join(job.asyncDir, `output-${step.index}.log`);
 }
 function nestedRunName(run) {
+  if (run.sessionName?.trim())
+    return run.sessionName.trim();
   if (run.agent)
     return run.agent;
   if (run.agents?.length)
@@ -701,13 +1584,33 @@ function nestedStatusGlyph(state, theme, seed) {
     return theme.fg("success", "✓");
   if (state === "failed")
     return theme.fg("error", "✗");
+  if (state === "partial")
+    return theme.fg("warning", "■");
   if (state === "paused")
     return theme.fg("warning", "■");
+  if (state === "stopped")
+    return theme.fg("warning", "■");
   return theme.fg("muted", "◦");
 }
 function nestedRunSeed(run) {
   return runningSeed(run.lastUpdate, run.lastActivityAt, run.currentStep, run.toolCount, run.turnCount, run.totalTokens?.total, run.currentToolStartedAt);
 }
+function formatClockTime(ms) {
+  if (ms === undefined || !Number.isFinite(ms))
+    return;
+  const date = new Date(ms);
+  const pad = (value) => value.toString().padStart(2, "0");
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function nestedRunEventTime(run) {
+  return run.state === "running" ? run.lastActivityAt ?? run.currentToolStartedAt ?? run.lastUpdate ?? run.startedAt : run.endedAt ?? run.lastUpdate ?? run.lastActivityAt ?? run.startedAt;
+}
+function nestedStepTimestamp(step, fallback) {
+  return formatClockTime(step.status === "running" ? step.lastActivityAt ?? step.currentToolStartedAt ?? fallback ?? step.startedAt : step.endedAt ?? step.lastActivityAt ?? fallback ?? step.startedAt);
+}
+function nestedTimestampPrefix(timestamp) {
+  return timestamp ? `[${timestamp}] ` : "";
+}
 function nestedActivity(input, state, snapshotNow) {
   const facts = [];
   if (input.currentTool && input.currentToolStartedAt !== undefined && snapshotNow !== undefined)
@@ -733,6 +1636,10 @@ function nestedActivity(input, state, snapshotNow) {
     return "queued…";
   if (state === "paused")
     return "Paused";
+  if (state === "stopped")
+    return "Stopped";
+  if (state === "partial")
+    return "Partial";
   if (state === "failed")
     return "Failed";
   return "Done";
@@ -741,8 +1648,53 @@ function formatNestedWidgetLines(children, theme, width, expanded, snapshotNow,
   if (!children?.length || lineBudget <= 0)
     return [];
   if (!expanded) {
-    const aggregate = formatNestedAggregate(children);
-    return aggregate ? [theme.fg("dim", `↳ ${aggregate}`)] : [];
+    const rows = [];
+    const maxLeaves = 4;
+    const maxLines = Math.min(6, lineBudget);
+    let leaves = 0;
+    let overflow = 0;
+    const appendLeaf = (step, prefix, fallback) => {
+      if (leaves >= maxLeaves) {
+        overflow++;
+        return;
+      }
+      leaves++;
+      const state = "status" in step ? step.status : step.state;
+      const modelThinking = formatModelThinking(step.model, step.thinking);
+      const activity = nestedActivity(step, state, snapshotNow ?? fallback);
+      const timestamp = "status" in step ? nestedStepTimestamp(step, fallback) : formatClockTime(nestedRunEventTime(step));
+      const error = step.error ? ` · ${step.error}` : "";
+      const name = "status" in step ? childDisplayName(step) : nestedRunName(step);
+      rows.push({
+        prefix,
+        text: `${nestedTimestampPrefix(timestamp)}${nestedStatusGlyph(state, theme)} ${name} · ${state}${modelThinking ? ` · ${modelThinking}` : ""}${activity ? ` · ${activity}` : ""}${error}`
+      });
+    };
+    for (const child of children) {
+      const steps = child.mode === "parallel" || child.mode === "chain" ? child.steps ?? [] : [];
+      if (steps.length > 0) {
+        const ownerModelThinking = formatModelThinking(child.model, child.thinking);
+        const ownerActivity = nestedActivity(child, child.state, snapshotNow ?? child.lastUpdate);
+        const ownerError = child.error ? ` · ${child.error}` : "";
+        rows.push({
+          prefix: "↳ ",
+          text: `OWNER ${nestedStatusGlyph(child.state, theme, nestedRunSeed(child))} ${nestedRunName(child)} · ${child.state}${ownerModelThinking ? ` · ${ownerModelThinking}` : ""}${ownerActivity ? ` · ${ownerActivity}` : ""}${ownerError}`
+        });
+        for (const step of steps)
+          appendLeaf(step, "↳ │  ", child.lastUpdate);
+      } else {
+        appendLeaf(child, "↳ ", child.lastUpdate);
+      }
+    }
+    if (overflow > 0)
+      rows.push({ prefix: "↳ ", text: `… +${overflow} more nested leaves` });
+    const visibleRows = rows.length <= maxLines ? rows : overflow > 0 ? [...rows.slice(0, Math.max(0, maxLines - 1)), rows.at(-1)] : rows.slice(0, maxLines);
+    return visibleRows.map((row, index) => {
+      const marker = index === visibleRows.length - 1 ? "└─" : "├─";
+      const prefix = row.prefix;
+      const text = row.text.startsWith("OWNER ") ? row.text.slice("OWNER ".length) : row.text;
+      return truncLine(theme.fg("dim", `${prefix}${marker} ${text}`), width);
+    });
   }
   const lines = [];
   const maxDepth = 2;
@@ -765,7 +1717,8 @@ function formatNestedWidgetLines(children, theme, width, expanded, snapshotNow,
       }
       const activity = nestedActivity(child, child.state, snapshotNow ?? child.lastUpdate);
       const error = child.error ? ` · ${child.error}` : "";
-      lines.push(theme.fg("dim", `${prefix}↳ ${nestedStatusGlyph(child.state, theme, nestedRunSeed(child))} ${nestedRunName(child)} · ${child.state} · ${activity}${error}`));
+      const modelThinking = formatModelThinking(child.model, child.thinking);
+      lines.push(theme.fg("dim", `${prefix}↳ ${nestedTimestampPrefix(formatClockTime(nestedRunEventTime(child)))}${nestedStatusGlyph(child.state, theme, nestedRunSeed(child))} ${nestedRunName(child)} · ${child.state}${modelThinking ? ` · ${modelThinking}` : ""} · ${activity}${error}`));
       if (depth === maxDepth) {
         const aggregate = formatNestedAggregate([...child.steps?.flatMap((step) => step.children ?? []) ?? [], ...child.children ?? []]);
         if (aggregate && lines.length < lineBudget)
@@ -775,7 +1728,8 @@ function formatNestedWidgetLines(children, theme, width, expanded, snapshotNow,
       for (const step of child.steps ?? []) {
         if (lines.length >= lineBudget)
           return;
-        lines.push(theme.fg("dim", `${prefix}  ↳ ${nestedStatusGlyph(step.status, theme)} ${step.agent} · ${step.status} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`));
+        const modelThinking = formatModelThinking(step.model, step.thinking);
+        lines.push(theme.fg("dim", `${prefix}  ↳ ${nestedTimestampPrefix(nestedStepTimestamp(step, child.lastUpdate))}${nestedStatusGlyph(step.status, theme)} ${childDisplayName(step)} · ${step.status}${modelThinking ? ` · ${modelThinking}` : ""} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`));
         append(step.children, depth + 1, `${prefix}    `);
       }
       append(child.children, depth + 1, `${prefix}  `);
@@ -784,88 +1738,160 @@ function formatNestedWidgetLines(children, theme, width, expanded, snapshotNow,
   append(children, 0, "");
   return lines.map((line) => truncLine(line, width));
 }
-function foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index, total, expanded, width) {
+function foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index, total, expanded, width, frame, options) {
+  const rowIndent = options?.rowIndent ?? "  ";
+  const detailIndent = options?.detailIndent ?? "    ";
   const status = widgetStepStatus(step.status, theme);
   const stats = widgetStepStats(theme, step);
   const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking);
-  const lines = [`  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index - 1))} ${itemTitle} ${index}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
+  const collapseDetails = shouldCollapseSingleChildDetails(job, step);
+  const displayName = collapseDetails ? singleChildAgentName(job, step) : childDisplayName(step);
+  const stageName = itemTitle === "Stage" ? compactTaskText(undefined, step.label) ?? boundedLaneValue(step.workflowKey) ?? displayName : undefined;
+  const stageIdentity = stageName && stageName !== displayName ? `${stageName} (${displayName})` : stageName ?? displayName;
+  const rowLabel = collapseDetails ? displayName : options?.rowLabel ?? `${itemTitle} ${index}/${total}: ${itemTitle === "Stage" ? stageIdentity : displayName}`;
+  const rowMarker = options?.rowMarker ? `${options.rowMarker} ` : "";
+  const lines = [`${rowIndent}${rowMarker}${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index - 1), frame)} ${themeBold(theme, rowLabel)}${contextModeBadge(theme, step.context)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
+  const lane = projectAsyncLane(job, step);
+  if (lane)
+    lines.push(...formatLaneProjectionLines(lane, theme, detailIndent));
+  const task = collapseDetails ? singleChildTask(job, step) : compactTaskText(step.description, step.label);
+  if (task)
+    lines.push(`${detailIndent}${theme.fg("dim", `task: ${task}`)}`);
   const activity = widgetStepActivityLine(step, width, expanded, job.updatedAt);
-  if (activity)
-    lines.push(`    ${theme.fg("dim", `⎿  ${activity}`)}`);
-  for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt)) {
-    lines.push(`    ${nestedLine}`);
+  const currentPath = options?.includeCurrentPath && step.currentPath ? shortenPath(step.currentPath) : undefined;
+  const activityWithPath = currentPath && activity && !activity.includes(currentPath) ? `${activity} · ${currentPath}` : activity ?? currentPath;
+  if (activityWithPath)
+    lines.push(`${detailIndent}${theme.fg("dim", `⎿  ${activityWithPath}`)}`);
+  for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, expanded ? 12 : 6)) {
+    lines.push(`${detailIndent}${nestedLine}`);
   }
+  const error = step.error?.trim() || step.execution?.error?.trim();
+  if (error)
+    lines.push(`${detailIndent}${theme.fg("error", `error: ${oneLine(error)}`)}`);
   if (step.status === "running") {
     if (!expanded)
-      lines.push(`    ${theme.fg("accent", liveDetailHintText())}`);
+      lines.push(`${detailIndent}${theme.fg("accent", liveDetailHintText())}`);
     const output = widgetOutputPath(job, step);
     if (output)
-      lines.push(`    ${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
+      lines.push(`${detailIndent}${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
     if (expanded) {
       const liveStatus = buildLiveStatusLine(step, job.updatedAt);
       if (liveStatus && liveStatus !== activity)
-        lines.push(`    ${theme.fg("accent", liveStatus)}`);
+        lines.push(`${detailIndent}${theme.fg("accent", liveStatus)}`);
       for (const tool of step.recentTools?.slice(-3) ?? []) {
         const maxArgsLen = Math.max(40, width - 30);
-        const argsPreview = tool.args.length <= maxArgsLen ? tool.args : `${tool.args.slice(0, maxArgsLen)}...`;
-        lines.push(`      ${theme.fg("dim", `${tool.tool}${argsPreview ? `: ${argsPreview}` : ""}`)}`);
+        const argsPreview = renderToolArgsPreview(tool.args, maxArgsLen, expanded);
+        lines.push(`${detailIndent}  ${theme.fg("dim", `${tool.tool}${argsPreview ? `: ${argsPreview}` : ""}`)}`);
       }
-      for (const line of step.recentOutput?.slice(-5) ?? []) {
-        lines.push(`      ${theme.fg("dim", line)}`);
+      for (const line of compactRecentOutputLines(step.recentOutput)) {
+        lines.push(`${detailIndent}  ${theme.fg("dim", line)}`);
       }
     }
   }
   return lines;
 }
-function foregroundStyleWidgetDetails(job, theme, expanded, width) {
-  if (!job.steps?.length)
+function hostStepWidgetLines(job, theme, indent) {
+  const rows = projectAsyncWorkflowRows([], job.hostSteps).filter((row) => row.kind);
+  const visible = rows.slice(0, 8);
+  const lines = visible.map((row) => {
+    const state = hostStepVerdictLabel(row.state, row.verdict);
+    const glyph = state === "running" ? theme.fg("accent", "●") : state === "pending" ? theme.fg("muted", "◦") : state === "pass" ? theme.fg("success", "✓") : state === "fail" || state === "error" ? theme.fg("error", "✗") : theme.fg("warning", "■");
+    const details = [
+      row.provider ? `provider:${row.provider}` : undefined,
+      row.role ? `role:${row.role}` : undefined,
+      row.target,
+      row.detail,
+      row.reasonCode ? `reason:${row.reasonCode}` : undefined,
+      row.freshness?.stale ? "stale" : row.freshness?.observedRef ? `ref:${row.freshness.observedRef}` : undefined,
+      row.reportPath ? `out:${hostStepReportName(row.reportPath)}` : undefined
+    ].filter(Boolean).join(" · ");
+    return `${indent}${glyph} ${row.kind}: ${row.name} · ${state}${details ? ` · ${details}` : ""}`;
+  });
+  if (rows.length > visible.length)
+    lines.push(`${indent}${theme.fg("dim", `… +${rows.length - visible.length} host steps hidden`)}`);
+  return lines;
+}
+function foregroundStyleWidgetDetails(job, theme, expanded, width, frame, projection = buildWorkflowWidgetProjection(job)) {
+  const { steps } = projection;
+  if (!steps.length) {
+    const lane = projectAsyncLane(job, laneStepForJob(job, steps));
     return [
+      ...workflowPreflightLines(job, expanded),
+      ...lane ? formatLaneProjectionLines(lane, theme, "  ") : [],
+      ...hostStepWidgetLines(job, theme, "  "),
       `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
-      ...formatNestedWidgetLines(job.nestedChildren, theme, width, expanded, job.updatedAt).map((line) => `  ${line}`)
+      ...formatNestedWidgetLines(job.nestedChildren, theme, width, expanded, job.updatedAt, expanded ? 12 : 6).map((line) => `  ${line}`)
     ];
+  }
   if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length)
-    return widgetChainDetails(job, theme, expanded, width);
-  const total = job.stepsTotal ?? job.steps.length;
-  const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
-  const lines = [];
-  for (const [index, step] of job.steps.entries()) {
-    lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index + 1, total, expanded, width));
+    return widgetChainDetails(job, theme, expanded, width, frame);
+  const lines = workflowPreflightLines(job, expanded);
+  const group = activeParallelWidgetGroup(job);
+  if (group) {
+    lines.push(...parallelWidgetGroupDetails(job, theme, group, expanded, width, frame, Boolean(job.activeParallelGroup)));
+  } else {
+    const { stageProgress, plannedKeys } = projection;
+    const total = job.mode === "chain" ? job.chainStepCount ?? job.stepsTotal ?? steps.length : stageProgress?.total ?? job.stepsTotal ?? steps.length;
+    const stageTotal = stageProgress?.total ?? total;
+    const extraStepCount = plannedKeys ? steps.filter((step) => step.workflowKey === undefined || !plannedKeys.has(step.workflowKey)).length : total;
+    let extraStepIndex = 0;
+    for (const [index, step] of steps.entries()) {
+      const isPlannedStage = plannedKeys !== undefined && step.workflowKey !== undefined && plannedKeys.has(step.workflowKey);
+      const itemTitle = isPlannedStage ? "Stage" : "Step";
+      const displayIndex = isPlannedStage ? (step.index ?? index) + 1 : plannedKeys ? ++extraStepIndex : index + 1;
+      const displayTotal = isPlannedStage ? stageTotal : extraStepCount;
+      lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, displayIndex, displayTotal, expanded, width, frame));
+    }
   }
-  const attached = new Set(job.steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
+  lines.push(...hostStepWidgetLines(job, theme, "  "));
+  const attached = new Set(steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
   const unattached = job.nestedChildren?.filter((child) => !attached.has(child.id)) ?? [];
-  for (const nestedLine of formatNestedWidgetLines(unattached, theme, width, expanded, job.updatedAt)) {
+  for (const nestedLine of formatNestedWidgetLines(unattached, theme, width, expanded, job.updatedAt, expanded ? 12 : 6)) {
     lines.push(`  ${nestedLine}`);
   }
   return lines;
 }
-function buildSingleWidgetLines(job, theme, width, expanded) {
-  const stats = widgetStats(job, theme);
-  const count = job.mode === "chain" ? job.chainStepCount : job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
+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;
   const mode = widgetJobName(job);
-  const title = `async subagent ${mode}${count && count > 1 ? ` (${count})` : ""}`;
+  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 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")}`,
-    `${widgetStatusGlyph(job, theme)} ${themeBold(theme, mode)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
-    ...foregroundStyleWidgetDetails(job, theme, expanded, width)
+    ...collapseDetails ? [] : [summary],
+    ...foregroundStyleWidgetDetails(job, theme, expanded, width, frame, projection)
   ].map((line) => truncLine(line, width));
 }
-function compactSingleWidgetLines(job, theme, width) {
-  const fullLines = buildSingleWidgetLines(job, theme, width, false);
+function compactSingleWidgetLines(job, theme, width, frame, projection = buildWorkflowWidgetProjection(job)) {
+  const fullLines = buildSingleWidgetLines(job, theme, width, false, frame, projection);
   if (fullLines.length <= 10 || !job.steps?.length || job.mode !== "parallel" && !job.activeParallelGroup)
     return fullLines;
-  const total = job.stepsTotal ?? job.steps.length;
-  const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+  const group = activeParallelWidgetGroup(job);
+  if (!group)
+    return fullLines;
+  const rows = parallelWidgetStepRows(group.steps, group.total, Boolean(job.activeParallelGroup));
   const lines = fullLines.slice(0, 2);
-  for (const [index, step] of job.steps.entries()) {
+  lines.push(parallelWidgetGroupHeader(group, theme, frame));
+  for (const [rowIndex, row] of rows.entries()) {
+    const step = row.step;
     const status = widgetStepStatus(step.status, theme);
     const activity = widgetStepActivityLine(step, width, false, job.updatedAt);
     const stepStats = widgetStepStats(theme, step);
     const activitySuffix = activity ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", activity)}` : "";
     const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking);
-    lines.push(`  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index))} ${itemTitle} ${index + 1}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${activitySuffix}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}`);
-    for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, false, job.updatedAt))
-      lines.push(`    ${nestedLine}`);
+    const task = compactTaskText(step.description, step.label);
+    const taskSuffix = task ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", `task: ${task}`)}` : "";
+    const marker = rowIndex === rows.length - 1 && rowIndex >= group.total - 1 ? "└─" : "├─";
+    lines.push(`    ${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, row.index), frame)} ${themeBold(theme, row.rowLabel)}${contextModeBadge(theme, step.context)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${taskSuffix}${activitySuffix}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}`);
+    const lane = projectAsyncLane(job, step);
+    if (lane)
+      lines.push(...formatLaneProjectionLines(lane, theme, "      "));
+    for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, false, job.updatedAt, 6))
+      lines.push(`      ${nestedLine}`);
   }
+  lines.push(...hostStepWidgetLines(job, theme, "  "));
   if (job.steps.some((step) => step.status === "running"))
     lines.push(theme.fg("accent", `  ${liveDetailHintText()}`));
   return lines.map((line) => truncLine(line, width));
@@ -894,13 +1920,14 @@ function widgetHeaderCounts(jobs) {
     queued: jobs.filter((job) => job.status === "queued"),
     complete: jobs.filter((job) => job.status === "complete"),
     failed: jobs.filter((job) => job.status === "failed"),
-    paused: jobs.filter((job) => job.status === "paused")
+    paused: jobs.filter((job) => job.status === "paused"),
+    stopped: jobs.filter((job) => job.status === "stopped")
   };
 }
-function buildSingleLineWidgetLines(jobs, theme, width) {
+function buildSingleLineWidgetLines(jobs, theme, width, frame) {
   const counts = widgetHeaderCounts(jobs);
   const hasActive = counts.running.length > 0 || counts.queued.length > 0;
-  const glyph = counts.running.length > 0 ? runningGlyph(widgetJobsRunningSeed(counts.running)) : hasActive ? "●" : "○";
+  const glyph = counts.running.length > 0 ? runningGlyph(animatedSeed(widgetJobsRunningSeed(counts.running), frame)) : hasActive ? "●" : "○";
   const parts = [];
   if (counts.running.length > 0)
     parts.push(`${counts.running.length}/${jobs.length} running`);
@@ -908,6 +1935,8 @@ function buildSingleLineWidgetLines(jobs, theme, width) {
     parts.push(`${counts.queued.length} queued`);
   if (counts.failed.length > 0)
     parts.push(`${counts.failed.length} failed`);
+  if (counts.stopped.length > 0)
+    parts.push(`${counts.stopped.length} stopped`);
   if (counts.paused.length > 0)
     parts.push(`${counts.paused.length} paused`);
   if (!hasActive && counts.complete.length > 0)
@@ -969,10 +1998,10 @@ function selectProgressiveJobKeys(jobs, previousKeys, bodyRows) {
   }
   return selected;
 }
-function progressiveHeaderLine(jobs, theme, width) {
+function progressiveHeaderLine(jobs, theme, width, frame) {
   const counts = widgetHeaderCounts(jobs);
   const hasActive = counts.running.length > 0 || counts.queued.length > 0;
-  const glyph = counts.running.length > 0 ? runningGlyph(widgetJobsRunningSeed(counts.running)) : hasActive ? "●" : "○";
+  const glyph = counts.running.length > 0 ? runningGlyph(animatedSeed(widgetJobsRunningSeed(counts.running), frame)) : hasActive ? "●" : "○";
   const parts = [];
   if (counts.running.length > 0)
     parts.push(formatAgentRunningLabel(counts.running.length));
@@ -981,6 +2010,8 @@ function progressiveHeaderLine(jobs, theme, width) {
   if (!hasActive) {
     if (counts.failed.length > 0)
       parts.push(`${counts.failed.length} failed`);
+    if (counts.stopped.length > 0)
+      parts.push(`${counts.stopped.length} stopped`);
     if (counts.paused.length > 0)
       parts.push(`${counts.paused.length} paused`);
     if (counts.complete.length > 0)
@@ -988,17 +2019,22 @@ function progressiveHeaderLine(jobs, theme, width) {
   }
   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) {
-  const stats = widgetStats(job, theme);
+function progressiveJobLine(job, theme, width, frame, projection = buildWorkflowWidgetProjection(job)) {
+  const stats = widgetStats(job, theme, projection);
   const activity = widgetActivity(job);
   const status = job.status === "complete" ? "done" : job.status;
+  const lane = projectAsyncLane(job, laneStepForJob(job, projection.steps));
+  const laneSummary = lane ? [lane.label ?? lane.role, lane.phase ? `phase:${lane.phase}` : undefined, lane.output ? `out:${lane.output}` : undefined, lane.workspace ? `workspace:${lane.workspace}` : `ref:${lane.ref}`].filter(Boolean).join(" · ") : "";
+  const laneSignals = lane ? [lane.next ? `next:${lane.next}` : undefined, ...lane.chips.map((chip) => formatLaneChip(chip, theme))].filter(Boolean).join(" · ") : "";
   const parts = [
-    themeBold(theme, widgetJobName(job)),
+    `${themeBold(theme, widgetJobName(job))}${contextModeBadge(theme, job.context)}`,
     theme.fg("dim", status),
+    laneSignals ? laneSignals : "",
+    laneSummary ? theme.fg("dim", laneSummary) : "",
     stats,
     activity && activity.toLowerCase() !== status ? theme.fg("dim", activity) : ""
   ].filter(Boolean);
-  return truncLine(`  ${widgetStatusGlyph(job, theme)} ${parts.join(` ${theme.fg("dim", "·")} `)}`, width);
+  return truncLine(`  ${widgetStatusGlyph(job, theme, frame)} ${parts.join(` ${theme.fg("dim", "·")} `)}`, width);
 }
 function progressiveHiddenLine(hiddenJobs, theme, width) {
   const counts = widgetHeaderCounts(hiddenJobs);
@@ -1007,15 +2043,15 @@ function progressiveHiddenLine(hiddenJobs, theme, width) {
     parts.push(`${counts.running.length} running`);
   if (counts.queued.length > 0)
     parts.push(`${counts.queued.length} queued`);
-  const finished = counts.complete.length + counts.failed.length + counts.paused.length;
+  const finished = counts.complete.length + counts.failed.length + counts.paused.length + counts.stopped.length;
   if (finished > 0)
     parts.push(`${finished} finished`);
   return truncLine(theme.fg("dim", `  +${hiddenJobs.length} more${parts.length ? ` (${parts.join(", ")})` : ""}`), width);
 }
-function buildProgressiveWidgetLines(jobs, theme, width, lockedRows, previousKeys) {
+function buildProgressiveWidgetLines(jobs, theme, width, lockedRows, previousKeys, frame, projectionFor = workflowWidgetProjectionLookup()) {
   const rowCount = Math.max(1, lockedRows);
   if (rowCount === 1)
-    return { lines: buildSingleLineWidgetLines(jobs, theme, width), visibleJobKeys: [] };
+    return { lines: buildSingleLineWidgetLines(jobs, theme, width, frame), visibleJobKeys: [] };
   const bodyRows = rowCount - 1;
   let visibleJobKeys = selectProgressiveJobKeys(jobs, previousKeys, bodyRows);
   const jobsByKey = new Map(jobs.map((job) => [progressiveJobKey(job), job]));
@@ -1028,8 +2064,8 @@ function buildProgressiveWidgetLines(jobs, theme, width, lockedRows, previousKey
     hiddenJobs = jobs.filter((job) => !visibleJobKeys.includes(progressiveJobKey(job)));
   }
   const lines = [
-    progressiveHeaderLine(jobs, theme, width),
-    ...visibleJobs.map((job) => progressiveJobLine(job, theme, width))
+    progressiveHeaderLine(jobs, theme, width, frame),
+    ...visibleJobs.map((job) => progressiveJobLine(job, theme, width, frame, projectionFor(job)))
   ];
   if (hiddenJobs.length > 0 && lines.length < rowCount)
     lines.push(progressiveHiddenLine(hiddenJobs, theme, width));
@@ -1040,6 +2076,12 @@ function buildProgressiveWidgetLines(jobs, theme, width, lockedRows, previousKey
 function collapsedWidgetLineBudget(rows) {
   return Math.max(10, Math.min(14, Math.floor(rows * 0.35)));
 }
+function paddedWidgetLine(line, width) {
+  if (width <= 2)
+    return " ".repeat(Math.max(0, width));
+  const text = ` ${truncLine(line, width - 2)} `;
+  return `${text}${" ".repeat(Math.max(0, width - visibleWidth(text)))}`;
+}
 function fitWidgetLineBudget(lines, theme, width, expanded) {
   const rows = process.stdout.rows || 30;
   const budget = expanded ? Math.max(12, Math.min(24, Math.floor(rows * 0.55))) : collapsedWidgetLineBudget(rows);
@@ -1050,74 +2092,98 @@ function fitWidgetLineBudget(lines, theme, width, expanded) {
   const hint = expanded ? `… ${hiddenCount} live-detail lines hidden` : `… ${hiddenCount} lines hidden · ${liveDetailKeyText()} expands`;
   return [...lines.slice(0, visibleLines), truncLine(theme.fg("dim", hint), width)];
 }
-function fitAdaptiveWidgetLines(jobs, lines, theme, width, expanded) {
+function fitAdaptiveWidgetLines(jobs, buildLines, theme, width, expanded, frame, projectionFor) {
   if (expanded) {
     resetWidgetLayoutSession();
-    return fitWidgetLineBudget(lines, theme, width, true);
+    return fitWidgetLineBudget(buildLines(), theme, width, true);
   }
   const hasMatchingSession = widgetSessionMatches(expanded);
   const rows = currentTerminalRows();
   const columns = currentTerminalColumns();
   const availableRows = estimateAvailableWidgetRows();
   if (hasMatchingSession && widgetLayoutSession?.tier === "single-line") {
-    return buildSingleLineWidgetLines(jobs, theme, width);
+    return buildSingleLineWidgetLines(jobs, theme, width, frame);
   }
   if (hasMatchingSession && widgetLayoutSession?.tier === "progressive" && widgetLayoutSession.lockedRows !== undefined) {
-    const rendered = buildProgressiveWidgetLines(jobs, theme, width, widgetLayoutSession.lockedRows, widgetLayoutSession.visibleJobKeys);
+    const rendered = buildProgressiveWidgetLines(jobs, theme, width, widgetLayoutSession.lockedRows, widgetLayoutSession.visibleJobKeys, frame, projectionFor);
     widgetLayoutSession.visibleJobKeys = rendered.visibleJobKeys;
     return rendered.lines;
   }
+  const lines = buildLines();
   if (lines.length <= availableRows) {
     widgetLayoutSession = { expanded, rows, columns, tier: "full", visibleJobKeys: [] };
     return fitWidgetLineBudget(lines, theme, width, false);
   }
+  if (availableRows > 2 && jobs.length === 1 && projectionFor?.(jobs[0]).stageProgress) {
+    widgetLayoutSession = { expanded, rows, columns, tier: "full", visibleJobKeys: [] };
+    return fitWidgetLineBudget(lines, theme, width, false);
+  }
   if (availableRows <= 2) {
     widgetLayoutSession = { expanded, rows, columns, tier: "single-line", visibleJobKeys: [] };
-    return buildSingleLineWidgetLines(jobs, theme, width);
+    return buildSingleLineWidgetLines(jobs, theme, width, frame);
   }
   const lockedRows = Math.min(availableRows, collapsedWidgetLineBudget(rows));
-  const rendered = buildProgressiveWidgetLines(jobs, theme, width, lockedRows, []);
+  const rendered = buildProgressiveWidgetLines(jobs, theme, width, lockedRows, [], frame, projectionFor);
   widgetLayoutSession = { expanded, rows, columns, tier: "progressive", lockedRows, visibleJobKeys: rendered.visibleJobKeys };
   return rendered.lines;
 }
-function buildWidgetComponent(jobs, expanded) {
+function buildWidgetComponent(jobs, isExpanded) {
   return (_tui, theme) => {
-    const width = getTermWidth();
-    const lines = expanded ? buildWidgetLines(jobs, theme, width, true) : jobs.length === 1 ? compactSingleWidgetLines(jobs[0], theme, width) : buildWidgetLines(jobs, theme, width, false);
     const container = new Container;
-    for (const line of fitAdaptiveWidgetLines(jobs, lines, theme, width, expanded))
-      container.addChild(new Text(line, 1, 0));
+    let cachedRenderWidth;
+    let cachedFrame;
+    let cachedExpanded;
+    let cachedLines;
+    container.render = (renderWidth) => {
+      const frame = Math.floor(Date.now() / WIDGET_ANIMATION_INTERVAL_MS);
+      const expanded = isExpanded();
+      if (cachedLines && cachedRenderWidth === renderWidth && cachedFrame === frame && cachedExpanded === expanded)
+        return cachedLines;
+      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);
+      cachedRenderWidth = renderWidth;
+      cachedFrame = frame;
+      cachedExpanded = expanded;
+      cachedLines = fitAdaptiveWidgetLines(jobs, buildLines, theme, width, expanded, frame, projectionFor).map((line) => paddedWidgetLine(line, renderWidth));
+      return cachedLines;
+    };
     return container;
   };
 }
-export function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = false) {
+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);
+    return buildSingleWidgetLines(jobs[0], theme, width, expanded, frame, projectionFor(jobs[0]));
   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");
   const lines = [];
   const hasActive = running.length > 0 || queued.length > 0;
-  const headerGlyph = running.length > 0 ? runningGlyph(widgetJobsRunningSeed(running)) : hasActive ? "●" : "○";
+  const headerGlyph = running.length > 0 ? runningGlyph(animatedSeed(widgetJobsRunningSeed(running), frame)) : hasActive ? "●" : "○";
   lines.push(truncLine(`${theme.fg(hasActive ? "accent" : "dim", headerGlyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "· background")}`, width));
   const items = [];
   let hiddenRunning = 0;
   let hiddenFinished = 0;
   let queuedSummaryShown = false;
   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}` : ""}`,
+      `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
+      ...widgetLaneDetailLines(job, theme, projection),
+      ...widgetParallelAgentDetails(job, theme, expanded, width, frame)
+    ]);
+  };
   for (const job of running) {
     if (slots <= 0) {
       hiddenRunning++;
       continue;
     }
-    const stats = widgetStats(job, theme);
-    items.push([
-      `${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
-      `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
-      ...widgetParallelAgentDetails(job, theme, expanded, width)
-    ]);
+    appendJob(job);
     slots--;
   }
   if (queued.length > 0 && slots > 0) {
@@ -1130,12 +2196,7 @@ export function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded =
       hiddenFinished++;
       continue;
     }
-    const stats = widgetStats(job, theme);
-    items.push([
-      `${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
-      `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
-      ...widgetParallelAgentDetails(job, theme, expanded, width)
-    ]);
+    appendJob(job);
     slots--;
   }
   const hiddenQueued = queued.length > 0 && !queuedSummaryShown ? queued.length : 0;
@@ -1162,6 +2223,9 @@ export function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded =
   }
   return lines;
 }
+export function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = false, frame) {
+  return buildWidgetLinesWithProjection(jobs, theme, width, expanded, frame);
+}
 export function renderWidget(ctx, jobs) {
   if (jobs.length === 0) {
     resetWidgetLayoutSession();
@@ -1171,50 +2235,151 @@ export function renderWidget(ctx, jobs) {
   }
   if (!ctx.hasUI)
     return;
-  ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, ctx.ui.getToolsExpanded?.() ?? false));
+  if (ctx.mode === "rpc") {
+    ctx.ui.setWidget(WIDGET_KEY, encodeAsyncStatusSnapshotWidget(jobs));
+    return;
+  }
+  ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, () => ctx.ui.getToolsExpanded?.() ?? false));
 }
-function renderSingleCompact(d, r, theme, frame) {
+function renderSingleCompact(d, r, theme, layout, frame, foregroundDetachShortcut) {
   const output = r.truncation?.text || getSingleResultOutput(r);
   const progress = r.progress || r.progressSummary;
-  const isRunning = r.progress?.status === "running";
-  const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+  const isRunning = isResultRunning(r);
+  const contextBadge = contextModeBadge(theme, r.context ?? d.context);
   const stats = statJoin(theme, [
     r.usage?.turns ? `⟳ ${r.usage.turns}` : "",
     formatProgressStats(theme, progress)
   ]);
   const c = new Container;
   const width = getTermWidth() - 4;
-  const modelDisplay = modelThinkingBadge(theme, r.model);
-  c.addChild(new Text(truncLine(`${resultGlyph(r, output, theme, isRunning, undefined, frame)} ${theme.fg("toolTitle", theme.bold(r.agent))}${modelDisplay}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
+  const detailIndent = mainWindowIndent(layout, 1);
+  const continuationIndent = mainWindowIndent(layout, 2) + (layout.horizontalSpacing > 0 ? " " : "");
+  const modelDisplay = modelThinkingBadge(theme, r.model ?? r.progress?.model, r.thinking ?? r.progress?.thinking);
+  c.addChild(new Text(truncLine(`${resultGlyph(r, output, theme, isRunning, undefined, frame)} ${theme.fg("toolTitle", theme.bold(foregroundSingleDisplayName(r)))}${modelDisplay}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
   if (isRunning && r.progress) {
+    const task = compactTaskText(r.task);
+    if (task)
+      c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}task: ${task}`), width), 0, 0));
     const progressSnapshotNow = snapshotNowForProgress(r.progress);
     const activity = compactCurrentActivity(r.progress);
-    c.addChild(new Text(truncLine(theme.fg("dim", `  ⎿  ${activity}`), width), 0, 0));
+    c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}⎿  ${activity}`), width), 0, 0));
     const liveStatus = buildLiveStatusLine(r.progress, progressSnapshotNow);
     if (liveStatus && liveStatus !== activity)
-      c.addChild(new Text(truncLine(theme.fg("dim", `     ${liveStatus}`), width), 0, 0));
-    c.addChild(new Text(truncLine(theme.fg("accent", `  ${liveDetailHintText()}`), width), 0, 0));
+      c.addChild(new Text(truncLine(theme.fg("dim", `${continuationIndent}${liveStatus}`), width), 0, 0));
+    for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, progressSnapshotNow)) {
+      c.addChild(new Text(truncLine(`${detailIndent}${nestedLine}`, width), 0, 0));
+    }
+    c.addChild(new Text(truncLine(theme.fg("accent", `${detailIndent}${foregroundSingleHintText(foregroundDetachShortcut)}`), width), 0, 0));
     if (r.artifactPaths)
-      c.addChild(new Text(truncLine(theme.fg("dim", `  output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
+      c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
     return c;
   }
-  c.addChild(new Text(truncLine(theme.fg("dim", `  ⎿  ${resultStatusLine(r, output)}`), width), 0, 0));
+  for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, r.progress?.lastActivityAt)) {
+    c.addChild(new Text(truncLine(`${detailIndent}${nestedLine}`, width), 0, 0));
+  }
+  c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}⎿  ${resultStatusLine(r, output)}`), width), 0, 0));
   const preview = firstOutputLine(output);
   if (preview && r.exitCode === 0 && !hasEmptyTextOutputWithoutOutputTarget(r.task, output)) {
-    c.addChild(new Text(truncLine(theme.fg("dim", `     ${preview}`), width), 0, 0));
+    c.addChild(new Text(truncLine(theme.fg("dim", `${continuationIndent}${preview}`), width), 0, 0));
   }
   if (r.sessionFile)
-    c.addChild(new Text(truncLine(theme.fg("dim", `  session: ${shortenPath(r.sessionFile)}`), width), 0, 0));
+    c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}session: ${shortenPath(r.sessionFile)}`), width), 0, 0));
   if (r.artifactPaths)
-    c.addChild(new Text(truncLine(theme.fg("dim", `  output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
+    c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
   if (r.truncation?.artifactPath)
-    c.addChild(new Text(truncLine(theme.fg("dim", `  full output: ${shortenPath(r.truncation.artifactPath)}`), width), 0, 0));
+    c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}full output: ${shortenPath(r.truncation.artifactPath)}`), width), 0, 0));
+  return c;
+}
+function workflowRowGlyph(row, theme, frame) {
+  if (row.state === "planned")
+    return theme.fg("muted", "◦");
+  if (row.state === "running")
+    return theme.fg("accent", runningGlyph(frame));
+  if (row.state === "complete")
+    return theme.fg("success", "✓");
+  if (row.state === "detached" || row.state === "stopped")
+    return theme.fg("warning", "■");
+  return theme.fg("error", "✗");
+}
+function workflowRowStateLabel(row, theme) {
+  const label = (row.state === "complete" ? "complete" : row.state).padEnd(8);
+  if (row.state === "planned")
+    return theme.fg("dim", label);
+  if (row.state === "running")
+    return theme.fg("accent", label);
+  if (row.state === "complete")
+    return theme.fg("success", label);
+  if (row.state === "detached" || row.state === "stopped")
+    return theme.fg("warning", label);
+  return theme.fg("error", label);
+}
+function workflowOverallState(rows, hasTerminalValue, isError) {
+  if (rows.some((row) => row.state === "failed"))
+    return "failed";
+  if (rows.some((row) => row.state === "detached"))
+    return "paused";
+  if (isError)
+    return "failed";
+  if (rows.length > 0 && rows.every((row) => row.state === "complete") || hasTerminalValue)
+    return "complete";
+  return "running";
+}
+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) : [];
+  const state = workflowOverallState(rows, workflow?.value !== undefined, result.isError);
+  const glyph = state === "running" ? theme.fg("accent", runningGlyph(frame)) : state === "complete" ? theme.fg("success", "✓") : state === "paused" ? theme.fg("warning", "■") : theme.fg("error", "✗");
+  const width = getTermWidth() - 4;
+  const runId = d.runId ? d.runId.slice(0, 12) : "workflow";
+  const repoLabel = d.chatProgress?.repoLabel ?? (d.chatProgress?.repoRelation === "same" ? "same repo" : "other repo");
+  const phase = rows.find((row) => row.state === "running" && row.phase)?.phase ?? [...rows].reverse().find((row) => row.phase)?.phase;
+  const c = new Container;
+  const rowIndent = mainWindowIndent(layout, 1);
+  c.addChild(new Text(truncLine(`${glyph} ${theme.fg("toolTitle", theme.bold("workflow"))} ${runId} ${theme.fg("dim", "·")} ${d.chatProgress?.repoRelation === "same" ? "same repo" : "other repo"} ${theme.fg("dim", "·")} ${state}`, width), 0, 0));
+  c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}Repo   ${repoLabel}`), width), 0, 0));
+  if (d.preflight)
+    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));
+  if (rows.length === 0) {
+    c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}◦ waiting for workflow child launches`), width), 0, 0));
+    return c;
+  }
+  const visible = visibleWorkflowRows(rows);
+  if (visible.hiddenRows > 0)
+    c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}… ${visible.hiddenRows} older workflow rows hidden`), width), 0, 0));
+  for (const row of visible.rows) {
+    const status = workflowRowStateLabel(row, theme);
+    const label = row.label && row.label !== row.key ? ` ${oneLine(row.label)}` : "";
+    const duration = row.durationMs !== undefined ? ` ${theme.fg("dim", `· ${formatDuration(row.durationMs)}`)}` : "";
+    const run = row.runId ? ` ${theme.fg("dim", `[${row.runId.slice(0, 8)}]`)}` : "";
+    const error = row.error ? ` ${theme.fg(row.state === "detached" ? "warning" : "error", `· ${compactWorkflowError(row.error)}`)}` : "";
+    const hints = expanded && row.preflight ? [
+      row.preflight.mode ? `mode:${row.preflight.mode}` : undefined,
+      row.preflight.decision ? `decision:${row.preflight.decision}` : undefined,
+      row.preflight.claims?.length ? `claims:${row.preflight.claims.join(",")}` : undefined,
+      row.preflight.expectedOutput ? `expected:${row.preflight.expectedOutput}` : undefined,
+      row.preflight.independence ? `independence:${row.preflight.independence}` : undefined
+    ].filter((value) => Boolean(value)).join(" · ") : "";
+    c.addChild(new Text(truncLine(`${rowIndent}${workflowRowGlyph(row, theme, frame)} ${status} ${theme.bold(row.key)}${label}${run}${duration}${error}${hints ? ` ${theme.fg("dim", `· ${hints}`)}` : ""}`, width), 0, 0));
+  }
+  if (workflow?.preflightWarnings?.length) {
+    const warningLines = expanded ? formatWorkflowPreflightWarnings(workflow.preflightWarnings, { indent: rowIndent }).split(`
+`) : [formatWorkflowPreflightWarningSummary(workflow.preflightWarnings, { indent: rowIndent, hint: "expand for debug" })];
+    for (const warningLine of warningLines)
+      c.addChild(new Text(truncLine(theme.fg("warning", warningLine), width), 0, 0));
+  }
+  if (workflow?.emits.length)
+    c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}Emits  ${workflow.emits.length}`), width), 0, 0));
   return c;
 }
-function renderMultiCompact(d, theme, frame) {
-  const hasRunning = d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running") || workflowGraphHasStatus(d, ["running"]);
-  const failed = d.results.some((r) => r.exitCode !== 0 && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["failed"]);
-  const paused = d.results.some((r) => (r.interrupted || r.detached) && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["paused", "detached"]);
+function renderMultiCompact(d, theme, layout, frame) {
+  const hasRunning = detailsHaveRunningResult(d);
+  const detached = d.results.some((r) => r.detached) || workflowGraphHasStatus(d, ["detached"]);
+  const stopped = d.results.some((r) => r.stopped) || workflowGraphHasStatus(d, ["stopped"]);
+  const failed = d.results.some((r) => !hasTerminalResultFlag(r) && r.exitCode !== 0 && !isResultRunning(r)) || workflowGraphHasStatus(d, ["failed"]);
+  const paused = d.results.some((r) => r.interrupted) || workflowGraphHasStatus(d, ["paused"]);
+  const partial = workflowGraphHasStatus(d, ["partial"]);
   let totalSummary = d.progressSummary;
   if (!totalSummary) {
     let sawProgress = false;
@@ -1234,29 +2399,36 @@ function renderMultiCompact(d, theme, frame) {
   const multiLabel = buildMultiProgressLabel(d, hasRunning);
   const itemTitle = multiLabel.itemTitle;
   const stats = statJoin(theme, [multiLabel.headerLabel, formatProgressStats(theme, totalSummary), formatTotalCostStat(d.totalCost)]);
-  const glyph = hasRunning ? theme.fg("accent", runningGlyph(frame !== undefined ? (runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex) ?? 0) + frame : runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex))) : failed ? theme.fg("error", "✗") : paused ? theme.fg("warning", "■") : theme.fg("success", "✓");
-  const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+  const aggregatePresentation = semanticResultPresentation({
+    running: hasRunning,
+    detached,
+    stopped,
+    interrupted: paused,
+    failed,
+    partial,
+    seed: runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex),
+    frame
+  });
+  const glyph = theme.fg(aggregatePresentation.tone, aggregatePresentation.glyph);
+  const contextBadge = contextModeBadge(theme, d.context);
   const c = new Container;
   const width = getTermWidth() - 4;
+  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));
   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;
   const chainEntries = buildChainRenderEntries(d, multiLabel);
-  const renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset) => {
-    const i = displayStart + offset;
-    const r = d.results[i];
-    const fallbackLabel = itemTitle.toLowerCase();
-    const rowNumber = multiLabel.showActiveGroupOnly ? i - multiLabel.groupStartIndex + 1 : i + 1;
-    return { kind: "result", resultIndex: i, rowNumber, agentName: useResultsDirectly ? r?.agent || `${fallbackLabel}-${rowNumber}` : d.chainAgents[i] || r?.agent || `${fallbackLabel}-${rowNumber}` };
-  });
+  const renderEntries = chainEntries ?? buildForegroundResultEntries(d, multiLabel, displayStart, displayEnd, useResultsDirectly);
   for (const entry of renderEntries) {
-    if (entry.kind === "placeholder") {
+    if (entry.kind === "group") {
       const glyph = widgetStepGlyph(entry.status, theme);
       const statusLabel = widgetStepStatus(entry.status, theme);
-      c.addChild(new Text(truncLine(`  ${glyph} ${entry.stepLabel}: ${themeBold(theme, entry.agentName)} ${theme.fg("dim", "·")} ${statusLabel}`, width), 0, 0));
+      const groupLabel = entry.groupLabel ? ` (${compactTaskText(undefined, entry.groupLabel) ?? entry.groupLabel})` : "";
+      c.addChild(new Text(truncLine(`${rowIndent}${glyph} ${entry.stepLabel}${groupLabel} ${theme.fg("dim", "·")} ${statusLabel}`, width), 0, 0));
       if (entry.error)
-        c.addChild(new Text(truncLine(theme.fg("error", `    ⎿  Error: ${entry.error}`), width), 0, 0));
+        c.addChild(new Text(truncLine(theme.fg("error", `${detailIndent}⎿  Error: ${entry.error}`), width), 0, 0));
       continue;
     }
     const i = entry.resultIndex;
@@ -1264,49 +2436,96 @@ function renderMultiCompact(d, theme, frame) {
     const rowNumber = entry.rowNumber;
     const agentName = entry.agentName;
     if (!r) {
-      const pendingLabel = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`;
-      c.addChild(new Text(truncLine(theme.fg("dim", `  ◦ ${pendingLabel}: ${agentName} · pending`), width), 0, 0));
+      const pendingLabel = entry.rowLabel ?? (entry.isParallel ? "" : `${itemTitle} ${rowNumber}`);
+      const labelPrefix = pendingLabel ? `${pendingLabel}: ` : "";
+      c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}◦ ${labelPrefix}${agentName} · pending`), width), 0, 0));
       continue;
     }
     const output = getSingleResultOutput(r);
-    const progressFromArray = d.progress?.find((p) => p.index === i) || d.progress?.find((p) => p.agent === r.agent && p.status === "running");
+    const progressFromArray = foregroundProgressForResult(d, i);
     const rProg = r.progress || progressFromArray || r.progressSummary;
-    const rRunning = rProg && "status" in rProg && rProg.status === "running";
+    const rRunning = rProg && "status" in rProg && isResultRunning(r, rProg.status);
     const rPending = rProg && "status" in rProg && rProg.status === "pending";
-    const stepNumber = r.progress?.index !== undefined ? r.progress.index + 1 : progressFromArray?.index !== undefined ? progressFromArray.index + 1 : i + 1;
     const stepStats = formatProgressStats(theme, rProg);
     const glyph = rPending ? theme.fg("dim", "◦") : resultGlyph(r, output, theme, rRunning, progressRunningSeed(rProg), frame);
     const pendingLabel = rPending ? ` ${theme.fg("dim", "· pending")}` : "";
-    const stepLabel = resultRowLabel(d, multiLabel, i, stepNumber);
-    const line = `${glyph} ${stepLabel}: ${themeBold(theme, agentName)}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${pendingLabel}`;
-    c.addChild(new Text(truncLine(`  ${line}`, width), 0, 0));
+    const stepLabel = entry.rowLabel;
+    const rowProgressModel = rProg && "status" in rProg ? rProg : undefined;
+    const rowModelDisplay = modelThinkingBadge(theme, r.model ?? rowProgressModel?.model, r.thinking ?? rowProgressModel?.thinking);
+    const labelPrefix = stepLabel ? `${stepLabel}: ` : "";
+    const line = `${glyph} ${labelPrefix}${themeBold(theme, agentName)}${contextModeBadge(theme, r.context)}${rowModelDisplay}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${pendingLabel}`;
+    c.addChild(new Text(truncLine(`${rowIndent}${line}`, width), 0, 0));
+    if (rRunning || rPending) {
+      const task = compactTaskText(r.task, workflowLabelForResult(d, i));
+      if (task)
+        c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}task: ${task}`), width), 0, 0));
+    }
     if (rRunning && rProg && "status" in rProg) {
-      const activity = compactCurrentActivity(rProg);
-      c.addChild(new Text(truncLine(theme.fg("dim", `    ⎿  ${activity}`), width), 0, 0));
-      c.addChild(new Text(truncLine(theme.fg("accent", `    ${liveDetailHintText()}`), width), 0, 0));
+      const liveProgress = rProg;
+      const activity = compactCurrentActivity(liveProgress);
+      c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}⎿  ${activity}`), width), 0, 0));
+      for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, snapshotNowForProgress(liveProgress))) {
+        c.addChild(new Text(truncLine(`${detailIndent}${nestedLine}`, width), 0, 0));
+      }
+      c.addChild(new Text(truncLine(theme.fg("accent", `${detailIndent}${liveDetailHintText()}`), width), 0, 0));
     } else if (!rPending && (r.exitCode !== 0 || r.interrupted || r.detached || hasEmptyTextOutputWithoutOutputTarget(r.task, output))) {
-      c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `    ⎿  ${resultStatusLine(r, output)}`), width), 0, 0));
+      c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `${detailIndent}⎿  ${resultStatusLine(r, output)}`), width), 0, 0));
+    }
+    if (!rRunning && !rPending) {
+      for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, r.progress?.lastActivityAt)) {
+        c.addChild(new Text(truncLine(`${detailIndent}${nestedLine}`, width), 0, 0));
+      }
     }
     const outputTarget = extractOutputTarget(r.task);
     if (outputTarget)
-      c.addChild(new Text(truncLine(theme.fg("dim", `    output: ${outputTarget}`), width), 0, 0));
+      c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}output: ${outputTarget}`), width), 0, 0));
     if (r.artifactPaths)
-      c.addChild(new Text(truncLine(theme.fg("dim", `    output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
+      c.addChild(new Text(truncLine(theme.fg("dim", `${detailIndent}output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
   }
   if (d.artifacts)
-    c.addChild(new Text(truncLine(theme.fg("dim", `  artifacts: ${shortenPath(d.artifacts.dir)}`), width), 0, 0));
+    c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}artifacts: ${shortenPath(d.artifacts.dir)}`), width), 0, 0));
   return c;
 }
-export function renderSubagentResult(result, options, theme, frame) {
+export function renderSubagentSummary(result, options, theme) {
+  const details = result.details;
+  const results = details?.results ?? [];
+  const hasSingleTerminalResult = results.length === 1 && hasTerminalResult(results[0]);
+  const hasOnlyTerminalResults = results.length > 0 && results.every(hasTerminalResult);
+  const running = !hasSingleTerminalResult && !hasOnlyTerminalResults && (options.isPartial === true || Boolean(details?.asyncId && details.mode !== "management") || Boolean(details && detailsHaveRunningResult(details)));
+  const stopped = results.some((entry) => entry.stopped) || Boolean(details && workflowGraphHasStatus(details, ["stopped"]));
+  const paused = results.some((entry) => entry.interrupted || entry.detached) || Boolean(details && workflowGraphHasStatus(details, ["paused", "detached"]));
+  const failed = result.isError === true || results.some((entry) => !hasTerminalResultFlag(entry) && entry.exitCode !== 0 && !isResultRunning(entry)) || Boolean(details && workflowGraphHasStatus(details, ["failed"]));
+  const partial = Boolean(details && workflowGraphHasStatus(details, ["partial"]));
+  const state = running ? "running" : failed ? "failed" : stopped ? "stopped" : paused ? "paused" : partial ? "partial" : "completed";
+  const glyph = state === "running" ? theme.fg("accent", STATIC_RUNNING_GLYPH) : state === "completed" ? theme.fg("success", "✓") : state === "failed" ? theme.fg("error", "✗") : theme.fg("warning", "■");
+  const label = details?.mode === "single" && results.length === 1 ? foregroundSingleDisplayName(results[0]) : details?.mode || "subagent";
+  return new Text(truncLine(`${glyph} ${theme.fg("toolTitle", theme.bold(label))} ${theme.fg("dim", "·")} ${theme.fg(state === "failed" ? "error" : state === "completed" ? "success" : state === "running" ? "accent" : "warning", state)}`, getTermWidth() - 4), 0, 0);
+}
+export function renderSubagentResult(result, options, theme, frame, rendererConfig, foregroundDetachShortcut) {
+  const layout = resolveMainWindowRenderLayout(rendererConfig);
+  const compact = (component) => capCompactMainWindowResult(component, layout, theme, !options.expanded);
   const d = result.details;
+  if (d?.mode === "workflow" && d.chatProgress?.mode === "live-card" && d.workflow?.value === undefined && (!result.isError || (d.workflow?.trace.length ?? 0) > 0)) {
+    return compact(renderWorkflowChatProgress(d, result, theme, options.expanded ? resolveMainWindowRenderLayout() : layout, frame, options.expanded));
+  }
   if (!d || !d.results.length) {
     const t = result.content[0];
     const text = t?.type === "text" ? t.text : "(no output)";
-    const contextPrefix = d?.context === "fork" ? `${theme.fg("warning", "[fork]")} ` : "";
+    const contextPrefix = contextModePrefix(theme, d?.context);
     const width = getTermWidth() - 4;
     if (!text.includes(`
 `))
-      return new Text(truncLine(`${contextPrefix}${text}`, width), 0, 0);
+      return compact(new Text(truncLine(`${contextPrefix}${text}`, width), 0, 0));
+    if (d && !options.expanded && !result.isError) {
+      const lines = text.split(/\r?\n/);
+      const firstNonEmptyLine = lines.find((line) => line.trim())?.trim() || "(no output)";
+      const compactLine = d.mode === "workflow" && d.preflight ? formatWorkflowPreflightPlanSummary(d.preflight) : firstNonEmptyLine;
+      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));
+      return compact(c);
+    }
     const c = new Container;
     const wrapped = wrapPlainText(`${contextPrefix}${text}`, width);
     for (const line of wrapped)
@@ -1317,25 +2536,34 @@ export function renderSubagentResult(result, options, theme, frame) {
   const mdTheme = getMarkdownTheme();
   if (d.mode === "single" && d.results.length === 1) {
     const r = d.results[0];
+    const detachableShortcut = d.asyncId || d.background ? undefined : foregroundDetachShortcut;
+    if (!r)
+      return compact(renderMultiCompact(d, theme, layout, frame));
     if (!expanded)
-      return renderSingleCompact(d, r, theme, frame);
-    const isRunning = r.progress?.status === "running";
-    const icon = isRunning ? theme.fg("warning", "running") : r.detached ? theme.fg("warning", "detached") : r.exitCode === 0 ? theme.fg("success", "ok") : theme.fg("error", "failed");
-    const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+      return compact(renderSingleCompact(d, r, theme, layout, frame, detachableShortcut));
+    const isRunning = isResultRunning(r);
+    const contextBadge = contextModeBadge(theme, r.context ?? d.context);
     const output = r.truncation?.text || getSingleResultOutput(r);
+    const presentation = styledResultPresentation(resultPresentation(r, output, isRunning, undefined, frame), theme);
     const progressInfo = isRunning && r.progress ? ` | ${r.progress.toolCount} tools, ${formatTokens(r.progress.tokens)} tok, ${formatDuration(r.progress.durationMs)}` : r.progressSummary ? ` | ${r.progressSummary.toolCount} tools, ${formatTokens(r.progressSummary.tokens)} tok, ${formatDuration(r.progressSummary.durationMs)}` : "";
     const w = getTermWidth() - 4;
     const fit = (text) => expanded ? text : truncLine(text, w);
     const toolCallLines = getToolCallLines(r, expanded);
     const c = new Container;
-    c.addChild(new Text(fit(`${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${contextBadge}${progressInfo}`), 0, 0));
+    c.addChild(new Text(fit(`${presentation.glyph} ${theme.fg("toolTitle", theme.bold(foregroundSingleDisplayName(r)))}${contextBadge}${progressInfo} ${theme.fg("dim", "·")} ${presentation.label}`), 0, 0));
     c.addChild(new Spacer(1));
     const taskMaxLen = Math.max(20, w - 8);
     const taskPreview = expanded || r.task.length <= taskMaxLen ? r.task : `${r.task.slice(0, taskMaxLen)}...`;
     c.addChild(new Text(fit(theme.fg("dim", `Task: ${taskPreview}`)), 0, 0));
     c.addChild(new Spacer(1));
+    if (!isRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped)) {
+      c.addChild(new Text(fit(theme.fg(r.exitCode !== 0 ? "error" : "dim", `  ⎿  ${resultStatusLine(r, output)}`)), 0, 0));
+    }
     if (isRunning && r.progress) {
       const progressSnapshotNow = snapshotNowForProgress(r.progress);
+      for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, progressSnapshotNow, 12)) {
+        c.addChild(new Text(fit(`  ${nestedLine}`), 0, 0));
+      }
       const toolLine = formatCurrentToolLine(r.progress, w, expanded, progressSnapshotNow);
       if (toolLine) {
         c.addChild(new Text(fit(theme.fg("warning", `> ${toolLine}`)), 0, 0));
@@ -1344,23 +2572,27 @@ export function renderSubagentResult(result, options, theme, frame) {
       if (liveStatusLine) {
         c.addChild(new Text(fit(theme.fg("accent", liveStatusLine)), 0, 0));
       }
-      c.addChild(new Text(fit(theme.fg("accent", liveDetailHintText())), 0, 0));
+      c.addChild(new Text(fit(theme.fg("accent", foregroundSingleHintText(detachableShortcut))), 0, 0));
       if (r.artifactPaths) {
         c.addChild(new Text(fit(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
       }
       if (r.progress.recentTools?.length) {
         for (const t of r.progress.recentTools.slice(-3)) {
           const maxArgsLen = Math.max(40, w - 24);
-          const argsPreview = expanded || t.args.length <= maxArgsLen ? t.args : `${t.args.slice(0, maxArgsLen)}...`;
+          const argsPreview = renderToolArgsPreview(t.args, maxArgsLen, expanded);
           c.addChild(new Text(fit(theme.fg("dim", `${t.tool}: ${argsPreview}`)), 0, 0));
         }
       }
-      for (const line of (r.progress.recentOutput ?? []).slice(-5)) {
+      for (const line of compactRecentOutputLines(r.progress.recentOutput)) {
         c.addChild(new Text(fit(theme.fg("dim", `  ${line}`)), 0, 0));
       }
       if (toolLine || liveStatusLine || r.progress.recentTools?.length || r.progress.recentOutput?.length || r.artifactPaths) {
         c.addChild(new Spacer(1));
       }
+    } else {
+      for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, r.progress?.lastActivityAt, 8)) {
+        c.addChild(new Text(fit(`  ${nestedLine}`), 0, 0));
+      }
     }
     if (expanded) {
       for (const line of toolCallLines) {
@@ -1392,13 +2624,24 @@ export function renderSubagentResult(result, options, theme, frame) {
     return c;
   }
   if (!expanded)
-    return renderMultiCompact(d, theme, frame);
-  const hasRunning = d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running") || workflowGraphHasStatus(d, ["running"]);
-  const ok = d.results.filter((r) => r.progress?.status === "completed" || r.exitCode === 0 && r.progress?.status !== "running").length;
-  const hasEmptyWithoutTarget = d.results.some((r) => r.exitCode === 0 && r.progress?.status !== "running" && hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r)));
-  const hasWorkflowFailure = workflowGraphHasStatus(d, ["failed"]);
-  const hasWorkflowPause = workflowGraphHasStatus(d, ["paused", "detached"]);
-  const icon = hasRunning ? theme.fg("warning", "running") : hasEmptyWithoutTarget ? theme.fg("warning", "warning") : hasWorkflowFailure ? theme.fg("error", "failed") : hasWorkflowPause ? theme.fg("warning", "paused") : ok === d.results.length ? theme.fg("success", "ok") : theme.fg("error", "failed");
+    return compact(renderMultiCompact(d, theme, layout, frame));
+  const hasRunning = detailsHaveRunningResult(d);
+  const detached = d.results.some((r) => r.detached) || workflowGraphHasStatus(d, ["detached"]);
+  const stopped = d.results.some((r) => r.stopped) || workflowGraphHasStatus(d, ["stopped"]);
+  const failed = d.results.some((r) => !hasTerminalResultFlag(r) && r.exitCode !== 0 && !isResultRunning(r)) || workflowGraphHasStatus(d, ["failed"]);
+  const paused = d.results.some((r) => r.interrupted) || workflowGraphHasStatus(d, ["paused"]);
+  const partial = workflowGraphHasStatus(d, ["partial"]);
+  const completedWithoutOutput = d.results.some((r) => !hasTerminalResultFlag(r) && r.exitCode === 0 && !isResultRunning(r) && hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r)));
+  const presentation = styledResultPresentation(semanticResultPresentation({
+    running: hasRunning,
+    detached,
+    stopped,
+    interrupted: paused,
+    failed,
+    partial,
+    completedWithoutOutput,
+    frame
+  }), theme);
   const totalSummary = d.progressSummary || d.results.reduce((acc, r) => {
     const prog = r.progress || r.progressSummary;
     if (prog) {
@@ -1414,22 +2657,21 @@ export function renderSubagentResult(result, options, theme, frame) {
   ].filter(Boolean);
   const summaryStr = summaryParts.length ? ` | ${summaryParts.join(", ")}` : "";
   const modeLabel = d.mode;
-  const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
+  const contextBadge = contextModeBadge(theme, d.context);
   const multiLabel = buildMultiProgressLabel(d, hasRunning);
   const itemTitle = multiLabel.itemTitle;
   const chainVis = d.chainAgents?.length && !multiLabel.hasParallelInChain ? d.chainAgents.map((agent, i) => {
     const result = d.results[i];
-    const isFailed = result && result.exitCode !== 0 && result.progress?.status !== "running";
-    const isComplete = result && result.exitCode === 0 && result.progress?.status !== "running";
-    const isEmptyWithoutTarget = Boolean(result) && Boolean(isComplete) && hasEmptyTextOutputWithoutOutputTarget(result.task, getSingleResultOutput(result));
+    const displayName = foregroundResultDisplayName(d, i, result, agent);
     const isCurrent = i === (d.currentStepIndex ?? d.results.length);
-    const stepIcon = isFailed ? theme.fg("error", "failed") : isEmptyWithoutTarget ? theme.fg("warning", "warning") : isComplete ? theme.fg("success", "done") : isCurrent && hasRunning ? theme.fg("warning", "running") : theme.fg("dim", "pending");
-    return `${stepIcon} ${agent}`;
+    const stepPresentation = result ? styledResultPresentation(resultPresentation(result, getSingleResultOutput(result), isCurrent && hasRunning && !hasTerminalResultFlag(result)), theme) : undefined;
+    const stepStatus = stepPresentation ? `${stepPresentation.glyph} ${stepPresentation.label}` : theme.fg("dim", "◦ pending");
+    return `${stepStatus} ${displayName}${contextModeBadge(theme, result?.context)}`;
   }).join(theme.fg("dim", " → ")) : null;
   const w = getTermWidth() - 4;
   const fit = (text) => expanded ? text : truncLine(text, w);
   const c = new Container;
-  c.addChild(new Text(fit(`${icon} ${theme.fg("toolTitle", theme.bold(modeLabel))}${contextBadge} · ${multiLabel.headerLabel}${summaryStr}`), 0, 0));
+  c.addChild(new Text(fit(`${presentation.glyph} ${theme.fg("toolTitle", theme.bold(modeLabel))}${contextBadge} · ${multiLabel.headerLabel}${summaryStr} ${theme.fg("dim", "·")} ${presentation.label}`), 0, 0));
   if (chainVis) {
     c.addChild(new Text(fit(`  ${chainVis}`), 0, 0));
   }
@@ -1437,17 +2679,13 @@ export function renderSubagentResult(result, options, theme, frame) {
   const displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0;
   const displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : useResultsDirectly ? d.results.length : d.chainAgents.length;
   const chainEntries = buildChainRenderEntries(d, multiLabel);
-  const renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset) => {
-    const i = displayStart + offset;
-    const r = d.results[i];
-    const rowNumber = multiLabel.showActiveGroupOnly ? i - multiLabel.groupStartIndex + 1 : i + 1;
-    return { kind: "result", resultIndex: i, rowNumber, agentName: useResultsDirectly ? r?.agent || `step-${rowNumber}` : d.chainAgents[i] || r?.agent || `step-${rowNumber}` };
-  });
+  const renderEntries = chainEntries ?? buildForegroundResultEntries(d, multiLabel, displayStart, displayEnd, useResultsDirectly);
   c.addChild(new Spacer(1));
   for (const entry of renderEntries) {
-    if (entry.kind === "placeholder") {
+    if (entry.kind === "group") {
       const statusLabel = widgetStepStatus(entry.status, theme);
-      c.addChild(new Text(fit(`  ${statusLabel} ${entry.stepLabel}: ${theme.bold(entry.agentName)}`), 0, 0));
+      const groupLabel = entry.groupLabel ? ` (${compactTaskText(undefined, entry.groupLabel) ?? entry.groupLabel})` : "";
+      c.addChild(new Text(fit(`  ${statusLabel} ${entry.stepLabel}${groupLabel}`), 0, 0));
       c.addChild(new Text(theme.fg(entry.status === "failed" ? "error" : "dim", `    status: ${entry.status}`), 0, 0));
       if (entry.error)
         c.addChild(new Text(theme.fg("error", `    error: ${entry.error}`), 0, 0));
@@ -1459,22 +2697,24 @@ export function renderSubagentResult(result, options, theme, frame) {
     const rowNumber = entry.rowNumber;
     const agentName = entry.agentName;
     if (!r) {
-      const pendingLabel = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`;
-      c.addChild(new Text(fit(theme.fg("dim", `  ${pendingLabel}: ${agentName}`)), 0, 0));
+      const pendingLabel = entry.rowLabel ?? (entry.isParallel ? "" : `${itemTitle} ${rowNumber}`);
+      const labelPrefix = pendingLabel ? `${pendingLabel}: ` : "";
+      c.addChild(new Text(fit(theme.fg("dim", `  ${labelPrefix}${agentName}`)), 0, 0));
       c.addChild(new Text(theme.fg("dim", `    status: pending`), 0, 0));
       c.addChild(new Spacer(1));
       continue;
     }
-    const progressFromArray = d.progress?.find((p) => p.index === i) || d.progress?.find((p) => p.agent === r.agent && p.status === "running");
+    const progressFromArray = foregroundProgressForResult(d, i);
     const rProg = r.progress || progressFromArray || r.progressSummary;
-    const rRunning = rProg?.status === "running";
-    const stepNumber = typeof rProg?.index === "number" ? rProg.index + 1 : i + 1;
+    const rRunning = isResultRunning(r, rProg?.status);
     const resultOutput = getSingleResultOutput(r);
-    const statusIcon = rRunning ? theme.fg("warning", "running") : r.exitCode !== 0 ? theme.fg("error", "failed") : hasEmptyTextOutputWithoutOutputTarget(r.task, resultOutput) ? theme.fg("warning", "warning") : theme.fg("success", "done");
+    const rowPresentation = styledResultPresentation(resultPresentation(r, resultOutput, rRunning, progressRunningSeed(rProg), frame), theme);
     const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(rProg.durationMs)}` : "";
-    const modelDisplay = modelThinkingBadge(theme, r.model);
-    const stepLabel = resultRowLabel(d, multiLabel, i, stepNumber);
-    const stepHeader = rRunning ? `${statusIcon} ${stepLabel}: ${theme.bold(theme.fg("warning", r.agent))}${modelDisplay}${stats}` : `${statusIcon} ${stepLabel}: ${theme.bold(r.agent)}${modelDisplay}${stats}`;
+    const modelDisplay = modelThinkingBadge(theme, r.model ?? rProg?.model, r.thinking ?? rProg?.thinking);
+    const stepLabel = entry.rowLabel;
+    const contextBadge = contextModeBadge(theme, r.context);
+    const labelPrefix = stepLabel ? `${stepLabel}: ` : "";
+    const stepHeader = rRunning ? `${rowPresentation.glyph} ${labelPrefix}${theme.bold(theme.fg("warning", agentName))}${contextBadge}${modelDisplay}${stats} ${theme.fg("dim", "·")} ${rowPresentation.label}` : `${rowPresentation.glyph} ${labelPrefix}${theme.bold(agentName)}${contextBadge}${modelDisplay}${stats} ${theme.fg("dim", "·")} ${rowPresentation.label}`;
     const toolCallLines = getToolCallLines(r, expanded);
     c.addChild(new Text(fit(stepHeader), 0, 0));
     const taskMaxLen = Math.max(20, w - 12);
@@ -1484,6 +2724,9 @@ export function renderSubagentResult(result, options, theme, frame) {
     if (outputTarget) {
       c.addChild(new Text(fit(theme.fg("dim", `    output: ${outputTarget}`)), 0, 0));
     }
+    if (!rRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped)) {
+      c.addChild(new Text(fit(theme.fg(r.exitCode !== 0 ? "error" : "dim", `    ⎿  ${resultStatusLine(r, resultOutput)}`)), 0, 0));
+    }
     if (r.skills?.length) {
       c.addChild(new Text(fit(theme.fg("dim", `    skills: ${r.skills.join(", ")}`)), 0, 0));
     }
@@ -1506,6 +2749,9 @@ export function renderSubagentResult(result, options, theme, frame) {
       if (liveStatusLine) {
         c.addChild(new Text(fit(theme.fg("accent", `    ${liveStatusLine}`)), 0, 0));
       }
+      for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, progressSnapshotNow, 8)) {
+        c.addChild(new Text(fit(`    ${nestedLine}`), 0, 0));
+      }
       c.addChild(new Text(fit(theme.fg("accent", `    ${liveDetailHintText()}`)), 0, 0));
       if (r.artifactPaths) {
         c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
@@ -1513,15 +2759,19 @@ export function renderSubagentResult(result, options, theme, frame) {
       if (rProg.recentTools?.length) {
         for (const t of rProg.recentTools.slice(-3)) {
           const maxArgsLen = Math.max(40, w - 30);
-          const argsPreview = expanded || t.args.length <= maxArgsLen ? t.args : `${t.args.slice(0, maxArgsLen)}...`;
+          const argsPreview = renderToolArgsPreview(t.args, maxArgsLen, expanded);
           c.addChild(new Text(fit(theme.fg("dim", `      ${t.tool}: ${argsPreview}`)), 0, 0));
         }
       }
-      const recentLines = (rProg.recentOutput ?? []).slice(-5);
-      for (const line of recentLines) {
+      for (const line of compactRecentOutputLines(rProg.recentOutput)) {
         c.addChild(new Text(fit(theme.fg("dim", `      ${line}`)), 0, 0));
       }
     }
+    if (!rRunning) {
+      for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, r.progress?.lastActivityAt, 8)) {
+        c.addChild(new Text(fit(`    ${nestedLine}`), 0, 0));
+      }
+    }
     if (!rRunning && r.artifactPaths) {
       c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
     }