@narumitw/pi-subagents 0.43.0 → 0.43.1

package/src/inspect-render.ts

@@ -0,0 +1,234 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Theme, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import type { SubagentInspectParams } from "./inspect.js";
+import {
+	booleanValue,
+	COLLAPSED_LIST_LIMIT,
+	expansionHint,
+	numberValue,
+	recordList,
+	recordValue,
+	renderFallbackResult,
+	safeBlock,
+	safeLine,
+	statusBadge,
+	stringValue,
+	type ToolRendererContext,
+	toolHeader,
+} from "./render-common.js";
+
+export function renderInspectCall(args: Partial<SubagentInspectParams>, theme: Theme) {
+	const action = safeLine(args.action, "...", 128);
+	const metadata: string[] = [];
+	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.includeClosed) metadata.push("include closed");
+	return new Text(toolHeader(theme, "subagent_inspect", action, metadata), 0, 0);
+}
+
+export function renderInspectResult(
+	result: AgentToolResult<Record<string, unknown>>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	context: ToolRendererContext<SubagentInspectParams>,
+) {
+	const details = recordValue(result.details);
+	const action = stringValue(details?.action);
+	if (!details || !action) return renderFallbackResult(result, options, theme, context.isError);
+
+	const rendered = renderAction(action, details, options.expanded, theme);
+	if (!rendered) return renderFallbackResult(result, options, theme, context.isError);
+	return new Text(rendered, 0, 0);
+}
+
+function renderAction(
+	action: string,
+	details: Record<string, unknown>,
+	expanded: boolean,
+	theme: Theme,
+): string | undefined {
+	switch (action) {
+		case "list_agents":
+			return renderList("agent", recordList(details.agents), details, expanded, theme, formatAgent);
+		case "get_agent": {
+			const agent = recordValue(details.agent);
+			if (!agent) return undefined;
+			const lines = [
+				`${statusBadge(theme, "completed")} · ${theme.fg("toolTitle", theme.bold(safeLine(agent.name, "agent", 256)))}${theme.fg("muted", ` (${safeLine(agent.source, "unknown", 128)})`)}`,
+				formatAgent(agent, theme, true),
+			];
+			if (!expanded) lines.push(expansionHint());
+			return lines.join("\n");
+		}
+		case "list_runs":
+			return renderList("run", recordList(details.runs), details, expanded, theme, formatRun);
+		case "get_run": {
+			const run = recordValue(details.run);
+			if (!run) return undefined;
+			const lines = [
+				`${statusBadge(theme, "completed")} · run ${theme.fg("accent", safeLine(run.id, "run", 256))}`,
+				formatRun(run, theme, true),
+			];
+			if (!expanded) lines.push(expansionHint());
+			return lines.join("\n");
+		}
+		case "list_models":
+			return renderList(
+				"model",
+				recordList(details.models),
+				details,
+				expanded,
+				theme,
+				formatModel,
+				stringValue(details.source),
+			);
+		case "status":
+			return renderStatus(details, expanded, theme);
+		case "diagnose":
+			return renderDiagnose(details, expanded, theme);
+		default:
+			return undefined;
+	}
+}
+
+function renderList(
+	label: string,
+	items: Record<string, unknown>[],
+	details: Record<string, unknown>,
+	expanded: boolean,
+	theme: Theme,
+	format: (item: Record<string, unknown>, theme: Theme, expanded: boolean) => string,
+	source = "",
+): string {
+	const returned = numberValue(details.returned, items.length);
+	const omitted = numberValue(details.omitted);
+	const noun = `${label}${returned === 1 ? "" : "s"}`;
+	const lines = [
+		`${statusBadge(theme, "completed")} · ${returned} ${noun}${source ? theme.fg("muted", ` · ${safeLine(source, "", 256)}`) : ""}`,
+	];
+	const selected = expanded ? items : items.slice(0, COLLAPSED_LIST_LIMIT);
+	for (const item of selected) lines.push(format(item, theme, expanded));
+	const hidden = Math.max(0, items.length - selected.length) + omitted;
+	if (hidden > 0) lines.push(theme.fg("muted", `… ${hidden} omitted`));
+	if (items.length === 0) lines.push(theme.fg("muted", `(no ${label}s)`));
+	if (!expanded && (items.length > 0 || omitted > 0)) lines.push(expansionHint());
+	return lines.join("\n");
+}
+
+function formatAgent(agent: Record<string, unknown>, theme: Theme, expanded: boolean): string {
+	const name = safeLine(agent.name, "agent", 256);
+	const source = safeLine(agent.source, "unknown", 128);
+	const model = stringValue(agent.model);
+	const toolCount = typeof agent.toolCount === "number" ? agent.toolCount : undefined;
+	const description = safeBlock(agent.description, "", 512).trim();
+	const lines = [
+		`${theme.fg("muted", "• ")}${theme.fg("accent", name)} ${theme.fg("muted", source)}${model ? theme.fg("dim", ` · ${safeLine(model, "", 256)}`) : ""}${toolCount !== undefined ? theme.fg("dim", ` · ${toolCount} tools`) : ""}`,
+	];
+	if (description) lines.push(`  ${theme.fg("toolOutput", description)}`);
+	if (expanded) {
+		const path = stringValue(agent.path);
+		const consultTools = stringList(agent.consultTools);
+		if (path) lines.push(`  ${theme.fg("dim", `path: ${safeLine(path, "", 2 * 1024)}`)}`);
+		lines.push(`  ${theme.fg("dim", `consult tools: ${consultTools.join(", ") || "none"}`)}`);
+	}
+	return lines.join("\n");
+}
+
+function formatRun(run: Record<string, unknown>, theme: Theme, expanded: boolean): string {
+	const id = safeLine(run.id, "run", 256);
+	const agent = safeLine(run.agent, "agent", 256);
+	const state = safeLine(run.state, "unknown", 128);
+	const unread = numberValue(run.unreadMessages);
+	const lines = [
+		`${theme.fg("muted", "• ")}${theme.fg("accent", id)} ${theme.fg("toolOutput", agent)} ${theme.fg("muted", state)}${unread > 0 ? theme.fg("warning", ` · unread:${unread}`) : ""}`,
+	];
+	if (expanded) {
+		const thinking = stringValue(run.thinkingLevel);
+		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`)}`,
+		);
+		if (task) lines.push(`  ${theme.fg("dim", `task: ${task}`)}`);
+		if (error) lines.push(`  ${theme.fg("error", `error: ${error}`)}`);
+	}
+	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") : "";
+	const reasoning = booleanValue(model.reasoning) ? theme.fg("dim", " · reasoning") : "";
+	const lines = [`${theme.fg("muted", "• ")}${theme.fg("accent", identity)}${current}${reasoning}`];
+	if (expanded) {
+		const name = stringValue(model.name);
+		const thinking = stringValue(model.thinkingLevel);
+		if (name) lines.push(`  ${theme.fg("toolOutput", safeLine(name, "", 512))}`);
+		lines.push(
+			`  ${theme.fg("dim", `context:${numberValue(model.contextWindow)} · max:${numberValue(model.maxTokens)}${thinking ? ` · thinking:${safeLine(thinking, "", 128)}` : ""}`)}`,
+		);
+	}
+	return lines.join("\n");
+}
+
+function renderStatus(
+	details: Record<string, unknown>,
+	expanded: boolean,
+	theme: Theme,
+): string | undefined {
+	const status = recordValue(details.status);
+	const stateful = recordValue(status?.stateful);
+	if (!status || !stateful) return undefined;
+	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 (expanded) {
+		const delivery = stringValue(stateful.completionDelivery);
+		const transport = stringValue(stateful.transport);
+		if (transport || delivery) {
+			lines.push(
+				theme.fg(
+					"dim",
+					[
+						transport && `transport:${safeLine(transport)}`,
+						delivery && `delivery:${safeLine(delivery)}`,
+					]
+						.filter(Boolean)
+						.join(" · "),
+				),
+			);
+		}
+	} else lines.push(expansionHint());
+	return lines.join("\n");
+}
+
+function renderDiagnose(details: Record<string, unknown>, expanded: boolean, theme: Theme): string {
+	const checks = recordList(details.checks);
+	const hasFail = checks.some((check) => check.status === "fail");
+	const hasWarning = checks.some((check) => check.status === "warning");
+	const overall = hasFail ? "failed" : hasWarning ? "warnings" : "passed";
+	const status = hasFail ? "failed" : hasWarning ? "warning" : "completed";
+	const lines = [`${statusBadge(theme, status)} · Diagnostics ${overall}`];
+	const selected = expanded ? checks : checks.slice(0, COLLAPSED_LIST_LIMIT);
+	for (const check of selected) {
+		const checkStatus = safeLine(check.status, "unknown", 64);
+		const color =
+			checkStatus === "fail" ? "error" : checkStatus === "warning" ? "warning" : "success";
+		lines.push(
+			`${theme.fg(color, checkStatus.toUpperCase())} ${theme.fg("accent", safeLine(check.name, "check", 256))} · ${theme.fg("toolOutput", safeBlock(check.message, "", 2 * 1024))}`,
+		);
+	}
+	if (checks.length === 0) lines.push(theme.fg("muted", "(no diagnostic checks)"));
+	if (!expanded && checks.length > 0) lines.push(expansionHint());
+	return lines.join("\n");
+}
+
+function stringList(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.flatMap((item) => (typeof item === "string" ? [safeLine(item, "", 256)] : []))
+		: [];
+}

