pi-goala 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 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.0
 ```
 
 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.0
 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     Choose an available provider/model for every role
 /goala-setup status     Show effective configuration
 ```
 
@@ -379,7 +380,13 @@ 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 picker reads Pi's available model registry and saves only after
+every role has been selected.
+
+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,10 @@ 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
+enumerates Pi's authenticated available models and stores provider, model, and
+reasoning independently for every role; 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,43 @@ 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` interactively selects a provider/model and reasoning level for each
+role from Pi's authenticated, available model registry. 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 +104,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,21 +578,27 @@ 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),
@@ -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,109 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type {
+	GoalaConfig,
+	ModelProfile,
+	ThinkingLevel,
+} from "./config.ts";
+
+type ModelRole =
+	| "planner"
+	| "executor"
+	| "stepVerifier"
+	| "verifier"
+	| "fallbackExecutor";
+
+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",
+];
+
+function profileLabel(profile: ModelProfile): string {
+	return `${profile.provider}/${profile.model}:${profile.thinkingLevel}`;
+}
+
+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) {
+		const existing = proposed[role.key];
+		const ordered = [...available].sort((left, right) => {
+			const leftCurrent =
+				left.provider === existing.provider && left.id === existing.model;
+			const rightCurrent =
+				right.provider === existing.provider && right.id === existing.model;
+			if (leftCurrent !== rightCurrent) return leftCurrent ? -1 : 1;
+			return `${left.provider}/${left.id}`.localeCompare(`${right.provider}/${right.id}`);
+		});
+		const choices = ordered.map((model) => {
+			const provider = ctx.modelRegistry.getProviderDisplayName(model.provider);
+			const name = model.name && model.name !== model.id ? `${model.name} · ` : "";
+			return `${provider} · ${name}${model.provider}/${model.id}`;
+		});
+		const selected = await ctx.ui.select(
+			`${role.label} model\nCurrent: ${profileLabel(existing)}`,
+			choices,
+		);
+		if (!selected) return undefined;
+		const model = ordered[choices.indexOf(selected)];
+		if (!model) return undefined;
+
+		let thinkingLevel: ThinkingLevel = "off";
+		if (model.reasoning) {
+			const selectedThinking = await ctx.ui.select(
+				`${role.label} reasoning\n${model.provider}/${model.id}`,
+				[...THINKING_LEVELS],
+			);
+			if (!selectedThinking) return undefined;
+			thinkingLevel = selectedThinking as ThinkingLevel;
+		}
+
+		const profile: ModelProfile = {
+			provider: model.provider,
+			model: model.id,
+			thinkingLevel,
+		};
+		if (role.key === "fallbackExecutor") {
+			proposed.fallbackExecutor = {
+				...profile,
+				afterRepairCycle: current.fallbackExecutor.afterRepairCycle,
+			};
+		} else {
+			proposed[role.key] = profile;
+		}
+	}
+	return proposed;
+}

package/package.json

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