@tshu-w/pi-agents 0.2.0 → 0.2.2

package/src/agents/registry.ts

@@ -31,7 +31,7 @@ export interface AgentNode {
 	sessionFile(): string | undefined;
 	agents: Agents;
 	/** Delivers a message to this node; used only for root Agents. */
-	receive(text: string, delivery: Delivery, messageId?: string): void;
+	receive(text: string, delivery: Delivery, messageId?: string, sender?: Sender): void;
 	/** A root Agent's turn was stopped: messages from other Agents become writes until the user's next input. */
 	stopped?: boolean;
 }
@@ -242,31 +242,56 @@ export function deliver(
 	const fromOwner = from !== undefined && target.ownerId === from.id;
 	const ids = recipientIds(target);
 	const text = from === undefined ? body : messageText(from, fromOwner, delivery, body, ids);
+	const by = from && sender(from, ids);
 	if (target.ownerId === undefined) {
 		const node = shared.nodes.get(target.id);
 		if (!node) throw new Error(`${label(target, ids)} is offline.`);
-		node.receive(text, delivery);
+		node.receive(text, delivery, undefined, by);
 		return { queued: false };
 	}
 	const owner = shared.nodes.get(target.ownerId);
 	if (!owner) throw new Error(`${label(target, ids)} is offline.`);
-	return owner.agents.accept(target.id, text, delivery, { fromOwner, notification: from === undefined });
+	return owner.agents.accept(target.id, text, delivery, { fromOwner, notification: from === undefined, sender: by });
 }
 
 export const MESSAGE_TAG = "agent-message";
+const REPLY_NOTE = ' note="Reply with send"';
+
+/** The sender of a message as its element names it: its name and its short ID among the recipient's visible Agents. */
+export interface Sender {
+	id: string;
+	name?: string;
+}
+
+export function sender(from: { id: string; name?: string }, ids: Iterable<string>): Sender {
+	return { id: shortId(from.id, ids), ...(from.name === undefined ? {} : { name: from.name }) };
+}
+
+/** The element a sender's message opens with, naming the sender as `agent-result` names its Agent. */
+function messageOpen({ id, name }: Sender): string {
+	return `<${MESSAGE_TAG}${name === undefined ? "" : ` name="${name}"`} id="${id}"`;
+}
 
 /** A message in an element naming its sender; an input from a sender other than the owner asks for a reply. */
 export function messageText(from: { id: string; name?: string }, fromOwner: boolean, delivery: Delivery, body: string, ids: Iterable<string>): string {
-	const note = !fromOwner && delivery !== "write" ? ' note="Reply with send"' : "";
-	return `<${MESSAGE_TAG} from="${from.name ?? shortId(from.id, ids)}" id="${shortId(from.id, ids)}"${note}>\n${body}\n</${MESSAGE_TAG}>`;
+	const note = !fromOwner && delivery !== "write" ? REPLY_NOTE : "";
+	return `${messageOpen(sender(from, ids))}${note}>\n${body}\n</${MESSAGE_TAG}>`;
+}
+
+/** The body of a message `messageText` made for `sender`, or undefined if `text` is not one. */
+export function messageBody(text: string, sender: Sender): string | undefined {
+	const open = messageOpen(sender);
+	const close = `\n</${MESSAGE_TAG}>`;
+	const header = [`${open}>\n`, `${open}${REPLY_NOTE}>\n`].find((start) => text.startsWith(start));
+	return header && text.length >= header.length + close.length && text.endsWith(close) ? text.slice(header.length, -close.length) : undefined;
 }
 
 /**
  * `messageId` marks a message from a root Agent in another process, so it is added once; `user`
- * marks the user's input from the task viewer.
+ * marks the user's input from the task viewer, and `sender` the Agent that sent it.
  */
