pi-squire 0.9.2 → 0.9.4

package/CHANGELOG.md

@@ -6,11 +6,44 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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
+
+- A collapsed delegate result previews its first 3 non-blank lines, in a
+  brighter color, with heading marks, backticks and bold stripped. Expanded,
+  the result comes right after the task under a `Result` label, and the ids
+  and files move to the end with the home directory shown as `~`. The
+  renderer tests change with it.
+
 ## [0.9.2] - 2026-10-22
 
 ### Changed
 
 - A delegate's footer shows its agent name in the theme's accent color.
+- Delegate results and closed-without-a-result messages are drawn with a
+  header (status icon, delegate name, model) and, collapsed, the first 3
+  lines of the result; expanded, the ids and files, the quoted task and the
+  result as Markdown. The text the parent model reads is unchanged apart from
+  the model. Messages from before this change show as plain text. The
+  renderer tests change with it.
+
+### Fixed
+
+- A delegate that finished on a different model than it launched on (a
+  fallback, or `/model` in its window) is now shown as `launched → finished`
+  in the result, the closed-without-a-result message and `delegation_status`,
+  read from the delegate's session file. It used to name the launch model.
 
 ## [0.9.1] - 2026-10-22
 
@@ -331,7 +364,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.2...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.9.4...HEAD
+[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
 [0.9.0]: https://github.com/gvanderclay/pi-squire/compare/v0.8.1...v0.9.0

package/README.md

@@ -443,6 +443,22 @@ Delegate session: <session file or id>
 - The header carries the agent, the model, the delegation id and the request
   id; the status is the envelope's (`done`, `failed` or
   `stopped`).
+- The model is the one the delegation was launched on. When the delegate's
+  session file shows it finished on another (a fallback after a usage limit,
+  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 `delegate` tool's own row is drawn the same way, so a launch and its
+  result match: a call line naming the agent and label, then a header with
+  a ◐ started icon, the delegate's name and the model it started on, a preview of the task and any skipped fallback models;
+  expanded, the whole task, then the delegation id, window, thinking and
+  auto-exit. A refused call keeps its plain error text. The closed-without-a-result message gets the same header with ⊘.
 - 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.2",
+	"version": "0.9.4",
 	"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

@@ -0,0 +1,197 @@
+// How delegations look in the parent: the `delegate` tool's row and the
+// result or gone message that arrives later share one header and preview
+// style. Both are drawn from structured details, while their text stays what
+// the parent model reads.
+import { homedir } from "node:os";
+
+import {
+	getMarkdownTheme,
+	keyText,
+	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 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. */
+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;
+
+/** The icon and theme color for each status; an unknown status gets a neutral icon. */
+const STATUS_STYLE: Record<string, { icon: string; color: "accent" | "success" | "error" | "warning" | "muted" }> = {
+	started: { icon: "◐", color: "accent" },
+	done: { icon: "✓", color: "success" },
+	failed: { icon: "✗", color: "error" },
+	stopped: { icon: "■", color: "warning" },
+	gone: { icon: "⊘", color: "warning" },
+};
+
+/** 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}`;
+	return headerLine(theme, style, details.name, modelLabel(details.model, details.finishedModel), trailer);
+}
+
+function headerLine(
+	theme: Theme,
+	style: { icon: string; color: "accent" | "success" | "error" | "warning" | "muted" },
+	name: string,
+	model: string,
+	trailer: string,
+): string {
+	return `${theme.fg(style.color, style.icon)} ${theme.fg("accent", name)} ${theme.fg("muted", model)}${
+		trailer === "" ? "" : theme.fg(style.color, trailer)
+	}`;
+}
+
+function expandHint(theme: Theme): Text {
+	return new Text(`${theme.fg("dim", keyText("app.tools.expand"))}${theme.fg("muted", " to expand")}`, 0, 0);
+}
+
+/** `path` with the home directory shown as `~`. */
+function tilde(path: string): string {
+	const home = homedir();
+	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
+		.split("\n")
+		.filter((line) => line.trim() !== "")
+		.slice(0, PREVIEW_LINES)
+		.map((line) =>
+			line
+				.replace(/^#+\s+/, "")
+				.replaceAll("`", "")
+				.replaceAll("**", ""),
+		);
+}
+
+/**
+ * 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
+ * with tool output; the model always gets the full content.
+ */
+export function renderMessage(
+	message: Parameters<MessageRenderer>[0],
+	{ expanded, outputPad }: MessageRenderOptions,
+	theme: Theme,
+): 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(expandHint(theme));
+		return box;
+	}
+	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;
+	}
+	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;
+}
+
+/** The `delegate` tool's call line: the tool, the agent and any label. Arguments may still be streaming. */
+export function renderDelegateCall(args: { agent?: unknown; label?: unknown }, theme: Theme): Component {
+	let line = theme.bold("delegate");
+	if (typeof args.agent === "string") line += ` ${theme.fg("accent", args.agent)}`;
+	if (typeof args.label === "string" && args.label !== "" && args.label !== "null")
+		line += ` ${theme.fg("muted", `· ${args.label}`)}`;
+	return new Text(line, 0, 0);
+}
+
+/**
+ * The `delegate` tool's result, in the result message's style: a started
+ * header, then a task preview and the hint, or, expanded, the whole task and
+ * the ids. 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 task = typeof context.args.task === "string" ? context.args.task : "";
+	const box = new Box(0, 0);
+	box.addChild(new TruncatedText(headerLine(theme, STATUS_STYLE.started, started.windowName, started.model, "")));
+	const skipped = started.skipped.map(({ model, reason }) => theme.fg("warning", `skipped ${model}: ${reason}`));
+	if (!expanded) {
+		for (const line of preview(task)) box.addChild(new TruncatedText(theme.fg("muted", line)));
+		for (const line of skipped) box.addChild(new TruncatedText(line));
+		box.addChild(expandHint(theme));
+		return box;
+	}
+	const quote = task
+		.split("\n")
+		.map((line) => theme.fg("muted", `> ${line}`))
+		.join("\n");
+	box.addChild(new Text(quote, 0, 0));
+	if (skipped.length + started.notices.length > 0)
+		box.addChild(new Text([...skipped, ...started.notices.map((line) => theme.fg("dim", line))].join("\n"), 0, 0));
+	box.addChild(new Spacer(1));
+	const ids = [
+		`delegation ${started.id}`,
+		`window ${started.windowName} (${started.windowId})`,
+		`thinking ${started.thinking}, auto-exit ${started.autoExit ? "on" : "off"}`,
+	];
+	box.addChild(new Text(ids.map((line) => theme.fg("dim", line)).join("\n"), 0, 0));
+	return box;
+}

package/src/results.ts

@@ -4,18 +4,13 @@
 // the message over, shows the parent one delegate result and records the
 // result. The records are the one source of truth for a delegation's state,
 // for the footer, `delegation_status` and `delegation_close`.
-import { readdirSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import {
-	type ExtensionAPI,
-	type ExtensionContext,
-	keyText,
-	type MessageRenderer,
-} from "@earendil-works/pi-coding-agent";
-import { Box, Text } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { readMarks } from "./limits.ts";
+import { modelLabel, renderMessage } from "./render.ts";
 
 /** The session entry type both delegation records and results use. */
 export const CUSTOM_TYPE = "delegate";