package/src/inspect.ts

@@ -2,12 +2,21 @@ import * as path from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
+import {
+	type AgentConfig,
+	type AgentScope,
+	type ConsultationCwdPolicy,
+	type DelegationCwdPolicy,
+	discoverAgents,
+} from "./agents.js";
 import { resolveConsultTools } from "./consult-policy.js";
+import { renderInspectCall, renderInspectResult } from "./inspect-render.js";
 import type { AgentRunInspectionDetail, AgentRunInspectionSummary } from "./registry.js";
 import { boundedPrivateText, boundText, safeDisplayPath, safeTerminalLine } from "./safe-text.js";
 import {
+	inspectCompletionDeliverySettings,
 	inspectConsultResourceSettings,
+	inspectCwdPolicySettings,
 	inspectDelegationWorkflowSettings,
 	inspectSubagentSettings,
 	resolveDelegationWorkflow,
@@ -49,6 +58,8 @@ export type SubagentInspectParams = Static<typeof SubagentInspectParams>;
 export interface SubagentInspectRuntime {
 	getBlockingEnabled(): boolean;
 	getConsultResourcePolicy(): "project-context" | "none" | "all";
+	getConsultationCwdPolicy(): ConsultationCwdPolicy;
+	getDelegationCwdPolicy(): DelegationCwdPolicy;
 	getRuntimeStatus(): StatefulSubagentRuntimeStatus;
 	listRunInspection(includeClosed?: boolean): AgentRunInspectionSummary[];
 	getRunInspection(agentId: string): AgentRunInspectionDetail | undefined;
@@ -79,6 +90,12 @@ export function registerSubagentInspect(pi: ExtensionAPI, runtime: SubagentInspe
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx): Promise<InspectToolResult> {
 			return executeSubagentInspect(validateInspectParams(params), ctx, runtime);
 		},
+		renderCall(args, theme) {
+			return renderInspectCall(args, theme);
+		},
+		renderResult(result, options, theme, context) {
+			return renderInspectResult(result, options, theme, context);
+		},
 	});
 }
 
