@dougbots/avenor-pi 0.3.6 → 0.4.0

package/dist/index.js

@@ -1,56 +1,500 @@
-import { Text } from "@earendil-works/pi-tui";
+import { Input, Key, Text, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { answerPermissionTool, eventsTool, followUpTool, shutdownTool, spawnTool, statusTool } from "@dougbots/avenor-core";
+import { Supervisor, answerPermissionTool, dial, eventsTool, followUpTool, inspectTool, observeRun, shutdownTool, spawnTool, statusTool } from "@dougbots/avenor-core";
 //#region src/watch.ts
-var EventFeedOverlay = class {
-	_events = [];
-	_runId;
-	_onClose;
-	_maxLines = 50;
-	constructor(runId, onClose) {
-		this._runId = runId;
-		this._onClose = onClose ?? (() => {});
+const ANSI_PATTERN = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+const TRANSCRIPT_SCROLL_STEP = 4;
+const ACTION_STATUS_CHARS = 180;
+const PREVIEW_CHARS = 240;
+const TOOL_PREVIEW_CHARS = 120;
+const FINAL_OUTPUT_CHARS = 600;
+const TRANSCRIPT_PADDING = 2;
+const INSPECT_ERROR_PREFIX = "error: ";
+const TERMINAL_STATUSES$1 = new Set([
+	"done",
+	"failed",
+	"timeout",
+	"killed"
+]);
+function emptySnapshot() {
+	return {
+		identity: {},
+		limits: {
+			transcript_entries: 64,
+			text_chars: 4e3,
+			tool_preview_chars: 1e3,
+			tools: 16,
+			permissions: 16,
+			legacy_keys: 128
+		},
+		ended: false,
+		assistant_text: "",
+		thought_text: "",
+		user_text: "",
+		transcript: [],
+		tools: [],
+		live_tools: [],
+		permissions: [],
+		_seen_seq_by_scope: {},
+		_recent_legacy_keys: []
+	};
+}
+function sanitizeText(text) {
+	return text.replace(ANSI_PATTERN, "").replaceAll("	", "  ").replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "");
+}
+function clipText(text, limit) {
+	if (!text) return void 0;
+	const clean = sanitizeText(text).trim();
+	if (!clean) return void 0;
+	if (clean.length <= limit) return clean;
+	return `${clean.slice(0, Math.max(0, limit - 1))}…`;
+}
+function compactWhitespace$1(text, limit) {
+	const clean = clipText(text, limit);
+	if (!clean) return void 0;
+	return clean.replace(/\s+/g, " ").trim() || void 0;
+}
+function padLine(text, width) {
+	const clipped = truncateToWidth(text, width);
+	return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+function wrapPrefixed(text, width, firstPrefix, nextPrefix = " ".repeat(Math.max(0, visibleWidth(firstPrefix)))) {
+	const clean = clipText(text, PREVIEW_CHARS);
+	if (!clean) return [];
+	return wrapTextWithAnsi(clean, Math.max(10, width - Math.max(visibleWidth(firstPrefix), visibleWidth(nextPrefix)))).map((line, index) => truncateToWidth(`${index === 0 ? firstPrefix : nextPrefix}${line}`, width));
+}
+function renderKv(theme, label, value, width) {
+	if (!value) return [];
+	return wrapPrefixed(value, width, theme.fg("dim", `${label}: `));
+}
+function usageSummary(usage) {
+	if (!usage) return void 0;
+	const order = [
+		"input_tokens",
+		"output_tokens",
+		"total_tokens",
+		"tokens"
+	];
+	const parts = [];
+	for (const key of order) {
+		const value = usage[key];
+		if (typeof value === "number" && Number.isFinite(value)) parts.push(`${key}=${value}`);
 	}
-	setOnClose(fn) {
-		this._onClose = fn;
+	if (parts.length === 0) {
+		const entries = Object.entries(usage).filter(([, value]) => typeof value === "number" || typeof value === "string" || typeof value === "boolean").slice(0, 4).map(([key, value]) => `${key}=${String(value)}`);
+		if (entries.length === 0) return void 0;
+		return entries.join(" · ");
 	}
-	setEvents(events) {
-		this._events = events.slice(-this._maxLines);
+	return parts.join(" · ");
+}
+function finalOutputPreview(status, snapshot) {
+	return clipText(status?.final_output ?? snapshot?.final_output ?? snapshot?.assistant_text, FINAL_OUTPUT_CHARS);
+}
+function currentStatusWord(status, snapshot) {
+	const raw = status?.status?.toLowerCase();
+	if (raw && TERMINAL_STATUSES$1.has(raw)) return raw;
+	if (snapshot.pending_permission) return "waiting";
+	if (snapshot.ended) {
+		const stop = snapshot.stop_reason?.toLowerCase();
+		if (stop && TERMINAL_STATUSES$1.has(stop)) return stop;
+		return raw && raw !== "running" ? raw : "done";
 	}
-	appendEvent(event) {
-		this._events.push(event);
-		if (this._events.length > this._maxLines) this._events = this._events.slice(-this._maxLines);
+	return raw ?? "running";
+}
+function isPromptable(status, snapshot) {
+	const current = currentStatusWord(status, snapshot);
+	return !TERMINAL_STATUSES$1.has(current) && current !== "unavailable";
+}
+function isFollowUpable(status, snapshot) {
+	return TERMINAL_STATUSES$1.has(currentStatusWord(status, snapshot)) || snapshot.ended;
+}
+function transcriptLabel(entry, theme) {
+	switch (entry.kind) {
+		case "assistant": return theme.fg("text", "A ");
+		case "thought": return theme.fg("muted", "~ ");
+		case "user": return theme.fg("accent", "> ");
+		case "tool": return theme.fg("toolTitle", `→ ${entry.title ?? "tool"}${entry.status ? ` [${entry.status}]` : ""} `);
+		case "permission": return theme.fg("warning", "🔒 ");
+		case "session": return theme.fg("success", "■ ");
+		case "status": return theme.fg("dim", "· ");
 	}
-	render(width) {
-		const lines = [];
-		const header = `📡 avenor watch: ${this._runId.slice(0, 8)}… (Esc to close)`;
-		lines.push(header);
-		lines.push("─".repeat(Math.min(width, header.length)));
-		if (this._events.length === 0) lines.push("  (waiting for events…)");
-		else for (const evt of this._events) {
-			const ts = new Date(evt.ts).toISOString().slice(11, 19);
-			const type = evt.type ?? "unknown";
-			const extra = this.summarizeEvent(evt);
-			lines.push(`  ${ts} ${type}${extra ? ` — ${extra}` : ""}`);
+}
+function transcriptText(entry) {
+	if (entry.kind === "tool") return compactWhitespace$1(entry.text, TOOL_PREVIEW_CHARS) ?? entry.title;
+	if (entry.kind === "session") return compactWhitespace$1(entry.text, PREVIEW_CHARS) ?? entry.status;
+	return compactWhitespace$1(entry.text, PREVIEW_CHARS);
+}
+function renderTranscriptLines(snapshot, width, theme) {
+	const out = [];
+	for (const entry of snapshot.transcript) {
+		const text = transcriptText(entry);
+		if (!text) continue;
+		const prefix = transcriptLabel(entry, theme);
+		out.push(...wrapPrefixed(text, width, prefix));
+	}
+	if (snapshot.live_tools.length > 0) {
+		if (out.length > 0) out.push("");
+		out.push(theme.fg("dim", "live tools:"));
+		for (const tool of snapshot.live_tools) out.push(...renderToolState(tool, width, theme));
+	}
+	if (snapshot.pending_permission) {
+		if (out.length > 0) out.push("");
+		out.push(...wrapPrefixed(snapshot.pending_permission.description, width, theme.fg("warning", "pending: ")));
+	}
+	return out;
+}
+function renderToolState(tool, width, theme) {
+	const preview = compactWhitespace$1(tool.preview, TOOL_PREVIEW_CHARS);
+	const firstPrefix = `${theme.fg("toolTitle", `→ ${tool.title ?? tool.kind ?? "tool"} `)}${(tool.live ? theme.fg("warning", "[running] ") : tool.status && `${theme.fg("dim", `[${tool.status}] `)}`) ?? ""}`;
+	return wrapPrefixed(preview ?? "(no preview)", width, firstPrefix);
+}
+function helpText(state) {
+	const actions = [
+		"↑/↓ scroll",
+		"pgup/pgdn page",
+		"home/end jump",
+		"esc close"
+	];
+	if (state.status && isPromptable(state.status, state.snapshot)) actions.unshift("enter send prompt", "ctrl-c cancel run");
+	else if (isFollowUpable(state.status, state.snapshot)) actions.unshift("enter follow up");
+	return actions.join(" · ");
+}
+var RunInspectorOverlay = class {
+	tui;
+	theme;
+	keybindings;
+	deps;
+	done;
+	onTrackRun;
+	input = new Input();
+	state;
+	observer = null;
+	observerUnsubscribe = null;
+	refreshPending = false;
+	scrollOffset = 0;
+	closed = false;
+	actionPending = false;
+	actionError;
+	_focused = false;
+	get focused() {
+		return this._focused;
+	}
+	set focused(value) {
+		this._focused = value;
+		this.input.focused = value;
+	}
+	constructor(tui, theme, keybindings, deps, run, done, onTrackRun) {
+		this.tui = tui;
+		this.theme = theme;
+		this.keybindings = keybindings;
+		this.deps = deps;
+		this.done = done;
+		this.onTrackRun = onTrackRun;
+		this.state = {
+			run,
+			snapshot: emptySnapshot(),
+			loading: true
+		};
+		this.input.onSubmit = (value) => {
+			const text = value.trim();
+			if (!text) return;
+			this.input.setValue("");
+			this.submit(text);
+		};
+		this.reload(true);
+	}
+	requestRender() {
+		this.tui.requestRender();
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.cleanup();
+		this.done();
+	}
+	dispose() {
+		if (this.closed) return;
+		this.closed = true;
+		this.cleanup();
+	}
+	invalidate() {
+		this.input.invalidate();
+	}
+	async cleanup() {
+		this.observerUnsubscribe?.();
+		this.observerUnsubscribe = null;
+		if (this.observer) {
+			const observer = this.observer;
+			this.observer = null;
+			await observer.close().catch(() => {});
 		}
-		return lines;
+	}
+	async reload(withObserver) {
+		this.state = {
+			...this.state,
+			loading: true,
+			error: void 0,
+			actionMessage: void 0
+		};
+		this.requestRender();
+		try {
+			const result = await this.deps.inspectRun(this.state.run);
+			if (this.closed) return;
+			const nextRun = {
+				...this.state.run,
+				runId: result.status.run_id ?? this.state.run.runId,
+				label: result.label ?? this.state.run.label,
+				agent: result.status.agent ?? this.state.run.agent,
+				runtimeId: result.status.runtime_id ?? result.snapshot.identity.runtime_id ?? this.state.run.runtimeId
+			};
+			this.state = {
+				run: nextRun,
+				status: result.status,
+				snapshot: result.snapshot,
+				loading: false
+			};
+			this.onTrackRun?.(nextRun, result.status);
+			this.requestRender();
+			await this.cleanup();
+			if (!withObserver) return;
+			if (TERMINAL_STATUSES$1.has(currentStatusWord(result.status, result.snapshot))) return;
+			if (!(nextRun.runtimeId ?? result.snapshot.identity.runtime_id)) return;
+			const observer = await this.deps.observeRun(nextRun, result.snapshot.latest_seq, result.snapshot);
+			if (this.closed || !observer) {
+				await observer?.close().catch(() => {});
+				return;
+			}
+			const applySnapshot = (snapshot) => {
+				this.state = {
+					...this.state,
+					snapshot: {
+						...snapshot,
+						identity: {
+							...snapshot.identity,
+							run_id: snapshot.identity.run_id ?? this.state.status?.run_id ?? this.state.run.runId
+						}
+					}
+				};
+				if (snapshot.ended && !this.refreshPending) {
+					this.refreshPending = true;
+					this.reload(false).finally(() => {
+						this.refreshPending = false;
+					});
+				}
+				this.requestRender();
+			};
+			this.observer = observer;
+			this.observerUnsubscribe = observer.subscribe((snapshot) => {
+				applySnapshot(snapshot);
+			});
+			const current = observer.snapshot();
+			if (current.last_event || current.transcript.length > 0 || current.pending_permission || current.ended) applySnapshot(current);
+		} catch (error) {
+			if (this.closed) return;
+			this.state = {
+				...this.state,
+				loading: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+			this.requestRender();
+		}
+	}
+	runAction(work, message) {
+		if (this.actionPending) return;
+		this.actionPending = true;
+		this.actionError = void 0;
+		if (message) this.state = {
+			...this.state,
+			actionMessage: clipText(message, ACTION_STATUS_CHARS)
+		};
+		this.requestRender();
+		work().catch((error) => {
+			this.actionError = error instanceof Error ? error.message : String(error);
+		}).finally(() => {
+			this.actionPending = false;
+			this.requestRender();
+		});
+	}
+	submit(text) {
+		const runtimeId = this.state.run.runtimeId ?? this.state.status?.runtime_id ?? this.state.snapshot.identity.runtime_id;
+		if (this.state.status && isPromptable(this.state.status, this.state.snapshot) && runtimeId) {
+			this.runAction(async () => {
+				await this.deps.promptRun(this.state.run, runtimeId, text);
+				this.state = {
+					...this.state,
+					actionMessage: clipText(`Queued prompt: ${text}`, ACTION_STATUS_CHARS)
+				};
+			}, "sending prompt…");
+			return;
+		}
+		if (!isFollowUpable(this.state.status, this.state.snapshot)) return;
+		this.runAction(async () => {
+			const next = await this.deps.followUpRun(this.state.run, text);
+			this.state = {
+				...this.state,
+				run: {
+					...this.state.run,
+					runId: next.run_id,
+					label: next.label,
+					runtimeId: void 0
+				},
+				actionMessage: clipText(`Started follow-up run ${next.label}`, ACTION_STATUS_CHARS)
+			};
+			this.scrollOffset = 0;
+			await this.reload(true);
+		}, "starting follow-up…");
+	}
+	cancelCurrentRun() {
+		const runtimeId = this.state.run.runtimeId ?? this.state.status?.runtime_id ?? this.state.snapshot.identity.runtime_id;
+		if (!runtimeId) return;
+		this.runAction(async () => {
+			await this.deps.cancelRun(this.state.run, runtimeId);
+			this.state = {
+				...this.state,
+				actionMessage: "cancel requested"
+			};
+		}, "cancelling run…");
 	}
 	handleInput(data) {
-		if (data === "\x1B") this._onClose();
+		if (matchesKey(data, Key.escape)) {
+			this.close();
+			return;
+		}
+		if (matchesKey(data, Key.up)) {
+			this.scrollOffset += TRANSCRIPT_SCROLL_STEP;
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.scrollOffset = Math.max(0, this.scrollOffset - TRANSCRIPT_SCROLL_STEP);
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, Key.pageUp)) {
+			this.scrollOffset += this.viewportHeight();
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, Key.pageDown)) {
+			this.scrollOffset = Math.max(0, this.scrollOffset - this.viewportHeight());
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, Key.home)) {
+			this.scrollOffset = Number.MAX_SAFE_INTEGER;
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, Key.end)) {
+			this.scrollOffset = 0;
+			this.requestRender();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("c")) && this.state.status && isPromptable(this.state.status, this.state.snapshot)) {
+			this.cancelCurrentRun();
+			return;
+		}
+		this.input.handleInput(data);
+		this.requestRender();
 	}
-	summarizeEvent(evt) {
-		if (evt.type === "tool.call" || evt.type === "tool.use") return `called ${String(evt.tool ?? evt.name ?? "")}`;
-		if (evt.type === "agent.message_chunk") return "thinking…";
-		if (evt.type?.startsWith("permission.")) return "permission requested";
-		if (evt.type === "tool.result") {
-			const result = evt.result;
-			if (typeof result === "string" && result.length < 80) return result;
-			return "completed";
+	viewportHeight() {
+		const rows = this.tui.terminal.rows || 30;
+		return Math.max(8, rows - 15);
+	}
+	render(width) {
+		const theme = this.theme;
+		const lines = [];
+		const horizontal = theme.fg("borderAccent", "─".repeat(Math.max(1, width)));
+		const innerWidth = Math.max(10, width);
+		lines.push(horizontal);
+		const title = this.state.run.label ?? this.state.run.runId;
+		const statusWord = currentStatusWord(this.state.status, this.state.snapshot);
+		const heading = `${theme.fg("accent", theme.bold(title))} ${theme.fg("dim", `(${this.state.run.runId})`)} ${theme.fg(statusWord === "done" ? "success" : statusWord === "failed" ? "error" : statusWord === "waiting" ? "warning" : "muted", statusWord)}`;
+		lines.push(truncateToWidth(heading, innerWidth));
+		const phase = this.state.snapshot.phase_label ?? this.state.status?.phase_label ?? this.state.snapshot.phase ?? this.state.status?.phase;
+		const summary = [
+			phase ? `phase=${phase}` : void 0,
+			this.state.snapshot.latest_seq !== void 0 ? `seq=${this.state.snapshot.latest_seq}` : void 0,
+			this.state.snapshot.identity.agent ?? this.state.status?.agent,
+			this.state.snapshot.identity.model ?? this.state.status?.model,
+			this.state.snapshot.identity.backend ?? this.state.status?.backend
+		].filter((value) => !!value).join(" · ");
+		lines.push(...renderKv(theme, "status", summary || void 0, innerWidth));
+		const identity = [
+			this.state.snapshot.identity.runtime_id ?? this.state.status?.runtime_id,
+			this.state.snapshot.identity.session_id ?? this.state.status?.session_id,
+			this.state.snapshot.identity.dir ?? this.state.status?.dir
+		].filter((value) => !!value).join(" · ");
+		lines.push(...renderKv(theme, "identity", identity || void 0, innerWidth));
+		lines.push(...renderKv(theme, "usage", usageSummary(this.state.snapshot.usage ?? this.state.status?.usage), innerWidth));
+		const finalOutput = finalOutputPreview(this.state.status, this.state.snapshot);
+		if (finalOutput && (this.state.snapshot.ended || TERMINAL_STATUSES$1.has(statusWord))) lines.push(...wrapPrefixed(finalOutput, innerWidth, theme.fg("success", "final: ")));
+		if (this.state.snapshot.pending_permission) {
+			lines.push(...wrapPrefixed(this.state.snapshot.pending_permission.description, innerWidth, theme.fg("warning", "permission: ")));
+			const optionText = this.state.snapshot.pending_permission.options.map((option) => `${option.option_id} (${option.label})`).join(", ");
+			lines.push(...wrapPrefixed(optionText, innerWidth, theme.fg("dim", "options: ")));
+		} else if (this.state.status?.pending_permission) {
+			lines.push(...wrapPrefixed(this.state.status.pending_permission.description, innerWidth, theme.fg("warning", "permission: ")));
+			const optionText = this.state.status.pending_permission.options.map((option) => `${option.option_id} (${option.label})`).join(", ");
+			lines.push(...wrapPrefixed(optionText, innerWidth, theme.fg("dim", "options: ")));
 		}
-		return "";
+		const liveTools = this.state.snapshot.live_tools.slice(-4);
+		if (liveTools.length > 0) {
+			lines.push(theme.fg("dim", "live tools:"));
+			for (const tool of liveTools) lines.push(...renderToolState(tool, innerWidth, theme));
+		}
+		if (this.state.loading) lines.push(theme.fg("muted", "loading…"));
+		if (this.state.actionMessage) lines.push(...wrapPrefixed(this.state.actionMessage, innerWidth, theme.fg("accent", "action: ")));
+		if (this.actionError) lines.push(...wrapPrefixed(this.actionError, innerWidth, theme.fg("error", INSPECT_ERROR_PREFIX)));
+		else if (this.state.error) lines.push(...wrapPrefixed(this.state.error, innerWidth, theme.fg("error", INSPECT_ERROR_PREFIX)));
+		lines.push(horizontal);
+		lines.push(theme.fg("dim", "transcript:"));
+		const transcript = renderTranscriptLines(this.state.snapshot, Math.max(10, innerWidth - TRANSCRIPT_PADDING), theme).map((line) => truncateToWidth(`  ${line}`, innerWidth));
+		const viewportHeight = this.viewportHeight();
+		const scrollNotice = this.scrollOffset > 0 ? truncateToWidth(theme.fg("dim", `… ${this.scrollOffset} line${this.scrollOffset === 1 ? "" : "s"} below`), innerWidth) : void 0;
+		const transcriptCapacity = Math.max(1, viewportHeight - (scrollNotice ? 1 : 0));
+		const maxOffset = Math.max(0, transcript.length - transcriptCapacity);
+		if (this.scrollOffset > maxOffset) this.scrollOffset = maxOffset;
+		const end = transcript.length - this.scrollOffset;
+		const start = Math.max(0, end - transcriptCapacity);
+		const body = transcript.slice(start, end);
+		while (body.length < transcriptCapacity) body.push("");
+		if (scrollNotice) body.push(scrollNotice);
+		for (const line of body) lines.push(padLine(line, innerWidth));
+		lines.push(horizontal);
+		lines.push(...this.input.render(innerWidth).map((line) => truncateToWidth(line, innerWidth)));
+		const promptHint = this.state.status && isPromptable(this.state.status, this.state.snapshot) ? "send prompt to running/waiting run" : isFollowUpable(this.state.status, this.state.snapshot) ? "start a follow-up run from this transcript" : "read-only view";
+		lines.push(truncateToWidth(theme.fg("dim", `${promptHint} · ${helpText(this.state)}`), innerWidth));
+		lines.push(horizontal);
+		return lines.map((line) => truncateToWidth(line, innerWidth));
 	}
-	invalidate() {}
 };
+async function openRunInspector(ctx, options) {
+	if (!ctx.hasUI) {
+		ctx.ui.notify("avenor-watch requires TUI mode", "warning");
+		return;
+	}
+	let runId = options.initialRunId?.trim();
+	if (!runId) {
+		if (options.trackedRuns.length === 0) {
+			ctx.ui.notify("No tracked runs", "warning");
+			return;
+		}
+		const selected = await ctx.ui.select("Watch run:", options.trackedRuns.map((run) => run.runId));
+		if (!selected) return;
+		runId = selected;
+	}
+	const tracked = options.trackedRuns.find((run) => run.runId === runId);
+	await ctx.ui.custom((tui, theme, keybindings, done) => new RunInspectorOverlay(tui, theme, keybindings, options.deps, tracked ?? { runId }, () => done(), options.onTrackRun), {
+		overlay: true,
+		overlayOptions: {
+			anchor: "center",
+			width: "95%",
+			maxHeight: "95%",
+			minWidth: 80
+		}
+	});
+}
 //#endregion
 //#region src/types.ts
 const TERMINAL_STATUSES = new Set([
@@ -80,14 +524,48 @@ function formatRunLine(entry) {
 //#endregion
 //#region src/index.ts
 const POLL_INTERVAL_MS = 3e3;
+const INSPECT_LIMIT = 128;
+const COMPLETION_OUTPUT_CHARS = 600;
+const INSPECT_JSON_STRING_CHARS = 600;
+const INSPECT_JSON_ARRAY_ITEMS = 24;
+const INSPECT_JSON_OBJECT_KEYS = 24;
+const INSPECT_JSON_DEPTH = 8;
+const defaultDeps = {
+	spawnTool,
+	statusTool,
+	eventsTool,
+	answerPermissionTool,
+	followUpTool,
+	inspectTool,
+	shutdownTool,
+	observeRun,
+	dial,
+	Supervisor
+};
+function statusSupervisorId(requestedSupervisorId, spawnedSupervisorId) {
+	return requestedSupervisorId ? spawnedSupervisorId : void 0;
+}
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function buildCompletionText(run, result) {
+function normalizeMultilinePreview(text, limit = COMPLETION_OUTPUT_CHARS) {
+	if (!text) return void 0;
+	const clean = sanitizeText(text).trim();
+	if (!clean) return void 0;
+	return clean.length <= limit ? clean : `${clean.slice(0, Math.max(0, limit - 1))}…`;
+}
+function quotedLines(text) {
+	const preview = normalizeMultilinePreview(text);
+	if (!preview) return [];
+	return preview.split("\n").slice(0, 8).map((line) => `> ${line}`);
+}
+function buildCompletionText(run, result, finalOutput) {
 	const lines = [`Sub-agent "${run.label}" finished with status **${result.status}**.`];
+	const output = normalizeMultilinePreview(finalOutput ?? result.final_output);
+	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(`\nCall \`avenor_events\` with \`run_id: "${run.runId}"\` to review the output, or \`avenor_follow_up\` to iterate.`);
+	lines.push("", `Call \`avenor_inspect\` with \`run_id: "${run.runId}"\` for the bounded transcript/snapshot, or \`avenor_follow_up\` to iterate.`);
 	return lines.join("\n");
 }
 function buildWaitingText(run, status) {
@@ -95,341 +573,598 @@ function buildWaitingText(run, status) {
 	const lines = [`Sub-agent "${run.label}" (${run.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_status\` to re-check.`);
+	if (!perm) lines.push(`Use \`avenor_follow_up\` with run_id "${run.runId}" to respond, or \`avenor_inspect\` to review context first.`);
 	return lines.join("\n");
 }
-function summarizeEvent(evt) {
-	const type = String(evt.type ?? evt.event ?? "");
-	if (type === "tool.call" || type === "tool.use") return `called ${String(evt.tool ?? evt.name ?? type)}`;
-	if (type === "agent.message_chunk") return "thinking…";
-	if (type.startsWith("permission.")) return `permission requested`;
-	return type;
-}
-async function src_default(pi) {
-	const trackedRuns = /* @__PURE__ */ new Map();
-	let pollingActive = false;
-	let pollingGeneration = 0;
-	let pollInFlight = null;
-	let sessionCtx = null;
-	async function pollRuns() {
-		const liveMap = /* @__PURE__ */ new Map();
-		try {
-			const allLive = await statusTool({});
-			const liveList = Array.isArray(allLive) ? allLive : [allLive];
-			for (const result of liveList) liveMap.set(result.run_id, result);
-		} catch (err) {
-			console.error("avenor pollRuns: failed to list singleton runs", err);
+function isTerminalStatus(status) {
+	return !!status && TERMINAL_STATUSES.has(status);
+}
+function renderStatusLines(entries) {
+	const active = entries.filter((e) => !isTerminalStatus(e.status));
+	if (active.length === 0) return [];
+	return active.map((e) => {
+		const emoji = statusEmoji(e.status);
+		const perm = e.pendingPermission ? " 🔒" : "";
+		const phase = e.phaseLabel ? ` [${e.phaseLabel}]` : "";
+		return `${emoji} ${e.label} — ${e.status}${phase}${perm}`;
+	});
+}
+function compactWhitespace(text, limit = 100) {
+	const clipped = clipText(text, limit);
+	return clipped ? clipped.replace(/\s+/g, " ").trim() : void 0;
+}
+function snapshotProgressText(label, snapshot) {
+	if (snapshot.pending_permission) return `[blocked] ${label} — permission: ${snapshot.pending_permission.description}`;
+	const phase = snapshot.phase_label ? ` (${snapshot.phase_label})` : snapshot.phase ? ` (${snapshot.phase})` : "";
+	const liveTool = snapshot.live_tools[snapshot.live_tools.length - 1];
+	if (liveTool) {
+		const toolName = liveTool.title ?? liveTool.kind ?? "tool";
+		const preview = compactWhitespace(liveTool.preview, 80);
+		return `${label}${phase} — ${toolName}${preview ? `: ${preview}` : ""}`;
+	}
+	const last = snapshot.transcript[snapshot.transcript.length - 1];
+	const transcriptWidth = 160;
+	const rendered = last ? compactWhitespace(renderTranscriptLines({
+		...snapshot,
+		transcript: [last],
+		live_tools: [],
+		pending_permission: void 0
+	}, transcriptWidth, {
+		fg: (_color, text) => text,
+		bg: (_color, text) => text,
+		bold: (text) => text,
+		italic: (text) => text
+	})[0], 80) : void 0;
+	return `${label}${phase}${rendered ? ` — ${rendered}` : ""}`;
+}
+function boundJsonValue(value, depth = 0) {
+	if (depth >= INSPECT_JSON_DEPTH) return "[truncated]";
+	if (typeof value === "string") {
+		const clean = sanitizeText(value);
+		return clean.length <= INSPECT_JSON_STRING_CHARS ? clean : `${clean.slice(0, INSPECT_JSON_STRING_CHARS - 1)}…`;
+	}
+	if (Array.isArray(value)) return value.slice(Math.max(0, value.length - INSPECT_JSON_ARRAY_ITEMS)).map((item) => boundJsonValue(item, depth + 1));
+	if (!value || typeof value !== "object") return value;
+	const result = {};
+	for (const [key, item] of Object.entries(value).slice(0, INSPECT_JSON_OBJECT_KEYS)) result[key] = boundJsonValue(item, depth + 1);
+	return result;
+}
+function buildInspectPayload(result) {
+	const finalOutput = finalOutputPreview(result.status, result.snapshot);
+	return boundJsonValue({
+		run_id: result.run_id,
+		label: result.label,
+		status: result.status,
+		snapshot: result.snapshot,
+		transcript: result.transcript,
+		tools: result.tools,
+		live_tools: result.live_tools,
+		permissions: result.permissions,
+		pending_permission: result.pending_permission,
+		final_output: finalOutput
+	});
+}
+function toWatchRunRef(run) {
+	return {
+		runId: run.runId,
+		label: run.label,
+		agent: run.agent,
+		runtimeId: run.runtimeId,
+		supervisorId: run.supervisorId
+	};
+}
+function createExtension(deps = defaultDeps) {
+	return async function(pi) {
+		const trackedRuns = /* @__PURE__ */ new Map();
+		let pollingActive = false;
+		let pollingGeneration = 0;
+		let pollInFlight = null;
+		let sessionCtx = null;
+		function upsertTrackedRun(run, status, blocking = false) {
+			const current = trackedRuns.get(run.runId);
+			trackedRuns.set(run.runId, {
+				runId: run.runId,
+				agent: run.agent ?? status?.agent ?? current?.agent ?? "unknown",
+				label: run.label ?? status?.label ?? current?.label ?? run.runId,
+				supervisorId: run.supervisorId ?? current?.supervisorId,
+				runtimeId: run.runtimeId ?? status?.runtime_id ?? current?.runtimeId,
+				startTime: current?.startTime ?? Date.now(),
+				lastStatus: status ?? current?.lastStatus,
+				blocking: current?.blocking ?? blocking,
+				permissionNotified: current?.permissionNotified
+			});
 		}
-		const entries = [];
-		for (const run of trackedRuns.values()) {
-			const live = liveMap.get(run.runId);
-			if (live) {
-				liveMap.delete(live.run_id);
-				run.lastStatus = live;
-				entries.push({
+		async function resolveFinalOutput(run, status) {
+			const preview = finalOutputPreview(status);
+			if (preview) return preview;
+			try {
+				const inspected = await deps.inspectTool({
 					runId: run.runId,
-					label: run.label,
-					status: live.status,
-					phase: live.phase,
-					phaseLabel: live.phase_label,
-					agent: run.agent,
-					pendingPermission: !!live.pending_permission,
-					permissionDescription: live.pending_permission?.description
+					supervisorId: run.supervisorId,
+					limit: INSPECT_LIMIT
 				});
-				continue;
+				return finalOutputPreview(inspected.status, inspected.snapshot);
+			} catch {
+				return;
 			}
+		}
+		async function pollRuns() {
+			const liveMap = /* @__PURE__ */ new Map();
 			try {
-				const raw = await statusTool({
-					runId: run.runId,
-					supervisorId: run.supervisorId
-				});
-				const result = Array.isArray(raw) ? raw[0] : raw;
-				if (!result) throw new Error("status response was empty");
-				run.lastStatus = result;
-				entries.push({
-					runId: run.runId,
-					label: run.label,
-					status: result.status,
-					phase: result.phase,
-					phaseLabel: result.phase_label,
-					agent: run.agent,
-					pendingPermission: !!result.pending_permission,
-					permissionDescription: result.pending_permission?.description
-				});
+				const allLive = await deps.statusTool({});
+				const liveList = Array.isArray(allLive) ? allLive : [allLive];
+				for (const result of liveList) liveMap.set(result.run_id, result);
 			} catch (err) {
-				console.error(`avenor pollRuns: statusTool failed for ${run.runId}`, err);
-				const previous = run.lastStatus;
-				entries.push({
-					runId: run.runId,
-					label: run.label,
-					status: previous?.status ?? "unavailable",
-					phase: previous?.phase,
-					phaseLabel: previous?.phase_label,
-					agent: run.agent,
-					pendingPermission: !!previous?.pending_permission,
-					permissionDescription: previous?.pending_permission?.description
-				});
+				console.error("avenor pollRuns: failed to list singleton runs", err);
 			}
+			const entries = [];
+			for (const run of trackedRuns.values()) {
+				const live = liveMap.get(run.runId);
+				if (live) {
+					liveMap.delete(live.run_id);
+					run.lastStatus = live;
+					entries.push({
+						runId: run.runId,
+						label: run.label,
+						status: live.status,
+						phase: live.phase,
+						phaseLabel: live.phase_label,
+						agent: run.agent,
+						pendingPermission: !!live.pending_permission,
+						permissionDescription: live.pending_permission?.description
+					});
+					continue;
+				}
+				try {
+					const raw = await deps.statusTool({
+						runId: run.runId,
+						supervisorId: run.supervisorId
+					});
+					const result = Array.isArray(raw) ? raw[0] : raw;
+					if (!result) throw new Error("status response was empty");
+					run.lastStatus = result;
+					entries.push({
+						runId: run.runId,
+						label: run.label,
+						status: result.status,
+						phase: result.phase,
+						phaseLabel: result.phase_label,
+						agent: run.agent,
+						pendingPermission: !!result.pending_permission,
+						permissionDescription: result.pending_permission?.description
+					});
+				} catch (err) {
+					console.error(`avenor pollRuns: statusTool failed for ${run.runId}`, err);
+					const previous = run.lastStatus;
+					entries.push({
+						runId: run.runId,
+						label: run.label,
+						status: previous?.status ?? "unavailable",
+						phase: previous?.phase,
+						phaseLabel: previous?.phase_label,
+						agent: run.agent,
+						pendingPermission: !!previous?.pending_permission,
+						permissionDescription: previous?.pending_permission?.description
+					});
+				}
+			}
+			for (const live of liveMap.values()) entries.push({
+				runId: live.run_id,
+				label: live.label,
+				status: live.status,
+				phase: live.phase,
+				phaseLabel: live.phase_label,
+				agent: live.agent ?? "unknown",
+				pendingPermission: !!live.pending_permission,
+				permissionDescription: live.pending_permission?.description
+			});
+			return entries;
 		}
-		for (const live of liveMap.values()) entries.push({
-			runId: live.run_id,
-			label: live.label,
-			status: live.status,
-			phase: live.phase,
-			phaseLabel: live.phase_label,
-			agent: "unknown",
-			pendingPermission: !!live.pending_permission,
-			permissionDescription: live.pending_permission?.description
-		});
-		return entries;
-	}
-	function renderStatusLines(entries) {
-		const active = entries.filter((e) => !TERMINAL_STATUSES.has(e.status));
-		if (active.length === 0) return [];
-		return active.map((e) => {
-			const emoji = statusEmoji(e.status);
-			const perm = e.pendingPermission ? ` 🔒` : "";
-			const phase = e.phaseLabel ? ` [${e.phaseLabel}]` : "";
-			return `${emoji} ${e.label} — ${e.status}${phase}${perm}`;
-		});
-	}
-	function updateWidget(entries) {
-		if (!sessionCtx) return;
-		const lines = renderStatusLines(entries);
-		if (lines.length > 0) {
-			sessionCtx.ui.setWidget("avenor-status", lines);
-			const parts = lines.map((l) => l.slice(0, 60));
-			sessionCtx.ui.setStatus("avenor", parts.join("  "));
-		} else {
-			sessionCtx.ui.setWidget("avenor-status", void 0);
-			sessionCtx.ui.setStatus("avenor", "");
+		function updateWidget(entries) {
+			if (!sessionCtx) return;
+			const lines = renderStatusLines(entries);
+			if (lines.length > 0) {
+				sessionCtx.ui.setWidget("avenor-status", lines);
+				sessionCtx.ui.setStatus("avenor", lines.map((line) => line.slice(0, 60)).join("  "));
+			} else {
+				sessionCtx.ui.setWidget("avenor-status", void 0);
+				sessionCtx.ui.setStatus("avenor", "");
+			}
 		}
-	}
-	function startPolling() {
-		if (pollingActive) return;
-		pollingActive = true;
-		const generation = ++pollingGeneration;
-		const tick = async () => {
-			if (!pollingActive || generation !== pollingGeneration) return;
-			const prevStatuses = /* @__PURE__ */ new Map();
-			for (const [id, run] of trackedRuns) prevStatuses.set(id, run.lastStatus?.status);
-			const currentPoll = pollRuns();
-			pollInFlight = currentPoll;
-			const entries = await currentPoll.finally(() => {
-				if (pollInFlight === currentPoll) pollInFlight = null;
-			});
-			if (!pollingActive || generation !== pollingGeneration) return;
-			updateWidget(entries);
-			for (const entry of entries) {
-				const run = trackedRuns.get(entry.runId);
-				if (!run) continue;
-				if (TERMINAL_STATUSES.has(entry.status)) {
-					const prevStatus = prevStatuses.get(entry.runId);
-					if (!prevStatus || !TERMINAL_STATUSES.has(prevStatus)) {
-						sessionCtx?.ui.notify(`Sub-agent "${entry.label}" finished: ${entry.status}`, entry.status === "done" ? "info" : "warning");
-						if (!run.blocking) try {
-							pi.sendUserMessage(buildCompletionText({
+		function startPolling() {
+			if (pollingActive) return;
+			pollingActive = true;
+			const generation = ++pollingGeneration;
+			const tick = async () => {
+				if (!pollingActive || generation !== pollingGeneration) return;
+				const prevStatuses = /* @__PURE__ */ new Map();
+				for (const [id, run] of trackedRuns) prevStatuses.set(id, run.lastStatus?.status);
+				const currentPoll = pollRuns();
+				pollInFlight = currentPoll;
+				const entries = await currentPoll.finally(() => {
+					if (pollInFlight === currentPoll) pollInFlight = null;
+				});
+				if (!pollingActive || generation !== pollingGeneration) return;
+				updateWidget(entries);
+				for (const entry of entries) {
+					const run = trackedRuns.get(entry.runId);
+					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 && run.lastStatus) {
+								const finalOutput = await resolveFinalOutput(run, run.lastStatus);
+								try {
+									pi.sendUserMessage(buildCompletionText({
+										runId: run.runId,
+										label: run.label
+									}, run.lastStatus, finalOutput), { deliverAs: "followUp" });
+								} catch (err) {
+									console.error("avenor tick: sendUserMessage failed", err);
+								}
+							}
+						}
+						trackedRuns.delete(entry.runId);
+					} else if (entry.pendingPermission && !run.blocking && !run.permissionNotified) {
+						run.permissionNotified = true;
+						if (run.lastStatus) try {
+							pi.sendUserMessage(buildWaitingText({
 								runId: run.runId,
-								label: run.label
+								label: run.label,
+								agent: run.agent
 							}, run.lastStatus), { deliverAs: "followUp" });
 						} catch (err) {
-							console.error("avenor tick: sendUserMessage failed", err);
+							console.error("avenor tick: sendUserMessage for permission failed", err);
 						}
-					}
-					trackedRuns.delete(entry.runId);
-				} else if (entry.pendingPermission && !run.blocking && !run.permissionNotified) {
-					run.permissionNotified = true;
-					try {
-						pi.sendUserMessage(buildWaitingText({
-							runId: run.runId,
-							label: run.label,
-							agent: run.agent
-						}, run.lastStatus), { deliverAs: "followUp" });
-					} catch (err) {
-						console.error("avenor tick: sendUserMessage for permission failed", err);
-					}
-				} else if (!entry.pendingPermission && run.permissionNotified) run.permissionNotified = false;
-			}
-			if (entries.some((e) => !TERMINAL_STATUSES.has(e.status)) && pollingActive && generation === pollingGeneration) setTimeout(() => {
-				tick().catch((err) => {
+					} else if (!entry.pendingPermission && run.permissionNotified) run.permissionNotified = false;
+				}
+				if (entries.some((entry) => !isTerminalStatus(entry.status)) && pollingActive && generation === pollingGeneration) setTimeout(() => {
+					tick().catch((err) => {
+						pollingActive = false;
+						console.error("avenor polling loop failed", err);
+					});
+				}, POLL_INTERVAL_MS);
+				else {
 					pollingActive = false;
-					console.error("avenor polling loop failed", err);
-				});
-			}, POLL_INTERVAL_MS);
-			else {
+					sessionCtx?.ui.setStatus("avenor", "");
+					sessionCtx?.ui.setWidget("avenor-status", void 0);
+				}
+			};
+			tick().catch((err) => {
 				pollingActive = false;
-				sessionCtx?.ui.setStatus("avenor", "");
-				sessionCtx?.ui.setWidget("avenor-status", void 0);
-			}
-		};
-		tick().catch((err) => {
+				console.error("avenor polling loop failed", err);
+			});
+		}
+		async function stopPolling() {
 			pollingActive = false;
-			console.error("avenor polling loop failed", err);
-		});
-	}
-	async function stopPolling() {
-		pollingActive = false;
-		pollingGeneration++;
-		await pollInFlight?.catch(() => {});
-		sessionCtx?.ui.setStatus("avenor", "");
-		sessionCtx?.ui.setWidget("avenor-status", void 0);
-	}
-	pi.on("session_start", async (_event, ctx) => {
-		sessionCtx = ctx;
-	});
-	pi.on("session_shutdown", async (_event, _ctx) => {
-		await stopPolling();
-		sessionCtx = null;
-	});
-	pi.on("before_agent_start", async (event, _ctx) => {
-		if (trackedRuns.size === 0) return;
-		const active = (await pollRuns()).filter((e) => !TERMINAL_STATUSES.has(e.status));
-		if (active.length === 0) return;
-		return { message: {
-			customType: "avenor-active-runs",
-			content: `Active sub-agents:\n${active.map((e) => {
-				const perm = e.pendingPermission ? ` [blocked: ${e.permissionDescription ?? "permission"}]` : "";
-				const phase = e.phaseLabel ? ` (${e.phaseLabel})` : "";
-				return `  • ${e.label} (${e.agent}): ${e.status}${phase}${perm}`;
-			}).join("\n")}`,
-			display: true
-		} };
-	});
-	pi.registerMessageRenderer("avenor-active-runs", (message, options, theme) => {
-		const lines = message.content.split("\n");
-		let text = "";
-		for (let i = 0; i < lines.length; i++) {
-			if (i === 0) text += theme.fg("info", theme.bold(lines[i]));
-			else text += theme.fg("muted", lines[i]);
-			if (i < lines.length - 1) text += "\n";
+			pollingGeneration++;
+			await pollInFlight?.catch(() => {});
+			sessionCtx?.ui.setStatus("avenor", "");
+			sessionCtx?.ui.setWidget("avenor-status", void 0);
 		}
-		return new Text(text, 0, 0);
-	});
-	pi.registerTool({
-		name: "avenor_spawn",
-		label: "Avenor Spawn",
-		description: "Dispatch an agent run via avenor. Blocks by default, showing live progress. Set wait=false for fire-and-forget.",
-		promptSnippet: "Dispatch sub-agent runs via avenor (spawn, status, events, follow-up, shutdown)",
-		promptGuidelines: [
-			"Use avenor_spawn to delegate well-defined tasks to sub-agents.",
-			"Use avenor_status to check progress of fire-and-forget runs.",
-			"Use avenor_events to inspect detailed output from a run.",
-			"Use avenor_follow_up to iterate on a completed run.",
-			"Use avenor_shutdown when done delegating work."
-		],
-		parameters: Type.Object({
-			agent: Type.String({ description: "Agent name (required, no default)" }),
-			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)" })),
-			label: Type.Optional(Type.String({ description: "Human-readable label for the run" })),
-			timeout: Type.Optional(Type.String({ description: "Timeout duration (e.g. 3600s)" })),
-			model: Type.Optional(Type.String({ description: "Model override" })),
-			backend: Type.Optional(Type.String({ description: "Backend override" })),
-			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)" }))
-		}),
-		async execute(_toolCallId, params, signal, onUpdate, ctx) {
-			if (signal?.aborted) return { content: [{
-				type: "text",
-				text: "Cancelled"
-			}] };
-			const wait = params.wait ?? true;
-			const dir = params.dir ?? ctx.cwd;
-			const label = params.label ?? `${params.agent}-${Date.now()}`;
-			const result = await spawnTool({
-				agent: params.agent,
-				prompt: params.prompt,
-				promptFile: params.prompt_file,
-				label,
-				dir,
-				timeout: params.timeout,
-				model: params.model,
-				backend: params.backend,
-				serverUrl: params.server_url,
-				supervisorId: params.supervisor_id
-			});
-			trackedRuns.set(result.run_id, {
-				runId: result.run_id,
-				agent: params.agent,
-				label,
-				supervisorId: result.supervisor_id,
-				runtimeId: result.runtime_id,
-				startTime: Date.now(),
-				blocking: wait
-			});
-			startPolling();
-			if (!wait) return {
-				content: [{
-					type: "text",
-					text: `Dispatched "${label}" (run_id: ${result.run_id}). Call avenor_status to check progress.`
-				}],
-				details: {
-					run_id: result.run_id,
-					label
+		function createWatchDeps() {
+			async function resolveSupervisorSocket(run) {
+				if (run.supervisorId) return run.supervisorId;
+				return (await deps.Supervisor.get()).supervisorId;
+			}
+			async function withClient(run, work) {
+				const socket = await resolveSupervisorSocket(run);
+				const client = await deps.dial(socket);
+				try {
+					return await work(client);
+				} finally {
+					client.close();
 				}
-			};
-			onUpdate?.({
-				content: [{
-					type: "text",
-					text: `Starting ${label}…`
-				}],
-				details: {
-					status: "running",
-					run_id: result.run_id
+			}
+			return {
+				inspectRun(run) {
+					return deps.inspectTool({
+						runId: run.runId,
+						supervisorId: run.supervisorId,
+						limit: INSPECT_LIMIT
+					});
+				},
+				async observeRun(run, afterSeq, initialSnapshot) {
+					const runtimeId = run.runtimeId;
+					if (!runtimeId) return null;
+					const socket = await resolveSupervisorSocket(run);
+					const client = await deps.dial(socket);
+					return deps.observeRun(client, {
+						runtime_id: runtimeId,
+						replay: true,
+						after_seq: afterSeq,
+						initial_snapshot: initialSnapshot,
+						close_client: true
+					});
+				},
+				cancelRun(run, runtimeId) {
+					return withClient(run, async (client) => {
+						await client.cancel(runtimeId);
+					});
+				},
+				promptRun(run, runtimeId, text) {
+					return withClient(run, async (client) => {
+						await client.prompt(runtimeId, text);
+					});
+				},
+				followUpRun(run, text) {
+					return deps.followUpTool({
+						runId: run.runId,
+						message: text,
+						supervisorId: run.supervisorId
+					});
 				}
+			};
+		}
+		async function followUpTrackedRun(run, text) {
+			const result = await deps.followUpTool({
+				runId: run.runId,
+				message: text,
+				supervisorId: run.supervisorId
+			});
+			try {
+				const rawStatus = await deps.statusTool({
+					runId: result.run_id,
+					supervisorId: run.supervisorId
+				});
+				const status = Array.isArray(rawStatus) ? rawStatus[0] : rawStatus;
+				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 waitForRunWithObserver(run, signal, onUpdate) {
+			let observer = null;
+			let unsubscribe;
+			let lastUpdate = "";
+			let abortListener;
+			const emit = (snapshot) => {
+				const text = snapshotProgressText(run.label ?? run.runId, snapshot);
+				if (text === lastUpdate) return;
+				lastUpdate = text;
+				onUpdate?.({
+					content: [{
+						type: "text",
+						text
+					}],
+					details: {
+						status: snapshot.pending_permission ? "waiting" : snapshot.ended ? "done" : "running",
+						run_id: run.runId
+					}
+				});
+			};
+			const waitPromise = new Promise((resolve) => {
+				const complete = () => resolve("settled");
+				(async () => {
+					try {
+						observer = await createWatchDeps().observeRun(run);
+						if (!observer) {
+							complete();
+							return;
+						}
+						const maybeComplete = (snapshot) => {
+							emit(snapshot);
+							if (snapshot.pending_permission || snapshot.ended) complete();
+						};
+						unsubscribe = observer.subscribe((snapshot) => {
+							maybeComplete(snapshot);
+						});
+						const current = observer.snapshot();
+						if (current.last_event || current.transcript.length > 0 || current.pending_permission || current.ended) maybeComplete(current);
+					} catch {
+						complete();
+					}
+				})();
 			});
+			const abortPromise = signal ? new Promise((resolve) => {
+				if (signal.aborted) {
+					resolve("aborted");
+					return;
+				}
+				const onAbort = () => resolve("aborted");
+				abortListener = onAbort;
+				signal.addEventListener("abort", onAbort, { once: true });
+			}) : void 0;
+			const outcome = abortPromise ? await Promise.race([waitPromise, abortPromise]) : await waitPromise;
+			if (signal && abortListener) signal.removeEventListener("abort", abortListener);
+			unsubscribe?.();
+			await observer?.close().catch(() => {});
+			if (outcome === "aborted") return { aborted: true };
+			try {
+				const raw = await deps.statusTool({
+					runId: run.runId,
+					supervisorId: run.supervisorId
+				});
+				return {
+					status: Array.isArray(raw) ? raw[0] : raw,
+					aborted: false
+				};
+			} catch {
+				return { aborted: false };
+			}
+		}
+		async function waitForRunByPolling(run, signal, onUpdate) {
 			let firstPoll = true;
 			while (!signal?.aborted) {
 				if (!firstPoll) await sleep(POLL_INTERVAL_MS);
 				firstPoll = false;
-				let raw;
 				try {
-					raw = await statusTool({
-						runId: result.run_id,
-						supervisorId: result.supervisor_id
+					const raw = await deps.statusTool({
+						runId: run.runId,
+						supervisorId: run.supervisorId
+					});
+					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})` : ""}`;
+					onUpdate?.({
+						content: [{
+							type: "text",
+							text
+						}],
+						details: {
+							status: status.status,
+							run_id: run.runId
+						}
 					});
+					if (status.status === "waiting" || isTerminalStatus(status.status)) return {
+						status,
+						aborted: false
+					};
 				} catch (err) {
 					console.error("avenor spawn poll: statusTool failed", err);
-					continue;
 				}
-				const status = Array.isArray(raw) ? raw[0] : raw;
-				if (!status) continue;
-				if (status.pending_permission) onUpdate?.({
+			}
+			return { aborted: true };
+		}
+		async function waitForRun(run, signal, onUpdate) {
+			const observed = await waitForRunWithObserver(run, signal, onUpdate);
+			if (observed.status || observed.aborted) return observed;
+			return waitForRunByPolling(run, signal, onUpdate);
+		}
+		pi.on("session_start", async (_event, ctx) => {
+			sessionCtx = ctx;
+		});
+		pi.on("session_shutdown", async () => {
+			await stopPolling();
+			sessionCtx = null;
+		});
+		pi.on("before_agent_start", async () => {
+			if (trackedRuns.size === 0) return;
+			const active = (await pollRuns()).filter((entry) => !isTerminalStatus(entry.status));
+			if (active.length === 0) return;
+			return { message: {
+				customType: "avenor-active-runs",
+				content: `Active sub-agents:\n${active.map((entry) => {
+					const perm = entry.pendingPermission ? ` [blocked: ${entry.permissionDescription ?? "permission"}]` : "";
+					const phase = entry.phaseLabel ? ` (${entry.phaseLabel})` : "";
+					return `  • ${entry.label} (${entry.agent}): ${entry.status}${phase}${perm}`;
+				}).join("\n")}`,
+				display: true
+			} };
+		});
+		pi.registerMessageRenderer("avenor-active-runs", (message, _options, theme) => {
+			const lines = message.content.split("\n");
+			let text = "";
+			for (let i = 0; i < lines.length; i++) {
+				text += i === 0 ? theme.fg("accent", theme.bold(lines[i] ?? "")) : theme.fg("muted", lines[i] ?? "");
+				if (i < lines.length - 1) text += "\n";
+			}
+			return new Text(text, 0, 0);
+		});
+		pi.registerTool({
+			name: "avenor_spawn",
+			label: "Avenor Spawn",
+			description: "Dispatch an agent run via avenor. Blocks by default, showing live progress. Set wait=false for fire-and-forget.",
+			promptSnippet: "Dispatch sub-agent runs via avenor (spawn, status, inspect, events, follow-up, shutdown)",
+			promptGuidelines: [
+				"Use avenor_spawn to delegate well-defined tasks to sub-agents.",
+				"Use avenor_status to check progress of fire-and-forget runs.",
+				"Use avenor_inspect to review a bounded transcript, tools, and final output from a run.",
+				"Use avenor_events only when raw event payloads are specifically needed.",
+				"Use avenor_follow_up to iterate on a completed run.",
+				"Use avenor_shutdown when done delegating work."
+			],
+			parameters: Type.Object({
+				agent: Type.String({ description: "Agent name (required, no default)" }),
+				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)" })),
+				label: Type.Optional(Type.String({ description: "Human-readable label for the run" })),
+				timeout: Type.Optional(Type.String({ description: "Timeout duration (e.g. 3600s)" })),
+				model: Type.Optional(Type.String({ description: "Model override" })),
+				backend: Type.Optional(Type.String({ description: "Backend override" })),
+				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)" }))
+			}),
+			async execute(_toolCallId, params, signal, onUpdate, ctx) {
+				if (signal?.aborted) return { content: [{
+					type: "text",
+					text: "Cancelled"
+				}] };
+				const wait = params.wait ?? true;
+				const dir = params.dir ?? ctx.cwd;
+				const label = params.label ?? `${params.agent}-${Date.now()}`;
+				const result = await deps.spawnTool({
+					agent: params.agent,
+					prompt: params.prompt,
+					promptFile: params.prompt_file,
+					label,
+					dir,
+					timeout: params.timeout,
+					model: params.model,
+					backend: params.backend,
+					serverUrl: params.server_url,
+					supervisorId: params.supervisor_id
+				});
+				const supervisorId = statusSupervisorId(params.supervisor_id, result.supervisor_id);
+				const runRef = {
+					runId: result.run_id,
+					agent: params.agent,
+					label,
+					supervisorId,
+					runtimeId: result.runtime_id
+				};
+				upsertTrackedRun(runRef, void 0, wait);
+				startPolling();
+				if (!wait) return {
 					content: [{
 						type: "text",
-						text: `[blocked] ${label} — permission: ${status.pending_permission.description}`
+						text: `Dispatched "${label}" (run_id: ${result.run_id}). Call avenor_status to check progress or avenor_inspect for a bounded transcript snapshot.`
 					}],
 					details: {
-						status: "permission",
+						run_id: result.run_id,
+						label
+					}
+				};
+				onUpdate?.({
+					content: [{
+						type: "text",
+						text: `Starting ${label}…`
+					}],
+					details: {
+						status: "running",
 						run_id: result.run_id
 					}
 				});
-				else {
-					let lastAction = "";
-					if (!params.supervisor_id) try {
-						const eventsResult = await eventsTool({
-							runId: result.run_id,
-							limit: 3
-						});
-						const last = eventsResult.events[eventsResult.events.length - 1];
-						if (last) lastAction = summarizeEvent(last);
-					} catch (err) {
-						console.error("avenor spawn poll: eventsTool failed", err);
-					}
-					onUpdate?.({
+				const waitResult = await waitForRun(runRef, signal, onUpdate);
+				if (waitResult.aborted) {
+					trackedRuns.delete(result.run_id);
+					return {
 						content: [{
 							type: "text",
-							text: `${label}${status.phase_label ? ` (${status.phase_label})` : ""}${lastAction ? ` — ${lastAction}` : ""}`
+							text: `Monitoring of "${label}" (run_id: ${result.run_id}) was interrupted. Use avenor_status or avenor_inspect to check.`
 						}],
-						details: {
-							status: status.status,
-							run_id: result.run_id,
-							lastAction
-						}
-					});
+						details: { run_id: result.run_id }
+					};
 				}
+				const status = waitResult.status;
+				if (!status) return {
+					content: [{
+						type: "text",
+						text: `Sub-agent "${label}" is still running. Use avenor_status or avenor_inspect to check progress.`
+					}],
+					details: {
+						status: "running",
+						run_id: result.run_id
+					}
+				};
+				upsertTrackedRun(runRef, status, wait);
 				if (status.status === "waiting") {
 					const tracked = trackedRuns.get(result.run_id);
 					if (tracked) tracked.permissionNotified = true;
@@ -450,7 +1185,11 @@ async function src_default(pi) {
 						}
 					};
 				}
-				if (TERMINAL_STATUSES.has(status.status)) {
+				if (isTerminalStatus(status.status)) {
+					const finalOutput = await resolveFinalOutput({
+						runId: result.run_id,
+						supervisorId
+					}, status);
 					trackedRuns.delete(result.run_id);
 					return {
 						content: [{
@@ -458,286 +1197,292 @@ async function src_default(pi) {
 							text: buildCompletionText({
 								runId: result.run_id,
 								label
-							}, status)
+							}, status, finalOutput)
 						}],
 						details: {
 							status: status.status,
 							run_id: result.run_id,
-							session_id: status.session_id
+							session_id: status.session_id,
+							final_output: finalOutput
 						}
 					};
 				}
+				return {
+					content: [{
+						type: "text",
+						text: `${label} is ${status.status}. Use avenor_status or avenor_inspect to check progress.`
+					}],
+					details: {
+						status: status.status,
+						run_id: result.run_id
+					}
+				};
+			},
+			renderCall(args, theme) {
+				const agent = theme.fg("toolTitle", theme.bold("avenor_spawn "));
+				const agentName = theme.fg("accent", args.agent);
+				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);
+			},
+			renderResult(result, { isPartial }, theme) {
+				if (isPartial) {
+					const status = result.details?.status ?? "running";
+					const emoji = statusEmoji(String(status));
+					return new Text(theme.fg("accent", `${emoji} ${result.content?.[0]?.text ?? "Running…"}`), 0, 0);
+				}
+				const status = String(result.details?.status ?? "");
+				if (status && isTerminalStatus(status)) {
+					const emoji = statusEmoji(status);
+					return new Text(`${theme.fg(status === "done" ? "success" : "error", `${emoji} ${status}`)}\n${(result.content?.[0]?.text ?? "").split("\n").map((line) => theme.fg("muted", `  ${line}`)).join("\n")}`, 0, 0);
+				}
+				return new Text((result.content?.[0]?.text ?? "").split("\n").map((line) => theme.fg("muted", line)).join("\n"), 0, 0);
 			}
-			trackedRuns.delete(result.run_id);
-			return {
-				content: [{
-					type: "text",
-					text: `Monitoring of "${label}" (run_id: ${result.run_id}) was interrupted. Use avenor_status to check.`
-				}],
-				details: { run_id: result.run_id }
-			};
-		},
-		renderCall(args, theme) {
-			const agent = theme.fg("toolTitle", theme.bold("avenor_spawn "));
-			const agentName = theme.fg("accent", args.agent);
-			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);
-		},
-		renderResult(result, { isPartial }, theme) {
-			if (isPartial) {
-				const emoji = statusEmoji(result.details?.status ?? "running");
-				return new Text(theme.fg("info", `${emoji} ${result.content?.[0]?.text ?? "Running…"}`), 0, 0);
-			}
-			const status = result.details?.status;
-			if (status && TERMINAL_STATUSES.has(status)) {
-				const emoji = statusEmoji(status);
-				const header = theme.fg(status === "done" ? "success" : "error", `${emoji} ${status}`);
-				const lines = (result.content?.[0]?.text ?? "").split("\n");
-				return new Text(header + "\n" + lines.map((l) => theme.fg("muted", `  ${l}`)).join("\n"), 0, 0);
+		});
+		pi.registerTool({
+			name: "avenor_status",
+			label: "Avenor Status",
+			description: "Get status of a run or all runs. Surfaces pending permission requests.",
+			parameters: Type.Object({
+				run_id: Type.Optional(Type.String({ description: "Specific run ID to query" })),
+				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
+			}),
+			async execute(_toolCallId, params) {
+				const result = await deps.statusTool({
+					runId: params.run_id,
+					supervisorId: params.supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
 			}
-			return new Text((result.content?.[0]?.text ?? "").split("\n").map((l) => theme.fg("muted", l)).join("\n"), 0, 0);
-		}
-	});
-	pi.registerTool({
-		name: "avenor_status",
-		label: "Avenor Status",
-		description: "Get status of a run or all runs. Surfaces pending permission requests.",
-		parameters: Type.Object({
-			run_id: Type.Optional(Type.String({ description: "Specific run ID to query" })),
-			supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
-		}),
-		async execute(_toolCallId, params) {
-			const result = await statusTool({
-				runId: params.run_id,
-				supervisorId: params.supervisor_id
-			});
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}],
-				details: result
-			};
-		}
-	});
-	pi.registerTool({
-		name: "avenor_answer_permission",
-		label: "Avenor Answer Permission",
-		description: "Answer a pending permission request for a sub-agent. Pass option_id from avenor_status pending_permission.options.",
-		parameters: Type.Object({
-			run_id: Type.String({ description: "Run ID with the pending permission" }),
-			option_id: Type.String({ description: "allow_once | allow_always | deny" }),
-			request_id: Type.Optional(Type.String({ description: "Permission request ID (auto-discovered if omitted)" })),
-			supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
-		}),
-		async execute(_toolCallId, params) {
-			const result = await answerPermissionTool({
-				runId: params.run_id,
-				optionId: params.option_id,
-				requestId: params.request_id,
-				supervisorId: params.supervisor_id
-			});
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}],
-				details: result
-			};
-		}
-	});
-	pi.registerTool({
-		name: "avenor_follow_up",
-		label: "Avenor Follow Up",
-		description: "Resume a completed run with a follow-up message.",
-		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" }))
-		}),
-		async execute(_toolCallId, params) {
-			const result = await followUpTool({
-				runId: params.run_id,
-				message: params.message,
-				label: params.label,
-				supervisorId: params.supervisor_id
-			});
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}],
-				details: result
-			};
-		}
-	});
-	pi.registerTool({
-		name: "avenor_events",
-		label: "Avenor Events",
-		description: "Read events from a run. Filter by type. Returns last N events.",
-		parameters: Type.Object({
-			run_id: Type.String({ description: "Run ID to read events from" }),
-			types: Type.Optional(Type.Array(Type.String(), { description: "Filter by event types" })),
-			limit: Type.Optional(Type.Number({ description: "Max events to return (default 50)" })),
-			supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
-		}),
-		async execute(_toolCallId, params) {
-			const result = await eventsTool({
-				runId: params.run_id,
-				types: params.types,
-				limit: params.limit,
-				supervisorId: params.supervisor_id
-			});
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify(result, null, 2)
-				}],
-				details: result
-			};
-		}
-	});
-	pi.registerTool({
-		name: "avenor_shutdown",
-		label: "Avenor Shutdown",
-		description: "Shut down the avenor supervisor and clean up temp files.",
-		parameters: Type.Object({
-			supervisor_id: Type.Optional(Type.String({ description: "Supervisor to shut down (defaults to singleton)" })),
-			force: Type.Optional(Type.Boolean({ description: "Force shutdown instead of graceful" }))
-		}),
-		async execute(_toolCallId, params) {
-			await stopPolling();
-			trackedRuns.clear();
-			const result = await shutdownTool({
-				supervisorId: params.supervisor_id,
-				force: params.force
-			});
-			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();
-			if (entries.length === 0) {
-				ctx.ui.notify("No active avenor runs", "info");
-				return;
+		});
+		pi.registerTool({
+			name: "avenor_inspect",
+			label: "Avenor Inspect",
+			description: "Inspect a run with bounded snapshot, transcript, tool, permission, and final output details.",
+			parameters: Type.Object({
+				run_id: Type.String({ description: "Run ID to inspect" }),
+				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" })),
+				limit: Type.Optional(Type.Number({ description: "Replay event limit (default 128)" })),
+				after_seq: Type.Optional(Type.Number({ description: "Only include events after this sequence number" }))
+			}),
+			async execute(_toolCallId, params) {
+				const payload = buildInspectPayload(await deps.inspectTool({
+					runId: params.run_id,
+					supervisorId: params.supervisor_id,
+					limit: params.limit,
+					after_seq: params.after_seq
+				}));
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(payload, null, 2)
+					}],
+					details: payload
+				};
 			}
-			const lines = entries.map((e) => formatRunLine(e));
-			ctx.ui.setWidget("avenor-status-detail", lines);
-		}
-	});
-	pi.registerCommand("avenor-watch", {
-		description: "Open a live event feed for a run",
-		getArgumentCompletions: (prefix) => {
-			const items = Array.from(trackedRuns.values()).filter((r) => r.label.startsWith(prefix) || r.runId.startsWith(prefix)).map((r) => ({
-				value: r.runId,
-				label: `${r.label} (${r.runId.slice(0, 8)})`
-			}));
-			return items.length > 0 ? items : null;
-		},
-		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("avenor-watch requires TUI mode", "warning");
-				return;
+		});
+		pi.registerTool({
+			name: "avenor_answer_permission",
+			label: "Avenor Answer Permission",
+			description: "Answer a pending permission request for a sub-agent. Pass option_id from avenor_status pending_permission.options.",
+			parameters: Type.Object({
+				run_id: Type.String({ description: "Run ID with the pending permission" }),
+				option_id: Type.String({ description: "allow_once | allow_always | deny" }),
+				request_id: Type.Optional(Type.String({ description: "Permission request ID (auto-discovered if omitted)" })),
+				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
+			}),
+			async execute(_toolCallId, params) {
+				const result = await deps.answerPermissionTool({
+					runId: params.run_id,
+					optionId: params.option_id,
+					requestId: params.request_id,
+					supervisorId: params.supervisor_id
+				});
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
 			}
-			let runId = args?.trim();
-			if (!runId) {
-				const runList = Array.from(trackedRuns.values());
-				if (runList.length === 0) {
-					ctx.ui.notify("No tracked runs", "warning");
-					return;
+		});
+		pi.registerTool({
+			name: "avenor_follow_up",
+			label: "Avenor Follow Up",
+			description: "Resume a completed run with a follow-up message.",
+			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" }))
+			}),
+			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 rawStatus = await deps.statusTool({
+						runId: result.run_id,
+						supervisorId: params.supervisor_id
+					});
+					const status = Array.isArray(rawStatus) ? rawStatus[0] : rawStatus;
+					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);
 				}
-				const choices = runList.map((r) => r.runId);
-				const labels = runList.map((r) => `${r.label} (${r.runId.slice(0, 8)})`);
-				const idx = await ctx.ui.select("Watch run:", labels);
-				if (idx === null) return;
-				runId = choices[idx];
+				startPolling();
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
 			}
-			let watchActive = true;
-			const overlay = new EventFeedOverlay(runId);
-			try {
-				const { events } = await eventsTool({
-					runId,
-					limit: 50
+		});
+		pi.registerTool({
+			name: "avenor_events",
+			label: "Avenor Events",
+			description: "Read events from a run. Filter by type. Returns last N events.",
+			parameters: Type.Object({
+				run_id: Type.String({ description: "Run ID to read events from" }),
+				types: Type.Optional(Type.Array(Type.String(), { description: "Filter by event types" })),
+				limit: Type.Optional(Type.Number({ description: "Max events to return (default 50)" })),
+				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" }))
+			}),
+			async execute(_toolCallId, params) {
+				const result = await deps.eventsTool({
+					runId: params.run_id,
+					types: params.types,
+					limit: params.limit,
+					supervisorId: params.supervisor_id
 				});
-				overlay.setEvents(events);
-			} catch (err) {
-				console.error("avenor watch: failed to load initial events", err);
-				overlay.setEvents([]);
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(result, null, 2)
+					}],
+					details: result
+				};
 			}
-			const handle = ctx.ui.custom((_tui, _theme, _kb, done) => {
-				overlay.setOnClose(() => {
-					watchActive = false;
-					done();
+		});
+		pi.registerTool({
+			name: "avenor_shutdown",
+			label: "Avenor Shutdown",
+			description: "Shut down the avenor supervisor and clean up temp files.",
+			parameters: Type.Object({
+				supervisor_id: Type.Optional(Type.String({ description: "Supervisor to shut down (defaults to singleton)" })),
+				force: Type.Optional(Type.Boolean({ description: "Force shutdown instead of graceful" }))
+			}),
+			async execute(_toolCallId, params) {
+				await stopPolling();
+				trackedRuns.clear();
+				const result = await deps.shutdownTool({
+					supervisorId: params.supervisor_id,
+					force: params.force
 				});
-				return overlay;
-			}, {
-				overlay: true,
-				overlayOptions: {
-					anchor: "right-center",
-					width: "45%",
-					minWidth: 60,
-					maxHeight: "70%"
-				},
-				onHandle: (h) => {
-					handle._inner = h;
+				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();
+				if (entries.length === 0) {
+					ctx.ui.notify("No active avenor runs", "info");
+					return;
 				}
-			});
-			const watchTick = async () => {
-				while (watchActive) {
-					await sleep(POLL_INTERVAL_MS);
-					try {
-						const { events } = await eventsTool({
-							runId,
-							limit: 50
-						});
-						overlay.setEvents(events);
-						handle.requestRender?.();
-					} catch (err) {
-						console.error("avenor watch poll: eventsTool failed", err);
-						watchActive = false;
+				ctx.ui.setWidget("avenor-status-detail", entries.map((entry) => formatRunLine(entry)));
+			}
+		});
+		pi.registerCommand("avenor-watch", {
+			description: "Open a live run inspector for an avenor run",
+			getArgumentCompletions: (prefix) => {
+				const items = Array.from(trackedRuns.values()).filter((run) => run.label.startsWith(prefix) || run.runId.startsWith(prefix)).map((run) => ({
+					value: run.runId,
+					label: `${run.label} (${run.runId.slice(0, 8)})`
+				}));
+				return items.length > 0 ? items : null;
+			},
+			handler: async (args, ctx) => {
+				await openRunInspector(ctx, {
+					trackedRuns: Array.from(trackedRuns.values()).map(toWatchRunRef),
+					initialRunId: args?.trim() || void 0,
+					deps: {
+						...createWatchDeps(),
+						followUpRun: (run, text) => followUpTrackedRun(run, text)
+					},
+					onTrackRun: (run, status) => {
+						upsertTrackedRun(run, status, false);
+						if (status && !isTerminalStatus(status.status)) startPolling();
 					}
-				}
-			};
-			watchTick();
-		}
-	});
-	pi.registerCommand("avenor-cancel", {
-		description: "Cancel a running avenor sub-agent",
-		getArgumentCompletions: (prefix) => {
-			const items = Array.from(trackedRuns.values()).filter((r) => r.label.startsWith(prefix) || r.runId.startsWith(prefix)).map((r) => ({
-				value: r.runId,
-				label: `${r.label} (${r.runId.slice(0, 8)})`
-			}));
-			return items.length > 0 ? items : null;
-		},
-		handler: async (args, ctx) => {
-			if (!args?.trim()) {
-				ctx.ui.notify("Usage: /avenor-cancel <run_id>", "warning");
-				return;
+				});
 			}
-			const runId = args.trim();
-			const run = trackedRuns.get(runId);
-			const label = run?.label ?? runId;
-			if (!await ctx.ui.confirm("Cancel run", `Cancel "${label}" (${runId.slice(0, 8)})?`)) return;
-			try {
-				const { Supervisor } = await import("@dougbots/avenor-core");
-				await (await Supervisor.get()).getClient().cancel(run?.lastStatus?.runtime_id ?? run?.runtimeId ?? runId);
-				ctx.ui.notify(`Cancelled "${label}"`, "info");
-			} catch (err) {
-				ctx.ui.notify(`Failed to cancel: ${err instanceof Error ? err.message : String(err)}`, "error");
+		});
+		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.runId.startsWith(prefix)).map((run) => ({
+					value: run.runId,
+					label: `${run.label} (${run.runId.slice(0, 8)})`
+				}));
+				return items.length > 0 ? items : null;
+			},
+			handler: async (args, ctx) => {
+				if (!args?.trim()) {
+					ctx.ui.notify("Usage: /avenor-cancel <run_id>", "warning");
+					return;
+				}
+				const runId = args.trim();
+				const run = trackedRuns.get(runId);
+				const label = run?.label ?? runId;
+				const runtimeId = run?.runtimeId ?? run?.lastStatus?.runtime_id;
+				if (!runtimeId) {
+					ctx.ui.notify(`No runtime id available for "${label}"`, "warning");
+					return;
+				}
+				if (!await ctx.ui.confirm("Cancel run", `Cancel "${label}" (${runId.slice(0, 8)})?`)) return;
+				try {
+					await createWatchDeps().cancelRun(toWatchRunRef(run ?? {
+						runId,
+						agent: "unknown",
+						label,
+						startTime: Date.now()
+					}), runtimeId);
+					ctx.ui.notify(`Cancelled "${label}"`, "info");
+				} catch (err) {
+					ctx.ui.notify(`Failed to cancel: ${err instanceof Error ? err.message : String(err)}`, "error");
+				}
 			}
-		}
-	});
+		});
+	};
 }
+var src_default = createExtension();
 //#endregion
-export { src_default as default };
+export { buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, src_default as default, isTerminalStatus, renderStatusLines, statusSupervisorId };