@dougbots/avenor-pi 0.15.0 → 0.16.1

package/dist/index.js

@@ -1,9 +1,9 @@
 import { Input, Key, Text, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { createHash, randomUUID } from "node:crypto";
-import { Supervisor, THINKING_LEVELS, answerPermissionTool, askTool, attachOwner, brokerReceiveTool, brokerReplyTool, cancelTool, dial, eventsTool, extractEventText, extractReplyMessage, followUpTool, formatAskFailure, inspectTool, killTool, normalizeAskTimeoutMs, observeRun, peersTool, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool } from "@dougbots/avenor-core";
+import { SUPERVISOR_RUN_ID, Supervisor, THINKING_LEVELS, answerPermissionTool, attachOwner, boundFinalOutput, brokerReceiveTool, createChildMessageProvider, createHostMessageProvider, dial, eventsTool, extractEventText, extractReplyMessage, extractTurnText, getSupervisorClient, inspectTool, installAskClaims, isClosedSocketError, isGenerationMismatchError, killTool, messageTool, normalizeAskTimeoutMs, normalizeTurnStopReason, observeRun, peersDetails, peersTool, renderPeerList, resultOutput, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, workflowCancelTool, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool } from "@dougbots/avenor-core";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { createHash } from "node:crypto";
 //#region src/subagent-broker.ts
 /** Deadline for a cleanup call whose caller's own deadline has already expired. */
 const ASK_CLEANUP_TIMEOUT_MS = 5e3;
@@ -36,25 +36,38 @@ function parseControlMessage(msg) {
 	return {
 		from_run_id: fromRunId,
 		message_id: messageId,
-		message: p.message
+		message: p.message,
+		role: typeof p.role === "string" ? p.role : void 0
 	};
 }
-function formatInboundAskBody(ask) {
-	return `**📨 Inbound ask**${ask.from_run_id ? ` from \`${ask.from_run_id}\`` : ""}\n\n${ask.message}\n\nTo answer, use avenor_reply({ reply_to_message_id: ${JSON.stringify(ask.message_id)}, message: "..." }).`;
+/**
+* Format an inbound ask as a steer body. Both modes share the formatter; only
+* the heading and the optional role metadata differ.
+*/
+function formatInboundAskBody(ask, options) {
+	const sender = ask.from_run_id;
+	const role = options.role ?? ask.role;
+	const from = sender ? role && role !== "agent" ? ` from \`${sender}\` (${role})` : ` from \`${sender}\`` : "";
+	return `**📨 ${options.heading}**${from}\n\n${ask.message}\n\nTo answer, use avenor_message({ action: "reply", reply_to: ${JSON.stringify(ask.message_id)}, message: "..." }).`;
 }
 /** A broker HTTP response error, so callers can classify by status instead of
 * matching digits in the request text. */
 var BrokerHttpError = class extends Error {
 	status;
-	constructor(path, status, body) {
+	code;
+	body;
+	constructor(path, status, body, code = "") {
 		super(`broker ${path}: ${status} ${body}`);
 		this.name = "BrokerHttpError";
 		this.status = status;
+		this.code = code;
+		this.body = body;
 	}
 };
 /** Build the `/send` body for one agent_message, as the broker child tools do. */
 function buildAgentMessage(fields) {
 	return {
+		...fields.generation !== void 0 ? { generation: fields.generation } : {},
 		from_run_id: fields.fromRunId,
 		to_run_id: fields.toRunId,
 		type: "agent_message",
@@ -70,6 +83,15 @@ function buildAgentMessage(fields) {
 		}
 	};
 }
+async function codedError(path, response) {
+	const body = (await response.text()).trim();
+	let code = "";
+	try {
+		const parsed = JSON.parse(body);
+		if (typeof parsed.code === "string") code = parsed.code;
+	} catch {}
+	return new BrokerHttpError(path, response.status, body, code);
+}
 async function postBroker(env, path, body, fetchImpl = fetch, signal) {
 	const res = await fetchImpl(`${env.brokerUrl}${path}`, {
 		method: "POST",
@@ -81,27 +103,45 @@ async function postBroker(env, path, body, fetchImpl = fetch, signal) {
 		}),
 		...signal ? { signal } : {}
 	});
-	if (!res.ok) throw new BrokerHttpError(path, res.status, (await res.text()).trim());
+	if (!res.ok) throw await codedError(path, res);
+	return res.json();
+}
+/** Authenticated GET; broker credentials travel in headers, never the URL. */
+async function getBroker(env, path, fetchImpl = fetch, signal) {
+	const res = await fetchImpl(`${env.brokerUrl}${path}`, {
+		method: "GET",
+		headers: {
+			"X-Avenor-Run-Id": env.runId,
+			"X-Avenor-Run-Token": env.token
+		},
+		...signal ? { signal } : {}
+	});
+	if (!res.ok) throw await codedError(path, res);
 	return res.json();
 }
+/** Read the ask generation `/sessions` advertises, or empty for none. */
+async function readGeneration(env, fetchImpl) {
+	const body = await getBroker(env, "/sessions", fetchImpl);
+	return typeof body?.generation === "string" ? body.generation : "";
+}
 /**
-* Resolve which pending ask to answer. Prefers an explicit message id (and its
-* asker); otherwise the most recent pending ask matching fromRunId.
+* Pin the generation on first use and reuse it, so one child binds to one broker
+* generation. The broker rotates it when its ask store resets; a pinned child is
+* then refused instead of being retargeted. A broker that advertises no
+* generation is not pinned, so the next call reads it again.
 */