@@ -70,8 +65,41 @@ export type Result = {
 	envelopePath: string;
 	/** The delegate's session file, when it could be found. */
 	sessionPath?: string;
+	/** The `provider/model` of the delegate's last assistant message, when its session file holds one. */
+	finishedModel?: string;
 };
 
+/** What both delegate messages carry for their view, beside the text the model reads. */
+type CommonDetails = {
+	name: string;
+	agent: string;
+	/** The model the delegation was launched on. */
+	model: string;
+	finishedModel?: string;
+	id: string;
+	requestId: string;
+	sessionPath?: string;
+};
+
+/** The task as the result quotes it: its text and copy path, or why there is none. */
+export type TaskQuote = { text: string; path: string } | { note: string };
+
+/** The details of a delegate message; the renderer draws from these. */
+export type MessageDetails =
+	| (CommonDetails & {
+			kind: "result";
+			/** The envelope's status: `done`, `failed` or `stopped`. */
+			status: string;
+			envelopePath: string;
+			limit?: string;
+			task: TaskQuote;
+			/** The reply body, capped. */
+			body: string;
+	  })
+	| (CommonDetails & { kind: "gone"; windowName: string });
+
+type ResultDetails = Extract<MessageDetails, { kind: "result" }>;
+
 /** One delegation as it stands: what was recorded at its start, plus what came after. */
 export type Recorded = Delegation & {
 	/** Set when a result arrived. */
@@ -165,6 +193,34 @@ export function findSession(dir: string | undefined, id: string): string | undef
 	return name === undefined ? undefined : join(dir, name);
 }
 
