@dougbots/avenor-pi 0.9.0 → 0.10.1

package/README.md

@@ -112,7 +112,7 @@ Available tools for LLM sub-agent management:
 
 | Tool | Description |
 |---|---|
-| `avenor_spawn` | Dispatch an agent run (blocking or fire-and-forget). Uses the `pi` backend by default; accepts `agent`, `model`, `prompt`, and `dir`. |
+| `avenor_spawn` | Dispatch an agent run (blocking or fire-and-forget). Uses the `pi` backend by default in direct mode; accepts optional `agent`, `model`, `prompt`, `dir`, `roster_file`, and `roster_entry`. |
 | `avenor_status` | Get status of a run or all runs; use `view="lifecycle"` for compact progress and permission checks |
 | `avenor_result` | Wait for a run and return its complete final output without transcript details |
 | `avenor_inspect` | Review a bounded transcript, tool activity, permissions, and final output |
@@ -121,17 +121,33 @@ Available tools for LLM sub-agent management:
 | `avenor_events` | Read events from a run |
 | `avenor_shutdown` | Shut down the avenor supervisor |
 
+### Direct and roster spawns
+
+Direct mode permits `agent`, `model`, and `backend` to be omitted independently, including a backend-only request; omitted values use runtime defaults. Pi supplies `backend: "pi"` for direct tool calls when no backend is given. Roster mode uses both `roster_file` and `roster_entry`, and leaves backend selection to the roster entry instead of applying Pi's direct default:
+
+```json
+{
+  "prompt": "Review the repository",
+  "roster_file": "/repo/roster.json",
+  "roster_entry": "reviewer"
+}
+```
+
+Each roster entry must contain `backend` and at least one of `agent` or `model`. Do not combine roster mode with direct `agent`, `model`, or `backend` overrides. Roster entries currently do not support `system` or `thinking`; `thinking` remains a run-level option and is validated against the effective backend. A resumed session must stay on its original backend. Use an absolute `roster_file` path when the Pi process and target project have different working directories.
+
 ### Pi-specific features
 
 Beyond the tools, the extension integrates with Pi's TUI and event system:
 
 - **Status widget** — persistent widget showing all active runs with status, phase, and permission state
-- **Footer status** — active runs shown in the Pi footer bar
+- **Footer status** — active runs and polling error counts shown in the Pi footer bar
+- **Polling diagnostics** — bounded polling errors are emitted on `avenor:poll:error` for companion extensions
 - **Live progress** — blocking `avenor_spawn` calls stream progress updates via `onUpdate`
 - **Context enrichment** — active sub-agents are automatically surfaced in the system prompt via `before_agent_start`
 - **Custom rendering** — The Pi extension renders all Avenor tool calls and results as themed, bounded summaries. Results have collapsed and expanded views.
 - **Commands** — interactive commands for run management:
   - `/avenor-status` — show status of all runs
