@phi-code-admin/phi-code 0.63.0 → 0.63.2

package/extensions/phi/memory.ts

@@ -4,10 +4,10 @@
  * Now powered by sigma-memory package which provides:
  * - NotesManager: Markdown files management
  * - OntologyManager: Knowledge graph with entities and relations  
- * - QMDManager: Vector search (if QMD is available)
+ * - VectorStore: Embedded vector search (sql.js + local embeddings)
  *
  * Features:
- * - memory_search: Unified search across notes, ontology, and QMD
+ * - memory_search: Unified search across notes, ontology, and vector store
  * - memory_write: Write content to memory files
  * - memory_read: Read specific memory files or list available ones
  * - memory_status: Get status of all memory subsystems
@@ -26,16 +26,12 @@ import { readFileSync } from "node:fs";
 import { SigmaMemory } from "sigma-memory";
 
 export default function memoryExtension(pi: ExtensionAPI) {
-	// Initialize sigma-memory
-	const sigmaMemory = new SigmaMemory({
-		// Default configuration, can be overridden
-		qmdEnabled: true,
-		qmdCommand: 'qmd'
-	});
+	// Initialize sigma-memory with embedded vector store
+	const sigmaMemory = new SigmaMemory();
 
-	// Initialize memory directories
-	sigmaMemory.init().catch(error => {
-		console.warn("Failed to initialize sigma-memory:", error);
+	// Initialize memory + vector store (lazy model download on first search)
+	sigmaMemory.init().catch(() => {
+		// Non-critical — memory works without vectors
 	});
 
 	/**
@@ -44,12 +40,15 @@ export default function memoryExtension(pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "memory_search",
 		label: "Memory Search",
-		description: "Search for content in memory using unified search (notes + ontology + QMD vector search)",
+		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.",
 			"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.",
+			"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.",
 		],
 		parameters: Type.Object({
 			query: Type.String({ description: "Search query to find in memory" }),
@@ -96,7 +95,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 								resultText += `Relation: ${data.type} (${data.from} → ${data.to})\n`;
 								resultText += `Properties: ${JSON.stringify(data.properties)}\n\n`;
 							}
-						} else if (result.source === 'qmd') {
+						} else if (result.source === 'vectors') {
 							const data = result.data;
 							resultText += `File: ${data.file} (line ${data.line})\n`;
 							resultText += `> ${data.content}\n\n`;
@@ -136,14 +135,18 @@ export default function memoryExtension(pi: ExtensionAPI) {
 			const { content, file } = params as { content: string; file?: string };
 
 			try {
-				// Use notes manager to write
+				// Write to notes
 				sigmaMemory.notes.write(content, file);
-
 				const filename = file || new Date().toISOString().split('T')[0] + '.md';
+
+				// Auto-index in vector store (non-blocking)
+				sigmaMemory.vectors.addDocument(filename, content).catch(() => {
+					// Vector indexing failed silently — notes still saved
+				});
 				
 				return {
-					content: [{ type: "text", text: `Content written to ${filename}` }],
-					details: { filename, contentLength: content.length }
+					content: [{ type: "text", text: `Content written to ${filename} (indexed for vector search)` }],
+					details: { filename, contentLength: content.length, vectorIndexed: true }
 				};
 
 			} catch (error) {
@@ -214,7 +217,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "memory_status",
 		label: "Memory Status",
-		description: "Get status of all memory subsystems (notes, ontology, QMD)",
+		description: "Get status of all memory subsystems (notes, ontology, vector search)",
 		parameters: Type.Object({}),
 
 		async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
@@ -236,14 +239,11 @@ export default function memoryExtension(pi: ExtensionAPI) {
 				statusText += `- Entities by type: ${JSON.stringify(status.ontology.entitiesByType)}\n`;
 				statusText += `- Relations by type: ${JSON.stringify(status.ontology.relationsByType)}\n\n`;
 				
-				// QMD status
-				statusText += `## QMD Vector Search\n`;
-				statusText += `- Available: ${status.qmd.available ? 'Yes' : 'No'}\n`;
-				if (status.qmd.available && status.qmd.status) {
-					statusText += `- Files indexed: ${status.qmd.status.files}\n`;
-					statusText += `- Chunks: ${status.qmd.status.chunks}\n`;
-					statusText += `- Last update: ${status.qmd.status.lastUpdate || 'Never'}\n`;
-				}
+				// Vector store status
+				statusText += `## Vector Search (embedded)\n`;
+				statusText += `- Documents: ${status.vectors.documentCount}\n`;
+				statusText += `- Chunks: ${status.vectors.chunkCount}\n`;
+				statusText += `- Last update: ${status.vectors.lastUpdate || 'Never'}\n`;
 
 				return {
 					content: [{ type: "text", text: statusText }],
@@ -292,7 +292,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 			const parts: string[] = [];
 			if (status.notes.count > 0) parts.push(`${status.notes.count} notes`);
 			if (status.ontology.entities > 0) parts.push(`${status.ontology.entities} entities`);
-			if (status.qmd.available) parts.push("QMD active");
+			if (status.vectors.chunkCount > 0) parts.push(`${status.vectors.chunkCount} vectors`);
 			if (parts.length > 0) {
 				ctx.ui.notify(`🧠 Memory: ${parts.join(", ")}`, "info");
 			}

package/extensions/phi/orchestrator.ts

@@ -450,23 +450,61 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 	// ─── Orchestration State ─────────────────────────────────────────
 
+	interface AgentDef {
+		name: string;
+		tools: string[];
+		systemPrompt: string;
+	}
+
 	interface OrchestratorPhase {
 		key: string;
 		label: string;
 		model: string;
 		fallback: string;
+		agent: AgentDef | null;
 		instruction: string;
 	}
 
 	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;
+
+	/**
+	 * Parse agent .md file with YAML frontmatter
+	 */
+	function loadAgentDef(name: string): AgentDef | null {
+		const dirs = [
+			join(process.cwd(), ".phi", "agents"),
+			join(homedir(), ".phi", "agent", "agents"),
+		];
+		for (const dir of dirs) {
+			const filePath = join(dir, `${name}.md`);
+			try {
+				const content = readFileSync(filePath, "utf-8");
+				const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+				if (!fmMatch) continue;
+				const fields: Record<string, string> = {};
+				for (const line of fmMatch[1].split("\n")) {
+					const m = line.match(/^(\w+):\s*(.*)$/);
+					if (m) fields[m[1]] = m[2].trim();
+				}
+				return {
+					name: fields.name || name,
+					tools: (fields.tools || "").split(",").map(t => t.trim()).filter(Boolean),
+					systemPrompt: fmMatch[2].trim(),
+				};
+			} catch { continue; }
+		}
+		return null;
+	}
 
 	/**
-	 * Load routing config and build phase queue with model assignments.
+	 * Load routing config and build phase queue with model assignments + agent definitions.
 	 */
 	function buildPhases(description: string): OrchestratorPhase[] {
-		// Read routing.json for model assignments
 		const routingPath = join(homedir(), ".phi", "agent", "routing.json");
 		let routing: any = { routes: {}, default: { model: "default" } };
 		try {
@@ -490,22 +528,27 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		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.`,
 			},
 			{
 				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.`,
 			},
 			{
 				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`,
 			},
 			{
 				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.`,
 			},
 			{
 				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.`,
 			},
 		];
@@ -513,7 +556,6 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 	/**
 	 * Switch model for the current phase.
-	 * Tries preferred model first, then fallback.
 	 */
 	async function switchModelForPhase(phase: OrchestratorPhase, ctx: any): Promise<string> {
 		const available = ctx.modelRegistry?.getAvailable?.() || [];
@@ -528,47 +570,90 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 		return ctx.model?.id || phase.model;
 	}
 
+	/**
+	 * Activate agent for a phase: set system prompt + restrict tools.
+	 */
+	function activateAgent(phase: OrchestratorPhase, ctx: any) {
+		if (phase.agent) {
+			// Save current tools for restoration
+			if (!savedTools) {
+				savedTools = pi.getActiveTools();
+			}
+			// Set agent's system prompt (will be injected via before_agent_start)
+			activeAgentPrompt = phase.agent.systemPrompt;
+			// Restrict tools to agent's allowed tools
+			if (phase.agent.tools.length > 0) {
+				activeAgentTools = phase.agent.tools;
+				pi.setActiveTools(phase.agent.tools);
+			}
+		} else {
+			activeAgentPrompt = null;
+			activeAgentTools = null;
+		}
+	}
+
+	/**
+	 * Deactivate agent: restore tools, clear prompt override.
+	 */
+	function deactivateAgent() {
+		activeAgentPrompt = null;
+		activeAgentTools = null;
+		if (savedTools) {
+			pi.setActiveTools(savedTools);
+			savedTools = null;
+		}
+	}
+
 	/**
 	 * Send the next phase in the queue.
-	 * Called after the agent goes idle (previous phase complete).
 	 */
 	function sendNextPhase(ctx: any) {
 		if (phaseQueue.length === 0) {
-			// All phases done
 			orchestrationActive = false;
+			deactivateAgent();
 			ctx.ui.notify(`\n✅ **All 5 phases complete!**`, "info");
 			return;
 		}
 
 		const phase = phaseQueue.shift()!;
 
-		// Switch model and send
 		switchModelForPhase(phase, ctx).then((modelId) => {
-			ctx.ui.notify(`\n${phase.label} → \`${modelId}\``, "info");
+			activateAgent(phase, ctx);
+			const agentName = phase.agent?.name || phase.key;
+			ctx.ui.notify(`\n${phase.label} → \`${modelId}\` (agent: ${agentName})`, "info");
 			setTimeout(() => pi.sendUserMessage(phase.instruction), 200);
 		});
 	}
 
+	// ─── System Prompt Injection — Agent personas ────────────────────
+
+	pi.on("before_agent_start", async (event, _ctx) => {
+		if (!orchestrationActive || !activeAgentPrompt) {
+			return { };
+		}
+		// Replace system prompt with the active agent's prompt
+		return { systemPrompt: activeAgentPrompt };
+	});
+
 	// ─── Output Event — Phase Chaining ───────────────────────────────
 
 	pi.on("output", async (_event, ctx) => {
 		if (!orchestrationActive || phaseQueue.length === 0) return;
 
-		// Debounce: clear any existing poll timer
 		if (idlePollTimer) {
 			clearInterval(idlePollTimer);
 			idlePollTimer = null;
 		}
 
-		// Poll for idle state (agent finishes tool calls + response)
 		let attempts = 0;
 		idlePollTimer = setInterval(() => {
 			attempts++;
-			if (attempts > 120) { // 60 seconds max
+			if (attempts > 120) {
 				clearInterval(idlePollTimer!);
 				idlePollTimer = null;
 				ctx.ui.notify("⚠️ Orchestrator timeout — phase took too long.", "warning");
 				orchestrationActive = false;
+				deactivateAgent();
 				return;
 			}
 			if (ctx.isIdle()) {
@@ -605,23 +690,27 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 			const specFile = `spec-${ts}.md`;
 			await writeFile(join(plansDir, specFile), `# ${description}\n\n**Created:** ${new Date().toLocaleString()}\n`, "utf-8");
 
-			// Build phases with model assignments from routing.json
+			// Build phases with model assignments + agent definitions
 			const phases = buildPhases(description);
 			phaseQueue = phases.slice(1); // Queue phases 2-5
 			orchestrationActive = true;
 			const firstPhase = phases[0];
 
-			ctx.ui.notify(`📋 **Orchestrator started** — 5 phases with model routing\n`, "info");
+			ctx.ui.notify(`📋 **Orchestrator started** — 5 phases with model routing + agent roles\n`, "info");
 
 			// Show the plan
 			for (const p of phases) {
-				ctx.ui.notify(`  ${p.label} → \`${p.model}\``, "info");
+				const agentName = p.agent?.name || p.key;
+				const toolCount = p.agent?.tools.length || 0;
+				ctx.ui.notify(`  ${p.label} → \`${p.model}\` (agent: ${agentName}, ${toolCount} tools)`, "info");
 			}
 			ctx.ui.notify("", "info");
 
-			// Switch model and send first phase after handler returns
+			// Switch model and activate agent for first phase
 			const modelId = await switchModelForPhase(firstPhase, ctx);
-			ctx.ui.notify(`${firstPhase.label} → \`${modelId}\``, "info");
+			activateAgent(firstPhase, ctx);
+			const agentName = firstPhase.agent?.name || firstPhase.key;
+			ctx.ui.notify(`${firstPhase.label} → \`${modelId}\` (agent: ${agentName})`, "info");
 			setTimeout(() => pi.sendUserMessage(firstPhase.instruction), 200);
 		},
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.63.0",
+	"version": "0.63.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -61,7 +61,7 @@
 		"phi-code-tui": "^0.56.3",
 		"proper-lockfile": "^4.1.2",
 		"sigma-agents": "^0.1.6",
-		"sigma-memory": "^0.1.2",
+		"sigma-memory": "0.2.0",
 		"sigma-skills": "^0.1.2",
 		"strip-ansi": "^7.1.0",
 		"undici": "^7.19.1",

package/scripts/postinstall.cjs

@@ -58,7 +58,18 @@ for (const pkg of sigmaPackages) {
   createLink(srcPkg, destLink, pkg);
 }
 
-// 3. Ensure settings.json has quietStartup: true
+// 3. Ensure memory directories exist (vector store DB created on first use)
+const memoryDir = join(homedir(), ".phi", "memory");
+const memoryNotesDir = join(memoryDir, "notes");
+const memoryOntologyDir = join(memoryDir, "ontology");
+for (const dir of [memoryDir, memoryNotesDir, memoryOntologyDir]) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    console.log(`  Φ Created ${dir}`);
+  }
+}
+
+// 4. Ensure settings.json has quietStartup: true
 const settingsPath = join(agentDir, "settings.json");
 try {
   let settings = {};