codingbuddy 5.2.0 → 5.3.0

package/dist/src/config/config.schema.js

@@ -98,6 +98,11 @@ exports.CodingBuddyConfigSchema = zod_1.z.object({
     auto: AutoConfigSchema.optional(),
     release: ReleaseConfigSchema.optional(),
     context: ContextConfigSchema.optional(),
+    experimental: zod_1.z
+        .object({
+        teamsCoordination: zod_1.z.boolean().default(false).optional(),
+    })
+        .optional(),
     upstreamRepos: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
     keyFiles: zod_1.z.array(zod_1.z.string()).optional(),
     avoid: zod_1.z.array(zod_1.z.string()).optional(),

package/dist/src/keyword/keyword.types.d.ts

@@ -1,4 +1,8 @@
 import type { DiffAnalysisResult } from './diff-analyzer';
+import type { CouncilPreset } from '../agent/council-preset.types';
+import type { CouncilSummary } from '../collaboration/council-summary.types';
+import type { ExecutionPlan } from '../agent/execution-plan.types';
+import type { TeamsCapabilityStatus } from '../agent/teams-capability.types';
 export declare const KEYWORDS: readonly ["PLAN", "ACT", "EVAL", "AUTO"];
 export type Mode = (typeof KEYWORDS)[number];
 export declare const MODE_AGENTS: readonly ["plan-mode", "act-mode", "eval-mode", "auto-mode"];
@@ -118,6 +122,10 @@ export interface ParseModeResult {
     taskmaestroInstallHint?: string;
     visual?: VisualData;
     diffAnalysis?: DiffAnalysisResult;
+    councilPreset?: CouncilPreset;
+    councilSummary?: CouncilSummary;
+    executionPlan?: ExecutionPlan;
+    teamsCapability?: TeamsCapabilityStatus;
 }
 export interface DispatchReadyParams {
     subagent_type: 'general-purpose';

package/dist/src/mcp/handlers/agent.handler.d.ts

@@ -2,16 +2,21 @@ import type { ToolDefinition } from './base.handler';
 import type { ToolResponse } from '../response.utils';
 import { AbstractHandler } from './abstract-handler';
 import { AgentService } from '../../agent/agent.service';
+import { AgentStackService } from '../../agent/agent-stack.service';
 import { ImpactEventService } from '../../impact';
+import { RuleEventCollector } from '../../rules/rule-event-collector';
 export declare class AgentHandler extends AbstractHandler {
     private readonly agentService;
+    private readonly agentStackService;
     private readonly impactEventService;
-    constructor(agentService: AgentService, impactEventService: ImpactEventService);
+    private readonly ruleEventCollector;
+    constructor(agentService: AgentService, agentStackService: AgentStackService, impactEventService: ImpactEventService, ruleEventCollector: RuleEventCollector);
     protected getHandledTools(): string[];
     protected handleTool(toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
     getToolDefinitions(): ToolDefinition[];
     private handleDispatchAgents;
     private handleGetAgentSystemPrompt;
     private handlePrepareParallelAgents;
+    private handleListAgentStacks;
     private extractInlineAgents;
 }

package/dist/src/mcp/handlers/agent.handler.js

@@ -13,18 +13,27 @@ exports.AgentHandler = void 0;
 const common_1 = require("@nestjs/common");
 const abstract_handler_1 = require("./abstract-handler");
 const agent_service_1 = require("../../agent/agent.service");
+const agent_stack_service_1 = require("../../agent/agent-stack.service");
 const verbosity_types_1 = require("../../shared/verbosity.types");
 const response_utils_1 = require("../response.utils");
 const validation_constants_1 = require("../../shared/validation.constants");
 const impact_1 = require("../../impact");
+const rule_event_collector_1 = require("../../rules/rule-event-collector");
 let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler {
-    constructor(agentService, impactEventService) {
+    constructor(agentService, agentStackService, impactEventService, ruleEventCollector) {
         super();
         this.agentService = agentService;
+        this.agentStackService = agentStackService;
         this.impactEventService = impactEventService;
+        this.ruleEventCollector = ruleEventCollector;
     }
     getHandledTools() {
-        return ['get_agent_system_prompt', 'prepare_parallel_agents', 'dispatch_agents'];
+        return [
+            'get_agent_system_prompt',
+            'prepare_parallel_agents',
+            'dispatch_agents',
+            'list_agent_stacks',
+        ];
     }
     async handleTool(toolName, args) {
         switch (toolName) {
@@ -34,6 +43,8 @@ let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler
                 return this.handlePrepareParallelAgents(args);
             case 'dispatch_agents':
                 return this.handleDispatchAgents(args);
+            case 'list_agent_stacks':
+                return this.handleListAgentStacks(args);
             default:
                 return (0, response_utils_1.createErrorResponse)(`Unknown tool: ${toolName}`);
         }
@@ -144,8 +155,12 @@ let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler
                         },
                         executionStrategy: {
                             type: 'string',
-                            enum: ['subagent', 'taskmaestro', 'teams'],
-                            description: 'Execution strategy for specialist agents. "subagent" (default) uses Claude Code Agent tool with run_in_background. "taskmaestro" returns tmux pane assignments for /taskmaestro skill. "teams" uses Claude Code native teams with shared TaskList coordination.',
+                            enum: ['subagent', 'taskmaestro', 'teams', 'taskmaestro+teams'],
+                            description: 'Execution strategy for specialist agents. "subagent" (default) uses Claude Code Agent tool with run_in_background. "taskmaestro" returns tmux pane assignments for /taskmaestro skill. "teams" uses Claude Code native teams with shared TaskList coordination. "taskmaestro+teams" uses TaskMaestro as outer transport with Teams as inner coordination.',
+                        },
+                        agentStack: {
+                            type: 'string',
+                            description: 'Agent stack name to resolve primary + specialists from a preset (e.g., "api-development"). Overrides primaryAgent and specialists when provided.',
                         },
                         inlineAgents: {
                             type: 'object',
@@ -171,6 +186,19 @@ let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler
                     required: ['mode'],
                 },
             },
+            {
+                name: 'list_agent_stacks',
+                description: 'List available agent stack presets. Each stack defines a primary agent and specialist combination for common workflows.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        category: {
+                            type: 'string',
+                            description: 'Optional category filter (e.g., "development", "review", "data", "security")',
+                        },
+                    },
+                },
+            },
         ];
     }
     async handleDispatchAgents(args) {
@@ -180,13 +208,25 @@ let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler
                 ? 'Missing required parameter: mode (PLAN, ACT, EVAL, or AUTO)'
                 : `Invalid mode: ${mode}. Must be PLAN, ACT, EVAL, or AUTO`);
         }
