codingbuddy 5.2.0 → 5.4.0

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

@@ -33,10 +33,18 @@ 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 clarification_gate_1 = require("./clarification-gate");
+const planning_stage_1 = require("./planning-stage");
+const execution_gate_1 = require("./execution-gate");
+const council_scene_builder_1 = require("./council-scene.builder");
 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 +54,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() {
@@ -73,6 +84,15 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
                             enum: ['minimal', 'standard', 'full'],
                             description: 'Control response detail level. minimal: metadata only; standard: truncated content (default); full: complete content',
                         },
+                        question_budget: {
+                            type: 'number',
+                            description: 'Clarification Gate budget (#1371). Maximum clarification questions remaining in this session. Defaults to 3 on the first call; pass the `questionBudget` returned from the previous PLAN response to decrement across rounds. When 0, the gate proceeds to planning with explicit assumptions.',
+                        },
+                        planning_stage: {
+                            type: 'string',
+                            enum: ['discover', 'design', 'plan'],
+                            description: 'Staged planning hint (#1372). Overrides automatic stage routing when the caller knows which stage to enter. Use "design" after the user confirms direction from Discover, or "plan" after the user confirms the approach from Design.',
+                        },
                     },
                     required: ['prompt'],
                 },
@@ -87,6 +107,15 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
         const recommendedAgent = (0, validation_constants_1.extractRequiredString)(args, 'recommended_agent') ?? undefined;
         const rawVerbosity = (0, validation_constants_1.extractRequiredString)(args, 'verbosity') ?? 'standard';
         const verbosity = (0, verbosity_types_1.isValidVerbosity)(rawVerbosity) ? rawVerbosity : 'standard';
+        const rawQuestionBudget = args?.['question_budget'];
+        const questionBudget = typeof rawQuestionBudget === 'number' && Number.isFinite(rawQuestionBudget)
+            ? rawQuestionBudget
+            : undefined;
+        const VALID_STAGES = new Set(['discover', 'design', 'plan']);
+        const rawPlanningStage = (0, validation_constants_1.extractRequiredString)(args, 'planning_stage') ?? undefined;
+        const planningStageHint = rawPlanningStage && VALID_STAGES.has(rawPlanningStage)
+            ? rawPlanningStage
+            : undefined;
         try {
             await this.configService.reload();
             let resolvedRecommendedAgent = recommendedAgent;
@@ -143,17 +172,53 @@ 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 reviewContext = this.buildReviewContext(result.mode, result.originalPrompt);
+            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 councilScene = (0, council_scene_builder_1.buildCouncilScene)(result.mode, councilPreset ?? undefined, visual, {
+                delegatesTo: result.delegates_to,
+                specialists: result.parallelAgentsRecommendation?.specialists,
+            });
+            const councilRenderInstructions = (0, council_scene_builder_1.buildCouncilSceneInstructions)(councilScene);
+            if (councilRenderInstructions) {
+                result.instructions += councilRenderInstructions;
+            }
+            const clarification = this.buildClarificationMetadata(result.mode, result.originalPrompt, questionBudget);
+            const clarificationInstructions = this.buildClarificationFirstInstructions(clarification);
+            const planningStage = this.buildPlanningStageMetadata(result.mode, clarification, planningStageHint);
+            const executionGate = this.buildExecutionGate(result.mode, clarification, planningStage, result.parallelAgentsRecommendation?.specialists);
+            const serializedExecutionPlan = executionPlan
+                ? (0, execution_plan_1.serializeExecutionPlan)(executionPlan)
+                : undefined;
+            const gatedFields = (0, execution_gate_1.suppressDispatchWhileGated)(executionGate, {
+                dispatchReady,
+                parallelAgentsRecommendation: result.parallelAgentsRecommendation,
+                executionPlan: serializedExecutionPlan,
+            });
             const response = (0, response_utils_1.createJsonResponse)({
                 ...result,
+                ...(clarificationInstructions !== undefined && { instructions: clarificationInstructions }),
                 language,
                 languageInstruction: languageInstructionResult.instruction,
                 resolvedModel,
-                ...(dispatchReady && { dispatchReady }),
+                ...(gatedFields.parallelAgentsRecommendation !== undefined && {
+                    parallelAgentsRecommendation: gatedFields.parallelAgentsRecommendation,
+                }),
+                ...(gatedFields.dispatchReady && { dispatchReady: gatedFields.dispatchReady }),
                 ...(deepThinkingInstructions && { deepThinkingInstructions }),
                 ...(planReviewGate && { planReviewGate }),
                 ...(agentDiscussion && { agentDiscussion }),
+                ...(reviewContext && { reviewContext }),
                 ...(visual && { visual }),
+                ...(councilPreset && { councilPreset }),
+                ...(councilScene && { councilScene }),
+                ...(gatedFields.executionPlan && { executionPlan: gatedFields.executionPlan }),
+                ...(teamsCapability && { teamsCapability }),
+                ...(clarification && clarification),
+                ...(planningStage && { planningStage }),
+                ...(executionGate && { executionGate }),
                 ...contextResult,
                 ...(projectRootWarning && { projectRootWarning }),
             });
@@ -165,6 +230,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) {
@@ -309,6 +384,55 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
             dispatch: 'recommend',
         };
     }
