@juicesharp/rpiv-advisor 0.1.2 → 0.6.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 juicesharp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,7 +5,7 @@ implementing the advisor-strategy pattern: the executor model can escalate
 decisions to a stronger reviewer model (e.g. Opus), receive guidance, and
 resume.
 
-![Advisor model selector](https://raw.githubusercontent.com/juicesharp/rpiv-advisor/main/docs/advisor.jpg)
+![Advisor model selector](https://raw.githubusercontent.com/juicesharp/rpiv-mono/main/packages/rpiv-advisor/docs/advisor.jpg)
 
 ## Installation
 

package/advisor-ui.ts

@@ -0,0 +1,112 @@
+/**
+ * advisor-ui — bordered select-panel builders for the /advisor command.
+ *
+ * Two public functions (showAdvisorPicker, showEffortPicker) share a private
+ * buildSelectPanel helper that owns the bordered-container layout and the
+ * SelectList theme wiring.
+ */
+
+import type { ThinkingLevel } from "@mariozechner/pi-ai";
+import { DynamicBorder, type ExtensionContext, type Theme } from "@mariozechner/pi-coding-agent";
+import { Container, type SelectItem, SelectList, Spacer, Text } from "@mariozechner/pi-tui";
+
+const MAX_VISIBLE_ROWS = 10;
+const NAV_HINT = "↑↓ navigate • enter select • esc cancel";
+
+const ADVISOR_HEADER_TITLE = "Advisor Tool";
+const ADVISOR_HEADER_PROSE_1 =
+	"When the active model needs stronger judgment — a complex decision, an ambiguous " +
+	"failure, a problem it's circling without progress — it escalates to the " +
+	"advisor model for guidance, then resumes. The advisor runs server-side " +
+	"and uses additional tokens.";
+const ADVISOR_HEADER_PROSE_2 =
+	"For certain workloads, pairing a faster model as the main model with a " +
+	"more capable one as the advisor gives near-top-tier performance with " +
+	"reduced token usage.";
+
+const EFFORT_HEADER_TITLE = "Reasoning Level";
+const EFFORT_HEADER_PROSE =
+	"Choose the reasoning effort level for the advisor. " +
+	"Higher levels produce stronger judgment but use more tokens.";
+
+function selectListTheme(theme: Theme) {
+	return {
+		selectedPrefix: (t: string) => theme.bg("selectedBg", theme.fg("accent", t)),
+		selectedText: (t: string) => theme.bg("selectedBg", theme.bold(t)),
+		description: (t: string) => theme.fg("muted", t),
+		scrollInfo: (t: string) => theme.fg("dim", t),
+		noMatch: (t: string) => theme.fg("warning", t),
+	};
+}
+
+function buildSelectPanel(theme: Theme, title: string, proseLines: string[], selectList: SelectList): Container {
+	const container = new Container();
+	const border = () => new DynamicBorder((s: string) => theme.fg("accent", s));
+
+	container.addChild(border());
+	container.addChild(new Spacer(1));
+	container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+	container.addChild(new Spacer(1));
+	for (const line of proseLines) {
+		container.addChild(new Text(line, 1, 0));
+		container.addChild(new Spacer(1));
+	}
+	container.addChild(selectList);
+	container.addChild(new Spacer(1));
+	container.addChild(new Text(theme.fg("dim", NAV_HINT), 1, 0));
+	container.addChild(new Spacer(1));
+	container.addChild(border());
+	return container;
+}
+
+export async function showAdvisorPicker(ctx: ExtensionContext, items: SelectItem[]): Promise<string | null> {
+	return ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+		const selectList = new SelectList(items, Math.min(items.length, MAX_VISIBLE_ROWS), selectListTheme(theme));
+		selectList.onSelect = (item) => done(item.value);
+		selectList.onCancel = () => done(null);
+
+		const container = buildSelectPanel(
+			theme,
+			ADVISOR_HEADER_TITLE,
+			[ADVISOR_HEADER_PROSE_1, ADVISOR_HEADER_PROSE_2],
+			selectList,
+		);
+
+		return {
+			render: (w) => container.render(w),
+			invalidate: () => container.invalidate(),
+			handleInput: (data) => {
+				selectList.handleInput(data);
+				tui.requestRender();
+			},
+		};
+	});
+}
+
+export async function showEffortPicker(
+	ctx: ExtensionContext,
+	items: SelectItem[],
+	currentEffort: ThinkingLevel | undefined,
+	defaultEffort: ThinkingLevel,
+): Promise<string | null> {
+	return ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+		const selectList = new SelectList(items, Math.min(items.length, MAX_VISIBLE_ROWS), selectListTheme(theme));
+		const preferredIdx = currentEffort ? items.findIndex((item) => item.value === currentEffort) : -1;
+		selectList.setSelectedIndex(
+			preferredIdx >= 0 ? preferredIdx : items.findIndex((item) => item.value === defaultEffort),
+		);
+		selectList.onSelect = (item) => done(item.value);
+		selectList.onCancel = () => done(null);
+
+		const container = buildSelectPanel(theme, EFFORT_HEADER_TITLE, [EFFORT_HEADER_PROSE], selectList);
+
+		return {
+			render: (w) => container.render(w),
+			invalidate: () => container.invalidate(),
+			handleInput: (data) => {
+				selectList.handleInput(data);
+				tui.requestRender();
+			},
+		};
+	});
+}

