codingbuddy 5.2.0 → 5.4.0

package/dist/src/mcp/handlers/clarification-gate.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLARIFICATION_TOPICS = exports.MIN_PROMPT_LENGTH = exports.DEFAULT_QUESTION_BUDGET = void 0;
+exports.hasOverridePhrase = hasOverridePhrase;
+exports.hasVagueIntent = hasVagueIntent;
+exports.hasTechnicalReference = hasTechnicalReference;
+exports.evaluateClarification = evaluateClarification;
+exports.DEFAULT_QUESTION_BUDGET = 3;
+exports.MIN_PROMPT_LENGTH = 20;
+const OVERRIDE_PHRASE_PATTERNS = [
+    /\bjust\s+do\s+it\b/i,
+    /\buse\s+your\s+(?:judg(?:e)?ment|best\s+guess|discretion)\b/i,
+    /\bgo\s+ahead\b/i,
+    /\bmake\s+assumptions?\b/i,
+    /\bassume\s+(?:whatever|defaults?|reasonable)\b/i,
+    /알아서\s*(?:해|진행|처리)/,
+    /그냥\s*(?:해|진행)/,
+    /임의로\s*(?:해|진행)/,
+];
+const VAGUE_INTENT_PATTERNS = [
+    /\bimprove\b/i,
+    /\b(?:make\s+it\s+)?better\b/i,
+    /\benhance\b/i,
+    /\boptimi[sz]e\b/i,
+    /\brefactor\b/i,
+    /\bclean\s*up\b/i,
+    /\btweak\b/i,
+    /\bfix\s+(?:stuff|things|issues?)\b/i,
+    /개선/,
+    /향상/,
+    /최적화/,
+    /정리/,
+    /개량/,
+];
+const TECHNICAL_REFERENCE_PATTERNS = [
+    /\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|swift|rb|php|c|cpp|h|hpp|cs|md|mdx|json|ya?ml|toml|sql|sh|bash|zsh|vue|svelte|html|css|scss|sass|less)\b/i,
+    /(?:^|[\s([`"'])[\w.-]+\/[\w.\-/]+/,
+    /\b[a-zA-Z_][\w]*\(/,
+    /\b[A-Z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]+\b/,
+    /\b[a-z][a-z0-9]+[A-Z][a-zA-Z0-9]+\b/,
+    /\b[a-z]+_[a-z][a-z0-9_]*\b/,
+    /`[^`]+`/,
+];
+function hasOverridePhrase(prompt) {
+    return OVERRIDE_PHRASE_PATTERNS.some(pattern => pattern.test(prompt));
+}
+function hasVagueIntent(prompt) {
+    return VAGUE_INTENT_PATTERNS.some(pattern => pattern.test(prompt));
+}
+function hasTechnicalReference(prompt) {
+    return TECHNICAL_REFERENCE_PATTERNS.some(pattern => pattern.test(prompt));
+}
+exports.CLARIFICATION_TOPICS = {
+    VAGUE_INTENT: 'vague-intent',
+    TARGET_ARTIFACT: 'target-artifact',
+    REQUEST_SCOPE: 'request-scope',
+};
+const TOPIC_PRIORITY = [
+    exports.CLARIFICATION_TOPICS.VAGUE_INTENT,
+    exports.CLARIFICATION_TOPICS.TARGET_ARTIFACT,
+    exports.CLARIFICATION_TOPICS.REQUEST_SCOPE,
+];
+function buildNextQuestion(topics) {
+    if (topics.includes(exports.CLARIFICATION_TOPICS.VAGUE_INTENT)) {
+        return 'What concrete change are you targeting — which behavior, file, or metric should differ after this task?';
+    }
+    if (topics.includes(exports.CLARIFICATION_TOPICS.TARGET_ARTIFACT)) {
+        return 'Which file, function, module, or component should this change apply to?';
+    }
+    if (topics.includes(exports.CLARIFICATION_TOPICS.REQUEST_SCOPE)) {
+        return 'Can you describe the goal, inputs, and expected outcome in a bit more detail?';
+    }
+    return 'Can you clarify the scope and success criteria of this request?';
+}
+function sortTopicsByPriority(topics) {
+    return TOPIC_PRIORITY.filter(topic => topics.has(topic));
+}
+function evaluateClarification(prompt, options = {}) {
+    const budget = options.questionBudget ?? exports.DEFAULT_QUESTION_BUDGET;
+    const trimmed = (prompt ?? '').trim();
+    if (budget <= 0) {
+        return {
+            clarificationNeeded: false,
+            planReady: true,
+            questionBudget: 0,
+            assumptionNote: 'Clarification budget exhausted. Proceeding with explicit assumptions — state each assumption clearly in the plan using "assuming …" language so the user can correct course.',
+        };
+    }
+    if (hasOverridePhrase(trimmed)) {
+        return {
+            clarificationNeeded: false,
+            planReady: true,
+            questionBudget: budget,
+        };
+    }
+    const hasTech = hasTechnicalReference(trimmed);
+    if (hasTech) {
+        return {
+            clarificationNeeded: false,
+            planReady: true,
+            questionBudget: budget,
+        };
+    }
+    const topics = new Set();
+    if (hasVagueIntent(trimmed)) {
+        topics.add(exports.CLARIFICATION_TOPICS.VAGUE_INTENT);
+        topics.add(exports.CLARIFICATION_TOPICS.TARGET_ARTIFACT);
+    }
+    if (trimmed.length > 0 && trimmed.length < exports.MIN_PROMPT_LENGTH) {
+        topics.add(exports.CLARIFICATION_TOPICS.REQUEST_SCOPE);
+        topics.add(exports.CLARIFICATION_TOPICS.TARGET_ARTIFACT);
+    }
+    if (topics.size === 0) {
+        return {
+            clarificationNeeded: false,
+            planReady: true,
+            questionBudget: budget,
+        };
+    }
+    const orderedTopics = sortTopicsByPriority(topics);
+    return {
+        clarificationNeeded: true,
+        planReady: false,
+        questionBudget: budget - 1,
+        nextQuestion: buildNextQuestion(orderedTopics),
+        clarificationTopics: orderedTopics,
+    };
+}
+//# sourceMappingURL=clarification-gate.js.map

package/dist/src/mcp/handlers/council-scene.builder.d.ts

@@ -0,0 +1,9 @@
+import type { CouncilScene } from './council-scene.types';
+import type { CouncilPreset } from '../../agent/council-preset.types';
+import type { Mode, VisualData } from '../../keyword/keyword.types';
+export interface CouncilSceneFallback {
+    delegatesTo?: string;
+    specialists?: string[];
+}
+export declare function buildCouncilSceneInstructions(councilScene?: CouncilScene): string | undefined;
+export declare function buildCouncilScene(mode: Mode, councilPreset: CouncilPreset | undefined, visual: VisualData | undefined, fallback?: CouncilSceneFallback): CouncilScene | undefined;

package/dist/src/mcp/handlers/council-scene.builder.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCouncilSceneInstructions = buildCouncilSceneInstructions;
+exports.buildCouncilScene = buildCouncilScene;
+const DEFAULT_FACE = '●‿●';
+const MODERATOR_COPY = {
+    PLAN: 'Council assembled — let us design this together.',
+    EVAL: 'Review council convened — specialists are ready.',
+    AUTO: 'Autonomous council activated — full cycle begins.',
+};
+function buildCouncilSceneInstructions(councilScene) {
+    if (!councilScene?.enabled || !councilScene.cast?.length) {
+        return undefined;
+    }
+    const castLines = councilScene.cast.map(m => `${m.face} ${m.name} [${m.role}]`).join('\n');
+    return (`\n\n📋 COUNCIL SCENE — Render this at the start of your first response, ` +
+        `right after the mode header:\n\n` +
+        `${councilScene.moderatorCopy}\n${castLines}\n\n` +
+        `Then proceed with your normal ${councilScene.format || 'standard'} mode response.`);
+}
+function buildCouncilScene(mode, councilPreset, visual, fallback) {
+    if (mode === 'ACT') {
+        return undefined;
+    }
+    const moderatorCopy = MODERATOR_COPY[mode];
+    if (!moderatorCopy) {
+        return undefined;
+    }
+    const cast = buildCast(councilPreset, visual, fallback);
+    if (cast.length === 0) {
+        return undefined;
+    }
+    return {
+        enabled: true,
+        cast,
+        moderatorCopy,
+        format: 'tiny-actor-grid',
+    };
+}
+function buildCast(councilPreset, visual, fallback) {
+    const faceLookup = new Map();
+    if (visual?.agents) {
+        for (const agent of visual.agents) {
+            faceLookup.set(agent.name, agent.face);
+            const slug = agent.name.toLowerCase().replace(/\s+/g, '-');
+            faceLookup.set(slug, agent.face);
+        }
+    }
+    if (councilPreset) {
+        return buildCastFromPreset(councilPreset, faceLookup);
+    }
+    if (visual?.agents?.length) {
+        return buildCastFromVisual(visual.agents);
+    }
+    if (fallback?.delegatesTo) {
+        return buildCastFromFallback(fallback, faceLookup);
+    }
+    return [];
+}
+function buildCastFromPreset(preset, faceLookup) {
+    const cast = [];
+    cast.push({
+        name: preset.primary,
+        role: 'primary',
+        face: faceLookup.get(preset.primary) ?? DEFAULT_FACE,
+    });
+    for (const specialist of preset.specialists) {
+        cast.push({
+            name: specialist,
+            role: 'specialist',
+            face: faceLookup.get(specialist) ?? DEFAULT_FACE,
+        });
+    }
+    return cast;
+}
+function buildCastFromVisual(agents) {
+    const [first, ...rest] = agents;
+    const cast = [];
+    if (first) {
+        cast.push({
+            name: first.name,
+            role: 'primary',
+            face: first.face || DEFAULT_FACE,
+        });
+    }
+    for (const agent of rest) {
+        cast.push({
+            name: agent.name,
+            role: 'specialist',
+            face: agent.face || DEFAULT_FACE,
+        });
+    }
+    return cast;
+}
+function buildCastFromFallback(fallback, faceLookup) {
+    const cast = [];
+    if (fallback.delegatesTo) {
+        cast.push({
+            name: fallback.delegatesTo,
+            role: 'primary',
+            face: faceLookup.get(fallback.delegatesTo) ?? DEFAULT_FACE,
+        });
+    }
+    if (fallback.specialists) {
+        for (const specialist of fallback.specialists) {
+            cast.push({
+                name: specialist,
+                role: 'specialist',
+                face: faceLookup.get(specialist) ?? DEFAULT_FACE,
+            });
+        }
+    }
+    return cast;
+}
+//# sourceMappingURL=council-scene.builder.js.map

package/dist/src/mcp/handlers/council-scene.types.d.ts

@@ -0,0 +1,11 @@
+export interface CouncilSceneCastMember {
+    name: string;
+    role: 'primary' | 'specialist';
+    face: string;
+}
+export interface CouncilScene {
+    enabled: boolean;
+    cast: CouncilSceneCastMember[];
+    moderatorCopy: string;
+    format: 'tiny-actor-grid';
+}

package/dist/src/mcp/handlers/council-scene.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=council-scene.types.js.map

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

@@ -1,11 +1,15 @@
 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[];
     private handleAgentDiscussion;
+    private isExperimentalEnabled;
     private collectOpinions;
     private generateOpinion;
     private detectConsensus;

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'];
     }
@@ -39,9 +47,12 @@ let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.Abstr
         return [
             {
                 name: 'agent_discussion',
-                description: 'Conduct a structured discussion among specialist agents on a given topic. ' +
-                    'Collects opinions from each specialist, detects consensus or disagreement, ' +
-                    'and returns a structured summary with severity assessments.',
+                description: '[EXPERIMENTAL — disabled by default] Produces templated synthesis of ' +
+                    'specialist opinions, not real specialist execution. The output does ' +
+                    'not reflect collective intelligence from live agents; treat it as a ' +
+                    'placeholder until the rebuild lands. Enable by setting ' +
+                    `${discussion_types_1.EXPERIMENTAL_DISCUSSION_ENV}=1. When disabled, the tool returns ` +
+                    '{disabled: true} without invoking synthesis.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -66,6 +77,14 @@ let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.Abstr
         ];
     }
     async handleAgentDiscussion(args) {
+        if (!this.isExperimentalEnabled()) {
+            const disabled = {
+                disabled: true,
+                reason: discussion_types_1.DISABLED_DISCUSSION_REASON,
+                experimentalFlag: discussion_types_1.EXPERIMENTAL_DISCUSSION_ENV,
+            };
+            return (0, response_utils_1.createJsonResponse)(disabled);
+        }
         const topic = (0, validation_constants_1.extractRequiredString)(args, 'topic');
         if (topic === null) {
             return (0, response_utils_1.createErrorResponse)('Missing required parameter: topic');
@@ -79,7 +98,7 @@ let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.Abstr
         const consensus = this.detectConsensus(opinions);
         const maxSeverity = this.computeMaxSeverity(opinions);
         const summary = this.generateSummary(topic, opinions, consensus);
-        const result = {
+        const base = {
             topic,
             specialists,
             opinions,
@@ -87,8 +106,28 @@ let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.Abstr
             summary,
             maxSeverity,
         };
+        const result = {
+            ...base,
+            experimental: true,
+            warning: discussion_types_1.EXPERIMENTAL_DISCUSSION_WARNING,
+        };
+        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);
     }
+    isExperimentalEnabled() {
+        return process.env[discussion_types_1.EXPERIMENTAL_DISCUSSION_ENV] === '1';
+    }
     collectOpinions(topic, specialists, context) {
         return specialists.map(agent => this.generateOpinion(agent, topic, context));
     }
@@ -163,6 +202,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/discussion.types.d.ts

@@ -16,3 +16,15 @@ export interface DiscussionResult {
     maxSeverity: OpinionSeverity;
 }
 export declare const VALID_SEVERITIES: readonly OpinionSeverity[];
+export declare const EXPERIMENTAL_DISCUSSION_ENV = "CODINGBUDDY_EXPERIMENTAL_DISCUSSION";
+export declare const EXPERIMENTAL_DISCUSSION_WARNING = "\u26A0\uFE0F experimental \u2014 templated synthesis, not real specialist execution";
+export declare const DISABLED_DISCUSSION_REASON = "templated synthesis not aligned with collective intelligence promise";
+export interface DisabledDiscussionResult {
+    disabled: true;
+    reason: string;
+    experimentalFlag: string;
+}
+export interface ExperimentalDiscussionResult extends DiscussionResult {
+    experimental: true;
+    warning: string;
+}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALID_SEVERITIES = void 0;
+exports.DISABLED_DISCUSSION_REASON = exports.EXPERIMENTAL_DISCUSSION_WARNING = exports.EXPERIMENTAL_DISCUSSION_ENV = exports.VALID_SEVERITIES = void 0;
 exports.VALID_SEVERITIES = [
     'info',
     'low',
@@ -8,4 +8,7 @@ exports.VALID_SEVERITIES = [
     'high',
     'critical',
 ];
+exports.EXPERIMENTAL_DISCUSSION_ENV = 'CODINGBUDDY_EXPERIMENTAL_DISCUSSION';
+exports.EXPERIMENTAL_DISCUSSION_WARNING = '\u26a0\ufe0f experimental — templated synthesis, not real specialist execution';
+exports.DISABLED_DISCUSSION_REASON = 'templated synthesis not aligned with collective intelligence promise';
 //# sourceMappingURL=discussion.types.js.map

package/dist/src/mcp/handlers/execution-gate.d.ts

@@ -0,0 +1,29 @@
+import type { ClarificationMetadata } from './clarification-gate';
+import type { PlanningStageMetadata } from './planning-stage';
+export interface ExecutionGate {
+    gated: boolean;
+    reason: string;
+    unblockCondition?: string;
+    deferredSpecialists?: string[];
+}
+export interface ExecutionGateInput {
+    clarification: ClarificationMetadata;
+    planningStage?: PlanningStageMetadata;
+    specialists?: string[];
+}
+export declare function evaluateExecutionGate(input: ExecutionGateInput): ExecutionGate;
+interface GatedParallelRecommendation {
+    specialists: string[];
+    hint: string;
+    dispatch?: string;
+    suggestedStack?: string;
+    stackBased?: boolean;
+}
+export interface GatedResponseFields<D = unknown, E = unknown> {
+    dispatchReady?: D;
+    parallelAgentsRecommendation?: GatedParallelRecommendation;
+    executionPlan?: E;
+}
+export type SuppressedResponseFields<D = unknown, E = unknown> = GatedResponseFields<D, E>;
+export declare function suppressDispatchWhileGated<D, E>(gate: ExecutionGate | undefined, fields: GatedResponseFields<D, E>): SuppressedResponseFields<D, E>;
+export {};

package/dist/src/mcp/handlers/execution-gate.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExecutionGate = evaluateExecutionGate;
+exports.suppressDispatchWhileGated = suppressDispatchWhileGated;
+const GATED_STAGES = new Set(['discover', 'design']);
+function evaluateExecutionGate(input) {
+    const { clarification, planningStage, specialists } = input;
+    if (clarification.planReady) {
+        return {
+            gated: false,
+            reason: 'Request is clear — full specialist dispatch permitted.',
+        };
+    }
+    if (clarification.clarificationNeeded) {
+        return buildGatedResult('Request is ambiguous — specialist dispatch deferred until clarification is resolved.', 'Resolve clarification questions or provide an explicit override (e.g., "just do it").', specialists);
+    }
+    if (planningStage && GATED_STAGES.has(planningStage.currentStage)) {
+        const stageName = planningStage.currentStage;
+        return buildGatedResult(`Currently in ${stageName} stage — specialist dispatch deferred until plan stage.`, stageName === 'discover'
+            ? 'Confirm direction to proceed through Design to Plan.'
+            : 'Confirm approach to proceed to Plan.', specialists);
+    }
+    return {
+        gated: false,
+        reason: 'Execution permitted — no gating conditions active.',
+    };
+}
+function suppressDispatchWhileGated(gate, fields) {
+    if (!gate || !gate.gated) {
+        return fields;
+    }
+    const result = {};
+    if (fields.parallelAgentsRecommendation) {
+        result.parallelAgentsRecommendation = {
+            ...fields.parallelAgentsRecommendation,
+            dispatch: 'deferred',
+        };
+    }
+    return result;
+}
+function buildGatedResult(reason, unblockCondition, specialists) {
+    return {
+        gated: true,
+        reason,
+        unblockCondition,
+        ...(specialists?.length && { deferredSpecialists: [...specialists] }),
+    };
+}
+//# sourceMappingURL=execution-gate.js.map

package/dist/src/mcp/handlers/index.d.ts

@@ -20,4 +20,5 @@ export { QualityReportHandler } from './quality-report.handler';
 export { BriefingHandler } from './briefing.handler';
 export { ResumeHandler } from './resume.handler';
 export { RuleImpactHandler } from './rule-impact.handler';
+export { ReviewPrHandler } from './review-pr.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.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;
+exports.TOOL_HANDLERS = exports.ReviewPrHandler = 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");
@@ -43,5 +43,7 @@ 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; } });
+var review_pr_handler_1 = require("./review-pr.handler");
+Object.defineProperty(exports, "ReviewPrHandler", { enumerable: true, get: function () { return review_pr_handler_1.ReviewPrHandler; } });
 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>;
@@ -30,7 +36,14 @@ export declare class ModeHandler extends AbstractHandler {
     private buildDispatchReady;
     private buildDeepThinkingInstructions;
     private buildPlanReviewGate;
+    private buildClarificationMetadata;
+    private buildExecutionGate;
+    private buildClarificationFirstInstructions;
+    private buildPlanningStageMetadata;
     private buildAgentDiscussion;
+    private buildReviewContext;
     private buildVisual;
+    private resolveTeamsCapability;
+    private buildExecutionPlan;
     private persistModeState;
 }