@howaboua/pi-ask 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -0,0 +1,49 @@
+# @howaboua/pi-ask
+
+## 0.0.7
+
+- The `ask` tool now supports steering questions that return immediately, preserve the full response panel, and deliver answers at the next safe boundary using the developer role under active Pi Codex Responses.
+
+## 0.0.6
+
+- Added a Code and Notebook Mode bridge API. This allows extensions that use Pi TUI to run inside `exec`.
+
+## 0.0.5
+
+### Changes
+
+- [#269](https://github.com/IgorWarzocha/howaboua-pi-stuff/pull/269) [`6138ffd`](https://github.com/IgorWarzocha/howaboua-pi-stuff/commit/6138ffd735bb4f7f80e451320dbfd0933a4acaa7) Thanks [@howaclawa](https://github.com/howaclawa)!:
+  - Add shared realtime voice prompts for ask prompts, Auto Trees, Shepherdr settlements, and review progress.
+  - Announce compaction and stream conversational Pi updates after two sentences.
+  - Keep silent tool-step summaries compatible without exposing Chat Completions thinking content.
+  - Configure delegation acknowledgements and deliver V3 delegations immediately.
+  - Preserve late delegations, calls after data-channel closure, prepared Code Mode prompts, and Codex cache continuity.
+  - Reduce LAN playback dropouts with one more jitter-buffer frame.
+
+## 0.0.4
+
+### Changes
+
+- [#131](https://github.com/IgorWarzocha/howaboua-pi-stuff/pull/131) [`828f52e`](https://github.com/IgorWarzocha/howaboua-pi-stuff/commit/828f52eff1291629d73c3058173cff2fa60e3b28) Thanks [@IgorWarzocha](https://github.com/IgorWarzocha)!:
+  - Uses configured Pi keybindings for ask navigation and theme-native TUI colors.
+
+## 0.0.3
+
+### Changes
+
+- [#128](https://github.com/IgorWarzocha/howaboua-pi-stuff/pull/128) [`9604ec3`](https://github.com/IgorWarzocha/howaboua-pi-stuff/commit/9604ec3505eff2d9ee789f42ef45038bc00da02e) Thanks [@IgorWarzocha](https://github.com/IgorWarzocha)!:
+  - Remove the duplicated ask tool name from the model-facing prompt inventory.
+
+## 0.0.2
+
+### Changes
+
+- [#120](https://github.com/IgorWarzocha/howaboua-pi-stuff/pull/120) [`8f82078`](https://github.com/IgorWarzocha/howaboua-pi-stuff/commit/8f82078a8e733dbe770c7b5fd9ad1b20cd5a21af) Thanks [@IgorWarzocha](https://github.com/IgorWarzocha)!:
+  - Report open ask panels as blocked to Herdr's Pi integration.
+
+## 0.0.1
+
+### Changes
+
+- [#113](https://github.com/IgorWarzocha/howaboua-pi-stuff/pull/113) [`f516f97`](https://github.com/IgorWarzocha/howaboua-pi-stuff/commit/f516f97c76ae27a354f80f85a5a34ecd56c4e9c4) Thanks [@IgorWarzocha](https://github.com/IgorWarzocha)!:
+  - Add interactive human input, review triage, and handoff prompts through the `ask` tool, plus configurable `/fold` and `/grill` workflows.

package/README.md

@@ -14,13 +14,17 @@ Try it for one session:
 pi -e npm:@howaboua/pi-ask
 ```
 
+When [Pi Codex](https://www.npmjs.com/package/@howaboua/pi-codex-conversion) 3.0.25 or newer is installed too, `ask` is available inside Code and Notebook Mode as `await tools.ask({ prompts, delivery?, handoff? })`.
+
 ## How it behaves
 
 The agent can present several independently decidable prompts in one tabbed panel. Each prompt supports a short title, supporting evidence, one or more choices, free text, and an optional comment. Review findings become one prompt each, so you can fix, defer, or reject them without translating a wall of prose back into instructions.
 
+Questions wait for your response by default. When the agent can continue useful reversible work, it can use `delivery: "steer"` instead. The tool then returns immediately, keeps the same panel open, and delivers your eventual response as steering at the next safe boundary. An active Pi Codex Responses adapter sends the answer with the developer role; other setups receive an ordinary user steering message. Pending steering questions survive session reloads.
+
 For work only you can complete—sign-in, authorization, hardware access, or another manual step—the agent can open a handoff and wait until you mark it done or unable to complete.
 
-When Pi runs inside Herdr with its Pi integration installed, an open ask panel marks the pane as blocked until you submit, dismiss, or abort it.
+When Pi runs inside Herdr with its Pi integration installed, only a waiting ask marks the pane as blocked. A steering ask remains pending while the agent continues.
 
 `Other/rephrase` is always available. Submit it blank when the prompt needs to be rephrased, split, or followed up instead of answered as written.
 
@@ -29,7 +33,7 @@ When Pi runs inside Herdr with its Pi integration installed, an open ask panel m
 - `/fold [report]` turns a long report or structured list into one interactive disposition prompt per item.
 - `/grill [idea]` investigates an idea, asks successive decisions, and keeps the agreed plan in `docs/`.
 
-Both templates are enabled by default. The extension creates `~/.pi/agent/ask.json` on first load:
+Both templates are enabled by default. The extension creates `ask.json` under Pi's agent directory on first load. That is `~/.pi/agent/ask.json` by default. `PI_CODING_AGENT_DIR` changes the agent directory.
 
 ```json
 {

package/ask/contracts.ts

@@ -1,13 +1,14 @@
+import { StringEnum } from "@earendil-works/pi-ai";
 import { type Static, Type } from "typebox";
 
-export { OTHER_OPTION_LABEL, REPHRASE_REQUEST_RESPONSE } from "./constants.js";
+const ASK_DELIVERIES = ["wait", "steer"] as const;
 
-export const ChoiceSchema = Type.Object({
+const ChoiceSchema = Type.Object({
 	label: Type.String({ description: "Short choice." }),
 	description: Type.Optional(Type.String({ description: "Optional detail." })),
 });
 
-export const PromptSchema = Type.Object({
+const PromptSchema = Type.Object({
 	title: Type.String({ description: "Short prompt." }),
 	body: Type.Optional(Type.String({ description: "Context or evidence." })),
 	multiple: Type.Optional(Type.Boolean({ description: "Allow multiple." })),
@@ -21,9 +22,14 @@ export const AskParameters = Type.Object({
 		Type.Boolean({ description: "Wait for user action." }),
 	),
 	prompts: Type.Array(PromptSchema, { description: "Prompts." }),
+	delivery: Type.Optional(
+		StringEnum(ASK_DELIVERIES, {
+			description:
+				"Wait for a gating response; steer while continuing reversible work. Omit to wait.",
+		}),
+	),
 });
 
-export type AskInput = Static<typeof AskParameters>;
 export type PromptChoice = Static<typeof ChoiceSchema>;
 
 export interface AskPrompt {
@@ -34,6 +40,11 @@ export interface AskPrompt {
 	choices: PromptChoice[];
 }
 
+export interface PendingAsk {
+	id: string;
+	prompts: AskPrompt[];
+}
+
 export interface AskResponse {
 	id: string;
 	selections: string[];

package/ask/coordinator.ts

@@ -0,0 +1,161 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AskPrompt, PendingAsk } from "./contracts.js";
+import { normalizeResponses, summarizeResponses } from "./normalize.js";
+import type { PendingAskUpdate } from "./pending.js";
+import { askWithPiUi } from "./pi-ui.js";
+import { askInTui } from "./tui.js";
+
+type AskInComposer = (
+	prompts: AskPrompt[],
+	signal: AbortSignal | undefined,
+) => Promise<unknown>;
+
+export interface AskCoordinatorOptions {
+	askInComposer?: AskInComposer;
+	deliverSteer?: (message: string) => void;
+	onPendingChange?: (update: PendingAskUpdate) => void;
+}
+
+interface PresentAskOptions {
+	handoff?: boolean;
+	steering?: boolean;
+	signal?: AbortSignal;
+}
+
+function steerResponse(prompts: AskPrompt[], responses: unknown): string {
+	const normalized = normalizeResponses(prompts, responses);
+	return normalized
+		? `Response to your earlier ask:\n${summarizeResponses(prompts, normalized)}`
+		: `I dismissed your earlier ask: ${prompts.map((prompt) => prompt.title).join("; ")}`;
+}
+
+export function createAskCoordinator({
+	askInComposer,
+	deliverSteer,
+	onPendingChange,
+}: AskCoordinatorOptions = {}) {
+	let generation = 0;
+	let sessionAbort = new AbortController();
+	let presentationTail = Promise.resolve();
+	const activeSteers = new Set<string>();
+
+	const present = (
+		ctx: ExtensionContext,
+		prompts: AskPrompt[],
+		{ handoff = false, steering = false, signal }: PresentAskOptions = {},
+	): Promise<unknown> => {
+		const run = async () => {
+			if (signal?.aborted) return null;
+			return askInComposer
+				? await askInComposer(prompts, signal)
+				: ctx.mode === "tui"
+					? await askInTui(ctx, prompts, {
+							handoff,
+							steering,
+							...(signal ? { signal } : {}),
+						})
+					: await askWithPiUi(ctx, prompts, {
+							handoff,
+							steering,
+							...(signal ? { signal } : {}),
+						});
+		};
+		const result = presentationTail.then(run, run);
+		presentationTail = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	};
+
+	const notifyFailure = (ctx: ExtensionContext, error: unknown) => {
+		const message = error instanceof Error ? error.message : String(error);
+		ctx.ui.notify(`Async ask failed: ${message}`, "error");
+		return message;
+	};
+
+	const deliver = (ctx: ExtensionContext, message: string): boolean => {
+		try {
+			deliverSteer?.(message);
+			return true;
+		} catch (error) {
+			notifyFailure(ctx, error);
+			return false;
+		}
+	};
+
+	const close = (ctx: ExtensionContext, id: string) => {
+		activeSteers.delete(id);
+		try {
+			onPendingChange?.({ version: 1, state: "closed", id });
+		} catch (error) {
+			notifyFailure(ctx, error);
+		}
+	};
+
+	const startSteer = (
+		request: PendingAsk,
+		ctx: ExtensionContext,
+		persist: boolean,
+	) => {
+		if (activeSteers.has(request.id) || sessionAbort.signal.aborted) return;
+		if (persist) {
+			onPendingChange?.({
+				version: 1,
+				state: "pending",
+				id: request.id,
+				prompts: request.prompts,
+			});
+		}
+		activeSteers.add(request.id);
+		const requestGeneration = generation;
+		void present(ctx, request.prompts, {
+			steering: true,
+			signal: sessionAbort.signal,
+		}).then(
+			(responses) => {
+				if (requestGeneration !== generation || sessionAbort.signal.aborted)
+					return;
+				if (deliver(ctx, steerResponse(request.prompts, responses)))
+					close(ctx, request.id);
+			},
+			(error: unknown) => {
+				if (requestGeneration !== generation || sessionAbort.signal.aborted)
+					return;
+				const message = notifyFailure(ctx, error);
+				if (
+					deliver(
+						ctx,
+						`The asynchronous ask failed before I could answer: ${message}`,
+					)
+				)
+					close(ctx, request.id);
+			},
+		);
+	};
+
+	return {
+		canSteer: deliverSteer !== undefined,
+		present,
+		requestSteer(request: PendingAsk, ctx: ExtensionContext) {
+			startSteer(request, ctx, true);
+		},
+		restorePending(pending: readonly PendingAsk[], ctx: ExtensionContext) {
+			generation++;
+			sessionAbort.abort();
+			sessionAbort = new AbortController();
+			presentationTail = Promise.resolve();
+			activeSteers.clear();
+			if ((!askInComposer && !ctx.hasUI) || !deliverSteer) return;
+			for (const request of pending) startSteer(request, ctx, false);
+		},
+		shutdown() {
+			generation++;
+			sessionAbort.abort();
+			activeSteers.clear();
+		},
+		get sessionSignal(): AbortSignal {
+			return sessionAbort.signal;
+		},
+	};
+}

package/ask/delivery.ts

@@ -0,0 +1,23 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export type TryCodexDeveloperMessage = (
+	pi: ExtensionAPI,
+	content: string,
+	options: { deliverAs: "steer"; triggerTurn: true },
+) => boolean;
+
+export function createSteerDelivery(
+	pi: ExtensionAPI,
+	trySendCodexDeveloperMessage?: TryCodexDeveloperMessage,
+): (message: string) => void {
+	return (message) => {
+		if (
+			trySendCodexDeveloperMessage?.(pi, message, {
+				deliverAs: "steer",
+				triggerTurn: true,
+			})
+		)
+			return;
+		pi.sendUserMessage(message, { deliverAs: "steer" });
+	};
+}

package/ask/normalize.ts

@@ -1,10 +1,5 @@
 import { HANDOFF_CHOICES, OTHER_OPTION_LABEL } from "./constants.js";
-import type {
-	AskInput,
-	AskPrompt,
-	AskResponse,
-	PromptChoice,
-} from "./contracts.js";
+import type { AskPrompt, AskResponse, PromptChoice } from "./contracts.js";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
@@ -14,7 +9,7 @@ export function textContent(text: string): { type: "text"; text: string } {
 	return { type: "text", text };
 }
 
-export function normalizePromptChoice(choice: unknown): PromptChoice | null {
+function normalizePromptChoice(choice: unknown): PromptChoice | null {
 	if (!isRecord(choice)) return null;
 	const label =
 		typeof choice["label"] === "string" ? choice["label"].trim() : "";
@@ -26,7 +21,7 @@ export function normalizePromptChoice(choice: unknown): PromptChoice | null {
 	return { label, ...(description ? { description } : {}) };
 }
 
-export function normalizePrompt(
+function normalizePrompt(
 	input: unknown,
 	index: number,
 	handoff = false,
@@ -49,17 +44,31 @@ export function normalizePrompt(
 	};
 }
 
-export function normalizeAskInput(params: AskInput | null | undefined): {
+export function isSteeringAskInput(input: unknown): boolean {
+	return (
+		isRecord(input) &&
+		input["delivery"] === "steer" &&
+		input["handoff"] !== true
+	);
+}
+
+export function normalizeAskInput(params: unknown): {
+	delivery: "wait" | "steer";
 	handoff: boolean;
 	prompts: AskPrompt[];
 } {
-	const handoff = params?.handoff === true;
-	const prompts = Array.isArray(params?.prompts)
-		? params.prompts
+	const input = isRecord(params) ? params : {};
+	const handoff = input["handoff"] === true;
+	const prompts = Array.isArray(input["prompts"])
+		? input["prompts"]
 				.map((prompt, index) => normalizePrompt(prompt, index, handoff))
 				.filter((prompt) => prompt !== null)
 		: [];
-	return { handoff, prompts };
+	return {
+		delivery: input["delivery"] === "steer" ? "steer" : "wait",
+		handoff,
+		prompts,
+	};
 }
 
 export function normalizeResponses(

package/ask/pending.ts

@@ -0,0 +1,39 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { AskPrompt, PendingAsk } from "./contracts.js";
+import { normalizeAskInput } from "./normalize.js";
+
+export const PENDING_ASK_ENTRY_TYPE = "pi-ask-pending";
+
+export type PendingAskUpdate =
+	| { version: 1; state: "pending"; id: string; prompts: AskPrompt[] }
+	| { version: 1; state: "closed"; id: string };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function parsePendingAskUpdate(value: unknown): PendingAskUpdate | undefined {
+	if (!isRecord(value) || value["version"] !== 1) return undefined;
+	const id = typeof value["id"] === "string" ? value["id"].trim() : "";
+	if (!id) return undefined;
+	if (value["state"] === "closed") return { version: 1, state: "closed", id };
+	if (value["state"] !== "pending") return undefined;
+	const { prompts } = normalizeAskInput({ prompts: value["prompts"] });
+	if (prompts.length === 0) return undefined;
+	return { version: 1, state: "pending", id, prompts };
+}
+
+export function readPendingAsks(
+	entries: readonly SessionEntry[],
+): PendingAsk[] {
+	const pending = new Map<string, PendingAsk>();
+	for (const entry of entries) {
+		if (entry.type !== "custom" || entry.customType !== PENDING_ASK_ENTRY_TYPE)
+			continue;
+		const update = parsePendingAskUpdate(entry.data);
+		if (!update) continue;
+		if (update.state === "closed") pending.delete(update.id);
+		else pending.set(update.id, { id: update.id, prompts: update.prompts });
+	}
+	return [...pending.values()];
+}

package/ask/pi-ui.ts

@@ -22,9 +22,14 @@ async function askOther(
 	return value === undefined ? null : customSelectionFor(value);
 }
 
-function promptText(prompt: AskPrompt, handoff: boolean): string {
+function promptText(
+	prompt: AskPrompt,
+	handoff: boolean,
+	steering: boolean,
+): string {
 	const text = prompt.body ? `${prompt.title}\n\n${prompt.body}` : prompt.title;
-	return handoff ? `Human action needed\n\n${text}` : text;
+	if (handoff) return `Human action needed\n\n${text}`;
+	return steering ? `Agent continues while you decide\n\n${text}` : text;
 }
 
 async function askComment(
@@ -56,18 +61,19 @@ async function askSingleWithPiUi(
 	ctx: ExtensionContext,
 	prompt: AskPrompt,
 	handoff: boolean,
+	steering: boolean,
 	signal?: AbortSignal,
 ): Promise<string[] | null> {
 	const choices = prompt.choices.map((choice) => choice.label);
 	const picked =
 		choices.length > 0
 			? await ctx.ui.select(
-					promptText(prompt, handoff),
+					promptText(prompt, handoff, steering),
 					[...choices, OTHER_OPTION_LABEL],
 					dialogOptions(signal),
 				)
 			: await ctx.ui.input(
-					promptText(prompt, handoff),
+					promptText(prompt, handoff, steering),
 					"Response",
 					dialogOptions(signal),
 				);
@@ -82,6 +88,7 @@ async function askMultipleWithPiUi(
 	ctx: ExtensionContext,
 	prompt: AskPrompt,
 	handoff: boolean,
+	steering: boolean,
 	signal?: AbortSignal,
 ): Promise<string[] | null> {
 	const choices = prompt.choices.map((choice) => choice.label);
@@ -89,7 +96,7 @@ async function askMultipleWithPiUi(
 	const picked: string[] = [];
 	while (true) {
 		const next = await ctx.ui.select(
-			promptText(prompt, handoff),
+			promptText(prompt, handoff, steering),
 			[
 				...choices.filter((choice) => !picked.includes(choice)),
 				OTHER_OPTION_LABEL,
@@ -112,14 +119,18 @@ async function askMultipleWithPiUi(
 export async function askWithPiUi(
 	ctx: ExtensionContext,
 	prompts: AskPrompt[],
-	{ handoff = false, signal }: { handoff?: boolean; signal?: AbortSignal } = {},
+	{
+		handoff = false,
+		steering = false,
+		signal,
+	}: { handoff?: boolean; steering?: boolean; signal?: AbortSignal } = {},
 ): Promise<AskResponse[] | null> {
 	if (!ctx.hasUI || signal?.aborted) return null;
 	const responses: AskResponse[] = [];
 	for (const prompt of prompts) {
 		const selections = prompt.multiple
-			? await askMultipleWithPiUi(ctx, prompt, handoff, signal)
-			: await askSingleWithPiUi(ctx, prompt, handoff, signal);
+			? await askMultipleWithPiUi(ctx, prompt, handoff, steering, signal)
+			: await askSingleWithPiUi(ctx, prompt, handoff, steering, signal);
 		if (!selections) return null;
 		const comment = await askComment(ctx, prompt, signal);
 		if (comment === null || signal?.aborted) return null;

package/ask/tool.ts

@@ -1,19 +1,17 @@
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { AskParameters, type AskPrompt } from "./contracts.js";
+import { AskParameters } from "./contracts.js";
 import {
+	type AskCoordinatorOptions,
+	createAskCoordinator,
+} from "./coordinator.js";
+import {
+	isSteeringAskInput,
 	normalizeAskInput,
 	normalizeResponses,
 	summarizeResponses,
 	textContent,
 } from "./normalize.js";
-import { askWithPiUi } from "./pi-ui.js";
-import { askInTui } from "./tui.js";
-
-type AskInComposer = (
-	prompts: AskPrompt[],
-	signal: AbortSignal | undefined,
-) => Promise<unknown>;
 
 interface BlockedState {
 	id: string;
@@ -24,28 +22,36 @@ interface BlockedState {
 
 type OnBlockedChange = (state: BlockedState) => void;
 
-export function createAskTool({
+interface AskToolOptions extends AskCoordinatorOptions {
+	onBlockedChange?: OnBlockedChange;
+}
+
+export function createAskRuntime({
 	askInComposer,
+	deliverSteer,
 	onBlockedChange,
-}: {
-	askInComposer?: AskInComposer;
-	onBlockedChange?: OnBlockedChange;
-} = {}) {
-	return defineTool({
+	onPendingChange,
+}: AskToolOptions = {}) {
+	const coordinator = createAskCoordinator({
+		...(askInComposer ? { askInComposer } : {}),
+		...(deliverSteer ? { deliverSteer } : {}),
+		...(onPendingChange ? { onPendingChange } : {}),
+	});
+
+	const tool = defineTool({
 		name: "ask",
 		label: "Ask",
-		description:
-			"Request user input or action and return the response. Requires interactive UI.",
+		description: "Request user input or action. Requires interactive UI.",
 		parameters: AskParameters,
 		promptSnippet: "Request human input or action.",
 		promptGuidelines: [
-			"ask: Use for needed user decisions or input; set handoff true for a user-only action and state its completion signal.",
+			"ask: Use steer only while useful reversible work can continue; wait for gating answers and handoffs, stating a handoff's completion signal.",
 			"ask: For reviews, make each finding a prompt with disposition choices; do not report first.",
 			"ask: Do not add Other/rephrase; it is automatic.",
 		],
 		executionMode: "sequential",
 		async execute(toolCallId, params, signal, _onUpdate, ctx) {
-			const { handoff, prompts } = normalizeAskInput(params);
+			const { delivery, handoff, prompts } = normalizeAskInput(params);
 			if (prompts.length === 0) {
 				throw new Error(
 					"ask requires at least one prompt with a non-empty title.",
@@ -53,6 +59,22 @@ export function createAskTool({
 			}
 			if (!askInComposer && !ctx.hasUI)
 				throw new Error("ask requires an interactive UI.");
+			if (handoff && delivery === "steer")
+				throw new Error("ask handoffs require delivery wait.");
+			if (delivery === "steer") {
+				if (!coordinator.canSteer)
+					throw new Error("ask steering delivery is unavailable.");
+				signal?.throwIfAborted();
+				coordinator.requestSteer({ id: toolCallId, prompts }, ctx);
+				return {
+					content: [
+						textContent(
+							"Question presented. Continue working; the response will arrive as steering.",
+						),
+					],
+					details: { kind: "prompt", pending: true, id: toolCallId },
+				};
+			}
 
 			const blockedState = {
 				id: toolCallId,
@@ -65,17 +87,13 @@ export function createAskTool({
 			onBlockedChange?.(blockedState);
 			let rawResponses: unknown;
 			try {
-				rawResponses = askInComposer
-					? await askInComposer(prompts, signal)
-					: ctx.mode === "tui"
-						? await askInTui(ctx, prompts, {
-								handoff,
-								...(signal ? { signal } : {}),
-							})
-						: await askWithPiUi(ctx, prompts, {
-								handoff,
-								...(signal ? { signal } : {}),
-							});
+				const presentationSignal = signal
+					? AbortSignal.any([signal, coordinator.sessionSignal])
+					: coordinator.sessionSignal;
+				rawResponses = await coordinator.present(ctx, prompts, {
+					handoff,
+					signal: presentationSignal,
+				});
 			} finally {
 				onBlockedChange?.({ ...blockedState, active: false });
 			}
@@ -95,12 +113,20 @@ export function createAskTool({
 				details: { kind: handoff ? "handoff" : "prompt", responses },
 			};
 		},
-		renderCall(args, theme) {
+		renderCall(args, theme, context) {
 			const count = Array.isArray(args.prompts) ? args.prompts.length : 0;
+			const label =
+				args.handoff === true
+					? "ask handoff "
+					: isSteeringAskInput(args)
+						? "ask steer "
+						: "ask ";
 			return new Text(
 				theme.fg(
-					"toolTitle",
-					theme.bold(args.handoff === true ? "ask handoff " : "ask "),
+					context && "isBlocked" in context && context.isBlocked === true
+						? "warning"
+						: "toolTitle",
+					theme.bold(label),
 				) + theme.fg("muted", `${count} prompt${count === 1 ? "" : "s"}`),
 				0,
 				0,
@@ -112,4 +138,14 @@ export function createAskTool({
 			return new Text(theme.fg("success", text), 0, 0);
 		},
 	});
+
+	return {
+		tool,
+		restorePending: coordinator.restorePending,
+		shutdown: coordinator.shutdown,
+	};
+}
+
+export function createAskTool(options: AskToolOptions = {}) {
+	return createAskRuntime(options).tool;
 }