@phi-code-admin/phi-code 0.57.7 → 0.57.9

package/extensions/phi/skill-loader.ts

@@ -1,335 +1,118 @@
 /**
  * Skill Loader Extension - Dynamic skill loading and context injection
  *
- * Automatically discovers and loads skills from ~/.phi/agent/skills/ and .phi/skills/
- * directories. Skills are folders containing SKILL.md files with specialized knowledge
- * or procedures. When skill-related keywords are detected in user input, the skill
- * content is automatically injected into the conversation context.
+ * Uses sigma-skills SkillScanner and SkillLoader for skill discovery and matching.
+ * Skills are folders containing SKILL.md files with specialized knowledge.
+ * When skill-related keywords are detected in user input, the model is notified
+ * and can load the full skill content via the `read` tool.
+ *
+ * Discovery locations (in priority order):
+ * 1. .phi/skills/ (project-local, highest priority)
+ * 2. ~/.phi/agent/skills/ (global user skills)
+ * 3. Bundled skills shipped with the package (lowest priority)
  *
  * Features:
  * - Automatic skill discovery at startup
  * - Keyword-based skill detection and loading
  * - /skills command to list available skills
- * - Contextual skill injection via ui notifications
- *
- * Usage:
- * 1. Copy to packages/coding-agent/extensions/phi/skill-loader.ts
- * 2. Create skill directories with SKILL.md files
- * 3. Skills auto-load when relevant keywords are detected
+ * - Contextual skill notification via ui.notify
  */
 
 import type { ExtensionAPI, ExtensionContext } from "phi-code";
