codingbuddy 5.4.1 → 5.5.0

package/README.md

@@ -20,6 +20,7 @@ npx codingbuddy init
 | Command | Description |
 |---------|-------------|
 | `codingbuddy init` | Analyze project and generate configuration |
+| `codingbuddy init --team` | Auto-detect installed AI tools and generate adapter configs |
 | `codingbuddy mcp` | Start MCP server (stdio mode by default) |
 | `codingbuddy install <source>` | Install plugin from git URL or registry |
 | `codingbuddy search <query>` | Search plugins in registry |
@@ -42,6 +43,8 @@ npx codingbuddy init
 
 | Tool | Description |
 |------|-------------|
+| `activate` | One-shot entry point returning rules, primary agent, specialists, and discussion format for a prompt. Preferred over `parse_mode` in Claude Code |
+| `suggest_rules` | Analyze execution history for repeated failure patterns and generate draft rule suggestions. Proposed for human review — never auto-applied |
 | `get_project_config` | Get project configuration settings |
 | `search_rules` | Search through rules and guidelines |
 | `get_agent_details` | Get detailed profile of a specialist agent |

package/dist/src/agent/teams-capability.service.d.ts

@@ -6,6 +6,7 @@ export declare class TeamsCapabilityService {
     constructor(configService: ConfigService);
     getStatus(): Promise<TeamsCapabilityStatus>;
     isAvailable(): Promise<boolean>;
+    private isClaudeCodeEnvironment;
     readEnvFlag(): boolean | undefined;
     private readConfigFlag;
 }

package/dist/src/agent/teams-capability.service.js

@@ -43,9 +43,18 @@ let TeamsCapabilityService = TeamsCapabilityService_1 = class TeamsCapabilitySer
             this.logger.debug(`Teams capability: ${status.reason}`);
             return status;
         }
+        if (this.isClaudeCodeEnvironment()) {
+            const status = {
+                available: true,
+                reason: 'Auto-enabled: Claude Code environment detected with native Teams support',
+                source: 'claude-native',
+            };
+            this.logger.debug(`Teams capability: ${status.reason}`);
+            return status;
+        }
         const status = {
             available: false,
-            reason: 'Teams coordination is experimental and disabled by default',
+            reason: 'Teams coordination disabled by default for non-Claude Code hosts',
             source: 'default',
         };
         this.logger.debug(`Teams capability: ${status.reason}`);
@@ -55,6 +64,11 @@ let TeamsCapabilityService = TeamsCapabilityService_1 = class TeamsCapabilitySer
         const status = await this.getStatus();
         return status.available;
     }