@@ -280,9 +297,26 @@ function projectRun(run: AgentRunInspectionDetail, ctx: ExtensionContext): Recor
 	return {
 		...projectRunSummary(run),
 		cwd: safeDisplayPath(run.cwd, ctx.cwd),
+		workspaceMode: run.workspaceMode ?? "shared",
 		thinkingLevel: run.thinkingLevel,
 		currentTask: run.currentTask ? boundedPrivateText(run.currentTask, 2 * 1024) : undefined,
 		error: run.error ? boundedPrivateText(run.error, 2 * 1024) : undefined,
+		target: run.target
+			? {
+					cwd: safeDisplayPath(run.target.cwd, ctx.cwd),
+					boundary: run.target.boundary,
+					trust: {
+						kind: run.target.trust.kind,
+						projectTrusted: run.target.trust.projectTrusted,
+						sourcePath: run.target.trust.sourcePath
+							? safeDisplayPath(run.target.trust.sourcePath, ctx.cwd)
+							: undefined,
+						warning: run.target.trust.warning
+							? boundedPrivateText(run.target.trust.warning, 512)
+							: undefined,
+					},
+				}
+			: undefined,
 		policy: run.policy
 			? {
 					inherited: projectToolNames(run.policy.inherited),
@@ -323,17 +357,31 @@ function projectStatus(runtime: SubagentInspectRuntime): Record<string, unknown>
 	const workflow = resolveDelegationWorkflow(runtime.getBlockingEnabled(), stateful.enabled);
 	const configured = inspectDelegationWorkflowSettings();
 	const resources = inspectConsultResourceSettings();
+	const cwdPolicy = inspectCwdPolicySettings();
+	const completion = inspectCompletionDeliverySettings();
 	return {
 		workflow,
 		configuredWorkflow: configured.value,
+		configuredWorkflowSource: configured.source,
 		stateful,
+		configuredCompletionDelivery: completion.value,
+		configuredCompletionDeliverySource: completion.source,
 		consultResources: runtime.getConsultResourcePolicy(),
+		consultationCwdPolicy: runtime.getConsultationCwdPolicy(),
+		configuredConsultationCwdPolicy: cwdPolicy.consultation.value,
+		consultationCwdPolicySource: cwdPolicy.consultation.source,
+		delegationCwdPolicy: runtime.getDelegationCwdPolicy(),
+		configuredDelegationCwdPolicy: cwdPolicy.delegation.value,
+		delegationCwdPolicySource: cwdPolicy.delegation.source,
 		configuredConsultResources: resources.value,
 		consultResourcesSource: resources.source,
 		settingsPath: safeDisplayPath(resources.path, process.cwd()),
 		settingsError:
-			configured.error || resources.error
-				? boundedPrivateText(configured.error ?? resources.error ?? "", 2 * 1024)
+			configured.error || resources.error || cwdPolicy.error || completion.error
+				? boundedPrivateText(
+						configured.error ?? resources.error ?? cwdPolicy.error ?? completion.error ?? "",
+						2 * 1024,
+					)
 				: undefined,
 	};
 }

package/src/persistence.ts

@@ -167,6 +167,8 @@ function isStoredState(value: unknown): value is StoredState {
 			Number.isFinite(record.updatedAt) &&
 			(record.parentId === undefined || typeof record.parentId === "string") &&
 			(record.thinkingLevel === undefined || isThinkingLevel(record.thinkingLevel)) &&
+			(record.workspaceMode === undefined || record.workspaceMode === "worktree") &&
+			(record.target === undefined || isTargetPolicyAudit(record.target)) &&
 			(record.children === undefined ||
 				(Array.isArray(record.children) &&
 					record.children.every((id) => typeof id === "string"))) &&
@@ -178,6 +180,33 @@ function isStoredState(value: unknown): value is StoredState {
 	});
 }
 
+function isTargetPolicyAudit(value: unknown): boolean {
+	if (!value || typeof value !== "object") return false;
+	const target = value as Record<string, unknown>;
+	if (
+		typeof target.cwd !== "string" ||
+		(target.boundary !== "current-workspace" && target.boundary !== "external") ||
+		!target.trust ||
+		typeof target.trust !== "object"
+	) {
+		return false;
+	}
+	const trust = target.trust as Record<string, unknown>;
+	return (
+		[
+			"session-trusted",
+			"session-untrusted",
+			"saved-trusted",
+			"saved-denied",
+			"unsaved",
+			"trust-error",
+		].includes(String(trust.kind)) &&
+		typeof trust.projectTrusted === "boolean" &&
+		(trust.sourcePath === undefined || typeof trust.sourcePath === "string") &&
+		(trust.warning === undefined || typeof trust.warning === "string")
+	);
+}
+
 function isAgentTurn(value: unknown): boolean {
 	if (!value || typeof value !== "object") return false;
 	const turn = value as Record<string, unknown>;

package/src/registry.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { SubagentThinkingLevel } from "./agents.js";
+import type { TargetPolicyAudit } from "./cwd-policy.js";
 import { DEFAULT_MAX_CONTEXT_BYTES, DEFAULT_MAX_OUTPUT_BYTES, truncateUtf8 } from "./limits.js";
 import { type AgentTurnRunner, normalizeTransport, type SubagentTransport } from "./transport.js";
 
@@ -50,6 +51,8 @@ export interface ManagedAgent {
 	context?: string;
 	contextSourceIds?: string[];
 	contextTruncated?: boolean;
+	workspaceMode?: "worktree";
+	target?: TargetPolicyAudit;
 	policy?: { inherited: string[]; overridden: string[]; unsupported: string[] };
 	mailbox: AgentMailboxMessage[];
 	currentMailboxMessageIds?: string[];
@@ -70,6 +73,8 @@ export interface AgentRunInspectionDetail extends AgentRunInspectionSummary {
 	thinkingLevel?: SubagentThinkingLevel;
 	currentTask?: string;
 	error?: string;
+	workspaceMode?: "worktree";
+	target?: TargetPolicyAudit;
 	policy?: { inherited: string[]; overridden: string[]; unsupported: string[] };
 }
 
@@ -243,6 +248,8 @@ export class AgentRegistry {
 		context?: string;
 		contextSourceIds?: string[];
 		contextTruncated?: boolean;
+		workspaceMode?: "worktree";
+		target?: TargetPolicyAudit;
 	}): Promise<ManagedAgent> {
 		if (!input.task.trim()) throw new Error("Subagent tasks cannot be empty");
 		const task = truncateUtf8(input.task, this.maxTaskBytes).text;
@@ -286,6 +293,8 @@ export class AgentRegistry {
 			context: input.context,
 			contextSourceIds: input.contextSourceIds,
 			contextTruncated: input.contextTruncated,
+			workspaceMode: input.workspaceMode,
+			target: input.target,
 		};
 		this.agents.set(record.id, record);
 		if (parent) {
@@ -549,6 +558,8 @@ export class AgentRegistry {
 			thinkingLevel: agent.thinkingLevel,
 			currentTask: agent.currentTask,
 			error: agent.error,
+			workspaceMode: agent.workspaceMode,
+			target: agent.target ? { ...agent.target, trust: { ...agent.target.trust } } : undefined,
 			policy: agent.policy
 				? {
 						inherited: [...agent.policy.inherited],
@@ -840,6 +851,7 @@ export class AgentRegistry {
 				: undefined,
 			history: agent.history.map((turn) => ({ ...turn })),
 			mailbox: agent.mailbox.map((message) => ({ ...message })),
+			target: agent.target ? { ...agent.target, trust: { ...agent.target.trust } } : undefined,
 			policy: agent.policy
 				? {
 						inherited: [...agent.policy.inherited],

package/src/render-common.ts

@@ -0,0 +1,252 @@
+import * as os from "node:os";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import {
+	keyHint,
+	type Theme,
+	type ThemeColor,
+	type ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { boundedPrivateText, safeTerminalLine } from "./safe-text.js";
+
+export const COLLAPSED_LIST_LIMIT = 5;
+export const COLLAPSED_ANSWER_LINES = 3;
+
+export interface ToolRendererContext<TArgs> {
+	args: TArgs;
+	isError: boolean;
+}
+
+export type RenderStatus =
+	| "starting"
+	| "running"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "interrupted"
+	| "idle"
+	| "closed"
+	| "warning";
+
+const STATUS_PRESENTATION: Record<
+	RenderStatus,
+	{ icon: string; label: string; color: ThemeColor }
+> = {
+	starting: { icon: "⏳", label: "Starting", color: "warning" },
+	running: { icon: "⏳", label: "Running", color: "warning" },
+	completed: { icon: "✓", label: "Completed", color: "success" },
+	failed: { icon: "✗", label: "Failed", color: "error" },
+	cancelled: { icon: "■", label: "Cancelled", color: "warning" },
+	interrupted: { icon: "■", label: "Interrupted", color: "warning" },
+	idle: { icon: "○", label: "Idle", color: "muted" },
+	closed: { icon: "✓", label: "Closed", color: "muted" },
+	warning: { icon: "◐", label: "Warning", color: "warning" },
+};
+
+export function recordValue(value: unknown): Record<string, unknown> | undefined {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+export function recordList(value: unknown): Record<string, unknown>[] {
+	return Array.isArray(value)
+		? value.flatMap((item) => {
+				const record = recordValue(item);
+				return record ? [record] : [];
+			})
+		: [];
+}
+
+export function stringValue(value: unknown, fallback = ""): string {
+	return typeof value === "string" ? value : fallback;
+}
+
+export function numberValue(value: unknown, fallback = 0): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+export function booleanValue(value: unknown): boolean {
+	return value === true;
+}
+
+export function safeLine(value: unknown, fallback = "...", maxBytes = 2 * 1024): string {
+	if (typeof value !== "string" || !value.trim()) return fallback;
+	return safeTerminalLine(value, maxBytes) || fallback;
+}
+
+export function safeBlock(value: unknown, fallback = "", maxBytes = 50 * 1024): string {
+	if (typeof value !== "string" || !value) return fallback;
+	return boundedPrivateText(value, maxBytes);
+}
+
+export function previewLines(value: unknown, maxLines = COLLAPSED_ANSWER_LINES): string {
+	const text = safeBlock(value, "", 8 * 1024).trim();
+	return text.split("\n").slice(0, maxLines).join("\n");
+}
+
+export function textResult(result: AgentToolResult<unknown>): string {
+	return result.content
+		.flatMap((part) => (part.type === "text" ? [part.text] : []))
+		.join("\n")
+		.trim();
+}
+
+export function toolHeader(
+	theme: Theme,
+	toolName: string,
+	primary?: unknown,
+	metadata: readonly string[] = [],
+): string {
+	let text = theme.fg("toolTitle", theme.bold(`${toolName} `));
+	if (primary !== undefined) text += theme.fg("accent", safeLine(primary));
+	const safeMetadata = metadata.filter(Boolean).map((item) => safeLine(item, "", 512));
+	if (safeMetadata.length > 0) text += theme.fg("muted", ` · ${safeMetadata.join(" · ")}`);
+	return text.trimEnd();
+}
+
+export function statusBadge(theme: Theme, status: RenderStatus, suffix?: string): string {
+	const presentation = STATUS_PRESENTATION[status];
+	const label = suffix
+		? `${presentation.label} · ${safeLine(suffix, "", 2 * 1024)}`
+		: presentation.label;
+	return `${theme.fg(presentation.color, presentation.icon)} ${theme.fg(presentation.color, label)}`;
+}
+
+export function renderFallbackResult(
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	isError = false,
+) {
+	const status: RenderStatus = isError ? "failed" : options.isPartial ? "running" : "completed";
+	const content = safeBlock(textResult(result), "(no output)", 8 * 1024);
+	return new Text(`${statusBadge(theme, status)}\n${theme.fg("toolOutput", content)}`, 0, 0);
+}
+
+export function expansionHint(): string {
+	return keyHint("app.tools.expand", "to expand");
+}
+
+export interface RenderActivityItem {
+	type: "text" | "toolCall";
+	text?: string;
+	name?: string;
+	args?: Record<string, unknown>;
+}
+
+export function projectRenderActivity(value: unknown): RenderActivityItem[] {
+	if (!Array.isArray(value)) return [];
+	const items: RenderActivityItem[] = [];
+	for (const item of value) {
+		const record = recordValue(item);
+		if (!record) continue;
+		if (record.type === "text" && typeof record.text === "string") {
+			items.push({ type: "text", text: safeBlock(record.text, "", 1024) });
+			continue;
+		}
+		if (record.type === "toolCall" && typeof record.name === "string") {
+			items.push({
+				type: "toolCall",
+				name: safeLine(record.name, "tool", 256),
+				args: recordValue(record.args) ?? {},
+			});
+		}
+	}
+	return items;
+}
+
+export function renderActivityLines(
+	items: readonly RenderActivityItem[],
+	theme: Theme,
+	limit?: number,
+	total = items.length,
+): string {
+	const selected = limit === undefined ? items : items.slice(-limit);
+	const lines: string[] = [];
+	const skipped = Math.max(0, total - selected.length);
+	if (skipped > 0) lines.push(theme.fg("muted", `… ${skipped} earlier activities`));
+	for (const item of selected) {
+		if (item.type === "text") {
+			const text = safeBlock(item.text, "", 1024).trim();
+			if (text) lines.push(theme.fg("toolOutput", text));
+		} else {
+			lines.push(
+				theme.fg("muted", "→ ") +
+					formatToolActivity(item.name ?? "tool", item.args ?? {}, theme.fg.bind(theme)),
+			);
+		}
+	}
+	return lines.join("\n");
+}
+
+export function formatToolActivity(
+	toolNameValue: unknown,
+	argsValue: unknown,
+	themeFg: (color: ThemeColor, text: string) => string,
+): string {
+	const toolName = safeLine(toolNameValue, "tool", 256);
+	const args = recordValue(argsValue) ?? {};
+	const shortenPath = (value: unknown, fallback = ".") => {
+		const filePath = safeLine(value, fallback, 2 * 1024);
+		const home = os.homedir();
+		return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+	};
+
+	switch (toolName) {
+		case "bash": {
+			const command = safeLine(args.command, "...", 512);
+			return themeFg("muted", "$ ") + themeFg("toolOutput", command);
+		}
+		case "read": {
+			const filePath = shortenPath(args.file_path ?? args.path, "...");
+			const offset = typeof args.offset === "number" ? args.offset : undefined;
+			const limit = typeof args.limit === "number" ? args.limit : undefined;
+			let text = themeFg("accent", filePath);
+			if (offset !== undefined || limit !== undefined) {
+				const startLine = offset ?? 1;
+				const endLine = limit !== undefined ? startLine + limit - 1 : "";
+				text += themeFg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+			}
+			return themeFg("muted", "read ") + text;
+		}
+		case "write": {
+			const filePath = shortenPath(args.file_path ?? args.path, "...");
+			const content = safeBlock(args.content, "", 2 * 1024);
+			const lines = content ? content.split("\n").length : 0;
+			return (
+				themeFg("muted", "write ") +
+				themeFg("accent", filePath) +
+				(lines > 1 ? themeFg("dim", ` (${lines} lines)`) : "")
+			);
+		}
+		case "edit":
+			return (
+				themeFg("muted", "edit ") +
+				themeFg("accent", shortenPath(args.file_path ?? args.path, "..."))
+			);
+		case "ls":
+			return themeFg("muted", "ls ") + themeFg("accent", shortenPath(args.path));
+		case "find":
+			return (
+				themeFg("muted", "find ") +
+				themeFg("accent", safeLine(args.pattern, "*", 512)) +
+				themeFg("dim", ` in ${shortenPath(args.path)}`)
+			);
+		case "grep":
+			return (
+				themeFg("muted", "grep ") +
+				themeFg("accent", `/${safeLine(args.pattern, "", 512)}/`) +
+				themeFg("dim", ` in ${shortenPath(args.path)}`)
+			);
+		default: {
+			let serialized = "{}";
+			try {
+				serialized = JSON.stringify(args);
+			} catch {
+				serialized = "{…}";
+			}
+			return themeFg("accent", toolName) + themeFg("dim", ` ${safeLine(serialized, "{}", 512)}`);
+		}
+	}
+}