pi-subagents 0.40.0 → 0.41.0

package/src/slash/subagents-admin.ts

@@ -84,22 +84,22 @@ function liveAvailableModels(ctx: ExtensionContext) {
 
 function buildBuiltinBase(agent: AgentConfig): BuiltinAgentOverrideBase {
 	return {
-		model: agent.model,
-		fallbackModels: agent.fallbackModels ? [...agent.fallbackModels] : undefined,
-		thinking: agent.thinking,
+		...(agent.model !== undefined ? { model: agent.model } : {}),
+		...(agent.fallbackModels !== undefined ? { fallbackModels: [...agent.fallbackModels] } : {}),
+		...(agent.thinking !== undefined ? { thinking: agent.thinking } : {}),
 		systemPromptMode: agent.systemPromptMode,
 		inheritProjectContext: agent.inheritProjectContext,
 		inheritSkills: agent.inheritSkills,
-		defaultContext: agent.defaultContext,
-		acceptanceRole: agent.acceptanceRole,
-		disabled: agent.disabled,
+		...(agent.defaultContext !== undefined ? { defaultContext: agent.defaultContext } : {}),
+		...(agent.acceptanceRole !== undefined ? { acceptanceRole: agent.acceptanceRole } : {}),
+		...(agent.disabled !== undefined ? { disabled: agent.disabled } : {}),
 		systemPrompt: agent.systemPrompt,
-		skills: agent.skills ? [...agent.skills] : undefined,
-		tools: agent.tools ? [...agent.tools] : undefined,
-		mcpDirectTools: agent.mcpDirectTools ? [...agent.mcpDirectTools] : undefined,
-		subagentOnlyExtensions: agent.subagentOnlyExtensions ? [...agent.subagentOnlyExtensions] : undefined,
-		completionGuard: agent.completionGuard,
-		toolBudget: agent.toolBudget,
+		...(agent.skills !== undefined ? { skills: [...agent.skills] } : {}),
+		...(agent.tools !== undefined ? { tools: [...agent.tools] } : {}),
+		...(agent.mcpDirectTools !== undefined ? { mcpDirectTools: [...agent.mcpDirectTools] } : {}),
+		...(agent.subagentOnlyExtensions !== undefined ? { subagentOnlyExtensions: [...agent.subagentOnlyExtensions] } : {}),
+		...(agent.completionGuard !== undefined ? { completionGuard: agent.completionGuard } : {}),
+		...(agent.toolBudget !== undefined ? { toolBudget: agent.toolBudget } : {}),
 	};
 }
 
@@ -290,7 +290,9 @@ async function saveAgentModel(ctx: ExtensionContext, agent: AgentConfig, selecte
 
 	const readOnlyMessage = readOnlyAgentMessage(agent, "model");
 	if (readOnlyMessage) return readOnlyMessage;
-	const updated: AgentConfig = { ...editableAgentConfig(agent), model: selectedModel };
+	const updated = editableAgentConfig(agent);
+	if (selectedModel === undefined) delete updated.model;
+	else updated.model = selectedModel;
 	fs.writeFileSync(updated.filePath, serializeAgent(updated, {
 		preserveFrontmatterFields: preservedAgentFrontmatterFields(agent, { model: selectedModel }),
 	}), "utf-8");
@@ -311,7 +313,9 @@ async function saveAgentThinking(ctx: ExtensionContext, agent: AgentConfig, sele
 
 	const readOnlyMessage = readOnlyAgentMessage(agent, "thinking");
 	if (readOnlyMessage) return readOnlyMessage;
-	const updated: AgentConfig = { ...editableAgentConfig(agent), thinking: selectedThinking };
+	const updated = editableAgentConfig(agent);
+	if (selectedThinking === undefined) delete updated.thinking;
+	else updated.thinking = selectedThinking;
 	fs.writeFileSync(updated.filePath, serializeAgent(updated, {
 		preserveFrontmatterFields: preservedAgentFrontmatterFields(agent, { thinking: selectedThinking }),
 	}), "utf-8");

package/src/tui/fleet-status.ts

@@ -1,11 +1,13 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type EditorComponent, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { formatModelThinking } from "../shared/formatters.ts";
-import type { AsyncJobStep, FleetViewPlacement, SubagentState } from "../shared/types.ts";
+import type { AsyncJobStep, FleetViewPlacement, NestedRunSummary, NestedStepSummary, SubagentState } from "../shared/types.ts";
+import { formatWorkflowJsonPreview } from "../workflows/scripted-workflow.ts";
 
 export const FLEET_STATUS_WIDGET_KEY = "subagent-fleet-status";
 
-const MAX_AGENT_ROWS = 5;
+// Six rows fit the accepted collapsed hierarchy: one owner, four direct leaves, and overflow.
+const MAX_AGENT_ROWS = 6;
 const REFRESH_MS = 500;
 
 type Theme = ExtensionContext["ui"]["theme"];
@@ -19,8 +21,23 @@ type FleetStatusEntry = {
 	description?: string;
 	startedAt: number;
 	tokens: number;
+	state: string;
+	nestedChildren?: NestedRunSummary[];
 };
 
+type FleetNestedRow = {
+	name: string;
+	state: NestedRunSummary["state"] | NestedStepSummary["status"];
+	modelThinking?: string;
+	activity?: string;
+	startedAt?: number;
+	overflow?: number;
+};
+
+type FleetTreeRow =
+	| { kind: "owner"; entry: FleetStatusEntry }
+	| { kind: "nested"; ownerKey: string; row: FleetNestedRow; last: boolean };
+
 export interface FleetStatusOptions {
 	refreshMs?: number;
 	maxAgentRows?: number;
@@ -55,6 +72,67 @@ function isActiveState(value: string): boolean {
 	return value === "running" || value === "queued" || value === "pending";
 }
 
+function nestedRunLabel(run: NestedRunSummary): string {
+	if (run.agent) return run.agent;
+	if (run.agents?.length) return run.agents.length === 1 ? run.agents[0]! : `${run.agents.slice(0, 2).join(", ")}${run.agents.length > 2 ? ` +${run.agents.length - 2}` : ""}`;
+	return run.id;
+}
+
+function nestedActivity(node: NestedRunSummary | NestedStepSummary): string | undefined {
+	if (node.currentTool) return `tool ${node.currentTool}`;
+	if (node.currentPath) return node.currentPath.split(/[\\/]/).at(-1);
+	if (node.activityState === "needs_attention") return "needs attention";
+	if (node.activityState === "active_long_running") return "long-running";
+	return undefined;
+}
+
+function nestedStatusGlyph(state: FleetNestedRow["state"], theme: Theme): string {
+	if (state === "running") return theme.fg("accent", "●");
+	if (state === "queued" || state === "pending") return theme.fg("muted", "◦");
+	if (state === "complete" || state === "completed") return theme.fg("success", "✓");
+	if (state === "failed" || state === "rejected") return theme.fg("error", "✗");
+	return theme.fg("warning", "■");
+}
+
+function nestedFleetRows(children: NestedRunSummary[] | undefined): FleetNestedRow[] {
+	const rows: FleetNestedRow[] = [];
+	for (const child of children ?? []) {
+		const steps = (child.mode === "parallel" || child.mode === "chain") ? child.steps ?? [] : [];
+		if (steps.length > 0) {
+			for (const step of steps) {
+				rows.push({
+					name: step.agent,
+					state: step.status,
+					...(formatModelThinking(step.model, step.thinking) ? { modelThinking: formatModelThinking(step.model, step.thinking) } : {}),
+					...(nestedActivity(step) ? { activity: nestedActivity(step) } : {}),
+					...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
+				});
+			}
+			continue;
+		}
+		rows.push({
+			name: nestedRunLabel(child),
+			state: child.state,
+			...(formatModelThinking(child.model, child.thinking) ? { modelThinking: formatModelThinking(child.model, child.thinking) } : {}),
+			...(nestedActivity(child) ? { activity: nestedActivity(child) } : {}),
+			...(child.startedAt !== undefined ? { startedAt: child.startedAt } : {}),
+		});
+	}
+	const visible = rows.slice(0, 4);
+	if (rows.length > visible.length) visible.push({ name: `… +${rows.length - visible.length} more nested leaves`, state: "complete", overflow: rows.length - visible.length });
+	return visible;
+}
+
+function fleetTreeRows(entries: FleetStatusEntry[]): FleetTreeRow[] {
+	const rows: FleetTreeRow[] = [];
+	for (const entry of entries) {
+		rows.push({ kind: "owner", entry });
+		const nested = nestedFleetRows(entry.nestedChildren);
+		for (const [index, row] of nested.entries()) rows.push({ kind: "nested", ownerKey: entry.key, row, last: index === nested.length - 1 });
+	}
+	return rows;
+}
+
 function isStaleExtensionContextError(error: unknown): boolean {
 	// Pi currently exposes stale contexts as plain Errors without a stable code or subtype.
 	return error instanceof Error
@@ -75,6 +153,10 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 					description: child.description,
 					startedAt: child.startedAt,
 					tokens: child.tokens ?? 0,
+					state: "running",
+					...((control.nestedChildren?.filter((nested) => nested.parentStepIndex === child.index).length ?? 0) > 0
+						? { nestedChildren: control.nestedChildren!.filter((nested) => nested.parentStepIndex === child.index) }
+						: control.activeChildren.size === 1 && control.nestedChildren?.length ? { nestedChildren: control.nestedChildren } : {}),
 				});
 			}
 			continue;
@@ -87,12 +169,27 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 			description: control.description,
 			startedAt: control.startedAt,
 			tokens: control.tokens ?? 0,
+			state: "running",
+			...(control.nestedChildren?.length ? { nestedChildren: control.nestedChildren } : {}),
 		});
 	}
 
 	for (const job of state.asyncJobs.values()) {
 		if (!isActiveState(job.status)) continue;
 		const startedAt = job.startedAt ?? job.updatedAt ?? Date.now();
+		if (job.mode === "workflow") {
+			const latestEmit = job.workflow?.emits?.length ? formatWorkflowJsonPreview(job.workflow.emits.at(-1), 120) : undefined;
+			entries.push({
+				key: `async:${job.asyncId}`,
+				agent: "workflow",
+				description: latestEmit !== undefined ? `latest emit: ${latestEmit}` : job.description,
+				startedAt,
+				tokens: job.totalTokens?.total ?? 0,
+				state: job.status,
+				...(job.nestedChildren?.length ? { nestedChildren: job.nestedChildren } : {}),
+			});
+			continue;
+		}
 		const steps: AsyncJobStep[] | undefined = job.steps?.length
 			? job.steps
 			: job.agents?.map((agent, index) => {
@@ -107,6 +204,8 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 				description: job.description,
 				startedAt,
 				tokens: job.totalTokens?.total ?? 0,
+				state: job.status,
+				...(job.nestedChildren?.length ? { nestedChildren: job.nestedChildren } : {}),
 			});
 			continue;
 		}
