pi-bro 0.16.0 → 0.18.0

package/bro.ts

@@ -22,6 +22,7 @@ import {
 	agySelection,
 	advisorFlagErrorHint,
 	CLAUDE_EFFORTS,
+	GROK_EFFORTS,
 	backendSupports,
 	execute as executeBackend,
 	parseBtwAgyLine,
@@ -59,16 +60,20 @@ type TuiLike = {
 };
 type ModalKind = "loading" | "streaming" | "result" | "help" | "empty" | "error";
 type BroSource = { text: string; label?: string };
-type BroResult = { source: BroSource; text: string };
-type ModalResult = { source?: BroSource; text: string; htmlPath?: string };
+type BroResult = { source: BroSource; text: string; model?: string };
+type ModalResult = { source?: BroSource; text: string; htmlPath?: string; model?: string };
 type BtwTurn = { question: string; answer: string };
-type BtwThread = { turns: BtwTurn[]; conversationId?: string; full: boolean };
+// `context` keeps the main-session seed so a fresh native session can be reseeded with the whole
+// thread; `sessionFull` is the access mode the native session last ran in.
+type BtwThread = { turns: BtwTurn[]; conversationId?: string; full: boolean; backend?: BackendName; model?: string; context?: string; sessionFull?: boolean };
 const EFFORTS = ["default", "low", "medium", "high"] as const;
-const BACKENDS = ["agy", "claude"] as const;
+const BACKENDS = ["agy", "claude", "grok"] as const;
 type BackendName = (typeof BACKENDS)[number];
 type BroEffort = "default" | "low" | "medium" | "high" | "xhigh" | "max";
 type AgyEffort = Exclude<BroEffort, "default" | "xhigh" | "max">;
 type ClaudeEffort = (typeof CLAUDE_EFFORTS)[number];
+export { GROK_EFFORTS };
+type GrokEffort = (typeof GROK_EFFORTS)[number];
 // "advisor" is a real capability (command, Agy invocation, Doctor check) like the other three;
 // see docs/plans/2026-09-19-bro-advisor-design.md. All four share one model/effort resolution,
 // override, and Doctor-check path via this single list -- there is no configuration-only tier.
@@ -90,6 +95,11 @@ export const CLAUDE_MODELS = [
 	{ id: "sonnet", label: "Claude Sonnet" },
 	{ id: "opus", label: "Claude Opus" },
 ] as const;
+export const GROK_MODELS = [
+	{ id: "grok-4.7", label: "Grok 4.7" },
+	{ id: "grok-4.7-build-fast", label: "Grok 4.7 Build Fast" },
+] as const;
+export { backendSupports as supportsBackend };
 type AgyModelFamily = {
 	id: string;
 	label: string;
@@ -114,12 +124,9 @@ const COMMANDS = [
 	{ value: "url", label: "url", description: "Explain a public webpage" },
 	{ value: "open", label: "open", description: "Reopen the last explanation" },
 	{ value: "doctor", label: "doctor", description: "Check whether Bro is ready" },
-	{ value: "usage", label: "usage", description: "Show current Agy usage" },
-	{ value: "model", label: "model", description: "View or choose the shared default Agy model" },
-	{ value: "effort", label: "effort", description: "View or choose the shared default reasoning effort" },
 	{ value: "show", label: "show", description: "Draw what happened in recent session turns as shapes" },
 	{ value: "mode", label: "mode", description: "View or choose explanation mode (brief, balanced, faithful)" },
-	{ value: "btw", label: "btw", description: "Open a side conversation (sandboxed by default; --full edits files)" },
+	{ value: "btw", label: "btw", description: "Open a side conversation (starts conversation-only; /mode toggles full permission)" },
 	{ 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" },
@@ -501,7 +508,7 @@ export async function extractWebPage(input: string, signal?: AbortSignal): Promi
 
 function parseBackend(value: unknown, context: string): BackendName {
 	if (typeof value !== "string" || !BACKENDS.some((backend) => backend === value)) {
-		throw new Error(`${context} backend must be "agy" or "claude".`);
+		throw new Error(`${context} backend must be "agy", "claude", or "grok".`);
 	}
 	return value as BackendName;
 }
@@ -514,6 +521,10 @@ function isClaudeEffort(effort: unknown): effort is ClaudeEffort | "default" {
 	return effort === "default" || CLAUDE_EFFORTS.some((item) => item === effort);
 }
 
+function isGrokEffort(effort: unknown): effort is GrokEffort | "default" {
+	return effort === "default" || GROK_EFFORTS.some((item) => item === effort);
+}
+
 function parseModelEffortPair(value: unknown, context: string): ModelEffortPair {
 	if (!isRecord(value) || typeof value.model !== "string" || !value.model.trim()) {
 		throw new Error(`${context} must contain a model and effort set to "default", "low", "medium", or "high".`);
@@ -525,6 +536,12 @@ function parseModelEffortPair(value: unknown, context: string): ModelEffortPair
 		}
 		return { backend, model: value.model.trim(), effort: value.effort };
 	}
+	if (backend === "grok") {
+		if (!isGrokEffort(value.effort)) {
+			throw new Error(`${context} must contain a model and effort set to "default", "low", "medium", "high", or "xhigh".`);
+		}
+		return { backend, model: value.model.trim(), effort: value.effort };
+	}
 	if (!isAgyEffort(value.effort)) {
 		throw new Error(`${context} must contain a model and effort set to "default", "low", "medium", or "high".`);
 	}
@@ -573,12 +590,14 @@ export function parseBroSettings(value: unknown): BroSettings {
 		throw new Error('Settings must contain a model and effort set to "default", "low", "medium", or "high".');
 	}
 	const backend = value.backend === undefined ? undefined : parseBackend(value.backend, "Settings");
-	const effortOk = backend === "claude" ? isClaudeEffort(value.effort) : isAgyEffort(value.effort);
+	const effortOk = backend === "claude" ? isClaudeEffort(value.effort) : backend === "grok" ? isGrokEffort(value.effort) : isAgyEffort(value.effort);
 	if (!effortOk) {
 		throw new Error(
 			backend === "claude"
 				? 'Settings must contain a model and effort set to "default", "low", "medium", "high", "xhigh", or "max".'
-				: 'Settings must contain a model and effort set to "default", "low", "medium", or "high".',
+				: backend === "grok"
+					? 'Settings must contain a model and effort set to "default", "low", "medium", "high", or "xhigh".'
+					: 'Settings must contain a model and effort set to "default", "low", "medium", or "high".',
 		);
 	}
 	const mode = value.mode === undefined ? DEFAULT_BRO_MODE : parseBroMode(value.mode);
@@ -630,8 +649,8 @@ export function resolveModelEffort(
 	pair: ModelEffortPair,
 	families: AgyModelFamily[],
 ): { pair: ModelEffortPair; family?: AgyModelFamily } {
-	// Claude selections never resolve through the Agy catalog; they pass through untouched.
-	if (pair.backend === "claude") return { pair };
+	// Claude/Grok selections never resolve through the Agy catalog; they pass through untouched.
+	if (pair.backend === "claude" || pair.backend === "grok") return { pair };
 	const family = families.find((item) => item.id === pair.model || item.variants.some((variant) => variant.id === pair.model));
 	if (!family) return { pair };
 	const variant = family.variants.find((item) => item.id === pair.model);
@@ -661,19 +680,31 @@ export function resolveClaudeModel(input: string): string {
 	return alias ? alias.id : trimmed;
 }
 
+// Grok seeds resolve to themselves; any other non-empty string passes through
+// untouched as an explicit user-entered model ID (installed `grok models` confirms).
+export function resolveGrokModel(input: string): string {
+	const trimmed = input.trim();
+	if (!trimmed) throw new Error("Grok model must be a non-empty model ID (grok-4.7, grok-4.7-build-fast, or an explicit model ID).");
+	return trimmed;
+}
+
 // Routes one capability's whole pair to its backend execution selection. Agy keeps the
-// existing model/effort split; Claude carries the model plus an optional effort
+// existing model/effort split; Claude/Grok carry the model plus an optional effort
 // ("default" means the CLI's own default and is omitted). Throws for an effort the
 // resolved backend does not support instead of silently sending a mismatched pair.
 export function selectionForCapability(settings: BroSettings, capability: Capability): BackendSelection {
 	const pair = capabilityPair(settings, capability);
-	if (capabilityBackend(settings, capability) === "claude") {
-		if (!isClaudeEffort(pair.effort)) {
-			throw new Error(`\`${pair.effort}\` is not supported on the Claude backend. Run \`/bro config\` to fix this.`);
+	const backend = capabilityBackend(settings, capability);
+	if (backend === "claude" || backend === "grok") {
+		const valid = backend === "claude" ? isClaudeEffort(pair.effort) : isGrokEffort(pair.effort);
+		if (!valid) {
+			throw new Error(`\`${pair.effort}\` is not supported on the ${backend === "claude" ? "Claude" : "Grok"} backend. Run \`/bro config\` to fix this.`);
 		}
-		return pair.effort === "default"
-			? { backend: "claude", model: pair.model }
-			: { backend: "claude", model: pair.model, effort: pair.effort };
+		return (
+			pair.effort === "default"
+				? { backend, model: pair.model }
+				: { backend, model: pair.model, effort: pair.effort }
+		) as BackendSelection;
 	}
 	if (!isAgyEffort(pair.effort)) {
 		throw new Error(`\`${pair.effort}\` is not supported on the Agy backend. Run \`/bro config\` to fix this.`);
@@ -681,6 +712,12 @@ export function selectionForCapability(settings: BroSettings, capability: Capabi
 	return agySelection({ model: pair.model, effort: pair.effort });
 }
 
+// The modal label for the exact selection a request runs with: model plus effort, where an
+// omitted effort (the model's own default) reads simply "default".
+export function selectionLabel(selection: BackendSelection): string {
+	return `${selection.model} · ${selection.effort ?? "default"}`;
+}
+
 function resolveCapabilitySettings(
 	settings: BroSettings,
 	capability: Capability,
@@ -912,6 +949,27 @@ async function checkClaudeAuth(pi: ExtensionAPI, signal: AbortSignal): Promise<s
 	}
 }
 
+async function checkGrokVersion(pi: ExtensionAPI, signal: AbortSignal): Promise<string> {
+	const runDirectory = await mkdtemp(join(tmpdir(), "pi-bro-"));
+	try {
+		const result = await pi.exec("grok", ["--version"], { cwd: runDirectory, signal, timeout: 10_000 });
+		if (signal.aborted) throw new Error("Canceled.");
+		if (result.killed || result.code !== 0) {
+			const detail = result.stderr.trim() || result.stdout.trim();
+			throw new Error(
+				detail
+					? `Grok could not start: ${detail}\n\nRun \`/bro doctor\` for setup help.`
+					: "Grok could not start. Make sure Grok is installed and on PATH, then run `/bro doctor`.",
+			);
+		}
+		const version = result.stdout.trim() || result.stderr.trim();
+		if (!version) throw new Error("Grok returned no version information. Update Grok, then run `/bro doctor` again.");
+		return version;
+	} finally {
+		await rm(runDirectory, { recursive: true, force: true });
+	}
+}
+
 async function checkAgyUsage(pi: ExtensionAPI, signal: AbortSignal): Promise<string> {
 	const runDirectory = await mkdtemp(join(tmpdir(), "pi-bro-"));
 	try {
@@ -958,10 +1016,11 @@ async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, sign
 		fail("Prompt", error);
 	}
 
-	// Probe only the backends some feature actually selects: a Claude-only setup never
+	// Probe only the backends some feature actually selects: a Claude/Grok-only setup never
 	// requires Agy to be installed, and vice versa.
 	const agyInUse = !settings || capabilityBackend(settings, "explain") === "agy" || capabilityBackend(settings, "show") === "agy" || capabilityBackend(settings, "btw") === "agy" || capabilityBackend(settings, "advisor") === "agy" || (settings.backend ?? "agy") === "agy";
 	const claudeInUse = !!settings && (capabilityBackend(settings, "explain") === "claude" || capabilityBackend(settings, "show") === "claude" || capabilityBackend(settings, "btw") === "claude" || capabilityBackend(settings, "advisor") === "claude" || settings.backend === "claude");
+	const grokInUse = !!settings && (capabilityBackend(settings, "explain") === "grok" || capabilityBackend(settings, "show") === "grok" || capabilityBackend(settings, "btw") === "grok" || capabilityBackend(settings, "advisor") === "grok" || settings.backend === "grok");
 
 	let agyStarted = false;
 	if (agyInUse) {
@@ -1014,12 +1073,35 @@ async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, sign
 		pass("Claude", "not probed — no feature selects the Claude backend");
 	}
 
+	// Version only, never a model request. No Grok auth probe exists, so a passing
+	// version says the CLI starts — it says nothing about auth or connectivity.
+	if (grokInUse) {
+		try {
+			pass("Grok", await checkGrokVersion(pi, signal));
+		} catch (error) {
+			if (signal.aborted) throw error;
+			fail("Grok", error);
+		}
+		pass("Grok auth", "unverified — no auth probe exists (version does not imply auth or connectivity)");
+	} else {
+		pass("Grok", "not probed — no feature selects the Grok backend");
+	}
+
 	if (settings) {
 		const defaultBackend = settings.backend ?? "agy";
 		if (defaultBackend === "claude") {
 			pass("Selected model", `claude \`${settings.model}\``);
 			if (!isClaudeEffort(settings.effort)) {
-				fail("Reasoning effort", `\`${settings.effort}\` is unsupported. Run \`/bro effort\` to choose another.`);
+				fail("Reasoning effort", `\`${settings.effort}\` is unsupported. Run \`/bro config\` to choose another.`);
+			} else if (settings.effort === "default") {
+				pass("Reasoning effort", "built into the selected model");
+			} else {
+				pass("Reasoning effort", settings.effort);
+			}
+		} else if (defaultBackend === "grok") {
+			pass("Selected model", `grok \`${settings.model}\``);
+			if (!isGrokEffort(settings.effort)) {
+				fail("Reasoning effort", `\`${settings.effort}\` is unsupported. Run \`/bro config\` to choose another.`);
 			} else if (settings.effort === "default") {
 				pass("Reasoning effort", "built into the selected model");
 			} else {
@@ -1028,7 +1110,7 @@ async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, sign
 		} else if (models) {
 			const current = resolveCatalogSettings(settings, models);
 			if (!current.family) {
-				fail("Selected model", `\`${settings.model}\` is unavailable. Run \`/bro model\` to choose another.`);
+				fail("Selected model", `\`${settings.model}\` is unavailable. Run \`/bro config\` to choose another.`);
 			} else {
 				pass("Selected model", `agy \`${current.family.id}\``);
 				const effort = current.settings.effort;
@@ -1037,7 +1119,7 @@ async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, sign
 				} else if (effort !== "default" && current.family.efforts.includes(effort as AgyEffort)) {
 					pass("Reasoning effort", effort);
 				} else {
-					fail("Reasoning effort", `\`${effort}\` is unsupported. Run \`/bro effort\` to choose another.`);
+					fail("Reasoning effort", `\`${effort}\` is unsupported. Run \`/bro config\` to choose another.`);
 				}
 			}
 		}
@@ -1048,10 +1130,6 @@ async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, sign
 			const backend = capabilityBackend(settings, capability);
 			const pair = capabilityPair(settings, capability);
 			if (backend === "claude") {
-				if (capability === "btw") {
-					fail(label, "`btw` is not supported on the Claude backend. Run `/bro config` to give it an Agy model.");
-					continue;
-				}
 				if (!isClaudeEffort(pair.effort)) {
 					fail(label, `\`${pair.effort}\` is unsupported for claude \`${pair.model}\`. Run \`/bro config\` to fix this.`);
 					continue;
@@ -1064,6 +1142,23 @@ async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, sign
 				);
 				continue;
 			}
+			if (backend === "grok") {
+				if (!backendSupports("grok", capability)) {
+					fail(label, `\`${capability}\` is not supported on the Grok backend for this capability. Run \`/bro config\` to give it another backend.`);
+					continue;
+				}
+				if (!isGrokEffort(pair.effort)) {
+					fail(label, `\`${pair.effort}\` is unsupported for grok \`${pair.model}\`. Run \`/bro config\` to fix this.`);
+					continue;
+				}
+				pass(
+					label,
+					override
+						? `override grok \`${pair.model}\`${pair.effort === "default" ? "" : ` (${pair.effort})`}`
+						: `grok \`${pair.model}\`${pair.effort === "default" ? "" : ` (${pair.effort})`} · using the shared default`,
+				);
+				continue;
+			}
 			if (!models) continue;
 			const resolved = resolveCapabilitySettings(settings, capability, models);
 			if (!resolved.family) {
@@ -1096,13 +1191,15 @@ async function doctorReport(pi: ExtensionAPI, ctx: ExtensionCommandContext, sign
 	pass("Advisor steering", resolveAdvisorState(ctx.sessionManager.getBranch()).steering.trim() ? "present" : "none");
 	if (settings && capabilityBackend(settings, "advisor") === "claude") {
 		pass("Advisor compatibility", "Claude backend — no Agy version floor applies");
+	} else if (settings && capabilityBackend(settings, "advisor") === "grok") {
+		pass("Advisor compatibility", "Grok backend — no Agy version floor applies; auth/connectivity unverified (no probe)");
 	} 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\`.`);
 
 	return `# Bro doctor\n\n${lines.join("\n")}\n\n**${failed ? "Bro needs attention." : "Bro is ready."}**\n\n${
 		failed
 			? "Fix the failed items, then press **R** to check again."
-			: "No assistant response was sent and no model turn was run. Claude version/auth status does not imply connectivity."
+			: "No assistant response was sent and no model turn was run. Version/auth checks do not imply connectivity (Grok auth is unverified — no probe exists)."
 	}`;
 }
 
@@ -1295,8 +1392,9 @@ async function simplify(
 	signal: AbortSignal,
 	settings: BroSettings,
 	onProgress?: (text: string) => void,
-): Promise<string> {
-	return runAgyText((await promptFor(response, settings.mode)).text, selectionForCapability(settings, "explain"), signal, onProgress);
+): Promise<{ text: string; model: string }> {
+	const selection = selectionForCapability(settings, "explain");
+	return { text: await runAgyText((await promptFor(response, settings.mode)).text, selection, signal, onProgress), model: selectionLabel(selection) };
 }
 
 async function runShowExplanation(
@@ -1305,8 +1403,9 @@ async function runShowExplanation(
 	signal: AbortSignal,
 	settings: BroSettings,
 	onProgress?: (text: string) => void,
-): Promise<string> {
-	return runAgyText(buildShowPrompt(transcript, steering), selectionForCapability(settings, "show"), signal, onProgress, "show");
+): Promise<{ text: string; model: string }> {
+	const selection = selectionForCapability(settings, "show");
+	return { text: await runAgyText(buildShowPrompt(transcript, steering), selection, signal, onProgress, "show"), model: selectionLabel(selection) };
 }
 
 // Thin presentation-boundary wrapper around the shared backend: coalesces raw text progress to the
@@ -1688,7 +1787,7 @@ export function advisorAttemptLabel(details: AdvisorToolDetails): string {
 		return `Bro advisor · ${details.model ?? "unknown model"} · ${details.attempt} attempt${details.attempt === 1 ? "" : "s"} · ${Math.ceil((details.durationMs ?? details.elapsedMs) / 1_000)}s`;
 	}
 	const latest = details.activity?.at(-1);
-	const backendLabel = details.backend === "claude" ? "Claude" : "Agy";
+	const backendLabel = details.backend === "claude" ? "Claude" : details.backend === "grok" ? "Grok" : "Agy";
 	// "last reported" + freshness, never a claim about what the backend is doing right now and never
 	// "stalled" -- silence since lastActivityAt is not itself evidence of a stuck run.
 	const activityLabel = latest
@@ -1708,9 +1807,10 @@ function showTurnsValues(current: number): string[] {
 // falsely healthy for an unavailable model), and flags a stored effort that isn't one of the
 // resolved family's supported efforts instead of silently showing it as if it were valid.
 function effortDisplay(resolved: { pair: ModelEffortPair; family?: AgyModelFamily }, backend: BackendName): string {
-	// Claude selections never touch the Agy catalog: the stored effort is valid exactly
-	// when it is one of the Claude levels (or "default" for the CLI's own default).
+	// Claude/Grok selections never touch the Agy catalog: the stored effort is valid exactly
+	// when it is one of that backend's levels (or "default" for the CLI's own default).
 	if (backend === "claude") return isClaudeEffort(resolved.pair.effort) ? resolved.pair.effort : `${resolved.pair.effort} (unsupported)`;
+	if (backend === "grok") return isGrokEffort(resolved.pair.effort) ? resolved.pair.effort : `${resolved.pair.effort} (unsupported)`;
 	if (!resolved.family) return "unavailable";
 	const fixed = !resolved.family.efforts.length;
 	const valid = fixed ? resolved.pair.effort === "default" : resolved.family.efforts.includes(resolved.pair.effort as AgyEffort);
@@ -1718,7 +1818,7 @@ function effortDisplay(resolved: { pair: ModelEffortPair; family?: AgyModelFamil
 	return fixed ? "fixed" : resolved.pair.effort;
 }
 
-// Model-picker values that switch to the Claude backend carry a "claude:" prefix so one
+// Model-picker values that switch backend carry a "claude:"/"grok:" prefix so one
 // atomic picker commit changes backend+model together -- cancelling the picker (Esc)
 // leaves both unchanged via the existing submenu-cancel path.
 const CLAUDE_OPTION_PREFIX = "claude:";
@@ -1727,6 +1827,19 @@ function parseClaudeOption(value: string): string | undefined {
 		? value.slice(CLAUDE_OPTION_PREFIX.length)
 		: undefined;
 }
+const GROK_OPTION_PREFIX = "grok:";
+function parseGrokOption(value: string): string | undefined {
+	return value.startsWith(GROK_OPTION_PREFIX) && value.length > GROK_OPTION_PREFIX.length
+		? value.slice(GROK_OPTION_PREFIX.length)
+		: undefined;
+}
+function parseBackendOption(value: string): { backend: "claude" | "grok"; id: string } | undefined {
+	const claudeId = parseClaudeOption(value);
+	if (claudeId !== undefined) return { backend: "claude", id: claudeId };
+	const grokId = parseGrokOption(value);
+	if (grokId !== undefined) return { backend: "grok", id: grokId };
+	return undefined;
+}
 
 // Testable core: takes settings/catalog/persist as plain arguments so smoke tests can drive
 // the exact interaction (submenus, cancel, cycling, save failure) without a real Agy process
@@ -1764,30 +1877,38 @@ export function createConfigModal(
 					value: family.id,
 					label: `${family.label}${family.efforts.length ? "" : " · fixed effort"}`,
 				})),
-				// Claude entries stay last so existing Agy keyboard navigation is unaffected.
+				// Claude/Grok entries stay last so existing Agy keyboard navigation is unaffected.
 				...CLAUDE_MODELS.map((model) => ({
 					value: `${CLAUDE_OPTION_PREFIX}${model.id}`,
 					label: `${model.label} · claude`,
 				})),
+				...GROK_MODELS.map((model) => ({
+					value: `${GROK_OPTION_PREFIX}${model.id}`,
+					label: `${model.label} · grok`,
+				})),
 			];
 			options.push({ value: "__claude_custom__", label: "Claude · custom model ID…" });
+			options.push({ value: "__grok_custom__", label: "Grok · custom model ID…" });
 			const input = new Input();
-			let enteringModel = false;
-			input.onSubmit = (value) => { if (value.trim()) pickerDone(`${CLAUDE_OPTION_PREFIX}${value.trim()}`); };
+			let enteringBackend: "claude" | "grok" | undefined;
+			input.onSubmit = (value) => {
+				if (value.trim() && enteringBackend) pickerDone(`${enteringBackend === "claude" ? CLAUDE_OPTION_PREFIX : GROK_OPTION_PREFIX}${value.trim()}`);
+			};
 			const picker = new SelectList(options, Math.min(options.length, 8), getSelectListTheme());
 			const selectedIndex = capability && current === "Default" ? 0 : options.findIndex((option) => option.value === current);
 			picker.setSelectedIndex(Math.max(0, selectedIndex));
 			picker.onSelect = (item) => {
-				if (item.value === "__claude_custom__") { enteringModel = true; tui.requestRender(); }
+				if (item.value === "__claude_custom__") { enteringBackend = "claude"; tui.requestRender(); }
+				else if (item.value === "__grok_custom__") { enteringBackend = "grok"; tui.requestRender(); }
 				else pickerDone(item.value);
 			};
 			picker.onCancel = () => pickerDone();
 			return {
-				render: (width: number) => enteringModel ? ["Claude model ID (Enter saves, Esc cancels)", ...input.render(width)] : picker.render(width),
+				render: (width: number) => enteringBackend ? [`${enteringBackend === "claude" ? "Claude" : "Grok"} model ID (Enter saves, Esc cancels)`, ...input.render(width)] : picker.render(width),
 				invalidate: () => { picker.invalidate(); input.invalidate(); },
 				handleInput: (data: string) => {
-					if (enteringModel && matchesKey(data, "escape")) pickerDone();
-					else if (enteringModel) input.handleInput(data);
+					if (enteringBackend && matchesKey(data, "escape")) pickerDone();
+					else if (enteringBackend) input.handleInput(data);
 					else picker.handleInput(data);
 				},
 			};
@@ -1823,10 +1944,10 @@ export function createConfigModal(
 
 		function refresh(): void {
 			const defaultBackend = settings.backend ?? "agy";
-			const def = resolveModelEffort({ model: settings.model, effort: settings.effort }, families);
-			modelItem.currentValue = defaultBackend === "claude" ? `${CLAUDE_OPTION_PREFIX}${settings.model}` : (def.family?.id ?? settings.model);
+			const def = resolveModelEffort({ backend: settings.backend, model: settings.model, effort: settings.effort }, families);
+			modelItem.currentValue = defaultBackend === "claude" ? `${CLAUDE_OPTION_PREFIX}${settings.model}` : defaultBackend === "grok" ? `${GROK_OPTION_PREFIX}${settings.model}` : (def.family?.id ?? settings.model);
 			effortItem.currentValue = effortDisplay(def, defaultBackend);
-			effortItem.values = defaultBackend === "claude" ? ["default", ...CLAUDE_EFFORTS] : def.family?.efforts.length ? [...def.family.efforts] : undefined;
+			effortItem.values = defaultBackend === "claude" ? ["default", ...CLAUDE_EFFORTS] : defaultBackend === "grok" ? ["default", ...GROK_EFFORTS] : def.family?.efforts.length ? [...def.family.efforts] : undefined;
 			modeItem.currentValue = settings.mode;
 			showTurnsItem.currentValue = String(settings.showTurns);
 			showTurnsItem.values = showTurnsValues(settings.showTurns);
@@ -1840,9 +1961,11 @@ export function createConfigModal(
 					? "Default"
 					: backend === "claude"
 						? `${CLAUDE_OPTION_PREFIX}${override.model}`
-						: (resolved.family?.id ?? override.model);
+						: backend === "grok"
+							? `${GROK_OPTION_PREFIX}${override.model}`
+							: (resolved.family?.id ?? override.model);
 				rows.effort.currentValue = backendSupports(backend, capability) ? effortDisplay(resolved, backend) : "unsupported backend";
-				rows.effort.values = backend === "claude" ? ["default", ...CLAUDE_EFFORTS] : resolved.family?.efforts.length ? [...resolved.family.efforts] : undefined;
+				rows.effort.values = backend === "claude" ? ["default", ...CLAUDE_EFFORTS] : backend === "grok" ? ["default", ...GROK_EFFORTS] : resolved.family?.efforts.length ? [...resolved.family.efforts] : undefined;
 			}
 		}
 		refresh();
@@ -1897,14 +2020,19 @@ export function createConfigModal(
 
 		const onChange = (id: string, newValue: string) => {
 			if (id === "model") {
-				const claudeId = parseClaudeOption(newValue);
-				if (claudeId !== undefined) {
-					const effort = settings.backend === "claude" && isClaudeEffort(settings.effort) ? settings.effort : "default";
-					settings = { ...settings, backend: "claude", model: resolveClaudeModel(claudeId), effort };
+				const switched = parseBackendOption(newValue);
+				if (switched !== undefined) {
+					if (switched.backend === "claude") {
+						const effort = settings.backend === "claude" && isClaudeEffort(settings.effort) ? settings.effort : "default";
+						settings = { ...settings, backend: "claude", model: resolveClaudeModel(switched.id), effort };
+					} else {
+						const effort = settings.backend === "grok" && isGrokEffort(settings.effort) ? settings.effort : "default";
+						settings = { ...settings, backend: "grok", model: resolveGrokModel(switched.id), effort };
+					}
 				} else {
 					const family = findFamily(newValue);
 					if (!family) return;
-					const keepCurrent = settings.backend !== "claude" && (settings.effort === "default" ? !family.efforts.length : family.efforts.includes(settings.effort as AgyEffort));
+					const keepCurrent = (settings.backend ?? "agy") === "agy" && (settings.effort === "default" ? !family.efforts.length : family.efforts.includes(settings.effort as AgyEffort));
 					// Backend-less internal pairs mean Agy; disk saves still tag them explicitly.
 					const { backend: _dropped, ...rest } = settings;
 					settings = { ...rest, model: family.id, effort: keepCurrent ? settings.effort : preferredEffort(family) };
@@ -1913,6 +2041,9 @@ export function createConfigModal(
 				if ((settings.backend ?? "agy") === "claude") {
 					if (!isClaudeEffort(newValue)) return;
 					settings = { ...settings, effort: newValue };
+				} else if ((settings.backend ?? "agy") === "grok") {
+					if (!isGrokEffort(newValue)) return;
+					settings = { ...settings, effort: newValue };
 				} else {
 					// Effort-only edit: pin the resolved family's canonical id, same reasoning as the
 					// capability-override effort-only edit below -- otherwise a shared default created
@@ -1936,14 +2067,22 @@ export function createConfigModal(
 					if (newValue === "__default__") {
 						settings = withCapabilityOverride(settings, capability, undefined);
 					} else {
-						const claudeId = parseClaudeOption(newValue);
-						if (claudeId !== undefined) {
+						const switched = parseBackendOption(newValue);
+						if (switched !== undefined) {
 							const currentEffort = capabilityPair(settings, capability).effort;
-							settings = withCapabilityOverride(settings, capability, {
-								backend: "claude",
-								model: resolveClaudeModel(claudeId),
-								effort: capabilityBackend(settings, capability) === "claude" && isClaudeEffort(currentEffort) ? currentEffort : "default",
-							});
+							if (switched.backend === "claude") {
+								settings = withCapabilityOverride(settings, capability, {
+									backend: "claude",
+									model: resolveClaudeModel(switched.id),
+									effort: capabilityBackend(settings, capability) === "claude" && isClaudeEffort(currentEffort) ? currentEffort : "default",
+								});
+							} else {
+								settings = withCapabilityOverride(settings, capability, {
+									backend: "grok",
+									model: resolveGrokModel(switched.id),
+									effort: capabilityBackend(settings, capability) === "grok" && isGrokEffort(currentEffort) ? currentEffort : "default",
+								});
+							}
 						} else {
 							const family = findFamily(newValue);
 							if (!family) return;
@@ -1960,6 +2099,11 @@ export function createConfigModal(
 					const existing = capabilityOverride(settings, capability);
 					const model = existing?.model ?? settings.model;
 					settings = withCapabilityOverride(settings, capability, { backend: "claude", model, effort: newValue });
+				} else if (capabilityBackend(settings, capability) === "grok") {
+					if (!isGrokEffort(newValue)) return;
+					const existing = capabilityOverride(settings, capability);
+					const model = existing?.model ?? settings.model;
+					settings = withCapabilityOverride(settings, capability, { backend: "grok", model, effort: newValue });
 				} else {
 					// Effort-only edit: pin the resolved family's canonical id, never whatever raw
 					// string happens to sit in settings.model/override.model (which — for a shared
@@ -2023,14 +2167,13 @@ export async function showBroConfigModal(ctx: ExtensionCommandContext, pi: Exten
 		ctx.ui.notify(withDoctor(error), "error");
 		return;
 	}
-	// A Claude-only setup (shared default and every override on Claude) opens without the
-	// Agy catalog; anything still on Agy keeps the previous hard requirement.
+	// Keep configuration repair accessible even when the Agy catalog is unavailable.
 	let families: AgyModelFamily[];
 	try {
 		families = await listAgyModels(pi);
 	} catch (error) {
 		families = [];
-		ctx.ui.notify("Agy model catalog unavailable — showing Claude settings without Agy choices.", "warning");
+		ctx.ui.notify("Agy model catalog unavailable — showing Claude/Grok settings without Agy choices.", "warning");
 	}
 	await ctx.ui.custom<void>(createConfigModal(settings, families, writeSettings), {
 		overlay: true,
@@ -2160,101 +2303,62 @@ export function helpText(settings?: BroSettings, settingsError?: string): string
 	const settingsSummary = settings
 		? `- **Backend:** ${settings.backend ?? "agy"}\n- **Model:** \`${settings.model}\`\n- **Reasoning effort:** ${settings.effort === "default" ? "built into the selected model" : settings.effort}\n- **Mode:** ${settings.mode}\n- **Show turns:** ${settings.showTurns}${overrideLines.length ? `\n${overrideLines.join("\n")}` : ""}`
 		: `Bro could not read its settings: ${settingsError}\n\nRun \`/bro doctor\` for setup help.`;
-	const advisorBackend = settings ? capabilityBackend(settings, "advisor") : "agy";
-	const advisorProcess = advisorBackend === "claude" ? "Claude process" : "Agy process";
 	return `# Bro
 
-Bro explains a dense assistant reply, pasted text, local document, or public webpage in plain language, draws recent session turns as shapes, or opens a sandboxed side conversation with \`/bro btw\` — without adding anything to Pi's conversation.
+Quick reference. The README is the full user guide: https://github.com/tranhoangnguyen03/pi-bro#readme
 
-## Explain
+## Explain and show
 
 - \`/bro\` — explain the latest completed assistant reply
 - \`/bro text [text]\` — explain pasted text, or the latest reply when text is omitted
-- \`/bro file <path>\` — explain a Markdown, text, PDF, or DOCX file
+- \`/bro file <path>\` — explain a workspace \`.md\`, \`.markdown\`, \`.txt\`, \`.pdf\`, or \`.docx\` file
 - \`/bro url <url>\` — explain one public webpage
-- \`/bro open\` — reopen the latest explanation
-- \`/bro show [n-turns] [query]\` — draw the last few session turns (default 1) as shapes, from user and assistant conversation text only (tool calls, tool results, reasoning, and images are omitted); add a query to steer what the shapes focus on
-
-Any other input is the source itself: a lone URL explains that webpage, an existing workspace file with a supported extension explains that file, and anything else is explained as pasted text. Quoted paths with spaces are routed too when the file exists.
-
-Press **R** to simplify the captured source again. Run a new \`/bro text\`, \`/bro file\`, \`/bro url\`, or \`/bro show\` command — or give \`/bro\` the input directly — to capture a new source.
-
-## Check and configure
-
-- \`/bro doctor\` — check settings, backends, account, model, effort, and mode (per-feature backend/model/effort)
-- \`/bro usage [--provider agy]\` — show current Agy limits
-- \`/bro model [id]\` — view or choose the shared default model (Agy catalog, or sonnet/opus/explicit IDs on the Claude backend)
-- \`/bro effort [low|medium|high|xhigh|max]\` — view or choose the shared default reasoning effort (xhigh/max are Claude-only)
-- \`/bro mode [brief|balanced|faithful]\` — view or choose explanation mode
-- \`/bro config\` — open an interactive settings screen for the shared default backend/model/effort, explain mode, show turns, and per-capability (explain/show/btw/advisor) backend, model, and effort overrides. Changes save immediately; Esc on a picker cancels without changing anything, Esc on the screen closes it and keeps whatever was already saved.
-
-\`/bro model\` and \`/bro effort\` always change the shared default that explain, show, btw, and advisor fall back to when they have no override. Use \`/bro config\` to give one of them its own backend, model, or effort. \`btw\` is not supported on the Claude backend.
+- \`/bro <input>\` — a lone URL, an existing supported file, or anything else as pasted text
+- \`/bro open\` — reopen the latest explanation without a new request
+- \`/bro show [n-turns] [query]\` — draw recent turns' conversation text as shapes; an optional query steers the focus
 
 ## Side conversation
 
-- \`/bro btw [--fresh] [--full] [question]\` — open a side conversation. Sandboxed (read-only) by default; add \`--full\` to let it read and edit the workspace, and \`--fresh\` to start without main-session context. Reopening preserves the thread's access mode (even with \`--fresh\`); use \`--sandbox\` to return to sandbox mode. Changing access mode starts a new thread. Inside the side thread, type questions and press Enter (empty Enter re-asks); exact commands \`/copy\` and \`/copy-all\` copy the latest answer or full thread to the system clipboard; exact commands \`/insert\` and \`/insert-all\` insert into the main editor without submitting (use \`/insert!\` or \`/insert-all!\` to replace an existing draft); \`/retry\` re-asks the last question; \`/clear\` resets the thread. Any other input is sent as a question. Esc closes.
+- \`/bro btw [question]\` — open a side conversation seeded with recent main-session context. It starts conversation-only; reopening keeps the thread and its mode.
+- Inside the modal: Enter asks (empty Enter re-asks); \`/mode\` toggles conversation-only / full permission (read and edit the workspace) and keeps the thread; \`/copy\` and \`/copy-all\` copy to the clipboard; \`/insert\` and \`/insert-all\` insert into an empty main editor without submitting; \`/retry\` re-asks; \`/clear\` resets. Any other text is sent as a question. Esc closes.
 
 ## Advisor
 
-- \`bro_advisor\` — a tool the executor agent can voluntarily call mid-task for a second opinion from a fresh ${advisorProcess} before or after a non-trivial decision. It is registered like any other tool and has no on/off switch of its own; whether the executor can actually call it depends entirely on this host's own tool restrictions
-- \`/bro advisor\` — a quick notice of whether \`bro_advisor\` is available right now, pointing at \`/bro config\`, \`/bro advisor-steer\`, and \`/bro doctor\`
-- \`/bro advisor-steer\` — open an editor for one persistent steering brief the advisor always sees. **Ctrl+S** saves, **Enter**/**Shift+Enter** insert newlines, **Ctrl+K** clears the saved brief and draft, **Ctrl+C** copies the full draft, and **Esc** closes without saving unsaved edits
-- \`/bro doctor\` — the full advisor diagnostic: whether this host exposes and activates \`bro_advisor\`, its resolved model/effort, steering presence, and the Agy compatibility floor
+- \`bro_advisor\` — a tool the executor agent may call for a second opinion from a fresh backend process with real, auto-approved workspace access; it is told to advise, not edit, but that is not enforced
+- \`/bro advisor\` — whether \`bro_advisor\` is available right now
+- \`/bro advisor-steer\` — edit the session's persistent steering brief (**Ctrl+S** save, **Ctrl+K** clear, **Ctrl+C** copy, **Esc** close)
+
+## Configure and check
 
-Each consultation is a fresh, standalone ${advisorProcess} — never resumed, never looping, never automatically triggered. Bro captures the context snapshot (system instructions, active tools, and the conversation so far including tool calls and results) automatically; the executor never has to assemble one. The advisor has real tool access in the workspace, running with permissions auto-approved, so it can verify claims itself; it is instructed to only return advice and leave edits to the executor, but that instruction is behavioral rather than an enforced sandbox constraint. The steering brief persists in the session (not sent to the model) and is restored on resume or reload; forking a session inherits it, and edits after the fork are independent of the original branch.
+- \`/bro config\` — shared default and per-capability (explain/show/btw/advisor) backend, model, and effort; explain mode; show turns. Changes save immediately.
+- \`/bro mode [brief|balanced|faithful]\` — view or choose the explanation mode
+- \`/bro doctor\` — check settings, prompt, and every selected backend without running a model turn
 
 ## Current settings
 
 ${settingsSummary}
 
-Saved in \`${SETTINGS_FILE}\`. Use the commands above, configure interactively via \`/bro config\`, or edit the file directly. Changes apply to future explanations. \`showTurns\` can be configured interactively in \`/bro config\` or edited directly in \`${SETTINGS_FILE}\`, and overridden per run with \`/bro show <n-turns>\`. Add a query after the count — or on its own, e.g. \`/bro show what changed in the auth flow\` — to steer what the shapes focus on.
+Saved in \`${SETTINGS_FILE}\`.
 
 ## Explanation modes
 
 - brief — the main point and next action, with no fixed word target
 - balanced — default; material detail with clearer structure
 - faithful — closest to the source, with no fixed word limit
-/bro show uses its own built-in draw prompt; the modes and \`bro-prompt.md\` do not affect it.
-If \`${PROMPT_FILE}\` exists and is valid, the selected mode stays saved but inactive because the custom prompt fully overrides it. Remove or rename \`bro-prompt.md\` to use the saved built-in mode again.
+
+A valid \`${PROMPT_FILE}\` (with \`{{response}}\` exactly once) overrides the modes; the saved mode stays inactive until you remove or rename it. Show always uses its own prompt.
 
 ## Controls
 
-- **Mouse wheel / trackpad** — scroll
-- **↑ / ↓** — scroll
+- **Mouse wheel / trackpad**, **↑ / ↓** — scroll
 - **C** — copy the full explanation
-- **R** — repeat the current action\n- **O** — open the HTML diagram when a show reply contains one
+- **R** — repeat the current action
+- **O** — open the HTML diagram when a show reply contains one
 - **Esc** — close, or cancel while Bro is working
 
-Bro temporarily captures mouse input while the modal is open. Native mouse selection may be unavailable or extend outside the modal; press **C** to copy everything reliably.
-
-## Important limits
-
-- Documents must be inside the current workspace, are limited to 10 MiB and 100,000 extracted characters, and must be \`.md\`, \`.markdown\`, \`.txt\`, \`.pdf\`, or \`.docx\`. Scanned PDFs need OCR first.
-- Web input is limited to one public HTML page. Bro cannot sign in, run page JavaScript, bypass paywalls or blocks, follow pagination, or understand images and video.
-- If a webpage fails, copy it into a text file or save it as a PDF, then use \`/bro file\`.
-- Show draws only what already happened in this session — the conversation text of the last few turns, with tool calls, tool results, reasoning, and images always omitted — and cannot read the repository or other files on its own. On a remote or headless session with no display, pressing **O** reports a failure instead of opening the diagram.
-- Show reflects what was reported in the conversation, not independent verification against the actual code or system state.
-- Btw threads are memory-only and do not survive reloads or restarts. A turn is capped at 2 minutes in sandbox mode and 10 minutes in full mode; the side conversation resumes through Agy's \`--conversation\` support.
-- Advisor consultations run with real tool access and auto-approved permissions (\`--dangerously-skip-permissions\`) — there is no enforced read-only isolation, only the advisor's own behavioral instructions to advise rather than implement. On invocation failure (not a completed answer), Bro retries with the identical snapshot, steering, and question: once after 5 seconds, once more after 10 seconds, then returns ${advisorBackend === "claude" ? "Claude" : "Agy"}'s own diagnostic as the failure.
-
-## Privacy and safety
-
-Bro sends the selected assistant reply, pasted text, locally extracted document or webpage text, or recent session conversation text (tool calls, tool results, reasoning, and images omitted) to the selected backend and its model provider. They may retain request data under their own policies.
-
-Bro never adds the explanation to Pi's conversation, session file, or main-agent context. The captured source and latest explanation stay in process memory until you change sessions, reload extensions, or exit Pi.
-
-Bro's explain, show, file, and url commands never modify project files. \`/bro btw\` runs sandboxed (read-only) by default; with \`--full\` it can read and edit the workspace, so use \`--full\` only when you want the side conversation to touch your project.
-For webpages, it connects directly to the site without browser cookies; the site sees your IP address and Bro's user agent. Do not use private or signed URLs.
-
-Usage and Doctor checks contact Agy but do not send source text or run a model turn. Pressing **C** sends the explanation to your system clipboard.
-
-Each advisor consultation sends the executor's system instructions, active tool list, ordered conversation (including tool calls and results, since the advisor needs to verify claims), your steering brief, and the executor's optional question to the selected backend and its model provider; the advisor process itself can read and edit the workspace with no permission prompts. The steering brief is stored as session-only extension data — never added to the main conversation Pi or the model sees; the advisor tool has no separate activation state.
+## Privacy
 
-## Custom prompt
-
-Create or edit \`${PROMPT_FILE}\` and include \`{{response}}\` exactly once. Bro reads it on the next explanation and never modifies it. Existing valid custom prompts continue working unchanged.
-
-A valid custom prompt fully overrides all built-in mode instructions. \`/bro mode\` still changes the saved mode, but that mode remains inactive until you remove or rename \`bro-prompt.md\`. An invalid custom prompt blocks explanations; run \`/bro doctor\` for the exact problem.`;
+Bro sends the captured source (or, for the advisor, the executor's instructions, tools, and conversation) to the selected backend and its model provider, which may retain it under their own policies. Nothing is added to Pi's conversation unless you insert it. Access controls differ by backend; see the README.`;
 }
 
 // The overlay framing pattern is adapted from pi-btw (MIT); see THIRD_PARTY_NOTICES.md.
@@ -2264,6 +2368,7 @@ class BroModal implements Focusable {
 	private kind: ModalKind = "loading";
 	private rawText = "";
 	private sourceLabel = "";
+	private modelLabel = "";
 	private notice = "";
 	private offset = 0;
 	private maxOffset = 0;
@@ -2292,8 +2397,8 @@ class BroModal implements Focusable {
 		this.setContent("streaming", text, "", false, false);
 	}
 
-	setResult(text: string, retryable: boolean, notice = "", sourceLabel = "", rawText = text): void {
-		this.setContent("result", text, rawText, true, retryable, notice, sourceLabel);
+	setResult(text: string, retryable: boolean, notice = "", sourceLabel = "", rawText = text, modelLabel = ""): void {
+		this.setContent("result", text, rawText, true, retryable, notice, sourceLabel, modelLabel);
 	}
 
 	setHtmlPath(path: string): void {
@@ -2317,6 +2422,7 @@ class BroModal implements Focusable {
 		retryable: boolean,
 		notice = "",
 		sourceLabel = "",
+		modelLabel = "",
 	): void {
 		this.kind = kind;
 		if (kind !== "result") this.htmlPath = "";
@@ -2328,6 +2434,7 @@ class BroModal implements Focusable {
 			.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
 			.replace(/\s+/g, " ")
 			.trim();
+		this.modelLabel = modelLabel;
 		if (kind !== "streaming") this.offset = 0;
 		this.markdown.setText(text);
 		this.tui.requestRender();
@@ -2377,7 +2484,11 @@ class BroModal implements Focusable {
 
 		const lines = [
 			this.borderLine(innerWidth, "top"),
-			this.frameLine(this.theme.fg("accent", this.theme.bold(`Bro${this.sourceLabel ? ` · ${this.sourceLabel}` : ""}${scroll}`)), innerWidth),
+			this.frameLine(
+				this.theme.fg("accent", this.theme.bold(`Bro${this.sourceLabel ? ` · ${this.sourceLabel}` : ""}`)) +
+					this.theme.fg("dim", `${this.modelLabel ? ` · ${this.modelLabel}` : ""}${scroll}`),
+				innerWidth,
+			),
 			this.ruleLine(innerWidth),
 		];
 
@@ -2518,7 +2629,7 @@ async function showBroModal(ctx: ExtensionCommandContext, options: BroModalOptio
 						current = result;
 						options.onResult?.(result);
 						const display = result.htmlPath ? stripShowHtmlFence(result.text) : result.text;
-						modal.setResult(display, options.retryable ?? true, "", result.source?.label, result.text);
+						modal.setResult(display, options.retryable ?? true, "", result.source?.label, result.text, result.model);
 						if (result.htmlPath) modal.setHtmlPath(result.htmlPath);
 					})
 					.catch((error) => {
@@ -2526,7 +2637,7 @@ async function showBroModal(ctx: ExtensionCommandContext, options: BroModalOptio
 						const message = error instanceof Error ? error.message : String(error);
 						if (previous) {
 							current = previous;
-							modal.setResult(previous.text, options.retryable ?? true, `Retry failed: ${message}`, previous.source?.label);
+							modal.setResult(previous.text, options.retryable ?? true, `Retry failed: ${message}`, previous.source?.label, previous.text, previous.model);
 						} else {
 							modal.setError(message);
 						}
@@ -2539,7 +2650,7 @@ async function showBroModal(ctx: ExtensionCommandContext, options: BroModalOptio
 			if (options.text !== undefined) {
 				modal.setStatic(options.kind ?? "help", options.text, options.copyable ?? false);
 			} else if (current) {
-				modal.setResult(current.text, options.retryable ?? Boolean(options.run), "", current.source?.label);
+				modal.setResult(current.text, options.retryable ?? Boolean(options.run), "", current.source?.label, current.text, current.model);
 			} else {
 				execute();
 			}
@@ -2559,26 +2670,50 @@ async function showBroModal(ctx: ExtensionCommandContext, options: BroModalOptio
 	);
 }
 
-export function parseBtwArguments(value: string): { fresh: boolean; full?: boolean; question: string; invalid?: string } {
-	let rest = value.trim();
-	let fresh = false;
-	let full: boolean | undefined;
-	while (rest.startsWith("--")) {
-		const space = rest.search(/\s/);
-		const token = space === -1 ? rest : rest.slice(0, space);
-		if (token === "--fresh") fresh = true;
-		else if (token === "--full") full = true;
-		else if (token === "--sandbox") full = false;
-		else return { fresh, full, question: "", invalid: `Unknown /bro btw flag: ${token}` };
-		rest = space === -1 ? "" : rest.slice(space).replace(/^\s+/, "");
+export function parseBtwArguments(value: string): { question: string; invalid?: string } {
+	const rest = value.trim();
+	if (!rest.startsWith("--")) return { question: rest };
+	const token = rest.split(/\s/, 1)[0]!;
+	if (token === "--full" || token === "--sandbox") {
+		return { question: "", invalid: `${token} was removed. Open /bro btw and type /mode to switch between conversation-only and full permission.` };
 	}
-	return { fresh, full, question: rest };
+	if (token === "--fresh") {
+		return { question: "", invalid: "--fresh was removed. Every new thread starts with main-session context; type /clear inside /bro btw to start over." };
+	}
+	return { question: "", invalid: `Unknown /bro btw flag: ${token}` };
+}
+
+// A new thread starts conversation-only; reopening keeps the thread and its mode.
+export function resolveBtwThread(existing: BtwThread | undefined): BtwThread {
+	return existing ?? { turns: [], full: false };
+}
+
+export function bindBtwBackend(thread: BtwThread, backend: BackendName): boolean {
+	const changed = thread.backend !== undefined && thread.backend !== backend;
+	if (changed) { thread.turns = []; thread.conversationId = undefined; thread.context = undefined; thread.sessionFull = undefined; }
+	thread.backend = backend;
+	return changed;
+}
+
+export function btwModeLabel(full: boolean): string {
+	return full ? "full permission" : "conversation-only";
+}
+
+// /mode keeps the transcript; whether the native session survives is decided by
+// nativeBtwContinuation on the next turn.
+export function toggleBtwMode(thread: BtwThread): void {
+	thread.full = !thread.full;
 }
 
-export function resolveBtwThread(existing: BtwThread | undefined, parsed: { fresh: boolean; full?: boolean }): BtwThread {
-	const targetFull = parsed.full ?? existing?.full ?? false;
-	const startFresh = parsed.fresh || (parsed.full !== undefined && existing !== undefined && existing.full !== parsed.full);
-	return !existing || startFresh ? { turns: [], full: targetFull } : existing;
+// Claude and Grok 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.
+export function nativeBtwContinuation(thread: BtwThread, backend: BackendName): string | undefined {
+	if (backend === "agy" && thread.conversationId && thread.sessionFull !== undefined && thread.sessionFull !== thread.full) {
+		thread.conversationId = undefined;
+	}
+	return thread.conversationId;
 }
 
 export function formatBtwTranscript(turns: readonly BtwTurn[]): string {
@@ -2595,26 +2730,23 @@ export function formatBtwTranscript(turns: readonly BtwTurn[]): string {
 
 export type BtwComposerAction =
 	| { kind: "clear" }
+	| { kind: "mode" }
 	| { kind: "retry" }
 	| { kind: "clipboard"; all: boolean }
-	| { kind: "insert"; all: boolean; force: boolean }
+	| { kind: "insert"; all: boolean }
+	| { kind: "removed"; command: string }
 	| { kind: "question"; text: string };
 
 export function parseBtwComposerCommand(value: string): BtwComposerAction {
 	const command = value.trim();
 	if (command === "/clear") return { kind: "clear" };
+	if (command === "/mode") return { kind: "mode" };
 	if (command === "/retry" || command === "") return { kind: "retry" };
 	if (command === "/copy" || command === "/copy-all") {
 		return { kind: "clipboard", all: command === "/copy-all" };
 	}
-	if (
-		command === "/insert" ||
-		command === "/insert!" ||
-		command === "/insert-all" ||
-		command === "/insert-all!"
-	) {
-		return { kind: "insert", all: command.startsWith("/insert-all"), force: command.endsWith("!") };
-	}
+	if (command === "/insert" || command === "/insert-all") return { kind: "insert", all: command === "/insert-all" };
+	if (command === "/insert!" || command === "/insert-all!") return { kind: "removed", command };
 	return { kind: "question", text: command };
 }
 
@@ -2630,12 +2762,6 @@ async function runBtwTurn(
 	signal: AbortSignal,
 	onProgress?: (text: string) => void,
 ): Promise<{ text: string; conversationId?: string }> {
-	// Claude supports explain/show (restricted, fresh) and advisor (workspace-full, fresh);
-	// btw is rejected. Fail before spawning anything so a Claude btw selection can never
-	// reach the Agy CLI.
-	if (selection.backend === "claude") {
-		throw new Error("`btw` is not supported on the Claude backend. Run `/bro config` to give it an Agy model.");
-	}
 	let updateTimer: ReturnType<typeof setTimeout> | undefined;
 	let latest: string | undefined;
 	const throttledProgress = onProgress
@@ -2657,7 +2783,7 @@ async function runBtwTurn(
 				feature: "btw",
 				prompt,
 				access: options.full ? "workspace-full" : "restricted",
-				cwd: options.full ? options.cwd : undefined,
+				cwd: options.cwd,
 				continuation: options.conversationId ? { id: options.conversationId } : undefined,
 			},
 			selection,
@@ -2681,6 +2807,7 @@ class BtwModal implements Focusable {
 	private bodyHeight = 1;
 	private running = false;
 	private full = false;
+	private model = "";
 	private disposed = false;
 
 	get focused(): boolean {
@@ -2721,6 +2848,11 @@ class BtwModal implements Focusable {
 		this.tui.requestRender();
 	}
 
+	setModel(model: string): void {
+		this.model = model;
+		this.tui.requestRender();
+	}
+
 	setFull(full: boolean): void {
 		this.full = full;
 		this.tui.requestRender();
@@ -2782,16 +2914,15 @@ class BtwModal implements Focusable {
 		const hiddenBelow = Math.max(0, this.maxOffset - this.offset);
 		const scroll = this.maxOffset > 0 ? ` · ↑${this.offset} ↓${hiddenBelow}` : "";
 
-		const mode = this.full
-			? this.theme.fg("accent", this.theme.bold("full · edits repo"))
-			: this.theme.fg("dim", "sandbox");
-		const header = this.theme.fg("accent", this.theme.bold("Bro · btw")) + this.theme.fg("dim", ` · ${mode}${scroll}`);
+		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)));
+		const header = this.theme.fg("accent", this.theme.bold("Bro · btw")) + model + mode + this.theme.fg("dim", scroll);
 
 		const composer = this.input.render(innerWidth)[0] ?? "";
 
 		const controls = this.running
 			? this.theme.fg("dim", "Thinking… · Esc cancel")
-			: this.theme.fg("dim", "Enter ask · Esc close · /copy · /copy-all · /insert · /insert-all · /clear · /retry");
+			: this.theme.fg("dim", "Enter ask · Esc close · /mode · /copy · /copy-all · /insert · /insert-all · /clear · /retry");
 
 		const lines = [
 			this.borderLine(innerWidth, "top"),
@@ -2817,7 +2948,7 @@ class BtwModal implements Focusable {
 
 async function openBtwModal(
 	ctx: ExtensionCommandContext,
-	options: { thread: BtwThread; initialQuestion?: string; seed: boolean },
+	options: { thread: BtwThread; initialQuestion?: string },
 ): Promise<void> {
 	const thread = options.thread;
 
@@ -2847,25 +2978,40 @@ async function openBtwModal(
 				modal.setRunning(true);
 				modal.clearComposer();
 
-				const first = thread.turns.length === 0;
-				let context: string | undefined;
-				if (first && options.seed) {
-					const captured = captureShowTranscript(ctx, BTW_CONTEXT_TURNS);
-					context = captured?.text;
+				let settings: BroSettings;
+				try {
+					settings = await readSettings();
+					const backend = capabilityBackend(settings, "btw");
+					if (bindBtwBackend(thread, backend)) modal.setNotice("Backend changed — started a fresh side thread.");
+				} catch (error) {
+					controller = undefined; modal.setRunning(false); modal.setNotice(errorMessage(error)); return;
+				}
+				if (thread.turns.length === 0) {
+					thread.conversationId = undefined;
+					let context = captureShowTranscript(ctx, BTW_CONTEXT_TURNS)?.text;
 					if (context && context.length > BTW_CONTEXT_MAX) {
 						context = `${context.slice(0, BTW_CONTEXT_MAX)}\n[… context truncated …]`;
 					}
+					thread.context = context;
 				}
+				// Resume natively when possible; otherwise seed the fresh native session with the main-session
+				// context plus every earlier turn so nothing is silently lost.
+				const conversationId = nativeBtwContinuation(thread, capabilityBackend(settings, "btw"));
+				const history = !conversationId && thread.turns.length ? formatBtwTranscript(thread.turns) : undefined;
+				const context = conversationId ? undefined : thread.context;
+				const full = thread.full;
 
 				thread.turns.push({ question, answer: "…" });
 				modal.setText(transcript());
 
 				try {
-					const settings = await readSettings();
+					const selection = selectionForCapability(settings, "btw");
+					thread.model = selectionLabel(selection);
+					modal.setModel(thread.model);
 					const result = await runBtwTurn(
-						buildBtwPrompt(context, question),
-						selectionForCapability(settings, "btw"),
-						{ full: thread.full, cwd: ctx.cwd, conversationId: thread.conversationId },
+						buildBtwPrompt(context, question, { full, history }),
+						selection,
+						{ full, cwd: ctx.cwd, conversationId },
 						turnController.signal,
 						(partial) => {
 							if (closed || turnController.signal.aborted) return;
@@ -2874,7 +3020,10 @@ async function openBtwModal(
 						},
 					);
 					if (turnController.signal.aborted) return;
-					if (result.conversationId) thread.conversationId = result.conversationId;
+					if (result.conversationId) {
+						thread.conversationId = result.conversationId;
+						thread.sessionFull = full;
+					}
 					thread.turns[thread.turns.length - 1]!.answer = result.text;
 				} catch (error) {
 					if (turnController.signal.aborted || closed) return;
@@ -2889,9 +3038,16 @@ async function openBtwModal(
 				}
 			};
 
+			const toggleMode = () => {
+				toggleBtwMode(thread);
+				modal.setFull(thread.full);
+				modal.setNotice(`Mode: ${btwModeLabel(thread.full)}`);
+			};
+
 			const clear = () => {
 				thread.turns = [];
 				thread.conversationId = undefined;
+				thread.context = undefined;
 				modal.clearComposer();
 				modal.setNotice("");
 				modal.setText("");
@@ -2922,14 +3078,14 @@ async function openBtwModal(
 				}
 			};
 
-			const insert = (all: boolean, force: boolean) => {
+			const insert = (all: boolean) => {
 				const text = all ? transcript() : (thread.turns.at(-1)?.answer ?? "");
 				if (!text.trim()) {
 					modal.setNotice("Nothing to insert yet.");
 					return;
 				}
-				if (ctx.ui.getEditorText().trim() && !force) {
-					modal.setNotice("Main editor has a draft. Use /insert! (or /insert-all!) to replace it.");
+				if (ctx.ui.getEditorText().trim()) {
+					modal.setNotice("Main editor has a draft. Edit or clear it first, then insert again.");
 					return;
 				}
 				ctx.ui.setEditorText(text);
@@ -2943,6 +3099,11 @@ async function openBtwModal(
 					clear();
 					return;
 				}
+				if (action.kind === "mode") {
+					modal.clearComposer();
+					toggleMode();
+					return;
+				}
 				if (action.kind === "clipboard") {
 					modal.clearComposer();
 					void copyOut(action.all);
@@ -2950,7 +3111,12 @@ async function openBtwModal(
 				}
 				if (action.kind === "insert") {
 					modal.clearComposer();
-					insert(action.all, action.force);
+					insert(action.all);
+					return;
+				}
+				if (action.kind === "removed") {
+					modal.clearComposer();
+					modal.setNotice(`${action.command} was removed. Edit or clear the main editor draft, then use /insert or /insert-all.`);
 					return;
 				}
 				if (action.kind === "retry") {
@@ -2962,6 +3128,7 @@ async function openBtwModal(
 			}
 
 			modal.setFull(thread.full);
+			modal.setModel(thread.model ?? "");
 			modal.setText(transcript());
 
 			if (options.initialQuestion) void runTurn(options.initialQuestion);
@@ -2985,7 +3152,7 @@ export default async function bro(pi: ExtensionAPI) {
 	let lastResult: BroResult | undefined;
 	let btwThread: BtwThread | undefined;
 	const remember = (result: ModalResult) => {
-		if (result.source) lastResult = { source: result.source, text: result.text };
+		if (result.source) lastResult = { source: result.source, text: result.text, model: result.model };
 	};
 
 	pi.on("session_start", async (_event, _ctx) => {
@@ -3061,8 +3228,8 @@ export default async function bro(pi: ExtensionAPI) {
 					// the activity throttle window.
 					activityCount: run.activityCount,
 				};
-				// The backend qualifier appears only for Claude, keeping the Agy header byte-identical.
-				const header = `Bro advisor · ${backend === "claude" ? "backend: claude · " : ""}model: ${selection.model} · effort: ${effort} · ${run.attempts} attempt${run.attempts === 1 ? "" : "s"} · ${Math.ceil(run.durationMs / 1_000)}s`;
+				// The backend qualifier appears only off Agy, keeping the Agy header byte-identical.
+				const header = `Bro advisor · ${backend === "agy" ? "" : `backend: ${backend} · `}model: ${selection.model} · effort: ${effort} · ${run.attempts} attempt${run.attempts === 1 ? "" : "s"} · ${Math.ceil(run.durationMs / 1_000)}s`;
 				const context = `Context · cwd: ${JSON.stringify(ctx.cwd)} · steering: ${details.steeringIncluded ? "included" : "none"} · snapshot: ${snapshot.text.length} chars · Bro truncation: none · omissions: ${omissions}`;
 				return { content: [{ type: "text", text: `${header}\n${context}\n\n${run.advice}` }], details };
 			} finally {
@@ -3111,6 +3278,12 @@ export default async function bro(pi: ExtensionAPI) {
 			let action = parts[0] ?? "";
 			let value = raw.slice(raw.split(/\s+/, 1)[0]?.length ?? 0).trim();
 
+			// Removed commands must never fall through to a paid text explanation.
+			if (action === "model" || action === "effort") {
+				ctx.ui.notify(`/bro ${action} was removed. Use /bro config to choose the shared default and per-capability ${action}; use /bro text <text> to explain text.`, "warning");
+				return;
+			}
+
 			// An unknown first word means the whole input is the source: route it by shape.
 			if (action && !KNOWN_ACTIONS.has(action)) {
 				const candidate = unquote(raw);
@@ -3142,13 +3315,14 @@ export default async function bro(pi: ExtensionAPI) {
 						return { text: "**Nothing to show yet**\n\nThis session has no conversation turns to draw. Run something first, then press **R**." };
 					}
 					let text: string;
+					let model: string;
 					try {
-						text = await runShowExplanation(captured.text, steering, signal, await readSettings(), onProgress);
+						({ text, model } = await runShowExplanation(captured.text, steering, signal, await readSettings(), onProgress));
 					} catch (error) {
 						throw new Error(withDoctor(error));
 					}
 					const html = extractShowHtml(text);
-					return { source: captured, text, ...(html ? { htmlPath: await writeShowHtml(html) } : {}) };
+					return { source: captured, text, model, ...(html ? { htmlPath: await writeShowHtml(html) } : {}) };
 				};
 				try {
 					await showBroModal(ctx, {
@@ -3179,7 +3353,7 @@ export default async function bro(pi: ExtensionAPI) {
 					try {
 						return {
 							source: target,
-							text: await simplify(target.text, signal, await readSettings(), onProgress),
+							...(await simplify(target.text, signal, await readSettings(), onProgress)),
 						};
 					} catch (error) {
 						throw new Error(withDoctor(error));
@@ -3215,24 +3389,6 @@ export default async function bro(pi: ExtensionAPI) {
 				return;
 			}
 
-			if (action === "usage") {
-				const valid = parts.length === 1 || (parts.length === 3 && parts[1] === "--provider" && parts[2] === "agy");
-				if (!valid) {
-					ctx.ui.notify("Use /bro usage or /bro usage --provider agy.", "warning");
-					return;
-				}
-				try {
-					await showBroModal(ctx, {
-						loadingText: "Checking Agy usage…",
-						retryable: false,
-						run: async (signal) => ({ text: await checkAgyUsage(pi, signal) }),
-					});
-				} catch (error) {
-					ctx.ui.notify(withDoctor(error), "error");
-				}
-				return;
-			}
-
 			if (action === "mode") {
 				const requested = parts[1];
 				if (parts.length > 2 || (requested && !parseBroMode(requested))) {
@@ -3262,188 +3418,6 @@ export default async function bro(pi: ExtensionAPI) {
 				return;
 			}
 
-			if (action === "model") {
-				if (parts.length > 2) {
-					ctx.ui.notify("Use /bro model or /bro model <id>.", "warning");
-					return;
-				}
-				try {
-					const settings = await readSettings();
-					// /bro model operates on the effective shared backend: no Agy catalog
-					// when the shared default is Claude.
-					if ((settings.backend ?? "agy") === "claude") {
-						const requested = value.trim();
-						let model: string | undefined;
-						if (requested) {
-							try {
-								model = resolveClaudeModel(requested);
-							} catch {
-								ctx.ui.notify("Use /bro model or /bro model <sonnet|opus|model-id>.", "warning");
-								return;
-							}
-						} else {
-							if (ctx.mode !== "tui") {
-								ctx.ui.notify("Use /bro model <sonnet|opus|model-id> outside Pi's interactive UI.", "warning");
-								return;
-							}
-							const choices = [
-								...CLAUDE_MODELS.map(
-									(entry) => `${entry.id} — ${entry.label}${entry.id === settings.model ? " (current)" : ""}`,
-								),
-								"Custom — enter a model ID…",
-							];
-							const choice = await ctx.ui.select(`Claude model (current: ${settings.model})`, choices);
-							if (!choice) return;
-							if (choice.startsWith("Custom")) {
-								const input = await ctx.ui.input("Claude model", "sonnet, opus, or an explicit model ID");
-								if (!input?.trim()) return;
-								model = resolveClaudeModel(input);
-							} else {
-								model = CLAUDE_MODELS[choices.indexOf(choice)]?.id;
-							}
-						}
-						if (!model) return;
-						const effort = settings.backend === "claude" && isClaudeEffort(settings.effort) ? settings.effort : "default";
-						await writeSettings({ ...settings, backend: "claude", model, effort });
-						ctx.ui.notify(`Bro model: claude ${model}${effort === "default" ? "" : ` (${effort})`}`, "info");
-						return;
-					}
-					const models = await listAgyModels(pi);
-					const current = resolveCatalogSettings(settings, models);
-					const requested = parts[1];
-					let selected: AgyModelFamily | undefined;
-					let selectedEffort: BroEffort | undefined;
-					if (requested) {
-						selected = models.find((item) => item.id.toLowerCase() === requested);
-						if (!selected) {
-							for (const family of models) {
-								const variant = family.variants.find((item) => item.id.toLowerCase() === requested);
-								if (variant) {
-									selected = family;
-									selectedEffort = variant.effort ?? "default";
-									break;
-								}
-							}
-						}
-						if (!selected) {
-							ctx.ui.notify(`Unknown Agy model "${requested}". Run /bro model to see available choices.`, "warning");
-							return;
-						}
-					} else {
-						if (ctx.mode !== "tui") {
-							ctx.ui.notify("Use /bro model <id> outside Pi's interactive UI.", "warning");
-							return;
-						}
-						const ordered = [...models].sort((a, b) => Number(b.id === current.family?.id) - Number(a.id === current.family?.id));
-						const choices = ordered.map(
-							(item) =>
-								`${item.id} — ${item.label} · ${item.efforts.length ? item.efforts.join("/") : "fixed effort"}${item.id === current.family?.id ? " (current)" : ""}`,
-						);
-						const choice = await ctx.ui.select(`Agy model (current: ${current.settings.model})`, choices);
-						if (!choice) return;
-						selected = ordered[choices.indexOf(choice)];
-					}
-					if (!selectedEffort) {
-						const currentEffort = current.settings.effort;
-						const canKeepCurrent =
-							current.family?.id === selected.id &&
-							(currentEffort === "default" ? !selected.efforts.length : selected.efforts.includes(currentEffort as AgyEffort));
-						selectedEffort = canKeepCurrent ? currentEffort : preferredEffort(selected);
-					}
-					await writeSettings({ ...settings, model: selected.id, effort: selectedEffort });
-					ctx.ui.notify(
-						`Bro model: ${selected.id}${selectedEffort === "default" ? "" : ` (${selectedEffort})`}`,
-						"info",
-					);
-				} catch (error) {
-					ctx.ui.notify(withDoctor(error), "error");
-				}
-				return;
-			}
-
-			if (action === "effort") {
-				const requested = parts[1];
-				// Claude levels pass this gate; each backend branch below validates strictly
-				// (the Agy branch still rejects xhigh/max with its supports-list warning).
-				if (parts.length > 2 || (requested && !isClaudeEffort(requested) && !EFFORTS.some((effort) => effort === requested))) {
-					ctx.ui.notify("Use /bro effort, or choose low, medium, or high.", "warning");
-					return;
-				}
-				try {
-					const settings = await readSettings();
-					// /bro effort operates on the effective shared backend: no Agy catalog
-					// when the shared default is Claude.
-					if ((settings.backend ?? "agy") === "claude") {
-						const allowed = ["default", ...CLAUDE_EFFORTS] as const;
-						if (requested && !allowed.some((effort) => effort === requested)) {
-							ctx.ui.notify("Use /bro effort, or choose default, low, medium, high, xhigh, or max.", "warning");
-							return;
-						}
-						let selected = requested as BroEffort | undefined;
-						if (!selected) {
-							if (ctx.mode !== "tui") {
-								ctx.ui.notify("Use /bro effort <default|low|medium|high|xhigh|max> outside Pi's interactive UI.", "warning");
-								return;
-							}
-							const efforts = [...CLAUDE_EFFORTS].sort(
-								(a, b) => Number(b === settings.effort) - Number(a === settings.effort),
-							);
-							const choices = efforts.map((effort) => `${effort}${effort === settings.effort ? " (current)" : ""}`);
-							const choice = await ctx.ui.select(`Claude reasoning effort (current: ${settings.effort})`, choices);
-							if (!choice) return;
-							selected = efforts[choices.indexOf(choice)];
-						}
-						if (!selected || !isClaudeEffort(selected)) return;
-						await writeSettings({ ...settings, backend: "claude", model: settings.model, effort: selected });
-						ctx.ui.notify(
-							selected === "default" ? "Bro reasoning effort: built into the selected model" : `Bro reasoning effort: ${selected}`,
-							"info",
-						);
-						return;
-					}
-					const current = resolveCatalogSettings(settings, await listAgyModels(pi));
-					if (!current.family) {
-						ctx.ui.notify(`Model "${settings.model}" is not in Agy's current model list. Run /bro model first.`, "warning");
-						return;
-					}
-					if (!current.family.efforts.length) {
-						if (requested && requested !== "default") {
-							ctx.ui.notify(`${current.family.label} uses a fixed effort level.`, "warning");
-							return;
-						}
-						await writeSettings({ ...current.settings, model: current.family.id, effort: "default" });
-						ctx.ui.notify(`${current.family.label} uses its built-in effort level.`, "info");
-						return;
-					}
-					if (requested === "default" || (requested && !current.family.efforts.includes(requested as AgyEffort))) {
-						ctx.ui.notify(
-							`${current.family.label} supports ${current.family.efforts.join(" or ")} effort.`,
-							"warning",
-						);
-						return;
-					}
-					let selected = requested as AgyEffort | undefined;
-					if (!selected) {
-						if (ctx.mode !== "tui") {
-							ctx.ui.notify("Use /bro effort <low|medium|high> outside Pi's interactive UI.", "warning");
-							return;
-						}
-						const efforts = [...current.family.efforts].sort(
-							(a, b) => Number(b === current.settings.effort) - Number(a === current.settings.effort),
-						);
-						const choices = efforts.map((effort) => `${effort}${effort === current.settings.effort ? " (current)" : ""}`);
-						const choice = await ctx.ui.select(`Agy reasoning effort (current: ${current.settings.effort})`, choices);
-						if (!choice) return;
-						selected = efforts[choices.indexOf(choice)];
-					}
-					await writeSettings({ ...current.settings, model: current.family.id, effort: selected });
-					ctx.ui.notify(`Bro reasoning effort: ${selected}`, "info");
-				} catch (error) {
-					ctx.ui.notify(withDoctor(error), "error");
-				}
-				return;
-			}
-
 			if (action === "btw") {
 				if (ctx.mode !== "tui") {
 					ctx.ui.notify("Use /bro btw in Pi's interactive UI.", "warning");
@@ -3455,10 +3429,11 @@ export default async function bro(pi: ExtensionAPI) {
 					return;
 				}
 				try {
-					if (capabilityBackend(await readSettings(), "btw") === "claude") throw new Error("Claude does not support /bro btw yet; choose an Agy override in /bro config.");
-					const thread = resolveBtwThread(btwThread, parsed);
+					const btwBackend = capabilityBackend(await readSettings(), "btw");
+					const thread = resolveBtwThread(btwThread);
+					if (bindBtwBackend(thread, btwBackend)) ctx.ui.notify("Backend changed — started a fresh side thread.", "info");
 					btwThread = thread;
-					await openBtwModal(ctx, { thread, initialQuestion: parsed.question, seed: !parsed.fresh });
+					await openBtwModal(ctx, { thread, initialQuestion: parsed.question });
 				} catch (error) {
 					ctx.ui.notify(withDoctor(error), "error");
 				}
@@ -3535,7 +3510,7 @@ export default async function bro(pi: ExtensionAPI) {
 					const settings = await readSettings();
 					return {
 						source: target,
-						text: await simplify(target.text, signal, settings, onProgress),
+						...(await simplify(target.text, signal, settings, onProgress)),
 					};
 				} catch (error) {
 					throw new Error(withDoctor(error));