@tshu-w/pi-agents 0.1.1 → 0.2.1

package/src/agents/agents.ts

@@ -18,12 +18,15 @@ import { fileURLToPath } from "node:url";
 import {
 	customMessage,
 	deliver,
+	addProgramSpend,
+	addSpend,
 	label,
 	messageText,
 	MESSAGE_TYPE,
 	nodes,
 	resolveTarget,
 	scheduler,
+	sender,
 	shortId,
 	TREE_ENTRY,
 	trackTreeWork,
@@ -31,15 +34,18 @@ import {
 	visibleIds,
 	type AgentState,
 	type Delivery,
+	type Sender,
 	type Entry,
+	type Spend,
 	type TreeMetadata,
 } from "./registry.ts";
+import { defaultSessionDir } from "../roots/paths.mjs";
 
 const AGENT_ENTRY = "pi-agents-agent";
 const SHUTDOWN_TIMEOUT_MS = 10_000;
 const EXTENSION_PATH = fileURLToPath(new URL("../index.ts", import.meta.url));
 export const SUBMIT_RESULT_TOOL_NAME = "submit_result";
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 
 export type Outcome = "completed" | "failed" | "aborted";
 type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
@@ -72,16 +78,11 @@ export interface AgentRecord {
 }
 
 
-function defaultSessionDirectory(cwd: string, agentDir: string): string {
-	const safePath = `--${path.resolve(cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-	return path.join(path.resolve(agentDir), "sessions", safePath);
-}
-
 function childSessionDirectory(cwd: string, currentCwd: string, currentSessionDir: string, agentDir: string): string {
-	const targetDefault = defaultSessionDirectory(cwd, agentDir);
+	const targetDefault = defaultSessionDir(cwd, agentDir);
 	if (!currentSessionDir) return path.join(targetDefault, "subagents");
 	const current = path.resolve(currentSessionDir);
-	const currentDefault = defaultSessionDirectory(currentCwd, agentDir);
+	const currentDefault = defaultSessionDir(currentCwd, agentDir);
 	if (current === currentDefault ||
 		(path.basename(current) === "subagents" && path.dirname(current) === currentDefault)) {
 		return path.join(targetDefault, "subagents");
@@ -121,8 +122,8 @@ function lastAnswer(session: AgentSession, before: number): { outcome: Outcome;
 	return { outcome: "completed", result: text };
 }
 
-/** Takes this extension's messages left in the agent queues after a run settles. */
-function takeQueued(agent: AgentSession["agent"]) {
+/** Takes this extension's messages out of the agent queues. */
+export function takeQueued(agent: AgentSession["agent"]) {
 	// peekQueuedMessages returns one message in one-at-a-time mode; read the queues whole.
 	const queues = agent as unknown as Record<"steeringQueue" | "followUpQueue", { messages: QueuedMessage[] }>;
 	const steering = queues.steeringQueue.messages.slice();
@@ -135,6 +136,19 @@ function takeQueued(agent: AgentSession["agent"]) {
 	return [...steering, ...followUps].filter(ours);
 }
 
+/** Whether a steer, which this turn must take in before its next model call, waits in the agent's queue; a write does not count. */
+export function steerQueued(agent: AgentSession["agent"] | undefined): boolean {
+	if (!agent) return false;
+	const queue = (agent as unknown as { steeringQueue: { messages: QueuedMessage[] } }).steeringQueue.messages;
+	return queue.some((message) => !(message.role === "custom" && message.customType === MESSAGE_TYPE
+		&& (message as { details?: { delivery?: string } }).details?.delivery === "write"));
+}
+
+// Pi does not report steers queued by extensions, so a wait checks the queue this often.
+export const STEER_POLL_MS = 250;
+
+export const WAIT_INTERRUPTED = "Stopped waiting for a new message. Wait again to keep waiting.";
+
 export interface Deferred {
 	promise: Promise<void>;
 	resolve(): void;
@@ -187,8 +201,10 @@ function ended(input: InputRecord): boolean {
 
 interface Input {
 	text: string;
-	/** The user's input from the Agent viewer. */
+	/** The user's input from the task viewer. */
 	user?: boolean;
+	/** The Agent that sent it. */
+	sender?: Sender;
 	record?: InputRecord;
 	permit?: symbol;
 	schema?: unknown;
@@ -198,7 +214,7 @@ interface Input {
 	silent?: boolean;
 }
 
-type Message = Pick<Input, "text" | "user">;
+type Message = Pick<Input, "text" | "user" | "sender">;
 
 interface Turn {
 	inputs: Input[];
@@ -208,6 +224,10 @@ interface Turn {
 	started: boolean;
 	/** Whether the turn holds a scheduler slot. */
 	slot: boolean;
+	/** When the turn got its slot, in milliseconds. */
+	since?: number;
+	/** What the turn's replies have cost. */
+	spent: Spend;
 	finished: boolean;
 	done: Deferred;
 }
@@ -226,6 +246,8 @@ interface Owned {
 	loading?: Promise<AgentSession>;
 	prepared?: Prepared;
 	waiters: number;
+	/** Its turn was stopped: messages from other Agents become writes until its owner's or user's next input. */
+	stopped?: boolean;
 }
 
 export interface SpawnRequest {
@@ -246,6 +268,8 @@ export interface WaitResult {
 export interface WaitOutcome {
 	results: WaitResult[];
 	pending: AgentRecord[];
+	/** A steer ended the wait. */
+	interrupted?: boolean;
 }
 
 /** The Agents owned by one loaded Agent. */
@@ -287,11 +311,11 @@ export class Agents {
 		return [...this.agents.values()].some((agent) => agent.turn !== undefined || agent.queue.length > 0);
 	}
 
-	/** An owned Agent's state, and its inputs pending behind its current or next turn. */
-	counts(id: string): { state: AgentState; pending: number } | undefined {
+	/** An owned Agent's state, its inputs pending behind its current or next turn, when its turn got a slot, and what the turn has cost. */
+	counts(id: string): { state: AgentState; pending: number; since?: number; spent?: Spend } | undefined {
 		const agent = this.agents.get(id);
 		if (!agent) return undefined;
-		return { state: this.state(agent), pending: agent.queue.length };
+		return { state: this.state(agent), pending: agent.queue.length, since: agent.turn?.since, spent: agent.turn?.spent };
 	}
 
 	private state(agent: Owned): AgentState {
@@ -362,8 +386,9 @@ export class Agents {
 			scheduler.releaseOutstanding(this.self.rootId, permit);
 			throw error;
 		}
-		const text = messageText({ id: this.self.id, name: this.self.name() }, true, "followUp", request.message, this.ids());
-		const queued = this.enqueue(agent, { text, permit, record: this.newRecord(agent) });
+		const self = { id: this.self.id, name: this.self.name() };
+		const text = messageText(self, true, "followUp", request.message, this.ids());
+		const queued = this.enqueue(agent, { text, sender: sender(self, this.ids()), permit, record: this.newRecord(agent) });
 		return { record: agent.record, queued };
 	}
 
@@ -391,16 +416,27 @@ export class Agents {
 	}
 
 	/**
-	 * Sends an input from the owner and resolves when it ends. With a schema, the Agent must call
+	 * Sends an input from the owner, `from` as its text names it, and resolves when it ends. With a schema, the Agent must call
 	 * `submit_result` with a matching value, which becomes the input's `value`; `text` tells it so.
+	 * An input not ended within `timeoutMs` is aborted alone, and `timedOut` is set.
 	 */
-	async request(id: string, text: string, delivery: "followUp" | "steer", schema?: unknown): Promise<InputRecord> {
+	async request(id: string, text: string, delivery: "followUp" | "steer", from: Sender, schema?: unknown, timeoutMs?: number): Promise<{ record: InputRecord; timedOut: boolean }> {
 		const agent = this.agent(id);
-		const input: Input = { text, permit: this.reserve(), record: this.newRecord(agent), done: deferred() };
+		const input: Input = { text, sender: from, permit: this.reserve(), record: this.newRecord(agent), done: deferred() };
 		if (schema !== undefined) input.schema = schema;
 		this.add(agent, input, delivery);
-		await input.done!.promise;
-		return input.record!;
+		let stopping: Promise<void> | undefined;
+		const timer = timeoutMs === undefined ? undefined : setTimeout(() => {
+			stopping = this.cancel(agent, input);
+			stopping.catch(() => {});
+		}, timeoutMs);
+		try {
+			await input.done!.promise;
+		} finally {
+			clearTimeout(timer);
+		}
+		await stopping;
+		return { record: input.record!, timedOut: stopping !== undefined && input.record!.state === "aborted" };
 	}
 
 	/** Records a value from `submit_result` for the Agent's current input with a schema. */
@@ -414,19 +450,20 @@ export class Agents {
 		input.submitted = { value: args.value };
 	}
 
-	accept(id: string, text: string, delivery: Delivery, options: { fromOwner: boolean; notification: boolean }): { queued: boolean } {
+	accept(id: string, text: string, delivery: Delivery, options: { fromOwner: boolean; notification: boolean; sender?: Sender }): { queued: boolean } {
 		const agent = this.agent(id);
+		if (agent.stopped && !options.fromOwner) delivery = "write";
 		if (delivery === "write") {
-			this.write(agent, text);
+			this.write(agent, text, options.sender);
 			return { queued: false };
 		}
 		// Notifications keep their owner informed even at the input limit.
 		const permit = options.notification ? undefined : this.reserve();
-		const input: Input = { text, permit, record: options.fromOwner && !options.notification ? this.newRecord(agent) : undefined };
+		const input: Input = { text, sender: options.sender, permit, record: options.fromOwner && !options.notification ? this.newRecord(agent) : undefined };
 		return { queued: this.add(agent, input, delivery) };
 	}
 
-	async wait(targets: Owned[] | undefined, history: number, timeoutSeconds: number, signal?: AbortSignal): Promise<WaitOutcome> {
+	async wait(targets: Owned[] | undefined, history: number, timeoutSeconds: number, signal?: AbortSignal, steered?: () => boolean): Promise<WaitOutcome> {
 		const selected = targets ?? [...this.agents.values()].filter((agent) =>
 			this.pending(agent) || agent.record.inputs.some((input) => ended(input) && !input.read));
 		const unique = [...new Set(selected)];
@@ -438,13 +475,18 @@ export class Agents {
 		const suspended = blocking && this.self.ownerId !== undefined && scheduler.suspend(this.self.rootId, this.self.id);
 		if (blocking) this.markWaiting(1);
 		let returned = false;
+		let interrupted = false;
 		try {
 			const deadline = Date.now() + timeoutSeconds * 1000;
 			while (unique.some((agent) => this.pending(agent))) {
 				const remaining = deadline - Date.now();
 				if (remaining <= 0) break;
+				if (steered?.()) {
+					interrupted = true;
+					break;
+				}
 				signal?.throwIfAborted();
-				await waitForChange(this.change.promise, remaining, signal);
+				await waitForChange(this.change.promise, steered ? Math.min(remaining, STEER_POLL_MS) : remaining, signal);
 			}
 			signal?.throwIfAborted();
 			const results: WaitResult[] = [];
@@ -455,7 +497,7 @@ export class Agents {
 				}
 			}
 			returned = true;
-			return { results, pending: unique.filter((agent) => this.pending(agent)).map((agent) => agent.record) };
+			return { results, pending: unique.filter((agent) => this.pending(agent)).map((agent) => agent.record), ...(interrupted && { interrupted }) };
 		} finally {
 			if (blocking) this.markWaiting(-1);
 			if (suspended) await scheduler.resume(this.self.rootId, this.self.id, this.limits.maxConcurrent, signal);
@@ -494,22 +536,38 @@ export class Agents {
 		if (silent) for (const input of [...agent.queue, ...(turn?.inputs ?? [])]) input.silent = true;
 		for (const input of agent.queue.splice(0)) this.end(agent, input, "aborted", "");
 		this.changed();
-		if (turn) {
-			turn.abort.abort();
-			const stopping = (async () => {
-				if (turn.started && agent.session) {
-					agent.session.abortCompaction();
-					agent.session.abortRetry();
-					await agent.session.abort();
-				}
-				await turn.done.promise;
-			})();
-			if (!await settlesBy(stopping, deadline)) {
-				this.finish(agent, turn, { outcome: "aborted", result: "" });
-				throw new Error(`Agent ${label(agent.record, this.ids())} did not stop within the timeout and may still be running.`);
+		if (turn) await this.stop(agent, turn, deadline);
+		return true;
+	}
+
+	/** Ends one input as aborted: withdraws it if queued, or else stops its turn, as `abort` does. */
+	private async cancel(agent: Owned, input: Input): Promise<void> {
+		const index = agent.queue.indexOf(input);
+		if (index !== -1) {
+			agent.queue.splice(index, 1);
+			this.end(agent, input, "aborted", "");
+			this.changed();
+		} else if (agent.turn?.inputs.includes(input)) {
+			await this.stop(agent, agent.turn, Date.now() + SHUTDOWN_TIMEOUT_MS);
+		}
+	}
+
+	/** Stops a turn; one that has not stopped by `deadline` is abandoned: its inputs end as aborted, and this throws. */
+	private async stop(agent: Owned, turn: Turn, deadline: number): Promise<void> {
+		agent.stopped = true;
+		turn.abort.abort();
+		const stopping = (async () => {
+			if (turn.started && agent.session) {
+				agent.session.abortCompaction();
+				agent.session.abortRetry();
+				await agent.session.abort();
 			}
+			await turn.done.promise;
+		})();
+		if (!await settlesBy(stopping, deadline)) {
+			this.finish(agent, turn, { outcome: "aborted", result: "" });
+			throw new Error(`Agent ${label(agent.record, this.ids())} did not stop within the timeout and may still be running.`);
 		}
-		return true;
 	}
 
 	restore(ctx: ExtensionContext): void {
@@ -539,9 +597,7 @@ export class Agents {
 		const deadline = Date.now() + SHUTDOWN_TIMEOUT_MS;
 		const agents = [...this.agents.values()];
 		const aborted = await Promise.allSettled(agents.map((agent) => this.abort(agent, { deadline })));
-		const closed = await Promise.allSettled(agents.map(async (agent) => {
-			const session = agent.session ?? await agent.loading?.catch(() => undefined);
-			if (!session) return;
+		const close = async (agent: Owned, session: AgentSession) => {
 			try {
 				if (!await settlesBy(session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" }), deadline)) {
 					throw new Error(`Agent ${label(agent.record, this.ids())} did not shut down within the timeout and may still be running.`);
@@ -550,13 +606,23 @@ export class Agents {
 				session.dispose();
 				agent.session = undefined;
 			}
+		};
+		const closed = await Promise.allSettled(agents.map(async (agent) => {
+			const loading = agent.loading;
+			if (!agent.session && loading && !await settlesBy(loading, deadline)) {
+				// A Session that loads after the timeout is closed once it does.
+				void loading.then((late) => close(agent, late).catch(() => {}), () => {});
+				throw new Error(`Agent ${label(agent.record, this.ids())} did not shut down within the timeout and may still be running.`);
+			}
+			const session = agent.session ?? await loading?.catch(() => undefined);
+			if (session) await close(agent, session);
 		}));
 		const errors = [...aborted, ...closed].flatMap((result) => result.status === "rejected" ? [result.reason] : []);
 		if (errors.length > 0) throw new Error(errors.map((error) => error instanceof Error ? error.message : String(error)).join("\n"));
 	}
 
-	private write(agent: Owned, text: string): void {
-		const message = customMessage(text, "write");
+	private write(agent: Owned, text: string, from?: Sender): void {
+		const message = customMessage(text, "write", { sender: from });
 		const session = agent.session;
 		if (session?.isStreaming) {
 			session.agent.steer({ role: "custom", ...message, timestamp: Date.now() });
@@ -584,6 +650,8 @@ export class Agents {
 
 	/** A steer joins the current turn; other inputs queue. Returns whether the input waits for a slot. */
 	private add(agent: Owned, input: Input, delivery: "followUp" | "steer"): boolean {
+		// While stopped, other senders' messages become writes, so this is the owner's or user's next input.
+		agent.stopped = false;
 		if (delivery !== "steer" || !agent.turn) return this.enqueue(agent, input);
 		this.join(agent, agent.turn, input);
 		return false;
@@ -596,9 +664,9 @@ export class Agents {
 		this.changed();
 		if (!turn.started) return;
 		if (agent.session?.isStreaming) {
-			agent.session.agent.steer({ role: "custom", ...customMessage(input.text, "steer", undefined, input.user), timestamp: Date.now() });
+			agent.session.agent.steer({ role: "custom", ...customMessage(input.text, "steer", { user: input.user, sender: input.sender }), timestamp: Date.now() });
 		} else {
-			turn.pending.push({ text: input.text, user: input.user });
+			turn.pending.push({ text: input.text, user: input.user, sender: input.sender });
 		}
 	}
 
@@ -606,7 +674,7 @@ export class Agents {
 		if (agent.turn || this.closing) return;
 		const head = agent.queue.shift();
 		if (!head) return;
-		const turn: Turn = { inputs: [head], pending: [], abort: new AbortController(), started: false, slot: false, finished: false, done: deferred() };
+		const turn: Turn = { inputs: [head], pending: [], abort: new AbortController(), started: false, slot: false, spent: { cost: 0, tokens: 0, unpriced: false }, finished: false, done: deferred() };
 		agent.turn = turn;
 		void this.runTurn(agent, turn);
 	}
@@ -616,6 +684,7 @@ export class Agents {
 		try {
 			await scheduler.acquireQueued(this.self.rootId, agent.record.id, this.limits.maxConcurrent, turn.abort.signal);
 			turn.slot = true;
+			turn.since = Date.now();
 			const session = await this.load(agent);
 			turn.abort.signal.throwIfAborted();
 			const before = session.getSessionStats().assistantMessages;
@@ -623,11 +692,11 @@ export class Agents {
 			for (const input of turn.inputs) if (input.record) input.record.state = "running";
 			this.persist(agent);
 			this.changed();
-			let batch: Message[] = turn.inputs.map(({ text, user }) => ({ text, user }));
+			let batch: Message[] = turn.inputs.map(({ text, user, sender }) => ({ text, user, sender }));
 			while (batch.length > 0 && !turn.abort.signal.aborted) {
-				for (const { text, user } of batch.slice(0, -1)) await session.sendCustomMessage(customMessage(text, "steer", undefined, user), { triggerTurn: false });
-				const last = batch.at(-1)!;
-				await session.sendCustomMessage(customMessage(last.text, "steer", undefined, last.user), { triggerTurn: true });
+				for (const { text, ...rest } of batch.slice(0, -1)) await session.sendCustomMessage(customMessage(text, "steer", rest), { triggerTurn: false });
+				const { text, ...rest } = batch.at(-1)!;
+				await session.sendCustomMessage(customMessage(text, "steer", rest), { triggerTurn: true });
 				await session.waitForIdle();
 				const leftover = takeQueued(session.agent);
 				for (const message of leftover) {
@@ -635,7 +704,7 @@ export class Agents {
 				}
 				batch = [
 					...turn.pending.splice(0),
-					...leftover.flatMap(({ content, details }) => details.delivery === "write" ? [] : [{ text: content, user: details.user }]),
+					...leftover.flatMap(({ content, details }) => details.delivery === "write" ? [] : [{ text: content, user: details.user, sender: details.sender }]),
 				];
 			}
 			const last = lastAnswer(session, before);
@@ -877,6 +946,11 @@ export class Agents {
 			finally { session.dispose(); }
 			throw error;
 		}
+		session.subscribe((event) => {
+			if (event.type !== "message_end" || event.message.role !== "assistant") return;
+			if (agent.turn) addSpend(agent.turn.spent, event.message.usage);
+			addProgramSpend(this.self.id, event.message.usage);
+		});
 		return session;
 	}
 }

package/src/agents/registry.ts

@@ -1,4 +1,5 @@
 /** The Agents loaded in this process, shared across trees: who sees whom, how targets resolve, and how messages are addressed. */
+import type { Usage } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Agents } from "./agents.ts";
 import { TreeScheduler } from "./scheduler.ts";
@@ -16,19 +17,23 @@ export interface AgentNode {
 	/** The node whose tree this node sees: its root, or the Program its Agents belong to. */
 	scopeId: string;
 	ownerId?: string;
-	/** A Program that owns Agents; no Agent sees it, but the user sees it in the task panel and the Agent viewer. */
+	/** A Program that owns Agents; no Agent sees it, but the user sees it in the task panel and the task viewer. */
 	program?: boolean;
 	/** Whether a Program runs in the background. */
 	background?: boolean;
 	/** When a Program started. */
 	createdAt?: string;
+	/** What the replies of a Program's Agents and the Agents under them have cost since it started. */
+	spent?: Spend;
 	name(): string | undefined;
 	cwd(): string;
 	busy(): boolean;
 	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;
 }
 
 export interface Entry {
@@ -86,6 +91,26 @@ export function trackTreeWork(rootId: string): () => void {
 	};
 }
 
+/** What replies cost: dollars, input and output tokens, and whether a reply had no price. */
+export interface Spend {
+	cost: number;
+	tokens: number;
+	unpriced: boolean;
+}
+
+export function addSpend(spend: Spend, usage: Usage): void {
+	spend.cost += usage.cost.total;
+	spend.tokens += usage.input + usage.output;
+	if (usage.cost.total === 0 && usage.input + usage.output + usage.cacheRead + usage.cacheWrite > 0) spend.unpriced = true;
+}
+
+/** Adds a reply of an Agent owned by `ownerId` to the Programs above it. */
+export function addProgramSpend(ownerId: string, usage: Usage): void {
+	for (let node = shared.nodes.get(ownerId); node; node = node.ownerId === undefined ? undefined : shared.nodes.get(node.ownerId)) {
+		if (node.spent) addSpend(node.spent, usage);
+	}
+}
+
 /** The Programs a node runs, oldest first. */
 export function programsOf(node: AgentNode): AgentNode[] {
 	return [...shared.nodes.values()]
@@ -169,7 +194,9 @@ export function treeMetadata(ctx: ExtensionContext): TreeMetadata | undefined {
 export function treeEntries(scopeId: string): Entry[] {
 	const root = shared.nodes.get(scopeId);
 	if (!root) return [];
-	const entries: Entry[] = root.program ? [] : [{
+	// A Program's Agent heads its own scope; it stays owned, so messages to it go through its owner.
+	const owned = root.ownerId === undefined ? undefined : shared.nodes.get(root.ownerId)?.agents.owned().find((agent) => agent.id === root.id);
+	const entries: Entry[] = root.program ? [] : [owned ? { ...owned, ownerId: root.ownerId } : {
 		id: root.id,
 		name: root.name(),
 		cwd: root.cwd(),
@@ -215,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 Agent 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/search.ts

@@ -4,6 +4,8 @@ import { entryLine, MESSAGE_TAG, MESSAGE_TYPE, type Entry } from "./registry.ts"
 interface SearchText {
 	time: number;
 	text: string;
+	/** A user message or an input, not a summary, write, or notification. */
+	request?: boolean;
 }
 
 /** Parsed texts by Session file, reused while the file is unchanged. */
@@ -32,9 +34,10 @@ function sessionTexts(sessionFile: string | undefined): SearchText[] {
 			const text = typeof content === "string"
 				? content
 				: Array.isArray(content) ? content.flatMap((part: any) => part?.type === "text" ? [part.text] : []).join("\n") : "";
-			if (text) texts.push({ time, text });
+			if (text) texts.push({ time, text, request: true });
 		} else if (entry.type === "custom_message" && entry.customType === MESSAGE_TYPE && typeof entry.content === "string") {
-			texts.push({ time, text: entry.content });
+			const request = entry.details?.delivery !== "write" && (entry.content.startsWith(`<${MESSAGE_TAG} `) || entry.details?.user === true);
+			texts.push({ time, text: entry.content, request });
 		}
 	}
 	cache.set(sessionFile, { stamp, texts });
@@ -85,9 +88,23 @@ export function searchEntries(entries: Entry[], query: string | undefined): List
 	return items.sort((left, right) => right.time - left.time).map(({ time: _time, ...item }) => item);
 }
 
+/** An entry with its latest matching excerpt, else its latest request, and its time. */
 export function listLine(item: ListItem, ids: Iterable<string>): string {
 	const line = entryLine(item.entry, ids);
-	return item.match ? `${line}\n  ${formatTime(item.match.time)}  ${item.match.excerpt}` : line;
+	const detail = item.match ?? latestRequest(item.entry.sessionFile);
+	return detail ? `${line}\n  ${formatTime(detail.time)}  ${detail.excerpt}` : line;
+}
+
+function latestRequest(sessionFile: string | undefined): { time: number; excerpt: string } | undefined {
+	const text = sessionTexts(sessionFile).findLast((text) => text.request);
+	if (!text) return undefined;
+	const flat = messageBody(text.text).replace(/\s+/g, " ").trim();
+	return { time: text.time, excerpt: flat.length > 120 ? `${flat.slice(0, 120)}…` : flat };
+}
+
+/** A message's body without its `agent-message` element. */
+function messageBody(content: string): string {
+	return content.startsWith(`<${MESSAGE_TAG} `) ? content.slice(content.indexOf("\n") + 1, content.lastIndexOf("\n")) : content;
 }
 
 /**
@@ -103,7 +120,7 @@ export function latestActivity(sessionFile: string | undefined): string | undefi
 		let entry: Record<string, any>;
 		try { entry = JSON.parse(line); } catch { continue; }
 		if (input === undefined && entry.type === "custom_message" && entry.customType === MESSAGE_TYPE && typeof entry.content === "string") {
-			input = entry.content.startsWith(`<${MESSAGE_TAG} `) ? entry.content.slice(entry.content.indexOf("\n") + 1, entry.content.lastIndexOf("\n")) : entry.content;
+			input = messageBody(entry.content);
 		}
 		if (input !== undefined && entry.type === "message" && entry.message?.role === "assistant" && Array.isArray(entry.message.content)) {
 			activity = replyActivity(entry.message.content) ?? activity;