@@ -122,6 +221,12 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 				description: step.description ?? job.description,
 				startedAt: step.startedAt ?? startedAt,
 				tokens: step.tokens?.total ?? (steps.length === 1 ? job.totalTokens?.total ?? 0 : 0),
+				state: step.status,
+				...((step.children?.length ?? 0) > 0
+					? { nestedChildren: step.children }
+					: job.nestedChildren?.filter((nested) => nested.parentStepIndex === index).length
+						? { nestedChildren: job.nestedChildren.filter((nested) => nested.parentStepIndex === index) }
+						: {}),
 			});
 		}
 	}
@@ -302,21 +407,30 @@ export class SubagentFleetStatus {
 
 	render(width: number, theme: Theme): string[] {
 		if (this.entries.length === 0) return [];
+		if (!this.active) {
+			const tokens = this.entries.reduce((total, entry) => total + entry.tokens, 0);
+			const label = `${this.entries.length} active ${this.entries.length === 1 ? "agent" : "agents"}`;
+			return [truncateToWidth(`  ${theme.fg("muted", label)} · ${theme.fg("dim", `${formatFleetTokens(tokens)} · ↓/← to inspect`)}`, width)];
+		}
 		const roster = this.rosterKeys();
 		const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
-		const hint = this.active
-			? "↑↓/jk select · enter inspect · esc back"
-			: "esc to interrupt · ← for agents · ↓ to manage";
-		const lines = [truncateToWidth(`  ${theme.fg("dim", hint)}`, width), ""];
+		const lines = [truncateToWidth(`  ${theme.fg("dim", "↑↓/jk select · enter inspect · esc back")}`, width), ""];
 		lines.push(truncateToWidth(`  ${this.bullet(0, selectedIndex, theme)} main`, width));
 
-		const visibleCount = Math.min(this.maxAgentRows, this.entries.length);
-		const selectedAgentIndex = Math.max(0, selectedIndex - 1);
-		const start = selectedAgentIndex < visibleCount ? 0 : selectedAgentIndex - visibleCount + 1;
-		const hiddenBelow = this.entries.length - (start + visibleCount);
+		const tree = fleetTreeRows(this.entries);
+		const selectedTreeIndex = Math.max(0, tree.findIndex((row) => row.kind === "owner" && row.entry.key === this.selectedKey));
+		const visibleCount = Math.min(this.maxAgentRows, tree.length);
+		const start = selectedTreeIndex < visibleCount ? 0 : selectedTreeIndex - visibleCount + 1;
+		const hiddenBelow = tree.length - (start + visibleCount);
 		if (start > 0) lines.push(rightAlign("", theme.fg("dim", `↑ ${start} more`), width));
 		for (let index = start; index < start + visibleCount; index++) {
-			lines.push(this.renderEntry(index + 1, selectedIndex, this.entries[index]!, width, theme));
+			const row = tree[index]!;
+			if (row.kind === "owner") {
+				const ownerIndex = this.entries.findIndex((entry) => entry.key === row.entry.key);
+				lines.push(this.renderEntry(ownerIndex + 1, selectedIndex, row.entry, width, theme));
+			} else {
+				lines.push(this.renderNestedRow(row.row, row.last, width, theme));
+			}
 		}
 		if (hiddenBelow > 0) lines.push(rightAlign("", theme.fg("dim", `↓ ${hiddenBelow} more`), width));
 		return lines;
@@ -325,14 +439,24 @@ export class SubagentFleetStatus {
 	private renderEntry(rosterIndex: number, selectedIndex: number, entry: FleetStatusEntry, width: number, theme: Theme): string {
 		const description = entry.description?.replace(/\s+/g, " ").trim();
 		const agent = entry.modelThinking ? `${entry.agent} (${entry.modelThinking})` : entry.agent;
-		const left = `  ${this.bullet(rosterIndex, selectedIndex, theme)} ${theme.fg("muted", agent)}${description ? `  ${description}` : ""}`;
+		const left = `  ${this.bullet(rosterIndex, selectedIndex, theme)} ${theme.fg("muted", agent)} · ${entry.state}${description ? `  ${description}` : ""}`;
 		const elapsed = Date.now() - entry.startedAt;
 		const right = theme.fg("dim", `${formatFleetElapsed(elapsed)} · ${formatFleetTokens(entry.tokens)}`);
 		return rightAlign(left, right, width);
 	}
 
+	private renderNestedRow(row: FleetNestedRow, last: boolean, width: number, theme: Theme): string {
+		const marker = last ? "└─" : "├─";
+		if (row.overflow !== undefined) return truncateToWidth(`    ${marker} ${theme.fg("dim", `+${row.overflow} nested leaves`)}`, width);
+		const modelThinking = row.modelThinking ? ` (${row.modelThinking})` : "";
+		const activity = row.activity ? ` · ${row.activity}` : "";
+		const left = `    ${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);
+	}
+
 	private bullet(rosterIndex: number, selectedIndex: number, theme: Theme): string {
-		return rosterIndex === selectedIndex ? theme.fg("accent", "⏺") : theme.fg("dim", "◯");
+		return rosterIndex === selectedIndex ? theme.fg("accent", ">") : " ";
 	}
 
 	private rosterKeys(): string[] {
@@ -368,14 +492,25 @@ export class SubagentFleetStatus {
 			active: this.active,
 			selected: this.selectedKey,
 			inspectorOpen: this.inspectorOpen,
-			entries: this.entries.map((entry) => [
-				entry.key,
-				entry.agent,
-				entry.modelThinking,
-				entry.description,
-				Math.round((now - entry.startedAt) / 1000),
-				entry.tokens,
-			]),
+			entries: this.entries.map((entry) => this.active
+				? [
+					entry.key,
+					entry.agent,
+					entry.state,
+					entry.modelThinking,
+					entry.description,
+					Math.round((now - entry.startedAt) / 1000),
+					entry.tokens,
+					entry.nestedChildren?.map((child) => [
+						child.id,
+						child.state,
+						child.model,
+						child.thinking,
+						child.lastUpdate,
+						child.steps?.map((step) => [step.agent, step.status, step.model, step.thinking, step.lastActivityAt]),
+					]),
+				]
+				: [entry.key, entry.state, entry.tokens]),
 		});
 	}
 

package/src/tui/fleet-transcript.ts

@@ -7,6 +7,89 @@ const DEFAULT_MAX_RECORDS = 240;
 const DEFAULT_MAX_BYTES = 2 * 1024 * 1024;
 const MAX_MESSAGE_CHARS = 64 * 1024;
 const TOOL_PREVIEW_LINES = 7;
+const BINARY_CONTENT_PLACEHOLDER = "[binary content omitted for safe display]";
+
+function isUnsafeDisplayCodePoint(codePoint: number): boolean {
+	const terminalControl = (codePoint <= 0x1f && codePoint !== 0x09 && codePoint !== 0x0a)
+		|| (codePoint >= 0x7f && codePoint <= 0x9f);
+	const bidiControl = codePoint === 0x061c
+		|| codePoint === 0x200e
+		|| codePoint === 0x200f
+		|| (codePoint >= 0x202a && codePoint <= 0x202e)
+		|| (codePoint >= 0x2066 && codePoint <= 0x2069);
+	const privateUse = (codePoint >= 0xe000 && codePoint <= 0xf8ff)
+		|| (codePoint >= 0xf0000 && codePoint <= 0xffffd)
+		|| (codePoint >= 0x100000 && codePoint <= 0x10fffd);
+	const invalidScalar = codePoint >= 0xd800 && codePoint <= 0xdfff;
+	const nonCharacter = (codePoint >= 0xfdd0 && codePoint <= 0xfdef)
+		|| (codePoint & 0xffff) === 0xfffe
+		|| (codePoint & 0xffff) === 0xffff;
+	return terminalControl || bidiControl || privateUse || invalidScalar || nonCharacter;
+}
+
+function looksLikeBinaryContent(text: string): boolean {
+	if (text.includes("\0")) return true;
+	let suspiciousControls = 0;
+	let replacementCharacters = 0;
+	let codePoints = 0;
+	for (const character of text) {
+		codePoints++;
+		const codePoint = character.codePointAt(0) ?? 0;
+		if ((codePoint <= 0x08) || (codePoint >= 0x0e && codePoint <= 0x1f)) suspiciousControls++;
+		if (codePoint === 0xfffd) replacementCharacters++;
+	}
+	if (codePoints === 0) return false;
+	return (suspiciousControls >= 4 && suspiciousControls / codePoints >= 0.1)
+		|| (replacementCharacters >= 3 && replacementCharacters / codePoints >= 0.1);
+}
+
+function safeDisplayText(text: string): string {
+	const normalized = text.replace(/\r\n/g, "\n");
+	if (looksLikeBinaryContent(normalized)) return BINARY_CONTENT_PLACEHOLDER;
+	let safe = "";
+	for (const character of normalized) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		safe += isUnsafeDisplayCodePoint(codePoint)
+			? `[U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}]`
+			: character;
+	}
+	return safe;
+}
+
+function sanitizeJsonDisplayValue(value: unknown): { value: unknown; changed: boolean } {
+	if (typeof value === "string") {
+		const safe = safeDisplayText(value);
+		return { value: safe, changed: safe !== value };
+	}
+	if (Array.isArray(value)) {
+		const sanitized = value.map(sanitizeJsonDisplayValue);
+		return {
+			value: sanitized.map((entry) => entry.value),
+			changed: sanitized.some((entry) => entry.changed),
+		};
+	}
+	if (value && typeof value === "object") {
+		let changed = false;
+		const sanitized: Record<string, unknown> = Object.create(null);
+		for (const [key, nested] of Object.entries(value)) {
+			const safeKey = safeDisplayText(key);
+			const safeValue = sanitizeJsonDisplayValue(nested);
+			sanitized[safeKey] = safeValue.value;
+			changed ||= safeKey !== key || safeValue.changed;
+		}
+		return { value: changed ? sanitized : value, changed };
+	}
+	return { value, changed: false };
+}
+
+function safeToolArgsPayload(payload: string): string {
+	try {
+		const sanitized = sanitizeJsonDisplayValue(JSON.parse(payload));
+		return sanitized.changed ? JSON.stringify(sanitized.value) : safeDisplayText(payload);
+	} catch {
+		return safeDisplayText(payload);
+	}
+}
 
 type Theme = ExtensionContext["ui"]["theme"];
 
@@ -142,6 +225,27 @@ function clipMessage(text: string): string {
 	return `${text.slice(0, MAX_MESSAGE_CHARS)}\n\n… message truncated`;
 }
 
+function safeTranscriptEvent(event: FleetTranscriptEvent): FleetTranscriptEvent {
+	if (event.kind === "assistant") {
+		return {
+			...event,
+			text: safeDisplayText(event.text),
+			...(event.model ? { model: safeDisplayText(event.model) } : {}),
+		};
+	}
+	if (event.kind === "user" || event.kind === "notice") {
+		return { ...event, text: safeDisplayText(event.text) };
+	}
+	return {
+		...event,
+		name: safeDisplayText(event.name),
+		...(event.args !== undefined ? { args: safeDisplayText(event.args) } : {}),
+		...(event.argsPayload !== undefined ? { argsPayload: safeToolArgsPayload(event.argsPayload) } : {}),
+		...(event.output !== undefined ? { output: safeDisplayText(event.output) } : {}),
+		...(event.error !== undefined ? { error: safeDisplayText(event.error) } : {}),
+	};
+}
+
 function findTool(
 	events: FleetTranscriptEvent[],
 	toolCallId: string | undefined,
@@ -274,13 +378,13 @@ function parseTranscriptLines(lines: string[], conversationStarted = false): { e
 	for (const event of events) {
 		if (event.kind === "tool") delete (event as MutableToolEvent).resultSeen;
 	}
-	return { events, malformed, explicitTruncation };
+	return { events: events.map(safeTranscriptEvent), malformed, explicitTruncation };
 }
 
 export function readFleetTranscript(filePath: string, options: FleetTranscriptReadOptions): FleetTranscript {
 	const validated = validateTranscriptPath(filePath, options.trustedRoots);
 	if (!validated.resolvedPath) {
-		return { path: filePath, events: [], truncated: false, ...(validated.warning ? { warning: validated.warning } : {}) };
+		return { path: filePath, events: [], truncated: false, ...(validated.warning ? { warning: safeDisplayText(validated.warning) } : {}) };
 	}
 	const maxRecords = Math.max(1, options.maxRecords ?? DEFAULT_MAX_RECORDS);
 	const tail = readTailLines(validated.resolvedPath, Math.max(1024, options.maxBytes ?? DEFAULT_MAX_BYTES));
@@ -295,7 +399,7 @@ export function readFleetTranscript(filePath: string, options: FleetTranscriptRe
 		path: filePath,
 		events: parsed.events,
 		truncated: tail.truncated || tail.lines.length > maxRecords || parsed.explicitTruncation,
-		...(warnings.length ? { warning: warnings.join(" ") } : {}),
+		...(warnings.length ? { warning: safeDisplayText(warnings.join(" ")) } : {}),
 	};
 }
 
@@ -404,12 +508,13 @@ export function renderFleetTranscript(
 	const lines: string[] = [];
 	if (transcript.truncated) lines.push(bounded(theme.fg("dim", "↑ Earlier activity omitted"), width));
 	if (transcript.warning) {
-		for (const line of renderWrapped(transcript.warning, Math.max(1, width - 2))) {
+		for (const line of renderWrapped(safeDisplayText(transcript.warning), Math.max(1, width - 2))) {
 			lines.push(bounded(`${theme.fg("warning", "!")} ${theme.fg("warning", line)}`, width));
 		}
 	}
 
-	for (const event of transcript.events) {
+	for (const rawEvent of transcript.events) {
+		const event = safeTranscriptEvent(rawEvent);
 		if (event.kind === "tool") {
 			if (options.expandedTools && (event.output || event.argsPayload || event.error)) {
 				lines.push(...renderExpandedTool(event, width, theme));

package/src/tui/fleet.ts

@@ -5,7 +5,7 @@ import { getMarkdownTheme, type ExtensionContext } from "@earendil-works/pi-codi
 import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component, type MarkdownTheme } from "@earendil-works/pi-tui";
 import { getArtifactPaths, getArtifactsDir } from "../shared/artifacts.ts";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../shared/formatters.ts";
-import { RESULTS_DIR, type AsyncJobState, type Details, type ForegroundChildControl, type ForegroundResumeChild, type ForegroundResumeRun, type ForegroundRunControl, type SubagentState } from "../shared/types.ts";
+import { DIRS, type AsyncJobState, type Details, type ForegroundChildControl, type ForegroundResumeChild, type ForegroundResumeRun, type ForegroundRunControl, type SubagentState } from "../shared/types.ts";
 import { readStatus } from "../shared/utils.ts";
 import { formatAsyncRunTranscript } from "../runs/background/fleet-view.ts";
 import { listAsyncRuns, type AsyncRunSummary } from "../runs/background/async-status.ts";
@@ -14,9 +14,11 @@ import { stopAsyncRun } from "../runs/foreground/async-stop-action.ts";
 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";
 
 const REFRESH_MS = 750;
 const MAX_RECENT_ASYNC_RUNS = 20;
+const MAX_FLEET_HISTORY_CANDIDATES = 100;
 const TRANSCRIPT_LINES = 200;
 
 type Theme = ExtensionContext["ui"]["theme"];
@@ -45,6 +47,7 @@ export interface FleetActionResult {
 export interface FleetActionHandlers {
 	steer(input: { runId: string; asyncDir: string; index?: number; message: string }): Promise<FleetActionResult>;
 	stop(input: { runId: string; asyncDir: string; index?: number }): Promise<FleetActionResult> | FleetActionResult;
+	inspect?(input: { runId: string; asyncDir: string; index?: number }): Promise<FleetActionResult>;
 }
 
 export interface FleetViewOptions {
@@ -104,7 +107,7 @@ function trackedJobSummary(job: AsyncJobState): AsyncRunSummary {
 
 function asyncItems(run: AsyncRunSummary, description?: string): FleetItem[] {
 	const updatedAt = run.lastUpdate ?? run.endedAt ?? run.startedAt;
-	if (run.steps.length === 0) {
+	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) => ({
@@ -121,6 +124,14 @@ function asyncItems(run: AsyncRunSummary, description?: string): FleetItem[] {
 	}));
 }
 
+function orderFleetAsyncRuns(runs: AsyncRunSummary[], terminalLimit: number): 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);
+	const terminal = runs.filter((run) => run.state !== "queued" && run.state !== "running").sort(byNewest);
+	return [...active, ...terminal.slice(0, terminalLimit)];
+}
+
 export function collectFleetSnapshot(
 	state: SubagentState,
 	options: { asyncDirRoot?: string; resultsDir?: string; limit?: number } = {},
@@ -163,30 +174,35 @@ export function collectFleetSnapshot(
 	try {
 		let runs: AsyncRunSummary[];
 		const descriptions = new Map<string, string>();
+		const tracked = [...(state.fleetJobs ?? state.asyncJobs).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 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]) {
+			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 !== undefined) {
-			runs = listAsyncRuns(options.asyncDirRoot, {
+			const trackedIds = new Set(trackedRuns.map((run) => run.id));
+			const history = listAsyncRuns(options.asyncDirRoot, {
 				...(state.currentSessionId ? { sessionId: state.currentSessionId } : {}),
-				limit: options.limit ?? MAX_RECENT_ASYNC_RUNS,
-				resultsDir: options.resultsDir ?? RESULTS_DIR,
+				entryLimit: MAX_FLEET_HISTORY_CANDIDATES,
+				resultsDir: options.resultsDir ?? DIRS.results,
 				reconcile: false,
-			});
+			}).filter((run) => !trackedIds.has(run.id));
+			runs = [...trackedRuns, ...history];
 		} else {
-			const tracked = [...(state.fleetJobs ?? state.asyncJobs).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 recent = tracked.filter((job) => job.status !== "queued" && job.status !== "running").sort(byUpdate).slice(0, options.limit ?? MAX_RECENT_ASYNC_RUNS);
-			runs = [];
-			for (const job of [...active, ...recent]) {
-				try {
-					runs.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)}`;
-				}
-			}
+			runs = trackedRuns;
+		}
+		for (const run of orderFleetAsyncRuns(runs, options.limit ?? MAX_RECENT_ASYNC_RUNS)) {
+			items.push(...asyncItems(run, descriptions.get(run.id)));
 		}
