pi-squire 0.9.3 → 0.9.5

package/CHANGELOG.md

@@ -6,6 +6,27 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.9.5] - 2026-10-23
+
+### Changed
+
+- A delegation is drawn as one tool call that changes state, in the style of
+  pi-interactive-subagents, replacing the 0.9.2 to 0.9.4 look: the `delegate`
+  row shows `○` with the agent, label and task while the call runs, and one
+  header, `● <name> (<model>) — started`, once the delegate starts; the result arrives as a
+  finished tool row on Pi's tool success or error background, `✓ <name> (<model>) — done` or `✗` with the status,
+  with a 5-line preview. The renderer tests change with it.
+
+## [0.9.4] - 2026-10-23
+
+### Changed
+
+- The `delegate` tool's row is drawn in the same style as the result message:
+  a call line naming the agent and label, then a ◐ header with the delegate's
+  name and model, a task preview and any skipped fallback models; expanded,
+  the whole task and the delegation id, window, thinking and auto-exit. The
+  text the model reads is unchanged.
+
 ## [0.9.3] - 2026-10-23
 
 ### Changed
@@ -354,7 +375,9 @@ author's dotfiles; the changes below are against that copy.
 
 - The published file list includes `child.ts`, which `index.ts` imports.
 
-[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.9.3...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.9.5...HEAD
+[0.9.5]: https://github.com/gvanderclay/pi-squire/compare/v0.9.4...v0.9.5
+[0.9.4]: https://github.com/gvanderclay/pi-squire/compare/v0.9.3...v0.9.4
 [0.9.3]: https://github.com/gvanderclay/pi-squire/compare/v0.9.2...v0.9.3
 [0.9.2]: https://github.com/gvanderclay/pi-squire/compare/v0.9.1...v0.9.2
 [0.9.1]: https://github.com/gvanderclay/pi-squire/compare/v0.9.0...v0.9.1

package/README.md

@@ -448,12 +448,20 @@ Delegate session: <session file or id>
   or `/model` in its window), it reads `launched → finished`, for example
   `(anthropic/claude-haiku-5-5 → openai/gpt-6-luna)`. `delegation_status`
   reports the same.
-- That text is what the parent model reads. The user sees it drawn instead:
-  collapsed, a header with a status icon (✓ done, ✗ failed, ■ stopped), the
-  delegate's name and the model, then the first 3 non-blank lines of the
-  result with heading marks, backticks and bold stripped; expanded (Ctrl+O),
-  the quoted task, the result as Markdown, then the ids and files, with the
-  home directory shown as `~`. The closed-without-a-result message gets the same header with ⊘.
+- That text is what the parent model reads. The user sees the delegation as
+  one tool call that changes state, in the style of
+  [pi-interactive-subagents](https://github.com/amosblomqvist/pi-interactive-subagents):
+  - The `delegate` row shows `○` with the agent, the label, the task's first
+    line and its line count while the call runs. Once the delegate starts,
+    that header is replaced by `● <name> (<model>) — started` over the same
+    task line, with any skipped fallback model. A refused call keeps its
+    `○` header above the plain error text.
+  - The result arrives drawn as a finished tool row, on Pi's tool success or
+    error background: `✓ <name> (<model>) — done`, or `✗` with `failed`,
+    `stopped` or `closed without a result`. Collapsed, it previews the first
+    5 non-blank lines with heading marks, backticks and bold stripped;
+    expanded (Ctrl+O), it shows the result as Markdown, the quoted task, then
+    the ids and files, with the home directory shown as `~`.
 - Stopping a delegate's run (Esc) sends no result: the provider holds the
   task, so the delegation stays running while the user steers it. The next
   run that completes sends the result, `done`, and its body opens with a note

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-squire",
-	"version": "0.9.3",
+	"version": "0.9.5",
 	"description": "Starts a delegate Pi session in a background tmux window, sends it the task over message:*, and shows the parent its result",
 	"keywords": [
 		"pi-package",

package/src/index.ts

@@ -49,6 +49,7 @@ import { Type } from "typebox";
 import { type Agent, isThinking, type Roster, readRoster, THINKING_LEVELS } from "./agents.ts";
 import { AGENT_ENV, AUTO_EXIT_ENV, FALLBACK_ENV, registerChild } from "./child.ts";
 import { activeMark, clearMarks, isFree, readMarks } from "./limits.ts";
+import { renderDelegateCall, renderDelegateResult } from "./render.ts";
 import { createResults, delegateName } from "./results.ts";
 import { createTmuxClient, type TmuxClient } from "./tmux.ts";
 import { createTracking, toolResult } from "./tracking.ts";
@@ -596,6 +597,8 @@ export default function delegate(
 			),
 		}),
 		outputSchema: DelegateSchema,
