@ashx-j/lunr 0.2.20 → 0.2.22

package/dist/node-runtime/{pi-subagents-T5WMMLBB.js → pi-subagents-FEUDLJOE.js}

@@ -6,7 +6,6 @@ import {
   ASYNC_DIR,
   DEFAULT_ARTIFACT_CONFIG,
   INTERCOM_DETACH_REQUEST_EVENT,
-  MAX_WIDGET_JOBS,
   POLL_INTERVAL_MS,
   RESULTS_DIR,
   SLASH_RESULT_TYPE,
@@ -17,6 +16,7 @@ import {
   SLASH_SUBAGENT_UPDATE_EVENT,
   SLASH_TEXT_RESULT_TYPE,
   SUBAGENT_ASYNC_COMPLETE_EVENT,
+  SUBAGENT_ASYNC_GUIDANCE,
   SUBAGENT_ASYNC_STARTED_EVENT,
   SUBAGENT_CHILD_ENV,
   SUBAGENT_CONTROL_EVENT,
@@ -27,12 +27,14 @@ import {
   SUBAGENT_PARENT_SESSION_ENV,
   SUBAGENT_RESULT_INTERCOM_EVENT,
   SUBAGENT_STEERING_NOTICE_EVENT,
+  SUPERVISOR_PROGRESS_TYPE,
+  SUPERVISOR_REQUEST_TYPE,
   TEMP_ROOT_DIR,
   WIDGET_KEY,
-  aggregateStepStatus,
   assertJsonSchemaObject,
   attachNestedChildrenToResultChildren,
   buildSubagentResultIntercomPayload,
+  childRowLabel,
   cleanupAllArtifactDirs,
   cleanupOldArtifacts,
   cleanupOldChainDirs,
@@ -45,11 +47,10 @@ import {
   formatAsyncRunProgressLabel,
   formatAsyncRunTranscript,
   formatCompactModelBadge,
-  formatControlNoticeMessage,
   formatDuration,
   formatModelSelection,
   formatNestedAggregate,
-  formatParallelOutcome,
+  formatNestedResultLines,
   formatTokens,
   formatToolCall,
   formatUsage,
@@ -60,9 +61,13 @@ import {
   getSingleResultOutput,
   handleSubagentControlNotice,
   hasLiveNestedDescendants,
+  isAsyncSubagentExecution,
+  legacySupervisorBody,
   listAsyncRuns,
+  normalizeAsyncLaunchConfig,
   normalizeParallelGroups,
   projectNestedRegistryForRoot,
+  readCommunication,
   readStatus,
   readSteerCapability,
   reconcileAsyncRun,
@@ -70,7 +75,9 @@ import {
   registerMainWatchdog,
   requestAsyncSteer,
   resolveAsyncRunLocation,
+  resolveCommunicationPeer,
   resolveCurrentSessionId,
+  resolveSubagentRequestParams,
   resolveSubagentResultStatus,
   resolveSubagentRunId,
   resolveTurnBudgetConfig,
@@ -79,33 +86,44 @@ import {
   sanitizeChildDescription,
   sanitizeSummary,
   shortenPath,
+  stopRequestPath,
+  subagentLaunchRunsAsync,
   summarizeAsyncStatus,
   updateAsyncJobNestedProjection,
   validateAcceptanceInput,
   validateExecutionAcceptance,
   validateToolBudgetConfig,
   writeAtomicJson
-} from "./chunk-46ECNOLF.js";
+} from "./chunk-QDGKKKUM.js";
+import {
+  formatControlNoticeMessage
+} from "./chunk-OAR4TYZE.js";
+import {
+  getSubagentSpinnerDefinition
+} from "./chunk-US544NN6.js";
+import "./chunk-5ZH3ZFIZ.js";
+import "./chunk-CSUZVNYE.js";
+import "./chunk-VSSXXL36.js";
+import "./chunk-53YJI7JU.js";
+import "./chunk-5ZQXRPMC.js";
+import "./chunk-AD6VXAO7.js";
+import "./chunk-LISUTZS3.js";
 import {
   createSubagentCancellation,
   registerSubagentCancellation
 } from "./chunk-BBUVIEZB.js";
-import "./chunk-25I2BHAA.js";
-import "./chunk-WKDK4C5P.js";
-import "./chunk-53YJI7JU.js";
-import "./chunk-KBKMCJDU.js";
+import "./chunk-5D7LC2ZQ.js";
+import "./chunk-M3LZLQW2.js";
+import "./chunk-KKUTQQV7.js";
 import "./chunk-CSFI6YXL.js";
 import "./chunk-FVDOXRUD.js";
-import "./chunk-AD6VXAO7.js";
-import "./chunk-6N22HULO.js";
-import "./chunk-M3LZLQW2.js";
 import "./chunk-RQ2Q5IYR.js";
 import {
   keyText
-} from "./chunk-DDWHZ633.js";
+} from "./chunk-GNN7H3B7.js";
 import {
   getMarkdownTheme
-} from "./chunk-RNBHABBA.js";
+} from "./chunk-7QWNYZDI.js";
 import "./chunk-FQMM2EZ2.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
@@ -115,7 +133,7 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import * as fs10 from "node:fs";
 import * as os from "node:os";
 import * as path12 from "node:path";
-import { Box, Container as Container2, Spacer as Spacer2, Text as Text2, truncateToWidth as truncateToWidth2, visibleWidth as visibleWidth3, wrapTextWithAnsi as wrapTextWithAnsi2 } from "@ashx-j/lunr-tui";
+import { Box as Box2, Container as Container3, Spacer as Spacer2, Text as Text3, truncateToWidth as truncateToWidth2, visibleWidth as visibleWidth3, wrapTextWithAnsi as wrapTextWithAnsi2 } from "@ashx-j/lunr-tui";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/tui/render.js
 import { Container, Markdown, Spacer, Text, visibleWidth } from "@ashx-j/lunr-tui";
@@ -177,7 +195,11 @@ function wrapPlainText(text, maxWidth) {
   }
   return lines;
 }
-var RUNNING_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"], STATIC_RUNNING_GLYPH = "\u25CF";
+var STATIC_RUNNING_GLYPH = "\u25CF", SUBAGENT_PAINT_INTERVAL_MS = 80;
+function selectedSubagentSpinner() {
+  let bridge = globalThis[/* @__PURE__ */ Symbol.for("@lunr/customize")];
+  return getSubagentSpinnerDefinition(bridge?.getSubagentSpinner?.() ?? "braille");
+}
 function runningSeed(...values) {
   let seed;
   for (let value of values)
@@ -185,7 +207,14 @@ function runningSeed(...values) {
   return seed;
 }
 function runningGlyph(seed) {
-  return seed === void 0 ? STATIC_RUNNING_GLYPH : RUNNING_FRAMES[Math.abs(seed) % RUNNING_FRAMES.length];
+  if (seed === void 0)
+    return STATIC_RUNNING_GLYPH;
+  let frames = selectedSubagentSpinner().frames;
+  return frames[Math.abs(seed) % frames.length];
+}
+function foregroundSpinnerFrame(timerFrame) {
+  let { interval } = selectedSubagentSpinner();
+  return Math.floor(Math.max(0, timerFrame) * SUBAGENT_PAINT_INTERVAL_MS / interval);
 }
 function progressRunningSeed(progress) {
   if (progress)
@@ -315,7 +344,8 @@ function formatCompactSubagentRow(theme, width, parts) {
   let stats = formatCompactRowStats(parts.tokens, parts.durationMs), body = [
     `${parts.prefix ?? ""}${parts.glyph} ${themeBold(theme, parts.description)}`,
     parts.modelBadge ? theme.fg("dim", parts.modelBadge) : "",
-    theme.fg("dim", stats)
+    theme.fg("dim", stats),
+    parts.terminalStatus ? theme.fg("dim", parts.terminalStatus) : ""
   ].filter(Boolean).join(` ${theme.fg("dim", "\xB7")} `);
   return truncLine(body, width);
 }
@@ -353,6 +383,12 @@ function formatWidgetAgents(agents) {
 function widgetJobName(job) {
   return job.mode === "parallel" ? "parallel" : job.mode === "chain" ? "chain" : job.mode === "single" && job.agents?.length === 1 ? job.agents[0] : job.agents?.length ? formatWidgetAgents(job.agents) : job.mode ?? "subagent";
 }
+function widgetActivity(job, now = Date.now()) {
+  let facts = [], snapshotNow = job.status === "running" ? now : job.updatedAt;
+  job.currentTool && job.currentToolStartedAt !== void 0 && snapshotNow !== void 0 ? facts.push(`${job.currentTool} ${formatDuration(Math.max(0, snapshotNow - job.currentToolStartedAt))}`) : job.currentTool && facts.push(job.currentTool), job.currentPath && facts.push(shortenPath(job.currentPath)), job.turnCount !== void 0 && facts.push(`${job.turnCount} turns`), job.toolCount !== void 0 && facts.push(`${job.toolCount} tools`);
+  let activity = buildLiveStatusLine(job, snapshotNow);
+  return activity && facts.length ? `${activity} \xB7 ${facts.join(" \xB7 ")}` : activity || (facts.length ? facts.join(" \xB7 ") : job.status === "running" ? "thinking\u2026" : job.status === "queued" ? "queued\u2026" : job.status === "paused" ? "Paused" : job.status === "stopped" ? "Stopped" : job.status === "failed" ? "Failed" : "Done");
+}
 function widgetStepRunningSeed(step, fallbackIndex) {
   return runningSeed(fallbackIndex, step.index);
 }
@@ -365,14 +401,9 @@ function widgetStepsRunningSeed(steps) {
 function widgetJobRunningSeed(job) {
   return runningSeed(job.currentStep, job.runningSteps, widgetStepsRunningSeed(job.steps));
 }
-function widgetJobsRunningSeed(jobs) {
-  let seed;
-  for (let job of jobs)
-    seed = runningSeed(seed, widgetJobRunningSeed(job));
-  return seed;
-}
 function widgetAnimFrame(now = Date.now()) {
-  return Math.floor(now / 80) % RUNNING_FRAMES.length;
+  let definition = selectedSubagentSpinner();
+  return Math.floor(now / definition.interval) % definition.frames.length;
 }
 function widgetStatusGlyph(job, theme, now = Date.now()) {
   return job.status === "running" ? theme.fg("accent", runningGlyph((widgetJobRunningSeed(job) ?? 0) + widgetAnimFrame(now))) : job.status === "queued" ? theme.fg("muted", "\u25E6") : job.status === "complete" ? theme.fg("success", "\u2713") : job.status === "paused" || job.status === "stopped" ? theme.fg("warning", "\u25A0") : theme.fg("error", "\u2717");
@@ -383,48 +414,6 @@ function widgetStepGlyph(status, theme, seed) {
 function widgetStepStatus(status, theme) {
   return status === "running" ? theme.fg("accent", "running") : status === "complete" || status === "completed" ? theme.fg("success", "complete") : status === "failed" ? theme.fg("error", "failed") : status === "paused" ? theme.fg("warning", "paused") : status === "stopped" ? theme.fg("warning", "stopped") : theme.fg("dim", status);
 }
-function widgetStepActivity(step, snapshotNow) {
-  let facts = [];
-  step.currentTool && step.currentToolStartedAt !== void 0 && snapshotNow !== void 0 ? facts.push(`${step.currentTool} ${formatDuration(Math.max(0, snapshotNow - step.currentToolStartedAt))}`) : step.currentTool && facts.push(step.currentTool), step.currentPath && facts.push(shortenPath(step.currentPath)), step.turnCount !== void 0 && facts.push(`${step.turnCount} turns`), step.toolCount !== void 0 && facts.push(`${step.toolCount} tools`), step.tokens?.total && facts.push(formatTokenStat(step.tokens.total));
-  let activity = buildLiveStatusLine(step, snapshotNow);
-  return activity && facts.length ? `${activity} \xB7 ${facts.join(" \xB7 ")}` : activity || facts.join(" \xB7 ");
-}
-function widgetChainDetails(job, theme, expanded = !1, width = getTermWidth()) {
-  if (!job.steps?.length)
-    return [];
-  let total = job.chainStepCount ?? job.steps.length, lines = [];
-  for (let span of buildAsyncChainStepSpans(total, job.steps.length, job.parallelGroups)) {
-    let steps = job.steps.slice(span.start, span.start + span.count);
-    if (span.isParallel) {
-      let status = aggregateStepStatus(steps);
-      lines.push(`  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(steps))} Step ${span.stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "\xB7")} ${theme.fg("dim", formatParallelOutcome(steps, span.count))}`);
-      continue;
-    }
-    let step = steps[0];
-    if (!step) {
-      lines.push(`  ${theme.fg("dim", `\u25E6 Step ${span.stepIndex + 1}/${total}: pending`)}`);
-      continue;
-    }
-    lines.push(...foregroundStyleWidgetStepLines(job, theme, step, "Step", span.stepIndex + 1, total, expanded, width));
-  }
-  return lines;
-}
-function widgetParallelAgentDetails(job, theme, expanded = !1, width = getTermWidth()) {
-  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);
-  let total = job.stepsTotal ?? job.steps.length, lines = [];
-  for (let [index, step] of job.steps.entries()) {
-    let marker = index === job.steps.length - 1 ? "\u2514" : "\u251C", activity = widgetStepActivity(step, job.updatedAt), itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step", modelDisplay = modelThinkingBadge(theme, step.model, step.thinking, step.modelSelection);
-    lines.push(`  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index))} ${itemTitle} ${index + 1}/${total}: ${step.agent} \xB7 ${widgetStepStatus(step.status, theme)}${modelDisplay}${activity ? ` \xB7 ${activity}` : ""}`)}`);
-    for (let nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, expanded ? 8 : 1))
-      lines.push(`    ${nestedLine}`);
-  }
-  return lines;
-}
 function parseParallelGroupAgentCount(label) {
   if (!label || !label.startsWith("[") || !label.endsWith("]"))
     return;
@@ -460,24 +449,16 @@ function buildChainStepSpans(details) {
 function isChainParallelGroupActive(details) {
   return details.mode !== "chain" || details.currentStepIndex === void 0 ? !1 : buildChainStepSpans(details).some((span) => span.stepIndex === details.currentStepIndex && span.isParallel);
 }
-function buildAsyncChainStepSpans(total, stepCount, parallelGroups = []) {
-  let spans = [], flatIndex = 0;
-  for (let stepIndex = 0; stepIndex < total; stepIndex++) {
-    let group = parallelGroups.find((candidate) => candidate.stepIndex === stepIndex);
-    if (group) {
-      spans.push({ stepIndex, start: group.start, count: group.count, isParallel: !0 }), flatIndex = Math.max(flatIndex, group.start + group.count);
-      continue;
-    }
-    spans.push({ stepIndex, start: flatIndex, count: flatIndex < stepCount ? 1 : 0, isParallel: !1 }), flatIndex++;
-  }
-  return spans;
-}
 function isDoneResult(result2) {
   let status = result2.progress?.status;
   return status === "completed" ? !0 : status === "running" || status === "pending" || result2.interrupted || result2.detached ? !1 : result2.exitCode === 0;
 }
 function workflowGraphHasStatus(details, statuses) {
-  return details.workflowGraph?.nodes.some((node) => statuses.includes(node.status)) ?? !1;
+  let matches = (nodes) => nodes.some((node) => statuses.includes(node.status) || matches(node.children ?? []));
+  return matches(details.workflowGraph?.nodes ?? []);
+}
+function resultAtFlatIndex(details, flatIndex) {
+  return details.results.find((result2, arrayIndex) => (result2.progress?.index ?? result2.progressSummary?.index ?? arrayIndex) === flatIndex);
 }
 function buildChainRenderEntries(details, label) {
   if (details.mode !== "chain" || !label.hasParallelInChain || label.showActiveGroupOnly)
@@ -495,13 +476,17 @@ function buildChainRenderEntries(details, label) {
       });
       continue;
     }
-    for (let index = span.start; index < span.start + span.count; index++)
+    for (let index = span.start; index < span.start + span.count; index++) {
+      let workflowStep = details.workflowGraph?.nodes.find((node) => node.stepIndex === span.stepIndex), workflowNode = workflowStep?.children?.find((node) => node.flatIndex === index) ?? (workflowStep?.flatIndex === index ? workflowStep : void 0), result2 = resultAtFlatIndex(details, index);
       entries.push({
         kind: "result",
         resultIndex: index,
         rowNumber: index + 1,
-        agentName: details.results[index]?.agent ?? details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`
+        agentName: result2?.agent ?? workflowNode?.label ?? details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`,
+        status: workflowNode?.status ?? span.status,
+        error: workflowNode?.error ?? span.error
       });
+    }
   }
   return entries;
 }
@@ -566,15 +551,6 @@ function resultRowLabel(details, label, resultIndex, stepNumber) {
   }
   return label.itemTitle === "Agent" ? `Agent ${label.activeParallelGroup ? Math.max(1, stepNumber - label.groupStartIndex) : stepNumber}/${label.totalCount}` : `Step ${stepNumber}`;
 }
-function widgetStepStats(theme, step, now = Date.now()) {
-  let running = step.status === "running", durationMs = step.durationMs !== void 0 ? step.durationMs + (running && step.lastActivityAt !== void 0 ? Math.max(0, now - step.lastActivityAt) : 0) : step.startedAt !== void 0 ? Math.max(0, (running ? now : step.endedAt ?? step.lastActivityAt ?? now) - step.startedAt) : void 0;
-  return statJoin(theme, [
-    step.turnCount !== void 0 ? `${step.turnCount} turns` : "",
-    step.toolCount !== void 0 ? formatToolUseStat(step.toolCount) : "",
-    step.tokens?.total ? formatTokenStat(step.tokens.total) : "",
-    durationMs !== void 0 ? `${running ? "" : "ran for "}${formatDuration(durationMs)}` : ""
-  ]);
-}
 function modelThinkingBadge(theme, model, thinking, selection) {
   let label = formatModelSelection(selection, model, thinking);
   return label ? theme.fg("dim", ` (${label})`) : "";
@@ -639,22 +615,15 @@ function formatNestedWidgetLines(children, theme, width, expanded, snapshotNow,
   };
   return append(children, 0, ""), lines.map((line) => truncLine(line, width));
 }
-function foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index, total, expanded, width) {
-  let status = widgetStepStatus(step.status, theme), stats = widgetStepStats(theme, step), modelDisplay = modelThinkingBadge(theme, step.model, step.thinking, step.modelSelection), lines = [`  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index - 1))} ${itemTitle} ${index}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "\xB7")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "\xB7")} ${stats}` : ""}`], activity = widgetStepActivityLine(step, width, expanded, job.updatedAt);
-  activity && lines.push(`    ${theme.fg("dim", `\u23BF  ${activity}`)}`);
-  for (let nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt))
-    lines.push(`    ${nestedLine}`);
-  if (step.status === "running" && (expanded || lines.push(`    ${theme.fg("accent", liveDetailHintText())}`), expanded)) {
-    let liveStatus = buildLiveStatusLine(step, job.updatedAt);
-    liveStatus && liveStatus !== activity && lines.push(`    ${theme.fg("accent", liveStatus)}`);
-    for (let tool of step.recentTools?.slice(-3) ?? []) {
-      let maxArgsLen = Math.max(40, width - 30), argsPreview = tool.args.length <= maxArgsLen ? tool.args : `${tool.args.slice(0, maxArgsLen)}...`;
-      lines.push(`      ${theme.fg("dim", `${tool.tool}${argsPreview ? `: ${argsPreview}` : ""}`)}`);
-    }
-    for (let line of step.recentOutput?.slice(-5) ?? [])
-      lines.push(`      ${theme.fg("dim", line)}`);
-  }
-  return lines;
+function compactTerminalStatus(status) {
+  if (status === "failed")
+    return "failed";
+  if (status === "paused")
+    return "paused";
+  if (status === "stopped")
+    return "stopped";
+  if (status === "detached")
+    return "detached";
 }
 function compactJobProgress(job, step, now = Date.now()) {
   let running = (step?.status ?? job.status) === "running", tokens = step?.tokens?.total ?? job.totalTokens?.total ?? 0;
@@ -675,14 +644,6 @@ function compactJobLead(job, step) {
     task: step?.description ?? step?.agent
   }) || widgetJobName(job);
 }
