pi-goala 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.3.1 (2026-07-26)
+
+- Make each phase default to keeping its current model configuration.
+- Separate reasoning-effort changes from provider/model changes.
+- Select provider, then a filtered model, while skipping provider selection
+  when only one authenticated provider is available.
+- Review, edit, save, or cancel the complete configuration atomically.
+
+## 0.3.0 (2026-07-26)
+
+- Add interactive per-phase provider, model, and reasoning selection from Pi's
+  authenticated available-model registry.
+- Support mixed-provider planner, executor, step-verifier, final-verifier, and
+  repeated-repair roles.
+- Migrate version 1 single-provider configuration to the version 2 per-role
+  schema without retaining the obsolete top-level provider.
+
 ## 0.2.0 (2026-07-26)
 
 - Rename the package, repository, extension namespace, storage, environment

package/README.md

@@ -39,7 +39,7 @@ pi install npm:pi-goala
 Pin a release for reproducible team installations:
 
 ```text
-pi install npm:pi-goala@0.2.0
+pi install npm:pi-goala@0.3.1
 ```
 
 Pi's package command both downloads Goala and registers its extension. A plain
@@ -49,7 +49,7 @@ supported installation path.
 From GitHub or a local checkout:
 
 ```text
-pi install git:github.com/barryking/pi-goala@v0.2.0
+pi install git:github.com/barryking/pi-goala@v0.3.1
 pi install /absolute/path/to/pi-goala
 ```
 
@@ -115,6 +115,7 @@ Useful commands:
 /memory retire <id>     Exclude an obsolete episode from recall
 /memory restore <id>    Restore a retired episode
 /goala-setup            Choose a model preset
+/goala-setup custom     Review or change each role's model and reasoning
 /goala-setup status     Show effective configuration
 ```
 
@@ -379,7 +380,16 @@ The recommended OpenAI Codex preset is:
 
 If those models are unavailable, Goala can use the model that was active
 when Pi started. Run `/goala-setup current` to persist that portable
-single-model configuration. Advanced users can configure each role in
+single-model configuration. Run `/goala-setup custom` to choose an
+authenticated provider/model and reasoning level separately for planning,
+execution, step verification, final verification, and repeated repair. The
+interactive wizard defaults to keeping each current role. It can change
+reasoning alone or select a provider followed by one of that provider's
+available models. Provider selection is skipped when only one is authenticated.
+A final summary can be edited, saved, or cancelled; nothing is written before
+save.
+
+Advanced users can edit the same per-role profiles in
 `~/.pi/agent/pi-goala/config.json`.
 
 The package does not overwrite Pi's `settings.json`, model list, skills,

package/docs/architecture.md

@@ -23,6 +23,7 @@ own one concern:
 | `workflow.ts` | Goal-state types, normalization, and invariants |
 | `memory.ts` | Verified episodic storage and retrieval |
 | `recovery.ts` | Discovery of unfinished goals in saved Pi sessions |
+| `setup.ts` | Interactive available-model selection for each lifecycle role |
 | `config.ts` | Namespaced configuration and model-role presets |
 
 Simple concern names are intentional: the directory already supplies the
@@ -122,7 +123,11 @@ planning and final verification, a faster model for implementation and routine
 step verification, and a balanced fallback after repeated repair. Independent
 step context and the final strong verifier preserve the trust boundary without
 paying the strongest-model cost at every human checkpoint. A portable
-current-model preset is available for other providers.
+current-model preset is available for other providers. The advanced setup
+defaults to retaining each role, supports reasoning-only changes, and filters
+models after provider selection. It stores provider, model, and reasoning
+independently for every role only after final review; mixed-provider workflows
+therefore use the same phase-routing path as the bundled preset.
 
 If a configured model cannot be resolved and current-model fallback is
 enabled, Goala uses the model that was active when the extension session

package/docs/configuration.md

@@ -46,35 +46,46 @@ and restore the backup to `~/.pi/agent/`.
 /goala-setup status
 /goala-setup openai
 /goala-setup current
+/goala-setup custom
 ```
 
 `openai` selects the tested Sol/Luna/Terra model split when those models are
 available. `current` assigns the model active at Pi startup to every role.
