pi-bro 0.25.1 → 0.27.0

package/src/bro.ts

@@ -8,7 +8,12 @@ import {
 	resolveBtwThread,
 } from "./btw.ts";
 import { doctorReport, showBroConfigModal } from "./doctor.ts";
+import { setPiHostContext } from "./backend.ts";
 import { openElevateModal } from "./elevate.ts";
+import { openGrillModal } from "./grill.ts";
+import { openRememberModal } from "./remember.ts";
+import { registerAboutUserTool } from "./remember-tool.ts";
+import { parseGrillArguments, type GrillThread } from "./grill-engine.ts";
 import {
 	type BroResult,
 	type ModalResult,
@@ -56,6 +61,10 @@ export * from "./doctor.ts";
 export * from "./btw.ts";
 export * from "./elevate.ts";
 export * from "./elevate-engine.ts";
+export * from "./grill.ts";
+export * from "./grill-engine.ts";
+export * from "./remember-store.ts";
+export * from "./remember-engine.ts";
 export * from "./explain-modal.ts";
 
 const COMMANDS = [
@@ -71,6 +80,8 @@ const COMMANDS = [
 	{ value: "guided-review", label: "guided-review", description: "Understand and assess a PR with captured code and optional private questions" },
 	{ value: "btw", label: "btw", description: "Open a side conversation (starts conversation-only; /mode toggles full permission)" },
 	{ value: "elevate", label: "elevate", description: "Discover missing expert considerations, then improve a request" },
+	{ value: "remember-me", label: "remember-me", description: "Help write and review personal memories; agents can unfold them on demand" },
+	{ value: "grill-me", label: "grill-me", description: "A private, one-question-at-a-time decision interview" },
 	{ value: "config", label: "config", description: "Configure shared defaults and per-capability model/effort overrides" },
 	{ value: "advisor", label: "advisor", description: "Check whether the executor's advisor tool is available right now" },
 	{ value: "advisor-steer", label: "advisor-steer", description: "View, edit, save, or clear the advisor's persistent steering brief" },
@@ -82,6 +93,7 @@ export default async function bro(pi: ExtensionAPI) {
 	let lastResult: ModalResult | undefined;
 	let lastShowSteering: string | undefined;
 	let btwThread: BtwThread | undefined;
+	let grillThread: GrillThread | undefined;
 	const remember = (result: ModalResult, showSteering?: string) => {
 		if (result.source) {
 			lastResult = result;
@@ -94,9 +106,11 @@ export default async function bro(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, _ctx) => {
 		lastResult = undefined;
 		btwThread = undefined;
+		grillThread = undefined;
 	});
 
 	registerAdvisorTool(pi);
+	registerAboutUserTool(pi);
 
 	pi.registerCommand("bro", {
 		description: "Explain text, documents, and webpages; draw session turns; open a side conversation; configure Bro and the executor's advisor tool",
@@ -106,6 +120,8 @@ export default async function bro(pi: ExtensionAPI) {
 			return matches.length ? matches : null;
 		},
 		handler: async (args, ctx) => {
+			// Publish the host registry so the in-process Pi backend can resolve models and runtime keys.
+			setPiHostContext(ctx);
 			const raw = args.trim();
 			const normalized = raw.toLowerCase();
 			const parts = normalized ? normalized.split(/\s+/) : [];
@@ -285,6 +301,25 @@ export default async function bro(pi: ExtensionAPI) {
 				return;
 			}
 
+			if (action === "remember-me") {
+				if (!hasBroCustomUi(ctx)) { ctx.ui.notify("Use /bro remember-me in Pi interactive UI.", "warning"); return; }
+				try { await openRememberModal(ctx, value); }
+				catch (error) { ctx.ui.notify(withDoctor(error), "error"); }
+				return;
+			}
+
+			if (action === "grill-me") {
+				if (!hasBroCustomUi(ctx)) { ctx.ui.notify("Use /bro grill-me in Pi's interactive UI.", "warning"); return; }
+				const parsed = parseGrillArguments(value);
+				if (parsed.invalid) { ctx.ui.notify(parsed.invalid, "warning"); return; }
+				const start = Boolean(parsed.topic);
+				if (start) grillThread = { topic: parsed.topic, depth: parsed.depth, turns: [], fullAccess: false };
+				else grillThread ??= { topic: "", depth: parsed.depth, turns: [], fullAccess: false };
+				try { await openGrillModal(ctx, grillThread, { start }); }
+				catch (error) { ctx.ui.notify(withDoctor(error), "error"); }
+				return;
+			}
+
 			if (action === "elevate") {
 				if (!hasBroCustomUi(ctx)) { ctx.ui.notify("Use /bro elevate in Pi interactive UI.", "warning"); return; }
 				try { await openElevateModal(ctx, value); }
@@ -438,6 +473,8 @@ export default async function bro(pi: ExtensionAPI) {
 			description: "Bro Elevate: improve the current editor draft",
 			handler: async (ctx) => {
 				if (!hasBroCustomUi(ctx)) { ctx.ui.notify("Elevate requires Pi interactive UI.", "warning"); return; }
+				// The shortcut bypasses the /bro handler, so publish the registry here for the Pi backend.
+				setPiHostContext(ctx);
 				try { await openElevateModal(ctx as import("@earendil-works/pi-coding-agent").ExtensionCommandContext); }
 				catch (error) { ctx.ui.notify(withDoctor(error), "error"); }
 			},

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);
@@ -189,8 +194,16 @@ export class BtwModal implements Focusable {
 	private running = false;
 	private full = false;
 	private model = "";
+	private customMode = "";
 	private disposed = false;
 	onInput?: () => void;
+	onKey?: (data: string) => boolean;
+	private suggestions = "";
+
+	setSuggestions(text: string): void {
+		this.suggestions = text;
+		this.tui.requestRender();
+	}
 
 	get focused(): boolean {
 		return this._focused;
@@ -207,6 +220,7 @@ export class BtwModal implements Focusable {
 		private readonly onClose: () => void,
 		private readonly onSubmit: (value: string) => void,
 		private readonly onDispose: () => void,
+		private readonly appearance: { title?: string; commands?: string; inputLabel?: string; idleHint?: string } = {},
 	) {
 		this.input.onSubmit = (value) => {
 			if (!this.running) this.onSubmit(value);
@@ -255,6 +269,12 @@ export class BtwModal implements Focusable {
 		this.tui.requestRender();
 	}
 
+	/** Reuse the BTW modal for independent interview flows without sharing BTW state. */
+	setCustomMode(label: string): void {
+		this.customMode = label;
+		this.tui.requestRender();
+	}
+
 	clearComposer(): void {
 		this.input.setValue("");
 		this.tui.requestRender();
@@ -280,6 +300,7 @@ export class BtwModal implements Focusable {
 	}
 
 	handleInput(data: string): void {
+		if (this.onKey?.(data)) return;
 		if (matchesKey(data, "escape")) {
 			this.onClose();
 			return;
@@ -298,18 +319,24 @@ export class BtwModal implements Focusable {
 			header: () => {
 				const scroll = this.scroller.indicator();
 				const model = this.model ? this.theme.fg("dim", ` · ${this.model}`) : "";
-				const mode = this.theme.fg("dim", " · ") + (this.full ? this.theme.fg("accent", this.theme.bold(btwModeLabel(true))) : this.theme.fg("dim", btwModeLabel(false)));
-				return this.theme.fg("accent", this.theme.bold("Bro · btw")) + model + mode + this.theme.fg("dim", scroll ? ` · ${scroll}` : "");
+				const mode = this.customMode
+					? this.theme.fg("dim", this.customMode)
+					: this.theme.fg("dim", " · ") + (this.full ? this.theme.fg("accent", this.theme.bold(btwModeLabel(true))) : this.theme.fg("dim", btwModeLabel(false)));
+				const title = this.theme.fg("accent", this.theme.bold(this.appearance.title ?? "Bro · btw"));
+				// Keep Grill's access warning ahead of text the frame may truncate.
+				const header = this.customMode ? `${mode} · ${title}${model}` : title + model + mode;
+				return header + this.theme.fg("dim", scroll ? ` · ${scroll}` : "");
 			},
 			body: (rows, innerWidth) => this.scroller.view(this.markdown.render(innerWidth), rows),
 			// The frame drops lines from the top when space runs out, so the composer goes last.
 			footer: [
-				...wrapTextWithAnsi("Commands: /mode · /copy · /copy-all · /insert · /insert-all · /clear · /retry", inner),
-				this.theme.fg("accent", this.theme.bold("Your message to Bro")),
+				...(this.appearance.commands === "" ? [] : wrapTextWithAnsi(this.appearance.commands ?? "Commands: /mode · /copy · /copy-all · /insert · /insert-all · /clear · /retry", inner)),
+				...(this.suggestions ? wrapTextWithAnsi(this.theme.fg("accent", this.suggestions), inner) : []),
+				this.theme.fg("accent", this.theme.bold(this.appearance.inputLabel ?? "Your message to Bro")),
 				this.input.render(inner)[0] ?? "",
 			],
 			notice: this.noticeText ? formatNotice(this.theme, this.noticeText, this.noticeTone) : undefined,
-			hints: this.running ? "Bro is thinking… · Esc close (stops reply)" : "Enter send · Esc close",
+			hints: this.running ? "Bro is thinking… · Esc close (stops reply)" : (this.appearance.idleHint ?? "Enter send · Esc close"),
 		});
 	}
 
@@ -410,7 +437,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 +449,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 =