feat(mcp): activate rule event tracking in core handlers (#1180)

apps/mcp-server/src/mcp/handlers/abstract-handler.integration.spec.ts

@@ -20,6 +20,7 @@ import { StateService } from '../../state/state.service';
 import { ContextDocumentService } from '../../context/context-document.service';
 import { DiagnosticLogService } from '../../diagnostic/diagnostic-log.service';
 import type { ImpactEventService } from '../../impact';
+import type { RuleEventCollector } from '../../rules/rule-event-collector';
 
 /**
  * Integration tests verifying all concrete handlers inherit
@@ -140,13 +141,19 @@ describe('Handler Security Integration', () => {
     } as unknown as DiagnosticLogService;
 
     const mockImpactEventService = { logEvent: vi.fn() } as unknown as ImpactEventService;
+    const mockRuleEventCollector = { record: vi.fn() } as unknown as RuleEventCollector;
 
     // Initialize handlers
-    agentHandler = new AgentHandler(mockAgentService, mockImpactEventService);
+    agentHandler = new AgentHandler(
+      mockAgentService,
+      mockImpactEventService,
+      mockRuleEventCollector,
+    );
     checklistHandler = new ChecklistContextHandler(
       mockChecklistService,
       mockContextService,
       mockImpactEventService,
+      mockRuleEventCollector,
     );
     configHandler = new ConfigHandler(
       mockConfigService,
@@ -168,6 +175,7 @@ describe('Handler Security Integration', () => {
       mockDiagnosticLogService,
       mockAgentServiceForMode as AgentService,
       mockImpactEventService,
+      mockRuleEventCollector,
     );
     rulesHandler = new RulesHandler(
       mockRulesService,

apps/mcp-server/src/mcp/handlers/agent.handler.spec.ts

@@ -2,11 +2,13 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { AgentHandler } from './agent.handler';
 import { AgentService } from '../../agent/agent.service';
 import type { ImpactEventService } from '../../impact';
+import type { RuleEventCollector } from '../../rules/rule-event-collector';
 
 describe('AgentHandler', () => {
   let handler: AgentHandler;
   let mockAgentService: AgentService;
   let mockImpactEventService: Partial<ImpactEventService>;
+  let mockRuleEventCollector: Partial<RuleEventCollector>;
 
   const mockSystemPromptResult = {
     agentName: 'security-specialist',
@@ -25,8 +27,13 @@ describe('AgentHandler', () => {
     } as unknown as AgentService;
 
     mockImpactEventService = { logEvent: vi.fn() };
+    mockRuleEventCollector = { record: vi.fn() };
 
-    handler = new AgentHandler(mockAgentService, mockImpactEventService as ImpactEventService);
+    handler = new AgentHandler(
+      mockAgentService,
+      mockImpactEventService as ImpactEventService,
+      mockRuleEventCollector as RuleEventCollector,
+    );
   });
 
   describe('handle', () => {
@@ -446,6 +453,76 @@ describe('AgentHandler', () => {
         });
       });
 
+      describe('rule event tracking', () => {
+        it('should record specialist_dispatched event on dispatch', async () => {
+          await handler.handle('dispatch_agents', {
+            mode: 'EVAL',
+            primaryAgent: 'security-specialist',
+            taskDescription: 'Review security',
+          });
+
+          expect(mockRuleEventCollector.record).toHaveBeenCalledWith(
+            expect.objectContaining({
+              type: 'specialist_dispatched',
+              domain: 'security-specialist',
+            }),
+          );
+        });
+
+        it('should record events for each specialist in parallel dispatch', async () => {
+          mockAgentService.dispatchAgents = vi.fn().mockResolvedValue({
+            ...mockDispatchResult,
+            parallelAgents: [
+              { name: 'accessibility-specialist' },
+              { name: 'performance-specialist' },
+            ],
+          });
+
+          await handler.handle('dispatch_agents', {
+            mode: 'EVAL',
+            specialists: ['accessibility-specialist', 'performance-specialist'],
+            includeParallel: true,
+          });
+
+          expect(mockRuleEventCollector.record).toHaveBeenCalledWith(
+            expect.objectContaining({
+              type: 'specialist_dispatched',
+              domain: 'accessibility-specialist',
+            }),
+          );
+          expect(mockRuleEventCollector.record).toHaveBeenCalledWith(
+            expect.objectContaining({
+              type: 'specialist_dispatched',
+              domain: 'performance-specialist',
+            }),
+          );
+        });
+
+        it('should not record events when dispatch fails', async () => {
+          mockAgentService.dispatchAgents = vi.fn().mockRejectedValue(new Error('Dispatch failed'));
+
+          await handler.handle('dispatch_agents', {
+            mode: 'EVAL',
+            primaryAgent: 'security-specialist',
+          });
+
+          expect(mockRuleEventCollector.record).not.toHaveBeenCalled();
+        });
+
+        it('should not break handler when event recording throws', async () => {
+          mockRuleEventCollector.record = vi.fn().mockImplementation(() => {
+            throw new Error('record error');
+          });
+
+          const result = await handler.handle('dispatch_agents', {
+            mode: 'EVAL',
+            primaryAgent: 'security-specialist',
+          });
+
+          expect(result?.isError).toBeFalsy();
+        });
+      });
+
       describe('executionStrategy parameter', () => {
         it('should pass executionStrategy "subagent" to service', async () => {
           await handler.handle('dispatch_agents', {

apps/mcp-server/src/mcp/handlers/agent.handler.ts

@@ -15,6 +15,7 @@ import {
   isRecordObject,
 } from '../../shared/validation.constants';
 import { ImpactEventService } from '../../impact';
+import { RuleEventCollector } from '../../rules/rule-event-collector';
 
 /**
  * Handler for agent-related tools
@@ -27,6 +28,7 @@ export class AgentHandler extends AbstractHandler {
   constructor(
     private readonly agentService: AgentService,
     private readonly impactEventService: ImpactEventService,
+    private readonly ruleEventCollector: RuleEventCollector,
   ) {
     super();
   }
@@ -256,6 +258,28 @@ export class AgentHandler extends AbstractHandler {
         // Never break handler execution
       }
 
+      try {
+        const timestamp = new Date().toISOString();
+        if (primaryAgent) {
+          this.ruleEventCollector.record({
+            type: 'specialist_dispatched',
+            timestamp,
+            domain: primaryAgent,
+          });
+        }
+        if (result.parallelAgents) {
+          for (const agent of result.parallelAgents as { name: string }[]) {
+            this.ruleEventCollector.record({
+              type: 'specialist_dispatched',
+              timestamp,
+              domain: agent.name,
+            });
+          }
+        }
+      } catch {
+        // Fire-and-forget: never break handler execution
+      }
+
       return createJsonResponse(result);
     } catch (error) {
       return createErrorResponse(

apps/mcp-server/src/mcp/handlers/checklist-context.handler.spec.ts

@@ -3,12 +3,14 @@ import { ChecklistContextHandler } from './checklist-context.handler';
 import { ChecklistService } from '../../checklist/checklist.service';
 import { ContextService } from '../../context/context.service';
 import type { ImpactEventService } from '../../impact';
+import type { RuleEventCollector } from '../../rules/rule-event-collector';
 
 describe('ChecklistContextHandler', () => {
   let handler: ChecklistContextHandler;
   let mockChecklistService: ChecklistService;
   let mockContextService: ContextService;
   let mockImpactEventService: Partial<ImpactEventService>;
+  let mockRuleEventCollector: Partial<RuleEventCollector>;
 
   const mockChecklistResult = {
     checklists: [{ domain: 'security', items: [], priority: 'high', icon: '🔒' }],
@@ -50,11 +52,13 @@ describe('ChecklistContextHandler', () => {
     } as unknown as ContextService;
 
     mockImpactEventService = { logEvent: vi.fn() };
+    mockRuleEventCollector = { record: vi.fn() };
 
     handler = new ChecklistContextHandler(
       mockChecklistService,
       mockContextService,
       mockImpactEventService as ImpactEventService,
+      mockRuleEventCollector as RuleEventCollector,
     );
   });
 
@@ -126,6 +130,45 @@ describe('ChecklistContextHandler', () => {
           text: expect.stringContaining('Checklist error'),
         });
       });
+
+      it('should record checklist_generated event for each domain', async () => {
+        await handler.handle('generate_checklist', {
+          domains: ['security', 'accessibility'],
+        });
+
+        expect(mockRuleEventCollector.record).toHaveBeenCalledWith(
+          expect.objectContaining({
+            type: 'checklist_generated',
+            domain: 'security',
+          }),
+        );
+        expect(mockRuleEventCollector.record).toHaveBeenCalledWith(
+          expect.objectContaining({
+            type: 'checklist_generated',
+            domain: 'accessibility',
+          }),
+        );
+      });
+
+      it('should not record events when checklist generation fails', async () => {
+        mockChecklistService.generateChecklist = vi.fn().mockRejectedValue(new Error('fail'));
+
+        await handler.handle('generate_checklist', { domains: ['security'] });
+
+        expect(mockRuleEventCollector.record).not.toHaveBeenCalled();
+      });
+
+      it('should not break handler when event recording throws', async () => {
+        mockRuleEventCollector.record = vi.fn().mockImplementation(() => {
+          throw new Error('record error');
+        });
+
+        const result = await handler.handle('generate_checklist', {
+          domains: ['security'],
+        });
+
+        expect(result?.isError).toBeFalsy();
+      });
     });
 
     describe('analyze_task', () => {

apps/mcp-server/src/mcp/handlers/checklist-context.handler.ts

@@ -13,6 +13,7 @@ import {
   type ValidMode,
 } from '../../shared/validation.constants';
 import { ImpactEventService } from '../../impact';
+import { RuleEventCollector } from '../../rules/rule-event-collector';
 
 /**
  * Valid checklist domains for runtime validation
@@ -37,6 +38,7 @@ export class ChecklistContextHandler extends AbstractHandler {
     private readonly checklistService: ChecklistService,
     private readonly contextService: ContextService,
     private readonly impactEventService: ImpactEventService,
+    private readonly ruleEventCollector: RuleEventCollector,
   ) {
     super();
   }
@@ -147,6 +149,19 @@ export class ChecklistContextHandler extends AbstractHandler {
         // Never break handler execution
       }
 
+      try {
+        const timestamp = new Date().toISOString();
+        for (const domain of domains ?? []) {
+          this.ruleEventCollector.record({
+            type: 'checklist_generated',
+            timestamp,
+            domain,
+          });
+        }
+      } catch {
+        // Fire-and-forget: never break handler execution
+      }
+
       return createJsonResponse(result);
     } catch (error) {
       return createErrorResponse(

apps/mcp-server/src/mcp/handlers/discussion.handler.spec.ts

@@ -1,12 +1,15 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { DiscussionHandler } from './discussion.handler';
 import type { AgentOpinion, DiscussionResult } from './discussion.types';
+import type { RuleEventCollector } from '../../rules/rule-event-collector';
 
 describe('DiscussionHandler', () => {
   let handler: DiscussionHandler;
+  let mockRuleEventCollector: Partial<RuleEventCollector>;
 
   beforeEach(() => {
-    handler = new DiscussionHandler();
+    mockRuleEventCollector = { record: vi.fn() };
+    handler = new DiscussionHandler(mockRuleEventCollector as RuleEventCollector);
   });
 
   describe('handle', () => {
@@ -167,6 +170,49 @@ describe('DiscussionHandler', () => {
     });
   });
 
+  describe('rule event tracking', () => {
+    it('should record specialist_dispatched event for each specialist', async () => {
+      await handler.handle('agent_discussion', {
+        topic: 'Auth review',
+        specialists: ['security-specialist', 'performance-specialist'],
+      });
+
+      expect(mockRuleEventCollector.record).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'specialist_dispatched',
+          domain: 'security-specialist',
+        }),
+      );
+      expect(mockRuleEventCollector.record).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'specialist_dispatched',
+          domain: 'performance-specialist',
+        }),
+      );
+    });
+
+    it('should not record events when validation fails', async () => {
+      await handler.handle('agent_discussion', {
+        specialists: ['security-specialist'],
+      });
+
+      expect(mockRuleEventCollector.record).not.toHaveBeenCalled();
+    });
+
+    it('should not break handler when event recording throws', async () => {
+      mockRuleEventCollector.record = vi.fn().mockImplementation(() => {
+        throw new Error('record error');
+      });
+
+      const result = await handler.handle('agent_discussion', {
+        topic: 'Auth review',
+        specialists: ['security-specialist'],
+      });
+
+      expect(result?.isError).toBeFalsy();
+    });
+  });
+
   describe('getToolDefinitions', () => {
     it('should return tool definitions', () => {
       const definitions = handler.getToolDefinitions();