+    isClaudeCodeEnvironment() {
+        return (process.env.CLAUDE_CODE === '1' ||
+            process.env.CLAUDE_CODE_ENTRYPOINT !== undefined ||
+            this.configService.getClientName() === 'claude-code');
+    }
     readEnvFlag() {
         const raw = process.env.CODINGBUDDY_TEAMS_ENABLED;
         if (raw === undefined || raw === '')

package/dist/src/agent/teams-capability.types.d.ts

@@ -3,4 +3,4 @@ export interface TeamsCapabilityStatus {
     readonly reason: string;
     readonly source: TeamsCapabilitySource;
 }
-export type TeamsCapabilitySource = 'config' | 'environment' | 'default';
+export type TeamsCapabilitySource = 'config' | 'environment' | 'claude-native' | 'default';

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

@@ -0,0 +1,22 @@
+import type { ToolDefinition } from './base.handler';
+import type { ToolResponse } from '../response.utils';
+import { AbstractHandler } from './abstract-handler';
+import { AgentService } from '../../agent/agent.service';
+import { TeamsCapabilityService } from '../../agent/teams-capability.service';
+import type { KeywordService } from '../../keyword/keyword.service';
+import { RulesService } from '../../rules/rules.service';
+export declare class ActivateHandler extends AbstractHandler {
+    private readonly keywordService;
+    private readonly agentService;
+    private readonly rulesService;
+    private readonly teamsCapability;
+    private readonly logger;
+    constructor(keywordService: KeywordService, agentService: AgentService, rulesService: RulesService, teamsCapability: TeamsCapabilityService);
+    protected getHandledTools(): string[];
+    protected handleTool(toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
+    getToolDefinitions(): ToolDefinition[];
+    private handleActivate;
+    private resolveMode;
+    private resolveSpecialists;
+    private getContextAwareSpecialists;
+}

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

@@ -0,0 +1,260 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ActivateHandler_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivateHandler = void 0;
+const common_1 = require("@nestjs/common");
+const abstract_handler_1 = require("./abstract-handler");
+const response_utils_1 = require("../response.utils");
+const agent_service_1 = require("../../agent/agent.service");
+const teams_capability_service_1 = require("../../agent/teams-capability.service");
+const keyword_module_1 = require("../../keyword/keyword.module");
+const keyword_types_1 = require("../../keyword/keyword.types");
+const rules_service_1 = require("../../rules/rules.service");
+const validation_constants_1 = require("../../shared/validation.constants");
+const MODE_DEFAULT_AGENTS = {
+    PLAN: 'plan-mode-agent',
+    ACT: 'act-mode-agent',
+    EVAL: 'eval-mode-agent',
+    AUTO: 'auto-mode-agent',
+};
+const CONTEXT_SPECIALIST_PATTERNS = [
+    {
+        pattern: /보안|security|auth|인증|JWT|OAuth|XSS|CSRF|취약점|vulnerability/i,
+        specialist: 'security-specialist',
+    },
+    {
+        pattern: /접근성|accessibility|a11y|WCAG|aria|스크린\s*리더|screen\s*reader/i,
+        specialist: 'accessibility-specialist',
+    },
+    {
+        pattern: /성능|performance|최적화|optimiz|빠르게|느린|slow|fast|bundle\s*size|로딩/i,
+        specialist: 'performance-specialist',
+    },
+    {
+        pattern: /다국어|i18n|internationalization|번역|locale|translation|localization/i,
+        specialist: 'i18n-specialist',
+    },
+    {
+        pattern: /SEO|검색\s*엔진|search\s*engine|메타|meta\s*tag|sitemap|구조화\s*데이터/i,
+        specialist: 'seo-specialist',
+    },
+    {
+        pattern: /문서화|document|README|API\s*문서|JSDoc|주석|comment/i,
+        specialist: 'documentation-specialist',
+    },
+    {
+        pattern: /UI|UX|디자인|design\s*system|사용자\s*경험|user\s*experience|인터랙션/i,
+        specialist: 'ui-ux-designer',
+    },
+    {
+        pattern: /외부\s*서비스|external\s*(api|service)|webhook|웹훅|third-?party|circuit\s*breaker|retry\s*pattern|API\s*integration|서드파티|연동|SDK\s*wrapper/i,
+        specialist: 'integration-specialist',
+    },
+    {
+        pattern: /observability|관측성|distributed\s*trac|분산\s*추적|SLI|SLO|error\s*budget|OpenTelemetry|otel|Prometheus|Grafana|Jaeger|Zipkin|log\s*aggregat|로그\s*수집|alerting\s*strateg|알림\s*전략|메트릭\s*수집|metric\s*collect|tracing\s*infra|monitoring|대시보드|dashboard|logs?\s*manag/i,
+        specialist: 'observability-specialist',
+    },
+    {
+        pattern: /event[- ]?driven|이벤트\s*기반|message\s*queue|메시지\s*큐|Kafka|RabbitMQ|SQS|Azure\s*Service\s*Bus|event\s*sourc|CQRS|saga\s*pattern|분산\s*트랜잭션|distributed\s*transaction|pub\/?sub|dead\s*letter|DLQ|websocket|SSE|server[- ]?sent|real[- ]?time|실시간|async\s*messag|비동기\s*통신/i,
+        specialist: 'event-architecture-specialist',
+    },
+    {
+        pattern: /migration|마이그레이션|migrate|이전|legacy\s*(system|code|moderniz)|레거시|upgrade\s*(framework|version|library)|업그레이드|strangler\s*fig|branch\s*by\s*abstraction|blue[- ]?green|canary\s*(deploy|release)|rollback|롤백|api\s*version|deprecat|dual[- ]?write|backward\s*compatib|호환성|zero[- ]?downtime|data\s*migration|데이터\s*마이그레이션|schema\s*migration|스키마\s*변경|cutover|전환/i,
+        specialist: 'migration-specialist',
+    },
+];
+const SPECIALIST_DOMAIN_MAP = {
+    'security-specialist': 'security',
+    'accessibility-specialist': 'accessibility',
+    'performance-specialist': 'performance',
+    'i18n-specialist': 'i18n',
+    'seo-specialist': 'seo',
+    'documentation-specialist': 'documentation',
+    'ui-ux-designer': 'ui-ux',
+    'integration-specialist': 'integration',
+    'observability-specialist': 'observability',
+    'event-architecture-specialist': 'event-architecture',
+    'migration-specialist': 'migration',
+    'architecture-specialist': 'architecture',
+    'test-strategy-specialist': 'testing',
+    'code-quality-specialist': 'code-quality',
+};
+let ActivateHandler = ActivateHandler_1 = class ActivateHandler extends abstract_handler_1.AbstractHandler {
+    constructor(keywordService, agentService, rulesService, teamsCapability) {
+        super();
+        this.keywordService = keywordService;
+        this.agentService = agentService;
+        this.rulesService = rulesService;
+        this.teamsCapability = teamsCapability;
+        this.logger = new common_1.Logger(ActivateHandler_1.name);
+    }
+    getHandledTools() {
+        return ['activate'];
+    }
+    async handleTool(toolName, args) {
+        switch (toolName) {
+            case 'activate':
+                return this.handleActivate(args);
+            default:
+                return (0, response_utils_1.createErrorResponse)(`Unknown tool: ${toolName}`);
+        }
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'activate',
+                description: 'One-shot entry point for collective intelligence workflow. ' +
+                    'Combines rule loading, primary agent resolution, specialist recommendation, ' +
+                    'and prompt generation in a single call — replacing the multi-step ' +
+                    'parse_mode + dispatch_agents ceremony. Returns everything needed to ' +
+                    'run a specialist council via Claude native Teams.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'Task description. May start with a mode keyword (PLAN/ACT/EVAL/AUTO) ' +
+                                'which will be auto-detected, or use the explicit mode parameter.',
+                        },
+                        mode: {
+                            type: 'string',
+                            enum: ['PLAN', 'ACT', 'EVAL', 'AUTO'],
+                            description: 'Explicit workflow mode. If omitted, auto-detected from prompt keywords.',
+                        },
+                        primaryAgent: {
+                            type: 'string',
+                            description: 'Explicit primary agent name. If omitted, uses mode default.',
+                        },
+                    },
+                    required: ['prompt'],
+                },
+            },
+        ];
+    }
+    async handleActivate(args) {
+        const prompt = (0, validation_constants_1.extractRequiredString)(args, 'prompt');
+        if (prompt === null) {
+            return (0, response_utils_1.createErrorResponse)('Missing required parameter: prompt');
+        }
+        const explicitMode = (0, validation_constants_1.extractOptionalString)(args, 'mode');
+        const { mode, taskPrompt } = this.resolveMode(prompt, explicitMode);
+        const rules = await this.keywordService.getRulesForMode(mode, 'standard');
+        const primaryAgentName = (0, validation_constants_1.extractOptionalString)(args, 'primaryAgent') ?? MODE_DEFAULT_AGENTS[mode];
+        let primaryAgent = null;
+        try {
+            const agentPrompt = await this.agentService.getAgentSystemPrompt(primaryAgentName, {
+                mode,
+                taskDescription: taskPrompt,
+            });
+            primaryAgent = {
+                name: primaryAgentName,
+                displayName: agentPrompt.displayName,
+                systemPrompt: agentPrompt.systemPrompt,
+            };
+        }
+        catch (error) {
+            this.logger.warn(`Failed to resolve primary agent '${primaryAgentName}': ${error instanceof Error ? error.message : 'Unknown'}`);
+        }
+        const specialists = await this.resolveSpecialists(mode, taskPrompt);
+        const specialistResults = [];
+        if (specialists.length > 0) {
+            try {
+                const prepared = await this.agentService.prepareParallelAgents(mode, specialists, undefined, taskPrompt, 'full');
+                for (const agent of prepared.agents) {
+                    specialistResults.push({
+                        name: agent.id,
+                        displayName: agent.displayName,
+                        prompt: agent.taskPrompt ?? agent.description ?? '',
+                        domain: SPECIALIST_DOMAIN_MAP[agent.id] ?? agent.id,
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to prepare specialists: ${error instanceof Error ? error.message : 'Unknown'}`);
+            }
+        }
+        const teamsStatus = await this.teamsCapability.getStatus();
+        return (0, response_utils_1.createJsonResponse)({
+            mode,
+            rules: rules.map(r => ({ name: r.name, content: r.content })),
+            primaryAgent,
+            specialists: specialistResults,
+            discussion: {
+                format: 'Each specialist: approve|concern|reject + reasoning + suggestedChanges',
+                consensus: 'No rejections = consensus reached',
+                crossReview: "Specialists review each other's opinions",
+            },
+            nativeIntegration: {
+                teams: teamsStatus.available
+                    ? 'Use Claude native Teams to run specialists as teammates for real-time debate'
+                    : 'Enable Teams via CODINGBUDDY_TEAMS_ENABLED=true or experimental.teamsCoordination config',
+                memory: 'Use Claude Code Memory for context persistence across sessions',
+                orchestration: 'Host manages mode transitions, clarification, permissions natively',
+            },
+        });
+    }
+    resolveMode(prompt, explicitMode) {
+        if (explicitMode && (0, validation_constants_1.isValidMode)(explicitMode)) {
+            return { mode: explicitMode, taskPrompt: prompt };
+        }
+        const trimmed = prompt.trim();
+        const keywordRegex = /^([^\s:：]+)\s*[:：]?\s*(.*)$/s;
+        const match = trimmed.match(keywordRegex);
+        if (match?.[1]) {
+            const candidate = match[1];
+            const upper = candidate.toUpperCase();
+            const rest = (match[2] ?? '').trim();
+            if (keyword_types_1.KEYWORDS.includes(upper)) {
+                return { mode: upper, taskPrompt: rest || trimmed };
+            }
+            const localized = keyword_types_1.LOCALIZED_KEYWORD_MAP[candidate] ?? keyword_types_1.LOCALIZED_KEYWORD_MAP[upper];
+            if (localized) {
+                return { mode: localized, taskPrompt: rest || trimmed };
+            }
+        }
+        return { mode: 'PLAN', taskPrompt: trimmed };
+    }
+    async resolveSpecialists(mode, prompt) {
+        let defaultSpecialists = [];
+        try {
+            const configContent = await this.rulesService.getRuleContent('keyword-modes.json');
+            const config = JSON.parse(configContent);
+            defaultSpecialists = config.modes[mode]?.defaultSpecialists ?? [];
+        }
+        catch {
+            this.logger.debug('Failed to load keyword-modes.json for default specialists');
+        }
+        const contextSpecialists = this.getContextAwareSpecialists(prompt);
+        return [...new Set([...defaultSpecialists, ...contextSpecialists])];
+    }
+    getContextAwareSpecialists(prompt) {
+        const specialists = [];
+        for (const { pattern, specialist } of CONTEXT_SPECIALIST_PATTERNS) {
+            if (pattern.test(prompt)) {
+                specialists.push(specialist);
+            }
+        }
+        return specialists;
+    }
+};
+exports.ActivateHandler = ActivateHandler;
+exports.ActivateHandler = ActivateHandler = ActivateHandler_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(keyword_module_1.KEYWORD_SERVICE)),
+    __metadata("design:paramtypes", [Function, agent_service_1.AgentService,
+        rules_service_1.RulesService,
+        teams_capability_service_1.TeamsCapabilityService])
+], ActivateHandler);
+//# sourceMappingURL=activate.handler.js.map

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

@@ -44,7 +44,7 @@ let BriefingHandler = BriefingHandler_1 = class BriefingHandler extends abstract
         return [
             {
                 name: 'create_briefing',
-                description: 'Capture current session state into a briefing document for cross-session recovery',
+                description: '[DEPRECATED — Use Claude Code Memory for cross-session context] Capture current session state into a briefing document for cross-session recovery.',
                 inputSchema: {
                     type: 'object',
                     properties: {

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

@@ -81,7 +81,7 @@ let ChecklistContextHandler = class ChecklistContextHandler extends abstract_han
             },
             {
                 name: 'analyze_task',
-                description: 'Analyze a task to provide contextual recommendations including risk assessment, relevant checklists, specialist recommendations, and workflow suggestions. Use this at the start of PLAN mode to get comprehensive task analysis.',
+                description: '[DEPRECATED — Use activate + /dream instead] Analyze a task to provide contextual recommendations including risk assessment, relevant checklists, specialist recommendations, and workflow suggestions.',
                 inputSchema: {
                     type: 'object',
                     properties: {

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

@@ -43,7 +43,7 @@ let ContextDocumentHandler = class ContextDocumentHandler extends abstract_handl
         return [
             {
                 name: 'read_context',
-                description: `Read the current context document from ${context_document_types_1.CONTEXT_FILE_PATH}. Returns all accumulated context from PLAN/ACT/EVAL modes including decisions, notes, and recommended agents. Supports verbosity levels for controlling returned data size.`,
+                description: `[DEPRECATED — Use Claude Code Memory instead for cross-session context persistence] Read the current context document from ${context_document_types_1.CONTEXT_FILE_PATH}. Returns all accumulated context from PLAN/ACT/EVAL modes including decisions, notes, and recommended agents. Supports verbosity levels for controlling returned data size.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -62,7 +62,7 @@ let ContextDocumentHandler = class ContextDocumentHandler extends abstract_handl
             },
             {
                 name: 'update_context',
-                description: `MANDATORY: Update the context document at ${context_document_types_1.CONTEXT_FILE_PATH}.
+                description: `[DEPRECATED — Use Claude Code Memory instead for cross-session context persistence] Update the context document at ${context_document_types_1.CONTEXT_FILE_PATH}.
 - PLAN mode: Resets (clears) existing content and starts fresh.
 - ACT/EVAL modes: Appends new section to existing content (requires PLAN first).
 - Automatic cleanup: If document exceeds size threshold, older sections are automatically summarized.

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

@@ -47,12 +47,11 @@ let DiscussionHandler = class DiscussionHandler extends abstract_handler_1.Abstr
         return [
             {
                 name: 'agent_discussion',
-                description: '[EXPERIMENTAL — disabled by default] Produces templated synthesis of ' +
-                    'specialist opinions, not real specialist execution. The output does ' +
-                    'not reflect collective intelligence from live agents; treat it as a ' +
-                    'placeholder until the rebuild lands. Enable by setting ' +
-                    `${discussion_types_1.EXPERIMENTAL_DISCUSSION_ENV}=1. When disabled, the tool returns ` +
-                    '{disabled: true} without invoking synthesis.',
+                description: 'Structured specialist discussion for collective intelligence workflows. ' +
+                    'Collects and synthesizes opinions from multiple specialist agents on a topic. ' +
+                    'For real-time specialist debate, use the `activate` tool with Claude native Teams. ' +
+                    `Set ${discussion_types_1.EXPERIMENTAL_DISCUSSION_ENV}=1 to enable built-in synthesis. ` +
+                    'When unset, returns guidance on using activate + Teams instead.',
                 inputSchema: {
                     type: 'object',
                     properties: {

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

@@ -17,8 +17,8 @@ export interface DiscussionResult {
 }
 export declare const VALID_SEVERITIES: readonly OpinionSeverity[];
 export declare const EXPERIMENTAL_DISCUSSION_ENV = "CODINGBUDDY_EXPERIMENTAL_DISCUSSION";
-export declare const EXPERIMENTAL_DISCUSSION_WARNING = "\u26A0\uFE0F experimental \u2014 templated synthesis, not real specialist execution";
-export declare const DISABLED_DISCUSSION_REASON = "templated synthesis not aligned with collective intelligence promise";
+export declare const EXPERIMENTAL_DISCUSSION_WARNING = "Built-in synthesis \u2014 for real specialist debate, use activate + Claude native Teams";
+export declare const DISABLED_DISCUSSION_REASON: string;
 export interface DisabledDiscussionResult {
     disabled: true;
     reason: string;

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

@@ -9,6 +9,7 @@ exports.VALID_SEVERITIES = [
     'critical',
 ];
 exports.EXPERIMENTAL_DISCUSSION_ENV = 'CODINGBUDDY_EXPERIMENTAL_DISCUSSION';
-exports.EXPERIMENTAL_DISCUSSION_WARNING = '\u26a0\ufe0f experimental — templated synthesis, not real specialist execution';
-exports.DISABLED_DISCUSSION_REASON = 'templated synthesis not aligned with collective intelligence promise';
+exports.EXPERIMENTAL_DISCUSSION_WARNING = 'Built-in synthesis — for real specialist debate, use activate + Claude native Teams';
+exports.DISABLED_DISCUSSION_REASON = 'Use the `activate` tool with Claude native Teams for real specialist debate. ' +
+    'Set CODINGBUDDY_EXPERIMENTAL_DISCUSSION=1 to enable built-in synthesis as an alternative.';
 //# sourceMappingURL=discussion.types.js.map

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

@@ -21,4 +21,6 @@ export { BriefingHandler } from './briefing.handler';
 export { ResumeHandler } from './resume.handler';
 export { RuleImpactHandler } from './rule-impact.handler';
 export { ReviewPrHandler } from './review-pr.handler';
+export { ActivateHandler } from './activate.handler';
+export { SuggestRulesHandler } from './suggest-rules.handler';
 export declare const TOOL_HANDLERS = "TOOL_HANDLERS";

package/dist/src/mcp/handlers/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOOL_HANDLERS = exports.ReviewPrHandler = exports.RuleImpactHandler = exports.ResumeHandler = exports.BriefingHandler = exports.QualityReportHandler = exports.ReleaseCheckHandler = exports.PluginValidationHandler = exports.ImpactHandler = exports.RuleInsightsHandler = exports.ContextArchiveHandler = exports.PipelineHandler = exports.ParallelValidationHandler = exports.DiscussionHandler = exports.TuiHandler = exports.ContextDocumentHandler = exports.ConventionsHandler = exports.ChecklistContextHandler = exports.ModeHandler = exports.AgentHandler = exports.SkillHandler = exports.ConfigHandler = exports.RulesHandler = void 0;
+exports.TOOL_HANDLERS = exports.SuggestRulesHandler = exports.ActivateHandler = exports.ReviewPrHandler = exports.RuleImpactHandler = exports.ResumeHandler = exports.BriefingHandler = exports.QualityReportHandler = exports.ReleaseCheckHandler = exports.PluginValidationHandler = exports.ImpactHandler = exports.RuleInsightsHandler = exports.ContextArchiveHandler = exports.PipelineHandler = exports.ParallelValidationHandler = exports.DiscussionHandler = exports.TuiHandler = exports.ContextDocumentHandler = exports.ConventionsHandler = exports.ChecklistContextHandler = exports.ModeHandler = exports.AgentHandler = exports.SkillHandler = exports.ConfigHandler = exports.RulesHandler = void 0;
 var rules_handler_1 = require("./rules.handler");
 Object.defineProperty(exports, "RulesHandler", { enumerable: true, get: function () { return rules_handler_1.RulesHandler; } });
 var config_handler_1 = require("./config.handler");
@@ -45,5 +45,9 @@ var rule_impact_handler_1 = require("./rule-impact.handler");
 Object.defineProperty(exports, "RuleImpactHandler", { enumerable: true, get: function () { return rule_impact_handler_1.RuleImpactHandler; } });
 var review_pr_handler_1 = require("./review-pr.handler");
 Object.defineProperty(exports, "ReviewPrHandler", { enumerable: true, get: function () { return review_pr_handler_1.ReviewPrHandler; } });
+var activate_handler_1 = require("./activate.handler");
+Object.defineProperty(exports, "ActivateHandler", { enumerable: true, get: function () { return activate_handler_1.ActivateHandler; } });
+var suggest_rules_handler_1 = require("./suggest-rules.handler");
+Object.defineProperty(exports, "SuggestRulesHandler", { enumerable: true, get: function () { return suggest_rules_handler_1.SuggestRulesHandler; } });
 exports.TOOL_HANDLERS = 'TOOL_HANDLERS';
 //# sourceMappingURL=index.js.map

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

@@ -40,7 +40,7 @@ let ResumeHandler = ResumeHandler_1 = class ResumeHandler extends abstract_handl
         return [
             {
                 name: 'resume_session',
-                description: 'Load a previous session briefing to restore context and continue work',
+                description: '[DEPRECATED — Use Claude Code Memory for session resume] Load a previous session briefing to restore context and continue work.',
                 inputSchema: {
                     type: 'object',
                     properties: {

package/dist/src/mcp/handlers/rule-impact.handler.d.ts

@@ -16,6 +16,7 @@ export declare class RuleImpactHandler extends AbstractHandler {
     private appendSummary;
     private appendTopRules;
     private appendDomainCoverage;
+    private appendEffectivenessScores;
     private appendUnusedRules;
     private appendTrends;
     private appendSuggestions;

package/dist/src/mcp/handlers/rule-impact.handler.js

@@ -104,6 +104,7 @@ let RuleImpactHandler = class RuleImpactHandler extends abstract_handler_1.Abstr
         this.appendSummary(lines, insights);
         this.appendTopRules(lines, insights);
         this.appendDomainCoverage(lines, insights);
+        this.appendEffectivenessScores(lines, insights);
         this.appendUnusedRules(lines, insights);
         this.appendTrends(lines, insights);
         this.appendSuggestions(lines, insights);
@@ -169,6 +170,24 @@ let RuleImpactHandler = class RuleImpactHandler extends abstract_handler_1.Abstr
         }
         lines.push('');
     }
+    appendEffectivenessScores(lines, insights) {
+        const scores = insights.effectivenessScores;
+        if (!scores || scores.length === 0)
+            return;
+        lines.push('## Auto-Generated Rule Effectiveness');
+        lines.push('');
+        lines.push('| Rule | Baseline | Current | Reduction | Verdict |');
+        lines.push('| --- | ---: | ---: | ---: | --- |');
+        for (const score of scores) {
+            const verdictBadge = score.verdict === 'effective'
+                ? '**EFFECTIVE**'
+                : score.verdict === 'needs-review'
+                    ? 'needs-review'
+                    : '_ineffective_';
+            lines.push(`| ${score.ruleName} | ${(score.baselineFailureRate * 100).toFixed(1)}% | ${(score.currentFailureRate * 100).toFixed(1)}% | ${score.reductionPercent}% | ${verdictBadge} |`);
+        }
+        lines.push('');
+    }
     appendUnusedRules(lines, insights) {
         lines.push('## Unused Rules');
         lines.push('');

package/dist/src/mcp/handlers/suggest-rules.handler.d.ts

@@ -0,0 +1,10 @@
+import { AbstractHandler } from './abstract-handler';
+import type { ToolDefinition } from './base.handler';
+import type { ToolResponse } from '../response.utils';
+export declare class SuggestRulesHandler extends AbstractHandler {
+    protected getHandledTools(): string[];
+    protected handleTool(_toolName: string, args: Record<string, unknown> | undefined): Promise<ToolResponse>;
+    getToolDefinitions(): ToolDefinition[];
+    private buildPipelineArgs;
+    private runPipeline;
+}

package/dist/src/mcp/handlers/suggest-rules.handler.js

@@ -0,0 +1,105 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuggestRulesHandler = void 0;
+const common_1 = require("@nestjs/common");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const abstract_handler_1 = require("./abstract-handler");
+const response_utils_1 = require("../response.utils");
+const validation_constants_1 = require("../../shared/validation.constants");
+const PIPELINE_SCRIPT = (0, path_1.join)(__dirname, '..', '..', '..', '..', 'packages', 'claude-code-plugin', 'hooks', 'lib', 'suggest_pipeline.py');
+const PIPELINE_TIMEOUT_MS = 30_000;
+let SuggestRulesHandler = class SuggestRulesHandler extends abstract_handler_1.AbstractHandler {
+    getHandledTools() {
+        return ['suggest_rules'];
+    }
+    async handleTool(_toolName, args) {
+        const pipelineArgs = this.buildPipelineArgs(args);
+        let stdout;
+        try {
+            stdout = await this.runPipeline(pipelineArgs);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return (0, response_utils_1.createErrorResponse)(`Pipeline execution failed: ${message}`);
+        }
+        let suggestions;
+        try {
+            suggestions = JSON.parse(stdout);
+        }
+        catch {
+            return (0, response_utils_1.createErrorResponse)(`Failed to parse pipeline output: ${stdout.slice(0, 200)}`);
+        }
+        return (0, response_utils_1.createJsonResponse)({
+            generatedAt: Date.now(),
+            count: suggestions.length,
+            suggestions,
+        });
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'suggest_rules',
+                description: 'Analyze execution history for repeated failure patterns and generate draft rule suggestions. ' +
+                    'Rules are proposed for human review — never auto-applied. ' +
+                    'Powered by PatternDetector → RuleSuggester pipeline.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        minOccurrences: {
+                            type: 'number',
+                            description: 'Minimum number of failures to count as a pattern (default: 3)',
+                        },
+                        days: {
+                            type: 'number',
+                            description: 'How many days back to search (default: 30)',
+                        },
+                        dbPath: {
+                            type: 'string',
+                            description: 'Path to history.db file. Defaults to ~/.codingbuddy/history.db',
+                        },
+                    },
+                    required: [],
+                },
+            },
+        ];
+    }
+    buildPipelineArgs(args) {
+        const pipelineArgs = [];
+        const dbPath = (0, validation_constants_1.extractOptionalString)(args, 'dbPath');
+        if (dbPath) {
+            pipelineArgs.push('--db-path', dbPath);
+        }
+        const minOccurrences = args?.minOccurrences;
+        if (typeof minOccurrences === 'number' && Number.isInteger(minOccurrences)) {
+            pipelineArgs.push('--min-occurrences', String(minOccurrences));
+        }
+        const days = args?.days;
+        if (typeof days === 'number' && Number.isInteger(days)) {
+            pipelineArgs.push('--days', String(days));
+        }
+        return pipelineArgs;
+    }
+    runPipeline(pipelineArgs) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)('python3', [PIPELINE_SCRIPT, ...pipelineArgs], { timeout: PIPELINE_TIMEOUT_MS }, (err, stdout, stderr) => {
+                if (err) {
+                    reject(new Error(`${err.message}${stderr ? `: ${stderr}` : ''}`));
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+};
+exports.SuggestRulesHandler = SuggestRulesHandler;
+exports.SuggestRulesHandler = SuggestRulesHandler = __decorate([
+    (0, common_1.Injectable)()
+], SuggestRulesHandler);
+//# sourceMappingURL=suggest-rules.handler.js.map

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

@@ -50,6 +50,8 @@ const handlers = [
     handlers_1.BriefingHandler,
     handlers_1.ResumeHandler,
     handlers_1.RuleImpactHandler,
+    handlers_1.ActivateHandler,
+    handlers_1.SuggestRulesHandler,
 ];
 let McpModule = class McpModule {
 };

package/dist/src/rules/rule-insights.service.d.ts

@@ -1,4 +1,11 @@
 import type { RuleStats } from './rule-tracker';
+export interface EffectivenessScore {
+    ruleName: string;
+    baselineFailureRate: number;
+    currentFailureRate: number;
+    reductionPercent: number;
+    verdict: 'effective' | 'needs-review' | 'ineffective';
+}
 export interface RuleInsight {
     generatedAt: number;
     summary: {
@@ -20,6 +27,7 @@ export interface RuleInsight {
         emerging: string[];
     };
     suggestions: string[];
+    effectivenessScores: EffectivenessScore[];
 }
 export declare class RuleInsightsService {
     generateInsights(stats: Record<string, RuleStats>, allRuleNames: string[], now?: number): RuleInsight;
@@ -27,5 +35,6 @@ export declare class RuleInsightsService {
     private classifyFrequency;
     private findUnusedRules;
     private analyzeTrends;
+    private computeEffectivenessScores;
     private generateSuggestions;
 }

package/dist/src/rules/rule-insights.service.js

@@ -13,6 +13,8 @@ const MONTH_MS = 30 * 24 * 60 * 60 * 1000;
 const TOP_RULES_LIMIT = 10;
 const EMERGING_THRESHOLD = 3;
 const SUGGESTION_UNUSED_PREVIEW = 5;
+const EFFECTIVE_THRESHOLD = 50;
+const NEEDS_REVIEW_THRESHOLD = 10;
 let RuleInsightsService = class RuleInsightsService {
     generateInsights(stats, allRuleNames, now = Date.now()) {
         const entries = Object.entries(stats);
@@ -24,6 +26,7 @@ let RuleInsightsService = class RuleInsightsService {
         const staleRules = entries.filter(([, s]) => now - s.lastUsed > MONTH_MS).length;
         const trends = this.analyzeTrends(entries, avgCount, now);
         const suggestions = this.generateSuggestions(topRules, unusedRules, trends.declining, entries.length);
+        const effectivenessScores = this.computeEffectivenessScores(entries);
         return {
             generatedAt: now,
             summary: {
@@ -36,6 +39,7 @@ let RuleInsightsService = class RuleInsightsService {
             unusedRules,
             trends,
             suggestions,
+            effectivenessScores,
         };
     }
     buildTopRules(entries, avgCount) {
@@ -75,6 +79,37 @@ let RuleInsightsService = class RuleInsightsService {
             .map(([name]) => name);
         return { recentlyActive, declining, emerging };
     }
+    computeEffectivenessScores(entries) {
+        const scores = [];
+        for (const [name, stat] of entries) {
+            if (!stat.generatedRule)
+                continue;
+            if (typeof stat.baselineFailureRate !== 'number' ||
+                typeof stat.currentFailureRate !== 'number')
+                continue;
+            const baseline = stat.baselineFailureRate;
+            const current = stat.currentFailureRate;
+            const reductionPercent = baseline > 0 ? ((baseline - current) / baseline) * 100 : 0;
+            let verdict;
+            if (reductionPercent >= EFFECTIVE_THRESHOLD) {
+                verdict = 'effective';
+            }
+            else if (reductionPercent >= NEEDS_REVIEW_THRESHOLD) {
+                verdict = 'needs-review';
+            }
+            else {
+                verdict = 'ineffective';
+            }
+            scores.push({
+                ruleName: name,
+                baselineFailureRate: baseline,
+                currentFailureRate: current,
+                reductionPercent: Math.round(reductionPercent * 10) / 10,
+                verdict,
+            });
+        }
+        return scores;
+    }
     generateSuggestions(topRules, unusedRules, declining, totalTracked) {
         const suggestions = [];
         if (totalTracked === 0) {

package/dist/src/rules/rule-tracker.d.ts

@@ -1,6 +1,9 @@
 export interface RuleStats {
     count: number;
     lastUsed: number;
+    generatedRule?: boolean;
+    baselineFailureRate?: number;
+    currentFailureRate?: number;
 }
 export interface RuleEffectivenessReport {
     totalRulesTracked: number;
@@ -17,6 +20,8 @@ export declare class RuleTracker {
     constructor(statsPath: string);
     static fromFile(statsPath: string): Promise<RuleTracker>;
     trackRuleUsage(ruleNames: string[]): void;
+    markRuleAsGenerated(ruleName: string): void;
+    recordFailureRate(ruleName: string, rate: number, kind: 'baseline' | 'current'): void;
     getStats(): Record<string, RuleStats>;
     detectUnusedRules(allRuleNames: string[], thresholdDays: number): string[];
     generateReport(): RuleEffectivenessReport;

package/dist/src/rules/rule-tracker.js

@@ -33,6 +33,27 @@ class RuleTracker {
             }
         }
     }
+    markRuleAsGenerated(ruleName) {
+        if (!ruleName)
+            return;
+        if (!this.stats[ruleName]) {
+            this.stats[ruleName] = { count: 0, lastUsed: Date.now() };
+        }
+        this.stats[ruleName].generatedRule = true;
+    }
+    recordFailureRate(ruleName, rate, kind) {
+        if (!ruleName)
+            return;
+        const stat = this.stats[ruleName];
+        if (!stat || !stat.generatedRule)
+            return;
+        if (kind === 'baseline') {
+            stat.baselineFailureRate = rate;
+        }
+        else {
+            stat.currentFailureRate = rate;
+        }
+    }
     getStats() {
         return JSON.parse(JSON.stringify(this.stats));
     }

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "5.4.1";
+export declare const VERSION = "5.5.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.4.1';
+exports.VERSION = '5.5.0';
 //# sourceMappingURL=version.js.map

package/dist/src/tui-bundle.mjs

@@ -2718,6 +2718,8 @@ var MONTH_MS = 30 * 24 * 60 * 60 * 1e3;
 var TOP_RULES_LIMIT = 10;
 var EMERGING_THRESHOLD = 3;
 var SUGGESTION_UNUSED_PREVIEW = 5;
+var EFFECTIVE_THRESHOLD = 50;
+var NEEDS_REVIEW_THRESHOLD = 10;
 var RuleInsightsService = class {
   generateInsights(stats, allRuleNames, now = Date.now()) {
     const entries = Object.entries(stats);
@@ -2734,6 +2736,7 @@ var RuleInsightsService = class {
       trends.declining,
       entries.length
     );
+    const effectivenessScores = this.computeEffectivenessScores(entries);
     return {
       generatedAt: now,
       summary: {
@@ -2745,7 +2748,8 @@ var RuleInsightsService = class {
       topRules: topRules.slice(0, TOP_RULES_LIMIT),
       unusedRules,
       trends,
-      suggestions
+      suggestions,
+      effectivenessScores
     };
   }
   buildTopRules(entries, avgCount) {
@@ -2774,6 +2778,33 @@ var RuleInsightsService = class {
     const emerging = entries.filter(([, s]) => now - s.lastUsed <= WEEK_MS && s.count <= EMERGING_THRESHOLD).map(([name]) => name);
     return { recentlyActive, declining, emerging };
   }
+  computeEffectivenessScores(entries) {
+    const scores = [];
+    for (const [name, stat2] of entries) {
+      if (!stat2.generatedRule) continue;
+      if (typeof stat2.baselineFailureRate !== "number" || typeof stat2.currentFailureRate !== "number")
+        continue;
+      const baseline = stat2.baselineFailureRate;
+      const current = stat2.currentFailureRate;
+      const reductionPercent = baseline > 0 ? (baseline - current) / baseline * 100 : 0;
+      let verdict;
+      if (reductionPercent >= EFFECTIVE_THRESHOLD) {
+        verdict = "effective";
+      } else if (reductionPercent >= NEEDS_REVIEW_THRESHOLD) {
+        verdict = "needs-review";
+      } else {
+        verdict = "ineffective";
+      }
+      scores.push({
+        ruleName: name,
+        baselineFailureRate: baseline,
+        currentFailureRate: current,
+        reductionPercent: Math.round(reductionPercent * 10) / 10,
+        verdict
+      });
+    }
+    return scores;
+  }
   generateSuggestions(topRules, unusedRules, declining, totalTracked) {
     const suggestions = [];
     if (totalTracked === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codingbuddy",
-  "version": "5.4.1",
+  "version": "5.5.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.4.1",
+    "codingbuddy-rules": "5.5.0",
     "eventemitter2": "6.4.9",
     "ink": "6.7.0",
     "minimatch": "10.2.3",