@aeondave/pi-persona 1.15.2 → 1.16.0

package/src/tools/delegate-tool.ts

@@ -3,10 +3,10 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import type { AgentConfig } from "../agents/agent.ts";
 import { Type } from "typebox";
 import { fenceUntrusted } from "../core/fence.ts";
-import { Text } from "@earendil-works/pi-tui";
+import { Text, visibleWidth } from "@earendil-works/pi-tui";
 import { Container, Spacer } from "@earendil-works/pi-tui";
 import { configuredModels } from "../extension/engine.ts";
-import { compactInlineText, sanitizeTerminalText } from "../ui/presentation.ts";
+import { compactInlineText, MAX_COLLAPSED_CARD_COLUMNS, sanitizeTerminalText } from "../ui/presentation.ts";
 import { compactVisibleText } from "../ui/presentation.ts";
 import { resolveModelRef } from "../core/models.ts";
 import { inventedLegNameHint } from "../core/naming.ts";
@@ -24,12 +24,125 @@ import type { AgentResult } from "../orchestration/types.ts";
 import { agentNodeStatusForDelegate, sanitizeLabel } from "../extension/shared.ts";
 import type { PersonaController } from "../persona/controller.ts";
 import type { AgentTree } from "../ui/agent-tree.ts";
-import type { AsyncRunTracker } from "../engine/async.ts";
+import { runDisplayName, type AsyncRunTracker } from "../engine/async.ts";
 import { emptyUsage, type ProgressSnapshot, type ToolEvent } from "../engine/stream.ts";
 import { progressPatch } from "../ui/agent-tree.ts";
 import type { AddNodeInput } from "../ui/agent-tree.ts";
 import type { RunLimits } from "../core/capabilities.ts";
 
