@phi-code-admin/phi-code 0.75.4 → 0.75.6

package/extensions/phi/init.ts

@@ -1,144 +1,75 @@
 /**
- * Phi Init Extension - Interactive setup wizard for Phi Code
+ * Phi Init Extension - Interactive setup wizard for Phi Code (legacy `/phi-init`).
  *
- * Detects providers (API keys + local endpoints), then lets the user
- * manually assign models to each agent role (code, debug, plan, explore, test, review).
+ * Detects providers (API keys + local endpoints), then lets the user manually
+ * assign models to each agent role (code, debug, plan, explore, test, review).
  *
  * Creates ~/.phi/agent/ structure with routing, agents, and memory.
+ *
+ * Hardening (2026-05-15):
+ *  - Uses the unified live-models registry (every provider is now refreshed
+ *    against its `/v1/models` endpoint, with static fallback when offline).
+ *  - The entire handler runs inside a defensive try/catch that surfaces errors
+ *    as `ctx.ui.notify("error")` instead of letting the host TUI crash. A
+ *    process-level `unhandledRejection` guard is installed once on first run
+ *    so a stray promise rejection during model probing cannot terminate phi-code.
+ *  - The API-key input flow now persists the key BEFORE any model enrichment
+ *    so a network failure on /v1/models cannot lose the user's input.
  */
 
 import type { ExtensionAPI } from "phi-code";
-import { writeFile, mkdir, copyFile, readdir, access, readFile } from "node:fs/promises";
+import { writeFile, mkdir, copyFile, readdir, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { existsSync } from "node:fs";
+import { fetchLiveModels, pingProvider, toPersistedModel } from "./providers/live-models.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
 interface DetectedProvider {
+	id: string;
 	name: string;
 	envVar: string;
 	baseUrl: string;
-	models: string[];
+	api: string;
+	requiresApiKey: boolean;
 	available: boolean;
-	local?: boolean; // True for Ollama/LM Studio (models discovered at runtime)
+	models: string[];
+	/** True for Ollama/LM Studio (models discovered at runtime, no key required). */
+	local?: boolean;
 }
 
 interface RoutingConfig {
-	routes: Record<string, {
-		description: string;
-		keywords: string[];
-		preferredModel: string;
-		fallback: string;
-		agent: string;
-	}>;
-	default: { model: string; agent: string | null };
-}
-
-// ─── Dynamic Model Specs via OpenRouter ──────────────────────────────────
-
-interface ModelSpec {
-	contextWindow: number;
-	maxTokens: number;
-	reasoning: boolean;
-}
-
-// Cache for OpenRouter model data (fetched once per session)
-let openRouterCache: Map<string, ModelSpec> | null = null;
-
-/**
- * Fetch model specs from OpenRouter's free API (no key needed).
- * Returns a map of model base name → specs.
- * Falls back to conservative defaults if unreachable.
- */
-async function fetchModelSpecs(): Promise<Map<string, ModelSpec>> {
-	if (openRouterCache) return openRouterCache;
-
-	const cache = new Map<string, ModelSpec>();
-
-	try {
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), 5000);
-		const res = await fetch("https://openrouter.ai/api/v1/models", {
-			signal: controller.signal,
-		});
-		clearTimeout(timeout);
-
-		if (res.ok) {
-			const data = await res.json() as any;
-			for (const m of (data.data || [])) {
-				const contextLength = m.context_length || 128000;
-				const maxOutput = m.top_provider?.max_completion_tokens || Math.min(contextLength, 16384);
-				const hasReasoning = (m.supported_parameters || []).includes("reasoning");
-
-				// Store by full ID and by base name (for fuzzy matching)
-				const spec: ModelSpec = {
-					contextWindow: contextLength,
-					maxTokens: typeof maxOutput === "number" ? maxOutput : 16384,
-					reasoning: hasReasoning,
-				};
-
-				cache.set(m.id, spec);
-				// Also store by short name (e.g., "qwen3.5-plus" from "qwen/qwen3.5-plus-02-15")
-				const parts = m.id.split("/");
-				if (parts.length > 1) {
-					cache.set(parts[1], spec);
-				}
-			}
+	routes: Record<
+		string,
+		{
+			description: string;
+			keywords: string[];
+			preferredModel: string;
+			fallback: string;
+			agent: string;
 		}
-	} catch {
-		// OpenRouter unreachable — cache stays empty, fallback used
-	}
-
-	openRouterCache = cache;
-	return cache;
+	>;
+	default: { model: string; agent: string | null };
 }
 
