@ashx-j/lunr 0.2.19 → 0.2.20

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

@@ -40,11 +40,11 @@ import {
   compactNestedResultChildren,
   deliverStopRequest,
   deliverSubagentResultIntercomEvent,
-  flatToLogicalStepIndex,
   formatActivityLabel,
   formatAgentRunningLabel,
   formatAsyncRunProgressLabel,
   formatAsyncRunTranscript,
+  formatCompactModelBadge,
   formatControlNoticeMessage,
   formatDuration,
   formatModelSelection,
@@ -64,12 +64,15 @@ import {
   normalizeParallelGroups,
   projectNestedRegistryForRoot,
   readStatus,
+  readSteerCapability,
   reconcileAsyncRun,
   reconcileNestedAsyncDescendants,
   registerMainWatchdog,
+  requestAsyncSteer,
   resolveAsyncRunLocation,
   resolveCurrentSessionId,
   resolveSubagentResultStatus,
+  resolveSubagentRunId,
   resolveTurnBudgetConfig,
   resolveWaitToolConfig,
   resolveWatchPath,
@@ -82,15 +85,19 @@ import {
   validateExecutionAcceptance,
   validateToolBudgetConfig,
   writeAtomicJson
-} from "./chunk-MCUNIRD5.js";
-import "./chunk-XATUM2HK.js";
+} from "./chunk-46ECNOLF.js";
+import {
+  createSubagentCancellation,
+  registerSubagentCancellation
+} from "./chunk-BBUVIEZB.js";
+import "./chunk-25I2BHAA.js";
 import "./chunk-WKDK4C5P.js";
 import "./chunk-53YJI7JU.js";
 import "./chunk-KBKMCJDU.js";
 import "./chunk-CSFI6YXL.js";
 import "./chunk-FVDOXRUD.js";
 import "./chunk-AD6VXAO7.js";
-import "./chunk-J26TSGDL.js";
+import "./chunk-6N22HULO.js";
 import "./chunk-M3LZLQW2.js";
 import "./chunk-RQ2Q5IYR.js";
 import {
@@ -104,10 +111,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
@@ -238,6 +245,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"}`;
 }
@@ -248,7 +265,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)
@@ -288,13 +308,16 @@ 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)
+  ].filter(Boolean).join(` ${theme.fg("dim", "\xB7")} `);
+  return truncLine(body, width);
 }
 function widgetRenderKey(job) {
   return JSON.stringify({
@@ -330,12 +353,6 @@ function formatWidgetAgents(agents) {
 function widgetJobName(job) {
   return job.mode === "parallel" ? "parallel" : job.mode === "chain" ? "chain" : job.mode === "single" && job.agents?.length === 1 ? job.agents[0] : job.agents?.length ? formatWidgetAgents(job.agents) : job.mode ?? "subagent";
 }
-function widgetActivity(job, now = Date.now()) {
-  let facts = [], snapshotNow = job.status === "running" ? now : job.updatedAt;
-  job.currentTool && job.currentToolStartedAt !== void 0 && snapshotNow !== void 0 ? facts.push(`${job.currentTool} ${formatDuration(Math.max(0, snapshotNow - job.currentToolStartedAt))}`) : job.currentTool && facts.push(job.currentTool), job.currentPath && facts.push(shortenPath(job.currentPath)), job.turnCount !== void 0 && facts.push(`${job.turnCount} turns`), job.toolCount !== void 0 && facts.push(`${job.toolCount} tools`);
-  let activity = buildLiveStatusLine(job, snapshotNow);
-  return activity && facts.length ? `${activity} \xB7 ${facts.join(" \xB7 ")}` : activity || (facts.length ? facts.join(" \xB7 ") : job.status === "running" ? "thinking\u2026" : job.status === "queued" ? "queued\u2026" : job.status === "paused" ? "Paused" : job.status === "stopped" ? "Stopped" : job.status === "failed" ? "Failed" : "Done");
-}
 function widgetStepRunningSeed(step, fallbackIndex) {
   return runningSeed(fallbackIndex, step.index);
 }
@@ -549,29 +566,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, [
@@ -663,12 +657,17 @@ function foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index, tota
   return lines;
 }
 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({
@@ -676,19 +675,30 @@ function compactJobLead(job, step) {
     task: step?.description ?? step?.agent
   }) || 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 activeJobStep(job) {
+  let steps = job.steps ?? [];
+  return steps.find((step) => step.status === "running") ?? steps.find((step) => step.status === "pending" || step.status === "queued") ?? steps[steps.length - 1];
+}
+function compactJobChildRows(job, theme, width, now = Date.now()) {
+  let steps = job.steps ?? [];
+  return steps.length <= 1 ? compactJobLines(job, steps[0], theme, width, now) : steps.flatMap((step) => compactJobLines(job, step, theme, width, now));
 }
-function buildSingleWidgetLines(job, theme, width, _expanded) {
-  let now = Date.now(), steps = job.steps ?? [];
+function compactJobLines(job, step, theme, width, now = Date.now()) {
+  let running = (step?.status ?? job.status) === "running", lead = compactJobLead(job, step), modelBadge = formatCompactModelBadge(step?.modelSelection, step?.model), glyph = step ? widgetStepGlyph(step.status, theme, running ? (widgetStepRunningSeed(step, step.index) ?? 0) + widgetAnimFrame(now) : widgetStepRunningSeed(step, step.index)) : widgetStatusGlyph(job, theme, now), progress = compactJobProgress(job, step, now);
+  return [formatCompactSubagentRow(theme, width, {
+    glyph,
+    description: lead,
+    modelBadge,
+    tokens: progress.tokens,
+    durationMs: progress.durationMs
+  })];
+}
+function buildSingleWidgetLines(job, theme, width, _expanded, now = Date.now()) {
+  let steps = job.steps ?? [];
   return steps.length <= 1 ? compactJobLines(job, steps[0], theme, width, now) : steps.flatMap((step) => compactJobLines(job, step, theme, width, now));
 }
-function compactSingleWidgetLines(job, theme, width) {
-  return buildSingleWidgetLines(job, theme, width, !1);
+function compactSingleWidgetLines(job, theme, width, now = Date.now()) {
+  return buildSingleWidgetLines(job, theme, width, !1, now);
 }
 var RESERVED_NON_WIDGET_ROWS = 19, widgetLayoutSession;
 function resetWidgetLayoutSession() {
@@ -718,7 +728,7 @@ function widgetHeaderCounts(jobs) {
   };
 }
 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 = [];
+  let counts = widgetHeaderCounts(jobs), hasActive = counts.running.length > 0 || counts.queued.length > 0, glyph = counts.running.length > 0 ? runningGlyph((widgetJobsRunningSeed(counts.running) ?? 0) + widgetAnimFrame()) : hasActive ? "\u25CF" : "\u25CB", parts = [];
   return counts.running.length > 0 && parts.push(`${counts.running.length}/${jobs.length} running`), counts.queued.length > 0 && parts.push(`${counts.queued.length} queued`), counts.failed.length > 0 && parts.push(`${counts.failed.length} failed`), counts.stopped.length > 0 && parts.push(`${counts.stopped.length} stopped`), counts.paused.length > 0 && parts.push(`${counts.paused.length} paused`), !hasActive && counts.complete.length > 0 && parts.push(`${counts.complete.length}/${jobs.length} done`), [truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "subagents")} (${parts.join(", ") || `${jobs.length} total`})`, width)];
 }
 function orderedWidgetJobs(jobs) {
@@ -763,17 +773,12 @@ function selectProgressiveJobKeys(jobs, previousKeys, bodyRows) {
   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 = [];
+  let counts = widgetHeaderCounts(jobs), hasActive = counts.running.length > 0 || counts.queued.length > 0, glyph = counts.running.length > 0 ? runningGlyph((widgetJobsRunningSeed(counts.running) ?? 0) + widgetAnimFrame()) : hasActive ? "\u25CF" : "\u25CB", parts = [];
   return counts.running.length > 0 && parts.push(formatAgentRunningLabel(counts.running.length)), counts.queued.length > 0 && parts.push(`${counts.queued.length} queued`), hasActive || (counts.failed.length > 0 && parts.push(`${counts.failed.length} failed`), counts.stopped.length > 0 && parts.push(`${counts.stopped.length} stopped`), counts.paused.length > 0 && parts.push(`${counts.paused.length} paused`), counts.complete.length > 0 && parts.push(`${counts.complete.length}/${jobs.length} done`)), truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "\xB7")} ${theme.fg("dim", parts.join(", ") || `${jobs.length} total`)}`, width);
 }
-function progressiveJobLine(job, theme, width) {
-  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 progressiveJobLine(job, theme, width, now = Date.now()) {
+  let row = compactJobLines(job, activeJobStep(job), theme, Math.max(1, width - 2), now)[0] ?? "";
+  return row ? `  ${row}` : "";
 }
 function progressiveHiddenLine(hiddenJobs, theme, width) {
   let counts = widgetHeaderCounts(hiddenJobs), parts = [];
@@ -822,20 +827,12 @@ function fitAdaptiveWidgetLines(jobs, lines, theme, width, expanded) {
   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;
-  };
-}
-function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = !1) {
+function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = !1, now = Date.now()) {
   if (jobs.length === 0)
     return [];
   if (jobs.length === 1)
-    return buildSingleWidgetLines(jobs[0], theme, width, expanded);
-  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";
+    return buildSingleWidgetLines(jobs[0], theme, width, expanded, now);
+  let running = jobs.filter((job) => job.status === "running"), queued = jobs.filter((job) => job.status === "queued"), finished = jobs.filter((job) => job.status !== "running" && job.status !== "queued"), lines = [], hasActive = running.length > 0 || queued.length > 0, headerGlyph = running.length > 0 ? runningGlyph((widgetJobsRunningSeed(running) ?? 0) + widgetAnimFrame(now)) : hasActive ? "\u25CF" : "\u25CB";
   lines.push(truncLine(`${theme.fg(hasActive ? "accent" : "dim", headerGlyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "\xB7 background")}`, width));
   let items = [], hiddenRunning = 0, hiddenFinished = 0, queuedSummaryShown = !1, slots = MAX_WIDGET_JOBS;
   for (let job of running) {
@@ -843,12 +840,8 @@ function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = !1) {
       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--;
+    let row = compactJobChildRows(job, theme, Math.max(1, width - 3), now);
+    items.push(expanded ? [...row, ...widgetParallelAgentDetails(job, theme, !0, width)] : row), slots--;
   }
   queued.length > 0 && slots > 0 && (items.push([`${theme.fg("muted", "\u25E6")} ${theme.fg("dim", `${queued.length} queued`)}`]), queuedSummaryShown = !0, slots--);
   for (let job of finished) {
@@ -856,12 +849,8 @@ function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = !1) {
       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 row = compactJobChildRows(job, theme, Math.max(1, width - 3), now);
+    items.push(expanded ? [...row, ...widgetParallelAgentDetails(job, theme, !0, width)] : row), slots--;
   }
   let hiddenQueued = queued.length > 0 && !queuedSummaryShown ? queued.length : 0, hiddenTotal = hiddenRunning + hiddenFinished + hiddenQueued;
   if (hiddenTotal > 0) {
@@ -876,36 +865,91 @@ function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = !1) {
   }
   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();
   }
-  widgetPaintTimer || (widgetPaintTimer = setInterval(() => {
-    widgetPaintCtx?.ui.requestRender?.();
-  }, 80), widgetPaintTimer.unref?.());
+  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?.());
+    }, 80), this.timer.unref?.());
+  }
+  stopTimer() {
+    this.timer && (clearInterval(this.timer), this.timer = void 0);
+  }
+  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 = this.expanded ? buildWidgetLines(this.jobs, theme, innerWidth, !0, now) : this.jobs.length === 1 ? compactSingleWidgetLines(this.jobs[0], theme, innerWidth, now) : buildWidgetLines(this.jobs, theme, innerWidth, !1, now), padded = fitAdaptiveWidgetLines(this.jobs, lines, theme, innerWidth, this.expanded).map((line) => {
+      let 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;
   }
-  ctx.hasUI && (ensureWidgetPaintTimer(ctx, jobs.some((job) => job.status === "running")), ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, ctx.ui.getToolsExpanded?.() ?? !1)));
+  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;
+  }
+  let widget = new SubagentAsyncWidget(jobs, void 0, { expanded, requestRender });
+  activeWidget = widget, ctx.ui.setWidget(WIDGET_KEY, (_tui, theme) => (widget.setTheme(theme), widget));
 }
 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", c = new Container(), width = getTermWidth() - 4, lead = compactRowLead({ description: r.description ?? r.agent, task: r.task }), modelBadge = formatCompactModelBadge(r.modelSelection ?? progress?.modelSelection, r.model ?? progress?.model);