+`custom` reviews each role and defaults to keeping its current configuration.
+For a change, it can adjust reasoning alone or select a provider followed by
+one of that provider's authenticated, available models. Provider selection is
+skipped when only one provider is available. The final summary can be edited,
+saved, or cancelled. Cancelling any prompt leaves the existing configuration
+unchanged.
 
 ## Full schema
 
 ```json
 {
-  "configVersion": 1,
-  "provider": "openai-codex",
+  "configVersion": 2,
   "planner": {
+    "provider": "openai-codex",
     "model": "gpt-5.6-sol",
     "thinkingLevel": "medium"
   },
   "executor": {
+    "provider": "openai-codex",
     "model": "gpt-5.6-luna",
     "thinkingLevel": "medium"
   },
   "fallbackExecutor": {
+    "provider": "openai-codex",
     "model": "gpt-5.6-terra",
     "thinkingLevel": "medium",
     "afterRepairCycle": 2
   },
   "stepVerifier": {
+    "provider": "openai-codex",
     "model": "gpt-5.6-luna",
     "thinkingLevel": "medium"
   },
   "verifier": {
+    "provider": "openai-codex",
     "model": "gpt-5.6-sol",
     "thinkingLevel": "medium"
   },
@@ -96,6 +107,10 @@ available. `current` assigns the model active at Pi startup to every role.
 
 Restart Pi or use `/reload` after manually editing the file.
 
+Version 1 configuration used one top-level `provider`. Goala reads that schema,
+applies the provider to every role, and writes only version 2 when the
+configuration is next saved.
+
 `reviewPolicy` accepts:
 
 - `final`: run the full approved plan and review the final result;

package/extensions/goala/config.ts

@@ -12,6 +12,7 @@ export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhi
 export type ReviewPolicy = "final" | "per-step";
 
 export interface ModelProfile {
+	provider: string;
 	model: string;
 	thinkingLevel: ThinkingLevel;
 }
@@ -28,8 +29,7 @@ export interface GoalaSetupPreset {
 }
 
 export interface GoalaConfig {
-	configVersion: 1;
-	provider: string;
+	configVersion: 2;
 	planner: ModelProfile;
 	executor: ModelProfile;
 	fallbackExecutor: ModelProfile & { afterRepairCycle: number };
@@ -44,13 +44,33 @@ export interface GoalaConfig {
 }
 
 export const OPENAI_CODEX_PRESET: GoalaConfig = {
-	configVersion: 1,
-	provider: "openai-codex",
-	planner: { model: "gpt-5.6-sol", thinkingLevel: "medium" },
-	executor: { model: "gpt-5.6-luna", thinkingLevel: "medium" },
-	fallbackExecutor: { model: "gpt-5.6-terra", thinkingLevel: "medium", afterRepairCycle: 2 },
-	stepVerifier: { model: "gpt-5.6-luna", thinkingLevel: "medium" },
-	verifier: { model: "gpt-5.6-sol", thinkingLevel: "medium" },
+	configVersion: 2,
+	planner: {
+		provider: "openai-codex",
+		model: "gpt-5.6-sol",
+		thinkingLevel: "medium",
+	},
+	executor: {
+		provider: "openai-codex",
+		model: "gpt-5.6-luna",
+		thinkingLevel: "medium",
+	},
+	fallbackExecutor: {
+		provider: "openai-codex",
+		model: "gpt-5.6-terra",
+		thinkingLevel: "medium",
+		afterRepairCycle: 2,
+	},
+	stepVerifier: {
+		provider: "openai-codex",
+		model: "gpt-5.6-luna",
+		thinkingLevel: "medium",
+	},
+	verifier: {
+		provider: "openai-codex",
+		model: "gpt-5.6-sol",
+		thinkingLevel: "medium",
+	},
 	reviewPolicy: "final",
 	autoVerify: true,
 	maxRepairCycles: 3,
@@ -74,20 +94,69 @@ export function configPath(): string {
 	return join(goalaHome(), "config.json");
 }
 
-function mergeConfig(parsed: Partial<GoalaConfig>): GoalaConfig {
+type PersistedConfig = Partial<GoalaConfig> & {
+	provider?: unknown;
+};
+
+function profileProvider(
+	profile: Partial<ModelProfile> | undefined,
+	legacyProvider: unknown,
+	fallback: ModelProfile,
+): string {
+	if (typeof profile?.provider === "string" && profile.provider) return profile.provider;
+	if (typeof legacyProvider === "string" && legacyProvider) return legacyProvider;
+	return fallback.provider;
+}
+
+function mergeProfile(
+	profile: Partial<ModelProfile> | undefined,
+	legacyProvider: unknown,
+	fallback: ModelProfile,
+): ModelProfile {
+	return {
+		...fallback,
+		...profile,
+		provider: profileProvider(profile, legacyProvider, fallback),
+	};
+}
+
+function mergeConfig(parsed: PersistedConfig): GoalaConfig {
+	const { provider: legacyProvider, ...current } = parsed;
 	return {
 		...OPENAI_CODEX_PRESET,
-		...parsed,
-		configVersion: 1,
+		...current,
+		configVersion: 2,
 		reviewPolicy: parsed.reviewPolicy === "per-step" ? "per-step" : "final",
-		planner: { ...OPENAI_CODEX_PRESET.planner, ...parsed.planner },
-		executor: { ...OPENAI_CODEX_PRESET.executor, ...parsed.executor },
+		planner: mergeProfile(
+			parsed.planner,
+			legacyProvider,
+			OPENAI_CODEX_PRESET.planner,
+		),
+		executor: mergeProfile(
+			parsed.executor,
+			legacyProvider,
+			OPENAI_CODEX_PRESET.executor,
+		),
 		fallbackExecutor: {
-			...OPENAI_CODEX_PRESET.fallbackExecutor,
-			...parsed.fallbackExecutor,
+			...mergeProfile(
+				parsed.fallbackExecutor,
+				legacyProvider,
+				OPENAI_CODEX_PRESET.fallbackExecutor,
+			),
+			afterRepairCycle:
+				parsed.fallbackExecutor?.afterRepairCycle ??
+				OPENAI_CODEX_PRESET.fallbackExecutor.afterRepairCycle,
 		},
-		stepVerifier: { ...OPENAI_CODEX_PRESET.stepVerifier, ...parsed.stepVerifier },
-		verifier: { ...OPENAI_CODEX_PRESET.verifier, ...parsed.verifier },
+		stepVerifier: mergeProfile(
+			parsed.stepVerifier,
+			legacyProvider,
+			OPENAI_CODEX_PRESET.stepVerifier,
+		),
+		verifier: mergeProfile(
+			parsed.verifier,
+			legacyProvider,
+			OPENAI_CODEX_PRESET.verifier,
+		),
 		memory: { ...OPENAI_CODEX_PRESET.memory, ...parsed.memory },
 	};
 }
@@ -95,7 +164,7 @@ function mergeConfig(parsed: Partial<GoalaConfig>): GoalaConfig {
 export function loadConfig(): GoalaConfig {
 	let config = OPENAI_CODEX_PRESET;
 	try {
-		const parsed = JSON.parse(readFileSync(configPath(), "utf8")) as Partial<GoalaConfig>;
+		const parsed = JSON.parse(readFileSync(configPath(), "utf8")) as PersistedConfig;
 		config = mergeConfig(parsed);
 	} catch {
 		config = mergeConfig({});
@@ -129,12 +198,11 @@ export function currentModelConfig(
 ): GoalaConfig {
 	return {
 		...OPENAI_CODEX_PRESET,
-		provider,
-		planner: { model, thinkingLevel },
-		executor: { model, thinkingLevel },
-		fallbackExecutor: { model, thinkingLevel, afterRepairCycle: 2 },
-		stepVerifier: { model, thinkingLevel },
-		verifier: { model, thinkingLevel },
+		planner: { provider, model, thinkingLevel },
+		executor: { provider, model, thinkingLevel },
+		fallbackExecutor: { provider, model, thinkingLevel, afterRepairCycle: 2 },
+		stepVerifier: { provider, model, thinkingLevel },
+		verifier: { provider, model, thinkingLevel },
 	};
 }
 
@@ -165,7 +233,7 @@ export function configuredModels(config: GoalaConfig): ModelIdentity[] {
 		config.fallbackExecutor,
 		config.stepVerifier,
 		config.verifier,
-	].map((profile) => ({ provider: config.provider, id: profile.model }));
+	].map((profile) => ({ provider: profile.provider, id: profile.model }));
 	return identities.filter(
 		(identity, index) =>
 			identities.findIndex(
@@ -178,13 +246,17 @@ export function configuredModels(config: GoalaConfig): ModelIdentity[] {
 export function formatConfig(config: GoalaConfig): string {
 	return [
 		`Config: ${configPath()}`,
-		`Planner: ${config.provider}/${config.planner.model}:${config.planner.thinkingLevel}`,
-		`Executor: ${config.provider}/${config.executor.model}:${config.executor.thinkingLevel}`,
-		`Step verifier: ${config.provider}/${config.stepVerifier.model}:${config.stepVerifier.thinkingLevel}`,
-		`Verifier: ${config.provider}/${config.verifier.model}:${config.verifier.thinkingLevel}`,
-		`Fallback: ${config.provider}/${config.fallbackExecutor.model}:${config.fallbackExecutor.thinkingLevel} from repair ${config.fallbackExecutor.afterRepairCycle}`,
+		`Planner: ${formatProfile(config.planner)}`,
+		`Executor: ${formatProfile(config.executor)}`,
+		`Step verifier: ${formatProfile(config.stepVerifier)}`,
+		`Verifier: ${formatProfile(config.verifier)}`,
+		`Fallback: ${formatProfile(config.fallbackExecutor)} from repair ${config.fallbackExecutor.afterRepairCycle}`,
 		`Review policy: ${config.reviewPolicy}`,
 		`Memory: ${config.memory.enabled ? "enabled" : "disabled"}; auto-recall ${config.memory.autoRecall ? "on" : "off"}`,
 		`Current-model fallback: ${config.allowCurrentModelFallback ? "allowed" : "disabled"}`,
 	].join("\n");
 }
+
+function formatProfile(profile: ModelProfile): string {
+	return `${profile.provider}/${profile.model}:${profile.thinkingLevel}`;
+}

package/extensions/goala/index.ts

@@ -9,6 +9,7 @@ import {
 	GOALA_SETUP_PRESETS,
 	loadConfig,
 	writeConfig,
+	type GoalaConfig,
 	type ModelProfile,
 	type ReviewPolicy,
 	type ThinkingLevel,
@@ -40,6 +41,7 @@ import {
 	moveToFreshSession,
 	slicePhaseContext,
 } from "./session.ts";
+import { selectModelRoles } from "./setup.ts";
 import {
 	formatSourceDrift,
 	inspectGoalSources,
@@ -142,7 +144,7 @@ export default function goala(pi: ExtensionAPI): void {
 		}
 
 		const profile = profileForPhase();
-		let model = ctx.modelRegistry.find(config.provider, profile.model);
+		let model = ctx.modelRegistry.find(profile.provider, profile.model);
 		if (!model && config.allowCurrentModelFallback) {
 			const fallback = sessionDefaultModel ?? (ctx.model
 				? { provider: ctx.model.provider, id: ctx.model.id }
@@ -151,7 +153,7 @@ export default function goala(pi: ExtensionAPI): void {
 				model = ctx.modelRegistry.find(fallback.provider, fallback.id);
 				if (model && !fallbackNoticeShown) {
 					ctx.ui.notify(
-						`Goala: ${config.provider}/${profile.model} is unavailable; using ${fallback.provider}/${fallback.id}. Run /goala-setup to configure model roles.`,
+						`Goala: ${profile.provider}/${profile.model} is unavailable; using ${fallback.provider}/${fallback.id}. Run /goala-setup to configure model roles.`,
 						"warning",
 					);
 					fallbackNoticeShown = true;
@@ -160,7 +162,7 @@ export default function goala(pi: ExtensionAPI): void {
 		}
 		if (!model) {
 			ctx.ui.notify(
-				`Goala: model not found: ${config.provider}/${profile.model}. Run /goala-setup current or edit the namespaced config.`,
+				`Goala: model not found: ${profile.provider}/${profile.model}. Run /goala-setup current or edit the namespaced config.`,
 				"error",
 			);
 			updateGoalUi(ctx, state);
@@ -169,7 +171,10 @@ export default function goala(pi: ExtensionAPI): void {
 
 		const selected = await pi.setModel(model);
 		if (!selected) {
-			ctx.ui.notify(`Goala: authenticate ${config.provider} before using ${profile.model}`, "warning");
+			ctx.ui.notify(
+				`Goala: authenticate ${profile.provider} before using ${profile.model}`,
+				"warning",
+			);
 			updateGoalUi(ctx, state);
 			return false;
 		}
@@ -558,10 +563,13 @@ Do not edit files or rely on executor claims. Finish with submit_step_verificati
 		if (!choice && ctx.hasUI) {
 			const selected = await ctx.ui.select("Goala setup", [
 				...GOALA_SETUP_PRESETS.map((preset) => preset.label),
+				"Configure each phase",
 				"Show current configuration",
 			]);
 			choice = selected === "Show current configuration"
 				? "status"
+				: selected === "Configure each phase"
+					? "custom"
 				: GOALA_SETUP_PRESETS.find((preset) => preset.label === selected)?.id ?? "";
 		}
 
@@ -570,28 +578,34 @@ Do not edit files or rely on executor claims. Finish with submit_step_verificati
 			return;
 		}
 
-		const preset = GOALA_SETUP_PRESETS.find((candidate) => candidate.id === choice);
-		if (!preset) {
-			ctx.ui.notify(
-				`Usage: /goala-setup [status | ${GOALA_SETUP_PRESETS.map((candidate) => candidate.id).join(" | ")}]`,
-				"warning",
-			);
-			return;
-		}
-		const current = ctx.model
-			? { provider: ctx.model.provider, id: ctx.model.id }
-			: sessionDefaultModel;
-		const proposed = preset.create(current);
-		if (!proposed) {
-			ctx.ui.notify(`Preset "${preset.label}" requires a current model.`, "warning");
-			return;
+		let proposed: GoalaConfig | undefined;
+		if (choice === "custom") {
+			proposed = await selectModelRoles(ctx, config);
+			if (!proposed) return;
+		} else {
+			const preset = GOALA_SETUP_PRESETS.find((candidate) => candidate.id === choice);
+			if (!preset) {
+				ctx.ui.notify(
+					`Usage: /goala-setup [status | custom | ${GOALA_SETUP_PRESETS.map((candidate) => candidate.id).join(" | ")}]`,
+					"warning",
+				);
+				return;
+			}
+			const current = ctx.model
+				? { provider: ctx.model.provider, id: ctx.model.id }
+				: sessionDefaultModel;
+			proposed = preset.create(current);
+			if (!proposed) {
+				ctx.ui.notify(`Preset "${preset.label}" requires a current model.`, "warning");
+				return;
+			}
 		}
 		const missing = configuredModels(proposed).filter(
 			(model) => !ctx.modelRegistry.find(model.provider, model.id),
 		);
 		if (missing.length > 0) {
 			ctx.ui.notify(
-				`Preset not saved; unavailable model(s): ${missing.map((model) => `${model.provider}/${model.id}`).join(", ")}.`,
+				`Configuration not saved; unavailable model(s): ${missing.map((model) => `${model.provider}/${model.id}`).join(", ")}.`,
 				"warning",
 			);
 			return;
@@ -605,7 +619,7 @@ Do not edit files or rely on executor claims. Finish with submit_step_verificati
 	}
 
 	pi.registerCommand("goala-setup", {
-		description: `Configure model roles: /goala-setup [status | ${GOALA_SETUP_PRESETS.map((preset) => preset.id).join(" | ")}]`,
+		description: `Configure model roles: /goala-setup [status | custom | ${GOALA_SETUP_PRESETS.map((preset) => preset.id).join(" | ")}]`,
 		handler: configureGoala,
 	});
 

package/extensions/goala/setup.ts

@@ -0,0 +1,305 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type {
+	GoalaConfig,
+	ModelProfile,
+	ThinkingLevel,
+} from "./config.ts";
+
+type ModelRole =
+	| "planner"
+	| "executor"
+	| "stepVerifier"
+	| "verifier"
+	| "fallbackExecutor";
+
+type AvailableModel = ReturnType<
+	ExtensionCommandContext["modelRegistry"]["getAvailable"]
+>[number];
+
+const MODEL_ROLES: ReadonlyArray<{ key: ModelRole; label: string }> = [
+	{ key: "planner", label: "Planner" },
+	{ key: "executor", label: "Executor" },
+	{ key: "stepVerifier", label: "Step verifier" },
+	{ key: "verifier", label: "Final verifier" },
+	{ key: "fallbackExecutor", label: "Repair fallback" },
+];
+
+const THINKING_LEVELS: readonly ThinkingLevel[] = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+];
+
+const KEEP_CURRENT = "Keep current";
+const CHANGE_REASONING = "Change reasoning effort";
+const CHANGE_MODEL = "Change provider or model";
+const SAVE_CONFIGURATION = "Save configuration";
+const EDIT_PHASE = "Edit a phase";
+const CANCEL = "Cancel";
+
+function titleCase(value: string): string {
+	return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+
+function thinkingLabel(level: ThinkingLevel): string {
+	if (level === "off") return "Off";
+	if (level === "xhigh") return "Extra high";
+	if (level === "max") return "Maximum";
+	return titleCase(level);
+}
+
+function providerLabel(
+	ctx: ExtensionCommandContext,
+	provider: string,
+): string {
+	const displayName = ctx.modelRegistry.getProviderDisplayName(provider);
+	return displayName === provider ? provider : `${displayName} (${provider})`;
+}
+
+function modelLabel(model: AvailableModel): string {
+	return model.name && model.name !== model.id
+		? `${model.name} (${model.id})`
+		: model.id;
+}
+
+function profileLabel(
+	ctx: ExtensionCommandContext,
+	available: AvailableModel[],
+	profile: ModelProfile,
+): string {
+	const model = available.find(
+		(candidate) =>
+			candidate.provider === profile.provider && candidate.id === profile.model,
+	);
+	const reasoning =
+		profile.thinkingLevel === "off"
+			? "Reasoning off"
+			: `${thinkingLabel(profile.thinkingLevel)} reasoning`;
+	return [
+		providerLabel(ctx, profile.provider),
+		model ? modelLabel(model) : `${profile.model} (unavailable)`,
+		reasoning,
+	].join(" / ");
+}
+
+function setProfile(
+	config: GoalaConfig,
+	role: ModelRole,
+	profile: ModelProfile,
+): void {
+	if (role === "fallbackExecutor") {
+		config.fallbackExecutor = {
+			...profile,
+			afterRepairCycle: config.fallbackExecutor.afterRepairCycle,
+		};
+		return;
+	}
+	config[role] = profile;
+}
+
+async function selectThinkingLevel(
+	ctx: ExtensionCommandContext,
+	roleLabel: string,
+	profile: ModelProfile,
+): Promise<ThinkingLevel | undefined> {
+	const ordered = [
+		profile.thinkingLevel,
+		...THINKING_LEVELS.filter((level) => level !== profile.thinkingLevel),
+	];
+	const choices = ordered.map((level, index) =>
+		index === 0 ? `${thinkingLabel(level)} (current)` : thinkingLabel(level),
+	);
+	const selected = await ctx.ui.select(
+		`${roleLabel} reasoning effort\nCurrent: ${thinkingLabel(profile.thinkingLevel)}`,
+		choices,
+	);
+	if (!selected) return undefined;
+	return ordered[choices.indexOf(selected)];
+}
+
+async function selectProvider(
+	ctx: ExtensionCommandContext,
+	available: AvailableModel[],
+	roleLabel: string,
+	currentProvider: string,
+): Promise<string | undefined> {
+	const providers = [...new Set(available.map((model) => model.provider))].sort(
+		(left, right) => {
+			if (left === currentProvider) return -1;
+			if (right === currentProvider) return 1;
+			return providerLabel(ctx, left).localeCompare(providerLabel(ctx, right));
+		},
+	);
+	if (providers.length === 1) return providers[0];
+
+	const choices = providers.map((provider, index) =>
+		index === 0 && provider === currentProvider
+			? `${providerLabel(ctx, provider)} (current)`
+			: providerLabel(ctx, provider),
+	);
+	const selected = await ctx.ui.select(
+		`${roleLabel} provider\nCurrent: ${providerLabel(ctx, currentProvider)}`,
+		choices,
+	);
+	if (!selected) return undefined;
+	return providers[choices.indexOf(selected)];
+}
+
+async function selectModel(
+	ctx: ExtensionCommandContext,
+	available: AvailableModel[],
+	roleLabel: string,
+	provider: string,
+	current: ModelProfile,
+): Promise<AvailableModel | undefined> {
+	const models = available
+		.filter((model) => model.provider === provider)
+		.sort((left, right) => {
+			const leftCurrent =
+				left.provider === current.provider && left.id === current.model;
+			const rightCurrent =
+				right.provider === current.provider && right.id === current.model;
+			if (leftCurrent !== rightCurrent) return leftCurrent ? -1 : 1;
+			return modelLabel(left).localeCompare(modelLabel(right));
+		});
+	const choices = models.map((model, index) =>
+		index === 0 &&
+		model.provider === current.provider &&
+		model.id === current.model
+			? `${modelLabel(model)} (current)`
+			: modelLabel(model),
+	);
+	const selected = await ctx.ui.select(
+		`${roleLabel} model\nProvider: ${providerLabel(ctx, provider)}`,
+		choices,
+	);
+	if (!selected) return undefined;
+	return models[choices.indexOf(selected)];
+}
+
+async function changeModel(
+	ctx: ExtensionCommandContext,
+	available: AvailableModel[],
+	roleLabel: string,
+	current: ModelProfile,
+): Promise<ModelProfile | undefined> {
+	const provider = await selectProvider(
+		ctx,
+		available,
+		roleLabel,
+		current.provider,
+	);
+	if (!provider) return undefined;
+	const model = await selectModel(ctx, available, roleLabel, provider, current);
+	if (!model) return undefined;
+
+	const profile: ModelProfile = {
+		provider: model.provider,
+		model: model.id,
+		thinkingLevel: model.reasoning ? current.thinkingLevel : "off",
+	};
+	if (!model.reasoning) return profile;
+
+	const thinkingLevel = await selectThinkingLevel(ctx, roleLabel, profile);
+	if (!thinkingLevel) return undefined;
+	return { ...profile, thinkingLevel };
+}
+
+async function configureRole(
+	ctx: ExtensionCommandContext,
+	available: AvailableModel[],
+	config: GoalaConfig,
+	role: { key: ModelRole; label: string },
+): Promise<boolean> {
+	const current = config[role.key];
+	const currentModel = available.find(
+		(model) =>
+			model.provider === current.provider && model.id === current.model,
+	);
+	const actions = [
+		KEEP_CURRENT,
+		...(currentModel?.reasoning ? [CHANGE_REASONING] : []),
+		CHANGE_MODEL,
+	];
+	const action = await ctx.ui.select(
+		`${role.label}\nCurrent: ${profileLabel(ctx, available, current)}`,
+		actions,
+	);
+	if (!action) return false;
+	if (action === KEEP_CURRENT) return true;
+
+	if (action === CHANGE_REASONING) {
+		const thinkingLevel = await selectThinkingLevel(ctx, role.label, current);
+		if (!thinkingLevel) return false;
+		setProfile(config, role.key, { ...current, thinkingLevel });
+		return true;
+	}
+
+	const profile = await changeModel(ctx, available, role.label, current);
+	if (!profile) return false;
+	setProfile(config, role.key, profile);
+	return true;
+}
+
+function reviewSummary(
+	ctx: ExtensionCommandContext,
+	available: AvailableModel[],
+	config: GoalaConfig,
+): string {
+	return MODEL_ROLES.map(
+		(role) =>
+			`${role.label}: ${profileLabel(ctx, available, config[role.key])}`,
+	).join("\n");
+}
+
+export async function selectModelRoles(
+	ctx: ExtensionCommandContext,
+	current: GoalaConfig,
+): Promise<GoalaConfig | undefined> {
+	if (!ctx.hasUI) {
+		ctx.ui.notify("Per-phase model setup requires interactive Pi.", "warning");
+		return undefined;
+	}
+
+	try {
+		await ctx.modelRegistry.refresh();
+	} catch {
+		// The current registry can still contain usable cached and built-in models.
+	}
+	const available = ctx.modelRegistry.getAvailable();
+	if (available.length === 0) {
+		ctx.ui.notify(
+			"No authenticated models are available. Run /login, then retry /goala-setup.",
+			"warning",
+		);
+		return undefined;
+	}
+
+	const proposed = structuredClone(current);
+	for (const role of MODEL_ROLES) {
+		if (!(await configureRole(ctx, available, proposed, role))) return undefined;
+	}
+
+	while (true) {
+		const action = await ctx.ui.select(
+			`Review Goala configuration\n${reviewSummary(ctx, available, proposed)}`,
+			[SAVE_CONFIGURATION, EDIT_PHASE, CANCEL],
+		);
+		if (!action || action === CANCEL) return undefined;
+		if (action === SAVE_CONFIGURATION) return proposed;
+
+		const selectedRole = await ctx.ui.select(
+			"Choose a phase to edit",
+			MODEL_ROLES.map((role) => role.label),
+		);
+		if (!selectedRole) return undefined;
+		const role = MODEL_ROLES.find((candidate) => candidate.label === selectedRole);
+		if (!role || !(await configureRole(ctx, available, proposed, role))) {
+			return undefined;
+		}
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goala",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Goal-oriented agent lifecycle, evidence, and verified memory for Pi.",
   "type": "module",
   "author": "Barry King",