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

package/extensions/phi/orchestrator.ts

@@ -1,16 +1,19 @@
 /**
- * Orchestrator Extension - Project planning and automatic task execution
+ * Orchestrator Extension - Full-cycle project planning and execution
  *
- * Provides tools for the LLM to create structured project plans and execute them:
- * - /plan: Interactive planning command → creates spec.md + todo.md
- * - /plans: List and manage existing plans
- * - /run: Execute plan tasks using sub-agents (each with own context + model)
- * - orchestrate tool: Create spec.md + todo.md from structured input
+ * WORKFLOW (single command):
+ *   /plan <description> → LLM analyzes → orchestrate tool → spec + todo → auto-execute → progress
+ *   Everything happens in one shot. No manual steps.
+ *
+ * Commands:
+ *   /plan   — Full workflow: plan + execute with sub-agents
+ *   /run    — Re-execute an existing plan (e.g. after fixes)
+ *   /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 or current model)
+ * - 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.
@@ -18,14 +21,23 @@
 
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "phi-code";
-import { writeFile, mkdir, readdir, readFile, access } from "node:fs/promises";
-import { join, dirname } from "node:path";
+import { writeFile, mkdir, readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { homedir } from "node:os";
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
+interface TaskDef {
+	title: string;
+	description: string;
+	agent?: string;
+	priority?: string;
+	dependencies?: number[];
+	subtasks?: string[];
+}
+
 interface TaskResult {
 	taskIndex: number;
 	title: string;
@@ -57,10 +69,6 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 	// ─── Agent Discovery ─────────────────────────────────────────────
 
-	/**
-	 * Load agent definitions from .md files.
-	 * Searches: project .phi/agents/ → global ~/.phi/agent/agents/ → bundled agents/
-	 */
 	function loadAgentDefs(): Map<string, AgentDef> {
 		const agents = new Map<string, AgentDef>();
 		const dirs = [
@@ -76,7 +84,7 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 				for (const file of files) {
 					if (!file.endsWith(".md")) continue;
 					const name = file.replace(".md", "");
-					if (agents.has(name)) continue; // Priority: project > global > bundled
+					if (agents.has(name)) continue;
 
 					try {
 						const content = readFileSync(join(dir, file), "utf-8");
@@ -85,32 +93,34 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 						const frontmatter = fmMatch[1];
 						const body = fmMatch[2].trim();
-
 						const desc = frontmatter.match(/description:\s*(.+)/)?.[1] || "";
 						const tools = frontmatter.match(/tools:\s*(.+)/)?.[1] || "";
 
 						agents.set(name, { name, description: desc, tools, systemPrompt: body });
-					} catch { /* skip unparseable files */ }
+					} catch { /* skip */ }
 				}
-			} catch { /* skip inaccessible dirs */ }
+			} catch { /* skip */ }
 		}
 
 		return agents;
 	}
 
