@phi-code-admin/phi-code 0.64.2 → 0.66.0

package/extensions/phi/orchestrator.ts

@@ -467,7 +467,6 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 	let phaseQueue: OrchestratorPhase[] = [];
 	let orchestrationActive = false;
-	let idlePollTimer: ReturnType<typeof setInterval> | null = null;
 	let activeAgentPrompt: string | null = null;
 	let activeAgentTools: string[] | null = null;
 	let savedTools: string[] | null = null;
@@ -504,6 +503,7 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 	/**
 	 * Load routing config and build phase queue with model assignments + agent definitions.
+	 * Each phase now reads outputs from previous phases and writes structured outputs.
 	 */
 	function buildPhases(description: string): OrchestratorPhase[] {
 		const routingPath = join(homedir(), ".phi", "agent", "routing.json");
@@ -526,31 +526,195 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		const test = getModel("test");
 		const review = getModel("review");
 
+		const ts = timestamp();
+
 		return [
 			{
 				key: "explore", label: "🔍 Phase 1 — EXPLORE", model: explore.preferred, fallback: explore.fallback,
 				agent: loadAgentDef("explore"),
-				instruction: `Analyze the project requirements and existing codebase. Identify what exists, what's needed, and any constraints.\n\n**Project:** ${description}\n\nList files, read key ones, check dependencies. Return a structured summary.`,
+				instruction: `You are the EXPLORE agent. Analyze the project requirements and existing codebase.
+
+**Project Request:** ${description}
+
+**Your tasks:**
+1. List all existing files and read key ones
+2. Identify tech stack, patterns, and constraints
+3. Create a STRUCTURED PROJECT BRIEF in \`.phi/plans/brief-${ts}.md\`:
+   - Context: what exists now
+   - Objective: what needs to be built
+   - Requirements: specific features needed
+   - Tech decisions: frameworks, patterns to use
+   - Constraints: what to NOT break
+
+**Step 4:** Write your findings to \`.phi/plans/explore-${ts}.md\`
+
+**Format for the project brief:**
+\`\`\`markdown
+## Project Brief
+
+### Context
+[Analyze what the user is asking for]
+
+### Objective
+[Clear, specific goal]
+
+### Requirements
+[Bullet list of what must be built]
+
+### Tech Decisions
+[Frameworks, patterns, architecture choices]
+
+### Constraints
+- Production-quality code, no placeholders
+- Every function fully implemented
+- Follow existing patterns if codebase exists
+- [Any other specific constraints]
+\`\`\``,
 			},
 			{
 				key: "plan", label: "📐 Phase 2 — PLAN", model: plan.preferred, fallback: plan.fallback,
 				agent: loadAgentDef("plan"),
-				instruction: `Design the architecture for this project. Define file structure, tech choices, and implementation approach.\n\n**Project:** ${description}\n\nBe specific: list every file to create with its purpose.`,
+				instruction: `You are the PLAN agent. Design the architecture and create a detailed task list.
+
+**Project Request:** ${description}
+
+**Step 1:** Read \`.phi/plans/brief-*.md\` (created by the explore phase)
+**Step 2:** Read \`.phi/plans/explore-*.md\` to understand the codebase analysis
+**Step 3:** Design the architecture based on findings
+**Step 4:** Create a DETAILED TODO LIST in \`.phi/plans/todo-${ts}.md\`:
+   For each task:
+   - Task number and title
+   - Agent assignment (code/test)
+   - Files to create/modify
+   - Specific implementation details
+   - Dependencies on other tasks
+
+**Format for the todo list:**
+\`\`\`markdown
+# TODO: Project Tasks
+
+## Task 1: [Task Title] [agent-type]
+- [ ] Specific implementation details
+- [ ] Files to create: path/to/file.ext
+- [ ] Expected behavior
+- Dependencies: None
+
+## Task 2: [Task Title] [agent-type]
+- [ ] Implementation details
+- Dependencies: Task 1
+\`\`\``,
 			},
 			{
 				key: "code", label: "💻 Phase 3 — CODE", model: code.preferred, fallback: code.fallback,
 				agent: loadAgentDef("code"),
-				instruction: `Implement the COMPLETE project. Create ALL files with production-quality code.\n\n**Project:** ${description}\n\n**Rules:**\n- Create every file needed\n- No placeholders, no TODOs, no stubs\n- Every function must be fully implemented\n- Follow the architecture from the previous planning phase`,
+				instruction: `You are the CODE agent. Implement the complete project.
+
+**Project Request:** ${description}
+
+**Step 1:** Read \`.phi/plans/brief-*.md\` for project context
+**Step 2:** Read \`.phi/plans/todo-*.md\` to get your task list
+**Step 3:** Implement EVERY task from the todo list, in order
+**Step 4:** Write a progress report to \`.phi/plans/progress-${ts}.md\`
+
+**Rules:**
+- Create every file listed in the plan
+- No placeholders, no TODOs, no stubs
+- Every function must be fully implemented
+- Follow the architecture from the plan
+- Check off tasks in your progress report as you complete them
+
+**Progress report format:**
+\`\`\`markdown
+# Progress Report
+
+## Completed Tasks
+- [x] Task 1: Description - DONE
+- [x] Task 2: Description - DONE
+
+## Files Created
+- path/to/file1.ext - Purpose
+- path/to/file2.ext - Purpose
+
+## Implementation Notes
+[Any important decisions or changes made]
+\`\`\``,
 			},
 			{
 				key: "test", label: "🧪 Phase 4 — TEST", model: test.preferred, fallback: test.fallback,
 				agent: loadAgentDef("test"),
-				instruction: `Test the implementation. Run the code, check for errors, verify it works.\n\n**Project:** ${description}\n\nFix any errors you find. Ensure the project runs correctly.`,
+				instruction: `You are the TEST agent. Verify the implementation.
+
+**Project Request:** ${description}
+
+**Step 1:** Read \`.phi/plans/todo-*.md\` to know what was planned
+**Step 2:** Read \`.phi/plans/progress-*.md\` to see what was done
+**Step 3:** Run the code, check for errors, test key features
+**Step 4:** Fix any errors you find
+**Step 5:** Write test results to \`.phi/plans/test-${ts}.md\`
+
+**Test report format:**
+\`\`\`markdown
+# Test Report
+
+## Tests Executed
+- [ ] Feature 1: Description - PASS/FAIL
+- [ ] Feature 2: Description - PASS/FAIL
+
+## Errors Found & Fixed
+- Error: Description
+  - Fix: What was done
+
+## Manual Testing
+- Tested: What was manually verified
+- Result: Pass/Fail with details
+
+## Final Status
+✅ All tests pass / ❌ Issues remain
+\`\`\``,
 			},
 			{
 				key: "review", label: "🔍 Phase 5 — REVIEW", model: review.preferred, fallback: review.fallback,
 				agent: loadAgentDef("review"),
-				instruction: `Review the code quality, security, and performance. Fix any issues.\n\n**Project:** ${description}\n\nCheck: error handling, edge cases, code style, documentation.`,
+				instruction: `You are the REVIEW agent. Final quality review.
+
+**Project Request:** ${description}
+
+**Step 1:** Read all \`.phi/plans/*.md\` files
+**Step 2:** Review code quality, security, performance
+**Step 3:** Fix any issues found
+**Step 4:** Write final report to \`.phi/plans/review-${ts}.md\`
+
+**Review checklist:**
+- Code quality: naming, structure, readability
+- Security: input validation, error handling
+- Performance: efficiency, resource usage
+- Documentation: comments, README if needed
+- Completeness: all requirements met
+
+**Final report format:**
+\`\`\`markdown
+# Final Review
+
+## Code Quality ✅/❌
+- Structure: Good/Needs work
+- Naming: Clear/Unclear
+- Comments: Adequate/Missing
+
+## Security ✅/❌
+- Input validation: Present/Missing
+- Error handling: Robust/Weak
+
+## Performance ✅/❌
+- Efficiency: Good/Could improve
+- Resource usage: Optimal/Excessive
+
+## Completeness ✅/❌
+- All requirements met: Yes/No
+- All files created: Yes/No
+
+## Final Verdict
+✅ Project ready for production / ❌ Issues need resolution
+\`\`\``,
 			},
 		];
 	}
