pi-subagents 0.65.1 → 0.67.0

package/src/tui/fleet-status.ts

@@ -8,6 +8,7 @@ import { contextModeLabel } from "../runs/shared/context-mode.ts";
 import { formatWorkflowJsonPreview } from "../workflows/scripted-workflow.ts";
 import { hostStepReportName, hostStepVerdictLabel } from "../runs/shared/host-step-status.ts";
 import { isStaleExtensionContextError } from "../shared/extension-context.ts";
+import { inlineWorkflowRenderKey } from "./render.ts";
 import { formatWorkflowChecklistBottleneck, formatWorkflowChecklistPhase, formatWorkflowChecklistSummary, projectWorkflowChecklist, type WorkflowChecklistPhase, type WorkflowChecklistProjection } from "../workflows/workflow-checklist.ts";
 
 export const FLEET_STATUS_WIDGET_KEY = "subagent-fleet-status";
@@ -17,6 +18,35 @@ const MAX_AGENT_ROWS = 6;
 const REFRESH_MS = 500;
 
 type Theme = ExtensionContext["ui"]["theme"];
+
+const FLEET_AGENT_IDENTITY_COLORS = [
+	"mdLink",
+	"mdHeading",
+	"syntaxFunction",
+	"syntaxKeyword",
+	"syntaxNumber",
+	"syntaxType",
+	"syntaxVariable",
+	"customMessageLabel",
+	"toolTitle",
+	"thinkingMedium",
+	"thinkingHigh",
+	"mdQuote",
+	"bashMode",
+	"userMessageText",
+	"mdCode",
+	"syntaxOperator",
+] as const satisfies readonly Exclude<Parameters<Theme["fg"]>[0], "accent" | "success" | "error" | "warning" | "muted" | "dim">[];
+
+export function fleetAgentIdentityColor(identity: string): (typeof FLEET_AGENT_IDENTITY_COLORS)[number] {
+	let hash = 2166136261;
+	for (let i = 0; i < identity.length; i++) {
+		hash ^= identity.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return FLEET_AGENT_IDENTITY_COLORS[(hash >>> 0) % FLEET_AGENT_IDENTITY_COLORS.length]!;
+}
+
 type FleetStatusTui = {
 	requestRender(): void;
 };
@@ -26,6 +56,7 @@ type FleetStatusEntry = {
 	parentKey?: string;
 	workflowWrapper?: boolean;
 	agent: string;
+	displayLabel?: string;
 	modelThinking?: string;
 	description?: string;
 	startedAt: number;
@@ -41,10 +72,12 @@ type FleetStatusEntry = {
 
 type FleetNestedRow = {
 	name: string;
+	agentIdentity?: string;
 	state: NestedRunSummary["state"] | NestedStepSummary["status"];
 	modelThinking?: string;
 	activity?: string;
 	startedAt?: number;
+	endedAt?: number;
 	depth: number;
 	overflow?: number;
 };
@@ -60,6 +93,7 @@ export interface FleetStatusOptions {
 	refreshMs?: number;
 	maxAgentRows?: number;
 	placement?: FleetViewPlacement;
+	onWorkflowCoverageChange?: (ui: ExtensionContext["ui"], coverage: ReadonlyMap<string, string>) => void;
 }
 
 export function resolveFleetViewPlacement(value: unknown): FleetViewPlacement {
@@ -70,14 +104,21 @@ export function formatFleetElapsed(ms: number): string {
 	return `${Math.max(0, Math.round(ms / 1000))}s`;
 }
 
-export function formatFleetTokens(count: number, window?: number): string {
+function detailElapsed(row: Pick<AsyncStatusWorkflowRow, "startedAt" | "endedAt" | "durationMs"> & { state: string }): string | undefined {
+	const duration = row.state === "running" && row.startedAt !== undefined
+		? Date.now() - row.startedAt
+		: row.durationMs ?? (row.startedAt !== undefined && row.endedAt !== undefined ? row.endedAt - row.startedAt : undefined);
+	return duration !== undefined ? formatFleetElapsed(duration) : undefined;
+}
+
+export function formatFleetTokens(count: number, window?: number, windowCount = 1): string {
 	const compact = (value: number): string => value >= 1_000_000
 		? `${(value / 1_000_000).toFixed(1)}M`
 		: value >= 1_000
 			? `${(value / 1_000).toFixed(1)}k`
 			: `${Math.max(0, Math.round(value))}`;
 	return window !== undefined
-		? `↓ ${compact(window)} window · ${compact(count)} spent`
+		? `↓ ${compact(window)} ${windowCount > 1 ? "Σ windows" : "window"} · ${compact(count)} spent`
 		: `↓ ${compact(count)} tokens`;
 }
 
@@ -184,11 +225,13 @@ function nestedFleetRows(children: NestedRunSummary[] | undefined, visibleLimit:
 					const activity = nestedActivity(step);
 					rows.push({
 						name: step.agent,
+						agentIdentity: step.agent,
 						state: step.status,
 						depth,
 						...(modelThinking ? { modelThinking } : {}),
 						...(activity ? { activity } : {}),
 						...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
+						...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
 					});
 					if (!appendRuns(step.children, depth + 1)) {
 						omitted += nestedStepDisplayCount(steps, stepIndex + 1);
@@ -206,11 +249,13 @@ function nestedFleetRows(children: NestedRunSummary[] | undefined, visibleLimit:
 				const activity = nestedActivity(child);
 				rows.push({
 					name: nestedRunLabel(child),
+					agentIdentity: child.agent ?? child.agents?.join("\0") ?? child.id,
 					state: child.state,
 					depth,
 					...(modelThinking ? { modelThinking } : {}),
 					...(activity ? { activity } : {}),
 					...(child.startedAt !== undefined ? { startedAt: child.startedAt } : {}),
+					...(child.endedAt !== undefined ? { endedAt: child.endedAt } : {}),
 				});
 			}
 			if (!appendRuns(child.children, depth + 1)) {
@@ -320,6 +365,7 @@ function projectPaneEntries(state: SubagentState): FleetStatusEntry[] {
 }
 
 export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntry[] {
+	const now = Date.now();
 	const entries: FleetStatusEntry[] = [];
 	const activeWorkflowKeys = new Set([...state.asyncJobs.values()]
 		.filter((job) => job.mode === "workflow" && isActiveState(job.status))
@@ -380,7 +426,7 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 
 	for (const job of state.asyncJobs.values()) {
 		if (!isActiveState(job.status)) continue;
-		const startedAt = job.startedAt ?? job.updatedAt ?? Date.now();
+		const startedAt = job.startedAt ?? job.updatedAt ?? now;
 		const linkedParentKey = linkedWorkflowParentKey(job.parentWorkflowRunId, activeWorkflowKeys);
 		if (job.mode === "workflow") {
 			const latestEmit = job.workflow?.emits?.length ? formatWorkflowJsonPreview(job.workflow.emits.at(-1), 120) : undefined;
@@ -392,7 +438,7 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 				hostSteps: job.hostSteps,
 				preflight: job.preflight,
 				trace: job.workflow?.trace,
-				now: job.updatedAt ?? Date.now(),
+				now,
 			});
 			entries.push({
 				key: `async:${job.asyncId}`,
@@ -439,7 +485,8 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 			entries.push({
 				key: `async:${job.asyncId}:${index}`,
 				...(linkedParentKey ? { parentKey: linkedParentKey } : {}),
-				agent: step.label ? `${step.label} (${step.agent})` : step.agent,
+				agent: step.agent,
+				...(step.label ? { displayLabel: `${step.label} (${step.agent})` } : {}),
 				...(modelThinking ? { modelThinking } : {}),
 				description: step.description ?? job.description,
 				startedAt: step.startedAt ?? startedAt,
@@ -492,6 +539,8 @@ export class SubagentFleetStatus {
 	private inspectorOpen = false;
 	private lastRenderKey = "";
 	private entries: FleetStatusEntry[] = [];
+	private workflowSnapshots = new Map<string, { snapshot: string; childRows: Set<string> }>();
+	private readonly onWorkflowCoverageChange: FleetStatusOptions["onWorkflowCoverageChange"];
 	private readonly state: SubagentState;
 	private readonly openInspector: (itemKey: string) => Promise<void> | void;
 	private readonly refreshMs: number;
@@ -508,10 +557,14 @@ export class SubagentFleetStatus {
 		this.refreshMs = options.refreshMs ?? REFRESH_MS;
 		this.maxAgentRows = options.maxAgentRows ?? MAX_AGENT_ROWS;
 		this.placement = options.placement ?? "belowEditor";
+		this.onWorkflowCoverageChange = options.onWorkflowCoverageChange;
 	}
 
 	setContext(ctx: ExtensionContext): void {
-		if (!ctx.hasUI) return;
+		if (!ctx.hasUI) {
+			this.clearUiRegistration();
+			return;
+		}
 		const ui = ctx.ui;
 		if (this.ui === ui) {
 			this.ctx = ctx;
@@ -548,6 +601,52 @@ export class SubagentFleetStatus {
 			return;
 		}
 		this.entries = collectFleetStatusEntries(this.state);
+		this.workflowSnapshots.clear();
+		if (this.active && !this.inspectorOpen && !this.state.fleetInspectorOpen && this.onWorkflowCoverageChange) {
+			const childrenByParent = new Map<string, AsyncJobState[]>();
+			for (const child of this.state.asyncJobs.values()) {
+				if (!child.parentWorkflowRunId) continue;
+				const children = childrenByParent.get(child.parentWorkflowRunId) ?? [];
+				children.push(child);
+				childrenByParent.set(child.parentWorkflowRunId, children);
+			}
+			const attachedByParent = new Map<string, FleetStatusEntry[]>();
+			for (const entry of this.entries) {
+				if (!entry.parentKey) continue;
+				const attached = attachedByParent.get(entry.parentKey) ?? [];
+				attached.push(entry);
+				attachedByParent.set(entry.parentKey, attached);
+			}
+			for (const job of this.state.asyncJobs.values()) {
+				// Fleet does not expand attached workflow wrappers or step descendants.
+				// Unknown/unsupported coverage deliberately retains the async tree.
+				if (job.mode !== "workflow" || !isActiveState(job.status) || job.parentWorkflowRunId
+					|| job.nestedChildren?.length || job.steps?.some((step) => step.children?.length)) continue;
+				const key = `async:${job.asyncId}`;
+				const children = childrenByParent.get(job.asyncId) ?? [];
+				const attached = attachedByParent.get(key) ?? [];
+				if (children.length && job.status !== "running") continue;
+				// Even without workflow rows, these children plus their owner cannot fit.
+				if (attached.length >= this.maxAgentRows) continue;
+				const rowKeys = new Set<string>();
+				let unsupported = false;
+				for (const child of children) {
+					if (!isActiveState(child.status) || (child.mode !== "single" && child.mode !== "parallel" && child.mode !== "chain")
+						|| child.hostSteps?.length || child.workflowGraph
+						|| childrenByParent.has(child.asyncId) || child.nestedChildren?.length
+						|| child.steps?.some((step) => step.children?.length || step.runner || !isActiveState(step.status))) {
+						unsupported = true; break;
+					}
+					const count = child.steps?.length || child.agents?.length || 0;
+					if (!count || (child.stepsTotal ?? 0) > count || (child.chainStepCount ?? 0) > count) {
+						unsupported = true; break;
+					}
+					for (let index = 0; index < count; index++) rowKeys.add(`async:${child.asyncId}:${child.steps?.[index]?.index ?? index}`);
+				}
+				if (unsupported || attached.length !== rowKeys.size || attached.some((entry) => !rowKeys.has(entry.key))) continue;
+				this.workflowSnapshots.set(key, { snapshot: inlineWorkflowRenderKey(job, children), childRows: rowKeys });
+			}
+		}
 		this.clampSelection();
 		if (this.inspectorOpen || this.state.fleetInspectorOpen) {
 			this.lastRenderKey = "";
@@ -563,6 +662,7 @@ export class SubagentFleetStatus {
 		}
 
 		const renderKey = this.getRenderKey();
+		if (!this.active || renderKey !== this.lastRenderKey) this.clearWorkflowCoverage();
 		if (!this.widgetRegistered) {
 			ctx.ui.setWidget(FLEET_STATUS_WIDGET_KEY, (tui, theme) => {
 				this.tui = tui;
@@ -573,6 +673,7 @@ export class SubagentFleetStatus {
 					},
 					dispose: () => {
 						if (this.tui !== tui) return;
+						this.clearWorkflowCoverage();
 						this.widgetRegistered = false;
 						this.tui = undefined;
 					},
@@ -654,17 +755,24 @@ export class SubagentFleetStatus {
 	}
 
 	render(width: number, theme: Theme): string[] {
-		if (!this.hasInlineSurface()) return [];
+		if (!this.hasInlineSurface() || this.state.widgetsSuspended || this.inspectorOpen || this.state.fleetInspectorOpen) {
+			this.clearWorkflowCoverage();
+			return [];
+		}
 		if (!this.active) {
+			this.clearWorkflowCoverage();
 			const workEntries = this.entries.filter((entry) => !entry.surface);
 			const projectEntries = this.entries.filter((entry) => entry.surface === "project-pane");
-			const tokens = workEntries.reduce((total, entry) => total + entry.tokens, 0);
-			const nativeEntries = workEntries.filter((entry) => !entry.external);
+			// Workflow totals can overlap child usage and omit live lanes. Do not
+			// present either wrapper totals or an active-only sum as workflow spend.
+			const hasWorkflow = workEntries.some((entry) => entry.workflowWrapper);
+			const nativeEntries = workEntries.filter((entry) => !entry.external && !entry.workflowWrapper && !entry.parentKey);
+			const tokens = nativeEntries.reduce((total, entry) => total + entry.tokens, 0);
 			const window = nativeEntries.length > 0 && nativeEntries.every((entry) => entry.window !== undefined)
 				? nativeEntries.reduce((total, entry) => total + entry.window!, 0)
 				: undefined;
 			const capacity = this.state.activeAsyncCapacity;
-			const hasNativeRows = workEntries.some((entry) => !entry.external);
+			const hasNativeRows = nativeEntries.length > 0 || hasWorkflow;
 			const showNativeSummary = hasNativeRows || Boolean(capacity?.used);
 			const asyncRuns = capacity && showNativeSummary && (capacity.used > 0 || capacity.limit > 0) ? `Async runs ${capacity.used}/${capacity.limit || "∞"}` : "";
 			const activeEntries = activeLeafAgentCount(workEntries);
@@ -673,7 +781,11 @@ export class SubagentFleetStatus {
 			const paneAttention = projectEntries.filter((entry) => entry.projectPane && projectPaneNeedsAttention(entry.projectPane)).length;
 			const panes = projectEntries.length > 0 ? `${projectEntries.length} pane${projectEntries.length === 1 ? "" : "s"}${paneAttention ? ` (${paneAttention} ⚠)` : ""}` : "";
 			const label = [agents, asyncRuns, panes].filter(Boolean).join(" · ");
-			const detail = [showNativeSummary ? formatFleetTokens(tokens, window) : undefined, "↓/← to inspect"].filter(Boolean).join(" · ");
+			const nativeUsage = formatFleetTokens(tokens, window, nativeEntries.length);
+			const usage = hasWorkflow
+				? nativeEntries.length > 0 ? `standalone: ${nativeUsage} · workflow usage on child rows` : "usage on child rows"
+				: nativeUsage;
+			const detail = [showNativeSummary ? usage : undefined, "↓/← to inspect"].filter(Boolean).join(" · ");
 			return [truncateToWidth(`  ${theme.fg("muted", label)}${label && detail ? " · " : ""}${theme.fg("dim", detail)}`, width)];
 		}
 		const roster = this.rosterKeys();
@@ -706,6 +818,26 @@ export class SubagentFleetStatus {
 			}
 		}
 		if (hiddenBelow > 0) lines.push(rightAlign("", theme.fg("dim", `↓ ${hiddenBelow} more`), width));
+		if (this.ui && this.widgetRegistered && this.onWorkflowCoverageChange) {
+			const coverage = new Map<string, string>();
+			for (const [key, { snapshot, childRows }] of this.workflowSnapshots) {
+				const ownerIndex = tree.findIndex((row) => row.kind === "owner" && row.entry.key === key);
+				const owner = tree[ownerIndex];
+				if (owner?.kind !== "owner" || ownerIndex < start) continue;
+				const count = childRows.size + (owner.entry.workflowRows?.length ?? 0) + (owner.entry.workflowChecklist?.phases.length ?? 0);
+				if (!count || ownerIndex + count >= start + visibleCount) continue;
+				const descendants = tree.slice(ownerIndex + 1, ownerIndex + count + 1);
+				if (!descendants.every((row) => (row.kind === "workflow" && row.ownerKey === key && !row.row.overflow
+					&& visibleWidth(this.renderWorkflowRow(row.row, row.last, Infinity, theme)) <= width)
+					|| (row.kind === "workflow-phase" && row.ownerKey === key
+						&& visibleWidth(this.renderWorkflowPhaseRow(row.phase, row.last, Infinity, theme)) <= width)
+					|| (row.kind === "child" && childRows.has(row.entry.key)
+						&& visibleWidth(this.renderEntry(rosterIndexByKey.get(row.entry.key) ?? 0, selectedIndex, row.entry, 0, theme, row.last ? "└─" : "├─", true)) <= width))) continue;
+				if (childRows.size && visibleWidth(this.renderEntry(rosterIndexByKey.get(key) ?? 0, selectedIndex, owner.entry, 0, theme, undefined, true)) > width) continue;
+				coverage.set(key.slice("async:".length), snapshot);
+			}
+			this.onWorkflowCoverageChange(this.ui, coverage);
+		}
 		this.renderProjectPaneSection(lines, selectedIndex, width, theme, rosterIndexByKey);
 		return lines;
 	}
@@ -721,18 +853,20 @@ export class SubagentFleetStatus {
 	}
 
 
-	private renderEntry(rosterIndex: number, selectedIndex: number, entry: FleetStatusEntry, width: number, theme: Theme, branch?: string): string {
-		const agent = entry.modelThinking ? `${entry.agent} (${entry.modelThinking})` : entry.agent;
+	private renderEntry(rosterIndex: number, selectedIndex: number, entry: FleetStatusEntry, width: number, theme: Theme, branch?: string, unclipped = false): string {
+		const label = entry.displayLabel ?? entry.agent;
+		const agent = entry.modelThinking ? `${label} (${entry.modelThinking})` : label;
 		const prefix = branch ? `    ${branch}` : " ";
 		const checklist = entry.workflowWrapper && entry.workflowChecklist
 			? ` · checklist ${formatWorkflowChecklistSummary(entry.workflowChecklist)}${entry.workflowChecklist.bottleneck ? ` · bottleneck ${formatWorkflowChecklistBottleneck(entry.workflowChecklist.bottleneck)}` : ""}`
 			: "";
-		const left = `${prefix} ${this.bullet(rosterIndex, selectedIndex, theme)} ${theme.fg("muted", agent)} · ${entry.state}${checklist}`;
+		const left = `${prefix} ${this.bullet(rosterIndex, selectedIndex, theme)} ${theme.fg(fleetAgentIdentityColor(entry.agent), agent)} · ${entry.state}${checklist}`;
 		const elapsed = Date.now() - entry.startedAt;
 		const rightText = entry.projectPane
 			? `${entry.projectPane.summary ?? "—"} · ${formatFleetElapsed(Date.now() - entry.projectPane.refreshedAt)} ago`
-				: entry.external ? formatFleetElapsed(elapsed) : `${formatFleetElapsed(elapsed)} · ${formatFleetTokens(entry.tokens, entry.window)}`;
+				: entry.external ? formatFleetElapsed(elapsed) : `${formatFleetElapsed(elapsed)} · ${entry.workflowWrapper ? "usage on child rows" : formatFleetTokens(entry.tokens, entry.window)}`;
 		const right = theme.fg("dim", rightText);
+		if (unclipped) return `${left} ${right}`;
 		return rightAlign(left, right, width);
 	}
 
@@ -742,9 +876,9 @@ export class SubagentFleetStatus {
 		if (row.overflow !== undefined) return truncateToWidth(`${indent}${marker} ${theme.fg("dim", `+${row.overflow} nested leaves`)}`, width);
 		const modelThinking = row.modelThinking ? ` (${row.modelThinking})` : "";
 		const activity = row.activity ? ` · ${row.activity}` : "";
-		const left = `${indent}${marker} ${nestedStatusGlyph(row.state, theme)} ${theme.fg("muted", `${row.name}${modelThinking}`)} · ${row.state}${activity}`;
-		const elapsed = row.startedAt !== undefined ? ` · ${formatFleetElapsed(Date.now() - row.startedAt)}` : "";
-		return truncateToWidth(`${left}${theme.fg("dim", elapsed)}`, width);
+		const left = `${indent}${marker} ${nestedStatusGlyph(row.state, theme)} ${theme.fg(fleetAgentIdentityColor(row.agentIdentity ?? row.name), `${row.name}${modelThinking}`)} · ${row.state}${activity}`;
+		const elapsed = detailElapsed(row);
+		return truncateToWidth(`${left}${elapsed !== undefined ? theme.fg("dim", ` · ${elapsed}`) : ""}`, width);
 	}
 
 	private workflowRowGlyph(row: AsyncStatusWorkflowRow, theme: Theme): string {
@@ -797,7 +931,7 @@ export class SubagentFleetStatus {
 		].filter((value): value is string => Boolean(value)).join(" · ") : "";
 		const left = `${indent}${marker} ${this.workflowRowGlyph(row, theme)} ${theme.fg("muted", `${kind}${row.name}${context ? ` ${context}` : ""}${modelThinking}`)} · ${this.workflowRowStateLabel(row, theme)}${activity}${hints ? ` · ${hints}` : ""}`;
 		const details = [
-			row.startedAt !== undefined ? formatFleetElapsed(Date.now() - row.startedAt) : undefined,
+			detailElapsed(row),
 			row.tokens !== undefined ? formatFleetTokens(row.tokens, row.window) : undefined,
 			row.provider ? `provider:${row.provider}` : undefined,
 			row.role ? `role:${row.role}` : undefined,
@@ -853,6 +987,7 @@ export class SubagentFleetStatus {
 					entry.surface,
 					entry.parentKey,
 					entry.agent,
+					entry.displayLabel,
 					entry.state,
 					entry.modelThinking,
 					entry.description,
@@ -876,6 +1011,8 @@ export class SubagentFleetStatus {
 						row.modelThinking,
 						row.activity,
 						row.startedAt,
+						row.endedAt,
+						row.durationMs,
 						row.tokens,
 						row.provider,
 						row.role,
@@ -889,10 +1026,12 @@ export class SubagentFleetStatus {
 					]),
 					nestedFleetRows(entry.nestedChildren, entry.parentKey ? 3 : 4).map((row) => [
 						row.name,
+						row.agentIdentity,
 						row.state,
 						row.modelThinking,
 						row.activity,
 						row.startedAt,
+						row.endedAt,
 						row.depth,
 						row.overflow,
 					]),
@@ -918,6 +1057,7 @@ export class SubagentFleetStatus {
 	}
 
 	private clearWidget(): void {
+		this.clearWorkflowCoverage();
 		if (!this.widgetRegistered) return;
 		try {
 			this.ui?.setWidget(FLEET_STATUS_WIDGET_KEY, undefined);
@@ -931,6 +1071,7 @@ export class SubagentFleetStatus {
 	}
 
 	private clearUiRegistration(): void {
+		this.clearWorkflowCoverage();
 		if (this.timer) clearInterval(this.timer);
 		this.timer = undefined;
 
@@ -961,4 +1102,8 @@ export class SubagentFleetStatus {
 			throw new AggregateError(cleanupErrors, "Failed to clean up FleetView UI registration");
 		}
 	}
+
+	private clearWorkflowCoverage(): void {
+		if (this.ui) this.onWorkflowCoverageChange?.(this.ui, new Map());
+	}
 }

package/src/tui/fleet.ts

@@ -18,8 +18,8 @@ import { resolveWorkflowForegroundSteeringTarget, steerWorkflowForegroundTarget
 import { contextModeBadge, contextModeLabel } from "../runs/shared/context-mode.ts";
 import { FLEET_STATUS_WIDGET_KEY } from "./fleet-status.ts";
 import { readFleetTranscript, renderFleetTranscript, type FleetTranscript } from "./fleet-transcript.ts";
-import { handleHerdrInspectorAction } from "../inspectors/herdr/actions.ts";
-import type { HerdrClient } from "../inspectors/herdr/client.ts";
+import { handleInspectorAction } from "../inspectors/actions.ts";
+import type { InspectorPlugin } from "../inspectors/types.ts";
 import { getLivePromptAudit, type LivePromptAudit, type PromptAuditView } from "../runs/foreground/prompt-audit.ts";
 
 const REFRESH_MS = 750;
@@ -110,7 +110,8 @@ export interface FleetViewOptions {
 	fleetKeybindings?: FleetKeybindingsConfig;
 	actions?: FleetActionHandlers;
 	copyText?: (text: string) => Promise<void> | void;
-	herdrClient?: HerdrClient;
+	inspectorPlugins?: readonly InspectorPlugin[];
+	inspectorEnv?: NodeJS.ProcessEnv;
 }
 
 function belongsToCurrentSession(sessionId: string | undefined, currentSessionId: string | null): boolean {
@@ -179,10 +180,16 @@ function asyncItems(run: AsyncRunSummary, description?: string): FleetItem[] {
 	}));
 }
 
-function orderFleetAsyncRuns(runs: AsyncRunSummary[], terminalLimit: number): AsyncRunSummary[] {
+function orderFleetAsyncRuns(runs: AsyncRunSummary[], terminalLimit: number, trackedJobs: Map<string, AsyncJobState>): AsyncRunSummary[] {
 	const updatedAt = (run: AsyncRunSummary) => run.lastUpdate ?? run.endedAt ?? run.startedAt;
 	const byNewest = (left: AsyncRunSummary, right: AsyncRunSummary) => updatedAt(right) - updatedAt(left);
-	const active = runs.filter((run) => run.state === "queued" || run.state === "running").sort(byNewest);
+	// Missing tracked starts must not inherit the summary's heartbeat-based display fallback.
+	const startedAt = (run: AsyncRunSummary) => {
+		const job = trackedJobs.get(run.id);
+		return job ? job.startedAt ?? 0 : run.startedAt;
+	};
+	const byStartedAt = (left: AsyncRunSummary, right: AsyncRunSummary) => 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)];
 }
@@ -208,7 +215,7 @@ export function collectFleetSnapshot(
 		liveWorkflowForegroundControls.add(control);
 		workflowForegroundChildCounts.set(control.parentWorkflowRunId, (workflowForegroundChildCounts.get(control.parentWorkflowRunId) ?? 0) + activeChildCount);
 	}
-	for (const control of [...state.foregroundControls.values()].sort((left, right) => right.updatedAt - left.updatedAt)) {
+	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;
@@ -249,7 +256,7 @@ export function collectFleetSnapshot(
 		const tracked = [...trackedJobs.values()]
 			.filter((job) => belongsToCurrentSession(job.sessionId, state.currentSessionId));
 		const byUpdate = (left: AsyncJobState, right: AsyncJobState) => (right.updatedAt ?? right.startedAt ?? 0) - (left.updatedAt ?? left.startedAt ?? 0);
-		const active = tracked.filter((job) => job.status === "queued" || job.status === "running").sort(byUpdate);
+		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: AsyncRunSummary[] = [];
 		for (const job of [...active, ...recent]) {
@@ -272,7 +279,7 @@ export function collectFleetSnapshot(
 		} else {
 			runs = trackedRuns;
 		}
-		for (const run of orderFleetAsyncRuns(runs, options.limit ?? MAX_RECENT_ASYNC_RUNS)) {
+		for (const run of orderFleetAsyncRuns(runs, options.limit ?? MAX_RECENT_ASYNC_RUNS, trackedJobs)) {
 			items.push(...asyncItems(run, descriptions.get(run.id)));
 		}
 	} catch (cause) {
@@ -937,23 +944,23 @@ export class SubagentFleetComponent implements Component {
 		return { runId: target.item.runId, asyncDir: target.item.run.asyncDir, ...(target.item.index !== undefined ? { index: target.item.index } : {}) };
 	}
 
-	private selectedHerdrInspectAction(): { runId: string; asyncDir: string; index?: number } | { reason: string } {
+	private selectedInspectAction(): { runId: string; asyncDir: string; index?: number } | { reason: string } {
 		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 Herdr controls." };
+		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 !== undefined ? { 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 Herdr inspection." };
+		if (!parent || !isActionableAsyncState(parent.status)) return { reason: "The parent workflow is no longer available for inspection." };
 		return { runId: parent.asyncId, asyncDir: parent.asyncDir };
 	}
 
-	private inspectSelectedHerdr(): void {
-		const target = this.selectedHerdrInspectAction();
-		if ("reason" in target || !this.options.actions?.inspect) this.setActionNotice({ text: "reason" in target ? target.reason : "Herdr inspector controls are unavailable in this context.", isError: true });
+	private inspectSelected(): void {
+		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));
 	}
 
@@ -1203,7 +1210,7 @@ export class SubagentFleetComponent implements Component {
 			return;
 		}
 		if (matchesFleetAction(data, this.keybindings, "inspect")) {
-			this.inspectSelectedHerdr();
+			this.inspectSelected();
 			return;
 		}
 	}
@@ -1358,7 +1365,7 @@ export class SubagentFleetComponent implements Component {
 			? ` j/k child · 1/2/3 view · g redo with guidance · c copy · Esc close Prompt Audit · ${position}`
 			: selected?.kind === "external"
 				? ` ${bindingLabel(this.keybindings, "selectUp")}/${bindingLabel(this.keybindings, "selectDown")} job · display-only · ${bindingLabel(this.keybindings, "refresh")} refresh · ${bindingLabel(this.keybindings, "close")} close · ${position}`
-				: ` ${bindingLabel(this.keybindings, "selectUp")}/${bindingLabel(this.keybindings, "selectDown")} agent · p Prompt Audit · ${bindingLabel(this.keybindings, "inspect")} Herdr · ${bindingLabel(this.keybindings, "steer")} steer · ${bindingLabel(this.keybindings, "stop")} stop · ${bindingLabel(this.keybindings, "toggleTools")} tools · ${bindingLabel(this.keybindings, "refresh")} refresh · ${bindingLabel(this.keybindings, "close")} close · ${position}`;
+				: ` ${bindingLabel(this.keybindings, "selectUp")}/${bindingLabel(this.keybindings, "selectDown")} agent · p Prompt Audit · ${bindingLabel(this.keybindings, "inspect")} Inspect · ${bindingLabel(this.keybindings, "steer")} steer · ${bindingLabel(this.keybindings, "stop")} stop · ${bindingLabel(this.keybindings, "toggleTools")} tools · ${bindingLabel(this.keybindings, "refresh")} refresh · ${bindingLabel(this.keybindings, "close")} close · ${position}`;
 		lines.push(this.theme.fg("border", "│") + fit(this.theme.fg("dim", footer), innerWidth) + this.theme.fg("border", "│"));
 		lines.push(this.theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
 		return lines.map((line) => truncateToWidth(line, width));
@@ -1407,7 +1414,7 @@ export async function openSubagentFleet(ctx: ExtensionContext, state: SubagentSt
 			}), `Failed to steer async run ${input.runId}.`);
 		},
 		stop: (input: { runId: string; asyncDir: string; index?: number }) => firstToolResultText(stopAsyncRun(state, input.runId, undefined, { asyncDir: input.asyncDir, resolvedId: input.runId }), `Failed to stop async run ${input.runId}.`),
-		inspect: async (input: { runId: string; asyncDir: string; index?: number }) => firstToolResultText(await handleHerdrInspectorAction("inspector.open", {
+		inspect: async (input: { runId: string; asyncDir: string; index?: number }) => firstToolResultText(await handleInspectorAction("inspector.open", {
 			id: input.runId,
 			dir: input.asyncDir,
 			focus: true,
@@ -1416,10 +1423,11 @@ export async function openSubagentFleet(ctx: ExtensionContext, state: SubagentSt
 			state,
 			sessionRoots: state.trustedSessionRoots,
 			cwd: state.baseCwd,
-			...(options.herdrClient ? { client: options.herdrClient } : {}),
 			...(state.authorityPolicy ? { authorityPolicy: state.authorityPolicy } : {}),
 			...(state.missionStoreConfig ? { missions: state.missionStoreConfig } : {}),
-		}), `Failed to open Herdr inspector for async run ${input.runId}.`),
+			...(options.inspectorPlugins ? { plugins: options.inspectorPlugins } : {}),
+			...(options.inspectorEnv ? { env: options.inspectorEnv } : {}),
+		}), `Failed to open inspector for async run ${input.runId}.`),
 		redoPrompt: async (input: { runId: string; index: number; guidance: string; control?: ForegroundRunControl }) => {
 			const control = input.control ?? state.foregroundControls.get(input.runId);
 			if (!control?.promptAuditRedo) return { text: "Redo is not available for this live child.", isError: true };