-	/**
-	 * Resolve the model for an agent type from routing.json.
-	 */
 	function resolveAgentModel(agentType: string): string | null {
 		const routingPath = join(homedir(), ".phi", "agent", "routing.json");
 		try {
 			const config = JSON.parse(readFileSync(routingPath, "utf-8"));
-			// Find the route that maps to this agent
-			for (const [_category, route] of Object.entries(config.routes || {})) {
+			for (const [_cat, route] of Object.entries(config.routes || {})) {
 				const r = route as any;
-				if (r.agent === agentType) {
-					return r.preferredModel || null;
-				}
+				if (r.agent === agentType) return r.preferredModel || null;
+			}
+			// Map agent type to route category
+			const categoryMap: Record<string, string> = {
+				code: "code", explore: "explore", plan: "plan",
+				test: "test", review: "review", debug: "debug",
+			};
+			const category = categoryMap[agentType];
+			if (category && config.routes?.[category]) {
+				return config.routes[category].preferredModel || null;
 			}
 			return config.default?.model || null;
 		} catch {
@@ -118,39 +128,23 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		}
 	}
 
-	/**
-	 * Find the phi CLI binary path.
-	 */
 	function findPhiBinary(): string {
-		// 1. Try the dist/cli.js from our package
 		const bundledCli = join(__dirname, "..", "..", "..", "dist", "cli.js");
 		if (existsSync(bundledCli)) return bundledCli;
-
-		// 2. Try global phi binary
 		try {
 			const which = require("child_process").execSync("which phi 2>/dev/null", { encoding: "utf-8" }).trim();
 			if (which) return which;
 		} catch { /* not in PATH */ }
-
-		// 3. Fallback to npx
 		return "npx";
 	}
 
 	// ─── Sub-Agent Execution ─────────────────────────────────────────
 
-	/**
-	 * Execute a task using a sub-agent process.
-	 * Each agent gets its own isolated phi process with:
-	 * - Its system prompt (from agent .md)
-	 * - Its model (from routing.json)
-	 * - No saved session (--no-save)
-	 * - JSON output mode (--json)
-	 */
 	function executeTask(
-		task: { title: string; description: string; agent?: string; subtasks?: string[] },
+		task: TaskDef,
 		agentDefs: Map<string, AgentDef>,
 		cwd: string,
-		timeoutMs: number = 300000, // 5 minutes per task
+		timeoutMs: number = 300000,
 	): Promise<TaskResult> {
 		return new Promise((resolve) => {
 			const agentType = task.agent || "code";
@@ -159,115 +153,203 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			const phiBin = findPhiBinary();
 			const startTime = Date.now();
 
-			// Build the task prompt
 			let taskPrompt = `Task: ${task.title}\n\n${task.description}`;
 			if (task.subtasks && task.subtasks.length > 0) {
 				taskPrompt += "\n\nSub-tasks:\n" + task.subtasks.map((st, i) => `${i + 1}. ${st}`).join("\n");
 			}
 			taskPrompt += "\n\nComplete this task. Be thorough and precise. Report what you did.";
 
-			// Build the command
 			const args: string[] = [];
-			if (phiBin === "npx") {
-				args.push("@phi-code-admin/phi-code");
-			}
+			if (phiBin === "npx") args.push("@phi-code-admin/phi-code");
 
-			// Add flags
-			args.push("--print"); // Non-interactive, output only
-			if (model && model !== "default") {
-				args.push("--model", model);
-			}
-			if (agentDef?.systemPrompt) {
-				args.push("--system-prompt", agentDef.systemPrompt);
-			}
-			args.push("--no-save"); // Don't create a session
+			args.push("--print");
+			if (model && model !== "default") args.push("--model", model);
+			if (agentDef?.systemPrompt) args.push("--system-prompt", agentDef.systemPrompt);
+			args.push("--no-save");
 			args.push(taskPrompt);
 
 			const cmd = phiBin === "npx" ? "npx" : "node";
 			const cmdArgs = phiBin === "npx" ? args : [phiBin, ...args];
 
-			const child = execFile(cmd, cmdArgs, {
+			execFile(cmd, cmdArgs, {
 				cwd,
 				timeout: timeoutMs,
-				maxBuffer: 10 * 1024 * 1024, // 10MB
+				maxBuffer: 10 * 1024 * 1024,
 				env: { ...process.env },
 			}, (error, stdout, stderr) => {
 				const durationMs = Date.now() - startTime;
-
 				if (error) {
 					resolve({
-						taskIndex: 0,
-						title: task.title,
-						agent: agentType,
-						status: "error",
-						output: `Error: ${error.message}\n${stderr || ""}`.trim(),
-						durationMs,
+						taskIndex: 0, title: task.title, agent: agentType,
+						status: "error", output: `Error: ${error.message}\n${stderr || ""}`.trim(), durationMs,
 					});
 				} else {
 					resolve({
-						taskIndex: 0,
-						title: task.title,
-						agent: agentType,
-						status: "success",
-						output: stdout.trim(),
-						durationMs,
+						taskIndex: 0, title: task.title, agent: agentType,
+						status: "success", output: stdout.trim(), durationMs,
 					});
 				}
 			});
 		});
 	}
 
-	// ─── Orchestrate Tool ────────────────────────────────────────────
+	// ─── Execute All Tasks ───────────────────────────────────────────
+
+	async function executePlan(
+		tasks: TaskDef[],
+		todoFile: string,
+		notify: (msg: string, type: "info" | "error" | "warning") => void,
+	): Promise<{ results: TaskResult[]; progressFile: string }> {
+		const agentDefs = loadAgentDefs();
+		const progressFile = todoFile.replace("todo-", "progress-");
+		const progressPath = join(plansDir, progressFile);
+		let progress = `# Progress: ${todoFile}\n\n`;
+		progress += `**Started:** ${new Date().toLocaleString()}\n`;
+		progress += `**Tasks:** ${tasks.length}\n\n`;
+		await writeFile(progressPath, progress, "utf-8");
+
+		notify(`🚀 Executing ${tasks.length} tasks with sub-agents...`, "info");
+
+		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`;
+			await writeFile(progressPath, progress, "utf-8");
+		}
+
+		const succeeded = results.filter(r => r.status === "success").length;
+		const failed = results.filter(r => r.status === "error").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 += `- **Total time:** ${(totalTime / 1000).toFixed(1)}s\n`;
+		await writeFile(progressPath, progress, "utf-8");
+
+		notify(
+			`\n🏁 **Execution complete!**\n` +
+			`✅ ${succeeded}/${results.length} succeeded | ❌ ${failed} failed | ⏱️ ${(totalTime / 1000).toFixed(1)}s\n` +
+			`Progress: \`${progressFile}\``,
+			failed === 0 ? "info" : "warning"
+		);
+
+		return { results, progressFile };
+	}
+
+	// ─── Generate Plan Files ─────────────────────────────────────────
+
+	function generateSpec(p: {
+		title: string; description: string; goals: string[]; requirements: string[];
+		architecture?: string[]; constraints?: string[]; successCriteria?: string[]; tasks: TaskDef[];
+	}): string {
+		let spec = `# ${p.title}\n\n`;
+		spec += `**Created:** ${new Date().toLocaleString()}\n\n`;
+		spec += `## Description\n\n${p.description}\n\n`;
+		spec += `## Goals\n\n`;
+		p.goals.forEach((g, i) => { spec += `${i + 1}. ${g}\n`; });
+		spec += "\n## Requirements\n\n";
+		p.requirements.forEach(r => { spec += `- ${r}\n`; });
+		spec += "\n";
+		if (p.architecture?.length) {
+			spec += `## Architecture\n\n`;
+			p.architecture.forEach(a => { spec += `- ${a}\n`; });
+			spec += "\n";
+		}
+		if (p.constraints?.length) {
+			spec += `## Constraints\n\n`;
+			p.constraints.forEach(c => { spec += `- ${c}\n`; });
+			spec += "\n";
+		}
+		if (p.successCriteria?.length) {
+			spec += `## Success Criteria\n\n`;
+			p.successCriteria.forEach(s => { spec += `- [ ] ${s}\n`; });
+			spec += "\n";
+		}
+		spec += `## Task Overview\n\n| # | Task | Agent | Priority | Dependencies |\n|---|------|-------|----------|-------------|\n`;
+		p.tasks.forEach((t, i) => {
+			const deps = t.dependencies?.map(d => `#${d}`).join(", ") || "—";
+			spec += `| ${i + 1} | ${t.title} | ${t.agent || "code"} | ${t.priority || "medium"} | ${deps} |\n`;
+		});
+		spec += `\n---\n*Generated by Phi Code Orchestrator*\n`;
+		return spec;
+	}
+
+	function generateTodo(title: string, tasks: TaskDef[]): string {
+		let todo = `# TODO: ${title}\n\n`;
+		todo += `**Created:** ${new Date().toLocaleString()}\n`;
+		todo += `**Tasks:** ${tasks.length}\n**Status:** executing\n\n`;
+		tasks.forEach((t, i) => {
+			const agentTag = t.agent ? ` [${t.agent}]` : "";
+			const prioTag = t.priority === "high" ? " 🔴" : t.priority === "low" ? " 🟢" : " 🟡";
+			const depsTag = t.dependencies?.length ? ` (after #${t.dependencies.join(", #")})` : "";
+			todo += `## Task ${i + 1}: ${t.title}${prioTag}${agentTag}${depsTag}\n\n- [ ] ${t.description}\n`;
+			if (t.subtasks) t.subtasks.forEach(st => { todo += `  - [ ] ${st}\n`; });
+			todo += "\n";
+		});
+		todo += `---\n\n## Progress\n\n- Total: ${tasks.length} tasks\n`;
+		todo += `- High priority: ${tasks.filter(t => t.priority === "high").length}\n`;
+		todo += `- Agents: ${[...new Set(tasks.map(t => t.agent || "code"))].join(", ")}\n`;
+		return todo;
+	}
+
+	// ─── Orchestrate Tool (plan + auto-execute) ──────────────────────
 
 	pi.registerTool({
 		name: "orchestrate",
 		label: "Project Orchestrator",
-		description: "Create structured project plan files (spec.md + todo.md) from analyzed project requirements. Call this AFTER you have analyzed the user's request and structured it into goals, requirements, architecture decisions, and tasks.",
-		promptSnippet: "Create spec.md + todo.md project plans. Use prompt-architect patterns to structure specs before calling.",
+		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.",
 		promptGuidelines: [
-			"When asked to plan a project: first analyze the request thoroughly, then call orchestrate with structured data.",
-			"Use the prompt-architect skill patterns (ROLE/CONTEXT/TASK/FORMAT/CONSTRAINTS) when structuring specifications.",
-			"Break tasks into small, actionable items. Each task should be completable by a single sub-agent.",
-			"Assign agent types to tasks: 'explore' for analysis, 'plan' for design, 'code' for implementation, 'test' for validation, 'review' for quality.",
+			"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.",
 		],
 		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" }),
 			requirements: Type.Array(Type.String(), { description: "Technical and functional requirements" }),
-			architecture: Type.Optional(Type.Array(Type.String(), { description: "Architecture decisions and tech stack" })),
+			architecture: Type.Optional(Type.Array(Type.String(), { description: "Architecture decisions" })),
 			tasks: Type.Array(
 				Type.Object({
 					title: Type.String({ description: "Task title" }),
-					description: Type.String({ description: "Detailed task description" }),
-					agent: Type.Optional(Type.String({ description: "Recommended agent: explore, plan, code, test, or review" })),
+					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 tasks this depends on (1-indexed)" })),
+					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" })),
 				}),
-				{ description: "Ordered list of tasks" }
+				{ description: "Ordered list of tasks to execute" }
 			),
-			constraints: Type.Optional(Type.Array(Type.String(), { description: "Project constraints and limitations" })),
-			successCriteria: Type.Optional(Type.Array(Type.String(), { description: "How to verify the project is done" })),
+			constraints: Type.Optional(Type.Array(Type.String(), { description: "Project constraints" })),
+			successCriteria: Type.Optional(Type.Array(Type.String(), { description: "Completion criteria" })),
 		}),
 
-		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			const p = params as {
-				title: string;
-				description: string;
-				goals: string[];
-				requirements: string[];
-				architecture?: string[];
-				tasks: Array<{
-					title: string;
-					description: string;
-					agent?: string;
-					priority?: string;
-					dependencies?: number[];
-					subtasks?: string[];
-				}>;
-				constraints?: string[];
-				successCriteria?: string[];
+				title: string; description: string; goals: string[]; requirements: string[];
+				architecture?: string[]; tasks: TaskDef[]; constraints?: string[]; successCriteria?: string[];
 			};
 
 			try {
@@ -276,99 +358,54 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 				const specFile = `spec-${ts}.md`;
 				const todoFile = `todo-${ts}.md`;
 
-				// ─── Generate spec.md ─────────────────────────────────
-				let spec = `# ${p.title}\n\n`;
-				spec += `**Created:** ${new Date().toLocaleString()}\n\n`;
-				spec += `## Description\n\n${p.description}\n\n`;
-
-				spec += `## Goals\n\n`;
-				p.goals.forEach((g, i) => { spec += `${i + 1}. ${g}\n`; });
-				spec += "\n";
-
-				spec += `## Requirements\n\n`;
-				p.requirements.forEach(r => { spec += `- ${r}\n`; });
-				spec += "\n";
-
-				if (p.architecture && p.architecture.length > 0) {
-					spec += `## Architecture\n\n`;
-					p.architecture.forEach(a => { spec += `- ${a}\n`; });
-					spec += "\n";
-				}
-
-				if (p.constraints && p.constraints.length > 0) {
-					spec += `## Constraints\n\n`;
-					p.constraints.forEach(c => { spec += `- ${c}\n`; });
-					spec += "\n";
-				}
-
-				if (p.successCriteria && p.successCriteria.length > 0) {
-					spec += `## Success Criteria\n\n`;
-					p.successCriteria.forEach(s => { spec += `- [ ] ${s}\n`; });
-					spec += "\n";
-				}
+				// Generate and write plan files
+				const spec = generateSpec(p);
+				const todo = generateTodo(p.title, p.tasks);
+				await writeFile(join(plansDir, specFile), spec, "utf-8");
+				await writeFile(join(plansDir, todoFile), todo, "utf-8");
 
-				spec += `## Task Overview\n\n`;
-				spec += `| # | Task | Agent | Priority | Dependencies |\n`;
-				spec += `|---|------|-------|----------|-------------|\n`;
-				p.tasks.forEach((t, i) => {
-					const deps = t.dependencies?.map(d => `#${d}`).join(", ") || "—";
-					spec += `| ${i + 1} | ${t.title} | ${t.agent || "code"} | ${t.priority || "medium"} | ${deps} |\n`;
-				});
-				spec += "\n";
-
-				spec += `---\n*Generated by Phi Code Orchestrator*\n`;
-
-				// ─── Generate todo.md ─────────────────────────────────
-				let todo = `# TODO: ${p.title}\n\n`;
-				todo += `**Created:** ${new Date().toLocaleString()}\n`;
-				todo += `**Tasks:** ${p.tasks.length}\n`;
-				todo += `**Status:** pending\n\n`;
-
-				p.tasks.forEach((t, i) => {
-					const agentTag = t.agent ? ` [${t.agent}]` : "";
-					const prioTag = t.priority === "high" ? " 🔴" : t.priority === "low" ? " 🟢" : " 🟡";
-					const depsTag = t.dependencies?.length ? ` (after #${t.dependencies.join(", #")})` : "";
-
-					todo += `## Task ${i + 1}: ${t.title}${prioTag}${agentTag}${depsTag}\n\n`;
-					todo += `- [ ] ${t.description}\n`;
-
-					if (t.subtasks) {
-						t.subtasks.forEach(st => {
-							todo += `  - [ ] ${st}\n`;
-						});
+				// Notify plan created
+				const notify = (msg: string, type: "info" | "error" | "warning") => {
+					// Use onUpdate for streaming progress to the user
+					if (_onUpdate) {
+						_onUpdate({ content: [{ type: "text", text: msg }] });
 					}
-					todo += "\n";
-				});
+				};
 
-				todo += `---\n\n## Progress\n\n`;
-				todo += `- Total: ${p.tasks.length} tasks\n`;
-				todo += `- High priority: ${p.tasks.filter(t => t.priority === "high").length}\n`;
-				todo += `- Agents needed: ${[...new Set(p.tasks.map(t => t.agent || "code"))].join(", ")}\n\n`;
-				todo += `*Run \`/run\` to execute tasks automatically with sub-agents.*\n`;
+				notify(`📋 Plan created: **${p.title}** (${p.tasks.length} tasks)\nNow executing with sub-agents...`, "info");
 
-				// Write files
-				await writeFile(join(plansDir, specFile), spec, "utf-8");
-				await writeFile(join(plansDir, todoFile), todo, "utf-8");
+				// Auto-execute all tasks
+				const { results, progressFile } = await executePlan(p.tasks, todoFile, notify);
+
+				const succeeded = results.filter(r => r.status === "success").length;
+				const failed = results.filter(r => r.status === "error").length;
+				const totalTime = results.reduce((sum, r) => sum + r.durationMs, 0);
 
-				const summary = `**✅ Project plan created!**
+				const summary = `**🏁 Project "${p.title}" — Complete!**
 
-📋 **${p.title}**
+**Plan files:** \`${specFile}\`, \`${todoFile}\`
+**Progress:** \`${progressFile}\`
 
-**Files:**
-- \`${specFile}\` — Full specification
-- \`${todoFile}\` — Task list with agent assignments
+**Results:**
+- ✅ Succeeded: ${succeeded}/${results.length}
+- ❌ Failed: ${failed}
+- ⏱️ Total time: ${(totalTime / 1000).toFixed(1)}s
 
-**Summary:**
-- ${p.goals.length} goals, ${p.requirements.length} requirements
-- ${p.tasks.length} tasks (${p.tasks.filter(t => t.priority === "high").length} high priority)
-- Agents: ${[...new Set(p.tasks.map(t => t.agent || "code"))].join(", ")}
+**Task details:**
+${results.map(r => {
+	const icon = r.status === "success" ? "✅" : "❌";
+	return `${icon} Task ${r.taskIndex}: ${r.title} [${r.agent}] (${(r.durationMs / 1000).toFixed(1)}s)`;
+}).join("\n")}
 
-**Execute:** Run \`/run\` to launch sub-agents and execute tasks automatically.
-Each agent gets its own context, model, and system prompt.`;
+All files in \`.phi/plans/\``;
 
 				return {
 					content: [{ type: "text", text: summary }],
-					details: { specFile, todoFile, taskCount: p.tasks.length, title: p.title },
+					details: {
+						specFile, todoFile, progressFile,
+						taskCount: p.tasks.length, succeeded, failed,
+						totalTimeMs: totalTime, title: p.title,
+					},
 				};
 			} catch (error) {
 				return {
@@ -379,14 +416,58 @@ Each agent gets its own context, model, and system prompt.`;
 		},
 	});
 
-	// ─── /run Command — Execute plan with sub-agents ─────────────────
+	// ─── /plan Command — Full workflow ───────────────────────────────
+
+	pi.registerCommand("plan", {
+		description: "Plan AND execute a project: creates spec + todo, then runs each task with isolated sub-agents",
+		handler: async (args, ctx) => {
+			const description = args.trim();
+
+			if (!description) {
+				ctx.ui.notify(`**Usage:** \`/plan <project description>\`
+
+**Full workflow in one command:**
+1. LLM analyzes your description
+2. Creates spec.md + todo.md
+3. Executes each task with an isolated sub-agent
+4. Each agent has its own context, model, and system prompt
+5. Results saved to progress.md
+
+**Examples:**
+  /plan Build a REST API for user authentication with JWT
+  /plan Add test coverage to the payment module
+  /plan Refactor the frontend to use TypeScript
+
+**Other commands:**
+  /run   — Re-execute an existing plan
+  /plans — List all plans and status`, "info");
+				return;
+			}
+
+			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`
+			);
+		},
+	});
+
+	// ─── /run Command — Re-execute existing plan ─────────────────────
 
 	pi.registerCommand("run", {
-		description: "Execute the latest plan's tasks using sub-agents (each with own context and model)",
+		description: "Re-execute an existing plan's tasks with sub-agents",
 		handler: async (args, ctx) => {
-			// Find the latest todo file
 			if (!existsSync(plansDir)) {
-				ctx.ui.notify("No plans found. Use `/plan <description>` to create one first.", "warning");
+				ctx.ui.notify("No plans found. Use `/plan <description>` to create and execute one.", "warning");
 				return;
 			}
 
@@ -398,219 +479,99 @@ Each agent gets its own context, model, and system prompt.`;
 				return;
 			}
 
-			const todoFile = todoFiles[0]; // Most recent
-			const todoPath = join(plansDir, todoFile);
-			const todoContent = await readFile(todoPath, "utf-8");
-
-			// Parse tasks from todo.md
-			const taskRegex = /## Task (\d+): (.+?)(?:\s*🔴|\s*🟡|\s*🟢)?\s*(?:\[(\w+)\])?\s*(?:\(after.*?\))?\n\n- \[ \] (.+?)(?:\n(?:  - \[ \] .+?\n)*)?/g;
-			const tasks: Array<{ index: number; title: string; agent: string; description: string; subtasks: string[] }> = [];
-
-			let match;
-			while ((match = taskRegex.exec(todoContent)) !== null) {
-				const subtaskRegex = /  - \[ \] (.+)/g;
+			const todoFile = todoFiles[0];
+			const todoContent = await readFile(join(plansDir, todoFile), "utf-8");
+
+			// Parse tasks
+			const tasks: TaskDef[] = [];
+			const sections = todoContent.split(/## Task \d+:/);
+			for (let i = 1; i < sections.length; i++) {
+				const section = sections[i];
+				const titleMatch = section.match(/^(.+?)(?:\s*🔴|\s*🟡|\s*🟢)/);
+				const agentMatch = section.match(/\[(\w+)\]/);
+				const descMatch = section.match(/- \[ \] (.+)/);
 				const subtasks: string[] = [];
-				const taskBlock = todoContent.slice(match.index, taskRegex.lastIndex + 500);
-				let stMatch;
-				while ((stMatch = subtaskRegex.exec(taskBlock)) !== null) {
-					subtasks.push(stMatch[1]);
+				const stMatches = section.matchAll(/  - \[ \] (.+)/g);
+				for (const m of stMatches) subtasks.push(m[1]);
+
+				if (titleMatch && descMatch) {
+					tasks.push({
+						title: titleMatch[1].trim(),
+						agent: agentMatch?.[1] || "code",
+						description: descMatch[1].trim(),
+						subtasks: subtasks.length > 0 ? subtasks : undefined,
+					});
 				}
-
-				tasks.push({
-					index: parseInt(match[1]),
-					title: match[2].trim(),
-					agent: match[3] || "code",
-					description: match[4].trim(),
-					subtasks,
-				});
 			}
 
 			if (tasks.length === 0) {
-				ctx.ui.notify("Could not parse tasks from the todo file. Check the format.", "error");
+				ctx.ui.notify("Could not parse tasks from todo file.", "error");
 				return;
 			}
 
-			// Load agent definitions
-			const agentDefs = loadAgentDefs();
-			const availableAgents = [...agentDefs.keys()].join(", ") || "none loaded";
-
-			// Confirm execution
 			const confirmed = await ctx.ui.confirm(
-				"Execute Plan",
-				`Found ${tasks.length} tasks in \`${todoFile}\`.\n` +
-				`Available agents: ${availableAgents}\n` +
-				`Each task will spawn an isolated phi process with its own context.\n\n` +
-				`Proceed?`
+				"Re-execute Plan",
+				`${tasks.length} tasks found in \`${todoFile}\`.\nEach will spawn an isolated sub-agent.\n\nProceed?`
 			);
-
 			if (!confirmed) {
-				ctx.ui.notify("Execution cancelled.", "info");
-				return;
-			}
-
-			// Create progress file
-			const progressFile = todoFile.replace("todo-", "progress-");
-			const progressPath = join(plansDir, progressFile);
-			let progress = `# Progress: ${todoFile}\n\n`;
-			progress += `**Started:** ${new Date().toLocaleString()}\n`;
-			progress += `**Tasks:** ${tasks.length}\n\n`;
-			await writeFile(progressPath, progress, "utf-8");
-
-			ctx.ui.notify(`🚀 Starting execution of ${tasks.length} tasks...`, "info");
-
-			// Execute tasks in order (respecting dependencies)
-			const results: TaskResult[] = [];
-			const completed = new Set<number>();
-
-			for (const task of tasks) {
-				ctx.ui.notify(`\n⏳ **Task ${task.index}: ${task.title}** [${task.agent}]`, "info");
-
-				// Execute the task
-				const result = await executeTask(
-					{ title: task.title, description: task.description, agent: task.agent, subtasks: task.subtasks },
-					agentDefs,
-					process.cwd(),
-				);
-				result.taskIndex = task.index;
-
-				results.push(result);
-				completed.add(task.index);
-
-				// Report result
-				const icon = result.status === "success" ? "✅" : "❌";
-				const duration = (result.durationMs / 1000).toFixed(1);
-				ctx.ui.notify(
-					`${icon} **Task ${task.index}: ${task.title}** (${duration}s)\n` +
-					`Agent: ${task.agent} | Output: ${result.output.slice(0, 500)}${result.output.length > 500 ? "..." : ""}`,
-					result.status === "success" ? "info" : "error"
-				);
-
-				// Update progress file
-				progress += `## Task ${task.index}: ${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, 2000)}\n\`\`\`\n\n`;
-				await writeFile(progressPath, progress, "utf-8");
-			}
-
-			// Final summary
-			const succeeded = results.filter(r => r.status === "success").length;
-			const failed = results.filter(r => r.status === "error").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 += `- **Total time:** ${(totalTime / 1000).toFixed(1)}s\n`;
-			await writeFile(progressPath, progress, "utf-8");
-
-			ctx.ui.notify(
-				`\n🏁 **Execution complete!**\n\n` +
-				`✅ Succeeded: ${succeeded}/${results.length}\n` +
-				`❌ Failed: ${failed}\n` +
-				`⏱️ Total time: ${(totalTime / 1000).toFixed(1)}s\n\n` +
-				`Progress saved to \`${progressFile}\``,
-				failed === 0 ? "info" : "warning"
-			);
-		},
-	});
-
-	// ─── /plan Command ───────────────────────────────────────────────
-
-	pi.registerCommand("plan", {
-		description: "Create a structured project plan (the LLM analyzes your description, then creates spec + todo files)",
-		handler: async (args, ctx) => {
-			const description = args.trim();
-
-			if (!description) {
-				ctx.ui.notify(`**Usage:** \`/plan <project description>\`
-
-**Examples:**
-  /plan Build a REST API for user authentication with JWT tokens
-  /plan Migrate the frontend from React to Next.js App Router
-  /plan Add comprehensive test coverage to the payment module
-
-The LLM will:
-1. Analyze your description
-2. Break down into tasks with agent assignments
-3. Create spec.md + todo.md files in .phi/plans/
-4. Run \`/run\` to execute with sub-agents
-
-Each sub-agent gets its own isolated context, model, and system prompt.`, "info");
+				ctx.ui.notify("Cancelled.", "info");
 				return;
 			}
 
-			ctx.sendUserMessage(
-				`Please analyze this project request and create a structured plan using the orchestrate tool.
-
-Project description: ${description}
-
-Instructions:
-- Identify clear goals, requirements, and architecture decisions
-- Break the work into small, actionable tasks (each doable by one agent)
-- Assign the best agent type to each task: explore (analysis), plan (design), code (implementation), test (validation), review (quality)
-- Set priorities (high/medium/low) and dependencies between tasks
-- Define success criteria for the project`
-			);
+			await executePlan(tasks, todoFile, (msg, type) => ctx.ui.notify(msg, type));
 		},
 	});
 
 	// ─── /plans Command ──────────────────────────────────────────────
 
 	pi.registerCommand("plans", {
-		description: "List existing project plans and their execution status",
+		description: "List all project plans and their execution status",
 		handler: async (_args, ctx) => {
-			try {
-				if (!existsSync(plansDir)) {
-					ctx.ui.notify("No plans yet. Use `/plan <description>` to create one.", "info");
-					return;
-				}
-
-				const files = await readdir(plansDir);
-				const specs = files.filter(f => f.startsWith("spec-") && f.endsWith(".md")).sort().reverse();
+			if (!existsSync(plansDir)) {
+				ctx.ui.notify("No plans yet. Use `/plan <description>` to create and execute one.", "info");
+				return;
+			}
 
-				if (specs.length === 0) {
-					ctx.ui.notify("No plans found. Use `/plan <description>` to create one.", "info");
-					return;
-				}
+			const files = await readdir(plansDir);
+			const specs = files.filter(f => f.startsWith("spec-") && f.endsWith(".md")).sort().reverse();
 
-				let output = `📁 **Project Plans** (${specs.length})\n\n`;
+			if (specs.length === 0) {
+				ctx.ui.notify("No plans found.", "info");
+				return;
+			}
 
-				for (const specFile of specs) {
-					const ts = specFile.replace("spec-", "").replace(".md", "");
-					const todoFile = `todo-${ts}.md`;
-					const progressFile = `progress-${ts}.md`;
+			let output = `📁 **Project Plans** (${specs.length})\n\n`;
 
-					try {
-						const content = await readFile(join(plansDir, specFile), "utf-8");
-						const titleMatch = content.match(/^# (.+)$/m);
-						const title = titleMatch ? titleMatch[1] : specFile;
-						const taskCount = (content.match(/\| \d+ \|/g) || []).length;
-						const date = ts.replace(/_/g, " ").substring(0, 10);
-
-						const hasTodo = files.includes(todoFile);
-						const hasProgress = files.includes(progressFile);
-						const status = hasProgress ? "🟢 executed" : hasTodo ? "🟡 planned" : "⚪ spec only";
-
-						output += `📋 **${title}** (${date}) ${status}\n`;
-						output += `   Spec: \`${specFile}\``;
-						if (hasTodo) output += ` | Todo: \`${todoFile}\``;
-						if (hasProgress) output += ` | Progress: \`${progressFile}\``;
-						output += "\n";
-						if (taskCount > 0) output += `   Tasks: ${taskCount}\n`;
-						output += "\n";
-					} catch {
-						output += `📋 \`${specFile}\`\n\n`;
-					}
+			for (const specFile of specs) {
+				const ts = specFile.replace("spec-", "").replace(".md", "");
+				const todoFile = `todo-${ts}.md`;
+				const progressFile = `progress-${ts}.md`;
+
+				try {
+					const content = await readFile(join(plansDir, specFile), "utf-8");
+					const titleMatch = content.match(/^# (.+)$/m);
+					const title = titleMatch ? titleMatch[1] : specFile;
+					const taskCount = (content.match(/\| \d+ \|/g) || []).length;
+					const date = ts.replace(/_/g, " ").substring(0, 10);
+
+					const hasTodo = files.includes(todoFile);
+					const hasProgress = files.includes(progressFile);
+					const status = hasProgress ? "🟢 executed" : hasTodo ? "🟡 planned" : "⚪ spec only";
+
+					output += `📋 **${title}** (${date}) ${status}\n`;
+					output += `   Spec: \`${specFile}\``;
+					if (hasTodo) output += ` | Todo: \`${todoFile}\``;
+					if (hasProgress) output += ` | Progress: \`${progressFile}\``;
+					output += "\n";
+					if (taskCount > 0) output += `   Tasks: ${taskCount}\n`;
+					output += "\n";
+				} catch {
+					output += `📋 \`${specFile}\`\n\n`;
 				}
-
-				output += `_Commands: \`/plan\` (create), \`/run\` (execute), \`read .phi/plans/<file>\` (view)_`;
-				ctx.ui.notify(output, "info");
-			} catch (error) {
-				ctx.ui.notify(`Failed to list plans: ${error}`, "error");
 			}
+
+			output += `_Commands: \`/plan\` (create+execute), \`/run\` (re-execute), \`read .phi/plans/<file>\` (view)_`;
+			ctx.ui.notify(output, "info");
 		},
 	});
 }

package/package.json

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