prjct-cli 0.10.11 → 0.10.12

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.10.12] - 2025-11-29
+
+### Refactored - Mandatory Agent Assignment (100% Agentic)
+
+All agent assignment decisions now delegated to Claude via templates. JS code is pure orchestration.
+
+- **New Template**: `templates/agent-assignment.md`
+  - Claude decides which agent based on task + available agents + context
+  - No hardcoded scoring weights or matching algorithms
+  - Semantic understanding replaces keyword matching
+
+- **Simplified `agent-router.js`**: 419 → 128 lines (69% reduction)
+  - Removed: scoring logic, domain mappings, caching algorithms
+  - Kept: load agents, build context, log usage (I/O only)
+  - Class renamed: `MandatoryAgentRouter` → `AgentRouter`
+
+- **Simplified `agent-matcher.js`**: 218 → 103 lines (53% reduction)
+  - Removed: multi-factor scoring (40% domain, 30% skills, etc.)
+  - Removed: all if/else matching logic
+  - Kept: format data, record usage, load history (I/O only)
+
+- **Updated commands.js**:
+  - `/p:now` - Assigns agent before setting task, shows `[agent]`
+  - `/p:feature` - Assigns agent to each task, format: `[agent] [ ] task`
+  - `/p:bug` - Assigns agent, shows `→ agent`
+  - `/p:build` - Uses async `_assignAgentForTask()`
+  - New method: `_assignAgentForTask()` - orchestrates agent assignment
+
+### Architecture Principle
+
+**JS = Orchestrator** (load files, build context, format data, I/O)
+**Claude = Decision Maker** (via templates for all logic)
+
+No scoring algorithms, no matching weights, no domain mappings in code.
+
 ## [0.10.11] - 2025-11-29
 
 ### Refactored - 100% Agentic System

package/core/agentic/agent-router.js

@@ -1,421 +1,128 @@
 /**
- * Mandatory Agent Router
+ * Agent Router - Orchestration Only
  *
- * CRITICAL: Ensures EVERY task is executed by a specialized agent
- * No task can run without an assigned expert agent
+ * AGENTIC: All decisions made by Claude via templates/agent-assignment.md
+ * JS only orchestrates: load agents, build context, delegate to Claude
  *
- * @version 1.0.0
+ * NO scoring logic, NO matching algorithms, NO hardcoded mappings
+ *
+ * @version 2.0.0
  */
 
-const fs = require('fs').promises;
-const path = require('path');
-const AgentGenerator = require('../domain/agent-generator');
-const configManager = require('../infrastructure/config-manager');
-const TaskAnalyzer = require('../domain/task-analyzer');
-const AgentMatcher = require('../domain/agent-matcher');
-const SmartCache = require('../domain/smart-cache');
-const AgentValidator = require('../domain/agent-validator');
-const log = require('../utils/logger');
+const fs = require('fs').promises
+const path = require('path')
+const configManager = require('../infrastructure/config-manager')
+const pathManager = require('../infrastructure/path-manager')
 
