@dougbots/avenor-pi 0.14.0 → 0.16.0

package/dist/index.js

@@ -1,10 +1,12 @@
 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, brokerReceiveTool, brokerReplyTool, cancelTool, dial, eventsTool, extractEventText, followUpTool, inspectTool, killTool, observeRun, peersTool, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool } from "@dougbots/avenor-core";
+import { Supervisor, THINKING_LEVELS, answerPermissionTool, attachOwner, boundFinalOutput, brokerReceiveTool, createChildMessageProvider, createHostMessageProvider, dial, eventsTool, extractEventText, extractReplyMessage, extractTurnText, getSupervisorClient, inspectTool, installAskClaims, 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;
 function readSubAgentEnv(env = process.env) {
 	const brokerUrl = env.AVENOR_BROKER_URL ?? "";
 	const runId = env.AVENOR_RUN_ID ?? "";
@@ -34,43 +36,540 @@ 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;
+	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",
+		payload: {
+			id: fields.messageId,
+			from: fields.fromRunId,
+			from_run_id: fields.fromRunId,
+			to_run_id: fields.toRunId,
+			message: fields.message,
+			role: fields.role,
+			...fields.expectsReply ? { expects_reply: true } : {},
+			...fields.replyTo !== void 0 ? { reply_to: fields.replyTo } : {}
+		}
+	};
+}
+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) {
+async function postBroker(env, path, body, fetchImpl = fetch, signal) {
 	const res = await fetchImpl(`${env.brokerUrl}${path}`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({
+			...body,
 			run_id: env.runId,
-			token: env.token,
-			...body
-		})
+			token: env.token
+		}),
+		...signal ? { signal } : {}
 	});