+interface DelegateLaunchSnapshot {
+	id: string;
+	label: string;
+	agent: string;
+	model?: string;
+}
+
+interface DelegateLaunchRow {
+	id: string;
+	fullName: string;
+	displayName: string;
+	clipped: boolean;
+	hasAlias: boolean;
+}
+
+const COLLAPSED_LAUNCH_ROWS = 3;
+
+/** Prefer session-persisted identity, then recover old launch cards from the live tracker. */
+function launchRows(
+	details: { runId?: unknown; runIds?: unknown; runs?: unknown },
+	tracker: AsyncRunTracker,
+	allowTracker: boolean,
+): DelegateLaunchRow[] {
+	const persisted = new Map<string, DelegateLaunchSnapshot>();
+	if (Array.isArray(details.runs)) {
+		for (const item of details.runs) {
+			if (!item || typeof item !== "object") continue;
+			const run = item as Record<string, unknown>;
+			if (typeof run.id !== "string" || typeof run.label !== "string" || typeof run.agent !== "string") continue;
+			persisted.set(run.id, {
+				id: run.id,
+				label: run.label,
+				agent: run.agent,
+				...(typeof run.model === "string" ? { model: run.model } : {}),
+			});
+		}
+	}
+	const storedIds = Array.isArray(details.runIds)
+		? details.runIds.filter((id): id is string => typeof id === "string")
+		: typeof details.runId === "string" ? [details.runId] : [];
+	const ids = [...storedIds];
+	const seenIds = new Set(ids);
+	for (const id of persisted.keys()) {
+		if (seenIds.has(id)) continue;
+		seenIds.add(id);
+		ids.push(id);
+	}
+	const entries = ids.map((id): { run: DelegateLaunchSnapshot; hasAlias: boolean } => {
+		const saved = persisted.get(id);
+		if (saved) return { run: saved, hasAlias: true };
+		const tracked = allowTracker ? tracker.peek(id) : undefined;
+		if (tracked) {
+			return {
+				run: {
+					id,
+					label: tracked.label ?? tracked.agent,
+					agent: tracked.agent,
+					...(tracked.model ? { model: tracked.model } : {}),
+				},
+				hasAlias: true,
+			};
+		}
+		// Older history may outlive both its launch snapshot and tracker entry. Retain the
+		// routing id as an explicitly diagnostic fallback so the batch count stays complete.
+		return { run: { id, label: id, agent: id }, hasAlias: false };
+	});
+	const named = entries.map(({ run, hasAlias }) => ({
+		id: compactInlineText(run.id, { maxChars: 64 }) || "run",
+		fullName: runDisplayName(run),
+		hasAlias,
+	}));
+	const counts = new Map<string, number>();
+	for (const row of named) counts.set(row.fullName, (counts.get(row.fullName) ?? 0) + 1);
+	return named.map((row) => {
+		const displayName = counts.get(row.fullName)! > 1
+			? `${compactInlineText(row.fullName, { maxChars: 56 })} [${compactInlineText(row.id, { maxChars: 16 })}]`
+			: row.fullName;
+		return {
+			...row,
+			displayName,
+			clipped: compactInlineText(displayName, { maxChars: 80 }) !== displayName,
+		};
+	});
+}
+
+function collapsedLaunchSummary(rows: readonly DelegateLaunchRow[], dropped: number | undefined): string {
+	const prefix = "delegate launched ";
+	const dropNote = dropped && dropped > 0 ? ` · ${dropped} task${dropped === 1 ? "" : "s"} dropped` : "";
+	const maxVisible = Math.min(rows.length, COLLAPSED_LAUNCH_ROWS);
+	for (let count = maxVisible; count >= 1; count--) {
+		const names = rows.slice(0, count).map((row) => row.displayName);
+		const omitted = rows.length - names.length;
+		const suffix = omitted > 0 ? `, +${omitted} more` : "";
+		const body = `${prefix}${names.join(", ")}${suffix}${dropNote}`;
+		const needsHint = omitted > 0 || rows.slice(0, count).some((row) => row.clipped) || body.length > MAX_COLLAPSED_CARD_COLUMNS || visibleWidth(body) > MAX_COLLAPSED_CARD_COLUMNS;
+		const candidate = `${body}${needsHint ? ` · ${expandDetailHint()}` : ""}`;
+		if (candidate.length <= MAX_COLLAPSED_CARD_COLUMNS && visibleWidth(candidate) <= MAX_COLLAPSED_CARD_COLUMNS) return candidate;
+	}
+	const omitted = rows.length - 1;
+	const suffix = omitted > 0 ? `, +${omitted} more` : "";
+	const hint = ` · ${expandDetailHint()}`;
+	const fixed = `${prefix}${suffix}${dropNote}${hint}`;
+	const aliasLimit = Math.max(16, Math.min(MAX_COLLAPSED_CARD_COLUMNS - visibleWidth(fixed), MAX_COLLAPSED_CARD_COLUMNS - fixed.length));
+	const first = compactInlineText(rows[0]!.displayName, { maxChars: aliasLimit });
+	return compactInlineText(`${prefix}${first}${suffix}${dropNote}${hint}`, { maxChars: MAX_COLLAPSED_CARD_COLUMNS });
+}
+
+function expandedLaunchDetails(text: string, rows: readonly DelegateLaunchRow[]): string {
+	if (rows.length === 0 || !rows.some((row) => row.hasAlias)) return text;
+	const diagnostics = rows.map((row) => `- ${row.fullName} [${row.id}]`).join("\n");
+	return `${text}\n\nLaunched workers:\n${diagnostics}`;
+}
+
 export interface DelegateToolDeps {
 	get lastCtx(): ExtensionContext | undefined;
 	set lastCtx(value: ExtensionContext | undefined);
@@ -290,9 +403,10 @@ export function registerDelegateTool(pi: ExtensionAPI, d: DelegateToolDeps): voi
 			"Pass agent and task for one worker, or a tasks array for parallel workers. Follow the active persona's delegation policy for required fields.",
 			"When requireBrief is active, EVERY worker needs brief: { objective, scopeRoe, position, constraints, requiredArtifacts, stopConditions } with nonempty values, including read-only scouts. In parallel mode put it in each tasks[].brief; task prose and a top-level brief do not substitute. Read the current per-turn delegation brief for a complete example.",
 			"A persona may also require a structured output contract or disjoint writeSet ownership for parallel writers. Incomplete calls are rejected before any worker starts; fill the missing fields across the batch before retrying.",
-			"In interactive sessions it runs in the BACKGROUND by default: you get run ids at once, stay free,",
-			"and each result returns to you automatically as a follow-up — do NOT poll (`intercom wait` only when",
-			"you need a result before your very next step; `sync: true` to block instead; headless runs default to sync).",
+			"In interactive sessions it runs in the BACKGROUND by default: you get run ids at once and stay free.",
+			"Work independently while children run; when only children remain, end your turn and let their automatic completion follow-ups wake you.",
+			"Do not monitor, poll, or automatically wait for all children. Use `intercom wait` only when a result is needed before your next step; `sync: true` intentionally blocks instead; headless runs default to sync.",
+			"Steering received during an active tool may be acted on after that tool returns; do not assume arbitrary tool work is interrupted immediately.",
 			"No fitting agent? Shape one on the fly: `operator` + `role` (extra system prompt) + `skills`.",
 			"Assign each worker's name before launch so it sees the same identity from its first turn; omitted names keep the generic fallback.",
 			"A `model` may be a loose name ('sonnet') — it resolves to YOUR provider's id; ambiguous names return",
@@ -449,13 +563,17 @@ export function registerDelegateTool(pi: ExtensionAPI, d: DelegateToolDeps): voi
 				const batchSlots = effectiveConcurrency < tasks.length ? new Semaphore(effectiveConcurrency) : undefined;
 				const nameOffset = asyncNameSequence;
 				asyncNameSequence += tasks.length;
-				const ids = tasks.map((t, i) => {
+				const runs = tasks.map((t, i): DelegateLaunchSnapshot => {
 					// Routed through specOf() (not a hand-rolled field list) so this, the interactive
 					// DEFAULT delegate path, never drifts from the sync path's mapping — NP2's per-leg
 					// `timeoutMs` (and any future knob) lands here for free instead of needing a second copy.
 					const spec = specOf(t, nameOffset + i);
-					return launchAsyncRun(t.agent, t.task, spec, nameFor(t, nameOffset + i), batchSlots);
+					const label = nameFor(t, nameOffset + i);
+					const id = launchAsyncRun(t.agent, t.task, spec, label, batchSlots);
+					const model = shortModel(spec.model);
+					return { id, label, agent: t.agent, ...(model ? { model } : {}) };
 				});
+				const ids = runs.map((run) => run.id);
 				const droppedNote = dropped > 0 ? ` ${dropped} task(s) beyond the max-children limit (${d.RUN_LIMITS.maxChildren}) were dropped.` : "";
 				return {
 					content: [
@@ -464,7 +582,7 @@ export function registerDelegateTool(pi: ExtensionAPI, d: DelegateToolDeps): voi
 							text: `Launched ${ids.length} async runs in the background (${ids.join(", ")}) — keep working; each notifies on completion. /peek to watch.${droppedNote}`,
 						},
 					],
-					details: { runIds: ids },
+					details: { runIds: ids, runs, ...(dropped > 0 ? { dropped } : {}) },
 					isError: false,
 				};
 			}
@@ -476,7 +594,9 @@ export function registerDelegateTool(pi: ExtensionAPI, d: DelegateToolDeps): voi
 				// survive exactly as they do in fan-out and sync mode.
 				const single = { ...params, agent, task };
 				const runSpec = specOf(single, nameIndex);
-				const id = launchAsyncRun(agent, task, runSpec, nameFor(single, nameIndex));
+				const label = nameFor(single, nameIndex);
+				const id = launchAsyncRun(agent, task, runSpec, label);
+				const model = shortModel(runSpec.model);
 				return {
 					content: [
 						{
@@ -484,7 +604,7 @@ export function registerDelegateTool(pi: ExtensionAPI, d: DelegateToolDeps): voi
 							text: `Launched async run ${id} (${agent}) — runs in the background; you'll be notified on completion. /peek ${id} to watch.`,
 						},
 					],
-					details: { runId: id },
+					details: { runId: id, runs: [{ id, label, agent, ...(model ? { model } : {}) }] },
 					isError: false,
 				};
 			}
