pi-subagents 0.37.2 → 0.38.0

package/src/runs/shared/subagent-startup-retry.ts

@@ -0,0 +1,101 @@
+import type { Usage } from "../../shared/types.ts";
+
+/**
+ * Retry delays for child processes that exit before any model or tool activity.
+ * The schedule is intentionally short and bounded to avoid amplifying persistent
+ * launch failures while allowing concurrent Pi startup locks to clear.
+ */
+export const SUBAGENT_STARTUP_RETRY_DELAYS_MS = [250, 750, 1500] as const;
+
+/** A genuine startup race should fail well before a model request can complete. */
+export const MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS = 2000;
+
+export interface SubagentStartupFailureEvidence {
+	exitCode: number | null | undefined;
+	error?: string;
+	finalOutput?: string;
+	messageCount: number;
+	toolCount: number;
+	usage: Usage;
+	durationMs: number;
+	protocolError?: unknown;
+	processSignal?: string | null;
+	observedMutationAttempt?: boolean;
+	detached?: boolean;
+	interrupted?: boolean;
+	timedOut?: boolean;
+	stopped?: boolean;
+	turnBudgetExceeded?: boolean;
+}
+
+function hasUsage(usage: Usage): boolean {
+	return usage.input !== 0
+		|| usage.output !== 0
+		|| usage.cacheRead !== 0
+		|| usage.cacheWrite !== 0
+		|| usage.cost !== 0
+		|| usage.turns !== 0;
+}
+
+/**
+ * Classify only unexplained, zero-activity child exits as startup failures.
+ * This intentionally fails closed: any model output, tool activity, usage,
+ * mutation evidence, diagnostic, or lifecycle interruption prevents a retry.
+ */
+export function isRetryableSubagentStartupFailure(evidence: SubagentStartupFailureEvidence): boolean {
+	return evidence.exitCode !== undefined
+		&& evidence.exitCode !== null
+		&& evidence.exitCode !== 0
+		&& !evidence.error?.trim()
+		&& !evidence.finalOutput?.trim()
+		&& evidence.messageCount === 0
+		&& evidence.toolCount === 0
+		&& !hasUsage(evidence.usage)
+		&& evidence.durationMs >= 0
+		&& evidence.durationMs <= MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS
+		&& evidence.protocolError === undefined
+		&& (evidence.processSignal === undefined || evidence.processSignal === null)
+		&& evidence.observedMutationAttempt !== true
+		&& evidence.detached !== true
+		&& evidence.interrupted !== true
+		&& evidence.timedOut !== true
+		&& evidence.stopped !== true
+		&& evidence.turnBudgetExceeded !== true;
+}
+
+export function formatSubagentStartupRetryNote(input: {
+	model: string;
+	attempt: number;
+	maxAttempts: number;
+	delayMs: number;
+}): string {
+	return `[startup-retry] ${input.model} exited before model or tool activity (attempt ${input.attempt}/${input.maxAttempts}). Retrying the same model in ${input.delayMs}ms.`;
+}
+
+export function formatSubagentStartupRetryExhaustedError(input: {
+	model: string;
+	attempts: number;
+}): string {
+	return `Subagent failed to start after ${input.attempts} attempts on ${input.model}; no model, tool, output, usage, or diagnostic activity was observed. This may be a concurrent Pi startup race. Retry the run or temporarily lower subagent concurrency.`;
+}
+
+/** Wait for a retry delay, returning false when any lifecycle signal aborts it. */
+export async function waitForSubagentStartupRetry(delayMs: number, signals: Array<AbortSignal | undefined>): Promise<boolean> {
+	const activeSignals = signals.filter((signal): signal is AbortSignal => Boolean(signal));
+	if (activeSignals.some((signal) => signal.aborted)) return false;
+	if (delayMs <= 0) return true;
+
+	return await new Promise<boolean>((resolve) => {
+		let settled = false;
+		const finish = (shouldRetry: boolean): void => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			for (const signal of activeSignals) signal.removeEventListener("abort", abort);
+			resolve(shouldRetry);
+		};
+		const abort = (): void => finish(false);
+		const timer = setTimeout(() => finish(true), delayMs);
+		for (const signal of activeSignals) signal.addEventListener("abort", abort, { once: true });
+	});
+}

