@oh-my-pi/pi-coding-agent 16.4.4 → 16.4.5

package/src/extensibility/custom-tools/loader.ts

@@ -21,6 +21,34 @@ import * as typebox from "../typebox";
 import { createNoOpUIContext, resolvePath, withExitGuard } from "../utils";
 import type { CustomToolAPI, CustomToolFactory, LoadedCustomTool, ToolLoadError } from "./types";
 
+interface LoadToolResult {
+	tools: LoadedCustomTool[];
+	errors: ToolLoadError[];
+}
+
+function isLoadableCustomTool(value: unknown): value is LoadedCustomTool["tool"] {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		"name" in value &&
+		typeof value.name === "string" &&
+		value.name.length > 0 &&
+		"description" in value &&
+		typeof value.description === "string" &&
+		"parameters" in value &&
+		"execute" in value &&
+		typeof value.execute === "function"
+	);
+}
+
+function invalidToolError(path: string, index: number, source: ToolLoadError["source"]): ToolLoadError {
+	return {
+		path,
+		error: `Tool factory returned invalid tool at index ${index}: expected object with string name, string description, parameters, and execute function`,
+		source,
+	};
+}
+
 /**
  * Load a single tool module using native Bun import.
  */
@@ -29,18 +57,20 @@ async function loadTool(
 	cwd: string,
 	sharedApi: CustomToolAPI,
 	source?: { provider: string; providerName: string; level: "user" | "project" },
-): Promise<{ tools: LoadedCustomTool[] | null; error: ToolLoadError | null }> {
+): Promise<LoadToolResult> {
 	const resolvedPath = resolvePath(toolPath, cwd);
 
 	// Skip declarative tool files (.md, .json) - these are metadata only, not executable modules
 	if (resolvedPath.endsWith(".md") || resolvedPath.endsWith(".json")) {
 		return {
-			tools: null,
-			error: {
-				path: toolPath,
-				error: "Declarative tool files (.md, .json) cannot be loaded as executable modules",
-				source,
-			},
+			tools: [],
+			errors: [
+				{
+					path: toolPath,
+					error: "Declarative tool files (.md, .json) cannot be loaded as executable modules",
+					source,
+				},
+			],
 		};
 	}
 
@@ -49,23 +79,32 @@ async function loadTool(
 		const factory = (module.default ?? module) as CustomToolFactory;
 
 		if (typeof factory !== "function") {
-			return { tools: null, error: { path: toolPath, error: "Tool must export a default function", source } };
+			return { tools: [], errors: [{ path: toolPath, error: "Tool must export a default function", source }] };
 		}
 
-		const toolResult = await withExitGuard(async () => factory(sharedApi));
+		const toolResult: unknown = await withExitGuard(async () => factory(sharedApi));
 		const toolsArray = Array.isArray(toolResult) ? toolResult : [toolResult];
 
-		const loadedTools: LoadedCustomTool[] = toolsArray.map(tool => ({
-			path: toolPath,
-			resolvedPath,
-			tool,
-			source,
-		}));
+		const loadedTools: LoadedCustomTool[] = [];
+		const errors: ToolLoadError[] = [];
+		for (const [index, tool] of toolsArray.entries()) {
+			if (!isLoadableCustomTool(tool)) {
+				errors.push(invalidToolError(toolPath, index, source));
+				continue;
+			}
+
+			loadedTools.push({
+				path: toolPath,
+				resolvedPath,
+				tool,
+				source,
+			});
+		}
 
-		return { tools: loadedTools, error: null };
+		return { tools: loadedTools, errors };
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		return { tools: null, error: { path: toolPath, error: `Failed to load tool: ${message}`, source } };
+		return { tools: [], errors: [{ path: toolPath, error: `Failed to load tool: ${message}`, source }] };
 	}
 }
 
