pi-subagents 0.80.0 → 0.82.0

package/bundle/chunk-7YMXOYEU.js

@@ -0,0 +1,1373 @@
+import {
+  getLivePromptAudit,
+  handleInspectorAction,
+  readFleetTranscript,
+  renderFleetTranscript,
+  resolveWorkflowForegroundSteeringTarget,
+  steerAsyncRun,
+  steerWorkflowForegroundTarget
+} from "./chunk-7IVSUMQQ.js";
+import {
+  FLEET_STATUS_WIDGET_KEY,
+  reportFleetWarning,
+  runningTone,
+  stepTaskSummary
+} from "./chunk-M2CTFYT3.js";
+import {
+  foregroundChildStateLabel,
+  formatAsyncRunTranscript,
+  stopAsyncRun
+} from "./chunk-7PCKZHR5.js";
+import {
+  contextModeBadge,
+  contextModeLabel,
+  decodeUtf8Tail,
+  listAsyncRuns
+} from "./chunk-VH5OAWVG.js";
+import "./chunk-NRQ75MGH.js";
+import "./chunk-OYF6AFDY.js";
+import "./chunk-NIXWDZZV.js";
+import "./chunk-XSWOTIA3.js";
+import "./chunk-7F6RKT6W.js";
+import "./chunk-CTPAE36Y.js";
+import "./chunk-7J4ZXMY7.js";
+import {
+  getArtifactPaths,
+  getArtifactsDir
+} from "./chunk-5TYMSZX3.js";
+import {
+  snapshotExternalRuns
+} from "./chunk-UKG4V45O.js";
+import {
+  childThinkingLevel,
+  formatDuration,
+  formatModelThinking,
+  formatTokenUsage,
+  formatTokens,
+  readStatus,
+  shortenPath
+} from "./chunk-CIZQXJ5Q.js";
+import {
+  DIRS
+} from "./chunk-5LFLVSTM.js";
+import "./chunk-YFCK7H2S.js";
+import "./chunk-Z7KVHQHL.js";
+
+// src/tui/fleet.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+// src/tui/fleet-layout.ts
+function fleetLayout(width, rows, selected, items) {
+  if (width < 36) return void 0;
+  const bodyHeight = Math.max(2, Math.floor(rows * 0.85) - 6);
+  const rosterWidth = Math.max(22, Math.min(46, Math.floor((width - 3) * 0.38)));
+  const rosterStart = Math.max(0, Math.min(selected - bodyHeight + 1, Math.max(0, items.length - bodyHeight)));
+  return {
+    width,
+    rows,
+    bodyHeight,
+    rosterStart,
+    roster: { x: 1, y: 3, width: rosterWidth, height: bodyHeight },
+    output: { x: rosterWidth + 2, y: 3, width: Math.max(1, width - rosterWidth - 3), height: bodyHeight },
+    rosterKeys: items.slice(rosterStart, rosterStart + bodyHeight).map((item) => item.key)
+  };
+}
+function fleetContains(rect, x, y) {
+  return x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height;
+}
+
+// src/tui/fleet-viewport.ts
+import { ScrollView } from "@earendil-works/pi-tui";
+var FleetViewport = class {
+  body = {
+    lines: [],
+    render() {
+      return this.lines;
+    },
+    invalidate() {
+    }
+  };
+  scroll = new ScrollView(this.body, { follow: "end", overscroll: "contain" });
+  requestRender;
+  resetTopOnLayout = false;
+  constructor(requestRender) {
+    this.requestRender = requestRender;
+  }
+  render(lines, width, height) {
+    this.body.lines = lines;
+    const rendered = this.scroll.render(width);
+    this.scroll.updateLayout(rendered.length, height, this.requestRender);
+    if (this.resetTopOnLayout) {
+      this.resetTopOnLayout = false;
+      this.scroll.scrollTo(0, { disableFollow: true });
+    }
+    return rendered.slice(this.scroll.scrollTop, this.scroll.scrollTop + this.scroll.viewportHeight);
+  }
+  resetTop() {
+    this.resetTopOnLayout = true;
+    this.scroll.scrollTo(0, { disableFollow: true });
+  }
+  follow() {
+    this.resetTopOnLayout = false;
+    this.scroll.scrollToEnd();
+  }
+};
+
+// src/tui/fleet.ts
+var REFRESH_MS = 750;
+var MIN_REFRESH_MS = 250;
+var MAX_RECENT_ASYNC_RUNS = 20;
+var MAX_FLEET_HISTORY_CANDIDATES = 100;
+var TRANSCRIPT_LINES = 200;
+var OUTPUT_TAIL_BYTES = 64 * 1024;
+var PROMPT_AUDIT_SUMMARY_WIDTH = 160;
+var DEFAULT_FLEET_KEYBINDINGS = {
+  close: ["escape", "ctrl+c", "q"],
+  scrollUp: ["K"],
+  scrollDown: ["J"],
+  selectUp: ["up", "k"],
+  selectDown: ["down", "j"],
+  selectFirst: ["home"],
+  selectLast: ["end"],
+  pageUp: ["pageUp"],
+  pageDown: ["pageDown"],
+  refresh: ["r", "R"],
+  steer: ["s"],
+  inspect: ["return", "H"],
+  stop: ["D"],
+  toggleTools: ["x", "X", "ctrl+o"]
+};
+function resolveFleetKeybindings(config) {
+  return Object.fromEntries(
+    Object.entries(DEFAULT_FLEET_KEYBINDINGS).map(([action, defaults]) => [action, config?.[action] ?? defaults])
+  );
+}
+function matchesFleetBinding(data, binding) {
+  const key = /^[A-Z]$/.test(binding) ? `shift+${binding.toLowerCase()}` : binding;
+  return matchesKey(data, key);
+}
+function matchesFleetAction(data, bindings, action) {
+  return bindings[action].some((binding) => matchesFleetBinding(data, binding));
+}
+function bindingLabel(bindings, action) {
+  return bindings[action].map((binding) => binding === "up" ? "\u2191" : binding === "down" ? "\u2193" : binding === "escape" ? "Esc" : binding === "return" ? "Enter" : binding).join("/");
+}
+function belongsToCurrentSession(sessionId, currentSessionId) {
+  return !currentSessionId || sessionId === currentSessionId;
+}
+function trackedJobSummary(job) {
+  const startedAt = job.startedAt ?? job.updatedAt ?? Date.now();
+  return {
+    id: job.asyncId,
+    asyncDir: job.asyncDir,
+    ...job.sessionId ? { sessionId: job.sessionId } : {},
+    state: job.status,
+    activityState: job.activityState,
+    lastActivityAt: job.lastActivityAt,
+    currentTool: job.currentTool,
+    currentToolStartedAt: job.currentToolStartedAt,
+    currentPath: job.currentPath,
+    turnCount: job.turnCount,
+    toolCount: job.toolCount,
+    steering: job.steering,
+    mode: job.mode ?? "single",
+    ...job.context ? { context: job.context } : {},
+    ...job.cwd ? { cwd: job.cwd } : {},
+    startedAt,
+    ...job.updatedAt !== void 0 ? { lastUpdate: job.updatedAt } : {},
+    ...job.timeoutMs !== void 0 ? { timeoutMs: job.timeoutMs } : {},
+    ...job.deadlineAt !== void 0 ? { deadlineAt: job.deadlineAt } : {},
+    ...job.timedOut !== void 0 ? { timedOut: job.timedOut } : {},
+    ...job.stopped !== void 0 ? { stopped: job.stopped } : {},
+    ...job.turnBudget ? { turnBudget: job.turnBudget } : {},
+    ...job.turnBudgetExceeded !== void 0 ? { turnBudgetExceeded: job.turnBudgetExceeded } : {},
+    ...job.wrapUpRequested !== void 0 ? { wrapUpRequested: job.wrapUpRequested } : {},
+    ...job.currentStep !== void 0 ? { currentStep: job.currentStep } : {},
+    ...job.chainStepCount !== void 0 ? { chainStepCount: job.chainStepCount } : {},
+    ...job.parallelGroups?.length ? { parallelGroups: job.parallelGroups } : {},
+    ...job.preflight ? { preflight: job.preflight } : {},
+    steps: (job.steps ?? job.agents?.map((agent, index) => ({ agent, index, status: job.status === "queued" ? "pending" : job.status })) ?? []).map((step, index) => ({
+      ...step,
+      index: step.index ?? index
+    })),
+    ...job.sessionDir ? { sessionDir: job.sessionDir } : {},
+    ...job.outputFile ? { outputFile: job.outputFile } : {},
+    ...job.totalTokens ? { totalTokens: job.totalTokens } : {},
+    ...job.sessionFile ? { sessionFile: job.sessionFile } : {},
+    ...job.nestedChildren?.length ? { nestedChildren: job.nestedChildren } : {}
+  };
+}
+function asyncItems(run, description) {
+  const updatedAt = run.lastUpdate ?? run.endedAt ?? run.startedAt;
+  if (run.steps.length === 0 || run.mode === "workflow") {
+    return [{ key: `async:${run.id}`, kind: "async", runId: run.id, agent: run.mode, state: run.state, updatedAt, run, ...description ? { description } : {} }];
+  }
+  return run.steps.map((step) => {
+    const task = stepTaskSummary(step, step.agent);
+    return {
+      key: `async:${run.id}:${step.index}`,
+      kind: "async",
+      runId: run.id,
+      index: step.index,
+      agent: step.label ? `${step.label} (${step.agent})` : step.agent,
+      state: step.status,
+      updatedAt: step.lastActivityAt ?? updatedAt,
+      run,
+      step,
+      ...task ? { task } : {},
+      ...description ? { description } : {}
+    };
+  });
+}
+function orderFleetAsyncRuns(runs, terminalLimit, trackedJobs) {
+  const updatedAt = (run) => run.lastUpdate ?? run.endedAt ?? run.startedAt;
+  const byNewest = (left, right) => updatedAt(right) - updatedAt(left);
+  const startedAt = (run) => {
+    const job = trackedJobs.get(run.id);
+    return job ? job.startedAt ?? 0 : run.startedAt;
+  };
+  const byStartedAt = (left, right) => startedAt(left) - startedAt(right) || left.id.localeCompare(right.id);
+  const active = runs.filter((run) => run.state === "queued" || run.state === "running").sort(byStartedAt);
+  const terminal = runs.filter((run) => run.state !== "queued" && run.state !== "running").sort(byNewest);
+  return [...active, ...terminal.slice(0, terminalLimit)];
+}
+function collectFleetSnapshot(state, options = {}) {
+  const items = [];
+  const activeForegroundIds = /* @__PURE__ */ new Set();
+  const trackedJobs = state.fleetJobs ?? state.asyncJobs;
+  const workflowParentIds = new Set([...trackedJobs.values()].filter((job) => job.mode === "workflow" && belongsToCurrentSession(job.sessionId, state.currentSessionId)).map((job) => job.asyncId));
+  const workflowForegroundChildCounts = /* @__PURE__ */ new Map();
+  const liveWorkflowForegroundControls = /* @__PURE__ */ new Set();
+  for (const control of state.foregroundControls.values()) {
+    const activeChildCount = control.activeChildren?.size ?? 0;
+    if (!control.parentWorkflowRunId || !workflowParentIds.has(control.parentWorkflowRunId) || !belongsToCurrentSession(control.sessionId, state.currentSessionId) || activeChildCount === 0) continue;
+    liveWorkflowForegroundControls.add(control);
+    workflowForegroundChildCounts.set(control.parentWorkflowRunId, (workflowForegroundChildCounts.get(control.parentWorkflowRunId) ?? 0) + activeChildCount);
+  }
+  for (const control of [...state.foregroundControls.values()].sort((left, right) => left.startedAt - right.startedAt || left.runId.localeCompare(right.runId))) {
+    activeForegroundIds.add(control.runId);
+    if (control.parentWorkflowRunId && workflowParentIds.has(control.parentWorkflowRunId) && ((workflowForegroundChildCounts.get(control.parentWorkflowRunId) ?? 0) <= 1 || !liveWorkflowForegroundControls.has(control))) continue;
+    if (control.activeChildren) {
+      for (const child of [...control.activeChildren.values()].sort((left, right) => left.index - right.index)) {
+        items.push({
+          key: `foreground-active:${control.runId}:${child.index}`,
+          kind: "foreground-active",
+          runId: control.runId,
+          index: child.index,
+          agent: child.agent,
+          state: "running",
+          updatedAt: child.updatedAt,
+          control,
+          activeChild: child,
+          ...child.description ? { description: child.description } : {}
+        });
+      }
+      continue;
+    }
+    items.push({
+      key: `foreground-active:${control.runId}:${control.currentIndex ?? 0}`,
+      kind: "foreground-active",
+      runId: control.runId,
+      ...control.currentIndex !== void 0 ? { index: control.currentIndex } : {},
+      agent: control.currentAgent ?? control.mode,
+      state: "running",
+      updatedAt: control.updatedAt,
+      control,
+      ...control.description ? { description: control.description } : {}
+    });
+  }
+  let error;
+  try {
+    let runs;
+    const descriptions = /* @__PURE__ */ new Map();
+    const tracked = [...trackedJobs.values()].filter((job) => belongsToCurrentSession(job.sessionId, state.currentSessionId));
+    const byUpdate = (left, right) => (right.updatedAt ?? right.startedAt ?? 0) - (left.updatedAt ?? left.startedAt ?? 0);
+    const active = tracked.filter((job) => job.status === "queued" || job.status === "running");
+    const recent = tracked.filter((job) => job.status !== "queued" && job.status !== "running").sort(byUpdate).slice(0, options.limit ?? MAX_RECENT_ASYNC_RUNS);
+    const trackedRuns = [];
+    for (const job of [...active, ...recent]) {
+      try {
+        trackedRuns.push(trackedJobSummary(job));
+        if (job.description) descriptions.set(job.asyncId, job.description);
+      } catch (cause) {
+        error = `Failed to inspect async run '${job.asyncId}': ${cause instanceof Error ? cause.message : String(cause)}`;
+      }
+    }
+    if (options.asyncDirRoot !== void 0) {
+      const trackedIds = new Set(trackedRuns.map((run) => run.id));
+      const history = listAsyncRuns(options.asyncDirRoot, {
+        ...state.currentSessionId ? { sessionId: state.currentSessionId } : {},
+        entryLimit: MAX_FLEET_HISTORY_CANDIDATES,
+        resultsDir: options.resultsDir ?? DIRS.results,
+        reconcile: false
+      }).filter((run) => !trackedIds.has(run.id));
+      runs = [...trackedRuns, ...history];
+    } else {
+      runs = trackedRuns;
+    }
+    for (const run of orderFleetAsyncRuns(runs, options.limit ?? MAX_RECENT_ASYNC_RUNS, trackedJobs)) {
+      items.push(...asyncItems(run, descriptions.get(run.id)));
+    }
+  } catch (cause) {
+    error = cause instanceof Error ? cause.message : String(cause);
+  }
+  if (state.currentSessionId) {
+    try {
+      for (const run of snapshotExternalRuns(state.currentSessionId, { ignoreMalformed: true, onMalformedRecord: (message) => reportFleetWarning(state, `Removed ${message}`) })) {
+        items.push({
+          key: `external:${run.id}`,
+          kind: "external",
+          runId: run.id,
+          agent: run.label,
+          state: run.state,
+          updatedAt: run.updatedAt ?? run.endedAt ?? run.startedAt,
+          run,
+          ...run.currentAction ? { description: run.currentAction } : {}
+        });
+      }
+    } catch (cause) {
+      const message = `Failed to inspect external jobs: ${cause instanceof Error ? cause.message : String(cause)}`;
+      error = error ? `${error}; ${message}` : message;
+    }
+  }
+  const recentForeground = [...state.foregroundRuns?.values() ?? []].filter((run) => belongsToCurrentSession(run.sessionId, state.currentSessionId) && !activeForegroundIds.has(run.runId)).sort((left, right) => right.updatedAt - left.updatedAt);
+  for (const run of recentForeground) {
+    for (const child of run.children) {
+      items.push({
+        key: `foreground-recent:${run.runId}:${child.index}`,
+        kind: "foreground-recent",
+        runId: run.runId,
+        index: child.index,
+        agent: child.agent,
+        state: child.status,
+        updatedAt: child.updatedAt ?? run.updatedAt,
+        run,
+        child
+      });
+    }
+  }
+  return { items, ...error ? { error } : {} };
+}
+function visibleWorkflowParentKeyForForegroundKey(state, key, items) {
+  for (const control of state.foregroundControls.values()) {
+    if (!control.parentWorkflowRunId) continue;
+    let matches = false;
+    if (control.activeChildren) {
+      for (const child of control.activeChildren.values()) {
+        if (`foreground-active:${control.runId}:${child.index}` === key) {
+          matches = true;
+          break;
+        }
+      }
+    } else {
+      matches = `foreground-active:${control.runId}:${control.currentIndex ?? 0}` === key;
+    }
+    if (!matches) continue;
+    const parentKey = `async:${control.parentWorkflowRunId}`;
+    return items.some((item) => item.key === parentKey) ? parentKey : void 0;
+  }
+  return void 0;
+}
+function fleetItemThinkingLevel(item) {
+  switch (item.kind) {
+    case "foreground-active":
+      return childThinkingLevel(item.activeChild ?? item.control);
+    case "foreground-recent":
+      return childThinkingLevel(item.child);
+    case "async":
+      return childThinkingLevel(item.step);
+    case "external":
+      return void 0;
+  }
+}
+function statusGlyph(item, theme) {
+  if (item.state === "running") return runningTone(theme, fleetItemThinkingLevel(item))("\u25CF");
+  if (item.state === "queued" || item.state === "pending") return theme.fg("muted", "\u25E6");
+  if (item.state === "complete" || item.state === "completed") return theme.fg("success", "\u2713");
+  if (item.state === "paused" || item.state === "stopped" || item.state === "detached") return theme.fg("warning", "\u25A0");
+  return theme.fg("error", "\u2717");
+}
+function foregroundPromptAuditCount(item, state) {
+  if (!state.currentSessionId || item.control.sessionId !== state.currentSessionId) return 0;
+  if (!item.control.activeChildren) return getLivePromptAudit(item.control, item.index ?? 0) ? 1 : 0;
+  return [...item.control.activeChildren.keys()].filter((index) => getLivePromptAudit(item.control, index)).length;
+}
+function promptAuditString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function authoredPromptSummary(text) {
+  if (typeof text !== "string") return void 0;
+  const summary = text.replace(/\s+/g, " ").trim();
+  return summary ? truncateToWidth(summary, PROMPT_AUDIT_SUMMARY_WIDTH, "\u2026") : void 0;
+}
+function foregroundAuthoredPromptSummary(item, state) {
+  if (!state.currentSessionId || item.control.sessionId !== state.currentSessionId) return void 0;
+  const prompt = getLivePromptAudit(item.control, item.index ?? 0);
+  return prompt ? authoredPromptSummary(prompt.authoredTask) : void 0;
+}
+function promptAuditText(prompt, view) {
+  switch (view) {
+    case "authored":
+      return promptAuditString(prompt.authoredTask);
+    case "runtime":
+      return promptAuditString(prompt.runtimeAdditions);
+    case "effective":
+      return promptAuditString(prompt.finalEffectivePrompt);
+  }
+}
+function promptAuditViewLabel(view) {
+  switch (view) {
+    case "authored":
+      return "[1] Authored task";
+    case "runtime":
+      return "[2] Runtime additions";
+    case "effective":
+      return "[3] Final effective prompt";
+  }
+}
+function foregroundActiveDetail(item, state) {
+  const { control } = item;
+  const live = item.activeChild ?? control;
+  const modelThinking = formatModelThinking(live.model, live.thinking);
+  const promptAuditCount = foregroundPromptAuditCount(item, state);
+  const promptSummary = foregroundAuthoredPromptSummary(item, state);
+  const lines = [
+    `Run: ${item.runId}`,
+    "Source: foreground",
+    `State: running`,
+    `Mode: ${control.mode}`,
+    control.parentWorkflowRunId ? `Workflow child of: ${control.parentWorkflowRunId}${control.workflowKey ? ` (${control.workflowKey})` : ""}` : void 0,
+    control.sourceRunId ? `Redo source: ${control.sourceRunId}` : void 0,
+    control.supersededByRunId ? `Superseded by: ${control.supersededByRunId}` : void 0,
+    item.index !== void 0 ? `Child: ${item.index} (${item.agent})` : `Agent: ${item.agent}`,
+    modelThinking ? `Model: ${modelThinking}` : void 0,
+    promptSummary ? `Task: ${promptSummary}` : void 0,
+    `Started: ${new Date(live.startedAt).toISOString()}`,
+    live.currentTool ? `Current tool: ${live.currentTool}${live.currentPath ? ` \xB7 ${shortenPath(live.currentPath)}` : ""}` : void 0,
+    live.turnCount !== void 0 ? `Turns: ${live.turnCount}` : void 0,
+    live.toolCount !== void 0 ? `Tools: ${live.toolCount}` : void 0,
+    live.tokens !== void 0 ? `Tokens: ${formatTokenUsage({ input: live.inputTokens ?? 0, output: live.outputTokens ?? 0, total: live.tokens, ...live.window !== void 0 ? { window: live.window } : {}, ...live.windowPeak !== void 0 ? { windowPeak: live.windowPeak } : {} }, "tokens")}` : void 0,
+    promptAuditCount > 0 ? `Prompt audit: ${promptAuditCount} live \xB7 3 views \xB7 p opens` : void 0,
+    "",
+    "Transcript",
+    "Live foreground output remains in the expanded subagent tool result. Persisted output and session paths appear here after the child settles."
+  ];
+  return lines.filter((line) => line !== void 0);
+}
+function pathWithin(base, candidate) {
+  const resolvedBase = path.resolve(base);
+  const resolvedCandidate = path.resolve(candidate);
+  return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`);
+}
+function trustedFileTail(filePath, trustedRoots) {
+  const resolvedPath = path.resolve(filePath);
+  if (trustedRoots.length === 0 || !trustedRoots.some((root) => pathWithin(root, resolvedPath))) return { warning: `output artifact is outside trusted roots: ${filePath}` };
+  let stat;
+  try {
+    stat = fs.lstatSync(resolvedPath);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return { unavailable: `output artifact unavailable: ${filePath}` };
+    return { warning: `output artifact could not be inspected: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  if (stat.isSymbolicLink()) return { warning: `output artifact refused a symlink: ${filePath}` };
+  if (!stat.isFile()) return { warning: `output artifact is not a file: ${filePath}` };
+  try {
+    const realPath = fs.realpathSync(resolvedPath);
+    const realRoots = trustedRoots.filter((root) => fs.existsSync(root)).map((root) => fs.realpathSync(root));
+    if (!realRoots.some((root) => pathWithin(root, realPath))) return { warning: `output artifact resolves outside trusted roots: ${filePath}` };
+    const fd = fs.openSync(realPath, "r");
+    try {
+      const bytes = Math.min(stat.size, OUTPUT_TAIL_BYTES);
+      const buffer = Buffer.alloc(bytes);
+      fs.readSync(fd, buffer, 0, bytes, stat.size - bytes);
+      return { text: decodeUtf8Tail(buffer) };
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch (error) {
+    return { warning: `output artifact could not be read: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function foregroundRecentOutputLines(item, state) {
+  const outputPath = item.child.artifactPaths?.outputPath ?? item.child.savedOutputPath;
+  const output = item.child.finalOutput ? { text: item.child.finalOutput } : outputPath ? trustedFileTail(path.isAbsolute(outputPath) ? outputPath : path.resolve(item.run.cwd, outputPath), uniquePaths([
+    fleetArtifactsRoot(state, item.run.cwd),
+    fleetArtifactsRoot(state, state.baseCwd)
+  ])) : void 0;
+  if (output?.warning) return [`(${output.warning})`];
+  if (output?.unavailable) return [`(${output.unavailable})`];
+  const outputLines = (output?.text ?? "").split(/\r?\n/).filter((line) => line.trim()).slice(-TRANSCRIPT_LINES);
+  return outputLines.length ? outputLines : ["(no recovered output available)"];
+}
+function foregroundRecentDetail(item, state) {
+  const { child, run } = item;
+  const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
+  const modelThinking = formatModelThinking(child.model, child.thinking);
+  const lines = [
+    `Run: ${item.runId}`,
+    "Source: foreground",
+    `State: ${foregroundChildStateLabel(run, child)}`,
+    `Mode: ${run.mode}`,
+    `Child: ${child.index} (${child.agent})${contextModeLabel(child.context) ? ` ${contextModeLabel(child.context)}` : ""}`,
+    modelThinking ? `Model: ${modelThinking}` : void 0,
+    `Updated: ${new Date(child.updatedAt ?? run.updatedAt).toISOString()}`,
+    outputPath ? `Output: ${outputPath}` : void 0,
+    child.sessionFile ? `Session: ${child.sessionFile}` : void 0,
+    child.transcriptPath ? `Transcript file: ${child.transcriptPath}` : void 0,
+    child.error ? `Error: ${child.error}` : void 0,
+    child.outputSaveError ? `Output warning: ${child.outputSaveError}` : void 0,
+    child.transcriptError ? `Transcript warning: ${child.transcriptError}` : void 0,
+    "",
+    "Result transcript tail"
+  ];
+  lines.push(...foregroundRecentOutputLines(item, state));
+  return lines.filter((line) => line !== void 0);
+}
+function externalElapsedEnd(run) {
+  const terminal = run.state !== "queued" && run.state !== "running";
+  return terminal ? run.endedAt ?? run.updatedAt ?? Date.now() : Date.now();
+}
+function workflowStepLabel(step, index) {
+  const key = step.workflowKey ?? `step ${index + 1}`;
+  const label = step.label && step.label !== key ? ` \xB7 ${step.label}` : "";
+  const phase = step.phase ? `${step.phase}: ` : "";
+  return `${phase}${key}${label} (${step.agent})`;
+}
+function workflowStepActivity(step) {
+  if (step.currentTool) return `tool ${step.currentTool}`;
+  if (step.currentPath) return shortenPath(step.currentPath);
+  if (step.activityState === "needs_attention") return "needs attention";
+  if (step.activityState === "active_long_running") return "long-running";
+  if (step.turnCount !== void 0) return `${step.turnCount} turns`;
+  if (step.toolCount !== void 0) return `${step.toolCount} tools`;
+  return void 0;
+}
+function visibleWorkflowProgressSteps(steps, visibleLimit) {
+  if (steps.length <= visibleLimit) return steps.map((step, index) => ({ step, index }));
+  const selected = /* @__PURE__ */ new Set();
+  for (const [index, step] of steps.entries()) {
+    if (step.status !== "complete" && step.status !== "completed") selected.add(index);
+    if (selected.size >= visibleLimit) break;
+  }
+  for (let index = steps.length - 1; index >= 0 && selected.size < visibleLimit; index--) selected.add(index);
+  const visible = [...selected].sort((left, right) => left - right).map((index) => ({ step: steps[index], index }));
+  return [{ hidden: steps.length - visible.length }, ...visible];
+}
+function workflowProgressLines(steps) {
+  if (!steps?.length) return [];
+  const lines = ["Workflow progress:"];
+  for (const row of visibleWorkflowProgressSteps(steps, 8)) {
+    if ("hidden" in row) {
+      lines.push(`  +${row.hidden} hidden workflow steps`);
+      continue;
+    }
+    const activity = workflowStepActivity(row.step);
+    const context = contextModeLabel(row.step.context);
+    const details = [row.step.status, activity, context, row.step.tokens ? formatTokenUsage(row.step.tokens) : void 0].filter(Boolean).join(" \xB7 ");
+    lines.push(`  ${row.index + 1}. ${workflowStepLabel(row.step, row.index)}${details ? ` \u2014 ${details}` : ""}`);
+  }
+  return lines;
+}
+function asyncDetail(item, state) {
+  const status = readStatus(item.run.asyncDir);
+  if (status) {
+    const trackedJob = state.fleetJobs?.get(item.runId) ?? state.asyncJobs.get(item.runId);
+    const lines = formatAsyncRunTranscript(status, item.run.asyncDir, {
+      index: item.index,
+      lines: TRANSCRIPT_LINES,
+      sessionRoots: uniquePaths([...state.trustedSessionRoots ?? [], trackedJob?.sessionRoot]),
+      trustedSessionFiles: [item.step?.sessionFile ?? item.run.sessionFile].filter((value) => Boolean(value)),
+      trustedSessionFileRoot: state.trustedSessionFileRoot
+    }).split("\n");
+    if (status.mode === "workflow" && item.index === void 0) {
+      const progress = workflowProgressLines(status.steps ?? item.run.steps);
+      if (progress.length) {
+        const modeIndex = lines.findIndex((line) => line.startsWith("Mode:"));
+        lines.splice(modeIndex >= 0 ? modeIndex + 1 : 0, 0, "", ...progress);
+      }
+    }
+    return lines;
+  }
+  const outputPath = item.index !== void 0 ? path.join(item.run.asyncDir, `output-${item.index}.log`) : void 0;
+  return [
+    `Run: ${item.runId}`,
+    "Source: async",
+    `State: ${item.state}`,
+    `Mode: ${item.run.mode}${contextModeLabel(item.run.context) ? ` ${contextModeLabel(item.run.context)}` : ""}`,
+    item.index !== void 0 ? `Child: ${item.index} (${item.agent})${contextModeLabel(item.step?.context) ? ` ${contextModeLabel(item.step?.context)}` : ""}` : `Agent: ${item.agent}${contextModeLabel(item.run.context) ? ` ${contextModeLabel(item.run.context)}` : ""}`,
+    outputPath ? `Output: ${outputPath}` : void 0,
+    item.step?.sessionFile ? `Session: ${item.step.sessionFile}` : item.run.sessionFile ? `Session: ${item.run.sessionFile}` : void 0,
+    "",
+    "Transcript",
+    "(status is no longer available)"
+  ].filter((line) => line !== void 0);
+}
+function externalDetail(item) {
+  return [
+    `Run: ${item.runId}`,
+    "Source: external \xB7 display-only",
+    `Owner: ${item.run.source}`,
+    `State: ${item.state}`,
+    `Started: ${new Date(item.run.startedAt).toISOString()}`,
+    item.run.updatedAt !== void 0 ? `Updated: ${new Date(item.run.updatedAt).toISOString()}` : void 0,
+    item.run.endedAt !== void 0 ? `Ended: ${new Date(item.run.endedAt).toISOString()}` : void 0,
+    `Elapsed: ${formatDuration(Math.max(0, externalElapsedEnd(item.run) - item.run.startedAt))}`,
+    item.run.currentAction ? `Current action: ${item.run.currentAction}` : void 0,
+    item.run.reportPath ? `Report path: ${item.run.reportPath}` : void 0,
+    item.run.transcriptPath ? `Transcript path: ${item.run.transcriptPath}` : void 0,
+    "",
+    "Preview",
+    item.run.preview ?? "(no preview supplied)",
+    "",
+    "The owning extension controls execution, persistence, cancellation, and results."
+  ].filter((line) => line !== void 0);
+}
+function detailLines(item, error, state) {
+  if (!item) return [error ? `Fleet scan failed: ${error}` : "No current-session Fleet jobs.", "", "New jobs appear here automatically while this inspector remains open."];
+  const lines = item.kind === "foreground-active" ? foregroundActiveDetail(item, state) : item.kind === "foreground-recent" ? foregroundRecentDetail(item, state) : item.kind === "external" ? externalDetail(item) : asyncDetail(item, state);
+  if (error) lines.unshift(`Fleet scan warning: ${error}`, "");
+  return lines;
+}
+function isActionableAsyncState(state) {
+  return state === "running" || state === "queued" || state === "pending";
+}
+function firstToolResultText(result, fallback) {
+  if (!result) return { text: fallback, isError: true };
+  const text = result.content.find((item) => item.type === "text")?.text ?? fallback;
+  return { text, ...result.isError ? { isError: true } : {} };
+}
+function uniquePaths(values) {
+  return [...new Set(values.filter((value) => Boolean(value)).map((value) => path.resolve(value)))];
+}
+function fleetArtifactsRoot(state, cwd) {
+  return getArtifactsDir(
+    state.parentSessionFile ?? null,
+    cwd,
+    state.artifactDirPreference
+  );
+}
+function transcriptTarget(item, state) {
+  if (item.kind === "external") return void 0;
+  if (item.kind === "foreground-active") {
+    const artifactsRoot = fleetArtifactsRoot(state, item.control.cwd ?? state.baseCwd);
+    return {
+      path: getArtifactPaths(artifactsRoot, item.runId, item.agent, item.index ?? 0).transcriptPath,
+      trustedRoots: [artifactsRoot]
+    };
+  }
+  if (item.kind === "foreground-recent") {
+    if (!item.child.transcriptPath) return void 0;
+    const transcriptPath2 = path.isAbsolute(item.child.transcriptPath) ? item.child.transcriptPath : path.resolve(item.run.cwd, item.child.transcriptPath);
+    return {
+      path: transcriptPath2,
+      trustedRoots: uniquePaths([
+        fleetArtifactsRoot(state, item.run.cwd),
+        fleetArtifactsRoot(state, state.baseCwd)
+      ])
+    };
+  }
+  const step = item.step ?? (item.run.steps.length === 1 ? item.run.steps[0] : void 0);
+  if (step?.runner?.type === "external-cli") return void 0;
+  const recordedSessionFile = step?.sessionFile ?? item.run.sessionFile;
+  const recordedPath = step?.transcriptPath ?? recordedSessionFile;
+  if (!recordedPath) return void 0;
+  const transcriptPath = path.isAbsolute(recordedPath) ? recordedPath : path.resolve(item.run.asyncDir, recordedPath);
+  const trackedJob = state.fleetJobs?.get(item.runId) ?? state.asyncJobs.get(item.runId);
+  return {
+    path: transcriptPath,
+    trustedRoots: uniquePaths([
+      item.run.asyncDir,
+      fleetArtifactsRoot(state, state.baseCwd),
+      trackedJob?.cwd ? fleetArtifactsRoot(state, trackedJob.cwd) : void 0,
+      item.run.sessionFile ? getArtifactsDir(item.run.sessionFile, item.run.cwd ?? state.baseCwd, state.artifactDirPreference) : void 0
+    ]),
+    ...!step?.transcriptPath && recordedSessionFile ? { trustedFiles: [recordedSessionFile], trustedFileRoot: state.trustedSessionFileRoot } : {}
+  };
+}
+function itemContext(item) {
+  if (item.kind === "async") return contextModeLabel(item.step?.context ?? item.run.context);
+  if (item.kind === "foreground-recent") return contextModeLabel(item.child.context);
+  return void 0;
+}
+function itemMode(item) {
+  if (item.kind === "external") return "display-only";
+  return item.kind === "foreground-active" ? item.control.mode : item.run.mode;
+}
+function itemSource(item) {
+  if (item.kind === "external") return `external \xB7 ${item.run.source}`;
+  if (item.kind === "async") return "background";
+  return item.kind === "foreground-active" ? "foreground \xB7 live" : "foreground \xB7 recent";
+}
+function itemStats(item) {
+  let model;
+  let tokens;
+  let tokenUsage;
+  let tools;
+  let durationMs;
+  if (item.kind === "foreground-active") {
+    const live = item.activeChild ?? item.control;
+    model = formatModelThinking(live.model, live.thinking) || void 0;
+    tokens = live.tokens;
+    if (tokens !== void 0) tokenUsage = { input: live.inputTokens ?? 0, output: live.outputTokens ?? 0, total: tokens, ...live.window !== void 0 ? { window: live.window } : {}, ...live.windowPeak !== void 0 ? { windowPeak: live.windowPeak } : {} };
+    tools = live.toolCount;
+    durationMs = Math.max(0, Date.now() - live.startedAt);
+  } else if (item.kind === "foreground-recent") {
+    model = formatModelThinking(item.child.model, item.child.thinking) || void 0;
+    tokens = item.child.tokens;
+    if (tokens !== void 0) tokenUsage = { input: 0, output: 0, total: tokens, ...item.child.window !== void 0 ? { window: item.child.window } : {}, ...item.child.windowPeak !== void 0 ? { windowPeak: item.child.windowPeak } : {} };
+    tools = item.child.toolCount;
+  } else if (item.kind === "external") {
+    durationMs = Math.max(0, externalElapsedEnd(item.run) - item.run.startedAt);
+  } else {
+    model = formatModelThinking(item.step?.model, item.step?.thinking) || void 0;
+    tokenUsage = item.step?.tokens ?? (item.index === void 0 ? item.run.totalTokens : void 0);
+    tokens = tokenUsage?.total;
+    tools = item.step?.toolCount ?? (item.index === void 0 ? item.run.toolCount : void 0);
+    const terminalRun = item.state !== "queued" && item.state !== "running" && item.state !== "pending";
+    const endTime = item.run.endedAt ?? (terminalRun ? item.run.lastUpdate : void 0) ?? Date.now();
+    durationMs = item.step?.durationMs ?? Math.max(0, endTime - item.run.startedAt);
+  }
+  return [
+    model,
+    tokenUsage ? formatTokenUsage(tokenUsage) : tokens !== void 0 ? `${formatTokens(tokens)} tok` : void 0,
+    tools !== void 0 ? `${tools} tool${tools === 1 ? "" : "s"}` : void 0,
+    durationMs !== void 0 ? formatDuration(durationMs) : void 0
+  ].filter((value) => Boolean(value));
+}
+function structuredHeader(item, width, theme, conversationState, promptSummary) {
+  const lines = [];
+  lines.push(rightAligned(` ${statusGlyph(item, theme)} ${theme.bold(item.agent)}`, theme.fg("dim", item.state), width));
+  const child = "index" in item && item.index !== void 0 ? ` \xB7 child ${item.index + 1}` : "";
+  const context = itemContext(item);
+  const identity = `${itemSource(item)} \xB7 ${item.runId.slice(0, 8)}${child} \xB7 ${itemMode(item)}${context ? ` ${context}` : ""}`;
+  lines.push(`  ${theme.fg("dim", identity)}`);
+  const stats = itemStats(item);
+  if (stats.length) lines.push(`  ${theme.fg("muted", stats.join(" \xB7 "))}`);
+  if (promptSummary) lines.push(`  ${theme.fg("muted", `Task: ${promptSummary}`)}`);
+  lines.push(`${theme.fg("accent", "Conversation")} ${theme.fg("dim", `\xB7 ${conversationState}`)}`);
+  return lines.map((line) => truncateToWidth(line, width));
+}
+function fit(text, width) {
+  const clipped = truncateToWidth(text, Math.max(0, width));
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+function rightAligned(left, right, width) {
+  const rightWidth = visibleWidth(right);
+  const leftWidth = Math.max(0, width - rightWidth - 1);
+  return fit(left, leftWidth) + " ".repeat(Math.max(1, width - leftWidth - rightWidth)) + fit(right, rightWidth);
+}
+function transcriptFingerprint(filePath) {
+  try {
+    const stat = fs.statSync(filePath, { bigint: true });
+    return `${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+  } catch {
+    return "missing";
+  }
+}
+var SubagentFleetComponent = class {
+  snapshot = { items: [] };
+  selected = 0;
+  selectedKey;
+  viewport;
+  renderedLayout;
+  expandedTools = false;
+  promptAuditOpen = false;
+  promptAuditView = "authored";
+  actionNotice;
+  steerDraft;
+  redoGuidanceDraft;
+  steerMode = "steer";
+  stopConfirming = false;
+  actionBusy = false;
+  transcriptCache;
+  disposed = false;
+  refreshTimer;
+  refreshMs;
+  tui;
+  theme;
+  markdownTheme;
+  state;
+  done;
+  options;
+  keybindings;
+  constructor(tui, theme, state, done, options = {}) {
+    this.tui = tui;
+    this.viewport = new FleetViewport(() => this.tui.requestRender());
+    this.theme = theme;
+    this.markdownTheme = options.markdownTheme ?? getMarkdownTheme();
+    this.state = state;
+    this.done = done;
+    this.options = options;
+    this.keybindings = resolveFleetKeybindings(options.fleetKeybindings);
+    this.refreshMs = Math.max(MIN_REFRESH_MS, options.refreshMs ?? REFRESH_MS);
+    this.selectedKey = options.initialKey;
+    this.refresh();
+    this.scheduleRefresh();
+  }
+  scheduleRefresh() {
+    if (this.disposed || this.refreshTimer) return;
+    this.refreshTimer = setTimeout(() => {
+      this.refreshTimer = void 0;
+      if (this.disposed) return;
+      try {
+        this.refresh();
+        this.tui.requestRender();
+      } finally {
+        this.scheduleRefresh();
+      }
+    }, this.refreshMs);
+    this.refreshTimer.unref?.();
+  }
+  stopRefresh() {
+    this.disposed = true;
+    if (this.refreshTimer) clearTimeout(this.refreshTimer);
+    this.refreshTimer = void 0;
+  }
+  refresh() {
+    const previousKey = this.snapshot.items[this.selected]?.key ?? this.selectedKey;
+    this.snapshot = collectFleetSnapshot(this.state, this.options);
+    let preserved = previousKey ? this.snapshot.items.findIndex((item) => item.key === previousKey) : -1;
+    if (preserved < 0 && previousKey) {
+      const parentKey = visibleWorkflowParentKeyForForegroundKey(this.state, previousKey, this.snapshot.items);
+      if (parentKey) preserved = this.snapshot.items.findIndex((item) => item.key === parentKey);
+    }
+    this.selected = preserved >= 0 ? preserved : Math.min(this.selected, Math.max(0, this.snapshot.items.length - 1));
+    this.selectedKey = this.snapshot.items[this.selected]?.key;
+  }
+  moveSelection(delta) {
+    this.selectItem(Math.max(0, Math.min(this.snapshot.items.length - 1, this.selected + delta)));
+  }
+  selectItem(index) {
+    if (!this.snapshot.items[index]) return;
+    this.selected = index;
+    this.selectedKey = this.snapshot.items[this.selected]?.key;
+    this.viewport.follow();
+    this.resetActionInput();
+    this.tui.requestRender();
+  }
+  selectedPromptAudit() {
+    const item = this.snapshot.items[this.selected];
+    if (item?.kind !== "foreground-active") return void 0;
+    if (!this.state.currentSessionId || item.control.sessionId !== this.state.currentSessionId) return void 0;
+    return getLivePromptAudit(item.control, item.index ?? 0);
+  }
+  promptAuditItems() {
+    const selected = this.snapshot.items[this.selected];
+    if (selected?.kind !== "foreground-active" || !this.state.currentSessionId || selected.control.sessionId !== this.state.currentSessionId) return [];
+    return this.snapshot.items.flatMap((item) => {
+      if (item.kind !== "foreground-active" || item.control !== selected.control) return [];
+      const prompt = getLivePromptAudit(item.control, item.index ?? 0);
+      return prompt ? [{ item, prompt }] : [];
+    });
+  }
+  selectedPromptText() {
+    const prompt = this.selectedPromptAudit();
+    return prompt ? promptAuditText(prompt, this.promptAuditView) : void 0;
+  }
+  movePromptSelection(delta) {
+    const items = this.promptAuditItems();
+    if (items.length === 0) return;
+    const currentKey = this.snapshot.items[this.selected]?.key;
+    const current = Math.max(0, items.findIndex(({ item }) => item.key === currentKey));
+    const target = items[Math.max(0, Math.min(items.length - 1, current + delta))]?.item;
+    if (!target) return;
+    this.selected = this.snapshot.items.findIndex((item) => item.key === target.key);
+    this.selectedKey = target.key;
+    this.viewport.resetTop();
+    this.tui.requestRender();
+  }
+  resetActionInput() {
+    this.steerDraft = void 0;
+    this.redoGuidanceDraft = void 0;
+    this.steerMode = "steer";
+    this.stopConfirming = false;
+  }
+  selectedAsyncAction() {
+    const item = this.snapshot.items[this.selected];
+    if (!item) return { reason: "No child is selected." };
+    if (item.kind === "external") return { reason: "External jobs are display-only and remain controlled by their owning extension." };
+    if (item.kind !== "async") return { reason: "Fleet controls are available for current-session top-level async runs only." };
+    if (!isActionableAsyncState(item.run.state) || !isActionableAsyncState(item.state)) return { reason: `Selected child is ${item.state}; controls require a running or queued async child.` };
+    return { item };
+  }
+  selectedSteerAction() {
+    const item = this.snapshot.items[this.selected];
+    if (item?.kind === "foreground-active" && item.control.parentWorkflowRunId) {
+      const parent = this.state.asyncJobs.get(item.control.parentWorkflowRunId) ?? this.state.fleetJobs?.get(item.control.parentWorkflowRunId);
+      if (!parent || !isActionableAsyncState(parent.status)) return { reason: "The parent workflow is no longer available for steering." };
+      return { runId: item.runId, asyncDir: parent.asyncDir, ...item.index !== void 0 ? { index: item.index } : {} };
+    }
+    const target = this.selectedAsyncAction();
+    if ("reason" in target) return target;
+    return { runId: target.item.runId, asyncDir: target.item.run.asyncDir, ...target.item.index !== void 0 ? { index: target.item.index } : {} };
+  }
+  selectedInspectAction() {
+    const item = this.snapshot.items[this.selected];
+    if (!item) return { reason: "No child is selected." };
+    if (item.kind === "external") return { reason: "External jobs are display-only and have no inspector controls." };
+    if (item.kind === "async") {
+      if (!isActionableAsyncState(item.run.state) || !isActionableAsyncState(item.state)) return { reason: `Selected child is ${item.state}; controls require a running or queued async child.` };
+      return { runId: item.runId, asyncDir: item.run.asyncDir, ...item.index !== void 0 ? { index: item.index } : {} };
+    }
+    if (item.kind !== "foreground-active" || !item.control.parentWorkflowRunId) return { reason: "Fleet controls are available for current-session top-level async runs only." };
+    const parent = this.state.asyncJobs.get(item.control.parentWorkflowRunId) ?? this.state.fleetJobs?.get(item.control.parentWorkflowRunId);
+    if (!parent || !isActionableAsyncState(parent.status)) return { reason: "The parent workflow is no longer available for inspection." };
+    return { runId: parent.asyncId, asyncDir: parent.asyncDir };
+  }
+  inspectSelected() {
+    const target = this.selectedInspectAction();
+    if ("reason" in target || !this.options.actions?.inspect) this.setActionNotice({ text: "reason" in target ? target.reason : "Inspector controls are unavailable in this context.", isError: true });
+    else this.runAction(() => this.options.actions.inspect(target));
+  }
+  actionLines() {
+    const lines = [];
+    if (this.actionBusy) lines.push(this.theme.fg("accent", "Action pending..."));
+    if (this.steerDraft !== void 0) {
+      lines.push(this.theme.fg("accent", `Steer message (${this.steerMode}): ${this.steerDraft}${this.theme.fg("dim", "\u258C")}`));
+      lines.push(this.theme.fg("dim", "Enter sends \xB7 Tab changes mode \xB7 Esc cancels \xB7 Backspace edits"));
+    } else if (this.redoGuidanceDraft !== void 0) {
+      lines.push(this.theme.fg("accent", `Redo guidance: ${this.redoGuidanceDraft}${this.theme.fg("dim", "\u258C")}`));
+      lines.push(this.theme.fg("dim", "Enter rewrites and reruns \xB7 Esc cancels \xB7 Backspace edits"));
+    } else if (this.stopConfirming) {
+      const selected = this.snapshot.items[this.selected];
+      lines.push(this.theme.fg("warning", `Confirm stop for async run ${selected?.runId ?? "selected run"}?`));
+      lines.push(this.theme.fg("dim", "Stop ends the run; use interrupt for a resumable pause. Enter/Y confirms \xB7 N returns \xB7 Esc cancels"));
+    } else if (this.actionNotice) {
+      lines.push(this.theme.fg(this.actionNotice.isError ? "error" : "success", this.actionNotice.text));
+    }
+    return lines;
+  }
+  withActionLines(body) {
+    const actionLines = this.actionLines();
+    return actionLines.length ? [...actionLines, "", ...body] : body;
+  }
+  setActionNotice(result) {
+    this.actionNotice = result;
+    this.resetActionInput();
+    this.viewport.resetTop();
+    this.refresh();
+    this.tui.requestRender();
+  }
+  runAction(action) {
+    if (this.actionBusy) return;
+    this.actionBusy = true;
+    this.actionNotice = void 0;
+    this.tui.requestRender();
+    void action().then((result) => this.setActionNotice(result)).catch((error) => this.setActionNotice({ text: error instanceof Error ? error.message : String(error), isError: true })).finally(() => {
+      this.actionBusy = false;
+      if (!this.disposed) this.tui.requestRender();
+    });
+  }
+  scrollDetail(delta) {
+    this.viewport.scroll.scrollBy(delta);
+  }
+  handleMouse(event) {
+    if (this.steerDraft !== void 0 || this.redoGuidanceDraft !== void 0 || this.stopConfirming || this.actionBusy) {
+      return { handled: true, render: false };
+    }
+    const layout = this.renderedLayout;
+    if (!layout || layout.width !== event.width || layout.rows !== (this.tui.terminal?.rows ?? 32)) {
+      return event.type === "wheel" ? { handled: true, render: false } : void 0;
+    }
+    if (event.type === "wheel" && fleetContains(layout.output, event.x, event.y)) {
+      this.scrollDetail(event.wheelDelta ?? 0);
+      return { handled: true, render: false };
+    }
+    if (this.promptAuditOpen) return { handled: true, render: false };
+    if (event.type === "click" && event.button === "left" && !event.shift && !event.alt && !event.ctrl && fleetContains(layout.roster, event.x, event.y)) {
+      const key = layout.rosterKeys[event.y - layout.roster.y];
+      const index = key === void 0 ? -1 : this.snapshot.items.findIndex((item) => item.key === key);
+      if (index < 0) return void 0;
+      this.selectItem(index);
+      return { handled: true, render: false };
+    }
+    return event.type === "wheel" ? { handled: true, render: false } : void 0;
+  }
+  handleInput(data) {
+    if (this.promptAuditOpen && this.redoGuidanceDraft !== void 0) {
+      if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+        this.resetActionInput();
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "return") || data === "\r" || data === "\n") {
+        const guidance = this.redoGuidanceDraft.trim();
+        if (!guidance) {
+          this.setActionNotice({ text: "Redo guidance cannot be empty.", isError: true });
+          return;
+        }
+        const selected = this.snapshot.items[this.selected];
+        if (selected?.kind !== "foreground-active" || !this.options.actions?.redoPrompt) {
+          this.setActionNotice({ text: "Redo is unavailable for this prompt.", isError: true });
+          return;
+        }
+        this.runAction(() => this.options.actions.redoPrompt({ runId: selected.runId, index: selected.index ?? 0, guidance, control: selected.control }));
+        return;
+      }
+      if (matchesKey(data, "backspace") || data === "\x7F") {
+        this.redoGuidanceDraft = this.redoGuidanceDraft.slice(0, -1);
+        this.tui.requestRender();
+        return;
+      }
+      if (data.length === 1 && data >= " " && data !== "\x7F") {
+        this.redoGuidanceDraft += data;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (this.promptAuditOpen) {
+      if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+        this.promptAuditOpen = false;
+        this.viewport.follow();
+        this.tui.requestRender();
+        return;
+      }
+      if (data === "j") return this.movePromptSelection(1);
+      if (data === "k") return this.movePromptSelection(-1);
+      if (data === "1" || data === "2" || data === "3") {
+        this.promptAuditView = data === "1" ? "authored" : data === "2" ? "runtime" : "effective";
+        this.viewport.resetTop();
+        this.tui.requestRender();
+        return;
+      }
+      if (data === "g") {
+        const prompt = this.selectedPromptAudit();
+        if (!prompt) this.setActionNotice({ text: "Prompt Audit is available only for a live child owned by this session.", isError: true });
+        else if (!prompt.rerun) this.setActionNotice({ text: "Redo is not safe for this prompt in this slice.", isError: true });
+        else if (!this.options.actions?.redoPrompt) this.setActionNotice({ text: "Redo controls are unavailable in this context.", isError: true });
+        else {
+          this.actionNotice = void 0;
+          this.redoGuidanceDraft = "";
+          this.viewport.resetTop();
+          this.tui.requestRender();
+        }
+        return;
+      }
+      if (data === "c") {
+        const text = this.selectedPromptText();
+        if (!text) this.setActionNotice({ text: "No prompt view is available to copy.", isError: true });
+        else if (!this.options.copyText) this.setActionNotice({ text: "Clipboard is unavailable in this context.", isError: true });
+        else this.runAction(async () => {
+          await this.options.copyText(text);
+          return { text: "Copied visible prompt view." };
+        });
+        return;
+      }
+      if (matchesFleetAction(data, this.keybindings, "scrollUp")) return this.scrollDetail(-1);
+      if (matchesFleetAction(data, this.keybindings, "scrollDown")) return this.scrollDetail(1);
+      if (matchesFleetAction(data, this.keybindings, "pageUp")) return this.scrollDetail(-this.viewport.scroll.viewportHeight);
+      if (matchesFleetAction(data, this.keybindings, "pageDown")) return this.scrollDetail(this.viewport.scroll.viewportHeight);
+      return;
+    }
+    if (this.steerDraft !== void 0) {
+      if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+        this.resetActionInput();
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "return") || data === "\r" || data === "\n") {
+        const message = this.steerDraft.trim();
+        if (!message) {
+          this.setActionNotice({ text: "Steer message cannot be empty.", isError: true });
+          return;
+        }
+        const target = this.selectedSteerAction();
+        if ("reason" in target || !this.options.actions) {
+          this.setActionNotice({ text: "reason" in target ? target.reason : "Fleet controls are unavailable in this context.", isError: true });
+          return;
+        }
+        this.runAction(() => this.options.actions.steer({ ...target, message, mode: this.steerMode }));
+        return;
+      }
+      if (matchesKey(data, "tab") || data === "	") {
+        const modes = ["steer", "follow_up", "auto"];
+        this.steerMode = modes[(modes.indexOf(this.steerMode) + 1) % modes.length];
+        this.tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, "backspace") || data === "\x7F") {
+        this.steerDraft = this.steerDraft.slice(0, -1);
+        this.tui.requestRender();
+        return;
+      }
+      if (data.length === 1 && data >= " " && data !== "\x7F") {
+        this.steerDraft += data;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (this.stopConfirming) {
+      if (matchesKey(data, "return") || data.toLowerCase() === "y") {
+        const target = this.selectedAsyncAction();
+        if ("reason" in target || !this.options.actions) {
+          this.setActionNotice({ text: "reason" in target ? target.reason : "Fleet controls are unavailable in this context.", isError: true });
+          return;
+        }
+        this.runAction(() => Promise.resolve(this.options.actions.stop({ runId: target.item.runId, asyncDir: target.item.run.asyncDir, ...target.item.index !== void 0 ? { index: target.item.index } : {} })));
+        return;
+      }
+      if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || data.toLowerCase() === "n" || matchesKey(data, "backspace")) {
+        this.resetActionInput();
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesFleetAction(data, this.keybindings, "close")) {
+      this.stopRefresh();
+      this.done(void 0);
+      return;
+    }
+    if (matchesFleetAction(data, this.keybindings, "scrollUp")) return this.scrollDetail(-1);
+    if (matchesFleetAction(data, this.keybindings, "scrollDown")) return this.scrollDetail(1);
+    if (matchesFleetAction(data, this.keybindings, "selectUp")) return this.moveSelection(-1);
+    if (matchesFleetAction(data, this.keybindings, "selectDown")) return this.moveSelection(1);
+    if (matchesFleetAction(data, this.keybindings, "selectFirst")) return this.moveSelection(-this.snapshot.items.length);
+    if (matchesFleetAction(data, this.keybindings, "selectLast")) return this.moveSelection(this.snapshot.items.length);
+    if (matchesFleetAction(data, this.keybindings, "pageUp")) return this.scrollDetail(-this.viewport.scroll.viewportHeight);
+    if (matchesFleetAction(data, this.keybindings, "pageDown")) return this.scrollDetail(this.viewport.scroll.viewportHeight);
+    if (matchesFleetAction(data, this.keybindings, "refresh")) {
+      this.transcriptCache = void 0;
+      this.refresh();
+      this.tui.requestRender();
+      return;
+    }
+    if (data === "p") {
+      if (!this.selectedPromptAudit()) this.setActionNotice({ text: "Prompt Audit is available only for a live child owned by this session.", isError: true });
+      else {
+        this.promptAuditOpen = true;
+        this.promptAuditView = "authored";
+        this.viewport.resetTop();
+        this.actionNotice = void 0;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesFleetAction(data, this.keybindings, "steer")) {
+      const target = this.selectedSteerAction();
+      if ("reason" in target || !this.options.actions) this.setActionNotice({ text: "reason" in target ? target.reason : "Fleet controls are unavailable in this context.", isError: true });
+      else {
+        this.actionNotice = void 0;
+        this.steerDraft = "";
+        this.viewport.resetTop();
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesFleetAction(data, this.keybindings, "stop")) {
+      const target = this.selectedAsyncAction();
+      if ("reason" in target || !this.options.actions) this.setActionNotice({ text: "reason" in target ? target.reason : "Fleet controls are unavailable in this context.", isError: true });
+      else {
+        this.actionNotice = void 0;
+        this.stopConfirming = true;
+        this.viewport.resetTop();
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesFleetAction(data, this.keybindings, "toggleTools")) {
+      this.expandedTools = !this.expandedTools;
+      this.transcriptCache = void 0;
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesFleetAction(data, this.keybindings, "inspect")) {
+      this.inspectSelected();
+      return;
+    }
+  }
+  rosterLines(layout) {
+    if (this.snapshot.items.length === 0) return [this.theme.fg("dim", "No tracked children")];
+    return layout.rosterKeys.map((_key, offset) => {
+      const index = layout.rosterStart + offset;
+      const item = this.snapshot.items[index];
+      const marker = index === this.selected ? this.theme.fg("accent", "\u203A") : " ";
+      const context = item.kind === "async" ? contextModeBadge(this.theme, item.step?.context ?? item.run.context) : item.kind === "foreground-recent" ? contextModeBadge(this.theme, item.child.context) : "";
+      const task = item.kind === "async" ? item.task : void 0;
+      const name = task && item.kind === "async" && item.step ? item.step.agent : item.agent;
+      const agent = index === this.selected ? this.theme.bold(name) : name;
+      const identity = task ?? item.runId.slice(0, 8);
+      const left = `${marker} ${statusGlyph(item, this.theme)} ${agent}${context} ${this.theme.fg("dim", `\xB7 ${identity}`)}`;
+      return rightAligned(left, this.theme.fg("dim", item.state), layout.roster.width);
+    });
+  }
+  renderedTranscript(target, width) {
+    const fingerprint = `${target.trustedRoots.join("\0")}|${target.trustedFiles?.join("\0") ?? ""}|${target.trustedFileRoot ?? ""}|${transcriptFingerprint(target.path)}`;
+    if (this.transcriptCache && this.transcriptCache.path === target.path && this.transcriptCache.fingerprint === fingerprint && this.transcriptCache.width === width && this.transcriptCache.expandedTools === this.expandedTools) {
+      return { transcript: this.transcriptCache.transcript, body: [...this.transcriptCache.body] };
+    }
+    const transcript = readFleetTranscript(target.path, {
+      trustedRoots: target.trustedRoots,
+      ...target.trustedFiles ? { trustedFiles: target.trustedFiles } : {},
+      ...target.trustedFileRoot ? { trustedFileRoot: target.trustedFileRoot } : {}
+    });
+    const body = transcript.events.length > 0 ? renderFleetTranscript(transcript, width, this.theme, this.markdownTheme, { expandedTools: this.expandedTools }) : [];
+    this.transcriptCache = transcript.readFailed ? void 0 : { path: target.path, fingerprint, width, expandedTools: this.expandedTools, transcript, body };
+    return { transcript, body: [...body] };
+  }
+  promptAuditDetail(width) {
+    const selected = this.snapshot.items[this.selected];
+    const prompt = this.selectedPromptAudit();
+    const items = this.promptAuditItems();
+    const selectedPosition = selected ? items.findIndex(({ item }) => item.key === selected.key) : -1;
+    const live = selected?.kind === "foreground-active" ? selected.activeChild ?? selected.control : void 0;
+    const viewLabel = promptAuditViewLabel(this.promptAuditView);
+    const promptText = this.selectedPromptText() ?? this.theme.fg("muted", "Selected prompt unavailable.");
+    const raw = [
+      this.theme.bold("Prompt Audit"),
+      this.theme.fg("dim", "Retention: live memory only \xB7 no storage"),
+      selected?.kind === "foreground-active" ? `Run: ${selected.runId}${selected.index !== void 0 ? ` \xB7 Child: ${selected.index}` : ""} \xB7 Agent: ${selected.agent}` : "Selected prompt unavailable",
+      live ? `Started: ${new Date(live.startedAt).toISOString()}` : void 0,
+      live ? `Model: ${formatModelThinking(live.model, live.thinking) || "default"}` : void 0,
+      prompt?.cwd ? `Cwd: ${prompt.cwd}` : void 0,
+      prompt?.outputPath ? `Output: ${prompt.outputPath}` : void 0,
+      this.theme.fg("dim", `Live children: ${items.map(({ item }) => item.agent).join(", ") || "none"}`),
+      this.theme.fg("dim", selectedPosition >= 0 ? `Selected: ${selectedPosition + 1}/${items.length}` : "Selected prompt unavailable"),
+      "",
+      this.theme.fg("accent", viewLabel),
+      promptText
+    ];
+    const body = raw.filter((line) => line !== void 0).flatMap((line) => wrapTextWithAnsi(line, Math.max(1, width)));
+    return { header: [], body: this.withActionLines(body) };
+  }
+  wrappedDetail(width) {
+    if (this.promptAuditOpen) return this.promptAuditDetail(width);
+    const selected = this.snapshot.items[this.selected];
+    let transcriptWarning;
+    if (selected) {
+      const target = transcriptTarget(selected, this.state);
+      if (target) {
+        const { transcript, body } = this.renderedTranscript(target, width);
+        transcriptWarning = transcript.warning;
+        if (transcript.events.length > 0) {
+          if (this.snapshot.error) body.unshift(this.theme.fg("warning", `Fleet scan warning: ${this.snapshot.error}`), "");
+          const latest = transcript.events.at(-1);
+          const conversationState = latest?.kind === "assistant" ? "assistant response" : latest?.kind === "user" ? "supervisor message" : latest?.kind === "tool" ? `${latest.name} \xB7 ${latest.status}` : "activity";
+          const promptSummary = selected.kind === "foreground-active" ? foregroundAuthoredPromptSummary(selected, this.state) : void 0;
+          return { header: structuredHeader(selected, width, this.theme, conversationState, promptSummary), body: this.withActionLines(body) };
+        }
+      }
+    }
+    const raw = detailLines(selected, this.snapshot.error, this.state);
+    if (transcriptWarning) raw.unshift(`Transcript preview warning: ${transcriptWarning}`, "");
+    const lines = [];
+    for (const line of raw) {
+      const styled = /^(Run|State|Mode|Source|Child|Agent|Model|Task):/.test(line) ? this.theme.bold(line) : /^(Transcript|Result transcript tail)/.test(line) ? this.theme.fg("accent", line) : /^(Output|Session|Transcript file|Artifacts):/.test(line) ? this.theme.fg("muted", line) : /^Transcript preview warning:/.test(line) ? this.theme.fg("warning", line) : line;
+      const wrapped = wrapTextWithAnsi(styled, Math.max(1, width));
+      lines.push(...wrapped.length ? wrapped : [""]);
+    }
+    return { header: [], body: this.withActionLines(lines) };
+  }
+  render(width) {
+    const layout = fleetLayout(width, this.tui.terminal?.rows ?? 32, this.selected, this.snapshot.items);
+    this.renderedLayout = layout;
+    if (!layout) return [truncateToWidth("Subagent fleet needs at least 36 columns. Esc closes.", width)];
+    const innerWidth = width - 2;
+    const { bodyHeight } = layout;
+    const rosterWidth = layout.roster.width;
+    const detailWidth = layout.output.width;
+    const roster = this.rosterLines(layout);
+    const detail = this.wrappedDetail(detailWidth);
+    const detailHeader = detail.header.slice(0, Math.max(0, bodyHeight - 1));
+    const outputBodyHeight = bodyHeight - detailHeader.length;
+    const visibleDetails = [
+      ...detailHeader,
+      ...this.viewport.render(detail.body, detailWidth, outputBodyHeight)
+    ];
+    const lines = [this.theme.fg("border", `\u256D${"\u2500".repeat(innerWidth)}\u256E`)];
+    const selected = this.snapshot.items[this.selected];
+    const title = selected?.kind === "external" ? ` ${this.theme.bold("Fleet inspector")} ${this.theme.fg("dim", "\xB7 external display-only")}` : ` ${this.theme.bold("Subagent fleet inspector")} ${this.theme.fg("dim", "\xB7 live controls")}`;
+    const selectedStatus = selected ? `${statusGlyph(selected, this.theme)} ${selected.agent} \xB7 ${selected.state} ` : this.theme.fg("dim", "no children ");
+    lines.push(this.theme.fg("border", "\u2502") + rightAligned(title, selectedStatus, innerWidth) + this.theme.fg("border", "\u2502"));
+    lines.push(this.theme.fg("border", `\u251C${"\u2500".repeat(rosterWidth)}\u252C${"\u2500".repeat(detailWidth)}\u2524`));
+    for (let index = 0; index < bodyHeight; index++) {
+      lines.push(
+        this.theme.fg("border", "\u2502") + fit(roster[index] ?? "", rosterWidth) + this.theme.fg("border", "\u2502") + fit(visibleDetails[index] ?? "", detailWidth) + this.theme.fg("border", "\u2502")
+      );
+    }
+    lines.push(this.theme.fg("border", `\u251C${"\u2500".repeat(rosterWidth)}\u2534${"\u2500".repeat(detailWidth)}\u2524`));
+    const position = this.snapshot.items.length ? `${this.selected + 1}/${this.snapshot.items.length}` : "0/0";
+    const footer = this.promptAuditOpen ? ` j/k child \xB7 1/2/3 view \xB7 g redo with guidance \xB7 c copy \xB7 Esc close Prompt Audit \xB7 ${position}` : selected?.kind === "external" ? ` ${bindingLabel(this.keybindings, "selectUp")}/${bindingLabel(this.keybindings, "selectDown")} job \xB7 display-only \xB7 ${bindingLabel(this.keybindings, "refresh")} refresh \xB7 ${bindingLabel(this.keybindings, "close")} close \xB7 ${position}` : ` ${bindingLabel(this.keybindings, "selectUp")}/${bindingLabel(this.keybindings, "selectDown")} agent \xB7 p Prompt Audit \xB7 ${bindingLabel(this.keybindings, "inspect")} Inspect \xB7 ${bindingLabel(this.keybindings, "steer")} steer \xB7 ${bindingLabel(this.keybindings, "stop")} stop \xB7 ${bindingLabel(this.keybindings, "toggleTools")} tools \xB7 ${bindingLabel(this.keybindings, "refresh")} refresh \xB7 ${bindingLabel(this.keybindings, "close")} close \xB7 ${position}`;
+    lines.push(this.theme.fg("border", "\u2502") + fit(this.theme.fg("dim", footer), innerWidth) + this.theme.fg("border", "\u2502"));
+    lines.push(this.theme.fg("border", `\u2570${"\u2500".repeat(innerWidth)}\u256F`));
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+  invalidate() {
+    this.renderedLayout = void 0;
+    this.transcriptCache = void 0;
+    this.refresh();
+  }
+  dispose() {
+    this.stopRefresh();
+  }
+};
+async function openSubagentFleet(ctx, state, options = {}) {
+  const wasOpen = state.fleetInspectorOpen === true;
+  state.fleetInspectorOpen = true;
+  if (typeof ctx.ui.setWidget === "function") ctx.ui.setWidget(FLEET_STATUS_WIDGET_KEY, void 0);
+  const copyText = options.copyText ?? (async (text) => {
+    const module = await import("@earendil-works/pi-coding-agent");
+    const copyToClipboard = module.copyToClipboard;
+    if (!copyToClipboard) throw new Error("Clipboard is unavailable in this Pi version.");
+    await copyToClipboard(text);
+  });
+  const actions = options.actions ?? {
+    steer: async (input) => {
+      const status = readStatus(input.asyncDir);
+      const liveWorkflowRunId = status?.mode === "workflow" && state.workflowControllers?.has(status.runId || input.runId) ? status.runId || input.runId : void 0;
+      if (liveWorkflowRunId) {
+        const route = state.foregroundControls.get(input.runId)?.parentWorkflowRunId === liveWorkflowRunId ? resolveWorkflowForegroundSteeringTarget({ state, childRunId: input.runId, asyncDirRoot: options.asyncDirRoot ?? DIRS.async }) : resolveWorkflowForegroundSteeringTarget({ state, workflowRunId: liveWorkflowRunId, asyncDirRoot: options.asyncDirRoot ?? DIRS.async });
+        if (!route.ok) return { text: route.message, isError: true };
+        return firstToolResultText(await steerWorkflowForegroundTarget({ target: route.target, message: input.message, mode: input.mode, ...input.index !== void 0 ? { index: input.index } : {} }), `Failed to steer foreground run ${input.runId}.`);
+      }
+      return firstToolResultText(await steerAsyncRun({
+        state,
+        runId: input.runId,
+        ...input.index !== void 0 ? { index: input.index } : {},
+        message: input.message,
+        mode: input.mode,
+        location: { asyncDir: input.asyncDir, resolvedId: input.runId }
+      }), `Failed to steer async run ${input.runId}.`);
+    },
+    stop: (input) => firstToolResultText(stopAsyncRun(state, input.runId, void 0, { asyncDir: input.asyncDir, resolvedId: input.runId }), `Failed to stop async run ${input.runId}.`),
+    inspect: async (input) => firstToolResultText(await handleInspectorAction("inspector.open", {
+      id: input.runId,
+      dir: input.asyncDir,
+      focus: true,
+      ...input.index !== void 0 ? { index: input.index } : {}
+    }, {
+      state,
+      sessionRoots: state.trustedSessionRoots,
+      cwd: state.baseCwd,
+      ...state.authorityPolicy ? { authorityPolicy: state.authorityPolicy } : {},
+      ...state.missionStoreConfig ? { missions: state.missionStoreConfig } : {},
+      plugins: options.inspectorPlugins?.(),
+      ...options.inspectorEnv ? { env: options.inspectorEnv } : {}
+    }), `Failed to open inspector for async run ${input.runId}.`),
+    redoPrompt: async (input) => {
+      const control = input.control ?? state.foregroundControls.get(input.runId);
+      if (!control?.promptAuditRedo) return { text: "Redo is not available for this live child.", isError: true };
+      return control.promptAuditRedo(input.index, input.guidance);
+    }
+  };
+  try {
+    await ctx.ui.custom(
+      (tui, theme, _keybindings, done) => new SubagentFleetComponent(tui, theme, state, done, { ...options, actions, copyText }),
+      {
+        overlay: true,
+        overlayOptions: { anchor: "center", width: "95%", minWidth: 60, maxHeight: "85%", margin: 1 }
+      }
+    );
+  } finally {
+    state.fleetInspectorOpen = wasOpen;
+  }
+}
+export {
+  DEFAULT_FLEET_KEYBINDINGS,
+  SubagentFleetComponent,
+  collectFleetSnapshot,
+  openSubagentFleet,
+  resolveFleetKeybindings
+};