+		renderCall: renderDelegateCall,
+		renderResult: renderDelegateResult,
 		// Opens a new window each call and removes nothing. Open world: the delegate calls a remote model and runs its agent's tools unattended.
 		annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
 		async execute(

package/src/render.ts

@@ -1,17 +1,23 @@
-// How a delegate message looks in the parent: drawn from the structured
-// details `results.ts` attaches, while the message's text stays what the
-// parent model reads.
+// How delegations look in the parent. A delegation reads as one tool call that
+// changes state: the `delegate` row shows ○ while its arguments arrive and ●
+// once started, and the result message that arrives later is drawn as a
+// finished tool row (✓ or ✗ on Pi's tool success or error background). The
+// style follows amosblomqvist/pi-interactive-subagents (c3e8b53,
+// pi-extension/subagents/index.ts:1891-1944 and 2353-2460). Everything is
+// drawn from structured details; the text the parent model reads is separate.
 import { homedir } from "node:os";
 
 import {
 	getMarkdownTheme,
-	keyText,
+	keyHint,
 	type MessageRenderer,
 	type MessageRenderOptions,
 	type Theme,
 } from "@earendil-works/pi-coding-agent";
-import { Box, type Component, Markdown, Spacer, Text, TruncatedText } from "@earendil-works/pi-tui";
+import { Box, type Component, Container, Markdown, Spacer, Text, TruncatedText } from "@earendil-works/pi-tui";
+import type { Static } from "typebox";
 
+import type { DelegateSchema } from "./index.ts";
 import type { MessageDetails } from "./results.ts";
 
 /** The launch model, or `launch → finished` when the delegate finished on another one. */
@@ -19,30 +25,20 @@ export function modelLabel(model: string, finished: string | undefined): string
 	return finished === undefined || finished === model ? model : `${model} → ${finished}`;
 }
 
-/** Lines of the body the collapsed view previews. */
-const PREVIEW_LINES = 3;
+/** Lines of a result the collapsed message previews. */
+const PREVIEW_LINES = 5;
+/** Characters of the task's first line the call row shows. */
+const TASK_PREVIEW_CHARS = 100;
 
-/** The icon and theme color for each status; an unknown status gets a neutral icon. */
-const STATUS_STYLE: Record<string, { icon: string; color: "success" | "error" | "warning" | "muted" }> = {
-	done: { icon: "✓", color: "success" },
-	failed: { icon: "✗", color: "error" },
-	stopped: { icon: "■", color: "warning" },
-	gone: { icon: "⊘", color: "warning" },
-};
+type Color = "success" | "error" | "warning" | "muted" | "dim";
 
