@phi-code-admin/phi-code 0.58.4 → 0.58.6

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,33 +398,36 @@ 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 in parallel waves. Each sub-agent gets isolated context + model. Use prompt-architect patterns for structured task descriptions.",
 		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.",
+			"When asked to plan or build a project: analyze the request thoroughly, then call the orchestrate tool. It plans AND executes automatically.",
+			"CRITICAL: Each task description must be SELF-CONTAINED. The sub-agent has NO shared history, NO access to the conversation, NO memory of previous tasks. Include ALL context it needs: file paths, expected behavior, relevant code patterns, and success criteria.",
+			"Structure each task description using the prompt-architect pattern: [CONTEXT] what exists and why → [TASK] what to do specifically → [FORMAT] expected output → [CONSTRAINTS] rules and limitations.",
+			"Assign agent types strategically: 'explore' (read-only analysis, codebase understanding), 'plan' (architecture, design decisions), 'code' (implementation, file creation/modification), 'test' (write + run tests, validate behavior), 'review' (security audit, quality check, read-only).",
+			"Set dependencies to maximize parallelism: tasks without dependencies run simultaneously in the same wave. Only add dependencies when a task truly needs another task's output.",
+			"Order tasks logically: explore → plan → code → test → review. But allow independent tasks at each stage to run in parallel.",
+			"Set priority=high for critical-path tasks, medium for standard work, low for nice-to-haves.",
 		],
 		parameters: Type.Object({
-			title: Type.String({ description: "Project title" }),
-			description: Type.String({ description: "Full project description with context" }),
-			goals: Type.Array(Type.String(), { description: "List of project goals" }),
+			title: Type.String({ description: "Concise project title" }),
+			description: Type.String({ description: "Full project description: what to build, why, and any relevant context" }),
+			goals: Type.Array(Type.String(), { description: "Measurable project goals (what success looks like)" }),
 			requirements: Type.Array(Type.String(), { description: "Technical and functional requirements" }),
-			architecture: Type.Optional(Type.Array(Type.String(), { description: "Architecture decisions" })),
+			architecture: Type.Optional(Type.Array(Type.String(), { description: "Architecture decisions, tech stack choices, trade-offs" })),
 			tasks: Type.Array(
 				Type.Object({
-					title: Type.String({ description: "Task title" }),
-					description: Type.String({ description: "Detailed task description with enough context for the agent to work independently" }),
-					agent: Type.Optional(Type.String({ description: "Agent type: explore, plan, code, test, or review" })),
-					priority: Type.Optional(Type.String({ description: "high, medium, or low" })),
-					dependencies: Type.Optional(Type.Array(Type.Number(), { description: "IDs of prerequisite tasks (1-indexed)" })),
-					subtasks: Type.Optional(Type.Array(Type.String(), { description: "Sub-task descriptions" })),
+					title: Type.String({ description: "Clear, action-oriented task title" }),
+					description: Type.String({ description: "SELF-CONTAINED task description. Include ALL context the sub-agent needs: file paths, expected behavior, code patterns, conventions. The agent has NO shared history." }),
+					agent: Type.Optional(Type.String({ description: "Agent type: explore (read-only analysis), plan (architecture), code (implementation), test (write+run tests), review (quality audit)" })),
+					priority: Type.Optional(Type.String({ description: "high (critical path), medium (standard), low (nice-to-have)" })),
+					dependencies: Type.Optional(Type.Array(Type.Number(), { description: "Task numbers this depends on (1-indexed). Only add when truly needed — fewer dependencies = more parallelism" })),
+					subtasks: Type.Optional(Type.Array(Type.String(), { description: "Specific sub-steps within this task" })),
 				}),
-				{ description: "Ordered list of tasks to execute" }
+				{ description: "Ordered list of tasks. Independent tasks run in parallel. Dependent tasks wait for prerequisites." }
 			),
-			constraints: Type.Optional(Type.Array(Type.String(), { description: "Project constraints" })),
-			successCriteria: Type.Optional(Type.Array(Type.String(), { description: "Completion criteria" })),
+			constraints: Type.Optional(Type.Array(Type.String(), { description: "Hard constraints: frameworks, patterns, rules, things to avoid" })),
+			successCriteria: Type.Optional(Type.Array(Type.String(), { description: "How to verify the project is complete and correct" })),
 		}),
 
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -445,18 +529,36 @@ All files in \`.phi/plans/\``;
 			}
 
 			ctx.sendUserMessage(
-				`Analyze this project request and execute it using the orchestrate tool.
-The orchestrate tool will create the plan AND execute all tasks automatically with sub-agents.
-
-Project: ${description}
-
-Instructions:
-- Identify goals, requirements, architecture decisions
-- Break into small tasks (each executable by one sub-agent independently)
-- Each task description must contain FULL context — the sub-agent has NO shared history
-- Assign agent types: explore (analysis), plan (design), code (implementation), test (validation), review (quality)
-- Set priorities and dependencies
-- Call the orchestrate tool — it handles everything from there`
+				`Analyze this project and call the orchestrate tool. It will create the plan AND execute all tasks automatically with parallel sub-agents.
+
+## Project
+${description}
+
+## Instructions
+
+1. **Analyze** the project: identify goals, requirements, technical constraints, and architecture decisions.
+
+2. **Decompose** into tasks. Each task will be executed by an isolated sub-agent that has:
+   - NO access to this conversation
+   - NO shared memory or context
+   - Its own model and system prompt
+   - Full tool access (read, write, edit, bash, grep, find, ls)
+
+3. **Write self-contained task descriptions** using this pattern:
+   - CONTEXT: What exists, relevant file paths, current state
+   - TASK: Exactly what to implement/analyze/test
+   - FORMAT: Expected output (files created, test results, etc.)
+   - CONSTRAINTS: Rules, conventions, things to avoid
+
+4. **Assign agents**: explore (read-only analysis), plan (design), code (implementation), test (write+run tests), review (quality audit)
+
+5. **Set dependencies** to maximize parallelism:
+   - Tasks without dependencies → same wave → run simultaneously
+   - Only add a dependency when a task truly needs another's output
+   - Typical flow: explore(wave 1) → plan(wave 2) → code(wave 3) → test(wave 4) → review(wave 5)
+   - But independent code tasks can run in parallel within the same wave
+
+6. **Call the orchestrate tool** with all structured data. It handles execution automatically.`
 			);
 		},
 	});

package/package.json

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