@dougbots/avenor-pi 0.8.3 → 0.9.0

package/README.md

@@ -86,8 +86,9 @@ packages/pi/
 ├── package.json
 ├── tsdown.config.ts
 ├── src/
-│   ├── index.ts          # main extension (tools, commands, hooks, rendering)
-│   ├── types.ts          # shared types, status emoji mapping
+│   ├── index.ts          # main extension, tool registration, commands, and hooks
+│   ├── render.ts         # host-only tool-call and result presentation
+│   ├── types.ts          # shared types and status emoji mapping
 │   └── watch.ts          # EventFeedOverlay TUI component
 └── dist/
     └── index.js          # built output (loaded by pi)
@@ -128,12 +129,25 @@ Beyond the tools, the extension integrates with Pi's TUI and event system:
 - **Footer status** — active runs shown in the Pi footer bar
 - **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** — tool calls and results are rendered with status emojis and color-coded output
+- **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-watch <run_id>` — open a live event feed overlay
   - `/avenor-cancel <run_id>` — cancel a running sub-agent
 
+### Tool-result channels
+
+Pi returns JSON model content in `content[0].text` and structured `details` for
+all tools except `avenor_spawn`. The renderer creates themed, bounded summaries
+for display. It does not modify the underlying model content or the `details`
+object.
+
+Pi's rendered summaries sanitize and bound the output, events, and snapshot rows
+they display. Use `avenor_result`, `avenor_inspect`, or `avenor_events` for the
+corresponding data.
+
+MCP clients render their own results.
+
 ### Agent profiles
 
 The `avenor_spawn` tool accepts an optional `agent` parameter that maps to a named profile in pi's `agents.json`:

package/dist/index.d.ts

@@ -1,9 +1,13 @@
 import { InspectResult, StatusResult, Supervisor, answerPermissionTool, dial, eventsTool, followUpTool, inspectTool, observeRun, resultTool, shutdownTool, spawnTool, statusTool } from "@dougbots/avenor-core";
-import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { EventBus, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 //#region src/types.d.ts
 interface RunStatusEntry {
   runId: string;
+  /** Supervisor socket provided at spawn time for namespace scoping. */
+  supervisorId?: string;
+  /** Runtime ID scoped to the explicit or singleton supervisor. */
+  runtimeId?: string;
   label: string;
   status: string;
   phase?: string;
@@ -19,6 +23,64 @@ interface RunStatusEntry {
   nestedCount?: number;
 }
 //#endregion
+//#region src/events.d.ts
+/** Emitted when the official extension completes a polling cycle. */
+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";
+type AvenorRunStatus = Readonly<Omit<RunStatusEntry, 'supervisorId' | 'pid' | 'permissionDescription'> & {
+  supervisorKey: string;
+}>;
+interface PollCompletedPayload {
+  /** Status for each direct run tracked by the official extension. */
+  readonly entries: readonly AvenorRunStatus[];
+  /** Wall-clock timestamp in epoch milliseconds. */
+  readonly timestamp: number;
+  /** Monotonic counter for this official-extension instance. */
+  readonly generation: number;
+}
+interface RunTerminalPayload {
+  readonly runId: string;
+  /** Stable opaque scope for the explicit or singleton supervisor. */
+  readonly supervisorKey: string;
+  readonly runtimeId?: string;
+  readonly label: string;
+  readonly agent: string;
+  readonly status: string;
+  /** Number of active descendants when the run was removed, if available. */
+  readonly nestedCount?: number;
+  readonly backend?: string;
+}
+interface RunTerminalPayloadInput {
+  readonly runId: string;
+  /** Local supervisor socket, converted to an opaque supervisorKey. */
+  readonly supervisorId?: string;
+  readonly runtimeId?: string;
+  readonly label: string;
+  readonly agent: string;
+  readonly status: string;
+  readonly nestedCount?: number;
+  readonly backend?: string;
+}
+interface AvenorEventMap {
+  [CHANNEL_POLL_COMPLETED]: PollCompletedPayload;
+  [CHANNEL_RUN_TERMINAL]: RunTerminalPayload;
+}
+type AvenorEventChannel = keyof AvenorEventMap;
+type AvenorEventBus = Pick<EventBus, 'emit' | 'on'>;
+/** Emit an Avenor event with a type-checked payload. */
+declare function emitAvenorEvent<K extends AvenorEventChannel>(bus: Pick<EventBus, 'emit'>, event: K, data: AvenorEventMap[K]): void;
+/** Subscribe to an Avenor event and return Pi's unsubscribe function. */
+declare function onAvenorEvent<K extends AvenorEventChannel>(bus: Pick<EventBus, 'on'>, event: K, handler: (data: AvenorEventMap[K]) => void): () => void;
+/**
+ * Copy and freeze the selected fields exposed to companion consumers.
+ * Keep this allowlist explicit so future private RunStatusEntry fields are not
+ * included in the event accidentally.
+ */
+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;
+//#endregion
 //#region src/index.d.ts
 interface ExtensionDeps {
   spawnTool: typeof spawnTool;
@@ -45,4 +107,4 @@ declare function buildInspectPayload(result: InspectResult): Record<string, unkn
 declare function createExtension(deps?: ExtensionDeps): (pi: ExtensionAPI) => Promise<void>;
 declare const _default: (pi: ExtensionAPI) => Promise<void>;
 //#endregion
-export { ExtensionDeps, buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, _default as default, isTerminalStatus, renderStatusLines, statusSupervisorId };
+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 };

package/dist/index.js

@@ -1,15 +1,16 @@
 import { Input, Key, Text, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { Supervisor, answerPermissionTool, dial, eventsTool, followUpTool, inspectTool, observeRun, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool } from "@dougbots/avenor-core";
+import { Supervisor, answerPermissionTool, dial, eventsTool, extractEventText, followUpTool, inspectTool, observeRun, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool } from "@dougbots/avenor-core";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { createHash } from "node:crypto";
 //#region src/watch.ts
 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 FINAL_OUTPUT_CHARS$1 = 600;
 const TRANSCRIPT_PADDING = 2;
 const INSPECT_ERROR_PREFIX = "error: ";
 const TERMINAL_STATUSES$1 = new Set([
@@ -90,7 +91,7 @@ function usageSummary(usage) {
 	return parts.join(" · ");
 }
 function finalOutputPreview(status, snapshot) {
-	return clipText(status?.final_output ?? snapshot?.final_output ?? snapshot?.assistant_text, FINAL_OUTPUT_CHARS);
+	return clipText(status?.final_output ?? snapshot?.final_output ?? snapshot?.assistant_text, FINAL_OUTPUT_CHARS$1);
 }
 function currentStatusWord(status, snapshot) {
 	const raw = status?.status?.toLowerCase();
@@ -702,6 +703,521 @@ function resolveAgentProfile(entries, environment = process.env) {
 	return selected;
 }
 //#endregion
+//#region src/events.ts
+/**
+* Public telemetry types and adapters for companion Pi extensions.
+*
+* The transport is Pi's shared `pi.events` bus. This module owns no event
+* handlers or singleton state, so consumers can use the surface even when
+* package dependencies are resolved from different module instances.
+*
+* Payloads select status fields and omit transcripts, final output, directories,
+* socket paths, raw status objects, and tool arguments.
+*/
+/** Emitted when the official extension completes a polling cycle. */
+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. */
+function createSupervisorKey(supervisorId) {
+	if (!supervisorId) return "singleton";
+	return `supervisor:${createHash("sha256").update(supervisorId).digest("hex").slice(0, 16)}`;
+}
+/** Emit an Avenor event with a type-checked payload. */
+function emitAvenorEvent(bus, event, data) {
+	bus.emit(event, data);
+}
+/** Subscribe to an Avenor event and return Pi's unsubscribe function. */
+function onAvenorEvent(bus, event, handler) {
+	return bus.on(event, handler);
+}
+/**
+* Copy and freeze the selected fields exposed to companion consumers.
+* Keep this allowlist explicit so future private RunStatusEntry fields are not
+* included in the event accidentally.
+*/
+function createPollCompletedPayload(entries, timestamp, generation) {
+	const publicEntries = entries.map((entry) => Object.freeze({
+		runId: entry.runId,
+		supervisorKey: createSupervisorKey(entry.supervisorId),
+		...entry.runtimeId !== void 0 && { runtimeId: entry.runtimeId },
+		label: entry.label,
+		status: entry.status,
+		...entry.phase !== void 0 && { phase: entry.phase },
+		...entry.phaseLabel !== void 0 && { phaseLabel: entry.phaseLabel },
+		agent: entry.agent,
+		...entry.pendingPermission !== void 0 && { pendingPermission: entry.pendingPermission },
+		...entry.backend !== void 0 && { backend: entry.backend },
+		...entry.nestedCount !== void 0 && { nestedCount: entry.nestedCount }
+	}));
+	return Object.freeze({
+		entries: Object.freeze(publicEntries),
+		timestamp,
+		generation
+	});
+}
+/** Copy and freeze a terminal payload before publishing it. */
+function createRunTerminalPayload(payload) {
+	return Object.freeze({
+		runId: payload.runId,
+		supervisorKey: createSupervisorKey(payload.supervisorId),
+		...payload.runtimeId !== void 0 && { runtimeId: payload.runtimeId },
+		label: payload.label,
+		agent: payload.agent,
+		status: payload.status,
+		...payload.nestedCount !== void 0 && { nestedCount: payload.nestedCount },
+		...payload.backend !== void 0 && { backend: payload.backend }
+	});
+}
+//#endregion
+//#region src/render.ts
+const FINAL_OUTPUT_CHARS = 600;
+const SCALAR_CHARS = 240;
+const EVENT_CHARS = 600;
+const PREVIEW_LINES = 12;
+const STATUS_ROWS = 12;
+const COLLECTION_ITEMS = 8;
+const INSPECT_ITEMS = 5;
+const CLEANUP_ITEMS = 8;
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function numberValue(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) return Number(value);
+}
+function itemMarker(count) {
+	return `… ${count} items omitted`;
+}
+function lineMarker(count) {
+	return `… ${count} lines omitted`;
+}
+function characterMarker(count) {
+	return `[preview clipped: ${count} characters omitted]`;
+}
+function cleanMultiline(value) {
+	if (typeof value !== "string") return void 0;
+	return sanitizeText(value).trim() || void 0;
+}
+function leadingClip(value, limit) {
+	if (value.length <= limit) return { text: value };
+	let prefixLength = Math.max(0, limit - characterMarker(value.length).length);
+	for (let attempt = 0; attempt < 3; attempt++) {
+		const omitted = value.length - prefixLength;
+		const nextPrefixLength = Math.max(0, limit - characterMarker(omitted).length);
+		if (nextPrefixLength === prefixLength) break;
+		prefixLength = nextPrefixLength;
+	}
+	const clipped = clipText(value, Math.max(1, prefixLength + 1)) ?? "";
+	const text = clipped.endsWith("…") ? clipped.slice(0, -1) : clipped.slice(0, prefixLength);
+	return {
+		text,
+		omitted: value.length - text.length
+	};
+}
+function scalar(value, fallback = "unknown", limit = SCALAR_CHARS) {
+	const clean = cleanMultiline(typeof value === "string" ? value : void 0);
+	if (!clean) return fallback;
+	const clipped = leadingClip(clean.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim(), limit);
+	return clipped.omitted === void 0 ? clipped.text : `${clipped.text}${characterMarker(clipped.omitted)}`;
+}
+function optionalScalar(value, limit = SCALAR_CHARS) {
+	const clean = cleanMultiline(typeof value === "string" ? value : void 0);
+	return clean ? scalar(clean, "unknown", limit) : void 0;
+}
+function preview(value, limit) {
+	const clean = cleanMultiline(value);
+	if (!clean) return void 0;
+	const clipped = leadingClip(clean, limit);
+	const lines = clipped.text.split("\n").slice(0, PREVIEW_LINES);
+	const omittedLines = Math.max(0, clean.split("\n").length - lines.length);
+	return [
+		...lines,
+		...clipped.omitted === void 0 ? [] : [characterMarker(clipped.omitted)],
+		...omittedLines === 0 ? [] : [lineMarker(omittedLines)]
+	];
+}
+function quoted(value) {
+	return `"${scalar(value).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+function optionalQuoted(value) {
+	return stringValue(value) ? quoted(value) : void 0;
+}
+function optionalNumber(value) {
+	return numberValue(value) === void 0 ? void 0 : String(numberValue(value));
+}
+function selected(record, key, fallback, defaultValue = "unknown") {
+	return scalar(stringValue(record?.[key]) ?? stringValue(fallback), defaultValue);
+}
+function selectedOptional(record, key) {
+	return optionalScalar(record?.[key]);
+}
+function hasStatusIdentity(record) {
+	return !!record && !!(stringValue(record.run_id) || stringValue(record.label) || stringValue(record.status));
+}
+function linesText(lines, theme) {
+	return new Text(lines.map((line, index) => theme.fg(index === 0 ? "toolTitle" : "muted", index === 0 ? theme.bold(line) : line)).join("\n"), 0, 0);
+}
+function fallback(tool) {
+	return [`Avenor ${tool} result unavailable.`, "Retry the tool or use avenor_status/avenor_inspect."];
+}
+function partial(result) {
+	const details = asRecord(result.details);
+	const label = optionalScalar(details?.label);
+	const status = optionalScalar(details?.status);
+	if (label && status) return [`Working: ${label} — ${status}`];
+	if (status) return [`Working: ${status}`];
+	if (label) return [`Working: ${label}`];
+	const content = result.content?.[0]?.text;
+	const firstLine = typeof content === "string" ? content.split(/\r?\n/).find((line) => line.trim()) : void 0;
+	if (firstLine) {
+		const clean = scalar(firstLine, "", SCALAR_CHARS);
+		if (clean && !clean.startsWith("{") && !clean.startsWith("[")) return [`Working: ${clean}`];
+	}
+	return ["Working…"];
+}
+function isTerminal(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+function permission(record) {
+	return asRecord(record?.pending_permission);
+}
+function permissionOptions(record) {
+	const options = record?.options;
+	return Array.isArray(options) ? options.map(asRecord).filter((value) => !!value) : [];
+}
+function optionRows(options) {
+	return options.slice(0, COLLECTION_ITEMS).map((option) => `${selected(option, "option_id")} (${selected(option, "label")})`).join(", ");
+}
+function optionLine(prefix, options) {
+	const rows = optionRows(options);
+	const omitted = options.length - Math.min(options.length, COLLECTION_ITEMS);
+	return `${prefix}${rows ? ` ${rows}` : ""}${omitted > 0 ? `${rows ? " " : " "}${itemMarker(omitted)}` : ""}`;
+}
+function guidance(status, pending, runId) {
+	if (status === "waiting") {
+		const options = permissionOptions(pending);
+		if (options.length > 0) return `Guidance: Call avenor_answer_permission with run_id "${runId}" and option_id "${selected(options[0], "option_id")}".`;
+		if (pending) return `Guidance: Permission input is required, but no options are available; call avenor_inspect with run_id "${runId}".`;
+		return `Guidance: Call avenor_follow_up or avenor_status with run_id "${runId}".`;
+	}
+	if (isTerminal(status)) return `Guidance: Call avenor_result or avenor_events with run_id "${runId}".`;
+	return `Guidance: Call avenor_result with run_id "${runId}".`;
+}
+function statusExpanded(status) {
+	return [
+		["Phase", "phase"],
+		["Phase label", "phase_label"],
+		["Session", "session_id"],
+		["Backend", "backend"],
+		["Agent", "agent"],
+		["Model", "model"],
+		["Latest sequence", "latest_seq"],
+		["Stop reason", "stop_reason"]
+	].flatMap(([label, key]) => {
+		const value = key === "latest_seq" ? optionalNumber(status[key]) : selectedOptional(status, key);
+		return value === void 0 ? [] : [`${label}: ${value}`];
+	});
+}
+function statusLines(details, args, expanded) {
+	if (Array.isArray(details)) {
+		const statuses = details.map(asRecord);
+		if (statuses.some((status) => !hasStatusIdentity(status))) return void 0;
+		const displayed = statuses.slice(0, STATUS_ROWS);
+		const lines = [
+			`Avenor status — ${statuses.length} runs`,
+			...displayed.map((status) => {
+				const runId = selected(status, "run_id", args.run_id);
+				return `${selected(status, "label", void 0, runId)} — ${selected(status, "status")} (run_id: ${runId})`;
+			}),
+			...statuses.length > displayed.length ? [itemMarker(statuses.length - displayed.length)] : []
+		];
+		if (!expanded) return lines;
+		for (const status of displayed) {
+			const runId = selected(status, "run_id", args.run_id);
+			lines.push(`Run: ${runId}`, `Label: ${selected(status, "label", void 0, runId)}`, `Status: ${selected(status, "status")}`, ...statusExpanded(status));
+		}
+		return lines;
+	}
+	const status = asRecord(details);
+	if (!hasStatusIdentity(status)) return void 0;
+	const runId = selected(status, "run_id", args.run_id);
+	const label = selected(status, "label", void 0, runId);
+	const state = selected(status, "status");
+	const pending = permission(status);
+	const options = permissionOptions(pending);
+	const finalPreview = preview(status.final_output, FINAL_OUTPUT_CHARS);
+	const lines = [
+		`Status: ${label} — ${state}`,
+		`Run: ${runId}`,
+		...pending ? [`Permission: ${selected(pending, "description")}`, optionLine("Options:", options)] : [],
+		...status.final_output_truncated === true ? [`Warning: final output preview is truncated; call avenor_result with run_id "${runId}".`] : [],
+		...finalPreview ? ["Final output:", ...finalPreview] : ["Final output: unavailable."],
+		guidance(state, pending, runId)
+	];
+	return expanded ? [...lines, ...statusExpanded(status)] : lines;
+}
+function resultLines(details, args, expanded) {
+	const result = asRecord(details);
+	if (!hasStatusIdentity(result)) return void 0;
+	const runId = selected(result, "run_id", args.run_id);
+	const label = selected(result, "label", void 0, runId);
+	const state = selected(result, "status");
+	const pending = permission(result);
+	const finalPreview = preview(result.output, FINAL_OUTPUT_CHARS);
+	const lines = [
+		`Result: ${label} — ${state}`,
+		`Run: ${runId}`,
+		...result.timed_out === true ? ["Warning: wait timed out; the run is still active."] : [],
+		...pending ? [`Permission: ${selected(pending, "description")}`] : [],
+		guidance(state, pending, runId),
+		...result.output_truncated === true ? [stringValue(result.output_event_path) ? `Warning: final output may be truncated; retry avenor_result or read the durable event path "${scalar(result.output_event_path)}".` : `Warning: final output may be truncated; call avenor_events with run_id "${runId}".`] : [],
+		...finalPreview ? ["Final output:", ...finalPreview] : ["Final output: unavailable."]
+	];
+	if (!expanded) return lines;
+	const session = selectedOptional(result, "session_id");
+	const stopReason = selectedOptional(result, "stop_reason");
+	return [
+		...lines,
+		...session ? [`Session: ${session}`] : [],
+		...stopReason ? [`Stop reason: ${stopReason}`] : []
+	];
+}
+function permissionLines(details, args) {
+	const result = asRecord(details);
+	if (!result || typeof result.ok !== "boolean") return void 0;
+	const runId = scalar(args.run_id);
+	return [
+		`Permission answer: ${result.ok ? "accepted" : "failed"}.`,
+		`Run: ${runId}`,
+		`Option: ${scalar(args.option_id)}`,
+		...stringValue(args.request_id) ? [`Request: ${scalar(args.request_id)}`] : [],
+		`Guidance: Call avenor_status with run_id "${runId}" to verify the permission state.`
+	];
+}
+function followUpLines(details, args) {
+	const result = asRecord(details);
+	if (!result || !stringValue(result.run_id) || !stringValue(result.label)) return void 0;
+	const runId = selected(result, "run_id", args.run_id);
+	const label = selected(result, "label", args.label, runId);
+	return [
+		`Follow-up: ${label} — dispatched.`,
+		`Source run: ${scalar(args.run_id)}`,
+		`Run: ${runId}`,
+		`Label: ${label}`,
+		`Guidance: Call avenor_status with run_id "${runId}".`
+	];
+}
+function eventSequence(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	return typeof value === "string" && value.trim() && Number.isFinite(Number(value)) ? value : void 0;
+}
+function eventRow(value) {
+	const name = stringValue(value.event) ?? stringValue(value.type) ?? "unknown";
+	const sequence = eventSequence(value.seq);
+	const text = extractEventText(value);
+	const previewText = text ? scalar(text, "unknown", EVENT_CHARS) : void 0;
+	return `Event ${sequence ?? "?"}: ${scalar(name)}${previewText ? ` — ${previewText}` : ""}`;
+}
+function eventsLines(details, args, expanded) {
+	const result = asRecord(details);
+	if (!result || !Array.isArray(result.events) || result.events.some((event) => !asRecord(event))) return void 0;
+	const events = result.events.map((event) => event);
+	const runId = scalar(args.run_id);
+	const types = Array.isArray(args.types) ? args.types : [];
+	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;
+	const displayed = events.slice(0, STATUS_ROWS);
+	lines.push(...displayed.map(eventRow));
+	if (events.length > displayed.length) lines.push(itemMarker(events.length - displayed.length));
+	return lines;
+}
+function inspectTranscriptRow(value) {
+	const kind = stringValue(value.kind);
+	const text = optionalScalar(value.text);
+	if (!kind) return void 0;
+	if (kind === "tool") {
+		const title = selected(value, "title", stringValue(value.kind) ?? stringValue(value.key));
+		const status = optionalScalar(value.status);
+		return `${title}${status ? ` (${status})` : ""}${text ? `: ${text}` : ""}`;
+	}
+	if (!text) return void 0;
+	if ([
+		"assistant",
+		"thought",
+		"user",
+		"permission",
+		"status",
+		"session"
+	].includes(kind)) return `${kind}: ${text}`;
+}
+function inspectToolRow(prefix, value) {
+	const title = selected(value, "title", stringValue(value.kind) ?? stringValue(value.key));
+	const status = optionalScalar(value.status);
+	const text = optionalScalar(value.preview);
+	return `${prefix}: ${title}${status ? ` (${status})` : ""}${text ? `: ${text}` : ""}`;
+}
+function inspectPermissionRow(value) {
+	const description = scalar(stringValue(value.description) ?? stringValue(value.question) ?? stringValue(value.tool) ?? stringValue(value.kind));
+	const options = permissionOptions(value);
+	const rows = optionRows(options);
+	return `Permission: ${description} (request_id: ${selected(value, "request_id")}); options:${rows ? ` ${rows}` : ""}${options.length > COLLECTION_ITEMS ? ` ${itemMarker(options.length - COLLECTION_ITEMS)}` : ""}`;
+}
+function inspectGroup(title, values, row) {
+	const rows = (Array.isArray(values) ? values.map(asRecord).filter((value) => !!value) : []).map(row).filter((value) => !!value);
+	return [
+		`${title}:`,
+		...rows.slice(0, INSPECT_ITEMS),
+		...rows.length > INSPECT_ITEMS ? [itemMarker(rows.length - INSPECT_ITEMS)] : []
+	];
+}
+function inspectLines(details, args, expanded) {
+	const inspect = asRecord(details);
+	const status = asRecord(inspect?.status);
+	if (!inspect || !status || !hasStatusIdentity(inspect) && !hasStatusIdentity(status)) return void 0;
+	const runId = selected(inspect, "run_id", args.run_id);
+	const label = selected(inspect, "label", void 0, runId);
+	const state = selected(status, "status");
+	const finalPreview = preview(inspect.final_output, FINAL_OUTPUT_CHARS);
+	const transcript = Array.isArray(inspect.transcript) ? inspect.transcript : [];
+	const tools = Array.isArray(inspect.tools) ? inspect.tools : [];
+	const liveTools = Array.isArray(inspect.live_tools) ? inspect.live_tools : [];
+	const permissions = Array.isArray(inspect.permissions) ? inspect.permissions : [];
+	const lines = [
+		`Inspect: ${label} — ${state}`,
+		`Run: ${runId}`,
+		`Counts: transcript=${transcript.length}, tools=${tools.length}, live_tools=${liveTools.length}, permissions=${permissions.length}`,
+		...finalPreview ? ["Final output:", ...finalPreview] : ["Final output: unavailable."],
+		`Guidance: Call avenor_events with run_id "${runId}" for raw events.`
+	];
+	if (!expanded) return lines;
+	return [
+		...lines,
+		...inspectGroup("Transcript", transcript, inspectTranscriptRow),
+		...inspectGroup("Tools", tools, (value) => inspectToolRow("Tool", value)),
+		...inspectGroup("Live tools", liveTools, (value) => inspectToolRow("Live tool", value)),
+		...inspectGroup("Permissions", permissions, inspectPermissionRow)
+	];
+}
+function shutdownLines(details, args, expanded) {
+	const result = asRecord(details);
+	if (!result || typeof result.ok !== "boolean" || !Array.isArray(result.cleaned_up)) return void 0;
+	const paths = result.cleaned_up.filter((path) => typeof path === "string");
+	const supervisor = stringValue(args.supervisor_id) ? scalar(args.supervisor_id) : "singleton";
+	const lines = [
+		`Avenor shutdown: ${result.ok ? "succeeded" : "failed"}.`,
+		`Supervisor: ${supervisor}`,
+		`Mode: ${args.force === true ? "force" : "graceful"}`,
+		paths.length > 0 ? `Cleanup: ${paths.length} paths` : "Cleanup: none",
+		...!result.ok ? ["Warning: shutdown did not complete.", "Guidance: retry avenor_shutdown."] : []
+	];
+	if (!expanded) return lines;
+	return [
+		...lines,
+		...paths.slice(0, CLEANUP_ITEMS).map((path) => `Cleanup path: ${scalar(path)}`),
+		...paths.length > CLEANUP_ITEMS ? [itemMarker(paths.length - CLEANUP_ITEMS)] : []
+	];
+}
+function render(tool, result, options, theme, build) {
+	try {
+		return linesText(options.isPartial ? partial(result) : build() ?? fallback(tool), theme);
+	} catch {
+		return new Text(fallback(tool).join("\n"), 0, 0);
+	}
+}
+function renderStatusCall(args, theme) {
+	const pieces = stringValue(args.run_id) ? [`avenor_status run_id ${quoted(args.run_id)}`] : ["avenor_status (all runs)"];
+	const view = optionalQuoted(args.view);
+	const supervisor = optionalQuoted(args.supervisor_id);
+	if (view) pieces.push(`view ${view}`);
+	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+	return linesText([pieces.join(" ")], theme);
+}
+function renderResultCall(args, theme) {
+	const pieces = [`avenor_result run_id ${quoted(args.run_id)}`];
+	if (args.wait !== void 0) pieces.push(`wait=${args.wait}`);
+	const timeout = optionalQuoted(args.timeout);
+	const supervisor = optionalQuoted(args.supervisor_id);
+	if (timeout) pieces.push(`timeout ${timeout}`);
+	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+	return linesText([pieces.join(" ")], theme);
+}
+function renderInspectCall(args, theme) {
+	const pieces = [`avenor_inspect run_id ${quoted(args.run_id)}`];
+	const limit = optionalNumber(args.limit);
+	const afterSequence = optionalNumber(args.after_seq);
+	const supervisor = optionalQuoted(args.supervisor_id);
+	if (limit) pieces.push(`limit=${limit}`);
+	if (afterSequence) pieces.push(`after_seq=${afterSequence}`);
+	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+	return linesText([pieces.join(" ")], theme);
+}
+function renderAnswerPermissionCall(args, theme) {
+	const pieces = [`avenor_answer_permission run_id ${quoted(args.run_id)}`, `option_id ${quoted(args.option_id)}`];
+	const request = optionalQuoted(args.request_id);
+	const message = optionalQuoted(args.message);
+	const supervisor = optionalQuoted(args.supervisor_id);
+	if (request) pieces.push(`request_id ${request}`);
+	if (message) pieces.push(`message ${message}`);
+	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+	return linesText([pieces.join(" ")], theme);
+}
+function renderFollowUpCall(args, theme) {
+	const pieces = [`avenor_follow_up run_id ${quoted(args.run_id)}`, `message ${quoted(args.message)}`];
+	const label = optionalQuoted(args.label);
+	const supervisor = optionalQuoted(args.supervisor_id);
+	if (label) pieces.push(`label ${label}`);
+	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+	return linesText([pieces.join(" ")], theme);
+}
+function renderEventsCall(args, theme) {
+	const pieces = [`avenor_events run_id ${quoted(args.run_id)}`];
+	if (Array.isArray(args.types)) {
+		const shown = args.types.slice(0, COLLECTION_ITEMS).map(quoted).join(", ");
+		pieces.push(`types=[${shown}]${args.types.length > COLLECTION_ITEMS ? ` ${itemMarker(args.types.length - COLLECTION_ITEMS)}` : ""}`);
+	}
+	const limit = optionalNumber(args.limit);
+	const supervisor = optionalQuoted(args.supervisor_id);
+	if (limit) pieces.push(`limit=${limit}`);
+	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+	return linesText([pieces.join(" ")], theme);
+}
+function renderShutdownCall(args, theme) {
+	const pieces = ["avenor_shutdown"];
+	const supervisor = optionalQuoted(args.supervisor_id);
+	if (supervisor) pieces.push(`supervisor_id ${supervisor}`);
+	if (args.force !== void 0) pieces.push(`force=${args.force}`);
+	return linesText([pieces.join(" ")], theme);
+}
+function renderStatusResult(result, options, theme, args) {
+	return render("status", result, options, theme, () => statusLines(result.details, args, options.expanded));
+}
+function renderResultResult(result, options, theme, args) {
+	return render("result", result, options, theme, () => resultLines(result.details, args, options.expanded));
+}
+function renderInspectResult(result, options, theme, args) {
+	return render("inspect", result, options, theme, () => inspectLines(result.details, args, options.expanded));
+}
+function renderAnswerPermissionResult(result, options, theme, args) {
+	return render("answer_permission", result, options, theme, () => permissionLines(result.details, args));
+}
+function renderFollowUpResult(result, options, theme, args) {
+	return render("follow_up", result, options, theme, () => followUpLines(result.details, args));
+}
+function renderEventsResult(result, options, theme, args) {
+	return render("events", result, options, theme, () => eventsLines(result.details, args, options.expanded));
+}
+function renderShutdownResult(result, options, theme, args) {
+	return render("shutdown", result, options, theme, () => shutdownLines(result.details, args, options.expanded));
+}
+//#endregion
 //#region src/index.ts
 const POLL_INTERVAL_MS = 3e3;
 const INSPECT_LIMIT = 128;
@@ -837,11 +1353,25 @@ function toWatchRunRef(run) {
 }
 function createExtension(deps = defaultDeps) {
 	return async function(pi) {
+		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);
+		}
+		function clearRunPollingFailures(run) {
+			clearPollingFailure(`run-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
+			clearPollingFailure(`spawn-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
+		}
 		function upsertTrackedRun(run, status, blocking = false) {
 			const current = trackedRuns.get(run.runId);
 			trackedRuns.set(run.runId, {
@@ -877,17 +1407,21 @@ function createExtension(deps = defaultDeps) {
 				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) {
-				console.error("avenor pollRuns: failed to list singleton runs", err);
+				reportPollingFailure("singleton-list", "avenor pollRuns: failed to list singleton runs", err);
 			}
 			const entries = [];
 			for (const run of trackedRuns.values()) {
 				const live = findLiveStatusForTrackedRun(run, liveMap.values());
 				if (live) {
 					liveMap.delete(live.run_id);
+					clearPollingFailure(`run-status:${run.supervisorId ?? "singleton"}:${run.runId}`);
 					run.lastStatus = live;
 					entries.push({
 						runId: run.runId,
+						supervisorId: run.supervisorId,
+						runtimeId: live.runtime_id ?? run.runtimeId,
 						label: run.label,
 						status: live.status,
 						phase: live.phase,
@@ -907,9 +1441,12 @@ 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;
 					entries.push({
 						runId: run.runId,
+						supervisorId: run.supervisorId,
+						runtimeId: result.runtime_id ?? run.runtimeId,
 						label: run.label,
 						status: result.status,
 						phase: result.phase,
@@ -921,10 +1458,12 @@ function createExtension(deps = defaultDeps) {
 						backend: result.backend
 					});
 				} catch (err) {
-					console.error(`avenor pollRuns: statusTool failed for ${run.runId}`, err);
+					reportPollingFailure(`run-status:${run.supervisorId ?? "singleton"}:${run.runId}`, `avenor pollRuns: statusTool failed for ${run.runId}`, err);
 					const previous = run.lastStatus;
 					entries.push({
 						runId: run.runId,
+						supervisorId: run.supervisorId,
+						runtimeId: previous?.runtime_id ?? run.runtimeId,
 						label: run.label,
 						status: previous?.status ?? "unavailable",
 						phase: previous?.phase,
@@ -939,6 +1478,7 @@ function createExtension(deps = defaultDeps) {
 			}
 			for (const live of liveMap.values()) entries.push({
 				runId: live.run_id,
+				runtimeId: live.runtime_id,
 				label: live.label,
 				status: live.status,
 				phase: live.phase,
@@ -987,6 +1527,7 @@ function createExtension(deps = defaultDeps) {
 				});
 				if (!pollingActive || generation !== pollingGeneration) return;
 				updateWidget(entries);
+				emitAvenorEvent(pi.events, CHANNEL_POLL_COMPLETED, createPollCompletedPayload(entries, Date.now(), ++telemetryGeneration));
 				for (const entry of entries) {
 					const run = trackedRuns.get(entry.runId);
 					if (!run) continue;
@@ -1009,6 +1550,17 @@ function createExtension(deps = defaultDeps) {
 						} catch (err) {
 							console.error("avenor tick: sendUserMessage failed", err);
 						}
+						emitAvenorEvent(pi.events, CHANNEL_RUN_TERMINAL, createRunTerminalPayload({
+							runId: entry.runId,
+							supervisorId: entry.supervisorId,
+							runtimeId: entry.runtimeId,
+							label: entry.label,
+							agent: entry.agent,
+							status: entry.status,
+							nestedCount: entry.nestedCount,
+							backend: entry.backend
+						}));
+						clearRunPollingFailures(run);
 						trackedRuns.delete(entry.runId);
 					} else if (entry.pendingPermission && !run.blocking && !run.permissionNotified) {
 						run.permissionNotified = true;
@@ -1031,6 +1583,7 @@ function createExtension(deps = defaultDeps) {
 				}, POLL_INTERVAL_MS);
 				else {
 					pollingActive = false;
+					reportedPollingFailures.clear();
 					sessionCtx?.ui.setStatus("avenor", "");
 					sessionCtx?.ui.setWidget("avenor-status", void 0);
 				}
@@ -1043,6 +1596,7 @@ 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);
@@ -1215,6 +1769,7 @@ 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",
@@ -1230,7 +1785,7 @@ function createExtension(deps = defaultDeps) {
 						aborted: false
 					};
 				} catch (err) {
-					console.error("avenor spawn poll: statusTool failed", err);
+					reportPollingFailure(`spawn-status:${run.supervisorId ?? "singleton"}:${run.runId}`, "avenor spawn poll: statusTool failed", err);
 				}
 			}
 			return { aborted: true };
@@ -1273,7 +1828,7 @@ function createExtension(deps = defaultDeps) {
 		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.",
+			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.",
 			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.",
@@ -1292,6 +1847,15 @@ function createExtension(deps = defaultDeps) {
 				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" })),
+				thinking: Type.Optional(Type.Union([
+					Type.Literal("off"),
+					Type.Literal("minimal"),
+					Type.Literal("low"),
+					Type.Literal("medium"),
+					Type.Literal("high"),
+					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)" })),
 				server_url: Type.Optional(Type.String({ description: "Backend server URL" })),
 				supervisor_id: Type.Optional(Type.String({ description: "Reuse an existing supervisor by socket path" })),
@@ -1316,6 +1880,7 @@ function createExtension(deps = defaultDeps) {
 					dir,
 					timeout: params.timeout,
 					model: params.model,
+					thinking: params.thinking,
 					backend,
 					agentProfile,
 					serverUrl: params.server_url,
@@ -1353,6 +1918,7 @@ function createExtension(deps = defaultDeps) {
 				});
 				const waitResult = await waitForRun(runRef, signal, onUpdate);
 				if (waitResult.aborted) {
+					clearRunPollingFailures(runRef);
 					trackedRuns.delete(result.run_id);
 					return {
 						content: [{
@@ -1399,6 +1965,16 @@ function createExtension(deps = defaultDeps) {
 						runId: result.run_id,
 						supervisorId
 					}, status);
+					emitAvenorEvent(pi.events, CHANNEL_RUN_TERMINAL, createRunTerminalPayload({
+						runId: result.run_id,
+						supervisorId,
+						runtimeId: status.runtime_id ?? runRef.runtimeId,
+						label,
+						agent: params.agent,
+						status: status.status,
+						backend: status.backend
+					}));
+					clearRunPollingFailures(runRef);
 					trackedRuns.delete(result.run_id);
 					return {
 						content: [{
@@ -1474,6 +2050,15 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: result
 				};
+			},
+			renderCall(args, theme, context) {
+				return renderStatusCall(context.args, theme);
+			},
+			renderResult(result, { expanded, isPartial }, theme, context) {
+				return renderStatusResult(result, {
+					expanded,
+					isPartial
+				}, theme, context.args);
 			}
 		});
 		pi.registerTool({
@@ -1500,8 +2085,21 @@ function createExtension(deps = defaultDeps) {
 						signal
 					});
 					completed = result.ready;
-					if (completed) trackedRuns.delete(params.run_id);
-					else if (tracked && result.status === "waiting") tracked.permissionNotified = true;
+					if (completed) {
+						emitAvenorEvent(pi.events, CHANNEL_RUN_TERMINAL, createRunTerminalPayload({
+							runId: params.run_id,
+							supervisorId: tracked?.supervisorId ?? params.supervisor_id,
+							runtimeId: tracked?.runtimeId ?? result.runtime_id,
+							label: tracked?.label ?? result.label ?? params.run_id,
+							agent: tracked?.agent ?? "unknown",
+							status: result.status ?? "done"
+						}));
+						clearRunPollingFailures({
+							runId: params.run_id,
+							supervisorId: tracked?.supervisorId ?? params.supervisor_id
+						});
+						trackedRuns.delete(params.run_id);
+					} else if (tracked && result.status === "waiting") tracked.permissionNotified = true;
 					return {
 						content: [{
 							type: "text",
@@ -1512,6 +2110,15 @@ function createExtension(deps = defaultDeps) {
 				} finally {
 					if (!completed && tracked && trackedRuns.get(params.run_id) === tracked) tracked.blocking = previousBlocking ?? false;
 				}
+			},
+			renderCall(args, theme, context) {
+				return renderResultCall(context.args, theme);
+			},
+			renderResult(result, { expanded, isPartial }, theme, context) {
+				return renderResultResult(result, {
+					expanded,
+					isPartial
+				}, theme, context.args);
 			}
 		});
 		pi.registerTool({
@@ -1538,6 +2145,15 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: payload
 				};
+			},
+			renderCall(args, theme, context) {
+				return renderInspectCall(context.args, theme);
+			},
+			renderResult(result, { expanded, isPartial }, theme, context) {
+				return renderInspectResult(result, {
+					expanded,
+					isPartial
+				}, theme, context.args);
 			}
 		});
 		pi.registerTool({
@@ -1566,6 +2182,15 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: result
 				};
+			},
+			renderCall(args, theme, context) {
+				return renderAnswerPermissionCall(context.args, theme);
+			},
+			renderResult(result, { expanded, isPartial }, theme, context) {
+				return renderAnswerPermissionResult(result, {
+					expanded,
+					isPartial
+				}, theme, context.args);
 			}
 		});
 		pi.registerTool({
@@ -1613,6 +2238,15 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: result
 				};
+			},
+			renderCall(args, theme, context) {
+				return renderFollowUpCall(context.args, theme);
+			},
+			renderResult(result, { expanded, isPartial }, theme, context) {
+				return renderFollowUpResult(result, {
+					expanded,
+					isPartial
+				}, theme, context.args);
 			}
 		});
 		pi.registerTool({
@@ -1639,6 +2273,15 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: result
 				};
+			},
+			renderCall(args, theme, context) {
+				return renderEventsCall(context.args, theme);
+			},
+			renderResult(result, { expanded, isPartial }, theme, context) {
+				return renderEventsResult(result, {
+					expanded,
+					isPartial
+				}, theme, context.args);
 			}
 		});
 		pi.registerTool({
@@ -1663,6 +2306,15 @@ function createExtension(deps = defaultDeps) {
 					}],
 					details: result
 				};
+			},
+			renderCall(args, theme, context) {
+				return renderShutdownCall(context.args, theme);
+			},
+			renderResult(result, { expanded, isPartial }, theme, context) {
+				return renderShutdownResult(result, {
+					expanded,
+					isPartial
+				}, theme, context.args);
 			}
 		});
 		pi.registerCommand("avenor-status", {
@@ -1740,4 +2392,4 @@ function createExtension(deps = defaultDeps) {
 }
 var src_default = createExtension();
 //#endregion
-export { buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, src_default as default, isTerminalStatus, renderStatusLines, statusSupervisorId };
+export { CHANNEL_POLL_COMPLETED, CHANNEL_RUN_TERMINAL, buildCompletionText, buildInspectPayload, compactWhitespace, createExtension, createPollCompletedPayload, createRunTerminalPayload, src_default as default, emitAvenorEvent, isTerminalStatus, onAvenorEvent, renderStatusLines, statusSupervisorId };

package/package.json

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