package/advisor.ts

@@ -14,34 +14,77 @@
  */
 
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
 import { homedir } from "node:os";
-import { completeSimple, supportsXhigh, type Message, type ThinkingLevel } from "@mariozechner/pi-ai";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { Api, Model, StopReason, Usage } from "@mariozechner/pi-ai";
+import { completeSimple, type Message, supportsXhigh, type ThinkingLevel } from "@mariozechner/pi-ai";
 import {
-	DynamicBorder,
-	convertToLlm,
-	serializeConversation,
 	type AgentToolResult,
 	type AgentToolUpdateCallback,
+	convertToLlm,
 	type ExtensionAPI,
 	type ExtensionContext,
 	type SessionEntry,
+	serializeConversation,
 } from "@mariozechner/pi-coding-agent";
-import {
-	Container,
-	SelectList,
-	Spacer,
-	Text,
-	type SelectItem,
-} from "@mariozechner/pi-tui";
+import type { SelectItem } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { showAdvisorPicker, showEffortPicker } from "./advisor-ui.js";
 
 // ---------------------------------------------------------------------------
-// Constants
+// Constants — grouped by concern, flat named consts (no namespaced objects)
 // ---------------------------------------------------------------------------
 
+// Tool identity
 export const ADVISOR_TOOL_NAME = "advisor";