-function activeJobStep(job) {
-  let steps = job.steps ?? [];
-  return steps.find((step) => step.status === "running") ?? steps.find((step) => step.status === "pending" || step.status === "queued") ?? steps[steps.length - 1];
-}
-function compactJobChildRows(job, theme, width, now = Date.now()) {
-  let steps = job.steps ?? [];
-  return steps.length <= 1 ? compactJobLines(job, steps[0], theme, width, now) : steps.flatMap((step) => compactJobLines(job, step, theme, width, now));
-}
 function compactJobLines(job, step, theme, width, now = Date.now()) {
   let running = (step?.status ?? job.status) === "running", lead = compactJobLead(job, step), modelBadge = formatCompactModelBadge(step?.modelSelection, step?.model), glyph = step ? widgetStepGlyph(step.status, theme, running ? (widgetStepRunningSeed(step, step.index) ?? 0) + widgetAnimFrame(now) : widgetStepRunningSeed(step, step.index)) : widgetStatusGlyph(job, theme, now), progress = compactJobProgress(job, step, now);
   return [formatCompactSubagentRow(theme, width, {
@@ -690,16 +651,10 @@ function compactJobLines(job, step, theme, width, now = Date.now()) {
     description: lead,
     modelBadge,
     tokens: progress.tokens,
-    durationMs: progress.durationMs
+    durationMs: progress.durationMs,
+    terminalStatus: compactTerminalStatus(step?.status ?? job.status)
   })];
 }
-function buildSingleWidgetLines(job, theme, width, _expanded, now = Date.now()) {
-  let steps = job.steps ?? [];
-  return steps.length <= 1 ? compactJobLines(job, steps[0], theme, width, now) : steps.flatMap((step) => compactJobLines(job, step, theme, width, now));
-}
-function compactSingleWidgetLines(job, theme, width, now = Date.now()) {
-  return buildSingleWidgetLines(job, theme, width, !1, now);
-}
 var RESERVED_NON_WIDGET_ROWS = 19, widgetLayoutSession;
 function resetWidgetLayoutSession() {
   widgetLayoutSession = void 0;
@@ -717,20 +672,6 @@ function currentTerminalColumns() {
 function widgetSessionMatches(expanded) {
   return widgetLayoutSession?.expanded === expanded && widgetLayoutSession.rows === currentTerminalRows() && widgetLayoutSession.columns === currentTerminalColumns();
 }
-function widgetHeaderCounts(jobs) {
-  return {
-    running: jobs.filter((job) => job.status === "running"),
-    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"),
-    stopped: jobs.filter((job) => job.status === "stopped")
-  };
-}
-function buildSingleLineWidgetLines(jobs, theme, width) {
-  let counts = widgetHeaderCounts(jobs), hasActive = counts.running.length > 0 || counts.queued.length > 0, glyph = counts.running.length > 0 ? runningGlyph((widgetJobsRunningSeed(counts.running) ?? 0) + widgetAnimFrame()) : hasActive ? "\u25CF" : "\u25CB", parts = [];
-  return counts.running.length > 0 && parts.push(`${counts.running.length}/${jobs.length} running`), counts.queued.length > 0 && parts.push(`${counts.queued.length} queued`), counts.failed.length > 0 && parts.push(`${counts.failed.length} failed`), counts.stopped.length > 0 && parts.push(`${counts.stopped.length} stopped`), counts.paused.length > 0 && parts.push(`${counts.paused.length} paused`), !hasActive && counts.complete.length > 0 && parts.push(`${counts.complete.length}/${jobs.length} done`), [truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "subagents")} (${parts.join(", ") || `${jobs.length} total`})`, width)];
-}
 function orderedWidgetJobs(jobs) {
   return [
     ...jobs.filter((job) => job.status === "running"),
@@ -738,68 +679,6 @@ function orderedWidgetJobs(jobs) {
     ...jobs.filter((job) => job.status !== "running" && job.status !== "queued")
   ];
 }
-function progressiveJobKey(job) {
-  return job.asyncId;
-}
-function isProgressiveActiveJob(job) {
-  return job?.status === "running" || job?.status === "queued";
-}
-function selectProgressiveJobKeys(jobs, previousKeys, bodyRows) {
-  if (bodyRows <= 0)
-    return [];
-  let jobsByKey = new Map(jobs.map((job) => [progressiveJobKey(job), job])), selected = [], append = (key) => {
-    selected.includes(key) || !jobsByKey.has(key) || selected.push(key);
-  };
-  for (let key of previousKeys)
-    if (isProgressiveActiveJob(jobsByKey.get(key)) && (append(key), selected.length >= bodyRows))
-      return selected;
-  for (let job of orderedWidgetJobs(jobs)) {
-    if (!isProgressiveActiveJob(job))
-      continue;
-    let key = progressiveJobKey(job);
-    if (append(key), selected.length >= bodyRows)
-      break;
-  }
-  if (selected.length >= bodyRows)
-    return selected;
-  for (let key of previousKeys)
-    if (!isProgressiveActiveJob(jobsByKey.get(key)) && (append(key), selected.length >= bodyRows))
-      return selected;
-  for (let job of orderedWidgetJobs(jobs)) {
-    let key = progressiveJobKey(job);
-    if (append(key), selected.length >= bodyRows)
-      break;
-  }
-  return selected;
-}
-function progressiveHeaderLine(jobs, theme, width) {
-  let counts = widgetHeaderCounts(jobs), hasActive = counts.running.length > 0 || counts.queued.length > 0, glyph = counts.running.length > 0 ? runningGlyph((widgetJobsRunningSeed(counts.running) ?? 0) + widgetAnimFrame()) : hasActive ? "\u25CF" : "\u25CB", parts = [];
-  return counts.running.length > 0 && parts.push(formatAgentRunningLabel(counts.running.length)), counts.queued.length > 0 && parts.push(`${counts.queued.length} queued`), hasActive || (counts.failed.length > 0 && parts.push(`${counts.failed.length} failed`), counts.stopped.length > 0 && parts.push(`${counts.stopped.length} stopped`), counts.paused.length > 0 && parts.push(`${counts.paused.length} paused`), counts.complete.length > 0 && parts.push(`${counts.complete.length}/${jobs.length} done`)), truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "\xB7")} ${theme.fg("dim", parts.join(", ") || `${jobs.length} total`)}`, width);
-}
-function progressiveJobLine(job, theme, width, now = Date.now()) {
-  let row = compactJobLines(job, activeJobStep(job), theme, Math.max(1, width - 2), now)[0] ?? "";
-  return row ? `  ${row}` : "";
-}
-function progressiveHiddenLine(hiddenJobs, theme, width) {
-  let counts = widgetHeaderCounts(hiddenJobs), parts = [];
-  counts.running.length > 0 && parts.push(`${counts.running.length} running`), counts.queued.length > 0 && parts.push(`${counts.queued.length} queued`);
-  let finished = counts.complete.length + counts.failed.length + counts.paused.length + counts.stopped.length;
-  return finished > 0 && parts.push(`${finished} finished`), truncLine(theme.fg("dim", `  +${hiddenJobs.length} more${parts.length ? ` (${parts.join(", ")})` : ""}`), width);
-}
-function buildProgressiveWidgetLines(jobs, theme, width, lockedRows, previousKeys) {
-  let rowCount = Math.max(1, lockedRows);
-  if (rowCount === 1)
-    return { lines: buildSingleLineWidgetLines(jobs, theme, width), visibleJobKeys: [] };
-  let bodyRows = rowCount - 1, visibleJobKeys = selectProgressiveJobKeys(jobs, previousKeys, bodyRows), jobsByKey = new Map(jobs.map((job) => [progressiveJobKey(job), job])), visibleJobs = visibleJobKeys.map((key) => jobsByKey.get(key)).filter((job) => !!job), hiddenJobs = jobs.filter((job) => !visibleJobKeys.includes(progressiveJobKey(job)));
-  hiddenJobs.length > 0 && visibleJobs.length >= bodyRows && bodyRows > 0 && (visibleJobs = visibleJobs.slice(0, bodyRows - 1), visibleJobKeys = visibleJobs.map(progressiveJobKey), hiddenJobs = jobs.filter((job) => !visibleJobKeys.includes(progressiveJobKey(job))));
-  let lines = [
-    progressiveHeaderLine(jobs, theme, width),
-    ...visibleJobs.map((job) => progressiveJobLine(job, theme, width))
-  ];
-  for (hiddenJobs.length > 0 && lines.length < rowCount && lines.push(progressiveHiddenLine(hiddenJobs, theme, width)); lines.length < rowCount; )
-    lines.push(" ");
-  return { lines: lines.slice(0, rowCount), visibleJobKeys };
-}
 function collapsedWidgetLineBudget(rows) {
   return Math.max(10, Math.min(14, Math.floor(rows * 0.35)));
 }
@@ -810,58 +689,41 @@ function fitWidgetLineBudget(lines, theme, width, expanded) {
   let visibleLines = Math.max(1, budget - 1), hiddenCount = lines.length - visibleLines, hint = expanded ? `\u2026 ${hiddenCount} live-detail lines hidden` : `\u2026 ${hiddenCount} lines hidden \xB7 ${liveDetailKeyText()} expands`;
   return [...lines.slice(0, visibleLines), truncLine(theme.fg("dim", hint), width)];
 }
-function fitAdaptiveWidgetLines(jobs, lines, theme, width, expanded) {
+function fitAdaptiveWidgetLines(_jobs, lines, theme, width, expanded) {
   if (expanded)
     return resetWidgetLayoutSession(), fitWidgetLineBudget(lines, theme, width, !0);
-  let hasMatchingSession = widgetSessionMatches(expanded), rows = currentTerminalRows(), columns = currentTerminalColumns(), availableRows = estimateAvailableWidgetRows();
-  if (hasMatchingSession && widgetLayoutSession?.tier === "single-line")
-    return buildSingleLineWidgetLines(jobs, theme, width);
-  if (hasMatchingSession && widgetLayoutSession?.tier === "progressive" && widgetLayoutSession.lockedRows !== void 0) {
-    let rendered2 = buildProgressiveWidgetLines(jobs, theme, width, widgetLayoutSession.lockedRows, widgetLayoutSession.visibleJobKeys);
-    return widgetLayoutSession.visibleJobKeys = rendered2.visibleJobKeys, rendered2.lines;
-  }
+  let rows = currentTerminalRows(), columns = currentTerminalColumns(), availableRows = estimateAvailableWidgetRows();
   if (lines.length <= availableRows)
-    return widgetLayoutSession = { expanded, rows, columns, tier: "full", visibleJobKeys: [] }, fitWidgetLineBudget(lines, theme, width, !1);
-  if (availableRows <= 2)
-    return widgetLayoutSession = { expanded, rows, columns, tier: "single-line", visibleJobKeys: [] }, buildSingleLineWidgetLines(jobs, theme, width);
-  let lockedRows = Math.min(availableRows, collapsedWidgetLineBudget(rows)), rendered = buildProgressiveWidgetLines(jobs, theme, width, lockedRows, []);
-  return widgetLayoutSession = { expanded, rows, columns, tier: "progressive", lockedRows, visibleJobKeys: rendered.visibleJobKeys }, rendered.lines;
+    return widgetLayoutSession = { expanded, rows, columns, tier: "full" }, fitWidgetLineBudget(lines, theme, width, !1);
+  let lockedRows = widgetSessionMatches(expanded) && widgetLayoutSession?.tier === "progressive" ? widgetLayoutSession.lockedRows ?? 1 : Math.max(1, Math.min(availableRows, collapsedWidgetLineBudget(rows)));
+  if (widgetLayoutSession = { expanded, rows, columns, tier: "progressive", lockedRows }, lockedRows === 1)
+    return lines.slice(0, 1);
+  let visibleCount = Math.max(1, lockedRows - 1), visible = lines.slice(0, visibleCount), hidden = lines.length - visible.length;
+  for (hidden > 0 && visible.push(truncLine(theme.fg("dim", `+${hidden} more`), width)); visible.length < lockedRows; )
+    visible.push(" ");
+  return visible.slice(0, lockedRows);
+}
+function widgetExpandedDiagnostics(job, step, index, theme, width, now) {
+  let lines = [], status = step?.status ?? job.status, runLabel = step ? `${job.asyncId}:${step.index ?? index}` : job.asyncId;
+  lines.push(truncLine(theme.fg("dim", `  \u23BF run ${runLabel} \xB7 ${status}`), width));
+  let error = step?.error;
+  error && lines.push(truncLine(theme.fg("error", `    ${error}`), width));
+  let snapshotNow = status === "running" ? now : step?.endedAt ?? job.updatedAt, activity = step ? widgetStepActivityLine(step, Math.max(1, width - 4), !0, snapshotNow) : widgetActivity(job, now);
+  activity && lines.push(truncLine(theme.fg("dim", `    ${activity}`), width));
+  for (let tool of step?.recentTools?.slice(-3) ?? [])
+    lines.push(truncLine(theme.fg("dim", `    ${tool.tool}${tool.args ? `: ${tool.args}` : ""}`), width));
+  for (let output of step?.recentOutput?.slice(-5) ?? [])
+    lines.push(truncLine(theme.fg("dim", `    ${output}`), width));
+  for (let nestedLine of formatNestedWidgetLines(step?.children ?? job.nestedChildren, theme, width, !0, snapshotNow))
+    lines.push(truncLine(`    ${nestedLine}`, width));
+  return lines;
 }
 function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = !1, now = Date.now()) {
-  if (jobs.length === 0)
-    return [];
-  if (jobs.length === 1)
-    return buildSingleWidgetLines(jobs[0], theme, width, expanded, now);
-  let running = jobs.filter((job) => job.status === "running"), queued = jobs.filter((job) => job.status === "queued"), finished = jobs.filter((job) => job.status !== "running" && job.status !== "queued"), lines = [], hasActive = running.length > 0 || queued.length > 0, headerGlyph = running.length > 0 ? runningGlyph((widgetJobsRunningSeed(running) ?? 0) + widgetAnimFrame(now)) : hasActive ? "\u25CF" : "\u25CB";
-  lines.push(truncLine(`${theme.fg(hasActive ? "accent" : "dim", headerGlyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "\xB7 background")}`, width));
-  let items = [], hiddenRunning = 0, hiddenFinished = 0, queuedSummaryShown = !1, slots = MAX_WIDGET_JOBS;
-  for (let job of running) {
-    if (slots <= 0) {
-      hiddenRunning++;
-      continue;
-    }
-    let row = compactJobChildRows(job, theme, Math.max(1, width - 3), now);
-    items.push(expanded ? [...row, ...widgetParallelAgentDetails(job, theme, !0, width)] : row), slots--;
-  }
-  queued.length > 0 && slots > 0 && (items.push([`${theme.fg("muted", "\u25E6")} ${theme.fg("dim", `${queued.length} queued`)}`]), queuedSummaryShown = !0, slots--);
-  for (let job of finished) {
-    if (slots <= 0) {
-      hiddenFinished++;
-      continue;
-    }
-    let row = compactJobChildRows(job, theme, Math.max(1, width - 3), now);
-    items.push(expanded ? [...row, ...widgetParallelAgentDetails(job, theme, !0, width)] : row), slots--;
-  }
-  let hiddenQueued = queued.length > 0 && !queuedSummaryShown ? queued.length : 0, hiddenTotal = hiddenRunning + hiddenFinished + hiddenQueued;
-  if (hiddenTotal > 0) {
-    let parts = [];
-    hiddenRunning > 0 && parts.push(`${hiddenRunning} running`), hiddenQueued > 0 && parts.push(`${hiddenQueued} queued`), hiddenFinished > 0 && parts.push(`${hiddenFinished} finished`), items.push([theme.fg("dim", `+${hiddenTotal} more (${parts.join(", ")})`)]);
-  }
-  for (let i = 0; i < items.length; i++) {
-    let item = items[i], last = i === items.length - 1, branch = last ? "\u2514\u2500" : "\u251C\u2500", continuation = last ? "   " : "\u2502  ";
-    lines.push(truncLine(`${theme.fg("dim", branch)} ${item[0]}`, width));
-    for (let detail of item.slice(1))
-      lines.push(truncLine(`${theme.fg("dim", continuation)} ${detail}`, width));
+  let lines = [];
+  for (let job of orderedWidgetJobs(jobs)) {
+    let steps = job.steps?.length ? job.steps : job.agents?.length ? job.agents.map((agent, index) => ({ agent, description: agent, status: job.status, index })) : [void 0];
+    for (let [index, step] of steps.entries())
+      lines.push(...compactJobLines(job, step, theme, width, now)), expanded && lines.push(...widgetExpandedDiagnostics(job, step, index, theme, width, now));
   }
   return lines;
 }
@@ -899,7 +761,7 @@ var activeWidget, SubagentAsyncWidget = class {
   startTimer() {
     this.timer || (this.timer = setInterval(() => {
       this.disposed || (this.invalidate(), this.requestRender?.());
-    }, 80), this.timer.unref?.());
+    }, SUBAGENT_PAINT_INTERVAL_MS), this.timer.unref?.());
   }
   stopTimer() {
     this.timer && (clearInterval(this.timer), this.timer = void 0);
@@ -916,7 +778,7 @@ var activeWidget, SubagentAsyncWidget = class {
       return [];
     if (this.cachedLines && this.cachedWidth === width && !this.hasRunning())
       return this.cachedLines;
-    let now = this.nowFn(), innerWidth = Math.max(1, width - 2), lines = this.expanded ? buildWidgetLines(this.jobs, theme, innerWidth, !0, now) : this.jobs.length === 1 ? compactSingleWidgetLines(this.jobs[0], theme, innerWidth, now) : buildWidgetLines(this.jobs, theme, innerWidth, !1, now), padded = fitAdaptiveWidgetLines(this.jobs, lines, theme, innerWidth, this.expanded).map((line) => {
+    let now = this.nowFn(), innerWidth = Math.max(1, width - 2), lines = buildWidgetLines(this.jobs, theme, innerWidth, this.expanded, now), padded = fitAdaptiveWidgetLines(this.jobs, lines, theme, innerWidth, this.expanded).map((line) => {
       let withPad = ` ${line}`, vis = visibleWidth(withPad);
       return withPad + " ".repeat(Math.max(0, width - vis));
     });
@@ -941,65 +803,71 @@ function renderWidget(ctx, jobs) {
   let widget = new SubagentAsyncWidget(jobs, void 0, { expanded, requestRender });
   activeWidget = widget, ctx.ui.setWidget(WIDGET_KEY, (_tui, theme) => (widget.setTheme(theme), widget));
 }
+function compactResultTerminalStatus(result2) {
+  if (result2.stopped)
+    return "stopped";
+  if (result2.detached)
+    return "detached";
+  if (result2.interrupted)
+    return "paused";
+  if (result2.exitCode !== 0)
+    return "failed";
+}
 function renderSingleCompact(d, r, theme, frame) {
-  let output = r.truncation?.text || getSingleResultOutput(r), progress = r.progress || r.progressSummary, isRunning = r.progress?.status === "running", c = new Container(), width = getTermWidth() - 4, lead = compactRowLead({ description: r.description ?? r.agent, task: r.task }), modelBadge = formatCompactModelBadge(r.modelSelection ?? progress?.modelSelection, r.model ?? progress?.model);
-  return c.addChild(animatedLine((f, now) => formatCompactSubagentRow(theme, width, {
-    glyph: resultGlyph(r, output, theme, isRunning, void 0, f),
+  let output = r.truncation?.text || getSingleResultOutput(r), progress = r.progress || r.progressSummary, isRunning = r.progress?.status === "running", width = getTermWidth() - 4, lead = compactRowLead({ description: r.description ?? r.agent, task: r.task }), modelBadge = formatCompactModelBadge(r.modelSelection ?? progress?.modelSelection, r.model ?? progress?.model);
+  return animatedLine((animationTick, now) => formatCompactSubagentRow(theme, width, {
+    glyph: resultGlyph(r, output, theme, isRunning, void 0, foregroundSpinnerFrame(animationTick)),
     description: lead,
     modelBadge,
     tokens: compactResultTokens(r),
-    durationMs: liveDurationMs(progress, isRunning, now)
-  }), frame, isRunning)), !isRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped) && c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `  \u23BF  ${resultStatusLine(r, output)}`), width), 0, 0)), c;
+    durationMs: liveDurationMs(progress, isRunning, now),
+    terminalStatus: compactResultTerminalStatus(r)
+  }), frame, isRunning);
+}
+function progressStatusGlyph(progress, theme, frame) {
+  return !progress || progress.status === "pending" ? theme.fg("muted", "\u25E6") : progress.status === "running" ? theme.fg("accent", runningGlyph((progressRunningSeed(progress) ?? 0) + (frame ?? 0))) : progress.status === "completed" ? theme.fg("success", "\u2713") : progress.status === "failed" ? theme.fg("error", "\u2717") : theme.fg("warning", "\u25A0");
+}
+function flattenCompactWorkflowNodes(nodes) {
+  let rows = [];
+  for (let node of nodes)
+    node.children?.length ? rows.push(...flattenCompactWorkflowNodes(node.children)) : rows.push(node);
+  return rows;
+}
+function compactForegroundEntries(d) {
+  let workflowNodes = flattenCompactWorkflowNodes(d.workflowGraph?.nodes ?? []);
+  if (workflowNodes.length === 0) {
+    let progressCount2 = d.progress?.reduce((count2, entry) => Math.max(count2, entry.index + 1), 0) ?? 0, chainCount = d.mode === "chain" ? buildChainStepSpans(d).reduce((count2, span) => Math.max(count2, span.start + span.count), 0) : 0, count = Math.max(d.results.length, progressCount2, d.chainChildren?.length ?? 0, d.chainAgents?.length ?? 0, chainCount);
+    return Array.from({ length: count }, (_, flatIndex) => ({ flatIndex }));
+  }
+  let entries = workflowNodes.map((node) => ({ flatIndex: node.flatIndex, node })), seen = new Set(entries.flatMap((entry) => entry.flatIndex === void 0 ? [] : [entry.flatIndex])), progressCount = d.progress?.reduce((count, entry) => Math.max(count, entry.index + 1), 0) ?? 0, dataCount = Math.max(d.results.length, progressCount, d.chainChildren?.length ?? 0);
+  for (let flatIndex = 0; flatIndex < dataCount; flatIndex++)
+    seen.has(flatIndex) || entries.push({ flatIndex });
+  return entries;
 }
 function renderMultiCompact(d, theme, frame) {
-  let hasRunning = d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running") || workflowGraphHasStatus(d, ["running"]), stopped = d.results.some((r) => r.stopped && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["stopped"]), failed = d.results.some((r) => !r.stopped && r.exitCode !== 0 && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["failed"]), paused = d.results.some((r) => (r.interrupted || r.detached) && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["paused", "detached"]), totalSummary = d.progressSummary;
-  if (!totalSummary) {
-    let sawProgress = !1, summary = { toolCount: 0, tokens: 0, durationMs: 0, lastActivityAt: void 0 };
-    for (let r of d.results) {
-      let prog = r.progress || r.progressSummary;
-      prog && (sawProgress = !0, summary.toolCount += prog.toolCount, summary.tokens += prog.tokens, summary.durationMs = d.mode === "chain" ? summary.durationMs + prog.durationMs : Math.max(summary.durationMs, prog.durationMs), prog.status === "running" && prog.lastActivityAt !== void 0 && (summary.lastActivityAt = Math.max(summary.lastActivityAt ?? 0, prog.lastActivityAt)));
-    }
-    sawProgress && (totalSummary = summary);
-  }
-  let multiLabel = buildMultiProgressLabel(d, hasRunning), itemTitle = multiLabel.itemTitle, glyph = (f) => hasRunning ? theme.fg("accent", runningGlyph(f !== void 0 ? (runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex) ?? 0) + f : runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex))) : stopped ? theme.fg("warning", "\u25A0") : failed ? theme.fg("error", "\u2717") : paused ? theme.fg("warning", "\u25A0") : theme.fg("success", "\u2713"), contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "", c = new Container(), width = getTermWidth() - 4;
-  c.addChild(animatedLine((f) => {
-    let stats = statJoin(theme, [multiLabel.headerLabel, formatTotalCostStat(d.totalCost)]);
-    return truncLine(`${glyph(f)} ${theme.fg("toolTitle", theme.bold(d.mode))}${contextBadge}${stats ? ` ${theme.fg("dim", "\xB7")} ${stats}` : ""}`, width);
-  }, frame, hasRunning));
-  let useResultsDirectly = multiLabel.hasParallelInChain || !d.chainAgents?.length, displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0, displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : useResultsDirectly ? d.results.length : d.chainAgents.length, chainEntries = buildChainRenderEntries(d, multiLabel), renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset) => {
-    let i = displayStart + offset, r = d.results[i], fallbackLabel = itemTitle.toLowerCase(), 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}` };
-  });
-  for (let entry of renderEntries) {
-    if (entry.kind === "placeholder") {
-      let glyph2 = widgetStepGlyph(entry.status, theme), statusLabel = widgetStepStatus(entry.status, theme);
-      c.addChild(new Text(truncLine(`  ${glyph2} ${entry.stepLabel}: ${themeBold(theme, entry.agentName)} ${theme.fg("dim", "\xB7")} ${statusLabel}`, width), 0, 0)), entry.error && c.addChild(new Text(truncLine(theme.fg("error", `    \u23BF  Error: ${entry.error}`), width), 0, 0));
-      continue;
-    }
-    let i = entry.resultIndex, r = d.results[i], rowNumber = entry.rowNumber, agentName = entry.agentName;
-    if (!r) {
-      let pendingLabel = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`;
-      c.addChild(new Text(truncLine(theme.fg("dim", `  \u25E6 ${pendingLabel}: ${agentName} \xB7 pending`), width), 0, 0));
-      continue;
-    }
-    let output = getSingleResultOutput(r), progressFromArray = d.progress?.find((p) => p.index === i) || d.progress?.find((p) => p.agent === r.agent && p.status === "running"), rProg = r.progress || progressFromArray || r.progressSummary, rRunning = rProg && "status" in rProg && rProg.status === "running", rPending = rProg && "status" in rProg && rProg.status === "pending", lead = compactRowLead({ description: r.description ?? agentName, task: r.task }), modelBadge = formatCompactModelBadge(r.modelSelection ?? (rProg && "modelSelection" in rProg ? rProg.modelSelection : void 0), r.model ?? (rProg && "model" in rProg ? rProg.model : void 0));
-    c.addChild(animatedLine((f, now) => {
-      let rowGlyph = rPending ? theme.fg("dim", "\u25E6") : resultGlyph(r, output, theme, rRunning, progressRunningSeed(rProg), f);
+  let c = new Container(), width = getTermWidth() - 4, entries = compactForegroundEntries(d);
+  for (let [rowIndex, entry] of entries.entries()) {
+    let flatIndex = entry.flatIndex, result2 = flatIndex === void 0 ? void 0 : resultAtFlatIndex(d, flatIndex), progress = result2?.progress ?? (flatIndex === void 0 ? void 0 : d.progress?.find((candidate) => candidate.index === flatIndex)) ?? result2?.progressSummary, status = progress?.status ?? entry.node?.status ?? "pending", description = compactRowLead({
+      description: result2?.description ?? progress?.description ?? entry.node?.label ?? (flatIndex === void 0 ? void 0 : d.chainChildren?.[flatIndex]?.description) ?? (flatIndex === void 0 ? void 0 : d.chainAgents?.[flatIndex]) ?? result2?.agent ?? progress?.agent,
+      task: result2?.task ?? progress?.task
+    }) || `child ${rowIndex + 1}`, running = status === "running", output = result2 ? getSingleResultOutput(result2) : "", modelBadge = formatCompactModelBadge(result2?.modelSelection ?? progress?.modelSelection, result2?.model ?? progress?.model);
+    c.addChild(animatedLine((animationTick, now) => {
+      let animationFrame = foregroundSpinnerFrame(animationTick);
       return formatCompactSubagentRow(theme, width, {
-        glyph: rowGlyph,
-        description: lead,
+        glyph: result2 ? resultGlyph(result2, output, theme, running, progressRunningSeed(progress), animationFrame) : progressStatusGlyph({ ...progress, status, index: flatIndex }, theme, animationFrame),
+        description,
         modelBadge,
-        tokens: compactResultTokens(r),
-        durationMs: liveDurationMs(rProg, !!rRunning, now),
-        prefix: "  "
+        tokens: result2 ? compactResultTokens(result2) : progress?.tokens ?? 0,
+        durationMs: liveDurationMs(progress, running, now),
+        terminalStatus: result2 ? compactResultTerminalStatus(result2) : compactTerminalStatus(status)
       });
-    }, frame, !!rRunning)), !rPending && !rRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped) && c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `    \u23BF  ${resultStatusLine(r, output)}`), width), 0, 0));
+    }, frame, running));
   }
   return c;
 }
 function renderSubagentResult(result2, options, theme, frame) {
-  let d = result2.details;
-  if (!d || !d.results.length) {
+  let d = result2.details, hasWorkflowRows = d?.mode !== "management" && !!(d?.workflowGraph?.nodes.length || d?.progress?.length || d?.chainChildren?.length);
+  if (!d || !d.results.length && !hasWorkflowRows) {
     let t = result2.content[0], text = t?.type === "text" ? t.text : "(no output)", contextPrefix = d?.context === "fork" ? `${theme.fg("warning", "[fork]")} ` : "", width = getTermWidth() - 4;
     if (!text.includes(`
 `))
@@ -1020,7 +888,7 @@ function renderSubagentResult(result2, options, theme, frame) {
       return fit3(`${icon2} ${theme.fg("toolTitle", theme.bold(r.agent))}${modelDisplay}${contextBadge2}${stats ? ` | ${stats}` : ""}`);
     }, frame, isRunning)), c2.addChild(new Spacer(1));
     let taskMaxLen = Math.max(20, w2 - 8), taskPreview = expanded || r.task.length <= taskMaxLen ? r.task : `${r.task.slice(0, taskMaxLen)}...`;
-    if (c2.addChild(new Text(fit3(theme.fg("dim", `Task: ${taskPreview}`)), 0, 0)), c2.addChild(new Spacer(1)), isRunning && r.progress) {
+    if (c2.addChild(new Text(fit3(theme.fg("dim", `Task: ${taskPreview}`)), 0, 0)), !isRunning && compactResultTerminalStatus(r) && c2.addChild(new Text(fit3(theme.fg(r.exitCode !== 0 ? "error" : "warning", resultStatusLine(r, output))), 0, 0)), c2.addChild(new Spacer(1)), isRunning && r.progress) {
       let progressSnapshotNow = snapshotNowForProgress(r.progress), toolLine = formatCurrentToolLine(r.progress, w2, expanded, progressSnapshotNow);
       toolLine && c2.addChild(new Text(fit3(theme.fg("warning", `> ${toolLine}`)), 0, 0));
       let liveStatusLine = buildLiveStatusLine(r.progress, progressSnapshotNow);
@@ -1042,7 +910,7 @@ function renderSubagentResult(result2, options, theme, frame) {
   }
   if (!expanded)
     return renderMultiCompact(d, theme, frame);
-  let hasRunning = d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running") || workflowGraphHasStatus(d, ["running"]), ok = d.results.filter((r) => r.progress?.status === "completed" || r.exitCode === 0 && r.progress?.status !== "running").length, hasEmptyWithoutTarget = d.results.some((r) => r.exitCode === 0 && r.progress?.status !== "running" && hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r))), hasWorkflowFailure = workflowGraphHasStatus(d, ["failed"]), hasWorkflowStop = d.results.some((r) => r.stopped && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["stopped"]), hasWorkflowPause = workflowGraphHasStatus(d, ["paused", "detached"]), icon = hasRunning ? theme.fg("warning", "running") : hasEmptyWithoutTarget ? theme.fg("warning", "warning") : hasWorkflowFailure ? theme.fg("error", "failed") : hasWorkflowStop ? theme.fg("warning", "stopped") : hasWorkflowPause ? theme.fg("warning", "paused") : ok === d.results.length ? theme.fg("success", "ok") : theme.fg("error", "failed"), totalSummary = d.progressSummary || d.results.reduce((acc, r) => {
+  let hasRunning = d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running") || workflowGraphHasStatus(d, ["running"]), ok = d.results.filter((r) => r.progress?.status === "completed" || r.exitCode === 0 && r.progress?.status !== "running").length, hasEmptyWithoutTarget = d.results.some((r) => r.exitCode === 0 && r.progress?.status !== "running" && hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r))), hasWorkflowFailure = workflowGraphHasStatus(d, ["failed"]), hasWorkflowStop = d.results.some((r) => r.stopped && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["stopped"]), hasWorkflowPause = workflowGraphHasStatus(d, ["paused", "detached"]), hasWorkflowPending = workflowGraphHasStatus(d, ["pending"]), icon = hasRunning ? theme.fg("warning", "running") : hasEmptyWithoutTarget ? theme.fg("warning", "warning") : hasWorkflowFailure ? theme.fg("error", "failed") : hasWorkflowStop ? theme.fg("warning", "stopped") : hasWorkflowPause ? theme.fg("warning", "paused") : hasWorkflowPending ? theme.fg("dim", "pending") : ok === d.results.length ? theme.fg("success", "ok") : theme.fg("error", "failed"), totalSummary = d.progressSummary || d.results.reduce((acc, r) => {
     let prog = r.progress || r.progressSummary;
     return prog && (acc.toolCount += prog.toolCount, acc.tokens += prog.tokens, acc.durationMs = d.mode === "chain" ? acc.durationMs + prog.durationMs : Math.max(acc.durationMs, prog.durationMs)), acc;
   }, { toolCount: 0, tokens: 0, durationMs: 0 }), modeLabel = d.mode, contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "", multiLabel = buildMultiProgressLabel(d, hasRunning), itemTitle = multiLabel.itemTitle, chainVis = d.chainAgents?.length && !multiLabel.hasParallelInChain ? d.chainAgents.map((agent, i) => {
@@ -1056,10 +924,26 @@ function renderSubagentResult(result2, options, theme, frame) {
     ].filter(Boolean), summaryStr = summaryParts.length ? ` | ${summaryParts.join(", ")}` : "";
     return fit2(`${icon} ${theme.fg("toolTitle", theme.bold(modeLabel))}${contextBadge} \xB7 ${multiLabel.headerLabel}${summaryStr}`);
   }, frame, hasRunning)), chainVis && c.addChild(new Text(fit2(`  ${chainVis}`), 0, 0));
