@phi-code-admin/phi-code 0.62.1 → 0.63.0

package/extensions/phi/init.ts

@@ -1,10 +1,8 @@
 /**
  * Phi Init Extension - Interactive setup wizard for Phi Code
  *
- * Three modes:
- * - auto: Use Alibaba Coding Plan defaults (instant, recommended)
- * - benchmark: Test available models with /benchmark, then assign (10-15 min)
- * - manual: User assigns each model role interactively
+ * 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.
  */
@@ -13,7 +11,7 @@ import type { ExtensionAPI } from "phi-code";
 import { writeFile, mkdir, copyFile, readdir, access, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
@@ -367,270 +365,10 @@ _Edit this file to customize Phi Code's behavior for your project._
 
 	// ─── MODE: Auto ──────────────────────────────────────────────────
 
-	// ─── Model Intelligence Database ─────────────────────────────────
-
-	interface ModelProfile {
-		id: string;
-		capabilities: {
-			coding: number;    // 0-100 score for code generation
-			reasoning: number; // 0-100 score for debugging/planning
-			speed: number;     // 0-100 score for fast tasks
-			general: number;   // 0-100 overall score
-		};
-		hasReasoning: boolean;
-	}
-
 	/**
-	 * Fetch model profiles from OpenRouter's free API.
-	 * Classifies each model based on its description, name, and supported parameters.
-	 * Falls back to name-based heuristics if OpenRouter is unreachable.
+	 * Manual mode is the only setup mode.
+	 * User assigns each model to each agent role interactively.
 	 */
-	async function fetchModelProfiles(modelIds: string[]): Promise<Map<string, ModelProfile>> {
-		const profiles = new Map<string, ModelProfile>();
-
-		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;
-				const orModels: any[] = data.data || [];
-
-				for (const modelId of modelIds) {
-					// Try exact match first, then fuzzy match by base name
-					const baseName = modelId.replace(/:.+$/, "").split("/").pop()?.toLowerCase() || modelId.toLowerCase();
-					const match = orModels.find((m: any) => {
-						const mId = m.id?.toLowerCase() || "";
-						const mName = m.name?.toLowerCase() || "";
-						return mId.includes(baseName) || mName.includes(baseName);
-					});
-
-					if (match) {
-						const desc = (match.description || "").toLowerCase();
-						const name = (match.name || "").toLowerCase();
-						const hasReasoning = (match.supported_parameters || []).includes("reasoning")
-							|| (match.supported_parameters || []).includes("include_reasoning");
-
-						// Score based on description keywords and model characteristics
-						let coding = 50, reasoning = 50, speed = 50, general = 60;
-
-						// Coding signals
-						if (/cod(e|ing|ex)|program|implement|refactor|software engineer/.test(desc) || /coder|codex|codestral/.test(name)) {
-							coding = 85;
-						}
-						// Reasoning signals
-						if (hasReasoning || /reason|think|logic|step.by.step|complex/.test(desc) || /o1|o3|pro|opus/.test(name)) {
-							reasoning = 85;
-						}
-						// Speed signals (smaller/cheaper models)
-						const pricing = match.pricing || {};
-						const promptCost = parseFloat(pricing.prompt || "0.01");
-						if (promptCost < 0.001 || /fast|flash|mini|small|haiku|lite|instant/.test(name)) {
-							speed = 85;
-						}
-						// General quality (larger context = usually better)
-						const ctx = match.context_length || 0;
-						if (ctx >= 200000) general = 80;
-						if (ctx >= 1000000) general = 90;
-						if (/frontier|flagship|most.advanced|best|state.of.the.art/.test(desc)) general = 90;
-
-						profiles.set(modelId, { id: modelId, capabilities: { coding, reasoning, speed, general }, hasReasoning });
-					}
-				}
-			}
-		} catch {
-			// OpenRouter unreachable — will fall back to heuristics
-		}
-
-		// Fill in any models not found in OpenRouter with name-based heuristics
-		for (const modelId of modelIds) {
-			if (!profiles.has(modelId)) {
-				profiles.set(modelId, classifyByName(modelId));
-			}
-		}
-
-		return profiles;
-	}
-
-	/**
-	 * Fallback: classify model by name patterns when OpenRouter data is unavailable.
-	 */
-	function classifyByName(modelId: string): ModelProfile {
-		const l = modelId.toLowerCase();
-		let coding = 50, reasoning = 50, speed = 50, general = 55;
-		let hasReasoning = false;
-
-		if (/coder|code|codestral/.test(l)) coding = 80;
-		if (/max|pro|plus|opus|large|o1|o3/.test(l)) { reasoning = 80; general = 75; }
-		if (/mini|flash|fast|small|haiku|lite/.test(l)) { speed = 80; }
-		if (/o1|o3|deepseek-r1|qwq/.test(l)) { hasReasoning = true; reasoning = 85; }
-
-		return { id: modelId, capabilities: { coding, reasoning, speed, general }, hasReasoning };
-	}
-
-	/**
-	 * Auto-assign models using OpenRouter rankings + models.dev data.
-	 * Works with ANY provider — cloud, local, or mixed.
-	 *
-	 * Strategy:
-	 * 1. Fetch model profiles from OpenRouter (free, no API key needed)
-	 * 2. Score each model for coding, reasoning, speed, and general tasks
-	 * 3. Assign best model per role based on scores
-	 * 4. Fall back to name-based heuristics if OpenRouter is unreachable
-	 * 5. Single model? → everything uses that model (still works!)
-	 */
-	async function autoMode(availableModels: string[], ctx?: any): Promise<Record<string, { preferred: string; fallback: string }>> {
-		const assignments: Record<string, { preferred: string; fallback: string }> = {};
-
-		if (availableModels.length === 0) {
-			const fb = { preferred: "default", fallback: "default" };
-			for (const role of TASK_ROLES) assignments[role.key] = fb;
-			assignments["default"] = fb;
-			return assignments;
-		}
-
-		if (availableModels.length === 1) {
-			const single = { preferred: availableModels[0], fallback: availableModels[0] };
-			for (const role of TASK_ROLES) assignments[role.key] = single;
-			assignments["default"] = single;
-			return assignments;
-		}
-
-		// Fetch intelligence from OpenRouter
-		if (ctx) ctx.ui.notify("📊 Fetching model rankings from OpenRouter...", "info");
-		const profiles = await fetchModelProfiles(availableModels);
-
-		// Find best model for each capability
-		function bestFor(capability: keyof ModelProfile["capabilities"]): string {
-			let best = availableModels[0], bestScore = 0;
-			for (const id of availableModels) {
-				const p = profiles.get(id);
-				if (p && p.capabilities[capability] > bestScore) {
-					bestScore = p.capabilities[capability];
-					best = id;
-				}
-			}
-			return best;
-		}
-
-		function secondBestFor(capability: keyof ModelProfile["capabilities"], excludeId: string): string {
-			let best = availableModels.find(m => m !== excludeId) || excludeId;
-			let bestScore = 0;
-			for (const id of availableModels) {
-				if (id === excludeId) continue;
-				const p = profiles.get(id);
-				if (p && p.capabilities[capability] > bestScore) {
-					bestScore = p.capabilities[capability];
-					best = id;
-				}
-			}
-			return best;
-		}
-
-		const bestCoder = bestFor("coding");
-		const bestReasoner = bestFor("reasoning");
-		const bestFast = bestFor("speed");
-		const bestGeneral = bestFor("general");
-
-		assignments["code"] = { preferred: bestCoder, fallback: secondBestFor("coding", bestCoder) };
-		assignments["debug"] = { preferred: bestReasoner, fallback: secondBestFor("reasoning", bestReasoner) };
-		assignments["plan"] = { preferred: bestReasoner, fallback: secondBestFor("reasoning", bestReasoner) };
-		assignments["explore"] = { preferred: bestFast, fallback: secondBestFor("speed", bestFast) };
-		assignments["test"] = { preferred: bestFast, fallback: secondBestFor("speed", bestFast) };
-		assignments["review"] = { preferred: bestGeneral, fallback: secondBestFor("general", bestGeneral) };
-		assignments["default"] = { preferred: bestGeneral, fallback: secondBestFor("general", bestGeneral) };
-
-		// Show what was assigned and why
-		if (ctx) {
-			ctx.ui.notify("📊 Model rankings applied:", "info");
-			for (const role of TASK_ROLES) {
-				const a = assignments[role.key];
-				const p = profiles.get(a.preferred);
-				const scores = p ? `(coding:${p.capabilities.coding} reasoning:${p.capabilities.reasoning} speed:${p.capabilities.speed})` : "";
-				ctx.ui.notify(`  ${role.label}: ${a.preferred} ${scores}`, "info");
-			}
-		}
-
-		return assignments;
-	}
-
-	// ─── MODE: Benchmark ─────────────────────────────────────────────
-
-	async function benchmarkMode(availableModels: string[], ctx: any): Promise<Record<string, { preferred: string; fallback: string }>> {
-		// Check if benchmark results already exist
-		const benchmarkPath = join(phiDir, "benchmark", "results.json");
-		let existingResults: any = null;
-		try {
-			await access(benchmarkPath);
-			const content = await readFile(benchmarkPath, "utf-8");
-			existingResults = JSON.parse(content);
-		} catch {
-			// No existing results
-		}
-
-		if (existingResults?.results?.length > 0) {
-			const useExisting = await ctx.ui.confirm(
-				"Use existing benchmarks?",
-				`Found ${existingResults.results.length} benchmark results from a previous run. Use them?`
-			);
-			if (useExisting) {
-				ctx.ui.notify("📊 Using existing benchmark results for model assignment.\n", "info");
-				return assignFromBenchmark(existingResults.results, availableModels);
-			}
-		}
-
-		// No existing results or user declined — run benchmarks now
-		ctx.ui.notify("🧪 Benchmark mode: launching model tests...", "info");
-		ctx.ui.notify("This tests each model with 6 coding tasks via real API calls.", "info");
-		ctx.ui.notify("⏱️ Estimated time: 2-3 minutes per model.\n", "info");
-
-		// Trigger benchmark via sendUserMessage — this runs /benchmark all
-		// which saves results to the same results.json path
-		pi.sendUserMessage("/benchmark all");
-		ctx.ui.notify("⏳ Benchmarks started. Once complete, run `/phi-init` again and select benchmark mode to use the results.\n", "info");
-		ctx.ui.notify("💡 The benchmark runs in the background. You'll see live results in the terminal.\n", "info");
-
-		// Return auto mode assignments as temporary defaults
-		// (will be overwritten when user re-runs /phi-init with benchmark results)
-		ctx.ui.notify("📋 Setting auto-mode defaults while benchmarks run...\n", "info");
-		return autoMode(availableModels, ctx);
-	}
-
-	function assignFromBenchmark(results: any[], availableModels: string[]): Record<string, { preferred: string; fallback: string }> {
-		const assignments: Record<string, { preferred: string; fallback: string }> = {};
-
-		// Sort by total score
-		const sorted = [...results].sort((a: any, b: any) => (b.totalScore || 0) - (a.totalScore || 0));
-		const bestOverall = sorted[0]?.modelId || availableModels[0];
-		const secondBest = sorted[1]?.modelId || bestOverall;
-
-		// Find best per category
-		function bestForCategory(category: string): string {
-			let best = { id: bestOverall, score: 0 };
-			for (const r of results) {
-				const catScore = r.categories?.[category]?.score ?? 0;
-				if (catScore > best.score) {
-					best = { id: r.modelId, score: catScore };
-				}
-			}
-			return best.id;
-		}
-
-		assignments["code"] = { preferred: bestForCategory("code-gen"), fallback: secondBest };
-		assignments["debug"] = { preferred: bestForCategory("debug"), fallback: secondBest };
-		assignments["plan"] = { preferred: bestForCategory("planning"), fallback: secondBest };
-		assignments["explore"] = { preferred: bestForCategory("speed"), fallback: secondBest };
-		assignments["test"] = { preferred: bestForCategory("speed"), fallback: secondBest };
-		assignments["review"] = { preferred: bestForCategory("orchestration"), fallback: secondBest };
-		assignments["default"] = { preferred: bestOverall, fallback: secondBest };
-
-		return assignments;
-	}
-
 	// ─── MODE: Manual ────────────────────────────────────────────────
 
 	async function manualMode(availableModels: string[], ctx: any): Promise<Record<string, { preferred: string; fallback: string }>> {
@@ -670,7 +408,7 @@ _Edit this file to customize Phi Code's behavior for your project._
 	// ─── Command ─────────────────────────────────────────────────────
 
 	pi.registerCommand("phi-init", {
-		description: "Initialize Phi Code — interactive setup wizard (3 modes: auto, benchmark, manual)",
+		description: "Initialize Phi Code — interactive setup wizard",
 		handler: async (args, ctx) => {
 			try {
 				ctx.ui.notify("╔══════════════════════════════════════╗", "info");
@@ -811,29 +549,10 @@ _Edit this file to customize Phi Code's behavior for your project._
 				const allModels = getAllAvailableModels(providers);
 				ctx.ui.notify(`\n✅ **${allModels.length} models** available from ${available.length} provider(s).\n`, "info");
 
-				// 2. Choose mode
-				const modeOptions = [
-					"auto — Use optimal defaults (instant)",
-					"benchmark — Test models first, assign by results (10-15 min)",
-					"manual — Choose each model yourself",
-				];
-				const modeChoice = await ctx.ui.select("Setup mode", modeOptions);
-				const mode = (modeChoice ?? "").startsWith("benchmark") ? "benchmark"
-					: (modeChoice ?? "").startsWith("manual") ? "manual"
-					: "auto";
-
-				ctx.ui.notify(`\n📋 Mode: **${mode}**\n`, "info");
-
-				// 3. Get assignments based on mode
-				let assignments: Record<string, { preferred: string; fallback: string }>;
-
-				if (mode === "auto") {
-					assignments = await autoMode(allModels, ctx);
-				} else if (mode === "benchmark") {
-					assignments = await benchmarkMode(allModels, ctx);
-				} else {
-					assignments = await manualMode(allModels, ctx);
-				}
+				// 2. Assign models to agents (manual)
+				ctx.ui.notify(`\n📋 **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");
@@ -882,130 +601,4 @@ _Edit this file to customize Phi Code's behavior for your project._
 		},
 	});
 
-	// ─── API Key Management Command ─────────────────────────────────
-
-	pi.registerCommand("api-key", {
-		description: "Set or view API keys (usage: /api-key set <provider> <key> | /api-key list)",
-		handler: async (args, ctx) => {
-			const parts = args.trim().split(/\s+/);
-			const action = parts[0]?.toLowerCase();
-
-			const PROVIDERS: Record<string, { envVar: string; name: string }> = {
-				alibaba: { envVar: "ALIBABA_CODING_PLAN_KEY", name: "Alibaba Coding Plan" },
-				dashscope: { envVar: "DASHSCOPE_API_KEY", name: "DashScope (Alibaba)" },
-				openai: { envVar: "OPENAI_API_KEY", name: "OpenAI" },
-				anthropic: { envVar: "ANTHROPIC_API_KEY", name: "Anthropic" },
-				google: { envVar: "GOOGLE_API_KEY", name: "Google" },
-				openrouter: { envVar: "OPENROUTER_API_KEY", name: "OpenRouter" },
-				groq: { envVar: "GROQ_API_KEY", name: "Groq" },
-				brave: { envVar: "BRAVE_API_KEY", name: "Brave Search" },
-			};
-
-			if (!action || action === "help") {
-				ctx.ui.notify(`**🔑 API Key Management**
-
-Usage:
-  /api-key set <provider> <key>   — Set an API key for this session
-  /api-key list                   — Show configured providers
-  /api-key providers              — List all supported providers
-
-Supported providers: ${Object.keys(PROVIDERS).join(", ")}
-
-Example:
-  /api-key set alibaba sk-sp-xxx
-  /api-key set openai sk-xxx
-
-Keys set with /api-key are active for the current session.
-For persistence, set environment variables:
-  • Windows: setx ALIBABA_CODING_PLAN_KEY "your-key"
-  • Linux/Mac: export ALIBABA_CODING_PLAN_KEY="your-key"`, "info");
-				return;
-			}
-
-			if (action === "list") {
-				let found = 0;
-				let msg = "**🔑 Configured API Keys:**\n";
-				for (const [id, info] of Object.entries(PROVIDERS)) {
-					const key = process.env[info.envVar];
-					if (key) {
-						const masked = key.substring(0, 6) + "..." + key.substring(key.length - 4);
-						msg += `  ✅ ${info.name} (${id}): ${masked}\n`;
-						found++;
-					}
-				}
-				if (found === 0) {
-					msg += "  ❌ No API keys configured\n";
-					msg += "\nUse `/api-key set <provider> <key>` to add one.";
-				}
-				ctx.ui.notify(msg, "info");
-				return;
-			}
-
-			if (action === "providers") {
-				let msg = "**Supported Providers:**\n";
-				for (const [id, info] of Object.entries(PROVIDERS)) {
-					const status = process.env[info.envVar] ? "✅" : "⬜";
-					msg += `  ${status} **${id}** — ${info.name} (${info.envVar})\n`;
-				}
-				ctx.ui.notify(msg, "info");
-				return;
-			}
-
-			if (action === "set") {
-				const provider = parts[1]?.toLowerCase();
-				const key = parts.slice(2).join(" ").trim();
-
-				if (!provider || !key) {
-					ctx.ui.notify("Usage: /api-key set <provider> <key>\nExample: /api-key set alibaba sk-sp-xxx", "warning");
-					return;
-				}
-
-				const info = PROVIDERS[provider];
-				if (!info) {
-					ctx.ui.notify(`Unknown provider "${provider}". Supported: ${Object.keys(PROVIDERS).join(", ")}`, "error");
-					return;
-				}
-
-				// Set in current process environment
-				process.env[info.envVar] = key;
-				if (provider === "alibaba") {
-					process.env.DASHSCOPE_API_KEY = key;
-				}
-
-				// Persist to models.json
-				const modelsJsonPath = join(homedir(), ".phi", "agent", "models.json");
-				let modelsConfig: any = { providers: {} };
-				try {
-					const existing = readFileSync(modelsJsonPath, "utf-8");
-					modelsConfig = JSON.parse(existing);
-				} catch { /* file doesn't exist yet */ }
-
-				// Find provider config from detectProviders
-				const providerDefs = detectProviders();
-				const providerDef = providerDefs.find(p => p.envVar === info.envVar);
-				if (providerDef) {
-					const providerId = providerDef.name.toLowerCase().replace(/\s+/g, "-");
-					modelsConfig.providers[providerId] = {
-						baseUrl: providerDef.baseUrl,
-						api: "openai-completions",
-						apiKey: key,
-						models: await Promise.all(providerDef.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,
-							};
-						})),
-					};
-					writeFileSync(modelsJsonPath, JSON.stringify(modelsConfig, null, 2), "utf-8");
-				}
-
-				const masked = key.substring(0, 6) + "..." + key.substring(key.length - 4);
-				ctx.ui.notify(`✅ **${info.name}** API key saved: ${masked}\n\n📁 Saved to \`~/.phi/agent/models.json\` (persistent)\n⚠️ **Restart phi** for the new models to load.`, "info");
-				return;
-			}
-
-			ctx.ui.notify("Unknown action. Use: /api-key set|list|providers|help", "warning");
-		},
-	});
 }