@@ -561,27 +681,25 @@ export function registerDelegateTool(pi: ExtensionAPI, d: DelegateToolDeps): voi
 			const title = theme.fg("toolTitle", theme.bold("delegate "));
 			const coerced = coerceDelegateParams(args);
 			const view = coerced.ok ? coerced.params : undefined;
+			const mode = wantsAsyncRun(view ?? args, true) ? theme.fg("warning", " async") : theme.fg("dim", " sync");
 			if (view?.tasks && view.tasks.length > 0) {
 				// Names live in the tree / final card — keep the call line itself minimal.
-				return new Text(`${title}${theme.fg("accent", `parallel (${view.tasks.length})`)}`, 0, 0);
+				return new Text(`${title}${theme.fg("accent", `parallel (${view.tasks.length})`)}${mode}`, 0, 0);
 			}
 			if (typeof args.tasks === "string" && args.tasks.trim()) {
-				return new Text(`${title}${theme.fg("accent", "parallel")}`, 0, 0);
+				return new Text(`${title}${theme.fg("accent", "parallel")}${mode}`, 0, 0);
 			}
-			const agent = compactInlineText(view?.agent ?? args.agent ?? "?", { maxChars: 80 }) || "?";
-			const preview = compactInlineText(view?.task ?? args.task ?? "", { maxChars: 60 });
-			// renderCall only fires in an interactive UI, where delegate runs in the BACKGROUND by
-			// default — pass hasUI:true to the same wantsAsyncRun the execute path uses, so the common
-			// (defaulted) background run still shows the tag; `sync: true` drops it.
-			const asyncTag = wantsAsyncRun(view ?? args, true) ? theme.fg("warning", " async") : "";
-			return new Text(`${title}${theme.fg("accent", agent)}${asyncTag}${theme.fg("dim", ` ${preview}`)}`, 0, 0);
+			const identity = [view?.name ?? args.name, view?.agent ?? args.agent ?? "?"].filter(Boolean).join(" · ");
+			const modelValue = view?.model ?? args.model;
+			const model = typeof modelValue === "string" && modelValue.trim() ? theme.fg("dim", ` · ${compactInlineText(shortModel(modelValue), { maxChars: 48 })}`) : "";
+			return new Text(`${title}${theme.fg("accent", compactInlineText(identity, { maxChars: 96 }) || "?")}${model}${mode}`, 0, 0);
 		},
 