-export function customMessage(text: string, delivery: Delivery, messageId?: string, user?: boolean) {
-	return { customType: MESSAGE_TYPE, content: text, display: true, details: { delivery, ...(messageId ? { messageId } : {}), ...(user ? { user } : {}) } };
+export function customMessage(text: string, delivery: Delivery, { messageId, user, sender }: { messageId?: string; user?: boolean; sender?: Sender } = {}) {
+	return { customType: MESSAGE_TYPE, content: text, display: true, details: { delivery, ...(messageId ? { messageId } : {}), ...(user ? { user } : {}), ...(sender ? { sender } : {}) } };
 }
 
 export function receivedMessageIds(ctx: ExtensionContext): string[] {

package/src/agents/tool.ts

@@ -1,9 +1,9 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
-import { boundBlocks, boundText } from "../output.ts";
+import { boundBlocks, boundText, type Truncation } from "../output.ts";
 import { rejectFields } from "../params.ts";
-import { renderTextResult, renderToolCall, startDuration, type DurationState } from "../render-call.ts";
+import { renderResultList, renderTextResult, renderToolCall, startDuration, type DurationState } from "../render-call.ts";
 import { agentSession } from "../roots/rpc.ts";
 import type { RootRuntime } from "../roots/runtime.ts";
 import {
@@ -35,12 +35,25 @@ function resultDetails({ agent, input, history }: WaitResult, result?: string) {
 	return { id: agent.id, name: agent.name, state: input.state, history, ...(result === undefined ? {} : { result }) };
 }
 
+type Named = { id: string; name?: string };
+
+/** The line naming the results left out to keep within Pi's output limits. */
+function omittedLine(omitted: Named[], ids: string[]): string {
+	return omitted.length > 0 ? `[Results omitted: ${omitted.map((agent) => label(agent, ids)).join(", ")}. Use wait with fewer targets.]` : "";
+}
+
+/** The line naming the Agents still pending, and that a steer ended the wait if one did. */
+function pendingLine(pending: Named[], interrupted: boolean | undefined, ids: string[]): string {
+	return pending.length > 0 ? `Still pending: ${pending.map((agent) => label(agent, ids)).join(", ")}${interrupted ? `\n${WAIT_INTERRUPTED}` : ""}` : "";
+}
+
 /** Renders wait results; returns the text and the results the caller has now read. */
 function renderWait(outcome: WaitOutcome, ids: string[]): { text: string; read: WaitResult[]; details: Record<string, unknown> } {
 	const { results, pending, interrupted } = outcome;
-	const pendingLine = pending.length > 0 ? `Still pending: ${pending.map((agent) => label(agent, ids)).join(", ")}${interrupted ? `\n${WAIT_INTERRUPTED}` : ""}` : "";
+	const pendingText = pendingLine(pending, interrupted, ids);
 	const flag = interrupted ? { interrupted } : {};
-	if (results.length === 0) return { text: pendingLine || "No results.", read: [], details: { results: [], pending: pending.map((agent) => agent.id), ...flag } };
+	const named = pending.map(({ id, name }) => ({ id, name }));
+	if (results.length === 0) return { text: pendingText || "No results.", read: [], details: { results: [], pending: named, ...flag } };
 	const only = results[0]!;
 	if (results.length === 1 && pending.length === 0 && !only.history && only.input.state === "completed") {
 		const bounded = boundText(only.input.result ?? "", "pi-agents-wait");
@@ -57,10 +70,10 @@ function renderWait(outcome: WaitOutcome, ids: string[]): { text: string; read:
 	});
 	let text = bounded.text;
 	const read = results.slice(0, bounded.shown);
-	const omitted = results.slice(bounded.shown);
-	if (omitted.length > 0) text += `\n\n[Results omitted: ${omitted.map((result) => label(result.agent, ids)).join(", ")}. Use wait with fewer targets.]`;
-	if (pendingLine) text += `\n\n${pendingLine}`;
-	return { text, read, details: { results: details, pending: pending.map((agent) => agent.id), ...flag, ...bounded.details } };
+	const omittedText = omittedLine(results.slice(bounded.shown).map((result) => result.agent), ids);
+	if (omittedText) text += `\n\n${omittedText}`;
+	if (pendingText) text += `\n\n${pendingText}`;
+	return { text, read, details: { results: details, pending: named, ...flag, ...bounded.details } };
 }
 
 /** Registers the `agent` tool. */
@@ -89,8 +102,18 @@ export function registerAgentTool(
 			startDuration(context.state as DurationState, args.action === "wait", context.executionStarted);
 			return renderToolCall("agent", args, theme, context.lastComponent);
 		},
-		// `wait` shows how long it has waited.
-		renderResult: (result, options, theme, context) => renderTextResult(result, options, theme, context),
+		// `wait` shows how long it has waited, and when collapsed, each result as a line with the first lines of its body.
+		renderResult: (result, options, theme, context) => renderTextResult(result, options, theme, context, (context.args as { action?: string }).action === "wait"
+			? () => {
+				const { results = [], pending = [], interrupted, ...truncated } = (result.details ?? {}) as { results?: ReturnType<typeof resultDetails>[]; pending?: Named[]; interrupted?: boolean } & Partial<Truncation>;
+				const only = results[0];
+				// As `renderWait` returns them, no results, or a single completed result alone, show as they are.
+				if (!only || (results.length === 1 && pending.length === 0 && !only.history && only.state === "completed")) return undefined;
+				const ids = [...results.map((entry) => entry.id), ...pending.map((agent) => agent.id)];
+				const notes = [omittedLine(results.filter((entry) => entry.result === undefined), ids), pendingLine(pending, interrupted, ids)];
+				return renderResultList(results.flatMap((entry) => entry.result === undefined ? [] : [{ line: `${label(entry, ids)}  ${entry.state}`, body: entry.result }]), notes, truncated, theme);
+			}
+			: undefined),
 		description: `Create, message, and coordinate Agents. \`spawn\` creates an owned Agent and sends its first input; \`send\` sends an input or a write to a visible Agent; \`wait\` waits for owned Agents and returns unread results; \`list\` finds visible Agents; \`abort\` stops an owned Agent's current turn and queued inputs while keeping it available. When an owned Agent finishes an input while its owner is not waiting for it, the owner receives a notification naming the Agent and outcome; \`wait\` returns the result. Owned Agents under the same root share \`${maxConcurrent}\` execution slots and a limit of \`${maxOutstanding}\` inputs that have not ended. Inputs that start a new turn queue when all slots are busy; new inputs are rejected at the input limit.`,
 		promptSnippet: "Create, message, and coordinate Agents",
 		promptGuidelines: [
@@ -105,7 +128,7 @@ export function registerAgentTool(
 			cwd: Type.Optional(Type.String({ description: "Working directory for `spawn` (default: the caller's current working directory)." })),
 			context: Type.Optional(StringEnum(["fresh", "fork"] as const, { description: "Context for `spawn` (default: fresh). fresh starts without the caller's conversation; fork snapshots it." })),
 			model: Type.Optional(Type.String({ description: "Model for `spawn` as provider/modelId (default: the caller's model)." })),
-			thinkingLevel: Type.Optional(StringEnum(THINKING_LEVELS, { description: "Thinking level for `spawn`: off, minimal, low, medium, high, or xhigh (default: the caller's level)." })),
+			thinkingLevel: Type.Optional(StringEnum(THINKING_LEVELS, { description: "Thinking level for `spawn`: off, minimal, low, medium, high, xhigh, or max (default: the caller's level)." })),
 			target: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())], { description: "Agent ID, name, or unique ID prefix for `send`, `wait`, or `abort`. `wait` and `send` with `deliverAs='write'` also accept an array. When omitted for `wait`, selects all owned Agents with pending or unread results." })),
 			deliverAs: Type.Optional(StringEnum(["followUp", "steer", "write"] as const, { description: "Delivery for `send` (default: followUp). followUp waits until the recipient's current turn ends; steer delivers after its current tool calls, before the next model call; write delivers like steer but never starts a turn and has no result." })),
 			history: Type.Optional(Type.Integer({ minimum: 0, description: "Number of most recent read results to return again per selected Agent for `wait` (default: 0)." })),

package/src/host/client.mjs

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { constants } from 'node:fs';
 import { open, readdir, stat, unlink } from 'node:fs/promises';
 import net from 'node:net';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { setTimeout as delay } from 'node:timers/promises';
 import { FRAME, frame, json, readFrames } from './frames.mjs';
@@ -27,6 +27,11 @@ export function hostStatus(path) {
   });
 }
 