package/src/shared/types.ts

@@ -566,6 +566,11 @@ export interface AgentProgress {
 	toolCount: number;
 	turnCount?: number;
 	tokens: number;
+	/** Resolved launch model/effort and split usage for public live projections. */
+	model?: string;
+	thinking?: string;
+	inputTokens?: number;
+	outputTokens?: number;
 	durationMs: number;
 	error?: string;
 	failedTool?: string;
@@ -762,6 +767,7 @@ export interface SingleResult {
 	/** Resolved launch context for this child. */
 	context?: "fresh" | "fork";
 	exitCode: number;
+	processSignal?: string | null;
 	detached?: boolean;
 	detachedReason?: string;
 	interrupted?: boolean;
@@ -1259,12 +1265,18 @@ export interface ForegroundChildControl {
 	currentPath?: string;
 	turnCount?: number;
 	tokens?: number;
+	inputTokens?: number;
+	outputTokens?: number;
+	model?: string;
+	thinking?: string;
 	toolCount?: number;
 	interrupt?: () => boolean;
 }
 
 export interface ForegroundRunControl {
 	runId: string;
+	/** Originating parent session; required for public fleet projection. */
+	sessionId?: string;
 	mode: SubagentRunMode;
 	startedAt: number;
 	updatedAt: number;
@@ -1281,6 +1293,10 @@ export interface ForegroundRunControl {
 	currentPath?: string;
 	turnCount?: number;
 	tokens?: number;
+	inputTokens?: number;
+	outputTokens?: number;
+	model?: string;
+	thinking?: string;
 	toolCount?: number;
 	/** Independently tracked children for foreground parallel work and fleet inspection. */
 	activeChildren?: Map<number, ForegroundChildControl>;

package/src/shared/utils.ts

@@ -412,6 +412,49 @@ export function compactForegroundDetails(details: Details): Details {
 	};
 }
 
+/**
+ * Streaming counterparts to compactForegroundResult / compactCompletedProgress.
+ *
+ * The completed-compaction helpers above bail out while a child is still
+ * `running`, so a long or deeply nested fan-out streams full, unbounded progress on
+ * every tick. Pi serializes each streamed `tool_execution_update` as a single
+ * child-stdout line, which the parent reads under `MAX_CHILD_PENDING_LINE_BYTES`;
+ * an unbounded running snapshot can cross that cap and kill the child with
+ * `protocol_output_limit`.
+ *
+ * These bound the STREAMED snapshot only. The final returned result keeps the full
+ * live progress and message transcript, and every live-display consumer already
+ * reads just the last few entries (`recentTools.slice(-3)`, `recentOutput.slice(-5)`).
+ */
+export const MAX_STREAMED_RECENT_TOOLS = 32;
+export const MAX_STREAMED_TOOL_CALLS = 64;
+export const MAX_STREAMED_OUTPUT_LINE_CHARS = 2000;
+
+/** Keep only the most recent tool-history entries in a streamed snapshot. */
+export function boundStreamedRecentTools(recentTools: AgentProgress["recentTools"]): AgentProgress["recentTools"] {
+	return recentTools.slice(-MAX_STREAMED_RECENT_TOOLS).map((tool) => ({ ...tool }));
+}
+
+/** Cap per-line length of recent output so one long line can't inflate a snapshot. */
+export function boundStreamedRecentOutput(recentOutput: string[]): string[] {
+	return recentOutput.map((line) =>
+		line.length > MAX_STREAMED_OUTPUT_LINE_CHARS
+			? `${line.slice(0, MAX_STREAMED_OUTPUT_LINE_CHARS)}… [truncated]`
+			: line,
+	);
+}
+
+/**
+ * Compact tool-call summaries for a streamed snapshot, standing in for the
+ * unbounded `messages` transcript. Prefers an existing `toolCalls` summary, else
+ * derives one from `messages`; bounded to the most recent calls.
+ */
+export function boundStreamedToolCalls(result: Pick<SingleResult, "toolCalls" | "messages">): ToolCallSummary[] | undefined {
+	const summaries = result.toolCalls?.length ? result.toolCalls : extractToolCallSummaries(result.messages);
+	if (!summaries.length) return undefined;
+	return summaries.slice(-MAX_STREAMED_TOOL_CALLS).map((summary) => ({ ...summary }));
+}
+
 export function hasEmptyTerminalAssistantResponse(messages: Message[]): boolean {
 	const lastAssistant = messages.findLast((message) => message.role === "assistant");
 	return lastAssistant?.role === "assistant"

package/src/slash/slash-commands.ts

@@ -336,12 +336,12 @@ class SubagentsStopSelector implements Component {
 			}
 			return;
 		}
-		if (matchesKey(data, "up")) {
+		if (matchesKey(data, "up") || matchesKey(data, "k")) {
 			this.selected = Math.max(0, this.selected - 1);
 			this.tui.requestRender();
 			return;
 		}
-		if (matchesKey(data, "down")) {
+		if (matchesKey(data, "down") || matchesKey(data, "j")) {
 			this.selected = Math.min(this.targets.length - 1, this.selected + 1);
 			this.tui.requestRender();
 			return;
@@ -375,7 +375,7 @@ class SubagentsStopSelector implements Component {
 			if (target.kind === "async") lines.push(this.theme.fg("dim", "Stop ends this run; use interrupt for a resumable pause."));
 			lines.push(this.theme.fg("dim", "Enter/Y confirms · N returns · Esc cancels"));
 		} else {
-			lines.push(this.theme.fg("dim", "↑/↓ select · Enter confirm · Esc cancel"));
+			lines.push(this.theme.fg("dim", "↑↓/jk select · Enter confirm · Esc cancel"));
 		}
 		return lines;
 	}

package/src/tui/fleet-status.ts

@@ -1,5 +1,5 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Editor, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { type EditorComponent, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { AsyncJobStep, FleetViewPlacement, SubagentState } from "../shared/types.ts";
 
 export const FLEET_STATUS_WIDGET_KEY = "subagent-fleet-status";
@@ -252,12 +252,12 @@ export class SubagentFleetStatus {
 
 		const roster = this.rosterKeys();
 		const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
-		if (matchesKey(data, "down")) {
+		if (matchesKey(data, "down") || matchesKey(data, "j")) {
 			this.selectedKey = roster[Math.min(roster.length - 1, selectedIndex + 1)] ?? "main";
 			this.refresh();
 			return { consume: true };
 		}
-		if (matchesKey(data, "up")) {
+		if (matchesKey(data, "up") || matchesKey(data, "k")) {
 			if (selectedIndex === 0) {
 				this.deactivate();
 				return { consume: true };
@@ -297,7 +297,7 @@ export class SubagentFleetStatus {
 		const roster = this.rosterKeys();
 		const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
 		const hint = this.active
-			? "↑↓ select · enter inspect · esc back"
+			? "↑↓/jk select · enter inspect · esc back"
 			: "esc to interrupt · ← for agents · ↓ to manage";
 		const lines = [truncateToWidth(`  ${theme.fg("dim", hint)}`, width), ""];
 		lines.push(truncateToWidth(`  ${this.bullet(0, selectedIndex, theme)} main`, width));
@@ -341,9 +341,16 @@ export class SubagentFleetStatus {
 	}
 
 	private editorHasFocus(): boolean {
-		// pi-tui exposes focus mutation but no focus getter; fail closed if this compatibility seam disappears.
+		// pi-tui exposes focus mutation but no focus getter, so inspect the focused
+		// component structurally. instanceof is unreliable across jiti module boundaries.
 		const focused = (this.tui as unknown as { focusedComponent?: unknown } | undefined)?.focusedComponent;
-		return focused instanceof Editor;
+		if (!focused || typeof focused !== "object") return false;
+		const candidate = focused as Partial<EditorComponent>;
+		return typeof candidate.render === "function"
+			&& typeof candidate.invalidate === "function"
+			&& typeof candidate.handleInput === "function"
+			&& typeof candidate.getText === "function"
+			&& typeof candidate.setText === "function";
 	}
 
 	private getRenderKey(): string {