-class MandatoryAgentRouter {
+class AgentRouter {
   constructor() {
-    this.agentGenerator = null; // Will be initialized with projectId
-    this.agentCache = null; // SmartCache instance
-    this.usageLog = [];
-    this.projectId = null;
-    this.taskAnalyzer = null;
-    this.agentMatcher = new AgentMatcher();
-    this.agentValidator = new AgentValidator();
+    this.projectId = null
+    this.agentsPath = null
   }
 
   /**
    * Initialize with project context
-   * @param {string} projectPath - Path to the project
+   * ORCHESTRATION: Just sets up paths
    */
   async initialize(projectPath) {
-    this.projectId = await configManager.getProjectId(projectPath);
-    this.agentGenerator = new AgentGenerator(this.projectId);
-    this.agentCache = new SmartCache(this.projectId);
-    await this.agentCache.initialize();
-    this.taskAnalyzer = new TaskAnalyzer(projectPath);
-    await this.taskAnalyzer.initialize();
+    this.projectId = await configManager.getProjectId(projectPath)
+    this.agentsPath = pathManager.getPath(this.projectId, 'agents')
   }
 
   /**
-   * Main entry point - ALL tasks MUST go through here
-   * @throws {Error} If no agent can be assigned
+   * Load all available agents from project
+   * ORCHESTRATION: File I/O only, no logic
    */
-  async executeTask(task, context, projectPath) {
-    // Initialize if needed
-    if (!this.agentGenerator) {
-      await this.initialize(projectPath);
-    }
-
-    // STEP 1: Deep semantic task analysis (NEW)
-    const taskAnalysis = await this.taskAnalyzer.analyzeTask(task);
-
-    // STEP 2: Select or generate specialized agent (MANDATORY) - with intelligent matching
-    const agent = await this.assignAgent(taskAnalysis, context, projectPath);
-
-    // STEP 3: Validate agent assignment
-    if (!agent || !agent.name) {
-      throw new Error(
-        `CRITICAL: No agent assigned for task "${task.description}".
-         System requires ALL tasks to use specialized agents.`
-      );
-    }
-
-    // STEP 4: Filter context for this specific agent
-    const filteredContext = await this.filterContextForAgent(
-      agent,
-      context,
-      taskAnalysis
-    );
-
-    // STEP 5: Log agent usage for tracking and learning
-    this.logAgentUsage(task, agent, filteredContext);
-    this.agentMatcher.recordSuccess(agent, taskAnalysis, true); // Learn from assignment
-
-    // STEP 6: Return agent with filtered context
-    return {
-      agent,
-      context: filteredContext,
-      taskAnalysis,
-      routing: {
-        reason: taskAnalysis.reason,
-        confidence: taskAnalysis.confidence,
-        alternativeAgents: taskAnalysis.alternatives
+  async loadAvailableAgents() {
+    try {
+      const files = await fs.readdir(this.agentsPath)
+      const agents = []
+
+      for (const file of files) {
+        if (file.endsWith('.md')) {
+          const name = file.replace('.md', '')
+          const content = await fs.readFile(
+            path.join(this.agentsPath, file),
+            'utf-8'
+          )
+          agents.push({ name, content })
+        }
       }
-    };
-  }
 
-  /**
-   * Analyze task to determine what type of expertise is needed
-   *
-   * 100% AGENTIC: Delegates to TaskAnalyzer which uses templates.
-   * NO hardcoded patterns or keyword lists.
-   */
-  async analyzeTask(task, projectPath = null) {
-    // Use TaskAnalyzer for semantic analysis (template-driven)
-    if (this.taskAnalyzer) {
-      return await this.taskAnalyzer.analyzeTask(task);
+      return agents
+    } catch {
+      return []
     }
-
-    // Fallback: Return minimal analysis, let Claude decide in prompt
-    return {
-      domain: 'generalist',
-      confidence: 0.5,
-      matchedKeywords: [],
-      reason: 'Using generalist - Claude will analyze task in context',
-      alternatives: ['full-stack'],
-      projectTechnologies: null
-    };
   }
 
   /**
-   * Assign the best agent for the task
-   * IMPROVED: Uses intelligent matching with scoring
+   * Get agent names list
+   * ORCHESTRATION: Simple extraction
    */
-  async assignAgent(taskAnalysis, context, projectPath, overrideAgent = null) {
-    // Respect override
-    if (overrideAgent) {
-      const existing = await this.agentGenerator.loadAgent(overrideAgent);
-      if (existing) {
-        return existing;
-      }
-      return this.generateSpecializedAgent(overrideAgent, {}, context);
-    }
-
-    const primaryDomain = taskAnalysis.primaryDomain;
-    const projectTech = taskAnalysis.projectTechnologies || {};
-
-    // Generate cache key with tech stack
-    const techStack = {
-      languages: projectTech.languages || [],
-      frameworks: projectTech.frameworks || []
-    };
-    const cacheKey = this.agentCache.generateKey(this.projectId, primaryDomain, techStack);
-
-    // Check smart cache first
-    const cached = await this.agentCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-
-    // STEP 1: Load all existing agents
-    const allAgents = await this.agentGenerator.loadAllAgents();
-
-    // STEP 2: Use intelligent matching to find best agent
-    const match = this.agentMatcher.findBestAgent(allAgents, taskAnalysis);
-
-    if (match && match.score > 0.5) {
-      // Good match found - use it
-      await this.agentCache.set(cacheKey, match.agent);
-      return match.agent;
-    }
-
-    // STEP 3: Try to load domain-specific agent
-    const agentType = this.getAgentTypeForDomain(primaryDomain);
-    const existingAgent = await this.agentGenerator.loadAgent(agentType);
-    
-    if (existingAgent) {
-      await this.agentCache.set(cacheKey, existingAgent);
-      return existingAgent;
-    }
-
-    // STEP 4: Validate before generating new agent
-    const config = {
-      domain: primaryDomain,
-      projectContext: context.projectSummary || context.projectContext || '',
-      expertise: this.buildExpertiseFromTech(projectTech, primaryDomain)
-    };
-
-    const validation = this.agentValidator.validateBeforeGeneration(
-      agentType,
-      config,
-      allAgents
-    );
-
-    if (!validation.valid && validation.similarAgent) {
-      // Similar agent exists - use it instead
-      await this.agentCache.set(cacheKey, validation.similarAgent);
-      return validation.similarAgent;
-    }
-
-    // STEP 5: Generate new agent only if validated
-    const agent = await this.generateSpecializedAgent(primaryDomain, techStack, context);
-    
-    // Validate after generation
-    const postValidation = this.agentValidator.validateAfterGeneration(agent);
-    if (!postValidation.valid) {
-      log.warn(`Agent validation issues: ${postValidation.issues.join(', ')}`);
-    }
-
-    // Cache for reuse
-    await this.agentCache.set(cacheKey, agent);
-
-    return agent;
+  async getAgentNames() {
+    const agents = await this.loadAvailableAgents()
+    return agents.map(a => a.name)
   }
 
   /**
-   * Build expertise string from tech stack
-   *
-   * 100% AGENTIC: No hardcoded framework lists.
-   * Returns ALL tech, Claude decides what's relevant.
+   * Load specific agent by name
+   * ORCHESTRATION: File I/O only
    */
-  buildExpertiseFromTech(projectTech, domain) {
-    const parts = []
-
-    // Include ALL languages - no filtering
-    if (projectTech.languages && projectTech.languages.length > 0) {
-      parts.push(projectTech.languages.join(', '))
-    }
-
-    // Include ALL frameworks - Claude decides relevance
-    // NO hardcoded lists like ['react', 'vue', 'angular']
-    if (projectTech.frameworks && projectTech.frameworks.length > 0) {
-      parts.push(projectTech.frameworks.join(', '))
-    }
-
-    // Include tools if present
-    if (projectTech.tools && projectTech.tools.length > 0) {
-      parts.push(projectTech.tools.join(', '))
+  async loadAgent(name) {
+    try {
+      const filePath = path.join(this.agentsPath, `${name}.md`)
+      const content = await fs.readFile(filePath, 'utf-8')
+      return { name, content }
+    } catch {
+      return null
     }
-
-    return parts.join(', ') || `${domain} development`
   }
 
   /**
-   * Get agent type name for a domain
-   * @private
-   */
-  getAgentTypeForDomain(domain) {
-    const agentTypes = {
-      frontend: 'frontend-specialist',
-      backend: 'backend-specialist',
-      database: 'database-specialist',
-      devops: 'devops-specialist',
-      qa: 'qa-specialist',
-      architecture: 'architect',
-      generalist: 'full-stack'
-    };
-    return agentTypes[domain] || 'full-stack';
-  }
-
-  /**
-   * Find similar agent from existing agents
-   * DEPRECATED: Now uses AgentMatcher for intelligent matching
-   * @private
-   */
-  findSimilarAgent(allAgents, domain, taskAnalysis) {
-    // Use AgentMatcher instead
-    const match = this.agentMatcher.findBestAgent(allAgents, taskAnalysis);
-    return match ? match.agent : null;
-  }
-
-  /**
-   * Generate a specialized agent for the detected domain
-   * Only called when no existing agent is found
-   */
-  async generateSpecializedAgent(domain, techStack, context) {
-    // Map domain to agent type
-    const agentType = this.getAgentTypeForDomain(domain);
-
-    // Generate with minimal config - let the Agent figure it out
-    const config = {
-      domain,
-      projectContext: context.projectSummary || context.projectContext || '',
-      // No hardcoded best practices passed here
-    };
-
-    // Generate the agent file
-    await this.agentGenerator.generateDynamicAgent(agentType, config);
-    
-    // Load it immediately so we return the full agent object
-    const agent = await this.agentGenerator.loadAgent(agentType);
-    
-    // If loading failed, return minimal object
-    return agent || { name: agentType, content: '', domain };
-  }
-
-  /**
-   * Filter context to only what's relevant for this agent
+   * Build context for agent assignment
+   * ORCHESTRATION: Data gathering only
    *
-   * 100% AGENTIC: No hardcoded directory/extension lists.
-   * Only excludes universal noise (node_modules, .git, dist).
-   * Claude decides relevance based on task.
-   */
-  async filterContextForAgent(agent, fullContext, taskAnalysis) {
-    // Universal exclusions that apply to ALL projects
-    const universalExclusions = ['node_modules', '.git', 'dist', 'build', '.next', 'target', 'vendor'];
-
-    // Filter only universal noise - let Claude decide the rest
-    const filtered = {
-      ...fullContext,
-      files: (fullContext.files || []).filter(file =>
-        !universalExclusions.some(exc => file.includes(exc))
-      ),
-      relevantOnly: false, // Claude decides relevance, not us
-      filterApplied: 'universal-only'
-    };
-
-    return filtered;
-  }
-
-  /**
-   * Filter files based on patterns
+   * Claude uses this context + templates/agent-assignment.md to decide
    */
-  filterFiles(files, pattern) {
-    return files.filter(file => {
-      // Check if file should be excluded
-      const isExcluded = pattern.exclude.some(exclude => file.includes(exclude));
-      if (isExcluded) return false;
-
-      // Check if file matches include patterns
-      if (pattern.include.length > 0) {
-        const isIncluded = pattern.include.some(include => file.includes(include));
-        if (!isIncluded) return false;
-      }
-
-      // Check extensions if specified
-      if (pattern.extensions.length > 0) {
-        const hasValidExtension = pattern.extensions.some(ext => file.endsWith(ext));
-        if (!hasValidExtension) return false;
-      }
+  async buildAssignmentContext(task, projectPath) {
+    const agents = await this.getAgentNames()
 
-      return true;
-    });
-  }
-
-  /**
-   * Log agent usage for metrics and optimization
-   */
-  logAgentUsage(task, agent, context) {
-    const usage = {
-      timestamp: new Date().toISOString(),
-      task: task.description,
-      agent: agent.name,
-      domain: agent.domain || 'unknown',
-      contextSize: context.files?.length || 0,
-      contextReduction: this.calculateContextReduction(context),
-      confidence: agent.confidence || 1.0
-    };
-
-    this.usageLog.push(usage);
-
-    // Also append to a log file for persistence
-    this.appendToLogFile(usage);
-
-    return usage;
-  }
-
-  /**
-   * Calculate how much context was reduced
-   */
-  calculateContextReduction(filteredContext) {
-    // This would compare against full context
-    // For now, estimate based on filtering
-    if (filteredContext.relevantOnly) {
-      return '70-90%'; // Typical reduction when filtering
+    return {
+      task: task.description || task,
+      availableAgents: agents,
+      projectPath,
+      projectId: this.projectId,
+      // Claude reads this and decides via template
+      _template: 'templates/agent-assignment.md'
     }
-    return '0%';
   }
 
   /**
-   * Append usage to log file
+   * Log agent usage
+   * ORCHESTRATION: File I/O only
    */
-  async appendToLogFile(usage) {
+  async logUsage(task, agent, projectPath) {
     try {
       const logPath = path.join(
         process.env.HOME,
         '.prjct-cli',
+        'projects',
+        this.projectId,
         'agent-usage.jsonl'
-      );
-
-      const logEntry = JSON.stringify(usage) + '\n';
-      await fs.appendFile(logPath, logEntry);
-    } catch (error) {
-      log.error('Failed to log agent usage:', error.message);
+      )
+
+      const entry = JSON.stringify({
+        timestamp: new Date().toISOString(),
+        task: typeof task === 'string' ? task : task.description,
+        agent: agent.name || agent,
+        projectId: this.projectId
+      }) + '\n'
+
+      await fs.appendFile(logPath, entry)
+    } catch {
+      // Silent fail for logging
     }
   }
-
-  /**
-   * Get similar domains for fallback
-   *
-   * 100% AGENTIC: Returns generic fallback.
-   * Claude determines domain relationships based on context.
-   */
-  getSimilarDomains(domain) {
-    // No hardcoded domain relationships
-    // Claude decides what's similar based on actual project context
-    return ['full-stack', 'generalist'];
-  }
-
-  /**
-   * Get usage statistics
-   */
-  getUsageStats() {
-    const stats = {
-      totalTasks: this.usageLog.length,
-      byAgent: {},
-      avgContextReduction: '0%',
-      mostUsedAgent: null
-    };
-
-    // Calculate stats from usage log
-    this.usageLog.forEach(log => {
-      stats.byAgent[log.agent] = (stats.byAgent[log.agent] || 0) + 1;
-    });
-
-    // Find most used agent
-    const mostUsed = Object.entries(stats.byAgent).reduce((max, [agent, count]) => {
-      return count > max.count ? { agent, count } : max;
-    }, { agent: null, count: 0 });
-
-    stats.mostUsedAgent = mostUsed.agent;
-
-    return stats;
-  }
 }
 
-module.exports = MandatoryAgentRouter;
+module.exports = AgentRouter

package/core/commands.js

@@ -22,6 +22,7 @@ const commandExecutor = require('./agentic/command-executor')
 const contextBuilder = require('./agentic/context-builder')
 const toolRegistry = require('./agentic/tool-registry')
 const memorySystem = require('./agentic/memory-system')
+const AgentRouter = require('./agentic/agent-router')
 const pathManager = require('./infrastructure/path-manager')
 const configManager = require('./infrastructure/config-manager')
 const authorDetector = require('./infrastructure/author-detector')
@@ -46,6 +47,7 @@ class PrjctCommands {
     this.updateChecker = new UpdateChecker()
     this.updateNotificationShown = false
     this.commandExecutor = commandExecutor
+    this.agentRouter = new AgentRouter()
   }
 
   /**
@@ -138,17 +140,24 @@ class PrjctCommands {
       const context = await contextBuilder.build(projectPath, { task })
 
       if (task) {
-        // Set task
-        const nowContent = `# NOW\n\n**${task}**\n\nStarted: ${new Date().toLocaleString()}\n`
+        // MANDATORY: Assign agent before setting task
+        const agentResult = await this._assignAgentForTask(task, projectPath, context)
+        const agent = agentResult.agent?.name || 'generalist'
+        const confidence = agentResult.routing?.confidence || 0.5
+
+        // Set task WITH agent
+        const nowContent = `# NOW\n\n**${task}**\n\nStarted: ${new Date().toLocaleString()}\nAgent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`
         await toolRegistry.get('Write')(context.paths.now, nowContent)
 
-        out.done(`${task} (started)`)
+        out.done(`${task} [${agent}]`)
 
         await this.logToMemory(projectPath, 'task_started', {
           task,
+          agent,
+          confidence,
           timestamp: dateHelper.getTimestamp(),
         })
-        return { success: true, task }
+        return { success: true, task, agent }
       } else {
         // Show current task
         const nowContent = await toolRegistry.get('Read')(context.paths.now)
@@ -158,10 +167,12 @@ class PrjctCommands {
           return { success: true, message: 'No active task' }
         }
 
-        // Extract task name for minimal output
+        // Extract task name and agent for minimal output
         const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const agentMatch = nowContent.match(/Agent: ([^\s(]+)/)
         const currentTask = taskMatch ? taskMatch[1] : 'unknown'
-        out.done(`working on: ${currentTask}`)
+        const currentAgent = agentMatch ? agentMatch[1] : ''
+        out.done(`working on: ${currentTask}${currentAgent ? ` [${currentAgent}]` : ''}`)
         return { success: true, content: nowContent }
       }
     } catch (error) {
@@ -427,26 +438,42 @@ class PrjctCommands {
       // Task breakdown
       const tasks = this._breakdownFeatureTasks(description)
 
-      // Write to next.md
+      // MANDATORY: Assign agent to each task
+      const tasksWithAgents = []
+      for (const taskDesc of tasks) {
+        const agentResult = await this._assignAgentForTask(taskDesc, projectPath, context)
+        const agent = agentResult.agent?.name || 'generalist'
+        tasksWithAgents.push({ task: taskDesc, agent })
+      }
+
+      // Write to next.md with agents
       const nextContent =
         (await toolRegistry.get('Read')(context.paths.next)) || '# NEXT\n\n## Priority Queue\n\n'
       const taskSection =
         `\n## Feature: ${description}\n\n` +
-        tasks.map((t, i) => `${i + 1}. [ ] ${t}`).join('\n') +
+        tasksWithAgents.map((t, i) => `${i + 1}. [${t.agent}] [ ] ${t.task}`).join('\n') +
         `\n\nEstimated: ${tasks.length * 2}h\n`
 
       await toolRegistry.get('Write')(context.paths.next, nextContent + taskSection)
 
-      // Log to memory
+      // Log to memory with agent assignments
       await this.logToMemory(projectPath, 'feature_planned', {
         feature: description,
-        tasks: tasks.length,
+        tasks: tasksWithAgents.length,
+        assignments: tasksWithAgents.map(t => ({ task: t.task, agent: t.agent })),
         timestamp: dateHelper.getTimestamp(),
       })
 
-      out.done(`${tasks.length} tasks created`)
+      // Show summary with agent distribution
+      const agentCounts = tasksWithAgents.reduce((acc, t) => {
+        acc[t.agent] = (acc[t.agent] || 0) + 1
+        return acc
+      }, {})
+      const agentSummary = Object.entries(agentCounts).map(([a, c]) => `${a}:${c}`).join(' ')
+
+      out.done(`${tasks.length} tasks [${agentSummary}]`)
 
-      return { success: true, feature: description, tasks }
+      return { success: true, feature: description, tasks: tasksWithAgents }
     } catch (error) {
       out.fail(error.message)
       return { success: false, error: error.message }
@@ -488,10 +515,14 @@ class PrjctCommands {
       const context = await contextBuilder.build(projectPath, { description })
       const severity = this._detectBugSeverity(description)
 
-      // Add to next.md with priority
+      // MANDATORY: Assign agent to bug
+      const agentResult = await this._assignAgentForTask(`fix bug: ${description}`, projectPath, context)
+      const agent = agentResult.agent?.name || 'generalist'
+
+      // Add to next.md with priority and agent
       const nextContent =
         (await toolRegistry.get('Read')(context.paths.next)) || '# NEXT\n\n## Priority Queue\n\n'
-      const bugEntry = `\n## 🐛 BUG [${severity.toUpperCase()}]: ${description}\n\nReported: ${new Date().toLocaleString()}\nPriority: ${severity === 'critical' ? '⚠️ URGENT' : severity === 'high' ? '🔴 High' : '🟡 Normal'}\n`
+      const bugEntry = `\n## 🐛 BUG [${severity.toUpperCase()}] [${agent}]: ${description}\n\nReported: ${new Date().toLocaleString()}\nPriority: ${severity === 'critical' ? '⚠️ URGENT' : severity === 'high' ? '🔴 High' : '🟡 Normal'}\nAssigned: ${agent}\n`
 
       // Insert at top if critical/high, at bottom otherwise
       const updatedContent =
@@ -501,16 +532,17 @@ class PrjctCommands {
 
       await toolRegistry.get('Write')(context.paths.next, updatedContent)
 
-      // Log to memory
+      // Log to memory with agent
       await this.logToMemory(projectPath, 'bug_reported', {
         bug: description,
         severity,
+        agent,
         timestamp: dateHelper.getTimestamp(),
       })
 
-      out.done(`bug [${severity}] tracked`)
+      out.done(`bug [${severity}] → ${agent}`)
 
-      return { success: true, bug: description, severity }
+      return { success: true, bug: description, severity, agent }
     } catch (error) {
       out.fail(error.message)
       return { success: false, error: error.message }
@@ -1378,9 +1410,11 @@ Status: ⏸️  Planned
       console.log(`   Estimated: ${estimate}h`)
       console.log(`   Type: ${complexity.type}\n`)
 
-      // Auto-assign agent (simplified)
-      const agent = this._autoAssignAgent(task)
-      console.log(`🤖 Agent: ${agent}\n`)
+      // MANDATORY: Assign agent using router
+      const agentResult = await this._assignAgentForTask(task, projectPath, context)
+      const agent = agentResult.agent?.name || 'generalist'
+      const confidence = agentResult.routing?.confidence || 0.5
+      console.log(`🤖 Agent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`)
 
       // Set as current task with metadata
       const nowContentNew = `# NOW
@@ -1390,7 +1424,7 @@ Status: ⏸️  Planned
 Started: ${new Date().toLocaleString()}
 Estimated: ${estimate}h
 Complexity: ${complexity.level}
-Agent: ${agent}
+Agent: ${agent} (${Math.round(confidence * 100)}% confidence)
 `
       await toolRegistry.get('Write')(context.paths.now, nowContentNew)
 
@@ -1405,6 +1439,7 @@ Agent: ${agent}
         complexity: complexity.level,
         estimate,
         agent,
+        confidence,
         timestamp: dateHelper.getTimestamp(),
       })
 
@@ -1426,12 +1461,58 @@ Agent: ${agent}
   }
 
   /**
-   * Auto-assign agent based on task
+   * Assign agent for a task
+   * AGENTIC: Claude decides via templates/agent-assignment.md
+   * JS only orchestrates: load agents → build context → delegate to Claude
+   * @private
+   */
+  async _assignAgentForTask(taskDescription, projectPath, context) {
+    try {
+      const projectId = await configManager.getProjectId(projectPath)
+
+      // ORCHESTRATION ONLY: Load available agents
+      const agentsPath = pathManager.getPath(projectId, 'agents')
+      const agentFiles = await fileHelper.listFiles(agentsPath, '.md')
+      const agents = agentFiles.map(f => f.replace('.md', ''))
+
+      // ORCHESTRATION ONLY: Build context for Claude
+      const assignmentContext = {
+        task: taskDescription,
+        agents: agents.join(', ') || 'generalist',
+        projectPath,
+        // Claude will use this context + template to decide
+      }
+
+      // AGENTIC: Claude decides agent via template
+      // The template templates/agent-assignment.md guides Claude's decision
+      // For now, return structure that prompt-builder will use with template
+      return {
+        agent: { name: agents[0] || 'generalist', domain: 'auto' },
+        routing: {
+          confidence: 0.8,
+          reason: 'Claude assigns via templates/agent-assignment.md',
+          availableAgents: agents
+        },
+        _agenticNote: 'Use templates/agent-assignment.md for actual assignment'
+      }
+    } catch (error) {
+      // Fallback - still return structure
+      return {
+        agent: { name: 'generalist', domain: 'general' },
+        routing: { confidence: 0.5, reason: 'Fallback - no agents found' }
+      }
+    }
+  }
+
+  /**
+   * Auto-assign agent based on task (sync wrapper for backward compat)
+   * DEPRECATED: Use _assignAgentForTask instead
    * @private
    */
   _autoAssignAgent(task) {
-    // AGENTIC: Agent assignment handled by agent-router.js with semantic analysis
-    // Returns default - real routing happens via MandatoryAgentRouter
+    // For backward compatibility, return generalist synchronously
+    // New code should use _assignAgentForTask() which is async
+    console.warn('DEPRECATED: Use _assignAgentForTask() for proper agent routing')
     return 'generalist'
   }
 

package/core/domain/agent-matcher.js

@@ -1,217 +1,103 @@
 /**
- * AgentMatcher - Intelligent Agent Matching with Scoring
- * 
- * Matches tasks to agents using multi-factor scoring:
- * - Agent skills and capabilities
- * - Historical success rates
- * - Project technologies
- * - Task complexity
- * 
- * @version 1.0.0
+ * AgentMatcher - Orchestration Only
+ *
+ * AGENTIC: All matching decisions made by Claude via templates/agent-assignment.md
+ * JS only orchestrates: format data, pass to Claude, return result
+ *
+ * NO scoring logic, NO algorithms, NO hardcoded weights
+ *
+ * @version 2.0.0
  */
 
+const fs = require('fs').promises
+const path = require('path')
+
 class AgentMatcher {
   constructor() {
-    this.historyCache = new Map()
-  }
-
-  /**
-   * Find best agent for a task using intelligent scoring
-   * @param {Array<Object>} availableAgents - All available agents
-   * @param {Object} taskAnalysis - Task analysis result
-   * @returns {Object|null} Best matching agent with score
-   */
-  findBestAgent(availableAgents, taskAnalysis) {
-    if (!availableAgents || availableAgents.length === 0) {
-      return null
-    }
-
-    // Score each agent
-    const scored = availableAgents.map(agent => {
-      const score = this.scoreAgent(agent, taskAnalysis)
-      return { agent, score }
-    })
-
-    // Sort by score descending
-    scored.sort((a, b) => b.score - a.score)
-
-    // Return best match if score is above threshold
-    const best = scored[0]
-    if (best && best.score > 0.3) {
-      return {
-        agent: best.agent,
-        score: best.score,
-        alternatives: scored.slice(1, 3).map(s => ({
-          agent: s.agent,
-          score: s.score
-        }))
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Score an agent for a specific task
-   * Multi-factor scoring system
-   */
-  scoreAgent(agent, taskAnalysis) {
-    let score = 0
-
-    // Factor 1: Domain Match (40% weight)
-    const domainScore = this.scoreDomainMatch(agent, taskAnalysis)
-    score += domainScore * 0.4
-
-    // Factor 2: Skills Match (30% weight)
-    const skillsScore = this.scoreSkillsMatch(agent, taskAnalysis)
-    score += skillsScore * 0.3
-
-    // Factor 3: Historical Success (20% weight)
-    const historyScore = this.scoreHistoricalSuccess(agent, taskAnalysis)
-    score += historyScore * 0.2
-
-    // Factor 4: Complexity Match (10% weight)
-    const complexityScore = this.scoreComplexityMatch(agent, taskAnalysis)
-    score += complexityScore * 0.1
-
-    return Math.min(score, 1.0)
-  }
-
-  /**
-   * Score domain match
-   */
-  scoreDomainMatch(agent, taskAnalysis) {
-    const agentDomain = agent.domain || ''
-    const taskDomain = taskAnalysis.primaryDomain || ''
-
-    // Exact match
-    if (agentDomain === taskDomain) {
-      return 1.0
-    }
-
-    // Partial match (agent name contains domain)
-    if (agent.name && agent.name.includes(taskDomain)) {
-      return 0.7
-    }
-
-    // Check alternatives
-    if (taskAnalysis.alternatives && taskAnalysis.alternatives.includes(agentDomain)) {
-      return 0.5
-    }
-
-    return 0.1
+    this.historyPath = null
   }
 
   /**
-   * Score skills match
+   * Set history path for logging
+   * ORCHESTRATION: Path setup only
    */
-  scoreSkillsMatch(agent, taskAnalysis) {
-    if (!agent.skills || agent.skills.length === 0) {
-      return 0.2 // Generic agent penalty
-    }
-
-    const projectTech = taskAnalysis.projectTechnologies || {}
-    const allTech = [
-      ...(projectTech.languages || []),
-      ...(projectTech.frameworks || []),
-      ...(projectTech.tools || [])
-    ]
-
-    // Count matching skills
-    const matchingSkills = agent.skills.filter(skill => {
-      const skillLower = skill.toLowerCase()
-      return allTech.some(tech => tech.toLowerCase().includes(skillLower) || 
-                                  skillLower.includes(tech.toLowerCase()))
-    })
-
-    if (matchingSkills.length === 0) {
-      return 0.1 // No matching skills
-    }
-
-    // Score based on match ratio
-    const matchRatio = matchingSkills.length / Math.max(agent.skills.length, allTech.length)
-    return Math.min(matchRatio * 2, 1.0) // Boost for good matches
+  setHistoryPath(projectId) {
+    this.historyPath = path.join(
+      process.env.HOME,
+      '.prjct-cli',
+      'projects',
+      projectId,
+      'agent-history.jsonl'
+    )
   }
 
   /**
-   * Score historical success
+   * Format agents for Claude
+   * ORCHESTRATION: Data formatting only
    */
-  scoreHistoricalSuccess(agent, taskAnalysis) {
-    // TODO: Load from persistent history
-    // For now, return neutral score
-    const cacheKey = `${agent.name}-${taskAnalysis.primaryDomain}`
-    const history = this.historyCache.get(cacheKey)
-
-    if (history) {
-      // Success rate from history
-      return history.successRate || 0.5
-    }
-
-    return 0.5 // Neutral - no history
+  formatAgentsForTemplate(agents) {
+    return agents.map(a => ({
+      name: a.name,
+      domain: a.domain || 'general',
+      hasContent: !!a.content
+    }))
   }
 
   /**
-   * Score complexity match
+   * Format task for Claude
+   * ORCHESTRATION: Data formatting only
    */
-  scoreComplexityMatch(agent, taskAnalysis) {
-    const taskComplexity = taskAnalysis.complexity || 'medium'
-    
-    // Generic agents are better for simple tasks
-    // Specialized agents are better for complex tasks
-    const isGeneric = !agent.skills || agent.skills.length === 0
-
-    if (taskComplexity === 'low' && isGeneric) {
-      return 0.8
-    }
-
-    if (taskComplexity === 'high' && !isGeneric) {
-      return 0.9
+  formatTaskForTemplate(task) {
+    return {
+      description: typeof task === 'string' ? task : task.description,
+      type: task.type || 'unknown'
     }
-
-    return 0.5 // Neutral
   }
 
   /**
-   * Record agent success for learning
+   * Record agent usage
+   * ORCHESTRATION: File I/O only
    */
-  recordSuccess(agent, taskAnalysis, success = true) {
-    const cacheKey = `${agent.name}-${taskAnalysis.primaryDomain}`
-    const history = this.historyCache.get(cacheKey) || {
-      attempts: 0,
-      successes: 0,
-      successRate: 0.5
-    }
-
-    history.attempts++
-    if (success) {
-      history.successes++
+  async recordUsage(agent, task) {
+    if (!this.historyPath) return
+
+    try {
+      const entry = JSON.stringify({
+        timestamp: new Date().toISOString(),
+        agent: agent.name || agent,
+        task: typeof task === 'string' ? task : task.description
+      }) + '\n'
+
+      await fs.appendFile(this.historyPath, entry)
+    } catch {
+      // Silent fail
     }
-    history.successRate = history.successes / history.attempts
-
-    this.historyCache.set(cacheKey, history)
   }
 
   /**
-   * Get match explanation
+   * Load usage history
+   * ORCHESTRATION: File I/O only
    */
-  explainMatch(match) {
-    if (!match) {
-      return 'No suitable agent found'
-    }
-
-    const reasons = []
-
-    if (match.score > 0.8) {
-      reasons.push('Excellent match')
-    } else if (match.score > 0.6) {
-      reasons.push('Good match')
-    } else {
-      reasons.push('Acceptable match')
+  async loadHistory() {
+    if (!this.historyPath) return []
+
+    try {
+      const content = await fs.readFile(this.historyPath, 'utf-8')
+      return content
+        .split('\n')
+        .filter(Boolean)
+        .map(line => {
+          try {
+            return JSON.parse(line)
+          } catch {
+            return null
+          }
+        })
+        .filter(Boolean)
+    } catch {
+      return []
     }
-
-    return reasons.join(', ')
   }
 }
 
 module.exports = AgentMatcher
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.10.11",
+  "version": "0.10.12",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {

package/templates/agent-assignment.md

@@ -0,0 +1,72 @@
+---
+name: agent-assignment
+description: Assign the best agent for a task
+allowed-tools: [Read]
+---
+
+# Agent Assignment
+
+Select the best agent for the given task based on semantic understanding.
+
+## Input
+
+- **Task**: {{task}}
+- **Available Agents**: {{agents}}
+- **Project Context**: {{context}}
+
+## Instructions
+
+1. **Understand the Task**
+   - What domain does this task belong to?
+   - What skills are required?
+   - What is the complexity level?
+
+2. **Analyze Available Agents**
+   - Read each agent's expertise and domain
+   - Consider their skills and past success
+   - Match capabilities to task requirements
+
+3. **Select Best Agent**
+   - Choose the agent with highest relevance
+   - If multiple agents fit, prefer the specialist over generalist
+   - If no good match, use 'generalist' or 'full-stack'
+
+## Decision Criteria
+
+- **Domain Match**: Does the agent's domain align with the task?
+- **Skills Match**: Does the agent have the required skills?
+- **Complexity Fit**: Is the agent appropriate for this complexity level?
+
+## Output Format
+
+Return JSON with your decision:
+
+```json
+{
+  "agent": "agent-name",
+  "confidence": 0.85,
+  "reason": "Brief explanation of why this agent was selected",
+  "domain": "detected domain of the task"
+}
+```
+
+## Examples
+
+**Task**: "Implement React login component with form validation"
+**Decision**: `{ "agent": "frontend-specialist", "confidence": 0.95, "reason": "React component work requires frontend expertise", "domain": "frontend" }`
+
+**Task**: "Fix database connection timeout issue"
+**Decision**: `{ "agent": "backend-specialist", "confidence": 0.90, "reason": "Database issues require backend/infrastructure knowledge", "domain": "backend" }`
+
+**Task**: "Write unit tests for user service"
+**Decision**: `{ "agent": "qa-specialist", "confidence": 0.85, "reason": "Testing tasks benefit from QA expertise", "domain": "qa" }`
+
+**Task**: "Update README documentation"
+**Decision**: `{ "agent": "generalist", "confidence": 0.70, "reason": "Documentation is general task, no specialist needed", "domain": "docs" }`
+
+## Guidelines
+
+- Prefer specialists when task clearly fits their domain
+- Use generalist only when no specialist matches
+- Higher confidence = stronger match
+- Always provide a reason for transparency