+    buildClarificationMetadata(mode, originalPrompt, questionBudget) {
+        if (mode !== 'PLAN' && mode !== 'AUTO') {
+            return undefined;
+        }
+        return (0, clarification_gate_1.evaluateClarification)(originalPrompt, {
+            ...(questionBudget !== undefined && { questionBudget }),
+        });
+    }
+    buildExecutionGate(mode, clarification, planningStage, specialists) {
+        if (mode !== 'PLAN' && mode !== 'AUTO') {
+            return undefined;
+        }
+        if (!clarification) {
+            return undefined;
+        }
+        return (0, execution_gate_1.evaluateExecutionGate)({
+            clarification,
+            planningStage,
+            specialists,
+        });
+    }
+    buildClarificationFirstInstructions(clarification) {
+        if (!clarification?.clarificationNeeded) {
+            return undefined;
+        }
+        const question = clarification.nextQuestion ??
+            'Can you clarify the scope and success criteria of this request?';
+        const budget = clarification.questionBudget ?? 0;
+        return ('🔴 CLARIFICATION REQUIRED — DO NOT PLAN.\n\n' +
+            'The request is ambiguous. You MUST:\n' +
+            '1. Ask EXACTLY the question below and STOP.\n' +
+            '2. Do NOT output any implementation plan, architecture, or code.\n' +
+            "3. Wait for the user's response before continuing.\n\n" +
+            `❓ Ask this: "${question}"\n\n` +
+            `Remaining question budget: ${budget}\n\n` +
+            'After the user answers, call parse_mode again with the clarified prompt ' +
+            `and question_budget=${budget} to continue.`);
+    }
+    buildPlanningStageMetadata(mode, clarification, stageHint) {
+        if (mode !== 'PLAN' && mode !== 'AUTO') {
+            return undefined;
+        }
+        if (!clarification) {
+            return undefined;
+        }
+        return (0, planning_stage_1.resolvePlanningStage)(clarification, {
+            ...(stageHint && { stageHint }),
+        });
+    }
     buildAgentDiscussion(mode, configValue) {
         if (mode !== 'EVAL') {
             return undefined;
@@ -320,6 +444,30 @@ let ModeHandler = ModeHandler_1 = class ModeHandler extends abstract_handler_1.A
             includeConsensus: true,
         };
     }