@@ -629,34 +793,11 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			activateAgent(phase, ctx);
 			const agentName = phase.agent?.name || phase.key;
 			ctx.ui.notify(`\n${phase.label} → \`${modelId}\` (agent: ${agentName})`, "info");
-			// Wait for agent to be idle, then send the phase instruction
-			waitForIdleThenSend(phase.instruction, ctx);
+			// Small delay to let the model switch settle, then send instruction
+			setTimeout(() => pi.sendUserMessage(phase.instruction), 500);
 		});
 	}
 
-	/**
-	 * 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) => {
@@ -667,42 +808,20 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		return { systemPrompt: activeAgentPrompt };
 	});
 
-	// ─── 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.
+	// ─── Agent End Event — Phase Chaining ────────────────────────────
+	// "agent_end" fires when the full agent loop completes (all tool calls
+	// resolved, response fully generated). This is the ONLY reliable signal
+	// that a phase has finished.
+	//
+	// Previous approach used "output" event which DOES NOT EXIST in Pi.
+	// That's why phases 2-5 never executed.
 
-	pi.on("output", async (_event, ctx) => {
+	pi.on("agent_end", async (_event, ctx) => {
 		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;
-		}
-
-		// 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;
+		// Phase complete — chain to next
+		phasePending = false;
+		sendNextPhase(ctx);
 	});
 
 	// ─── /plan Command — Full workflow ───────────────────────────────

package/package.json

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