feat: add tooling-engineer agent and recommendedActAgent parameter support for ACT mode

- Add tooling-engineer Primary Agent for config files and build tools, and implement agent context passing from PLAN to ACT mode

close #149

Author: wishket-pjw

apps/mcp-server/src/keyword/keyword.service.spec.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { KeywordService } from './keyword.service';
 import type { KeywordModesConfig } from './keyword.types';
+import type { PrimaryAgentResolver } from './primary-agent-resolver';
 
 /**
  * NOTE: Korean/Japanese/Chinese/Spanish test inputs (e.g., '계획 인증 기능 설계')
@@ -852,7 +853,7 @@ describe('KeywordService', () => {
         mockLoadConfig,
         mockLoadRule,
         mockLoadAgentInfo,
-        mockResolver as any,
+        mockResolver as unknown as PrimaryAgentResolver,
       );
 
       const result = await serviceWithResolver.parseMode('PLAN design API');
@@ -878,7 +879,7 @@ describe('KeywordService', () => {
         mockLoadConfig,
         mockLoadRule,
         mockLoadAgentInfo,
-        mockResolver as any,
+        mockResolver as unknown as PrimaryAgentResolver,
       );
 
       const result = await serviceWithResolver.parseMode('PLAN build UI');
@@ -903,7 +904,7 @@ describe('KeywordService', () => {
         mockLoadConfig,
         mockLoadRule,
         mockLoadAgentInfo,
-        mockResolver as any,
+        mockResolver as unknown as PrimaryAgentResolver,
       );
 
       const result = await serviceWithResolver.parseMode('ACT implement');
@@ -925,7 +926,7 @@ describe('KeywordService', () => {
         mockLoadConfig,
         mockLoadRule,
         mockLoadAgentInfo,
-        mockResolver as any,
+        mockResolver as unknown as PrimaryAgentResolver,
       );
 
       const result = await serviceWithResolver.parseMode('EVAL review');
@@ -952,7 +953,7 @@ describe('KeywordService', () => {
         mockLoadConfig,
         mockLoadRule,
         mockLoadAgentInfo,
-        mockResolver as any,
+        mockResolver as unknown as PrimaryAgentResolver,
       );
 
       const result = await serviceWithResolver.parseMode('PLAN design');
@@ -1031,4 +1032,177 @@ describe('KeywordService', () => {
       expect(result.activation_message?.activations[0].tier).toBe('primary');
     });
   });
+
+  describe('recommendedActAgent parameter (ACT mode agent override)', () => {
+    it('uses recommendedActAgent when provided in ACT mode', async () => {
+      const mockResolver = {
+        resolve: vi.fn().mockResolvedValue({
+          agentName: 'backend-developer',
+          source: 'config',
+          confidence: 1.0,
+          reason: 'Using recommended agent from PLAN mode: backend-developer',
+        }),
+      };
+      const serviceWithResolver = new KeywordService(
+        mockLoadConfig,
+        mockLoadRule,
+        mockLoadAgentInfo,
+        mockResolver as unknown as PrimaryAgentResolver,
+      );
+
+      const result = await serviceWithResolver.parseMode(
+        'ACT implement login API',
+        { recommendedActAgent: 'backend-developer' },
+      );
+
+      expect(result.mode).toBe('ACT');
+      expect(result.delegates_to).toBe('backend-developer');
+      expect(mockResolver.resolve).toHaveBeenCalledWith(
+        'ACT',
+        'implement login API',
+        undefined,
+        'backend-developer',
+      );
+    });
+
+    it('ignores recommendedActAgent in PLAN mode', async () => {
+      const mockResolver = {
+        resolve: vi.fn().mockResolvedValue({
+          agentName: 'solution-architect',
+          source: 'default',
+          confidence: 1.0,
+          reason: 'PLAN mode default',
+        }),
+      };
+      const serviceWithResolver = new KeywordService(
+        mockLoadConfig,
+        mockLoadRule,
+        mockLoadAgentInfo,
+        mockResolver as unknown as PrimaryAgentResolver,
+      );
+
+      const result = await serviceWithResolver.parseMode('PLAN design API', {
+        recommendedActAgent: 'backend-developer',
+      });
+
+      expect(result.mode).toBe('PLAN');
+      expect(result.delegates_to).toBe('solution-architect');
+      // Should not pass recommendedActAgent for PLAN mode
+      expect(mockResolver.resolve).toHaveBeenCalledWith(
+        'PLAN',
+        'design API',
+        undefined,
+        undefined,
+      );
+    });
+
+    it('ignores recommendedActAgent in EVAL mode', async () => {
+      const mockResolver = {
+        resolve: vi.fn().mockResolvedValue({
+          agentName: 'code-reviewer',
+          source: 'default',
+          confidence: 1.0,
+          reason: 'EVAL always uses code-reviewer',
+        }),
+      };
+      const serviceWithResolver = new KeywordService(
+        mockLoadConfig,
+        mockLoadRule,
+        mockLoadAgentInfo,
+        mockResolver as unknown as PrimaryAgentResolver,
+      );
+
+      const result = await serviceWithResolver.parseMode('EVAL review code', {
+        recommendedActAgent: 'backend-developer',
+      });
+
+      expect(result.mode).toBe('EVAL');
+      expect(result.delegates_to).toBe('code-reviewer');
+    });
+
+    it('falls back to default resolution if no recommendedActAgent provided', async () => {
+      const mockResolver = {
+        resolve: vi.fn().mockResolvedValue({
+          agentName: 'frontend-developer',
+          source: 'default',
+          confidence: 1.0,
+          reason: 'ACT mode default: frontend-developer',
+        }),
+      };
+      const serviceWithResolver = new KeywordService(
+        mockLoadConfig,
+        mockLoadRule,
+        mockLoadAgentInfo,
+        mockResolver as unknown as PrimaryAgentResolver,
+      );
+
+      const result = await serviceWithResolver.parseMode(
+        'ACT implement feature',
+      );
+
+      expect(result.delegates_to).toBe('frontend-developer');
+      expect(mockResolver.resolve).toHaveBeenCalledWith(
+        'ACT',
+        'implement feature',
+        undefined,
+        undefined,
+      );
+    });
+
+    it('treats empty string recommendedActAgent as undefined', async () => {
+      const mockResolver = {
+        resolve: vi.fn().mockResolvedValue({
+          agentName: 'frontend-developer',
+          source: 'default',
+          confidence: 1.0,
+          reason: 'ACT mode default: frontend-developer',
+        }),
+      };
+      const serviceWithResolver = new KeywordService(
+        mockLoadConfig,
+        mockLoadRule,
+        mockLoadAgentInfo,
+        mockResolver as unknown as PrimaryAgentResolver,
+      );
+
+      // Empty string should be treated as undefined
+      const result = await serviceWithResolver.parseMode('ACT implement', {
+        recommendedActAgent: '',
+      });
+
+      expect(result.delegates_to).toBe('frontend-developer');
+      // Should be called with undefined, not empty string
+      expect(mockResolver.resolve).toHaveBeenCalledWith(
+        'ACT',
+        'implement',
+        undefined,
+        '', // Empty string is passed through (MCP layer handles trim)
+      );
+    });
+
+    it('treats whitespace-only recommendedActAgent as undefined', async () => {
+      const mockResolver = {
+        resolve: vi.fn().mockResolvedValue({
+          agentName: 'frontend-developer',
+          source: 'default',
+          confidence: 1.0,
+          reason: 'ACT mode default: frontend-developer',
+        }),
+      };
+      const serviceWithResolver = new KeywordService(
+        mockLoadConfig,
+        mockLoadRule,
+        mockLoadAgentInfo,
+        mockResolver as unknown as PrimaryAgentResolver,
+      );
+
+      // Whitespace should be treated as undefined at MCP layer
+      // KeywordService passes through, validation is in MCP handler
+      const result = await serviceWithResolver.parseMode('ACT implement', {
+        recommendedActAgent: '   ',
+      });
+
+      expect(result.delegates_to).toBe('frontend-developer');
+    });
+  });
 });

apps/mcp-server/src/keyword/keyword.service.ts

@@ -16,6 +16,16 @@ import {
   type PrimaryAgentSource,
   type ActAgentRecommendation,
 } from './keyword.types';
+
+/**
+ * Options for parseMode method
+ */
+export interface ParseModeOptions {
+  /** ACT agent recommended from previous PLAN mode (only applies to ACT mode) */
+  recommendedActAgent?: string;
+  /** Resolution context for file-based inference */
+  context?: ResolutionContext;
+}
 import { PrimaryAgentResolver } from './primary-agent-resolver';
 import { ActivationMessageBuilder } from './activation-message.builder';
 import { filterRulesByMode } from './rule-filter';