-		for (const run of runs) items.push(...asyncItems(run, descriptions.get(run.id)));
 	} catch (cause) {
 		error = cause instanceof Error ? cause.message : String(cause);
 	}
@@ -390,7 +406,7 @@ function itemStats(item: FleetItem): string[] {
 		tokens = item.child.tokens;
 		tools = item.child.toolCount;
 	} else {
-		model = item.step?.model;
+		model = formatModelThinking(item.step?.model, item.step?.thinking) || undefined;
 		tokens = item.step?.tokens?.total ?? (item.index === undefined ? item.run.totalTokens?.total : undefined);
 		tools = item.step?.toolCount ?? (item.index === undefined ? item.run.toolCount : undefined);
 		const terminalRun = item.state !== "queued" && item.state !== "running" && item.state !== "pending";
@@ -662,6 +678,12 @@ export class SubagentFleetComponent implements Component {
 			}
 			return;
 		}
+		if (data === "H") {
+			const target = this.selectedAsyncAction();
+			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 });
+			else this.runAction(() => this.options.actions!.inspect!({ runId: target.item.runId, asyncDir: target.item.run.asyncDir, ...(target.item.index !== undefined ? { index: target.item.index } : {}) }));
+			return;
+		}
 		if (data === "D") {
 			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 });