+  return c.addChild(animatedLine((f, now) => formatCompactSubagentRow(theme, width, {
+    glyph: resultGlyph(r, output, theme, isRunning, void 0, f),
+    description: lead,
+    modelBadge,
+    tokens: compactResultTokens(r),
+    durationMs: liveDurationMs(progress, isRunning, now)
+  }), frame, isRunning)), !isRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped) && c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `  \u23BF  ${resultStatusLine(r, output)}`), width), 0, 0)), c;
 }
 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;
@@ -918,8 +962,8 @@ function renderMultiCompact(d, theme, frame) {
     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)]);
+  c.addChild(animatedLine((f) => {
+    let stats = statJoin(theme, [multiLabel.headerLabel, formatTotalCostStat(d.totalCost)]);
     return truncLine(`${glyph(f)} ${theme.fg("toolTitle", theme.bold(d.mode))}${contextBadge}${stats ? ` ${theme.fg("dim", "\xB7")} ${stats}` : ""}`, width);
   }, frame, hasRunning));
   let useResultsDirectly = multiLabel.hasParallelInChain || !d.chainAgents?.length, displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0, displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : useResultsDirectly ? d.results.length : d.chainAgents.length, chainEntries = buildChainRenderEntries(d, multiLabel), renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset) => {
@@ -934,15 +978,22 @@ function renderMultiCompact(d, theme, frame) {
     }
     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));