+/** The file of the Session a host runs; Pi keeps a relative session directory relative, so it resolves against the host's cwd. */
+export function hostSessionFile(host) {
+  return host.session?.file && resolve(host.cwd, host.session.file);
+}
+
 export function alive(pid) {
   try { process.kill(pid, 0); return true; }
   catch (error) { return error.code !== 'ESRCH'; }

package/src/host/rpc-client.mjs

@@ -3,7 +3,7 @@
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { setTimeout as delay } from 'node:timers/promises';
-import { alive, hostStatus, settledHosts, startHost } from './client.mjs';
+import { alive, hostSessionFile, hostStatus, settledHosts, startHost } from './client.mjs';
 import { readSessionHeader, readSessionId } from '../roots/guard.mjs';
 import { openStream, request } from '../roots/transport.mjs';
 import { piPackage } from '../pi.mjs';
@@ -13,8 +13,7 @@ const TIMEOUT_MS = 30000;
 const NOT_READY = ['ENOENT', 'ECONNREFUSED', 'SOCKET_MODE', 'NOT_READY'];
 const GONE = ['ENOENT', 'ECONNREFUSED', 'ECONNRESET'];
 // Options that choose the Session; another Session opens with the rest.
-const SESSION_FLAGS = new Set(['--session', '--session-id', '--fork', '--name', '-n']);
-const SESSION_SWITCHES = new Set(['-c', '--continue', '-r', '--resume']);
+const SESSION_OPTIONS = new Set(['--session', '--session-id', '--fork', '--name', '-n', '-c', '--continue', '-r', '--resume']);
 
 function fault(code, message) {
   return Object.assign(new Error(message), { code });
@@ -42,20 +41,39 @@ async function connect(paths, id, handlers, live, role = 'rpc') {
   }
 }
 
+/**
+ * Whether Pi's `parseArgs` reads `next` as the value of `arg`. It decides by the form of `next`, so a probe of that form
+ * shows it: the probe is consumed, or parsed on its own as a message, a file, an unknown short option, or an unknown flag.
+ */
+function takesValue(parseArgs, arg, next) {
+  const probe = next.startsWith('---') ? '---\0' : next.startsWith('-') ? '-\0' : next.startsWith('@') ? '@\0' : '\0';
+  const parsed = parseArgs([arg, probe]);
+  if (probe === '\0') return !parsed.messages.includes(probe);
+  if (probe === '@\0') return !parsed.fileArgs.includes('\0');
+  // Only Pi's own diagnostic for the probe alone; an option may consume it and report it as an invalid value.
+  if (probe === '-\0') return !parsed.diagnostics.some(({ message }) => message === `Unknown option: ${probe}`);
+  return !parsed.unknownFlags.has('-\0');
+}
+
+/** `args` in the groups Pi reads: an option with its value, or an argument alone; from `--` on, one group. */
+export function argGroups(parseArgs, args) {
+  const groups = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--') {
+      groups.push(args.slice(i));
+      break;
+    }
+    groups.push(i + 1 < args.length && takesValue(parseArgs, args[i], args[i + 1]) ? [args[i], args[++i]] : [args[i]]);
+  }
+  return groups;
+}
+
 /** `args` without the prompts, and without the options that make Pi non-interactive. */
 function withoutPrompts(parseArgs, args) {
-  const options = [];
-  let separated = false;
-  for (let i = 0, before = parseArgs([]); i < args.length; i++) {
-    const after = parseArgs(args.slice(0, i + 1));
-    const positional = after.messages.length > before.messages.length || after.fileArgs.length > before.fileArgs.length;
-    before = after;
-    if (separated || positional) continue;
-    if (args[i] === '--') separated = true;
-    else if (args[i] === '--mode') i++;
-    else if (args[i] !== '-p' && args[i] !== '--print') options.push(args[i]);
-  }
-  return options;
+  return argGroups(parseArgs, args).filter(group => {
+    const parsed = parseArgs(group);
+    return !parsed.messages.length && !parsed.fileArgs.length && !['-p', '--print', '--mode'].includes(group[0]);
+  }).flat();
 }
 
 /** The prompts Pi sends on startup for `parsed`: its initial message, then each further message. */