@@ -792,7 +814,7 @@ export class SubagentFleetComponent implements Component {
 		}
 		lines.push(this.theme.fg("border", `├${"─".repeat(rosterWidth)}┴${"─".repeat(detailWidth)}┤`));
 		const position = this.snapshot.items.length ? `${this.selected + 1}/${this.snapshot.items.length}` : "0/0";
-		const footer = ` ↑↓/jk agent · s steer · D stop · x/Ctrl+O tools · r refresh · Esc close · ${position}`;
+		const footer = ` ↑↓/jk agent · H Herdr · s steer · D stop · x/Ctrl+O tools · r refresh · Esc 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));
@@ -819,9 +841,19 @@ export async function openSubagentFleet(ctx: ExtensionContext, state: SubagentSt
 			runId: input.runId,
 			...(input.index !== undefined ? { index: input.index } : {}),
 			message: input.message,
-			location: { asyncDir: input.asyncDir, resolvedId: input.runId },
+			location: { asyncDir: input.asyncDir, resolvedId: input.runId } as Parameters<typeof steerAsyncRun>[0]["location"],
 		}), `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", {
+			id: input.runId,
+			dir: input.asyncDir,
+			...(input.index !== undefined ? { index: input.index } : {}),
+		}, {
+			state,
+			cwd: state.baseCwd,
+			...(state.authorityPolicy ? { authorityPolicy: state.authorityPolicy } : {}),
+			...(state.missionStoreConfig ? { missions: state.missionStoreConfig } : {}),
+		}), `Failed to open Herdr inspector for async run ${input.runId}.`),
 	} satisfies FleetActionHandlers;
 	try {
 		await ctx.ui.custom<undefined>(