-function resolveReplyTarget(pending, fromRunId, replyToMessageId) {
-	if (replyToMessageId) {
-		const hit = pending.get(replyToMessageId);
-		if (!hit) return null;
-		const from = fromRunId ?? hit.from_run_id;
-		if (!from) return null;
-		return {
-			from_run_id: from,
-			message_id: replyToMessageId
-		};
-	}
-	let match;
-	for (const [, entry] of pending) if (!fromRunId || entry.from_run_id === fromRunId) match = entry;
-	return match ?? null;
+function pinGeneration(env, fetchImpl) {
+	let pinned;
+	return () => {
+		pinned ??= readGeneration(env, fetchImpl).then((generation) => {
+			if (!generation) pinned = void 0;
+			return generation;
+		}, (error) => {
+			pinned = void 0;
+			throw error;
+		});
+		return pinned;
+	};
 }
 function combineSignals(...signals) {
 	const active = signals.filter((signal) => signal !== void 0);
@@ -109,32 +149,47 @@ function combineSignals(...signals) {
 	if (active.length === 1) return active[0];
 	return AbortSignal.any(active);
 }
-function describeFailure(error) {
-	if (error instanceof Error) {
-		if (error.name === "TimeoutError") return "timed out";
-		if (error.name === "AbortError") return "cancelled";
-		return error.message || error.name;
-	}
-	return String(error);
-}
 /**
 * Withdraw a pending ask through the broker as this run. The broker's own error
 * propagates so a caller reporting to a model shows its exact text.
 */
-async function withdrawPendingAsk(env, messageId, fetchImpl = fetch) {
-	await postBroker(env, "/cancel_message", { cancel_message_id: messageId }, fetchImpl, AbortSignal.timeout(ASK_CLEANUP_TIMEOUT_MS));
+async function withdrawPendingAsk(env, messageId, generation, fetchImpl = fetch) {
+	const body = await postBroker(env, "/cancel_message", {
+		cancel_message_id: messageId,
+		generation
+	}, fetchImpl, AbortSignal.timeout(ASK_CLEANUP_TIMEOUT_MS));
+	if (typeof body?.outcome === "string" && body.outcome) return { outcome: body.outcome };
+	return { outcome: "withdrawn" };
 }
 /**
 * Withdraw a pending ask and classify whether the edge may still exist on the
 * broker: true means the cleanup could not be confirmed, false means it is gone.
 */
-async function withdrawAsk(env, messageId, fetchImpl) {
+async function withdrawAsk(env, messageId, generation, fetchImpl) {
 	try {
-		await withdrawPendingAsk(env, messageId, fetchImpl);
-		return false;
+		return {
+			pending: false,
+			outcome: (await withdrawPendingAsk(env, messageId, generation, fetchImpl)).outcome
+		};
 	} catch (error) {
-		if (error instanceof BrokerHttpError) return error.status !== 404;
-		return true;
+		if (error instanceof BrokerHttpError) {
+			if (error.code === "fence-capacity") return {
+				pending: true,
+				outcome: "possibly-pending"
+			};
+			if (error.status === 404) return {
+				pending: false,
+				outcome: "edge-absent"
+			};
+			return {
+				pending: true,
+				outcome: "possibly-pending"
+			};
+		}
+		return {
+			pending: true,
+			outcome: "possibly-pending"
+		};
 	}
 }
 /** Fetch causes for a dial that never opened, so no request reached the broker. */
@@ -187,12 +242,10 @@ async function brokerReachable(env, fetchImpl) {
 	}
 }
 /**
-* Whether a failed send provably never reached the broker, mirroring the host's
-* rule: a dial that never opened or an unusable broker address carries no
-* request, and a send that drew no HTTP response while the broker no longer
-* accepts a dial cannot have left its edge in a broker that is gone. An HTTP
-* response, a reset, or an abort against a broker that answers at all may have
-* been processed and still needs a withdraw.
+* Whether a failed send provably never reached the broker: a dial that never
+* opened or an unusable broker address carries no request, and a send that drew
+* no HTTP response while the broker no longer accepts a dial cannot have left
+* its edge in a broker that is gone.
 */
 async function sendNeverReachedBroker(error, env, fetchImpl) {
 	if (error instanceof BrokerHttpError) return false;
@@ -200,21 +253,84 @@ async function sendNeverReachedBroker(error, env, fetchImpl) {
 	if (abortedBeforeResponse(error)) return false;
 	return !await brokerReachable(env, fetchImpl);
 }
+function brokerOutcome(body) {
+	const record = body !== null && typeof body === "object" ? body : {};
+	return typeof record.outcome === "string" && record.outcome ? record.outcome : "sent";
+}
 /**
-* Ask another run through the inherited broker as this run, then wait for the
-* correlated reply. A failed send, wait, timeout, or abort withdraws the ask
-* and reports its message id plus whether it is still pending, matching the
-* host-side ask tool's contract.
+* The outcome the wire contract documents for a known code, or undefined for a
+* code outside it. This mirrors the Go transport's wireErrorClasses table: a
+* code whose documented outcome is a credential or edge refusal keeps it, and
+* every other code names a request that was never admitted.
 */
-async function askViaBroker(env, args, fetchImpl = fetch) {
-	const messageId = randomUUID();
-	const role = args.role ?? "agent";
+function knownCodeOutcome(code) {
+	switch (code) {
+		case "auth-rejected":
+		case "sender-mismatch": return "auth-rejected";
+		case "not-ask-sender":
+		case "not-ask-target": return "edge-absent";
+		case "invalid-request":
+		case "generation-mismatch":
+		case "unsupported-protocol":
+		case "malformed-message-id":
+		case "message-id-expired":
+		case "message-id-horizon":
+		case "duplicate-message-id":
+		case "mutual-ask":
+		case "fence-capacity":
+		case "target-unavailable":
+		case "transport-closed":
+		case "unsupported-operation": return "not-sent";
+		default: return;
+	}
+}
+/**
+* The outcome of a response the messaging envelope does not describe, as the Go
+* local transport classifies it: only a 401 there is a credential rejection, a
+* code-less 403 is the router's not-ask-target refusal, and every other status
+* leaves transmission uncertain.
+*/
+function unenvelopedOutcome(status) {
+	if (status === 401) return "auth-rejected";
+	if (status === 403) return "edge-absent";
+	return "possibly-pending";
+}
+/**
+* Classify a broker HTTP rejection the way the Go local transport does: the
+* body's outcome wins, then a known wire code, then the status. A rejection that
+* names neither leaves transmission uncertain, so it is never reported
+* `not-sent`; only a send that provably never left the surface is.
+*/
+function brokerErrorOutcome(error) {
+	if (!(error instanceof BrokerHttpError)) return void 0;
+	try {
+		const parsed = JSON.parse(error.body);
+		if (parsed && typeof parsed.outcome === "string" && parsed.outcome) return parsed.outcome;
+	} catch {}
+	if (error.code) return knownCodeOutcome(error.code) ?? "possibly-pending";
+	return unenvelopedOutcome(error.status);
+}
+/**
+* The outcome of a generation pin that failed before any message was sent: no
+* request reached the send route, so only a credential refusal keeps its own
+* outcome and everything else is a message that was never sent.
+*/
+function pinFailureOutcome(error) {
+	return brokerErrorOutcome(error) === "auth-rejected" ? "auth-rejected" : "not-sent";
+}
+async function brokerAsk(env, args, messageId, fetchImpl, pin) {
+	const role = "agent";
 	const timeoutMs = normalizeAskTimeoutMs(args.timeoutMs);
 	const signal = combineSignals(args.signal, timeoutMs !== void 0 ? AbortSignal.timeout(timeoutMs) : void 0);
-	const fail = async (detail) => {
-		const pending = await withdrawAsk(env, messageId, fetchImpl);
-		throw new Error(formatAskFailure(messageId, pending, detail));
-	};
+	let generation;
+	try {
+		generation = await pin();
+	} catch (error) {
+		return {
+			outcome: pinFailureOutcome(error),
+			messageId
+		};
+	}
 	try {
 		await postBroker(env, "/send", buildAgentMessage({
 			fromRunId: env.runId,
@@ -222,22 +338,237 @@ async function askViaBroker(env, args, fetchImpl = fetch) {
 			messageId,
 			message: args.message,
 			role,
-			expectsReply: true
+			expectsReply: true,
+			generation
 		}), fetchImpl, signal);
 	} catch (error) {
-		if (await sendNeverReachedBroker(error, env, fetchImpl)) throw new Error(formatAskFailure(messageId, false, `send ask: ${describeFailure(error)}`));
-		return fail(`send ask: ${describeFailure(error)}`);
+		if (await sendNeverReachedBroker(error, env, fetchImpl)) return {
+			outcome: "not-sent",
+			messageId
+		};
+		const rejected = brokerErrorOutcome(error);
+		if (rejected) return {
+			outcome: rejected,
+			messageId
+		};
+		return {
+			outcome: (await withdrawAsk(env, messageId, generation, fetchImpl)).outcome,
+			messageId
+		};
 	}
 	let reply;
 	try {
-		reply = await postBroker(env, "/wait_reply", { waiting_for: messageId }, fetchImpl, signal);
+		reply = await postBroker(env, "/wait_reply", {
+			waiting_for: messageId,
+			generation
+		}, fetchImpl, signal);
 	} catch (error) {
-		return fail(`wait for reply: ${describeFailure(error)}`);
+		const timedOut = error instanceof Error && error.name === "TimeoutError" || brokerErrorOutcome(error) === "timed-out";
+		const cleaned = await withdrawAsk(env, messageId, generation, fetchImpl);
+		if (timedOut) return {
+			outcome: "timed-out",
+			messageId
+		};
+		const outcome = brokerErrorOutcome(error);
+		if (outcome) return {
+			outcome,
+			messageId
+		};
+		if (cleaned.pending) return {
+			outcome: "possibly-pending",
+			messageId
+		};
+		return {
+			outcome: cleaned.outcome,
+			messageId
+		};
 	}
-	const record = reply && typeof reply === "object" ? reply : {};
+	const record = reply !== null && typeof reply === "object" ? reply : {};
+	const outcome = brokerOutcome(record);
+	const result = {
+		outcome,
+		messageId
+	};
+	if (outcome === "replied") result.reply = extractReplyMessage(record);
+	return result;
+}
+function peerRecords(body) {
+	const sessions = body !== null && typeof body === "object" ? body.sessions ?? [] : [];
+	if (!Array.isArray(sessions)) return [];
+	return sessions.map((raw) => {
+		const session = raw !== null && typeof raw === "object" ? raw : {};
+		const record = { run_id: typeof session.run_id === "string" ? session.run_id : "" };
+		for (const key of [
+			"label",
+			"kind",
+			"status",
+			"backend",
+			"model",
+			"dir"
+		]) {
+			const value = session[key];
+			if (typeof value === "string" && value) record[key] = value;
+		}
+		return record;
+	}).filter((record) => record.run_id !== "");
+}
+function wireCode(code) {
+	switch (code) {
+		case "not-permitted": return "not_permitted";
+		case "invalid-name": return "invalid_name";
+		case "unknown-target": return "unknown_target";
+		case "ambiguous-name": return "ambiguous_name";
+		default: return;
+	}
+}
+/** A broker refusal as the router's typed tool error. */
+function brokerToolError(error) {
+	if (error instanceof BrokerHttpError) {
+		const code = wireCode(error.code) ?? (error.status === 403 ? "not_permitted" : error.status === 404 ? "unknown_target" : error.status === 409 ? "ambiguous_name" : "refused");
+		const text = (() => {
+			try {
+				const parsed = JSON.parse(error.body);
+				if (typeof parsed.error === "string") return parsed.error;
+			} catch {}
+			return error.body || error.message;
+		})();
+		const typed = new Error(text);
+		typed.name = "ToolError";
+		typed.code = code;
+		typed.facts = {};
+		return typed;
+	}
+	return error instanceof Error ? error : new Error(String(error));
+}
+/**
+* The inherited-broker implementation of the core ChildBroker contract. Every
+* request authenticates as this run; a transport failure keeps its own text and
+* becomes a refusal at the router boundary.
+*/
+function createBrokerChildBroker(env, fetchImpl = fetch) {
+	const pin = pinGeneration(env, fetchImpl);
 	return {
-		reply: extractReplyMessage(record),
-		from_run_id: record.from_run_id ?? ""
+		async tell(targetRunId, message, messageId) {
+			let generation;
+			try {
+				generation = await pin();
+			} catch (error) {
+				return {
+					outcome: pinFailureOutcome(error),
+					messageId
+				};
+			}
+			let body;
+			try {
+				body = await postBroker(env, "/send", buildAgentMessage({
+					fromRunId: env.runId,
+					toRunId: targetRunId,
+					messageId,
+					message,
+					role: "agent",
+					generation
+				}), fetchImpl);
+			} catch (error) {
+				return {
+					outcome: brokerErrorOutcome(error) ?? (await sendNeverReachedBroker(error, env, fetchImpl) ? "not-sent" : "possibly-pending"),
+					messageId
+				};
+			}
+			return {
+				outcome: brokerOutcome(body),
+				messageId: typeof body?.message_id === "string" && body.message_id ? body.message_id : messageId
+			};
+		},
+		ask(targetRunId, message, messageId, timeoutMs, signal) {
+			return brokerAsk(env, {
+				toRunId: targetRunId,
+				message,
+				timeoutMs,
+				signal
+			}, messageId, fetchImpl, pin);
+		},
+		async reply(askerRunId, inboundAskId, message) {
+			let body;
+			try {
+				body = await postBroker(env, "/send", buildAgentMessage({
+					fromRunId: env.runId,
+					toRunId: askerRunId,
+					messageId: `${inboundAskId}.reply`,
+					message,
+					role: "agent",
+					replyTo: inboundAskId
+				}), fetchImpl);
+			} catch (error) {
+				return {
+					outcome: brokerErrorOutcome(error) ?? (await sendNeverReachedBroker(error, env, fetchImpl) ? "not-sent" : "possibly-pending"),
+					messageId: inboundAskId
+				};
+			}
+			return {
+				outcome: brokerOutcome(body),
+				messageId: inboundAskId
+			};
+		},
+		async withdraw(messageId) {
+			let generation;
+			try {
+				generation = await pin();
+			} catch (error) {
+				throw brokerToolError(error);
+			}
+			try {
+				return { outcome: brokerOutcome(await postBroker(env, "/cancel_message", {
+					cancel_message_id: messageId,
+					generation
+				}, fetchImpl)) };
+			} catch (error) {
+				if (error instanceof BrokerHttpError) {
+					if (error.code === "fence-capacity") return { outcome: "possibly-pending" };
+					if (error.status === 404) {
+						try {
+							const parsed = JSON.parse(error.body);
+							if (typeof parsed.outcome === "string" && parsed.outcome) return { outcome: parsed.outcome };
+						} catch {}
+						return { outcome: "edge-absent" };
+					}
+				}
+				throw brokerToolError(error);
+			}
+		},
+		async peers() {
+			return { peers: peerRecords(await getBroker(env, "/sessions", fetchImpl)) };
+		},
+		async rename(req) {
+			try {
+				const body = await postBroker(env, "/rename", {
+					session_id: req.sessionId ?? "",
+					name: req.name
+				}, fetchImpl);
+				return {
+					outcome: "renamed",
+					runId: typeof body?.run_id === "string" ? body.run_id : "",
+					label: typeof body?.label === "string" ? body.label : "",
+					previousLabel: typeof body?.previous_label === "string" ? body.previous_label : ""
+				};
+			} catch (error) {
+				throw brokerToolError(error);
+			}
+		},
+		async last(runId) {
+			try {
+				const body = await getBroker(env, `/last_message?target=${encodeURIComponent(runId)}`, fetchImpl);
+				return {
+					outcome: "sent",
+					label: typeof body?.label === "string" ? body.label : void 0,
+					hasRecord: body?.has_record === true,
+					finalOutput: typeof body?.final_output === "string" ? body.final_output : "",
+					stopReason: typeof body?.stop_reason === "string" ? body.stop_reason : void 0,
+					truncated: body?.final_output_truncated === true
+				};
+			} catch (error) {
+				throw brokerToolError(error);
+			}
+		}
 	};
 }
 //#endregion
@@ -569,7 +900,7 @@ var RunInspectorOverlay = class {
 		}
 		if (!isFollowUpable(this.state.status, this.state.snapshot)) return;
 		this.runAction(async () => {
-			const next = await this.deps.followUpRun(this.state.run, text);
+			const next = await this.deps.resumeRun(this.state.run, text);
 			this.state = {
 				...this.state,
 				run: {
@@ -1173,7 +1504,7 @@ function guidance(status, pending, runId) {
 		const options = permissionOptions(pending);
 		if (options.length > 0) return `Guidance: Call avenor_answer_permission with run_id "${runId}" and option_id "${selected(options[0], "option_id")}".`;
 		if (pending) return `Guidance: Permission input is required, but no options are available; call avenor_inspect with run_id "${runId}".`;
-		return `Guidance: Call avenor_follow_up or avenor_status with run_id "${runId}".`;
+		return `Guidance: Call avenor_message with action "resume" or avenor_status with run_id "${runId}".`;
 	}
 	if (isTerminal(status)) return `Guidance: Call avenor_result or avenor_events with run_id "${runId}".`;
 	return `Guidance: Call avenor_result with run_id "${runId}".`;
@@ -1269,18 +1600,33 @@ function permissionLines(details, args) {
 		`Guidance: Call avenor_status with run_id "${runId}" to verify the permission state.`
 	];
 }
-function followUpLines(details, args) {
+function messageLines(details, args) {
 	const result = asRecord(details);
-	if (!result || !stringValue(result.run_id) || !stringValue(result.label)) return void 0;
-	const runId = selected(result, "run_id", args.run_id);
-	const label = selected(result, "label", args.label, runId);
-	return [
-		`Follow-up: ${label} — dispatched.`,
-		`Source run: ${scalar(args.run_id)}`,
-		`Run: ${runId}`,
-		`Label: ${label}`,
-		`Guidance: Call avenor_status with run_id "${runId}".`
-	];
+	if (!result) return void 0;
+	const action = selectedOptional(result, "action") ?? stringValue(args.action) ?? "tell";
+	if (action === "resume") {
+		const runId = selected(result, "run_id", args.target);
+		const label = selected(result, "label", args.label, runId);
+		if (!stringValue(runId) || !stringValue(label)) return void 0;
+		return [
+			`Resume: ${label} — dispatched.`,
+			`Source run: ${scalar(args.target)}`,
+			`Run: ${runId}`,
+			`Label: ${label}`,
+			`Guidance: Call avenor_status with run_id "${runId}".`
+		];
+	}
+	const outcome = selectedOptional(result, "outcome") ?? "done";
+	const lines = [`${action.charAt(0).toUpperCase() + action.slice(1)}: ${outcome}.`];
+	const text = selectedOptional(result, "text");
+	if (text) lines.push(scalar(text));
+	const messageId = selectedOptional(result, "message_id") ?? stringValue(args.reply_to) ?? stringValue(args.message_id);
+	if (messageId) lines.push(`Message: ${scalar(messageId)}`);
+	const reply = selectedOptional(result, "reply");
+	if (action === "ask" && reply) lines.push(`Reply: ${scalar(reply)}`);
+	const target = selectedOptional(result, "label") ?? (action === "reply" ? void 0 : stringValue(args.target));
+	if (target) lines.push(`Target: ${scalar(target)}`);
+	return lines;
 }
 function eventSequence(value) {
 	if (typeof value === "number" && Number.isFinite(value)) return String(value);
@@ -1502,12 +1848,21 @@ function renderAnswerPermissionCall(args, theme) {
 	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
 	return linesText([pieces.join(" ")], theme);
 }
-function renderFollowUpCall(args, theme) {
-	const pieces = [`avenor_follow_up run_id ${quoted(args.run_id)}`, `message ${quoted(args.message)}`];
-	const label = optionalQuoted(args.label);
-	const supervisor = optionalQuoted(args.supervisor_id);
-	if (label) pieces.push(`label ${label}`);
-	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+function renderMessageResumeCall(args, theme) {
+	const action = stringValue(args.action) || "tell";
+	const pieces = [`avenor_message action ${quoted(action)}`];
+	if (action === "reply") pieces.push(`reply_to ${quoted(args.reply_to)}`, `message ${quoted(args.message)}`);
+	else if (action === "withdraw") pieces.push(`message_id ${quoted(args.message_id)}`);
+	else if (action === "control_reply") {
+		pieces.push(`target ${quoted(args.target)}`);
+		if (args.payload !== void 0) pieces.push(`payload ${quoted(JSON.stringify(args.payload))}`);
+	} else {
+		pieces.push(`target ${quoted(args.target)}`, `message ${quoted(args.message)}`);
+		if (action === "resume") {
+			const label = optionalQuoted(args.label);
+			if (label) pieces.push(`label ${label}`);
+		}
+	}
 	return linesText([pieces.join(" ")], theme);
 }
 function renderEventsCall(args, theme) {
@@ -1541,8 +1896,8 @@ function renderInspectResult(result, options, theme, args) {
 function renderAnswerPermissionResult(result, options, theme, args) {
 	return render("answer_permission", result, options, theme, () => permissionLines(result.details, args));
 }
-function renderFollowUpResult(result, options, theme, args) {
-	return render("follow_up", result, options, theme, () => followUpLines(result.details, args));
+function renderMessageResumeResult(result, options, theme, args) {
+	return render("message", result, options, theme, () => messageLines(result.details, args));
 }
 function renderEventsResult(result, options, theme, args) {
 	return render("events", result, options, theme, () => eventsLines(result.details, args, options.expanded));
@@ -1577,11 +1932,10 @@ const defaultDeps = {
 	statusTool,
 	eventsTool,
 	answerPermissionTool,
-	followUpTool,
+	messageTool,
 	inspectTool,
 	resultTool,
 	brokerReceiveTool,
-	brokerReplyTool,
 	shutdownTool,
 	killTool,
 	workflowStatusTool,
@@ -1592,6 +1946,8 @@ const defaultDeps = {
 	workflowGateTool,
 	workflowControllerStatusTool,
 	workflowReadyTool,
+	workflowCancelTool,
+	getSupervisorClient,
 	observeRun,
 	dial,
 	attachOwner,
@@ -1633,7 +1989,7 @@ function buildCompletionText(run, result, finalOutput) {
 	if (output) lines.push("", "Final output:", ...quotedLines(output));
 	if (result.stop_reason && result.stop_reason.toUpperCase() !== result.status.toUpperCase()) lines.push(`Stop reason: ${result.stop_reason}`);
 	if (result.session_id) lines.push(`Session: \`${result.session_id}\``);
-	lines.push("", `Call \`avenor_inspect\` with \`run_id: "${run.runId}"\` for the bounded transcript/snapshot, or \`avenor_follow_up\` to iterate.`);
+	lines.push("", `Call \`avenor_inspect\` with \`run_id: "${run.runId}"\` for the bounded transcript/snapshot, or \`avenor_message\` with \`action: "resume"\` to iterate.`);
 	return lines.join("\n");
 }
 function buildWaitingText(run, status) {
@@ -1642,7 +1998,7 @@ function buildWaitingText(run, status) {
 	const lines = [`Sub-agent "${run.label}" (${agent}) is waiting for input.`];
 	if (perm) lines.push(`Permission request: ${perm.description}`, `To answer: call \`avenor_answer_permission\` with run_id "${run.runId}", option_id "allow_once" | "allow_always" | "deny"`);
 	else if (status.phase_label) lines.push(`Question: ${status.phase_label}`);
-	if (!perm) lines.push(`Use \`avenor_follow_up\` with run_id "${run.runId}" to respond, or \`avenor_inspect\` to review context first.`);
+	if (!perm) lines.push(`Use \`avenor_message\` with \`action: "resume"\` and target "${run.runId}" to respond, or \`avenor_inspect\` to review context first.`);
 	return lines.join("\n");
 }
 function isTerminalStatus(status) {
@@ -1745,7 +2101,18 @@ function createExtension(deps = defaultDeps, options = {}) {
 		let pollingErrorCount = 0;
 		const pollingErrors = [];
 		let lastStatusEntries = [];
+		let lastTurnSocketClosed = false;
 		const pendingWaits = /* @__PURE__ */ new Set();
+		/** The agent-facing prose clause for a stopping point. A synthetic status
+		* such as `asking` has no run-status spelling, so it must not appear raw in
+		* this prose. Structured payloads still carry the raw status (the
+		* avenor_result JSON reports it as `interrupted_by.status`) so consumers can
+		* check it. */
+		function describeStoppingPoint(stop) {
+			if (stop.status === "waiting") return "reached a permission request";
+			if (stop.status === "asking") return "asked a question for you";
+			return `reached ${stop.status}`;
+		}
 		function interruptPendingWaits(stop, excludeRunKey) {
 			for (const wait of [...pendingWaits]) {
 				if (wait.runKey === excludeRunKey) continue;
@@ -1761,6 +2128,29 @@ function createExtension(deps = defaultDeps, options = {}) {
 			pendingWaits.add(wait);
 			return wait;
 		}
+		/** An inbound ask is a stopping point: the asker cannot finish until it is
+		* answered, so every blocking wait returns, the asker's own wait included. */
+		function interruptWaitsForAsk(ask) {
+			interruptPendingWaits({
+				runId: ask.from_run_id,
+				status: "asking"
+			});
+		}
+		/** Surface one inbound ask: hand the body to the session, remember it so a
+		* reply can reach the asker, then let every blocking wait return. Delivery
+		* comes first so a throw leaves the waits waiting on an ask the agent never
+		* saw, rather than reporting an ask it cannot answer. */
+		function surfaceInboundAsk(pending, ask, heading) {
+			pi.sendUserMessage(formatInboundAskBody(ask, {
+				heading,
+				role: ask.role
+			}), { deliverAs: "steer" });
+			pending.set(ask.message_id, {
+				from_run_id: ask.from_run_id,
+				message_id: ask.message_id
+			});
+			interruptWaitsForAsk(ask);
+		}
 		function createInterruptibleWait(runKey, signal) {
 			const controller = new AbortController();
 			let stopped;
@@ -1854,11 +2244,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 					for (const msg of msgs) {
 						const ask = parseControlMessage(msg);
 						if (!ask) continue;
-						subAgentPendingAsks.set(ask.message_id, {
-							from_run_id: ask.from_run_id,
-							message_id: ask.message_id
-						});
-						pi.sendUserMessage(formatInboundAskBody(ask), { deliverAs: "steer" });
+						surfaceInboundAsk(subAgentPendingAsks, ask, "Inbound ask");
 					}
 				} catch (error) {
 					consecutiveFailures++;
@@ -1873,6 +2259,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 		}
 		let hostPollTimer = null;
 		let hostPollGeneration = 0;
+		let hostReceiveGeneration;
 		const hostPendingAsks = /* @__PURE__ */ new Map();
 		function stopHostAskPoll() {
 			hostPollGeneration++;
@@ -1886,20 +2273,27 @@ function createExtension(deps = defaultDeps, options = {}) {
 			const generation = hostPollGeneration;
 			const intervalMs = options.pollIntervalMs ?? 2e3;
 			const tick = async () => {
+				const startedAt = Date.now();
 				try {
-					const { asks } = await deps.brokerReceiveTool({});
-					if (generation !== hostPollGeneration) return;
-					for (const ask of asks) {
-						hostPendingAsks.set(ask.message_id, {
-							from_run_id: ask.from_run_id,
-							message_id: ask.message_id
-						});
-						const body = `**📨 Ask from sub-agent** (\`${ask.role && ask.role !== "agent" ? `${ask.from_run_id} (${ask.role})` : ask.from_run_id}\`)\n\n${ask.message}\n\nTo answer, use the intercom tool: avenor_reply({ from_run_id: ${JSON.stringify(ask.from_run_id)}, reply_to_message_id: ${JSON.stringify(ask.message_id)}, message: "..." })`;
-						pi.sendUserMessage(body, { deliverAs: "steer" });
+					const receive = () => hostReceiveGeneration ? deps.brokerReceiveTool({
+						generation: hostReceiveGeneration,
+						timeout_ms: intervalMs
+					}) : deps.brokerReceiveTool({ timeout_ms: intervalMs });
+					let received;
+					try {
+						received = await receive();
+					} catch (error) {
+						if (!hostReceiveGeneration || !isGenerationMismatchError(error)) throw error;
+						hostReceiveGeneration = void 0;
+						disposeHostProviders();
+						received = await receive();
 					}
+					if (generation !== hostPollGeneration) return;
+					if (received.generation) hostReceiveGeneration = received.generation;
+					for (const ask of received.asks) surfaceInboundAsk(hostPendingAsks, ask, "Ask from sub-agent");
 				} catch {}
 				if (generation !== hostPollGeneration) return;
-				hostPollTimer = setTimeout(() => void tick(), intervalMs);
+				hostPollTimer = setTimeout(() => void tick(), Math.max(0, intervalMs - (Date.now() - startedAt)));
 				hostPollTimer.unref?.();
 			};
 			hostPollTimer = setTimeout(() => void tick(), intervalMs);
@@ -2227,44 +2621,22 @@ function createExtension(deps = defaultDeps, options = {}) {
 						await client.interruptAndPrompt(runtimeId, text);
 					});
 				},
-				followUpRun(run, text) {
-					return deps.followUpTool({
-						runId: run.runId,
-						message: text,
-						supervisorId: run.supervisorId
-					});
+				resumeRun(run, text) {
+					return resumeTrackedRun(run, text);
 				}
 			};
 		}
-		async function followUpTrackedRun(run, text) {
-			const result = await deps.followUpTool({
-				runId: run.runId,
-				message: text,
-				supervisorId: run.supervisorId
-			});
-			try {
-				const status = asStatusResult(await deps.statusTool({
-					runId: result.run_id,
-					supervisorId: run.supervisorId
-				}));
-				upsertTrackedRun({
-					runId: result.run_id,
-					label: result.label,
-					agent: status?.agent ?? run.agent,
-					runtimeId: status?.runtime_id,
-					supervisorId: run.supervisorId
-				}, status, false);
-				startPolling();
-			} catch {
-				upsertTrackedRun({
-					runId: result.run_id,
-					label: result.label,
-					agent: run.agent,
-					supervisorId: run.supervisorId
-				}, void 0, false);
-				startPolling();
-			}
-			return result;
+		async function resumeTrackedRun(run, text) {
+			const provider = await hostMessageProvider(run.supervisorId);
+			const result = await deps.messageTool({
+				action: "resume",
+				target: run.runId,
+				message: text
+			}, provider);
+			return {
+				run_id: result.runId ?? run.runId,
+				label: result.label ?? run.runId
+			};
 		}
 		async function waitForRunWithObserver(run, signal, onUpdate) {
 			let observer = null;
@@ -2372,9 +2744,110 @@ function createExtension(deps = defaultDeps, options = {}) {
 			if (observed.status || observed.aborted) return observed;
 			return waitForRunByPolling(run, signal, onUpdate);
 		}
+		const hostProviders = /* @__PURE__ */ new Map();
+		const hostAskClaims = /* @__PURE__ */ new Map();
+		function disposeHostProvider(supervisorId) {
+			const key = supervisorId ?? "";
+			const binding = hostProviders.get(key);
+			hostProviders.delete(key);
+			hostAskClaims.delete(key);
+			if (key === "") lastTurnSocketClosed = false;
+			if (!binding || binding.isSingleton || !binding.client) return;
+			try {
+				binding.client.close();
+			} catch {}
+		}
+		function disposeHostProviders() {
+			for (const key of [...hostProviders.keys()]) disposeHostProvider(key);
+			hostAskClaims.clear();
+			lastTurnSocketClosed = false;
+		}
+		async function defaultHostProviderFor(supervisorId) {
+			const key = supervisorId ?? "";
+			const existing = hostProviders.get(key);
+			if (existing) return existing.provider;
+			const { client, isSingleton } = await (deps.getSupervisorClient ?? getSupervisorClient)(supervisorId, { owner: true });
+			const preflight = await client.messagePreflight();
+			const provider = createHostMessageProvider({
+				surface: "pi-host",
+				supervisorId: supervisorId ?? Supervisor.currentInstance()?.supervisorId ?? "",
+				generation: preflight.generation,
+				client,
+				onResumed: (result) => trackResumed(supervisorId, result)
+			});
+			hostProviders.set(key, {
+				provider,
+				client,
+				isSingleton
+			});
+			return provider;
+		}
+		async function trackResumed(supervisorId, result) {
+			const run = {
+				runId: result.runId ?? "",
+				label: result.label ?? result.runId ?? "",
+				supervisorId
+			};
+			try {
+				const status = asStatusResult(await deps.statusTool({
+					runId: run.runId,
+					supervisorId
+				}));
+				upsertTrackedRun({
+					runId: run.runId,
+					label: run.label,
+					agent: status?.agent,
+					runtimeId: status?.runtime_id,
+					supervisorId
+				}, status, false);
+			} catch {
+				upsertTrackedRun(run, void 0, false);
+			}
+			startPolling();
+		}
+		const hostProviderFor = deps.hostProviderFor ?? defaultHostProviderFor;
+		const childProvider = isSubAgentBrokerMode && subAgentEnv ? createChildMessageProvider({
+			surface: "pi-child",
+			runId: subAgentEnv.runId,
+			broker: createBrokerChildBroker(subAgentEnv),
+			pendingAsks: subAgentPendingAsks,
+			pollGeneration: () => subAgentPollGeneration
+		}) : null;
+		async function hostMessageProvider(supervisorId) {
+			const provider = await hostProviderFor(supervisorId);
+			const key = supervisorId ?? "";
+			let claims = hostAskClaims.get(key);
+			if (!claims) {
+				claims = /* @__PURE__ */ new Map();
+				hostAskClaims.set(key, claims);
+			}
+			installAskClaims(provider, claims, hostPendingAsks, () => hostPollGeneration);
+			if (!provider.onResumed) provider.onResumed = (result) => trackResumed(supervisorId, result);
+			return provider;
+		}
+		async function messageProvider(supervisorId) {
+			if (childProvider) return childProvider;
+			return hostMessageProvider(supervisorId);
+		}
+		pi.on("turn_end", async (event) => {
+			if (isSubAgentBrokerMode) return;
+			if (lastTurnSocketClosed) return;
+			if (!deps.Supervisor.currentInstance?.()) return;
+			const turn = extractTurnText([event.message]);
+			try {
+				const provider = await hostProviderFor(void 0);
+				if (!provider.recordLastTurn) return;
+				const bounded = boundFinalOutput(turn.text);
+				await provider.recordLastTurn(bounded, normalizeTurnStopReason(turn.stopReason), turn.text.length > bounded.length);
+			} catch (error) {
+				if (isClosedSocketError(error)) lastTurnSocketClosed = true;
+				console.error("[avenor] session_last_set failed:", error instanceof Error ? error.message : error);
+			}
+		});
 		pi.on("session_start", async (_event, ctx) => {
 			sessionCtx = ctx;
 			lastStatusEntries = [];
+			lastTurnSocketClosed = false;
 			pollingErrorCount = 0;
 			pollingErrors.length = 0;
 			if (!isSubAgentBrokerMode) startHostAskPoll();
@@ -2383,6 +2856,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 		pi.on("session_shutdown", async () => {
 			stopHostAskPoll();
 			stopSubAgentPoll();
+			disposeHostProviders();
 			hostPendingAsks.clear();
 			subAgentPendingAsks.clear();
 			await stopPolling();
@@ -2422,15 +2896,15 @@ function createExtension(deps = defaultDeps, options = {}) {
 		pi.registerTool({
 			name: "avenor_spawn",
 			label: "Avenor Spawn",
-			description: `Dispatch an agent run via avenor. Optional thinking accepts ${[...THINKING_LEVELS].slice(0, -1).join(", ")}, or ${THINKING_LEVELS[THINKING_LEVELS.length - 1]}; unsupported backends reject explicit values. Blocks by default, showing live progress. Set wait=false for fire-and-forget. With several blocking spawns in parallel, the first stopping point (permission or completion) interrupts the other waits.`,
+			description: `Dispatch an agent run via avenor. Optional thinking accepts ${[...THINKING_LEVELS].slice(0, -1).join(", ")}, or ${THINKING_LEVELS[THINKING_LEVELS.length - 1]}; unsupported backends reject explicit values. Blocks by default, showing live progress. Set wait=false for fire-and-forget. With several blocking spawns in parallel, the first stopping point (a permission request, an inbound ask, or completion) interrupts the other waits.`,
 			promptSnippet: "Dispatch sub-agent runs via avenor (spawn, status, result, inspect, events, follow-up, shutdown)",
 			promptGuidelines: [
 				"Use avenor_spawn to delegate well-defined tasks to sub-agents.",
 				"Use avenor_status (view \"lifecycle\") only to check progress or pending permissions.",
-				"Use avenor_result to retrieve the final result of a sub-agent; it waits by default, but set wait=false for runs that already completed. When awaiting multiple runs, the first stopping point (permission or completion) interrupts the other waits.",
+				"Use avenor_result to retrieve the final result of a sub-agent; it waits by default, but set wait=false for runs that already completed. When awaiting multiple runs, the first stopping point (a permission request, an inbound ask, or completion) interrupts the other waits.",
 				"Use avenor_inspect to review a bounded transcript and tool activity from a run.",
 				"Use avenor_events only when you specifically need raw event payloads.",
-				"Use avenor_follow_up to iterate on a completed run.",
+				"Use avenor_message with action \"resume\" to iterate on a completed run.",
 				"Use avenor_shutdown when done delegating work.",
 				"When roster_entry is set, the roster selects agent, model, and backend; do not pass those fields alongside it.",
 				"If a roster spawn fails validation or resolution, do not retry the roster: respawn without roster_file/roster_entry. Direct selectors (agent, model, backend) are optional; omission uses runtime defaults."
@@ -2482,6 +2956,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 					...params,
 					backend
 				};
+				const parentRunId = isSubAgentBrokerMode ? void 0 : !params.supervisor_id || Boolean(deps.Supervisor.isCurrentInstance?.(params.supervisor_id)) ? SUPERVISOR_RUN_ID : void 0;
 				const result = await deps.spawnTool({
 					...params.agent !== void 0 ? { agent: params.agent } : {},
 					...params.prompt !== void 0 ? { prompt: params.prompt } : {},
@@ -2496,7 +2971,8 @@ function createExtension(deps = defaultDeps, options = {}) {
 					...params.roster_entry !== void 0 ? { rosterEntry: params.roster_entry } : {},
 					...agentProfile !== void 0 ? { agentProfile } : {},
 					...params.server_url !== void 0 ? { serverUrl: params.server_url } : {},
-					...params.supervisor_id !== void 0 ? { supervisorId: params.supervisor_id } : {}
+					...params.supervisor_id !== void 0 ? { supervisorId: params.supervisor_id } : {},
+					...parentRunId !== void 0 ? { parent_run_id: parentRunId } : {}
 				});
 				const supervisorId = statusSupervisorId(params.supervisor_id, result.supervisor_id);
 				const runRef = {
@@ -2551,7 +3027,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 							return {
 								content: [{
 									type: "text",
-									text: `Monitoring of "${label}" (run_id: ${result.run_id}) was interrupted: "${stop.label ?? stop.runId}" reached ${stop.status === "waiting" ? "a permission request" : stop.status}. Handle that first; this run's final result is delivered automatically.`
+									text: `Monitoring of "${label}" (run_id: ${result.run_id}) was interrupted: "${stop.label ?? stop.runId}" ${describeStoppingPoint(stop)}. Handle that first; this run's final result is delivered automatically.`
 								}],
 								details: {
 									run_id: result.run_id,
@@ -2717,7 +3193,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 		pi.registerTool({
 			name: "avenor_result",
 			label: "Avenor Result",
-			description: `Retrieve the complete final output of a run without transcript or event details. Waits by default; set wait=false to retrieve an already-completed run without blocking. When several runs are pending, the first stopping point (a permission request or completion on any run) interrupts other blocking waits so they can be handled; re-issue the interrupted wait afterwards.`,
+			description: `Retrieve the complete final output of a run without transcript or event details. Waits by default; set wait=false to retrieve an already-completed run without blocking. When several runs are pending, the first stopping point (a permission request, an inbound ask, or completion on any run) interrupts other blocking waits so they can be handled; re-issue the interrupted wait afterwards.`,
 			parameters: Type.Object({
 				run_id: Type.String({ description: "Run ID or label" }),
 				wait: Type.Optional(Type.Boolean({ description: "Wait for a terminal result (default true); false retrieves the current state without blocking" })),
@@ -2852,205 +3328,94 @@ function createExtension(deps = defaultDeps, options = {}) {
 			}
 		});
 		pi.registerTool({
-			name: "avenor_follow_up",
-			label: "Avenor Follow Up",
-			description: "Resume a completed run with a follow-up message.",
+			name: "avenor_message",
+			label: "Avenor Message",
+			description: "Send a message to another agent run, answer an inbound ask, withdraw a pending ask, or resume a completed run. Every action is explicit and the result states whether a failed ask can still be withdrawn. `control_reply` is available only on the claude-channel surface.",
 			parameters: Type.Object({
-				run_id: Type.String({ description: "Completed run ID to resume" }),
-				message: Type.String({ description: "Follow-up message text" }),
-				label: Type.Optional(Type.String({ description: "Override label (defaults to <original>-followup)" })),
-				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
+				action: Type.Union([
+					Type.Literal("tell"),
+					Type.Literal("ask"),
+					Type.Literal("reply"),
+					Type.Literal("resume"),
+					Type.Literal("withdraw"),
+					Type.Literal("control_reply")
+				], { description: "tell | ask | reply | resume | withdraw | control_reply" }),
+				target: Type.Optional(Type.String({ description: "Recipient for tell/ask/resume (a run id, a peer label, or \"self\"), or the opaque control message id for control_reply" })),
+				message: Type.Optional(Type.String({ description: "Message text for tell/ask/reply/resume" })),
+				reply_to: Type.Optional(Type.String({ description: "Inbound ask id being answered (reply)" })),
+				message_id: Type.Optional(Type.String({ description: "Ask id being withdrawn (withdraw)" })),
+				timeout_ms: Type.Optional(Type.Integer({ description: "Bound on the ask wait in milliseconds" })),
+				label: Type.Optional(Type.String({ description: "Override label for the resumed run (resume)" })),
+				idempotency_key: Type.Optional(Type.String({ description: "Forwarded verbatim to the resume authority (resume)" })),
+				payload: Type.Optional(Type.Unknown({ description: "Control reply body (control_reply)" }))
 			}),
-			async execute(_toolCallId, params) {
-				const result = await deps.followUpTool({
-					runId: params.run_id,
-					message: params.message,
-					label: params.label,
-					supervisorId: params.supervisor_id
-				});
-				try {
-					const status = asStatusResult(await deps.statusTool({
-						runId: result.run_id,
-						supervisorId: params.supervisor_id
-					}));
-					upsertTrackedRun({
-						runId: result.run_id,
-						label: result.label,
-						agent: status?.agent,
-						runtimeId: status?.runtime_id,
-						supervisorId: params.supervisor_id
-					}, status, false);
-				} catch {
-					upsertTrackedRun({
-						runId: result.run_id,
-						label: result.label,
-						supervisorId: params.supervisor_id
-					}, void 0, false);
-				}
-				startPolling();
+			async execute(_toolCallId, params, signal) {
+				const provider = await messageProvider(void 0);
+				const result = await deps.messageTool(params, provider, { signal });
 				return {
 					content: [{
 						type: "text",
-						text: JSON.stringify(result, null, 2)
+						text: result.text ?? ""
 					}],
-					details: result
+					details: resultOutput(result)
 				};
 			},
-			renderCall(args, theme, context) {
-				return renderFollowUpCall(context.args, theme);
+			renderCall(args, theme) {
+				return renderMessageResumeCall(args, theme);
 			},
 			renderResult(result, { expanded, isPartial }, theme, context) {
-				return renderFollowUpResult(result, {
+				return renderMessageResumeResult(result, {
 					expanded,
 					isPartial
 				}, theme, context.args);
 			}
 		});
 		pi.registerTool({
-			name: "avenor_ask",
-			label: "Avenor Ask",
-			description: "Ask another agent run a question and block until it replies. An optional timeout_ms bounds the wait; a failed ask reports its message_id and whether it is still pending (withdrawable via avenor_cancel) or already withdrawn.",
+			name: "avenor_peers",
+			label: "Avenor Peers",
+			description: "List the visible agent sessions, rename a run, or read a run's last agent message. `last` returns the target's final text with its stop reason, or an empty result when the target has no completed turn yet.",
 			parameters: Type.Object({
-				to_run_id: Type.String({ description: "Target run ID" }),
-				message: Type.String({ description: "Question to ask the other agent" }),
-				timeout_ms: Type.Optional(Type.Integer({ description: "Optional timeout in milliseconds for the ask" })),
-				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path (ignored in a Pi sub-agent, which asks through its inherited broker)" }))
+				action: Type.Optional(Type.Union([
+					Type.Literal("list"),
+					Type.Literal("rename"),
+					Type.Literal("last")
+				], { description: "list (the default) | rename | last" })),
+				name: Type.Optional(Type.String({ description: "New display name (rename)" })),
+				session_id: Type.Optional(Type.String({ description: "Run to rename; omitted renames the caller (rename)" })),
+				target: Type.Optional(Type.String({ description: "Peer to read: a run id, a label, or \"self\" (last)" }))
 			}),
-			async execute(_toolCallId, params, signal) {
-				const result = isSubAgentBrokerMode && subAgentEnv ? await askViaBroker(subAgentEnv, {
-					toRunId: params.to_run_id,
-					message: params.message,
-					timeoutMs: params.timeout_ms,
-					signal
-				}) : await askTool({
-					toRunId: params.to_run_id,
-					message: params.message,
-					timeoutMs: params.timeout_ms,
-					supervisorId: params.supervisor_id
-				});
+			async execute(_toolCallId, params) {
+				const result = await peersTool(params, await messageProvider(void 0));
 				return {
 					content: [{
 						type: "text",
-						text: `Reply from ${result.from_run_id || params.to_run_id}:\n${result.reply}`
+						text: result.action === "list" ? [result.text, renderPeerList(result.peers)].filter((part) => part !== "").join("\n\n") : result.text
 					}],
-					details: result
+					details: peersDetails(result)
 				};
 			}
 		});
 		pi.registerTool({
-			name: "avenor_reply",
-			label: "Avenor Reply (host)",
-			description: "Reply to an inbound ask received from a sub-agent. Answer the most recent ask from a given sub-agent, or reply to a specific message_id from avenor_ask.",
+			name: "avenor_workflow_cancel",
+			label: "Avenor Workflow Cancel",
+			description: "Cancel a workflow instance. The actor and reason are required.",
 			parameters: Type.Object({
-				from_run_id: Type.Optional(Type.String({ description: "Sub-agent run id to reply to (the asker)" })),
-				reply_to_message_id: Type.Optional(Type.String({ description: "The ask's broker message id to answer specifically" })),
-				message: Type.String({ description: "Your answer" }),
-				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
+				workflow_id: Type.String({ description: "Workflow ID" }),
+				actor: Type.String({ description: "Who is cancelling" }),
+				reason: Type.String({ description: "Why the workflow is being cancelled" }),
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor ID for multi-supervisor mode" }))
 			}),
 			async execute(_toolCallId, params) {
-				if (isSubAgentBrokerMode && subAgentEnv) {
-					const target = resolveReplyTarget(subAgentPendingAsks, params.from_run_id, params.reply_to_message_id);
-					if (!target) return {
-						content: [{
-							type: "text",
-							text: "No pending ask found to reply to. Pass from_run_id and/or reply_to_message_id."
-						}],
-						details: { error: true }
-					};
-					const generation = subAgentPollGeneration;
-					subAgentPendingAsks.delete(target.message_id);
-					try {
-						await postBroker(subAgentEnv, "/send", buildAgentMessage({
-							fromRunId: subAgentEnv.runId,
-							toRunId: target.from_run_id,
-							messageId: randomUUID(),
-							message: params.message,
-							role: "agent",
-							replyTo: target.message_id
-						}));
-					} catch (error) {
-						if (generation === subAgentPollGeneration) subAgentPendingAsks.set(target.message_id, target);
-						throw error;
-					}
-					return { content: [{
-						type: "text",
-						text: "Reply sent"
-					}] };
-				}
-				const target = resolveReplyTarget(hostPendingAsks, params.from_run_id, params.reply_to_message_id);
-				if (!target) return {
-					content: [{
-						type: "text",
-						text: "No pending ask found to reply to. Pass from_run_id and/or reply_to_message_id."
-					}],
-					details: { error: true }
-				};
-				const generation = hostPollGeneration;
-				hostPendingAsks.delete(target.message_id);
-				try {
-					await deps.brokerReplyTool({
-						toRunId: target.from_run_id,
-						replyTo: target.message_id,
-						message: params.message,
-						supervisorId: params.supervisor_id
-					});
-				} catch (error) {
-					if (generation === hostPollGeneration) hostPendingAsks.set(target.message_id, target);
-					throw error;
-				}
-				return { content: [{
-					type: "text",
-					text: "Reply sent"
-				}] };
-			}
-		});
-		pi.registerTool({
-			name: "avenor_peers",
-			label: "Avenor Peers",
-			description: "List all connected agent sessions with their status and metadata.",
-			parameters: Type.Object({}),
-			async execute() {
-				const result = await peersTool({});
-				if (result.peers.length === 0) return { content: [{
-					type: "text",
-					text: "No other agent sessions connected."
-				}] };
-				return { content: [{
-					type: "text",
-					text: `**Active sessions:**\n${result.peers.map((p) => {
-						const parts = [p.label ? `${p.label} (${p.run_id})` : p.run_id];
-						const tags = [
-							p.status,
-							p.backend,
-							p.model
-						].filter(Boolean);
-						if (tags.length) parts.push(`[${tags.join(", ")}]`);
-						return `  ${parts.join(" ")}`;
-					}).join("\n")}`
-				}] };
-			}
-		});
-		pi.registerTool({
-			name: "avenor_cancel",
-			label: "Avenor Cancel",
-			description: "Cancel a pending ask by its message ID.",
-			parameters: Type.Object({ message_id: Type.String({ description: "Message ID of the pending ask to cancel" }) }),
-			async execute(_toolCallId, params) {
-				if (isSubAgentBrokerMode && subAgentEnv) {
-					await withdrawPendingAsk(subAgentEnv, params.message_id);
-					return {
-						content: [{
-							type: "text",
-							text: `Cancelled ${params.message_id}`
-						}],
-						details: { cancelled: true }
-					};
-				}
-				const result = await cancelTool({ messageId: params.message_id });
+				const result = await deps.workflowCancelTool({
+					workflow_id: params.workflow_id,
+					actor: params.actor,
+					reason: params.reason,
+					supervisor_id: params.supervisor_id
+				});
 				return {
 					content: [{
 						type: "text",
-						text: `Cancelled ${params.message_id}`
+						text: JSON.stringify(result, null, 2)
 					}],
 					details: result
 				};
@@ -3118,6 +3483,8 @@ function createExtension(deps = defaultDeps, options = {}) {
 					supervisorId: params.supervisor_id,
 					force: params.force
 				});
+				disposeHostProvider(params.supervisor_id);
+				if (targetIsSingleton && target !== void 0) disposeHostProvider(void 0);
 				return {
 					content: [{
 						type: "text",
@@ -3410,7 +3777,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 					initialRunId: args?.trim() || void 0,
 					deps: {
 						...createWatchDeps(),
-						followUpRun: (run, text) => followUpTrackedRun(run, text)
+						resumeRun: (run, text) => resumeTrackedRun(run, text)
 					},
 					onTrackRun: (run, status) => {
 						upsertTrackedRun(run, status, false);