@@ -129,28 +168,22 @@ export class CustomToolLoader {
 
 	async load(pathsWithSources: ToolPathWithSource[]): Promise<void> {
 		for (const { path: toolPath, source } of pathsWithSources) {
-			const { tools: loadedTools, error } = await loadTool(toolPath, this.#sharedApi.cwd, this.#sharedApi, source);
+			const { tools: loadedTools, errors } = await loadTool(toolPath, this.#sharedApi.cwd, this.#sharedApi, source);
+			this.errors.push(...errors);
 
-			if (error) {
-				this.errors.push(error);
-				continue;
-			}
-
-			if (loadedTools) {
-				for (const loadedTool of loadedTools) {
-					// Check for name conflicts
-					if (this.#seenNames.has(loadedTool.tool.name)) {
-						this.errors.push({
-							path: toolPath,
-							error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
-							source,
-						});
-						continue;
-					}
-
-					this.#seenNames.add(loadedTool.tool.name);
-					this.tools.push(loadedTool);
+			for (const loadedTool of loadedTools) {
+				// Check for name conflicts
+				if (this.#seenNames.has(loadedTool.tool.name)) {
+					this.errors.push({
+						path: toolPath,
+						error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
+						source,
+					});
+					continue;
 				}
+
+				this.#seenNames.add(loadedTool.tool.name);
+				this.tools.push(loadedTool);
 			}
 		}
 	}

package/src/extensibility/extensions/types.ts

@@ -113,6 +113,46 @@ export interface ExtensionUISelectOption {
 
 export type ExtensionUISelectItem = string | ExtensionUISelectOption;
 
+export interface ExtensionAskDialogOption {
+	label: string;
+	description?: string;
+	preview?: string;
+}
+
+export interface ExtensionAskDialogQuestion {
+	id: string;
+	question: string;
+	header?: string;
+	options: ExtensionAskDialogOption[];
+	multi?: boolean;
+	recommended?: number;
+}
+
+export interface ExtensionAskDialogResultItem {
+	id: string;
+	question: string;
+	options: string[];
+	multi: boolean;
+	selectedOptions: string[];
+	customInput?: string;
+	note?: string;
+	timedOut?: boolean;
+}
+
+export interface ExtensionAskDialogSubmitResult {
+	kind: "submit";
+	results: ExtensionAskDialogResultItem[];
+}
+
+/** Chat-redirect result: the user chose "Chat about this" instead of
+ *  answering. Distinct from `undefined` (cancel) so AskTool can hand off to
+ *  the chat loop rather than aborting. */
+export interface ExtensionAskDialogChatResult {
+	kind: "chat";
+}
+
+export type ExtensionAskDialogResult = ExtensionAskDialogSubmitResult | ExtensionAskDialogChatResult;
+
 export function getExtensionUISelectOptionLabel(option: ExtensionUISelectItem): string {
 	return typeof option === "string" ? option : option.label;
 }
@@ -195,6 +235,12 @@ export interface ExtensionUIContext {
 	/** Show a text input dialog. */
 	input(title: string, placeholder?: string, dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
 
+	/** Show the rich ask dialog when the interactive TUI surface is available. */
+	askDialog?(
+		questions: ExtensionAskDialogQuestion[],
+		dialogOptions?: ExtensionUIDialogOptions,
+	): Promise<ExtensionAskDialogResult | undefined>;
+
 	/** Show a notification to the user. */
 	notify(message: string, type?: "info" | "warning" | "error"): void;
 

package/src/irc/bus.ts

@@ -104,8 +104,19 @@ export class IrcBus {
 	): Promise<IrcDeliveryReceipt> {
 		const message: IrcMessage = { ...msg, id: Snowflake.next(), ts: Date.now() };
 		const ref = this.#registry.get(message.to);
-		if (!ref || ref.status === "aborted") {
-			return { to: message.to, outcome: "failed", error: `Unknown or terminated agent "${message.to}".` };
+		if (!ref) {
+			return {
+				to: message.to,
+				outcome: "failed",
+				error: `Unknown agent "${message.to}" — check \`irc list\` for live peers.`,
+			};
+		}
+		if (ref.status === "aborted") {
+			return {
+				to: message.to,
+				outcome: "failed",
+				error: `Agent "${message.to}" was hard-aborted and cannot be messaged or revived. Its transcript remains readable at history://${message.to}.`,
+			};
 		}
 		// Advisor refs are observability-only transcripts, never messageable peers.
 		if (ref.kind === "advisor") {
@@ -175,7 +186,7 @@ export class IrcBus {
 		filter: { from?: string },
 		timeoutMs: number,
 		signal?: AbortSignal,
-		options?: { drainPending?: boolean },
+		options?: { drainPending?: boolean; liveness?: { registry: AgentRegistry; senderId: string } },
 	): Promise<IrcMessage | null> {
 		if (signal?.aborted) {
 			throw signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted");
@@ -190,35 +201,49 @@ export class IrcBus {
 		const { promise, resolve, reject } = Promise.withResolvers<IrcMessage | null>();
 		let timer: NodeJS.Timeout | undefined;
 		let onAbort: (() => void) | undefined;
+		let unsubscribeLiveness: (() => void) | undefined;
 
-		const waiter: IrcWaiter = {
-			from: filter.from,
-			resolve: msg => {
-				cleanup();
-				resolve(msg);
-			},
-			cancel: () => {
-				cleanup();
-			},
+		const liveness = options?.liveness;
+		const livenessReason = filter.from
+			? `IRC wait aborted: agent "${filter.from}" is not running`
+			: "IRC wait aborted: no running peers remain";
+
+		const settle = (
+			outcome: { kind: "message"; msg: IrcMessage } | { kind: "timeout" } | { kind: "abort"; error: Error },
+		): void => {
+			cleanup();
+			if (outcome.kind === "message") {
+				resolve(outcome.msg);
+			} else if (outcome.kind === "timeout") {
+				resolve(null);
+			} else {
+				reject(outcome.error);
+			}
 		};
+
 		const cleanup = (): void => {
 			this.#removeWaiter(agentId, waiter);
 			clearTimeout(timer);
 			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+			unsubscribeLiveness?.();
+		};
+
+		const waiter: IrcWaiter = {
+			from: filter.from,
+			resolve: msg => settle({ kind: "message", msg }),
+			cancel: () => cleanup(),
 		};
 
 		if (signal) {
-			onAbort = () => {
-				cleanup();
-				reject(signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"));
-			};
+			onAbort = () =>
+				settle({
+					kind: "abort",
+					error: signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"),
+				});
 			signal.addEventListener("abort", onAbort, { once: true });
 		}
 		if (timeoutMs > 0) {
-			timer = setTimeout(() => {
-				cleanup();
-				resolve(null);
-			}, timeoutMs);
+			timer = setTimeout(() => settle({ kind: "timeout" }), timeoutMs);
 			timer.unref?.();
 		}
 
@@ -228,6 +253,22 @@ export class IrcBus {
 			this.#waiters.set(agentId, waiters);
 		}
 		waiters.push(waiter);
+
+		if (liveness) {
+			const { registry, senderId } = liveness;
+			const hasRunningSender = (from?: string): boolean =>
+				registry.listVisibleTo(senderId).some(ref => ref.status === "running" && (!from || ref.id === from));
+			const check = filter.from ? () => hasRunningSender(filter.from) : () => hasRunningSender();
+			unsubscribeLiveness = registry.onChange(() => {
+				if (!check()) {
+					settle({ kind: "abort", error: new Error(livenessReason) });
+				}
+			});
+			if (!check()) {
+				settle({ kind: "abort", error: new Error(livenessReason) });
+			}
+		}
+
 		return promise;
 	}
 

package/src/modes/components/__tests__/pause-screen.test.ts

@@ -0,0 +1,143 @@
+import { afterEach, beforeAll, describe, expect, it } from "bun:test";
+import { agentPauseGate } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Settings } from "../../../config/settings";
+import { getThemeByName, setThemeInstance } from "../../theme/theme";
+import { PauseScreenComponent, type PauseScreenHost, renderPauseScreen, runPauseScreen } from "../pause-screen";
+
+// Strip SGR colors so assertions see visible text only.
+const stripAnsi = (text: string): string => text.replace(/\x1b\[[0-9;]*m/g, "");
+
+interface FakeHost {
+	host: PauseScreenHost;
+	shown: Component[];
+	statuses: string[];
+	hiddenCount(): number;
+}
+
+function makeHost(rows = 24): FakeHost {
+	const shown: Component[] = [];
+	const statuses: string[] = [];
+	let hidden = 0;
+	const host: PauseScreenHost = {
+		ui: {
+			showOverlay(component) {
+				shown.push(component);
+				return {
+					hide: () => {
+						hidden++;
+					},
+					setHidden() {},
+					isHidden: () => false,
+				};
+			},
+			setFocus() {},
+			requestRender() {},
+			terminal: { rows },
+		},
+		showStatus(message) {
+			statuses.push(message);
+		},
+	};
+	return { host, shown, statuses, hiddenCount: () => hidden };
+}
+
+describe("pause screen", () => {
+	beforeAll(async () => {
+		await Settings.init({ inMemory: true });
+		const loaded = await getThemeByName("dark");
+		if (!loaded) throw new Error("theme unavailable");
+		setThemeInstance(loaded);
+	});
+
+	afterEach(() => {
+		// The gate is process-global: never leak an engaged pause into other files.
+		agentPauseGate.resume();
+	});
+
+	describe("renderPauseScreen", () => {
+		it("paints exactly the requested rows with title, explainer, clock, and hint", () => {
+			const lines = renderPauseScreen(80, 24, 65_000);
+			expect(lines.length).toBe(24);
+			const text = lines.map(stripAnsi).join("\n");
+			expect(text).toContain("P A U S E D");
+			expect(text).toContain("Main agent, subagents, and advisor");
+			expect(text).toContain("paused for 1:05");
+			expect(text).toContain("esc · enter · space — resume");
+			expect(text).toContain("█".repeat(5));
+		});
+
+		it("drops to the compact card on small terminals", () => {
+			const lines = renderPauseScreen(40, 10, 3_000);
+			expect(lines.length).toBe(10);
+			const text = lines.map(stripAnsi).join("\n");
+			expect(text).toContain("▌▌ P A U S E D");
+			expect(text).toContain("paused for 0:03");
+			expect(text).toContain("esc to resume");
+			expect(text).not.toContain("█".repeat(5)); // no room for the big glyph
+		});
+
+		it("rolls the clock into hours past 60 minutes", () => {
+			const text = renderPauseScreen(80, 24, 3_725_000).map(stripAnsi).join("\n");
+			expect(text).toContain("paused for 1:02:05");
+		});
+
+		it("displays the session name when provided in full mode", () => {
+			const lines = renderPauseScreen(80, 24, 65_000, "My Awesome Session");
+			const text = lines.map(stripAnsi).join("\n");
+			expect(text).toContain("My Awesome Session");
+			expect(text).toContain("P A U S E D");
+		});
+
+		it("displays the session name when provided in compact mode", () => {
+			const lines = renderPauseScreen(40, 10, 3_000, "Compact Session Title");
+			const text = lines.map(stripAnsi).join("\n");
+			expect(text).toContain("Compact Session Title");
+			expect(text).toContain("▌▌ P A U S E D");
+		});
+	});
+
+	describe("runPauseScreen", () => {
+		it("engages the gate for the screen's lifetime and releases it on escape", async () => {
+			const { host, shown, statuses, hiddenCount } = makeHost();
+			expect(agentPauseGate.paused).toBe(false);
+
+			const run = runPauseScreen(host);
+			await Bun.sleep(1);
+			expect(agentPauseGate.paused).toBe(true);
+			expect(shown.length).toBe(1);
+
+			const component = shown[0];
+			expect(component).toBeInstanceOf(PauseScreenComponent);
+			if (component instanceof PauseScreenComponent) {
+				component.handleInput("\x1b"); // escape → resume
+			}
+			await run;
+
+			expect(agentPauseGate.paused).toBe(false);
+			expect(hiddenCount()).toBe(1);
+			expect(statuses.some(message => message.includes("Resumed after"))).toBe(true);
+		});
+
+		it("treats ctrl+c as resume, never as abort-and-stay-paused", async () => {
+			const { host, shown } = makeHost();
+			const run = runPauseScreen(host);
+			await Bun.sleep(1);
+
+			const component = shown[0];
+			if (component instanceof PauseScreenComponent) {
+				component.handleInput("\x03"); // ctrl+c
+			}
+			await run;
+			expect(agentPauseGate.paused).toBe(false);
+		});
+
+		it("is a no-op when the gate is already engaged elsewhere", async () => {
+			agentPauseGate.pause();
+			const { host, shown } = makeHost();
+			await runPauseScreen(host); // must resolve immediately, not park
+			expect(shown.length).toBe(0);
+			expect(agentPauseGate.paused).toBe(true); // foreign pause not stolen
+		});
+	});
+});

package/src/modes/components/advisor-config.ts

@@ -40,7 +40,7 @@ import { formatModelSelectorValue } from "../../config/model-resolver";
 import type { Settings } from "../../config/settings";
 import { getSelectListTheme, theme } from "../theme/theme";
 import { HookEditorComponent } from "./hook-editor";
-import { ModelSelectorComponent } from "./model-selector";
+import { buildBrowserItems, ModelBrowser, sortModelItems } from "./model-browser";
 import {
 	bottomBorder,
 	divider,
@@ -461,27 +461,35 @@ export class AdvisorConfigOverlayComponent implements Component {
 	}
 
 	#showModelPicker(index: number): void {
-		const picker = new ModelSelectorComponent(
-			this.#tui,
-			undefined,
-			this.#settings,
-			this.#modelRegistry,
-			this.#scopedModels,
-			(model, _role, _thinking, selector) => {
-				const base = selector ?? `${model.provider}/${model.id}`;
-				const efforts = getSupportedEfforts(model);
-				if (efforts.length === 0) {
-					this.#doc.advisors[index].model = base;
-					this.#dirty = true;
-					this.#showDetail(index);
-				} else {
-					this.#showThinkingPicker(index, base, efforts);
-				}
-			},
-			() => this.#showDetail(index),
-			{ directSelect: true, pickerHint: "Pick this advisor's model · Enter / click select · Esc back" },
-		);
-		this.#setScreen("model", picker, "Type to search · Enter / click pick model · Esc back");
+		const mruOrder = this.#settings.getStorage()?.getModelUsageOrder() ?? [];
+		let models: ReadonlyArray<Model>;
+		if (this.#scopedModels.length > 0) {
+			models = this.#scopedModels.map(scoped => scoped.model);
+		} else {
+			try {
+				models = this.#modelRegistry.getAvailable();
+			} catch {
+				models = [];
+			}
+		}
+		const items = buildBrowserItems(models);
+		sortModelItems(items, { mruOrder });
+
+		const picker = new ModelBrowser(this.#settings, {});
+		picker.setMruOrder(mruOrder);
+		picker.setItems(items);
+		picker.onActivate = item => {
+			const efforts = getSupportedEfforts(item.model);
+			if (efforts.length === 0) {
+				this.#doc.advisors[index].model = item.selector;
+				this.#dirty = true;
+				this.#showDetail(index);
+			} else {
+				this.#showThinkingPicker(index, item.selector, efforts);
+			}
+		};
+		picker.onCancel = () => this.#showDetail(index);
+		this.#setScreen("model", picker, "Type to search · Enter / click twice picks · Esc back");
 	}
 
 	#showThinkingPicker(index: number, selector: string, efforts: readonly string[]): void {