package/extensions/phi/orchestrator.ts

@@ -2,21 +2,18 @@
  * Orchestrator Extension - Full-cycle project planning and execution
  *
  * WORKFLOW (single command):
- *   /plan <description> → LLM analyzes → orchestrate tool → spec + todo → auto-execute → progress
- *   Everything happens in one shot. No manual steps.
+ *   /plan <description> → 5 sequential agent phases → each with its own model
+ *
+ * The orchestrator uses event-driven phase chaining:
+ *   1. Send phase 1 message with model A
+ *   2. Detect when agent goes idle (output event + polling)
+ *   3. Switch to model B, send phase 2
+ *   4. Repeat until all 5 phases complete
  *
  * Commands:
- *   /plan   — Full workflow: plan + execute with sub-agents
- *   /run    — Re-execute an existing plan (e.g. after fixes)
+ *   /plan   — Full workflow: plan + execute with agents
+ *   /run    — Re-execute an existing plan
  *   /plans  — List plans and their execution status
- *
- * Sub-agent execution:
- * Each task spawns a separate `phi` CLI process with:
- * - Its own system prompt (from the agent .md file)
- * - Its own model (from routing.json)
- * - Its own context (isolated, no shared history)
- * - Its own tool access (read, write, edit, bash, etc.)
- * Results are collected into progress.md and reported to the user.
  */
 
 import { Type } from "@sinclair/typebox";
