@hank-warren/pi-ask-user-question 0.5.3 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @hank-warren/pi-ask-user-question
 
+## 0.6.0
+
+### Minor Changes
+
+- c079c51: Announce tool availability on a new event, and stop mistaking a symlinked install for somebody else's package.
+
+  Every reconcile now emits `hank:ask-user:availability` (`ASK_USER_AVAILABILITY_EVENT`) with `{ available: boolean }`, letting a consumer such as pi-plan-mode decide whether its own fallback question tool is needed without racing hook order. Availability is read back from the host rather than assumed from the write, because Pi silently ignores a name excluded by `--tools` or a tool policy, and a false positive would leave an interactive session with no question tool at all.
+
+  The check for whether the registered `ask_user_question` is still backed by this package now canonicalizes both paths before comparing. `import.meta.url` is realpath-resolved by Node while Pi passes `sourceInfo.baseDir` through untouched, so every workspace, pnpm, and `npm link` install compared two spellings of the same directory, concluded the tool belonged to someone else, and never restored it after the first headless run. A path that cannot be resolved falls back to a lexical compare rather than failing closed.
+
+  `AbortSignal` is wired through the questionnaire with exactly-once listener cleanup, and the blocked signal is always cleared in a `finally`.
+
 ## 0.5.3
 
 ### Patch Changes

package/ask-user-question.ts

