codingbuddy 5.1.3 → 5.3.0

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/briefing.handler.d.ts

@@ -0,0 +1,12 @@
+import type { ToolDefinition } from './base.handler';
+import type { ToolResponse } from '../response.utils';
+import { AbstractHandler } from './abstract-handler';
+import { BriefingService } from '../../context/briefing.service';
+export declare class BriefingHandler extends AbstractHandler {
+    private readonly briefingService;
+    private readonly logger;
+    constructor(briefingService: BriefingService);
+    protected getHandledTools(): string[];
+    protected handleTool(_toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
+    getToolDefinitions(): ToolDefinition[];
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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);
+};
+var BriefingHandler_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BriefingHandler = void 0;
+const common_1 = require("@nestjs/common");
+const abstract_handler_1 = require("./abstract-handler");
+const briefing_service_1 = require("../../context/briefing.service");
+const response_utils_1 = require("../response.utils");
+const validation_constants_1 = require("../../shared/validation.constants");
+let BriefingHandler = BriefingHandler_1 = class BriefingHandler extends abstract_handler_1.AbstractHandler {
+    constructor(briefingService) {
+        super();
+        this.briefingService = briefingService;
+        this.logger = new common_1.Logger(BriefingHandler_1.name);
+    }
+    getHandledTools() {
+        return ['create_briefing'];
+    }
+    async handleTool(_toolName, args) {
+        try {
+            const contextPath = (0, validation_constants_1.extractOptionalString)(args, 'contextPath');
+            const projectRoot = (0, validation_constants_1.extractOptionalString)(args, 'projectRoot');
+            const result = await this.briefingService.createBriefing({
+                contextPath,
+                projectRoot,
+            });
+            return (0, response_utils_1.createJsonResponse)(result);
+        }
+        catch (error) {
+            this.logger.error(`Briefing creation failed: ${error}`);
+            return (0, response_utils_1.createErrorResponse)(`Briefing creation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'create_briefing',
+                description: 'Capture current session state into a briefing document for cross-session recovery',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        contextPath: {
+                            type: 'string',
+                            description: 'Path to context.md file (default: docs/codingbuddy/context.md)',
+                        },
+                        projectRoot: {
+                            type: 'string',
+                            description: 'Project root directory (default: auto-detected)',
+                        },
+                    },
+                    required: [],
+                },
+            },
+        ];
+    }
+};
+exports.BriefingHandler = BriefingHandler;
+exports.BriefingHandler = BriefingHandler = BriefingHandler_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [briefing_service_1.BriefingService])
+], BriefingHandler);
+//# sourceMappingURL=briefing.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/index.d.ts

@@ -16,4 +16,8 @@ export { RuleInsightsHandler } from './rule-insights.handler';
 export { ImpactHandler } from './impact.handler';
 export { PluginValidationHandler } from './plugin-validation.handler';
 export { ReleaseCheckHandler } from './release-check.handler';
+export { QualityReportHandler } from './quality-report.handler';
+export { BriefingHandler } from './briefing.handler';
+export { ResumeHandler } from './resume.handler';
+export { RuleImpactHandler } from './rule-impact.handler';
 export declare const TOOL_HANDLERS = "TOOL_HANDLERS";

package/dist/src/mcp/handlers/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_HANDLERS = exports.ReleaseCheckHandler = exports.PluginValidationHandler = exports.ImpactHandler = exports.RuleInsightsHandler = exports.ContextArchiveHandler = exports.PipelineHandler = exports.ParallelValidationHandler = exports.DiscussionHandler = exports.TuiHandler = exports.ContextDocumentHandler = exports.ConventionsHandler = exports.ChecklistContextHandler = exports.ModeHandler = exports.AgentHandler = exports.SkillHandler = exports.ConfigHandler = exports.RulesHandler = void 0;
+exports.TOOL_HANDLERS = exports.RuleImpactHandler = exports.ResumeHandler = exports.BriefingHandler = exports.QualityReportHandler = exports.ReleaseCheckHandler = exports.PluginValidationHandler = exports.ImpactHandler = exports.RuleInsightsHandler = exports.ContextArchiveHandler = exports.PipelineHandler = exports.ParallelValidationHandler = exports.DiscussionHandler = exports.TuiHandler = exports.ContextDocumentHandler = exports.ConventionsHandler = exports.ChecklistContextHandler = exports.ModeHandler = exports.AgentHandler = exports.SkillHandler = exports.ConfigHandler = exports.RulesHandler = void 0;
 var rules_handler_1 = require("./rules.handler");
 Object.defineProperty(exports, "RulesHandler", { enumerable: true, get: function () { return rules_handler_1.RulesHandler; } });
 var config_handler_1 = require("./config.handler");
@@ -35,5 +35,13 @@ var plugin_validation_handler_1 = require("./plugin-validation.handler");
 Object.defineProperty(exports, "PluginValidationHandler", { enumerable: true, get: function () { return plugin_validation_handler_1.PluginValidationHandler; } });
 var release_check_handler_1 = require("./release-check.handler");
 Object.defineProperty(exports, "ReleaseCheckHandler", { enumerable: true, get: function () { return release_check_handler_1.ReleaseCheckHandler; } });
+var quality_report_handler_1 = require("./quality-report.handler");
+Object.defineProperty(exports, "QualityReportHandler", { enumerable: true, get: function () { return quality_report_handler_1.QualityReportHandler; } });
+var briefing_handler_1 = require("./briefing.handler");
+Object.defineProperty(exports, "BriefingHandler", { enumerable: true, get: function () { return briefing_handler_1.BriefingHandler; } });
+var resume_handler_1 = require("./resume.handler");
+Object.defineProperty(exports, "ResumeHandler", { enumerable: true, get: function () { return resume_handler_1.ResumeHandler; } });
+var rule_impact_handler_1 = require("./rule-impact.handler");
+Object.defineProperty(exports, "RuleImpactHandler", { enumerable: true, get: function () { return rule_impact_handler_1.RuleImpactHandler; } });
 exports.TOOL_HANDLERS = 'TOOL_HANDLERS';
 //# sourceMappingURL=index.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

@@ -0,0 +1,14 @@
+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, ruleEventCollector: RuleEventCollector);
+    protected getHandledTools(): string[];
+    protected handleTool(_toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
+    getToolDefinitions(): ToolDefinition[];
+}