@narumitw/pi-subagents 0.49.3 → 0.52.0

package/src/in-process-transport.ts

@@ -9,12 +9,29 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { type AgentConfig, discoverAgents, type SubagentThinkingLevel } from "./agents.js";
 import { redactPrivateText } from "./context.js";
+import { appendDelegationContract } from "./delegation-contract.js";
 import { resolveDefaultSubagentTimeoutMs } from "./execution.js";
 import { DEFAULT_MAX_CONTEXT_BYTES, DEFAULT_MAX_OUTPUT_BYTES, truncateUtf8 } from "./limits.js";
-import { assertPiPromptSourcesAreReadableFiles } from "./prompt-source-safety.js";
+import { resolvePiPromptResources } from "./prompt-resources.js";
 import type { AgentTurn, ManagedAgent, TurnOutcome } from "./registry.js";
+import { appendResultInstruction } from "./result-contract.js";
+import { safeTerminalLine } from "./safe-text.js";
 import { readSubagentSettings } from "./settings.js";
+import {
+	formatTimeoutCheckpoint,
+	formatTurnTerminationMessage,
+	journalMessages,
+	TimeoutProgressJournal,
+	TURN_TERMINATION_VERSION,
+	type TurnTerminationReport,
+} from "./timeout-checkpoint.js";
+import {
+	buildTimeoutFinalizationPrompt,
+	resolveTimeoutFinalizationMs,
+} from "./timeout-finalization.js";
 import type { SubagentTransport } from "./transport.js";
+import type { TransportProgressCallback, TransportTelemetry } from "./transport-types.js";
+import { TurnBudgetMonitor, type TurnBudgetStop, type TurnLimits } from "./turn-budget.js";
 
 const BUILT_IN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
 const DEFAULT_ABORT_GRACE_MS = 5_000;