+      let pendingLabel = chainEntries ? resultRowLabel(d, multiLabel, i, rowNumber) : `${itemTitle} ${rowNumber}`;
+      c.addChild(new Text(truncLine(theme.fg("dim", `  \u25E6 ${pendingLabel}: ${agentName} \xB7 pending`), width), 0, 0));
       continue;
     }
-    let output = getSingleResultOutput(r), progressFromArray = d.progress?.find((p) => p.index === i) || d.progress?.find((p) => p.agent === r.agent && p.status === "running"), rProg = r.progress || progressFromArray || r.progressSummary, rRunning = rProg && "status" in rProg && rProg.status === "running", rPending = rProg && "status" in rProg && rProg.status === "pending", 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));
+    let output = getSingleResultOutput(r), progressFromArray = d.progress?.find((p) => p.index === i) || d.progress?.find((p) => p.agent === r.agent && p.status === "running"), rProg = r.progress || progressFromArray || r.progressSummary, rRunning = rProg && "status" in rProg && rProg.status === "running", rPending = rProg && "status" in rProg && rProg.status === "pending", lead = compactRowLead({ description: r.description ?? agentName, task: r.task }), modelBadge = formatCompactModelBadge(r.modelSelection ?? (rProg && "modelSelection" in rProg ? rProg.modelSelection : void 0), r.model ?? (rProg && "model" in rProg ? rProg.model : void 0));
     c.addChild(animatedLine((f, now) => {
-      let 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 rowGlyph = rPending ? theme.fg("dim", "\u25E6") : resultGlyph(r, output, theme, rRunning, progressRunningSeed(rProg), f);
+      return formatCompactSubagentRow(theme, width, {
+        glyph: rowGlyph,
+        description: lead,
+        modelBadge,
+        tokens: compactResultTokens(r),
+        durationMs: liveDurationMs(rProg, !!rRunning, now),
+        prefix: "  "
+      });
+    }, frame, !!rRunning)), !rPending && !rRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped) && c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `    \u23BF  ${resultStatusLine(r, output)}`), width), 0, 0));
   }
   return c;
 }
