@phi-code-admin/phi-code 0.72.0 → 0.74.0

package/agents/test.md

@@ -33,6 +33,9 @@ Use implementation results to know which files were created/modified and what be
 - **Realistic assertions**: Test what matters, not trivial details
 - **Match conventions**: Use the project's test framework, directory structure, and naming patterns
 - **Clean test code**: Tests are documentation — use descriptive names that explain expected behavior
+- Prefer targeted `edit` calls over full file rewrites. When a test fails, fix ONLY the failing test function, not the entire file
+- Maximum 1 full file rewrite per test file. After that, use `edit` for surgical fixes
+- When debugging test failures: read the error → locate the exact failing assertion → fix that specific line
 
 ## Test Writing
 

package/extensions/phi/memory.ts

@@ -43,9 +43,10 @@ export default function memoryExtension(pi: ExtensionAPI) {
 		description: "Search for content in memory using unified search (notes + ontology + vector search)",
 		promptSnippet: "Search project memory (notes, ontology, vector search). ALWAYS call before answering questions about prior work, decisions, or project context.",
 		promptGuidelines: [
-			"Before answering questions about prior work, architecture, decisions, or project context: call memory_search first.",
+			"MANDATORY: Before starting ANY task, call memory_search with relevant keywords. This is not optional.",
 			"When starting work on a topic, search memory for existing notes and learnings.",
 			"After completing important work or learning something new, use memory_write to save it.",
+			"MANDATORY: After completing any significant work, call memory_write to save what you did and what you learned.",
 			"When a command fails or produces an unexpected error, document the error and fix in memory_write (self-improvement).",
 			"When the user corrects you, save the correction in memory_write so you never repeat the mistake.",
 			"After a significant debugging session, write a summary of root cause and solution to memory.",

package/extensions/phi/orchestrator.ts

@@ -16,41 +16,12 @@
  *   /plans  — List plans and their execution status
  */
 
-import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "phi-code";
 import { writeFile, mkdir, readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
-// execFile removed — tasks now execute in-session, no subprocess
 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;
-	agent: string;
-	status: "success" | "error" | "skipped";
-	output: string;
-	durationMs: number;
-}
-
-interface AgentDef {
-	name: string;
-	description: string;
-	tools: string;
-	systemPrompt: string;
-}
-
 // ─── Extension ───────────────────────────────────────────────────────────
 
 export default function orchestratorExtension(pi: ExtensionAPI) {
@@ -64,390 +35,6 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		return new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
 	}
 
-	// ─── Agent Discovery ─────────────────────────────────────────────
-
-	function loadAgentDefs(): Map<string, AgentDef> {
-		const agents = new Map<string, AgentDef>();
-		const dirs = [
-			join(process.cwd(), ".phi", "agents"),
-			join(homedir(), ".phi", "agent", "agents"),
-			join(__dirname, "..", "..", "..", "agents"),
-		];
-
-		for (const dir of dirs) {
-			if (!existsSync(dir)) continue;
-			try {
-				const files = require("fs").readdirSync(dir) as string[];
-				for (const file of files) {
-					if (!file.endsWith(".md")) continue;
-					const name = file.replace(".md", "");
-					if (agents.has(name)) continue;
-
-					try {
-						const content = readFileSync(join(dir, file), "utf-8");
-						const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
-						if (!fmMatch) continue;
-
-						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 */ }
-				}
-			} catch { /* skip */ }
-		}
-
-		return agents;
-	}
-
-	function resolveAgentModel(agentType: string): string | null {
-		const routingPath = join(homedir(), ".phi", "agent", "routing.json");
-		try {
-			const config = JSON.parse(readFileSync(routingPath, "utf-8"));
-			for (const [_cat, route] of Object.entries(config.routes || {})) {
-				const r = route as any;
-				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 {
-			return null;
-		}
-	}
-
-	function findPhiBinary(): string {
-		// Try the bundled CLI relative to extensions dir
-		const bundledCli = join(__dirname, "..", "..", "..", "dist", "cli.js");
-		if (existsSync(bundledCli)) return bundledCli;
-
-		// Try npm global install paths
-		const npmGlobalPaths = [
-			join(homedir(), "AppData", "Roaming", "npm", "node_modules", "@phi-code-admin", "phi-code", "dist", "cli.js"), // Windows
-			join(homedir(), ".npm-global", "lib", "node_modules", "@phi-code-admin", "phi-code", "dist", "cli.js"), // Linux custom
-			"/usr/local/lib/node_modules/@phi-code-admin/phi-code/dist/cli.js", // Linux/Mac default
-			"/usr/lib/node_modules/@phi-code-admin/phi-code/dist/cli.js", // Some Linux
-		];
-		for (const p of npmGlobalPaths) {
-			if (existsSync(p)) return p;
-		}
-
-		// Try `which phi` (Linux/Mac) or `where phi` (Windows)
-		try {
-			const isWin = process.platform === "win32";
-			const cmd = isWin ? "where" : "which";
-			const result = require("child_process").execSync(`${cmd} phi 2>${isWin ? "NUL" : "/dev/null"}`, { encoding: "utf-8" }).trim();
-			if (result) {
-				const firstLine = result.split("\n")[0].trim();
-				// On Windows, `where phi` returns the .cmd shim; we need the actual JS
-				if (isWin && firstLine.endsWith(".cmd")) {
-					const npmPrefix = require("child_process").execSync("npm prefix -g", { encoding: "utf-8" }).trim();
-					const jsPath = join(npmPrefix, "node_modules", "@phi-code-admin", "phi-code", "dist", "cli.js");
-					if (existsSync(jsPath)) return jsPath;
-				}
-				return firstLine;
-			}
-		} catch { /* not in PATH */ }
-
-		// Last resort: assume phi is in PATH (works with shell:true on Windows)
-		return "phi";
-	}
-
-	// ─── Task Execution (in-session, no subprocess) ─────────────────
-
-	/**
-	 * Execute a task by sending it as a user message to the current session.
-	 * The LLM handles it directly — no subprocess spawning, no cold boot.
-	 * Much faster and more reliable than spawning phi --print processes.
-	 */
-	function executeTaskInSession(
-		task: TaskDef,
-		sharedContext: {
-			projectTitle: string;
-			projectDescription: string;
-			specSummary: string;
-			completedTasks: Array<{ index: number; title: string; agent: string; output: string }>;
-		},
-	): { taskPrompt: string } {
-		const agentType = task.agent || "code";
-
-		// Build prompt with shared context
-		let taskPrompt = `## 🔧 Task: ${task.title} [${agentType}]\n\n`;
-
-		taskPrompt += `**Project:** ${sharedContext.projectTitle}\n\n`;
-
-		if (sharedContext.specSummary) {
-			taskPrompt += `**Spec:** ${sharedContext.specSummary}\n\n`;
-		}
-
-		// Inject results from dependency tasks
-		const deps = task.dependencies || [];
-		if (deps.length > 0) {
-			const depResults = sharedContext.completedTasks.filter(ct => deps.includes(ct.index));
-			if (depResults.length > 0) {
-				taskPrompt += `**Previous results:**\n`;
-				for (const dep of depResults) {
-					const truncated = dep.output.length > 500 ? dep.output.slice(0, 500) + "..." : dep.output;
-					taskPrompt += `- Task ${dep.index} (${dep.title}): ${truncated}\n`;
-				}
-				taskPrompt += "\n";
-			}
-		}
-
-		// The actual task
-		taskPrompt += `### What to do\n\n${task.description}\n`;
-		if (task.subtasks && task.subtasks.length > 0) {
-			taskPrompt += "\n**Sub-tasks:**\n" + task.subtasks.map((st, i) => `${i + 1}. ${st}`).join("\n") + "\n";
-		}
-		taskPrompt += `\n**Instructions:** Execute this task completely. Create/edit all necessary files. Report what you did.\n`;
-
-		return { taskPrompt };
-	}
-
-	// ─── Execute All Tasks (parallel with dependency resolution) ─────
-
-	async function executePlan(
-		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 progressFile = todoFile.replace("todo-", "progress-");
-		const progressPath = join(plansDir, progressFile);
-		const totalTasks = tasks.length;
-
-		const sharedContext = {
-			projectTitle: projectContext?.title || "Project",
-			projectDescription: projectContext?.description || "",
-			specSummary: projectContext?.specSummary || "",
-			completedTasks: [] as Array<{ index: number; title: string; agent: string; output: string }>,
-		};
-
-		notify(`🚀 Executing ${totalTasks} tasks in-session...`, "info");
-
-		// Build a single comprehensive prompt with ALL tasks
-		let megaPrompt = `# 📋 Project: ${sharedContext.projectTitle}\n\n`;
-		megaPrompt += `${sharedContext.projectDescription}\n\n`;
-		if (sharedContext.specSummary) {
-			megaPrompt += `## Spec\n${sharedContext.specSummary}\n\n`;
-		}
-		megaPrompt += `## Tasks (execute ALL in order)\n\n`;
-
-		const results: TaskResult[] = [];
-
-		for (let i = 0; i < tasks.length; i++) {
-			const task = tasks[i];
-			const { taskPrompt } = executeTaskInSession(task, sharedContext);
-			megaPrompt += `---\n\n${taskPrompt}\n\n`;
-			results.push({
-				taskIndex: i + 1, title: task.title,
-				agent: task.agent || "code", status: "success",
-				output: "(in-session)", durationMs: 0,
-			});
-		}
-
-		megaPrompt += `---\n\n## ⚠️ Instructions\n\n`;
-		megaPrompt += `Execute ALL ${totalTasks} tasks above **sequentially**. For each task:\n`;
-		megaPrompt += `1. Create/edit the required files using your tools\n`;
-		megaPrompt += `2. Report what you did briefly\n`;
-		megaPrompt += `3. Move to the next task\n\n`;
-		megaPrompt += `Do NOT skip any task. Complete the entire project.\n`;
-
-		// Write progress file
-		let progress = `# Progress: ${todoFile}\n\n`;
-		progress += `**Started:** ${new Date().toLocaleString()}\n`;
-		progress += `**Tasks:** ${totalTasks} | **Mode:** in-session\n\n`;
-		for (const r of results) {
-			progress += `- Task ${r.taskIndex}: ${r.title} [${r.agent}]\n`;
-		}
-		await writeFile(progressPath, progress, "utf-8");
-
-		// Return the mega-prompt as tool result — LLM sees it and executes
-		return { results, progressFile, megaPrompt };
-	}
-
-	// ─── 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 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 thoroughly, then call the orchestrate tool. It plans AND executes automatically.",
-			"CRITICAL: Each task description must be SELF-CONTAINED. The sub-agent has NO access to this conversation. It receives: (1) project context (title, description, spec summary) automatically, (2) outputs from its dependency tasks automatically, (3) your task description. So include specific details: file paths, expected behavior, code patterns, success criteria. Don't repeat the project description — that's injected automatically.",
-			"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: "Concise project title" }),
-			description: Type.String({ description: "Full project description: what to build, why, and any relevant context" }),
-			goals: Type.Union([Type.Array(Type.String()), Type.String()], { description: "Measurable project goals (what success looks like)" }),
-			requirements: Type.Union([Type.Array(Type.String()), Type.String()], { description: "Technical and functional requirements" }),
-			architecture: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Architecture decisions, tech stack choices, trade-offs" })),
-			tasks: Type.Array(
-				Type.Object({
-					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. Independent tasks run in parallel. Dependent tasks wait for prerequisites." }
-			),
-			constraints: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Hard constraints: frameworks, patterns, rules, things to avoid" })),
-			successCriteria: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "How to verify the project is complete and correct" })),
-		}),
-
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			const raw = params as any;
-
-			// Normalize string fields to arrays (some models send strings instead of arrays)
-			const toArray = (v: any): string[] => {
-				if (!v) return [];
-				if (Array.isArray(v)) return v;
-				if (typeof v === "string") return v.split("\n").map((s: string) => s.replace(/^[-•*]\s*/, "").trim()).filter(Boolean);
-				return [];
-			};
-
-			const p = {
-				title: raw.title as string,
-				description: raw.description as string,
-				goals: toArray(raw.goals),
-				requirements: toArray(raw.requirements),
-				architecture: raw.architecture ? toArray(raw.architecture) : undefined,
-				tasks: raw.tasks as TaskDef[],
-				constraints: raw.constraints ? toArray(raw.constraints) : undefined,
-				successCriteria: raw.successCriteria ? toArray(raw.successCriteria) : undefined,
-			};
-
-			try {
-				await ensurePlansDir();
-				const ts = timestamp();
-				const specFile = `spec-${ts}.md`;
-				const todoFile = `todo-${ts}.md`;
-
-				// 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");
-
-				// 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 }] });
-					}
-				};
-
-				notify(`📋 Plan created: **${p.title}** (${p.tasks.length} tasks)\nNow executing with sub-agents...`, "info");
-
-				// Auto-execute all tasks
-				// 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, megaPrompt } = await executePlan(
-					p.tasks, todoFile, notify,
-					{ title: p.title, description: p.description, specSummary },
-				);
-
-				const header = `**📋 Project "${p.title}" — ${p.tasks.length} tasks planned!**\n` +
-					`Plan: \`${specFile}\`, \`${todoFile}\` | Progress: \`${progressFile}\`\n\n` +
-					`---\n\n`;
-
-				// Return the mega-prompt as tool result
-				// The LLM sees this and executes all tasks in its current turn
-				return {
-					content: [{ type: "text", text: header + megaPrompt }],
-					details: {
-						specFile, todoFile, progressFile,
-						taskCount: p.tasks.length,
-					},
-				};
-			} catch (error) {
-				return {
-					content: [{ type: "text", text: `Orchestration failed: ${error}` }],
-					details: { error: String(error) },
-				};
-			}
-		},
-	});
-
 	// ─── Orchestration State ─────────────────────────────────────────
 
 	interface AgentDef {
@@ -471,6 +58,10 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 	let activeAgentTools: string[] | null = null;
 	let savedTools: string[] | null = null;
 	let phasePending = false; // true while waiting for a phase to complete
+	let phaseTimeoutId: ReturnType<typeof setTimeout> | null = null;
+	const MAX_PHASE_DURATION_MS = 10 * 60 * 1000; // 10 minutes per phase
+	const MAX_TOOL_CALLS_PER_PHASE = 60; // Safety limit
+	let phaseStartTime: number | null = null;
 
 	/**
 	 * Parse agent .md file with YAML frontmatter
@@ -541,6 +132,9 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 **Project Request:** ${description}
 
 **Your tasks:**
+
+**Parallelization:** When making multiple tool calls that don't depend on each other (e.g., memory_search + ontology_query, or reading 2+ files), call them IN PARALLEL in the same response. This is faster.
+
 1. Call \`memory_search\` with project-relevant keywords (MANDATORY)
 2. List all existing files and read key ones
 3. Identify tech stack, patterns, and constraints
@@ -555,6 +149,7 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 **LAST ACTION (MANDATORY):** Call \`memory_write\` to save your exploration findings for downstream agents.
 
 **Knowledge Graph:**
+// TODO: ontology_batch_add for reducing API calls (currently single-item only)
 After your analysis, use \`ontology_add\` to save key project entities AND their relations:
 - Add entities for: the project, each major library, each module/directory
 - Add relations between them: "uses", "contains", "depends_on", "implements"
@@ -721,6 +316,8 @@ After implementation, use \`memory_write\` to save a summary of what was built,
 - On Linux/Mac fallback: \`lsof -ti:PORT | xargs kill -9\`
 - Always clean up after tests: kill background processes, remove temp files
 
+**Anti-loop rule:** If the SAME test fails 3 times in a row with the same error after your fixes, STOP trying to fix it. Write the failure in your test report as "UNRESOLVED" and move on. Do not waste more than 3 iterations on the same issue.
+
 After testing, use \`memory_write\` to save test results, bugs found, and lessons learned.` + runtimeInfo,
 			},
 			{
@@ -780,7 +377,12 @@ After your review, use \`memory_write\` ONCE to save:
 - Common mistakes to avoid in future projects
 Tag the note with relevant keywords for vector search.
 
-**Important:** Write lessons-learned ONCE. Do not call memory_write twice with the same filename or duplicate content.` + runtimeInfo,
+**Important:** Write lessons-learned ONCE. Do not call memory_write twice with the same filename or duplicate content.
+
+**Ontology enrichment:** After your review, use \`ontology_add\` to save your key findings:
+- Add a "review-report" entity with type "Document"
+- Add relations to the project: "reviews" → project, quality score as entity property
+- Save any new architectural decisions or patterns discovered` + runtimeInfo,
 			},
 		];
 	}
@@ -852,6 +454,16 @@ Tag the note with relevant keywords for vector search.
 			setOrchestrationActive(false);
 			phasePending = false;
 			deactivateAgent();
+			if (phaseTimeoutId) { clearTimeout(phaseTimeoutId); phaseTimeoutId = null; }
+			// Generate global final summary
+			const totalPhases = 5; // always 5
+			const elapsed = phaseStartTime ? Math.round((Date.now() - phaseStartTime) / 1000) : 0;
+			const minutes = Math.floor(elapsed / 60);
+			const seconds = elapsed % 60;
+			ctx.ui.notify(`\n📊 **Orchestration Summary**\n` +
+				`  Phases: ${totalPhases}/5 completed\n` +
+				`  Duration: ${minutes}m ${seconds}s\n` +
+				`  Check \`.phi/plans/\` for all reports`, "info");
 			try {
 				ctx.ui.notify(`\n✅ **All 5 phases complete!**`, "info");
 			} catch {
@@ -870,6 +482,15 @@ Tag the note with relevant keywords for vector search.
 			ctx.ui.notify(`\n${phase.label} → \`${modelId}\` (agent: ${agentName})`, "info");
 			// Small delay to let the model switch settle, then send instruction
 			setTimeout(() => pi.sendUserMessage(phase.instruction), 500);
+			// Set phase timeout — abort if phase takes too long
+			if (phaseTimeoutId) clearTimeout(phaseTimeoutId);
+			phaseTimeoutId = setTimeout(() => {
+				if (orchestrationActive && phasePending) {
+					ctx.ui.notify(`\n⏰ **Phase timed out** (${MAX_PHASE_DURATION_MS / 60000} min limit). Skipping to next phase.`, "warning");
+					phasePending = false;
+					sendNextPhase(ctx);
+				}
+			}, MAX_PHASE_DURATION_MS);
 		});
 	}
 
@@ -902,6 +523,9 @@ Tag the note with relevant keywords for vector search.
 			return;
 		}
 
+		// Clear phase timeout on normal completion
+		if (phaseTimeoutId) { clearTimeout(phaseTimeoutId); phaseTimeoutId = null; }
+
 		// Build a structured summary of what happened in this phase
 		// Instead of raw LLM text, extract concrete actions: files created/modified,
 		// errors encountered, test results. This gives the next phase actionable context.
@@ -930,8 +554,12 @@ Tag the note with relevant keywords for vector search.
 					const match = content.match(/edited (.+)/) || content.match(/in (.+)/);
 					if (match) filesEdited.push(match[1]);
 				}
-				// Track errors
-				if (content.includes('ERR:') || content.includes('Error:') || content.includes('FAIL')) {
+				// Track errors — but filter out edit retries (old_text mismatch = normal retry, not error)
+				if ((content.includes('ERR:') || content.includes('Error:') || content.includes('FAIL'))
+					&& !content.includes('old text must match')
+					&& !content.includes('The old text')
+					&& !content.includes('oldText not found')
+					&& !content.includes('old_text not found')) {
 					const preview = content.slice(0, 150).replace(/\n/g, ' ');
 					errorsHit.push(`${name}: ${preview}`);
 				}
@@ -943,13 +571,42 @@ Tag the note with relevant keywords for vector search.
 			}
 		}
 
+		// Detect API errors (401, auth failures) — abort workflow if found
+		const hasAuthError = messages.some((msg: any) => {
+			const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content || '');
+			return content.includes('401') && (content.includes('invalid access token') || content.includes('token expired') || content.includes('Unauthorized'));
+		});
+		if (hasAuthError || (toolCallCount === 0 && messages.length > 0)) {
+			const errorMsg = hasAuthError ? 'API authentication error (401)' : 'Phase produced 0 tool calls — possible API or model error';
+			ctx.ui.notify(`\n❌ **Orchestrator aborted:** ${errorMsg}\nCheck your API key and model configuration.`, "error");
+			setOrchestrationActive(false);
+			phasePending = false;
+			deactivateAgent();
+			if (phaseTimeoutId) { clearTimeout(phaseTimeoutId); phaseTimeoutId = null; }
+			return;
+		}
+
 		// Build the summary
 		const summaryParts: string[] = [];
 		summaryParts.push(`Tool calls: ${toolCallCount}`);
+		// Anti-loop guard: warn if tool calls are excessive
+		if (toolCallCount > MAX_TOOL_CALLS_PER_PHASE) {
+			summaryParts.push(`⚠️ WARNING: Phase used ${toolCallCount} tool calls (limit: ${MAX_TOOL_CALLS_PER_PHASE}). Possible loop detected.`);
+		}
 		if (filesWritten.length > 0) summaryParts.push(`Files created/written: ${filesWritten.join(', ')}`);
 		if (filesEdited.length > 0) summaryParts.push(`Files edited: ${filesEdited.join(', ')}`);
 		if (testResults.length > 0) summaryParts.push(`Test results:\n${testResults.join('\n')}`);
 		if (errorsHit.length > 0) summaryParts.push(`Errors encountered: ${errorsHit.length}\n${errorsHit.slice(0, 5).join('\n')}`);
+
+		// Verify mandatory tool usage
+		const toolNames = messages
+			.filter((m: any) => m.role === 'tool' || m.role === 'function' || m.role === 'toolResult')
+			.map((m: any) => (m as any).name || (m as any).toolName || '');
+		const hasMemorySearch = toolNames.includes('memory_search');
+		const hasMemoryWrite = toolNames.includes('memory_write');
+		if (!hasMemorySearch) summaryParts.push(`⚠️ Phase did NOT call memory_search (mandatory)`);
+		if (!hasMemoryWrite) summaryParts.push(`⚠️ Phase did NOT call memory_write (mandatory)`);
+
 		const phaseSummary = summaryParts.join('\n');
 
 		// Inject structured summary into next phase
@@ -1005,6 +662,8 @@ Tag the note with relevant keywords for vector search.
 			}
 			ctx.ui.notify("", "info");
 
+			// Record orchestration start time for final summary
+			phaseStartTime = Date.now();
 			// Switch model and activate agent for first phase
 			const modelId = await switchModelForPhase(firstPhase, ctx);
 			activateAgent(firstPhase, ctx);
@@ -1017,61 +676,12 @@ Tag the note with relevant keywords for vector search.
 	// ─── /run Command — Re-execute existing plan ─────────────────────
 
 	pi.registerCommand("run", {
-		description: "Re-execute an existing plan's tasks with sub-agents",
-		handler: async (args, ctx) => {
-			if (!existsSync(plansDir)) {
-				ctx.ui.notify("No plans found. Use `/plan <description>` to create and execute one.", "warning");
-				return;
-			}
-
-			const files = (await readdir(plansDir)).sort().reverse();
-			const todoFiles = files.filter(f => f.startsWith("todo-") && f.endsWith(".md"));
-
-			if (todoFiles.length === 0) {
-				ctx.ui.notify("No todo files found. Use `/plan <description>` first.", "warning");
-				return;
-			}
-
-			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 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,
-					});
-				}
-			}
-
-			if (tasks.length === 0) {
-				ctx.ui.notify("Could not parse tasks from todo file.", "error");
-				return;
-			}
-
-			const confirmed = await ctx.ui.confirm(
-				"Re-execute Plan",
-				`${tasks.length} tasks found in \`${todoFile}\`.\nEach will spawn an isolated sub-agent.\n\nProceed?`
+		description: "Re-execute an existing plan (deprecated — use /plan instead)",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(
+				"⚠️ `/run` is deprecated. Use `/plan <description>` to create and execute a new plan with the 5-phase orchestrator.",
+				"warning",
 			);
-			if (!confirmed) {
-				ctx.ui.notify("Cancelled.", "info");
-				return;
-			}
-
-			await executePlan(tasks, todoFile, (msg, type) => ctx.ui.notify(msg, type));
 		},
 	});
 

package/package.json

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