-		renderResult(result, { expanded }, theme) {
+		renderResult(result, { expanded }, theme, context) {
 			// Safe: the delegate `execute` above always stores `{ views: DelegateView[] }` (sync,
 			// single/parallel) or `{ runId | runIds }` (async) in `details`; the double cast just narrows
 			// Pi's opaque `details` type to that known shape for rendering.
-			const details = result.details as unknown as { views?: DelegateView[]; runId?: string; runIds?: string[] } | undefined;
+			const details = result.details as unknown as { views?: DelegateView[]; runId?: string; runIds?: string[]; runs?: unknown; dropped?: number } | undefined;
 			const views = details?.views ?? [];
 			if (views.length === 0) {
 				const first = result.content[0];
@@ -590,8 +708,28 @@ export function registerDelegateTool(pi: ExtensionAPI, d: DelegateToolDeps): voi
 					: details?.runId
 						? `async run ${details.runId}`
 						: "(no output)";
-				const text = first?.type === "text" ? first.text : fallback;
-				return new Text(sanitizeTerminalText(text), 0, 0);
+				const text = sanitizeTerminalText(first?.type === "text" ? first.text : fallback);
+				const allowTracker = context === undefined || context.isPartial === true;
+				const rows = details ? launchRows(details, d.tracker, allowTracker) : [];
+				if (expanded) return new Text(expandedLaunchDetails(text, rows), 0, 0);
+				if (details?.runId || details?.runIds?.length) {
+					if (rows.length > 0 && !result.isError) {
+						return new Text(theme.fg("accent", collapsedLaunchSummary(rows, details.dropped)), 0, 0);
+					}
+					if (result.isError) {
+						const preview = compactVisibleText(text, { maxLines: 4, maxLineChars: 100 });
+						return new Text(`${theme.fg("error", theme.bold("failed"))}\n${theme.fg("toolOutput", preview.text)}${preview.truncated ? `\n${theme.fg("dim", expandDetailHint())}` : ""}`, 0, 0);
+					}
+					const ids = details.runIds?.length ? details.runIds.slice(0, 3) : [details.runId as string];
+					const omitted = (details.runIds?.length ?? 0) - ids.length;
+					const dropped = details.dropped ? ` · ${details.dropped} task${details.dropped === 1 ? "" : "s"} dropped (max children)` : "";
+					return new Text(`${theme.fg("toolTitle", theme.bold("delegate "))}${theme.fg("accent", `launched ${ids.join(", ")}${omitted > 0 ? `, +${omitted} more` : ""}`)}${theme.fg("dim", dropped)}`, 0, 0);
+				}
+				if (result.isError) {
+					const preview = compactVisibleText(text, { maxLines: 4, maxLineChars: 100 });
+					return new Text(`${theme.fg("error", theme.bold("delegate failed"))}\n${theme.fg("toolOutput", preview.text)}${preview.truncated ? `\n${theme.fg("dim", expandDetailHint())}` : ""}`, 0, 0);
+				}
+				return new Text(theme.fg("toolOutput", compactVisibleText(text, { maxLines: 4, maxLineChars: 100 }).text), 0, 0);
 			}
 			const title = theme.fg("toolTitle", theme.bold("delegate "));
 			const running = views.filter((v) => v.running).length;

package/src/tools/intercom-tool.ts

@@ -10,7 +10,7 @@ import {
 	type AsyncRun, AsyncRunTracker, boundCompletionSurface, buildPeekDigest, buildWaitTimeoutNote,
 	MAX_ASYNC_STATUS_ROWS,
 	dedupeRunsById, getFullRunOutput, IdleCoalescingNotifier,
-	renderCompletion, runDurationLabel,
+	renderCompletion, runDisplayName, runDurationLabel,
 } from "../engine/async.ts";
 import { fenceUntrusted } from "../core/fence.ts";
 import { sanitizeDisplayLabel } from "../core/display-label.ts";
@@ -31,6 +31,7 @@ export interface IntercomToolDeps {
 	bus: InProcessBus;
 	SUPERVISOR: string;
 	STALL_FLAG_MS: number;
+	waitingRunIds?: () => ReadonlySet<string>;
 	missingRunMessage(id: string, display: string | undefined): string;
 	stopAgent(nodeId: string): boolean;
 	steerAgent(nodeId: string, text: string): boolean;
@@ -60,7 +61,22 @@ export function fenceIntercomToolOutcome(out: IntercomOutcome, action: string, f
 	return action === "message" && out.details.ok ? fence(out.text) : fenceIntercomOutcome(out, fence);
 }
 
+/** Renderer-local state only. The persisted result, not this cache, owns display identity. */
+interface IntercomRenderState {
+	target?: { id: string; label: string };
+	callText?: Text;
+	formatCall?: (target: string) => string;
+}
+
 export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): void {
+	function displayRunTarget(id: string): string {
+		const run = d.tracker?.peek(id);
+		if (!run) return sanitizeDisplayLabel(id, "run");
+		const name = runDisplayName(run);
+		// An alias is presentation, never a unique address. Disambiguate collisions without rerouting.
+		const collision = d.tracker.list().some((other) => other.id !== id && runDisplayName(other) === name);
+		return collision ? `${name} [${sanitizeDisplayLabel(id, "run")}]` : name;
+	}
 	// ── intercom tool (supervisor side of the comm plane: read/answer children) ───
 	const IntercomToolParams = Type.Object({
 		action: Type.Union(
@@ -78,14 +94,15 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 			],
 			{
 				description:
-					"peek = watch async sub-agents · result = retrieve one complete settled result by run id · wait = BLOCK until async run(s) settle and collect their bounded reports (a join) · steer = soft redirect into one by run id (it may ignore it) · stop = request engine cancellation by run id · message = retrieve one drained bus message by message id · list/inbox/reply/send = coaching messages (needs a coaching persona)",
+					"peek = watch async sub-agents · result = retrieve one complete settled result by run id · wait = collect current reports; sync:true joins (default: nonblocking with UI, blocking headless) · steer = soft redirect into one by run id (it may ignore it) · stop = request engine cancellation by run id · message = retrieve one drained bus message by message id · list/inbox/reply/send = coaching messages (needs a coaching persona)",
 			},
 		),
-		to: Type.Optional(Type.String({ maxLength: MAX_INTERCOM_REF_CHARS, description: "result/steer/stop/peek: the async run id (e.g. 'run-1') · wait: an async run id; omit it to join all running and pending completions · send: the child handle (from `list`)" })),
+		to: Type.Optional(Type.String({ maxLength: MAX_INTERCOM_REF_CHARS, description: "result/steer/stop/peek: the async run id (e.g. 'run-1') · wait: an async run id; omit it to collect all current/pending completions · send: the child handle (from `list`)" })),
 		messageId: Type.Optional(Type.String({ maxLength: MAX_INTERCOM_REF_CHARS, description: "message: the drained bus message id shown by `inbox`" })),
 		askId: Type.Optional(Type.String({ maxLength: MAX_INTERCOM_REF_CHARS, description: "reply: the message id of the child's pending question" })),
 		message: Type.Optional(Type.String({ maxLength: MAX_INTERCOM_MESSAGE_CHARS, description: "steer/reply/send: the text to deliver" })),
-		timeoutMs: Type.Optional(Type.Number({ description: "wait: max ms to hold your turn (default 600000; values below 1000 clamp to 1000, values above 600000 clamp to 600000) — on timeout you get what settled + what's still running" })),
+		sync: Type.Optional(Type.Boolean({ description: "wait: block for runs to settle; defaults to false in interactive/RPC sessions and true in headless sessions" })),
+		timeoutMs: Type.Optional(Type.Number({ description: "wait with sync:true: max ms to hold your turn (default 600000; values below 1000 clamp to 1000, values above 600000 clamp to 600000) — on timeout you get what settled + what's still running" })),
 	});
 	pi.registerTool({
 		name: "intercom",
@@ -93,9 +110,10 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 		description: [
 			"See, steer, message, and JOIN your running sub-agents.",
 			"`peek` watches what your async sub-agents are doing; `result` retrieves one complete settled",
-			"payload by run id; `wait` blocks until runs settle and returns a bounded join report;",
+			"payload by run id; `wait` collects current reports and is nonblocking by default with UI (interactive/RPC); set `sync: true` for an intentional bounded join. Headless defaults to joining; set `sync: false` for a snapshot. Do not automatically wait for all children.",
+			"Work independently while children run; when only children remain, end your turn and let completion follow-ups wake you; do not monitor or poll healthy children.",
 			"`steer` sends a soft course-correction to one (by run id); in-process async runs can receive it mid-run,",
-			"while child-engine (MCP/worktree) async runs receive it as a brokered follow-up.",
+			"while child-engine (MCP/worktree) async runs receive it as a brokered follow-up. After remaining tools return, Pi can consume steering; arbitrary active tool work is not promised to stop immediately.",
 			"`message` retrieves a drained bus message by its message id; `list`/`inbox`/`reply`/`send` exchange coaching messages (a child reaches you via `contact_supervisor`)",
 			"and need a `coaching: on` persona.",
 		].join(" "),
@@ -105,6 +123,7 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 			// `to` comes from model-authored tool arguments. Use the exact value for routing, but never
 			// interpolate it into trusted prose without reducing it to compact identifier metadata.
 			const displayTarget = params.to === undefined ? undefined : sanitizeDisplayLabel(params.to, "run");
+			const targetSnapshot = params.to === undefined ? {} : { runId: params.to, target: displayRunTarget(params.to) };
 			// peek + wait + steer + stop are supervisor→child controls over the async d.tracker /
 			// steer handles — available to EVERY persona (no dependency on the coaching bus).
 			if (params.action === "peek") {
@@ -113,7 +132,7 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 				const runs = params.to
 					? [d.tracker.peek(params.to)].filter((r): r is AsyncRun => !!r)
 					: dedupeRunsById([...d.tracker.running(), ...d.completionNotifier.peekPending()]);
-				return { content: [{ type: "text", text: buildPeekDigest(runs, { now: Date.now(), stallMs: d.STALL_FLAG_MS }) }], details: { action: "peek", ok: true }, isError: false };
+				return { content: [{ type: "text", text: buildPeekDigest(runs, { now: Date.now(), stallMs: d.STALL_FLAG_MS, ...(d.waitingRunIds ? { waitingForSupervisor: d.waitingRunIds() } : {}) }) }], details: { action: "peek", ok: true, ...targetSnapshot }, isError: false };
 			}
 			if (params.action === "result") {
 				if (!params.to) {
@@ -121,12 +140,12 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 				}
 				const run = d.tracker.peek(params.to);
 				if (!run) {
-					return { content: [{ type: "text", text: d.missingRunMessage(params.to, displayTarget) }], details: failureDetails({ action: "result", ok: false }), isError: true };
+					return { content: [{ type: "text", text: d.missingRunMessage(params.to, displayTarget) }], details: failureDetails({ action: "result", ok: false, ...targetSnapshot }), isError: true };
 				}
 				if (run.status === "running") {
 					return {
-						content: [{ type: "text", text: `${displayTarget} is still running. Use intercom peek/wait, or request result after it settles.` }],
-						details: failureDetails({ action: "result", ok: false, status: run.status }),
+						content: [{ type: "text", text: `${targetSnapshot.target} is still running. Use intercom peek/wait, or request result after it settles.` }],
+						details: failureDetails({ action: "result", ok: false, status: run.status, ...targetSnapshot }),
 						isError: true,
 					};
 				}
@@ -149,7 +168,7 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 				d.publishPersonaCost();
 				return {
 					content: [{ type: "text", text: `${run.id} (${displayRun}) · ${run.status}${took ? ` · ${took}` : ""}${cause}\n${body}` }],
-					details: { action: "result", ok: true, status: run.status, runId: run.id },
+					details: { action: "result", ok: true, status: run.status, ...targetSnapshot },
 					isError: false,
 					...toolUsageField(billed),
 				};
@@ -158,7 +177,7 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 				// No `to` → wait on running legs AND collect settled legs still queued for follow-up
 				// delivery, so a wait in the settle→deliver gap returns their results (not "nothing").
 				if (params.to && !d.tracker.peek(params.to)) {
-					return { content: [{ type: "text", text: d.missingRunMessage(params.to, displayTarget) }], details: failureDetails({ action: "wait", ok: false }), isError: true };
+					return { content: [{ type: "text", text: d.missingRunMessage(params.to, displayTarget) }], details: failureDetails({ action: "wait", ok: false, ...targetSnapshot }), isError: true };
 				}
 				const ids = params.to
 					? [params.to]
@@ -166,6 +185,31 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 				if (ids.length === 0) {
 					return { content: [{ type: "text", text: "No async runs to wait for." }], details: { action: "wait", ok: true }, isError: false };
 				}
+				// Interactive/RPC defaults to a snapshot: waiting inside a tool stalls queued user steering.
+				// Headless retains its historical join; callers can override either default with sync.
+				if (!(params.sync ?? ctx.hasUI !== true)) {
+					const current = ids.map((id) => d.tracker.peek(id)).filter((run): run is AsyncRun => !!run);
+					const settled = current.filter((run) => run.status !== "running");
+					const still = current.filter((run) => run.status === "running");
+					const settledIds = new Set(settled.map((run) => run.id));
+					d.completionNotifier.discard((run) => settledIds.has(run.id));
+					for (const id of settledIds) d.tracker.markCollected(id);
+					const report = settled.length > 0 ? renderCompletion(settled, fenceUntrusted, (t) => d.scanForSurrender(t)) : "";
+					const stillIds = still.map((run) => sanitizeDisplayLabel(run.id, "run"));
+					const omitted = stillIds.length > MAX_ASYNC_STATUS_ROWS;
+					const runningNote = still.length > 0
+						? `Background continues; automatic completion will notify you. End your turn when this is the only remaining work. Still running: ${stillIds.slice(0, MAX_ASYNC_STATUS_ROWS).join(", ")}${omitted ? `, … +${stillIds.length - MAX_ASYNC_STATUS_ROWS} more` : ""}.`
+						: "";
+					const text = boundCompletionSurface([report, runningNote].filter(Boolean).join("\n\n") || "Nothing to report (unknown run ids?).");
+					const billed = d.childUsage.accountMany(settled.map((run) => ({ key: run.id, usage: run.result?.usage ?? emptyUsage() })));
+					d.publishPersonaCost();
+					return {
+						content: [{ type: "text", text }],
+							details: { action: "wait", ok: true, settled: [...settledIds], running: still.map((run) => run.id), ...targetSnapshot },
+						isError: false,
+						...toolUsageField(billed),
+					};
+				}
 				// Bounded join: never longer than a child's ask timeout (bus `ask` default 600s),
 				// so a coaching child blocking on OUR reply can't deadlock us past its own timeout.
 				// Default matches that ceiling — heavy sub-agents (30+ turns) routinely outlast a
@@ -193,7 +237,7 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 				d.publishPersonaCost();
 				return {
 					content: [{ type: "text", text }],
-					details: { action: "wait", ok: true, settled: [...settledIds], running: still.map((r) => r.id) },
+					details: { action: "wait", ok: true, settled: [...settledIds], running: still.map((r) => r.id), ...targetSnapshot },
 					isError: false,
 					...toolUsageField(billed),
 				};
@@ -203,18 +247,26 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 					return { content: [{ type: "text", text: "intercom steer needs { to: <run id>, message }." }], details: failureDetails({ action: "steer", ok: false }), isError: true };
 				}
 				const nodeId = `async:${params.to}`;
+				const knownRun = d.tracker.peek(params.to);
+				if (knownRun && knownRun.status !== "running") {
+					return {
+						content: [{ type: "text", text: `Cannot steer "${targetSnapshot.target}" — this run is already settled (${knownRun.status}). Use intercom result with to="${displayTarget}" to inspect its retained result.` }],
+						details: failureDetails({ action: "steer", ok: false, status: knownRun.status, ...targetSnapshot }),
+						isError: true,
+					};
+				}
 				if (!d.steerRegistry.has(nodeId)) {
 					return {
-						content: [{ type: "text", text: `Cannot steer "${displayTarget}" — no live steer handle is available (the run may have finished or not started yet, or its engine/broker does not expose steering).` }],
-						details: failureDetails({ action: "steer", ok: false }),
+						content: [{ type: "text", text: `Cannot steer "${targetSnapshot.target}" — no live steer handle is available (the run may not have started yet, or its engine/broker does not expose steering).` }],
+						details: failureDetails({ action: "steer", ok: false, ...targetSnapshot }),
 						isError: true,
 					};
 				}
 				// Routed through the guarded d.steerAgent so a just-finished/d.disposed handle can't throw.
 				const steered = d.steerAgent(nodeId, params.message);
 				return steered
-					? { content: [{ type: "text", text: `Steering sent to ${displayTarget} (soft request; use action "stop" to request cancellation).` }], details: { action: "steer", ok: true }, isError: false }
-					: { content: [{ type: "text", text: `Could not steer "${displayTarget}" — it may have just finished, or the message was empty.` }], details: failureDetails({ action: "steer", ok: false }), isError: true };
+					? { content: [{ type: "text", text: `Steering queued for ${targetSnapshot.target} (${displayTarget}).` }], details: { action: "steer", ok: true, ...targetSnapshot, message: params.message }, isError: false }
+					: { content: [{ type: "text", text: `Could not steer "${targetSnapshot.target}" — it may have just finished, or the message was empty.` }], details: failureDetails({ action: "steer", ok: false, ...targetSnapshot }), isError: true };
 			}
 			if (params.action === "stop") {
 				if (!params.to) {
@@ -226,21 +278,21 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 				const repeated = d.stopRequested.has(nodeId);
 				const stopped = d.stopAgent(nodeId);
 				if (stopped && !repeated) {
-					return { content: [{ type: "text", text: `Cancellation requested for ${displayTarget}. Check its terminal result; changes already made are not undone.` }], details: { action: "stop", ok: true }, isError: false };
+					return { content: [{ type: "text", text: `Cancellation requested for ${targetSnapshot.target}. Check its terminal result; changes already made are not undone.` }], details: { action: "stop", ok: true, ...targetSnapshot }, isError: false };
 				}
 				// A repeated stop has just invoked the REAL cancel handle again. Only now force-clear
 				// d.tracker state if engine settlement is still lagging; the handle remains registered
 				// until onComplete so cancellation can never be replaced by UI-only bookkeeping.
 				if (stopped && repeated && d.tracker.forceSettle(params.to, "force-stopped by supervisor after repeated engine cancellation")) {
 					return {
-						content: [{ type: "text", text: `Force-cleared ${displayTarget} after repeating the engine cancellation; it will no longer be tracked as running.` }],
-						details: { action: "stop", ok: true },
+						content: [{ type: "text", text: `Force-cleared ${targetSnapshot.target} after repeating the engine cancellation; it will no longer be tracked as running.` }],
+						details: { action: "stop", ok: true, ...targetSnapshot },
 						isError: false,
 					};
 				}
 				return {
-					content: [{ type: "text", text: `Cannot stop "${displayTarget}" — no such running run (it already finished).` }],
-					details: failureDetails({ action: "stop", ok: false }),
+					content: [{ type: "text", text: `Cannot stop "${targetSnapshot.target}" — no such running run (it already finished).` }],
+					details: failureDetails({ action: "stop", ok: false, ...targetSnapshot }),
 					isError: true,
 				};
 			}
@@ -261,28 +313,63 @@ export function registerIntercomTool(pi: ExtensionAPI, d: IntercomToolDeps): voi
 			}
 			return { content: [{ type: "text", text }], details: out.details.ok ? out.details : failureDetails(out.details), isError: !out.details.ok };
 		},
-		renderCall(args, theme) {
+		renderCall(args, theme, context) {
+			const state = context?.state as IntercomRenderState | undefined;
 			const action = compactInlineText(args.action ?? "?", { maxChars: 24 }) || "?";
 			let target = "";
-			if (action === "wait" || action === "peek") target = compactInlineText(args.to ?? "all", { maxChars: 80 }) || "all";
-			else if (["result", "steer", "stop", "send"].includes(action)) target = compactInlineText(args.to ?? "?", { maxChars: 80 }) || "?";
+			const runTarget = typeof args.to === "string"
+				? state?.target?.id === args.to ? state.target.label : displayRunTarget(args.to)
+				: undefined;
+			if (action === "wait" || action === "peek") target = runTarget ?? "all";
+			else if (["result", "steer", "stop"].includes(action)) target = runTarget ?? "?";
+			else if (action === "send") target = compactInlineText(args.to ?? "?", { maxChars: 80 }) || "?";
 			else if (action === "message") target = compactInlineText(args.messageId ?? "?", { maxChars: 80 }) || "?";
 			else if (action === "reply") target = compactInlineText(args.askId ?? "?", { maxChars: 80 }) || "?";
 			const timeout = action === "wait" && Number.isFinite(args.timeoutMs) && args.timeoutMs !== undefined
 				? ` · ${Math.max(0, Math.floor(args.timeoutMs))}ms`
 				: "";
-			return new Text(
-				`${theme.fg("toolTitle", theme.bold("intercom "))}${theme.fg("accent", action)}${target ? theme.fg("dim", ` ${target}${timeout}`) : ""}`,
-				0,
-				0,
-			);
+			const formatCall = (label: string) => `${theme.fg("toolTitle", theme.bold("intercom "))}${theme.fg("accent", action)}${label ? theme.fg("dim", ` ${compactInlineText(label, { maxChars: 80 })}${timeout}`) : ""}`;
+			const component = new Text(formatCall(target), 0, 0);
+			if (state) { state.callText = component; state.formatCall = formatCall; }
+			return component;
 		},
-		renderResult(result, { expanded }, theme) {
-			const details = (result.details ?? {}) as { action?: string; ok?: boolean };
+		renderResult(result, { expanded }, theme, context) {
+			const details = (result.details ?? {}) as { action?: string; ok?: boolean; runId?: string; target?: string; message?: string };
+			const state = context?.state as IntercomRenderState | undefined;
+			const action = details.action ?? context?.args?.action;
+			const savedId = details.runId ?? context?.args?.to;
+			const legacyCompleted = !details.target && context !== undefined && context.isPartial !== true
+				&& ["steer", "stop", "result", "peek", "wait"].includes(action ?? "");
+			if (state && typeof savedId === "string" && (details.target || legacyCompleted)) {
+				// Old receipts have no display snapshot. A new session may reuse their run ID;
+				// the current tracker cannot supply a historical alias for that unrelated execution.
+				state.target = { id: savedId, label: details.target ? compactInlineText(details.target, { maxChars: 80 }) : sanitizeDisplayLabel(savedId, "run") };
+				// Pi renders the call before the result. Update that same Text rather than causing a
+				// recursive invalidation, so restored history uses its saved alias on its first frame.
+				if (state.callText && state.formatCall) state.callText.setText(state.formatCall(state.target.label));
+			}
 			const first = result.content[0];
 			const full = sanitizeTerminalText(first?.type === "text" ? first.text : "(no output)");
 			const failed = details.ok === false;
 			const prefix = failed ? `${theme.fg("error", theme.bold("failed"))}\n` : "";
+			if (details.action === "steer" && details.ok === true) {
+				const target = compactInlineText(details.target ?? state?.target?.label ?? (legacyCompleted && typeof savedId === "string" ? sanitizeDisplayLabel(savedId, "run") : details.runId ? displayRunTarget(details.runId) : ""), { maxChars: 80 });
+				const message = typeof details.message === "string" ? details.message : context?.args?.message;
+				// Old persisted receipts may predate message snapshots. Keep their original content
+				// available in expansion rather than fabricating a message that was never recorded.
+				if (expanded) {
+					const text = typeof message === "string"
+						? `Steering queued${target ? ` for ${target}` : ""}.${details.runId ? `\nRun: ${sanitizeDisplayLabel(details.runId, "run")}` : ""}\n\n${sanitizeTerminalText(message)}`
+						: full;
+					return new Text(theme.fg("toolOutput", text), 0, 0);
+				}
+				const title = compactInlineText(`steering queued${target ? ` · ${target}` : ""}`, { maxChars: 100 });
+				const preview = typeof message === "string" ? compactVisibleText(message, { maxLines: 3, maxLineChars: 100 }) : undefined;
+				// Native Pi already rendered `intercom steer <alias>` above this result. Show the
+				// instruction directly there; only standalone/older renderers need another identity row.
+				const showTitle = !state?.callText || !preview;
+				return new Text(`${showTitle ? theme.fg("success", title) : ""}${preview ? `${showTitle ? "\n" : ""}${theme.fg("toolOutput", preview.text)}${preview.truncated ? `\n${theme.fg("dim", expandDetailHint())}` : ""}` : ""}`, 0, 0);
+			}
 			if (expanded) return new Text(`${prefix}${theme.fg("toolOutput", full)}`, 0, 0);
 			const preview = compactVisibleText(full, { maxLines: 4, maxLineChars: 100 });
 			const hint = preview.truncated ? `\n${theme.fg("dim", expandDetailHint())}` : "";