@phi-code-admin/phi-code 0.68.0 → 0.69.0

package/agents/code.md

@@ -39,3 +39,10 @@ Use this context to understand the project scope and build on previous work. Do
 2. **What was done**: Concise implementation summary
 3. **Verification**: What you checked (compilation, tests, edge cases)
 4. **Concerns**: Any TODOs, limitations, or risks
+
+## Constraints
+- Write ONE file per tool call — never combine multiple files in a single response
+- Keep each file under 500 lines — split into modules if needed
+- Files containing JSX/TSX syntax MUST use .tsx extension, not .ts
+- Pure TypeScript files use .ts extension
+- When using React/Ink components, ALWAYS use .tsx

package/agents/explore.md

@@ -31,6 +31,13 @@ Use the project context to focus your analysis on what matters. Avoid duplicatin
 - **Read-only**: You NEVER modify files
 - **Time-efficient**: Focus on what the task asks. Don't analyze the entire codebase if only one module matters
 
+## Ontology Rules
+- After adding entities, ALWAYS create relations between them
+- Relation types: "uses", "contains", "depends_on", "implements", "extends"
+- Example: Project "finance-tracker" --uses--> Library "ink"
+- A knowledge graph without relations is just a flat list — useless
+- Create at minimum: project→uses→each library, project→contains→each module
+
 ## Output Format
 
 Structure your findings for maximum utility to downstream agents:

package/extensions/phi/memory.ts

@@ -254,15 +254,38 @@ export default function memoryExtension(pi: ExtensionAPI) {
 					if (!p.from || !p.to || !p.relationType) {
 						return { content: [{ type: "text", text: "Relation requires 'from', 'to', and 'relationType'" }], isError: true };
 					}
+					
+					// Try finding source entity by ID first, then by name
+					let sourceEntity = sigmaMemory.ontology.findEntity({ id: p.from })[0];
+					if (!sourceEntity) {
+						// Try finding by name (case-insensitive)
+						const allEntities = sigmaMemory.ontology.findEntity({});
+						sourceEntity = allEntities.find(e => e.name.toLowerCase() === p.from.toLowerCase());
+						if (!sourceEntity) {
+							return { content: [{ type: "text", text: `Source entity not found: ${p.from}` }], isError: true };
+						}
+					}
+					
+					// Try finding target entity by ID first, then by name
+					let targetEntity = sigmaMemory.ontology.findEntity({ id: p.to })[0];
+					if (!targetEntity) {
+						// Try finding by name (case-insensitive)
+						const allEntities = sigmaMemory.ontology.findEntity({});
+						targetEntity = allEntities.find(e => e.name.toLowerCase() === p.to.toLowerCase());
+						if (!targetEntity) {
+							return { content: [{ type: "text", text: `Target entity not found: ${p.to}` }], isError: true };
+						}
+					}
+					
 					const id = sigmaMemory.ontology.addRelation({
-						from: p.from,
-						to: p.to,
+						from: sourceEntity.id,
+						to: targetEntity.id,
 						type: p.relationType,
 						properties: p.properties || {},
 					});
 					return {
-						content: [{ type: "text", text: `Relation added: \`${p.from}\` → **${p.relationType}** → \`${p.to}\` — ID: \`${id}\`` }],
-						details: { id, from: p.from, to: p.to, type: p.relationType },
+						content: [{ type: "text", text: `Relation added: \`${sourceEntity.name}\` → **${p.relationType}** → \`${targetEntity.name}\` — ID: \`${id}\`` }],
+						details: { id, from: sourceEntity.id, to: targetEntity.id, type: p.relationType },
 					};
 				}
 				return { content: [{ type: "text", text: "Type must be 'entity' or 'relation'" }], isError: true };

package/extensions/phi/orchestrator.ts