+const TOOL_LABEL = "Advisor";
+
+// Persistence
+const CONFIG_DIR = join(homedir(), ".config", "rpiv-advisor");
+const ADVISOR_CONFIG_PATH = join(CONFIG_DIR, "advisor.json");
+const CONFIG_FILE_MODE = 0o600;
+
+// Selector sentinels — double-underscore form is collision-proof against real provider:id keys
+const NO_ADVISOR_VALUE = "__no_advisor__";
+const OFF_VALUE = "__off__";
+
+// Effort levels
+const BASE_EFFORT_LEVELS: ThinkingLevel[] = ["minimal", "low", "medium", "high"];
+const XHIGH_EFFORT_LEVEL: ThinkingLevel = "xhigh";
+const DEFAULT_EFFORT: ThinkingLevel = "high";
+const RECOMMENDED_EFFORT_SUFFIX = "  (recommended)";
+
+// UI — labels used by command flow; panel prose/titles live in advisor-ui.ts
+const CHECKMARK = " ✓";
+
+// Messages (static)
+const MSG_ADVISOR_DISABLED = "Advisor disabled";
+const MSG_REQUIRES_INTERACTIVE = "/advisor requires interactive mode";
+
+// Errors (static)
+const ERR_NO_MODEL = "No advisor model is configured. The user can enable one with the /advisor command.";
+const ERR_CALL_ABORTED = "Advisor call was cancelled before it completed.";
+const ERR_EMPTY_RESPONSE = "Advisor returned no text content.";
+const ERR_NO_MODEL_SELECTED = "no advisor model selected";
+const ERR_EMPTY_RESPONSE_DETAIL = "empty response";
+const ERR_ABORTED_DETAIL = "aborted";
+const ERR_UNKNOWN = "unknown error";
+
+// Errors/messages (parameterized)
+const errMisconfigured = (label: string, err: string) => `Advisor (${label}) is misconfigured: ${err}`;
+const errNoApiKey = (label: string) => `Advisor (${label}) has no API key available.`;
+const errNoApiKeyDetail = (provider: string) => `no API key for ${provider}`;
+const errCallFailed = (err: string | undefined) => `Advisor call failed: ${err ?? ERR_UNKNOWN}`;
+const errCallThrew = (msg: string) => `Advisor call threw: ${msg}`;
+const errSelectionNotFound = (choice: string) => `Advisor selection not found: ${choice}`;
+const errModelUnavailable = (key: string) => `Previously configured advisor model ${key} is no longer available`;
+const msgAdvisorEnabled = (label: string, effort: ThinkingLevel | undefined) =>
+	`Advisor: ${label}${effort ? `, ${effort}` : ""}`;
+const msgAdvisorRestored = (label: string, effort: ThinkingLevel | undefined) =>
+	`Advisor restored: ${label}${effort ? `, ${effort}` : ""}`;
+const msgConsulting = (label: string, effort: ThinkingLevel | undefined) =>
+	`Consulting advisor (${label}${effort ? `, ${effort}` : ""})…`;
 
 // ---------------------------------------------------------------------------
 // Config file persistence (cross-session)
@@ -52,8 +95,6 @@ interface AdvisorConfig {
 	effort?: ThinkingLevel;
 }
 
