codingbuddy 5.2.0 → 5.4.0

package/dist/src/keyword/keyword.service.js

@@ -12,9 +12,12 @@ const rule_filter_1 = require("./rule-filter");
 const skill_content_utils_1 = require("../skill/skill-content.utils");
 const agent_summary_utils_1 = require("../agent/agent-summary.utils");
 const rules_content_utils_1 = require("../rules/rules-content.utils");
+const permission_forecast_1 = require("./permission-forecast");
 const keyword_core_1 = require("../shared/keyword-core");
 const taskmaestro_detector_1 = require("./taskmaestro-detector");
 const diff_analyzer_1 = require("./diff-analyzer");
+const stack_matcher_1 = require("../agent/stack-matcher");
+const planning_contract_1 = require("../mcp/handlers/planning-contract");
 const BASE_CONFIG = (0, keyword_core_1.getDefaultModeConfig)();
 const DEFAULT_CONFIG = {
     modes: {
@@ -109,6 +112,7 @@ class KeywordService {
         this.getMaxIncludedSkillsFn = options?.getMaxIncludedSkillsFn;
         this.getClientTypeFn = options?.getClientTypeFn;
         this.trackRuleUsageFn = options?.trackRuleUsageFn;
+        this.loadStacksFn = options?.loadStacksFn;
         this.cacheTTL = process.env.NODE_ENV === 'production' ? 3600000 : 300000;
     }
     async parseMode(prompt, options) {
@@ -187,13 +191,16 @@ class KeywordService {
         }
         const resolvedAgent = await this.resolvePrimaryAgent(mode, originalPrompt, modeConfig.delegates_to, options?.context, recommendedActAgent, diffAnalysis ?? undefined);
         await this.addAgentInfoToResult(result, resolvedAgent);
-        this.addParallelAgentsToResult(result, mode, config, originalPrompt);
+        await this.addParallelAgentsToResult(result, mode, config, originalPrompt);
         await this.addActRecommendationToResult(result, mode, originalPrompt);
         this.addActivationMessageToResult(result, resolvedAgent);
         this.addDisplayInstructionToResult(result, mode);
         await this.addAutoConfigToResult(result, mode);
         this.addComplexityToResult(result, mode, originalPrompt);
         await this.addIncludedSkillsToResult(result, originalPrompt, options);
+        if (mode === 'PLAN' || mode === 'AUTO') {
+            await this.enforceRequiredAgentSkills(result, options);
+        }
         await this.addIncludedAgentToResult(result, mode, options);
         const taskmaestroInstalled = (0, taskmaestro_detector_1.isTaskmaestroAvailable)();
         result.availableStrategies = taskmaestroInstalled ? ['subagent', 'taskmaestro'] : ['subagent'];
@@ -202,6 +209,7 @@ class KeywordService {
                 'TaskMaestro skill not found at ~/.claude/skills/taskmaestro/SKILL.md. To enable tmux-based parallel specialist execution, install the taskmaestro skill.';
         }
         this.addReleaseChecklistIfNeeded(result, mode, originalPrompt);
+        result.permissionForecast = (0, permission_forecast_1.generatePermissionForecast)(mode, originalPrompt);
         return result;
     }
     addReleaseChecklistIfNeeded(result, mode, originalPrompt) {
@@ -241,8 +249,8 @@ class KeywordService {
             result.delegate_agent_info = delegateAgentInfo;
         }
     }
-    addParallelAgentsToResult(result, mode, config, originalPrompt) {
-        const recommendation = this.getParallelAgentsRecommendation(mode, config, originalPrompt);
+    async addParallelAgentsToResult(result, mode, config, originalPrompt) {
+        const recommendation = await this.getParallelAgentsRecommendation(mode, config, originalPrompt);
         if (recommendation) {
             result.parallelAgentsRecommendation = recommendation;
         }
@@ -335,6 +343,58 @@ class KeywordService {
             this.logger.warn(`Failed to auto-include skills: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    async enforceRequiredAgentSkills(result, options) {
+        if (!this.loadAgentInfoFn || !this.loadSkillContentFn || !result.delegates_to)
+            return;
+        try {
+            const agentData = await this.loadAgentInfoFn(result.delegates_to);
+            const requiredSkillNames = this.extractRequiredSkillNames(agentData);
+            if (requiredSkillNames.length === 0)
+                return;
+            const verbosity = options?.verbosity ?? 'standard';
+            if (!result.included_skills) {
+                result.included_skills = [];
+            }
+            for (const skillName of requiredSkillNames) {
+                const existingIndex = result.included_skills.findIndex(s => s.name === skillName);
+                const content = await this.loadSkillContentFn(skillName);
+                if (!content)
+                    continue;
+                const enforcedSkill = {
+                    name: content.name,
+                    description: content.description,
+                    content: verbosity === 'minimal' ? '' : content.content,
+                    reason: 'Required by planning agent',
+                };
+                if (existingIndex >= 0) {
+                    result.included_skills[existingIndex] = enforcedSkill;
+                }
+                else {
+                    result.included_skills.push(enforcedSkill);
+                }
+            }
+            result.requiredSkillsEnforced = true;
+            result.requiredSkillNames = requiredSkillNames;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to enforce required agent skills: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    extractRequiredSkillNames(agentData) {
+        if (!agentData || typeof agentData !== 'object')
+            return [];
+        const agent = agentData;
+        const skills = agent.skills;
+        if (!skills || typeof skills !== 'object')
+            return [];
+        const required = skills.required;
+        if (!Array.isArray(required))
+            return [];
+        return required
+            .filter((s) => typeof s === 'object' && s !== null)
+            .map(s => s.name)
+            .filter((n) => typeof n === 'string');
+    }
     async getMaxIncludedSkills() {
         if (!this.getMaxIncludedSkillsFn)
             return keyword_types_1.DEFAULT_MAX_INCLUDED_SKILLS;
@@ -407,15 +467,34 @@ class KeywordService {
                     expertise: summary.expertise,
                 };
             }
+            const planningContract = (0, planning_contract_1.resolvePlanningContract)(mode, result.delegates_to);
+            if (planningContract) {
+                result.included_agent.planningContract = [...planningContract];
+            }
             this.logger.log(`Auto-included agent: ${agentPrompt.displayName} (verbosity: ${verbosity})`);
         }
     }
     getPrimaryAgentTier(agentName) {
         return keyword_types_1.ALL_PRIMARY_AGENTS.includes(agentName) ? 'primary' : 'specialist';
     }
-    getParallelAgentsRecommendation(mode, config, prompt) {
+    async getParallelAgentsRecommendation(mode, config, prompt) {
         const modeConfig = config.modes[mode];
-        const baseSpecialists = modeConfig?.defaultSpecialists ?? [];
+        const defaultSpecialists = modeConfig?.defaultSpecialists ?? [];
+        let stackResult = null;
+        let stackSpecialists;
+        if (prompt && this.loadStacksFn) {
+            try {
+                const stacks = await this.loadStacksFn();
+                stackResult = (0, stack_matcher_1.matchStack)(prompt, stacks);
+                if (stackResult) {
+                    const matched = stacks.find(s => s.name === stackResult.stackName);
+                    stackSpecialists = matched?.specialist_agents;
+                }
+            }
+            catch {
+            }
+        }
+        const baseSpecialists = stackSpecialists?.length ? stackSpecialists : defaultSpecialists;
         const contextSpecialists = prompt ? this.getContextAwareSpecialists(prompt) : [];
         const allSpecialists = [...new Set([...baseSpecialists, ...contextSpecialists])];
         if (allSpecialists.length === 0) {
@@ -432,10 +511,15 @@ class KeywordService {
         else {
             hint = `Use Task tool with subagent_type="general-purpose" and run_in_background=true for each specialist. Call prepare_parallel_agents MCP tool to get ready-to-use prompts.`;
         }
-        return {
+        const result = {
             specialists: allSpecialists,
             hint,
         };
+        if (stackResult) {
+            result.suggestedStack = stackResult.stackName;
+            result.stackBased = true;
+        }
+        return result;
     }
     getContextAwareSpecialists(prompt) {
         const specialists = [];

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

@@ -1,6 +1,21 @@
 import type { DiffAnalysisResult } from './diff-analyzer';
+import type { CouncilPreset } from '../agent/council-preset.types';
+import type { ExecutionPlan } from '../agent/execution-plan.types';
+import type { TeamsCapabilityStatus } from '../agent/teams-capability.types';
 export declare const KEYWORDS: readonly ["PLAN", "ACT", "EVAL", "AUTO"];
 export type Mode = (typeof KEYWORDS)[number];
+export type PermissionClass = 'read-only' | 'repo-write' | 'network' | 'destructive' | 'external';
+export interface ApprovalBundle {
+    name: string;
+    actions: string[];
+    permissionClass: PermissionClass;
+    reason: string;
+}
+export interface PermissionForecast {
+    permissionClasses: PermissionClass[];
+    approvalBundles: ApprovalBundle[];
+    permissionSummary: string;
+}
 export declare const MODE_AGENTS: readonly ["plan-mode", "act-mode", "eval-mode", "auto-mode"];
 export declare const PLAN_PRIMARY_AGENTS: readonly ["solution-architect", "technical-planner"];
 export declare const ACT_PRIMARY_AGENTS: readonly ["tooling-engineer", "platform-engineer", "data-engineer", "data-scientist", "ai-ml-engineer", "mobile-developer", "frontend-developer", "backend-developer", "devops-engineer", "agent-architect", "test-engineer", "security-engineer", "systems-developer", "software-engineer"];
@@ -41,6 +56,8 @@ export interface ParallelAgentRecommendation {
     specialists: string[];
     hint: string;
     dispatch?: DispatchStrength;
+    suggestedStack?: string;
+    stackBased?: boolean;
 }
 export interface IncludedSkill {
     name: string;
@@ -52,6 +69,7 @@ export interface IncludedAgent {
     name: string;
     systemPrompt: string;
     expertise: string[];
+    planningContract?: string[];
 }
 export type PrimaryAgentSource = 'explicit' | 'explicit_patterns' | 'config' | 'intent' | 'context' | 'default';
 export interface PrimaryAgentResolutionResult {
@@ -118,6 +136,12 @@ export interface ParseModeResult {
     taskmaestroInstallHint?: string;
     visual?: VisualData;
     diffAnalysis?: DiffAnalysisResult;
+    councilPreset?: CouncilPreset;
+    requiredSkillsEnforced?: boolean;
+    requiredSkillNames?: string[];
+    executionPlan?: ExecutionPlan;
+    teamsCapability?: TeamsCapabilityStatus;
+    permissionForecast?: PermissionForecast;
 }
 export interface DispatchReadyParams {
     subagent_type: 'general-purpose';
@@ -157,6 +181,12 @@ export interface VisualData {
     collaboration: CollaborationConfig;
 }
 export type { DiffAnalysisResult, DiffAgentScore } from './diff-analyzer';
+export interface ReviewContext {
+    detected: boolean;
+    pr_number: number;
+    issue_number?: number;
+    hint: string;
+}
 export interface ModeConfig {
     description: string;
     instructions: string;

package/dist/src/keyword/permission-forecast.d.ts

@@ -0,0 +1,2 @@
+import type { Mode, PermissionForecast } from './keyword.types';
+export declare function generatePermissionForecast(mode: Mode, prompt: string): PermissionForecast;

package/dist/src/keyword/permission-forecast.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePermissionForecast = generatePermissionForecast;
+const SHIP_PATTERNS = /\b(ship|deploy|push|pr\b|pull\s*request|merge|release)\b/i;
+const TEST_PATTERNS = /\b(tests?|lint|typecheck|format|check|verify|coverage)\b/i;
+const INSTALL_PATTERNS = /\b(install|add\s+package|add\s+dependency|yarn\s+add|npm\s+install)\b/i;
+const DELETE_PATTERNS = /\b(delete|remove|drop|reset|clean|destroy)\b/i;
+const REVIEW_PATTERNS = /\b(review|comment|approve|feedback|pr\b|pull\s*request)\b/i;
+const SHIP_BUNDLE = {
+    name: 'Ship changes',
+    actions: ['git add', 'git commit', 'git push', 'gh pr create'],
+    permissionClass: 'external',
+    reason: 'Committing, pushing, and creating a PR requires repo-write and GitHub API access',
+};
+const TEST_BUNDLE = {
+    name: 'Run checks',
+    actions: ['yarn test', 'yarn lint', 'yarn typecheck'],
+    permissionClass: 'read-only',
+    reason: 'Running tests and linters reads the codebase but does not modify it',
+};
+const INSTALL_BUNDLE = {
+    name: 'Install dependencies',
+    actions: ['yarn install', 'yarn add'],
+    permissionClass: 'network',
+    reason: 'Package installation fetches from external registries',
+};
+const REVIEW_BUNDLE = {
+    name: 'Review PR',
+    actions: ['gh pr review', 'gh pr comment'],
+    permissionClass: 'external',
+    reason: 'Reviewing or commenting on a PR uses the GitHub API',
+};
+const MODE_BASE_CLASSES = {
+    PLAN: ['read-only'],
+    ACT: ['read-only', 'repo-write'],
+    EVAL: ['read-only'],
+    AUTO: ['read-only', 'repo-write', 'external'],
+};
+function generatePermissionForecast(mode, prompt) {
+    const classes = new Set(MODE_BASE_CLASSES[mode]);
+    const bundles = [];
+    if (SHIP_PATTERNS.test(prompt)) {
+        classes.add('repo-write');
+        classes.add('external');
+        bundles.push(SHIP_BUNDLE);
+    }
+    if (TEST_PATTERNS.test(prompt)) {
+        bundles.push(TEST_BUNDLE);
+    }
+    if (INSTALL_PATTERNS.test(prompt)) {
+        classes.add('network');
+        bundles.push(INSTALL_BUNDLE);
+    }
+    if (DELETE_PATTERNS.test(prompt)) {
+        classes.add('destructive');
+    }
+    if (REVIEW_PATTERNS.test(prompt) && mode === 'EVAL') {
+        classes.add('external');
+        bundles.push(REVIEW_BUNDLE);
+    }
+    if (mode === 'ACT' && bundles.length === 0) {
+        bundles.push({
+            name: 'Code changes',
+            actions: ['file edit', 'git add', 'git commit'],
+            permissionClass: 'repo-write',
+            reason: 'Implementation involves editing files and creating commits',
+        });
+    }
+    const permissionClasses = sortPermissionClasses([...classes]);
+    return {
+        permissionClasses,
+        approvalBundles: bundles,
+        permissionSummary: buildSummary(mode, permissionClasses, bundles),
+    };
+}
+const CLASS_ORDER = [
+    'read-only',
+    'repo-write',
+    'network',
+    'destructive',
+    'external',
+];
+function sortPermissionClasses(classes) {
+    return [...classes].sort((a, b) => CLASS_ORDER.indexOf(a) - CLASS_ORDER.indexOf(b));
+}
+function buildSummary(mode, classes, bundles) {
+    const highest = classes[classes.length - 1];
+    const bundleNames = bundles.map(b => b.name).join(', ');
+    if (bundles.length === 0) {
+        return `${mode} mode requires ${highest} permissions`;
+    }
+    return `${mode} mode requires ${highest} permissions — expected actions: ${bundleNames}`;
+}
+//# sourceMappingURL=permission-forecast.js.map

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+export declare const DEFAULT_QUESTION_BUDGET = 3;
+export declare const MIN_PROMPT_LENGTH = 20;
+export interface ClarificationOptions {
+    questionBudget?: number;
+}
+export interface ClarificationMetadata {
+    clarificationNeeded: boolean;
+    planReady: boolean;
+    questionBudget?: number;
+    nextQuestion?: string;
+    clarificationTopics?: string[];
+    assumptionNote?: string;
+}
+export declare function hasOverridePhrase(prompt: string): boolean;
+export declare function hasVagueIntent(prompt: string): boolean;
+export declare function hasTechnicalReference(prompt: string): boolean;
+export declare const CLARIFICATION_TOPICS: {
+    readonly VAGUE_INTENT: "vague-intent";
+    readonly TARGET_ARTIFACT: "target-artifact";
+    readonly REQUEST_SCOPE: "request-scope";
+};
+export declare function evaluateClarification(prompt: string, options?: ClarificationOptions): ClarificationMetadata;