@tshu-w/pi-agents 0.2.2 → 0.4.0

package/src/programs/programs.ts

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { deferred, settlesBy, STEER_POLL_MS, WAIT_INTERRUPTED, waitForChange, type Deferred } from "../agents/agents.ts";
-import { shortId, trackTreeWork } from "../agents/registry.ts";
-import { boundBlocks, boundText, type Truncation } from "../output.ts";
+import { deferred, hold, release, settlesBy, STEER_POLL_MS, waitForChange, type Deferred, type Held, type WaitEnd } from "../agents/agents.ts";
+import { shortId, trackTreeWork, type Notice } from "../agents/registry.ts";
+import { boundText } from "../output.ts";
 import { CLEANUP_TIMEOUT_MS, PROGRAM_TOOL_NAME, type ProgramFiles, type ProgramOutcome, type ProgramRunResult } from "./execute.ts";
 
 const PROGRAM_ENTRY = "pi-agents-program";
@@ -23,9 +23,6 @@ export interface ProgramRecord {
 	files?: ProgramFiles;
 	/** The tool calls its result lists, which the task viewer shows after a restart. */
 	calls?: unknown[];
-	/** Whether `wait` has returned the result. */
-	returned: boolean;
-	notified: boolean;
 }
 
 /** What the task viewer shows of a Program, as its tool call shows in the foreground. */
@@ -46,14 +43,13 @@ interface Running {
 	release?: () => void;
 	/** Whether some of its work did not stop. */
 	abandoned?: boolean;
-	waiters: number;
+	/** Stopped by the caller, which is not notified. */
+	silent?: boolean;
 }
 
 export interface ProgramWaitOutcome {
-	results: ProgramRecord[];
+	end: WaitEnd;
 	running: ProgramRecord[];
-	/** A steer ended the wait. */
-	interrupted?: boolean;
 }
 
 function ended(record: ProgramRecord): boolean {
@@ -72,13 +68,15 @@ export class Programs {
 	private change: Deferred = deferred();
 	private closing = false;
 	private viewers = new Set<() => void>();
+	private held: Held[] = [];
 
 	constructor(
 		private rootId: string,
 		private hooks: {
 			appendEntry(customType: string, data: unknown): void;
-			notify(text: string): void;
-			/** Called when a Program starts, ends, or has its result returned. */
+			/** Delivers a notification with Programs' results and their images. */
+			notify(text: string, notice: Notice): void;
+			/** Called when a Program starts or ends. */
 			changed?(): void;
 		},
 	) {}
@@ -99,7 +97,7 @@ export class Programs {
 			}
 			if (entry.type !== "custom" || entry.customType !== PROGRAM_ENTRY) continue;
 			const record = entry.data as ProgramRecord;
-			this.programs.set(record.id, { record, waiters: 0 });
+			this.programs.set(record.id, { record });
 		}
 		for (const program of this.programs.values()) {
 			const callId = callIds.get(program.record.id);
@@ -111,16 +109,15 @@ export class Programs {
 			record.state = "stopped";
 			record.content = [{ type: "text", text: "Script failed\nOutput:\nScript error:\nScript aborted: the caller went offline" }];
 			record.isError = true;
-			record.notified = true;
 			this.persist(record);
 		}
 	}
 
 	/** Starts a background Program, which `run` executes with its ID and reports its partial results to `update`, and returns its record. */
 	start(code: string, run: (id: string, signal: AbortSignal, abort: () => void, update: (result: unknown) => void) => Promise<ProgramRunResult>): ProgramRecord {
-		const record: ProgramRecord = { id: randomUUID(), state: "running", startedAt: Date.now(), returned: false, notified: false };
+		const record: ProgramRecord = { id: randomUUID(), state: "running", startedAt: Date.now() };
 		const controller = new AbortController();
-		const program: Running = { record, code, controller, waiters: 0 };
+		const program: Running = { record, code, controller };
 		const update = (result: unknown) => {
 			if (ended(record)) return;
 			program.result = result as Running["result"];
@@ -189,7 +186,7 @@ export class Programs {
 	async stop(program: Running, reason = "Program stopped"): Promise<boolean> {
 		if (ended(program.record)) return false;
 		// As with `abort`, the caller that stops a Program is not notified.
-		program.record.notified = true;
+		program.silent = true;
 		program.controller?.abort(new Error(reason));
 		if (!await settlesBy(program.done!, Date.now() + CLEANUP_TIMEOUT_MS)) {
 			program.abandoned = true;
@@ -200,20 +197,23 @@ export class Programs {
 		return true;
 	}
 
-	/** The given Programs, or running Programs and ended ones whose result has not been returned. */
+	/** The given Programs, or the running ones. */
 	select(ids: string[] | undefined): Running[] {
-		return [...new Set(ids?.map((id) => this.target(id)) ?? [...this.programs.values()].filter(({ record }) => !ended(record) || !record.returned))];
+		return [...new Set(ids?.map((id) => this.target(id)) ?? this.programs.values())];
 	}
 
 	running(programs: Running[]): boolean {
 		return programs.some(({ record }) => !ended(record));
 	}
 
-	async wait(unique: Running[], timeoutSeconds: number, signal?: AbortSignal, steered?: () => boolean): Promise<ProgramWaitOutcome> {
-		for (const program of unique) program.waiters += 1;
-		let returned = false;
-		let interrupted = false;
+	/** Waits until the Programs have ended; a steer ends it early. Their notifications are held until it ends, then delivered as one. */
+	async wait(programs: Running[], timeoutSeconds: number, signal?: AbortSignal, steered?: () => boolean): Promise<ProgramWaitOutcome> {
+		const unique = programs.filter(({ record }) => !ended(record));
+		if (unique.length === 0) return { end: "nothing", running: [] };
+		const held: Held = { ids: new Set(unique.map(({ record }) => record.id)), notices: [] };
+		this.held.push(held);
 		try {
+			let interrupted = false;
 			const deadline = Date.now() + timeoutSeconds * 1000;
 			while (unique.some(({ record }) => !ended(record))) {
 				const remaining = deadline - Date.now();
@@ -226,36 +226,15 @@ export class Programs {
 				await waitForChange(this.change.promise, steered ? Math.min(remaining, STEER_POLL_MS) : remaining, signal);
 			}
 			signal?.throwIfAborted();
-			returned = true;
-			return {
-				results: unique.filter(({ record }) => ended(record)).map(({ record }) => record),
-				running: unique.filter(({ record }) => !ended(record)).map(({ record }) => record),
-				...(interrupted && { interrupted }),
-			};
+			const running = unique.filter(({ record }) => !ended(record)).map(({ record }) => record);
+			return { end: running.length === 0 ? "completed" : interrupted ? "interrupted" : "timedOut", running };
 		} finally {
-			for (const program of unique) {
-				program.waiters -= 1;
-				const { record } = program;
-				if (!ended(record) || record.notified) continue;
-				if (returned) {
-					record.notified = true;
-					this.persist(record);
-				} else if (program.waiters === 0) {
-					this.notify(record);
-				}
-			}
+			this.held.splice(this.held.indexOf(held), 1);
+			const released = this.closing ? undefined : release(held);
+			if (released) this.hooks.notify(released.text, released.notice);
 		}
 	}
 
-	markReturned(records: ProgramRecord[]): void {
-		for (const record of records) {
-			if (record.returned) continue;
-			record.returned = true;
-			this.persist(record);
-		}
-		this.hooks.changed?.();
-	}
-
 	async shutdown(): Promise<void> {
 		this.closing = true;
 		const stopped = await Promise.allSettled([...this.programs.values()].map((program) => this.stop(program, "the caller went offline")));
@@ -277,7 +256,7 @@ export class Programs {
 		if (files && (files.read.length > 0 || files.written.length > 0 || files.edited.length > 0)) record.files = files;
 		program.controller = undefined;
 		this.persist(record);
-		if (program.waiters === 0) this.notify(record);
+		if (!program.silent) this.notify(record);
 		const previous = this.change;
 		this.change = deferred();
 		previous.resolve();
@@ -290,10 +269,14 @@ export class Programs {
 	}
 
 	private notify(record: ProgramRecord): void {
-		if (this.closing || record.notified) return;
-		record.notified = true;
-		this.persist(record);
-		this.hooks.notify(`Program ${this.label(record)} ${record.state}.`);
+		if (this.closing) return;
+		const images = (record.content ?? []).filter((item): item is Extract<Item, { type: "image" }> => item.type === "image");
+		const { kept, notice } = boundText(textOf(record.content), "pi-agents-program-notification");
+		const id = this.label(record);
+		const header = SCRIPT_HEADER.exec(kept);
+		const text = `<${PROGRAM_RESULT_TAG} id="${id}" status="${record.state}">\n${kept}\n</${PROGRAM_RESULT_TAG}>${notice ? `\n\n${notice}` : ""}`;
+		const result = { id, status: record.state, ...(header?.[1] !== undefined && { seconds: Number(header[1]) }), body: kept.slice(header?.[0].length ?? 0), ...(notice && { notice }) };
+		if (!hold(this.held, record.id, { text, result, ...(images.length ? { images } : {}) })) this.hooks.notify(text, { results: [result], ...(images.length ? { images } : {}) });
 	}
 
 	private persist(record: ProgramRecord): void {
@@ -323,69 +306,10 @@ export function addProgramFiles(
 	}
 }
 
-function resultBlock(record: ProgramRecord, ids: string[]): string {
-	return `<program-result id="${shortId(record.id, ids)}" status="${record.state}">\n${textOf(record.content)}\n</program-result>`;
-}
+export const PROGRAM_RESULT_TAG = "program-result";
 
 // The header codemode puts before a Program's output; a Program that ended before its run did has no wall time.
-const SCRIPT_HEADER = /^Script (?:completed|failed)\n(?:Wall time ([\d.]+) seconds\n)?Output:\n/;
-
-export interface ProgramResultDetails {
-	id: string;
-	state: ProgramState;
-	wallTimeSeconds?: number;
-	/** The output the result shows, without the header. */
-	output?: string;
-}
-
-/** A result's details, with the output in the first `available` characters of its text, if shown. */
-function resultDetails(record: ProgramRecord, available?: number): ProgramResultDetails {
-	const text = textOf(record.content);
-	const header = SCRIPT_HEADER.exec(text);
-	return {
-		id: record.id,
-		state: record.state,
-		...(header?.[1] !== undefined && { wallTimeSeconds: Number(header[1]) }),
-		...(available !== undefined && { output: text.slice(0, available).slice(header?.[0].length ?? 0) }),
-	};
-}
-
-/** Renders wait results; returns the content, its details, and the results the caller has now received. */
-/** The line naming the results left out to keep within Pi's output limits. */
-export function omittedLine(omitted: string[], ids: string[]): string {
-	return omitted.length > 0 ? `[Results omitted: ${omitted.map((id) => shortId(id, ids)).join(", ")}. Use wait with fewer targets.]` : "";
-}
-
-/** The line naming the Programs still running, and that a steer ended the wait if one did. */
-export function runningLine(running: string[], interrupted: boolean | undefined, ids: string[]): string {
-	return running.length > 0 ? `Still running: ${running.map((id) => shortId(id, ids)).join(", ")}${interrupted ? `\n${WAIT_INTERRUPTED}` : ""}` : "";
-}
-
-export function renderProgramWait({ results, running, interrupted }: ProgramWaitOutcome, ids: string[]): { content: Item[]; details: { results: ProgramResultDetails[] } & Partial<Truncation>; returned: ProgramRecord[]; isError?: boolean } {
-	const runningText = runningLine(running.map((record) => record.id), interrupted, ids);
-	if (results.length === 0) return { content: [{ type: "text", text: runningText || "No results." }], details: { results: [] }, returned: [] };
-	const images = (shown: ProgramRecord[]) => shown.flatMap((record) => (record.content ?? []).filter((item) => item.type === "image"));
-	const only = results[0]!;
-	if (results.length === 1 && running.length === 0 && only.state === "completed") {
-		const bounded = boundText(textOf(only.content), "pi-agents-program-wait");
-		return { content: [{ type: "text", text: bounded.text }, ...images(results)], details: { results: [resultDetails(only)], ...bounded.details }, returned: results };
-	}
-	const blocks = results.map((record) => resultBlock(record, ids));
-	const bounded = boundBlocks(blocks, "program-result", "pi-agents-program-wait");
-	let offset = 0;
-	const details = results.map((record, index) => {
-		const block = blocks[index]!;
-		const available = Math.max(0, bounded.kept.length - offset - block.indexOf("\n") - 1);
-		offset += block.length + 2;
-		return resultDetails(record, index < bounded.shown ? available : undefined);
-	});
-	let text = bounded.text;
-	const returned = results.slice(0, bounded.shown);
-	const omittedText = omittedLine(results.slice(bounded.shown).map((record) => record.id), ids);
-	if (omittedText) text += `\n\n${omittedText}`;
-	if (runningText) text += `\n\n${runningText}`;
-	return { content: [{ type: "text", text }, ...images(returned)], details: { results: details, ...bounded.details }, returned };
-}
+export const SCRIPT_HEADER = /^Script (?:completed|failed)\n(?:Wall time ([\d.]+) seconds\n)?Output:\n/;
 
 export function programListLine(record: ProgramRecord, ids: string[]): string {
 	return `${shortId(record.id, ids)}  ${record.state}`;

package/src/programs/scope.ts

@@ -73,7 +73,7 @@ export function programScope(
 			const ids = visibleIds(agentId, false);
 			const text = messageText(from, true, delivery, body, ids);
 			if (delivery === "write") {
-				agents.accept(agentId, text, "write", { fromOwner: true, notification: false, sender: sender(from, ids) });
+				agents.accept(agentId, text, "write", { fromOwner: true, sender: sender(from, ids) });
 				return undefined;
 			}
 			const { record, timedOut } = await agents.request(agentId, text, delivery, sender(from, ids), schema, timeout === undefined ? undefined : timeout * 1000);

package/src/programs/tool.ts

@@ -5,7 +5,7 @@ import { writeSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import * as path from "node:path";
 import { Type } from "typebox";
-import { settlesBy, steerQueued, SUBMIT_RESULT_TOOL_NAME, type Limits } from "../agents/agents.ts";
+import { settlesBy, steerQueued, SUBMIT_RESULT_TOOL_NAME, waitText, type Limits } from "../agents/agents.ts";
 import { nodes, trackTreeWork, type AgentNode } from "../agents/registry.ts";
 import { rejectFields } from "../params.ts";
 import { agentSession } from "../roots/rpc.ts";
@@ -15,11 +15,11 @@ import { CLEANUP_TIMEOUT_MS, executeProgram, PROGRAM_TOOL_NAME, type ProgramRunO
 import { commandSession, runDetached } from "./host-patches.ts";
 import { programDescription, programLoadout, programRenderers } from "./loadout.ts";
 import { randomUUID } from "node:crypto";
-import { CLEANUP_ERROR, programListLine, Programs, renderProgramWait } from "./programs.ts";
+import { CLEANUP_ERROR, programListLine, Programs } from "./programs.ts";
 import { PROGRAM_MESSAGE, runOutput } from "./run-output.mjs";
 import { agentGlobals, withAgentPrefix } from "./sandbox.ts";
 
-const PROGRAM_DESCRIPTION = `Run JavaScript that composes tool calls and Agents; only its output and return value reach the caller. \`run\` runs a Program in the foreground, or in the background with \`background\`; \`wait\` waits for background Programs and returns their results; \`list\` lists background Programs; \`stop\` stops a running Program. When a background Program ends while its caller is not waiting for it, the caller receives a notification; \`wait\` returns the result.
+const PROGRAM_DESCRIPTION = `Run JavaScript that composes tool calls and Agents; only its output and return value reach the caller. \`run\` runs a Program in the foreground, or in the background with \`background\`; \`wait\` waits for background Programs to end; \`list\` lists background Programs; \`stop\` stops a running Program. When a background Program ends, the caller receives a notification with the result.
 
 Program code is the body of an async function. It calls the caller's tools through \`tools.*\`, which excludes \`program\`, and creates Agents through \`agent()\`. These Agents belong to the Program, are isolated from other Agents, and go offline when it ends.
 
@@ -161,14 +161,14 @@ export function registerProgramTools(
 		promptGuidelines: [
 			"Use `program(action='run', code=...)` to call tools or Agents several times without a model turn between the calls, for example to read many files, filter large tool output, fan out Agents, or loop until a condition holds.",
 			"Use `Promise.allSettled` for independent calls. Return only what the caller needs; use `text()` for progress worth reading.",
-			"Use `background=true` for long Programs, and `program(action='wait', ...)` when the next step depends on their results.",
+			"Use `background=true` for long Programs, and `program(action='wait', ...)` when your next step or answer depends on their results.",
 		],
 		parameters: Type.Object({
 			action: StringEnum(["run", "wait", "list", "stop"] as const, { description: "Operation and applicable parameters: `run(code, background?, timeout?)`, `wait(target?, timeout?)`, `list(limit?, offset?)`, or `stop(target)`." }),
 			code: Type.Optional(Type.String({ description: "JavaScript async-function body for `run`." })),
 			background: Type.Optional(Type.Boolean({ description: "Whether `run` returns the Program ID at once (default: false)." })),
 			timeout: Type.Optional(Type.Number({ exclusiveMinimum: 0, description: "Maximum seconds. For `run` (default: none), expiry stops the Program. For `wait` (default: 30, min: 10, max: 3600), expiry does not stop Programs." })),
-			target: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())], { description: "Program ID or unique ID prefix for `wait` or `stop`. `wait` also accepts an array. When omitted for `wait`, selects running Programs and ended Programs whose result has not been returned." })),
+			target: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())], { description: "Program ID or unique ID prefix for `wait` or `stop`. `wait` also accepts an array. When omitted for `wait`, selects running Programs." })),
 			limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200, description: "Maximum Programs returned by `list` (default: 20, max: 200)." })),
 			offset: Type.Optional(Type.Integer({ minimum: 0, description: "Number of Programs to skip for `list` (default: 0)." })),
 		}),
@@ -200,10 +200,12 @@ export function registerProgramTools(
 					onUpdate?.({ content: [], details: undefined });
 					const session = agentSession(current.sessionManager);
 					const waitFor = () => programs!.wait(selected, timeout, signal, () => steerQueued(session?.agent));
-					const outcome = programs.running(selected) ? await self.agents.whileSuspended(waitFor, signal, true) : await waitFor();
-					const rendered = renderProgramWait(outcome, programs.ids());
-					programs.markReturned(rendered.returned);
-					return { content: rendered.content, details: { ...rendered.details, running: outcome.running.map((record) => record.id), ...(outcome.interrupted && { interrupted: true }) } };
+					const { end, running } = programs.running(selected) ? await self.agents.whileSuspended(waitFor, signal, true) : await waitFor();
+					const text = waitText(end, `Still running: ${running.map((record) => programs!.label(record)).join(", ")}`);
+					return {
+						content: [{ type: "text", text }],
+						details: { running: running.map((record) => record.id), ...(end === "timedOut" && { timedOut: true }), ...(end === "interrupted" && { interrupted: true }) },
+					};
 				}
 				case "list": {
 					rejectFields(params, "list", ["code", "background", "timeout", "target"]);
@@ -232,9 +234,9 @@ export function registerProgramTools(
 	});
 
 	/** A run as Pi shows a `run` call: the script, then its calls and output. */
-	const renderRun = (call: ProgramCall, result: { content: unknown[]; details?: unknown }, isPartial: boolean, isError: boolean, expanded: boolean, outputPad: number, theme: Theme) => {
+	const renderRun = (call: ProgramCall, result: { content: unknown[]; details?: unknown }, isPartial: boolean, isError: boolean, expanded: boolean, outputPad: number, theme: Theme, state = {}) => {
 		const component = new Box(outputPad, 1, (text) => theme.bg(isPartial ? "toolPendingBg" : isError ? "toolErrorBg" : "toolSuccessBg", text));
-		const context = { args: call, state: {}, executionStarted: true, expanded, isError, showImages: false, isPartial } as never;
+		const context = { args: call, state, executionStarted: true, expanded, isError, showImages: false, isPartial } as never;
 		component.addChild(renderers.renderCall!(call, theme, context));
 		component.addChild(renderers.renderResult!(result as never, { expanded, isPartial }, theme, context));
 		return component;
@@ -263,7 +265,9 @@ export function registerProgramTools(
 			current.ui.setWidget(widget, (ui, theme) => {
 				tui = ui;
 				const outputPad = pi.getSettings().outputPad === 0 ? 0 : 1;
-				return { render: (width: number) => renderRun(call, partial, !ended, partial.isError === true, current.ui.getToolsExpanded(), outputPad, theme).render(width), invalidate() {} };
+				// The widget redraws on each update, so it keeps its state as a tool row does.
+				const state = {};
+				return { render: (width: number) => renderRun(call, partial, !ended, partial.isError === true, current.ui.getToolsExpanded(), outputPad, theme, state).render(width), invalidate() {} };
 			});
 		}
 		let run: Awaited<ReturnType<typeof runProgram>>;

package/src/roots/guard.mjs

@@ -35,6 +35,11 @@ export function readSessionHeader(path) {
 
 const installed = Symbol.for('pi-agents.guard');
 
+/** Releases the locks a Session in this process holds, so that another process can open it. */
+export function releaseSession(sm) {
+  Object.getPrototypeOf(sm)[installed]?.release(sm);
+}
+
 /** Patches Pi's Session classes so every persisted Session holds its locks. Idempotent across /reload. */
 export function installGuard({ SessionManager, AgentSession, AgentSessionRuntime, parseSessionEntries, stateDir }) {
   const p = SessionManager.prototype;

package/src/roots/paths.mjs

@@ -26,6 +26,7 @@ export function statePaths(env = process.env) {
     workbench: join(state, 'workbench.json'),
     hostLog: join(state, 'host.log'),
     daemonLog: join(state, 'daemon.log'),
+    mainSession: join(state, 'main.json'),
     host(pid) { return join(runtime, `h-${pid}.sock`); },
     locks: join(runtime, 'locks'),
     daemon: join(runtime, 'daemon.sock'),

package/src/ui/message.ts

@@ -1,6 +1,28 @@
 import { getMarkdownTheme, UserMessageComponent, type MessageRenderer } from "@earendil-works/pi-coding-agent";
 import { Box, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
-import { messageBody, type Sender } from "../agents/registry.ts";
+import { RESULT_TAG } from "../agents/agents.ts";
+import { messageBody, type NotifiedResult, type Sender } from "../agents/registry.ts";
+import { PROGRAM_RESULT_TAG, SCRIPT_HEADER } from "../programs/programs.ts";
+import { formatDuration, renderResultList } from "../render-call.ts";
+
+const AGENT_NOTIFICATION = new RegExp(`^<${RESULT_TAG} name="([^"]*)" id="([^"]*)" status="([^"]*)">\\n([\\s\\S]*)\\n</${RESULT_TAG}>(?:\\n+([\\s\\S]*))?$`);
+const PROGRAM_NOTIFICATION = new RegExp(`^<${PROGRAM_RESULT_TAG} id="([^"]*)" status="([^"]*)">\\n([\\s\\S]*)\\n</${PROGRAM_RESULT_TAG}>(?:\\n+([\\s\\S]*))?$`);
+
+/** The result of a notification made before notifications recorded their results, parsed from its text. */
+function parsedResult(text: string): NotifiedResult | undefined {
+	const agent = AGENT_NOTIFICATION.exec(text);
+	if (agent) return { name: agent[1], id: agent[2]!, status: agent[3]!, body: agent[4]!, notice: agent[5] };
+	const program = PROGRAM_NOTIFICATION.exec(text);
+	if (!program) return undefined;
+	const header = SCRIPT_HEADER.exec(program[3]!);
+	return { id: program[1]!, status: program[2]!, ...(header?.[1] !== undefined && { seconds: Number(header[1]) }), body: program[3]!.slice(header?.[0].length ?? 0), notice: program[4] };
+}
+
+/** A result's line: an Agent's name and ID, or a Program's ID and wall time, with its status. */
+function resultLine({ name, id, status, seconds }: NotifiedResult): string {
+	if (name !== undefined) return `${name} (${id})  ${status}`;
+	return [`Program ${id}`, status, ...(seconds === undefined ? [] : [formatDuration(seconds * 1000)])].join("  ");
+}
 
 /**
  * Collapsed, a message from another Agent shows its sender after the label, as Pi shows a collapsed skill, and the
@@ -8,14 +30,26 @@ import { messageBody, type Sender } from "../agents/registry.ts";
  * model received.
  */
 export const renderAgentMessage: MessageRenderer = (message, { expanded, outputPad }, theme) => {
-	if (expanded || typeof message.content !== "string") return undefined;
-	const details = message.details as { user?: boolean; sender?: Sender } | undefined;
-	if (details?.user) return new UserMessageComponent(message.content, getMarkdownTheme(), outputPad);
-	const body = details?.sender && messageBody(message.content, details.sender);
-	if (body === undefined) return undefined;
-	const { id, name } = details!.sender!;
+	if (expanded) return undefined;
+	const details = message.details as { user?: boolean; sender?: Sender; results?: NotifiedResult[] } | undefined;
+	// A Program's notification also holds the images of its result, which show when expanded.
+	const content = typeof message.content === "string" ? message.content : message.content.find((part) => part.type === "text")?.text;
+	if (content === undefined) return undefined;
+	if (details?.user) return new UserMessageComponent(content, getMarkdownTheme(), outputPad);
 	const box = new Box(outputPad, 1, (text) => theme.bg("customMessageBg", text));
 	const label = theme.fg("customMessageLabel", `\x1b[1m[${message.customType}]\x1b[22m`);
+	// A notification shows each of its results as a line with the first lines of its body.
+	const parsed = !details?.sender && !details?.results && parsedResult(content);
+	const results = details?.results ?? (parsed ? [parsed] : undefined);
+	if (results) {
+		box.addChild(new Text(label, 0, 0));
+		box.addChild(new Spacer(1));
+		box.addChild(renderResultList(results.map((result) => ({ line: resultLine(result), body: result.body })), results.flatMap((result) => result.notice ? [result.notice] : []), {}, theme));
+		return box;
+	}
+	const body = details?.sender && messageBody(content, details.sender);
+	if (body === undefined) return undefined;
+	const { id, name } = details!.sender!;
 	const sender = name === undefined ? theme.fg("customMessageText", ` from ${id}`) : theme.fg("customMessageText", ` from ${name}`) + theme.fg("dim", ` (${id})`);
 	box.addChild(new Text(label + sender, 0, 0));
 	box.addChild(new Spacer(1));

package/src/ui/panel.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Container, TruncatedText } from "@earendil-works/pi-tui";
-import { label, nodes, onTreeChange, programLabel, programsOf, type AgentNode, type Spend } from "../agents/registry.ts";
+import { label, liveWork, onTreeChange, programLabel, taskLive, tasksOf, type AgentNode, type Spend, type Task } from "../agents/registry.ts";
 
 const WIDGET_KEY = "pi-agents";
 
@@ -23,53 +23,38 @@ function cost({ cost, tokens, unpriced }: Spend): string {
 	return tokens < 10_000_000 ? `${(tokens / 1_000_000).toFixed(1)}M tok` : `${Math.round(tokens / 1_000_000)}M tok`;
 }
 
+/** The cost of `spent`, once there is any. */
+function spend(spent: Spend | undefined): string[] {
+	return spent && (spent.cost > 0 || spent.tokens > 0) ? [cost(spent)] : [];
+}
+
 /**
- * The task panel: the Agent's live owned Agents and running background Programs as a tree, in the
- * order they started, with their Programs' live Agents under them, and how long each has run and what
- * it has cost. Empty when none.
+ * The task panel: the Agent's live work as a tree, in the order it started, with how long each has run
+ * and what it has cost. Empty when none.
  */
 export function panelLines(self: AgentNode, now = Date.now()): string[] {
-	const rows: Array<{ line: string; parent?: number; shown: boolean }> = [];
 	const ids = self.agents.ids();
-	let live = 0;
-	// A live row is listed with its owners, so the tree stays readable.
-	const show = (index: number | undefined) => {
-		for (let row = index === undefined ? undefined : rows[index]; row && !row.shown; row = row.parent === undefined ? undefined : rows[row.parent]) row.shown = true;
-	};
-	const visit = (node: AgentNode, level: number, parent?: number) => {
-		const children = [
-			...node.agents.owned().map((entry) => ({ at: entry.createdAt ?? "", entry })),
-			...programsOf(node).filter((program) => program.background).map((program) => ({ at: program.createdAt ?? "", program })),
-		].sort((a, b) => a.at.localeCompare(b.at));
-		for (const child of children) {
-			const index = rows.length;
-			if ("program" in child) {
-				const since = Date.parse(child.program.createdAt ?? "");
-				const time = since ? [elapsed(since, now), ...(child.program.spent ? [cost(child.program.spent)] : [])] : [];
-				rows.push({ line: `${"  ".repeat(level)}${[programLabel(child.program), "running", ...time].join("  ")}`, parent, shown: false });
-				live += 1;
-				show(index);
-				visit(child.program, level + 1, index);
-				continue;
-			}
-			const { entry } = child;
-			const own = node.agents.counts(entry.id);
-			const pending = own?.pending ? [`${own.pending} pending`] : [];
-			const time = own?.since ? [elapsed(own.since, now), ...(own.spent ? [cost(own.spent)] : [])] : [];
-			rows.push({ line: `${"  ".repeat(level)}Agent ${[label(entry, ids), entry.state, ...time, ...pending].join("  ")}`, parent, shown: false });
-			if (entry.state !== "idle") {
-				live += 1;
-				show(index);
-			}
-			const loaded = nodes.get(entry.id);
-			if (loaded) visit(loaded, level + 1, index);
+	const line = (task: Task): string => {
+		if ("program" in task) {
+			const since = Date.parse(task.program.createdAt ?? "");
+			const time = since ? [elapsed(since, now), ...spend(task.program.spent)] : [];
+			return [programLabel(task.program), "running", ...time].join("  ");
 		}
+		const { entry, owner } = task;
+		const own = owner.agents.counts(entry.id);
+		const pending = own?.pending ? [`${own.pending} pending`] : [];
+		const time = own?.since ? [elapsed(own.since, now), ...spend(own.spent)] : [];
+		return `Agent ${[label(entry, ids), entry.state, ...time, ...pending].join("  ")}`;
 	};
-	visit(self, 0);
-	const lines = rows.filter((row) => row.shown).map((row) => row.line);
+	// A row is listed while it is live or has live work under it, so the tree stays readable.
+	const rows = (tasks: Task[], level: number): string[] => tasks.flatMap((task) => {
+		const under = rows(task.tasks, level + 1);
+		return taskLive(task) || under.length > 0 ? [`${"  ".repeat(level)}${line(task)}`, ...under] : [];
+	});
+	const lines = rows(tasksOf(self), 0);
 	if (lines.length === 0) return [];
 	if (lines.length > MAX_LINES - 1) lines.splice(MAX_LINES - 2, Infinity, `+${lines.length - (MAX_LINES - 2)} more`);
-	return [`Tasks (${live} live, /tasks to view)`, ...lines.map((line) => `  ${line}`)];
+	return [`Tasks (${liveWork(self)} live, /tasks to view)`, ...lines.map((line) => `  ${line}`)];
 }
 
 /**