codingbuddy 5.3.0 → 5.4.0

package/dist/src/agent/index.d.ts

@@ -10,3 +10,4 @@ export * from './agent-stack.schema';
 export * from './agent-stack.loader';
 export * from './execution-plan';
 export * from './execution-plan.types';
+export * from './stack-matcher';

package/dist/src/agent/index.js

@@ -26,4 +26,5 @@ __exportStar(require("./agent-stack.schema"), exports);
 __exportStar(require("./agent-stack.loader"), exports);
 __exportStar(require("./execution-plan"), exports);
 __exportStar(require("./execution-plan.types"), exports);
+__exportStar(require("./stack-matcher"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/agent/stack-matcher.d.ts

@@ -0,0 +1,13 @@
+export interface StackMatchInput {
+    name: string;
+    category: string;
+    tags: string[];
+    specialist_agents?: string[];
+}
+export interface StackMatchResult {
+    stackName: string;
+    confidence: number;
+    matchedTags: string[];
+    stackBased: true;
+}
+export declare function matchStack(prompt: string, stacks: readonly StackMatchInput[]): StackMatchResult | null;

package/dist/src/agent/stack-matcher.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchStack = matchStack;
+const DOMAIN_KEYWORDS = [
+    { pattern: /\bREST\b/i, tags: ['rest', 'api'] },
+    { pattern: /\bGraphQL\b/i, tags: ['graphql', 'api'] },
+    { pattern: /\bAPI\b/i, tags: ['api'] },
+    { pattern: /\bbackend\b/i, tags: ['backend'] },
+    { pattern: /\bendpoint/i, tags: ['api', 'backend'] },
+    { pattern: /\bcontroller/i, tags: ['api', 'backend'] },
+    { pattern: /\bservice\s+layer/i, tags: ['backend'] },
+    { pattern: /\broute/i, tags: ['api', 'backend'] },
+    { pattern: /\bsecurity\b/i, tags: ['security'] },
+    { pattern: /\baudit\b/i, tags: ['audit', 'security'] },
+    { pattern: /\b(?:vulnerability|vulnerabilities)\b/i, tags: ['vulnerability', 'security'] },
+    { pattern: /\bcompliance\b/i, tags: ['compliance', 'security'] },
+    { pattern: /\bOAuth\b/i, tags: ['security'] },
+    { pattern: /\bJWT\b/i, tags: ['security'] },
+    { pattern: /\b(?:XSS|CSRF)\b/i, tags: ['security', 'vulnerability'] },
+    { pattern: /\bauthenticat/i, tags: ['security'] },
+    { pattern: /\bUI\b/i, tags: ['ui', 'frontend'] },
+    { pattern: /\bUX\b/i, tags: ['ux', 'frontend'] },
+    { pattern: /\baccessibility\b/i, tags: ['accessibility', 'frontend'] },
+    { pattern: /\bSEO\b/i, tags: ['seo', 'frontend'] },
+    { pattern: /\bfrontend\b/i, tags: ['frontend'] },
+    { pattern: /\bETL\b/i, tags: ['etl', 'data'] },
+    { pattern: /\bpipeline\b/i, tags: ['pipeline', 'data'] },
+    { pattern: /\banalytics\b/i, tags: ['analytics', 'data'] },
+    { pattern: /\bdata\s+(warehouse|lake|pipeline|ingestion)/i, tags: ['data', 'pipeline'] },
+    { pattern: /\bmodel\s+(training|inference|deploy)/i, tags: ['model', 'ml'] },
+    { pattern: /\bML\b/i, tags: ['ml'] },
+    { pattern: /\bmachine\s*learning/i, tags: ['ml', 'ai'] },
+    { pattern: /\binference\b/i, tags: ['inference', 'ml'] },
+    { pattern: /\btraining\b/i, tags: ['training', 'ml'] },
+    { pattern: /\bfull[- ]?stack\b/i, tags: ['fullstack'] },
+    { pattern: /보안/i, tags: ['security'] },
+    { pattern: /취약점/i, tags: ['vulnerability', 'security'] },
+    { pattern: /감사/i, tags: ['audit', 'security'] },
+    { pattern: /접근성/i, tags: ['accessibility', 'frontend'] },
+    { pattern: /데이터\s*파이프라인/i, tags: ['data', 'pipeline'] },
+    { pattern: /머신\s*러닝|기계\s*학습/i, tags: ['ml', 'ai'] },
+];
+const MIN_CONFIDENCE = 0.3;
+function matchStack(prompt, stacks) {
+    if (!prompt || stacks.length === 0)
+        return null;
+    const detectedTags = new Set();
+    for (const { pattern, tags } of DOMAIN_KEYWORDS) {
+        if (pattern.test(prompt)) {
+            for (const tag of tags)
+                detectedTags.add(tag);
+        }
+    }
+    if (detectedTags.size === 0)
+        return null;
+    let bestResult = null;
+    for (const stack of stacks) {
+        const matched = [];
+        for (const tag of stack.tags) {
+            if (detectedTags.has(tag))
+                matched.push(tag);
+        }
+        if (matched.length === 0)
+            continue;
+        const tagCoverage = matched.length / stack.tags.length;
+        const detectedCoverage = matched.length / detectedTags.size;
+        const confidence = Math.min((tagCoverage + detectedCoverage) / 2, 1.0);
+        if (confidence < MIN_CONFIDENCE)
+            continue;
+        if (!bestResult || confidence > bestResult.confidence) {
+            bestResult = {
+                stackName: stack.name,
+                confidence,
+                matchedTags: matched,
+                stackBased: true,
+            };
+        }
+    }
+    return bestResult;
+}
+//# sourceMappingURL=stack-matcher.js.map

package/dist/src/collaboration/index.d.ts

@@ -3,5 +3,3 @@ export { STANCES, STANCE_ICONS, createAgentOpinion, createCrossReview, createDis
 export { DiscussionEngine } from './discussion-engine';
 export { formatOpinion, formatCrossReview, formatConsensus, formatDiscussionRound, } from './terminal-formatter';
 export { mapSeverityToStance, convertSpecialistResult, convertSpecialistResults, type FindingSeverity, type SpecialistFinding, type SpecialistResult, } from './opinion-adapter';
-export type { CouncilInput, CouncilSummary, Disagreement, DisagreementPosition, } from './council-summary.types';
-export { generateCouncilSummary } from './council-summary.service';

package/dist/src/collaboration/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateCouncilSummary = exports.convertSpecialistResults = exports.convertSpecialistResult = exports.mapSeverityToStance = exports.formatDiscussionRound = exports.formatConsensus = exports.formatCrossReview = exports.formatOpinion = exports.DiscussionEngine = exports.calculateConsensus = exports.createDiscussionRound = exports.createCrossReview = exports.createAgentOpinion = exports.STANCE_ICONS = exports.STANCES = void 0;
+exports.convertSpecialistResults = exports.convertSpecialistResult = exports.mapSeverityToStance = exports.formatDiscussionRound = exports.formatConsensus = exports.formatCrossReview = exports.formatOpinion = exports.DiscussionEngine = exports.calculateConsensus = exports.createDiscussionRound = exports.createCrossReview = exports.createAgentOpinion = exports.STANCE_ICONS = exports.STANCES = void 0;
 var types_1 = require("./types");
 Object.defineProperty(exports, "STANCES", { enumerable: true, get: function () { return types_1.STANCES; } });
 Object.defineProperty(exports, "STANCE_ICONS", { enumerable: true, get: function () { return types_1.STANCE_ICONS; } });
@@ -19,6 +19,4 @@ var opinion_adapter_1 = require("./opinion-adapter");
 Object.defineProperty(exports, "mapSeverityToStance", { enumerable: true, get: function () { return opinion_adapter_1.mapSeverityToStance; } });
 Object.defineProperty(exports, "convertSpecialistResult", { enumerable: true, get: function () { return opinion_adapter_1.convertSpecialistResult; } });
 Object.defineProperty(exports, "convertSpecialistResults", { enumerable: true, get: function () { return opinion_adapter_1.convertSpecialistResults; } });
-var council_summary_service_1 = require("./council-summary.service");
-Object.defineProperty(exports, "generateCouncilSummary", { enumerable: true, get: function () { return council_summary_service_1.generateCouncilSummary; } });
 //# sourceMappingURL=index.js.map

package/dist/src/keyword/keyword.module.js

@@ -16,6 +16,7 @@ const skill_module_1 = require("../skill/skill.module");
 const skill_recommendation_service_1 = require("../skill/skill-recommendation.service");
 const agent_module_1 = require("../agent/agent.module");
 const agent_service_1 = require("../agent/agent.service");
+const agent_stack_service_1 = require("../agent/agent-stack.service");
 const agent_utils_1 = require("../shared/agent.utils");
 const client_type_1 = require("../shared/client-type");
 const keyword_service_1 = require("./keyword.service");
@@ -30,7 +31,7 @@ exports.KeywordModule = KeywordModule = __decorate([
         providers: [
             {
                 provide: exports.KEYWORD_SERVICE,
-                useFactory: (rulesService, configService, skillRecommendationService, agentService) => {
+                useFactory: (rulesService, configService, skillRecommendationService, agentService, agentStackService) => {
                     const logger = new common_1.Logger('KeywordModule');
                     const loadConfig = async () => {
                         const content = await rulesService.getRuleContent('keyword-modes.json');
@@ -157,6 +158,35 @@ exports.KeywordModule = KeywordModule = __decorate([
                             return null;
                         }
                     };
+                    const loadStacks = async () => {
+                        try {
+                            const summaries = await agentStackService.listStacks();
+                            const results = [];
+                            for (const summary of summaries) {
+                                try {
+                                    const full = await agentStackService.resolveStack(summary.name);
+                                    results.push({
+                                        name: full.name,
+                                        category: full.category,
+                                        tags: full.tags,
+                                        specialist_agents: full.specialist_agents,
+                                    });
+                                }
+                                catch {
+                                    results.push({
+                                        name: summary.name,
+                                        category: summary.category,
+                                        tags: summary.tags ?? [],
+                                    });
+                                }
+                            }
+                            return results;
+                        }
+                        catch (error) {
+                            logger.debug(`Failed to load agent stacks: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                            return [];
+                        }
+                    };
                     const options = {
                         primaryAgentResolver,
                         loadAutoConfigFn: loadAutoConfig,
@@ -165,10 +195,17 @@ exports.KeywordModule = KeywordModule = __decorate([
                         loadAgentSystemPromptFn: loadAgentSystemPrompt,
                         getMaxIncludedSkillsFn: getMaxIncludedSkills,
                         getClientTypeFn: () => (0, client_type_1.resolveClientType)(configService.getClientName()),
+                        loadStacksFn: loadStacks,
                     };
                     return new keyword_service_1.KeywordService(loadConfig, loadRule, loadAgent, options);
                 },
-                inject: [rules_service_1.RulesService, config_service_1.ConfigService, skill_recommendation_service_1.SkillRecommendationService, agent_service_1.AgentService],
+                inject: [
+                    rules_service_1.RulesService,
+                    config_service_1.ConfigService,
+                    skill_recommendation_service_1.SkillRecommendationService,
+                    agent_service_1.AgentService,
+                    agent_stack_service_1.AgentStackService,
+                ],
             },
         ],
         exports: [exports.KEYWORD_SERVICE],

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

@@ -2,6 +2,7 @@ import { type Mode, type RuleContent, type ParseModeResult, type KeywordModesCon
 import { type VerbosityLevel } from '../shared/verbosity.types';
 import { PrimaryAgentResolver } from './primary-agent-resolver';
 import { type ClientType } from '../shared/client-type';
+import { type StackMatchInput } from '../agent/stack-matcher';
 export interface ParseModeOptions {
     recommendedActAgent?: string;
     context?: ResolutionContext;
@@ -19,6 +20,7 @@ export interface KeywordServiceOptions {
     getMaxIncludedSkillsFn?: () => Promise<number | null>;
     getClientTypeFn?: () => ClientType;
     trackRuleUsageFn?: (ruleNames: string[]) => void;
+    loadStacksFn?: () => Promise<StackMatchInput[]>;
 }
 export interface SkillRecommendationInfo {
     skillName: string;
@@ -54,6 +56,7 @@ export declare class KeywordService {
     private readonly getMaxIncludedSkillsFn?;
     private readonly getClientTypeFn?;
     private readonly trackRuleUsageFn?;
+    private readonly loadStacksFn?;
     private static readonly CONTEXT_SPECIALIST_PATTERNS;
     constructor(loadConfigFn: () => Promise<KeywordModesConfig>, loadRuleFn: (path: string) => Promise<string>, loadAgentInfoFn?: ((agentName: string) => Promise<unknown>) | undefined, options?: KeywordServiceOptions);
     parseMode(prompt: string, options?: ParseModeOptions): Promise<ParseModeResult>;
@@ -73,6 +76,8 @@ export declare class KeywordService {
     private addAutoConfigToResult;
     private addComplexityToResult;
     private addIncludedSkillsToResult;
+    private enforceRequiredAgentSkills;
+    private extractRequiredSkillNames;
     private getMaxIncludedSkills;
     private loadSkillsInParallel;
     private addIncludedAgentToResult;

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,10 +1,21 @@
 import type { DiffAnalysisResult } from './diff-analyzer';
 import type { CouncilPreset } from '../agent/council-preset.types';
-import type { CouncilSummary } from '../collaboration/council-summary.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"];
@@ -45,6 +56,8 @@ export interface ParallelAgentRecommendation {
     specialists: string[];
     hint: string;
     dispatch?: DispatchStrength;
+    suggestedStack?: string;
+    stackBased?: boolean;
 }
 export interface IncludedSkill {
     name: string;
@@ -56,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 {
@@ -123,9 +137,11 @@ export interface ParseModeResult {
     visual?: VisualData;
     diffAnalysis?: DiffAnalysisResult;
     councilPreset?: CouncilPreset;
-    councilSummary?: CouncilSummary;
+    requiredSkillsEnforced?: boolean;
+    requiredSkillNames?: string[];
     executionPlan?: ExecutionPlan;
     teamsCapability?: TeamsCapabilityStatus;
+    permissionForecast?: PermissionForecast;
 }
 export interface DispatchReadyParams {
     subagent_type: 'general-purpose';
@@ -165,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.js

@@ -160,7 +160,7 @@ let AgentHandler = class AgentHandler extends abstract_handler_1.AbstractHandler
                         },
                         agentStack: {
                             type: 'string',
-                            description: 'Agent stack name to resolve primary + specialists from a preset (e.g., "api-development"). Overrides primaryAgent and specialists when provided.',
+                            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',

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;