@@ -57,6 +74,9 @@ export interface ParentRuntimeSnapshot {
 export interface ChildSession {
 	readonly sessionId: string;
 	readonly messages: readonly unknown[];
+	readonly provider?: string;
+	readonly model?: string;
+	readonly thinkingLevel?: SubagentThinkingLevel;
 	prompt(text: string): Promise<void>;
 	subscribe(listener: (event: unknown) => void): () => void;
 	abort(): Promise<void>;
@@ -83,6 +103,7 @@ export interface InProcessTransportOptions {
 	discoverAgent?: (agent: ManagedAgent) => AgentConfig | undefined;
 	defaultTimeoutMs?: number;
 	abortGraceMs?: number;
+	timeoutFinalizationMs?: number;
 }
 
 interface ChildSessionRecord {
@@ -96,6 +117,7 @@ type PromptSettlement =
 	| { kind: "completed" }
 	| { kind: "failed"; error: unknown }
 	| { kind: "timeout" }
+	| { kind: "limit"; stop: TurnBudgetStop }
 	| { kind: "aborted" };
 
 export class InProcessTransport implements SubagentTransport {
@@ -118,37 +140,101 @@ export class InProcessTransport implements SubagentTransport {
 		this.abortGraceMs = options.abortGraceMs ?? DEFAULT_ABORT_GRACE_MS;
 	}
 
-	async runTurn(agent: ManagedAgent, task: string, signal: AbortSignal): Promise<TurnOutcome> {
-		if (signal.aborted) return interruptedOutcome("");
+	async runTurn(
+		agent: ManagedAgent,
+		task: string,
+		signal: AbortSignal,
+		onProgress?: TransportProgressCallback,
+	): Promise<TurnOutcome> {
+		const startedAt = Date.now();
+		let telemetry: TransportTelemetry = {
+			transport: "in-process",
+			phase: "starting",
+			updatedAt: startedAt,
+			timing: { startedAt, transportStartedAt: startedAt },
+		};
+		const publish = (patch: Partial<TransportTelemetry>) => {
+			telemetry = {
+				...telemetry,
+				...patch,
+				timing: { ...telemetry.timing, ...patch.timing },
+				updatedAt: Date.now(),
+			};
+			onProgress?.({ ...telemetry, timing: { ...telemetry.timing } });
+		};
+		publish({});
+		if (signal.aborted) {
+			publish({ phase: "interrupted", failurePhase: "starting" });
+			return { ...interruptedOutcome(""), telemetry };
+		}
 		const agentConfig = this.discoverAgent(agent);
 		if (!agentConfig) {
-			return { output: "", exitCode: 1, error: `Unknown subagent: ${agent.agent}` };
+			publish({ phase: "failed", failurePhase: "starting" });
+			return {
+				output: "",
+				exitCode: 1,
+				error: `Unknown subagent: ${agent.agent}`,
+				telemetry,
+			};
 		}
 		let tools: string[] | undefined;
 		try {
-			tools = validateInProcessTools(agentConfig.tools);
+			tools = validateInProcessTools(agent.executionPlan?.effectiveTools ?? agentConfig.tools);
 		} catch (error) {
-			return { output: "", exitCode: 1, error: errorMessage(error) };
+			publish({ phase: "failed", failurePhase: "starting" });
+			return { output: "", exitCode: 1, error: errorMessage(error), telemetry };
 		}
 		let record: ChildSessionRecord;
 		try {
 			record = await this.getOrCreate(agent, agentConfig, tools);
 		} catch (error) {
-			return { output: "", exitCode: 1, error: errorMessage(error) };
+			publish({ phase: "failed", failurePhase: "starting" });
+			return { output: "", exitCode: 1, error: errorMessage(error), telemetry };
+		}
+		publish({
+			phase: "ready",
+			provider: record.session.provider,
+			model: record.session.model,
+			thinkingLevel: record.session.thinkingLevel,
+			timing: { readyAt: Date.now() },
+		});
+		if (signal.aborted) {
+			await this.releaseById(agent.id).catch(() => undefined);
+			publish({ phase: "interrupted", failurePhase: "ready" });
+			return { ...interruptedOutcome(""), telemetry };
 		}
-		if (signal.aborted) return interruptedOutcome("");
 		const prompt = buildCurrentTurnPrompt(agent, task);
-		const timeoutMs = agentConfig.timeoutMs ?? this.defaultTimeoutMs;
+		const timeoutMs =
+			agent.currentTimeoutMs ?? agent.timeoutMs ?? agentConfig.timeoutMs ?? this.defaultTimeoutMs;
 		const startingMessageCount = record.session.messages.length;
 		record.lastOutput = "";
-		const settlement = await this.runPrompt(record, prompt, signal, timeoutMs);
+		publish({ phase: "running", timing: { promptAcceptedAt: Date.now() } });
+		const settlement = await this.runPrompt(record, prompt, signal, timeoutMs, {
+			idleTimeoutMs: agent.currentIdleTimeoutMs ?? agent.idleTimeoutMs,
+			maxTurns: agent.currentMaxTurns ?? agent.maxTurns,
+			maxToolCalls: agent.currentMaxToolCalls ?? agent.maxToolCalls,
+		});
 		const final = latestAssistant(record.session.messages.slice(startingMessageCount));
 		const output = truncateUtf8(final.output || record.lastOutput, DEFAULT_MAX_OUTPUT_BYTES);
 		const truncated = output.truncated || agent.contextTruncated;
 		const policy = inProcessPolicy(agentConfig, agent);
+		const settledAt = Date.now();
+		if (signal.aborted && (settlement.kind === "timeout" || settlement.kind === "limit")) {
+			publish({ phase: "interrupted", failurePhase: "running", timing: { settledAt } });
+			return {
+				...interruptedOutcome(output.text),
+				truncated,
+				policy,
+				telemetry,
+			};
+		}
 
 		switch (settlement.kind) {
 			case "completed":
+				publish({
+					phase: final.stopReason === "error" ? "failed" : "settled",
+					timing: { settledAt },
+				});
 				if (final.stopReason === "error") {
 					return {
 						output: output.text,
@@ -156,13 +242,16 @@ export class InProcessTransport implements SubagentTransport {
 						truncated,
 						error: final.error || "In-process subagent returned an error",
 						policy,
+						telemetry,
 					};
 				}
 				if (final.stopReason === "aborted") {
+					publish({ phase: "interrupted", failurePhase: "running" });
 					return {
 						...interruptedOutcome(output.text),
 						truncated,
 						policy,
+						telemetry,
 					};
 				}
 				return {
@@ -170,28 +259,104 @@ export class InProcessTransport implements SubagentTransport {
 					exitCode: 0,
 					truncated,
 					policy,
+					telemetry,
 				};
 			case "failed":
+				publish({ phase: "failed", failurePhase: "running", timing: { settledAt } });
 				return {
 					output: output.text,
 					exitCode: 1,
 					truncated,
 					error: errorMessage(settlement.error),
 					policy,
+					telemetry,
 				};
 			case "timeout":
+			case "limit": {
+				const stop =
+					settlement.kind === "limit"
+						? settlement.stop
+						: ({ reason: "work_timeout", limit: timeoutMs } as const);
+				const journal = new TimeoutProgressJournal();
+				journalMessages(journal, record.session.messages.slice(startingMessageCount));
+				const termination: TurnTerminationReport = {
+					version: TURN_TERMINATION_VERSION,
+					reason: stop.reason,
+					limit: stop.limit,
+					checkpoint: journal.checkpoint(task, output.text),
+					finalization: { attempted: false, status: "skipped", durationMs: 0 },
+				};
+				let finalizedOutput = output.text || formatTimeoutCheckpoint(termination.checkpoint);
+				let finalizationError: string | undefined;
+				if (!signal.aborted && this.sessions.get(agent.id) === record) {
+					publish({ phase: "finalizing", failurePhase: "running" });
+					const summaryStart = record.session.messages.length;
+					const finalizationStartedAt = Date.now();
+					record.lastOutput = "";
+					const summarySettlement = await this.runPrompt(
+						record,
+						buildTimeoutFinalizationPrompt({
+							task,
+							partialOutput: output.text,
+							checkpoint: termination.checkpoint,
+							terminationReason: stop.reason,
+							resultFormat: agent.resultFormat,
+						}),
+						signal,
+						resolveTimeoutFinalizationMs(timeoutMs, this.options.timeoutFinalizationMs),
+					);
+					const summary = latestAssistant(record.session.messages.slice(summaryStart));
+					const boundedSummary = truncateUtf8(
+						summary.output || record.lastOutput,
+						DEFAULT_MAX_OUTPUT_BYTES,
+					);
+					if (
+						summarySettlement.kind === "completed" &&
+						summary.stopReason !== "error" &&
+						boundedSummary.text.trim()
+					) {
+						finalizedOutput = boundedSummary.text;
+						termination.finalization = {
+							attempted: true,
+							status: "completed",
+							durationMs: Date.now() - finalizationStartedAt,
+						};
+					} else {
+						finalizationError =
+							summarySettlement.kind === "failed"
+								? errorMessage(summarySettlement.error)
+								: `timeout summary ${summarySettlement.kind}`;
+						termination.finalization = {
+							attempted: true,
+							status: summarySettlement.kind === "timeout" ? "timed_out" : "failed",
+							durationMs: Date.now() - finalizationStartedAt,
+							error: finalizationError,
+						};
+					}
+				}
+				publish({ phase: "failed", failurePhase: "running", timing: { settledAt: Date.now() } });
 				return {
-					output: output.text,
+					output: finalizedOutput,
 					exitCode: 124,
 					truncated,
-					error: `In-process subagent timed out after ${timeoutMs}ms`,
+					error: [
+						formatTurnTerminationMessage(stop.reason, stop.limit, "In-process subagent"),
+						finalizationError,
+					]
+						.filter(Boolean)
+						.join("; "),
 					policy,
+					termination,
+					telemetry,
 				};
+			}
 			case "aborted":
+				publish({ phase: "interrupted", failurePhase: "running", timing: { settledAt } });
 				return {
 					...interruptedOutcome(output.text),
 					truncated,
 					policy,
+					telemetry,
 				};
 		}
 	}
@@ -289,11 +454,41 @@ export class InProcessTransport implements SubagentTransport {
 		prompt: string,
 		signal: AbortSignal,
 		timeoutMs: number,
+		limits: TurnLimits = {},
 	): Promise<PromptSettlement> {
+		if (signal.aborted) return { kind: "aborted" };
 		let timeout: NodeJS.Timeout | undefined;
 		let abortHandler: (() => void) | undefined;
-		const promptSettlement: Promise<PromptSettlement> = record.session
-			.prompt(prompt)
+		let resolveLimit!: (settlement: PromptSettlement) => void;
+		const limitSettlement = new Promise<PromptSettlement>((resolve) => {
+			resolveLimit = resolve;
+		});
+		const monitor = new TurnBudgetMonitor({
+			...limits,
+			onExceeded: (stop) => resolveLimit({ kind: "limit", stop }),
+		});
+		const unsubscribeBudget = record.session.subscribe((event) => {
+			const type = childEventType(event);
+			if (type === "tool_execution_end") monitor.recordActivity();
+			if (type !== "message_end") return;
+			const message = eventMessage(event);
+			if (!message || typeof message !== "object" || Array.isArray(message)) return;
+			const value = message as Record<string, unknown>;
+			if (value.role === "toolResult") {
+				monitor.recordActivity();
+				return;
+			}
+			if (value.role !== "assistant") return;
+			monitor.recordToolCalls(assistantToolCallCount(value.content));
+			monitor.recordAssistantTurn(
+				typeof value.stopReason === "string" ? value.stopReason : undefined,
+			);
+		});
+		const promptSettlement: Promise<PromptSettlement> = Promise.resolve()
+			.then(() => {
+				if (signal.aborted) throw new Error("In-process subagent prompt aborted before start");
+				return record.session.prompt(prompt);
+			})
 			.then(() => ({ kind: "completed" as const }))
 			.catch((error: unknown) => ({ kind: "failed" as const, error }));
 		const timeoutSettlement = new Promise<PromptSettlement>((resolve) => {
@@ -302,13 +497,31 @@ export class InProcessTransport implements SubagentTransport {
 		const abortSettlement = new Promise<PromptSettlement>((resolve) => {
 			abortHandler = () => resolve({ kind: "aborted" });
 			signal.addEventListener("abort", abortHandler, { once: true });
+			if (signal.aborted) abortHandler();
 		});
-		const settlement = await Promise.race([promptSettlement, timeoutSettlement, abortSettlement]);
+		const settlement = await Promise.race([
+			promptSettlement,
+			timeoutSettlement,
+			abortSettlement,
+			limitSettlement,
+		]);
 		if (timeout) clearTimeout(timeout);
 		if (abortHandler) signal.removeEventListener("abort", abortHandler);
-		if (settlement.kind === "timeout" || settlement.kind === "aborted") {
-			await settleWithin(record.session.abort(), this.abortGraceMs);
-			const settledAfterAbort = await completesWithin(promptSettlement, this.abortGraceMs);
+		try {
+			unsubscribeBudget();
+		} catch {
+			// The owning record's unsubscribe/dispose path remains authoritative.
+		}
+		monitor.dispose();
+		if (
+			settlement.kind === "timeout" ||
+			settlement.kind === "limit" ||
+			settlement.kind === "aborted"
+		) {
+			const [, settledAfterAbort] = await Promise.all([
+				settleWithin(record.session.abort(), this.abortGraceMs),
+				completesWithin(promptSettlement, this.abortGraceMs),
+			]);
 			if (!settledAfterAbort) this.discardRecord(record);
 		}
 		return settlement;
@@ -331,7 +544,7 @@ export function validateInProcessTools(tools: string[] | undefined): string[] |
 	const unsupported = unique.filter((tool) => !BUILT_IN_TOOL_NAMES.has(tool));
 	if (unsupported.length > 0) {
 		throw new Error(
-			`In-process subagents cannot load extension/custom tools: ${unsupported.join(", ")}. Use stateful.transport "subprocess" for this agent.`,
+			`In-process subagents cannot load extension/custom tools: ${unsupported.map((tool) => safeTerminalLine(tool, 256)).join(", ")}. Use stateful.transport "subprocess" for this agent.`,
 		);
 	}
 	return unique;
@@ -392,6 +605,15 @@ export async function createSdkChildSession(
 		get messages() {
 			return session.messages;
 		},
+		get provider() {
+			return session.model?.provider;
+		},
+		get model() {
+			return session.model?.id;
+		},
+		get thinkingLevel() {
+			return session.thinkingLevel;
+		},
 		prompt: (text) => session.prompt(text),
 		subscribe: (listener) => session.subscribe((event) => listener(event)),
 		abort: () => session.abort(),
@@ -491,7 +713,7 @@ async function prepareInProcessServices(
 	agentSystemPrompt: string,
 	projectTrusted: boolean,
 ): Promise<{ services: AgentSessionServices; support: CoreSessionSupport }> {
-	assertPiPromptSourcesAreReadableFiles(cwd, agentDir, projectTrusted, ["SYSTEM.md"]);
+	const promptResources = await resolvePiPromptResources(cwd, projectTrusted, agentDir);
 	const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
 	const support = await loadCoreSessionSupport();
 	if (!support) throw unsupportedInProcessCoreError();
@@ -501,7 +723,10 @@ async function prepareInProcessServices(
 		settingsManager,
 		resourceLoaderOptions: {
 			noExtensions: true,
-			appendSystemPrompt: agentSystemPrompt.trim() ? [agentSystemPrompt] : [],
+			appendSystemPrompt: [
+				...promptResources.appendSystemPromptPaths,
+				...(agentSystemPrompt.trim() ? [agentSystemPrompt] : []),
+			],
 		},
 	});
 	return { services, support };
@@ -556,17 +781,19 @@ export function seedChildSessionManager(
 	}
 }
 
-function buildCurrentTurnPrompt(agent: ManagedAgent, task: string): string {
+export function buildCurrentTurnPrompt(agent: ManagedAgent, task: string): string {
 	const ids = new Set(agent.currentMailboxMessageIds ?? []);
 	const messages = agent.mailbox
 		.filter((message) => ids.has(message.id))
 		.slice(-20)
 		.map((message) => `From ${message.senderId}: ${redactPrivateText(message.content)}`)
 		.join("\n");
+	const base = messages
+		? `${redactPrivateText(task)}\n\nMailbox messages:\n${messages}`
+		: redactPrivateText(task);
+	const contracted = appendDelegationContract(base, agent.contract, DEFAULT_MAX_CONTEXT_BYTES);
 	return truncateUtf8(
-		messages
-			? `${redactPrivateText(task)}\n\nMailbox messages:\n${messages}`
-			: redactPrivateText(task),
+		appendResultInstruction(contracted.text, agent.resultFormat),
 		DEFAULT_MAX_CONTEXT_BYTES,
 	).text;
 }
@@ -590,6 +817,23 @@ function latestAssistant(messages: readonly unknown[]): {
 	return { output: "" };
 }
 
+function childEventType(event: unknown): string | undefined {
+	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
+	const type = (event as { type?: unknown }).type;
+	return typeof type === "string" ? type : undefined;
+}
+
+function assistantToolCallCount(content: unknown): number {
+	if (!Array.isArray(content)) return 0;
+	return content.filter(
+		(part) =>
+			part &&
+			typeof part === "object" &&
+			!Array.isArray(part) &&
+			(part as { type?: unknown }).type === "toolCall",
+	).length;
+}
+
 function eventMessage(event: unknown): unknown {
 	if (!event || typeof event !== "object") return undefined;
 	const candidate = event as { type?: string; message?: unknown };

package/src/inspect-render.ts

@@ -24,6 +24,7 @@ export function renderInspectCall(args: Partial<SubagentInspectParams>, theme: T
 	if (args.agentScope) metadata.push(`[${args.agentScope}]`);
 	if (args.agent) metadata.push(`agent:${safeLine(args.agent, "", 256)}`);
 	if (args.agentId) metadata.push(`id:${safeLine(args.agentId, "", 256)}`);
+	if (args.workflowId) metadata.push(`workflow:${safeLine(args.workflowId, "", 256)}`);
 	if (args.includeClosed) metadata.push("include closed");
 	return new Text(toolHeader(theme, "subagent_inspect", action, metadata), 0, 0);
 }
@@ -74,6 +75,23 @@ function renderAction(
 			if (!expanded) lines.push(expansionHint());
 			return lines.join("\n");
 		}
+		case "list_workflows":
+			return renderList(
+				"workflow",
+				recordList(details.workflows),
+				details,
+				expanded,
+				theme,
+				formatWorkflow,
+			);
+		case "get_workflow": {
+			const workflow = recordValue(details.workflow);
+			if (!workflow) return undefined;
+			return [
+				`${statusBadge(theme, "completed")} · workflow ${theme.fg("accent", safeLine(workflow.workflowId, "workflow", 256))}`,
+				formatWorkflow(workflow, theme, expanded),
+			].join("\n");
+		}
 		case "list_models":
 			return renderList(
 				"model",
@@ -84,6 +102,17 @@ function renderAction(
 				formatModel,
 				stringValue(details.source),
 			);
+		case "preview_context": {
+			const preview = recordValue(details.preview);
+			if (!preview) return undefined;
+			return [
+				`${statusBadge(theme, "completed")} · context ${theme.fg("accent", safeLine(preview.mode, "none", 128))}`,
+				theme.fg(
+					"dim",
+					`${numberValue(preview.turns)} turns · ${numberValue(preview.sourceCount)} sources · ${numberValue(preview.bytes)} bytes${preview.truncated === true ? " · truncated" : ""}`,
+				),
+			].join("\n");
+		}
 		case "status":
 			return renderStatus(details, expanded, theme);
 		case "diagnose":
@@ -146,17 +175,61 @@ function formatRun(run: Record<string, unknown>, theme: Theme, expanded: boolean
 	];
 	if (expanded) {
 		const thinking = stringValue(run.thinkingLevel);
+		const timeout = numberValue(run.currentTimeoutMs) || numberValue(run.timeoutMs);
+		const idleTimeout = numberValue(run.currentIdleTimeoutMs) || numberValue(run.idleTimeoutMs);
+		const maxTurns = numberValue(run.currentMaxTurns) || numberValue(run.maxTurns);
+		const maxToolCalls = numberValue(run.currentMaxToolCalls) || numberValue(run.maxToolCalls);
 		const task = safeBlock(run.currentTask, "", 2 * 1024).trim();
 		const error = safeBlock(run.error, "", 2 * 1024).trim();
 		lines.push(
-			`  ${theme.fg("dim", `${numberValue(run.historyCount)} history · ${thinking ? `thinking:${safeLine(thinking, "", 128)} · ` : ""}${numberValue(run.children)} children`)}`,
+			`  ${theme.fg("dim", `${numberValue(run.historyCount)} history · ${thinking ? `thinking:${safeLine(thinking, "", 128)} · ` : ""}${timeout ? `timeout:${timeout}ms · ` : ""}${idleTimeout ? `idle:${idleTimeout}ms · ` : ""}${maxTurns ? `turns:${maxTurns} · ` : ""}${maxToolCalls ? `tools:${maxToolCalls} · ` : ""}${numberValue(run.children)} children`)}`,
 		);
+		const context = recordValue(run.context);
+		const telemetry = recordValue(run.telemetry);
+		if (context) {
+			lines.push(
+				`  ${theme.fg("dim", `context: ${numberValue(context.turns)} turns · ${numberValue(context.sources)} sources · ${numberValue(context.bytes)} bytes${context.truncated === true ? " · truncated" : ""}`)}`,
+			);
+		}
+		if (telemetry) {
+			lines.push(
+				`  ${theme.fg("dim", `transport: ${safeLine(telemetry.transport, "unknown", 128)} · phase:${safeLine(telemetry.phase, "unknown", 128)}${stringValue(telemetry.protocol) ? ` · ${safeLine(telemetry.protocol, "", 128)}` : ""}`)}`,
+			);
+		}
 		if (task) lines.push(`  ${theme.fg("dim", `task: ${task}`)}`);
 		if (error) lines.push(`  ${theme.fg("error", `error: ${error}`)}`);
 	}
 	return lines.join("\n");
 }
 
+function formatWorkflow(
+	workflow: Record<string, unknown>,
+	theme: Theme,
+	expanded: boolean,
+): string {
+	const id = safeLine(workflow.workflowId, "workflow", 256);
+	const states = recordValue(workflow.states);
+	const stateText = states
+		? Object.entries(states)
+				.map(([state, count]) => `${safeLine(state, "unknown", 128)}:${numberValue(count)}`)
+				.join(" · ")
+		: "";
+	const lines = [
+		`${theme.fg("muted", "• ")}${theme.fg("accent", id)} ${theme.fg("muted", `${numberValue(workflow.itemCount)} items · generation:${numberValue(workflow.generation)}`)}`,
+	];
+	if (stateText) lines.push(`  ${theme.fg("dim", stateText)}`);
+	if (expanded) {
+		for (const item of recordList(workflow.items).slice(0, COLLAPSED_LIST_LIMIT)) {
+			lines.push(
+				`  ${theme.fg("muted", "- ")}${theme.fg("toolOutput", safeLine(item.id, "task", 256))} ${theme.fg("dim", safeLine(item.state, "unknown", 128))}`,
+			);
+		}
+		const omitted = numberValue(workflow.omittedItems);
+		if (omitted > 0) lines.push(theme.fg("muted", `  … ${omitted} tasks omitted`));
+	}
+	return lines.join("\n");
+}
+
 function formatModel(model: Record<string, unknown>, theme: Theme, expanded: boolean): string {
 	const identity = `${safeLine(model.provider, "provider", 256)}/${safeLine(model.id, "model", 256)}`;
 	const current = booleanValue(model.current) ? theme.fg("success", " · current") : "";
@@ -181,11 +254,15 @@ function renderStatus(
 	const status = recordValue(details.status);
 	const stateful = recordValue(status?.stateful);
 	if (!status || !stateful) return undefined;
+	const currentLimits = recordValue(status.statefulLimits) ?? recordValue(stateful.limits);
 	const lines = [
 		`${statusBadge(theme, "completed")} · runtime status`,
 		`${theme.fg("muted", "workflow: ")}${theme.fg("accent", safeLine(status.workflow, "unknown", 128))} · ${numberValue(stateful.activeAgents)} active · ${numberValue(stateful.retainedAgents)} retained`,
 		`${theme.fg("muted", "stateful: ")}${stateful.initialized === true ? "initialized" : "not initialized"} · resources: ${safeLine(status.consultResources, "unknown", 128)}`,
 	];
+	if (currentLimits) {
+		lines.push(`${theme.fg("muted", "limits: ")}${formatDetachedLimits(currentLimits)}`);
+	}
 	if (expanded) {
 		const delivery = stringValue(stateful.completionDelivery);
 		const transport = stringValue(stateful.transport);
@@ -202,10 +279,33 @@ function renderStatus(
 				),
 			);
 		}
+		const configured = recordValue(status.configuredStatefulLimits);
+		const sources = recordValue(status.configuredStatefulLimitSources);
+		if (configured) {
+			lines.push(theme.fg("dim", `configured: ${formatDetachedLimits(configured, sources)}`));
+		}
 	} else lines.push(expansionHint());
 	return lines.join("\n");
 }
 
+function formatDetachedLimits(
+	limits: Record<string, unknown>,
+	sources?: Record<string, unknown>,
+): string {
+	return [
+		["agents", "maxAgents"],
+		["active", "maxActiveTurns"],
+		["children", "maxChildrenPerAgent"],
+		["depth", "maxDepth"],
+		["stored", "maxStoredAgents"],
+	]
+		.map(([label, field]) => {
+			const source = stringValue(sources?.[field]);
+			return `${label}:${numberValue(limits[field])}${source ? ` (${safeLine(source, "", 64)})` : ""}`;
+		})
+		.join(" · ");
+}
+
 function renderDiagnose(details: Record<string, unknown>, expanded: boolean, theme: Theme): string {
 	const checks = recordList(details.checks);
 	const hasFail = checks.some((check) => check.status === "fail");