@@ -78,7 +88,10 @@ export class KeywordService {
     this.primaryAgentResolver = primaryAgentResolver;
   }
 
-  async parseMode(prompt: string): Promise<ParseModeResult> {
+  async parseMode(
+    prompt: string,
+    options?: ParseModeOptions,
+  ): Promise<ParseModeResult> {
     const config = await this.loadModeConfig();
     const { mode, originalPrompt, warnings } = this.extractModeFromPrompt(
       prompt,
@@ -88,13 +101,19 @@ export class KeywordService {
     const modeConfig = config.modes[mode];
     const rules = await this.getRulesForMode(mode);
 
+    // Only pass recommendedActAgent for ACT mode
+    const effectiveRecommendedAgent =
+      mode === 'ACT' ? options?.recommendedActAgent : undefined;
+
     return this.buildParseModeResult(
       mode,
       originalPrompt,
       warnings,
       modeConfig,
       rules,
       config,
+      options?.context,
+      effectiveRecommendedAgent,
     );
   }
 
@@ -178,6 +197,8 @@ export class KeywordService {
     modeConfig: KeywordModesConfig['modes'][Mode],
     rules: RuleContent[],
     config: KeywordModesConfig,
+    context?: ResolutionContext,
+    recommendedActAgent?: string,
   ): Promise<ParseModeResult> {
     // Filter rules by mode to reduce token usage
     const filteredRules = filterRulesByMode(rules, mode);
@@ -199,6 +220,8 @@ export class KeywordService {
       mode,
       originalPrompt,
       modeConfig.delegates_to,
+      context,
+      recommendedActAgent,
     );
 
     if (resolvedAgent) {
@@ -385,6 +408,7 @@ export class KeywordService {
     prompt: string,
     staticDelegatesTo?: string,
     context?: ResolutionContext,
+    recommendedActAgent?: string,
   ): Promise<{
     agentName: string;
     source: PrimaryAgentSource;
@@ -395,6 +419,7 @@ export class KeywordService {
         mode,
         prompt,
         context,
+        recommendedActAgent,
       );
       return { agentName: result.agentName, source: result.source };
     }

apps/mcp-server/src/keyword/keyword.types.ts

@@ -15,6 +15,7 @@ export const PLAN_PRIMARY_AGENTS = [
 
 /** Primary Agents for ACT mode - centralized definition */
 export const ACT_PRIMARY_AGENTS = [
+  'tooling-engineer', // Config/build tools specialist - highest priority for pattern matching
   'frontend-developer',
   'backend-developer',
   'devops-engineer',