@@ -548,7 +548,12 @@ export default function orchestratorExtension(pi: ExtensionAPI) {
 
 **Step 4:** Write your findings to \`.phi/plans/explore-${ts}.md\`
 
-After your analysis, use \`ontology_add\` to save key project entities (files, modules, dependencies) to the knowledge graph.
+**Knowledge Graph:**
+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"
+- Example: entity "finance-tracker" (type: Project) → relation "uses" → entity "ink" (type: Library)
+- ALWAYS create relations — entities without relations are useless
 
 **Format for the project brief:**
 \`\`\`markdown
@@ -578,6 +583,11 @@ After your analysis, use \`ontology_add\` to save key project entities (files, m
 				agent: loadAgentDef("plan"),
 				instruction: `You are the PLAN agent. Design the architecture and create a detailed task list.
 
+**Context Retrieval:**
+1. Use \`ontology_query\` to retrieve all entities and relations from Phase 1
+2. Use \`memory_search\` with project-relevant keywords to find existing notes
+3. Use this knowledge to inform your plan
+
 **Project Request:** ${description}
 
 **Step 1:** Read \`.phi/plans/brief-*.md\` (created by the explore phase)
@@ -604,13 +614,20 @@ After your analysis, use \`ontology_add\` to save key project entities (files, m
 ## Task 2: [Task Title] [agent-type]
 - [ ] Implementation details
 - Dependencies: Task 1
-\`\`\``,
+\`\`\`
+
+Before finishing, use \`memory_write\` to save your plan summary with relevant tags for future reference.`,
 			},
 			{
 				key: "code", label: "💻 Phase 3 — CODE", model: code.preferred, fallback: code.fallback,
 				agent: loadAgentDef("code"),
 				instruction: `You are the CODE agent. Implement the complete project.
 
+**Context Retrieval:**
+1. Use \`memory_search\` with project keywords to find notes from previous phases
+2. Use \`ontology_query\` to understand the project structure and dependencies
+3. Use this context to guide implementation
+
 **Project Request:** ${description}
 
 **Step 1:** Read \`.phi/plans/brief-*.md\` for project context
@@ -639,13 +656,25 @@ After your analysis, use \`ontology_add\` to save key project entities (files, m
 
 ## Implementation Notes
 [Any important decisions or changes made]
-\`\`\``,
+\`\`\`
+
+After implementation, use \`memory_write\` to save a summary of what was built, patterns used, and any issues encountered.
+
+**CRITICAL RULES:**
+- Write ONE file per tool call — NEVER combine multiple files in a single response
+- Keep each file under 500 lines. If longer, split into modules
+- After writing each file, verify it exists with \`ls\` before proceeding`,
 			},
 			{
 				key: "test", label: "🧪 Phase 4 — TEST", model: test.preferred, fallback: test.fallback,
 				agent: loadAgentDef("test"),
 				instruction: `You are the TEST agent. Verify the implementation.
 
+**Context Retrieval:**
+1. Use \`memory_search\` to find implementation notes from the CODE phase
+2. Use \`ontology_query\` to understand the project architecture
+3. Use this context to focus your testing
+
 **Project Request:** ${description}
 
 **Step 1:** Read \`.phi/plans/todo-*.md\` to know what was planned
@@ -677,13 +706,20 @@ After your analysis, use \`ontology_add\` to save key project entities (files, m
 **CRITICAL RULES:**
 - NEVER run a server with \`&\` without cleanup. Always use: \`timeout 15 bash -c 'node src/index.js & PID=$!; sleep 2; curl ...; kill $PID'\`
 - ALWAYS kill background processes after testing
-- If a test hangs, use \`timeout\` to prevent deadlock`,
+- If a test hangs, use \`timeout\` to prevent deadlock
+
+After testing, use \`memory_write\` to save test results, bugs found, and lessons learned.`,
 			},
 			{
 				key: "review", label: "🔍 Phase 5 — REVIEW", model: review.preferred, fallback: review.fallback,
 				agent: loadAgentDef("review"),
 				instruction: `You are the REVIEW agent. Final quality review.
 
+**Context Retrieval:**
+1. Use \`memory_search\` to find all notes from previous phases (explore, plan, code, test)
+2. Use \`ontology_query\` to understand the full project architecture
+3. Review all \`.phi/plans/*.md\` files for complete context
+
 **Project Request:** ${description}
 
 **Step 1:** Read all \`.phi/plans/*.md\` files
@@ -723,7 +759,11 @@ After your analysis, use \`ontology_add\` to save key project entities (files, m
 ✅ Project ready for production / ❌ Issues need resolution
 \`\`\`
 
-After your review, use \`memory_write\` to save key lessons learned, patterns found, and important decisions for future reference.`,
+After your review, use \`memory_write\` to save:
+- Key lessons learned about this project type
+- Patterns that worked well
+- Common mistakes to avoid in future projects
+Tag the note with relevant keywords for vector search.`,
 			},
 		];
 	}

package/package.json

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