-  let useResultsDirectly = multiLabel.hasParallelInChain || !d.chainAgents?.length, displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0, displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : useResultsDirectly ? d.results.length : d.chainAgents.length, chainEntries = buildChainRenderEntries(d, multiLabel), renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset) => {
-    let i = displayStart + offset, r = d.results[i], 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}` };
-  });
+  let chainEntries = buildChainRenderEntries(d, multiLabel), fallbackEntries = compactForegroundEntries(d).filter((entry) => !multiLabel.showActiveGroupOnly || entry.flatIndex === void 0 || entry.flatIndex >= multiLabel.groupStartIndex && entry.flatIndex < multiLabel.groupEndIndex).map((entry, rowIndex) => {
+    if (entry.flatIndex === void 0)
+      return {
+        kind: "placeholder",
+        rowNumber: entry.node?.stepIndex !== void 0 ? entry.node.stepIndex + 1 : rowIndex + 1,
+        stepLabel: `Step ${entry.node?.stepIndex !== void 0 ? entry.node.stepIndex + 1 : rowIndex + 1}`,
+        agentName: entry.node?.label ?? `step-${rowIndex + 1}`,
+        status: entry.node?.status ?? "pending",
+        error: entry.node?.error
+      };
+    let result3 = resultAtFlatIndex(d, entry.flatIndex), rowNumber = multiLabel.showActiveGroupOnly ? entry.flatIndex - multiLabel.groupStartIndex + 1 : entry.flatIndex + 1;
+    return {
+      kind: "result",
+      resultIndex: entry.flatIndex,
+      rowNumber,
+      agentName: result3?.agent ?? entry.node?.label ?? d.chainChildren?.[entry.flatIndex]?.description ?? d.chainAgents?.[entry.flatIndex] ?? `step-${rowNumber}`,
+      status: entry.node?.status,
+      error: entry.node?.error
+    };
+  }), renderEntries = chainEntries ?? fallbackEntries;
   c.addChild(new Spacer(1));
   for (let entry of renderEntries) {
     if (entry.kind === "placeholder") {
@@ -1067,10 +951,10 @@ function renderSubagentResult(result2, options, theme, frame) {
       c.addChild(new Text(fit2(`  ${statusLabel} ${entry.stepLabel}: ${theme.bold(entry.agentName)}`), 0, 0)), c.addChild(new Text(theme.fg(entry.status === "failed" ? "error" : "dim", `    status: ${entry.status}`), 0, 0)), entry.error && c.addChild(new Text(theme.fg("error", `    error: ${entry.error}`), 0, 0)), c.addChild(new Spacer(1));
       continue;
     }
-    let i = entry.resultIndex, r = d.results[i], rowNumber = entry.rowNumber, agentName = entry.agentName;
+    let i = entry.resultIndex, r = resultAtFlatIndex(d, i), rowNumber = entry.rowNumber, agentName = entry.agentName;
     if (!r) {
-      let pendingLabel = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`;
-      c.addChild(new Text(fit2(theme.fg("dim", `  ${pendingLabel}: ${agentName}`)), 0, 0)), c.addChild(new Text(theme.fg("dim", "    status: pending"), 0, 0)), c.addChild(new Spacer(1));
+      let rowLabel = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`, status = entry.status ?? "pending";
+      c.addChild(new Text(fit2(theme.fg(status === "failed" ? "error" : "dim", `  ${rowLabel}: ${agentName}`)), 0, 0)), c.addChild(new Text(theme.fg(status === "failed" ? "error" : "dim", `    status: ${status}`), 0, 0)), entry.error && c.addChild(new Text(theme.fg("error", `    error: ${entry.error}`), 0, 0)), c.addChild(new Spacer(1));
       continue;
     }
     let progressFromArray = d.progress?.find((p) => p.index === i) || d.progress?.find((p) => p.agent === r.agent && p.status === "running"), rProg = r.progress || progressFromArray || r.progressSummary, rRunning = rProg?.status === "running", stepNumber = typeof rProg?.index == "number" ? rProg.index + 1 : i + 1, resultOutput = getSingleResultOutput(r), 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"), modelDisplay = modelThinkingBadge(theme, r.model, r.thinking ?? (rProg && "thinking" in rProg ? rProg.thinking : void 0), r.modelSelection ?? (rProg && "modelSelection" in rProg ? rProg.modelSelection : void 0)), stepLabel = resultRowLabel(d, multiLabel, i, stepNumber), toolCallLines = getToolCallLines(r, expanded);
@@ -1079,7 +963,7 @@ function renderSubagentResult(result2, options, theme, frame) {
       return fit2(rRunning ? `${statusIcon} ${stepLabel}: ${theme.bold(theme.fg("warning", r.agent))}${modelDisplay}${stats ? ` | ${stats}` : ""}` : `${statusIcon} ${stepLabel}: ${theme.bold(r.agent)}${modelDisplay}${stats ? ` | ${stats}` : ""}`);
     }, frame, rRunning));
     let taskMaxLen = Math.max(20, w - 12), taskPreview = expanded || r.task.length <= taskMaxLen ? r.task : `${r.task.slice(0, taskMaxLen)}...`;
-    if (c.addChild(new Text(fit2(theme.fg("dim", `    task: ${taskPreview}`)), 0, 0)), r.skills?.length && c.addChild(new Text(fit2(theme.fg("dim", `    skills: ${r.skills.join(", ")}`)), 0, 0)), r.skillsWarning && c.addChild(new Text(fit2(theme.fg("warning", `    Warning: ${r.skillsWarning}`)), 0, 0)), r.attemptedModels && r.attemptedModels.length > 1 && c.addChild(new Text(fit2(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" \u2192 ")}`)), 0, 0)), rRunning && rProg) {
+    if (c.addChild(new Text(fit2(theme.fg("dim", `    task: ${taskPreview}`)), 0, 0)), !rRunning && compactResultTerminalStatus(r) && c.addChild(new Text(fit2(theme.fg(r.exitCode !== 0 ? "error" : "warning", `    ${resultStatusLine(r, resultOutput)}`)), 0, 0)), r.skills?.length && c.addChild(new Text(fit2(theme.fg("dim", `    skills: ${r.skills.join(", ")}`)), 0, 0)), r.skillsWarning && c.addChild(new Text(fit2(theme.fg("warning", `    Warning: ${r.skillsWarning}`)), 0, 0)), r.attemptedModels && r.attemptedModels.length > 1 && c.addChild(new Text(fit2(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" \u2192 ")}`)), 0, 0)), rRunning && rProg) {
       rProg.skills?.length && c.addChild(new Text(fit2(theme.fg("accent", `    skills: ${rProg.skills.join(", ")}`)), 0, 0));
       let progressSnapshotNow = snapshotNowForProgress(rProg), toolLine = formatCurrentToolLine(rProg, w, expanded, progressSnapshotNow);
       toolLine && c.addChild(new Text(fit2(theme.fg("warning", `    > ${toolLine}`)), 0, 0));
@@ -1349,7 +1233,7 @@ var SkillOverride = Type.Unsafe({
     description: "Children always start with a fresh session. Fork context is not available."
   })),
   chainDir: Type.Optional(Type.String({ description: "Persistent chain artifact directory; defaults to user-scoped temp storage." })),
-  async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
+  async: Type.Optional(Type.Boolean({ description: "Run async in the background. Defaults to true when omitted; set false for immediate foreground results." })),
   timeoutMs: Type.Optional(Type.Integer({ minimum: 1, description: "Optional run-level timeout in ms for foreground and async/background runs. Alias of maxRuntimeMs." })),
   maxRuntimeMs: Type.Optional(Type.Integer({ minimum: 1, description: "Alias of timeoutMs for optional run-level timeout in foreground and async/background runs." })),
   turnBudget: Type.Optional(TurnBudgetOverride),
@@ -1360,7 +1244,7 @@ var SkillOverride = Type.Unsafe({
   share: Type.Optional(Type.Boolean({ description: "Upload session to GitHub Gist for sharing (default: false)" })),
   sessionDir: Type.Optional(Type.String({ description: "Directory to store session logs (default: temp; enables sessions even if share=false)" })),
   // Clarification TUI
-  clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution. Explicit clarify: true keeps the run foreground for the clarify UI; omitted clarify can still run in the background when async: true is set." })),
+  clarify: Type.Optional(Type.Boolean({ description: "Show the interactive TUI preview/editor before execution. clarify:true keeps the run foreground even when async is omitted or true." })),
   control: Type.Optional(ControlOverrides),
   output: Type.Optional(Type.Unsafe({
     anyOf: [
@@ -1596,7 +1480,7 @@ function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
         if (parsed.type !== "subagent.control")
           return;
         let record = parsed;
-        if (!record.event || !Array.isArray(record.channels))
+        if (!record.event || !Array.isArray(record.channels) || record.event.reason === "completion_guard")
           return;
         let payload = {
           event: record.event,
@@ -1922,7 +1806,7 @@ ${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChil
             asyncId: data.id,
             asyncDir: data.asyncDir
           });
-          payload.requestId = `async-result:${sessionId}:${completionKey}`, attempts.set(file, (attempts.get(file) ?? 0) + 1);
+          payload.requestId = `async-result:${sessionId}:${completionKey}`, payload.ownerNotificationSessionId = sessionId, attempts.set(file, (attempts.get(file) ?? 0) + 1);
           let delivered = await deliverSubagentResultIntercomEvent(pi.events, payload);
           if (!isCurrent())
             return;
@@ -2527,7 +2411,7 @@ function substituteArgs(template, args) {
   return template.replace(/\$ARGUMENTS/g, all).replace(/\$@/g, all).replace(/\$\{(\d+):-([^}]*)\}/g, (_match, index, fallback) => args[Number(index) - 1] || fallback).replace(/\$(\d+)/g, (_match, index) => args[Number(index) - 1] ?? "");
 }
 function parseRuntimeOptions(words) {
-  let args = [], descriptionOverride, permissions, worktree = !1, bg = !1;
+  let args = [], descriptionOverride, permissions, worktree = !1, async;
   for (let i = 0; i < words.length; i++) {
     let word = words[i];
     if (word === "--read-only") {
@@ -2543,7 +2427,11 @@ function parseRuntimeOptions(words) {
       continue;
     }
     if (word === "--bg" || word === "--async") {
-      bg = !0;
+      async = !0;
+      continue;
+    }
+    if (word === "--fg" || word === "--foreground") {
+      async = !1;
       continue;
     }
     if (word === "--description") {
@@ -2557,7 +2445,7 @@ function parseRuntimeOptions(words) {
     }
     args.push(word);
   }
-  return { args, descriptionOverride, permissions, worktree, bg };
+  return { args, descriptionOverride, permissions, worktree, async };
 }
 function splitChainDeclaration(input) {
   let delimiter = input.indexOf(" -- ");
@@ -2576,7 +2464,7 @@ function workflowParams(workflow, args, runtime) {
     ...workflow.skill !== void 0 ? { skill: workflow.skill } : {},
     ...workflow.cwd ? { cwd: workflow.cwd } : {},
     ...runtime.worktree || workflow.worktree ? { worktree: !0 } : {},
-    ...runtime.bg ? { async: !0 } : {}
+    ...runtime.async !== void 0 ? { async: runtime.async } : {}
   };
 }
 function workflowChainStep(workflow, args, runtime) {
@@ -2624,7 +2512,7 @@ function registerPromptWorkflowCommands(input) {
               throw new Error(`Unknown prompt workflow in chain '${workflow.name}': ${stepName}`);
             return workflowChainStep(step, runtime.args, runtime);
           });
-          await run({ chain, task: runtime.args.join(" "), clarify: !1, ...runtime.bg ? { async: !0 } : {} }, ctx);
+          await run({ chain, task: runtime.args.join(" "), clarify: !1, ...runtime.async !== void 0 ? { async: runtime.async } : {} }, ctx);
           return;
         }
         await run(workflowParams(workflow, runtime.args, runtime), ctx);
@@ -2652,7 +2540,7 @@ function registerPromptWorkflowCommands(input) {
             throw new Error(`Unknown prompt workflow: ${name}`);
           return workflowChainStep(workflow, runtime.args, runtime);
         });
-        await run({ chain, task: runtime.args.join(" "), clarify: !1, ...runtime.bg ? { async: !0 } : {} }, ctx);
+        await run({ chain, task: runtime.args.join(" "), clarify: !1, ...runtime.async !== void 0 ? { async: runtime.async } : {} }, ctx);
       } catch (error) {
         ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
       }
@@ -3232,15 +3120,14 @@ var parseInlineConfig = (raw) => {
   let end = token.lastIndexOf("]");
   return { name: token.slice(0, bracket), config: parseInlineConfig(token.slice(bracket + 1, end !== -1 ? end : void 0)) };
 }, extractExecutionFlags = (rawArgs) => {
-  let args = rawArgs.trim(), bg = !1;
+  let args = rawArgs.trim(), async;
   for (; ; ) {
-    if (args.endsWith(" --bg") || args === "--bg") {
-      bg = !0, args = args === "--bg" ? "" : args.slice(0, -5).trim();
-      continue;
-    }
-    break;
+    let match = args.match(/(?:^|\s)(--bg|--async|--fg|--foreground)$/);
+    if (!match)
+      break;
+    async ??= match[1] === "--bg" || match[1] === "--async", args = args.slice(0, match.index).trim();
   }
-  return { args, bg };
+  return { args, async };
 };
 function sendSlashText(pi, text) {
   pi.sendMessage({ customType: SLASH_TEXT_RESULT_TYPE, content: text, display: !0 });
@@ -3821,16 +3708,16 @@ function registerSlashCommands(pi, state) {
     }
   };
   pi.registerCommand("run", {
-    description: "Run a prompt-defined child: /run description[tier=standard] task [--bg]",
+    description: "Run an async prompt-defined child; add --foreground to wait inline",
     handler: async (args, ctx) => {
-      let { args: cleanedArgs, bg } = extractExecutionFlags(args), input = cleanedArgs.trim(), firstSpace = input.indexOf(" ");
+      let { args: cleanedArgs, async } = extractExecutionFlags(args), input = cleanedArgs.trim(), firstSpace = input.indexOf(" ");
       if (!input) {
-        ctx.ui.notify("Usage: /run <description> <task> [--bg]", "error");
+        ctx.ui.notify("Usage: /run <description> <task> [--foreground]", "error");
         return;
       }
       let { name: description, config: inline } = parseAgentToken(firstSpace === -1 ? input : input.slice(0, firstSpace)), task = firstSpace === -1 ? "" : input.slice(firstSpace + 1).trim();
       if (!description || !task || !inline.tier) {
-        ctx.ui.notify("Usage: /run <description>[tier=light|standard|heavy] <task> [--bg]", "error");
+        ctx.ui.notify("Usage: /run <description>[tier=light|standard|heavy] <task> [--foreground]", "error");
         return;
       }
       let finalTask = task;
@@ -3838,21 +3725,21 @@ function registerSlashCommands(pi, state) {
 
 ${finalTask}`);
       let params = { description, permissions: inline.permissions ?? "full", tier: inline.tier, task: finalTask, clarify: !1 };
-      inline.output !== void 0 && (params.output = inline.output), inline.outputMode !== void 0 && (params.outputMode = inline.outputMode), inline.skill !== void 0 && (params.skill = inline.skill), bg && (params.async = !0), await runSlashSubagent(pi, ctx, params);
+      inline.output !== void 0 && (params.output = inline.output), inline.outputMode !== void 0 && (params.outputMode = inline.outputMode), inline.skill !== void 0 && (params.skill = inline.skill), async !== void 0 && (params.async = async), await runSlashSubagent(pi, ctx, params);
     }
   }), pi.registerCommand("chain", {
-    description: 'Run prompt-defined children in sequence: /chain inspect "task" -> implement [--bg]',
+    description: "Run prompt-defined children as an async sequence; add --foreground to wait inline",
     handler: async (args, ctx) => {
-      let { args: cleanedArgs, bg } = extractExecutionFlags(args), built = buildChainExpressionSteps(state, cleanedArgs, ctx);
+      let { args: cleanedArgs, async } = extractExecutionFlags(args), built = buildChainExpressionSteps(state, cleanedArgs, ctx);
       if (!built)
         return;
       let params = { chain: built.chain, task: built.task, clarify: !1 };
-      bg && (params.async = !0), await runSlashSubagent(pi, ctx, params);
+      async !== void 0 && (params.async = async), await runSlashSubagent(pi, ctx, params);
     }
   }), pi.registerCommand("parallel", {
-    description: 'Run prompt-defined children in parallel: /parallel inspect "task1" -> review "task2" [--bg]',
+    description: "Run prompt-defined children async in parallel; add --foreground to wait inline",
     handler: async (args, ctx) => {
-      let { args: cleanedArgs, bg } = extractExecutionFlags(args), parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
+      let { args: cleanedArgs, async } = extractExecutionFlags(args), parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
       if (!parsed)
         return;
       let tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
@@ -3877,7 +3764,7 @@ ${finalTask}`);
         return;
       }
       let params = { tasks, clarify: !1 };
-      bg && (params.async = !0), await runSlashSubagent(pi, ctx, params);
+      async !== void 0 && (params.async = async), await runSlashSubagent(pi, ctx, params);
     }
   }), pi.registerCommand("subagent-cost", {
     description: "Show parent and subagent child usage cost for this session",
@@ -4591,6 +4478,7 @@ function parseQuestionRecord(raw) {
     runId: input.runId.trim(),
     childIndex,
     childId: input.childId.trim(),
+    ...typeof input.childDescription == "string" && input.childDescription.trim() ? { childDescription: input.childDescription.trim() } : {},
     parentSessionId: input.parentSessionId.trim(),
     parentGeneration,
     ...incarnation ? { childIncarnation: incarnation } : {}
@@ -4699,6 +4587,7 @@ function createSupervisorQuestion(input) {
     runId: input.runId,
     childIndex: input.childIndex,
     childId: input.childId,
+    ...input.childDescription ? { childDescription: input.childDescription } : {},
     parentSessionId: input.parentSessionId,
     parentGeneration: input.parentGeneration,
     ...input.childIncarnation ? { childIncarnation: input.childIncarnation } : {}
@@ -4764,8 +4653,7 @@ function formatParentQuestionForChild(question) {
 function formatSupervisorQuestionAnswer(question) {
   let state = supervisorQuestionPublicState(question), lines = [
     state === "answered" ? `Subagent answer (${question.id})` : `Subagent question ${state} (${question.id})`,
-    `Run: ${question.runId}`,
-    `Child: ${question.childId} [#${question.childIndex}]`,
+    `From: ${question.childDescription ?? `Subagent ${question.childIndex + 1}`}`,
     `Decision: ${question.reason}`
   ];
   return state === "answered" && question.answer?.trim() ? lines.push("", question.answer.trim()) : question.cancelReason && lines.push("", question.cancelReason), lines.join(`
@@ -4922,8 +4810,9 @@ function askRunningAsyncChild(input) {
   let capability = readSteerCapability(resolved.location.asyncDir, child.index);
   if (!capability?.supported)
     throw new Error("This child is not ready to receive questions. Continue other work until it is ready; no question was queued.");
-  let incarnation = { pid: capability.pid, readyAt: capability.readyAt }, question = createSupervisorQuestion({
+  let incarnation = { pid: capability.pid, readyAt: capability.readyAt }, step = status.steps?.[child.index], childDescription = resolveCommunicationPeer(input.state, status.runId, child.index, child.childId, step?.description ?? child.agent), question = createSupervisorQuestion({
     channelDir,
+    childDescription,
     reason,
     message,
     runId: status.runId,
@@ -4953,12 +4842,50 @@ function askRunningAsyncChild(input) {
       runId: status.runId,
       childIndex: child.index,
       childId: child.childId,
+      communication: { direction: "to", peer: childDescription, message, kind: "question" },
       delivered: !1,
       answered: !1
     }
   };
 }
 
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/tui/communication.js
+import { Box, Container as Container2, Text as Text2 } from "@ashx-j/lunr-tui";
+function renderCommunicationBody(communication, theme) {
+  let direction = communication.direction === "from" ? "From" : "To";
+  return new Text2(`${theme.fg("muted", `${direction}: ${communication.peer}`)}
+
+${communication.message}`, 0, 0);
+}
+function renderCommunicationCard(communication, expanded, theme) {
+  let box = new Box(1, 1, (text) => theme.bg("toolSuccessBg", text));
+  return box.addChild(new Text2(theme.fg("toolTitle", theme.bold(`\u25CF subagent ${communication.kind}`)), 0, 0)), expanded && box.addChild(renderCommunicationBody(communication, theme)), box;
+}
+function renderCommunicationCall(name, args, theme, context, communication) {
+  let container = new Container2(), details = context?.result?.details, saved = readCommunication(details?.communication) ?? communication, action = args.action ?? (args.reason === "need_decision" ? "request" : args.reason === "interview_request" ? "interview" : args.reason === "progress_update" ? "progress" : args.reason);
+  return container.addChild(new Text2(theme.fg("toolTitle", theme.bold(`${name}${action ? ` ${action}` : ""}`)), 0, 0)), context?.expanded && saved && container.addChild(renderCommunicationBody(saved, theme)), container;
+}
+function renderCommunicationResult(content, details, expanded, isError, theme) {
+  let container = new Container2();
+  if (!expanded)
+    return container;
+  if (isError)
+    container.addChild(new Text2(theme.fg("error", content.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
+`)), 0, 0));
+  else {
+    let saved = details;
+    saved?.response ? container.addChild(new Text2(`
+${theme.fg("muted", "From: Supervisor")}
+
+${saved.response}`, 0, 0)) : saved?.steering?.state ? container.addChild(new Text2(`
+Delivery: ${saved.steering.state === "recovered" ? "recovered; replacement launched" : saved.steering.state}`, 0, 0)) : saved?.asyncId && saved.communication ? container.addChild(new Text2(`
+Continuation launched.`, 0, 0)) : saved?.state && saved.communication ? container.addChild(new Text2(`
+${saved.state === "pending" ? "Question queued; awaiting an answer." : saved.state}`, 0, 0)) : saved?.communication || container.addChild(new Text2(content.filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
+`), 0, 0));
+  }
+  return container;
+}
+
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/intercom/native-supervisor-channel.js
 var REQUESTS_DIR = "requests", REPLIES_DIR = "replies", NATIVE_SUPERVISOR_TOOL_NAME = "subagent_supervisor";
 var MAX_MESSAGE_BYTES2 = 64 * 1024, DEFAULT_ASK_TIMEOUT_MS2 = 600 * 1e3, CHANNEL_POLL_MS = Math.min(POLL_INTERVAL_MS, 500), STALE_EMPTY_CHANNEL_AGE_MS = 60 * 1e3, STALE_EMPTY_CHANNEL_CLEANUP_INTERVAL_MS = 60 * 1e3, PARENT_ASK_DESCRIPTION = [
@@ -4970,11 +4897,13 @@ var MAX_MESSAGE_BYTES2 = 64 * 1024, DEFAULT_ASK_TIMEOUT_MS2 = 600 * 1e3, CHANNEL
   "Use pending or list to find child requests awaiting your reply; status reports channel availability. Free-form send is unsupported. Asking never revives a child or changes its assignment.",
   'Reply: { action: "reply", replyTo: "<requestId>", message: "..." }'
 ].join(" "), CHILD_CONTACT_DESCRIPTION = [
-  "Contact the parent/supervisor session for a blocking decision, structured interview, progress update, or reply to a parent question.",
+  "Contact the supervisor for decisions outside your assigned authority, safety concerns, or blockers. Make reversible implementation choices within your scope yourself.",
+  "need_decision/interview_request wait for a reply: state the blocked decision, evidence, and recommended choice. Consolidate related questions; continue independent work before opening a blocking request.",
+  "Return one self-contained final report with outcomes, verification, blockers, and artifact paths; the runtime delivers it. Routine work already appears in activity indicators.",
   "For parent questions use action='reply' with replyTo set to the question id. Answer from current findings and uncertainty; do not start extra investigation just to reply. Continue the assigned task after replying.",
   "Do not open a blocking need_decision while a parent question is already outstanding for this child."
 ].join(" "), ContactSupervisorParamsSchema = Type2.Object({
-  reason: Type2.Optional(Type2.String({ enum: ["need_decision", "interview_request", "progress_update"] })),
+  reason: Type2.Optional(Type2.String({ enum: ["need_decision", "interview_request", "progress_update", "handoff"] })),
   message: Type2.Optional(Type2.String()),
   interview: Type2.Optional(Type2.Unsafe({ type: "object", additionalProperties: !0 })),
   action: Type2.Optional(Type2.String({ enum: ["reply"] })),
@@ -4998,6 +4927,40 @@ function safeSegment2(value) {
 function replyPath(channelDir, requestId) {
   return path8.join(channelDir, REPLIES_DIR, `${safeSegment2(requestId)}.json`);
 }
+function communicationKind(reason) {
+  return reason === "progress_update" ? "progress" : reason === "handoff" ? "handoff" : reason === "interview_request" ? "interview" : "request";
+}
+function communicationBody(message, interview, protocolVersion) {
+  let body = protocolVersion === 2 ? message : legacySupervisorBody(message);
+  return interview !== void 0 && protocolVersion === 2 ? `${body}
+
+${JSON.stringify(interview, null, 2)}` : body;
+}
+function requestCommunication(request, state) {
+  return {
+    direction: "from",
+    peer: resolveCommunicationPeer(state, request.runId, request.childIndex, request.agent, request.description),
+    message: communicationBody(request.message, request.interview, request.protocolVersion),
+    kind: communicationKind(request.reason)
+  };
+}
+function registerSupervisorRenderers(pi, state) {
+  for (let customType of [SUPERVISOR_REQUEST_TYPE, SUBAGENT_SUPERVISOR_ANSWER_TYPE])
+    pi.registerMessageRenderer(customType, (message, options, theme) => {
+      let details = message.details, communication = readCommunication(details?.communication) ?? {
+        direction: "from",
+        peer: details?.runId ? resolveCommunicationPeer(state, details.runId, details.childIndex ?? 0, details.childId ?? details.agent) : "Subagent",
+        message: legacySupervisorBody(typeof message.content == "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.text).join(`
+`)),
+        kind: customType === SUBAGENT_SUPERVISOR_ANSWER_TYPE ? "answer" : communicationKind(details?.reason)
+      };
+      return renderCommunicationCard(communication, options.expanded, theme);
+    });
+  pi.registerEntryRenderer(SUPERVISOR_PROGRESS_TYPE, (entry, options, theme) => {
+    let communication = readCommunication(entry.data?.communication);
+    return communication ? renderCommunicationCard(communication, options.expanded, theme) : void 0;
+  });
+}
 function askTimeoutMs2() {
   let parsed = Number(process.env.PI_INTERCOM_ASK_TIMEOUT_MS);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ASK_TIMEOUT_MS2;
@@ -5012,7 +4975,7 @@ function hasTool(pi, name) {
 function parseRequestFile(file, channelDir) {
   try {
     let parsed = JSON.parse(fs7.readFileSync(file, "utf-8"));
-    return parsed.type !== "subagent.supervisor.request" || typeof parsed.id != "string" || !parsed.id || parsed.reason !== "need_decision" && parsed.reason !== "interview_request" && parsed.reason !== "progress_update" || typeof parsed.message != "string" || !parsed.message || typeof parsed.runId != "string" || typeof parsed.agent != "string" || typeof parsed.childIndex != "number" ? void 0 : { ...parsed, channelDir, requestFile: file };
+    return parsed.type !== "subagent.supervisor.request" || parsed.supervisorSessionId !== void 0 && (typeof parsed.supervisorSessionId != "string" || !parsed.supervisorSessionId.trim()) || typeof parsed.id != "string" || !parsed.id || parsed.reason !== "need_decision" && parsed.reason !== "interview_request" && parsed.reason !== "progress_update" && parsed.reason !== "handoff" || parsed.protocolVersion !== void 0 && parsed.protocolVersion !== 2 || parsed.protocolVersion === 2 && parsed.expectsReply !== (parsed.reason === "need_decision" || parsed.reason === "interview_request") || parsed.reason === "handoff" && parsed.protocolVersion !== 2 || parsed.description !== void 0 && typeof parsed.description != "string" || typeof parsed.message != "string" || !parsed.message || typeof parsed.runId != "string" || typeof parsed.agent != "string" || typeof parsed.childIndex != "number" ? void 0 : { ...parsed, channelDir, requestFile: file };
   } catch {
     return;
   }
@@ -5022,7 +4985,7 @@ function hasPendingBlockingSupervisorRequest(runId, sessionId, now = Date.now())
     return !1;
   for (let { channelDir, file } of listRequestFiles()) {
     let request = parseRequestFile(file, channelDir);
-    if (request?.expectsReply && request.runId === runId && !(sessionId && request.orchestratorSessionId && request.orchestratorSessionId !== sessionId) && !fs7.existsSync(replyPath(request.channelDir, request.id)) && !(now > requestExpiresAt(request, now)))
+    if (request?.expectsReply && request.runId === runId && !(sessionId && (request.supervisorSessionId ?? request.orchestratorSessionId) !== sessionId) && !fs7.existsSync(replyPath(request.channelDir, request.id)) && !(now > requestExpiresAt(request, now)))
       return !0;
   }
   return !1;
@@ -5117,9 +5080,16 @@ function currentContextSessionId(state, ctx) {
   }
   return state.currentSessionId ?? void 0;
 }
+function currentSupervisorSessionId(state, ctx) {
+  try {
+    return ctx.sessionManager.getSessionFile?.() ?? currentContextSessionId(state, ctx);
+  } catch {
+    return state.currentSessionId ?? void 0;
+  }
+}
 function requestMatchesContext(request, state, ctx) {
-  let currentSessionId = currentContextSessionId(state, ctx);
-  return !!(currentSessionId && request.orchestratorSessionId === currentSessionId);
+  let currentSessionId = request.supervisorSessionId !== void 0 ? currentSupervisorSessionId(state, ctx) : currentContextSessionId(state, ctx);
+  return !!(currentSessionId && (request.supervisorSessionId ?? request.orchestratorSessionId) === currentSessionId);
 }
 function removeRequestFile(file) {
   try {
@@ -5131,22 +5101,26 @@ function requestExpiresAt(request, now) {
   let expiresAt = request.expiresAt;
   return typeof expiresAt == "number" && Number.isFinite(expiresAt) ? expiresAt : Number.isFinite(request.createdAt) ? request.createdAt + askTimeoutMs2() : now;
 }
-function requestRunInactive(request, state) {
+function requestRunState(request, state) {
   if (state.foregroundControls.has(request.runId))
-    return !1;
+    return "active";
   let foregroundRun = state.foregroundRuns?.get(request.runId), foregroundChild = foregroundRun?.children.find((child) => child.index === request.childIndex && child.agent === request.agent) ?? foregroundRun?.children[request.childIndex];
   if (foregroundChild)
-    return foregroundChild.status !== "detached";
-  let asyncJob = state.asyncJobs.get(request.runId);
-  if (!asyncJob)
-    return !1;
-  if (asyncJob.status === "complete" || asyncJob.status === "failed" || asyncJob.status === "paused")
-    return !0;
-  let stepStatus = asyncJob.steps?.[request.childIndex]?.status;
-  return stepStatus === "complete" || stepStatus === "completed" || stepStatus === "failed" || stepStatus === "paused";
+    return foregroundChild.status === "stopped" ? "stopped" : foregroundChild.status === "detached" ? "active" : "inactive";
+  let job = state.asyncJobs.get(request.runId) ?? state.fleetJobs?.get(request.runId), asyncDir = job?.asyncDir ?? path8.join(ASYNC_DIR, safeSegment2(request.runId)), status = readStatus(asyncDir), runStatus = status?.state ?? job?.status, stepStatus = (status?.steps ?? job?.steps)?.[request.childIndex]?.status;
+  return fs7.existsSync(stopRequestPath(asyncDir)) || runStatus === "stopped" || job?.status === "stopped" || status?.stopped || stepStatus === "stopped" ? "stopped" : ["complete", "failed", "paused"].includes(runStatus ?? "") || ["complete", "completed", "failed", "paused"].includes(stepStatus ?? "") ? "inactive" : "active";
 }
 function requestLifecycle(request, state, ctx, now) {
-  return ctx && !requestMatchesContext(request, state, ctx) ? "wrong-session" : fs7.existsSync(request.requestFile) ? request.expectsReply && fs7.existsSync(replyPath(request.channelDir, request.id)) ? "resolved" : request.expectsReply && now > requestExpiresAt(request, now) ? "expired" : request.expectsReply && requestRunInactive(request, state) ? "inactive" : "pending" : "missing";
+  if (ctx && !requestMatchesContext(request, state, ctx))
+    return "wrong-session";
+  if (!fs7.existsSync(request.requestFile))
+    return "missing";
+  if (request.expectsReply && fs7.existsSync(replyPath(request.channelDir, request.id)))
+    return "resolved";
+  if (request.expectsReply && now > requestExpiresAt(request, now))
+    return "expired";
+  let runState = requestRunState(request, state);
+  return runState === "stopped" || request.expectsReply && runState === "inactive" ? "inactive" : "pending";
 }
 function cleanupRequestLifecycle(request, lifecycle) {
   (lifecycle === "resolved" || lifecycle === "expired" || lifecycle === "inactive") && removeRequestFile(request.requestFile);
@@ -5162,9 +5136,9 @@ function formatPendingLine(request) {
   let replyHint = request.expectsReply ? ` Reply: ${NATIVE_SUPERVISOR_TOOL_NAME}({ action: "reply", replyTo: "${request.id}", message: "..." })` : "";
   return `- ${request.id}: ${request.agent} [${request.runId}#${request.childIndex}] ${request.reason}.${replyHint}`;
 }
-function requestVisibleText(request) {
-  let lines = [request.message];
-  return request.expectsReply && lines.push("", `Reply with: ${NATIVE_SUPERVISOR_TOOL_NAME}({ action: "reply", replyTo: "${request.id}", message: "..." })`), lines.join(`
+function requestVisibleText(request, communication) {
+  let lines = [`From: ${communication.peer}`, "", communication.message];
+  return request.reason === "interview_request" && lines.push("", "Reply with JSON matching the requested interview shape."), request.expectsReply && lines.push("", `Reply with: ${NATIVE_SUPERVISOR_TOOL_NAME}({ action: "reply", replyTo: "${request.id}", message: "..." })`), lines.join(`
 `);
 }
 function writeReply(request, message) {
@@ -5213,6 +5187,13 @@ function buildParentIntercomTool(pending, state, name = "intercom") {
     label: name === "intercom" ? "Intercom" : "Subagent Supervisor",
     description: PARENT_ASK_DESCRIPTION,
     parameters: ParentSupervisorParamsSchema,
+    renderCall(args, theme, context) {
+      let request = args.action === "reply" ? pending.get(args.replyTo) : void 0, peer = request ? requestCommunication(request, state).peer : args.id ? resolveCommunicationPeer(state, args.id, args.index ?? 0, args.childId) : "Subagent";
+      return renderCommunicationCall(name, args, theme, context, args.message ? { direction: "to", peer, message: args.message, kind: args.action === "ask" ? "question" : "reply" } : void 0);
+    },
+    renderResult(result2, options, theme, context) {
+      return renderCommunicationResult(result2.content, result2.details, options.expanded, context.isError, theme);
+    },
     async execute(_id, params) {
       refreshPendingRequests(pending, state, state.lastUiContext ?? void 0);
       let input = params;
@@ -5225,7 +5206,7 @@ function buildParentIntercomTool(pending, state, name = "intercom") {
       }
       if (input.action === "reply") {
         let request = resolvePendingRequest(pending, input);
-        return writeReply(request, input.message ?? ""), pending.delete(request.id), { content: [{ type: "text", text: `Replied to supervisor request ${request.id}.` }], details: { replyTo: request.id, runId: request.runId, agent: request.agent } };
+        return writeReply(request, input.message ?? ""), pending.delete(request.id), { content: [{ type: "text", text: `Replied to ${requestCommunication(request, state).peer}.` }], details: { replyTo: request.id, runId: request.runId, agent: request.agent, communication: { ...requestCommunication(request, state), direction: "to", kind: "reply", message: input.message } } };
       }
       if (input.action === "ask")
         return askRunningAsyncChild({
@@ -5244,32 +5225,33 @@ function buildParentIntercomTool(pending, state, name = "intercom") {
   };
 }
 function questionMatchesParentContext(question, state, ctx) {
-  let sessionId = currentContextSessionId(state, ctx);
+  let sessionId = currentSupervisorSessionId(state, ctx);
   return !(!sessionId || question.parentSessionId !== sessionId || (state.sessionGeneration ?? 0) !== question.parentGeneration);
 }
-function notifyQuestionTerminal(pi, question, channelDir) {
+function notifyQuestionTerminal(pi, question, channelDir, state) {
   if (!supervisorQuestionIsTerminal(question) || question.notifiedAt || (pi.events?.emit(SUBAGENT_QUESTION_EVENT, {
     questionId: question.id,
     state: supervisorQuestionPublicState(question),
     runId: question.runId
   }), isQuestionWaitActive(question.id)) || !claimQuestionNotification(channelDir, question.id))
     return;
-  let state = supervisorQuestionPublicState(question);
+  let outcome = supervisorQuestionPublicState(question), communication = { direction: "from", peer: question.childDescription ?? resolveCommunicationPeer(state, question.runId, question.childIndex, question.childId), message: question.answer ?? question.cancelReason ?? outcome, kind: "answer" };
   pi.sendMessage({
     customType: SUBAGENT_SUPERVISOR_ANSWER_TYPE,
     content: formatSupervisorQuestionAnswer(question),
-    display: state === "answered",
+    display: outcome === "answered",
     details: {
       questionId: question.id,
-      state,
+      state: outcome,
+      communication,
       runId: question.runId,
       childIndex: question.childIndex,
       childId: question.childId,
       reason: question.reason,
-      answered: state === "answered",
+      answered: outcome === "answered",
       delivered: !!question.deliveredAt
     }
-  }, { triggerTurn: state === "answered" });
+  }, { triggerTurn: outcome === "answered" });
 }
 function pollSupervisorQuestions(pi, state, ctx) {
   for (let channelDir of listSupervisorChannelDirs())
@@ -5277,11 +5259,11 @@ function pollSupervisorQuestions(pi, state, ctx) {
       if (!questionMatchesParentContext(question, state, ctx))
         continue;
       let current = reconcileAsyncQuestion(channelDir, question, state);
-      notifyQuestionTerminal(pi, current, channelDir);
+      notifyQuestionTerminal(pi, current, channelDir, state);
     }
 }
 function createNativeSupervisorChannel(pi, state) {
-  let pending = /* @__PURE__ */ new Map(), seenFiles = /* @__PURE__ */ new Set(), poller, lastStaleCleanupAt = 0, registerParentTools = () => {
+  let pending = /* @__PURE__ */ new Map(), seenFiles = /* @__PURE__ */ new Set(), deliveredRequests = /* @__PURE__ */ new Set(), poller, lastStaleCleanupAt = 0, registerParentTools = () => {
     hasTool(pi, NATIVE_SUPERVISOR_TOOL_NAME) || pi.registerTool(buildParentIntercomTool(pending, state, NATIVE_SUPERVISOR_TOOL_NAME)), hasTool(pi, "intercom") || pi.registerTool(buildParentIntercomTool(pending, state));
   }, cleanupStaleChannelsIfDue = () => {
     let nowMs = Date.now();
@@ -5322,19 +5304,25 @@ function createNativeSupervisorChannel(pi, state) {
         seenFiles.add(file), cleanupRequestLifecycle(request, lifecycle);
         continue;
       }
-      if (seenFiles.add(file), request.expectsReply ? pending.set(request.id, request) : removeRequestFile(request.requestFile), pi.sendMessage({
-        customType: "subagent_supervisor_request",
-        content: requestVisibleText(request),
+      if (request.expectsReply && pending.set(request.id, request), deliveredRequests.has(request.id)) {
+        seenFiles.add(file);
+        continue;
+      }
+      let communication = requestCommunication(request, state), details = {
+        id: request.id,
+        reason: request.reason,
+        expectsReply: request.expectsReply,
+        runId: request.runId,
+        agent: request.agent,
+        childIndex: request.childIndex,
+        communication
+      };
+      if (request.reason === "progress_update" && request.protocolVersion === 2 ? pi.appendEntry(SUPERVISOR_PROGRESS_TYPE, details) : pi.sendMessage({
+        customType: SUPERVISOR_REQUEST_TYPE,
+        content: requestVisibleText(request, communication),
         display: !0,
-        details: {
-          id: request.id,
-          reason: request.reason,
-          expectsReply: request.expectsReply,
-          runId: request.runId,
-          agent: request.agent,
-          childIndex: request.childIndex
-        }
-      }), request.expectsReply) {
+        details
+      }, { triggerTurn: request.expectsReply || request.reason === "handoff" }), deliveredRequests.add(request.id), seenFiles.add(file), request.expectsReply || removeRequestFile(request.requestFile), request.expectsReply) {
         let job = state.asyncJobs.get(request.runId);
         job && (job.activityState = "needs_attention");
         let events = pi.events;
@@ -5355,10 +5343,17 @@ function createNativeSupervisorChannel(pi, state) {
   };
   return {
     start: () => {
-      poller || (registerParentTools(), poll(), poller = setInterval(poll, CHANNEL_POLL_MS), poller.unref?.());
+      if (!poller) {
+        registerParentTools();
+        for (let entry of state.lastUiContext?.sessionManager.getBranch?.() ?? []) {
+          let data = entry.type === "custom_message" && entry.customType === SUPERVISOR_REQUEST_TYPE ? entry.details : entry.type === "custom" && entry.customType === SUPERVISOR_PROGRESS_TYPE ? entry.data : void 0;
+          data && typeof data == "object" && "id" in data && typeof data.id == "string" && deliveredRequests.add(data.id);
+        }
+        poll(), poller = setInterval(poll, CHANNEL_POLL_MS), poller.unref?.();
+      }
     },
     dispose: () => {
-      cancelOwnedQuestions("parent supervisor channel disposed"), poller && clearInterval(poller), poller = void 0, pending.clear(), seenFiles.clear();
+      cancelOwnedQuestions("parent supervisor channel disposed"), poller && clearInterval(poller), poller = void 0, pending.clear(), seenFiles.clear(), deliveredRequests.clear();
     },
     pending,
     cancelOwnedQuestions,
@@ -5930,6 +5925,8 @@ async function waitForSubagents(params, signal, deps) {
     ].join(", ");
     if (signal?.aborted)
       return result(`Wait aborted after ${formatDuration(now() - startedAt)}. Still active: ${stillActive}.`, !0);
+    if (deps.shouldYield?.())
+      return result("Wait yielded for pending session messages; background work remains active.");
     if (now() - startedAt >= timeoutMs)
       return result(`Wait timed out after ${formatDuration(timeoutMs)} with ${activeInitialRuns.length} async run(s) and ${activeInitialProviderItems.length} provider item(s) still active: ${stillActive}. The work keeps going; call subagent_wait again or inspect subagent status.`, !0);
     try {
@@ -5965,7 +5962,7 @@ function registerWaitTool(pi, state, enabled = resolveWaitToolConfig().enabled,
     label: "Subagent Wait",
     description: `Block until background work owned by this session changes, then return.
 
-In an interactive chat, do not call this merely to wait: return control to the user and let Pi wake the session on completion. Call it when the current request must run to completion in this turn, when a skill cannot return before its work finishes, or in a non-interactive run where there is no next turn.
+Call this when the current turn or skill must finish after its children. For normal interactive completion, yield and let lunR wake the session. Headless sessions auto-drain current-session work after the agent turn.
 
 \u2022 { } \u2014 return when the first initially active async run or registered provider item finishes, or when a subagent needs attention.
 \u2022 { all: true } \u2014 wait for every async run and provider item that was active when the call began.
@@ -6005,7 +6002,7 @@ async function drainOutstandingWork(deps) {
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
     throw new Error("Auto-drain timeoutMs must be a positive finite number.");
   let deadlineAt = now() + timeoutMs, hasWork = deps.hasWork ?? hasOutstandingWork, wait = deps.wait ?? waitForSubagents;
-  for (; hasWork(sessionId, now()); ) {
+  for (; !deps.hasPendingMessages?.() && hasWork(sessionId, now()); ) {
     let remainingMs = deadlineAt - now();
     if (remainingMs <= 0)
       throw new Error(`Auto-drain timed out after ${timeoutMs}ms with background work still active in session '${sessionId}'.`);
@@ -6014,6 +6011,7 @@ async function drainOutstandingWork(deps) {
       events: deps.events,
       now,
       stopOnAttention: !1,
+      shouldYield: deps.hasPendingMessages,
       failOnFailedRuns: !0
     });
     if (waitResult.isError)
@@ -6165,7 +6163,32 @@ function buildCompletionDetails(result2) {
     status,
     ...result2.source ? { source: result2.source } : {},
     ...taskInfo ? { taskInfo } : {},
-    resultPreview: summary,
+    resultPreview: [
+      result2.id ? `Run: ${result2.id}` : void 0,
+      result2.asyncDir ? `Async dir: ${result2.asyncDir}` : void 0,
+      result2.results?.length ? result2.results.map((child, index) => {
+        let output = child.summary ?? (child.error ? `${child.error}
+
+Output:
+${child.output}` : child.output), report = child.acceptance?.childReport, childIndex = child.index ?? index;
+        return [
+          `${childIndex + 1}. ${child.agent} [${child.status ?? resolveSubagentResultStatus({ success: child.success, state: result2.state })}]`,
+          child.artifactPath ? `Output artifact: ${child.artifactPath}` : void 0,
+          child.sessionPath ? `Session: ${child.sessionPath}` : void 0,
+          child.sessionPath && result2.id && result2.source !== "foreground" ? `Revive: subagent({ action: "resume", id: ${JSON.stringify(result2.id)}, index: ${childIndex}, message: "..." })` : void 0,
+          ...formatNestedResultLines(child.children),
+          output,
+          report ? `\`\`\`acceptance-report
+${JSON.stringify(report, null, 2)}
+\`\`\`` : void 0
+        ].filter((line) => line !== void 0).join(`
+`);
+      }).join(`
+
+`) : summary
+    ].filter((line) => line !== void 0).join(`
+
+`),
     ...typeof result2.durationMs == "number" ? { durationMs: result2.durationMs } : {},
     ...session ? { sessionLabel: session.label, sessionValue: session.value } : {}
   };
@@ -6278,16 +6301,17 @@ var CUSTOM_TOOL_DESCRIPTION_FILE = "subagent-tool-description.md", CUSTOM_TOOL_D
 \u2022 Choose the lowest tier that can reliably complete the task.
 \u2022 light: Use for simple, straightforward tasks that require little reasoning. Good for quick checks, finding information, collecting facts for research, inspecting a small amount of code, or verifying a specific fact.
 \u2022 standard: Use for moderately difficult work and everyday coding tasks. Good for writing simple code, fixing a clearly described bug, reviewing a focused change, or completing work with clear requirements. Use heavy when the task requires deep architectural understanding or complex reasoning.
-\u2022 heavy: Use for complex or ambiguous tasks that require deep reasoning and strong code understanding. Good for implementing complex plans, debugging difficult or poorly understood problems, reviewing large or high-risk changes, and making architectural decisions.`, SUBAGENT_SAFETY_GUIDANCE = `SAFETY-CRITICAL SUBAGENT GUIDANCE:
+\u2022 heavy: Use for complex or ambiguous tasks that require deep reasoning and strong code understanding. Good for implementing complex plans, debugging difficult or poorly understood problems, reviewing large or high-risk changes, and making architectural decisions.`, SUBAGENT_COORDINATION_GUIDANCE = "Define file ownership, local decision authority, and required outputs at launch. Establish shared contracts before dependent parallel work; use chains and artifacts to pass results. Native child intercom reaches the supervisor only, not siblings. Reserve parent relays for actionable exceptions, not routine progress or implementation approvals.", SUBAGENT_SAFETY_GUIDANCE = `SAFETY-CRITICAL SUBAGENT GUIDANCE:
 \u2022 Prompt children directly. There is no agent roster. Every execution task needs task (the full child prompt) and description (a concise UI label).
 \u2022 Every executable child chooses exactly one of tier: "light"|"standard"|"heavy" (default) or model: "provider/id" when the user names a model. Do not pass both, and do not use inherit. Missing, disabled, unconfigured, unavailable, or unauthenticated selections fail before launch.
 \u2022 Optional thinking (off/minimal/low/medium/high/xhigh/max) is only valid with an explicit model. Tier launches use the configured tier thinking level.
 ${SUBAGENT_TIER_GUIDANCE}
 \u2022 permissions is "full" or "read-only". Omitted permissions means full. Plan-mode parents must pass permissions: "read-only"; full or omitted launches are rejected.
 \u2022 Keep execution and control separate: omit action for SINGLE/PARALLEL/CHAIN execution; use action only for status/interrupt/stop/resume/steer/append-step/doctor/watchdog.status|check|recommend-model/schedule*.
-\u2022 Async/background runs: launch with async:true only when work can proceed independently. Do not sleep or poll status just to wait. In an interactive session, normally return control and let lunR wake you; use subagent_wait when this request must run to completion in the current turn or skill. Headless sessions auto-drain current-session work.
+\u2022 ${SUBAGENT_ASYNC_GUIDANCE}
 \u2022 Child-safety boundary: ordinary children are not orchestrators and must not run subagents. Only explicitly configured fanout children may use the child-safe subagent tool, still bounded by depth/session limits.
 \u2022 Writing/review safety: keep one full-access writer for the same cwd/worktree. Use fresh-context permissions: "read-only" children for independent review, then have the parent synthesize and apply fixes as the sole writer unless an isolated worktree was intentionally requested.
+\u2022 ${SUBAGENT_COORDINATION_GUIDANCE}
 \u2022 Artifacts/status essentials: chain outputs live under {chain_dir}; async runs expose asyncId/asyncDir with status.json, events.jsonl, output logs, and status via { action: "status", id }. Include output paths and residual risks when reporting results.`, FULL_SUBAGENT_TOOL_DESCRIPTION = `Delegate work to generic children by prompting them directly. There are no named agent types.
 
 EXECUTION (use exactly ONE mode):
@@ -6339,6 +6363,7 @@ EXECUTE:
 \u2022 description is required (single-line, max 80 chars, UI only). task is the full child prompt. permissions omitted = full. Plan-mode parents must pass permissions:"read-only".
 \u2022 Exactly one of tier:"light"|"standard"|"heavy" (default) or model:"provider/id" when the user names a model. thinking only with model. No inherit; fail closed on unavailable selections. Children always start fresh. timeoutMs/maxRuntimeMs apply to foreground and async/background runs.
 ${SUBAGENT_TIER_GUIDANCE}
+\u2022 ${SUBAGENT_COORDINATION_GUIDANCE}
 \u2022 Chain templates may use {task}, {previous}, {chain_dir}, and named outputs. Parallel worktree isolation requires a clean git repo.
 \u2022 Chain example: { chain: [{task:"Analyze {task}", description:"Analyze request", tier:"standard"}, {parallel: [{task:"Check {previous}", description:"Check prior result", tier:"light", permissions:"read-only", count: 3}]}] }
 
@@ -6348,7 +6373,7 @@ CONTROL:
 \u2022 Opt-in schedule actions: schedule, schedule-list, schedule-status, schedule-cancel. Schedule only explicit delayed runs the user asked for.
 
 ASYNC / WAIT:
-\u2022 async:true detaches background work. Do not sleep or poll just to wait. Interactive sessions normally yield for completion notifications; use subagent_wait for run-to-completion turns or skills. Headless sessions auto-drain current-session work.
+\u2022 ${SUBAGENT_ASYNC_GUIDANCE}
 \u2022 Status and artifacts live under asyncId/asyncDir with status.json, events.jsonl, output logs, session files, and { action:"status", id:"..." }.
 
 SAFETY:
@@ -6478,30 +6503,58 @@ function effectiveParallelTaskCount(tasks) {
     return total + count;
   }, 0);
 }
-function callIsAsync(args, asyncByDefault) {
-  return args?.clarify === !0 ? !1 : args?.async === !0 ? !0 : args?.async === !1 ? !1 : asyncByDefault === !0;
-}
-function renderSubagentCall(args, theme, context, options) {
+function matchingActionJobs(state, requestedId) {
+  let jobs = /* @__PURE__ */ new Map();
+  for (let job of state.asyncJobs.values())
+    jobs.set(job.asyncId, job);
+  for (let job of state.fleetJobs?.values() ?? [])
+    jobs.set(job.asyncId, job);
+  let exact = jobs.get(requestedId);
+  return exact ? [exact] : [...jobs.values()].filter((job) => job.asyncId.startsWith(requestedId));
+}
+function resolveSubagentActionDisplayTitle(args, state) {
+  let requestedId = (args.id || args.runId || "").trim();
+  if (!requestedId)
+    return;
+  let matches = matchingActionJobs(state, requestedId);
+  if (matches.length !== 1)
+    return;
+  let job = matches[0], steps = job.steps ?? [];
+  if (Number.isInteger(args.index)) {
+    let step = steps.find((candidate) => candidate.index === args.index) ?? steps[args.index];
+    return step ? childRowLabel(step) : void 0;
+  }
+  if (steps.length === 1)
+    return childRowLabel(steps[0]);
+  if (steps.length > 1)
+    return `${job.mode ?? "subagent"} run`;
+  if (job.agents?.length === 1)
+    return job.agents[0];
+  if (job.agents?.length)
+    return `${job.mode ?? "subagent"} run`;
+}
+function renderSubagentCall(rawArgs, theme, context, options) {
+  let args = resolveSubagentRequestParams(rawArgs);
   if (args.action) {
-    let target = args.id || args.runId || "";
-    return new Text2(`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`, 0, 0);
+    let resolvedTitle = context?.result?.details?.displayTitle || options?.resolveActionTitle?.(args), target = resolvedTitle || args.id || args.runId || "";
+    return (args.action === "steer" || args.action === "resume") && args.message ? renderCommunicationCall("subagent", args, theme, context, { direction: "to", peer: resolvedTitle || "Subagent", kind: "steer", message: args.message }) : new Text3(`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`, 0, 0);
   }
-  let isParallel = (args.tasks?.length ?? 0) > 0, parallelCount = effectiveParallelTaskCount(args.tasks), asyncMark = callIsAsync(args, options?.asyncByDefault) ? `${theme.fg("warning", "async")} ` : "";
+  let isParallel = (args.tasks?.length ?? 0) > 0, parallelCount = effectiveParallelTaskCount(args.tasks), asyncMark = subagentLaunchRunsAsync(args) ? `${theme.fg("warning", "async")} ` : "";
   if (args.chain?.length)
-    return new Text2(`${theme.fg("toolTitle", theme.bold("subagent "))}${asyncMark}chain (${args.chain.length})`, 0, 0);
+    return new Text3(`${theme.fg("toolTitle", theme.bold("subagent "))}${asyncMark}chain (${args.chain.length})`, 0, 0);
   if (isParallel)
-    return new Text2(`${theme.fg("toolTitle", theme.bold("subagent "))}${asyncMark}parallel (${parallelCount})`, 0, 0);
+    return new Text3(`${theme.fg("toolTitle", theme.bold("subagent "))}${asyncMark}parallel (${parallelCount})`, 0, 0);
   let description = !context?.result && !context?.isPartial && !context?.expanded && !context?.isError ? theme.fg("accent", args.description || args.task || "?") : "", title = theme.fg("toolTitle", theme.bold("subagent")), rest = [asyncMark.trim() ? theme.fg("warning", "async") : "", description].filter(Boolean).join(" ");
-  return new Text2(rest ? `${title} ${rest}` : title, 0, 0);
+  return new Text3(rest ? `${title} ${rest}` : title, 0, 0);
 }
 function renderSubagentNotify(details, theme) {
   let status = typeof details?.status == "string" ? details.status : "", icon = status === "completed" ? theme.fg("success", "\u2713") : status === "failed" ? theme.fg("error", "\u2717") : theme.fg("warning", "\u25A0"), title = details?.agent || "child";
-  return new Text2(`${icon} ${theme.bold(title)} ${theme.fg("dim", status)}`, 0, 0);
+  return new Text3(`${icon} ${theme.bold(title)} ${theme.fg("dim", status)}`, 0, 0);
 }
 function ensureSubagentResultAnimation(context) {
   let state = context.state;
   state.subagentResultAnimationTimer || typeof context.invalidate == "function" && (state.frame === void 0 && (state.frame = 0), state.subagentResultAnimationTimer = setInterval(() => {
-    state.frame = ((state.frame ?? 0) + 1) % 10;
+    state.frame = (state.frame ?? 0) + 1;
     try {
       let entries = state.animEntries;
       if (entries?.length && typeof context.requestRender == "function") {
@@ -6513,7 +6566,7 @@ function ensureSubagentResultAnimation(context) {
         context.invalidate();
     } catch {
     }
-  }, 80));
+  }, SUBAGENT_PAINT_INTERVAL_MS));
 }
 function isSlashResultError(result2) {
   return result2.details?.results.some((entry) => entry.exitCode !== 0 && entry.progress?.status !== "running") || !1;
@@ -6523,14 +6576,14 @@ function isStaleExtensionContextError(error) {
 }
 function rebuildSlashResultContainer(container, result2, options, theme) {
   container.clear(), container.addChild(new Spacer2(1));
-  let boxTheme = isSlashResultRunning(result2) ? "toolPendingBg" : isSlashResultError(result2) ? "toolErrorBg" : "toolSuccessBg", box = new Box(1, 1, (text) => theme.bg(boxTheme, text));
+  let boxTheme = isSlashResultRunning(result2) ? "toolPendingBg" : isSlashResultError(result2) ? "toolErrorBg" : "toolSuccessBg", box = new Box2(1, 1, (text) => theme.bg(boxTheme, text));
   box.addChild(renderSubagentResult(result2, options, theme)), container.addChild(box);
 }
 function createSlashResultComponent(details, options, theme) {
-  let container = new Container2(), lastVersion = -1;
+  let container = new Container3(), lastVersion = -1;
   return container.render = (width) => {
     let snapshot = getSlashRenderableSnapshot(details);
-    return (snapshot.version !== lastVersion || isSlashResultRunning(snapshot.result)) && (lastVersion = snapshot.version, rebuildSlashResultContainer(container, snapshot.result, options, theme)), Container2.prototype.render.call(container, width);
+    return (snapshot.version !== lastVersion || isSlashResultRunning(snapshot.result)) && (lastVersion = snapshot.version, rebuildSlashResultContainer(container, snapshot.result, options, theme)), Container3.prototype.render.call(container, width);
   }, container;
 }
 function registerSubagentExtension(pi) {
@@ -6543,7 +6596,7 @@ function registerSubagentExtension(pi) {
     } catch {
     }
   ensureAccessibleDir(RESULTS_DIR), ensureAccessibleDir(ASYNC_DIR), cleanupOldChainDirs();
-  let config = loadConfig(), waitToolConfig = resolveWaitToolConfig(config.waitTool), asyncByDefault = config.asyncByDefault === !0, tempArtifactsDir = getArtifactsDir(null);
+  let config = normalizeAsyncLaunchConfig(loadConfig()), waitToolConfig = resolveWaitToolConfig(config.waitTool), tempArtifactsDir = getArtifactsDir(null);
   cleanupAllArtifactDirs(DEFAULT_ARTIFACT_CONFIG.cleanupDays);
   let state = {
     baseCwd: "",
@@ -6594,18 +6647,17 @@ function registerSubagentExtension(pi) {
       }), markLaunchReady = () => {
         launchReady || (launchReady = !0, pendingLaunches.delete(launchReadyPromise), pendingAsyncLaunches.delete(launchReadyPromise), resolveLaunchReady());
       };
-      pendingLaunches.add(launchReadyPromise), (params.task || params.tasks || params.chain) && !params.clarify && (params.async === !0 || params.async === void 0 && asyncByDefault || config.forceTopLevelAsync === !0) && pendingAsyncLaunches.add(launchReadyPromise);
+      pendingLaunches.add(launchReadyPromise), isAsyncSubagentExecution(resolveSubagentRequestParams(params)) && pendingAsyncLaunches.add(launchReadyPromise);
       try {
         let currentGeneration = generation;
         if (signal?.throwIfAborted(), !executorPromise) {
-          let pending = import("./subagent-executor-SRFC26SJ.js").then(({ createSubagentExecutor }) => {
+          let pending = import("./subagent-executor-MLUMBWCP.js").then(({ createSubagentExecutor }) => {
             if (generation !== currentGeneration)
               throw new Error("Subagent session changed before initialization");
             return createSubagentExecutor({
               pi,
               state,
               config,
-              asyncByDefault,
               waitToolEnabled: waitToolConfig.enabled,
               handleScheduledRunAction: (params2, ctx2) => scheduledRunManager.handleToolCall(params2, ctx2),
               watchdog: mainWatchdog,
@@ -6628,24 +6680,32 @@ function registerSubagentExtension(pi) {
       }
     }
   };
-  executorExecute = executor.execute, pi.registerMessageRenderer(SLASH_RESULT_TYPE, (message, options, theme) => {
+  executorExecute = executor.execute, registerSupervisorRenderers(pi, state), pi.registerMessageRenderer(SLASH_RESULT_TYPE, (message, options, theme) => {
     let details = resolveSlashMessageDetails(message.details);
     if (details)
       return createSlashResultComponent(details, options, theme);
   }), pi.registerMessageRenderer(SLASH_TEXT_RESULT_TYPE, (message, _options, _theme) => {
     let content = typeof message.content == "string" ? message.content : message.content.filter((entry) => entry.type === "text").map((entry) => entry.text).join(`
 `);
-    return new Text2(content, 0, 0);
+    return new Text3(content, 0, 0);
   }), pi.registerMessageRenderer("subagent-notify", (message, _options, theme) => {
     let content = typeof message.content == "string" ? message.content : "", details = message.details ?? parseSubagentNotifyContent(content);
-    return details ? renderSubagentNotify(details, theme) : new Text2(content, 0, 0);
+    return details ? renderSubagentNotify(details, theme) : new Text3(content, 0, 0);
   }), pi.registerMessageRenderer(SUBAGENT_STEERING_MESSAGE_TYPE, (message, _options, theme) => {
     let details = message.details;
     if (details)
-      return new Text2(theme.fg(details.state === "recovered" ? "warning" : "error", formatSteeringNotice(details)), 0, 0);
+      return new Text3(theme.fg(details.state === "recovered" ? "warning" : "error", formatSteeringNotice(details)), 0, 0);
   }), pi.registerMessageRenderer(SUBAGENT_CONTROL_MESSAGE_TYPE, () => {
   });
-  let executeSubagentCollapsed = (id, params, signal, onUpdate, ctx) => (ctx.hasUI && ctx.ui.setToolsExpanded(!1), executor.execute(id, params, signal, onUpdate, ctx)), slashBridge = registerSlashSubagentBridge({
+  let executeSubagentCollapsed = async (id, params, signal, onUpdate, ctx) => {
+    ctx.hasUI && ctx.ui.setToolsExpanded(!1);
+    let isCommunication = (params.action === "steer" || params.action === "resume") && typeof params.message == "string", displayTitle = isCommunication ? resolveSubagentActionDisplayTitle(params, state) : void 0, jobs = isCommunication ? matchingActionJobs(state, (params.id || params.runId || "").trim()) : [], targetNames = new Map(jobs.length === 1 ? jobs[0].steps?.map((step, index) => [step.index ?? index, childRowLabel(step)]) : []), result2 = await executor.execute(id, params, signal, onUpdate, ctx);
+    if (displayTitle && result2.details && (result2.details.displayTitle = displayTitle), isCommunication && result2.details) {
+      let targets = result2.details.steering?.targets.map((target) => targetNames.get(target.index) ?? `Subagent ${target.index + 1}`), peer = targets?.length ? targets.join(", ") : displayTitle || "Subagent";
+      result2.details.communication = { direction: "to", peer, kind: "steer", message: params.message };
+    }
+    return result2;
+  }, slashBridge = registerSlashSubagentBridge({
     events: pi.events,
     getContext: () => state.lastUiContext,
     execute: (id, params, signal, onUpdate, ctx) => executeSubagentCollapsed(id, params, signal, onUpdate, ctx)
@@ -6670,8 +6730,12 @@ function registerSubagentExtension(pi) {
     execute(id, params, signal, onUpdate, ctx) {
       return executeSubagentCollapsed(id, params, signal, onUpdate, ctx);
     },
-    renderCall: (args, theme, context) => renderSubagentCall(args, theme, context, { asyncByDefault }),
+    renderCall: (args, theme, context) => renderSubagentCall(args, theme, context, {
+      resolveActionTitle: (params) => resolveSubagentActionDisplayTitle(params, state)
+    }),
     renderResult(result2, options, theme, context) {
+      if (result2.details?.communication)
+        return renderCommunicationResult(result2.content, result2.details, options.expanded, context.isError, theme);
       subagentResultIsRunning(result2) ? ensureSubagentResultAnimation(context) : clearLegacyResultAnimationTimer(context);
       let state2 = context.state, entries = [];
       state2.animEntries = entries, subagentAnimSink.current = entries;
@@ -6689,7 +6753,7 @@ function registerSubagentExtension(pi) {
     launches.length !== 0 && await awaitWithAbort(Promise.all(launches).then(() => {
     }), signal);
   }), pi.on("agent_end", async (_event, ctx) => {
-    ctx.hasUI || await drainOutstandingWork({ state, events: pi.events });
+    ctx.hasUI || await drainOutstandingWork({ state, events: pi.events, hasPendingMessages: () => ctx.hasPendingMessages() });
   }), registerSlashCommands(pi, state);
   let eventUnsubscribeStoreKey = "__piSubagentEventUnsubscribes", controlNoticeSeenStoreKey = "__piSubagentVisibleControlNotices", previousEventUnsubscribes = globalStore[eventUnsubscribeStoreKey];
   if (Array.isArray(previousEventUnsubscribes)) {