@ashx-j/lunr-dev 0.2.19-dev.10.1 → 0.2.21-dev.12.1

package/dist/node-runtime/{pi-subagents-VKCLYIBY.js → pi-subagents-WEHV3W7H.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,
@@ -29,10 +29,10 @@ import {
   SUBAGENT_STEERING_NOTICE_EVENT,
   TEMP_ROOT_DIR,
   WIDGET_KEY,
-  aggregateStepStatus,
   assertJsonSchemaObject,
   attachNestedChildrenToResultChildren,
   buildSubagentResultIntercomPayload,
+  childRowLabel,
   cleanupAllArtifactDirs,
   cleanupOldArtifacts,
   cleanupOldChainDirs,
@@ -40,16 +40,16 @@ import {
   compactNestedResultChildren,
   deliverStopRequest,
   deliverSubagentResultIntercomEvent,
-  flatToLogicalStepIndex,
   formatActivityLabel,
   formatAgentRunningLabel,
   formatAsyncRunProgressLabel,
   formatAsyncRunTranscript,
+  formatCompactModelBadge,
   formatControlNoticeMessage,
   formatDuration,
   formatModelSelection,
   formatNestedAggregate,
-  formatParallelOutcome,
+  formatNestedResultLines,
   formatTokens,
   formatToolCall,
   formatUsage,
@@ -60,40 +60,54 @@ import {
   getSingleResultOutput,
   handleSubagentControlNotice,
   hasLiveNestedDescendants,
+  isAsyncSubagentExecution,
   listAsyncRuns,
+  normalizeAsyncLaunchConfig,
   normalizeParallelGroups,
   projectNestedRegistryForRoot,
   readStatus,
+  readSteerCapability,
   reconcileAsyncRun,
   reconcileNestedAsyncDescendants,
   registerMainWatchdog,
+  requestAsyncSteer,
   resolveAsyncRunLocation,
   resolveCurrentSessionId,
+  resolveSubagentRequestParams,
   resolveSubagentResultStatus,
+  resolveSubagentRunId,
   resolveTurnBudgetConfig,
   resolveWaitToolConfig,
   resolveWatchPath,
   sanitizeChildDescription,
   sanitizeSummary,
   shortenPath,
+  subagentLaunchRunsAsync,
   summarizeAsyncStatus,
   updateAsyncJobNestedProjection,
   validateAcceptanceInput,
   validateExecutionAcceptance,
   validateToolBudgetConfig,
   writeAtomicJson
-} from "./chunk-MUMMMTW4.js";
-import "./chunk-MGSB2C3M.js";
-import "./chunk-K72NVGUB.js";
+} from "./chunk-N3PNL74S.js";
+import {
+  createSubagentCancellation,
+  getSubagentSpinnerDefinition,
+  registerSubagentCancellation
+} from "./chunk-A3KMVBZV.js";
+import "./chunk-5ZH3ZFIZ.js";
+import "./chunk-ZVSORYRM.js";
+import "./chunk-GT5F3OKM.js";
 import "./chunk-53YJI7JU.js";
 import "./chunk-GZQHMEWL.js";
 import "./chunk-ZCHMJ34K.js";
-import "./chunk-5Q45AVQG.js";
-import "./chunk-ZRDIMBEQ.js";
-import "./chunk-M3LZLQW2.js";
-import "./chunk-5OLJGVCB.js";
+import "./chunk-LISUTZS3.js";
 import "./chunk-FVDOXRUD.js";
-import "./chunk-ZSEZY3II.js";
+import "./chunk-MW2XJZIK.js";
+import "./chunk-D466UAID.js";
+import "./chunk-M3LZLQW2.js";
+import "./chunk-VTPM5V35.js";
+import "./chunk-3ONQTOMR.js";
 import "./chunk-RQ2Q5IYR.js";
 import {
   keyText
@@ -106,10 +120,10 @@ import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/extension/index.js
-import { randomUUID as randomUUID3 } from "node:crypto";
-import * as fs9 from "node:fs";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import * as fs10 from "node:fs";
 import * as os from "node:os";
-import * as path11 from "node:path";
+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";
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/tui/render.js
@@ -172,7 +186,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)
@@ -180,7 +198,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)
@@ -240,6 +265,16 @@ function statJoin(theme, parts) {
 function formatTokenStat(tokens) {
   return `${formatTokens(tokens)} token`;
 }
+function usageTokenTotal(usage) {
+  return usage ? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) : 0;
+}
+function compactResultTokens(result2) {
+  let progress = result2.progress || result2.progressSummary;
+  if (progress && progress.tokens > 0)
+    return progress.tokens;
+  let fromUsage = usageTokenTotal(result2.usage);
+  return fromUsage > 0 ? fromUsage : progress?.tokens ?? 0;
+}
 function formatToolUseStat(count) {
   return `${count} tool use${count === 1 ? "" : "s"}`;
 }
@@ -250,7 +285,10 @@ function formatTotalCostStat(totalCost) {
   return totalCost.inputTokens && parts.push(`in:${formatTokens(totalCost.inputTokens)}`), totalCost.outputTokens && parts.push(`out:${formatTokens(totalCost.outputTokens)}`), totalCost.costUsd && parts.push(`$${totalCost.costUsd.toFixed(4)}`), parts.join(" ");
 }
 function liveDurationMs(progress, running, now) {
-  return progress ? !running || progress.lastActivityAt === void 0 ? progress.durationMs : progress.durationMs + Math.max(0, now - progress.lastActivityAt) : 0;
+  if (!progress)
+    return 0;
+  let durationMs = progress.durationMs ?? 0;
+  return !running || progress.lastActivityAt === void 0 ? durationMs : durationMs + Math.max(0, now - progress.lastActivityAt);
 }
 function formatProgressStats(theme, progress, includeDuration = !0, options = {}) {
   if (!progress)
@@ -290,13 +328,17 @@ function resultStatusLine(result2, output) {
 function resultGlyph(result2, output, theme, running = result2.progress?.status === "running", seed = progressRunningSeed(result2.progress ?? result2.progressSummary), frame) {
   return running ? frame !== void 0 ? theme.fg("accent", runningGlyph((seed ?? 0) + frame)) : theme.fg("accent", runningGlyph(seed)) : result2.detached || result2.stopped || result2.interrupted ? theme.fg("warning", "\u25A0") : result2.exitCode !== 0 ? theme.fg("error", "\u2717") : hasEmptyTextOutputWithoutOutputTarget(result2.task, output) ? theme.fg("warning", "\u2713") : theme.fg("success", "\u2713");
 }
-function formatCompactStatsHangLine(progress, width, paint = (s) => s, prefix = "  \u23BF  ", now = Date.now(), running = !1) {
-  let toolCount = progress?.toolCount ?? 0, tokens = progress?.tokens ?? 0, durationMs = liveDurationMs(progress, running, now), body = [
-    formatToolUseStat(toolCount),
-    formatTokenStat(tokens),
-    durationMs > 0 ? formatDuration(durationMs) : "0ms"
-  ].join(" \xB7 ");
-  return truncLine(paint(`${prefix}${body}`), width);
+function formatCompactRowStats(tokens, durationMs) {
+  return `${formatTokenStat(tokens)} \xB7 ${durationMs > 0 ? formatDuration(durationMs) : "0ms"}`;
+}
+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),
+    parts.terminalStatus ? theme.fg("dim", parts.terminalStatus) : ""
+  ].filter(Boolean).join(` ${theme.fg("dim", "\xB7")} `);
+  return truncLine(body, width);
 }
 function widgetRenderKey(job) {
   return JSON.stringify({
@@ -350,14 +392,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");
@@ -368,48 +405,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;
@@ -445,24 +440,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)
@@ -480,13 +467,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;
 }
@@ -551,38 +542,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 widgetStats(job, theme, now = Date.now()) {
-  let parts = [], stepsTotal = job.stepsTotal ?? job.agents?.length ?? 1;
-  if (job.activeParallelGroup) {
-    let running = job.runningSteps ?? (job.status === "running" ? 1 : 0), done = job.completedSteps ?? (job.status === "complete" ? stepsTotal : 0);
-    if (job.mode === "parallel")
-      job.status === "running" && running > 0 && parts.push(formatAgentRunningLabel(running)), stepsTotal > 0 && parts.push(`${done}/${stepsTotal} done`);
-    else {
-      let logicalStep = (job.currentStep !== void 0 ? job.parallelGroups?.find((group) => job.currentStep >= group.start && job.currentStep < group.start + group.count) : job.parallelGroups?.find((group) => group.start === 0))?.stepIndex ?? job.currentStep ?? 0, total = job.chainStepCount ?? stepsTotal, groupParts = [`${done}/${stepsTotal} done`];
-      job.status === "running" && running > 0 && groupParts.unshift(formatAgentRunningLabel(running)), parts.push(`step ${logicalStep + 1}/${total} \xB7 parallel group: ${groupParts.join(" \xB7 ")}`);
-    }
-  } else if (job.currentStep !== void 0)
-    if (job.mode === "chain" && job.parallelGroups?.length) {
-      let total = job.chainStepCount ?? stepsTotal;
-      parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups) + 1}/${total}`);
-    } else
-      parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
-  else stepsTotal > 1 && parts.push(`steps ${stepsTotal}`);
-  if (job.toolCount !== void 0 && parts.push(formatToolUseStat(job.toolCount)), job.totalTokens?.total && parts.push(formatTokenStat(job.totalTokens.total)), job.startedAt !== void 0) {
-    let end = job.status === "running" ? now : job.updatedAt;
-    end !== void 0 && parts.push(`${job.status === "running" ? "" : "ran for "}${formatDuration(Math.max(0, end - job.startedAt))}`);
-  }
-  return statJoin(theme, parts);
-}
-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})`) : "";
@@ -647,30 +606,28 @@ 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", startedAt = step?.startedAt ?? job.startedAt, endedAt = running ? now : step?.endedAt ?? step?.lastActivityAt ?? job.updatedAt ?? now, durationMs = step?.durationMs !== void 0 ? step.durationMs : startedAt !== void 0 ? Math.max(0, endedAt - startedAt) : 0;
-  return {
-    toolCount: step?.toolCount ?? job.toolCount ?? 0,
-    tokens: step?.tokens?.total ?? job.totalTokens?.total ?? 0,
-    durationMs
-  };
+  let running = (step?.status ?? job.status) === "running", tokens = step?.tokens?.total ?? job.totalTokens?.total ?? 0;
+  if (step?.durationMs !== void 0)
+    return {
+      tokens,
+      durationMs: liveDurationMs({ durationMs: step.durationMs, lastActivityAt: step.lastActivityAt }, running, now)
+    };
+  let startedAt = step?.startedAt ?? job.startedAt;
+  if (startedAt === void 0)
+    return { tokens, durationMs: 0 };
+  let endedAt = running ? now : step?.endedAt ?? step?.lastActivityAt ?? job.updatedAt ?? now;
+  return { tokens, durationMs: Math.max(0, endedAt - startedAt) };
 }
 function compactJobLead(job, step) {
   return compactRowLead({
@@ -679,18 +636,15 @@ function compactJobLead(job, step) {
   }) || widgetJobName(job);
 }
 function compactJobLines(job, step, theme, width, now = Date.now()) {
-  let running = (step?.status ?? job.status) === "running", lead = compactJobLead(job, step), modelBadge = formatModelSelection(step?.modelSelection, step?.model, step?.thinking), permissionBadge = step?.permissions ? theme.fg("dim", step.permissions) : "", glyph = step ? widgetStepGlyph(step.status, theme, running ? (widgetStepRunningSeed(step, step.index) ?? 0) + widgetAnimFrame(now) : widgetStepRunningSeed(step, step.index)) : widgetStatusGlyph(job, theme, now), hang = formatCompactStatsHangLine(compactJobProgress(job, step, now), width, (s) => theme.fg("dim", s), "  \u23BF  ", now, running);
-  return [
-    truncLine(`${glyph} ${themeBold(theme, lead)}${modelBadge ? ` ${theme.fg("dim", "\xB7")} ${theme.fg("dim", modelBadge)}` : ""}${permissionBadge ? ` ${theme.fg("dim", "\xB7")} ${permissionBadge}` : ""}`, width),
-    hang
-  ];
-}
-function buildSingleWidgetLines(job, theme, width, _expanded) {
-  let now = Date.now(), 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) {
-  return buildSingleWidgetLines(job, theme, width, !1);
+  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, {
+    glyph,
+    description: lead,
+    modelBadge,
+    tokens: progress.tokens,
+    durationMs: progress.durationMs,
+    terminalStatus: compactTerminalStatus(step?.status ?? job.status)
+  })];
 }
 var RESERVED_NON_WIDGET_ROWS = 19, widgetLayoutSession;
 function resetWidgetLayoutSession() {
@@ -709,20 +663,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)) : 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"),
@@ -730,73 +670,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)) : 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) {
-  let stats = widgetStats(job, theme), activity = widgetActivity(job), status = job.status === "complete" ? "done" : job.status, parts = [
-    themeBold(theme, widgetJobName(job)),
-    theme.fg("dim", status),
-    stats,
-    activity && activity.toLowerCase() !== status ? theme.fg("dim", activity) : ""
-  ].filter(Boolean);
-  return truncLine(`  ${widgetStatusGlyph(job, theme)} ${parts.join(` ${theme.fg("dim", "\xB7")} `)}`, width);
-}
-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)));
 }
@@ -807,150 +680,185 @@ 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;
-}
-function buildWidgetComponent(jobs, expanded) {
-  return (_tui, theme) => {
-    let width = getTermWidth(), lines = expanded ? buildWidgetLines(jobs, theme, width, !0) : jobs.length === 1 ? compactSingleWidgetLines(jobs[0], theme, width) : buildWidgetLines(jobs, theme, width, !1), container = new Container();
-    for (let line of fitAdaptiveWidgetLines(jobs, lines, theme, width, expanded))
-      container.addChild(new Text(line, 1, 0));
-    return container;
-  };
+    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) {
-  if (jobs.length === 0)
-    return [];
-  if (jobs.length === 1)
-    return buildSingleWidgetLines(jobs[0], theme, width, expanded);
-  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)) : 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 stats = widgetStats(job, theme);
-    items.push([
-      `${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "\xB7")} ${stats}` : ""}`,
-      `  ${theme.fg("dim", `\u23BF  ${widgetActivity(job)}`)}`,
-      ...widgetParallelAgentDetails(job, theme, expanded, width)
-    ]), 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 stats = widgetStats(job, theme);
-    items.push([
-      `${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "\xB7")} ${stats}` : ""}`,
-      `  ${theme.fg("dim", `\u23BF  ${widgetActivity(job)}`)}`,
-      ...widgetParallelAgentDetails(job, theme, expanded, width)
-    ]), 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));
+function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = !1, now = Date.now()) {
+  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;
 }
