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

package/extensions/phi/orchestrator.ts

@@ -144,6 +144,12 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		task: TaskDef,
 		agentDefs: Map<string, AgentDef>,
 		cwd: string,
+		sharedContext: {
+			projectTitle: string;
+			projectDescription: string;
+			specSummary: string;
+			completedTasks: Array<{ index: number; title: string; agent: string; output: string }>;
+		},
 		timeoutMs: number = 300000,
 	): Promise<TaskResult> {
 		return new Promise((resolve) => {
@@ -153,7 +159,33 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			const phiBin = findPhiBinary();
 			const startTime = Date.now();
 
-			let taskPrompt = `Task: ${task.title}\n\n${task.description}`;
+			// Build prompt with shared context
+			let taskPrompt = "";
+
+			// Inject shared project context (lightweight, always included)
+			taskPrompt += `# Project Context\n\n`;
+			taskPrompt += `**Project:** ${sharedContext.projectTitle}\n`;
+			taskPrompt += `**Description:** ${sharedContext.projectDescription}\n\n`;
+
+			if (sharedContext.specSummary) {
+				taskPrompt += `## Specification Summary\n${sharedContext.specSummary}\n\n`;
+			}
+
+			// Inject results from dependency tasks (only the ones this task depends on)
+			const deps = task.dependencies || [];
+			if (deps.length > 0) {
+				const depResults = sharedContext.completedTasks.filter(ct => deps.includes(ct.index));
+				if (depResults.length > 0) {
+					taskPrompt += `## Previous Task Results (your dependencies)\n\n`;
+					for (const dep of depResults) {
+						const truncatedOutput = dep.output.length > 1500 ? dep.output.slice(0, 1500) + "\n...(truncated)" : dep.output;
+						taskPrompt += `### Task ${dep.index}: ${dep.title} [${dep.agent}]\n\`\`\`\n${truncatedOutput}\n\`\`\`\n\n`;
+					}
+				}
+			}
+
+			// The actual task
+			taskPrompt += `---\n\n# Your Task\n\n**${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");
 			}
@@ -199,17 +231,25 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		tasks: TaskDef[],
 		todoFile: string,
 		notify: (msg: string, type: "info" | "error" | "warning") => void,
+		projectContext?: { title: string; description: string; specSummary: string },
 	): 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**Mode:** parallel (dependency-aware)\n\n`;
+		progress += `**Tasks:** ${tasks.length}\n**Mode:** parallel (dependency-aware, shared context)\n\n`;
 		await writeFile(progressPath, progress, "utf-8");
 
+		// Shared context for sub-agents
+		const sharedContext = {
+			projectTitle: projectContext?.title || "Project",
+			projectDescription: projectContext?.description || "",
+			specSummary: projectContext?.specSummary || "",
+			completedTasks: [] as Array<{ index: number; title: string; agent: string; output: string }>,
+		};
+
 		// 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[] = [];
@@ -268,22 +308,29 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 				notify(`⏳ Task ${idx + 1}: **${t.title}** [${t.agent || "code"}]`, "info");
 			}
 
-			// Launch all ready tasks simultaneously
+			// Launch all ready tasks simultaneously (each gets shared context)
 			const promises = readyIndices.map(async (idx) => {
 				const task = tasks[idx];
-				const result = await executeTask(task, agentDefs, process.cwd());
+				const result = await executeTask(task, agentDefs, process.cwd(), sharedContext);
 				result.taskIndex = idx + 1;
 				return result;
 			});
 
 			const waveResults = await Promise.all(promises);
 
-			// Process results
+			// Process results and feed into shared context for next wave
 			for (const result of waveResults) {
 				results.push(result);
 
 				if (result.status === "success") {
 					completed.add(result.taskIndex);
+					// Add to shared context so dependent tasks can see this result
+					sharedContext.completedTasks.push({
+						index: result.taskIndex,
+						title: result.title,
+						agent: result.agent,
+						output: result.output,
+					});
 				} else {
 					failed.add(result.taskIndex);
 				}
@@ -399,33 +446,35 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		name: "orchestrate",
 		label: "Project Orchestrator",
 		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.",
+		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).",
-			"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.",
+			"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) {
@@ -457,7 +506,18 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 				notify(`📋 Plan created: **${p.title}** (${p.tasks.length} tasks)\nNow executing with sub-agents...`, "info");
 
 				// Auto-execute all tasks
-				const { results, progressFile } = await executePlan(p.tasks, todoFile, notify);
+				// Build spec summary for shared context
+				const specSummary = [
+					`Goals: ${p.goals.join("; ")}`,
+					`Requirements: ${p.requirements.join("; ")}`,
+					p.architecture?.length ? `Architecture: ${p.architecture.join("; ")}` : "",
+					p.constraints?.length ? `Constraints: ${p.constraints.join("; ")}` : "",
+				].filter(Boolean).join("\n");
+
+				const { results, progressFile } = await executePlan(
+					p.tasks, todoFile, notify,
+					{ title: p.title, description: p.description, specSummary },
+				);
 
 				const succeeded = results.filter(r => r.status === "success").length;
 				const failed = results.filter(r => r.status === "error").length;
@@ -527,18 +587,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.5",
+	"version": "0.58.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {