pi-bro 0.25.1 → 0.26.0

package/src/btw.ts

@@ -75,11 +75,13 @@ export function toggleBtwMode(thread: BtwThread): void {
 // Claude, Grok, Codex, and Muse run btw in the workspace for both modes and resume one native session across
 // /mode switches. An Agy conversation stays bound to the workspace it started in (a sandbox scratch
 // dir vs. the repo), so an access change drops it; the next turn reseeds a fresh native session
-// with the main-session context and the whole thread.
+// with the main-session context and the whole thread. Pi behaves like Agy here: its restricted mode
+// exposes no tools at all while full access uses read/bash/edit/write, so an access change must not
+// continue a session whose tool loadout is now wrong.
 // A native session remembers every earlier prompt, including old preferences, so a preferences
 // change (or deletion) on any backend starts a fresh session reseeded with the quoted thread.
 export function nativeBtwContinuation(thread: BtwThread, backend: BackendName, preferences = ""): string | undefined {
-	if (backend === "agy" && thread.conversationId && thread.sessionFull !== undefined && thread.sessionFull !== thread.full) {
+	if ((backend === "agy" || backend === "pi") && thread.conversationId && thread.sessionFull !== undefined && thread.sessionFull !== thread.full) {
 		thread.conversationId = undefined;
 	}
 	if (thread.conversationId && (thread.sessionPreferences ?? "") !== preferences) thread.conversationId = undefined;
@@ -129,13 +131,15 @@ export function parseBtwComposerCommand(value: string): BtwComposerAction {
 // existing throw-on-failure / { text, conversationId } contract. A conversationId is only ever
 // returned on success (see backend.ts's continuation handling), preserving current behavior on
 // failed turns.
+// An expired continuation is reported as `continuationExpired` so the caller can forget the dead id;
+// otherwise every later turn would resend it and the thread would stay stuck.
 export async function runBtwTurn(
 	prompt: string,
 	selection: BackendSelection,
 	options: { full: boolean; cwd: string; conversationId?: string },
 	signal: AbortSignal,
 	onProgress?: (text: string) => void,
-): Promise<{ text: string; conversationId?: string }> {
+): Promise<{ text: string; conversationId?: string; expiredContinuation?: true }> {
 	let updateTimer: ReturnType<typeof setTimeout> | undefined;
 	let latest: string | undefined;
 	const throttledProgress = onProgress
@@ -165,6 +169,7 @@ export async function runBtwTurn(
 			throttledProgress,
 		);
 		if (outcome.status === "success") return { text: outcome.text, conversationId: outcome.continuation?.id };
+		if (outcome.continuationExpired) return { text: "", expiredContinuation: true };
 		throw new Error(outcome.message);
 	} finally {
 		if (updateTimer) clearTimeout(updateTimer);
@@ -410,7 +415,7 @@ export async function openBtwModal(
 					thread.model = selectionLabel(selection);
 					thread.preferences = Boolean(preferences);
 					modal.setModel(btwHeaderLabel(thread));
-					const result = await runBtwTurn(
+					let result = await runBtwTurn(
 						buildBtwPrompt(context, question, { full, history, preferences }),
 						selection,
 						{ full, cwd: ctx.cwd, conversationId },
@@ -422,6 +427,25 @@ export async function openBtwModal(
 						},
 					);
 					if (turnController.signal.aborted) return;
+					if (result.expiredContinuation) {
+						// The native session is gone. Drop the dead id, rebuild the prompt from this thread's own
+						// transcript AND its captured main-session context (the local `context` is undefined
+						// whenever a continuation existed), and run once more so nothing is silently lost.
+						thread.conversationId = undefined;
+						modal.setNotice("Side thread expired — reseeded from the transcript and session context.", "warning");
+						const reseeded = await runBtwTurn(
+							buildBtwPrompt(thread.context, question, { full, history: formatBtwTranscript(thread.turns.slice(0, -1)), preferences }),
+							selection,
+							{ full, cwd: ctx.cwd },
+							turnController.signal,
+							(partial) => {
+								if (closed || turnController.signal.aborted) return;
+								thread.turns[thread.turns.length - 1]!.answer = partial;
+								modal.setText(transcript());
+							},
+						);
+						result = reseeded;
+					}
 					if (result.conversationId) {
 						thread.conversationId = result.conversationId;
 						thread.sessionFull = full;

package/src/config-ui.ts

@@ -11,9 +11,11 @@ import {
 import { getSelectListTheme, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
 import {
 	type AgyModelFamily,
+	type BackendName,
 	type BroSettings,
 	type Capability,
 	type ExternalBackend,
+	type PiModelChoice,
 	CAPABILITIES,
 	CAPABILITY_LABELS,
 	EXTERNAL_BACKENDS,
@@ -23,6 +25,8 @@ import {
 	capabilityOverride,
 	capabilityPair,
 	effortDisplay,
+	externalModelDisplay,
+	isExternalBackend,
 	resolveModelEffort,
 	withCapabilityOverride,
 } from "./settings.ts";
@@ -33,6 +37,21 @@ import { errorMessage } from "./util.ts";
 
 const SHOW_TURNS_PRESETS = [1, 2, 3, 5, 8];
 
+// The step-1 backend list, in display order. "Default" has no backend value and is only offered for
+// per-capability rows (a capability can inherit the shared default). "agy" is included but has no
+// EXTERNAL_BACKENDS entry: its models come from the live Agy catalog.
+const BACKEND_CHOICES: readonly { value: BackendName; label: string }[] = [
+	{ value: "agy", label: "Agy" },
+	{ value: "claude", label: "Claude" },
+	{ value: "grok", label: "Grok" },
+	{ value: "codex", label: "Codex" },
+	{ value: "muse", label: "Muse" },
+	{ value: "pi", label: "Pi" },
+] as const;
+
+// The prefix used to carry a backend selection out of the step-1 picker and into applyModelChange.
+const BACKEND_SENTINEL = "__backend__:";
+
 function showTurnsValues(current: number): string[] {
 	return [...new Set([...SHOW_TURNS_PRESETS, current])].sort((a, b) => a - b).map(String);
 }
@@ -44,6 +63,7 @@ export function createConfigModal(
 	initialSettings: BroSettings,
 	families: AgyModelFamily[],
 	persistSettings: (settings: BroSettings) => Promise<void>,
+	piModels: PiModelChoice[] = [],
 ): (tui: TuiLike, theme: Theme, keybindings: unknown, done: (value?: void) => void) => Component & { dispose?(): void } {
 	return (tui, theme, _keybindings, done) => {
 		// Size the host list once, then stop interaction if a later resize cannot show the whole
@@ -71,60 +91,140 @@ export function createConfigModal(
 			done(undefined);
 		};
 
+		// Two-step picker: backend first, then a model for that backend. Esc in step 2 returns to step 1
+		// without saving; only a complete model selection calls pickerDone, so a cancel never mutates
+		// settings. The Agy family list is step 2 for the Agy backend, keeping the catalog behavior.
 		const modelPicker = (current: string, pickerDone: (value?: string) => void, capability?: Capability) => {
 			const defaultResolved = resolveModelEffort({ model: settings.model, effort: settings.effort }, families);
-			const options: SelectItem[] = [
+			const currentBackend = capability
+				? (capabilityOverride(settings, capability) ? capabilityBackend(settings, capability) : undefined)
+				: (settings.backend ?? "agy");
+			const backendOptions: SelectItem[] = [
 				...(capability ? [{ value: "__default__", label: `Default (${defaultResolved.family?.label ?? settings.model})` }] : []),
-				...families.map((family) => ({
-					value: family.id,
-					label: `${family.label}${family.efforts.length ? "" : " · fixed effort"}`,
+				...BACKEND_CHOICES.map((choice) => ({
+					value: `${BACKEND_SENTINEL}${choice.value}`,
+					label: choice.label,
 				})),
-				// Alternative CLI entries stay last so existing Agy keyboard navigation is unaffected.
-				...Object.values(EXTERNAL_BACKENDS).flatMap((meta) =>
-					meta.models.map((model) => ({
-						value: `${meta.prefix}${model.id}`,
-						label: `${model.label} · ${meta.name}`,
-					})),
-				),
 			];
-			for (const meta of Object.values(EXTERNAL_BACKENDS)) {
-				options.push({ value: `__${meta.name}_custom__`, label: `${meta.label} · custom model ID…` });
-			}
+			const backendIndex = capability && current === "Default" ? 0 : backendOptions.findIndex((option) => option.value === `${BACKEND_SENTINEL}${currentBackend ?? "agy"}`);
+
 			const input = new Input();
-			let enteringBackend: ExternalBackend | undefined;
-			input.onSubmit = (value) => {
-				if (value.trim() && enteringBackend) {
-					const meta = EXTERNAL_BACKENDS[enteringBackend];
-					pickerDone(`${meta.prefix}${value.trim()}`);
+			let step: "backend" | "model" | "custom" = "backend";
+			let chosenBackend: BackendName | undefined;
+			let customError: string | undefined;
+
+			const buildModelOptions = (backend: BackendName): SelectItem[] => {
+				if (backend === "agy") {
+					return families.map((family) => ({
+						value: family.id,
+						label: `${family.label}${family.efforts.length ? "" : " · fixed effort"}`,
+					}));
 				}
+				const meta = EXTERNAL_BACKENDS[backend];
+				const models = backend === "pi" ? piModels.map((choice) => ({ id: choice.value, label: choice.label })) : meta.models;
+				return [
+					...models.map((model) => ({ value: `${meta.prefix}${model.id}`, label: model.label })),
+					{ value: `__${backend}_custom__`, label: `${meta.label} · custom model ID…` },
+				];
 			};
-			const picker = new SelectList(options, Math.min(options.length, 8, listRows), getSelectListTheme());
-			const selectedIndex = capability && current === "Default" ? 0 : options.findIndex((option) => option.value === current);
-			picker.setSelectedIndex(Math.max(0, selectedIndex));
+
+			let modelSelectList: SelectList | undefined;
+			const currentModelPicker = (): SelectList => {
+				if (!modelSelectList) {
+					const items = chosenBackend ? buildModelOptions(chosenBackend) : [];
+					modelSelectList = new SelectList(items, Math.min(items.length, 8, listRows), getSelectListTheme());
+					// Pi's list row shows the bare "<provider>/<id>" while the option value carries the transport
+					// prefix, so also try the prefixed form when matching the current selection.
+					const prefix = chosenBackend && chosenBackend !== "agy" ? EXTERNAL_BACKENDS[chosenBackend].prefix : "";
+					modelSelectList.setSelectedIndex(Math.max(0, items.findIndex((option) => option.value === current || option.value === `${prefix}${current}`)));
+					modelSelectList.onSelect = (item) => {
+						if (chosenBackend && chosenBackend !== "agy" && item.value === `__${chosenBackend}_custom__`) {
+							step = "custom";
+							customError = undefined;
+							tui.requestRender();
+							return;
+						}
+						pickerDone(item.value);
+					};
+					// Esc in step 2 goes back to the backend list; it never saves a half-made choice.
+					modelSelectList.onCancel = () => {
+						step = "backend";
+						chosenBackend = undefined;
+						customError = undefined;
+						tui.requestRender();
+					};
+				}
+				return modelSelectList;
+			};
+
+			const picker = new SelectList(backendOptions, Math.min(backendOptions.length, 8, listRows), getSelectListTheme());
+			picker.setSelectedIndex(Math.max(0, backendIndex));
 			picker.onSelect = (item) => {
-				const custom = (Object.keys(EXTERNAL_BACKENDS) as ExternalBackend[]).find((b) => item.value === `__${b}_custom__`);
-				if (custom) { enteringBackend = custom; tui.requestRender(); }
-				else pickerDone(item.value);
+				const value = item.value;
+				if (!value.startsWith(BACKEND_SENTINEL)) {
+					pickerDone(value); // "__default__" for a capability
+					return;
+				}
+				const backend = value.slice(BACKEND_SENTINEL.length) as BackendName;
+				chosenBackend = backend;
+				modelSelectList = undefined;
+				currentModelPicker();
+				step = "model";
+				tui.requestRender();
 			};
 			picker.onCancel = () => pickerDone();
-			const customLabel = () => enteringBackend ? EXTERNAL_BACKENDS[enteringBackend].label : "";
+
+			input.onSubmit = (value) => {
+				if (!value.trim() || !chosenBackend || chosenBackend === "agy") return;
+				// Validate before leaving the step so a malformed ID (Pi needs "<provider>/<id>") shows an
+				// inline hint and leaves the field open, instead of throwing out of the input handler.
+				const choice = `${EXTERNAL_BACKENDS[chosenBackend].prefix}${value.trim()}`;
+				try {
+					EXTERNAL_BACKENDS[chosenBackend].resolveModel(value.trim());
+				} catch (error) {
+					customError = errorMessage(error);
+					tui.requestRender();
+					return;
+				}
+				customError = undefined;
+				pickerDone(choice);
+			};
+
 			return {
 				// SettingsList draws an open submenu instead of its own list and hints, so the picker brings its own.
-				render: (width: number) => enteringBackend
-					? [
-						`${customLabel()} model ID:`,
-						...input.render(width),
-						"",
-						truncateToWidth(theme.fg("dim", "  Enter save · Esc back"), width),
-					]
-					: [...picker.render(width), "", truncateToWidth(theme.fg("dim", "  ↑/↓ choose · Enter select · Esc back"), width)],
-				invalidate: () => { picker.invalidate(); input.invalidate(); },
+				render: (width: number) => {
+					if (step === "custom" && chosenBackend && chosenBackend !== "agy") {
+						return [
+							`${EXTERNAL_BACKENDS[chosenBackend].label} model ID:${chosenBackend === "pi" ? " <provider>/<id>" : ""}`,
+							...input.render(width),
+							...(customError ? [truncateToWidth(theme.fg("warning", `  ${customError}`), width)] : []),
+							"",
+							truncateToWidth(theme.fg("dim", "  Enter save · Esc back"), width),
+						];
+					}
+					const list = step === "backend" ? picker : currentModelPicker();
+					const hint = step === "backend" ? "  ↑/↓ choose backend · Enter select · Esc back" : "  ↑/↓ choose model · Enter select · Esc back";
+					return [...list.render(width), "", truncateToWidth(theme.fg("dim", hint), width)];
+				},
+				invalidate: () => { picker.invalidate(); modelSelectList?.invalidate(); input.invalidate(); },
 				// SettingsList hands an open submenu its own events unchanged.
-				handleMouse: (event: BroMouseEvent) => (enteringBackend ? delegateMouse(input, event, { top: 1, left: 0, width: tui.terminal?.columns ?? 80, height: 1 }) : delegateMouse(picker, event)),
+				handleMouse: (event: BroMouseEvent) =>
+					step === "custom"
+						? delegateMouse(input, event, { top: 1, left: 0, width: tui.terminal?.columns ?? 80, height: 1 })
+						: delegateMouse(step === "backend" ? picker : currentModelPicker(), event),
 				handleInput: (data: string) => {
-					if (enteringBackend && matchesKey(data, "escape")) pickerDone();
-					else if (enteringBackend) input.handleInput(data);
-					else picker.handleInput(data);
+					if (step === "custom") {
+						if (matchesKey(data, "escape")) {
+							step = "model";
+							customError = undefined;
+							tui.requestRender();
+							return;
+						}
+						input.handleInput(data);
+						return;
+					}
+					if (step === "backend") picker.handleInput(data);
+					else currentModelPicker().handleInput(data);
 				},
 			};
 		};
@@ -160,17 +260,15 @@ export function createConfigModal(
 		function refresh(): void {
 			const defaultBackend = settings.backend ?? "agy";
 			const def = resolveModelEffort({ backend: settings.backend, model: settings.model, effort: settings.effort }, families);
-			modelItem.currentValue =
-				defaultBackend in EXTERNAL_BACKENDS
-					? `${EXTERNAL_BACKENDS[defaultBackend as ExternalBackend].prefix}${settings.model}`
-					: (def.family?.id ?? settings.model);
+			modelItem.currentValue = isExternalBackend(defaultBackend)
+				? externalModelDisplay(defaultBackend, settings.model)
+				: (def.family?.id ?? settings.model);
 			effortItem.currentValue = effortDisplay(def, defaultBackend);
-			effortItem.values =
-				defaultBackend in EXTERNAL_BACKENDS
-					? ["default", ...EXTERNAL_BACKENDS[defaultBackend as ExternalBackend].efforts]
-					: def.family?.efforts.length
-						? [...def.family.efforts]
-						: undefined;
+			effortItem.values = isExternalBackend(defaultBackend)
+				? ["default", ...EXTERNAL_BACKENDS[defaultBackend].efforts]
+				: def.family?.efforts.length
+					? [...def.family.efforts]
+					: undefined;
 			modeItem.currentValue = settings.mode;
 			showTurnsItem.currentValue = String(settings.showTurns);
 			showTurnsItem.values = showTurnsValues(settings.showTurns);
@@ -182,8 +280,8 @@ export function createConfigModal(
 				const rows = capabilityItems[capability];
 				rows.model.currentValue = !override
 					? "Default"
-					: backend in EXTERNAL_BACKENDS
-						? `${EXTERNAL_BACKENDS[backend as ExternalBackend].prefix}${override.model}`
+					: isExternalBackend(backend)
+						? externalModelDisplay(backend, override.model)
 						: (resolved.family?.id ?? override.model);
 				rows.effort.currentValue = effortDisplay(resolved, backend);
 				rows.effort.values =

package/src/doctor.ts

@@ -1,7 +1,13 @@
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	getAgentDir,
+	resolveModelScopeWithDiagnostics,
+	SettingsManager,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
 import {
 	ADVISOR_COMPATIBILITY,
 	ADVISOR_STEERING_FILE,
@@ -10,7 +16,7 @@ import {
 	readAdvisorSteering,
 	resolveAdvisorState,
 } from "./advisor.ts";
-import { agyFailureMessage, reviewBackendNotice } from "./backend.ts";
+import { agyFailureMessage, bridgePiRuntimeForCatalog, piEffectiveEffort, reviewBackendNotice, splitPiModel } from "./backend.ts";
 import { createConfigModal } from "./config-ui.ts";
 import { openBroOverlay } from "./modal-kit.ts";
 import {
@@ -18,6 +24,7 @@ import {
 	type AgyModelFamily,
 	type BackendName,
 	type BroSettings,
+	type PiModelChoice,
 	CAPABILITIES,
 	CAPABILITY_LABELS,
 	EFFORTS,
@@ -28,10 +35,12 @@ import {
 	isCodexEffort,
 	isGrokEffort,
 	isMuseEffort,
+	isPiEffort,
 	readPreferences,
 	readSettings,
 	resolveCapabilitySettings,
 	resolveModelEffort,
+	toPiModelChoices,
 	writeSettings,
 } from "./settings.ts";
 import { hasBroCustomUi } from "./ui-capabilities.ts";
@@ -103,6 +112,44 @@ export async function listAgyModels(pi: ExtensionAPI, signal?: AbortSignal): Pro
 	}
 }
 
+// The Pi backend's selectable models: the configured scoped models (enabledModels) when present,
+// else every model with configured auth. Physical models only -- a virtual model routes elsewhere
+// and cannot be driven as a standalone in-process session. This never makes a model request.
+export async function listPiModels(
+	ctx: ExtensionCommandContext,
+	signal?: AbortSignal,
+): Promise<{ models: PiModelChoice[]; scope: "scoped" | "available"; diagnostics: string[]; modelRuntime: Awaited<ReturnType<typeof bridgePiRuntimeForCatalog>> }> {
+	let projectTrusted = true;
+	try { projectTrusted = ctx.isProjectTrusted?.() ?? true; } catch { projectTrusted = false; }
+	const settingsManager = SettingsManager.create(ctx.cwd, getAgentDir(), { projectTrusted });
+	// Share the executor's bridge: without the host's runtime credentials this catalog would hide
+	// models that a run can actually use, so `/bro config` and `/bro doctor` would disagree with it.
+	const modelRuntime = await bridgePiRuntimeForCatalog(ctx, getAgentDir());
+	if (signal?.aborted) throw new Error("Canceled.");
+
+	const patterns = settingsManager.getEnabledModels() ?? [];
+	if (patterns.length) {
+		const resolved = await resolveModelScopeWithDiagnostics(patterns, modelRuntime);
+		const diagnostics = resolved.diagnostics.map((entry) => entry.message);
+		// A configured scope is authoritative even when it resolves to nothing: silently substituting
+		// every authenticated model would offer choices the user never scoped in, and would hide the
+		// diagnostics that explain why. The caller shows them.
+		return { models: toPiModelChoices(resolved.scopedModels), scope: "scoped", diagnostics, modelRuntime };
+	}
+
+	const available = modelRuntime.getAvailableSnapshot().map((model) => ({ model }));
+	return { models: toPiModelChoices(available), scope: "available", diagnostics: [], modelRuntime };
+}
+
+// The requested and effective Pi effort, computed rather than assumed: a model that cannot reason
+// runs at "off", and a level the model does not offer is clamped by the SDK. Reporting the real
+// value is what makes this line truthful instead of a blanket clamp claim.
+function piEffortDetail(model: Parameters<typeof piEffectiveEffort>[0], effort: string): string {
+	const effective = piEffectiveEffort(model, effort);
+	if (effective === effort) return effort === "default" ? "Pi's configured default" : effort;
+	return `${effort} → ${effective} (clamped)`;
+}
+
 async function checkAgyVersion(pi: ExtensionAPI, signal: AbortSignal): Promise<string> {
 	const runDirectory = await mkdtemp(join(tmpdir(), "pi-bro-"));
 	try {
@@ -212,6 +259,13 @@ export async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContex
 	let settings: BroSettings | undefined;
 	let models: AgyModelFamily[] | undefined;
 	let agyVersion: string | undefined;
+	let piRuntime: Awaited<ReturnType<typeof bridgePiRuntimeForCatalog>> | undefined;
+	const findPiModel = (provider: string, id: string) => {
+		const model = piRuntime?.getModel(provider, id) ?? ctx.modelRegistry.find(provider, id);
+		return model?.api === "pi-virtual" ? undefined : model;
+	};
+	const hasPiAuth = (model: NonNullable<ReturnType<typeof findPiModel>>) =>
+		piRuntime?.hasConfiguredAuth(model.provider) || ctx.modelRegistry.hasConfiguredAuth(model);
 	const pass = (name: string, detail: string) => lines.push(`- ✓ **${name}:** ${detail}`);
 	const fail = (name: string, error: unknown) => {
 		failed = true;
@@ -242,6 +296,7 @@ export async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContex
 	const grokInUse = backendInUse("grok");
 	const codexInUse = backendInUse("codex");
 	const museInUse = backendInUse("muse");
+	const piInUse = backendInUse("pi");
 
 	let agyStarted = false;
 	if (agyInUse) {
@@ -340,6 +395,23 @@ export async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContex
 		pass("Muse", "not probed — no feature selects the Muse backend");
 	}
 
+	// Pi is in-process: validate the selected physical model against the bridged runtime without a
+	// CLI spawn or a live model turn. A passing answer means the model resolves and has configured
+	// auth; it is not a connectivity test.
+	if (piInUse) {
+		try {
+			const { models: piModels, scope, diagnostics, modelRuntime } = await listPiModels(ctx, signal);
+			piRuntime = modelRuntime;
+			pass("Pi model catalog", `${piModels.length} physical model${piModels.length === 1 ? "" : "s"} selectable · ${scope === "scoped" ? "from enabledModels (scoped)" : "all models with configured auth"}`);
+			for (const diagnostic of diagnostics) lines.push(`- ℹ **Pi scoped models:** ${diagnostic}`);
+		} catch (error) {
+			if (signal.aborted) throw error;
+			fail("Pi model catalog", error);
+		}
+	} else {
+		pass("Pi", "not probed — no feature selects the Pi backend");
+	}
+
 	if (settings) {
 		const defaultBackend = settings.backend ?? "agy";
 		if (defaultBackend === "claude") {
@@ -378,6 +450,25 @@ export async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContex
 			} else {
 				pass("Reasoning effort", settings.effort);
 			}
+		} else if (defaultBackend === "pi") {
+			const parts = splitPiModel(settings.model);
+			const physical = parts ? findPiModel(parts.providerId, parts.modelId) : undefined;
+			if (!parts) {
+				fail("Selected model", `\`${settings.model}\` is not a \`<provider>/<id>\` Pi model. Run \`/bro config\` to choose another.`);
+			} else if (!physical) {
+				fail("Selected model", `pi \`${settings.model}\` is unavailable or virtual. Run \`/bro config\` to choose another.`);
+			} else {
+				if (!hasPiAuth(physical)) {
+					fail("Selected model", `pi \`${settings.model}\` has no configured auth. Sign in with Pi's /login, then run \`/bro doctor\`.`);
+				} else {
+					pass("Selected model", `pi \`${settings.model}\``);
+				}
+			}
+			if (!isPiEffort(settings.effort)) {
+				fail("Reasoning effort", `\`${settings.effort}\` is unsupported. Run \`/bro config\` to choose another.`);
+			} else {
+				pass("Reasoning effort", piEffortDetail(physical, settings.effort));
+			}
 		} else if (models) {
 			const current = resolveCatalogSettings(settings, models);
 			if (!current.family) {
@@ -455,6 +546,41 @@ export async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContex
 				);
 				continue;
 			}
+			if (backend === "pi") {
+				if (!isPiEffort(pair.effort)) {
+					fail(label, `\`${pair.effort}\` is unsupported for pi \`${pair.model}\`. Run \`/bro config\` to fix this.`);
+					continue;
+				}
+				const parts = splitPiModel(pair.model);
+				if (!parts) {
+					fail(label, `\`${pair.model}\` is not a \`<provider>/<id>\` Pi model. Run \`/bro config\` to fix this.`);
+					continue;
+				}
+				const physical = findPiModel(parts.providerId, parts.modelId);
+				if (!physical) {
+					fail(label, `\`${pair.model}\` is unavailable or virtual. Run \`/bro config\` to choose a physical model.`);
+					continue;
+				}
+				if (!hasPiAuth(physical)) {
+					fail(label, `\`${pair.model}\` resolves but has no configured auth. Sign in with Pi's /login, then run \`/bro doctor\`.`);
+					continue;
+				}
+				// Scope membership is reported separately from catalog membership: a model can be usable
+				// without being in enabledModels, and the picker would not offer it as a scoped choice.
+				const scoped = (ctx.scopedModels ?? []).some((entry) => entry.model.provider === parts.providerId && entry.model.id === parts.modelId);
+				const tools =
+					capability === "advisor"
+						? "read/bash/edit/write in the workspace, no nested delegation or MCP"
+						: capability === "btw"
+							? "none in conversation-only; read/bash/edit/write in the workspace in full permission"
+							: capability === "review"
+								? "read/grep/find/ls in the captured checkout, no shell"
+								: "no tools";
+						passCapability(
+							`${override ? "override " : ""}pi \`${pair.model}\` · effort ${piEffortDetail(physical, pair.effort)} · ${scoped ? "in your scoped models" : "not in your scoped models"} · tools: ${tools}`,
+						);
+				continue;
+			}
 			// No Agy catalog available: the Agy branch above is the only one that gets here, so there is
 			// nothing to validate, but a shell-capable review override still deserves its advisory.
 			if (!models) {
@@ -504,6 +630,8 @@ export async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContex
 		pass("Advisor compatibility", "Codex backend — no Agy version floor applies");
 	} else if (settings && capabilityBackend(settings, "advisor") === "muse") {
 		pass("Advisor compatibility", "Muse backend — no Agy version floor applies; auth/connectivity unverified (no probe)");
+	} else if (settings && capabilityBackend(settings, "advisor") === "pi") {
+		pass("Advisor compatibility", "Pi backend — runs in-process; no Agy version floor or CLI probe applies");
 	} else if (agyVersion && advisorAgyCompatible(agyVersion)) pass("Advisor compatibility", ADVISOR_COMPATIBILITY);
 	else if (agyVersion) fail("Advisor compatibility", `installed \`${agyVersion}\`; requires Agy >=1.1.15. Run \`agy update\`.`);
 
@@ -534,5 +662,16 @@ export async function showBroConfigModal(ctx: ExtensionCommandContext, pi: Exten
 		families = [];
 		ctx.ui.notify("Agy model catalog unavailable — showing other backend settings without Agy choices.", "warning");
 	}
-	await openBroOverlay<void>(ctx, createConfigModal(settings, families, writeSettings));
+	// The Pi catalog is loaded independently so /bro config still works when Agy is offline.
+	let piModels: PiModelChoice[] = [];
+	try {
+		const catalog = await listPiModels(ctx);
+		piModels = catalog.models;
+		// A configured scope that resolves to nothing leaves the Pi model list empty; say why instead of
+		// showing a silently empty picker.
+		for (const diagnostic of catalog.diagnostics) ctx.ui.notify(`Pi scoped models: ${diagnostic}`, "warning");
+	} catch (error) {
+		ctx.ui.notify(`Pi model catalog unavailable — Pi choices will be empty. ${errorMessage(error)}`, "warning");
+	}
+	await openBroOverlay<void>(ctx, createConfigModal(settings, families, writeSettings, piModels));
 }

package/src/explain-modal.ts

@@ -397,7 +397,7 @@ Quick reference. Full user guide: https://github.com/tranhoangnguyen03/pi-bro/bl
 - \`/bro guided-review <PR number or URL>\` — automatically explain and assess a PR with captured code and optional private questions (local Pi interactive only; Git and authenticated gh required).
 - Reviews save automatically. Reopen the same PR without a model call; bare \`/bro guided-review\` lists saved reviews (\`resume\` is an alias). Captured code stays unchanged.
 - Enter opens items or activates focused actions. Tab changes focus; Esc goes back, then closes from Contents. Close saves; Stop and close cancels active work first.
-- Copy finding uses the clipboard, not GitHub. Regenerate requires confirmation and reviews the same capture. For untrusted PRs, prefer Claude/Muse: file-only tools, no shell/writes/web. Codex/Grok allow shell in a read-only sandbox; Agy's sandbox permits project writes. All three show an advisory. Choose a review override in /bro config. Repository text can mislead; citations are not proof.
+- Copy finding uses the clipboard, not GitHub. Regenerate requires confirmation and reviews the same capture. For untrusted PRs, prefer Claude/Muse/Pi: file-only tools, no shell/writes/web. Codex/Grok allow shell in a read-only sandbox; Agy's sandbox permits project writes. All three show an advisory. Choose a review override in /bro config. Repository text can mislead; citations are not proof.
 
 ## Elevate
 
@@ -420,7 +420,7 @@ Quick reference. Full user guide: https://github.com/tranhoangnguyen03/pi-bro/bl
 ## Configure and check
 
 - \`/bro preferences\` — tell Bro about yourself and how you like answers; added to explain, show, btw, Elevate and Guided Review prompts, never the advisor (**Ctrl+S** save, **Ctrl+K** delete, **Ctrl+C** copy, **Esc** close)
-- \`/bro config\` — shared default and per-capability (explain/show/btw/advisor/review) backend, model, and effort; explain mode; show turns. Changes save immediately. If the terminal is too small, Esc closes config after pending saves finish; a failed save keeps it open.
+- \`/bro config\` — shared default and per-capability (explain/show/btw/advisor/review) backend, model, and effort; explain mode; show turns. Two steps: choose the backend (Agy, Claude, Grok, Codex, Muse, Pi), then its model; Esc steps back without saving. Changes save immediately. If the terminal is too small, Esc closes config after pending saves finish; a failed save keeps it open.
 - \`/bro mode [brief|balanced|faithful]\` — view or choose the explanation mode
 - \`/bro doctor\` — check settings, preferences, and every selected backend without running a model turn