+  - `/avenor-errors` — show and clear recent polling errors
   - `/avenor-watch <run_id>` — open a live event feed overlay
   - `/avenor-cancel <run_id>` — cancel a running sub-agent
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { InspectResult, StatusResult, Supervisor, answerPermissionTool, dial, eventsTool, followUpTool, inspectTool, observeRun, resultTool, shutdownTool, spawnTool, statusTool } from "@dougbots/avenor-core";
+import { InspectResult, StatusResult, Supervisor, answerPermissionTool, brokerReceiveTool, brokerReplyTool, dial, eventsTool, followUpTool, inspectTool, observeRun, resultTool, shutdownTool, spawnTool, statusTool, workflowCompleteTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowStatusTool, workflowWaitTool } from "@dougbots/avenor-core";
 import { EventBus, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 //#region src/types.d.ts
@@ -28,6 +28,31 @@ interface RunStatusEntry {
 declare const CHANNEL_POLL_COMPLETED: "avenor:poll:completed";
 /** Emitted when the extension observes a terminal run result. */
 declare const CHANNEL_RUN_TERMINAL: "avenor:run:terminal";
+/** Emitted when a best-effort polling operation fails. */
+declare const CHANNEL_POLL_ERROR: "avenor:poll:error";
+type PollErrorSource = 'singleton-list' | 'run-status' | 'spawn-status';
+interface PollErrorPayload {
+  /** Polling operation that failed. */
+  readonly source: PollErrorSource;
+  /** Run associated with the failure, when the operation was run-specific. */
+  readonly runId?: string;
+  /** Human-readable operation description. */
+  readonly message: string;
+  /** Bounded, sanitized error text suitable for debug consumers. */
+  readonly error: string;
+  /** Number of polling errors observed by this extension instance. */
+  readonly count: number;
+  /** Wall-clock timestamp in epoch milliseconds. */
+  readonly timestamp: number;
+}
+interface PollErrorPayloadInput {
+  readonly source: PollErrorSource;
+  readonly runId?: string;
+  readonly message: string;
+  readonly error: unknown;
+  readonly count: number;
+  readonly timestamp: number;
+}
 type AvenorRunStatus = Readonly<Omit<RunStatusEntry, 'supervisorId' | 'pid' | 'permissionDescription'> & {
   supervisorKey: string;
 }>;
@@ -65,6 +90,7 @@ interface RunTerminalPayloadInput {
 interface AvenorEventMap {
   [CHANNEL_POLL_COMPLETED]: PollCompletedPayload;
   [CHANNEL_RUN_TERMINAL]: RunTerminalPayload;
+  [CHANNEL_POLL_ERROR]: PollErrorPayload;
 }
 type AvenorEventChannel = keyof AvenorEventMap;
 type AvenorEventBus = Pick<EventBus, 'emit' | 'on'>;
@@ -80,6 +106,8 @@ declare function onAvenorEvent<K extends AvenorEventChannel>(bus: Pick<EventBus,
 declare function createPollCompletedPayload(entries: readonly RunStatusEntry[], timestamp: number, generation: number): PollCompletedPayload;
 /** Copy and freeze a terminal payload before publishing it. */
 declare function createRunTerminalPayload(payload: RunTerminalPayloadInput): RunTerminalPayload;
+/** Copy, bound, sanitize, and freeze a polling error before publishing it. */
+declare function createPollErrorPayload(payload: PollErrorPayloadInput): PollErrorPayload;
 //#endregion
 //#region src/index.d.ts
 interface ExtensionDeps {
@@ -90,12 +118,29 @@ interface ExtensionDeps {
   followUpTool: typeof followUpTool;
   inspectTool: typeof inspectTool;
   resultTool: typeof resultTool;
+  brokerReceiveTool: typeof brokerReceiveTool;
+  brokerReplyTool: typeof brokerReplyTool;
   shutdownTool: typeof shutdownTool;
+  workflowStatusTool: typeof workflowStatusTool;
+  workflowWaitTool: typeof workflowWaitTool;
+  workflowInspectTool: typeof workflowInspectTool;
+  workflowEventsTool: typeof workflowEventsTool;
+  workflowCompleteTool: typeof workflowCompleteTool;
+  workflowGateTool: typeof workflowGateTool;
   observeRun: typeof observeRun;
   dial: typeof dial;
   Supervisor: typeof Supervisor;
 }
 declare function statusSupervisorId(requestedSupervisorId: string | undefined, spawnedSupervisorId: string): string | undefined;
+type SpawnHostParams = {
+  agent?: string;
+  model?: string;
+  backend?: string;
+  roster_file?: string;
+  roster_entry?: string;
+};
+/** Project shared spawn identity into Pi tool metadata without resolving rosters here. */
+declare function spawnIdentityMetadata(params: SpawnHostParams, status?: Pick<StatusResult, 'roster_file' | 'roster_entry' | 'agent' | 'model' | 'backend' | 'effective_agent' | 'effective_model' | 'effective_backend'>): Record<string, unknown>;
 declare function buildCompletionText(run: {
   runId: string;
   label: string;
@@ -104,7 +149,11 @@ declare function isTerminalStatus(status: string | undefined): boolean;
 declare function renderStatusLines(entries: RunStatusEntry[]): string[];
 declare function compactWhitespace(text: string | undefined, limit?: number): string | undefined;
 declare function buildInspectPayload(result: InspectResult): Record<string, unknown>;
-declare function createExtension(deps?: ExtensionDeps): (pi: ExtensionAPI) => Promise<void>;
+interface ExtensionOptions {
+  /** Polling cadence; injectable so tests can drive deterministic ticks. */
+  pollIntervalMs?: number;
+}
+declare function createExtension(deps?: ExtensionDeps, options?: ExtensionOptions): (pi: ExtensionAPI) => Promise<void>;
 declare const _default: (pi: ExtensionAPI) => Promise<void>;
 //#endregion
-export { type AvenorEventBus, type AvenorEventChannel, type AvenorEventMap, type AvenorRunStatus, CHANNEL_POLL_COMPLETED, CHANNEL_RUN_TERMINAL, ExtensionDeps, type PollCompletedPayload, type RunTerminalPayload, type RunTerminalPayloadInput, buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, createPollCompletedPayload, createRunTerminalPayload, _default as default, emitAvenorEvent, isTerminalStatus, onAvenorEvent, renderStatusLines, statusSupervisorId };
+export { type AvenorEventBus, type AvenorEventChannel, type AvenorEventMap, type AvenorRunStatus, CHANNEL_POLL_COMPLETED, CHANNEL_POLL_ERROR, CHANNEL_RUN_TERMINAL, ExtensionDeps, ExtensionOptions, type PollCompletedPayload, type PollErrorPayload, type PollErrorPayloadInput, type PollErrorSource, type RunTerminalPayload, type RunTerminalPayloadInput, buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, createPollCompletedPayload, createPollErrorPayload, createRunTerminalPayload, _default as default, emitAvenorEvent, isTerminalStatus, onAvenorEvent, renderStatusLines, spawnIdentityMetadata, statusSupervisorId };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Input, Key, Text, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { Supervisor, answerPermissionTool, dial, eventsTool, extractEventText, followUpTool, inspectTool, observeRun, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool } from "@dougbots/avenor-core";
+import { Supervisor, THINKING_LEVELS, answerPermissionTool, askTool, brokerReceiveTool, brokerReplyTool, cancelTool, dial, eventsTool, extractEventText, followUpTool, inspectTool, observeRun, peersTool, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, workflowCompleteTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowStatusTool, workflowWaitTool } from "@dougbots/avenor-core";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { createHash } from "node:crypto";
@@ -475,12 +475,12 @@ var RunInspectorOverlay = class {
 function matchingWatchRuns(runs, selector) {
 	const query = selector.trim().toLowerCase();
 	if (!query) return [];
-	const byId = runs.find((run) => run.runId.toLowerCase() === query);
-	if (byId) return [byId];
+	const byId = runs.filter((run) => run.runId.toLowerCase() === query);
+	if (byId.length > 0) return byId;
 	return runs.filter((run) => run.label?.toLowerCase() === query || run.agent?.toLowerCase() === query);
 }
 function watchRunChoice(run) {
-	return `${sanitizeText(run.label ?? run.runId)}${run.agent ? ` · ${sanitizeText(run.agent)}` : ""} · ${sanitizeText(run.runId).slice(0, 8)}`;
+	return `${sanitizeText(run.label ?? run.runId)}${run.agent ? ` · ${sanitizeText(run.agent)}` : ""}${run.supervisorId ? ` · ${sanitizeText(run.supervisorId)}` : ""} · ${sanitizeText(run.runId).slice(0, 8)}`;
 }
 async function selectWatchRun(ctx, runs) {
 	const choices = runs.map(watchRunChoice);
@@ -522,7 +522,20 @@ async function openRunInspector(ctx, options) {
 }
 //#endregion
 //#region src/types.ts
-function findLiveStatusForTrackedRun(run, liveStatuses) {
+/**
+* Find a live status for a tracked run from the unqualified live-status list.
+*
+* `statusTool({})` only describes the current singleton supervisor, so it is
+* authoritative solely for runs that live in the singleton namespace. Runs on
+* another supervisor must be polled through their own supervisor; matching
+* them against this list could correlate a run with a colliding id (for
+* example a shared `rt_1`) owned by a different supervisor.
+*
+* @param singletonScope true when the tracked run belongs to the singleton
+*   supervisor (no explicit socket, or a socket equal to the current instance).
+*/
+function findLiveStatusForTrackedRun(run, liveStatuses, singletonScope) {
+	if (!singletonScope) return void 0;
 	const knownRunIds = new Set([run.runId, run.lastStatus?.run_id].filter((id) => !!id));
 	let runtimeMatch;
 	for (const status of liveStatuses) {
@@ -556,16 +569,18 @@ function formatRunLine(entry) {
 	return `${emoji} ${entry.label} (${entry.agent}) — ${entry.status}${phase}${perm}`;
 }
 /**
-* decideCompletion determines whether to skip, defer, or send the completion
+* decideCompletion determines whether to skip or send the completion
 * steering message for a tracked run that has reached terminal status.
 *
-* The deferral prevents duplication when avenor_result consumes the result
-* in the same turn: if the agent calls avenor_result between the defer and
-* the next tick, the run is deleted from tracking and the send never fires.
+* The message is delivered on the same terminal tick — never deferred to a
+* later cycle — so a run that is the last live one still gets its completion.
+* `blocking` suppresses it while avenor_result is awaiting (it will deliver
+* the result itself and set `consumed`), and `consumed` suppresses it once
+* avenor_result has already returned the result successfully.
 */
 function decideCompletion(run) {
 	if (run.blocking) return "skip";
-	if (!run.completionPending) return "defer";
+	if (run.consumed) return "skip";
 	return "send";
 }
 //#endregion
@@ -718,7 +733,15 @@ function resolveAgentProfile(entries, environment = process.env) {
 const CHANNEL_POLL_COMPLETED = "avenor:poll:completed";
 /** Emitted when the extension observes a terminal run result. */
 const CHANNEL_RUN_TERMINAL = "avenor:run:terminal";
-/** Derive a stable non-connectable scope from a local supervisor socket. */
+/** Emitted when a best-effort polling operation fails. */
+const CHANNEL_POLL_ERROR = "avenor:poll:error";
+/** Maximum sanitized error text exposed to companion extensions. */
+const POLL_ERROR_TEXT_CHARS = 600;
+function sanitizeAndBoundText(value) {
+	const text = sanitizeText(String(value)).trim();
+	if (!text) return "unknown error";
+	return text.length <= POLL_ERROR_TEXT_CHARS ? text : `${text.slice(0, POLL_ERROR_TEXT_CHARS - 1)}…`;
+}
 function createSupervisorKey(supervisorId) {
 	if (!supervisorId) return "singleton";
 	return `supervisor:${createHash("sha256").update(supervisorId).digest("hex").slice(0, 16)}`;
@@ -769,6 +792,17 @@ function createRunTerminalPayload(payload) {
 		...payload.backend !== void 0 && { backend: payload.backend }
 	});
 }
+/** Copy, bound, sanitize, and freeze a polling error before publishing it. */
+function createPollErrorPayload(payload) {
+	return Object.freeze({
+		source: payload.source,
+		...payload.runId !== void 0 && { runId: payload.runId },
+		message: sanitizeAndBoundText(payload.message),
+		error: sanitizeAndBoundText(payload.error),
+		count: payload.count,
+		timestamp: payload.timestamp
+	});
+}
 //#endregion
 //#region src/render.ts
 const FINAL_OUTPUT_CHARS = 600;
@@ -1031,9 +1065,11 @@ function eventsLines(details, args, expanded) {
 	const displayedTypes = types.slice(0, COLLECTION_ITEMS).map((type) => scalar(type)).join(", ");
 	const lines = [`Events: ${runId} — ${events.length} events`, ...types.length > 0 ? [`Filter: ${displayedTypes}${types.length > COLLECTION_ITEMS ? ` ${itemMarker(types.length - COLLECTION_ITEMS)}` : ""}`] : []];
 	if (events.length === 0) return [...lines, "No events."];
-	lines.push(`Preview: ${eventRow(events[0])}`);
-	if (events.length > 1) lines.push(itemMarker(events.length - 1));
-	if (!expanded) return lines;
+	if (!expanded) {
+		lines.push(`Preview: ${eventRow(events[0])}`);
+		if (events.length > 1) lines.push(itemMarker(events.length - 1));
+		return lines;
+	}
 	const displayed = events.slice(0, STATUS_ROWS);
 	lines.push(...displayed.map(eventRow));
 	if (events.length > displayed.length) lines.push(itemMarker(events.length - displayed.length));
@@ -1226,6 +1262,7 @@ const INSPECT_JSON_STRING_CHARS = 600;
 const INSPECT_JSON_ARRAY_ITEMS = 24;
 const INSPECT_JSON_OBJECT_KEYS = 24;
 const INSPECT_JSON_DEPTH = 8;
+const MAX_POLL_ERRORS = 100;
 const defaultDeps = {
 	spawnTool,
 	statusTool,
@@ -1234,14 +1271,60 @@ const defaultDeps = {
 	followUpTool,
 	inspectTool,
 	resultTool,
+	brokerReceiveTool,
+	brokerReplyTool,
 	shutdownTool,
+	workflowStatusTool,
+	workflowWaitTool,
+	workflowInspectTool,
+	workflowEventsTool,
+	workflowCompleteTool,
+	workflowGateTool,
 	observeRun,
 	dial,
 	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;
 }
+/** Project shared spawn identity into Pi tool metadata without resolving rosters here. */
+function spawnIdentityMetadata(params, status) {
+	const metadata = {};
+	const add = (key, value) => {
+		if (typeof value === "string" && value.length > 0) metadata[key] = value;
+	};
+	add("roster_file", status?.roster_file ?? params.roster_file);
+	add("roster_entry", status?.roster_entry ?? params.roster_entry);
+	add("effective_agent", status?.effective_agent ?? status?.agent ?? params.agent);
+	add("effective_model", status?.effective_model ?? status?.model ?? params.model);
+	add("effective_backend", status?.effective_backend ?? status?.backend ?? params.backend);
+	return metadata;
+}
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1267,7 +1350,8 @@ function buildCompletionText(run, result, finalOutput) {
 }
 function buildWaitingText(run, status) {
 	const perm = status.pending_permission;
-	const lines = [`Sub-agent "${run.label}" (${run.agent}) is waiting for input.`];
+	const agent = run.agent ?? status.effective_agent ?? status.agent ?? "roster";
+	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.`);
@@ -1351,30 +1435,51 @@ function toWatchRunRef(run) {
 		supervisorId: run.supervisorId
 	};
 }
-function createExtension(deps = defaultDeps) {
+/**
+* Namespace a run id by its supervisor so runs on different supervisors can
+* never collide or be correlated, even when they share runtime ids (e.g.
+* `rt_1`). An undefined supervisorId denotes the singleton namespace. The
+* NUL separator cannot appear in socket paths or generated run ids, so the
+* singleton and each explicit supervisor stay disjoint.
+*/
+function trackedRunKey(supervisorId, runId) {
+	return `${supervisorId ?? ""}\u0000${runId}`;
+}
+function createExtension(deps = defaultDeps, options = {}) {
 	return async function(pi) {
+		const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
 		let telemetryGeneration = 0;
 		const trackedRuns = /* @__PURE__ */ new Map();
 		let pollingActive = false;
 		let pollingGeneration = 0;
 		let pollInFlight = null;
 		let sessionCtx = null;
-		const reportedPollingFailures = /* @__PURE__ */ new Set();
-		function reportPollingFailure(key, message, error) {
-			if (reportedPollingFailures.has(key)) return;
-			reportedPollingFailures.add(key);
-			console.error(message, error);
-		}
-		function clearPollingFailure(key) {
-			reportedPollingFailures.delete(key);
+		let pollingErrorCount = 0;
+		const pollingErrors = [];
+		let lastStatusEntries = [];
+		function recordPollingError(source, message, error, runId) {
+			pollingErrorCount++;
+			const payload = createPollErrorPayload({
+				source,
+				runId,
+				message,
+				error,
+				count: pollingErrorCount,
+				timestamp: Date.now()
+			});
+			pollingErrors.push(payload);
+			if (pollingErrors.length > MAX_POLL_ERRORS) pollingErrors.shift();
+			emitAvenorEvent(pi.events, CHANNEL_POLL_ERROR, payload);
 		}
-		function clearRunPollingFailures(run) {
-			clearPollingFailure(`run-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
-			clearPollingFailure(`spawn-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
+		function clearPollingErrors() {
+			pollingErrorCount = 0;
+			pollingErrors.length = 0;
+			updateWidget(lastStatusEntries);
 		}
 		function upsertTrackedRun(run, status, blocking = false) {
-			const current = trackedRuns.get(run.runId);
-			trackedRuns.set(run.runId, {
+			const key = trackedRunKey(run.supervisorId, run.runId);
+			const current = trackedRuns.get(key);
+			trackedRuns.set(key, {
 				runId: run.runId,
 				agent: run.agent ?? status?.agent ?? current?.agent ?? "unknown",
 				label: run.label ?? status?.label ?? current?.label ?? run.runId,
@@ -1384,9 +1489,29 @@ function createExtension(deps = defaultDeps) {
 				lastStatus: status ?? current?.lastStatus,
 				blocking: current?.blocking ?? blocking,
 				permissionNotified: current?.permissionNotified,
-				completionPending: current?.completionPending
+				consumed: current?.consumed
 			});
 		}
+		/**
+		* Look a run up in the per-supervisor tracking namespace. When a
+		* supervisor is supplied, resolve exactly. Without one, prefer the
+		* singleton namespace and only fall back to a run id walk when it is
+		* unambiguous across supervisors. Duplicate run ids across supervisors
+		* without an explicit supervisor return undefined so callers never bind
+		* flags or telemetry to the wrong supervisor's run.
+		*/
+		function getTrackedRun(runId, supervisorId) {
+			if (supervisorId !== void 0) return trackedRuns.get(trackedRunKey(supervisorId, runId));
+			const singleton = trackedRuns.get(trackedRunKey(void 0, runId));
+			if (singleton) return singleton;
+			let match;
+			for (const run of trackedRuns.values()) {
+				if (run.runId !== runId) continue;
+				if (match) return void 0;
+				match = run;
+			}
+			return match;
+		}
 		async function resolveFinalOutput(run, status) {
 			const preview = finalOutputPreview(status);
 			if (preview) return preview;
@@ -1402,22 +1527,23 @@ function createExtension(deps = defaultDeps) {
 			}
 		}
 		async function pollRuns() {
+			const errorCountAtPollStart = pollingErrorCount;
 			const liveMap = /* @__PURE__ */ new Map();
 			try {
 				const allLive = await deps.statusTool({});
 				const liveList = Array.isArray(allLive) ? allLive : [allLive];
 				for (const result of liveList) liveMap.set(result.run_id, result);
-				clearPollingFailure("singleton-list");
 			} catch (err) {
-				reportPollingFailure("singleton-list", "avenor pollRuns: failed to list singleton runs", err);
+				recordPollingError("singleton-list", "failed to list singleton runs", err);
 			}
 			const entries = [];
 			for (const run of trackedRuns.values()) {
-				const live = findLiveStatusForTrackedRun(run, liveMap.values());
+				const singletonScope = !run.supervisorId || Boolean(deps.Supervisor.isCurrentInstance?.(run.supervisorId));
+				const live = singletonScope ? findLiveStatusForTrackedRun(run, liveMap.values(), singletonScope) : void 0;
 				if (live) {
 					liveMap.delete(live.run_id);
-					clearPollingFailure(`run-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
 					run.lastStatus = live;
+					run.agent = live.agent ?? run.agent;
 					entries.push({
 						runId: run.runId,
 						supervisorId: run.supervisorId,
@@ -1426,7 +1552,7 @@ function createExtension(deps = defaultDeps) {
 						status: live.status,
 						phase: live.phase,
 						phaseLabel: live.phase_label,
-						agent: run.agent,
+						agent: run.agent ?? "unknown",
 						pendingPermission: !!live.pending_permission,
 						permissionDescription: live.pending_permission?.description,
 						pid: live.pid,
@@ -1441,8 +1567,8 @@ function createExtension(deps = defaultDeps) {
 					});
 					const result = Array.isArray(raw) ? raw[0] : raw;
 					if (!result) throw new Error("status response was empty");
-					clearPollingFailure(`run-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
 					run.lastStatus = result;
+					run.agent = result.agent ?? run.agent;
 					entries.push({
 						runId: run.runId,
 						supervisorId: run.supervisorId,
@@ -1451,14 +1577,14 @@ function createExtension(deps = defaultDeps) {
 						status: result.status,
 						phase: result.phase,
 						phaseLabel: result.phase_label,
-						agent: run.agent,
+						agent: run.agent ?? "unknown",
 						pendingPermission: !!result.pending_permission,
 						permissionDescription: result.pending_permission?.description,
 						pid: result.pid,
 						backend: result.backend
 					});
 				} catch (err) {
-					reportPollingFailure(`run-status:${run.supervisorId ?? "singleton"}:${run.runId}`, `avenor pollRuns: statusTool failed for ${run.runId}`, err);
+					recordPollingError("run-status", "statusTool failed while polling a run", err, run.runId);
 					const previous = run.lastStatus;
 					entries.push({
 						runId: run.runId,
@@ -1468,7 +1594,7 @@ function createExtension(deps = defaultDeps) {
 						status: previous?.status ?? "unavailable",
 						phase: previous?.phase,
 						phaseLabel: previous?.phase_label,
-						agent: run.agent,
+						agent: run.agent ?? previous?.agent ?? "unknown",
 						pendingPermission: !!previous?.pending_permission,
 						permissionDescription: previous?.pending_permission?.description,
 						pid: previous?.pid,
@@ -1495,21 +1621,24 @@ function createExtension(deps = defaultDeps) {
 				let idx = 0;
 				for (const entry of entries) if (entry.backend === "pi" && entry.pid && !isTerminalStatus(entry.status)) entry.nestedCount = nestedCounts[idx++] ?? 0;
 			}
+			if (pollingErrorCount === errorCountAtPollStart) pollingErrorCount = 0;
 			return entries;
 		}
 		function updateWidget(entries) {
+			lastStatusEntries = entries;
 			if (!sessionCtx) return;
 			const lines = renderStatusLines(entries);
+			const errorSuffix = pollingErrorCount > 0 ? `errors:${pollingErrorCount}` : "";
 			if (lines.length > 0) {
 				sessionCtx.ui.setWidget("avenor-status", lines);
 				const statusStr = lines.map((line) => line.slice(0, 60)).join("  ");
 				const nestedTotal = entries.filter((e) => !isTerminalStatus(e.status)).reduce((sum, e) => sum + (e.nestedCount ?? 0), 0);
 				const total = lines.length + nestedTotal;
-				const statusWithTotal = nestedTotal > 0 ? `${statusStr}  total:${total}` : statusStr;
+				const statusWithTotal = [nestedTotal > 0 ? `${statusStr}  total:${total}` : statusStr, errorSuffix].filter(Boolean).join("  ");
 				sessionCtx.ui.setStatus("avenor", statusWithTotal);
 			} else {
 				sessionCtx.ui.setWidget("avenor-status", void 0);
-				sessionCtx.ui.setStatus("avenor", "");
+				sessionCtx.ui.setStatus("avenor", errorSuffix);
 			}
 		}
 		function startPolling() {
@@ -1529,18 +1658,16 @@ function createExtension(deps = defaultDeps) {
 				updateWidget(entries);
 				emitAvenorEvent(pi.events, CHANNEL_POLL_COMPLETED, createPollCompletedPayload(entries, Date.now(), ++telemetryGeneration));
 				for (const entry of entries) {
-					const run = trackedRuns.get(entry.runId);
+					const entryKey = trackedRunKey(entry.supervisorId, entry.runId);
+					const run = trackedRuns.get(entryKey);
 					if (!run) continue;
 					if (isTerminalStatus(entry.status)) {
-						const prevStatus = prevStatuses.get(entry.runId);
-						if (!(prevStatus && isTerminalStatus(prevStatus))) sessionCtx?.ui.notify(`Sub-agent "${entry.label}" finished: ${entry.status}`, entry.status === "done" ? "info" : "warning");
-						if (run.blocking) continue;
-						const action = decideCompletion(run);
-						if (action === "defer") {
-							run.completionPending = true;
+						if (decideCompletion(run) === "skip") {
+							if (run.consumed) trackedRuns.delete(entryKey);
 							continue;
 						}
-						if (action === "skip") continue;
+						const prevStatus = prevStatuses.get(entryKey);
+						if (!(prevStatus && isTerminalStatus(prevStatus))) sessionCtx?.ui.notify(`Sub-agent "${entry.label}" finished: ${entry.status}`, entry.status === "done" ? "info" : "warning");
 						const finalOutput = await resolveFinalOutput(run, run.lastStatus);
 						try {
 							pi.sendUserMessage(buildCompletionText({
@@ -1560,8 +1687,7 @@ function createExtension(deps = defaultDeps) {
 							nestedCount: entry.nestedCount,
 							backend: entry.backend
 						}));
-						clearRunPollingFailures(run);
-						trackedRuns.delete(entry.runId);
+						trackedRuns.delete(entryKey);
 					} else if (entry.pendingPermission && !run.blocking && !run.permissionNotified) {
 						run.permissionNotified = true;
 						if (run.lastStatus) try {
@@ -1580,12 +1706,10 @@ function createExtension(deps = defaultDeps) {
 						pollingActive = false;
 						console.error("avenor polling loop failed", err);
 					});
-				}, POLL_INTERVAL_MS);
+				}, pollIntervalMs);
 				else {
 					pollingActive = false;
-					reportedPollingFailures.clear();
-					sessionCtx?.ui.setStatus("avenor", "");
-					sessionCtx?.ui.setWidget("avenor-status", void 0);
+					updateWidget([]);
 				}
 			};
 			tick().catch((err) => {
@@ -1596,10 +1720,11 @@ function createExtension(deps = defaultDeps) {
 		async function stopPolling() {
 			pollingActive = false;
 			pollingGeneration++;
-			reportedPollingFailures.clear();
 			await pollInFlight?.catch(() => {});
-			sessionCtx?.ui.setStatus("avenor", "");
-			sessionCtx?.ui.setWidget("avenor-status", void 0);
+			pollingErrorCount = 0;
+			pollingErrors.length = 0;
+			lastStatusEntries = [];
+			updateWidget([]);
 		}
 		function createWatchDeps() {
 			async function resolveSupervisorSocket(run) {
@@ -1759,7 +1884,7 @@ function createExtension(deps = defaultDeps) {
 		async function waitForRunByPolling(run, signal, onUpdate) {
 			let firstPoll = true;
 			while (!signal?.aborted) {
-				if (!firstPoll) await sleep(POLL_INTERVAL_MS);
+				if (!firstPoll) await sleep(pollIntervalMs);
 				firstPoll = false;
 				try {
 					const raw = await deps.statusTool({
@@ -1769,7 +1894,6 @@ function createExtension(deps = defaultDeps) {
 					const status = Array.isArray(raw) ? raw[0] : raw;
 					if (!status) continue;
 					const text = status.pending_permission ? `[blocked] ${run.label ?? run.runId} — permission: ${status.pending_permission.description}` : `${run.label ?? run.runId}${status.phase_label ? ` (${status.phase_label})` : ""}`;
-					clearPollingFailure(`spawn-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
 					onUpdate?.({
 						content: [{
 							type: "text",
@@ -1785,7 +1909,7 @@ function createExtension(deps = defaultDeps) {
 						aborted: false
 					};
 				} catch (err) {
-					reportPollingFailure(`spawn-status:${run.supervisorId ?? "singleton"}:${run.runId}`, "avenor spawn poll: statusTool failed", err);
+					recordPollingError("spawn-status", "statusTool failed while waiting for a run", err, run.runId);
 				}
 			}
 			return { aborted: true };
@@ -1797,9 +1921,15 @@ function createExtension(deps = defaultDeps) {
 		}
 		pi.on("session_start", async (_event, ctx) => {
 			sessionCtx = ctx;
+			lastStatusEntries = [];
+			pollingErrorCount = 0;
+			pollingErrors.length = 0;
+			startHostAskPoll(ctx);
 		});
 		pi.on("session_shutdown", async () => {
 			await stopPolling();
+			stopHostAskPoll();
+			hostPendingAsks.clear();
 			sessionCtx = null;
 		});
 		pi.on("before_agent_start", async () => {
@@ -1828,7 +1958,7 @@ function createExtension(deps = defaultDeps) {
 		pi.registerTool({
 			name: "avenor_spawn",
 			label: "Avenor Spawn",
-			description: "Dispatch an agent run via avenor. Optional thinking accepts off, minimal, low, medium, high, xhigh, or max; unsupported backends reject explicit values. Blocks by default, showing live progress. Set wait=false for fire-and-forget.",
+			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.`,
 			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.",
@@ -1840,7 +1970,7 @@ function createExtension(deps = defaultDeps) {
 				"Use avenor_shutdown when done delegating work."
 			],
 			parameters: Type.Object({
-				agent: Type.String({ description: "Agent name (required, no default)" }),
+				agent: Type.Optional(Type.String({ description: "Optional agent name; omission uses the supplied model or runtime defaults" })),
 				prompt: Type.Optional(Type.String({ description: "Prompt text" })),
 				prompt_file: Type.Optional(Type.String({ description: "Path to prompt file" })),
 				dir: Type.Optional(Type.String({ description: "Working directory (defaults to session directory)" })),
@@ -1856,7 +1986,9 @@ function createExtension(deps = defaultDeps) {
 					Type.Literal("xhigh"),
 					Type.Literal("max")
 				], { description: "Thinking level; omission uses the backend default" })),
-				backend: Type.Optional(Type.String({ description: "Backend override (defaults to pi)" })),
+				backend: Type.Optional(Type.String({ description: "Backend override (defaults to pi for direct mode)" })),
+				roster_file: Type.Optional(Type.String({ description: "Path to the roster map" })),
+				roster_entry: Type.Optional(Type.String({ description: "Roster entry to select" })),
 				server_url: Type.Optional(Type.String({ description: "Backend server URL" })),
 				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" })),
 				wait: Type.Optional(Type.Boolean({ description: "Block until complete (default true)" }))
@@ -1866,25 +1998,39 @@ function createExtension(deps = defaultDeps) {
 					type: "text",
 					text: "Cancelled"
 				}] };
+				validateSpawnSelection({
+					agent: params.agent,
+					model: params.model,
+					backend: params.backend,
+					roster_file: params.roster_file,
+					roster_entry: params.roster_entry
+				});
 				const wait = params.wait ?? true;
 				const dir = params.dir ?? ctx.cwd;
-				const label = params.label ?? `${params.agent}-${Date.now()}`;
-				const backend = params.backend ?? "pi";
+				const label = params.label ?? `${params.agent ?? params.roster_entry ?? params.model ?? "avenor"}-${Date.now()}`;
+				const rosterMode = Boolean(params.roster_entry);
+				const backend = rosterMode ? params.backend : params.backend ?? "pi";
 				const entries = ctx.sessionManager?.getEntries?.();
-				const agentProfile = backend === "pi" ? resolveAgentProfile(entries) : void 0;
+				const agentProfile = rosterMode || backend === "pi" ? resolveAgentProfile(entries) : void 0;
+				const hostParams = {
+					...params,
+					backend
+				};
 				const result = await deps.spawnTool({
-					agent: params.agent,
-					prompt: params.prompt,
-					promptFile: params.prompt_file,
+					...params.agent !== void 0 ? { agent: params.agent } : {},
+					...params.prompt !== void 0 ? { prompt: params.prompt } : {},
+					...params.prompt_file !== void 0 ? { promptFile: params.prompt_file } : {},
 					label,
 					dir,
-					timeout: params.timeout,
-					model: params.model,
-					thinking: params.thinking,
-					backend,
-					agentProfile,
-					serverUrl: params.server_url,
-					supervisorId: params.supervisor_id
+					...params.timeout !== void 0 ? { timeout: params.timeout } : {},
+					...params.model !== void 0 ? { model: params.model } : {},
+					...params.thinking !== void 0 ? { thinking: params.thinking } : {},
+					...backend !== void 0 ? { backend } : {},
+					...params.roster_file !== void 0 ? { rosterFile: params.roster_file } : {},
+					...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 } : {}
 				});
 				const supervisorId = statusSupervisorId(params.supervisor_id, result.supervisor_id);
 				const runRef = {
@@ -1903,7 +2049,8 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: {
 						run_id: result.run_id,
-						label
+						label,
+						...spawnIdentityMetadata(hostParams)
 					}
 				};
 				onUpdate?.({
@@ -1918,14 +2065,16 @@ function createExtension(deps = defaultDeps) {
 				});
 				const waitResult = await waitForRun(runRef, signal, onUpdate);
 				if (waitResult.aborted) {
-					clearRunPollingFailures(runRef);
-					trackedRuns.delete(result.run_id);
+					trackedRuns.delete(trackedRunKey(supervisorId, result.run_id));
 					return {
 						content: [{
 							type: "text",
 							text: `Monitoring of "${label}" (run_id: ${result.run_id}) was interrupted. Use avenor_status or avenor_inspect to check.`
 						}],
-						details: { run_id: result.run_id }
+						details: {
+							run_id: result.run_id,
+							...spawnIdentityMetadata(hostParams)
+						}
 					};
 				}
 				const status = waitResult.status;
@@ -1936,12 +2085,13 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: {
 						status: "running",
-						run_id: result.run_id
+						run_id: result.run_id,
+						...spawnIdentityMetadata(hostParams)
 					}
 				};
 				upsertTrackedRun(runRef, status, wait);
 				if (status.status === "waiting") {
-					const tracked = trackedRuns.get(result.run_id);
+					const tracked = getTrackedRun(result.run_id, supervisorId);
 					if (tracked) tracked.permissionNotified = true;
 					return {
 						content: [{
@@ -1956,7 +2106,8 @@ function createExtension(deps = defaultDeps) {
 							status: "waiting",
 							run_id: result.run_id,
 							session_id: status.session_id,
-							...status.pending_permission && { pending_permission: status.pending_permission }
+							...status.pending_permission && { pending_permission: status.pending_permission },
+							...spawnIdentityMetadata(hostParams, status)
 						}
 					};
 				}
@@ -1974,8 +2125,7 @@ function createExtension(deps = defaultDeps) {
 						status: status.status,
 						backend: status.backend
 					}));
-					clearRunPollingFailures(runRef);
-					trackedRuns.delete(result.run_id);
+					trackedRuns.delete(trackedRunKey(supervisorId, result.run_id));
 					return {
 						content: [{
 							type: "text",
@@ -1988,7 +2138,8 @@ function createExtension(deps = defaultDeps) {
 							status: status.status,
 							run_id: result.run_id,
 							session_id: status.session_id,
-							final_output: finalOutput
+							final_output: finalOutput,
+							...spawnIdentityMetadata(hostParams, status)
 						}
 					};
 				}
@@ -1999,13 +2150,14 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: {
 						status: status.status,
-						run_id: result.run_id
+						run_id: result.run_id,
+						...spawnIdentityMetadata(hostParams, status)
 					}
 				};
 			},
 			renderCall(args, theme) {
 				const agent = theme.fg("toolTitle", theme.bold("avenor_spawn "));
-				const agentName = theme.fg("accent", args.agent);
+				const agentName = theme.fg("accent", args.agent ?? args.roster_entry ?? args.model ?? "roster");
 				const label = args.label ? theme.fg("dim", ` "${args.label}"`) : "";
 				const wait = args.wait === false ? theme.fg("warning", " [async]") : "";
 				return new Text(agent + agentName + label + wait, 0, 0);
@@ -2072,7 +2224,7 @@ function createExtension(deps = defaultDeps) {
 				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
 			}),
 			async execute(_toolCallId, params, signal) {
-				const tracked = trackedRuns.get(params.run_id);
+				const tracked = getTrackedRun(params.run_id, params.supervisor_id);
 				const previousBlocking = tracked?.blocking;
 				if (tracked) tracked.blocking = true;
 				let completed = false;
@@ -2086,6 +2238,7 @@ function createExtension(deps = defaultDeps) {
 					});
 					completed = result.ready;
 					if (completed) {
+						if (tracked) tracked.consumed = true;
 						emitAvenorEvent(pi.events, CHANNEL_RUN_TERMINAL, createRunTerminalPayload({
 							runId: params.run_id,
 							supervisorId: tracked?.supervisorId ?? params.supervisor_id,
@@ -2094,11 +2247,7 @@ function createExtension(deps = defaultDeps) {
 							agent: tracked?.agent ?? "unknown",
 							status: result.status ?? "done"
 						}));
-						clearRunPollingFailures({
-							runId: params.run_id,
-							supervisorId: tracked?.supervisorId ?? params.supervisor_id
-						});
-						trackedRuns.delete(params.run_id);
+						if (tracked) trackedRuns.delete(trackedRunKey(tracked.supervisorId, tracked.runId));
 					} else if (tracked && result.status === "waiting") tracked.permissionNotified = true;
 					return {
 						content: [{
@@ -2108,7 +2257,7 @@ function createExtension(deps = defaultDeps) {
 						details: result
 					};
 				} finally {
-					if (!completed && tracked && trackedRuns.get(params.run_id) === tracked) tracked.blocking = previousBlocking ?? false;
+					if (!completed && tracked && getTrackedRun(params.run_id, params.supervisor_id) === tracked) tracked.blocking = previousBlocking ?? false;
 				}
 			},
 			renderCall(args, theme, context) {
@@ -2249,6 +2398,94 @@ function createExtension(deps = defaultDeps) {
 				}, theme, context.args);
 			}
 		});
+		pi.registerTool({
+			name: "avenor_ask",
+			label: "Avenor Ask",
+			description: "Ask another agent run a question and block until it replies.",
+			parameters: Type.Object({
+				to_run_id: Type.String({ description: "Target run ID" }),
+				message: Type.String({ description: "Question to ask the other agent" })
+			}),
+			async execute(_toolCallId, params) {
+				return askTool({
+					toRunId: params.to_run_id,
+					message: params.message
+				});
+			}
+		});
+		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.",
+			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" }))
+			}),
+			async execute(_toolCallId, params) {
+				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 {
+					content: [{
+						type: "text",
+						text: "No pending ask found to reply to. Pass from_run_id and/or reply_to_message_id."
+					}],
+					details: { error: true }
+				};
+				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({
 			name: "avenor_events",
 			label: "Avenor Events",
@@ -2293,8 +2530,20 @@ function createExtension(deps = defaultDeps) {
 				force: Type.Optional(Type.Boolean({ description: "Force shutdown instead of graceful" }))
 			}),
 			async execute(_toolCallId, params) {
-				await stopPolling();
-				trackedRuns.clear();
+				const target = params.supervisor_id;
+				const targetIsSingleton = target === void 0 || Boolean(deps.Supervisor.isCurrentInstance?.(target));
+				let removed = 0;
+				for (const [key, run] of trackedRuns) if (targetIsSingleton ? !run.supervisorId || Boolean(deps.Supervisor.isCurrentInstance?.(run.supervisorId)) : run.supervisorId === target) {
+					trackedRuns.delete(key);
+					removed++;
+				}
+				if (removed > 0 && trackedRuns.size === 0) await stopPolling();
+				else if (removed > 0) {
+					pollingActive = false;
+					pollingGeneration++;
+					await pollInFlight?.catch(() => {});
+					startPolling();
+				}
 				const result = await deps.shutdownTool({
 					supervisorId: params.supervisor_id,
 					force: params.force
@@ -2317,10 +2566,178 @@ function createExtension(deps = defaultDeps) {
 				}, theme, context.args);
 			}
 		});
+		pi.registerTool({
+			name: "avenor_workflow_status",
+			label: "Avenor Workflow Status",
+			description: "Get lightweight status for a workflow instance",
+			parameters: Type.Object({
+				workflow_id: Type.String({ description: "Workflow ID" }),
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor ID for multi-supervisor mode" }))
+			}),
+			async execute(_toolCallId, params) {
+				const result = await deps.workflowStatusTool({
+					workflowId: params.workflow_id,
+					supervisorId: params.supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
+			}
+		});
+		pi.registerTool({
+			name: "avenor_workflow_wait",
+			label: "Avenor Workflow Wait",
+			description: "Wait for a workflow to reach a terminal state or until timeout",
+			parameters: Type.Object({
+				workflow_id: Type.String({ description: "Workflow ID" }),
+				timeout: Type.Optional(Type.String({ description: "Timeout (e.g. 30s, 5m)" })),
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor ID for multi-supervisor mode" }))
+			}),
+			async execute(_toolCallId, params) {
+				const result = await deps.workflowWaitTool({
+					workflowId: params.workflow_id,
+					timeout: params.timeout,
+					supervisorId: params.supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
+			}
+		});
+		pi.registerTool({
+			name: "avenor_workflow_inspect",
+			label: "Avenor Workflow Inspect",
+			description: "Return the full instance detail for a workflow",
+			parameters: Type.Object({
+				workflow_id: Type.String({ description: "Workflow ID" }),
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor ID for multi-supervisor mode" }))
+			}),
+			async execute(_toolCallId, params) {
+				const result = await deps.workflowInspectTool({
+					workflowId: params.workflow_id,
+					supervisorId: params.supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
+			}
+		});
+		pi.registerTool({
+			name: "avenor_workflow_events",
+			label: "Avenor Workflow Events",
+			description: "Read log events from a workflow instance's event log",
+			parameters: Type.Object({
+				workflow_id: Type.String({ description: "Workflow ID" }),
+				after_seq: Type.Optional(Type.Number({ description: "Only include events after this sequence number" })),
+				limit: Type.Optional(Type.Number({ description: "Max events to return (default 50)" })),
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor ID for multi-supervisor mode" }))
+			}),
+			async execute(_toolCallId, params) {
+				const result = await deps.workflowEventsTool({
+					workflowId: params.workflow_id,
+					afterSeq: params.after_seq,
+					limit: params.limit,
+					supervisorId: params.supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
+			}
+		});
+		pi.registerTool({
+			name: "avenor_workflow_complete",
+			label: "Avenor Workflow Complete",
+			description: "Atomically complete a machine/external handoff activation",
+			parameters: Type.Object({
+				workflow_id: Type.String({ description: "Workflow ID" }),
+				node_id: Type.String({ description: "Node ID" }),
+				activation_id: Type.String({ description: "Activation ID" }),
+				attempt_id: Type.String({ description: "Attempt ID" }),
+				lease_id: Type.String({ description: "Lease ID" }),
+				owner_token: Type.String({ description: "Owner token" }),
+				outcome: Type.String({ description: "Outcome" }),
+				outputs: Type.Optional(Type.Unknown({ description: "Outputs" })),
+				artifacts: Type.Optional(Type.Unknown({ description: "Artifacts" })),
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor ID for multi-supervisor mode" }))
+			}),
+			async execute(_toolCallId, params) {
+				const { supervisor_id, ...rest } = params;
+				const result = await deps.workflowCompleteTool({
+					...rest,
+					supervisorId: supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
+			}
+		});
+		pi.registerTool({
+			name: "avenor_workflow_gate",
+			label: "Avenor Workflow Gate",
+			description: "Record a gate decision on a parked awaiting_gate activation",
+			parameters: Type.Object({
+				workflow_id: Type.String({ description: "Workflow ID" }),
+				node_id: Type.String({ description: "Node ID" }),
+				gate_id: Type.String({ description: "Gate ID" }),
+				activation_id: Type.String({ description: "Activation ID" }),
+				operation: Type.Union([
+					Type.Literal("satisfy"),
+					Type.Literal("reject"),
+					Type.Literal("waive"),
+					Type.Literal("external_result")
+				], { description: "Gate operation" }),
+				actor: Type.Optional(Type.String({ description: "Actor" })),
+				reason: Type.Optional(Type.String({ description: "Reason" })),
+				outcome: Type.Optional(Type.String({ description: "Outcome" })),
+				subject: Type.Optional(Type.Unknown({ description: "Subject" })),
+				poll_id: Type.Optional(Type.String({ description: "Poll ID" })),
+				source: Type.Optional(Type.String({ description: "Source" })),
+				result: Type.Optional(Type.String({ description: "Result" })),
+				response_hash: Type.Optional(Type.String({ description: "Response hash" })),
+				observed_at: Type.Optional(Type.String({ description: "Observed at" })),
+				evidence_ids: Type.Optional(Type.Array(Type.String(), { description: "Evidence IDs" })),
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor ID for multi-supervisor mode" }))
+			}),
+			async execute(_toolCallId, params) {
+				const { supervisor_id, ...rest } = params;
+				const result = await deps.workflowGateTool({
+					...rest,
+					supervisorId: supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
+			}
+		});
 		pi.registerCommand("avenor-status", {
 			description: "Show status of all avenor runs",
 			handler: async (_args, ctx) => {
 				const entries = await pollRuns();
+				updateWidget(entries);
 				if (entries.length === 0) {
 					ctx.ui.notify("No active avenor runs", "info");
 					return;
@@ -2328,12 +2745,28 @@ function createExtension(deps = defaultDeps) {
 				ctx.ui.setWidget("avenor-status-detail", entries.map((entry) => formatRunLine(entry)));
 			}
 		});
+		pi.registerCommand("avenor-errors", {
+			description: "Show and clear recent Avenor polling errors",
+			handler: async (_args, ctx) => {
+				if (pollingErrors.length === 0) {
+					ctx.ui.setWidget("avenor-errors", void 0);
+					ctx.ui.notify("No recorded avenor polling errors", "info");
+					return;
+				}
+				const errorLines = pollingErrors.map((error) => {
+					const run = error.runId ? ` [${error.runId}]` : "";
+					return `${new Date(error.timestamp).toLocaleTimeString()} ${error.message}${run}: ${error.error}`;
+				});
+				ctx.ui.setWidget("avenor-errors", errorLines);
+				clearPollingErrors();
+			}
+		});
 		pi.registerCommand("avenor-watch", {
 			description: "Open a live run inspector by run ID, label, or agent name",
 			getArgumentCompletions: (prefix) => {
-				const items = Array.from(trackedRuns.values()).filter((run) => run.label.startsWith(prefix) || run.agent.startsWith(prefix) || run.runId.startsWith(prefix)).map((run) => ({
+				const items = Array.from(trackedRuns.values()).filter((run) => run.label.startsWith(prefix) || run.agent?.startsWith(prefix) || run.runId.startsWith(prefix)).map((run) => ({
 					value: run.runId,
-					label: `${sanitizeText(run.label)} (${sanitizeText(run.agent)}, ${sanitizeText(run.runId).slice(0, 8)})`
+					label: `${sanitizeText(run.label)} (${sanitizeText(run.agent ?? "roster")}, ${sanitizeText(run.runId).slice(0, 8)})`
 				}));
 				return items.length > 0 ? items : null;
 			},
@@ -2355,10 +2788,13 @@ function createExtension(deps = defaultDeps) {
 		pi.registerCommand("avenor-cancel", {
 			description: "Cancel a running avenor sub-agent",
 			getArgumentCompletions: (prefix) => {
-				const items = Array.from(trackedRuns.values()).filter((run) => run.label.startsWith(prefix) || run.agent.startsWith(prefix) || run.runId.startsWith(prefix)).map((run) => ({
-					value: run.runId,
-					label: `${sanitizeText(run.label)} (${sanitizeText(run.agent)}, ${sanitizeText(run.runId).slice(0, 8)})`
-				}));
+				const runs = Array.from(trackedRuns.values());
+				const items = runs.filter((run) => run.label.startsWith(prefix) || run.agent?.startsWith(prefix) || run.runId.startsWith(prefix)).map((run) => {
+					return {
+						value: runs.some((other) => other !== run && other.runId === run.runId) ? `${run.supervisorId ?? ""}::${run.runId}` : run.runId,
+						label: `${sanitizeText(run.label)} (${sanitizeText(run.agent ?? "roster")}, ${sanitizeText(run.runId).slice(0, 8)})`
+					};
+				});
 				return items.length > 0 ? items : null;
 			},
 			handler: async (args, ctx) => {
@@ -2366,8 +2802,11 @@ function createExtension(deps = defaultDeps) {
 					ctx.ui.notify("Usage: /avenor-cancel <run_id>", "warning");
 					return;
 				}
-				const runId = args.trim();
-				const run = trackedRuns.get(runId);
+				const raw = args.trim();
+				const sep = raw.lastIndexOf("::");
+				const supervisorId = sep >= 0 ? raw.slice(0, sep) || void 0 : void 0;
+				const runId = sep >= 0 ? raw.slice(sep + 2) : raw;
+				const run = getTrackedRun(runId, supervisorId);
 				const label = run?.label ?? runId;
 				const runtimeId = run?.runtimeId ?? run?.lastStatus?.runtime_id;
 				if (!runtimeId) {
@@ -2392,4 +2831,4 @@ function createExtension(deps = defaultDeps) {
 }
 var src_default = createExtension();
 //#endregion
-export { CHANNEL_POLL_COMPLETED, CHANNEL_RUN_TERMINAL, buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, createPollCompletedPayload, createRunTerminalPayload, src_default as default, emitAvenorEvent, isTerminalStatus, onAvenorEvent, renderStatusLines, statusSupervisorId };
+export { CHANNEL_POLL_COMPLETED, CHANNEL_POLL_ERROR, CHANNEL_RUN_TERMINAL, buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, createPollCompletedPayload, createPollErrorPayload, createRunTerminalPayload, src_default as default, emitAvenorEvent, isTerminalStatus, onAvenorEvent, renderStatusLines, spawnIdentityMetadata, statusSupervisorId };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougbots/avenor-pi",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -35,7 +35,7 @@
     "dev": "tsdown --watch"
   },
   "dependencies": {
-    "@dougbots/avenor-core": "^0.9.0"
+    "@dougbots/avenor-core": "^0.10.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",