+/**
+ * The `provider/model` of the last assistant message in a delegate's session
+ * file: the model that actually answered, after any fallback or `/model`.
+ * Undefined when the file is missing or holds no assistant message.
+ */
+export function finishedModel(sessionPath: string | undefined): string | undefined {
+	if (sessionPath === undefined) return undefined;
+	let lines: string[];
+	try {
+		lines = readFileSync(sessionPath, "utf8").split("\n");
+	} catch {
+		return undefined;
+	}
+	for (let i = lines.length - 1; i >= 0; i--) {
+		let entry: { type?: unknown; message?: { role?: unknown; provider?: unknown; model?: unknown } };
+		try {
+			entry = JSON.parse(lines[i]);
+		} catch {
+			continue; // a line still being written, or a blank one
+		}
+		const message = entry?.message;
+		if (entry?.type !== "message" || message?.role !== "assistant") continue;
+		if (typeof message.provider === "string" && typeof message.model === "string")
+			return `${message.provider}/${message.model}`;
+	}
+	return undefined;
+}
+
 /** The line naming a usage-limit mark this delegation recorded, if any; a `done` delegation finished on a fallback. */
 function limitLine(id: string, status: string): string | undefined {
 	const now = Date.now();
@@ -177,54 +233,67 @@ function limitLine(id: string, status: string): string | undefined {
 	}${status === "done" ? " It finished on a fallback model; its session names which." : ""}`;
 }
 
-/** The one message the parent sees for a settled delegation. */
-function resultText(delegation: Delegation, payload: Inbound, session: string | undefined): string {
+/** The details of a settled delegation's result message. */
+function resultDetails(
+	delegation: Delegation,
+	payload: Inbound,
+	session: string | undefined,
+	finished: string | undefined,
+): ResultDetails {
 	const reply = payload.envelope;
 	const copy = payload.requests.find((request) => request.envelope?.id === delegation.requestId);
-	let quote: string;
+	let task: TaskQuote;
 	if (copy === undefined) {
-		quote = `[delegate] The task ${delegation.requestId} has no copy in sent/; only its id is known.`;
+		task = { note: `[delegate] The task ${delegation.requestId} has no copy in sent/; only its id is known.` };
 	} else {
 		const cut = cap(copy.envelope.body, TASK_CAP);
-		const lines =
+		const text =
 			cut === undefined ? copy.envelope.body : `${cut}\n[delegate] Task cut at 2 KiB; the full copy is ${copy.path}`;
-		quote = `Task, quoted from ${copy.path}:\n${lines
-			.split("\n")
-			.map((line) => `> ${line}`)
-			.join("\n")}`;
+		task = { text, path: copy.path };
 	}
 	const cut = cap(reply.body, BODY_CAP);
-	const result =
+	const body =
 		cut === undefined ? reply.body : `${cut}\n[delegate] Body cut at 32 KiB; the full envelope is ${payload.path}`;
 	const limit = reply.status === "stopped" ? undefined : limitLine(delegation.id, reply.status);
+	return {
+		kind: "result",
+		status: reply.status,
+		name: recordedName(delegation),
+		agent: delegation.agent,
+		model: delegation.model,
+		...(finished === undefined ? {} : { finishedModel: finished }),
+		id: delegation.id,
+		requestId: delegation.requestId,
+		envelopePath: payload.path,
+		...(session === undefined ? {} : { sessionPath: session }),
+		...(limit === undefined ? {} : { limit }),
+		task,
+		body,
+	};
+}
+
+/** The one message the parent model reads for a settled delegation. */
+function resultText(details: ResultDetails): string {
+	const { task } = details;
+	const quote =
+		"note" in task
+			? task.note
+			: `Task, quoted from ${task.path}:\n${task.text
+					.split("\n")
+					.map((line) => `> ${line}`)
+					.join("\n")}`;
 	return [
-		`[delegate] Result from ${delegation.agent} (${delegation.model}), delegation ${delegation.id}, request ${delegation.requestId}.`,
-		`Status: ${reply.status}`,
-		...(limit === undefined ? [] : [limit]),
+		`[delegate] Result from ${details.agent} (${modelLabel(details.model, details.finishedModel)}), delegation ${details.id}, request ${details.requestId}.`,
+		`Status: ${details.status}`,
+		...(details.limit === undefined ? [] : [details.limit]),
 		quote,
-		`Envelope: ${payload.path}`,
-		`Delegate session: ${session ?? delegation.id}`,
+		`Envelope: ${details.envelopePath}`,
+		`Delegate session: ${details.sessionPath ?? details.id}`,
 		"",
-		result,
+		details.body,
 	].join("\n");
 }
 
-/**
- * Collapsed, a delegate message shows its first two lines (who answered and the
- * status) and a hint; expanded, Pi's default rendering of the whole message.
- * The model always gets the full content. Ctrl+O toggles it with tool output.
- */
-export const renderMessage: MessageRenderer = (message, { expanded, outputPad }, theme) => {
-	if (expanded || typeof message.content !== "string") return undefined;
-	const lines = message.content.split("\n");
-	const shown = lines.slice(0, 2).join("\n");
-	const hint =
-		lines.length > 2 ? `\n${theme.fg("dim", keyText("app.tools.expand"))}${theme.fg("muted", " to expand")}` : "";
-	const box = new Box(outputPad, 1, (text) => theme.bg("customMessageBg", text));
-	box.addChild(new Text(`${theme.fg("customMessageText", shown)}${hint}`, 0, 0));
-	return box;
-};
-
 export function createResults(pi: ExtensionAPI): Results {
 	pi.registerMessageRenderer(CUSTOM_TYPE, renderMessage);
 	/** Every recorded delegation by its id, in the order recorded. */
@@ -306,13 +375,26 @@ export function createResults(pi: ExtensionAPI): Results {
 		if (record === undefined || record.result !== undefined || record.closed === true || record.gone === true)
 			return false;
 		const session = findSession(ctx?.sessionManager.getSessionDir(), record.id);
+		const finished = finishedModel(session);
 		pi.appendEntry(CUSTOM_TYPE, { id, gone: true });
 		record.gone = true;
+		const details: MessageDetails = {
+			kind: "gone",
+			name: recordedName(record),
+			agent: record.agent,
+			model: record.model,
+			...(finished === undefined ? {} : { finishedModel: finished }),
+			id: record.id,
+			requestId: record.requestId,
+			...(session === undefined ? {} : { sessionPath: session }),
+			windowName: record.windowName,
+		};
 		pi.sendMessage(
 			{
 				customType: CUSTOM_TYPE,
+				details,
 				content: [
-					`[delegate] Delegation ${record.id} (${record.agent}, ${record.model}), request ${record.requestId}, closed without a result: its window ${record.windowName} is gone and no reply arrived.`,
+					`[delegate] Delegation ${record.id} (${record.agent}, ${modelLabel(record.model, finished)}), request ${record.requestId}, closed without a result: its window ${record.windowName} is gone and no reply arrived.`,
 					`Delegate session: ${session ?? record.id}`,
 					"A reply that arrives later is still delivered.",
 				].join("\n"),
@@ -336,9 +418,11 @@ export function createResults(pi: ExtensionAPI): Results {
 		const delegation = byRequest.get(requestId) as Recorded;
 		shown.add(reply.id);
 		const session = findSession(ctx?.sessionManager.getSessionDir(), delegation.id);
+		const finished = finishedModel(session);
+		const details = resultDetails(delegation, payload, session, finished);
 		// Steer, not follow-up: a busy parent gets the result before its next model call, not after it has answered.
 		pi.sendMessage(
-			{ customType: CUSTOM_TYPE, content: resultText(delegation, payload, session), display: true },
+			{ customType: CUSTOM_TYPE, content: resultText(details), details, display: true },
 			{ triggerTurn: true, deliverAs: "steer" },
 		);
 		const result: Result = {
@@ -346,6 +430,7 @@ export function createResults(pi: ExtensionAPI): Results {
 			replyId: reply.id,
 			envelopePath: payload.path,
 			...(session === undefined ? {} : { sessionPath: session }),
+			...(finished === undefined ? {} : { finishedModel: finished }),
 		};
 		pi.appendEntry(CUSTOM_TYPE, { id: delegation.id, result });
 		delegation.result = result;

package/src/tracking.ts

@@ -8,6 +8,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Type } from "typebox";
 
 import { type Mark, readMarks } from "./limits.ts";
+import { modelLabel } from "./render.ts";
 import {
 	type DelegationState,
 	deriveState,
@@ -55,7 +56,10 @@ const DelegationSchema = Type.Object({
 	id: Type.String(),
 	name: Type.String(),
 	agent: Type.String(),
-	model: Type.String(),
+	model: Type.String({ description: "The model it was launched on." }),
+	finishedModel: Type.Optional(
+		Type.String({ description: "The model its result came from, read from its session file; done only." }),
+	),
 	thinking: Type.String(),
 	autoExit: Type.Boolean(),
 	windowId: Type.String(),
@@ -193,7 +197,7 @@ function view(record: Recorded, windows: TmuxWindow[] | undefined, ctx: Extensio
 function viewText({ record, state, name, sessionPath, lastActive }: View): string {
 	const seen = lastActive === undefined ? "" : ` (last active ${ago(Date.now() - lastActive.getTime())})`;
 	const lines = [
-		`${record.id} ${record.agent} (${record.model}, thinking ${record.thinking})`,
+		`${record.id} ${record.agent} (${modelLabel(record.model, record.result?.finishedModel)}, thinking ${record.thinking})`,
 		`  name: ${name}`,
 		`  state: ${stateLine(state, record)}${seen}`,
 		`  window: ${record.windowName} (${record.windowId})`,
@@ -211,6 +215,7 @@ function viewDetails({ record, state, name, sessionPath, lastActive }: View): Re
 		name,
 		agent: record.agent,
 		model: record.model,
+		...(record.result?.finishedModel === undefined ? {} : { finishedModel: record.result.finishedModel }),
 		thinking: record.thinking,
 		autoExit: record.autoExit === true,
 		windowId: record.windowId,