-var widgetPaintTimer, widgetPaintCtx;
-function clearWidgetPaintTimer() {
-  widgetPaintTimer && (clearInterval(widgetPaintTimer), widgetPaintTimer = void 0), widgetPaintCtx = void 0;
-}
-function ensureWidgetPaintTimer(ctx, running) {
-  if (widgetPaintCtx = ctx, !running || !ctx.hasUI) {
-    clearWidgetPaintTimer();
-    return;
+var activeWidget, SubagentAsyncWidget = class {
+  jobs;
+  expanded;
+  theme;
+  requestRender;
+  nowFn;
+  timer;
+  disposed = !1;
+  cachedWidth;
+  cachedLines;
+  constructor(jobs, theme, options) {
+    this.jobs = jobs, this.theme = theme, this.expanded = options?.expanded ?? !1, this.requestRender = options?.requestRender, this.nowFn = options?.now ?? Date.now, this.syncTimer();
+  }
+  setTheme(theme) {
+    this.theme = theme, this.invalidate();
+  }
+  setJobs(jobs) {
+    this.jobs = jobs, this.invalidate(), this.syncTimer();
+  }
+  setExpanded(expanded) {
+    this.expanded !== expanded && (this.expanded = expanded, this.invalidate());
+  }
+  setRequestRender(requestRender) {
+    this.requestRender = requestRender;
+  }
+  hasRunning() {
+    return this.jobs.some((job) => job.status === "running");
+  }
+  syncTimer() {
+    this.disposed || (this.hasRunning() ? this.startTimer() : this.stopTimer());
+  }
+  startTimer() {
+    this.timer || (this.timer = setInterval(() => {
+      this.disposed || (this.invalidate(), this.requestRender?.());
+    }, SUBAGENT_PAINT_INTERVAL_MS), this.timer.unref?.());
+  }
+  stopTimer() {
+    this.timer && (clearInterval(this.timer), this.timer = void 0);
   }
-  widgetPaintTimer || (widgetPaintTimer = setInterval(() => {
-    widgetPaintCtx?.ui.requestRender?.();
-  }, 80), widgetPaintTimer.unref?.());
+  invalidate() {
+    this.cachedWidth = void 0, this.cachedLines = void 0;
+  }
+  dispose() {
+    this.disposed = !0, this.stopTimer(), activeWidget === this && (activeWidget = void 0);
+  }
+  render(width) {
+    let theme = this.theme;
+    if (!theme)
+      return [];
+    if (this.cachedLines && this.cachedWidth === width && !this.hasRunning())
+      return this.cachedLines;
+    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));
+    });
+    return this.cachedWidth = width, this.cachedLines = padded, padded;
+  }
+};
+function disposeSubagentWidget() {
+  activeWidget?.dispose(), activeWidget = void 0;
 }
 function renderWidget(ctx, jobs) {
   if (jobs.length === 0) {
-    resetWidgetLayoutSession(), clearWidgetPaintTimer(), ctx.hasUI && ctx.ui.setWidget(WIDGET_KEY, void 0);
+    resetWidgetLayoutSession(), disposeSubagentWidget(), ctx.hasUI && ctx.ui.setWidget(WIDGET_KEY, void 0);
+    return;
+  }
+  if (!ctx.hasUI)
+    return;
+  let expanded = ctx.ui.getToolsExpanded?.() ?? !1, requestRender = () => ctx.ui.requestRender?.();
+  if (activeWidget) {
+    activeWidget.setJobs(jobs), activeWidget.setExpanded(expanded), activeWidget.setRequestRender(requestRender), ctx.ui.requestRender?.();
     return;
   }
-  ctx.hasUI && (ensureWidgetPaintTimer(ctx, jobs.some((job) => job.status === "running")), ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, ctx.ui.getToolsExpanded?.() ?? !1)));
+  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", contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "", c = new Container(), width = getTermWidth() - 4, lead = compactRowLead({ description: r.description ?? r.agent, task: r.task }), modelBadge = formatModelSelection(r.modelSelection ?? progress?.modelSelection, r.model ?? progress?.model, r.thinking ?? progress?.thinking), permissionBadge = r.permissions ? theme.fg("dim", r.permissions) : "";
-  if (c.addChild(animatedLine((f, now) => {
-    let stats = formatProgressStats(theme, progress, !0, { running: isRunning, terminal: !isRunning, now });
-    return truncLine(`${resultGlyph(r, output, theme, isRunning, void 0, f)} ${themeBold(theme, lead)}${modelBadge ? ` ${theme.fg("dim", "\xB7")} ${theme.fg("dim", modelBadge)}` : ""}${permissionBadge ? ` ${theme.fg("dim", "\xB7")} ${permissionBadge}` : ""}${contextBadge}${stats ? ` ${theme.fg("dim", "\xB7")} ${stats}` : ""}`, width);
-  }, frame, isRunning)), isRunning && r.progress)
-    return c.addChild(animatedLine((_f, now) => formatCompactStatsHangLine(r.progress, width, (s) => theme.fg("dim", s), "  \u23BF  ", now, !0), frame, !0)), c;
-  c.addChild(new Text(truncLine(theme.fg("dim", `  \u23BF  ${resultStatusLine(r, output)}`), width), 0, 0));
-  let preview = firstOutputLine(output);
-  return preview && r.exitCode === 0 && !hasEmptyTextOutputWithoutOutputTarget(r.task, output) && c.addChild(new Text(truncLine(theme.fg("dim", `     ${preview}`), width), 0, 0)), r.sessionFile && c.addChild(new Text(truncLine(theme.fg("dim", `  session: ${shortenPath(r.sessionFile)}`), width), 0, 0)), c;
+  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),
+    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, now) => {
-    let stats = statJoin(theme, [multiLabel.headerLabel, formatProgressStats(theme, totalSummary, !0, { running: hasRunning, terminal: !hasRunning, now }), 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 pendingLabel2 = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`;
-      c.addChild(new Text(truncLine(theme.fg("dim", `  \u25E6 ${pendingLabel2}: ${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", pendingLabel = rPending ? ` ${theme.fg("dim", "\xB7 pending")}` : "", lead = compactRowLead({ description: r.description ?? agentName, task: r.task }), permissionBadge = r.permissions ? theme.fg("dim", r.permissions) : "", modelBadge = formatModelSelection(r.modelSelection ?? (rProg && "modelSelection" in rProg ? rProg.modelSelection : void 0), r.model ?? (rProg && "model" in rProg ? rProg.model : void 0), r.thinking ?? (rProg && "thinking" in rProg ? rProg.thinking : void 0));
-    c.addChild(animatedLine((f, now) => {
-      let glyph2 = rPending ? theme.fg("dim", "\u25E6") : resultGlyph(r, output, theme, rRunning, progressRunningSeed(rProg), f), stepStats = formatProgressStats(theme, rProg, !0, { running: !!rRunning, terminal: !rRunning && !rPending, now });
-      return truncLine(`  ${glyph2} ${themeBold(theme, lead)}${modelBadge ? ` ${theme.fg("dim", "\xB7")} ${theme.fg("dim", modelBadge)}` : ""}${permissionBadge ? ` ${theme.fg("dim", "\xB7")} ${permissionBadge}` : ""}${stepStats ? ` ${theme.fg("dim", "\xB7")} ${stepStats}` : ""}${pendingLabel}`, width);
-    }, frame, !!rRunning)), rRunning && rProg && "status" in rProg ? c.addChild(animatedLine((_f, now) => formatCompactStatsHangLine(rProg, width, (s) => theme.fg("dim", s), "    \u23BF  ", now, !0), frame, !0)) : !rPending && (r.exitCode !== 0 || r.interrupted || r.detached || hasEmptyTextOutputWithoutOutputTarget(r.task, output)) && c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `    \u23BF  ${resultStatusLine(r, output)}`), width), 0, 0));
+  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: result2 ? resultGlyph(result2, output, theme, running, progressRunningSeed(progress), animationFrame) : progressStatusGlyph({ ...progress, status, index: flatIndex }, theme, animationFrame),
+        description,
+        modelBadge,
+        tokens: result2 ? compactResultTokens(result2) : progress?.tokens ?? 0,
+        durationMs: liveDurationMs(progress, running, now),
+        terminalStatus: result2 ? compactResultTerminalStatus(result2) : compactTerminalStatus(status)
+      });
+    }, 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(`
 `))
@@ -971,7 +879,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);
@@ -993,7 +901,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) => {
@@ -1007,10 +915,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") {
@@ -1018,10 +942,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);
@@ -1030,7 +954,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));
@@ -1059,15 +983,15 @@ import { Type } from "typebox";
 function keepTopLevelParameterDescriptions(schema) {
   return pruneNestedDescriptions(schema, []);
 }