-const ADVISOR_CONFIG_PATH = join(homedir(), ".config", "rpiv-advisor", "advisor.json");
-
 function loadAdvisorConfig(): AdvisorConfig {
 	if (!existsSync(ADVISOR_CONFIG_PATH)) return {};
 	try {
@@ -69,12 +110,12 @@ function saveAdvisorConfig(key: string | undefined, effort: ThinkingLevel | unde
 	if (effort) config.effort = effort;
 	try {
 		mkdirSync(dirname(ADVISOR_CONFIG_PATH), { recursive: true });
-		writeFileSync(ADVISOR_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+		writeFileSync(ADVISOR_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
 	} catch {
 		// write may fail on disk-full or permission errors — best effort only
 	}
 	try {
-		chmodSync(ADVISOR_CONFIG_PATH, 0o600);
+		chmodSync(ADVISOR_CONFIG_PATH, CONFIG_FILE_MODE);
 	} catch {
 		// chmod may fail on some filesystems — best effort only
 	}
@@ -86,26 +127,14 @@ function parseModelKey(key: string): { provider: string; modelId: string } | und
 	return { provider: key.slice(0, idx), modelId: key.slice(idx + 1) };
 }
 
-export const ADVISOR_SYSTEM_PROMPT = `You are an advisor model in an advisor-strategy pattern. An executor model is running a task end-to-end — calling tools, reading results, iterating toward a solution. When the executor hits a decision it cannot reasonably solve alone, it consults you for guidance.
-
-You read the shared conversation context and return ONE of:
-- a plan (concrete next steps the executor should take),
-- a correction (the executor is going down a wrong path — redirect it),
-- a stop signal (the executor should halt and escalate to the user).
-
-You NEVER call tools. You NEVER produce user-facing output. Be concise, directive, and grounded in the shared context. Name files, functions, and line numbers where possible. No preamble, no apologies, no meta-commentary about being an advisor — just the guidance the executor needs.`;
-
 // ---------------------------------------------------------------------------
-// Types
+// System prompt — loaded once at module init from prompts/advisor-system.txt
 // ---------------------------------------------------------------------------
 
-export interface AdvisorDetails {
-	advisorModel?: string;
-	effort?: ThinkingLevel;
-	usage?: Usage;
-	stopReason?: StopReason;
-	errorMessage?: string;
-}
+export const ADVISOR_SYSTEM_PROMPT = readFileSync(
+	fileURLToPath(new URL("./prompts/advisor-system.txt", import.meta.url)),
+	"utf-8",
+).trimEnd();
 
 // ---------------------------------------------------------------------------
 // Module state — in-memory, resets each session
@@ -144,10 +173,7 @@ export function restoreAdvisorState(ctx: ExtensionContext, pi: ExtensionAPI): vo
 	const model = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
 	if (!model) {
 		if (ctx.hasUI) {
-			ctx.ui.notify(
-				`Previously configured advisor model ${config.modelKey} is no longer available`,
-				"warning",
-			);
+			ctx.ui.notify(errModelUnavailable(config.modelKey), "warning");
 		}
 		return;
 	}
@@ -163,10 +189,7 @@ export function restoreAdvisorState(ctx: ExtensionContext, pi: ExtensionAPI): vo
 	}
 
 	if (ctx.hasUI) {
-		ctx.ui.notify(
-			`Advisor restored: ${model.provider}:${model.id}${config.effort ? `, ${config.effort}` : ""}`,
-			"info",
-		);
+		ctx.ui.notify(msgAdvisorRestored(`${model.provider}:${model.id}`, config.effort), "info");
 	}
 }
 
@@ -174,6 +197,14 @@ export function restoreAdvisorState(ctx: ExtensionContext, pi: ExtensionAPI): vo
 // Core execute logic — curate context, call advisor, return structured result
 // ---------------------------------------------------------------------------
 
+export interface AdvisorDetails {
+	advisorModel?: string;
+	effort?: ThinkingLevel;
+	usage?: Usage;
+	stopReason?: StopReason;
+	errorMessage?: string;
+}
+
 function buildErrorResult(
 	advisorLabel: string | undefined,
 	userText: string,
@@ -182,9 +213,7 @@ function buildErrorResult(
 	const effort = getAdvisorEffort();
 	return {
 		content: [{ type: "text", text: userText }],
-		details: advisorLabel
-			? { advisorModel: advisorLabel, effort, errorMessage }
-			: { effort, errorMessage },
+		details: advisorLabel ? { advisorModel: advisorLabel, effort, errorMessage } : { effort, errorMessage },
 	};
 }
 
@@ -195,30 +224,17 @@ async function executeAdvisor(
 ): Promise<AgentToolResult<AdvisorDetails>> {
 	const advisor = getAdvisorModel();
 	if (!advisor) {
-		return buildErrorResult(
-			undefined,
-			"No advisor model is configured. The user can enable one with the /advisor command.",
-			"no advisor model selected",
-		);
+		return buildErrorResult(undefined, ERR_NO_MODEL, ERR_NO_MODEL_SELECTED);
 	}
 	const advisorLabel = `${advisor.provider}:${advisor.id}`;
 	const effort = getAdvisorEffort();
 
 	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(advisor);
 	if (!auth.ok) {
-		return buildErrorResult(
-			advisorLabel,
-			`Advisor (${advisorLabel}) is misconfigured: ${auth.error}`,
-			auth.error,
-		);
+		return buildErrorResult(advisorLabel, errMisconfigured(advisorLabel, auth.error), auth.error);
 	}
 	if (!auth.apiKey) {
-		const msg = `no API key for ${advisor.provider}`;
-		return buildErrorResult(
-			advisorLabel,
-			`Advisor (${advisorLabel}) has no API key available.`,
-			msg,
-		);
+		return buildErrorResult(advisorLabel, errNoApiKey(advisorLabel), errNoApiKeyDetail(advisor.provider));
 	}
 
 	const branch = ctx.sessionManager.getBranch();
@@ -239,7 +255,7 @@ async function executeAdvisor(
 	};
 
 	onUpdate?.({
-		content: [{ type: "text", text: `Consulting advisor (${advisorLabel}${effort ? `, ${effort}` : ""})…` }],
+		content: [{ type: "text", text: msgConsulting(advisorLabel, effort) }],
 		details: { advisorModel: advisorLabel, effort },
 	});
 
@@ -252,27 +268,20 @@ async function executeAdvisor(
 
 		if (response.stopReason === "aborted") {
 			return {
-				content: [
-					{ type: "text", text: "Advisor call was cancelled before it completed." },
-				],
+				content: [{ type: "text", text: ERR_CALL_ABORTED }],
 				details: {
 					advisorModel: advisorLabel,
 					effort,
 					usage: response.usage,
 					stopReason: response.stopReason,
-					errorMessage: response.errorMessage ?? "aborted",
+					errorMessage: response.errorMessage ?? ERR_ABORTED_DETAIL,
 				},
 			};
 		}
 
 		if (response.stopReason === "error") {
 			return {
-				content: [
-					{
-						type: "text",
-						text: `Advisor call failed: ${response.errorMessage ?? "unknown error"}`,
-					},
-				],
+				content: [{ type: "text", text: errCallFailed(response.errorMessage) }],
 				details: {
 					advisorModel: advisorLabel,
 					effort,
@@ -291,13 +300,13 @@ async function executeAdvisor(
 
 		if (!advisorText) {
 			return {
-				content: [{ type: "text", text: "Advisor returned no text content." }],
+				content: [{ type: "text", text: ERR_EMPTY_RESPONSE }],
 				details: {
 					advisorModel: advisorLabel,
 					effort,
 					usage: response.usage,
 					stopReason: response.stopReason,
-					errorMessage: "empty response",
+					errorMessage: ERR_EMPTY_RESPONSE_DETAIL,
 				},
 			};
 		}
@@ -313,11 +322,7 @@ async function executeAdvisor(
 		};
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);
-		return buildErrorResult(
-			advisorLabel,
-			`Advisor call threw: ${message}`,
-			message,
-		);
+		return buildErrorResult(advisorLabel, errCallThrew(message), message);
 	}
 }
 
@@ -350,7 +355,7 @@ const ADVISOR_PROMPT_GUIDELINES: string[] = [
 export function registerAdvisorTool(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: ADVISOR_TOOL_NAME,
-		label: "Advisor",
+		label: TOOL_LABEL,
 		description: ADVISOR_DESCRIPTION,
 		promptSnippet: ADVISOR_PROMPT_SNIPPET,
 		promptGuidelines: ADVISOR_PROMPT_GUIDELINES,
@@ -381,27 +386,6 @@ export function registerAdvisorBeforeAgentStart(pi: ExtensionAPI): void {
 // /advisor slash command — opens selector panel for picking the advisor model
 // ---------------------------------------------------------------------------
 
-const ADVISOR_HEADER_TITLE = "Advisor Tool";
-
-const ADVISOR_HEADER_PROSE_1 =
-	"When the active model needs stronger judgment — a complex decision, an ambiguous " +
-	"failure, a problem it's circling without progress — it escalates to the " +
-	"advisor model for guidance, then resumes. The advisor runs server-side " +
-	"and uses additional tokens.";
-
-const ADVISOR_HEADER_PROSE_2 =
-	"For certain workloads, pairing a faster model as the main model with a " +
-	"more capable one as the advisor gives near-top-tier performance with " +
-	"reduced token usage.";
-
-const NO_ADVISOR_VALUE = "__no_advisor__";
-
-const EFFORT_HEADER_TITLE = "Reasoning Level";
-
-const EFFORT_HEADER_PROSE =
-	"Choose the reasoning effort level for the advisor. " +
-	"Higher levels produce stronger judgment but use more tokens.";
-
 function modelKey(m: { provider: string; id: string }): string {
 	return `${m.provider}:${m.id}`;
 }
@@ -411,7 +395,7 @@ export function registerAdvisorCommand(pi: ExtensionAPI): void {
 		description: "Configure the advisor model for the advisor-strategy pattern",
 		handler: async (_args, ctx) => {
 			if (!ctx.hasUI) {
-				ctx.ui.notify("/advisor requires interactive mode", "error");
+				ctx.ui.notify(MSG_REQUIRES_INTERACTIVE, "error");
 				return;
 			}
 
@@ -421,74 +405,15 @@ export function registerAdvisorCommand(pi: ExtensionAPI): void {
 
 			const items: SelectItem[] = availableModels.map((m) => {
 				const key = modelKey(m);
-				const check = key === currentKey ? " ✓" : "";
+				const check = key === currentKey ? CHECKMARK : "";
 				return { value: key, label: `${m.name}  (${m.provider})${check}` };
 			});
 			items.push({
 				value: NO_ADVISOR_VALUE,
-				label: currentKey === undefined ? "No advisor ✓" : "No advisor",
+				label: currentKey === undefined ? `No advisor${CHECKMARK}` : "No advisor",
 			});
 
-			const choice = await ctx.ui.custom<string | null>(
-				(tui, theme, _kb, done) => {
-					const container = new Container();
-
-					container.addChild(
-						new DynamicBorder((s: string) => theme.fg("accent", s)),
-					);
-					container.addChild(new Spacer(1));
-					container.addChild(
-						new Text(
-							theme.fg("accent", theme.bold(ADVISOR_HEADER_TITLE)),
-							1,
-							0,
-						),
-					);
-					container.addChild(new Spacer(1));
-					container.addChild(new Text(ADVISOR_HEADER_PROSE_1, 1, 0));
-					container.addChild(new Spacer(1));
-					container.addChild(new Text(ADVISOR_HEADER_PROSE_2, 1, 0));
-					container.addChild(new Spacer(1));
-
-					const selectList = new SelectList(
-						items,
-						Math.min(items.length, 10),
-						{
-							selectedPrefix: (t) => theme.bg("selectedBg", theme.fg("accent", t)),
-							selectedText: (t) => theme.bg("selectedBg", theme.bold(t)),
-							description: (t) => theme.fg("muted", t),
-							scrollInfo: (t) => theme.fg("dim", t),
-							noMatch: (t) => theme.fg("warning", t),
-						},
-					);
-					selectList.onSelect = (item) => done(item.value);
-					selectList.onCancel = () => done(null);
-					container.addChild(selectList);
-
-					container.addChild(new Spacer(1));
-					container.addChild(
-						new Text(
-							theme.fg("dim", "↑↓ navigate • enter select • esc cancel"),
-							1,
-							0,
-						),
-					);
-					container.addChild(new Spacer(1));
-					container.addChild(
-						new DynamicBorder((s: string) => theme.fg("accent", s)),
-					);
-
-					return {
-						render: (w) => container.render(w),
-						invalidate: () => container.invalidate(),
-						handleInput: (data) => {
-							selectList.handleInput(data);
-							tui.requestRender();
-						},
-					};
-				},
-			);
-
+			const choice = await showAdvisorPicker(ctx, items);
 			if (!choice) {
 				return;
 			}
@@ -501,104 +426,36 @@ export function registerAdvisorCommand(pi: ExtensionAPI): void {
 				setAdvisorEffort(undefined);
 				saveAdvisorConfig(undefined, undefined);
 				if (activeHas) {
-					pi.setActiveTools(
-						activeTools.filter((n) => n !== ADVISOR_TOOL_NAME),
-					);
+					pi.setActiveTools(activeTools.filter((n) => n !== ADVISOR_TOOL_NAME));
 				}
-				ctx.ui.notify("Advisor disabled", "info");
+				ctx.ui.notify(MSG_ADVISOR_DISABLED, "info");
 				return;
 			}
 
 			const picked = availableModels.find((m) => modelKey(m) === choice);
 			if (!picked) {
-				ctx.ui.notify(`Advisor selection not found: ${choice}`, "error");
+				ctx.ui.notify(errSelectionNotFound(choice), "error");
 				return;
 			}
 
 			// Effort picker — only for reasoning-capable models
 			let effortChoice: ThinkingLevel | undefined;
 			if (picked.reasoning) {
-				const OFF_VALUE = "__off__";
-				const baseLevels: ThinkingLevel[] = ["minimal", "low", "medium", "high"];
-				const levels = supportsXhigh(picked)
-					? [...baseLevels, "xhigh" as ThinkingLevel]
-					: baseLevels;
+				const levels = supportsXhigh(picked) ? [...BASE_EFFORT_LEVELS, XHIGH_EFFORT_LEVEL] : BASE_EFFORT_LEVELS;
 
 				const effortItems: SelectItem[] = [
 					{ value: OFF_VALUE, label: "off" },
 					...levels.map((level) => ({
 						value: level,
-						label: level === "high" ? `${level}  (recommended)` : level,
+						label: level === DEFAULT_EFFORT ? `${level}${RECOMMENDED_EFFORT_SUFFIX}` : level,
 					})),
 				];
 
-				const effortResult = await ctx.ui.custom<string | null>(
-					(tui, theme, _kb, done) => {
-						const container = new Container();
-
-						container.addChild(
-							new DynamicBorder((s: string) => theme.fg("accent", s)),
-						);
-						container.addChild(new Spacer(1));
-						container.addChild(
-							new Text(
-								theme.fg("accent", theme.bold(EFFORT_HEADER_TITLE)),
-								1,
-								0,
-							),
-						);
-						container.addChild(new Spacer(1));
-						container.addChild(new Text(EFFORT_HEADER_PROSE, 1, 0));
-						container.addChild(new Spacer(1));
-
-						const selectList = new SelectList(
-							effortItems,
-							Math.min(effortItems.length, 10),
-							{
-								selectedPrefix: (t) => theme.bg("selectedBg", theme.fg("accent", t)),
-								selectedText: (t) => theme.bg("selectedBg", theme.bold(t)),
-								description: (t) => theme.fg("muted", t),
-								scrollInfo: (t) => theme.fg("dim", t),
-								noMatch: (t) => theme.fg("warning", t),
-							},
-						);
-						const currentEffort = getAdvisorEffort();
-						const defaultIdx = currentEffort
-							? effortItems.findIndex((item) => item.value === currentEffort)
-							: -1;
-						selectList.setSelectedIndex(defaultIdx >= 0 ? defaultIdx : effortItems.findIndex((item) => item.value === "high"));
-						selectList.onSelect = (item) => done(item.value);
-						selectList.onCancel = () => done(null);
-						container.addChild(selectList);
-
-						container.addChild(new Spacer(1));
-						container.addChild(
-							new Text(
-								theme.fg("dim", "↑↓ navigate • enter select • esc cancel"),
-								1,
-								0,
-							),
-						);
-						container.addChild(new Spacer(1));
-						container.addChild(
-							new DynamicBorder((s: string) => theme.fg("accent", s)),
-						);
-
-						return {
-							render: (w) => container.render(w),
-							invalidate: () => container.invalidate(),
-							handleInput: (data) => {
-								selectList.handleInput(data);
-								tui.requestRender();
-							},
-						};
-					},
-				);
-
+				const effortResult = await showEffortPicker(ctx, effortItems, getAdvisorEffort(), DEFAULT_EFFORT);
 				if (!effortResult) {
 					return;
 				}
-				effortChoice = effortResult === OFF_VALUE ? undefined : effortResult as ThinkingLevel;
+				effortChoice = effortResult === OFF_VALUE ? undefined : (effortResult as ThinkingLevel);
 			}
 
 			setAdvisorEffort(effortChoice);
@@ -607,10 +464,7 @@ export function registerAdvisorCommand(pi: ExtensionAPI): void {
 			if (!activeHas) {
 				pi.setActiveTools([...activeTools, ADVISOR_TOOL_NAME]);
 			}
-			ctx.ui.notify(
-				`Advisor: ${picked.provider}:${picked.id}${effortChoice ? `, ${effortChoice}` : ""}`,
-				"info",
-			);
+			ctx.ui.notify(msgAdvisorEnabled(modelKey(picked), effortChoice), "info");
 		},
 	});
 }

package/index.ts

@@ -11,18 +11,18 @@
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import {
-    registerAdvisorTool,
-    registerAdvisorCommand,
-    registerAdvisorBeforeAgentStart,
-    restoreAdvisorState,
+	registerAdvisorBeforeAgentStart,
+	registerAdvisorCommand,
+	registerAdvisorTool,
+	restoreAdvisorState,
 } from "./advisor.js";
 
 export default function (pi: ExtensionAPI) {
-    registerAdvisorTool(pi);
-    registerAdvisorCommand(pi);
-    registerAdvisorBeforeAgentStart(pi);
+	registerAdvisorTool(pi);
+	registerAdvisorCommand(pi);
+	registerAdvisorBeforeAgentStart(pi);
 
-    pi.on("session_start", async (_event, ctx) => {
-        restoreAdvisorState(ctx, pi);
-    });
+	pi.on("session_start", async (_event, ctx) => {
+		restoreAdvisorState(ctx, pi);
+	});
 }

package/package.json

@@ -1,24 +1,40 @@
 {
   "name": "@juicesharp/rpiv-advisor",
-  "version": "0.1.2",
+  "version": "0.6.1",
   "description": "Pi extension: advisor-strategy pattern — escalate to a stronger reviewer model",
-  "keywords": ["pi-package", "pi-extension", "rpiv", "advisor"],
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "rpiv",
+    "advisor"
+  ],
   "type": "module",
   "license": "MIT",
   "author": "juicesharp",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/juicesharp/rpiv-advisor.git"
+    "url": "git+https://github.com/juicesharp/rpiv-mono.git",
+    "directory": "packages/rpiv-advisor"
   },
-  "homepage": "https://github.com/juicesharp/rpiv-advisor#readme",
+  "homepage": "https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-advisor#readme",
   "bugs": {
-    "url": "https://github.com/juicesharp/rpiv-advisor/issues"
+    "url": "https://github.com/juicesharp/rpiv-mono/issues"
   },
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "index.ts",
+    "advisor.ts",
+    "advisor-ui.ts",
+    "prompts/",
+    "README.md",
+    "LICENSE"
+  ],
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.ts"
+    ]
   },
   "peerDependencies": {
     "@mariozechner/pi-ai": "*",

package/prompts/advisor-system.txt

@@ -0,0 +1,8 @@
+You are an advisor model in an advisor-strategy pattern. An executor model is running a task end-to-end — calling tools, reading results, iterating toward a solution. When the executor hits a decision it cannot reasonably solve alone, it consults you for guidance.
+
+You read the shared conversation context and return ONE of:
+- a plan (concrete next steps the executor should take),
+- a correction (the executor is going down a wrong path — redirect it),
+- a stop signal (the executor should halt and escalate to the user).
+
+You NEVER call tools. You NEVER produce user-facing output. Be concise, directive, and grounded in the shared context. Name files, functions, and line numbers where possible. No preamble, no apologies, no meta-commentary about being an advisor — just the guidance the executor needs.