@phi-code-admin/phi-code 0.58.3 → 0.58.5

package/extensions/phi/init.ts

@@ -149,12 +149,12 @@ function getAllAvailableModels(providers: DetectedProvider[]): string[] {
 // ─── Routing Presets ─────────────────────────────────────────────────────
 
 const TASK_ROLES = [
-	{ key: "code", label: "Code Generation", desc: "Writing and modifying code", agent: "code", defaultModel: "qwen3-coder-plus" },
-	{ key: "debug", label: "Debugging", desc: "Finding and fixing bugs", agent: "code", defaultModel: "qwen3-max-2026-01-23" },
-	{ key: "plan", label: "Planning", desc: "Architecture and design", agent: "plan", defaultModel: "qwen3-max-2026-01-23" },
-	{ key: "explore", label: "Exploration", desc: "Code reading and analysis", agent: "explore", defaultModel: "kimi-k2.5" },
-	{ key: "test", label: "Testing", desc: "Running and writing tests", agent: "test", defaultModel: "kimi-k2.5" },
-	{ key: "review", label: "Code Review", desc: "Quality and security review", agent: "review", defaultModel: "qwen3.5-plus" },
+	{ key: "code", label: "Code Generation", desc: "Writing and modifying code", agent: "code", defaultModel: "default" },
+	{ key: "debug", label: "Debugging", desc: "Finding and fixing bugs", agent: "code", defaultModel: "default" },
+	{ key: "plan", label: "Planning", desc: "Architecture and design", agent: "plan", defaultModel: "default" },
+	{ key: "explore", label: "Exploration", desc: "Code reading and analysis", agent: "explore", defaultModel: "default" },
+	{ key: "test", label: "Testing", desc: "Running and writing tests", agent: "test", defaultModel: "default" },
+	{ key: "review", label: "Code Review", desc: "Quality and security review", agent: "review", defaultModel: "default" },
 ] as const;
 
 const KEYWORDS: Record<string, string[]> = {
@@ -455,16 +455,12 @@ _Edit this file to customize Phi Code's behavior for your project._
 	// ─── MODE: Benchmark ─────────────────────────────────────────────
 
 	async function benchmarkMode(availableModels: string[], ctx: any): Promise<Record<string, { preferred: string; fallback: string }>> {
-		ctx.ui.notify("🧪 Benchmark mode: running tests on available models...", "info");
-		ctx.ui.notify("This will test each model with 6 coding tasks. It may take 10-15 minutes.", "info");
-		ctx.ui.notify("💡 Tip: You can run `/benchmark all` separately and use `/benchmark results` to see rankings.\n", "info");
-
 		// Check if benchmark results already exist
 		const benchmarkPath = join(phiDir, "benchmark", "results.json");
 		let existingResults: any = null;
 		try {
 			await access(benchmarkPath);
-			const content = await (await import("node:fs/promises")).readFile(benchmarkPath, "utf-8");
+			const content = await readFile(benchmarkPath, "utf-8");
 			existingResults = JSON.parse(content);
 		} catch {
 			// No existing results
@@ -473,18 +469,28 @@ _Edit this file to customize Phi Code's behavior for your project._
 		if (existingResults?.results?.length > 0) {
 			const useExisting = await ctx.ui.confirm(
 				"Use existing benchmarks?",
-				`Found ${existingResults.results.length} existing benchmark results. Use them instead of re-running?`
+				`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);
 			}
 		}
 
-		// Run benchmarks via the /benchmark command
-		ctx.ui.notify("Starting benchmarks... (this runs in the background, continue with /phi-init after /benchmark completes)\n", "info");
-		ctx.ui.notify("Run: `/benchmark all` then `/phi-init` again with mode=benchmark to use results.\n", "info");
+		// 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
+		ctx.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");
 
-		// Fall back to auto for now
+		// 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);
 	}
 

package/extensions/phi/orchestrator.ts

@@ -193,7 +193,7 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		});
 	}
 
-	// ─── Execute All Tasks ───────────────────────────────────────────
+	// ─── Execute All Tasks (parallel with dependency resolution) ─────
 
 	async function executePlan(
 		tasks: TaskDef[],
@@ -205,52 +205,133 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		const progressPath = join(plansDir, progressFile);
 		let progress = `# Progress: ${todoFile}\n\n`;
 		progress += `**Started:** ${new Date().toLocaleString()}\n`;
-		progress += `**Tasks:** ${tasks.length}\n\n`;
+		progress += `**Tasks:** ${tasks.length}\n**Mode:** parallel (dependency-aware)\n\n`;
 		await writeFile(progressPath, progress, "utf-8");
 
-		notify(`🚀 Executing ${tasks.length} tasks with sub-agents...`, "info");
-
+		// Build dependency graph
+		// Task indices are 1-based in the plan files
+		const completed = new Set<number>();
+		const failed = new Set<number>();
 		const results: TaskResult[] = [];
 
-		for (let i = 0; i < tasks.length; i++) {
-			const task = tasks[i];
-			const agentType = task.agent || "code";
-			notify(`⏳ Task ${i + 1}/${tasks.length}: **${task.title}** [${agentType}]`, "info");
-
-			const result = await executeTask(task, agentDefs, process.cwd());
-			result.taskIndex = i + 1;
-			results.push(result);
-
-			const icon = result.status === "success" ? "✅" : "❌";
-			const duration = (result.durationMs / 1000).toFixed(1);
-			const outputPreview = result.output.length > 500 ? result.output.slice(0, 500) + "..." : result.output;
-			notify(`${icon} Task ${i + 1}: **${task.title}** (${duration}s)\n${outputPreview}`,
-				result.status === "success" ? "info" : "error");
-
-			progress += `## Task ${i + 1}: ${task.title}\n\n`;
-			progress += `- **Status:** ${result.status}\n`;
-			progress += `- **Agent:** ${result.agent}\n`;
-			progress += `- **Duration:** ${duration}s\n`;
-			progress += `- **Output:**\n\n\`\`\`\n${result.output.slice(0, 3000)}\n\`\`\`\n\n`;
+		// Check which tasks can run (all dependencies completed successfully)
+		function getReadyTasks(): number[] {
+			const ready: number[] = [];
+			for (let i = 0; i < tasks.length; i++) {
+				const taskNum = i + 1;
+				if (completed.has(taskNum) || failed.has(taskNum)) continue;
+
+				const deps = tasks[i].dependencies || [];
+				const allDepsMet = deps.every(d => completed.has(d));
+				const anyDepFailed = deps.some(d => failed.has(d));
+
+				if (anyDepFailed) {
+					// Skip tasks whose dependencies failed
+					failed.add(taskNum);
+					results.push({
+						taskIndex: taskNum,
+						title: tasks[i].title,
+						agent: tasks[i].agent || "code",
+						status: "skipped",
+						output: `Skipped: dependency #${deps.find(d => failed.has(d))} failed`,
+						durationMs: 0,
+					});
+					notify(`⏭️ Task ${taskNum}: **${tasks[i].title}** — skipped (dependency failed)`, "warning");
+				} else if (allDepsMet) {
+					ready.push(i);
+				}
+			}
+			return ready;
+		}
+
+		const totalTasks = tasks.length;
+		let wave = 1;
+
+		notify(`🚀 Executing ${totalTasks} tasks with sub-agents (parallel mode)...`, "info");
+
+		// Execute in waves — each wave runs independent tasks in parallel
+		while (completed.size + failed.size < totalTasks) {
+			const readyIndices = getReadyTasks();
+
+			if (readyIndices.length === 0) {
+				// Deadlock or all done
+				break;
+			}
+
+			const parallelCount = readyIndices.length;
+			if (parallelCount > 1) {
+				notify(`\n🔄 **Wave ${wave}** — ${parallelCount} tasks in parallel`, "info");
+			}
+
+			for (const idx of readyIndices) {
+				const t = tasks[idx];
+				notify(`⏳ Task ${idx + 1}: **${t.title}** [${t.agent || "code"}]`, "info");
+			}
+
+			// Launch all ready tasks simultaneously
+			const promises = readyIndices.map(async (idx) => {
+				const task = tasks[idx];
+				const result = await executeTask(task, agentDefs, process.cwd());
+				result.taskIndex = idx + 1;
+				return result;
+			});
+
+			const waveResults = await Promise.all(promises);
+
+			// Process results
+			for (const result of waveResults) {
+				results.push(result);
+
+				if (result.status === "success") {
+					completed.add(result.taskIndex);
+				} else {
+					failed.add(result.taskIndex);
+				}
+
+				const icon = result.status === "success" ? "✅" : "❌";
+				const duration = (result.durationMs / 1000).toFixed(1);
+				const outputPreview = result.output.length > 500 ? result.output.slice(0, 500) + "..." : result.output;
+				notify(`${icon} Task ${result.taskIndex}: **${result.title}** (${duration}s)\n${outputPreview}`,
+					result.status === "success" ? "info" : "error");
+
+				progress += `## Task ${result.taskIndex}: ${result.title}\n\n`;
+				progress += `- **Status:** ${result.status}\n`;
+				progress += `- **Agent:** ${result.agent}\n`;
+				progress += `- **Wave:** ${wave}\n`;
+				progress += `- **Duration:** ${duration}s\n`;
+				progress += `- **Output:**\n\n\`\`\`\n${result.output.slice(0, 3000)}\n\`\`\`\n\n`;
+			}
+
 			await writeFile(progressPath, progress, "utf-8");
+			wave++;
 		}
 
-		const succeeded = results.filter(r => r.status === "success").length;
-		const failed = results.filter(r => r.status === "error").length;
+		// Sort results by task index for consistent reporting
+		results.sort((a, b) => a.taskIndex - b.taskIndex);
+
+		const succeededCount = results.filter(r => r.status === "success").length;
+		const failedCount = results.filter(r => r.status === "error").length;
+		const skippedCount = results.filter(r => r.status === "skipped").length;
 		const totalTime = results.reduce((sum, r) => sum + r.durationMs, 0);
 
 		progress += `---\n\n## Summary\n\n`;
 		progress += `- **Completed:** ${new Date().toLocaleString()}\n`;
-		progress += `- **Succeeded:** ${succeeded}/${results.length}\n`;
-		progress += `- **Failed:** ${failed}\n`;
+		progress += `- **Waves:** ${wave - 1}\n`;
+		progress += `- **Succeeded:** ${succeededCount}/${results.length}\n`;
+		progress += `- **Failed:** ${failedCount}\n`;
+		progress += `- **Skipped:** ${skippedCount}\n`;
 		progress += `- **Total time:** ${(totalTime / 1000).toFixed(1)}s\n`;
 		await writeFile(progressPath, progress, "utf-8");
 
+		const statusParts = [`✅ ${succeededCount} succeeded`];
+		if (failedCount > 0) statusParts.push(`❌ ${failedCount} failed`);
+		if (skippedCount > 0) statusParts.push(`⏭️ ${skippedCount} skipped`);
+
 		notify(
-			`\n🏁 **Execution complete!**\n` +
-			`✅ ${succeeded}/${results.length} succeeded | ❌ ${failed} failed | ⏱️ ${(totalTime / 1000).toFixed(1)}s\n` +
+			`\n🏁 **Execution complete!** (${wave - 1} waves)\n` +
+			statusParts.join(" | ") + ` | ⏱️ ${(totalTime / 1000).toFixed(1)}s\n` +
 			`Progress: \`${progressFile}\``,
-			failed === 0 ? "info" : "warning"
+			failedCount === 0 ? "info" : "warning"
 		);
 
 		return { results, progressFile };
@@ -317,13 +398,14 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "orchestrate",
 		label: "Project Orchestrator",
-		description: "Create a project plan AND automatically execute all tasks with sub-agents. Each agent gets its own isolated context, model, and system prompt. Call this after analyzing the user's project request.",
-		promptSnippet: "Plan + execute projects. Creates spec/todo, then runs each task with an isolated sub-agent.",
+		description: "Create a project plan AND automatically execute all tasks with sub-agents in parallel. Each agent gets its own isolated context, model, and system prompt. Tasks without dependencies run simultaneously.",
+		promptSnippet: "Plan + execute projects. Creates spec/todo, then runs tasks in parallel waves with isolated sub-agents.",
 		promptGuidelines: [
 			"When asked to plan or build a project: analyze the request, then call orchestrate. It will plan AND execute automatically.",
 			"Break tasks into small, actionable items. Each task is executed by an isolated sub-agent.",
 			"Assign agent types: 'explore' (analysis), 'plan' (design), 'code' (implementation), 'test' (validation), 'review' (quality).",
-			"Order tasks by dependency. Sub-agents execute sequentially, respecting the order.",
+			"Set dependencies carefully: tasks without dependencies run in parallel. Tasks with dependencies wait for their prerequisites.",
+			"Independent tasks run simultaneously (same wave). Dependent tasks wait for their prerequisites to complete.",
 		],
 		parameters: Type.Object({
 			title: Type.String({ description: "Project title" }),

package/package.json

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