-	if (!res.ok) throw new Error(`broker ${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 : "";
+}
+/**
+* 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 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);
+	if (active.length === 0) return void 0;
+	if (active.length === 1) return active[0];
+	return AbortSignal.any(active);
+}
 /**
-* Resolve which pending ask to answer. Prefers an explicit message id (and its
-* asker); otherwise the most recent pending ask matching fromRunId.
+* 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.
 */
-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;
+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, generation, fetchImpl) {
+	try {
+		return {
+			pending: false,
+			outcome: (await withdrawPendingAsk(env, messageId, generation, fetchImpl)).outcome
+		};
+	} catch (error) {
+		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 {
-			from_run_id: from,
-			message_id: replyToMessageId
+			pending: true,
+			outcome: "possibly-pending"
 		};
 	}
-	let match;
-	for (const [, entry] of pending) if (!fromRunId || entry.from_run_id === fromRunId) match = entry;
-	return match ?? null;
+}
+/** Fetch causes for a dial that never opened, so no request reached the broker. */
+const NEVER_REACHED_CODES = new Set([
+	"ECONNREFUSED",
+	"ConnectionRefused",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"ERR_INVALID_URL"
+]);
+/**
+* Whether a fetch failure carries only dial-level causes, so no request was
+* carried to the broker and no ask edge can exist. Undici aggregates one error
+* per dialled address, so every attempt must have failed at the dial.
+*/
+function dialNeverOpened(error, depth = 0) {
+	if (depth > 5 || error === null || error === void 0) return false;
+	const node = error;
+	if (typeof node.code === "string" && NEVER_REACHED_CODES.has(node.code)) return true;
+	if (Array.isArray(node.errors) && node.errors.length > 0) return node.errors.every((cause) => dialNeverOpened(cause, depth + 1));
+	return dialNeverOpened(node.cause, depth + 1);
+}
+/** Whether the failure came from a caller or timeout abort, not from the wire. */
+function abortedBeforeResponse(error, depth = 0) {
+	if (depth > 5 || error === null || error === void 0) return false;
+	const node = error;
+	if (node.name === "AbortError" || node.name === "TimeoutError") return true;
+	if (Array.isArray(node.errors) && node.errors.some((cause) => abortedBeforeResponse(cause, depth + 1))) return true;
+	return abortedBeforeResponse(node.cause, depth + 1);
+}
+/** Deadline for the reachability probe, short enough to precede a cleanup. */
+const BROKER_PROBE_TIMEOUT_MS = 250;
+/**
+* Whether the broker still answers HTTP at all. The endpoint is unauthenticated
+* and any response counts, so a live broker that rejects the request is still
+* reachable. Only a dial that never opened means the broker is gone: the
+* probe's own deadline, a reset, and every other transport failure are
+* inconclusive, so a slow broker that already processed the send still counts
+* as reachable and the caller withdraws rather than calling the ask gone.
+*/
+async function brokerReachable(env, fetchImpl) {
+	try {
+		await fetchImpl(`${env.brokerUrl}/health`, { signal: AbortSignal.timeout(BROKER_PROBE_TIMEOUT_MS) });
+		return true;
+	} catch (error) {
+		return !dialNeverOpened(error);
+	}
+}
+/**
+* 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;
+	if (dialNeverOpened(error)) return true;
+	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";
+}
+/**
+* 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.
+*/
+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);
+	let generation;
+	try {
+		generation = await pin();
+	} catch (error) {
+		return {
+			outcome: pinFailureOutcome(error),
+			messageId
+		};
+	}
+	try {
+		await postBroker(env, "/send", buildAgentMessage({
+			fromRunId: env.runId,
+			toRunId: args.toRunId,
+			messageId,
+			message: args.message,
+			role,
+			expectsReply: true,
+			generation
+		}), fetchImpl, signal);
+	} catch (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,
+			generation
+		}, fetchImpl, signal);
+	} catch (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 !== 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 {
+		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
 //#region src/watch.ts
@@ -401,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: {
@@ -1005,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}".`;
@@ -1101,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);
@@ -1334,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) {
@@ -1373,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));
@@ -1409,11 +1932,10 @@ const defaultDeps = {
 	statusTool,
 	eventsTool,
 	answerPermissionTool,
-	followUpTool,
+	messageTool,
 	inspectTool,
 	resultTool,
 	brokerReceiveTool,
-	brokerReplyTool,
 	shutdownTool,
 	killTool,
 	workflowStatusTool,
@@ -1424,35 +1946,13 @@ const defaultDeps = {
 	workflowGateTool,
 	workflowControllerStatusTool,
 	workflowReadyTool,
+	workflowCancelTool,
+	getSupervisorClient,
 	observeRun,
 	dial,
+	attachOwner,
 	Supervisor
 };
-let hostPollTimer = null;
-const hostPendingAsks = /* @__PURE__ */ new Map();
-function stopHostAskPoll() {
-	if (hostPollTimer) {
-		clearInterval(hostPollTimer);
-		hostPollTimer = null;
-	}
-}
-async function startHostAskPoll(ctx) {
-	stopHostAskPoll();
-	hostPollTimer = setInterval(async () => {
-		try {
-			const { asks } = await deps.brokerReceiveTool({});
-			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: "..." })`;
-				await ctx.sendUserMessage(body, { deliverAs: "steer" });
-			}
-		} catch (error) {}
-	}, 2e3);
-	hostPollTimer.unref?.();
-}
 function statusSupervisorId(requestedSupervisorId, spawnedSupervisorId) {
 	return requestedSupervisorId ? spawnedSupervisorId : void 0;
 }
@@ -1489,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) {
@@ -1498,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) {
@@ -1602,6 +2102,16 @@ function createExtension(deps = defaultDeps, options = {}) {
 		const pollingErrors = [];
 		let lastStatusEntries = [];
 		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;
@@ -1617,6 +2127,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;
@@ -1695,7 +2228,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 				subAgentPollTimer = null;
 			}
 		}
-		async function startSubAgentPoll(ctx) {
+		async function startSubAgentPoll() {
 			if (!subAgentEnv) return;
 			stopSubAgentPoll();
 			const generation = subAgentPollGeneration;
@@ -1704,16 +2237,13 @@ function createExtension(deps = defaultDeps, options = {}) {
 			const tick = async () => {
 				try {
 					const msgs = await postBroker(subAgentEnv, "/poll-control", {}) ?? [];
+					if (generation !== subAgentPollGeneration) return;
 					if (consecutiveFailures >= 3) console.error("[avenor] sub-agent broker poll recovered");
 					consecutiveFailures = 0;
 					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
-						});
-						await ctx.sendUserMessage(formatInboundAskBody(ask), { deliverAs: "steer" });
+						surfaceInboundAsk(subAgentPendingAsks, ask, "Inbound ask");
 					}
 				} catch (error) {
 					consecutiveFailures++;
@@ -1726,6 +2256,48 @@ function createExtension(deps = defaultDeps, options = {}) {
 			subAgentPollTimer = setTimeout(() => void tick(), intervalMs);
 			subAgentPollTimer.unref?.();
 		}
+		let hostPollTimer = null;
+		let hostPollGeneration = 0;
+		let hostReceiveGeneration;
+		const hostPendingAsks = /* @__PURE__ */ new Map();
+		function stopHostAskPoll() {
+			hostPollGeneration++;
+			if (hostPollTimer) {
+				clearTimeout(hostPollTimer);
+				hostPollTimer = null;
+			}
+		}
+		function startHostAskPoll() {
+			stopHostAskPoll();
+			const generation = hostPollGeneration;
+			const intervalMs = options.pollIntervalMs ?? 2e3;
+			const tick = async () => {
+				const startedAt = Date.now();
+				try {
+					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(), Math.max(0, intervalMs - (Date.now() - startedAt)));
+				hostPollTimer.unref?.();
+			};
+			hostPollTimer = setTimeout(() => void tick(), intervalMs);
+			hostPollTimer.unref?.();
+		}
 		function recordPollingError(source, message, error, runId) {
 			pollingErrorCount++;
 			const payload = createPollErrorPayload({
@@ -2010,7 +2582,7 @@ function createExtension(deps = defaultDeps, options = {}) {
 			}
 			async function withClient(run, work) {
 				if (!run.supervisorId || deps.Supervisor.isCurrentInstance(run.supervisorId)) return work((await deps.Supervisor.get()).getClient());
-				const client = await deps.dial(run.supervisorId);
+				const client = await deps.attachOwner(run.supervisorId);
 				try {
 					return await work(client);
 				} finally {
@@ -2048,44 +2620,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;
@@ -2193,20 +2743,117 @@ 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 (!binding || binding.isSingleton || !binding.client) return;
+			try {
+				binding.client.close();
+			} catch {}
+		}
+		function disposeHostProviders() {
+			for (const key of [...hostProviders.keys()]) disposeHostProvider(key);
+			hostAskClaims.clear();
+		}
+		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 (!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) {
+				console.error("[avenor] session_last_set failed:", error instanceof Error ? error.message : error);
+			}
+		});
 		pi.on("session_start", async (_event, ctx) => {
 			sessionCtx = ctx;
 			lastStatusEntries = [];
 			pollingErrorCount = 0;
 			pollingErrors.length = 0;
-			startHostAskPoll(ctx);
-			startSubAgentPoll(ctx);
+			if (!isSubAgentBrokerMode) startHostAskPoll();
+			startSubAgentPoll();
 		});
 		pi.on("session_shutdown", async () => {
-			await stopPolling();
 			stopHostAskPoll();
 			stopSubAgentPoll();
+			disposeHostProviders();
 			hostPendingAsks.clear();
 			subAgentPendingAsks.clear();
+			await stopPolling();
 			for (const wait of [...pendingWaits]) {
 				pendingWaits.delete(wait);
 				wait.interrupt({
@@ -2243,15 +2890,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."
@@ -2372,7 +3019,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,
@@ -2538,7 +3185,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" })),
@@ -2673,183 +3320,97 @@ 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" }))
+				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) {
-				return askTool({
-					toRunId: params.to_run_id,
-					message: params.message,
-					timeoutMs: params.timeout_ms,
-					supervisorId: params.supervisor_id
-				});
+				const result = await peersTool(params, await messageProvider(void 0));
+				return {
+					content: [{
+						type: "text",
+						text: result.action === "list" ? [result.text, renderPeerList(result.peers)].filter((part) => part !== "").join("\n\n") : result.text
+					}],
+					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 }
-					};
-					subAgentPendingAsks.delete(target.message_id);
-					try {
-						await postBroker(subAgentEnv, "/send", {
-							from_run_id: subAgentEnv.runId,
-							to_run_id: target.from_run_id,
-							type: "agent_message",
-							payload: {
-								id: randomUUID(),
-								from_run_id: subAgentEnv.runId,
-								to_run_id: target.from_run_id,
-								message: params.message,
-								role: "agent",
-								reply_to: target.message_id
-							}
-						});
-					} catch (error) {
-						subAgentPendingAsks.set(target.message_id, target);
-						throw error;
-					}
-					return { content: [{
-						type: "text",
-						text: "Reply sent"
-					}] };
-				}
-				let fromRunId = params.from_run_id;
-				let messageId = params.reply_to_message_id;
-				if (!messageId) {
-					let match;
-					for (const [, pending] of hostPendingAsks) if (pending.from_run_id === fromRunId && (!match || pending.message_id > match.message_id)) match = pending;
-					if (match) messageId = match.message_id;
-				}
-				if (!fromRunId || !messageId) return {
+				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: "No pending ask found to reply to. Pass from_run_id and/or reply_to_message_id."
+						text: JSON.stringify(result, null, 2)
 					}],
-					details: { error: true }
+					details: result
 				};
-				await deps.brokerReplyTool({
-					toRunId: fromRunId,
-					replyTo: messageId,
-					message: params.message,
-					supervisorId: params.supervisor_id
-				});
-				hostPendingAsks.delete(messageId);
-				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) {
-				return cancelTool({ messageId: params.message_id });
 			}
 		});
 		pi.registerTool({
@@ -2914,6 +3475,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",
@@ -3206,7 +3769,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);