@@ -77,7 +77,7 @@ export function registerTool(pi: ExtensionAPI): void {
 		description: DESCRIPTION,
 		parameters: QuestionParamsSchema,
 
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			const typed = params as unknown as AskUserParams;
 
 			// Backstop only — reconcile.ts should already have stripped the tool
@@ -96,6 +96,11 @@ export function registerTool(pi: ExtensionAPI): void {
 			}
 
 			const session = new QuestionnaireSession(typed);
+			if (signal?.aborted) return buildResponse(session.cancelledResult(), typed);
+
+			let dialog: QuestionnaireDialog | undefined;
+			const cancel = () => dialog?.cancel();
+			signal?.addEventListener("abort", cancel, { once: true });
 			emitPrompt(pi, typed);
 			emitBlocked(pi, true);
 			try {
@@ -110,8 +115,8 @@ export function registerTool(pi: ExtensionAPI): void {
 				// pi-auto-permissions' approval prompt already puts `OptionSelector`.
 				// pi restores the input editor when `done` fires.
 				const result = await ctx.ui.custom<QuestionnaireResult | null>(
-					(tui, theme, _keybindings, done) =>
-						new QuestionnaireDialog({
+					(tui, theme, _keybindings, done) => {
+						dialog = new QuestionnaireDialog({
 							session,
 							theme,
 							// Reuse pi's own markdown theme so previews match the
@@ -119,7 +124,10 @@ export function registerTool(pi: ExtensionAPI): void {
 							markdownTheme: getMarkdownTheme(),
 							done,
 							requestRender: () => tui.requestRender(),
-						}),
+						});
+						if (signal?.aborted) queueMicrotask(() => dialog?.cancel());
+						return dialog;
+					},
 				);
 
 				// `custom()` resolving undefined means the host reported hasUI but
@@ -133,6 +141,7 @@ export function registerTool(pi: ExtensionAPI): void {
 				}
 				return buildResponse(result, typed);
 			} finally {
+				signal?.removeEventListener("abort", cancel);
 				// In `finally` so listeners are never left believing we are still
 				// blocked on a human after a throw.
 				emitBlocked(pi, false);

package/events.ts

@@ -53,3 +53,11 @@ export interface AskUserBlockedEventPayload {
 	/** True while input is awaited; false when the wait ends (answer, cancel, or error). */
 	active: boolean;
 }
+
+/** Emitted after the active tool set has been reconciled for the current run. */
+export const ASK_USER_AVAILABILITY_EVENT = "hank:ask-user:availability" as const;
+
+export interface AskUserAvailabilityEventPayload {
+	/** True only when an interactive global question tool is active and usable. */
+	available: boolean;
+}

package/index.ts

@@ -11,13 +11,16 @@
  * reconcile.ts.
  */
 
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerTool } from "./ask-user-question.ts";
 import { registerReconciler } from "./reconcile.ts";
 
 export {
+	ASK_USER_AVAILABILITY_EVENT,
 	ASK_USER_BLOCKED_EVENT,
 	ASK_USER_PROMPT_EVENT,
+	type AskUserAvailabilityEventPayload,
 	type AskUserBlockedEventPayload,
 	type AskUserPromptEventPayload,
 	type AskUserPromptOption,
@@ -26,5 +29,7 @@ export {
 
 export default function askUserQuestionExtension(pi: ExtensionAPI): void {
 	registerTool(pi);
-	registerReconciler(pi);
+	// Our own location, resolved without touching a runtime action method:
+	// nothing on `pi` may be *called* during extension loading.
+	registerReconciler(pi, fileURLToPath(import.meta.url));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-ask-user-question",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Structured questionnaire tool for Pi with numbered options, digit hotkeys and Tab-to-comment, composed from the shared permission-selector component.",
   "type": "module",
   "keywords": [

package/reconcile.ts

@@ -22,7 +22,10 @@
  * `before_agent_start` runs.
  */
 
+import { realpathSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ASK_USER_AVAILABILITY_EVENT } from "./events.ts";
 import { TOOL_NAME } from "./tool/schema.ts";
 
 /**
@@ -30,18 +33,82 @@ import { TOOL_NAME } from "./tool/schema.ts";
  * already in the right state, the active set (and every sibling tool in it) is
  * left untouched.
  */
-export function reconcileTool(pi: ExtensionAPI, ctx: ExtensionContext): void {
+export function reconcileTool(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	ownSourcePath?: string,
+): boolean {
 	const active = pi.getActiveTools();
 	const present = active.includes(TOOL_NAME);
+	let wrote = false;
 	if (!ctx.hasUI && present) {
 		pi.setActiveTools(active.filter((name) => name !== TOOL_NAME));
-	} else if (ctx.hasUI && !present) {
+		wrote = true;
+	} else if (ctx.hasUI && !present && ownsRegisteredTool(pi, ownSourcePath)) {
 		pi.setActiveTools([...active, TOOL_NAME]);
+		wrote = true;
 	}
+	// Availability is read back from the host, never assumed from the list we
+	// asked for: Pi silently ignores a name that is excluded by --tools or a
+	// tool policy, so an accepted write is not proof the tool is there. Plan
+	// mode drops its own fallback on this signal, and a false positive would
+	// leave an interactive session with no question tool at all.
+	const available =
+		ctx.hasUI && (wrote ? pi.getActiveTools() : active).includes(TOOL_NAME);
+	pi.events?.emit(ASK_USER_AVAILABILITY_EVENT, { available });
+	return available;
 }
 
-export function registerReconciler(pi: ExtensionAPI): void {
+/**
+ * Whether the name is still backed by *this* package's registration.
+ *
+ * Compared by directory, not by exact path: Pi records the extension path as
+ * it was configured (relative, npm-resolved, or synthetic) while `baseDir` is
+ * the resolved directory, and only the directory is stable across all three.
+ * Anything unknowable fails open to "ours", which preserves the original
+ * always-restore behaviour on hosts that report no source information.
+ */
+function ownsRegisteredTool(pi: ExtensionAPI, ownSourcePath?: string): boolean {
+	if (!ownSourcePath || typeof pi.getAllTools !== "function") return true;
+	const effective = pi.getAllTools().find((tool) => tool.name === TOOL_NAME);
+	if (!effective) return true;
+	const info = effective.sourceInfo as { path?: string; baseDir?: string } | undefined;
+	const ownDir = dirname(ownSourcePath);
+	if (info?.baseDir) return sameDirectory(info.baseDir, ownDir);
+	if (info?.path) return sameDirectory(dirname(info.path), ownDir);
+	return true;
+}
+
+/**
+ * Directory equality that survives a symlink on either side.
+ *
+ * `resolve()` alone is not enough, and the asymmetry is guaranteed rather than
+ * unlucky: `ownSourcePath` comes from `import.meta.url`, which Node hands back
+ * already realpath-resolved, while Pi passes `sourceInfo.baseDir` through
+ * untouched (`core/source-info.js`). Any workspace, pnpm, or npm-link install
+ * reaches the package through a symlink, so the two spellings differ for the
+ * same directory — and the caller treats a mismatch as "not ours", which would
+ * strip `ask_user_question` on the first headless run and never restore it,
+ * leaving an interactive session with no question tool at all.
+ *
+ * A `realpathSync` throw (a deleted or unreadable path) falls back to the
+ * lexical form rather than propagating, matching the fail-open posture of
+ * every other branch in `ownsRegisteredTool`.
+ */
+function sameDirectory(a: string, b: string): boolean {
+	const canonical = (path: string): string => {
+		const absolute = resolve(path);
+		try {
+			return realpathSync(absolute);
+		} catch {
+			return absolute;
+		}
+	};
+	return canonical(a) === canonical(b);
+}
+
+export function registerReconciler(pi: ExtensionAPI, ownSourcePath?: string): void {
 	pi.on("before_agent_start", (_event, ctx) => {
-		reconcileTool(pi, ctx);
+		reconcileTool(pi, ctx, ownSourcePath);
 	});
 }

package/view/dialog.ts

@@ -215,6 +215,11 @@ export class QuestionnaireDialog {
 		this.opts.done(result);
 	}
 
+	/** Cancel from an external lifecycle signal. Safe to call after user completion. */
+	cancel(): void {
+		this.finish(this.session.cancelledResult());
+	}
+
 	/** True while the free-text custom-answer editor is open. */
 	isTypingCustom(): boolean {
 		return this.tab?.customText !== undefined;