@phi-code-admin/phi-code 0.63.4 → 0.64.0

package/extensions/phi/init.ts

@@ -462,10 +462,7 @@ _Edit this file to customize Phi Code's behavior for your project._
 					ctx.ui.notify(`  ${status} ${p.name}${tag}${modelCount}`, "info");
 				}
 
-				// If no cloud providers have keys, prompt for setup
-				if (cloudConfigured.length === 0) {
-					ctx.ui.notify("\n⚠️ No cloud API keys configured.\n", "warning");
-				}
+				// No warning needed — the wizard itself handles configuration
 
 				// Always offer to add a provider via select menu
 				const providerOptions = [

package/extensions/phi/orchestrator.ts

@@ -471,6 +471,7 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 	let activeAgentPrompt: string | null = null;
 	let activeAgentTools: string[] | null = null;
 	let savedTools: string[] | null = null;
+	let phasePending = false; // true while waiting for a phase to complete
 
 	/**
 	 * Parse agent .md file with YAML frontmatter
@@ -607,24 +608,55 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 	/**
 	 * Send the next phase in the queue.
 	 */
+	function setOrchestrationActive(active: boolean) {
+		orchestrationActive = active;
+		(globalThis as any).__phiOrchestrationActive = active;
+	}
+
 	function sendNextPhase(ctx: any) {
 		if (phaseQueue.length === 0) {
-			orchestrationActive = false;
+			setOrchestrationActive(false);
+			phasePending = false;
 			deactivateAgent();
 			ctx.ui.notify(`\n✅ **All 5 phases complete!**`, "info");
 			return;
 		}
 
 		const phase = phaseQueue.shift()!;
+		phasePending = true;
 
 		switchModelForPhase(phase, ctx).then((modelId) => {
 			activateAgent(phase, ctx);
 			const agentName = phase.agent?.name || phase.key;
 			ctx.ui.notify(`\n${phase.label} → \`${modelId}\` (agent: ${agentName})`, "info");
-			setTimeout(() => pi.sendUserMessage(phase.instruction), 200);
+			// Wait for agent to be idle, then send the phase instruction
+			waitForIdleThenSend(phase.instruction, ctx);
 		});
 	}
 
+	/**
+	 * Reliable phase sending: poll isIdle() then sendUserMessage.
+	 * Retries up to 240 attempts (120 seconds).
+	 */
+	function waitForIdleThenSend(message: string, ctx: any) {
+		let attempts = 0;
+		const timer = setInterval(() => {
+			attempts++;
+			if (attempts > 240) {
+				clearInterval(timer);
+				ctx.ui.notify("⚠️ Orchestrator timeout — agent never became idle.", "warning");
+				setOrchestrationActive(false);
+				phasePending = false;
+				deactivateAgent();
+				return;
+			}
+			if (ctx.isIdle()) {
+				clearInterval(timer);
+				setTimeout(() => pi.sendUserMessage(message), 300);
+			}
+		}, 500);
+	}
+
 	// ─── System Prompt Injection — Agent personas ────────────────────
 
 	pi.on("before_agent_start", async (event, _ctx) => {
@@ -636,33 +668,41 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 	});
 
 	// ─── Output Event — Phase Chaining ───────────────────────────────
+	// Fires on each output chunk. We use it to detect when a phase completes.
+	// The key fix: only start ONE idle-check timer per phase, not one per chunk.
 
 	pi.on("output", async (_event, ctx) => {
-		if (!orchestrationActive || phaseQueue.length === 0) return;
+		if (!orchestrationActive || !phasePending) return;
+		if (phaseQueue.length === 0 && phasePending) {
+			// Last phase in progress — wait for it to finish, then complete
+		}
 
+		// Debounce: clear any existing timer, start fresh
 		if (idlePollTimer) {
 			clearInterval(idlePollTimer);
 			idlePollTimer = null;
 		}
 
-		let attempts = 0;
-		idlePollTimer = setInterval(() => {
-			attempts++;
-			if (attempts > 120) {
-				clearInterval(idlePollTimer!);
-				idlePollTimer = null;
-				ctx.ui.notify("⚠️ Orchestrator timeout — phase took too long.", "warning");
-				orchestrationActive = false;
-				deactivateAgent();
-				return;
-			}
-			if (ctx.isIdle()) {
-				clearInterval(idlePollTimer!);
-				idlePollTimer = null;
-				sendNextPhase(ctx);
-			}
-		}, 500);
-	});
+		// After output, wait a bit then check if the agent is truly idle
+		// Use a longer initial delay (2 seconds) to let tool calls complete
+		idlePollTimer = setTimeout(() => {
+			let attempts = 0;
+			idlePollTimer = setInterval(() => {
+				attempts++;
+				if (attempts > 60) { // 30 seconds after last output
+					clearInterval(idlePollTimer!);
+					idlePollTimer = null;
+					// Don't timeout — the phase might still have tool calls
+					return;
+				}
+				if (ctx.isIdle()) {
+					clearInterval(idlePollTimer!);
+					idlePollTimer = null;
+					phasePending = false;
+					sendNextPhase(ctx);
+				}
+			}, 500) as any;
+		}, 2000) as any;
 
 	// ─── /plan Command — Full workflow ───────────────────────────────
 
@@ -693,7 +733,8 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			// Build phases with model assignments + agent definitions
 			const phases = buildPhases(description);
 			phaseQueue = phases.slice(1); // Queue phases 2-5
-			orchestrationActive = true;
+			setOrchestrationActive(true);
+			phasePending = true;
 			const firstPhase = phases[0];
 
 			ctx.ui.notify(`📋 **Orchestrator started** — 5 phases with model routing + agent roles\n`, "info");

package/extensions/phi/smart-router.ts

@@ -77,6 +77,11 @@ export default function smartRouterExtension(pi: ExtensionAPI) {
 			return { action: "continue" };
 		}
 
+		// Do NOT route during orchestration — the orchestrator manages models
+		if ((globalThis as any).__phiOrchestrationActive) {
+			return { action: "continue" };
+		}
+
 		const recommendation = router.getRecommendation(event.text);
 
 		if (recommendation.category !== "general") {

package/package.json

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