@aeondave/pi-persona 1.17.0 → 1.17.3

package/src/tools/delegate.ts

@@ -1,28 +1,13 @@
 /**
- * The `delegate` tool's core logic — pure, engine-injected, testable. Maps params
- * to engine runs (single + bounded parallel), formats the result, and emits live
- * per-task "views" (running → done/failed) so the UI can show each sub-agent as
- * it runs. A task may carry `skills`/`model`/`tools` to spawn a *dynamic* sub-agent
- * (e.g. the generic `operator` specialised by the skills it loads). Capability
- * gating happens upstream in the `tool_call` hook.
+ * The `delegate` tool's pure core: parameter coercion and validation, the task → run-spec mapping,
+ * and the anti-loop ledger. A task may carry `skills`/`model`/`tools` to spawn a *dynamic* sub-agent
+ * (e.g. the generic `operator` specialised by the skills it loads). Capability gating happens
+ * upstream in the `tool_call` hook; launching and settling live in `delegate-tool.ts`.
  */
 
-import { type ChildUsage, emptyUsage, type ToolEvent } from "../engine/stream.ts";
-import { mapWithConcurrency } from "../orchestration/parallel.ts";
 import { cappedList } from "../core/format.ts";
 import { sanitizeDisplayLabel } from "../core/display-label.ts";
-import { validateParallelWriteSets } from "../core/ownership.ts";
-import { aggregateResults } from "../orchestration/reducers.ts";
-import {
-	type AgentRunSpec,
-	type InfrastructureFailure,
-	isInfrastructureFailure,
-	isPositiveFiniteMs,
-	legFailure,
-	type SteerFn,
-	type StrategyEngine,
-} from "../orchestration/sdk.ts";
-import type { AgentResult } from "../orchestration/types.ts";
+import { type AgentRunSpec, type InfrastructureFailure, isInfrastructureFailure, isPositiveFiniteMs } from "../orchestration/sdk.ts";
 
 export interface DelegateTask {
 	agent: string;
@@ -73,8 +58,6 @@ export interface DelegateParams {
 	outputContract?: string;
 	tasks?: DelegateTask[];
 	concurrency?: number;
-	async?: boolean;
-	sync?: boolean;
 }
 
 /** Structured cold-start context that any persona policy may require. */
@@ -299,21 +282,6 @@ export function coerceDelegateParams(raw: unknown): { ok: true; params: Delegate
 	return { ok: true, params: bag as DelegateParams };
 }
 
-/** A live per-sub-agent view for the UI (running → done/failed). */
-export interface DelegateView {
-	agent: string;
-	/** Display label: `name · model` (e.g. "kiln-port · sonnet-4-6"). */
-	label: string;
-	running: boolean;
-	ok: boolean;
-	/** Terminal failure classification; `abort` projects as stopped rather than failed in the UI. */
-	failureKind?: AgentResult["failureKind"];
-	output: string;
-	/** The tool the leg is currently running (e.g. "grep src/…"), "" if none. */
-	activity: string;
-	usage: ChildUsage;
-}
-
 /** Short model name for display: drop provider + `claude-` + any `:thinking`. */
 export function shortModel(ref: string | undefined): string {
 	if (!ref) return "";
@@ -323,8 +291,7 @@ export function shortModel(ref: string | undefined): string {
 
 /** The bare display NAME for a sub-agent (no model suffix): the loader's name, or a codename
  *  for a generic operator, else the agent's own name. Exported so a caller that folds in the
- *  model itself (e.g. the async tree node, `AsyncRun.label`) doesn't have to strip it back out
- *  of {@link labelFor}'s composite string. */
+ *  model itself (e.g. the async tree node, `AsyncRun.label`). */
 export function nameFor(t: { agent: string; name?: string }, index: number): string {
 	// No catalog of call-signs: an unnamed generic operator stays the agent name, disambiguated
 	// by index. The model is supposed to invent `<call-sign>-<purpose>` itself; this is only the
@@ -333,28 +300,8 @@ export function nameFor(t: { agent: string; name?: string }, index: number): str
 	return sanitizeDisplayLabel(t.name?.trim() || fallback, fallback);
 }
 
-/** Display label for a sub-agent: its bare {@link nameFor} name plus its short model. */
-export function labelFor(t: { agent: string; name?: string; model?: string }, index: number): string {
-	const name = nameFor(t, index);
-	const m = shortModel(t.model);
-	return m ? `${name} · ${m}` : name;
-}
-
-export interface DelegateOutcome {
-	text: string;
-	results: AgentResult[];
-	views: DelegateView[];
-	ok: boolean;
-}
-
-/** Hard ceilings the engine enforces regardless of what the LLM asks for. */
-export interface DelegateLimits {
-	maxConcurrency: number;
-	maxChildren: number;
-}
-
-/** Normalize an LLM-authored concurrency request once for sync scheduling, async scheduling, and
- * policy gates. Fractional/non-finite inputs fail toward serialization instead of rounding up. */
+/** Normalize an LLM-authored concurrency request once for scheduling and policy gates.
+ * Fractional/non-finite inputs fail toward serialization instead of rounding up. */
 export function normalizeDelegateConcurrency(value: number | undefined, maximum: number): number {
 	const ceiling = Math.max(1, Number.isFinite(maximum) ? Math.floor(maximum) : 1);
 	if (value === undefined) return ceiling;
@@ -363,9 +310,8 @@ export function normalizeDelegateConcurrency(value: number | undefined, maximum:
 }
 
 /** Map a task to the run-spec fields the engine accepts — the single source of truth for the
- *  delegate path's field mapping. Exported so the async launch path (extension.ts) routes
- *  through the SAME mapping instead of duplicating it (a duplicated copy is how NP2's
- *  `timeoutMs` could silently miss the async fan-out, which is the interactive default). */
+ *  delegate path's field mapping (a second copy is how a per-leg knob like `timeoutMs` silently
+ *  misses one launch route). */
 export function specOf(t: DelegateTask, index = 0): AgentRunSpec {
 	const renderedBrief = renderDelegationBrief(t.brief);
 	const spec: AgentRunSpec = {
@@ -406,6 +352,18 @@ export interface DelegationKeyInput {
 	isolation?: string;
 }
 
+/** The ledger's view of a task or run spec: just the key fields, absent when unset. */
+export function keyInputOf(t: Pick<DelegateTask, "agent" | "task" | "model" | "role" | "tools" | "isolation">): DelegationKeyInput {
+	return {
+		agent: t.agent,
+		task: t.task,
+		...(t.model ? { model: t.model } : {}),
+		...(t.role ? { role: t.role } : {}),
+		...(t.tools !== undefined ? { tools: t.tools } : {}),
+		...(t.isolation ? { isolation: t.isolation } : {}),
+	};
+}
+
 export class DelegationLedger {
 	private readonly failures = new Map<string, number>();
 	private readonly maxKeys = 200;
@@ -469,9 +427,6 @@ export class DelegationLedger {
  * an operator abort is cancellation, and an engine REJECTION is the harness breaking (see
  * {@link isInfrastructureFailure}) — a full disk or a crashed adapter says nothing about whether the
  * delegation was a good idea, and two of them would blacklist a task that was never really attempted.
- * Lives beside the ledger so every path that records feeds it the same notion of evidence: the sync
- * fan-out settles a rejection as `ok:false` while the single and async paths let it propagate, and
- * without this the identical infrastructure crash would count in one path and vanish in the others.
  */
 export function shouldRecordDelegationOutcome(result: Partial<InfrastructureFailure>): boolean {
 	return result.failureKind !== "abort" && !isInfrastructureFailure(result);
@@ -518,146 +473,3 @@ export function unknownContractError(requested: Array<string | undefined>, insta
 		"`outputContract` takes a contract NAME; omit it for free-form output and describe the report shape in `requiredArtifacts`."
 	);
 }
-
-/**
- * Should this `delegate` call run in the BACKGROUND (async)? An explicit `async` always wins;
- * otherwise an interactive session (`hasUI`) defaults to background — the supervisor stays free and
- * results return as follow-ups — unless the call opts out with `sync: true`. A headless run (no UI,
- * e.g. `pi -p`) defaults to SYNC: the single turn must carry the result, and nothing drains a
- * follow-up after the process exits. `renderCall` passes `hasUI: true` (it only ever fires in a UI),
- * so the async tag it shows tracks the exact same default the execute path takes.
- */
-export function wantsAsyncRun(params: { async?: boolean; sync?: boolean }, hasUI: boolean): boolean {
-	return params.async ?? (hasUI && params.sync !== true);
-}
-
-function viewOf(agent: string, label: string, r: AgentResult): DelegateView {
-	return {
-		agent,
-		label,
-		running: false,
-		ok: r.ok,
-		...(r.failureKind !== undefined ? { failureKind: r.failureKind } : {}),
-		output: r.ok ? r.output || "(no output)" : r.error ?? "(failed)",
-		activity: "",
-		usage: r.usage,
-	};
-}
-
-export async function runDelegate(
-	params: DelegateParams,
-	engine: StrategyEngine,
-	limits: DelegateLimits = { maxConcurrency: 4, maxChildren: 8 },
-	onProgress?: (views: DelegateView[]) => void,
-	onLegStart?: (index: number, abort: () => void) => void,
-	onLegSteerable?: (index: number, steer: SteerFn) => void,
-	/** The RUN-level abort signal — the same one the caller baked into its engine. A whole-run
-	 *  cancellation reaches a leg through THIS, never through the per-leg controller below, so
-	 *  without it a cancelled leg whose engine rejects is filed as an agent failure and the user's
-	 *  own stop renders as FAILED. Mirrors `SDKDeps.signal`, which classifies the same way. */
-	signal?: AbortSignal,
-	/** Authoritative per-leg tool lifecycle; arguments and output are intentionally absent. */
-	onLegToolEvent?: (index: number, event: ToolEvent) => void,
-): Promise<DelegateOutcome> {
-	if (params.tasks && params.tasks.length > 0) {
-		// Enforce the hard ceilings: cap the fan-out and clamp the concurrency the
-		// LLM requested — a strategy/tool call cannot exceed the declared limits.
-		const tasks = params.tasks.slice(0, limits.maxChildren);
-		const dropped = params.tasks.length - tasks.length;
-		const concurrency = normalizeDelegateConcurrency(params.concurrency, limits.maxConcurrency);
-		if (concurrency > 1) {
-			const writeSetError = validateParallelWriteSets(tasks);
-			if (writeSetError) return { text: writeSetError, results: [], views: [], ok: false };
-		}
-		const labels = tasks.map((t, i) => labelFor(t, i));
-		const views: DelegateView[] = tasks.map((t, i) => ({
-			agent: t.agent,
-			label: labels[i] as string,
-			running: true,
-			ok: false,
-			output: "",
-			activity: "",
-			usage: emptyUsage(),
-		}));
-		onProgress?.(views.map((v) => ({ ...v })));
-
-		const results = await mapWithConcurrency(tasks, concurrency, async (t, i) => {
-			const ac = new AbortController();
-			onLegStart?.(i, () => ac.abort());
-			// An engine that REJECTS becomes this leg's own ok:false result: the fan-out's completed
-			// siblings (already spawned and billed) must still reach the supervisor. Nothing in here
-			// is run-fatal — the max-children ceiling was applied to `tasks` before anything spawned.
-			let r: AgentResult;
-			try {
-				r = await engine.run(
-					specOf(t, i),
-					(p) => {
-						// Stream the leg's rolling output + current tool activity.
-						if (p.toolEvent) onLegToolEvent?.(i, p.toolEvent);
-						const cur = views[i] as DelegateView;
-						views[i] = { ...cur, output: p.output || cur.output, activity: p.activity ?? "" };
-						onProgress?.(views.map((v) => ({ ...v })));
-					},
-					ac.signal,
-					(steer) => onLegSteerable?.(i, steer),
-				);
-			} catch (err) {
-				r = legFailure(t.agent, err, ac.signal.aborted || (signal?.aborted ?? false));
-			}
-			views[i] = viewOf(t.agent, labels[i] as string, r);
-			onProgress?.(views.map((v) => ({ ...v })));
-			return r;
-		});
-		const agg = aggregateResults(results);
-		const text =
-			dropped > 0
-				? `${agg.output}\n\n[pi-persona] ${dropped} task(s) beyond the max-children limit (${limits.maxChildren}) were dropped.`
-				: agg.output;
-		return { text, results, views, ok: agg.ok };
-	}
-
-	if (params.agent && params.task) {
-		const single: DelegateTask = { agent: params.agent, task: params.task };
-		if (params.name) single.name = params.name;
-		if (params.skills && params.skills.length > 0) single.skills = params.skills;
-		if (params.model) single.model = params.model;
-		if (params.tools !== undefined) single.tools = params.tools;
-		if (params.role?.trim()) single.role = params.role.trim();
-		if (params.isolation !== undefined) single.isolation = params.isolation;
-		if (params.mcp !== undefined) single.mcp = params.mcp;
-		if (params.timeoutMs !== undefined) single.timeoutMs = params.timeoutMs;
-		if (params.brief !== undefined) single.brief = params.brief;
-		if (params.writeSet !== undefined) single.writeSet = params.writeSet;
-		if (params.outputContract !== undefined) single.outputContract = params.outputContract;
-		const label = labelFor(single, 0);
-		const view: DelegateView = {
-			agent: params.agent,
-			label,
-			running: true,
-			ok: false,
-			output: "",
-			activity: "",
-			usage: emptyUsage(),
-		};
-		onProgress?.([{ ...view }]);
-		const ac = new AbortController();
-		onLegStart?.(0, () => ac.abort());
-		const r = await engine.run(
-			specOf(single),
-			(p) => {
-				if (p.toolEvent) onLegToolEvent?.(0, p.toolEvent);
-				if (p.output) view.output = p.output;
-				view.activity = p.activity ?? "";
-				onProgress?.([{ ...view }]);
-			},
-			ac.signal,
-			(steer) => onLegSteerable?.(0, steer),
-		);
-		const text = r.ok ? r.output || "(no output)" : `Agent "${params.agent}" failed: ${r.error ?? "(no detail)"}`;
-		const terminalView = viewOf(params.agent, label, r);
-		onProgress?.([{ ...terminalView }]);
-		return { text, results: [r], views: [terminalView], ok: r.ok };
-	}
-
-	return { text: "delegate: provide either { agent, task } or { tasks: [{ agent, task }, ...] }", results: [], views: [], ok: false };
-}

package/src/tools/exocom-work.ts

@@ -5,7 +5,7 @@
 import { randomUUID } from "node:crypto";
 import { type Static, Type } from "typebox";
 
-import { type ExtensionAPI, keyHint } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 
 import { attributePeer } from "../core/fence.ts";
@@ -15,6 +15,8 @@ import type { ExocomPlane } from "../exocom/plane.ts";
 import type { ExocomSemanticFrame } from "../exocom/envelope.ts";
 import { EXOCOM_WAIT_MAX_MS, waitTimeoutMs } from "../exocom/wait.ts";
 import { normalizeMetadataText } from "../exocom/registry.ts";
+import { renderLiteralToolResult } from "../ui/literal-tool-result.ts";
+import { createReportBody } from "../ui/report-body.ts";
 
 const TOKEN = { minLength: 1, maxLength: 128, pattern: "^[A-Za-z0-9._:-]+$" } as const;
 
@@ -90,11 +92,6 @@ function result(text: string, details: Record<string, unknown>) {
 	return { content: [{ type: "text" as const, text }], details };
 }
 
-function workToolFailed(renderedResult: unknown): boolean {
-	return !!renderedResult && typeof renderedResult === "object"
-		&& (renderedResult as { isError?: unknown }).isError === true;
-}
-
 export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps): void {
 	const identity = () => {
 		const plane = deps.getPlane();
@@ -122,12 +119,7 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Claim "))}${theme.fg("accent", normalizeMetadataText(args.work_key, 80, "work"))}`, 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom claim failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
-		},
+		renderResult: renderLiteralToolResult,
 	});
 
 	pi.registerTool({
@@ -161,12 +153,7 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Ask "))}${theme.fg("accent", normalizeMetadataText(args.target, 80, "peer"))}`, 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom ask failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
-		},
+		renderResult: renderLiteralToolResult,
 	});
 
 	pi.registerTool({
@@ -191,12 +178,7 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Answer "))}${theme.fg("accent", normalizeMetadataText(args.ask_id, 80, "ask"))}`, 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom answer failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
-		},
+		renderResult: renderLiteralToolResult,
 	});
 
 	pi.registerTool({
@@ -221,12 +203,7 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Decline "))}${theme.fg("accent", normalizeMetadataText(args.ask_id, 80, "ask"))}`, 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom decline failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
-		},
+		renderResult: renderLiteralToolResult,
 	});
 
 	pi.registerTool({
@@ -250,11 +227,14 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Wait "))}${theme.fg("accent", normalizeMetadataText(args.work_key, 80, "work"))}`, 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom wait failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
+		renderResult(res, options, theme, context) {
+			// A retained answer is peer prose, not the literal receipt for arming a wait.
+			// Its ok=false can be a valid negative answer; only the host error flag is failure.
+			if (options.expanded && !(context?.isError ?? res.isError) && res.details?.status === "answered") {
+				const text = res.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+				return createReportBody(text, theme, {}, context?.lastComponent);
+			}
+			return renderLiteralToolResult(res, options, theme, context);
 		},
 	});
 
@@ -274,12 +254,7 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Release "))}${theme.fg("accent", normalizeMetadataText(args.work_key, 80, "work"))}`, 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom release failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
-		},
+		renderResult: renderLiteralToolResult,
 	});
 
 	pi.registerTool({
@@ -298,12 +273,7 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Progress "))}${theme.fg("accent", normalizeMetadataText(args.work_key, 80, "work"))}`, 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom progress failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
-		},
+		renderResult: renderLiteralToolResult,
 	});
 
 	pi.registerTool({
@@ -318,11 +288,6 @@ export function registerExocomWorkTools(pi: ExtensionAPI, deps: ExocomWorkDeps):
 		renderCall(_args, theme) {
 			return new Text(theme.fg("toolTitle", theme.bold("Exocom Status")), 0, 0);
 		},
-		renderResult(res, { expanded }, theme) {
-			const first = res.content.find((item) => item.type === "text");
-			const text = first?.type === "text" ? first.text : "Exocom status failed";
-			if (workToolFailed(res)) return new Text(theme.fg("error", text), 0, 0);
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
-		},
+		renderResult: renderLiteralToolResult,
 	});
 }

package/src/tools/exocom.ts

@@ -19,6 +19,7 @@ import { type Static, Type } from "typebox";
 
 import { keyHint, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
+import { renderLiteralToolResult } from "../ui/literal-tool-result.ts";
 
 import { fencePeer } from "../core/fence.ts";
 import { inventedExocomNameHint } from "../core/naming.ts";
@@ -227,12 +228,11 @@ function isSendDetails(details: unknown): details is ExocomSendDetails {
 	return Array.isArray(shape.failed) || typeof shape.msg_id === "string";
 }
 
-function renderSendResult(details: ExocomSendDetails, expanded: boolean): string {
+function renderSendResult(details: ExocomSendDetails): string {
 	if ("failed" in details) {
 		const failed = details.failedCount ?? details.failed.length;
 		const queued = details.queuedCount ?? details.msg_ids.length;
-		const summary = `${queued > 0 ? "✓" : "✗"} queued ${queued} peer${queued === 1 ? "" : "s"}${failed > 0 ? ` · ${failed} failed` : ""}`;
-		if (!expanded) return `${summary} (${keyHint("app.tools.expand", "to expand")})`;
+		const summary = `queued ${queued} peer${queued === 1 ? "" : "s"}${failed > 0 ? ` · ${failed} failed` : ""}`;
 		const lines = [summary];
 		if (details.msg_ids.length > 0) lines.push(`msg_ids: ${details.msg_ids.join(", ")}`);
 		for (const failure of details.failed) {
@@ -242,8 +242,7 @@ function renderSendResult(details: ExocomSendDetails, expanded: boolean): string
 		if ((details.omittedFailures ?? 0) > 0) lines.push(`…and ${details.omittedFailures} more failures omitted; retry only the failed targets shown above.`);
 		return lines.join("\n");
 	}
-	const summary = `✓ queued to ${details.target} · msg_id=${details.msg_id}`;
-	return expanded ? summary : `${summary} (${keyHint("app.tools.expand", "to expand")})`;
+	return `queued to ${details.target} · msg_id=${details.msg_id}`;
 }
 
 /** `getPlane` is a LIVE accessor, not a captured value: a `canUseBus` downgrade (`stopExocom`,
@@ -294,7 +293,7 @@ export function registerExocomTools(
 		renderCall(_args, theme) {
 			return new Text(theme.fg("toolTitle", theme.bold("Exocom List")), 0, 0);
 		},
-		renderResult(result, { expanded }, theme) {
+		renderResult(result, { expanded }, theme, context) {
 			const details = result.details as unknown as {
 				peers?: ExocomPeerSummary[];
 				total?: number;
@@ -303,9 +302,8 @@ export function registerExocomTools(
 				scopeCode?: string;
 				homeWorkspace?: { label?: string; code?: string; sameAsScope?: boolean };
 			} | undefined;
-			if (!details || !Array.isArray(details.peers)) {
-				const first = result.content.find((item) => item.type === "text");
-				return new Text(theme.fg("error", first?.type === "text" ? first.text : "Exocom list failed"), 0, 0);
+			if (context?.isError || !details || !Array.isArray(details.peers)) {
+				return renderLiteralToolResult(result, { expanded }, theme, { isError: true });
 			}
 			const peers = details.peers;
 			const total = typeof details.total === "number" ? details.total : peers.length;
@@ -448,15 +446,14 @@ export function registerExocomTools(
 			const suffix = preview.length < message.length ? "…" : "";
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Send "))}${theme.fg("accent", target)}${preview ? theme.fg("dim", ` ${preview}${suffix}`) : ""}`, 0, 0);
 		},
-		renderResult(result, { expanded }, theme) {
+		renderResult(result, { expanded }, theme, context) {
 			const details = result.details as unknown as ExocomSendDetails | undefined;
 			// pi renders this for a FAILED call too, handing us the error's empty details object — an
 			// unrecognised shape is a failure to show, not a send to congratulate the user on.
-			if (!isSendDetails(details)) {
-				const text = result.content.find((item) => item.type === "text");
-				return new Text(theme.fg("error", text?.type === "text" ? text.text : "(no result)"), 0, 0);
+			if (context?.isError || !isSendDetails(details)) {
+				return renderLiteralToolResult(result, { expanded }, theme, { isError: true });
 			}
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", renderSendResult(details, expanded)), 0, 0);
+			return renderLiteralToolResult({ ...result, content: [{ type: "text", text: renderSendResult(details) }] }, { expanded }, theme, context);
 		},
 	});
 
@@ -475,15 +472,14 @@ export function registerExocomTools(
 		renderCall(args, theme) {
 			return new Text(`${theme.fg("toolTitle", theme.bold("Exocom Name "))}${theme.fg("accent", normalizeMetadataText(args.name, 96, "peer"))}`, 0, 0);
 		},
-		renderResult(result, { expanded }, theme) {
+		renderResult(result, { expanded }, theme, context) {
 			const details = result.details as unknown as { name?: string } | undefined;
-			if (!details?.name) {
-				const first = result.content.find((item) => item.type === "text");
-				return new Text(theme.fg("error", first?.type === "text" ? first.text : "Exocom name failed"), 0, 0);
+			if (context?.isError || !details?.name) {
+				return renderLiteralToolResult(result, { expanded }, theme, { isError: true });
 			}
 			const name = normalizeMetadataText(details.name, 96, "(unchanged)");
 			const text = `exocom: you are now "${name}"`;
-			return new Text(theme.fg(expanded ? "toolOutput" : "accent", expanded ? text : `${text} (${keyHint("app.tools.expand", "to expand")})`), 0, 0);
+			return renderLiteralToolResult({ ...result, content: [{ type: "text", text }] }, { expanded }, theme, context);
 		},
 	});
 }