-function pruneNestedDescriptions(value, path12) {
+function pruneNestedDescriptions(value, path13) {
   if (!value || typeof value != "object")
     return value;
   let result2 = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
   for (let key of Reflect.ownKeys(value)) {
     let descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (descriptor && !(key === "description" && !isPropertiesMap(path12) && !isTopLevelParameterHelpText(path12))) {
+    if (descriptor && !(key === "description" && !isPropertiesMap(path13) && !isTopLevelParameterHelpText(path13))) {
       if ("value" in descriptor) {
-        let nextPath = typeof key == "string" ? [...path12, key] : path12;
+        let nextPath = typeof key == "string" ? [...path13, key] : path13;
         descriptor.value = pruneNestedDescriptions(descriptor.value, nextPath);
       }
       Object.defineProperty(result2, key, descriptor);
@@ -1075,11 +999,11 @@ function pruneNestedDescriptions(value, path12) {
   }
   return result2;
 }
-function isPropertiesMap(path12) {
-  return path12[path12.length - 1] === "properties";
+function isPropertiesMap(path13) {
+  return path13[path13.length - 1] === "properties";
 }
-function isTopLevelParameterHelpText(path12) {
-  return path12.length === 2 && path12[0] === "properties";
+function isTopLevelParameterHelpText(path13) {
+  return path13.length === 2 && path13[0] === "properties";
 }
 var SkillOverride = Type.Unsafe({
   anyOf: [
@@ -1097,10 +1021,16 @@ var SkillOverride = Type.Unsafe({
 }), OutputModeOverride = Type.String({
   enum: ["inline", "file-only"],
   description: "Return saved output inline (default) or only a concise file reference. file-only requires output to be a path."
-}), TierOverride = Type.String({
+}), TIER_SELECTION_DESCRIPTION = "Choose the lowest model tier that can reliably complete the task: 'light' for quick checks, fact gathering, and small code inspections; 'standard' for everyday coding, clearly described bugs, and focused reviews; 'heavy' for complex implementation, difficult debugging, architectural decisions, and large or high-risk reviews.", TierOverride = Type.Optional(Type.String({
   enum: ["light", "standard", "heavy"],
-  description: "Required model tier: 'light' for simple/fast work, 'standard' for typical coding, or 'heavy' for complex reasoning. The configured tier model must be available and authenticated."
-}), ReadsOverride = Type.Unsafe({
+  description: `Required by default. ${TIER_SELECTION_DESCRIPTION} Do not combine with model. The configured tier model must be available and authenticated.`
+})), ModelOverride = Type.Optional(Type.String({
+  minLength: 1,
+  description: "Explicit provider/model id only when the user names a model. Do not combine with tier. Optional thinking belongs in the thinking field or as a known :level suffix."
+})), ThinkingOverride = Type.Optional(Type.String({
+  enum: ["off", "minimal", "low", "medium", "high", "xhigh", "max"],
+  description: "Thinking level for an explicit model launch. Omit for tier launches (they use configured tier thinking)."
+})), ReadsOverride = Type.Unsafe({
   anyOf: [
     { type: "array", items: { type: "string" } },
     { type: "boolean", enum: [!1] }
@@ -1147,6 +1077,8 @@ var SkillOverride = Type.Unsafe({
   reads: Type.Optional(ReadsOverride),
   progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for this task" })),
   tier: TierOverride,
+  model: ModelOverride,
+  thinking: ThinkingOverride,
   skill: Type.Optional(SkillOverride),
   toolBudget: Type.Optional(ToolBudgetOverride),
   acceptance: Type.Optional(AcceptanceOverride)
@@ -1166,6 +1098,8 @@ var SkillOverride = Type.Unsafe({
   progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
   skill: Type.Optional(SkillOverride),
   tier: TierOverride,
+  model: ModelOverride,
+  thinking: ThinkingOverride,
   toolBudget: Type.Optional(ToolBudgetOverride),
   acceptance: Type.Optional(AcceptanceOverride)
 }), DynamicExpandSchema = Type.Object({
@@ -1195,6 +1129,8 @@ var SkillOverride = Type.Unsafe({
   progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
   skill: Type.Optional(SkillOverride),
   tier: TierOverride,
+  model: ModelOverride,
+  thinking: ThinkingOverride,
   toolBudget: Type.Optional(ToolBudgetOverride),
   acceptance: Type.Optional(AcceptanceOverride)
 }, { additionalProperties: !1 }), DynamicCollectSchema = Type.Object({
@@ -1217,6 +1153,8 @@ var SkillOverride = Type.Unsafe({
   progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking in {chain_dir}" })),
   skill: Type.Optional(SkillOverride),
   tier: TierOverride,
+  model: ModelOverride,
+  thinking: ThinkingOverride,
   toolBudget: Type.Optional(ToolBudgetOverride),
   acceptance: Type.Optional(AcceptanceOverride),
   parallel: Type.Optional(Type.Unsafe({
@@ -1234,7 +1172,7 @@ var SkillOverride = Type.Unsafe({
     description: "Create isolated git worktrees for each parallel task."
   }))
 }, {
-  description: "Chain step: use {task, description, tier, permissions?} for sequential, {parallel: [...]} for static concurrent execution, or {expand, parallel: {...}, collect} for dynamic fanout. Every executable child requires tier.",
+  description: "Chain step: use {task, description, tier|model, permissions?} for sequential, {parallel: [...]} for static concurrent execution, or {expand, parallel: {...}, collect} for dynamic fanout. Every executable child needs exactly one of tier or model.",
   additionalProperties: !1
 }), ControlOverrides = Type.Object({
   enabled: Type.Optional(Type.Boolean({ description: "Enable/disable subagent control attention tracking for this run" })),
@@ -1273,12 +1211,9 @@ var SkillOverride = Type.Unsafe({
   })),
   lines: Type.Optional(Type.Integer({ minimum: 1, maximum: 500, description: "Maximum transcript lines for action='status', view='transcript'. Defaults to 80." })),
   message: Type.Optional(Type.String({ description: "Follow-up message for action='resume' or non-terminal guidance for action='steer'. Use index to choose a child from multi-child runs." })),
-  scope: Type.Optional(Type.String({ enum: ["session", "user", "project"], description: "Scope for action='watchdog.configure'. Defaults to session to avoid persistent settings writes unless user/project is explicit." })),
-  target: Type.Optional(Type.String({ enum: ["main", "children"], description: "Target for action='watchdog.configure'. Defaults to main." })),
-  thinking: Type.Optional(Type.Unsafe({ anyOf: [{ type: "string" }, { type: "boolean", enum: [!1] }], description: "Thinking level for action='watchdog.configure' (off/minimal/low/medium/high/xhigh/max, inherit, or false for off)." })),
   schedule: Type.Optional(Type.String({ description: "Explicit one-shot schedule for action='schedule'. Only honored when scheduledRuns.enabled is true. Use '+10m' or a future ISO timestamp with timezone; scheduled runs always launch async with fresh context." })),
   scheduleName: Type.Optional(Type.String({ description: "Optional display name for action='schedule'." })),
-  tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{task, description, tier, permissions?, count?, output?, outputMode?, reads?, progress?}, ...]" })),
+  tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{task, description, tier|model, thinking?, permissions?, count?, output?, outputMode?, reads?, progress?}, ...]" })),
   concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Top-level PARALLEL mode only: max concurrent tasks. Defaults to config.parallel.concurrency or unlimited." })),
   worktree: Type.Optional(Type.Boolean({
     description: "Create isolated git worktrees for parallel tasks; requires clean git state."
@@ -1289,7 +1224,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),
@@ -1300,7 +1235,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: [
@@ -1313,15 +1248,26 @@ var SkillOverride = Type.Unsafe({
   skill: Type.Optional(SkillOverride),
   tier: Type.Optional(Type.String({
     enum: ["light", "standard", "heavy"],
-    description: "Required for SINGLE execution. Omit for control actions; PARALLEL and CHAIN children carry their own required tier."
+    description: `Preferred for SINGLE execution. Required by default. Omit for control actions. Do not combine with model; PARALLEL and CHAIN children carry their own tier or model. ${TIER_SELECTION_DESCRIPTION}`
+  })),
+  model: Type.Optional(Type.String({
+    minLength: 1,
+    description: "Explicit provider/model for SINGLE execution only when the user names a model. Do not combine with tier."
+  })),
+  thinking: Type.Optional(Type.String({
+    enum: ["off", "minimal", "low", "medium", "high", "xhigh", "max"],
+    description: "Thinking level for an explicit model launch. Tier launches use configured tier thinking instead."
   })),
   acceptance: Type.Optional(AcceptanceOverride)
 }), SubagentParams = keepTopLevelParameterDescriptions(SubagentParamsSchema), SubagentWaitParamsSchema = Type.Object({
   id: Type.Optional(Type.String({
     description: "Async run or remembered detached foreground run id/prefix to wait for one specific run. Omit to wait across every active async run started in this session."
   })),
+  questionId: Type.Optional(Type.String({
+    description: "Wait for one supervisor question id from subagent_supervisor action='ask'. Returns when that question is answered, expired, or cancelled. Separate from final async run results."
+  })),
   all: Type.Optional(Type.Boolean({
-    description: "Wait for ALL active runs to finish. Default false: return as soon as the first run finishes, so a fleet manager can spawn a replacement and wait again. Ignored when id targets a single run."
+    description: "Wait for ALL active runs to finish. Default false: return as soon as the first run finishes, so a fleet manager can spawn a replacement and wait again. Ignored when id or questionId targets one item."
   })),
   timeoutMs: Type.Optional(Type.Integer({
     minimum: 1,
@@ -1346,28 +1292,28 @@ function typeName(value) {
 function quoteList(keys) {
   return keys.map((key) => `"${key}"`).join(", ");
 }
-function disallowedMessage(path12, keys, allowed, example) {
+function disallowedMessage(path13, keys, allowed, example) {
   let subject = keys.length === 1 ? `property "${keys[0]}" is not allowed` : `properties ${quoteList(keys)} are not allowed`, examplePart = example ? `
 
 Example: ${example}` : "";
-  return `subagent ${path12}: ${subject}.
+  return `subagent ${path13}: ${subject}.
 Allowed properties: ${allowed.join(", ")}.${examplePart}`;
 }
-function expectObject(value, path12, allowed, example) {
+function expectObject(value, path13, allowed, example) {
   if (!isPlainObject(value)) {
     let examplePart = example ? `
 
 Example: ${example}` : "";
-    throw new Error(`subagent ${path12}: expected an object, received ${typeName(value)}.
+    throw new Error(`subagent ${path13}: expected an object, received ${typeName(value)}.
 Allowed properties: ${allowed.join(", ")}.${examplePart}`);
   }
 }
-function checkNoExtraKeys(value, path12, schema, allowed, example) {
+function checkNoExtraKeys(value, path13, schema, allowed, example) {
   if (schema.additionalProperties !== !1)
     return;
   let extra = disallowedKeys(value, allowed);
   if (extra.length > 0)
-    throw new Error(disallowedMessage(path12, extra, allowed, example));
+    throw new Error(disallowedMessage(path13, extra, allowed, example));
 }
 function validateChainInput(args) {
   if (!isPlainObject(args))
@@ -1525,7 +1471,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,
@@ -1620,8 +1566,7 @@ function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
         }
         widgetRenderKey(job) !== widgetStateBefore && (widgetChanged = !0);
       }
-      let timerNeedsPaint = [...state.asyncJobs.values()].some((job) => job.status === "running");
-      (widgetChanged || timerNeedsPaint) && state.lastUiContext?.hasUI && rerenderWidget(state.lastUiContext);
+      widgetChanged && state.lastUiContext?.hasUI && rerenderWidget(state.lastUiContext);
     }, pollIntervalMs), state.poller.unref?.());
   };
   return { ensurePoller, refreshWidget, handleStarted: (data) => {
@@ -1761,15 +1706,15 @@ function createFileCoalescer(handler, defaultDelayMs, timerApi = defaultTimerApi
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/runs/background/result-watcher.js
 var WATCHER_RESTART_DELAY_MS = 3e3, POLL_INTERVAL_MS2 = 3e3;
-function sanitizeNestedResultChildren(value, resultPath, label) {
+function sanitizeNestedResultChildren(value, resultPath, label, report) {
   if (value === void 0)
     return;
   if (!Array.isArray(value)) {
-    console.error(`Ignoring invalid nested children in subagent result file '${resultPath}' at ${label}: expected an array.`);
+    report(`Ignoring invalid nested children in subagent result file '${resultPath}' at ${label}: expected an array.`);
     return;
   }
   let children = value.map((child) => sanitizeSummary(child)).filter((child) => !!child);
-  return children.length !== value.length && console.error(`Ignoring ${value.length - children.length} invalid nested child record(s) in subagent result file '${resultPath}' at ${label}.`), children.length ? children : void 0;
+  return children.length !== value.length && report(`Ignoring ${value.length - children.length} invalid nested child record(s) in subagent result file '${resultPath}' at ${label}.`), children.length ? children : void 0;
 }
 function getErrorCode(error) {
   return typeof error == "object" && error !== null && "code" in error ? error.code : void 0;
@@ -1782,27 +1727,27 @@ function shouldFallBackToPolling(error) {
   return code === "EMFILE" || code === "ENOSPC";
 }
 function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps = {}) {
-  let fsApi = deps.fs ?? fs2, timers = deps.timers ?? { setTimeout, clearTimeout, setInterval, clearInterval }, handleResult = async (file) => {
-    let resultPath = path2.join(resultsDir, file);
-    if (fsApi.existsSync(resultPath))
+  let fsApi = deps.fs ?? fs2, timers = deps.timers ?? { setTimeout, clearTimeout, setInterval, clearInterval }, generation = 0, inFlight = /* @__PURE__ */ new Set(), attempts = /* @__PURE__ */ new Map(), report = (message, error) => {
+    pi.appendEntry?.("subagent_result_delivery", { message, error: error instanceof Error ? error.message : error });
+  }, handleResult = async (file) => {
+    if (inFlight.has(file) || (attempts.get(file) ?? 0) >= 3)
+      return;
+    let currentGeneration = generation, sessionId = state.currentSessionId, isCurrent = () => generation === currentGeneration && state.currentSessionId === sessionId, resultPath = path2.join(resultsDir, file);
+    if (fsApi.existsSync(resultPath)) {
+      inFlight.add(file);
       try {
         let data = JSON.parse(fsApi.readFileSync(resultPath, "utf-8"));
         if (typeof data.sessionId != "string" || data.sessionId !== state.currentSessionId)
           return;
-        let runId = data.runId ?? data.id ?? file.replace(/\.json$/i, ""), hasExplicitNestedChildren = data.nestedChildren !== void 0, nestedChildren = compactNestedResultChildren(sanitizeNestedResultChildren(data.nestedChildren, resultPath, "nestedChildren"));
+        let runId = data.runId ?? data.id ?? file.replace(/\.json$/i, ""), hasExplicitNestedChildren = data.nestedChildren !== void 0, nestedChildren = compactNestedResultChildren(sanitizeNestedResultChildren(data.nestedChildren, resultPath, "nestedChildren", report));
         if (!nestedChildren?.length && !hasExplicitNestedChildren)
           try {
             nestedChildren = compactNestedResultChildren(projectNestedRegistryForRoot(runId)?.children);
           } catch (error) {
-            console.error(`Failed to enrich subagent result file '${resultPath}' with nested registry children; will retry later:`, error);
+            report(`Failed to enrich subagent result file '${resultPath}' with nested registry children; will retry later:`, error);
             return;
           }
-        let now = Date.now(), completionKey = buildCompletionKey(data, `result:${file}`);
-        if (markSeenWithTtl(state.completionSeen, completionKey, now, completionTtlMs)) {
-          fsApi.unlinkSync(resultPath);
-          return;
-        }
-        let hasResultChildren = Array.isArray(data.results) && data.results.length > 0, resultChildren = hasResultChildren ? data.results : [{
+        let now = Date.now(), completionKey = buildCompletionKey(data, `result:${file}`), hasResultChildren = Array.isArray(data.results) && data.results.length > 0, resultChildren = hasResultChildren ? data.results : [{
           agent: data.agent,
           output: data.summary,
           success: data.success
@@ -1810,7 +1755,7 @@ function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps = {})
           let baseOutput = result2.output ?? data.summary, hasRealOutput = typeof baseOutput == "string" && baseOutput.trim().length > 0, output = hasRealOutput ? baseOutput : "(no output)", summary = result2.success === !1 && result2.error ? `${result2.error}${hasRealOutput ? `
 
 Output:
-${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChildren.length === 1 ? data.sessionFile : void 0), childNestedChildren = sanitizeNestedResultChildren(result2.children, resultPath, `results[${index}].children`), childState = result2.state === "paused" || result2.state === "stopped" ? result2.state : result2.stopped === !0 ? "stopped" : data.state === "paused" || !hasResultChildren && (data.state === "stopped" || typeof result2.success != "boolean") ? data.state : void 0;
+${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChildren.length === 1 ? data.sessionFile : void 0), childNestedChildren = sanitizeNestedResultChildren(result2.children, resultPath, `results[${index}].children`, report), childState = result2.state === "paused" || result2.state === "stopped" ? result2.state : result2.stopped === !0 ? "stopped" : data.state === "paused" || !hasResultChildren && (data.state === "stopped" || typeof result2.success != "boolean") ? data.state : void 0;
           return {
             agent: result2.agent ?? data.agent ?? `step-${index + 1}`,
             status: resolveSubagentResultStatus({
@@ -1824,7 +1769,24 @@ ${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChil
             ...result2.intercomTarget ? { intercomTarget: result2.intercomTarget } : {},
             ...childNestedChildren ? { children: childNestedChildren } : {}
           };
-        }), nestedChildren), intercomTarget = data.intercomTarget?.trim();
+        }), nestedChildren);
+        if (markSeenWithTtl(state.completionSeen, completionKey, now, completionTtlMs) || pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+          ...data,
+          runId,
+          ...nestedChildren?.length ? { nestedChildren } : {},
+          ...Array.isArray(data.results) ? { results: hasResultChildren ? normalizedChildren.map((child, index) => ({
+            ...data.results[index],
+            agent: child.agent,
+            status: child.status,
+            summary: child.summary,
+            index: child.index,
+            artifactPath: child.artifactPath,
+            sessionPath: child.sessionPath,
+            children: child.children
+          })) : [] } : {}
+        }), !isCurrent())
+          return;
+        let intercomTarget = data.state === "stopped" ? void 0 : data.intercomTarget?.trim();
         if (intercomTarget) {
           let mode = data.mode === "single" || data.mode === "parallel" || data.mode === "chain" ? data.mode : resultChildren.length > 1 ? "chain" : "single", payload = buildSubagentResultIntercomPayload({
             to: intercomTarget,
@@ -1835,30 +1797,24 @@ ${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChil
             asyncId: data.id,
             asyncDir: data.asyncDir
           });
-          await deliverSubagentResultIntercomEvent(pi.events, payload) || console.error(`Subagent async grouped result intercom delivery was not acknowledged for '${resultPath}'.`);
+          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;
+          if (!delivered) {
+            report(`Async result delivery pending for '${runId}'; output retained.`, resultPath), attempts.get(file) < 3 && state.resultFileCoalescer.schedule(file, 1e3);
+            return;
+          }
         }
-        pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
-          ...data,
-          runId,
-          ...nestedChildren?.length ? { nestedChildren } : {},
-          ...Array.isArray(data.results) ? {
-            results: hasResultChildren ? normalizedChildren.map((child, index) => ({
-              ...data.results[index],
-              agent: child.agent,
-              status: child.status,
-              summary: child.summary,
-              index: child.index,
-              artifactPath: child.artifactPath,
-              sessionPath: child.sessionPath,
-              children: child.children
-            })) : []
-          } : {}
-        }), fsApi.unlinkSync(resultPath);
+        isCurrent() && fsApi.unlinkSync(resultPath);
       } catch (error) {
         if (isNotFoundError(error))
           return;
-        console.error(`Failed to process subagent result file '${resultPath}':`, error);
+        report(`Failed to process subagent result file '${resultPath}'.`, error);
+      } finally {
+        inFlight.delete(file);
       }
+    }
   };
   state.resultFileCoalescer = createFileCoalescer((file) => {
     handleResult(file);
@@ -1869,10 +1825,10 @@ ${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChil
     } catch (error) {
       if (isNotFoundError(error))
         return;
-      console.error(`Failed to scan subagent result directory '${resultsDir}':`, error);
+      report(`Failed to scan subagent result directory '${resultsDir}':`, error);
     }
   }, startPollingFallback = (reason) => {
-    state.watcher?.close(), state.watcher = null, !state.watcherRestartTimer && (console.error(`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${getErrorCode(reason) ?? "unknown error"}).`), primeExistingResults(), state.watcherRestartTimer = timers.setInterval(primeExistingResults, POLL_INTERVAL_MS2), state.watcherRestartTimer.unref?.());
+    state.watcher?.close(), state.watcher = null, !state.watcherRestartTimer && (report(`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${getErrorCode(reason) ?? "unknown error"}).`), primeExistingResults(), state.watcherRestartTimer = timers.setInterval(primeExistingResults, POLL_INTERVAL_MS2), state.watcherRestartTimer.unref?.());
   }, scheduleRestart = () => {
     state.watcherRestartTimer || (state.watcherRestartTimer = timers.setTimeout(() => {
       state.watcherRestartTimer = null;
@@ -1883,7 +1839,7 @@ ${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChil
           startPollingFallback(error);
           return;
         }
-        console.error(`Failed to restart subagent result watcher for '${resultsDir}':`, error), scheduleRestart();
+        report(`Failed to restart subagent result watcher for '${resultsDir}':`, error), scheduleRestart();
       }
     }, WATCHER_RESTART_DELAY_MS), state.watcherRestartTimer.unref?.());
   }, startResultWatcher = () => {
@@ -1901,19 +1857,19 @@ ${baseOutput}` : ""}` : output, sessionPath = result2.sessionFile ?? (resultChil
             startPollingFallback(error);
             return;
           }
-          console.error(`Subagent result watcher failed for '${resultsDir}':`, error), state.watcher?.close(), state.watcher = null, scheduleRestart();
+          report(`Subagent result watcher failed for '${resultsDir}':`, error), state.watcher?.close(), state.watcher = null, scheduleRestart();
         }), state.watcher.unref?.();
       } catch (error) {
         if (shouldFallBackToPolling(error)) {
           startPollingFallback(error);
           return;
         }
-        console.error(`Failed to start subagent result watcher for '${resultsDir}':`, error), state.watcher = null, scheduleRestart();
+        report(`Failed to start subagent result watcher for '${resultsDir}':`, error), state.watcher = null, scheduleRestart();
       }
     }
   };
   return { startResultWatcher, primeExistingResults, stopResultWatcher: () => {
-    state.watcher?.close(), state.watcher = null, state.watcherRestartTimer && (timers.clearTimeout(state.watcherRestartTimer), timers.clearInterval(state.watcherRestartTimer)), state.watcherRestartTimer = null, state.resultFileCoalescer.clear();
+    generation++, attempts.clear(), state.watcher?.close(), state.watcher = null, state.watcherRestartTimer && (timers.clearTimeout(state.watcherRestartTimer), timers.clearInterval(state.watcherRestartTimer)), state.watcherRestartTimer = null, state.resultFileCoalescer.clear();
   } };
 }
 
@@ -2446,7 +2402,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") {
@@ -2462,7 +2418,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") {
@@ -2476,7 +2436,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(" -- ");
@@ -2495,7 +2455,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) {
@@ -2543,7 +2503,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);
@@ -2571,7 +2531,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");
       }
@@ -3102,6 +3062,12 @@ var parseInlineConfig = (raw) => {
       case "tier":
         (val === "light" || val === "standard" || val === "heavy") && (config.tier = val);
         break;
+      case "model":
+        val && (config.model = val);
+        break;
+      case "thinking":
+        ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(val) && (config.thinking = val);
+        break;
       case "permissions":
         (val === "full" || val === "read-only") && (config.permissions = val);
         break;
@@ -3145,15 +3111,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 });
@@ -3651,12 +3616,16 @@ function loadInlineOutputSchema(baseCwd, agent, value) {
 }
 var mapParsedTaskToStepObject = (step, fallbackTask, isFirst, opts) => {
   let { name, config, task: stepTask } = step;
-  if (!config.tier)
-    throw new SlashParseError(`Step '${name}' requires tier=light, tier=standard, or tier=heavy.`);
+  if (!config.tier && !config.model)
+    throw new SlashParseError(`Step '${name}' requires tier=light|standard|heavy or model=provider/id.`);
+  if (config.tier && config.model)
+    throw new SlashParseError(`Step '${name}' must choose exactly one of tier or model.`);
   return config.acceptance !== void 0 && validateInlineAcceptanceInput(config.acceptance, name), {
     description: name,
     permissions: config.permissions ?? "full",
-    tier: config.tier,
+    ...config.tier ? { tier: config.tier } : {},
+    ...config.model ? { model: config.model } : {},
+    ...config.thinking ? { thinking: config.thinking } : {},
     ...stepTask ? { task: stepTask } : isFirst && fallbackTask ? { task: fallbackTask } : {},
     ...config.output !== void 0 ? { output: config.output } : {},
     ...config.outputMode !== void 0 ? { outputMode: config.outputMode } : {},
@@ -3730,16 +3699,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;
@@ -3747,27 +3716,29 @@ 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 }) => ({
         description: name,
         permissions: config.permissions ?? "full",
-        tier: config.tier,
+        ...config.tier ? { tier: config.tier } : {},
+        ...config.model ? { model: config.model } : {},
+        ...config.thinking ? { thinking: config.thinking } : {},
         task: stepTask ?? parsed.task,
         ...config.output !== void 0 ? { output: config.output } : {},
         ...config.outputMode !== void 0 ? { outputMode: config.outputMode } : {},
@@ -3775,12 +3746,16 @@ ${finalTask}`);
         ...config.skill !== void 0 ? { skill: config.skill } : {},
         ...config.progress !== void 0 ? { progress: config.progress } : {}
       }));
-      if (tasks.some((task) => !task.tier)) {
-        ctx.ui.notify("Every parallel child requires [tier=light|standard|heavy].", "error");
+      if (tasks.some((task) => !task.tier && !task.model)) {
+        ctx.ui.notify("Every parallel child requires [tier=light|standard|heavy] or [model=provider/id].", "error");
+        return;
+      }
+      if (tasks.some((task) => task.tier && task.model)) {
+        ctx.ui.notify("Each parallel child must choose exactly one of tier or model.", "error");
         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",
@@ -4404,28 +4379,506 @@ function registerSlashSubagentBridge(options) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/intercom/native-supervisor-channel.js
+import * as fs7 from "node:fs";
+import * as path8 from "node:path";
+import { Type as Type2 } from "typebox";
+
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/intercom/supervisor-questions.js
+import { randomUUID as randomUUID3 } from "node:crypto";
 import * as fs6 from "node:fs";
 import * as path7 from "node:path";
-import { Type as Type2 } from "typebox";
-var SUPERVISOR_CHANNEL_ROOT = path7.join(TEMP_ROOT_DIR, "supervisor-channels"), REQUESTS_DIR = "requests", REPLIES_DIR = "replies", NATIVE_SUPERVISOR_TOOL_NAME = "subagent_supervisor", MAX_MESSAGE_BYTES = 64 * 1024, DEFAULT_ASK_TIMEOUT_MS = 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, ContactSupervisorParamsSchema = Type2.Object({
-  reason: Type2.String({ enum: ["need_decision", "interview_request", "progress_update"] }),
+var QUESTIONS_DIR = "questions", SUPERVISOR_CHANNEL_ROOT = path7.join(TEMP_ROOT_DIR, "supervisor-channels"), SUBAGENT_SUPERVISOR_ANSWER_TYPE = "subagent_supervisor_answer", SUBAGENT_QUESTION_EVENT = "subagent:supervisor-question", MAX_MESSAGE_BYTES = 64 * 1024, DEFAULT_ASK_TIMEOUT_MS = 600 * 1e3, activeQuestionWaits = /* @__PURE__ */ new Set();
+function askTimeoutMs() {
+  let parsed = Number(process.env.PI_INTERCOM_ASK_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ASK_TIMEOUT_MS;
+}
+function safeSegment(value) {
+  return value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+function resolveSupervisorChannelDir(runId, agent, childIndex) {
+  return path7.join(SUPERVISOR_CHANNEL_ROOT, `${safeSegment(runId)}-${safeSegment(agent)}-${childIndex}`);
+}
+function questionsDir(channelDir) {
+  return path7.join(channelDir, QUESTIONS_DIR);
+}
+function questionFile(channelDir, questionId) {
+  return path7.join(questionsDir(channelDir), `${safeSegment(questionId)}.json`);
+}
+function deliveredFile(channelDir, questionId) {
+  return path7.join(questionsDir(channelDir), `${safeSegment(questionId)}.delivered.json`);
+}
+function terminalFile(channelDir, questionId) {
+  return path7.join(questionsDir(channelDir), `${safeSegment(questionId)}.terminal.json`);
+}
+function notifiedFile(channelDir, questionId) {
+  return path7.join(questionsDir(channelDir), `${safeSegment(questionId)}.notified.json`);
+}
+function lateFile(channelDir, questionId) {
+  return path7.join(questionsDir(channelDir), `${safeSegment(questionId)}.late.json`);
+}
+function writeExclusiveJson(filePath, payload) {
+  fs6.mkdirSync(path7.dirname(filePath), { recursive: !0, mode: 448 });
+  let temporary = `${filePath}.${randomUUID3()}.tmp`;
+  try {
+    return fs6.writeFileSync(temporary, JSON.stringify(payload), { encoding: "utf-8", flag: "wx", mode: 384 }), fs6.linkSync(temporary, filePath), !0;
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return !1;
+    throw error;
+  } finally {
+    fs6.rmSync(temporary, { force: !0 });
+  }
+}
+function readJsonFile(filePath) {
+  return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+}
+function tryReadJson(filePath) {
+  try {
+    return readJsonFile(filePath);
+  } catch (error) {
+    return error.code === "ENOENT", void 0;
+  }
+}
+function parseIncarnation(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let input = raw, pid = input.pid, readyAt = input.readyAt;
+  if (!(!Number.isInteger(pid) || pid === void 0 || pid <= 0) && !(typeof readyAt != "number" || !Number.isFinite(readyAt) || readyAt <= 0))
+    return { pid, readyAt };
+}
+function parseQuestionRecord(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let input = raw;
+  if (input.type !== "subagent.supervisor.question" || typeof input.id != "string" || !input.id.trim() || typeof input.createdAt != "number" || !Number.isFinite(input.createdAt) || typeof input.expiresAt != "number" || !Number.isFinite(input.expiresAt) || typeof input.reason != "string" || !input.reason.trim() || typeof input.message != "string" || !input.message.trim() || typeof input.runId != "string" || !input.runId.trim())
+    return;
+  let childIndex = input.childIndex;
+  if (!Number.isInteger(childIndex) || childIndex === void 0 || childIndex < 0 || typeof input.childId != "string" || !input.childId.trim() || typeof input.parentSessionId != "string" || !input.parentSessionId.trim())
+    return;
+  let parentGeneration = input.parentGeneration;
+  if (!Number.isInteger(parentGeneration) || parentGeneration === void 0 || parentGeneration < 0)
+    return;
+  let incarnation = parseIncarnation(input.childIncarnation);
+  return {
+    type: "subagent.supervisor.question",
+    id: input.id.trim(),
+    createdAt: input.createdAt,
+    expiresAt: input.expiresAt,
+    reason: input.reason.trim(),
+    message: input.message.trim(),
+    runId: input.runId.trim(),
+    childIndex,
+    childId: input.childId.trim(),
+    parentSessionId: input.parentSessionId.trim(),
+    parentGeneration,
+    ...incarnation ? { childIncarnation: incarnation } : {}
+  };
+}
+function parseDeliveredRecord(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let input = raw;
+  if (input.type !== "subagent.supervisor.delivered" || typeof input.id != "string" || !input.id.trim() || typeof input.at != "number" || !Number.isFinite(input.at))
+    return;
+  let incarnation = parseIncarnation(input);
+  if (incarnation)
+    return { type: "subagent.supervisor.delivered", id: input.id.trim(), at: input.at, pid: incarnation.pid, readyAt: incarnation.readyAt };
+}
+function parseTerminalRecord(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let input = raw;
+  if (!(input.type !== "subagent.supervisor.terminal" || typeof input.id != "string" || !input.id.trim()) && !(typeof input.at != "number" || !Number.isFinite(input.at))) {
+    if (input.state === "answered")
+      return typeof input.message != "string" || !input.message.trim() ? void 0 : { type: "subagent.supervisor.terminal", id: input.id.trim(), state: "answered", at: input.at, message: input.message };
+    if (input.state === "expired")
+      return { type: "subagent.supervisor.terminal", id: input.id.trim(), state: "expired", at: input.at };
+    if (input.state === "cancelled")
+      return typeof input.reason != "string" || !input.reason.trim() ? void 0 : { type: "subagent.supervisor.terminal", id: input.id.trim(), state: "cancelled", at: input.at, reason: input.reason.trim() };
+  }
+}
+function parseNotifiedRecord(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let input = raw;
+  if (!(input.type !== "subagent.supervisor.notified" || typeof input.id != "string" || !input.id.trim()) && !(typeof input.at != "number" || !Number.isFinite(input.at)))
+    return { type: "subagent.supervisor.notified", id: input.id.trim(), at: input.at };
+}
+function parseLateRecord(raw) {
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let input = raw;
+  if (!(input.type !== "subagent.supervisor.late-answer" || typeof input.id != "string" || !input.id.trim()) && !(typeof input.at != "number" || !Number.isFinite(input.at) || typeof input.message != "string"))
+    return { type: "subagent.supervisor.late-answer", id: input.id.trim(), at: input.at, message: input.message };
+}
+function composeQuestion(record, channelDir) {
+  let delivered = parseDeliveredRecord(tryReadJson(deliveredFile(channelDir, record.id))), terminal = parseTerminalRecord(tryReadJson(terminalFile(channelDir, record.id))), notified = parseNotifiedRecord(tryReadJson(notifiedFile(channelDir, record.id))), late = parseLateRecord(tryReadJson(lateFile(channelDir, record.id)));
+  return {
+    ...record,
+    ...delivered ? { deliveredAt: delivered.at, childIncarnation: record.childIncarnation ?? { pid: delivered.pid, readyAt: delivered.readyAt } } : {},
+    ...terminal?.state === "answered" ? { answeredAt: terminal.at, answer: terminal.message } : {},
+    ...terminal?.state === "expired" ? { expiredAt: terminal.at } : {},
+    ...terminal?.state === "cancelled" ? { cancelledAt: terminal.at, cancelReason: terminal.reason } : {},
+    ...notified ? { notifiedAt: notified.at } : {},
+    ...late ? { lateAnswerAt: late.at, ...terminal?.state === "answered" ? {} : { answer: late.message } } : {}
+  };
+}
+function assertMessageSize(value, label) {
+  if (Buffer.byteLength(value, "utf-8") > MAX_MESSAGE_BYTES)
+    throw new Error(`${label} is too large.`);
+}
+function ensureQuestionsDir(channelDir) {
+  fs6.mkdirSync(questionsDir(channelDir), { recursive: !0, mode: 448 });
+}
+function supervisorQuestionPublicState(question) {
+  return question.answeredAt ? "answered" : question.expiredAt ? "expired" : question.cancelledAt ? "cancelled" : "pending";
+}
+function supervisorQuestionIsTerminal(question) {
+  return supervisorQuestionPublicState(question) !== "pending";
+}
+function readSupervisorQuestion(channelDir, questionId) {
+  let record = parseQuestionRecord(tryReadJson(questionFile(channelDir, questionId)));
+  if (!(!record || record.id !== questionId))
+    return composeQuestion(record, channelDir);
+}
+function listSupervisorQuestions(channelDir) {
+  let dir = questionsDir(channelDir), entries;
+  try {
+    entries = fs6.readdirSync(dir).filter((name) => name.endsWith(".json") && !name.endsWith(".delivered.json") && !name.endsWith(".terminal.json") && !name.endsWith(".notified.json") && !name.endsWith(".late.json"));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  let questions = [];
+  for (let entry of entries.sort()) {
+    let record = parseQuestionRecord(tryReadJson(path7.join(dir, entry)));
+    record && questions.push(composeQuestion(record, channelDir));
+  }
+  return questions;
+}
+function writeTerminal(channelDir, record) {
+  return writeExclusiveJson(terminalFile(channelDir, record.id), record);
+}
+function createSupervisorQuestion(input) {
+  let reason = input.reason.trim(), message = input.message.trim();
+  if (!reason)
+    throw new Error("reason is required and must name the concrete decision the child's answer will change.");
+  if (!message)
+    throw new Error("message is required for supervisor questions.");
+  assertMessageSize(reason, "reason"), assertMessageSize(message, "message");
+  let createdAt = input.now ?? Date.now(), timeoutMs = input.timeoutMs && input.timeoutMs > 0 ? input.timeoutMs : askTimeoutMs(), record = {
+    type: "subagent.supervisor.question",
+    id: input.id ?? randomUUID3(),
+    createdAt,
+    expiresAt: createdAt + timeoutMs,
+    reason,
+    message,
+    runId: input.runId,
+    childIndex: input.childIndex,
+    childId: input.childId,
+    parentSessionId: input.parentSessionId,
+    parentGeneration: input.parentGeneration,
+    ...input.childIncarnation ? { childIncarnation: input.childIncarnation } : {}
+  };
+  if (assertMessageSize(JSON.stringify(record), "Supervisor question"), ensureQuestionsDir(input.channelDir), !writeExclusiveJson(questionFile(input.channelDir, record.id), record))
+    throw new Error(`Supervisor question '${record.id}' already exists.`);
+  return composeQuestion(record, input.channelDir);
+}
+function outstandingQuestionsForChild(channelDir, childIndex, childId) {
+  return refreshSupervisorQuestionLifecycle(channelDir), listSupervisorQuestions(channelDir).filter((question) => !(supervisorQuestionIsTerminal(question) || question.childIndex !== childIndex || childId && question.childId !== childId));
+}
+function hasBlockingSupervisorRequest(channelDir, runId, childIndex) {
+  let directory = path7.join(channelDir, "requests");
+  if (!fs6.existsSync(directory))
+    return !1;
+  for (let name of fs6.readdirSync(directory)) {
+    if (!name.endsWith(".json"))
+      continue;
+    let raw = tryReadJson(path7.join(directory, name));
+    if (!raw || typeof raw != "object")
+      continue;
+    let request = raw;
+    if (!(request.type !== "subagent.supervisor.request" || request.expectsReply !== !0) && !(request.runId !== runId || request.childIndex !== childIndex || typeof request.id != "string") && !(typeof request.expiresAt == "number" && request.expiresAt <= Date.now()) && !fs6.existsSync(path7.join(channelDir, "replies", `${safeSegment(request.id)}.json`)))
+      return !0;
+  }
+  return !1;
+}
+function hasOutstandingQuestionForChild(channelDir, childIndex, childId) {
+  return outstandingQuestionsForChild(channelDir, childIndex, childId).length > 0;
+}
+function incarnationMatches(expected, actual) {
+  return expected ? expected.pid === actual.pid && expected.readyAt === actual.readyAt : !0;
+}
+function expireSupervisorQuestion(channelDir, questionId, now = Date.now()) {
+  let current = readSupervisorQuestion(channelDir, questionId);
+  return !current || supervisorQuestionIsTerminal(current) || now <= current.expiresAt ? current && supervisorQuestionIsTerminal(current) ? current : void 0 : (writeTerminal(channelDir, { type: "subagent.supervisor.terminal", id: questionId, state: "expired", at: now }), readSupervisorQuestion(channelDir, questionId));
+}
+function cancelSupervisorQuestion(channelDir, questionId, reason, now = Date.now()) {
+  let current = readSupervisorQuestion(channelDir, questionId);
+  return !current || supervisorQuestionIsTerminal(current) ? current : (writeTerminal(channelDir, { type: "subagent.supervisor.terminal", id: questionId, state: "cancelled", at: now, reason: reason.trim() || "cancelled" }), readSupervisorQuestion(channelDir, questionId));
+}
+function refreshSupervisorQuestionLifecycle(channelDir, now = Date.now()) {
+  let changed = [];
+  for (let question of listSupervisorQuestions(channelDir))
+    if (!supervisorQuestionIsTerminal(question) && now > question.expiresAt) {
+      let expired = expireSupervisorQuestion(channelDir, question.id, now);
+      expired && expired.expiredAt && changed.push(expired);
+    }
+  return changed;
+}
+function formatParentQuestionForChild(question) {
+  return [
+    `Parent question (${question.id})`,
+    `Decision needed: ${question.reason}`,
+    "",
+    question.message,
+    "",
+    `Reply with: contact_supervisor({ action: "reply", replyTo: "${question.id}", message: "..." })`,
+    "Answer from current findings and uncertainty. Do not silently start extra investigation. Continue the assigned task after replying."
+  ].join(`
+`);
+}
+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}]`,
+    `Decision: ${question.reason}`
+  ];
+  return state === "answered" && question.answer?.trim() ? lines.push("", question.answer.trim()) : question.cancelReason && lines.push("", question.cancelReason), lines.join(`
+`);
+}
+function registerQuestionWait(questionIds) {
+  let ids = [...questionIds];
+  for (let id of ids)
+    activeQuestionWaits.add(id);
+  return () => {
+    for (let id of ids)
+      activeQuestionWaits.delete(id);
+  };
+}
+function isQuestionWaitActive(questionId) {
+  return activeQuestionWaits.has(questionId);
+}
+function claimQuestionNotification(channelDir, questionId, now = Date.now()) {
+  return writeExclusiveJson(notifiedFile(channelDir, questionId), {
+    type: "subagent.supervisor.notified",
+    id: questionId,
+    at: now
+  });
+}
+function listSupervisorChannelDirs() {
+  let entries;
+  try {
+    entries = fs6.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: !0 });
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => path7.join(SUPERVISOR_CHANNEL_ROOT, entry.name));
+}
+function findSupervisorQuestion(questionId) {
+  let id = questionId.trim();
+  if (id)
+    for (let channelDir of listSupervisorChannelDirs()) {
+      let question = readSupervisorQuestion(channelDir, id);
+      if (question)
+        return { channelDir, question };
+    }
+}
+function cancelPendingSupervisorQuestionsForOwner(input) {
+  if (!input.parentSessionId?.trim())
+    return [];
+  let now = input.now ?? Date.now(), cancelled = [];
+  for (let channelDir of listSupervisorChannelDirs())
+    for (let question of listSupervisorQuestions(channelDir)) {
+      if (supervisorQuestionIsTerminal(question) || question.parentSessionId !== input.parentSessionId || input.parentGeneration !== void 0 && question.parentGeneration !== input.parentGeneration || input.runId && question.runId !== input.runId)
+        continue;
+      let next = cancelSupervisorQuestion(channelDir, question.id, input.reason, now);
+      next?.cancelledAt && cancelled.push(next);
+    }
+  return cancelled;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-subagents/src/intercom/supervisor-ask.js
+function runningSteps(status) {
+  return (status.steps ?? []).map((step, index) => ({
+    index,
+    childId: step.childId ?? step.agent,
+    agent: step.agent,
+    status: step.status
+  })).filter((step) => step.status === "running").map((step) => ({ index: step.index, childId: step.childId, agent: step.agent }));
+}
+function resolveAskChild(status, params) {
+  if (params.index !== void 0 && (!Number.isInteger(params.index) || params.index < 0))
+    throw new Error("index must be a non-negative integer.");
+  let running = runningSteps(status);
+  if (params.childId?.trim()) {
+    let childId = params.childId.trim(), matches = (status.steps ?? []).map((step, index) => ({ index, childId: step.childId ?? step.agent, agent: step.agent, status: step.status })).filter((step) => step.childId === childId);
+    if (matches.length === 0)
+      throw new Error(`Async run '${status.runId}' has no child '${childId}'.`);
+    if (matches.length > 1)
+      throw new Error(`Async run '${status.runId}' has multiple children named '${childId}'. Pass index.`);
+    let match = matches[0];
+    if (params.index !== void 0 && params.index !== match.index)
+      throw new Error(`Child '${childId}' is index ${match.index}, not ${params.index}.`);
+    if (match.status !== "running")
+      throw new Error(`Async run '${status.runId}' child ${match.index} is ${match.status} and cannot be asked.`);
+    return { index: match.index, childId: match.childId, agent: match.agent };
+  }
+  if (params.index !== void 0) {
+    let steps = status.steps ?? [];
+    if (params.index >= steps.length)
+      throw new Error(`Async run '${status.runId}' has ${steps.length} children. Index ${params.index} is out of range.`);
+    let step = steps[params.index];
+    if (step.status !== "running")
+      throw new Error(`Async run '${status.runId}' child ${params.index} is ${step.status} and cannot be asked.`);
+    return { index: params.index, childId: step.childId ?? step.agent, agent: step.agent };
+  }
+  if (running.length === 1)
+    return running[0];
+  throw running.length === 0 ? new Error(`Async run '${status.runId}' has no running child to ask.`) : new Error(`Async run '${status.runId}' has ${running.length} running children. Pass index or childId; broadcast asks are not supported.`);
+}
+function requestMatchesChild(request, runId, child) {
+  if (!request.expectsReply || typeof request.runId != "string" || request.runId !== runId)
+    return !1;
+  let indexMatches = Number.isInteger(request.childIndex) && request.childIndex === child.index, idMatches = request.agent === child.childId || request.agent === child.agent || request.childTarget === child.childId;
+  return indexMatches && idMatches;
+}
+function reconcileAsyncQuestion(channelDir, question, state) {
+  expireSupervisorQuestion(channelDir, question.id);
+  let current = readSupervisorQuestion(channelDir, question.id) ?? question;
+  if (supervisorQuestionIsTerminal(current))
+    return current;
+  let resolved = resolveSubagentRunId(current.runId, { state });
+  if (resolved?.kind !== "async" || !resolved.location.asyncDir)
+    return current;
+  let status = readStatus(resolved.location.asyncDir);
+  if (!status)
+    return current;
+  let step = status.steps?.[current.childIndex], capability = readSteerCapability(resolved.location.asyncDir, current.childIndex), reason;
+  status.sessionId !== current.parentSessionId ? reason = "async run ownership changed" : status.state !== "running" || !step || step.status !== "running" ? reason = "target child is no longer running" : (step.childId ?? step.agent) !== current.childId ? reason = "target child identity changed" : capability && !incarnationMatches(current.childIncarnation, capability) ? reason = "target child process changed" : capability && !capability.supported && (reason = "target child no longer accepts questions");
+  let delivery = status.steering?.recent.find((request) => request.id === current.id)?.targets.find((target) => target.index === current.childIndex);
+  return (delivery?.state === "failed" || delivery?.state === "late") && (reason = delivery.reason ?? "question delivery failed"), reason ? cancelSupervisorQuestion(channelDir, current.id, reason) ?? current : current;
+}
+function askRunningAsyncChild(input) {
+  let runId = input.params.id?.trim();
+  if (!runId)
+    throw new Error("action='ask' requires id for the async run.");
+  let reason = input.params.reason?.trim(), message = input.params.message?.trim();
+  if (!reason)
+    throw new Error("action='ask' requires reason naming the concrete decision the child's answer will change.");
+  if (!message)
+    throw new Error("action='ask' requires message.");
+  let sessionId = input.state.currentSessionId;
+  if (!sessionId)
+    throw new Error("action='ask' requires an active session identity.");
+  let resolved = resolveSubagentRunId(runId, { state: input.state });
+  if (!resolved)
+    throw new Error(`No async run matched '${runId}'.`);
+  if (resolved.kind !== "async")
+    throw new Error("action='ask' targets a running async child only. It does not revive, reassign, or broadcast.");
+  if (!resolved.location.asyncDir)
+    throw new Error(`Async run '${resolved.id}' has no live run directory.`);
+  let status = readStatus(resolved.location.asyncDir);
+  if (!status)
+    throw new Error(`Async run '${resolved.id}' has no status.`);
+  if (!status.sessionId || status.sessionId !== sessionId)
+    throw new Error(`Async run '${resolved.id}' was not found in the active session.`);
+  if (status.state !== "running")
+    throw new Error(`Async run '${resolved.id}' is ${status.state} and cannot be asked.`);
+  let child = resolveAskChild(status, input.params), channelDir = resolveSupervisorChannelDir(status.runId, child.childId, child.index);
+  if (hasOutstandingQuestionForChild(channelDir, child.index, child.childId))
+    throw new Error(`A question is already outstanding for async run '${status.runId}' child ${child.index}. Wait for that answer or expiry before asking again.`);
+  for (let request of input.childRequests ?? [])
+    if (requestMatchesChild(request, status.runId, child))
+      throw new Error(`Child ${child.index} is waiting for a supervisor reply. Asking now would deadlock. Reply to the child request first.`);
+  if (hasBlockingSupervisorRequest(channelDir, status.runId, child.index))
+    throw new Error("Child is waiting for a supervisor reply. Reply to its request before asking a question.");
+  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({
+    channelDir,
+    reason,
+    message,
+    runId: status.runId,
+    childIndex: child.index,
+    childId: child.childId,
+    parentSessionId: sessionId,
+    parentGeneration: input.state.sessionGeneration ?? 0,
+    childIncarnation: incarnation
+  });
+  try {
+    if (hasBlockingSupervisorRequest(channelDir, status.runId, child.index))
+      throw new Error("Child is waiting for a supervisor reply. Reply to its request before asking a question.");
+    requestAsyncSteer(resolved.location.asyncDir, {
+      message: formatParentQuestionForChild(question),
+      targetIndex: child.index,
+      source: "supervisor-question",
+      id: question.id
+    });
+  } catch (error) {
+    throw cancelSupervisorQuestion(channelDir, question.id, "failed to queue delivery to child"), error instanceof Error ? error : new Error(String(error));
+  }
+  return {
+    content: [{ type: "text", text: `Question ${question.id} queued for async run ${status.runId} child ${child.index}. The child's answer is delivered separately from the run result.` }],
+    details: {
+      questionId: question.id,
+      state: "pending",
+      runId: status.runId,
+      childIndex: child.index,
+      childId: child.childId,
+      delivered: !1,
+      answered: !1
+    }
+  };
+}
+
+// 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 = [
+  "Ask a specific running async child, or reply to a child supervisor request.",
+  "Ask only when the child owns missing context, the answer changes a concrete next decision, and waiting risks a block or rework.",
+  "Use available results first, batch related questions, and keep working while awaiting the answer. Do not use ask for status checks, polling, duplicate queries, or step-by-step supervision. Follow up only when the answer leaves the original decision unresolved.",
+  "Returns a question id immediately. The child's explicit answer is delivered separately from the final run result.",
+  'Ask: { action: "ask", id: "<runId>", index?: 0, childId?: "...", reason: "<concrete decision>", message: "..." }',
+  "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.",
+  "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"] })),
   message: Type2.Optional(Type2.String()),
-  interview: Type2.Optional(Type2.Unsafe({ type: "object", additionalProperties: !0 }))
+  interview: Type2.Optional(Type2.Unsafe({ type: "object", additionalProperties: !0 })),
+  action: Type2.Optional(Type2.String({ enum: ["reply"] })),
+  replyTo: Type2.Optional(Type2.String())
 }, { additionalProperties: !1 }), IntercomParamsSchema = Type2.Object({
   action: Type2.String({ enum: ["list", "send", "ask", "reply", "pending", "status"] }),
   to: Type2.Optional(Type2.String()),
   message: Type2.Optional(Type2.String()),
-  replyTo: Type2.Optional(Type2.String())
+  replyTo: Type2.Optional(Type2.String()),
+  id: Type2.Optional(Type2.String({ description: "Async run id for action='ask'." })),
+  index: Type2.Optional(Type2.Integer({ minimum: 0, description: "Zero-based child index for action='ask'. Select index or childId when more than one child is running." })),
+  childId: Type2.Optional(Type2.String({ description: "Private child identity for action='ask'." })),
+  reason: Type2.Optional(Type2.String({ description: "Concrete decision the child's answer will change. Required for action='ask'." }))
+}, { additionalProperties: !1 }), ParentSupervisorParamsSchema = Type2.Object({
+  ...IntercomParamsSchema.properties,
+  action: Type2.String({ enum: ["list", "ask", "reply", "pending", "status"] })
 }, { additionalProperties: !1 });
-function safeSegment(value) {
+function safeSegment2(value) {
   return value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
 }
 function replyPath(channelDir, requestId) {
-  return path7.join(channelDir, REPLIES_DIR, `${safeSegment(requestId)}.json`);
+  return path8.join(channelDir, REPLIES_DIR, `${safeSegment2(requestId)}.json`);
 }
-function askTimeoutMs() {
+function askTimeoutMs2() {
   let parsed = Number(process.env.PI_INTERCOM_ASK_TIMEOUT_MS);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ASK_TIMEOUT_MS;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ASK_TIMEOUT_MS2;
 }
 function hasTool(pi, name) {
   try {
@@ -4436,16 +4889,26 @@ function hasTool(pi, name) {
 }
 function parseRequestFile(file, channelDir) {
   try {
-    let parsed = JSON.parse(fs6.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 };
+    let parsed = JSON.parse(fs7.readFileSync(file, "utf-8"));
+    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" || 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;
   }
 }
+function hasPendingBlockingSupervisorRequest(runId, sessionId, now = Date.now()) {
+  if (!runId)
+    return !1;
+  for (let { channelDir, file } of listRequestFiles()) {
+    let request = parseRequestFile(file, channelDir);
+    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;
+}
 function listRequestFiles() {
   let channelEntries;
   try {
-    channelEntries = fs6.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: !0 });
+    channelEntries = fs7.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: !0 });
   } catch (error) {
     if (error.code === "ENOENT")
       return [];
@@ -4455,34 +4918,34 @@ function listRequestFiles() {
   for (let entry of channelEntries) {
     if (!entry.isDirectory())
       continue;
-    let channelDir = path7.join(SUPERVISOR_CHANNEL_ROOT, entry.name), requestsDir = path7.join(channelDir, REQUESTS_DIR), requestEntries;
+    let channelDir = path8.join(SUPERVISOR_CHANNEL_ROOT, entry.name), requestsDir = path8.join(channelDir, REQUESTS_DIR), requestEntries;
     try {
-      requestEntries = fs6.readdirSync(requestsDir, { withFileTypes: !0 });
+      requestEntries = fs7.readdirSync(requestsDir, { withFileTypes: !0 });
     } catch {
       continue;
     }
     for (let requestEntry of requestEntries)
-      requestEntry.isFile() && requestEntry.name.endsWith(".json") && files.push({ channelDir, file: path7.join(requestsDir, requestEntry.name) });
+      requestEntry.isFile() && requestEntry.name.endsWith(".json") && files.push({ channelDir, file: path8.join(requestsDir, requestEntry.name) });
   }
   return files;
 }
 function readDirectoryEntries(dir) {
   try {
-    return fs6.readdirSync(dir, { withFileTypes: !0 });
+    return fs7.readdirSync(dir, { withFileTypes: !0 });
   } catch (error) {
     return error.code === "ENOENT" ? [] : void 0;
   }
 }
 function directoryMtimeMs(dir) {
   try {
-    return fs6.statSync(dir).mtimeMs;
+    return fs7.statSync(dir).mtimeMs;
   } catch {
     return 0;
   }
 }
 function removeEmptyDirectory(dir) {
   try {
-    return fs6.rmdirSync(dir), !0;
+    return fs7.rmdirSync(dir), !0;
   } catch (error) {
     let code = error.code;
     if (code === "ENOENT")
@@ -4493,19 +4956,22 @@ function removeEmptyDirectory(dir) {
   }
 }
 function removeStaleEmptySupervisorChannel(channelDir, nowMs) {
-  let requestsDir = path7.join(channelDir, REQUESTS_DIR), repliesDir = path7.join(channelDir, REPLIES_DIR), newestKnownMtimeMs = Math.max(directoryMtimeMs(channelDir), directoryMtimeMs(requestsDir), directoryMtimeMs(repliesDir));
+  let requestsDir = path8.join(channelDir, REQUESTS_DIR), repliesDir = path8.join(channelDir, REPLIES_DIR), questionsPath = path8.join(channelDir, QUESTIONS_DIR), newestKnownMtimeMs = Math.max(directoryMtimeMs(channelDir), directoryMtimeMs(requestsDir), directoryMtimeMs(repliesDir), directoryMtimeMs(questionsPath));
   if (nowMs - newestKnownMtimeMs < STALE_EMPTY_CHANNEL_AGE_MS)
     return !1;
   let requestEntries = readDirectoryEntries(requestsDir);
   if (!requestEntries || requestEntries.length > 0)
     return !1;
   let replyEntries = readDirectoryEntries(repliesDir);
-  return !(!replyEntries || replyEntries.length > 0 || !removeEmptyDirectory(requestsDir) || !removeEmptyDirectory(repliesDir) || !removeEmptyDirectory(channelDir));
+  if (!replyEntries || replyEntries.length > 0)
+    return !1;
+  let questionEntries = readDirectoryEntries(questionsPath);
+  return !(!questionEntries || questionEntries.length > 0 || !removeEmptyDirectory(requestsDir) || !removeEmptyDirectory(repliesDir) || !removeEmptyDirectory(questionsPath) || !removeEmptyDirectory(channelDir));
 }
 function cleanupStaleEmptySupervisorChannels(nowMs = Date.now()) {
   let channelEntries;
   try {
-    channelEntries = fs6.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: !0 });
+    channelEntries = fs7.readdirSync(SUPERVISOR_CHANNEL_ROOT, { withFileTypes: !0 });
   } catch (error) {
     if (error.code === "ENOENT")
       return 0;
@@ -4515,7 +4981,7 @@ function cleanupStaleEmptySupervisorChannels(nowMs = Date.now()) {
   for (let entry of channelEntries)
     if (entry.isDirectory())
       try {
-        removeStaleEmptySupervisorChannel(path7.join(SUPERVISOR_CHANNEL_ROOT, entry.name), nowMs) && removed++;
+        removeStaleEmptySupervisorChannel(path8.join(SUPERVISOR_CHANNEL_ROOT, entry.name), nowMs) && removed++;
       } catch {
       }
   return removed;
@@ -4529,19 +4995,26 @@ 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 {
-    fs6.rmSync(file, { force: !0 });
+    fs7.rmSync(file, { force: !0 });
   } catch {
   }
 }
 function requestExpiresAt(request, now) {
   let expiresAt = request.expiresAt;
-  return typeof expiresAt == "number" && Number.isFinite(expiresAt) ? expiresAt : Number.isFinite(request.createdAt) ? request.createdAt + askTimeoutMs() : now;
+  return typeof expiresAt == "number" && Number.isFinite(expiresAt) ? expiresAt : Number.isFinite(request.createdAt) ? request.createdAt + askTimeoutMs2() : now;
 }
 function requestRunInactive(request, state) {
   if (state.foregroundControls.has(request.runId))
@@ -4558,7 +5031,7 @@ function requestRunInactive(request, state) {
   return stepStatus === "complete" || stepStatus === "completed" || stepStatus === "failed" || stepStatus === "paused";
 }
 function requestLifecycle(request, state, ctx, now) {
-  return ctx && !requestMatchesContext(request, state, ctx) ? "wrong-session" : fs6.existsSync(request.requestFile) ? request.expectsReply && fs6.existsSync(replyPath(request.channelDir, request.id)) ? "resolved" : request.expectsReply && now > requestExpiresAt(request, now) ? "expired" : request.expectsReply && requestRunInactive(request, state) ? "inactive" : "pending" : "missing";
+  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";
 }
 function cleanupRequestLifecycle(request, lifecycle) {
   (lifecycle === "resolved" || lifecycle === "expired" || lifecycle === "inactive") && removeRequestFile(request.requestFile);
@@ -4623,8 +5096,8 @@ function buildParentIntercomTool(pending, state, name = "intercom") {
   return {
     name,
     label: name === "intercom" ? "Intercom" : "Subagent Supervisor",
-    description: name === "intercom" ? "Native pi-subagents supervisor channel. Use reply/pending/status to answer child subagent requests." : "Native pi-subagents supervisor channel. Use reply/pending/status to answer child subagent requests without overriding pi-intercom.",
-    parameters: IntercomParamsSchema,
+    description: PARENT_ASK_DESCRIPTION,
+    parameters: ParentSupervisorParamsSchema,
     async execute(_id, params) {
       refreshPendingRequests(pending, state, state.lastUiContext ?? void 0);
       let input = params;
@@ -4639,10 +5112,59 @@ function buildParentIntercomTool(pending, state, name = "intercom") {
         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 } };
       }
-      throw input.action === "send" || input.action === "ask" ? new Error("Native pi-subagents intercom currently handles supervisor replies. Child agents initiate asks with contact_supervisor.") : new Error(`Unsupported intercom action: ${input.action}`);
+      if (input.action === "ask")
+        return askRunningAsyncChild({
+          params: {
+            id: input.id,
+            index: input.index,
+            childId: input.childId,
+            reason: input.reason,
+            message: input.message
+          },
+          state,
+          childRequests: pending.values()
+        });
+      throw input.action === "send" ? new Error("Native pi-subagents intercom does not support free-form send. Use action='ask' for a running async child or action='reply' for a pending child request.") : new Error(`Unsupported intercom action: ${input.action}`);
     }
   };
 }
+function questionMatchesParentContext(question, state, ctx) {
+  let sessionId = currentSupervisorSessionId(state, ctx);
+  return !(!sessionId || question.parentSessionId !== sessionId || (state.sessionGeneration ?? 0) !== question.parentGeneration);
+}
+function notifyQuestionTerminal(pi, question, channelDir) {
+  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);
+  pi.sendMessage({
+    customType: SUBAGENT_SUPERVISOR_ANSWER_TYPE,
+    content: formatSupervisorQuestionAnswer(question),
+    display: state === "answered",
+    details: {
+      questionId: question.id,
+      state,
+      runId: question.runId,
+      childIndex: question.childIndex,
+      childId: question.childId,
+      reason: question.reason,
+      answered: state === "answered",
+      delivered: !!question.deliveredAt
+    }
+  }, { triggerTurn: state === "answered" });
+}
+function pollSupervisorQuestions(pi, state, ctx) {
+  for (let channelDir of listSupervisorChannelDirs())
+    for (let question of listSupervisorQuestions(channelDir)) {
+      if (!questionMatchesParentContext(question, state, ctx))
+        continue;
+      let current = reconcileAsyncQuestion(channelDir, question, state);
+      notifyQuestionTerminal(pi, current, channelDir);
+    }
+}
 function createNativeSupervisorChannel(pi, state) {
   let pending = /* @__PURE__ */ new Map(), seenFiles = /* @__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));
@@ -4655,12 +5177,24 @@ function createNativeSupervisorChannel(pi, state) {
       } catch {
       }
     }
+  }, cancelOwnedQuestions = (reason) => {
+    state.currentSessionId && cancelPendingSupervisorQuestionsForOwner({
+      parentSessionId: state.currentSessionId,
+      parentGeneration: state.sessionGeneration ?? 0,
+      reason
+    });
+  }, settleRunQuestions = (runId, reason) => {
+    state.currentSessionId && cancelPendingSupervisorQuestionsForOwner({
+      parentSessionId: state.currentSessionId,
+      runId,
+      reason
+    });
   }, poll = () => {
     cleanupStaleChannelsIfDue();
     let ctx = state.lastUiContext;
     if (!ctx)
       return;
-    refreshPendingRequests(pending, state, ctx);
+    refreshPendingRequests(pending, state, ctx), pollSupervisorQuestions(pi, state, ctx);
     let now = Date.now();
     for (let { channelDir, file } of listRequestFiles()) {
       if (seenFiles.has(file))
@@ -4673,7 +5207,7 @@ function createNativeSupervisorChannel(pi, state) {
         seenFiles.add(file), cleanupRequestLifecycle(request, lifecycle);
         continue;
       }
-      seenFiles.add(file), request.expectsReply ? pending.set(request.id, request) : removeRequestFile(request.requestFile), pi.sendMessage({
+      if (seenFiles.add(file), request.expectsReply ? pending.set(request.id, request) : removeRequestFile(request.requestFile), pi.sendMessage({
         customType: "subagent_supervisor_request",
         content: requestVisibleText(request),
         display: !0,
@@ -4685,12 +5219,23 @@ function createNativeSupervisorChannel(pi, state) {
           agent: request.agent,
           childIndex: request.childIndex
         }
-      }), request.expectsReply && pi.events?.emit(INTERCOM_DETACH_REQUEST_EVENT, {
-        requestId: request.id,
-        runId: request.runId,
-        agent: request.agent,
-        childIndex: request.childIndex
-      });
+      }), request.expectsReply) {
+        let job = state.asyncJobs.get(request.runId);
+        job && (job.activityState = "needs_attention");
+        let events = pi.events;
+        events?.emit(INTERCOM_DETACH_REQUEST_EVENT, {
+          requestId: request.id,
+          runId: request.runId,
+          agent: request.agent,
+          childIndex: request.childIndex
+        }), events?.emit(SUBAGENT_CONTROL_EVENT, {
+          type: "needs_attention",
+          to: "needs_attention",
+          runId: request.runId,
+          agent: request.agent,
+          index: request.childIndex
+        });
+      }
     }
   };
   return {
@@ -4698,14 +5243,16 @@ function createNativeSupervisorChannel(pi, state) {
       poller || (registerParentTools(), poll(), poller = setInterval(poll, CHANNEL_POLL_MS), poller.unref?.());
     },
     dispose: () => {
-      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();
     },
-    pending
+    pending,
+    cancelOwnedQuestions,
+    settleRunQuestions
   };
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/extension/rpc.js
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import { Compile } from "typebox/compile";
 var SUBAGENT_RPC_PROTOCOL_VERSION = 1, SUBAGENT_RPC_REQUEST_EVENT = "subagents:rpc:v1:request", SUBAGENT_RPC_READY_EVENT = "subagents:rpc:v1:ready", SUBAGENT_RPC_REPLY_EVENT_PREFIX = "subagents:rpc:v1:reply:", SUBAGENT_RPC_METHODS = ["ping", "status", "spawn", "interrupt", "stop"], SubagentRpcError = class extends Error {
   code;
@@ -4812,7 +5359,7 @@ function stopAsyncRun(params, options, ctx) {
   }
   if (!location.asyncDir)
     throw new SubagentRpcError("not_found", "Async run not found or already completed; stop requires a live async run directory.");
-  let currentSessionId = ctx.sessionManager.getSessionId(), initialStatus = readStatus(location.asyncDir), initialRunId = initialStatus?.runId ?? location.resolvedId ?? path8.basename(location.asyncDir);
+  let currentSessionId = ctx.sessionManager.getSessionId(), initialStatus = readStatus(location.asyncDir), initialRunId = initialStatus?.runId ?? location.resolvedId ?? path9.basename(location.asyncDir);
   if (!initialStatus)
     throw new SubagentRpcError("not_found", `Status file not found for async run '${initialRunId}'.`);
   if (!currentSessionId || initialStatus.sessionId !== currentSessionId)
@@ -5044,7 +5591,9 @@ var ACTIVE_STATES = ["queued", "running"], DEFAULT_TIMEOUT_MS = 1800 * 1e3, MIN_
   SUBAGENT_FOREGROUND_COMPLETE_EVENT,
   SUBAGENT_CONTROL_EVENT,
   SUBAGENT_CONTROL_INTERCOM_EVENT,
-  SUBAGENT_RESULT_INTERCOM_EVENT
+  SUBAGENT_RESULT_INTERCOM_EVENT,
+  INTERCOM_DETACH_REQUEST_EVENT,
+  SUBAGENT_QUESTION_EVENT
 ];
 function defaultSleep(ms, signal) {
   return new Promise((resolve3) => {
@@ -5113,8 +5662,8 @@ function summarizeForegroundChildren(run, indices) {
     !indices.has(child.index) || child.status === "detached" || counts.set(child.status, (counts.get(child.status) ?? 0) + 1);
   return [...counts.entries()].map(([status, count]) => `${count} ${status}`).join(", ");
 }
-function needsAttention(run) {
-  return run.activityState === "needs_attention";
+function needsAttention(run, sessionId) {
+  return run.activityState === "needs_attention" || hasPendingBlockingSupervisorRequest(run.id, sessionId);
 }
 function backgroundWorkIdentity(item) {
   return `${item.provider}\0${item.sessionId}\0${item.id}`;
@@ -5136,7 +5685,7 @@ function activeRunsForSession(params, deps) {
   return params.id ? runs.filter((run) => matchesId(run, params.id)) : runs;
 }
 function attentionRunsForSession(params, deps, initialIds) {
-  return activeRunsForSession(params, deps).filter((run) => needsAttention(run) && initialIds.has(run.id));
+  return activeRunsForSession(params, deps).filter((run) => needsAttention(run, deps.state.currentSessionId) && initialIds.has(run.id));
 }
 function allRunsForSession(params, deps) {
   let asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR, resultsDir = deps.resultsDir ?? RESULTS_DIR, runs = listAsyncRuns(asyncDirRoot, {
@@ -5182,12 +5731,57 @@ async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, p
     await waitForWake(pollIntervalMs, signal, deps);
   }
 }
+async function waitForSupervisorQuestion(questionId, signal, deps, startedAt, now, pollIntervalMs, timeoutMs) {
+  let sessionId = deps.state.currentSessionId;
+  if (!sessionId)
+    return result("subagent_wait requires an active session identity to scope background work safely.", !0);
+  let releaseWait = registerQuestionWait([questionId]);
+  try {
+    for (; ; ) {
+      let found = findSupervisorQuestion(questionId);
+      if (!found)
+        return result(`No supervisor question matched "${questionId}".`, !0);
+      let { channelDir } = found, { question } = found;
+      if (question.parentSessionId !== sessionId || deps.state.currentSessionId !== sessionId)
+        return result(`Supervisor question "${questionId}" belongs to another session.`, !0);
+      if ((deps.state.sessionGeneration ?? 0) !== question.parentGeneration)
+        return result(`Supervisor question "${questionId}" was cancelled by a session replacement.`, !0);
+      if (question = reconcileAsyncQuestion(channelDir, question, deps.state), supervisorQuestionIsTerminal(question)) {
+        claimQuestionNotification(channelDir, question.id);
+        let state = supervisorQuestionPublicState(question);
+        return {
+          content: [{ type: "text", text: formatSupervisorQuestionAnswer(question) }],
+          ...state === "answered" ? {} : { isError: !0 },
+          details: {
+            mode: "management",
+            results: [],
+            questionId: question.id,
+            state,
+            runId: question.runId,
+            answered: state === "answered",
+            delivered: !!question.deliveredAt
+          }
+        };
+      }
+      if (signal?.aborted)
+        return result(`Wait aborted after ${formatDuration(now() - startedAt)} for supervisor question "${questionId}".`, !0);
+      if (now() - startedAt >= timeoutMs)
+        return result(`Wait timed out after ${formatDuration(timeoutMs)} for supervisor question "${questionId}". The question remains pending until answered, expired, or cancelled.`, !0);
+      await waitForWake(pollIntervalMs, signal, deps);
+    }
+  } finally {
+    releaseWait();
+  }
+}
 async function waitForSubagents(params, signal, deps) {
   if (deps.enabled === !1)
     return result('subagent_wait is disabled by config.waitTool or PI_SUBAGENT_WAIT_TOOL_ENABLED; returning immediately without blocking background work. Active work keeps going, and you can inspect subagents with subagent({ action: "status" }) or rely on completion notifications.');
   if (!deps.state.currentSessionId)
     return result("subagent_wait requires an active session identity to scope background work safely.", !0);
-  let now = deps.now ?? Date.now, pollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS), timeoutMs = params.timeoutMs !== void 0 && params.timeoutMs > 0 ? params.timeoutMs : DEFAULT_TIMEOUT_MS, startedAt = now(), waitForAll = params.id ? !0 : params.all === !0, active, foreground, providerSnapshot;
+  let now = deps.now ?? Date.now, pollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS), timeoutMs = params.timeoutMs !== void 0 && params.timeoutMs > 0 ? params.timeoutMs : DEFAULT_TIMEOUT_MS, startedAt = now();
+  if (params.questionId?.trim())
+    return waitForSupervisorQuestion(params.questionId.trim(), signal, deps, startedAt, now, pollIntervalMs, timeoutMs);
+  let waitForAll = params.id ? !0 : params.all === !0, active, foreground, providerSnapshot;
   try {
     active = activeRunsForSession(params, deps), foreground = activeDetachedForegroundRuns(params, deps), providerSnapshot = params.id ? { providers: [], items: [] } : backgroundWorkForSession(deps, startedAt);
   } catch (error) {
@@ -5208,7 +5802,7 @@ async function waitForSubagents(params, signal, deps) {
   let providerActive = providerSnapshot.items;
   if (active.length === 0 && providerActive.length === 0)
     return result(params.id ? `No active run matched "${params.id}". Nothing to wait for.` : "No active async runs or registered provider work in this session. Nothing to wait for.");
-  let waitParams = params.id ? { ...params, id: active[0].id } : params, initialAsyncIds = new Set(active.map((run) => run.id)), initialProviderIds = new Set(providerActive.map(backgroundWorkIdentity)), initialProviderNames = new Set(providerActive.map((item) => item.provider)), initialCount = initialAsyncIds.size + initialProviderIds.size, stopOnAttention = deps.stopOnAttention !== !1, attention = active.filter((run) => needsAttention(run)), isDone = () => {
+  let waitParams = params.id ? { ...params, id: active[0].id } : params, initialAsyncIds = new Set(active.map((run) => run.id)), initialProviderIds = new Set(providerActive.map(backgroundWorkIdentity)), initialProviderNames = new Set(providerActive.map((item) => item.provider)), initialCount = initialAsyncIds.size + initialProviderIds.size, stopOnAttention = deps.stopOnAttention !== !1, attention = active.filter((run) => needsAttention(run, deps.state.currentSessionId)), isDone = () => {
     if (stopOnAttention && attention.some((run) => initialAsyncIds.has(run.id)))
       return !0;
     let activeAsyncIds = new Set(active.map((run) => run.id)), activeProviderIds2 = new Set(providerActive.map(backgroundWorkIdentity));
@@ -5256,11 +5850,12 @@ 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.
 \u2022 { id: "..." } \u2014 wait for one async or remembered detached foreground subagent run (id or prefix).
+\u2022 { questionId: "..." } \u2014 wait for one supervisor question from subagent_supervisor action='ask' (answered/expired/cancelled). Separate from final run results.
 \u2022 { timeoutMs: 600000 } \u2014 stop waiting after N ms; active work keeps running.
 
 Provider jobs are session-scoped and identified exactly, so replacing one job with another cannot hide a completion. Provider extensions must be explicitly loaded in this process. In a child agent, keep \`subagent_wait\` in the child tool allowlist and load each provider through the agent's extensions or subagentOnlyExtensions; this tool never loads providers or grants tools itself.${enabled ? "" : `
@@ -5395,7 +5990,7 @@ function formatSingleCompletion(details) {
 }
 function parseSubagentNotifyContent(content) {
   let lines = content.split(`
-`), match = (lines[0] ?? "").match(/^(Background task|Detached foreground task) (completed|failed|paused): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
+`), match = (lines[0] ?? "").match(/^(Background task|Detached foreground task) (completed|failed|paused|stopped): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
   if (!match)
     return;
   let body = lines.slice(2), sessionIndex = -1;
@@ -5439,7 +6034,7 @@ function sendCompletion(pi, details) {
     customType: "subagent-notify",
     content,
     display: !0
-  }, { triggerTurn: !0 });
+  }, { triggerTurn: details.some((detail) => detail.status !== "stopped") });
 }
 function completionBatchKey(result2) {
   let sessionId = typeof result2.sessionId == "string" ? result2.sessionId.trim() : "";
@@ -5449,13 +6044,38 @@ function completionBatchKey(result2) {
   return cwd ? `cwd:${cwd}` : "unknown";
 }
 function buildCompletionDetails(result2) {
-  let agent = result2.agent ?? "unknown", summary = typeof result2.summary == "string" ? result2.summary : "", status = !result2.success && (result2.exitCode === 0 || result2.state === "paused" || summary.startsWith("Paused after interrupt.")) ? "paused" : result2.success ? "completed" : "failed", taskInfo = result2.taskIndex !== void 0 && result2.totalTasks !== void 0 ? ` (${result2.taskIndex + 1}/${result2.totalTasks})` : void 0, session = result2.shareUrl ? { label: "Session", value: result2.shareUrl } : result2.shareError ? { label: "Session share error", value: result2.shareError } : result2.sessionFile ? { label: "Session file", value: result2.sessionFile } : void 0;
+  let agent = result2.agent ?? "unknown", summary = typeof result2.summary == "string" ? result2.summary : "", paused = !result2.success && (result2.exitCode === 0 || result2.state === "paused" || summary.startsWith("Paused after interrupt.")), status = result2.state === "stopped" ? "stopped" : paused ? "paused" : result2.success ? "completed" : "failed", taskInfo = result2.taskIndex !== void 0 && result2.totalTasks !== void 0 ? ` (${result2.taskIndex + 1}/${result2.totalTasks})` : void 0, session = result2.shareUrl ? { label: "Session", value: result2.shareUrl } : result2.shareError ? { label: "Session share error", value: result2.shareError } : result2.sessionFile ? { label: "Session file", value: result2.sessionFile } : void 0;
   return {
     agent,
     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 } : {}
   };
@@ -5538,15 +6158,15 @@ function handleSubagentSteeringNotice(input) {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/extension/config.js
-import * as fs7 from "node:fs";
-import * as path9 from "node:path";
+import * as fs8 from "node:fs";
+import * as path10 from "node:path";
 function getConfigPath() {
-  return path9.join(getAgentDir(), "extensions", "subagent", "config.json");
+  return path10.join(getAgentDir(), "extensions", "subagent", "config.json");
 }
 function readConfigForUpdate(configPath = getConfigPath()) {
-  if (!fs7.existsSync(configPath))
+  if (!fs8.existsSync(configPath))
     return {};
-  let parsed = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+  let parsed = JSON.parse(fs8.readFileSync(configPath, "utf-8"));
   if (!parsed || typeof parsed != "object" || Array.isArray(parsed))
     throw new Error(`Subagent config at '${configPath}' must be a JSON object`);
   return parsed;
@@ -5562,25 +6182,31 @@ function loadConfig() {
 }
 
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/extension/tool-description.js
-import * as fs8 from "node:fs";
-import * as path10 from "node:path";
-var CUSTOM_TOOL_DESCRIPTION_FILE = "subagent-tool-description.md", CUSTOM_TOOL_DESCRIPTION_MAX_BYTES = 50 * 1024, SUBAGENT_SAFETY_GUIDANCE = `SAFETY-CRITICAL SUBAGENT GUIDANCE:
+import * as fs9 from "node:fs";
+import * as path11 from "node:path";
+var CUSTOM_TOOL_DESCRIPTION_FILE = "subagent-tool-description.md", CUSTOM_TOOL_DESCRIPTION_MAX_BYTES = 50 * 1024, SUBAGENT_TIER_GUIDANCE = `TIER SELECTION:
+\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 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 also needs tier: "light", "standard", or "heavy". Direct model overrides and parent-model inheritance are not available. A missing, disabled, unconfigured, unavailable, or unauthenticated tier fails before launch.
+\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.*/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 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 ${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 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):
-\u2022 SINGLE: { task, description, tier, permissions? } \u2014 one child. Multiple SINGLE calls in the same turn run concurrently; explicit concurrency/run limits still apply.
-\u2022 PARALLEL: { tasks: [{task, description, tier, permissions?, count?, output?, reads?, progress?}, ...], concurrency?: number, worktree?: true } \u2014 one-call concurrent execution (default: all tasks at once; worktree: isolate each task in a git worktree)
-\u2022 CHAIN: { chain: [{task, description, tier, permissions?}, {parallel:[{task, description, tier, permissions?, count:3}]}] } \u2014 sequential pipeline with optional parallel fan-out. Use chain when a later child needs an earlier result.
+\u2022 SINGLE: { task, description, tier|model, thinking?, permissions? } \u2014 one child. Multiple SINGLE calls in the same turn run concurrently; explicit concurrency/run limits still apply.
+\u2022 PARALLEL: { tasks: [{task, description, tier|model, thinking?, permissions?, count?, output?, reads?, progress?}, ...], concurrency?: number, worktree?: true } \u2014 one-call concurrent execution (default: all tasks at once; worktree: isolate each task in a git worktree)
+\u2022 CHAIN: { chain: [{task, description, tier|model, thinking?, permissions?}, {parallel:[{task, description, tier|model, thinking?, permissions?, count:3}]}] } \u2014 sequential pipeline with optional parallel fan-out. Use chain when a later child needs an earlier result.
 \u2022 description is required, single-line, max 80 characters. It is UI metadata only. task is the complete child prompt.
 \u2022 permissions: "full" (default) or "read-only". Full includes coding tools (read, search, shell, edit, write, web, LSP, MCP) and excludes parent-owned tools (cron, memory, behavior, goals, nested subagents). Plan-mode parents may launch only permissions: "read-only".
-\u2022 Every executable child requires tier: "light", "standard", or "heavy". Direct model overrides and parent-model inheritance are rejected. The configured tier model and credentials must be available.
+\u2022 Model selection: pass tier by default ("light"|"standard"|"heavy"). Pass model: "provider/id" only when the user specifies a model. Exactly one of tier or model. Optional thinking only with model; tier uses configured thinking. Direct model launches do not require tier mode to be enabled. No inherit and no silent fallback for an explicit model.
 \u2022 Children always start with a fresh session (no inherited parent transcript).
 \u2022 Optional timeout: { timeoutMs } or { maxRuntimeMs } sets a run-level max runtime for foreground and async/background runs
 
@@ -5595,8 +6221,7 @@ CHAIN EXAMPLES:
 \u2022 Mixed: { chain: [{task:"Research {task}", description:"Research request", tier:"standard", permissions:"read-only"}, {parallel: [{task:"Review {previous}", description:"Review findings", tier:"light", permissions:"read-only", count: 2}]}, {task:"Summarize {previous}", description:"Summarize reviews", tier:"standard"}] }
 
 CONTROL (use action field, omit task/chain/tasks):
-\u2022 { action: "watchdog.status" | "watchdog.check" | "watchdog.recommend-model" } - inspect the opt-in subagent watchdog and its strong complementary model recommendation
-\u2022 { action: "watchdog.configure", model: "recommended" | "inherit" | "provider/model[:thinking]", scope?: "session" | "user" | "project", target?: "main" | "children", thinking?: "inherit" | "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" } - configure watchdog model selection; default scope is session, use persistent scopes only when the user asks
+\u2022 { action: "watchdog.status" | "watchdog.check" | "watchdog.recommend-model" } - inspect the opt-in subagent watchdog and its strong complementary model recommendation (read-only; there is no configure action)
 \u2022 { action: "status", id: "..." } - inspect an async/background run by id or prefix
 \u2022 { action: "status", view: "fleet" } - read-only active foreground/async fleet view with transcript commands
 \u2022 { action: "status", id: "...", view: "transcript", index?: 0, lines?: 80 } - tail a run or child output/session transcript
@@ -5604,10 +6229,12 @@ CONTROL (use action field, omit task/chain/tasks):
 \u2022 { action: "stop", id: "..." } - stop a current-session top-level async run; stopped runs finish with state "stopped"
 \u2022 { action: "resume", id: "...", message: "...", index?: 0 } - interrupt then follow up with a live async child, or revive a completed async/foreground child from its session
 \u2022 { action: "steer", id: "...", message: "...", index?: 0 } - await correlated child input acceptance for up to 3 seconds; returns delivered, scheduled, pending, partial, recovered, or failed with a request id. Only top-level single runs may recover after a further 15-second pause/revival bound; chain, parallel, and nested runs never auto-interrupt.
+\u2022 subagent_supervisor({ action: "ask", id, reason, message, index?, childId? }) - ask one running async child; returns question id immediately. Ask only when the child owns missing context, the answer changes a concrete next decision, and waiting risks block/rework. No broadcast, revive, task replacement, status polling, or micromanagement.
+\u2022 subagent_wait({ questionId }) - wait for that supervisor question answer/expiry/cancel. Answers stay separate from final run results.
 \u2022 { action: "append-step", id: "...", chain: [{task:"Use {previous}", description:"Follow-up step", tier:"standard"}] } - append one step to the tail of a running async chain
 
 SCHEDULE (opt-in; requires { "scheduledRuns": { "enabled": true } } in config.json):
-\u2022 { action: "schedule", task, description, tier, permissions?, schedule: "+10m" | "2030-01-01T09:00:00Z", scheduleName? } - defer a child launch until a future time. Also accepts tasks[] or chain[]. Scheduled runs always launch async with fresh context; they become normal tracked async runs once they fire. Only schedule explicit delayed runs the user asked for.
+\u2022 { action: "schedule", task, description, tier|model, thinking?, permissions?, schedule: "+10m" | "2030-01-01T09:00:00Z", scheduleName? } - defer a child launch until a future time. Also accepts tasks[] or chain[]. Scheduled runs always launch async with fresh context; they become normal tracked async runs once they fire. Only schedule explicit delayed runs the user asked for.
 \u2022 { action: "schedule-list" } - list scheduled runs for this session
 \u2022 { action: "schedule-status", id: "..." } - inspect one scheduled run
 \u2022 { action: "schedule-cancel", id: "..." } - cancel a scheduled run before it fires
@@ -5618,19 +6245,20 @@ DIAGNOSTICS:
 ${SUBAGENT_SAFETY_GUIDANCE}`, COMPACT_SUBAGENT_TOOL_DESCRIPTION = `Delegate to generic children by prompting them. Use exactly one mode per call.
 
 EXECUTE:
-\u2022 SINGLE {task, description, tier, permissions?} (same-turn singles overlap); PARALLEL {tasks:[{task,description,tier,permissions?,count?,output?,reads?,progress?}], concurrency?, worktree?}; CHAIN {chain:[{task,description,tier,permissions?},{parallel:[...]}]} for sequential work.
+\u2022 SINGLE {task, description, tier|model, thinking?, permissions?} (same-turn singles overlap); PARALLEL {tasks:[{task,description,tier|model,thinking?,permissions?,count?,output?,reads?,progress?}], concurrency?, worktree?}; CHAIN {chain:[{task,description,tier|model,thinking?,permissions?},{parallel:[...]}]} for sequential work.
 \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 Every executable child requires tier:"light"|"standard"|"heavy". Direct model overrides and parent-model inheritance are rejected; tier resolution fails closed. Children always start with a fresh session. timeoutMs/maxRuntimeMs apply to foreground and async/background runs.
+\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 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}]}] }
 
 CONTROL:
-\u2022 Use action without execution fields: doctor, watchdog.status, watchdog.check, watchdog.recommend-model, watchdog.configure, status, interrupt, stop, resume, steer, append-step.
+\u2022 Use action without execution fields: doctor, watchdog.status, watchdog.check, watchdog.recommend-model, status, interrupt, stop, resume, steer, append-step.
 \u2022 Async control actions: status, interrupt, stop, resume, steer, append-step. Use stop with an id for current-session top-level async runs. Use status view:"fleet" for active-run overview, view:"transcript" to tail child output, and steer for acknowledged live guidance. Steering delivery means lunR accepted the correlated user input, not model compliance; use index for a specific child.
 \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:
@@ -5649,8 +6277,8 @@ function resolveToolDescriptionMode(config, options) {
 function customDescriptionPaths(options) {
   let cwd = options?.cwd ?? process.cwd(), agentDir = options?.agentDir ?? getAgentDir();
   return [
-    path10.join(getProjectConfigDir(cwd), CUSTOM_TOOL_DESCRIPTION_FILE),
-    path10.join(agentDir, CUSTOM_TOOL_DESCRIPTION_FILE)
+    path11.join(getProjectConfigDir(cwd), CUSTOM_TOOL_DESCRIPTION_FILE),
+    path11.join(agentDir, CUSTOM_TOOL_DESCRIPTION_FILE)
   ];
 }
 function renderCustomTemplate(template, options) {
@@ -5673,7 +6301,7 @@ function loadCustomToolDescription(options) {
   for (let filePath of customDescriptionPaths(options)) {
     let stat;
     try {
-      stat = fs8.statSync(filePath);
+      stat = fs9.statSync(filePath);
     } catch (error) {
       if (typeof error == "object" && error !== null && "code" in error && error.code === "ENOENT")
         continue;
@@ -5689,7 +6317,7 @@ function loadCustomToolDescription(options) {
       continue;
     }
     try {
-      let template = fs8.readFileSync(filePath, "utf-8").trim();
+      let template = fs9.readFileSync(filePath, "utf-8").trim();
       if (!template) {
         warn(options, `Ignoring empty custom tool description '${filePath}'.`);
         continue;
@@ -5728,24 +6356,24 @@ function buildSubagentToolDescription(config = {}, options) {
 // packages/coding-agent/dist/builtin-extensions/pi-subagents/src/extension/index.js
 function getSubagentSessionRoot(parentSessionFile) {
   if (parentSessionFile) {
-    let baseName = path11.basename(parentSessionFile, ".jsonl"), sessionsDir = path11.dirname(parentSessionFile);
-    return path11.join(sessionsDir, baseName);
+    let baseName = path12.basename(parentSessionFile, ".jsonl"), sessionsDir = path12.dirname(parentSessionFile);
+    return path12.join(sessionsDir, baseName);
   }
-  return fs9.mkdtempSync(path11.join(os.tmpdir(), "pi-subagent-session-"));
+  return fs10.mkdtempSync(path12.join(os.tmpdir(), "pi-subagent-session-"));
 }
 function expandTilde(p) {
-  return p.startsWith("~/") ? path11.join(os.homedir(), p.slice(2)) : p;
+  return p.startsWith("~/") ? path12.join(os.homedir(), p.slice(2)) : p;
 }
 function ensureAccessibleDir(dirPath) {
-  fs9.mkdirSync(dirPath, { recursive: !0 });
+  fs10.mkdirSync(dirPath, { recursive: !0 });
   try {
-    fs9.accessSync(dirPath, fs9.constants.R_OK | fs9.constants.W_OK);
+    fs10.accessSync(dirPath, fs10.constants.R_OK | fs10.constants.W_OK);
   } catch {
     try {
-      fs9.rmSync(dirPath, { recursive: !0, force: !0 });
+      fs10.rmSync(dirPath, { recursive: !0, force: !0 });
     } catch {
     }
-    fs9.mkdirSync(dirPath, { recursive: !0 }), fs9.accessSync(dirPath, fs9.constants.R_OK | fs9.constants.W_OK);
+    fs10.mkdirSync(dirPath, { recursive: !0 }), fs10.accessSync(dirPath, fs10.constants.R_OK | fs10.constants.W_OK);
   }
 }
 function isSlashResultRunning(result2) {
@@ -5760,23 +6388,58 @@ function effectiveParallelTaskCount(tasks) {
     return total + count;
   }, 0);
 }
-function renderSubagentCall(args, theme, context) {
+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 || "";
+    let target = context?.result?.details?.displayTitle || options?.resolveActionTitle?.(args) || args.id || args.runId || "";
     return new Text2(`${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), asyncLabel = args.async === !0 && args.clarify !== !0 ? 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 "))}chain (${args.chain.length})${asyncLabel}`, 0, 0);
+    return new Text2(`${theme.fg("toolTitle", theme.bold("subagent "))}${asyncMark}chain (${args.chain.length})`, 0, 0);
   if (isParallel)
-    return new Text2(`${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})${asyncLabel}`, 0, 0);
-  let description = !context?.isPartial && !context?.expanded && !context?.isError ? theme.fg("accent", args.description || args.task || "?") : "";
-  return new Text2(`${theme.fg("toolTitle", theme.bold(description ? "subagent " : "subagent"))}${description}${asyncLabel}`, 0, 0);
+    return new Text2(`${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);
+}
+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);
 }
 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") {
@@ -5788,7 +6451,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;
@@ -5818,11 +6481,12 @@ 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: "",
     currentSessionId: null,
+    sessionGeneration: 0,
     foregroundSubagentInFlight: 0,
     subagentSpawns: { sessionId: null, count: 0 },
     asyncJobs: /* @__PURE__ */ new Map(),
@@ -5844,15 +6508,19 @@ function registerSubagentExtension(pi) {
     }
   }, supervisorChannel = createNativeSupervisorChannel(pi, state), mainWatchdog = registerMainWatchdog(pi), { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(pi, state, RESULTS_DIR, 600 * 1e3);
   startResultWatcher(), primeExistingResults();
-  let generation = 0, executorPromise, pendingLaunches = /* @__PURE__ */ new Set(), runtimeCleanup = () => {
-    generation++, executorPromise = void 0, pendingLaunches.clear(), mainWatchdog.dispose(), stopResultWatcher(), scheduledRunManager.stop(), supervisorChannel.dispose(), clearPendingForegroundControlNotices(state), state.poller && (clearInterval(state.poller), state.poller = null);
+  let generation = 0, executorPromise, pendingLaunches = /* @__PURE__ */ new Set(), pendingAsyncLaunches = /* @__PURE__ */ new Set(), unregisterCancellation, runtimeCleanup = () => {
+    generation++, supervisorChannel.cancelOwnedQuestions("parent runtime replaced"), state.sessionGeneration = (state.sessionGeneration ?? 0) + 1, executorPromise = void 0, pendingLaunches.clear(), pendingAsyncLaunches.clear(), unregisterCancellation?.(), mainWatchdog.dispose(), stopResultWatcher(), scheduledRunManager.stop(), supervisorChannel.dispose(), clearPendingForegroundControlNotices(state), disposeSubagentWidget(), state.poller && (clearInterval(state.poller), state.poller = null);
   };
   globalStore[runtimeCleanupStoreKey] = runtimeCleanup;
-  let { ensurePoller, refreshWidget, handleStarted, handleComplete, resetJobs, restoreActiveJobs } = createAsyncJobTracker(pi, state, ASYNC_DIR, {
+  let { ensurePoller, refreshWidget, handleStarted, handleComplete: trackComplete, resetJobs, restoreActiveJobs } = createAsyncJobTracker(pi, state, ASYNC_DIR, {
     widgetEnabled: config.asyncWidget !== !1
-  }), executorExecute, scheduledRunManager = createScheduledRunManager({
+  }), handleComplete = (data) => {
+    trackComplete(data);
+    let result2 = data;
+    typeof state.currentSessionId == "string" && result2.sessionId !== state.currentSessionId || typeof result2.id == "string" && result2.id.trim() && supervisorChannel.settleRunQuestions(result2.id, "async run settled");
+  }, executorExecute, scheduledRunManager = createScheduledRunManager({
     config,
-    launch: (params, ctx, signal) => executorExecute ? executorExecute(randomUUID3(), params, signal, void 0, ctx) : Promise.resolve({
+    launch: (params, ctx, signal) => executorExecute ? executorExecute(randomUUID4(), params, signal, void 0, ctx) : Promise.resolve({
       content: [{ type: "text", text: "Scheduled subagent launch is unavailable (executor not ready)." }],
       isError: !0,
       details: { mode: "management", results: [] }
@@ -5862,20 +6530,19 @@ function registerSubagentExtension(pi) {
       let resolveLaunchReady, launchReady = !1, launchReadyPromise = new Promise((resolve3) => {
         resolveLaunchReady = resolve3;
       }), markLaunchReady = () => {
-        launchReady || (launchReady = !0, pendingLaunches.delete(launchReadyPromise), resolveLaunchReady());
+        launchReady || (launchReady = !0, pendingLaunches.delete(launchReadyPromise), pendingAsyncLaunches.delete(launchReadyPromise), resolveLaunchReady());
       };
-      pendingLaunches.add(launchReadyPromise);
+      pendingLaunches.add(launchReadyPromise), isAsyncSubagentExecution(resolveSubagentRequestParams(params)) && pendingAsyncLaunches.add(launchReadyPromise);
       try {
         let currentGeneration = generation;
         if (signal?.throwIfAborted(), !executorPromise) {
-          let pending = import("./subagent-executor-EFLTO32A.js").then(({ createSubagentExecutor }) => {
+          let pending = import("./subagent-executor-CXKXQDHH.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,
@@ -5906,35 +6573,20 @@ function registerSubagentExtension(pi) {
     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);
-  }), pi.registerMessageRenderer("subagent-notify", (message, options, theme) => {
+  }), pi.registerMessageRenderer("subagent-notify", (message, _options, theme) => {
     let content = typeof message.content == "string" ? message.content : "", details = message.details ?? parseSubagentNotifyContent(content);
-    if (!details)
-      return new Text2(content, 0, 0);
-    let icon = details.status === "completed" ? theme.fg("success", "\u2713") : details.status === "paused" ? theme.fg("warning", "\u25A0") : theme.fg("error", "\u2717"), parts = [];
-    details.taskInfo && parts.push(details.taskInfo), details.durationMs !== void 0 && parts.push(formatDuration(details.durationMs));
-    let notifyLabel = details.taskInfo || details.agent || "child", text = `${icon} ${theme.bold(notifyLabel)} ${theme.fg("dim", details.status)}`;
-    parts.length > 0 && (text += ` ${theme.fg("dim", "\xB7")} ${parts.map((part) => theme.fg("dim", part)).join(` ${theme.fg("dim", "\xB7")} `)}`);
-    let trimmedPreview = details.resultPreview.trim(), previewLines = options.expanded ? trimmedPreview.split(`
-`).filter((line) => line.trim()) : [trimmedPreview.split(`
-`, 1)[0] ?? ""].filter((line) => line.trim());
-    for (let line of previewLines.length > 0 ? previewLines : ["(no output)"])
-      text += `
-  ${theme.fg("dim", `\u23BF  ${line}`)}`;
-    if (!options.expanded && trimmedPreview.includes(`
-`)) {
-      let expandKey = keyText("app.tools.expand");
-      text += `
-  ${theme.fg("dim", `${expandKey} full notification`)}`;
-    }
-    return details.sessionLabel && details.sessionValue && (text += `
-  ${theme.fg("muted", `${details.sessionLabel}: ${shortenPath(details.sessionValue)}`)}`), new Text2(text, 0, 0);
+    return details ? renderSubagentNotify(details, theme) : new Text2(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);
   }), 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 displayTitle = params.action === "steer" ? resolveSubagentActionDisplayTitle(params, state) : void 0, result2 = await executor.execute(id, params, signal, onUpdate, ctx);
+    return displayTitle && result2.details && (result2.details.displayTitle = displayTitle), result2;
+  }, slashBridge = registerSlashSubagentBridge({
     events: pi.events,
     getContext: () => state.lastUiContext,
     execute: (id, params, signal, onUpdate, ctx) => executeSubagentCollapsed(id, params, signal, onUpdate, ctx)
@@ -5959,7 +6611,9 @@ function registerSubagentExtension(pi) {
     execute(id, params, signal, onUpdate, ctx) {
       return executeSubagentCollapsed(id, params, signal, onUpdate, ctx);
     },
-    renderCall: renderSubagentCall,
+    renderCall: (args, theme, context) => renderSubagentCall(args, theme, context, {
+      resolveActionTitle: (params) => resolveSubagentActionDisplayTitle(params, state)
+    }),
     renderResult(result2, options, theme, context) {
       subagentResultIsRunning(result2) ? ensureSubagentResultAnimation(context) : clearLegacyResultAnimationTimer(context);
       let state2 = context.state, entries = [];
@@ -6018,16 +6672,25 @@ function registerSubagentExtension(pi) {
     } catch {
     }
   }, resetSessionState = (ctx) => {
-    if (generation++, executorPromise = void 0, pendingLaunches.clear(), state.baseCwd = ctx.cwd, state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager), state.subagentSpawns = { sessionId: state.currentSessionId, count: 0 }, !process.env[SUBAGENT_CHILD_ENV]) {
-      let sessionId = ctx.sessionManager.getSessionId();
-      sessionId && (process.env[SUBAGENT_PARENT_SESSION_ENV] = sessionId);
-    }
-    state.lastUiContext = ctx, cleanupSessionArtifacts(ctx), clearPendingForegroundControlNotices(state), resetJobs(ctx), restoreActiveJobs(ctx), scheduledRunManager.bindSession(ctx), restoreSlashFinalSnapshots(ctx.sessionManager.getEntries()), primeExistingResults();
+    if (generation++, supervisorChannel.cancelOwnedQuestions("parent session replaced"), state.sessionGeneration = (state.sessionGeneration ?? 0) + 1, executorPromise = void 0, pendingLaunches.clear(), pendingAsyncLaunches.clear(), unregisterCancellation?.(), state.baseCwd = ctx.cwd, state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager), state.subagentSpawns = { sessionId: state.currentSessionId, count: 0 }, !process.env[SUBAGENT_CHILD_ENV]) {
+      let sessionId2 = ctx.sessionManager.getSessionId();
+      sessionId2 && (process.env[SUBAGENT_PARENT_SESSION_ENV] = sessionId2);
+    }
+    state.lastUiContext = ctx, cleanupSessionArtifacts(ctx), clearPendingForegroundControlNotices(state), resetJobs(ctx), restoreActiveJobs(ctx);
+    let sessionId = state.currentSessionId, sessionGeneration = generation;
+    sessionId && (unregisterCancellation = registerSubagentCancellation(sessionId, createSubagentCancellation({
+      pendingLaunches: pendingAsyncLaunches,
+      isCurrent: () => generation === sessionGeneration && state.currentSessionId === sessionId,
+      getActiveRunIds: () => [...state.asyncJobs.values()].filter((job) => job.sessionId === sessionId && (job.status === "queued" || job.status === "running")).map((job) => job.asyncId),
+      async stopRun(id) {
+        return !(await executor.execute(randomUUID4(), { action: "stop", id }, new AbortController().signal, void 0, ctx)).isError;
+      }
+    }))), scheduledRunManager.bindSession(ctx), restoreSlashFinalSnapshots(ctx.sessionManager.getEntries()), primeExistingResults();
   };
   pi.on("session_start", (_event, ctx) => {
     resetSessionState(ctx), rpcBridge.emitReady(ctx), supervisorChannel.start();
   }), pi.on("session_shutdown", () => {
-    generation++, executorPromise = void 0, pendingLaunches.clear(), delete process.env[SUBAGENT_PARENT_SESSION_ENV];
+    generation++, supervisorChannel.cancelOwnedQuestions("parent session shutdown"), state.sessionGeneration = (state.sessionGeneration ?? 0) + 1, executorPromise = void 0, pendingLaunches.clear(), pendingAsyncLaunches.clear(), unregisterCancellation?.(), delete process.env[SUBAGENT_PARENT_SESSION_ENV];
     for (let unsubscribe of eventUnsubscribes)
       try {
         unsubscribe();
@@ -6036,7 +6699,7 @@ function registerSubagentExtension(pi) {
     globalStore[eventUnsubscribeStoreKey] === eventUnsubscribes && delete globalStore[eventUnsubscribeStoreKey], stopResultWatcher(), scheduledRunManager.stop(), state.poller && clearInterval(state.poller), state.poller = null, clearPendingForegroundControlNotices(state);
     for (let timer of state.cleanupTimers.values())
       clearTimeout(timer);
-    state.cleanupTimers.clear(), state.asyncJobs.clear(), clearSlashSnapshots(), slashBridge.cancelAll(), slashBridge.dispose(), promptTemplateBridge.cancelAll(), promptTemplateBridge.dispose(), supervisorChannel.dispose(), globalStore[runtimeCleanupStoreKey] === runtimeCleanup && delete globalStore[runtimeCleanupStoreKey];
+    state.cleanupTimers.clear(), state.asyncJobs.clear(), clearSlashSnapshots(), slashBridge.cancelAll(), slashBridge.dispose(), promptTemplateBridge.cancelAll(), promptTemplateBridge.dispose(), supervisorChannel.dispose(), globalStore[runtimeCleanupStoreKey] === runtimeCleanup && delete globalStore[runtimeCleanupStoreKey], disposeSubagentWidget();
     try {
       state.lastUiContext?.hasUI && state.lastUiContext.ui.setWidget(WIDGET_KEY, void 0);
     } catch (error) {