codingbuddy 5.3.0 → 5.4.0

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

@@ -38,6 +38,10 @@ 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, councilPresetService, teamsCapabilityService, impactEventService, ruleEventCollector) {
@@ -80,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'],
                 },
@@ -94,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;
@@ -150,23 +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 }),
-                ...(executionPlan && { executionPlan: (0, execution_plan_1.serializeExecutionPlan)(executionPlan) }),
+                ...(councilScene && { councilScene }),
+                ...(gatedFields.executionPlan && { executionPlan: gatedFields.executionPlan }),
                 ...(teamsCapability && { teamsCapability }),
+                ...(clarification && clarification),
+                ...(planningStage && { planningStage }),
+                ...(executionGate && { executionGate }),
                 ...contextResult,
                 ...(projectRootWarning && { projectRootWarning }),
             });
@@ -332,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;
@@ -343,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`;

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/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/shared/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "5.3.0";
+export declare const VERSION = "5.4.0";

package/dist/src/shared/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '5.3.0';
+exports.VERSION = '5.4.0';
 //# sourceMappingURL=version.js.map

package/dist/src/ship/review-pr.service.d.ts

@@ -0,0 +1,15 @@
+import { ChecklistService } from '../checklist/checklist.service';
+import type { ReviewPrInput, ReviewPrResult } from './review-pr.types';
+export declare class ReviewPrService {
+    private readonly checklistService;
+    private readonly logger;
+    private readonly mapper;
+    constructor(checklistService: ChecklistService);
+    reviewPr(input: ReviewPrInput): Promise<ReviewPrResult>;
+    private fetchPrMeta;
+    private fetchPrDiff;
+    private generateChecklists;
+    private mapSpecialists;
+    private fetchIssueCriteria;
+    private buildReviewProtocol;
+}

package/dist/src/ship/review-pr.service.js

@@ -0,0 +1,136 @@
+"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 ReviewPrService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewPrService = void 0;
+const common_1 = require("@nestjs/common");
+const child_process_1 = require("child_process");
+const file_specialist_mapper_1 = require("./file-specialist-mapper");
+const checklist_service_1 = require("../checklist/checklist.service");
+let ReviewPrService = ReviewPrService_1 = class ReviewPrService {
+    constructor(checklistService) {
+        this.checklistService = checklistService;
+        this.logger = new common_1.Logger(ReviewPrService_1.name);
+        this.mapper = new file_specialist_mapper_1.FileSpecialistMapper();
+    }
+    async reviewPr(input) {
+        const start = Date.now();
+        const { prNumber, issueNumber } = input;
+        const prMeta = this.fetchPrMeta(prNumber);
+        const diff = this.fetchPrDiff(prNumber);
+        const checklists = await this.generateChecklists(prMeta.changedFiles);
+        const recommendedSpecialists = this.mapSpecialists(prMeta.changedFiles);
+        const acceptanceCriteria = issueNumber ? this.fetchIssueCriteria(issueNumber) : null;
+        const reviewProtocol = this.buildReviewProtocol(prNumber, issueNumber);
+        return {
+            prMeta,
+            diff,
+            checklists,
+            recommendedSpecialists,
+            acceptanceCriteria,
+            reviewProtocol,
+            duration: Date.now() - start,
+        };
+    }
+    fetchPrMeta(prNumber) {
+        try {
+            const raw = (0, child_process_1.execSync)(`gh pr view ${prNumber} --json title,headRefName,files,additions,deletions`, { encoding: 'utf-8', timeout: 15000 });
+            const data = JSON.parse(raw);
+            return {
+                title: data.title ?? '',
+                branch: data.headRefName ?? '',
+                changedFiles: (data.files ?? []).map((f) => f.path),
+                additions: data.additions ?? 0,
+                deletions: data.deletions ?? 0,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch PR #${prNumber}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    fetchPrDiff(prNumber) {
+        try {
+            return (0, child_process_1.execSync)(`gh pr diff ${prNumber}`, {
+                encoding: 'utf-8',
+                timeout: 15000,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+        }
+        catch (error) {
+            this.logger.warn(`Failed to fetch diff for PR #${prNumber}: ${error}`);
+            return '';
+        }
+    }
+    async generateChecklists(changedFiles) {
+        if (changedFiles.length === 0)
+            return [];
+        try {
+            const result = await this.checklistService.generateChecklist({
+                files: changedFiles,
+            });
+            return result.checklists;
+        }
+        catch (error) {
+            this.logger.warn(`Checklist generation failed: ${error}`);
+            return [];
+        }
+    }
+    mapSpecialists(changedFiles) {
+        const mapped = this.mapper.mapFiles(changedFiles);
+        const specialists = [...new Set(mapped.map(m => m.specialist))];
+        return specialists;
+    }
+    fetchIssueCriteria(issueNumber) {
+        try {
+            const raw = (0, child_process_1.execSync)(`gh issue view ${issueNumber} --json body`, {
+                encoding: 'utf-8',
+                timeout: 10000,
+            });
+            const data = JSON.parse(raw);
+            const body = data.body ?? '';
+            const criteriaMatch = body.match(/## Acceptance criteria\s*\n([\s\S]*?)(?=\n## |\n---|$)/i);
+            return criteriaMatch ? criteriaMatch[1].trim() : body.slice(0, 2000);
+        }
+        catch {
+            return null;
+        }
+    }
+    buildReviewProtocol(prNumber, issueNumber) {
+        const issueCmd = issueNumber ? `\ngh issue view ${issueNumber}` : '';
+        return [
+            'Follow the canonical PR review cycle (pr-review-cycle.md):',
+            '',
+            '1. CI GATE (BLOCKING): gh pr checks ' + prNumber,
+            '2. LOCAL VERIFICATION: yarn lint && yarn type-check',
+            '3. READ THE DIFF: gh pr diff ' + prNumber,
+            '4. CODE QUALITY SCAN: unused imports, any types, missing error handling, dead code',
+            '5. SPEC COMPLIANCE: ' + (issueNumber ? `gh issue view ${issueNumber}` : 'N/A'),
+            '6. TEST COVERAGE: new logic tested? edge cases covered?',
+            '7. WRITE REVIEW: gh pr review ' + prNumber + ' --comment --body "<structured review>"',
+            '',
+            'Severity scale: critical / high / medium / low (see severity-classification.md)',
+            'Approval gate: Critical=0 AND High=0',
+            '',
+            'Commands:',
+            `gh pr checks ${prNumber}`,
+            `gh pr diff ${prNumber}`,
+            issueCmd,
+        ]
+            .filter(Boolean)
+            .join('\n');
+    }
+};
+exports.ReviewPrService = ReviewPrService;
+exports.ReviewPrService = ReviewPrService = ReviewPrService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [checklist_service_1.ChecklistService])
+], ReviewPrService);
+//# sourceMappingURL=review-pr.service.js.map