@@ -1057,15 +1108,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);
@@ -1073,11 +1124,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: [
@@ -1095,10 +1146,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] }
@@ -1145,6 +1202,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)
@@ -1164,6 +1223,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({
@@ -1193,6 +1254,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({
@@ -1215,6 +1278,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({
@@ -1232,7 +1297,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" })),
@@ -1271,12 +1336,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."
@@ -1311,15 +1373,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,
@@ -1344,28 +1417,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))
@@ -1618,8 +1691,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) => {
@@ -1759,15 +1831,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;
@@ -1780,27 +1852,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
@@ -1808,7 +1880,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({
@@ -1822,7 +1894,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,
@@ -1833,30 +1922,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}`, 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);
@@ -1867,10 +1950,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;
@@ -1881,7 +1964,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 = () => {
@@ -1899,19 +1982,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();
   } };
 }
 
@@ -3100,6 +3183,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;
@@ -3649,12 +3738,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 } : {},
@@ -3765,7 +3858,9 @@ ${finalTask}`);
       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 } : {},
@@ -3773,8 +3868,12 @@ ${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 };
@@ -4402,28 +4501,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 {
@@ -4434,16 +5011,26 @@ function hasTool(pi, name) {
 }
 function parseRequestFile(file, channelDir) {
   try {
-    let parsed = JSON.parse(fs6.readFileSync(file, "utf-8"));
+    let parsed = JSON.parse(fs7.readFileSync(file, "utf-8"));
     return parsed.type !== "subagent.supervisor.request" || typeof parsed.id != "string" || !parsed.id || parsed.reason !== "need_decision" && parsed.reason !== "interview_request" && parsed.reason !== "progress_update" || typeof parsed.message != "string" || !parsed.message || typeof parsed.runId != "string" || typeof parsed.agent != "string" || typeof parsed.childIndex != "number" ? void 0 : { ...parsed, channelDir, requestFile: file };
   } 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.orchestratorSessionId && 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 [];
@@ -4453,34 +5040,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")
@@ -4491,19 +5078,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;
@@ -4513,7 +5103,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;
@@ -4533,13 +5123,13 @@ function requestMatchesContext(request, state, ctx) {
 }
 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))
@@ -4556,7 +5146,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);
@@ -4621,8 +5211,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;
@@ -4637,10 +5227,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 = currentContextSessionId(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));
@@ -4653,12 +5292,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))
@@ -4671,7 +5322,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,
@@ -4683,12 +5334,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 {
@@ -4696,14 +5358,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;
@@ -4810,7 +5474,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)
@@ -5042,7 +5706,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) => {
@@ -5111,8 +5777,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}`;
@@ -5134,7 +5800,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, {
@@ -5180,12 +5846,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) {
@@ -5206,7 +5917,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));
@@ -5259,6 +5970,7 @@ In an interactive chat, do not call this merely to wait: return control to the u
 \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 ? "" : `