@@ -451,10 +448,141 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	// ─── Orchestration State ─────────────────────────────────────────
+
+	interface OrchestratorPhase {
+		key: string;
+		label: string;
+		model: string;
+		fallback: string;
+		instruction: string;
+	}
+
+	let phaseQueue: OrchestratorPhase[] = [];
+	let orchestrationActive = false;
+	let idlePollTimer: ReturnType<typeof setInterval> | null = null;
+
+	/**
+	 * Load routing config and build phase queue with model assignments.
+	 */
+	function buildPhases(description: string): OrchestratorPhase[] {
+		// Read routing.json for model assignments
+		const routingPath = join(homedir(), ".phi", "agent", "routing.json");
+		let routing: any = { routes: {}, default: { model: "default" } };
+		try {
+			routing = JSON.parse(readFileSync(routingPath, "utf-8"));
+		} catch { /* no routing config */ }
+
+		function getModel(routeKey: string): { preferred: string; fallback: string } {
+			const route = routing.routes?.[routeKey];
+			return {
+				preferred: route?.preferredModel || routing.default?.model || "default",
+				fallback: route?.fallback || routing.default?.model || "default",
+			};
+		}
+
+		const explore = getModel("explore");
+		const plan = getModel("plan");
+		const code = getModel("code");
+		const test = getModel("test");
+		const review = getModel("review");
+
+		return [
+			{
+				key: "explore", label: "🔍 Phase 1 — EXPLORE", model: explore.preferred, fallback: explore.fallback,
+				instruction: `Analyze the project requirements and existing codebase. Identify what exists, what's needed, and any constraints.\n\n**Project:** ${description}\n\nList files, read key ones, check dependencies. Return a structured summary.`,
+			},
+			{
+				key: "plan", label: "📐 Phase 2 — PLAN", model: plan.preferred, fallback: plan.fallback,
+				instruction: `Design the architecture for this project. Define file structure, tech choices, and implementation approach.\n\n**Project:** ${description}\n\nBe specific: list every file to create with its purpose.`,
+			},
+			{
+				key: "code", label: "💻 Phase 3 — CODE", model: code.preferred, fallback: code.fallback,
+				instruction: `Implement the COMPLETE project. Create ALL files with production-quality code.\n\n**Project:** ${description}\n\n**Rules:**\n- Create every file needed\n- No placeholders, no TODOs, no stubs\n- Every function must be fully implemented\n- Follow the architecture from the previous planning phase`,
+			},
+			{
+				key: "test", label: "🧪 Phase 4 — TEST", model: test.preferred, fallback: test.fallback,
+				instruction: `Test the implementation. Run the code, check for errors, verify it works.\n\n**Project:** ${description}\n\nFix any errors you find. Ensure the project runs correctly.`,
+			},
+			{
+				key: "review", label: "🔍 Phase 5 — REVIEW", model: review.preferred, fallback: review.fallback,
+				instruction: `Review the code quality, security, and performance. Fix any issues.\n\n**Project:** ${description}\n\nCheck: error handling, edge cases, code style, documentation.`,
+			},
+		];
+	}
+
+	/**
+	 * Switch model for the current phase.
+	 * Tries preferred model first, then fallback.
+	 */
+	async function switchModelForPhase(phase: OrchestratorPhase, ctx: any): Promise<string> {
+		const available = ctx.modelRegistry?.getAvailable?.() || [];
+		const preferred = available.find((m: any) => m.id === phase.model);
+		const fallback = available.find((m: any) => m.id === phase.fallback);
+		const target = preferred || fallback;
+
+		if (target && target.id !== ctx.model?.id) {
+			const switched = await pi.setModel(target);
+			if (switched) return target.id;
+		}
+		return ctx.model?.id || phase.model;
+	}
+
+	/**
+	 * Send the next phase in the queue.
+	 * Called after the agent goes idle (previous phase complete).
+	 */
+	function sendNextPhase(ctx: any) {
+		if (phaseQueue.length === 0) {
+			// All phases done
+			orchestrationActive = false;
+			ctx.ui.notify(`\n✅ **All 5 phases complete!**`, "info");
+			return;
+		}
+
+		const phase = phaseQueue.shift()!;
+
+		// Switch model and send
+		switchModelForPhase(phase, ctx).then((modelId) => {
+			ctx.ui.notify(`\n${phase.label} → \`${modelId}\``, "info");
+			setTimeout(() => pi.sendUserMessage(phase.instruction), 200);
+		});
+	}
+
+	// ─── Output Event — Phase Chaining ───────────────────────────────
+
+	pi.on("output", async (_event, ctx) => {
+		if (!orchestrationActive || phaseQueue.length === 0) return;
+
+		// Debounce: clear any existing poll timer
+		if (idlePollTimer) {
+			clearInterval(idlePollTimer);
+			idlePollTimer = null;
+		}
+
+		// Poll for idle state (agent finishes tool calls + response)
+		let attempts = 0;
+		idlePollTimer = setInterval(() => {
+			attempts++;
+			if (attempts > 120) { // 60 seconds max
+				clearInterval(idlePollTimer!);
+				idlePollTimer = null;
+				ctx.ui.notify("⚠️ Orchestrator timeout — phase took too long.", "warning");
+				orchestrationActive = false;
+				return;
+			}
+			if (ctx.isIdle()) {
+				clearInterval(idlePollTimer!);
+				idlePollTimer = null;
+				sendNextPhase(ctx);
+			}
+		}, 500);
+	});
+
 	// ─── /plan Command — Full workflow ───────────────────────────────
 
 	pi.registerCommand("plan", {
-		description: "Plan AND execute a project with agents — describe what to build",
+		description: "Plan AND execute a project — 5 phases, each with its own model from routing.json",
 		handler: async (args, ctx) => {
 			const description = args.trim();
 
@@ -477,35 +605,24 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			const specFile = `spec-${ts}.md`;
 			await writeFile(join(plansDir, specFile), `# ${description}\n\n**Created:** ${new Date().toLocaleString()}\n`, "utf-8");
 
-			ctx.ui.notify(`📋 Executing project with agent workflow...`, "info");
-
-			// Build a single comprehensive prompt with all agent phases
-			const prompt = `# Project: ${description}
-
-## Your workflow (follow these phases in order):
+			// Build phases with model assignments from routing.json
+			const phases = buildPhases(description);
+			phaseQueue = phases.slice(1); // Queue phases 2-5
+			orchestrationActive = true;
+			const firstPhase = phases[0];
 
-### Phase 1 — 🔍 EXPLORE
-Analyze the project requirements and any existing codebase. List what exists, what's needed, and constraints.
+			ctx.ui.notify(`📋 **Orchestrator started** — 5 phases with model routing\n`, "info");
 
-### Phase 2 — 📐 PLAN  
-Design the architecture, file structure, and tech choices. Be specific about file names and structure.
-
-### Phase 3 — 💻 CODE
-Implement EVERYTHING. Create ALL files with complete, production-quality code. No placeholders, no TODOs, no "implement later". Every file must be fully functional.
-
-### Phase 4 — 🧪 TEST
-Run the code. Verify it works. Fix any errors you find.
-
-### Phase 5 — 🔍 REVIEW
-Check code quality. Fix any issues. Ensure everything is polished.
-
-## Rules
-- Complete ALL 5 phases in this turn
-- Create every file needed for a working project
-- Announce each phase as you start it (e.g. "## Phase 1 — Exploring...")
-- Do NOT stop after planning — implement everything`;
+			// Show the plan
+			for (const p of phases) {
+				ctx.ui.notify(`  ${p.label} → \`${p.model}\``, "info");
+			}
+			ctx.ui.notify("", "info");
 
-			ctx.ui.pasteToEditor(prompt);
+			// Switch model and send first phase after handler returns
+			const modelId = await switchModelForPhase(firstPhase, ctx);
+			ctx.ui.notify(`${firstPhase.label} → \`${modelId}\``, "info");
+			setTimeout(() => pi.sendUserMessage(firstPhase.instruction), 200);
 		},
 	});
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.62.1",
+	"version": "0.63.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {