@narumitw/pi-subagents 0.42.0 → 0.43.1

package/src/config-ui.ts

@@ -1,23 +1,33 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
-import { type CompletionDelivery, discoverAgents } from "./agents.js";
+import {
+	type CompletionDelivery,
+	type ConsultationCwdPolicy,
+	type ConsultResourcePolicy,
+	type DelegationCwdPolicy,
+	discoverAgents,
+} from "./agents.js";
 import type { ManagedAgent } from "./registry.js";
 import {
 	type DelegationWorkflow,
 	hasOwn,
 	inspectCompletionDeliverySettings,
+	inspectConsultResourceSettings,
+	inspectCwdPolicySettings,
 	inspectDelegationWorkflowSettings,
 	readSubagentSettings,
 	sameToolSet,
 	uniqueToolNames,
 	updateAgentToolsSetting,
 	updateCompletionDeliverySetting,
+	updateConsultResourceSetting,
+	updateCwdPolicySetting,
 	updateDelegationWorkflowSetting,
 } from "./settings.js";
 import { formatStatefulAgentLine, type StatefulSubagentRuntimeStatus } from "./stateful.js";
 
 const SUBCOMMANDS = [
-	{ value: "settings", label: "settings", description: "Configure completion behavior" },
+	{ value: "settings", label: "settings", description: "Configure subagent user settings" },
 	{ value: "status", label: "status", description: "Show effective subagent settings" },
 	{ value: "help", label: "help", description: "Show subagent settings help" },
 ];