-/** The header line: status icon, the delegate's name and the model it ran on. */
-function header(details: MessageDetails, theme: Theme): string {
-	const status = details.kind === "gone" ? "gone" : details.status;
-	const known = Object.hasOwn(STATUS_STYLE, status);
-	const style = known ? STATUS_STYLE[status] : { icon: "•", color: "muted" as const };
-	let trailer = "";
-	if (details.kind === "gone") trailer = " closed without a result";
-	else if (!known) trailer = ` ${details.status}`;
-	const model = theme.fg("muted", modelLabel(details.model, details.finishedModel));
-	return `${theme.fg(style.color, style.icon)} ${theme.fg("accent", details.name)} ${model}${
-		trailer === "" ? "" : theme.fg(style.color, trailer)
-	}`;
-}
+/** The icon, its color and the status word for each way a delegation ends. */
+const ENDINGS: Record<string, { icon: string; color: Color; word: string; wordColor: Color }> = {
+	done: { icon: "✓", color: "success", word: "done", wordColor: "dim" },
+	failed: { icon: "✗", color: "error", word: "failed", wordColor: "error" },
+	stopped: { icon: "✗", color: "warning", word: "stopped", wordColor: "warning" },
+	gone: { icon: "✗", color: "warning", word: "closed without a result", wordColor: "warning" },
+};
 
 /** `path` with the home directory shown as `~`. */
 function tilde(path: string): string {
@@ -50,26 +46,11 @@ function tilde(path: string): string {
 	return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
 }
 
-function metadata(details: MessageDetails): string[] {
-	const lines = [`delegation ${details.id}`, `request ${details.requestId}`];
-	if (details.kind === "result") lines.push(`envelope ${tilde(details.envelopePath)}`);
-	else lines.push(`window ${details.windowName}`);
-	lines.push(
-		`session ${details.sessionPath === undefined ? `${details.id} (no session file found)` : tilde(details.sessionPath)}`,
-	);
-	return lines;
-}
-
-/**
- * The first non-blank lines of a body, with heading marks, backticks and bold
- * markers stripped. Plain text, not Markdown, because a cut-off fragment can
- * break mid-list or mid-code-block.
- */
-function preview(body: string): string[] {
-	return body
+/** Non-blank lines with heading marks, backticks and bold markers stripped, for a plain-text preview. */
+function plainLines(text: string): string[] {
+	return text
 		.split("\n")
 		.filter((line) => line.trim() !== "")
-		.slice(0, PREVIEW_LINES)
 		.map((line) =>
 			line
 				.replace(/^#+\s+/, "")
@@ -78,10 +59,20 @@ function preview(body: string): string[] {
 		);
 }
 
+function idLines(details: MessageDetails): string[] {
+	const lines = [`delegation ${details.id}`, `request ${details.requestId}`];
+	if (details.kind === "result") lines.push(`envelope ${tilde(details.envelopePath)}`);
+	else lines.push(`window ${details.windowName}`);
+	lines.push(
+		`session ${details.sessionPath === undefined ? `${details.id} (no session file found)` : tilde(details.sessionPath)}`,
+	);
+	return lines;
+}
+
 /**
- * A delegate message drawn from its details. Collapsed: a header, a short
- * preview of the result body and an expand hint. Expanded: the header, the
- * quoted task, the body as Markdown, then the ids and files. Ctrl+O toggles it
+ * A delegate result or gone message, drawn as a finished tool row: a header
+ * (icon, name, model, status), then a preview and the expand hint, or,
+ * expanded, the result as Markdown, the task and the ids. Ctrl+O toggles it
  * with tool output; the model always gets the full content.
  */
 export function renderMessage(
@@ -91,37 +82,120 @@ export function renderMessage(
 ): Component | undefined {
 	const details = message.details as MessageDetails | undefined;
 	if (details?.kind !== "result" && details?.kind !== "gone") return undefined;
-	const box = new Box(outputPad, 1, (text) => theme.bg("customMessageBg", text));
-	if (!expanded) {
-		box.addChild(new TruncatedText(header(details, theme)));
-		if (details.kind === "result") {
-			for (const line of preview(details.body)) box.addChild(new TruncatedText(theme.fg("muted", line)));
-		}
-		box.addChild(new Text(`${theme.fg("dim", keyText("app.tools.expand"))}${theme.fg("muted", " to expand")}`, 0, 0));
-		return box;
+	const status = details.kind === "gone" ? "gone" : details.status;
+	const background = status === "done" ? "toolSuccessBg" : "toolErrorBg";
+	const box = new Box(outputPad, 1, (text) => theme.bg(background, text));
+	const header = headerLine(details, status, theme);
+	box.addChild(expanded ? new Text(header, 0, 0) : new TruncatedText(header));
+	if (details.kind === "result" && details.limit !== undefined)
+		box.addChild(new Text(theme.fg("warning", details.limit), 0, 0));
+	for (const child of expanded ? expandedLines(details, theme) : collapsedLines(details, theme)) box.addChild(child);
+	return box;
+}
+
+/** The icon, the delegate's name, the model and the status word. */
+function headerLine(details: MessageDetails, status: string, theme: Theme): string {
+	const ending = Object.hasOwn(ENDINGS, status)
+		? ENDINGS[status]
+		: { icon: "•", color: "muted" as const, word: status, wordColor: "muted" as const };
+	const model = modelLabel(details.model, details.finishedModel);
+	return `${theme.fg(ending.color, ending.icon)} ${theme.fg("toolTitle", theme.bold(details.name))}${theme.fg(
+		"dim",
+		` (${model}) —`,
+	)} ${theme.fg(ending.wordColor, ending.word)}`;
+}
+
+/** A result's first lines, a count of the rest, and the expand hint. */
+function collapsedLines(details: MessageDetails, theme: Theme): Component[] {
+	const children: Component[] = [];
+	if (details.kind === "result") {
+		const lines = plainLines(details.body);
+		for (const line of lines.slice(0, PREVIEW_LINES)) children.push(new TruncatedText(theme.fg("dim", line)));
+		if (lines.length > PREVIEW_LINES)
+			children.push(new Text(theme.fg("muted", `… ${lines.length - PREVIEW_LINES} more lines`), 0, 0));
 	}
-	box.addChild(new Text(header(details, theme), 0, 0));
-	const dim = metadata(details);
-	if (details.kind === "gone") dim.push("A reply that arrives later is still delivered.");
-	else if (details.limit !== undefined) dim.push(details.limit);
-	const metadataText = new Text(dim.map((line) => theme.fg("dim", line)).join("\n"), 0, 0);
-	if (details.kind === "gone") {
-		box.addChild(metadataText);
-		return box;
+	children.push(new Text(keyHint("app.tools.expand", "to expand"), 0, 0));
+	return children;
+}
+
+/** The result as Markdown and the quoted task, then the ids and files. */
+function expandedLines(details: MessageDetails, theme: Theme): Component[] {
+	const dim = (lines: string[]): Text => new Text(lines.map((line) => theme.fg("dim", line)).join("\n"), 0, 0);
+	const children: Component[] = [];
+	if (details.kind === "result") {
+		const { task } = details;
+		const quote = "note" in task ? [task.note] : [`Task (${tilde(task.path)}):`, ...task.text.split("\n")];
+		children.push(new Spacer(1), new Markdown(details.body, 0, 0, getMarkdownTheme()), new Spacer(1), dim(quote));
 	}
-	const { task } = details;
-	const quote =
-		"note" in task
-			? theme.fg("muted", task.note)
-			: `${theme.fg("muted", `Task (${tilde(task.path)}):`)}\n${task.text
-					.split("\n")
-					.map((line) => theme.fg("muted", `> ${line}`))
-					.join("\n")}`;
-	box.addChild(new Text(quote, 0, 0));
-	box.addChild(new Spacer(1));
-	box.addChild(new Text(theme.fg("dim", "Result"), 0, 0));
-	box.addChild(new Markdown(details.body, 0, 0, getMarkdownTheme()));
-	box.addChild(new Spacer(1));
-	box.addChild(metadataText);
-	return box;
+	const tail = details.kind === "gone" ? ["A reply that arrives later is still delivered."] : [];
+	children.push(new Spacer(1), dim([...idLines(details), ...tail]));
+	return children;
+}
+
+/** The task's first non-blank line, cut at 100 characters, and its line count when it has more than one. */
+function taskLine(task: unknown, theme: Theme): string {
+	if (typeof task !== "string") return "";
+	const first = task.split("\n").find((line) => line.trim() !== "") ?? "";
+	const shown = first.length > TASK_PREVIEW_CHARS ? `${first.slice(0, TASK_PREVIEW_CHARS)}…` : first;
+	const total = task.split("\n").length;
+	return `${shown === "" ? "" : theme.fg("toolOutput", shown)}${total > 1 ? theme.fg("muted", ` (${total} lines)`) : ""}`;
+}
+
+/**
+ * The `delegate` tool's call: ○, the agent, any label and the task line,
+ * while arguments stream and the call runs. Pi redraws the call above the
+ * result, so once a launch succeeds the call draws nothing and the result's
+ * header is the row's only one; a refused call keeps it above the error.
+ */
+export function renderDelegateCall(
+	args: { agent?: unknown; label?: unknown; task?: unknown },
+	theme: Theme,
+	context: { isPartial: boolean; isError: boolean },
+): Component {
+	if (!context.isPartial && !context.isError) return new Container();
+	const agent = typeof args.agent === "string" && args.agent !== "" ? args.agent : "…";
+	let text = `○ ${theme.fg("toolTitle", theme.bold(agent))}`;
+	if (typeof args.label === "string" && args.label !== "" && args.label !== "null")
+		text += theme.fg("dim", ` [${args.label}]`);
+	const task = taskLine(args.task, theme);
+	if (task !== "") text += `\n${task}`;
+	return new Text(text, 0, 0);
+}
+
+/**
+ * The `delegate` tool's result: ●, the delegate's name, its model and
+ * "started", the task line and any skipped fallback models; expanded, the ids too. A
+ * refused or blocked call has no details and keeps its plain text.
+ */
+export function renderDelegateResult(
+	result: { content: { type: string; text?: string }[]; details?: unknown },
+	{ expanded }: { expanded: boolean },
+	theme: Theme,
+	context: { args: { task?: unknown }; isError: boolean },
+): Component {
+	const details = result.details as Partial<Static<typeof DelegateSchema>> | undefined;
+	if (context.isError || details?.outcome !== "started") {
+		const text = result.content.map((part) => part.text ?? "").join("\n");
+		return new Text(context.isError ? theme.fg("error", text) : text, 0, 0);
+	}
+	const started = details as Static<typeof DelegateSchema>;
+	const lines = [
+		`${theme.fg("accent", "●")} ${theme.fg("toolTitle", theme.bold(started.windowName))}${theme.fg(
+			"dim",
+			` (${started.model}) — started`,
+		)}`,
+	];
+	const task = taskLine(context.args.task, theme);
+	if (task !== "") lines.push(task);
+	lines.push(...started.skipped.map(({ model, reason }) => theme.fg("warning", `[Skipped ${model}: ${reason}]`)));
+	if (expanded)
+		lines.push(
+			...[
+				...started.notices,
+				`delegation ${started.id}`,
+				`window ${started.windowName} (${started.windowId})`,
+				`thinking ${started.thinking}, auto-exit ${started.autoExit ? "on" : "off"}`,
+			].map((line) => theme.fg("dim", line)),
+		);
+	return new Text(lines.join("\n"), 0, 0);
 }