-        const primaryAgent = (0, validation_constants_1.extractOptionalString)(args, 'primaryAgent');
-        const specialists = (0, validation_constants_1.extractStringArray)(args, 'specialists');
+        const agentStack = (0, validation_constants_1.extractOptionalString)(args, 'agentStack');
+        let primaryAgent = (0, validation_constants_1.extractOptionalString)(args, 'primaryAgent');
+        let specialists = (0, validation_constants_1.extractStringArray)(args, 'specialists');
         const targetFiles = (0, validation_constants_1.extractStringArray)(args, 'targetFiles');
         const taskDescription = (0, validation_constants_1.extractOptionalString)(args, 'taskDescription');
-        const includeParallel = args?.includeParallel === true;
+        let includeParallel = args?.includeParallel === true;
         const executionStrategy = args?.executionStrategy ?? 'subagent';
         const inlineAgents = this.extractInlineAgents(args);
+        if (agentStack) {
+            try {
+                const stack = await this.agentStackService.resolveStack(agentStack);
+                primaryAgent = primaryAgent ?? stack.primary_agent;
+                specialists = specialists?.length ? specialists : stack.specialist_agents;
+                includeParallel = includeParallel || stack.specialist_agents.length > 0;
+            }
+            catch (error) {
+                return (0, response_utils_1.createErrorResponse)(`Failed to resolve agent stack: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
         try {
             const result = await this.agentService.dispatchAgents({
                 mode: mode,
@@ -218,6 +258,27 @@ let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler
             }
             catch {
             }
+            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) {
+                        this.ruleEventCollector.record({
+                            type: 'specialist_dispatched',
+                            timestamp,
+                            domain: agent.name,
+                        });
+                    }
+                }
+            }
+            catch {
+            }
             return (0, response_utils_1.createJsonResponse)(result);
         }
         catch (error) {
@@ -283,6 +344,16 @@ let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler
             return (0, response_utils_1.createErrorResponse)(`Failed to prepare parallel agents: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    async handleListAgentStacks(args) {
+        const category = (0, validation_constants_1.extractOptionalString)(args, 'category');
+        try {
+            const stacks = await this.agentStackService.listStacks(category);
+            return (0, response_utils_1.createJsonResponse)({ stacks });
+        }
+        catch (error) {
+            return (0, response_utils_1.createErrorResponse)(`Failed to list agent stacks: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
     extractInlineAgents(args) {
         const raw = args?.inlineAgents;
         if (!(0, validation_constants_1.isRecordObject)(raw))
@@ -294,6 +365,8 @@ exports.AgentHandler = AgentHandler;
 exports.AgentHandler = AgentHandler = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [agent_service_1.AgentService,
-        impact_1.ImpactEventService])
+        agent_stack_service_1.AgentStackService,
+        impact_1.ImpactEventService,
+        rule_event_collector_1.RuleEventCollector])
 ], AgentHandler);
 //# sourceMappingURL=agent.handler.js.map

package/dist/src/mcp/handlers/checklist-context.handler.d.ts

@@ -4,11 +4,13 @@ import { AbstractHandler } from './abstract-handler';
 import { ChecklistService } from '../../checklist/checklist.service';
 import { ContextService } from '../../context/context.service';
 import { ImpactEventService } from '../../impact';
+import { RuleEventCollector } from '../../rules/rule-event-collector';
 export declare class ChecklistContextHandler extends AbstractHandler {
     private readonly checklistService;
     private readonly contextService;
     private readonly impactEventService;
-    constructor(checklistService: ChecklistService, contextService: ContextService, impactEventService: ImpactEventService);
+    private readonly ruleEventCollector;
+    constructor(checklistService: ChecklistService, contextService: ContextService, impactEventService: ImpactEventService, ruleEventCollector: RuleEventCollector);
     protected getHandledTools(): string[];
     protected handleTool(toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
     getToolDefinitions(): ToolDefinition[];

package/dist/src/mcp/handlers/checklist-context.handler.js

@@ -17,6 +17,7 @@ const context_service_1 = require("../../context/context.service");
 const response_utils_1 = require("../response.utils");
 const validation_constants_1 = require("../../shared/validation.constants");
 const impact_1 = require("../../impact");
+const rule_event_collector_1 = require("../../rules/rule-event-collector");
 const VALID_CHECKLIST_DOMAINS = [
     'security',
     'accessibility',
@@ -26,11 +27,12 @@ const VALID_CHECKLIST_DOMAINS = [
     'seo',
 ];
 let ChecklistContextHandler = class ChecklistContextHandler extends abstract_handler_1.AbstractHandler {
-    constructor(checklistService, contextService, impactEventService) {
+    constructor(checklistService, contextService, impactEventService, ruleEventCollector) {
         super();
         this.checklistService = checklistService;
         this.contextService = contextService;
         this.impactEventService = impactEventService;
+        this.ruleEventCollector = ruleEventCollector;
     }
     getHandledTools() {
         return ['generate_checklist', 'analyze_task'];
@@ -120,6 +122,18 @@ let ChecklistContextHandler = class ChecklistContextHandler extends abstract_han
             }
             catch {
             }
+            try {
+                const timestamp = new Date().toISOString();
+                for (const domain of domains ?? []) {
+                    this.ruleEventCollector.record({
+                        type: 'checklist_generated',
+                        timestamp,
+                        domain,
+                    });
+                }
+            }
+            catch {
+            }
             return (0, response_utils_1.createJsonResponse)(result);
         }
         catch (error) {
@@ -152,6 +166,7 @@ exports.ChecklistContextHandler = ChecklistContextHandler = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [checklist_service_1.ChecklistService,
         context_service_1.ContextService,
-        impact_1.ImpactEventService])
+        impact_1.ImpactEventService,
+        rule_event_collector_1.RuleEventCollector])
 ], ChecklistContextHandler);
 //# sourceMappingURL=checklist-context.handler.js.map

package/dist/src/mcp/handlers/discussion.handler.d.ts

@@ -1,7 +1,10 @@
 import type { ToolDefinition } from './base.handler';
 import type { ToolResponse } from '../response.utils';
 import { AbstractHandler } from './abstract-handler';
+import { RuleEventCollector } from '../../rules/rule-event-collector';
 export declare class DiscussionHandler extends AbstractHandler {
+    private readonly ruleEventCollector;
+    constructor(ruleEventCollector: RuleEventCollector);
     protected getHandledTools(): string[];
     protected handleTool(toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
     getToolDefinitions(): ToolDefinition[];

package/dist/src/mcp/handlers/discussion.handler.js

@@ -5,6 +5,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiscussionHandler = void 0;
 const common_1 = require("@nestjs/common");
@@ -12,6 +15,7 @@ const abstract_handler_1 = require("./abstract-handler");
 const response_utils_1 = require("../response.utils");
 const validation_constants_1 = require("../../shared/validation.constants");
 const discussion_types_1 = require("./discussion.types");
+const rule_event_collector_1 = require("../../rules/rule-event-collector");
 const SPECIALIST_DOMAINS = {
     'security-specialist': { domain: 'security', defaultSeverity: 'high' },
     'performance-specialist': { domain: 'performance', defaultSeverity: 'medium' },
@@ -24,6 +28,10 @@ const SPECIALIST_DOMAINS = {
 };
 const SEVERITY_ORDER = ['info', 'low', 'medium', 'high', 'critical'];
 let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.AbstractHandler {
+    constructor(ruleEventCollector) {
+        super();
+        this.ruleEventCollector = ruleEventCollector;
+    }
     getHandledTools() {
         return ['agent_discussion'];
     }
@@ -87,6 +95,18 @@ let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.Abstr
             summary,
             maxSeverity,
         };
+        try {
+            const timestamp = new Date().toISOString();
+            for (const specialist of specialists) {
+                this.ruleEventCollector.record({
+                    type: 'specialist_dispatched',
+                    timestamp,
+                    domain: specialist,
+                });
+            }
+        }
+        catch {
+        }
         return (0, response_utils_1.createJsonResponse)(result);
     }
     collectOpinions(topic, specialists, context) {
@@ -163,6 +183,7 @@ let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.Abstr
 };
 exports.DiscussionHandler = DiscussionHandler;
 exports.DiscussionHandler = DiscussionHandler = __decorate([
-    (0, common_1.Injectable)()
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [rule_event_collector_1.RuleEventCollector])
 ], DiscussionHandler);
 //# sourceMappingURL=discussion.handler.js.map

package/dist/src/mcp/handlers/mode.handler.d.ts

@@ -9,7 +9,10 @@ import { StateService } from '../../state/state.service';
 import { ContextDocumentService } from '../../context/context-document.service';
 import { DiagnosticLogService } from '../../diagnostic/diagnostic-log.service';
 import { AgentService } from '../../agent/agent.service';
+import { CouncilPresetService } from '../../agent/council-preset.service';
+import { TeamsCapabilityService } from '../../agent/teams-capability.service';
 import { ImpactEventService } from '../../impact';
+import { RuleEventCollector } from '../../rules/rule-event-collector';
 export declare class ModeHandler extends AbstractHandler {
     private readonly keywordService;
     private readonly configService;
@@ -19,9 +22,12 @@ export declare class ModeHandler extends AbstractHandler {
     private readonly contextDocService;
     private readonly diagnosticLogService;
     private readonly agentService;
+    private readonly councilPresetService;
+    private readonly teamsCapabilityService;
     private readonly impactEventService;
+    private readonly ruleEventCollector;
     private readonly logger;
-    constructor(keywordService: KeywordService, configService: ConfigService, languageService: LanguageService, modelResolverService: ModelResolverService, stateService: StateService, contextDocService: ContextDocumentService, diagnosticLogService: DiagnosticLogService, agentService: AgentService, impactEventService: ImpactEventService);
+    constructor(keywordService: KeywordService, configService: ConfigService, languageService: LanguageService, modelResolverService: ModelResolverService, stateService: StateService, contextDocService: ContextDocumentService, diagnosticLogService: DiagnosticLogService, agentService: AgentService, councilPresetService: CouncilPresetService, teamsCapabilityService: TeamsCapabilityService, impactEventService: ImpactEventService, ruleEventCollector: RuleEventCollector);
     protected getHandledTools(): string[];
     getToolDefinitions(): ToolDefinition[];
     protected handleTool(toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
@@ -32,5 +38,7 @@ export declare class ModeHandler extends AbstractHandler {
     private buildPlanReviewGate;
     private buildAgentDiscussion;
     private buildVisual;
+    private resolveTeamsCapability;
+    private buildExecutionPlan;
     private persistModeState;
 }

package/dist/src/mcp/handlers/mode.handler.js

@@ -33,10 +33,14 @@ const keyword_types_2 = require("../../keyword/keyword.types");
 const visual_data_builder_1 = require("../../keyword/visual-data.builder");
 const verbosity_types_1 = require("../../shared/verbosity.types");
 const agent_service_1 = require("../../agent/agent.service");
+const council_preset_service_1 = require("../../agent/council-preset.service");
+const teams_capability_service_1 = require("../../agent/teams-capability.service");
+const execution_plan_1 = require("../../agent/execution-plan");
 const impact_1 = require("../../impact");
+const rule_event_collector_1 = require("../../rules/rule-event-collector");
 const CONTEXT_TITLE_MAX_LENGTH = 50;
 let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.AbstractHandler {
-    constructor(keywordService, configService, languageService, modelResolverService, stateService, contextDocService, diagnosticLogService, agentService, impactEventService) {
+    constructor(keywordService, configService, languageService, modelResolverService, stateService, contextDocService, diagnosticLogService, agentService, councilPresetService, teamsCapabilityService, impactEventService, ruleEventCollector) {
         super();
         this.keywordService = keywordService;
         this.configService = configService;
@@ -46,7 +50,10 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
         this.contextDocService = contextDocService;
         this.diagnosticLogService = diagnosticLogService;
         this.agentService = agentService;
+        this.councilPresetService = councilPresetService;
+        this.teamsCapabilityService = teamsCapabilityService;
         this.impactEventService = impactEventService;
+        this.ruleEventCollector = ruleEventCollector;
         this.logger = new common_1.Logger(ModeHandler_1.name);
     }
     getHandledTools() {
@@ -143,6 +150,9 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
             const deepThinkingInstructions = this.buildDeepThinkingInstructions(result.mode);
             const planReviewGate = this.buildPlanReviewGate(result.mode, settings?.ai?.planReviewGate);
             const agentDiscussion = this.buildAgentDiscussion(result.mode, settings?.ai?.agentDiscussion);
+            const councilPreset = this.councilPresetService.resolvePreset(result.mode) ?? undefined;
+            const teamsCapability = await this.resolveTeamsCapability();
+            const executionPlan = this.buildExecutionPlan(dispatchReady, teamsCapability);
             const visual = await this.buildVisual(result.mode, result.delegates_to, result.parallelAgentsRecommendation?.specialists, settings?.eco);
             const response = (0, response_utils_1.createJsonResponse)({
                 ...result,
@@ -154,6 +164,9 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
                 ...(planReviewGate && { planReviewGate }),
                 ...(agentDiscussion && { agentDiscussion }),
                 ...(visual && { visual }),
+                ...(councilPreset && { councilPreset }),
+                ...(executionPlan && { executionPlan: (0, execution_plan_1.serializeExecutionPlan)(executionPlan) }),
+                ...(teamsCapability && { teamsCapability }),
                 ...contextResult,
                 ...(projectRootWarning && { projectRootWarning }),
             });
@@ -165,6 +178,16 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
             }
             catch {
             }
+            try {
+                this.ruleEventCollector.record({
+                    type: 'mode_activated',
+                    timestamp: new Date().toISOString(),
+                    rule: result.mode,
+                    details: { agent: result.agent },
+                });
+            }
+            catch {
+            }
             return response;
         }
         catch (error) {
@@ -353,6 +376,57 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
             return undefined;
         }
     }
+    async resolveTeamsCapability() {
+        try {
+            return await this.teamsCapabilityService.getStatus();
+        }
+        catch (error) {
+            this.logger.warn(`Failed to resolve Teams capability: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return undefined;
+        }
+    }
+    buildExecutionPlan(dispatchReady, teamsCapability) {
+        if (!dispatchReady) {
+            return undefined;
+        }
+        const agents = [];
+        if (dispatchReady.primaryAgent) {
+            agents.push({
+                name: dispatchReady.primaryAgent.name,
+                displayName: dispatchReady.primaryAgent.displayName,
+                description: dispatchReady.primaryAgent.description,
+                dispatchParams: dispatchReady.primaryAgent.dispatchParams,
+            });
+        }
+        if (dispatchReady.parallelAgents?.length) {
+            for (const agent of dispatchReady.parallelAgents) {
+                agents.push({
+                    name: agent.name,
+                    displayName: agent.displayName,
+                    description: agent.description,
+                    dispatchParams: agent.dispatchParams,
+                });
+            }
+        }
+        if (agents.length === 0) {
+            return undefined;
+        }
+        const outer = (0, execution_plan_1.subagentLayer)(agents);
+        if (teamsCapability?.available) {
+            const inner = (0, execution_plan_1.teamsLayer)({
+                team_name: 'auto',
+                description: 'Auto-generated Teams coordination layer',
+                teammates: agents.map(a => ({
+                    name: a.name,
+                    subagent_type: 'general-purpose',
+                    team_name: 'auto',
+                    prompt: a.description,
+                })),
+            });
+            return (0, execution_plan_1.buildNestedPlan)(outer, inner);
+        }
+        return (0, execution_plan_1.buildSimplePlan)(outer);
+    }
     async persistModeState(mode) {
         try {
             await this.stateService.updateLastMode(mode);
@@ -375,6 +449,9 @@ exports.ModeHandler = ModeHandler = ModeHandler_1 = __decorate([
         context_document_service_1.ContextDocumentService,
         diagnostic_log_service_1.DiagnosticLogService,
         agent_service_1.AgentService,
-        impact_1.ImpactEventService])
+        council_preset_service_1.CouncilPresetService,
+        teams_capability_service_1.TeamsCapabilityService,
+        impact_1.ImpactEventService,
+        rule_event_collector_1.RuleEventCollector])
 ], ModeHandler);
 //# sourceMappingURL=mode.handler.js.map

package/dist/src/mcp/handlers/quality-report.handler.d.ts

@@ -2,10 +2,12 @@ import type { ToolDefinition } from './base.handler';
 import type { ToolResponse } from '../response.utils';
 import { AbstractHandler } from './abstract-handler';
 import { QualityReportService } from '../../ship/quality-report.service';
+import { RuleEventCollector } from '../../rules/rule-event-collector';
 export declare class QualityReportHandler extends AbstractHandler {
     private readonly qualityReportService;
+    private readonly ruleEventCollector;
     private readonly logger;
-    constructor(qualityReportService: QualityReportService);
+    constructor(qualityReportService: QualityReportService, ruleEventCollector: RuleEventCollector);
     protected getHandledTools(): string[];
     protected handleTool(_toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
     getToolDefinitions(): ToolDefinition[];

package/dist/src/mcp/handlers/quality-report.handler.js

@@ -16,10 +16,12 @@ const abstract_handler_1 = require("./abstract-handler");
 const quality_report_service_1 = require("../../ship/quality-report.service");
 const response_utils_1 = require("../response.utils");
 const validation_constants_1 = require("../../shared/validation.constants");
+const rule_event_collector_1 = require("../../rules/rule-event-collector");
 let QualityReportHandler = QualityReportHandler_1 = class QualityReportHandler extends abstract_handler_1.AbstractHandler {
-    constructor(qualityReportService) {
+    constructor(qualityReportService, ruleEventCollector) {
         super();
         this.qualityReportService = qualityReportService;
+        this.ruleEventCollector = ruleEventCollector;
         this.logger = new common_1.Logger(QualityReportHandler_1.name);
     }
     getHandledTools() {
@@ -36,6 +38,21 @@ let QualityReportHandler = QualityReportHandler_1 = class QualityReportHandler e
                 changedFiles,
                 timeout,
             });
+            try {
+                const domains = result.domains;
+                if (domains?.length) {
+                    const timestamp = new Date().toISOString();
+                    for (const d of domains) {
+                        this.ruleEventCollector.record({
+                            type: 'specialist_dispatched',
+                            timestamp,
+                            domain: d.domain,
+                        });
+                    }
+                }
+            }
+            catch {
+            }
             return (0, response_utils_1.createJsonResponse)(result);
         }
         catch (error) {
@@ -70,6 +87,7 @@ let QualityReportHandler = QualityReportHandler_1 = class QualityReportHandler e
 exports.QualityReportHandler = QualityReportHandler;
 exports.QualityReportHandler = QualityReportHandler = QualityReportHandler_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [quality_report_service_1.QualityReportService])
+    __metadata("design:paramtypes", [quality_report_service_1.QualityReportService,
+        rule_event_collector_1.RuleEventCollector])
 ], QualityReportHandler);
 //# sourceMappingURL=quality-report.handler.js.map

package/dist/src/rules/rules.service.d.ts

@@ -11,6 +11,7 @@ export declare class RulesService {
     getRuleContent(relativePath: string): Promise<string>;
     listAgents(): Promise<string[]>;
     private sortAgentsByPriority;
+    getRulesDir(): string;
     isModeAgent(agentName: string): boolean;
     getAgent(name: string): Promise<AgentProfile>;
     searchRules(query: string): Promise<SearchResult[]>;
@@ -18,6 +19,11 @@ export declare class RulesService {
         name: string;
         description: string;
         triggers?: SkillFrontmatterTrigger[];
+        userInvocable?: boolean;
+        disableModelInvocation?: boolean;
+        context?: string;
+        agent?: string;
+        allowedTools?: string[];
     }>>;
     getSkill(name: string): Promise<Skill>;
 }

package/dist/src/rules/rules.service.js

@@ -82,6 +82,9 @@ let RulesService = RulesService_1 = class RulesService {
         const sortedModeAgents = keyword_types_1.MODE_AGENTS.filter(agent => foundModeAgents.includes(agent));
         return [...sortedModeAgents, ...otherAgents.sort()];
     }
+    getRulesDir() {
+        return this.rulesDir;
+    }
     isModeAgent(agentName) {
         return keyword_types_1.MODE_AGENTS.includes(agentName);
     }

package/dist/src/rules/skill.schema.d.ts

@@ -13,5 +13,10 @@ export interface Skill {
     content: string;
     path: string;
     triggers?: SkillFrontmatterTrigger[];
+    userInvocable?: boolean;
+    disableModelInvocation?: boolean;
+    context?: string;
+    agent?: string;
+    allowedTools?: string[];
 }
 export declare function parseSkill(content: string, filePath: string): Skill;