@@ -26,7 +36,13 @@ const TOOL_VIEWPORT_SIZE = 10;
 export interface SubagentSettingsRuntime {
 	getBlockingEnabled(): boolean;
 	getCompletionDelivery(): CompletionDelivery;
+	getConsultResourcePolicy(): ConsultResourcePolicy;
+	getConsultationCwdPolicy(): ConsultationCwdPolicy;
+	getDelegationCwdPolicy(): DelegationCwdPolicy;
 	setCompletionDelivery(value: CompletionDelivery): void;
+	setConsultResourcePolicy(value: ConsultResourcePolicy): void;
+	setConsultationCwdPolicy(value: ConsultationCwdPolicy): void;
+	setDelegationCwdPolicy(value: DelegationCwdPolicy): void;
 	getRuntimeStatus(): StatefulSubagentRuntimeStatus;
 	listAgents(includeClosed?: boolean): ManagedAgent[];
 	clearAgents(): Promise<number>;
@@ -86,7 +102,7 @@ function registerSubagentPrimaryCommand(
 					showSubagentStatus(ctx, runtime);
 					return;
 				case "help":
-					showSubagentHelp(ctx);
+					showSubagentHelp(ctx, runtime);
 					return;
 				default:
 					if (ctx.mode === "tui" || ctx.hasUI) {
@@ -114,7 +130,7 @@ async function showSubagentManager(
 		| "main"
 		| "workflow"
 		| "agents"
-		| "completion"
+		| "settings"
 		| "advanced"
 		| "status"
 		| "help"
@@ -124,6 +140,9 @@ async function showSubagentManager(
 		| "set-workflow"
 		| "clear-agents"
 		| "set-completion"
+		| "set-consult-resources"
+		| "set-consultation-cwd"
+		| "set-delegation-cwd"
 		| "load-agent-picker"
 		| "pick-agent"
 		| "toggle-tool"
@@ -154,10 +173,10 @@ async function showSubagentManager(
 							to: "agents",
 						},
 						{
-							id: "completion",
-							label: "Completion behavior",
-							description: "Choose whether async completion waits or resumes automatically",
-							to: "completion",
+							id: "settings",
+							label: "Settings",
+							description: "Configure targets, trusted resources, and async completion",
+							to: "settings",
 						},
 						{
 							id: "advanced",
@@ -236,7 +255,7 @@ async function showSubagentManager(
 					hint: "back",
 				};
 			},
-			completion: () => completionSettingsScreen(),
+			settings: () => subagentSettingsScreen(runtime),
 			advanced: () => ({
 				kind: "actions",
 				title: "Advanced Subagent Settings",
@@ -266,7 +285,7 @@ async function showSubagentManager(
 			help: () => ({
 				kind: "detail",
 				title: "Subagents help",
-				lines: helpLines(),
+				lines: helpLines(runtime),
 				hint: "back",
 			}),
 			"agent-picker": () => {
@@ -388,6 +407,10 @@ async function showSubagentManager(
 				return { kind: "stay" };
 			},
 			"set-completion": async ({ value }) => applyCompletionSetting(value, ctx, runtime),
+			"set-consult-resources": async ({ value }) =>
+				applyConsultResourceSetting(value, ctx, runtime),
+			"set-consultation-cwd": async ({ value }) => applyConsultationCwdSetting(value, ctx, runtime),
+			"set-delegation-cwd": async ({ value }) => applyDelegationCwdSetting(value, ctx, runtime),
 			"load-agent-picker": async () => {
 				availableAgents = discoverAgents(ctx.cwd, "user", readSubagentSettings() ?? {}).agents;
 				if (availableAgents.length === 0) {
@@ -468,7 +491,7 @@ async function showSubagentSettings(
 	runtime: SubagentSettingsRuntime,
 	owner: MenuOwner,
 ) {
-	const snapshot = inspectCompletionDeliverySettings();
+	const snapshot = inspectConsultResourceSettings();
 	if (ctx.mode !== "tui") {
 		if (ctx.hasUI) {
 			ctx.ui.notify(
@@ -479,11 +502,20 @@ async function showSubagentSettings(
 		return;
 	}
 	const generation = owner.generation;
-	const menu = defineMenu<undefined, "completion", "set-completion", ExtensionCommandContext>({
-		start: "completion",
-		screens: { completion: () => completionSettingsScreen() },
+	type SettingsAction =
+		| "set-completion"
+		| "set-consult-resources"
+		| "set-consultation-cwd"
+		| "set-delegation-cwd";
+	const menu = defineMenu<undefined, "settings", SettingsAction, ExtensionCommandContext>({
+		start: "settings",
+		screens: { settings: () => subagentSettingsScreen(runtime) },
 		actions: {
 			"set-completion": async ({ value }) => applyCompletionSetting(value, ctx, runtime),
+			"set-consult-resources": async ({ value }) =>
+				applyConsultResourceSetting(value, ctx, runtime),
+			"set-consultation-cwd": async ({ value }) => applyConsultationCwdSetting(value, ctx, runtime),
+			"set-delegation-cwd": async ({ value }) => applyDelegationCwdSetting(value, ctx, runtime),
 		},
 	});
 	await runMenu(ctx, menu, {
@@ -493,25 +525,61 @@ async function showSubagentSettings(
 	});
 }
 
-function completionSettingsScreen() {
-	const snapshot = inspectCompletionDeliverySettings();
+function subagentSettingsScreen(runtime: SubagentSettingsRuntime) {
+	const completion = inspectCompletionDeliverySettings();
+	const consult = inspectConsultResourceSettings();
+	const cwdPolicy = inspectCwdPolicySettings();
+	const error = completion.error ?? consult.error ?? cwdPolicy.error;
 	return {
 		kind: "settings" as const,
-		title: snapshot.error ? "Subagent User Settings · Read only" : "Subagent User Settings",
+		title: error ? "Subagent User Settings · Read only" : "Subagent User Settings",
 		lines: [
 			"Applies now and to future sessions",
-			safeTerminalText(snapshot.path),
-			...(snapshot.error ? [`Settings cannot be edited: ${safeTerminalText(snapshot.error)}`] : []),
+			"Target and trust settings control startup resources, not filesystem access or sandboxing.",
+			"Manage folder trust with Pi /trust; restart Pi after changing it.",
+			safeTerminalText(consult.path),
+			...(error ? [`Settings cannot be edited: ${safeTerminalText(error)}`] : []),
 		],
-		items: snapshot.error
+		items: error
 			? []
 			: [
+					{
+						id: "consultationCwd",
+						label: "Read-only consultation target",
+						description:
+							"Untrusted external targets inherit no target/project resources; agent and package read-only prompts remain.",
+						currentValue: consultationCwdLabel(runtime.getConsultationCwdPolicy()),
+						values: ["Anywhere · untrusted targets inherit nothing", "Current workspace only"],
+						action: "set-consultation-cwd" as const,
+					},
+					{
+						id: "delegationCwd",
+						label: "General delegation target",
+						description:
+							"Controls starting directories, not absolute paths, shell commands, or OS permissions.",
+						currentValue: delegationCwdLabel(runtime.getDelegationCwdPolicy()),
+						values: [
+							"Current or saved-trusted folders",
+							"Current workspace only",
+							"Anywhere · normal Pi permissions",
+						],
+						action: "set-delegation-cwd" as const,
+					},
+					{
+						id: "consultResources",
+						label: "Consultation resources for trusted targets",
+						description:
+							"Choose which trusted context, system, skill, and prompt resources a consultation inherits.",
+						currentValue: consultResourceLabel(runtime.getConsultResourcePolicy()),
+						values: ["Project context only", "No inherited resources", "All trusted resources"],
+						action: "set-consult-resources" as const,
+					},
 					{
 						id: "completionDelivery",
 						label: "When async work finishes",
 						description:
 							"Wait for your next turn, or request one synthesis turn after the root settles.",
-						currentValue: completionLabel(snapshot.value),
+						currentValue: completionLabel(runtime.getCompletionDelivery()),
 						values: ["Wait until my next turn", "Resume automatically when finished"],
 						action: "set-completion" as const,
 					},
@@ -539,6 +607,74 @@ function applyCompletionSetting(
 	}
 }
 
+function applyConsultResourceSetting(
+	value: string | undefined,
+	ctx: ExtensionCommandContext,
+	runtime: SubagentSettingsRuntime,
+) {
+	const previous = runtime.getConsultResourcePolicy();
+	const next: ConsultResourcePolicy =
+		value === "No inherited resources"
+			? "none"
+			: value === "All trusted resources"
+				? "all"
+				: "project-context";
+	if (next === previous) return { kind: "stay" as const };
+	try {
+		updateConsultResourceSetting(next);
+		runtime.setConsultResourcePolicy(next);
+		ctx.ui.notify(`Saved and applied: ${consultResourceLabel(next)}.`, "info");
+		return { kind: "stay" as const };
+	} catch (error) {
+		ctx.ui.notify(`Subagent settings were not saved: ${formatError(error)}`, "error");
+		return { kind: "rejected" as const };
+	}
+}
+
+function applyConsultationCwdSetting(
+	value: string | undefined,
+	ctx: ExtensionCommandContext,
+	runtime: SubagentSettingsRuntime,
+) {
+	const previous = runtime.getConsultationCwdPolicy();
+	const next: ConsultationCwdPolicy =
+		value === "Current workspace only" ? "current-workspace" : "anywhere";
+	if (next === previous) return { kind: "stay" as const };
+	try {
+		updateCwdPolicySetting("consultation", next);
+		runtime.setConsultationCwdPolicy(next);
+		ctx.ui.notify(`Saved and applied: ${consultationCwdLabel(next)}.`, "info");
+		return { kind: "stay" as const };
+	} catch (error) {
+		ctx.ui.notify(`Subagent settings were not saved: ${formatError(error)}`, "error");
+		return { kind: "rejected" as const };
+	}
+}
+
+function applyDelegationCwdSetting(
+	value: string | undefined,
+	ctx: ExtensionCommandContext,
+	runtime: SubagentSettingsRuntime,
+) {
+	const previous = runtime.getDelegationCwdPolicy();
+	const next: DelegationCwdPolicy =
+		value === "Current workspace only"
+			? "current-workspace"
+			: value === "Anywhere · normal Pi permissions"
+				? "anywhere"
+				: "trusted-targets";
+	if (next === previous) return { kind: "stay" as const };
+	try {
+		updateCwdPolicySetting("delegation", next);
+		runtime.setDelegationCwdPolicy(next);
+		ctx.ui.notify(`Saved and applied: ${delegationCwdLabel(next)}.`, "info");
+		return { kind: "stay" as const };
+	} catch (error) {
+		ctx.ui.notify(`Subagent settings were not saved: ${formatError(error)}`, "error");
+		return { kind: "rejected" as const };
+	}
+}
+
 function blockReloadWithRetainedAgents(
 	ctx: ExtensionCommandContext,
 	runtime: SubagentSettingsRuntime,
@@ -583,9 +719,9 @@ function showSubagentStatus(ctx: ExtensionCommandContext, runtime: SubagentSetti
 	);
 }
 
-function showSubagentHelp(ctx: ExtensionCommandContext) {
+function showSubagentHelp(ctx: ExtensionCommandContext, runtime: SubagentSettingsRuntime) {
 	if (ctx.mode !== "tui" && !ctx.hasUI) return;
-	ctx.ui.notify(helpLines().join("\n"), "info");
+	ctx.ui.notify(helpLines(runtime).join("\n"), "info");
 }
 
 function statusLines(runtime: SubagentSettingsRuntime): string[] {
@@ -593,13 +729,20 @@ function statusLines(runtime: SubagentSettingsRuntime): string[] {
 	return formatStatus(runtime.getRuntimeStatus(), snapshot, runtime).split("\n");
 }
 
-function helpLines(): string[] {
+function helpLines(runtime: SubagentSettingsRuntime): string[] {
 	const snapshot = inspectCompletionDeliverySettings();
+	const cwdPolicy = inspectCwdPolicySettings();
 	return [
 		"/subagents — choose delegation workflow, manage current agents, and configure agent tools",
-		"/subagents settings — configure async completion behavior",
+		"/subagents settings — configure target locations, trusted resources, and async completion",
 		"/subagents status — show current-session and user-setting values",
 		"/subagents help — show this help",
+		"Target policies control startup directories and resources, not filesystem access or sandboxing.",
+		"Manage saved folder trust with Pi /trust and restart Pi after changing it.",
+		`Runtime consultation target: ${consultationCwdLabel(runtime.getConsultationCwdPolicy())}`,
+		`Configured consultation target: ${consultationCwdLabel(cwdPolicy.consultation.value)} (${cwdPolicy.consultation.source})`,
+		`Runtime delegation target: ${delegationCwdLabel(runtime.getDelegationCwdPolicy())}`,
+		`Configured delegation target: ${delegationCwdLabel(cwdPolicy.delegation.value)} (${cwdPolicy.delegation.source})`,
 		`User settings: ${safeTerminalText(snapshot.path)}`,
 	];
 }
@@ -610,9 +753,18 @@ function formatManagerSummary(
 	configured: ReturnType<typeof inspectDelegationWorkflowSettings>,
 ): string {
 	const current = currentWorkflow(runtime, status);
+	const cwdPolicy = inspectCwdPolicySettings();
+	const consult = inspectConsultResourceSettings();
 	return [
 		`Delegation: ${workflowLabel(current)}`,
 		`Completion: ${completionLabel(status.completionDelivery)}`,
+		`Consult target: ${consultationCwdLabel(runtime.getConsultationCwdPolicy())}`,
+		`Delegation target: ${delegationCwdLabel(runtime.getDelegationCwdPolicy())}`,
+		`Consult resources: ${consultResourceLabel(runtime.getConsultResourcePolicy())}`,
+		`Configured consult target: ${consultationCwdLabel(cwdPolicy.consultation.value)} · ${cwdPolicy.consultation.source}`,
+		`Configured delegation target: ${delegationCwdLabel(cwdPolicy.delegation.value)} · ${cwdPolicy.delegation.source}`,
+		`Configured consult resources: ${consultResourceLabel(consult.value)} · ${consult.source}`,
+		`Settings: ${safeTerminalText(cwdPolicy.path)}`,
 		`Agents: ${status.activeAgents} active · ${status.retainedAgents} retained`,
 		...(configured.value !== current
 			? [`Configured after reload: ${workflowLabel(configured.value)}`]
@@ -627,6 +779,8 @@ function formatStatus(
 	runtime?: SubagentSettingsRuntime,
 ): string {
 	const configuredWorkflow = inspectDelegationWorkflowSettings();
+	const consult = inspectConsultResourceSettings();
+	const cwdPolicy = inspectCwdPolicySettings();
 	const current = runtime ? currentWorkflow(runtime, status) : configuredWorkflow.value;
 	return [
 		"Current session",
@@ -634,15 +788,24 @@ function formatStatus(
 		`  Async runtime: ${status.initialized ? "initialized" : status.enabled ? "not initialized" : "disabled"}`,
 		`  Transport: ${status.transport}`,
 		`  Completion: ${completionLabel(status.completionDelivery)}`,
+		`  Consultation target: ${consultationCwdLabel(runtime?.getConsultationCwdPolicy() ?? cwdPolicy.consultation.value)}`,
+		`  Delegation target: ${delegationCwdLabel(runtime?.getDelegationCwdPolicy() ?? cwdPolicy.delegation.value)}`,
+		`  Consultation resources: ${consultResourceLabel(runtime?.getConsultResourcePolicy() ?? consult.value)}`,
 		`  Agents: ${status.activeAgents} active, ${status.retainedAgents} retained`,
 		"User settings",
 		`  Delegation source: ${configuredWorkflow.source}`,
 		`  Configured delegation: ${workflowLabel(configuredWorkflow.value)}`,
 		`  Completion source: ${snapshot.source}`,
 		`  Configured completion: ${completionLabel(snapshot.value)}`,
+		`  Configured consultation target: ${consultationCwdLabel(cwdPolicy.consultation.value)}`,
+		`  Consultation target source: ${cwdPolicy.consultation.source}`,
+		`  Configured delegation target: ${delegationCwdLabel(cwdPolicy.delegation.value)}`,
+		`  Delegation target source: ${cwdPolicy.delegation.source}`,
+		`  Configured consultation resources: ${consultResourceLabel(consult.value)}`,
+		`  Consultation resource source: ${consult.source}`,
 		`  Path: ${safeTerminalText(snapshot.path)}`,
-		configuredWorkflow.error || snapshot.error
-			? `  Warning: ${safeTerminalText(configuredWorkflow.error ?? snapshot.error ?? "invalid settings")}`
+		configuredWorkflow.error || snapshot.error || cwdPolicy.error
+			? `  Warning: ${safeTerminalText(configuredWorkflow.error ?? snapshot.error ?? cwdPolicy.error ?? "invalid settings")}`
 			: "  Warning: none",
 		configuredWorkflow.value !== current
 			? "Configured delegation differs from this session. Run /reload to apply it."
@@ -688,13 +851,45 @@ function completionLabel(value: CompletionDelivery): string {
 	return value === "auto-resume" ? "Resume automatically when finished" : "Wait until my next turn";
 }
 
+function consultationCwdLabel(value: ConsultationCwdPolicy): string {
+	return value === "current-workspace"
+		? "Current workspace only"
+		: "Anywhere · untrusted targets inherit nothing";
+}
+
+function delegationCwdLabel(value: DelegationCwdPolicy): string {
+	switch (value) {
+		case "trusted-targets":
+			return "Current or saved-trusted folders";
+		case "current-workspace":
+			return "Current workspace only";
+		case "anywhere":
+			return "Anywhere · normal Pi permissions";
+	}
+}
+
+function consultResourceLabel(value: ConsultResourcePolicy): string {
+	switch (value) {
+		case "project-context":
+			return "Project context only";
+		case "none":
+			return "No inherited resources";
+		case "all":
+			return "All trusted resources";
+	}
+}
+
 function workflowEffects(current: DelegationWorkflow, next: DelegationWorkflow): string[] {
 	const blockingEnabled = (value: DelegationWorkflow) =>
 		value === "all" || value === "blocking-only";
 	const asyncEnabled = (value: DelegationWorkflow) => value === "all" || value === "async-only";
 	const effects: string[] = [];
 	if (blockingEnabled(current) !== blockingEnabled(next)) {
-		effects.push(blockingEnabled(next) ? "Add blocking `subagent`" : "Remove blocking `subagent`");
+		effects.push(
+			blockingEnabled(next)
+				? "Add blocking `subagent` and read-only `subagent_consult`"
+				: "Remove blocking `subagent` and read-only `subagent_consult`",
+		);
 	}
 	if (asyncEnabled(current) !== asyncEnabled(next)) {
 		effects.push(

package/src/consult-policy.ts

@@ -0,0 +1,15 @@
+export const READ_ONLY_CONSULT_TOOLS = ["read", "grep", "find", "ls"] as const;
+
+const READ_ONLY_CONSULT_TOOL_SET = new Set<string>(READ_ONLY_CONSULT_TOOLS);
+
+export function resolveConsultTools(tools: readonly string[] | undefined): string[] {
+	if (tools === undefined) return [...READ_ONLY_CONSULT_TOOLS];
+	const seen = new Set<string>();
+	const effective: string[] = [];
+	for (const tool of tools) {
+		if (!READ_ONLY_CONSULT_TOOL_SET.has(tool) || seen.has(tool)) continue;
+		seen.add(tool);
+		effective.push(tool);
+	}
+	return effective;
+}

package/src/consult-render.ts

@@ -0,0 +1,194 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import {
+	getMarkdownTheme,
+	type Theme,
+	type ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import type { ConsultDetails, SubagentConsultParams } from "./consult.js";
+import { formatUsageStats } from "./render.js";
+import {
+	COLLAPSED_ANSWER_LINES,
+	COLLAPSED_LIST_LIMIT,
+	expansionHint,
+	previewLines,
+	projectRenderActivity,
+	type RenderStatus,
+	recordValue,
+	renderActivityLines,
+	renderFallbackResult,
+	safeBlock,
+	safeLine,
+	statusBadge,
+	stringValue,
+	type ToolRendererContext,
+	textResult,
+	toolHeader,
+} from "./render-common.js";
+
+export function renderConsultCall(args: Partial<SubagentConsultParams>, theme: Theme) {
+	const scope = args.agentScope ?? "user";
+	const text = [
+		toolHeader(theme, "subagent_consult", args.agent, [`[${scope}]`, "read-only"]),
+		`  ${theme.fg("dim", safeLine(args.task, "...", 2 * 1024))}`,
+	].join("\n");
+	return new Text(text, 0, 0);
+}
+
+export function renderConsultResult(
+	result: AgentToolResult<ConsultDetails>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	context: ToolRendererContext<SubagentConsultParams>,
+) {
+	const details = recordValue(result.details);
+	if (!details || !recordValue(details.policy)) {
+		return renderFallbackResult(result, options, theme, context.isError);
+	}
+
+	const progress = recordValue(details.progress);
+	const child = recordValue(details.child);
+	const status = consultStatus(details, progress, options, context.isError);
+	const agent = safeLine(details.agent, safeLine(context.args?.agent, "subagent"), 256);
+	const source = safeLine(details.agentSource, "unknown", 128);
+	const usage = recordValue(progress?.usage ?? child?.usage);
+	const usageText = formatUnknownUsage(
+		usage,
+		stringValue(details.model) || undefined,
+		stringValue(details.thinkingLevel) || undefined,
+		stringValue(progress?.actualProvider ?? child?.actualProvider) || undefined,
+		stringValue(progress?.actualModel ?? child?.actualModel) || undefined,
+	);
+	const effectiveTools = stringList(recordValue(details.policy)?.effectiveTools);
+	const activity = projectRenderActivity(progress?.recentActivity);
+	const activityTotal = Math.max(
+		activity.length,
+		typeof progress?.recentActivityTotal === "number" ? progress.recentActivityTotal : 0,
+	);
+	const answer = safeBlock(textResult(result), "", 50 * 1024).trim();
+
+	if (options.expanded) {
+		const container = new Container();
+		container.addChild(
+			new Text(
+				`${statusBadge(theme, status)} · ${theme.fg("toolTitle", theme.bold(agent))}${theme.fg("muted", ` (${source})`)}`,
+				0,
+				0,
+			),
+		);
+		if (usageText) container.addChild(new Text(theme.fg("dim", usageText), 0, 0));
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(theme.fg("muted", "─── Task ───"), 0, 0));
+		container.addChild(
+			new Text(theme.fg("dim", safeBlock(context.args?.task, "(unavailable)", 50 * 1024)), 0, 0),
+		);
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(theme.fg("muted", "─── Policy ───"), 0, 0));
+		container.addChild(new Text(theme.fg("dim", policySummary(details.policy)), 0, 0));
+		if (activity.length > 0) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("muted", "─── Activity ───"), 0, 0));
+			container.addChild(
+				new Text(renderActivityLines(activity, theme, undefined, activityTotal), 0, 0),
+			);
+		}
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(theme.fg("muted", "─── Answer ───"), 0, 0));
+		if (answer) container.addChild(new Markdown(answer, 0, 0, getMarkdownTheme()));
+		else
+			container.addChild(
+				new Text(
+					theme.fg("muted", options.isPartial ? "(waiting for output)" : "(no output)"),
+					0,
+					0,
+				),
+			);
+		return container;
+	}
+
+	const lines = [
+		`${statusBadge(theme, status)} · ${theme.fg("toolTitle", theme.bold(agent))}${theme.fg("muted", ` (${source})`)}`,
+	];
+	if (usageText) lines.push(theme.fg("dim", usageText));
+	if (effectiveTools.length > 0 && options.isPartial) {
+		lines.push(theme.fg("dim", `tools: ${effectiveTools.join(", ")}`));
+	}
+	if (activity.length > 0) {
+		lines.push(renderActivityLines(activity, theme, COLLAPSED_LIST_LIMIT, activityTotal));
+	} else if (options.isPartial) {
+		lines.push(
+			theme.fg("muted", status === "starting" ? "(starting child)" : "(waiting for activity)"),
+		);
+	} else if (answer) {
+		lines.push(theme.fg("toolOutput", previewLines(answer, COLLAPSED_ANSWER_LINES)));
+	} else {
+		const error = safeBlock(child?.error, "", 2 * 1024).trim();
+		lines.push(theme.fg(status === "failed" ? "error" : "muted", error || "(no output)"));
+	}
+	if (!options.isPartial) lines.push(expansionHint());
+	return new Text(lines.filter(Boolean).join("\n"), 0, 0);
+}
+
+function consultStatus(
+	details: Record<string, unknown>,
+	progress: Record<string, unknown> | undefined,
+	options: ToolRenderResultOptions,
+	isError: boolean,
+): RenderStatus {
+	if (details.cancelled === true) return "cancelled";
+	if (isError || details.isError === true) {
+		const child = recordValue(details.child);
+		return child?.aborted === true && child?.timedOut !== true ? "cancelled" : "failed";
+	}
+	if (options.isPartial) return progress?.phase === "starting" ? "starting" : "running";
+	return "completed";
+}
+
+function stringList(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.flatMap((item) => (typeof item === "string" ? [safeLine(item, "", 256)] : []))
+		: [];
+}
+
+function policySummary(value: unknown): string {
+	const policy = recordValue(value);
+	if (!policy) return "(unavailable)";
+	const resources = recordValue(policy.effectiveResources);
+	const tools = stringList(policy.effectiveTools);
+	return [
+		`tools: ${tools.length > 0 ? tools.join(", ") : "none"}`,
+		`resources: ${safeLine(resources?.policy ?? policy.requestedResources, "unknown", 256)}`,
+		`extensions: ${safeLine(policy.extensions, "unknown", 128)}`,
+		`session persistence: ${safeLine(policy.sessionPersistence, "unknown", 128)}`,
+		`retained agent: ${policy.retainedAgent === false ? "no" : "unknown"}`,
+	].join("\n");
+}
+
+function formatUnknownUsage(
+	value: Record<string, unknown> | undefined,
+	model?: string,
+	thinkingLevel?: string,
+	actualProvider?: string,
+	actualModel?: string,
+): string {
+	const usage = value ?? {};
+	return formatUsageStats(
+		{
+			input: safeNumber(usage.input),
+			output: safeNumber(usage.output),
+			cacheRead: safeNumber(usage.cacheRead),
+			cacheWrite: safeNumber(usage.cacheWrite),
+			cost: safeNumber(usage.cost),
+			contextTokens: safeNumber(usage.contextTokens),
+			turns: safeNumber(usage.turns),
+		},
+		model,
+		thinkingLevel as never,
+		actualProvider,
+		actualModel,
+	);
+}
+
+function safeNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}