@hank-warren/pi-plan-mode 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @hank-warren/pi-plan-mode
 
+## 1.5.0
+
+### Minor Changes
+
+- c079c51: Keep the completed plan out of model context, stage the Plan tools, and fail honestly when a plan cannot be saved.
+
+  The completed-plan card is a display-only session entry rendered through `registerEntryRenderer` instead of a message, so the plan stays visible and restorable in the transcript while never entering model context or compaction. `plan_mode_complete` returns a one-line `Plan saved to <path>.` pointer; the durable file remains the handoff.
+
+  `plan_mode_complete` now writes the file first and throws when the write fails, rather than reporting success and returning `undefined`. Prior state stays intact and the call is retryable.
+
+  `plan_mode_complete` and the `plan_mode_question` fallback activate when Plan mode is entered or restored, so a session that never plans does not carry their schemas. Ownership of `ask_user_question` is resolved by package directory and read back from the host rather than assumed from the write, and every reconcile is announced on an event, so the fallback no longer depends on hook order between packages. A headless run has no legitimate question tool, so the prompt and the finalize steer switch to a plain-text variant instead of naming a tool that both packages strip.
+
+  `AbortSignal` is wired through the question tool with exactly-once cleanup.
+
 ## 1.4.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-plan-mode",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Plan mode for Pi: research and design with a durable plan file that survives compaction.",
   "type": "module",
   "keywords": [

package/src/completion-tool.ts

@@ -57,7 +57,12 @@ export function planFromCompletionDetails(value: unknown) {
 
 export function planModeCompleted(plan: string, planPath?: string) {
 	return {
-		content: [{ type: "text" as const, text: `**Proposed Plan**\n\n${plan}` }],
+		content: [
+			{
+				type: "text" as const,
+				text: planPath ? `Plan saved to ${planPath}.` : "Plan saved.",
+			},
+		],
 		details: {
 			version: PLAN_MODE_COMPLETE_VERSION,
 			source: PLAN_MODE_COMPLETE_TOOL_NAME,

package/src/plan-mode.ts

@@ -28,6 +28,8 @@ import { createPlanExportController } from "./plan-export-controller.js";
 import {
 	clearPlanModeUi,
 	planModeStatusText as formatPlanModeStatusText,
+	registerPlanModeCardRenderer,
+	showPlanModePlan,
 	showStoredPlan,
 	updatePlanModeUi,
 } from "./presentation.js";
@@ -53,6 +55,7 @@ import {
 import { type PlanModeState, readLegacyThinkingCapture, restorePlanModeState } from "./state.js";
 
 const STATE_ENTRY_TYPE = "plan-mode-state";
+const ASK_USER_AVAILABILITY_EVENT = "hank:ask-user:availability";
 /**
  * Plan mode's entire enforcement surface. Everything else — bash, subagents,
  * MCP, and other extension tools — is left to the session's normal permission
@@ -72,38 +75,18 @@ const BLOCKED_TOOLS = new Set(["edit", "write"]);
 const SETTINGS_RELOAD_DEBOUNCE_MS = 75;
 
 /**
- * Which question tool the prompt should name this turn.
+ * Which question tool the prompt may name this turn, read from the tool set
+ * the model will actually see.
  *
- * Detection is by tool NAME only, with no dependency on
- * `@hank-warren/pi-ask-user-question`: any extension registering
- * `ask_user_question` is treated as the preferred implementation. It offers
- * previews, notes, question tabs, digit hotkeys and checkbox multi-select;
- * `plan_mode_question` renders through plain `ctx.ui.select` + `ctx.ui.editor`
- * and has none of them.
- *
- * Evaluated per turn rather than once at mode entry, so the prompt cannot go
- * stale if the tool set changes mid-session.
+ * `null` means neither is active — a headless run, where both interactive
+ * tools are deliberately stripped. Naming one there would send the model after
+ * a tool it cannot call, so the prompt switches to asking in plain text.
  */
-function preferredQuestionTool(pi: ExtensionAPI): string {
-	return pi.getActiveTools().includes(ASK_USER_QUESTION_TOOL)
-		? ASK_USER_QUESTION_TOOL
-		: PLAN_MODE_QUESTION_TOOL;
-}
-
-/**
- * Hide `plan_mode_question` from the model whenever the better tool is present,
- * so it never sees two overlapping question tools and cannot call the weaker
- * one. The tool stays *registered* either way, so a historical transcript still
- * resolves it, and a host without `ask_user_question` keeps it fully functional.
- *
- * Idempotent, and writes only when something actually changes: siblings are
- * untouched, and repeated `before_agent_start` events are free.
- */
-function reconcileQuestionTool(pi: ExtensionAPI, preferred: string): void {
-	if (preferred === PLAN_MODE_QUESTION_TOOL) return;
+function preferredQuestionTool(pi: ExtensionAPI): string | null {
 	const active = pi.getActiveTools();
-	if (!active.includes(PLAN_MODE_QUESTION_TOOL)) return;
-	pi.setActiveTools(active.filter((name) => name !== PLAN_MODE_QUESTION_TOOL));
+	if (active.includes(ASK_USER_QUESTION_TOOL)) return ASK_USER_QUESTION_TOOL;
+	if (active.includes(PLAN_MODE_QUESTION_TOOL)) return PLAN_MODE_QUESTION_TOOL;
+	return null;
 }
 
 type InteractiveUi = typeof import("./interactive-ui.js");
@@ -138,7 +121,41 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 	let menuController = new AbortController();
 	let settingsWatch: ReturnType<typeof watch> | undefined;
 	let settingsReloadTimer: ReturnType<typeof setTimeout> | undefined;
+	let planToolsActivated = false;
+	let currentHasUI = false;
+	let globalQuestionAvailable = false;
 	const persistState = () => pi.appendEntry<PlanModeState>(STATE_ENTRY_TYPE, state);
+
+	const reconcilePlanToolSurface = (hasUI: boolean, availability?: boolean) => {
+		currentHasUI = hasUI;
+		const active = pi.getActiveTools();
+		globalQuestionAvailable = availability ?? (hasUI && active.includes(ASK_USER_QUESTION_TOOL));
+		const wanted = new Set(active);
+		const completeWanted = planToolsActivated;
+		const fallbackWanted = planToolsActivated && hasUI && !globalQuestionAvailable;
+		if (completeWanted) wanted.add(PLAN_MODE_COMPLETE_TOOL_NAME);
+		else wanted.delete(PLAN_MODE_COMPLETE_TOOL_NAME);
+		if (fallbackWanted) wanted.add(PLAN_MODE_QUESTION_TOOL);
+		else wanted.delete(PLAN_MODE_QUESTION_TOOL);
+		const next = [...wanted];
+		if (next.length !== active.length || next.some((name, index) => name !== active[index])) {
+			pi.setActiveTools(next);
+		}
+	};
+	const activatePlanTools = (hasUI: boolean) => {
+		planToolsActivated = true;
+		reconcilePlanToolSurface(hasUI);
+	};
+
+	registerPlanModeCardRenderer(pi);
+	pi.events.on(ASK_USER_AVAILABILITY_EVENT, (payload: unknown) => {
+		const available =
+			typeof payload === "object" && payload !== null &&
+			typeof (payload as { available?: unknown }).available === "boolean"
+				? (payload as { available: boolean }).available
+				: undefined;
+		if (available !== undefined) reconcilePlanToolSurface(currentHasUI, available);
+	});
 	const planExports = createPlanExportController({
 		getState: () => state,
 		getSettings: () => settings,
@@ -183,12 +200,14 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 		label: "Plan question",
 		description:
 			"Ask the user one to three Plan-mode clarification questions with meaningful options, then wait for the answer. Only available while Plan mode is active.",
+		// Kept, now that the tool is staged: this guidance reaches the model only
+		// in a session that has actually entered Plan mode.
 		promptSnippet: "Ask user decision questions while Plan mode is active",
 		promptGuidelines: [
 			"In Plan mode, use plan_mode_question for important preferences, tradeoffs, or assumptions that cannot be discovered from read-only exploration.",
 		],
 		parameters: PLAN_MODE_QUESTION_PARAMS,
-		async execute(_toolCallId, params: unknown, _signal, _onUpdate, ctx) {
+		async execute(_toolCallId, params: unknown, signal, _onUpdate, ctx) {
 			if (!state.enabled) {
 				return planModeQuestionCancelled(
 					[],
@@ -212,11 +231,20 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 
 			const sessionGeneration = menuGeneration;
 			const questionWorkflowGeneration = workflowGeneration;
-			return answerPlanModeQuestions(parsed.questions, ctx, {
-				isCurrent: () =>
-					sessionGeneration === menuGeneration && questionWorkflowGeneration === workflowGeneration,
-				isEnabled: () => state.enabled,
-			});
+			const questionSignal = signal
+				? AbortSignal.any([signal, menuController.signal])
+				: menuController.signal;
+			return answerPlanModeQuestions(
+				parsed.questions,
+				ctx,
+				{
+					isCurrent: () =>
+						sessionGeneration === menuGeneration &&
+						questionWorkflowGeneration === workflowGeneration,
+					isEnabled: () => state.enabled,
+				},
+				questionSignal,
+			);
 		},
 	});
 
@@ -243,6 +271,10 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 		},
 	});
 
+	// Registered tools remain available for transcript replay; the active set is
+	// narrowed at session_start rather than here, because Pi refuses action
+	// methods (getActiveTools/setActiveTools) during extension loading.
+
 	pi.registerCommand("plan", {
 		description: "Enter or manage Plan mode",
 		getArgumentCompletions: completePlanArguments,
@@ -384,6 +416,9 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 
 	pi.on("session_start", async (event, ctx) => {
 		const generation = ++menuGeneration;
+		planToolsActivated = false;
+		currentHasUI = ctx.hasUI;
+		reconcilePlanToolSurface(ctx.hasUI);
 		refreshStateBeforeFirstAgentStart = event.reason === "new";
 		menuController.abort(new DOMException("Plan-mode session replaced", "AbortError"));
 		menuController = new AbortController();
@@ -401,6 +436,7 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 			state = { ...state, enabled: true, awaitingAction: state.planPath !== undefined };
 		}
 		if (persistFlagActivation) persistState();
+		if (state.enabled) activatePlanTools(ctx.hasUI);
 		updateUi(ctx);
 	});
 
@@ -430,6 +466,7 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 	});
 
 	pi.on("before_agent_start", (event, ctx) => {
+		currentHasUI = ctx.hasUI;
 		if (refreshStateBeforeFirstAgentStart) {
 			refreshStateBeforeFirstAgentStart = false;
 			restoreState(ctx);
@@ -443,11 +480,12 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 			persistState();
 			updateUi(ctx);
 		}
-		// Read fresh and write immediately, exactly like pi-ask-user-question's own
-		// reconciler, so the two hooks converge on the same result in either
-		// execution order.
-		const questionTool = preferredQuestionTool(pi);
-		reconcileQuestionTool(pi, questionTool);
+		if (state.enabled && !planToolsActivated) activatePlanTools(ctx.hasUI);
+		else reconcilePlanToolSurface(ctx.hasUI);
+		// A headless run has no legitimate question tool, whatever the active set
+		// still says: pi-ask-user-question strips its own tool on this same hook,
+		// and hook order between the two packages is not ours to depend on.
+		const questionTool = ctx.hasUI ? preferredQuestionTool(pi) : null;
 		if (state.enabled) {
 			return { systemPrompt: `${event.systemPrompt}\n\n${buildPlanModePrompt(questionTool)}` };
 		}
@@ -476,6 +514,7 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 
 	function enterPlanMode(ctx: ExtensionContext) {
 		workflowGeneration += 1;
+		activatePlanTools(ctx.hasUI);
 		state = { ...state, enabled: true, awaitingAction: false };
 		persistState();
 		updateUi(ctx);
@@ -525,20 +564,20 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 	 * Writes the durable plan file and marks the plan ready. A write failure
 	 * keeps Plan mode active rather than silently losing the plan.
 	 */
-	async function acceptCompletedPlan(plan: string, ctx: ExtensionContext) {
+	async function acceptCompletedPlan(plan: string, ctx: ExtensionContext): Promise<string> {
 		const planPath = sessionPlanPath ?? resolveSessionPlanPath(ctx);
-		sessionPlanPath = planPath;
 		try {
 			await writePlanFile(planPath, plan);
 		} catch (error: unknown) {
 			const detail = error instanceof Error ? error.message : String(error);
-			ctx.ui.notify(`Unable to save the plan to ${planPath}: ${detail}`, "error");
-			return undefined;
+			throw new Error(`Unable to save the plan to ${planPath}: ${detail}`);
 		}
+		sessionPlanPath = planPath;
 		state = { ...state, planPath, awaitingAction: true };
 		pendingReadyNonce = ++readyPresentationNonce;
 		persistState();
 		updateUi(ctx);
+		showPlanModePlan(pi, ctx, "Proposed Plan", plan);
 		return planPath;
 	}
 
@@ -551,8 +590,12 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 			ctx.ui.notify("Plan mode is not active. Use /plan first.", "warning");
 			return;
 		}
+		// Same rule as the prompt: a headless run has no question tool to name.
+		const questionTool = ctx.hasUI ? preferredQuestionTool(pi) : null;
 		sendPlanModeUserMessage(
-			`Finalize the current implementation plan now. If any material decision remains, use ${preferredQuestionTool(pi)} instead. Otherwise call plan_mode_complete alone as your final action with the complete decision-ready plan.`,
+			`Finalize the current implementation plan now. If any material decision remains, ${
+				questionTool === null ? "ask it in plain text" : `use ${questionTool}`
+			} instead. Otherwise call plan_mode_complete alone as your final action with the complete decision-ready plan.`,
 			ctx,
 		);
 	}

package/src/presentation.ts

@@ -1,10 +1,59 @@
-import { Text } from "@earendil-works/pi-tui";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Markdown, Text } from "@earendil-works/pi-tui";
+import {
+	getMarkdownTheme,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import { readPlanFile } from "./plan-file.js";
 import type { PlanModeState } from "./state.js";
 
 const STATUS_KEY = "plan-mode";
 const PLAN_WIDGET_KEY = "plan-mode-plan";
+export const PLAN_CARD_ENTRY_TYPE = "plan-mode-card";
+
+type PlanCardData = { title: string; plan: string };
+
+/**
+ * Persisted entry data is input, not a guarantee.
+ *
+ * The renderer runs against whatever is on disk, which may predate a field, be
+ * truncated by a partial write, or have been hand-edited. Pi contains a
+ * renderer throw as an inline `[plan-mode-card] renderer failed: …` box —
+ * survivable, but a needlessly ugly way to say "this card is old".
+ */
+function planCardData(value: unknown): PlanCardData | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	const { title, plan } = value as { title?: unknown; plan?: unknown };
+	return typeof title === "string" && typeof plan === "string"
+		? (value as PlanCardData)
+		: undefined;
+}
+
+/**
+ * The completed-plan card, as a display-only session entry.
+ *
+ * A custom *entry* rather than a message, which is what buys the property a
+ * message could not: Pi maps a `custom` entry to no context messages at all
+ * and skips it during compaction, so the plan stays visible and restorable in
+ * the transcript while never entering model context and never costing a
+ * compaction budget. The model gets a one-line `Plan saved to <path>.` from
+ * `plan_mode_complete` instead, and reads the durable file when it implements.
+ *
+ * pi-loop's approval card is the same mechanism for the same reason
+ * (`packages/pi-loop/src/presentation.ts`).
+ */
+export function registerPlanModeCardRenderer(pi: ExtensionAPI): void {
+	pi.registerEntryRenderer(PLAN_CARD_ENTRY_TYPE, (entry) => {
+		const data = planCardData(entry.data);
+		if (!data) return new Text("Plan card unavailable.", 0, 0);
+		return new Markdown(
+			`**${data.title}**\n\n${data.plan}`,
+			0,
+			0,
+			getMarkdownTheme(),
+		);
+	});
+}
 
 /**
  * The one thing both surfaces render.
@@ -152,14 +201,7 @@ export function showPlanModePlan(
 	plan: string,
 ) {
 	try {
-		pi.sendMessage(
-			{
-				customType: "proposed-plan",
-				content: `**${title}**\n\n${plan}`,
-				display: true,
-			},
-			{ triggerTurn: false },
-		);
+		pi.appendEntry<PlanCardData>(PLAN_CARD_ENTRY_TYPE, { title, plan });
 	} catch (error: unknown) {
 		const detail = error instanceof Error ? error.message : String(error);
 		ctx.ui.notify(`Unable to show completed plan: ${detail}`, "error");

package/src/prompt.ts

@@ -41,9 +41,29 @@ const QUESTION_TOOL_PROFILES: Record<string, QuestionToolProfile> = {
  *
  * The default keeps the exported function callable with no arguments and keeps
  * a standalone `pi-plan-mode` install reading exactly as it did before.
+ *
+ * Passing `null` builds the headless variant: no interactive question tool is
+ * active in that session, so naming one would tell the model to call a tool it
+ * cannot see. It asks in plain text instead.
  */
-export function buildPlanModePrompt(questionTool: string = PLAN_MODE_QUESTION_TOOL) {
-	const tool = QUESTION_TOOL_PROFILES[questionTool] ?? QUESTION_TOOL_PROFILES[PLAN_MODE_QUESTION_TOOL];
+export function buildPlanModePrompt(questionTool: string | null = PLAN_MODE_QUESTION_TOOL) {
+	const tool =
+		questionTool === null
+			? undefined
+			: (QUESTION_TOOL_PROFILES[questionTool] ??
+				QUESTION_TOOL_PROFILES[PLAN_MODE_QUESTION_TOOL]);
+	const askBullet = tool
+		? `Use ${tool.name} for important preferences, tradeoffs, or assumption locks that cannot be discovered by non-mutating exploration. ${tool.bounds} Do not include filler options.`
+		: "This session has no interactive question tool, so ask in plain text: put important preferences, tradeoffs, or assumption locks that non-mutating exploration cannot settle in your reply as 1-3 concise questions with 2-4 meaningful options each. Do not include filler options, and never call a question tool that is not in your tool set.";
+	const declineBullet = tool
+		? `${tool.decline}, do not jump straight to a final plan when the missing answer is high impact. Ask one concise plain-text question or proceed only with a clearly stated low-risk assumption.`
+		: "If the question goes unanswered, do not jump straight to a final plan when the missing answer is high impact. Ask it again more concisely, or proceed only with a clearly stated low-risk assumption recorded in the plan.";
+	const endingBullet = tool
+		? `If a material decision remains, use ${tool.name}. If interactive UI is unavailable, ask one concise plain-text question instead.`
+		: "If a material decision remains, ask one concise plain-text question instead.";
+	const revisionClause = tool
+		? `continue planning with ${tool.name} instead of calling plan_mode_complete`
+		: "continue planning with a plain-text question instead of calling plan_mode_complete";
 	return `${PLAN_CONTEXT_MARKER}
 # Plan Mode (Conversational)
 
@@ -73,14 +93,14 @@ You are in Plan Mode, a collaboration mode for producing a decision-complete imp
 ## Phase 3 — Implementation chat
 
 - Once intent is stable, keep asking until the spec is decision-complete: approach, interfaces, data flow, edge cases/failure modes, testing and acceptance criteria, and any migration or compatibility constraints.
-- Use ${tool.name} for important preferences, tradeoffs, or assumption locks that cannot be discovered by non-mutating exploration. ${tool.bounds} Do not include filler options.
-- ${tool.decline}, do not jump straight to a final plan when the missing answer is high impact. Ask one concise plain-text question or proceed only with a clearly stated low-risk assumption.
+- ${askBullet}
+- ${declineBullet}
 
 ## Ending each turn
 
 Every Plan-mode turn that advances or finalizes the plan must end in exactly one of these ways:
 
-- If a material decision remains, use ${tool.name}. If interactive UI is unavailable, ask one concise plain-text question instead.
+- ${endingBullet}
 - If the implementation plan is decision-complete, call plan_mode_complete alone as your final action. Do not call other tools in the same batch and do not emit a normal assistant response after it.
 
 If a follow-up asks only for clarification and does not change or challenge the plan, answer it directly, then call plan_mode_complete alone as the final action with the complete unchanged plan so it remains available for implementation.
@@ -101,7 +121,7 @@ Keep the plan concise, human and agent digestible, and free of open decisions. P
 
 The plan is saved to a durable file, so it survives compaction and can be re-read at any time.
 
-If the user requests revisions after a completed plan, the next plan_mode_complete call must contain a complete replacement, not a delta. If there is not enough information for a complete replacement, continue planning with ${tool.name} instead of calling plan_mode_complete.`;
+If the user requests revisions after a completed plan, the next plan_mode_complete call must contain a complete replacement, not a delta. If there is not enough information for a complete replacement, ${revisionClause}.`;
 }
 
 /**

package/src/question-tool.ts

@@ -152,11 +152,13 @@ export async function answerPlanModeQuestions(
 	questions: PlanModeQuestion[],
 	ctx: ExtensionContext,
 	lifecycle: { isCurrent(): boolean; isEnabled(): boolean },
+	signal?: AbortSignal,
 ) {
 	const answers = await askPlanModeQuestions(
 		questions,
 		ctx,
-		() => lifecycle.isCurrent() && lifecycle.isEnabled(),
+		() => lifecycle.isCurrent() && lifecycle.isEnabled() && !signal?.aborted,
+		signal,
 	);
 	if (!lifecycle.isCurrent()) {
 		return planModeQuestionCancelled(
@@ -186,18 +188,22 @@ export async function askPlanModeQuestions(
 	questions: PlanModeQuestion[],
 	ctx: ExtensionContext,
 	shouldContinue: () => boolean = () => true,
+	signal?: AbortSignal,
 ): Promise<PlanModeQuestionAnswer[] | undefined> {
 	const answers: PlanModeQuestionAnswer[] = [];
 	for (const question of questions) {
+		if (!shouldContinue() || signal?.aborted) return undefined;
 		const choices = question.options.map(formatPlanModeQuestionChoice);
 		const otherChoice = `${question.options.length + 1}. Other (free-form)`;
-		const choice = await ctx.ui.select(`${question.header}: ${question.question}`, [
-			...choices,
-			otherChoice,
-		]);
+		const choice = await raceWithAbort(
+			ctx.ui.select(`${question.header}: ${question.question}`, [...choices, otherChoice]),
+			signal,
+		);
 		if (!shouldContinue() || !choice) return undefined;
 		if (choice === otherChoice) {
-			const customAnswer = (await ctx.ui.editor(question.question, ""))?.trim();
+			const customAnswer = (
+				await raceWithAbort(ctx.ui.editor(question.question, ""), signal)
+			)?.trim();
 			if (!shouldContinue() || !customAnswer) return undefined;
 			answers.push({
 				id: question.id,
@@ -223,6 +229,16 @@ export async function askPlanModeQuestions(
 	return answers;
 }
 
+async function raceWithAbort<T>(operation: Promise<T>, signal?: AbortSignal): Promise<T | undefined> {
+	if (!signal) return operation;
+	if (signal.aborted) return undefined;
+	return new Promise<T | undefined>((resolve, reject) => {
+		const abort = () => resolve(undefined);
+		signal.addEventListener("abort", abort, { once: true });
+		operation.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+}
+
 function formatPlanModeQuestionChoice(option: PlanModeQuestionOption, index: number) {
 	return `${index + 1}. ${option.label}${option.description ? ` — ${option.description}` : ""}`;
 }