@@ -90,7 +108,7 @@ export async function runHeadless({ pi, paths, args, mode, findRunning, warnIgno
 
   // The host runs Pi without the prompts, which arrive as RPC commands instead.
   const hostArgs = withoutPrompts(parseArgs, args);
-  const sessionArgs = hostArgs.filter((arg, i) => !SESSION_FLAGS.has(arg) && !SESSION_SWITCHES.has(arg) && !SESSION_FLAGS.has(hostArgs[i - 1]));
+  const sessionArgs = argGroups(parseArgs, hostArgs).filter(([option]) => !SESSION_OPTIONS.has(option)).flat();
 
   /** Starts a host for `hostArgs` in `cwd`; resolves once its Pi reports the Session. */
   async function host(hostArgs, cwd) {
@@ -108,10 +126,12 @@ export async function runHeadless({ pi, paths, args, mode, findRunning, warnIgno
 
   /** Connects to the Session in `file`, starting it in a host in `cwd` if no Pi runs it. */
   async function open(file, cwd, handlers) {
+    // A Session Pi created in a relative session directory has a relative file.
+    file = resolve(cwd, file);
     const deadline = performance.now() + TIMEOUT_MS;
     for (;;) {
       const id = readSessionId(file);
-      const holds = h => h.session && (h.session.id === id || h.session.file === file);
+      const holds = h => h.session && (h.session.id === id || hostSessionFile(h) === file);
       try {
         const held = (await settledHosts(paths, holds)).find(holds);
         if (held) return await connect(paths, held.session.id, handlers, () => alive(held.pid));

package/src/index.ts

@@ -15,8 +15,10 @@ import { Agents, type Limits } from "./agents/agents.ts";
 import {
 	customMessage,
 	liveWork,
+	MESSAGE_TYPE,
 	messageText,
 	rememberRoots,
+	sender,
 	visibleIds,
 	nodes,
 	receivedMessageIds,
@@ -39,6 +41,7 @@ import { createReporter } from "./roots/report.ts";
 import { installQueuePatches } from "./roots/queue.ts";
 import { agentSession, installRpcPatches } from "./roots/rpc.ts";
 import { createRootRuntime } from "./roots/runtime.ts";
+import { renderAgentMessage } from "./ui/message.ts";
 import { createPanel } from "./ui/panel.ts";
 import { showQueue } from "./ui/queue.ts";
 import { openTaskViewer } from "./ui/viewer.ts";
@@ -105,7 +108,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			if (message.user) return pi.sendUserMessage(message.body, { deliverAs: delivery === "steer" ? "steer" : "followUp" });
 			// The header names the sender by a short ID unique among the roots this root sees.
 			rememberRoots((await roots.roots()).map((root) => root.id));
-			if (node) node.receive(messageText(message.sender!, false, delivery, message.body, visibleIds(node.scopeId, true)), delivery, message.id);
+			if (!node) return;
+			const ids = visibleIds(node.scopeId, true);
+			node.receive(messageText(message.sender!, false, delivery, message.body, ids), delivery, message.id, sender(message.sender!, ids));
 		},
 		treeIdle: () => node === undefined || treeIdle(node.rootId),
 		receivedIds: receivedMessageIds,
@@ -150,9 +155,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			cwd: () => ctx?.cwd ?? current.cwd,
 			busy: () => !(ctx?.isIdle() ?? true),
 			sessionFile: () => ctx?.sessionManager.getSessionFile(),
-			receive: (text, delivery, messageId) => {
+			receive: (text, delivery, messageId, from) => {
 				const as = created.stopped ? "write" : delivery;
-				pi.sendMessage(customMessage(text, as, messageId), as === "write"
+				pi.sendMessage(customMessage(text, as, { messageId, sender: from }), as === "write"
 					? { deliverAs: "steer" }
 					: { deliverAs: as, triggerTurn: true });
 				queue.update();
@@ -209,6 +214,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 
 	registerAgentTool(pi, { limits: settings, roots, requireNode });
 	registerProgramTools(pi, { agentDir, settings, piCodemode, requireNode, programs: () => programs });
+	pi.registerMessageRenderer(MESSAGE_TYPE, renderAgentMessage);
 
 	pi.registerCommand("tasks", {
 		description: "Watch an Agent or Program; `/tasks panel` toggles the panel",

package/src/output.ts

@@ -18,6 +18,8 @@ export interface BoundedText {
 	text: string;
 	/** The kept prefix of the text, without the notice. */
 	kept: string;
+	/** The notice naming the file with the full text. */
+	notice?: string;
 	details?: Truncation;
 }
 
@@ -30,9 +32,11 @@ export function boundText(text: string, prefix: string): BoundedText {
 	const summary = truncation.firstLineExceedsLimit
 		? `Line 1 is ${formatSize(Buffer.byteLength(text.split("\n")[0]!, "utf8"))}, exceeds ${formatSize(truncation.maxBytes)} limit.`
 		: `Showing lines 1-${truncation.outputLines} of ${truncation.totalLines}${truncation.truncatedBy === "bytes" ? ` (${formatSize(truncation.maxBytes)} limit)` : ""}.`;
+	const notice = `[${summary} Full output: ${fullOutputPath}]`;
 	return {
-		text: `${truncation.content}\n\n[${summary} Full output: ${fullOutputPath}]`,
+		text: `${truncation.content}\n\n${notice}`,
 		kept: truncation.content,
+		notice,
 		details: { truncation, fullOutputPath },
 	};
 }

package/src/programs/codemode.ts

@@ -25,6 +25,20 @@ export function loadCodemode(): Promise<Codemode> {
 	return loaded;
 }
 
+/** Where Pi's executor starts codemode workers from. */
+export interface PiWorkerSource {
+	getQuickJSWasmPath(): string;
+	getCodemodeWorkerSpecifier(): string | URL | undefined;
+}
+
+let workerSource: Promise<PiWorkerSource> | undefined;
+
+/** Loads Pi's `dist/config.js`, the module its executor reads them from. */
+export function loadPiWorkerSource(): Promise<PiWorkerSource> {
+	workerSource ??= import(pathToFileURL(join(getPackageDir(), "dist", "config.js")).href);
+	return workerSource;
+}
+
 /** Parts of Pi's `codemode` tool that its package entry does not export. */
 export interface PiCodemode {
 	/** Pi's `codemode` tool definition; `program` reuses its `prepareLoadout` and, since Pi 1.2.0, `reachesTools`. */

package/src/programs/execute.ts

@@ -6,7 +6,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { CodemodeResult, CodemodeTool } from "@earendil-works/pi-codemode";
 import type { AgentToolResult, AgentToolUpdateCallback, ExtensionToolContext } from "@earendil-works/pi-coding-agent";
-import { loadCodemode, loadPiCodemode } from "./codemode.ts";
+import { loadCodemode, loadPiCodemode, loadPiWorkerSource } from "./codemode.ts";
 import type { DetachedCallOptions } from "./host-patches.ts";
 
 export const PROGRAM_TOOL_NAME = "program";
@@ -104,20 +104,67 @@ interface SandboxExtras {
 const sandboxExtras = new AsyncLocalStorage<SandboxExtras>();
 let sandboxPatch: Promise<void> | undefined;
 
+/**
+ * Since Pi 1.3.0, its executor admits at most two codemode workers per process, which background
+ * Programs waiting on Agents use up. A Program's worker is admitted on its own terms instead: any
+ * number may run, and none starts while this many are still exiting after their scripts ended.
+ */
+const MAX_EXITING_WORKERS = 2;
+const exitingWorkers = new Set<{ exited: boolean }>();
+
+/** A launcher for one Program's worker, from where Pi's executor starts its own. */
+function programWorker(codemode: Awaited<ReturnType<typeof loadCodemode>>, wasmPath: string, workerUrl: string | URL | undefined) {
+	let worker: { exited: boolean } | undefined;
+	let ended = false;
+	const options = {
+		wasm: codemode.loadQuickJSWasm(wasmPath),
+		workerUrl,
+		acquireWorker: () => {
+			// The script can end while the QuickJS module loads, before its worker starts.
+			if (ended) throw new Error("The Program ended before its worker started.");
+			if (exitingWorkers.size >= MAX_EXITING_WORKERS) {
+				throw new Error(`${exitingWorkers.size} workers of ended Programs are still shutting down. Retry after they exit.`);
+			}
+			const started = { exited: false };
+			worker = started;
+			return () => {
+				started.exited = true;
+				exitingWorkers.delete(started);
+			};
+		},
+	};
+	const sandbox = new codemode.CodemodeSandbox(options) as unknown as Record<string, unknown>;
+	return {
+		launch: sandbox.launch,
+		ended() {
+			ended = true;
+			if (worker && !worker.exited) exitingWorkers.add(worker);
+		},
+	};
+}
+
 async function patchSandbox(): Promise<void> {
-	const proto = (await loadCodemode()).CodemodeSandbox.prototype as unknown as Record<string, any>;
+	const [codemode, source] = await Promise.all([loadCodemode(), loadPiWorkerSource()]);
+	const wasmPath = source.getQuickJSWasmPath();
+	const workerUrl = source.getCodemodeWorkerSpecifier();
+	const proto = codemode.CodemodeSandbox.prototype as unknown as Record<string, any>;
 	const execute = proto.execute;
 	proto.execute = function (this: Record<string, any>, code: string, options: Record<string, unknown> = {}) {
 		const current = sandboxExtras.getStore();
 		if (!current || current.used) return execute.call(this, code, options);
 		current.used = true;
 		for (const global of current.globals) this.globalsByName.set(global.name, global);
+		// Before Pi 1.2.0, the sandbox starts its worker itself, with no limit.
+		const worker = typeof this.launch === "function" ? programWorker(codemode, wasmPath, workerUrl) : undefined;
+		if (worker) this.launch = worker.launch;
 		const timeoutMs = Math.min(current.timeoutMs, (options.timeoutMs as number | undefined) ?? this.timeoutMs);
 		return execute.call(this, current.prepare(code), { ...options, timeoutMs }).then((result: CodemodeResult) => {
+			worker?.ended();
 			current.result = result;
 			current.ended();
 			return result;
 		}, (error: unknown) => {
+			worker?.ended();
 			current.ended();
 			throw error;
 		});

package/src/programs/loadout.ts

@@ -2,7 +2,10 @@ import { highlightCode, type ExtensionAPI, type ToolDefinition } from "@earendil
 import { Text } from "@earendil-works/pi-tui";
 import { CODEMODE_TOOL_NAME, type PiCodemode } from "./codemode.ts";
 import { PROGRAM_TOOL_NAME } from "./execute.ts";
-import { formatToolCall, moreLines, renderTextResult, startDuration, type DurationState } from "../render-call.ts";
+import { shortId } from "../agents/registry.ts";
+import { formatDuration, formatToolCall, moreLines, renderResultList, renderTextResult, startDuration, type DurationState } from "../render-call.ts";
+import type { Truncation } from "../output.ts";
+import { omittedLine, runningLine, type ProgramResultDetails } from "./programs.ts";
 
 /** The first line of the `codemode` description, which the `program` intro replaces. */
 const CODEMODE_FIRST_LINE = "Run JavaScript code to orchestrate/compose tool calls\n";
@@ -91,9 +94,21 @@ export function programRenderers(piCodemode: PiCodemode): Renderers {
 			component.setText(text);
 			return component;
 		},
-		// `wait` shows how long it has waited; the other results render like `codemode`.
+		// `wait` shows how long it has waited, and when collapsed, each result as a line with the first lines of its output;
+		// the other results render like `codemode`.
 		renderResult: (result, options, theme, context) => (context.args as { action?: string }).action === "wait"
-			? renderTextResult(result, options, theme, context)
+			? renderTextResult(result, options, theme, context, () => {
+				const { results = [], running = [], interrupted, ...truncated } = (result.details ?? {}) as { results?: ProgramResultDetails[]; running?: string[]; interrupted?: boolean } & Partial<Truncation>;
+				const only = results[0];
+				// As `renderProgramWait` returns them, no results, or a single completed result alone, show as they are.
+				if (!only || (results.length === 1 && running.length === 0 && only.state === "completed")) return undefined;
+				const ids = [...results.map((entry) => entry.id), ...running];
+				const notes = [omittedLine(results.flatMap((entry) => entry.output === undefined ? [entry.id] : []), ids), runningLine(running, interrupted, ids)];
+				return renderResultList(results.flatMap(({ id, state, wallTimeSeconds, output }) => output === undefined ? [] : [{
+					line: [`Program ${shortId(id, ids)}`, state, ...(wallTimeSeconds === undefined ? [] : [formatDuration(wallTimeSeconds * 1000)])].join("  "),
+					body: output,
+				}]), notes, truncated, theme);
+			})
 			: piCodemode.renderResult(result, options, theme, context) as Text,
 	};
 }

package/src/programs/programs.ts

@@ -2,7 +2,7 @@ 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 } from "../output.ts";
+import { boundBlocks, boundText, type Truncation } 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";
@@ -327,23 +327,64 @@ 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>`;
 }
 
-/** Renders wait results; returns the content and the results the caller has now received. */
-export function renderProgramWait({ results, running, interrupted }: ProgramWaitOutcome, ids: string[]): { content: Item[]; returned: ProgramRecord[]; isError?: boolean } {
-	const runningLine = running.length > 0 ? `Still running: ${running.map((record) => shortId(record.id, ids)).join(", ")}${interrupted ? `\n${WAIT_INTERRUPTED}` : ""}` : "";
-	if (results.length === 0) return { content: [{ type: "text", text: runningLine || "No results." }], returned: [] };
+// 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)], returned: results };
+		return { content: [{ type: "text", text: bounded.text }, ...images(results)], details: { results: [resultDetails(only)], ...bounded.details }, returned: results };
 	}
-	const bounded = boundBlocks(results.map((record) => resultBlock(record, ids)), "program-result", "pi-agents-program-wait");
+	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 omitted = results.slice(bounded.shown);
-	if (omitted.length > 0) text += `\n\n[Results omitted: ${omitted.map((record) => shortId(record.id, ids)).join(", ")}. Use wait with fewer targets.]`;
-	if (runningLine) text += `\n\n${runningLine}`;
-	return { content: [{ type: "text", text }, ...images(returned)], returned };
+	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 function programListLine(record: ProgramRecord, ids: string[]): string {

package/src/programs/scope.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Agents, settlesBy, SUBMIT_RESULT_TOOL_NAME, THINKING_LEVELS, type Limits } from "../agents/agents.ts";
-import { label, messageText, nodes, treeChanged, visibleIds, type AgentNode } from "../agents/registry.ts";
+import { label, messageText, nodes, sender, treeChanged, visibleIds, type AgentNode } from "../agents/registry.ts";
 import { CLEANUP_TIMEOUT_MS } from "./execute.ts";
 import type { AgentOptions, ProgramAgentHost, SendOptions } from "./sandbox.ts";
 
@@ -70,12 +70,13 @@ export function programScope(
 			}
 			const agent = agents.ownedTarget(agentId).record;
 			const body = schema === undefined ? message : `${message}\n\nWhen done, call \`${SUBMIT_RESULT_TOOL_NAME}\` with a \`value\` that matches this JSON Schema:\n${JSON.stringify(schema)}`;
-			const text = messageText(from, true, delivery, body, visibleIds(agentId, false));
+			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 });
+				agents.accept(agentId, text, "write", { fromOwner: true, notification: false, sender: sender(from, ids) });
 				return undefined;
 			}
-			const { record, timedOut } = await agents.request(agentId, text, delivery, schema, timeout === undefined ? undefined : timeout * 1000);
+			const { record, timedOut } = await agents.request(agentId, text, delivery, sender(from, ids), schema, timeout === undefined ? undefined : timeout * 1000);
 			if (record.state === "completed") return schema === undefined ? record.result : record.value;
 			if (record.state === "failed") throw new Error(`Agent ${label(agent, agents.ids())} failed: ${record.result}`);
 			// An aborted input, timed out or not, shows as a cancelled call.

package/src/programs/tool.ts

@@ -203,7 +203,7 @@ export function registerProgramTools(
 					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: { running: outcome.running.map((record) => record.id), ...(outcome.interrupted && { interrupted: true }) } };
+					return { content: rendered.content, details: { ...rendered.details, running: outcome.running.map((record) => record.id), ...(outcome.interrupted && { interrupted: true }) } };
 				}
 				case "list": {
 					rejectFields(params, "list", ["code", "background", "timeout", "target"]);