-/**
- * Get model spec by ID. Tries OpenRouter cache first with fuzzy matching,
- * then falls back to conservative defaults.
- */
-async function getModelSpec(id: string): Promise<ModelSpec> {
-	const cache = await fetchModelSpecs();
-
-	// Exact match
-	if (cache.has(id)) return cache.get(id)!;
+// ─── One-time global unhandledRejection guard ────────────────────────────
 
-	// Try common prefixed variants
-	const prefixes = ["qwen/", "moonshotai/", "z-ai/", "minimax/", "openai/", "anthropic/", "google/"];
-	for (const prefix of prefixes) {
-		const key = prefix + id;
-		if (cache.has(key)) return cache.get(key)!;
-	}
-
-	// Fuzzy: find by base name inclusion
-	const lower = id.toLowerCase().replace(/[-_.]/g, "");
-	for (const [key, spec] of cache) {
-		const keyLower = key.toLowerCase().replace(/[-_.]/g, "");
-		if (keyLower.includes(lower) || lower.includes(keyLower.split("/").pop() || "")) {
-			return spec;
+let unhandledRejectionGuardInstalled = false;
+function installUnhandledRejectionGuard(): void {
+	if (unhandledRejectionGuardInstalled) return;
+	unhandledRejectionGuardInstalled = true;
+	process.on("unhandledRejection", (reason) => {
+		// Swallow async failures from extension wizards so they cannot terminate the TUI.
+		// The wizard itself reports the failure via ctx.ui.notify in its own try/catch.
+		const message = reason instanceof Error ? reason.message : String(reason);
+		try {
+			// Best effort logging — process.stderr survives TUI shutdown unlike console.
+			process.stderr.write(`[phi-init] swallowed unhandledRejection: ${message}\n`);
+		} catch {
+			// no-op
 		}
-	}
-
-	// Conservative fallback
-	return { contextWindow: 128000, maxTokens: 16384, reasoning: true };
-}
-
-/**
- * Synchronous fallback for non-async contexts.
- * Uses cached data if available, otherwise returns defaults.
- */
-function getModelSpecSync(id: string): ModelSpec {
-	if (!openRouterCache) return { contextWindow: 128000, maxTokens: 16384, reasoning: true };
-
-	if (openRouterCache.has(id)) return openRouterCache.get(id)!;
-
-	const prefixes = ["qwen/", "moonshotai/", "z-ai/", "minimax/", "openai/", "anthropic/", "google/"];
-	for (const prefix of prefixes) {
-		if (openRouterCache.has(prefix + id)) return openRouterCache.get(prefix + id)!;
-	}
-
-	return { contextWindow: 128000, maxTokens: 16384, reasoning: true };
+	});
 }
 
 // ─── Provider Detection ──────────────────────────────────────────────────
@@ -146,115 +77,132 @@ function getModelSpecSync(id: string): ModelSpec {
 function detectProviders(): DetectedProvider[] {
 	const providers: DetectedProvider[] = [
 		{
+			id: "alibaba-codingplan",
 			name: "Alibaba Coding Plan",
 			envVar: "ALIBABA_CODING_PLAN_KEY",
 			baseUrl: "https://coding-intl.dashscope.aliyuncs.com/v1",
-			models: ["qwen3.5-plus", "qwen3-max-2026-01-23", "qwen3-coder-plus", "qwen3-coder-next", "kimi-k2.5", "glm-5", "glm-4.7", "MiniMax-M2.5"],
+			api: "openai-completions",
+			requiresApiKey: true,
 			available: false,
+			models: [],
 		},
 		{
+			id: "opencode-go",
 			name: "OpenCode Go",
 			envVar: "OPENCODE_GO_API_KEY",
 			baseUrl: "https://opencode.ai/zen/go/v1",
-			models: ["kimi-k2.6", "kimi-k2.5", "qwen3-coder", "qwen3-coder-plus", "glm-4.6", "glm-5", "deepseek-v3", "minimax-m2", "MiniMax-M2.5", "moonshotai-kimi-thinking", "z-ai-glm-4.7", "gpt-oss-120b"],
+			api: "openai-completions",
+			requiresApiKey: true,
 			available: false,
+			models: [],
 		},
 		{
+			id: "openai",
 			name: "OpenAI",
 			envVar: "OPENAI_API_KEY",
 			baseUrl: "https://api.openai.com/v1",
-			models: ["gpt-4o", "gpt-4o-mini", "o1", "o3-mini"],
+			api: "openai-completions",
+			requiresApiKey: true,
 			available: false,
+			models: [],
 		},
 		{
+			id: "anthropic",
 			name: "Anthropic",
 			envVar: "ANTHROPIC_API_KEY",
 			baseUrl: "https://api.anthropic.com/v1",
-			models: ["claude-sonnet-4-20250514", "claude-3-5-haiku-20241022"],
+			api: "anthropic-messages",
+			requiresApiKey: true,
 			available: false,
+			models: [],
 		},
 		{
-			name: "Google",
+			id: "google",
+			name: "Google Gemini",
 			envVar: "GOOGLE_API_KEY",
 			baseUrl: "https://generativelanguage.googleapis.com/v1beta",
-			models: ["gemini-2.5-pro", "gemini-2.5-flash"],
+			api: "google",
+			requiresApiKey: true,
 			available: false,
+			models: [],
 		},
 		{
+			id: "openrouter",
 			name: "OpenRouter",
 			envVar: "OPENROUTER_API_KEY",
 			baseUrl: "https://openrouter.ai/api/v1",
-			models: [],
+			api: "openai-completions",
+			requiresApiKey: true,
 			available: false,
+			models: [],
 		},
 		{
+			id: "groq",
 			name: "Groq",
 			envVar: "GROQ_API_KEY",
 			baseUrl: "https://api.groq.com/openai/v1",
-			models: ["llama-3.3-70b-versatile", "mixtral-8x7b-32768"],
+			api: "openai-completions",
+			requiresApiKey: true,
 			available: false,
+			models: [],
 		},
 		{
+			id: "ollama",
 			name: "Ollama",
 			envVar: "OLLAMA",
 			baseUrl: "http://localhost:11434/v1",
-			models: [], // Discovered at runtime
+			api: "openai-completions",
+			requiresApiKey: false,
 			available: false,
+			models: [],
 			local: true,
 		},
 		{
+			id: "lm-studio",
 			name: "LM Studio",
 			envVar: "LM_STUDIO",
 			baseUrl: "http://localhost:1234/v1",
-			models: [], // Discovered at runtime
+			api: "openai-completions",
+			requiresApiKey: false,
 			available: false,
+			models: [],
 			local: true,
 		},
 	];
 
 	for (const p of providers) {
-		if (p.local) {
-			// Local providers: check if server is running by probing the URL
-			p.available = false; // Will be checked async in detectLocalProviders()
-		} else {
-			p.available = !!process.env[p.envVar];
+		if (!p.local && process.env[p.envVar]) {
+			p.available = true;
 		}
 	}
-
 	return providers;
 }
 
 /**
- * Detect local providers (Ollama, LM Studio) by probing their endpoints
- * and fetching available models dynamically.
+ * Probe local providers (Ollama, LM Studio) and live-fetch their model list.
+ * Failures are silent — local servers are optional.
  */
 async function detectLocalProviders(providers: DetectedProvider[]): Promise<void> {
-	for (const p of providers) {
-		if (!p.local) continue;
-		try {
-			const controller = new AbortController();
-			const timeout = setTimeout(() => controller.abort(), 3000);
-			const res = await fetch(`${p.baseUrl}/models`, {
-				signal: controller.signal,
-				headers: { Authorization: `Bearer ${p.envVar === "OLLAMA" ? "ollama" : "lm-studio"}` },
-			});
-			clearTimeout(timeout);
-			if (res.ok) {
-				const data = await res.json() as any;
-				const models = (data.data || []).map((m: any) => m.id).filter(Boolean);
-				if (models.length > 0) {
-					p.models = models;
+	await Promise.all(
+		providers
+			.filter((p) => p.local)
+			.map(async (p) => {
+				const result = await fetchLiveModels(p.id, { forceRefresh: true, timeoutMs: 2_500 });
+				if (result.models.length > 0 && result.source !== "fallback") {
+					p.models = result.models.map((m) => m.id);
 					p.available = true;
 				}
-			}
-		} catch {
-			// Server not running — that's fine
-		}
-	}
+			}),
+	);
 }
 
 function getAllAvailableModels(providers: DetectedProvider[]): string[] {
-	return providers.filter(p => p.available).flatMap(p => p.models);
+	const ids = new Set<string>();
+	for (const p of providers) {
+		if (!p.available) continue;
+		for (const id of p.models) ids.add(id);
+	}
+	return [...ids];
 }
 
 // ─── Routing Presets ─────────────────────────────────────────────────────
@@ -277,7 +225,9 @@ const KEYWORDS: Record<string, string[]> = {
 	review: ["review", "audit", "quality", "security", "improve", "optimize"],
 };
 
-function createRouting(assignments: Record<string, { preferred: string; fallback: string }>): RoutingConfig {
+function createRouting(
+	assignments: Record<string, { preferred: string; fallback: string }>,
+): RoutingConfig {
 	const routes: RoutingConfig["routes"] = {};
 	for (const role of TASK_ROLES) {
 		const assignment = assignments[role.key];
@@ -298,35 +248,37 @@ function createRouting(assignments: Record<string, { preferred: string; fallback
 // ─── Extension ───────────────────────────────────────────────────────────
 
 export default function initExtension(pi: ExtensionAPI) {
+	installUnhandledRejectionGuard();
+
 	const phiDir = join(homedir(), ".phi");
 	const agentDir = join(phiDir, "agent");
 	const agentsDir = join(agentDir, "agents");
 	const memoryDir = join(phiDir, "memory");
-
-	/**
-	 * Create all necessary directories
-	 */
-	async function ensureDirs() {
-		for (const dir of [agentDir, agentsDir, join(agentDir, "skills"), join(agentDir, "extensions"), memoryDir, join(memoryDir, "ontology")]) {
+	const modelsJsonPath = join(agentDir, "models.json");
+
+	async function ensureDirs(): Promise<void> {
+		for (const dir of [
+			agentDir,
+			agentsDir,
+			join(agentDir, "skills"),
+			join(agentDir, "extensions"),
+			memoryDir,
+			join(memoryDir, "ontology"),
+		]) {
 			await mkdir(dir, { recursive: true });
 		}
 	}
 
-	/**
-	 * Copy bundled agent definitions to user directory
-	 */
-	async function copyBundledAgents() {
+	async function copyBundledAgents(): Promise<void> {
 		const bundledDir = resolve(join(__dirname, "..", "..", "..", "agents"));
 		if (!existsSync(bundledDir)) return;
-
 		try {
 			const files = await readdir(bundledDir);
 			for (const file of files) {
-				if (file.endsWith(".md")) {
-					const dest = join(agentsDir, file);
-					if (!existsSync(dest)) {
-						await copyFile(join(bundledDir, file), dest);
-					}
+				if (!file.endsWith(".md")) continue;
+				const dest = join(agentsDir, file);
+				if (!existsSync(dest)) {
+					await copyFile(join(bundledDir, file), dest);
 				}
 			}
 		} catch {
@@ -334,14 +286,12 @@ export default function initExtension(pi: ExtensionAPI) {
 		}
 	}
 
-	/**
-	 * Create AGENTS.md template
-	 */
-	async function createAgentsTemplate() {
+	async function createAgentsTemplate(): Promise<void> {
 		const agentsMdPath = join(memoryDir, "AGENTS.md");
-		if (existsSync(agentsMdPath)) return; // Don't overwrite
-
-		await writeFile(agentsMdPath, `# AGENTS.md — Persistent Instructions
+		if (existsSync(agentsMdPath)) return;
+		await writeFile(
+			agentsMdPath,
+			`# AGENTS.md — Persistent Instructions
 
 This file is loaded at the start of every session. Use it to store:
 - Project conventions and rules
@@ -367,280 +317,342 @@ This file is loaded at the start of every session. Use it to store:
 ---
 
 _Edit this file to customize Phi Code's behavior for your project._
-`, "utf-8");
+`,
+			"utf-8",
+		);
 	}
 
-	// ─── MODE: Auto ──────────────────────────────────────────────────
+	// ─── Persistence helper (single source of truth for models.json writes) ──
 
-	/**
-	 * Manual mode is the only setup mode.
-	 * User assigns each model to each agent role interactively.
-	 */
-	// ─── MODE: Manual ────────────────────────────────────────────────
+	async function readModelsConfig(): Promise<{ providers: Record<string, any> }> {
+		try {
+			const raw = await readFile(modelsJsonPath, "utf-8");
+			const parsed = JSON.parse(raw) as { providers?: Record<string, any> };
+			return { providers: parsed.providers ?? {} };
+		} catch {
+			return { providers: {} };
+		}
+	}
+
+	async function writeModelsConfig(config: { providers: Record<string, any> }): Promise<void> {
+		await mkdir(agentDir, { recursive: true });
+		await writeFile(modelsJsonPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+	}
+
+	async function persistProviderKey(
+		provider: DetectedProvider,
+		apiKey: string,
+	): Promise<void> {
+		const config = await readModelsConfig();
+		const existing = config.providers[provider.id] ?? {};
+		config.providers[provider.id] = {
+			...existing,
+			baseUrl: provider.baseUrl,
+			api: provider.api,
+			apiKey,
+		};
+		await writeModelsConfig(config);
+	}
 
-	async function manualMode(availableModels: string[], ctx: any): Promise<Record<string, { preferred: string; fallback: string }>> {
-		ctx.ui.notify("🎛️ Manual mode: assign a model to each task category.\n", "info");
+	async function persistProviderModels(
+		provider: DetectedProvider,
+		models: ReturnType<typeof toPersistedModel>[],
+	): Promise<void> {
+		const config = await readModelsConfig();
+		const existing = config.providers[provider.id] ?? {};
+		config.providers[provider.id] = {
+			...existing,
+			baseUrl: provider.baseUrl,
+			api: provider.api,
+			models,
+		};
+		await writeModelsConfig(config);
+	}
 
-		const modelOptions = ["default (use current model)", ...availableModels];
+	// ─── Manual model assignment (one model per orchestration role) ─────
+	//
+	// As of 0.75.6, `/phi-init` ONLY configures orchestration role models
+	// (used by `/plan` and the orchestrator). The chat default model is
+	// owned exclusively by `/model` and persisted via the settings manager.
+	// We intentionally do NOT ask "Default model" here — that would override
+	// the user's `/model` choice on every routing decision.
+
+	async function manualMode(
+		availableModels: string[],
+		ctx: any,
+	): Promise<Record<string, { preferred: string; fallback: string }>> {
+		ctx.ui.notify(
+			"Assign a model to each orchestration role.\n" +
+				"These models are used by `/plan` and the orchestrator — NOT by normal chat.\n" +
+				"The chat default model is controlled via `/model` (and stays sticky across prompts).\n",
+			"info",
+		);
+		const modelOptions = ["default (use current chat model)", ...availableModels];
 		const assignments: Record<string, { preferred: string; fallback: string }> = {};
 
 		for (const role of TASK_ROLES) {
-			// Primary model selection
-			const chosen = await ctx.ui.select(
-				`${role.label} — ${role.desc}`,
-				modelOptions,
-			);
-			const preferredModel = (chosen && chosen !== modelOptions[0]) ? chosen : "default";
+			const chosen = await ctx.ui.select(`${role.label} — ${role.desc}`, modelOptions);
+			const preferredModel = chosen && chosen !== modelOptions[0] ? chosen : "default";
 
-			// Fallback model selection
-			const fallbackOptions = modelOptions.filter(m => m !== chosen);
-			const fallbackChoice = await ctx.ui.select(
-				`Fallback for ${role.label}`,
-				fallbackOptions,
-			);
-			const fallback = (fallbackChoice && fallbackChoice !== modelOptions[0]) ? fallbackChoice : "default";
+			const fallbackOptions = modelOptions.filter((m) => m !== chosen);
+			const fallbackChoice = await ctx.ui.select(`Fallback for ${role.label}`, fallbackOptions);
+			const fallback = fallbackChoice && fallbackChoice !== modelOptions[0] ? fallbackChoice : "default";
 
 			assignments[role.key] = { preferred: preferredModel, fallback };
-			ctx.ui.notify(`  ✅ ${role.label}: ${preferredModel} (fallback: ${fallback})`, "info");
+			ctx.ui.notify(`  ${role.label}: ${preferredModel} (fallback: ${fallback})`, "info");
 		}
 
-		// Default model
-		const defaultChoice = await ctx.ui.select("Default model (for general tasks)", modelOptions);
-		let defaultModel = (defaultChoice && defaultChoice !== modelOptions[0]) ? defaultChoice : "default";
-		assignments["default"] = { preferred: defaultModel, fallback: availableModels[0] || "default" };
-
+		// Orchestrator fallback (used only when a specific route has no model).
+		// This is NOT the chat default — `/model` controls that.
+		assignments["default"] = {
+			preferred: "default",
+			fallback: availableModels[0] || "default",
+		};
 		return assignments;
 	}
 
-	// ─── Command ─────────────────────────────────────────────────────
+	// ─── Per-provider configuration step ─────────────────────────────────
+
+	async function configureProvider(provider: DetectedProvider, ctx: any): Promise<void> {
+		if (provider.local) {
+			const port = provider.id === "ollama" ? 11434 : 1234;
+			const result = await fetchLiveModels(provider.id, { forceRefresh: true, timeoutMs: 2_500 });
+			if (result.source === "live" && result.models.length > 0) {
+				provider.models = result.models.map((m) => m.id);
+				provider.available = true;
+				ctx.ui.notify(
+					`${provider.name} is running with ${provider.models.length} model(s).\n`,
+					"info",
+				);
+			} else {
+				ctx.ui.notify(
+					`${provider.name} not reachable on port ${port}. Start it and re-run \`/phi-init\`.\n`,
+					"warning",
+				);
+			}
+			return;
+		}
 
-	pi.registerCommand("phi-init", {
-		description: "Initialize Phi Code (legacy alias — prefer /setup for the refined wizard)",
-		handler: async (args, ctx) => {
+		// Cloud provider — API key required.
+		ctx.ui.notify(
+			`\n${provider.name}\nNote: the key you type will be visible on screen. Stored in ${modelsJsonPath} (chmod 0600 on Unix).`,
+			"info",
+		);
+
+		const apiKey = await ctx.ui.input(
+			`Enter your ${provider.name} API key`,
+			"Paste your key here",
+		);
+
+		if (apiKey === undefined) {
+			ctx.ui.notify("Cancelled. No key saved.", "warning");
+			return;
+		}
+		const trimmed = apiKey.trim();
+		if (trimmed.length < 5) {
+			ctx.ui.notify("Invalid API key (too short). Skipped.\n", "error");
+			return;
+		}
+
+		// Persist the key FIRST. Any subsequent failure during live-fetch must
+		// not cause the user to lose what they just typed.
+		try {
+			await persistProviderKey(provider, trimmed);
+			process.env[provider.envVar] = trimmed;
+		} catch (err) {
 			ctx.ui.notify(
-				"NOTE: `/phi-init` is the legacy wizard. The refined replacement is `/setup` " +
-					"(richer flow: Alibaba dual-endpoint, OpenCode Go auto-fetch, ping validation, " +
-					"separate chat/orchestration assignments, hot-reload integration). " +
-					"This legacy command still works for backwards compatibility.",
-				"info",
+				`Failed to write ${modelsJsonPath}: ${err instanceof Error ? err.message : String(err)}`,
+				"error",
 			);
-			try {
-				ctx.ui.notify("╔══════════════════════════════════════╗", "info");
-				ctx.ui.notify("║     φ  Phi Code Setup Wizard        ║", "info");
-				ctx.ui.notify("╚══════════════════════════════════════╝\n", "info");
+			return;
+		}
 
-				// Pre-fetch model specs from OpenRouter (async, cached)
-				ctx.ui.notify("🔍 Fetching model specs from OpenRouter...", "info");
-				await fetchModelSpecs();
+		// Optional ping — informational only, never fatal.
+		ctx.ui.setStatus?.("phi-init-ping", `Pinging ${provider.name}...`);
+		const ping = await pingProvider(provider.id, trimmed, 5_000).catch((err) => ({
+			ok: false,
+			error: err instanceof Error ? err.message : String(err),
+		}));
+		ctx.ui.setStatus?.("phi-init-ping", undefined);
+		if (ping.ok) {
+			ctx.ui.notify(`${provider.name} ping OK (200).`, "info");
+		} else {
+			ctx.ui.notify(
+				`${provider.name} ping failed: ${ping.error ?? "unknown"}. Key saved anyway — you can retry with \`/keys test ${provider.id}\`.`,
+				"warning",
+			);
+		}
 
-				// 1. Detect providers
-				ctx.ui.notify("🔍 Detecting providers...\n", "info");
+		// Fetch live model list (with fallback) and persist it.
+		ctx.ui.setStatus?.("phi-init-fetch", `Fetching ${provider.name} models...`);
+		const live = await fetchLiveModels(provider.id, {
+			apiKey: trimmed,
+			forceRefresh: true,
+			timeoutMs: 6_000,
+		});
+		ctx.ui.setStatus?.("phi-init-fetch", undefined);
+
+		const persistedModels = live.models.map(toPersistedModel);
+		try {
+			await persistProviderModels(provider, persistedModels);
+		} catch (err) {
+			ctx.ui.notify(
+				`Failed to write provider models to ${modelsJsonPath}: ${err instanceof Error ? err.message : String(err)}`,
+				"error",
+			);
+			return;
+		}
+
+		provider.models = persistedModels.map((m) => m.id);
+		provider.available = true;
+		const masked = `${trimmed.slice(0, 6)}...${trimmed.slice(-4)}`;
+		ctx.ui.notify(
+			`${provider.name} configured (${masked}) — ${persistedModels.length} models (source: ${live.source}${live.error ? `, ${live.error}` : ""}).\n`,
+			"info",
+		);
+	}
+
+	// ─── Command ─────────────────────────────────────────────────────
+
+	pi.registerCommand("phi-init", {
+		description: "Initialize Phi Code (legacy alias — prefer /setup for the refined wizard)",
+		handler: async (_args, ctx) => {
+			try {
+				ctx.ui.notify(
+					"`/phi-init` configures **orchestration** roles only (Code / Debug / Plan / Explore / " +
+						"Test / Review — used by `/plan` and the orchestrator).\n\n" +
+						"The **chat default model** is owned exclusively by `/model` and stays sticky across " +
+						"prompts. This wizard will NOT change it.",
+					"info",
+				);
+
+				ctx.ui.notify("    Phi Code Setup Wizard (orchestration roles)", "info");
+
+				// 1. Detect providers (env vars + local servers + previously saved keys)
+				ctx.ui.notify("Detecting providers...\n", "info");
 				const providers = detectProviders();
 
-				// Also check models.json for previously configured providers
-				const modelsJsonPath = join(agentDir, "models.json");
-				try {
-					const mjContent = await readFile(modelsJsonPath, "utf-8");
-					const mjConfig = JSON.parse(mjContent);
-					if (mjConfig.providers) {
-						for (const [id, config] of Object.entries<any>(mjConfig.providers)) {
-							// Mark provider as available if it has an API key in models.json
-							if (config.apiKey) {
-								const match = providers.find(p =>
-									id.includes(p.name.toLowerCase().split(" ")[0]) ||
-									p.name.toLowerCase().replace(/\s+/g, "-") === id
-								);
-								if (match) {
-									match.available = true;
-									if (config.models?.length > 0) {
-										match.models = config.models.map((m: any) => m.id || m);
-									}
-								}
-							}
+				// Merge in any previously saved providers from models.json.
+				const savedConfig = await readModelsConfig();
+				for (const [id, config] of Object.entries(savedConfig.providers)) {
+					const match = providers.find((p) => p.id === id);
+					if (!match) continue;
+					if (config?.apiKey) {
+						match.available = true;
+						if (Array.isArray(config.models) && config.models.length > 0) {
+							match.models = config.models.map((m: any) => (typeof m === "string" ? m : m?.id)).filter(Boolean);
 						}
 					}
-				} catch { /* no models.json yet */ }
+				}
 
 				// Probe local providers (Ollama, LM Studio)
 				await detectLocalProviders(providers);
 
-				let available = providers.filter(p => p.available);
-				const cloudConfigured = available.filter(p => !p.local);
-
-				// Always show provider status and offer to add/change
-				ctx.ui.notify("**Provider Status:**", "info");
+				ctx.ui.notify("Provider Status:", "info");
 				for (const p of providers) {
-					const status = p.available ? "✅" : "⬜";
+					const status = p.available ? "[ok]" : "[--]";
 					const tag = p.local ? " (local)" : "";
 					const modelCount = p.available ? ` — ${p.models.length} model(s)` : "";
 					ctx.ui.notify(`  ${status} ${p.name}${tag}${modelCount}`, "info");
 				}
 
-				// No warning needed — the wizard itself handles configuration
-
-				// Provider configuration loop — add as many providers as needed
+				// Provider configuration loop
 				let addingProviders = true;
 				while (addingProviders) {
 					const providerOptions = [
 						"Done — continue with current providers",
-						...providers.map(p => {
-							const status = p.available ? "✅" : "⬜";
+						...providers.map((p) => {
+							const status = p.available ? "[ok]" : "[--]";
 							const tag = p.local ? " (local)" : "";
 							const modelCount = p.available ? ` (${p.models.length} models)` : "";
 							return `${status} ${p.name}${tag}${modelCount}`;
 						}),
 					];
-					const addProvider = await ctx.ui.select("Configure a provider (add multiple!):", providerOptions);
+					const addProvider = await ctx.ui.select(
+						"Configure a provider (add multiple!):",
+						providerOptions,
+					);
 
 					const choiceIdx = providerOptions.indexOf(addProvider ?? "");
-					if (choiceIdx <= 0) { // 0 = Done, or cancelled
+					if (choiceIdx <= 0) {
 						addingProviders = false;
 						break;
 					}
 
 					const chosen = providers[choiceIdx - 1];
-
-					if (chosen.local) {
-						const port = chosen.name === "Ollama" ? 11434 : 1234;
-						if (!chosen.available) {
-							ctx.ui.notify(`\n💡 **${chosen.name}** — make sure it's running on port ${port}.`, "info");
-							ctx.ui.notify("Then restart phi and run `/phi-init` again.\n", "info");
-						} else {
-							ctx.ui.notify(`\n✅ **${chosen.name}** is running with ${chosen.models.length} model(s).\n`, "info");
-						}
-					} else {
-						// Cloud provider — choose auth method
-						const supportsOAuth = ["openai", "anthropic", "google"].includes(
-							chosen.name.toLowerCase().split(" ")[0]
+					try {
+						await configureProvider(chosen, ctx);
+					} catch (err) {
+						// Never bubble up — keep the wizard alive.
+						ctx.ui.notify(
+							`Provider configuration failed: ${err instanceof Error ? err.message : String(err)}`,
+							"error",
 						);
-
-						let authMethod = "api-key";
-						if (supportsOAuth) {
-							const authChoice = await ctx.ui.select(
-								`How to authenticate with ${chosen.name}?`,
-								["API Key (paste your key)", "OAuth (browser login via /login)"]
-							);
-							if (authChoice?.includes("OAuth")) {
-								authMethod = "oauth";
-							}
-						}
-
-						if (authMethod === "oauth") {
-							ctx.ui.notify(`\n🔐 **${chosen.name}** — Use \`/login\` after setup to authenticate via OAuth.`, "info");
-							ctx.ui.notify("OAuth opens a browser window for secure login.\n", "info");
-							// Mark as available for model assignment (auth will be done via /login)
-							chosen.available = true;
-						} else {
-							// API Key method
-							ctx.ui.notify(`\n🔑 **${chosen.name}**`, "info");
-
-							const apiKey = await ctx.ui.input(
-								`Enter your ${chosen.name} API key`,
-								"Paste your key here"
-							);
-
-							if (!apiKey || apiKey.trim().length < 5) {
-								ctx.ui.notify("❌ Invalid API key. Skipped.\n", "error");
-							} else {
-								// Save to models.json (merges with existing)
-								let modelsConfig: any = { providers: {} };
-								try {
-									const existing = await readFile(modelsJsonPath, "utf-8");
-									modelsConfig = JSON.parse(existing);
-									if (!modelsConfig.providers) modelsConfig.providers = {};
-								} catch { /* new file */ }
-
-								const providerId = chosen.name.toLowerCase().replace(/\s+/g, "-");
-								modelsConfig.providers[providerId] = {
-									baseUrl: chosen.baseUrl,
-									api: "openai-completions",
-									apiKey: apiKey.trim(),
-									models: await Promise.all(chosen.models.map(async (id: string) => {
-										const spec = await getModelSpec(id);
-										return {
-											id,
-											name: id,
-											reasoning: spec.reasoning,
-											input: ["text"],
-											contextWindow: spec.contextWindow,
-											maxTokens: spec.maxTokens,
-										};
-									})),
-								};
-
-								await writeFile(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
-								process.env[chosen.envVar] = apiKey.trim();
-								chosen.available = true;
-
-								const masked = apiKey.trim().substring(0, 6) + "..." + apiKey.trim().slice(-4);
-								ctx.ui.notify(`✅ **${chosen.name}** configured (${masked})`, "info");
-								ctx.ui.notify(`   ${chosen.models.length} models added to \`models.json\`\n`, "info");
-							}
-						}
 					}
-				} // end while (addingProviders)
-
-				// Re-check available after potential additions
-				available = providers.filter(p => p.available);
+				}
 
+				const available = providers.filter((p) => p.available);
 				if (available.length === 0) {
-					ctx.ui.notify("\n❌ No providers available. Run `/phi-init` again after setting up a provider.", "error");
+					ctx.ui.notify(
+						"No providers available. Run `/phi-init` again after setting up a provider.",
+						"error",
+					);
 					return;
 				}
 
 				const allModels = getAllAvailableModels(providers);
-				ctx.ui.notify(`\n✅ **${allModels.length} models** available from ${available.length} provider(s).\n`, "info");
-
-				// 2. Assign models to agents (manual)
-				ctx.ui.notify(`\n📋 **Assign a model to each agent role:**\n`, "info");
+				ctx.ui.notify(
+					`\n${allModels.length} models available from ${available.length} provider(s).\n`,
+					"info",
+				);
 
+				// 2. Assign models to agents
+				ctx.ui.notify("Assign a model to each agent role:\n", "info");
 				const assignments = await manualMode(allModels, ctx);
 
-				// 4. Create directory structure
-				ctx.ui.notify("\n📁 Creating directories...", "info");
+				// 3. Persist everything
+				ctx.ui.notify("Creating directories...", "info");
 				await ensureDirs();
 
-				// 5. Write routing config
-				ctx.ui.notify("🔀 Writing routing configuration...", "info");
+				ctx.ui.notify("Writing routing configuration...", "info");
 				const routing = createRouting(assignments);
-				await writeFile(join(agentDir, "routing.json"), JSON.stringify(routing, null, 2), "utf-8");
+				await writeFile(
+					join(agentDir, "routing.json"),
+					JSON.stringify(routing, null, 2),
+					"utf-8",
+				);
 
-				// 6. Copy bundled agents
-				ctx.ui.notify("🤖 Setting up sub-agents...", "info");
+				ctx.ui.notify("Setting up sub-agents...", "info");
 				await copyBundledAgents();
 
-				// 7. Create AGENTS.md template
-				ctx.ui.notify("📝 Creating memory template...", "info");
+				ctx.ui.notify("Creating memory template...", "info");
 				await createAgentsTemplate();
 
-				// 8. Summary
-				ctx.ui.notify("\n╔══════════════════════════════════════╗", "info");
-				ctx.ui.notify("║     ✅  Setup Complete!              ║", "info");
-				ctx.ui.notify("╚══════════════════════════════════════╝\n", "info");
-
-				ctx.ui.notify("**Configuration:**", "info");
-				ctx.ui.notify(`  📁 Config: ${agentDir}`, "info");
-				ctx.ui.notify(`  📁 Memory: ${memoryDir}`, "info");
-				ctx.ui.notify(`  🤖 Agents: ${agentsDir}`, "info");
-
-				ctx.ui.notify("\n**Model Assignments:**", "info");
+				ctx.ui.notify("\n     Setup Complete!\n", "info");
+				ctx.ui.notify("Configuration:", "info");
+				ctx.ui.notify(`  Config: ${agentDir}`, "info");
+				ctx.ui.notify(`  Memory: ${memoryDir}`, "info");
+				ctx.ui.notify(`  Agents: ${agentsDir}`, "info");
+				ctx.ui.notify("\nOrchestration role assignments (used by `/plan`):", "info");
 				for (const role of TASK_ROLES) {
 					const a = assignments[role.key];
 					ctx.ui.notify(`  ${role.label}: \`${a.preferred}\` (fallback: \`${a.fallback}\`)`, "info");
 				}
-				ctx.ui.notify(`  Default: \`${assignments["default"].preferred}\``, "info");
-
-				ctx.ui.notify("\n**Next steps:**", "info");
-				ctx.ui.notify("  • Edit `~/.phi/memory/AGENTS.md` with your project instructions", "info");
-				ctx.ui.notify("  • Run `/agents` to see available sub-agents", "info");
-				ctx.ui.notify("  • Run `/skills` to see available skills", "info");
-				ctx.ui.notify("  • Run `/benchmark all` to test model performance", "info");
-				ctx.ui.notify("  • Start coding! 🚀\n", "info");
-
+				ctx.ui.notify(
+					"\nChat default model: use `/model` (this wizard does NOT change the chat default).",
+					"info",
+				);
+				ctx.ui.notify("\nNext steps:", "info");
+				ctx.ui.notify("  - `/model` to pick the chat default model (sticky across prompts)", "info");
+				ctx.ui.notify("  - `/plan <description>` to run the orchestrator with the roles above", "info");
+				ctx.ui.notify("  - `/routing` to inspect the route table (auto-switch is OFF by default)", "info");
+				ctx.ui.notify("  - `/models refresh` to re-fetch the live model catalog", "info");
+				ctx.ui.notify("  - Edit `~/.phi/memory/AGENTS.md` with your project instructions", "info");
+				ctx.ui.notify("  - Start coding!\n", "info");
 			} catch (error) {
-				ctx.ui.notify(`❌ Setup failed: ${error}`, "error");
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.ui.notify(`Setup failed: ${message}`, "error");
 			}
 		},
 	});
-
 }