@@ -5393,7 +6105,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;
@@ -5437,7 +6149,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() : "";
@@ -5447,7 +6159,7 @@ 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,
@@ -5536,15 +6248,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;
@@ -5560,25 +6272,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 Keep execution and control separate: omit action for SINGLE/PARALLEL/CHAIN execution; use action only for status/interrupt/stop/resume/steer/append-step/doctor/watchdog.status|check|recommend-model/schedule*.
 \u2022 Async/background runs: launch with async:true only when work can proceed independently. Do not sleep or poll status just to wait. In an interactive session, normally return control and let lunR wake you; use subagent_wait when this request must run to completion in the current turn or skill. Headless sessions auto-drain current-session work.
 \u2022 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
 
@@ -5593,8 +6311,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
@@ -5602,10 +6319,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
@@ -5616,14 +6335,15 @@ 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.
 
@@ -5647,8 +6367,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) {
@@ -5671,7 +6391,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;
@@ -5687,7 +6407,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;
@@ -5726,24 +6446,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) {
@@ -5758,18 +6478,25 @@ function effectiveParallelTaskCount(tasks) {
     return total + count;
   }, 0);
 }
-function renderSubagentCall(args, theme, context) {
+function callIsAsync(args, asyncByDefault) {
+  return args?.clarify === !0 ? !1 : args?.async === !0 ? !0 : args?.async === !1 ? !1 : asyncByDefault === !0;
+}
+function renderSubagentCall(args, theme, context, options) {
   if (args.action) {
     let target = args.id || args.runId || "";
     return new Text2(`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`, 0, 0);
   }
-  let 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 = callIsAsync(args, options?.asyncByDefault) ? `${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;
@@ -5821,6 +6548,7 @@ function registerSubagentExtension(pi) {
   let state = {
     baseCwd: "",
     currentSessionId: null,
+    sessionGeneration: 0,
     foregroundSubagentInFlight: 0,
     subagentSpawns: { sessionId: null, count: 0 },
     asyncJobs: /* @__PURE__ */ new Map(),
@@ -5842,15 +6570,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: [] }
@@ -5860,13 +6592,13 @@ 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), (params.task || params.tasks || params.chain) && !params.clarify && (params.async === !0 || params.async === void 0 && asyncByDefault || config.forceTopLevelAsync === !0) && pendingAsyncLaunches.add(launchReadyPromise);
       try {
         let currentGeneration = generation;
         if (signal?.throwIfAborted(), !executorPromise) {
-          let pending = import("./subagent-executor-5Q5A4HJ2.js").then(({ createSubagentExecutor }) => {
+          let pending = import("./subagent-executor-SRFC26SJ.js").then(({ createSubagentExecutor }) => {
             if (generation !== currentGeneration)
               throw new Error("Subagent session changed before initialization");
             return createSubagentExecutor({
@@ -5904,28 +6636,9 @@ 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)
@@ -5957,7 +6670,7 @@ 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, { asyncByDefault }),
     renderResult(result2, options, theme, context) {
       subagentResultIsRunning(result2) ? ensureSubagentResultAnimation(context) : clearLegacyResultAnimationTimer(context);
       let state2 = context.state, entries = [];
@@ -6016,16 +6729,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();
@@ -6034,7 +6756,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) {