package/dist/src/ship/review-pr.types.d.ts

@@ -0,0 +1,21 @@
+export interface ReviewPrInput {
+    prNumber: number;
+    issueNumber?: number;
+    timeout?: number;
+}
+export interface PrMeta {
+    title: string;
+    branch: string;
+    changedFiles: string[];
+    additions: number;
+    deletions: number;
+}
+export interface ReviewPrResult {
+    prMeta: PrMeta;
+    diff: string;
+    checklists: unknown[];
+    recommendedSpecialists: string[];
+    acceptanceCriteria: string | null;
+    reviewProtocol: string;
+    duration: number;
+}

package/dist/src/ship/review-pr.types.js

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

package/dist/src/ship/ship.module.js

@@ -8,14 +8,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShipModule = void 0;
 const common_1 = require("@nestjs/common");
+const checklist_module_1 = require("../checklist/checklist.module");
 const quality_report_service_1 = require("./quality-report.service");
+const review_pr_service_1 = require("./review-pr.service");
 let ShipModule = class ShipModule {
 };
 exports.ShipModule = ShipModule;
 exports.ShipModule = ShipModule = __decorate([
     (0, common_1.Module)({
-        providers: [quality_report_service_1.QualityReportService],
-        exports: [quality_report_service_1.QualityReportService],
+        imports: [checklist_module_1.ChecklistModule],
+        providers: [quality_report_service_1.QualityReportService, review_pr_service_1.ReviewPrService],
+        exports: [quality_report_service_1.QualityReportService, review_pr_service_1.ReviewPrService],
     })
 ], ShipModule);
 //# sourceMappingURL=ship.module.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codingbuddy",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "Multi-AI Rules MCP Server - One source of truth for AI coding rules across all AI assistants",
   "author": "JeremyDev87",
   "license": "MIT",
@@ -77,7 +77,7 @@
     "@nestjs/core": "11.1.9",
     "@nestjs/platform-express": "11.1.9",
     "chalk": "5.4.1",
-    "codingbuddy-rules": "5.3.0",
+    "codingbuddy-rules": "5.4.0",
     "eventemitter2": "6.4.9",
     "ink": "6.7.0",
     "minimatch": "10.2.3",

package/dist/src/collaboration/council-summary.service.d.ts

@@ -1,2 +0,0 @@
-import type { CouncilInput, CouncilSummary } from './council-summary.types';
-export declare function generateCouncilSummary(inputs: readonly CouncilInput[]): CouncilSummary;