+    buildReviewContext(mode, originalPrompt) {
+        if (mode !== 'EVAL') {
+            return undefined;
+        }
+        const prMatch = originalPrompt.match(/(?:PR\s*#?(\d+)|pull\s*request\s*#?(\d+))/i);
+        if (!prMatch) {
+            return undefined;
+        }
+        const prNumber = parseInt(prMatch[1] ?? prMatch[2], 10);
+        if (isNaN(prNumber)) {
+            return undefined;
+        }
+        const issueMatch = originalPrompt.match(/issue\s*#?(\d+)/i);
+        const issueNumber = issueMatch ? parseInt(issueMatch[1], 10) : undefined;
+        const hintParams = issueNumber
+            ? `pr_number: ${prNumber}, issue_number: ${issueNumber}`
+            : `pr_number: ${prNumber}`;
+        return {
+            detected: true,
+            pr_number: prNumber,
+            ...(issueNumber && { issue_number: issueNumber }),
+            hint: `Call review_pr({ ${hintParams} }) to get structured review data including diff, checklists, and specialist recommendations.`,
+        };
+    }
     async buildVisual(mode, delegatesTo, specialists, eco) {
         try {
             const modeAgentName = `${mode.toLowerCase()}-mode`;
@@ -353,6 +501,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 +574,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/planning-contract.d.ts

@@ -0,0 +1,2 @@
+export declare const PLANNING_CONTRACT: readonly string[];
+export declare function resolvePlanningContract(mode: string, agentId?: string): readonly string[] | undefined;

package/dist/src/mcp/handlers/planning-contract.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLANNING_CONTRACT = void 0;
+exports.resolvePlanningContract = resolvePlanningContract;
+exports.PLANNING_CONTRACT = [
+    'Ask one clarifying question at a time — do not batch questions.',
+    'Wait for user confirmation before advancing to the next planning stage.',
+    'Use the recommended skill for the current stage (brainstorming for discover, writing-plans for plan).',
+    'Present 2-3 alternative approaches with trade-offs before settling on a direction.',
+    'Break implementation into bite-sized tasks (2-5 minutes each).',
+];
+const PLANNING_AGENT_IDS = new Set([
+    'technical-planner',
+    'solution-architect',
+    'plan-mode',
+    'auto-mode',
+]);
+const PLANNING_MODES = new Set(['PLAN', 'AUTO']);
+function resolvePlanningContract(mode, agentId) {
+    if (!PLANNING_MODES.has(mode.toUpperCase())) {
+        return undefined;
+    }
+    if (agentId && PLANNING_AGENT_IDS.has(agentId)) {
+        return exports.PLANNING_CONTRACT;
+    }
+    return undefined;
+}
+//# sourceMappingURL=planning-contract.js.map

package/dist/src/mcp/handlers/planning-stage.d.ts

@@ -0,0 +1,20 @@
+import type { ClarificationMetadata } from './clarification-gate';
+export type PlanningStage = 'discover' | 'design' | 'plan';
+export interface StageProgression {
+    completedStages: PlanningStage[];
+    currentStage: PlanningStage;
+    remainingStages: PlanningStage[];
+}
+export interface PlanningStageMetadata {
+    currentStage: PlanningStage;
+    stageDescription: string;
+    nextStage?: 'design' | 'plan';
+    stageTransitionHint?: string;
+    recommendedAgent?: string;
+    recommendedSkill?: string;
+    stageProgression?: StageProgression;
+}
+export interface PlanningStageOptions {
+    stageHint?: PlanningStage;
+}
+export declare function resolvePlanningStage(clarification: ClarificationMetadata, options?: PlanningStageOptions): PlanningStageMetadata;

package/dist/src/mcp/handlers/planning-stage.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePlanningStage = resolvePlanningStage;
+const STAGE_DESCRIPTIONS = {
+    discover: 'Discover: Surface questions, constraints, and the option space before committing to an approach.',
+    design: 'Design: Synthesize candidate approaches, compare trade-offs, and identify open risks.',
+    plan: 'Plan: Produce a concrete, step-by-step implementation plan.',
+};
+const STAGE_TRANSITION_HINTS = {
+    discover: 'Answer the clarification question(s) or confirm the direction to proceed to Design.',
+    design: 'Confirm the preferred approach to proceed to the concrete implementation Plan.',
+};
+const STAGE_AGENTS = {
+    discover: 'solution-architect',
+    design: 'solution-architect',
+    plan: 'technical-planner',
+};
+const STAGE_SKILLS = {
+    discover: 'brainstorming',
+    design: undefined,
+    plan: 'writing-plans',
+};
+function resolvePlanningStage(clarification, options = {}) {
+    const stage = resolveStage(clarification, options);
+    return {
+        currentStage: stage,
+        stageDescription: STAGE_DESCRIPTIONS[stage],
+        ...(stage !== 'plan' && { nextStage: getNextStage(stage) }),
+        ...(stage !== 'plan' && {
+            stageTransitionHint: STAGE_TRANSITION_HINTS[stage],
+        }),
+        recommendedAgent: STAGE_AGENTS[stage],
+        ...(STAGE_SKILLS[stage] && { recommendedSkill: STAGE_SKILLS[stage] }),
+        stageProgression: buildStageProgression(stage),
+    };
+}
+function resolveStage(clarification, options) {
+    if (options.stageHint) {
+        return options.stageHint;
+    }
+    if (clarification.clarificationNeeded) {
+        return 'discover';
+    }
+    return 'discover';
+}
+function getNextStage(stage) {
+    return stage === 'discover' ? 'design' : 'plan';
+}
+const ALL_STAGES = ['discover', 'design', 'plan'];
+function buildStageProgression(currentStage) {
+    const currentIndex = ALL_STAGES.indexOf(currentStage);
+    return {
+        completedStages: ALL_STAGES.slice(0, currentIndex),
+        currentStage,
+        remainingStages: ALL_STAGES.slice(currentIndex + 1),
+    };
+}
+//# sourceMappingURL=planning-stage.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/mcp/handlers/review-pr.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 { ReviewPrService } from '../../ship/review-pr.service';
+export declare class ReviewPrHandler extends AbstractHandler {
+    private readonly reviewPrService;
+    private readonly logger;
+    constructor(reviewPrService: ReviewPrService);
+    protected getHandledTools(): string[];
+    protected handleTool(_toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
+    getToolDefinitions(): ToolDefinition[];
+}

package/dist/src/mcp/handlers/review-pr.handler.js

@@ -0,0 +1,81 @@
+"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 ReviewPrHandler_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewPrHandler = void 0;
+const common_1 = require("@nestjs/common");
+const abstract_handler_1 = require("./abstract-handler");
+const review_pr_service_1 = require("../../ship/review-pr.service");
+const response_utils_1 = require("../response.utils");
+let ReviewPrHandler = ReviewPrHandler_1 = class ReviewPrHandler extends abstract_handler_1.AbstractHandler {
+    constructor(reviewPrService) {
+        super();
+        this.reviewPrService = reviewPrService;
+        this.logger = new common_1.Logger(ReviewPrHandler_1.name);
+    }
+    getHandledTools() {
+        return ['review_pr'];
+    }
+    async handleTool(_toolName, args) {
+        try {
+            const prNumber = args?.pr_number;
+            if (typeof prNumber !== 'number' || !Number.isFinite(prNumber) || prNumber <= 0) {
+                return (0, response_utils_1.createErrorResponse)('pr_number is required and must be a positive number');
+            }
+            const issueNumber = typeof args?.issue_number === 'number' && args.issue_number > 0
+                ? args.issue_number
+                : undefined;
+            const timeout = typeof args?.timeout === 'number' && args.timeout > 0 ? args.timeout : 30000;
+            const result = await this.reviewPrService.reviewPr({
+                prNumber,
+                issueNumber,
+                timeout,
+            });
+            return (0, response_utils_1.createJsonResponse)(result);
+        }
+        catch (error) {
+            this.logger.error(`review_pr failed: ${error}`);
+            return (0, response_utils_1.createErrorResponse)(`review_pr failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'review_pr',
+                description: 'Fetch PR metadata, diff, checklists, and specialist recommendations for EVAL-mode PR review. Returns structured data for comprehensive code review.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pr_number: {
+                            type: 'number',
+                            description: 'PR number to review',
+                        },
+                        issue_number: {
+                            type: 'number',
+                            description: 'Optional linked issue number for spec compliance check',
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Timeout in milliseconds (default: 30000)',
+                        },
+                    },
+                    required: ['pr_number'],
+                },
+            },
+        ];
+    }
+};
+exports.ReviewPrHandler = ReviewPrHandler;
+exports.ReviewPrHandler = ReviewPrHandler = ReviewPrHandler_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [review_pr_service_1.ReviewPrService])
+], ReviewPrHandler);
+//# sourceMappingURL=review-pr.handler.js.map

package/dist/src/mcp/mcp.module.js

@@ -46,6 +46,7 @@ const handlers = [
     handlers_1.PluginValidationHandler,
     handlers_1.ReleaseCheckHandler,
     handlers_1.QualityReportHandler,
+    handlers_1.ReviewPrHandler,
     handlers_1.BriefingHandler,
     handlers_1.ResumeHandler,
     handlers_1.RuleImpactHandler,

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;

package/dist/src/rules/skill.schema.js

@@ -13,6 +13,30 @@ class SkillSchemaError extends Error {
     }
 }
 exports.SkillSchemaError = SkillSchemaError;
+function splitAllowedTools(s) {
+    const result = [];
+    let current = '';
+    let depth = 0;
+    for (const ch of s) {
+        if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            const trimmed = current.trim();
+            if (trimmed)
+                result.push(trimmed);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    const trimmed = current.trim();
+    if (trimmed)
+        result.push(trimmed);
+    return result;
+}
 const SkillFrontmatterTriggerSchema = z.object({
     pattern: z.string().min(1),
     confidence: z.enum(['high', 'medium', 'low']),
@@ -24,6 +48,13 @@ const SkillFrontmatterSchema = z.object({
         .regex(/^[a-z0-9-]+$/, 'Skill name must be lowercase alphanumeric with hyphens only'),
     description: z.string().min(1).max(500),
     triggers: z.array(SkillFrontmatterTriggerSchema).optional(),
+    'user-invocable': z.boolean().optional(),
+    'disable-model-invocation': z.boolean().optional(),
+    context: z.string().optional(),
+    agent: z.string().optional(),
+    'allowed-tools': z
+        .union([z.array(z.string()), z.string().transform(s => splitAllowedTools(s))])
+        .optional(),
 });
 const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 function parseFrontmatter(content) {
@@ -65,6 +96,11 @@ function parseSkill(content, filePath) {
         content: body,
         path: filePath,
         triggers: result.data.triggers,
+        userInvocable: result.data['user-invocable'],
+        disableModelInvocation: result.data['disable-model-invocation'],
+        context: result.data.context,
+        agent: result.data.agent,
+        allowedTools: result.data['allowed-tools'],
     };
 }
 //# sourceMappingURL=skill.schema.js.map