-import { readdir, readFile, access, stat } from "node:fs/promises";
+import { SkillScanner, SkillLoader } from "sigma-skills";
+import type { SkillsConfig } from "sigma-skills";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
-interface Skill {
-	name: string;
-	path: string;
-	content: string;
-	keywords: string[];
-	description: string;
-	source: "global" | "local";
-}
-
 export default function skillLoaderExtension(pi: ExtensionAPI) {
-	let availableSkills: Skill[] = [];
-	const globalSkillsDir = join(homedir(), ".phi", "agent", "skills");
-	const localSkillsDir = join(process.cwd(), ".phi", "skills");
-
-	/**
-	 * Extract keywords and description from SKILL.md content
-	 */
-	function parseSkillContent(content: string): { keywords: string[]; description: string } {
-		const lines = content.split('\n');
-		const keywords: string[] = [];
-		let description = "";
+	const config: SkillsConfig = {
+		globalDir: join(homedir(), ".phi", "agent", "skills"),
+		projectDir: join(process.cwd(), ".phi", "skills"),
+		bundledDir: join(__dirname, "..", "..", "..", "skills"),
+		autoInject: true,
+	};
 
-		// Look for keywords in frontmatter or explicit sections
-		let inFrontmatter = false;
-		let foundKeywords = false;
+	const scanner = new SkillScanner(config);
+	const loader = new SkillLoader(scanner);
 
-		for (const line of lines) {
-			const trimmed = line.trim();
-
-			// YAML frontmatter
-			if (trimmed === '---') {
-				inFrontmatter = !inFrontmatter;
-				continue;
-			}
-
-			if (inFrontmatter) {
-				if (trimmed.startsWith('keywords:') || trimmed.startsWith('tags:')) {
-					const keywordLine = trimmed.split(':')[1];
-					if (keywordLine) {
-						// Parse YAML array or comma-separated
-						const parsed = keywordLine
-							.replace(/[\[\]]/g, '')
-							.split(',')
-							.map(k => k.trim().toLowerCase())
-							.filter(k => k.length > 0);
-						keywords.push(...parsed);
-						foundKeywords = true;
-					}
-				}
-				if (trimmed.startsWith('description:')) {
-					description = trimmed.split(':', 2)[1]?.trim() || "";
-				}
-				continue;
-			}
-
-			// Look for explicit keywords section
-			if (trimmed.toLowerCase().includes('keywords:') || trimmed.toLowerCase().includes('tags:')) {
-				const keywordText = trimmed.split(':')[1];
-				if (keywordText) {
-					const parsed = keywordText
-						.split(',')
-						.map(k => k.trim().toLowerCase())
-						.filter(k => k.length > 0);
-					keywords.push(...parsed);
-					foundKeywords = true;
-				}
-				continue;
-			}
-
-			// Use first heading as description if none found
-			if (!description && trimmed.startsWith('#')) {
-				description = trimmed.replace(/^#+\s*/, '').trim();
-			}
-		}
-
-		// If no explicit keywords, derive from content
-		if (!foundKeywords) {
-			const contentLower = content.toLowerCase();
-			const commonKeywords = [
-				'docker', 'kubernetes', 'aws', 'azure', 'gcp', 'terraform',
-				'python', 'javascript', 'typescript', 'react', 'node',
-				'git', 'github', 'gitlab', 'ci/cd', 'devops',
-				'database', 'postgresql', 'mysql', 'mongodb', 'redis',
-				'api', 'rest', 'graphql', 'microservices',
-				'security', 'auth', 'oauth', 'jwt',
-				'test', 'testing', 'unit', 'integration',
-				'deploy', 'deployment', 'production'
-			];
-
-			for (const keyword of commonKeywords) {
-				if (contentLower.includes(keyword)) {
-					keywords.push(keyword);
-				}
-			}
-
-			// Also include skill directory name as keyword
-			const skillName = description.toLowerCase().replace(/\s+/g, '-');
-			if (skillName) keywords.push(skillName);
-		}
-
-		return { keywords, description };
-	}
-
-	/**
-	 * Load skills from a directory
-	 */
-	async function loadSkillsFromDirectory(directory: string, source: "global" | "local"): Promise<Skill[]> {
-		const skills: Skill[] = [];
-
-		try {
-			await access(directory);
-			const entries = await readdir(directory);
-
-			for (const entry of entries) {
-				const skillPath = join(directory, entry);
-				
-				try {
-					const skillStat = await stat(skillPath);
-					if (!skillStat.isDirectory()) continue;
-
-					const skillFilePath = join(skillPath, "SKILL.md");
-					
-					try {
-						await access(skillFilePath);
-						const content = await readFile(skillFilePath, 'utf-8');
-						const { keywords, description } = parseSkillContent(content);
-
-						skills.push({
-							name: entry,
-							path: skillPath,
-							content,
-							keywords,
-							description: description || entry,
-							source
-						});
-
-					} catch {
-						// No SKILL.md file, skip this directory
-					}
-				} catch {
-					// Can't access directory, skip
-				}
-			}
-		} catch {
-			// Directory doesn't exist, return empty array
-		}
+	// ─── Input Event: Match skills to user input ─────────────────────
 
-		return skills;
-	}
-
-	/**
-	 * Load all available skills
-	 */
-	async function loadAllSkills(): Promise<void> {
-		const globalSkills = await loadSkillsFromDirectory(globalSkillsDir, "global");
-		const localSkills = await loadSkillsFromDirectory(localSkillsDir, "local");
-		
-		availableSkills = [...globalSkills, ...localSkills];
-		
-		console.log(`Loaded ${availableSkills.length} skills (${globalSkills.length} global, ${localSkills.length} local)`);
-	}
-
-	/**
-	 * Find relevant skills for input text
-	 */
-	function findRelevantSkills(text: string): Skill[] {
-		const textLower = text.toLowerCase();
-		const relevantSkills: Array<{ skill: Skill; matchCount: number }> = [];
-
-		for (const skill of availableSkills) {
-			let matches = 0;
-			
-			// Check for keyword matches
-			for (const keyword of skill.keywords) {
-				if (textLower.includes(keyword)) {
-					matches++;
-				}
-			}
-
-			// Check for skill name match
-			if (textLower.includes(skill.name.toLowerCase())) {
-				matches += 2; // Name match gets higher weight
-			}
-
-			if (matches > 0) {
-				relevantSkills.push({ skill, matchCount: matches });
-			}
-		}
-
-		// Sort by match count (most relevant first) and return top 3
-		return relevantSkills
-			.sort((a, b) => b.matchCount - a.matchCount)
-			.slice(0, 3)
-			.map(item => item.skill);
-	}
-
-	/**
-	 * Input interceptor for skill detection
-	 */
 	pi.on("input", async (event, ctx) => {
-		// Skip if this is an extension-generated message
 		if (event.source === "extension") {
 			return { action: "continue" };
 		}
 
-		// Find relevant skills
-		const relevantSkills = findRelevantSkills(event.text);
+		const matches = loader.findRelevantSkills(event.text);
 
-		if (relevantSkills.length > 0) {
-			// Inject skill content into context
-			for (const skill of relevantSkills) {
-				const skillMessage = `Skill Context: ${skill.name}
-
-${skill.content}
-
----
-This skill was automatically loaded based on your request. Use this knowledge to assist with the task.`;
-
-				// Notify the model about the relevant skill content
-				// The model can then use the `read` tool to load the full SKILL.md
-				ctx.ui.notify(`📚 Relevant skill loaded: **${skill.name}**\n${skill.description}\nUse \`read ${skill.path}\` for full content.`, "info");
+		if (matches.length > 0) {
+			// Notify about top matches (max 3)
+			const topMatches = matches.slice(0, 3);
+			for (const match of topMatches) {
+				ctx.ui.notify(
+					`📚 Relevant skill: **${match.skill.name}** — ${match.skill.description}\nUse \`read ${match.skill.path}/SKILL.md\` for full content.`,
+					"info"
+				);
 			}
 
-			// Notify user which skills were loaded
-			const skillNames = relevantSkills.map(s => s.name).join(", ");
-			ctx.ui.notify(`🧠 Loaded ${relevantSkills.length} skill(s): ${skillNames}`, "info");
+			const skillNames = topMatches.map(m => m.skill.name).join(", ");
+			ctx.ui.notify(`🧠 Loaded ${topMatches.length} skill(s): ${skillNames}`, "info");
 		}
 
 		return { action: "continue" };
 	});
 
-	/**
-	 * /skills command - List available skills
-	 */
+	// ─── /skills Command ─────────────────────────────────────────────
+
 	pi.registerCommand("skills", {
-		description: "List available skills or show skill details",
-		getArgumentCompletions: (prefix) => {
-			const skillNames = availableSkills.map(s => s.name);
-			const filtered = skillNames.filter(name => name.toLowerCase().startsWith(prefix.toLowerCase()));
-			return filtered.length > 0 ? filtered.map(name => ({ value: name, label: name })) : null;
-		},
+		description: "List available skills or show details for a specific skill",
 		handler: async (args, ctx) => {
-			const skillName = args.trim();
+			const query = args.trim();
 
-			if (!skillName) {
+			if (!query) {
 				// List all skills
-				if (availableSkills.length === 0) {
-					ctx.ui.notify("No skills found. Create skill directories with SKILL.md files in:\n- ~/.phi/agent/skills/\n- .phi/skills/", "info");
+				const skills = loader.listSkills();
+
+				if (skills.length === 0) {
+					ctx.ui.notify(
+						"No skills found. Create skill directories with SKILL.md files in:\n" +
+						`- \`${config.projectDir}\` (project-local)\n` +
+						`- \`${config.globalDir}\` (global)\n` +
+						"Or install bundled skills via `/phi-init`.",
+						"info"
+					);
 					return;
 				}
 
-				let message = `🧠 **Available Skills** (${availableSkills.length})\n\n`;
-
-				// Group by source
-				const globalSkills = availableSkills.filter(s => s.source === "global");
-				const localSkills = availableSkills.filter(s => s.source === "local");
-
-				if (globalSkills.length > 0) {
-					message += "**Global Skills:**\n";
-					globalSkills.forEach(skill => {
-						const keywords = skill.keywords.slice(0, 3).join(", ");
-						message += `- **${skill.name}** - ${skill.description}\n`;
-						message += `  Keywords: ${keywords}\n\n`;
-					});
-				}
-
-				if (localSkills.length > 0) {
-					message += "**Project Skills:**\n";
-					localSkills.forEach(skill => {
-						const keywords = skill.keywords.slice(0, 3).join(", ");
-						message += `- **${skill.name}** - ${skill.description}\n`;
-						message += `  Keywords: ${keywords}\n\n`;
-					});
+				let message = `**📚 Available Skills (${skills.length}):**\n\n`;
+				for (const skill of skills) {
+					message += `  **${skill.name}** — ${skill.description}\n`;
+					message += `    📁 \`${skill.path}\`\n`;
 				}
-
-				message += "\nUse `/skills <name>` to view a specific skill.";
-
+				message += `\nUse \`/skills <name>\` for details.`;
 				ctx.ui.notify(message, "info");
-
 			} else {
 				// Show specific skill
-				const skill = availableSkills.find(s => s.name.toLowerCase() === skillName.toLowerCase());
-				
-				if (!skill) {
-					ctx.ui.notify(`Skill "${skillName}" not found. Use /skills to list available skills.`, "warning");
-					return;
+				const content = loader.getSkillContext(query);
+				if (content) {
+					const skill = loader.listSkills().find(s => s.name === query);
+					ctx.ui.notify(
+						`**📚 Skill: ${query}**\n\n` +
+						`Path: \`${skill?.path || "unknown"}\`\n` +
+						`Keywords: ${skill?.keywords.slice(0, 10).join(", ") || "none"}\n\n` +
+						`---\n\n${content.slice(0, 2000)}${content.length > 2000 ? "\n\n... (truncated, use `read` for full content)" : ""}`,
+						"info"
+					);
+				} else {
+					ctx.ui.notify(`Skill "${query}" not found. Use \`/skills\` to list available skills.`, "warning");
 				}
-
-				const message = `🧠 **Skill: ${skill.name}**
-
-**Description:** ${skill.description}
-**Source:** ${skill.source}
-**Path:** ${skill.path}
-**Keywords:** ${skill.keywords.join(", ")}
-
-**Content Preview:**
-${skill.content.slice(0, 500)}${skill.content.length > 500 ? "..." : ""}`;
-
-				ctx.ui.notify(message, "info");
 			}
 		},
 	});
 
-	/**
-	 * Load skills on session start
-	 */
+	// ─── Session Start: Load skills ──────────────────────────────────
+
 	pi.on("session_start", async (_event, _ctx) => {
-		await loadAllSkills();
+		const skills = loader.listSkills();
+		console.log(`[skill-loader] Loaded ${skills.length} skills from 3 locations`);
 	});
-}
+}

package/extensions/phi/smart-router.ts

@@ -1,105 +1,35 @@
 /**
  * Smart Router Extension - Intelligent model routing for different task types
  *
- * Analyzes user input keywords and suggests the optimal model:
- * - code: implement, create, build, refactor → qwen3-coder-plus
- * - debug: fix, bug, error, crash → qwen3-max-2026-01-23
- * - explore: read, analyze, explain, understand → kimi-k2.5
- * - plan: plan, design, architect, spec → qwen3-max-2026-01-23
- * - test: test, verify, validate, check → kimi-k2.5
- * - review: review, audit, quality, security → qwen3.5-plus
+ * Uses sigma-agents SmartRouter for task classification and model recommendation.
+ * Analyzes user input keywords and suggests the optimal model per task category.
  *
- * Configuration: ~/.phi/agent/routing.json (same format as config/routing.json)
+ * Configuration: ~/.phi/agent/routing.json
  * Command: /routing — show config, enable/disable, test, reload
  */
 
 import type { ExtensionAPI } from "phi-code";
+import { SmartRouter } from "sigma-agents";
+import type { RoutingConfig, TaskCategory } from "sigma-agents";
 import { readFile, mkdir, writeFile, access } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
-// ─── Types ───────────────────────────────────────────────────────────────
+// ─── Extension Config ────────────────────────────────────────────────────
 
-interface RouteEntry {
-	description: string;
-	keywords: string[];
-	preferredModel: string;
-	fallback: string;
-	agent: string;
-}
-
-interface RoutingConfig {
-	routes: Record<string, RouteEntry>;
-	default: { model: string; agent: string | null };
-}
-
-interface FullConfig {
-	routing: RoutingConfig;
+interface ExtensionConfig {
 	enabled: boolean;
 	notifyOnRecommendation: boolean;
 }
 
-// ─── Defaults (aligned with config/routing.json and default-models.json) ──
-
-const DEFAULT_ROUTING: RoutingConfig = {
-	routes: {
-		code: {
-			description: "Code generation, implementation, refactoring",
-			keywords: ["implement", "create", "build", "refactor", "write", "add", "modify", "update", "generate", "code", "develop", "function", "class"],
-			preferredModel: "qwen3-coder-plus",
-			fallback: "qwen3.5-plus",
-			agent: "code",
-		},
-		debug: {
-			description: "Debugging, fixing, error resolution",
-			keywords: ["fix", "bug", "error", "debug", "crash", "broken", "failing", "issue", "troubleshoot", "repair", "solve"],
-			preferredModel: "qwen3-max-2026-01-23",
-			fallback: "qwen3.5-plus",
-			agent: "code",
-		},
-		explore: {
-			description: "Code reading, analysis, understanding",
-			keywords: ["read", "analyze", "explain", "understand", "find", "search", "look", "show", "what", "how", "explore", "examine"],
-			preferredModel: "kimi-k2.5",
-			fallback: "glm-4.7",
-			agent: "explore",
-		},
-		plan: {
-			description: "Architecture, design, planning",
-			keywords: ["plan", "design", "architect", "spec", "structure", "organize", "strategy", "approach", "roadmap"],
-			preferredModel: "qwen3-max-2026-01-23",
-			fallback: "qwen3.5-plus",
-			agent: "plan",
-		},
-		test: {
-			description: "Testing, validation, verification",
-			keywords: ["test", "verify", "validate", "check", "assert", "coverage", "unit", "integration", "e2e"],
-			preferredModel: "kimi-k2.5",
-			fallback: "glm-4.7",
-			agent: "test",
-		},
-		review: {
-			description: "Code review, quality assessment",
-			keywords: ["review", "audit", "quality", "security", "improve", "optimize", "refine", "critique"],
-			preferredModel: "qwen3.5-plus",
-			fallback: "qwen3-max-2026-01-23",
-			agent: "review",
-		},
-	},
-	default: {
-		model: "qwen3.5-plus",
-		agent: null,
-	},
-};
-
 // ─── Extension ───────────────────────────────────────────────────────────
 
 export default function smartRouterExtension(pi: ExtensionAPI) {
 	const configDir = join(homedir(), ".phi", "agent");
 	const configPath = join(configDir, "routing.json");
 
-	let config: FullConfig = {
-		routing: DEFAULT_ROUTING,
+	let router = new SmartRouter(SmartRouter.defaultConfig());
+	let extConfig: ExtensionConfig = {
 		enabled: true,
 		notifyOnRecommendation: true,
 	};
@@ -109,99 +39,54 @@ export default function smartRouterExtension(pi: ExtensionAPI) {
 	 */
 	async function loadConfig() {
 		try {
-			await access(configPath);
-			const text = await readFile(configPath, "utf-8");
-			const userConfig = JSON.parse(text);
-
-			// Support both flat format (routes at top level) and wrapped format
-			if (userConfig.routes) {
-				config.routing = {
-					routes: { ...DEFAULT_ROUTING.routes, ...userConfig.routes },
-					default: userConfig.default || DEFAULT_ROUTING.default,
-				};
-			}
-
-			if (typeof userConfig.enabled === "boolean") config.enabled = userConfig.enabled;
-			if (typeof userConfig.notifyOnRecommendation === "boolean") config.notifyOnRecommendation = userConfig.notifyOnRecommendation;
+			const config = await SmartRouter.loadConfig(configPath);
+			router = new SmartRouter(config);
 		} catch {
 			// No config file — use defaults, and save them for reference
 			try {
 				await mkdir(configDir, { recursive: true });
-				await writeFile(configPath, JSON.stringify(DEFAULT_ROUTING, null, 2), "utf-8");
+				const defaultConfig = SmartRouter.defaultConfig();
+				await writeFile(configPath, JSON.stringify(defaultConfig, null, 2), "utf-8");
 			} catch {
 				// Can't write, that's fine
 			}
 		}
 	}
 
-	/**
-	 * Analyze input text to classify task type
-	 */
-	function classifyTask(text: string): { category: string | null; confidence: number; matches: string[]; route: RouteEntry | null } {
-		const lower = text.toLowerCase();
-		const results: Array<{ category: string; confidence: number; matches: string[]; route: RouteEntry }> = [];
-
-		for (const [category, route] of Object.entries(config.routing.routes)) {
-			const matches: string[] = [];
-
-			for (const keyword of route.keywords) {
-				if (lower.includes(keyword.toLowerCase())) {
-					matches.push(keyword);
-				}
-			}
-
-			if (matches.length > 0) {
-				// Confidence = weighted match ratio
-				// More matches = higher confidence, but cap at 95%
-				const ratio = matches.length / route.keywords.length;
-				const confidence = Math.min(95, Math.round(ratio * 100 + matches.length * 5));
-				results.push({ category, confidence, matches, route });
-			}
-		}
-
-		if (results.length === 0) {
-			return { category: null, confidence: 0, matches: [], route: null };
-		}
-
-		// Highest confidence wins
-		results.sort((a, b) => b.confidence - a.confidence);
-		return results[0];
-	}
-
-	// ─── Input Event ─────────────────────────────────────────────────
-
 	/**
 	 * Resolve a model name to an available model.
 	 * If the preferred model exists in the registry, use it.
 	 * Otherwise, fall back to the current model.
 	 */
 	function resolveModel(preferredModel: string, ctx: any): string {
-		// Check if model exists in registry
 		try {
 			const available = ctx.modelRegistry?.getAvailable?.() || [];
 			if (available.some((m: any) => m.id === preferredModel)) {
 				return preferredModel;
 			}
-			// Model not available — use current model
 			return ctx.model?.id || preferredModel;
 		} catch {
 			return ctx.model?.id || preferredModel;
 		}
 	}
 
+	// ─── Input Event ─────────────────────────────────────────────────
+
 	pi.on("input", async (event, ctx) => {
-		if (!config.enabled || event.source === "extension") {
+		if (!extConfig.enabled || event.source === "extension") {
 			return { action: "continue" };
 		}
 
-		const result = classifyTask(event.text);
+		const recommendation = router.getRecommendation(event.text);
 
-		if (result.category && result.confidence >= 25 && result.route) {
-			if (config.notifyOnRecommendation) {
-				const resolved = resolveModel(result.route.preferredModel, ctx);
-				const suffix = resolved !== result.route.preferredModel ? ` (→ ${resolved})` : "";
+		if (recommendation.category !== "general") {
+			if (extConfig.notifyOnRecommendation) {
+				const resolved = resolveModel(recommendation.model, ctx);
+				const suffix = resolved !== recommendation.model ? ` (→ ${resolved})` : "";
+				const route = (router as any).config?.routes?.[recommendation.category];
+				const desc = route?.keywords?.slice(0, 3)?.join(", ") || recommendation.category;
 				ctx.ui.notify(
-					`🔀 ${result.route.description} → \`${result.route.preferredModel}\`${suffix} (${result.confidence}% | ${result.matches.join(", ")})`,
+					`🔀 ${recommendation.category} → \`${recommendation.model}\`${suffix} (${desc})`,
 					"info"
 				);
 			}
@@ -218,17 +103,17 @@ export default function smartRouterExtension(pi: ExtensionAPI) {
 			const arg = args.trim().toLowerCase();
 
 			if (!arg) {
-				// Show current config
-				let output = `**🔀 Smart Router**\n\n`;
-				output += `Status: ${config.enabled ? "✅ Enabled" : "❌ Disabled"}\n`;
-				output += `Notifications: ${config.notifyOnRecommendation ? "On" : "Off"}\n\n`;
+				const routingConfig = (router as any).config as RoutingConfig;
+				let output = `**🔀 Smart Router** (powered by sigma-agents)\n\n`;
+				output += `Status: ${extConfig.enabled ? "✅ Enabled" : "❌ Disabled"}\n`;
+				output += `Notifications: ${extConfig.notifyOnRecommendation ? "On" : "Off"}\n\n`;
 
 				output += `**Routes:**\n`;
-				for (const [cat, route] of Object.entries(config.routing.routes)) {
-					output += `  **${cat}** → \`${route.preferredModel}\` (fallback: \`${route.fallback}\`) [agent: ${route.agent}]\n`;
+				for (const [cat, route] of Object.entries(routingConfig.routes)) {
+					output += `  **${cat}** → \`${route.preferredModel}\` (fallback: \`${route.fallback}\`) [agent: ${route.agent || "none"}]\n`;
 					output += `    Keywords: ${route.keywords.slice(0, 6).join(", ")}${route.keywords.length > 6 ? "..." : ""}\n`;
 				}
-				output += `\n  **default** → \`${config.routing.default.model}\`\n`;
+				output += `\n  **default** → \`${routingConfig.default.model}\`\n`;
 
 				output += `\nConfig: \`${configPath}\``;
 				output += `\nCommands: \`/routing enable|disable|notify-on|notify-off|reload|test\``;
@@ -239,19 +124,19 @@ export default function smartRouterExtension(pi: ExtensionAPI) {
 
 			switch (arg) {
 				case "enable":
-					config.enabled = true;
+					extConfig.enabled = true;
 					ctx.ui.notify("✅ Smart routing enabled.", "info");
 					break;
 				case "disable":
-					config.enabled = false;
+					extConfig.enabled = false;
 					ctx.ui.notify("❌ Smart routing disabled.", "info");
 					break;
 				case "notify-on":
-					config.notifyOnRecommendation = true;
+					extConfig.notifyOnRecommendation = true;
 					ctx.ui.notify("🔔 Routing notifications enabled.", "info");
 					break;
 				case "notify-off":
-					config.notifyOnRecommendation = false;
+					extConfig.notifyOnRecommendation = false;
 					ctx.ui.notify("🔕 Routing notifications disabled.", "info");
 					break;
 				case "reload":
@@ -271,10 +156,8 @@ export default function smartRouterExtension(pi: ExtensionAPI) {
 
 					let output = "**🧪 Routing Test:**\n\n";
 					for (const input of tests) {
-						const result = classifyTask(input);
-						const model = result.route?.preferredModel || config.routing.default.model;
-						const tag = result.category || "default";
-						output += `"${input}"\n  → **${tag}** (${result.confidence}%) → \`${model}\`\n\n`;
+						const rec = router.getRecommendation(input);
+						output += `"${input}"\n  → **${rec.category}** → \`${rec.model}\`\n\n`;
 					}
 					ctx.ui.notify(output, "info");
 					break;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.57.7",
+	"version": "0.57.9",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -43,10 +43,6 @@
 	},
 	"dependencies": {
 		"@mariozechner/jiti": "^2.6.2",
-		"phi-code-agent": "^0.56.3",
-		"phi-code-ai": "^0.56.3",
-		"phi-code-tui": "^0.56.3",
-		"sigma-memory": "^0.1.0",
 		"@silvia-odwyer/photon-node": "^0.3.4",
 		"chalk": "^5.5.0",
 		"cli-highlight": "^2.1.11",
@@ -58,7 +54,13 @@
 		"ignore": "^7.0.5",
 		"marked": "^15.0.12",
 		"minimatch": "^10.2.3",
+		"phi-code-agent": "^0.56.3",
+		"phi-code-ai": "^0.56.3",
+		"phi-code-tui": "^0.56.3",
 		"proper-lockfile": "^4.1.2",
+		"sigma-agents": "^0.1.1",
+		"sigma-memory": "^0.1.0",
+		"sigma-skills": "^0.1.0",
 		"strip-ansi": "^7.1.0",
 		"undici": "^7.19.1",
 		"yaml": "^2.8.2"