@ai-coders/context 0.5.2 → 0.6.1

package/dist/services/mcp/mcpServer.js

@@ -4,16 +4,59 @@
  *
  * Exposes code analysis tools and semantic context as MCP resources.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIContextMCPServer = void 0;
 exports.startMCPServer = startMCPServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod_1 = require("zod");
+const path = __importStar(require("path"));
 const tools_1 = require("../ai/tools");
 const toolRegistry_1 = require("../ai/toolRegistry");
 const contextBuilder_1 = require("../semantic/contextBuilder");
 const version_1 = require("../../version");
+const providerFactory_1 = require("../ai/providerFactory");
+const workflow_1 = require("../workflow");
+// Default model for MCP tools that require LLM
+const DEFAULT_MODEL = providerFactory_1.DEFAULT_MODELS.google || 'gemini-3-flash-preview';
+const start_1 = require("../start");
+const report_1 = require("../report");
+const export_1 = require("../export");
+const stack_1 = require("../stack");
+const workflow_2 = require("../../workflow");
 class AIContextMCPServer {
     constructor(options = {}) {
         this.transport = null;
@@ -203,16 +246,19 @@ class AIContextMCPServer {
                 semantic: zod_1.z.boolean().default(true).optional()
                     .describe('Enable semantic analysis for richer templates'),
                 include: zod_1.z.array(zod_1.z.string()).optional().describe('Include patterns'),
-                exclude: zod_1.z.array(zod_1.z.string()).optional().describe('Exclude patterns')
+                exclude: zod_1.z.array(zod_1.z.string()).optional().describe('Exclude patterns'),
+                autoFill: zod_1.z.boolean().default(true).optional()
+                    .describe('Automatically fill scaffolding with codebase-aware content (default: true)')
             }
-        }, async ({ repoPath, type, outputDir, semantic, include, exclude }) => {
+        }, async ({ repoPath, type, outputDir, semantic, include, exclude, autoFill }) => {
             const result = await tools_1.initializeContextTool.execute({
                 repoPath: repoPath || this.options.repoPath || process.cwd(),
                 type,
                 outputDir,
                 semantic,
                 include,
-                exclude
+                exclude,
+                autoFill
             }, { toolCallId: '', messages: [] });
             return {
                 content: [{
@@ -230,16 +276,19 @@ class AIContextMCPServer {
                 outputDir: zod_1.z.string().optional().describe('Output directory'),
                 title: zod_1.z.string().optional().describe('Plan title (defaults to formatted planName)'),
                 summary: zod_1.z.string().optional().describe('Plan summary/goal'),
-                semantic: zod_1.z.boolean().default(true).optional().describe('Enable semantic analysis')
+                semantic: zod_1.z.boolean().default(true).optional().describe('Enable semantic analysis'),
+                autoFill: zod_1.z.boolean().default(true).optional()
+                    .describe('Automatically fill plan with codebase-aware content (default: true)')
             }
-        }, async ({ planName, repoPath, outputDir, title, summary, semantic }) => {
+        }, async ({ planName, repoPath, outputDir, title, summary, semantic, autoFill }) => {
             const result = await tools_1.scaffoldPlanTool.execute({
                 planName,
                 repoPath: repoPath || this.options.repoPath || process.cwd(),
                 outputDir,
                 title,
                 summary,
-                semantic
+                semantic,
+                autoFill
             }, { toolCallId: '', messages: [] });
             return {
                 content: [{
@@ -315,7 +364,888 @@ class AIContextMCPServer {
                     }]
             };
         });
-        this.log('Registered 12 tools');
+        // getCodebaseMap tool - retrieve sections of the codebase map JSON
+        this.server.registerTool('getCodebaseMap', {
+            description: (0, toolRegistry_1.getToolDescription)('getCodebaseMap', true),
+            inputSchema: {
+                repoPath: zod_1.z.string().optional().describe('Repository path (defaults to cwd)'),
+                section: zod_1.z.enum([
+                    'all',
+                    'stack',
+                    'structure',
+                    'architecture',
+                    'symbols',
+                    'symbols.classes',
+                    'symbols.interfaces',
+                    'symbols.functions',
+                    'symbols.types',
+                    'symbols.enums',
+                    'publicAPI',
+                    'dependencies',
+                    'stats'
+                ]).default('all').optional()
+                    .describe('Section of the codebase map to retrieve. Use specific sections to reduce token usage.')
+            }
+        }, async ({ repoPath, section }) => {
+            const result = await tools_1.getCodebaseMapTool.execute({
+                repoPath: repoPath || this.options.repoPath || process.cwd(),
+                section
+            }, { toolCallId: '', messages: [] });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2)
+                    }]
+            };
+        });
+        this.log('Registered 13 tools');
+        // Register PREVC workflow tools
+        this.registerWorkflowTools();
+    }
+    /**
+     * Register PREVC workflow tools
+     */
+    registerWorkflowTools() {
+        const repoPath = this.options.repoPath || process.cwd();
+        // workflowInit - Initialize a PREVC workflow
+        this.server.registerTool('workflowInit', {
+            description: 'Initialize a PREVC workflow with automatic scale detection. PREVC = Planejamento, Revisão, Execução, Validação, Confirmação.',
+            inputSchema: {
+                name: zod_1.z.string().describe('Name of the project/feature'),
+                description: zod_1.z.string().optional().describe('Description for scale detection'),
+                scale: zod_1.z.enum(['QUICK', 'SMALL', 'MEDIUM', 'LARGE', 'ENTERPRISE']).optional()
+                    .describe('Project scale (auto-detected if not provided)')
+            }
+        }, async ({ name, description, scale }) => {
+            try {
+                const resolvedRepoPath = path.resolve(repoPath);
+                const service = new workflow_1.WorkflowService(resolvedRepoPath);
+                const status = await service.init({
+                    name,
+                    description,
+                    scale: scale,
+                });
+                // Include file paths for visibility
+                const contextPath = path.join(resolvedRepoPath, '.context');
+                const statusFilePath = path.join(contextPath, 'workflow', 'status.yaml');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Workflow initialized: ${name}`,
+                                scale: (0, workflow_2.getScaleName)(status.project.scale),
+                                currentPhase: status.project.current_phase,
+                                phases: Object.keys(status.phases).filter((p) => status.phases[p].status !== 'skipped'),
+                                statusFilePath,
+                                contextPath,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // workflowStatus - Get current workflow status
+        this.server.registerTool('workflowStatus', {
+            description: 'Get the current status of the PREVC workflow including phases, roles, and progress.',
+            inputSchema: {}
+        }, async () => {
+            try {
+                const resolvedRepoPath = path.resolve(repoPath);
+                const service = new workflow_1.WorkflowService(resolvedRepoPath);
+                if (!(await service.hasWorkflow())) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: 'No workflow found. Run workflowInit first.',
+                                    statusFilePath: path.join(resolvedRepoPath, '.context', 'workflow', 'status.yaml')
+                                }, null, 2)
+                            }]
+                    };
+                }
+                const summary = await service.getSummary();
+                const status = await service.getStatus();
+                const statusFilePath = path.join(resolvedRepoPath, '.context', 'workflow', 'status.yaml');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                name: summary.name,
+                                scale: (0, workflow_2.getScaleName)(summary.scale),
+                                currentPhase: {
+                                    code: summary.currentPhase,
+                                    name: workflow_2.PHASE_NAMES_EN[summary.currentPhase],
+                                },
+                                progress: summary.progress,
+                                isComplete: summary.isComplete,
+                                phases: status.phases,
+                                roles: status.roles,
+                                statusFilePath,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // workflowAdvance - Advance to the next phase
+        this.server.registerTool('workflowAdvance', {
+            description: 'Complete the current phase and advance to the next phase in the PREVC workflow.',
+            inputSchema: {
+                outputs: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('List of artifact paths generated in the current phase')
+            }
+        }, async ({ outputs }) => {
+            try {
+                const service = new workflow_1.WorkflowService(repoPath);
+                if (!(await service.hasWorkflow())) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: 'No workflow found. Run workflowInit first.'
+                                }, null, 2)
+                            }]
+                    };
+                }
+                const nextPhase = await service.advance(outputs);
+                if (nextPhase) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    message: `Advanced to ${workflow_2.PHASE_NAMES_EN[nextPhase]} phase`,
+                                    nextPhase: {
+                                        code: nextPhase,
+                                        name: workflow_2.PHASE_NAMES_EN[nextPhase],
+                                    }
+                                }, null, 2)
+                            }]
+                    };
+                }
+                else {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    message: 'Workflow completed!',
+                                    isComplete: true
+                                }, null, 2)
+                            }]
+                    };
+                }
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // workflowHandoff - Handoff between roles
+        this.server.registerTool('workflowHandoff', {
+            description: 'Perform a handoff from one role to another within the PREVC workflow.',
+            inputSchema: {
+                from: zod_1.z.enum(workflow_2.PREVC_ROLES)
+                    .describe('Role handing off'),
+                to: zod_1.z.enum(workflow_2.PREVC_ROLES)
+                    .describe('Role receiving handoff'),
+                artifacts: zod_1.z.array(zod_1.z.string()).describe('Artifacts being handed off')
+            }
+        }, async ({ from, to, artifacts }) => {
+            try {
+                const service = new workflow_1.WorkflowService(repoPath);
+                if (!(await service.hasWorkflow())) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: 'No workflow found. Run workflowInit first.'
+                                }, null, 2)
+                            }]
+                    };
+                }
+                await service.handoff(from, to, artifacts);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Handoff complete: ${workflow_2.ROLE_DISPLAY_NAMES[from]} → ${workflow_2.ROLE_DISPLAY_NAMES[to]}`,
+                                from: { role: from, displayName: workflow_2.ROLE_DISPLAY_NAMES[from] },
+                                to: { role: to, displayName: workflow_2.ROLE_DISPLAY_NAMES[to] },
+                                artifacts
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // workflowCollaborate - Start a collaboration session
+        this.server.registerTool('workflowCollaborate', {
+            description: 'Start a multi-role collaboration session for complex decisions or brainstorming.',
+            inputSchema: {
+                topic: zod_1.z.string().describe('Topic for the collaboration session'),
+                participants: zod_1.z.array(zod_1.z.enum(workflow_2.PREVC_ROLES))
+                    .optional()
+                    .describe('Roles to participate (auto-selected if not provided)')
+            }
+        }, async ({ topic, participants }) => {
+            try {
+                const service = new workflow_1.WorkflowService(repoPath);
+                const session = await service.startCollaboration(topic, participants);
+                const status = session.getStatus();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Collaboration session started: ${topic}`,
+                                sessionId: status.id,
+                                topic: status.topic,
+                                participants: status.participants.map((p) => ({
+                                    role: p,
+                                    displayName: workflow_2.ROLE_DISPLAY_NAMES[p],
+                                })),
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // workflowCreateDoc - Create a document for the current phase
+        this.server.registerTool('workflowCreateDoc', {
+            description: 'Create a document template for the current phase of the PREVC workflow.',
+            inputSchema: {
+                type: zod_1.z.enum(['prd', 'tech-spec', 'architecture', 'adr', 'test-plan', 'changelog'])
+                    .describe('Type of document to create'),
+                name: zod_1.z.string().describe('Name/title for the document')
+            }
+        }, async ({ type, name }) => {
+            try {
+                const service = new workflow_1.WorkflowService(repoPath);
+                if (!(await service.hasWorkflow())) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: 'No workflow found. Run workflowInit first.'
+                                }, null, 2)
+                            }]
+                    };
+                }
+                // For now, return the document path that should be created
+                const docPath = `.context/workflow/docs/${type}-${name.toLowerCase().replace(/\s+/g, '-')}.md`;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Document template ready: ${type}`,
+                                documentType: type,
+                                suggestedPath: docPath,
+                                name,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.log('Registered 6 workflow tools');
+        // Register extended workflow tools (start, report, export, stack detection)
+        this.registerExtendedWorkflowTools();
+    }
+    /**
+     * Register extended workflow tools (start, report, export, stack detection)
+     */
+    registerExtendedWorkflowTools() {
+        const repoPath = this.options.repoPath || process.cwd();
+        // projectStart - Unified start command
+        this.server.registerTool('projectStart', {
+            description: 'Start a new project with unified setup: scaffolding + context fill + workflow initialization. Supports workflow templates (hotfix, feature, mvp).',
+            inputSchema: {
+                featureName: zod_1.z.string().describe('Feature/project name'),
+                template: zod_1.z.enum(['hotfix', 'feature', 'mvp', 'auto']).optional()
+                    .describe('Workflow template (hotfix=quick fix, feature=standard, mvp=complete)'),
+                skipFill: zod_1.z.boolean().optional().describe('Skip AI-assisted context filling'),
+                skipWorkflow: zod_1.z.boolean().optional().describe('Skip workflow initialization'),
+            }
+        }, async ({ featureName, template, skipFill, skipWorkflow }) => {
+            try {
+                const startService = new start_1.StartService({
+                    ui: {
+                        displayOutput: () => { },
+                        displaySuccess: () => { },
+                        displayError: () => { },
+                        displayInfo: () => { },
+                        displayWarning: () => { },
+                        startSpinner: () => { },
+                        stopSpinner: () => { },
+                        updateSpinner: () => { },
+                        prompt: async () => '',
+                        confirm: async () => true,
+                    },
+                    t: (key) => key,
+                    version: version_1.VERSION,
+                    defaultModel: 'claude-3-5-sonnet-20241022',
+                });
+                const result = await startService.run(repoPath, {
+                    featureName,
+                    template: template,
+                    skipFill,
+                    skipWorkflow,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: result.workflowStarted || result.initialized,
+                                initialized: result.initialized,
+                                filled: result.filled,
+                                workflowStarted: result.workflowStarted,
+                                scale: result.scale ? (0, workflow_2.getScaleName)(result.scale) : null,
+                                featureName: result.featureName,
+                                stack: result.stackDetected ? {
+                                    primaryLanguage: result.stackDetected.primaryLanguage,
+                                    frameworks: result.stackDetected.frameworks,
+                                } : null,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // projectReport - Generate visual reports
+        this.server.registerTool('projectReport', {
+            description: 'Generate a visual progress report for the current PREVC workflow. Shows phases, roles, deliverables, and a visual dashboard.',
+            inputSchema: {
+                format: zod_1.z.enum(['json', 'markdown', 'dashboard']).default('dashboard').optional()
+                    .describe('Output format: json (raw data), markdown (formatted), dashboard (visual)'),
+                includeStack: zod_1.z.boolean().optional().describe('Include technology stack info'),
+            }
+        }, async ({ format, includeStack }) => {
+            try {
+                const reportService = new report_1.ReportService({
+                    ui: {
+                        displayOutput: () => { },
+                        displaySuccess: () => { },
+                        displayError: () => { },
+                        displayInfo: () => { },
+                        displayWarning: () => { },
+                        startSpinner: () => { },
+                        stopSpinner: () => { },
+                        updateSpinner: () => { },
+                    },
+                    t: (key) => key,
+                    version: version_1.VERSION,
+                });
+                const report = await reportService.generate(repoPath, { includeStack });
+                let output;
+                if (format === 'json') {
+                    output = JSON.stringify(report, null, 2);
+                }
+                else if (format === 'dashboard') {
+                    output = reportService.generateVisualDashboard(report);
+                }
+                else {
+                    // Markdown format - use visual dashboard as fallback
+                    output = reportService.generateVisualDashboard(report);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: output
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // exportRules - Export rules to AI tools
+        this.server.registerTool('exportRules', {
+            description: 'Export context rules to AI tool directories (Cursor, Claude, GitHub Copilot, Windsurf, Cline, Aider, Codex). Bidirectional rules sync.',
+            inputSchema: {
+                preset: zod_1.z.enum(['cursor', 'claude', 'github', 'windsurf', 'cline', 'aider', 'codex', 'all']).default('all')
+                    .describe('Target AI tool preset or "all" for all supported tools'),
+                force: zod_1.z.boolean().optional().describe('Overwrite existing files'),
+                dryRun: zod_1.z.boolean().optional().describe('Preview changes without writing'),
+            }
+        }, async ({ preset, force, dryRun }) => {
+            try {
+                const exportService = new export_1.ExportRulesService({
+                    ui: {
+                        displayOutput: () => { },
+                        displaySuccess: () => { },
+                        displayError: () => { },
+                        displayInfo: () => { },
+                        displayWarning: () => { },
+                        startSpinner: () => { },
+                        stopSpinner: () => { },
+                        updateSpinner: () => { },
+                    },
+                    t: (key) => key,
+                    version: version_1.VERSION,
+                });
+                const result = await exportService.run(repoPath, { preset, force, dryRun });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                filesCreated: result.filesCreated,
+                                filesSkipped: result.filesSkipped,
+                                filesFailed: result.filesFailed,
+                                targets: result.targets,
+                                errors: result.errors,
+                                dryRun: dryRun || false,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // detectStack - Detect project technology stack
+        this.server.registerTool('detectStack', {
+            description: 'Detect the project technology stack including languages, frameworks, build tools, and test frameworks. Useful for intelligent defaults.',
+            inputSchema: {}
+        }, async () => {
+            try {
+                const detector = new stack_1.StackDetector();
+                const stackInfo = await detector.detect(repoPath);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                stack: stackInfo,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.log('Registered 4 extended workflow tools');
+        // Register plan-workflow integration tools
+        this.registerPlanTools();
+    }
+    /**
+     * Register plan-workflow integration tools
+     */
+    registerPlanTools() {
+        const repoPath = this.options.repoPath || process.cwd();
+        // linkPlan - Link a plan to the current workflow
+        this.server.registerTool('linkPlan', {
+            description: 'Link an implementation plan to the current PREVC workflow. Plans provide detailed steps mapped to workflow phases.',
+            inputSchema: {
+                planSlug: zod_1.z.string().describe('Plan slug/identifier (filename without .md)'),
+            }
+        }, async ({ planSlug }) => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const ref = await linker.linkPlan(planSlug);
+                if (!ref) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: `Plan not found: ${planSlug}`,
+                                }, null, 2)
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                plan: ref,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // getLinkedPlans - Get all plans linked to the workflow
+        this.server.registerTool('getLinkedPlans', {
+            description: 'Get all implementation plans linked to the current PREVC workflow.',
+            inputSchema: {}
+        }, async () => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const plans = await linker.getLinkedPlans();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                plans,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // getPlanDetails - Get detailed plan with PREVC mapping
+        this.server.registerTool('getPlanDetails', {
+            description: 'Get detailed plan information including phases mapped to PREVC, agents, and documentation.',
+            inputSchema: {
+                planSlug: zod_1.z.string().describe('Plan slug/identifier'),
+            }
+        }, async ({ planSlug }) => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const plan = await linker.getLinkedPlan(planSlug);
+                if (!plan) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: `Plan not found or not linked: ${planSlug}`,
+                                }, null, 2)
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                plan: {
+                                    ...plan,
+                                    phasesWithPrevc: plan.phases.map(p => ({
+                                        ...p,
+                                        prevcPhaseName: workflow_2.PHASE_NAMES_EN[p.prevcPhase],
+                                    })),
+                                },
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // getPlansForPhase - Get plans relevant to current PREVC phase
+        this.server.registerTool('getPlansForPhase', {
+            description: 'Get all plans that have work items for a specific PREVC phase.',
+            inputSchema: {
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).describe('PREVC phase'),
+            }
+        }, async ({ phase }) => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const plans = await linker.getPlansForPhase(phase);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                phase,
+                                phaseName: workflow_2.PHASE_NAMES_EN[phase],
+                                plans: plans.map(p => ({
+                                    slug: p.ref.slug,
+                                    title: p.ref.title,
+                                    phasesInThisPrevc: p.phases
+                                        .filter(ph => ph.prevcPhase === phase)
+                                        .map(ph => ({ id: ph.id, name: ph.name, status: ph.status })),
+                                    hasPendingWork: linker.hasPendingWorkForPhase(p, phase),
+                                })),
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // updatePlanPhase - Update plan phase status
+        this.server.registerTool('updatePlanPhase', {
+            description: 'Update the status of a plan phase (syncs with PREVC workflow tracking).',
+            inputSchema: {
+                planSlug: zod_1.z.string().describe('Plan slug/identifier'),
+                phaseId: zod_1.z.string().describe('Phase ID within the plan (e.g., "phase-1")'),
+                status: zod_1.z.enum(['pending', 'in_progress', 'completed', 'skipped']).describe('New status'),
+            }
+        }, async ({ planSlug, phaseId, status }) => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const success = await linker.updatePlanPhase(planSlug, phaseId, status);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success,
+                                planSlug,
+                                phaseId,
+                                status,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // recordDecision - Record a decision in a plan
+        this.server.registerTool('recordDecision', {
+            description: 'Record a decision made during plan execution. Decisions are tracked and can be referenced later.',
+            inputSchema: {
+                planSlug: zod_1.z.string().describe('Plan slug/identifier'),
+                title: zod_1.z.string().describe('Decision title'),
+                description: zod_1.z.string().describe('Decision description and rationale'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional().describe('Related PREVC phase'),
+                alternatives: zod_1.z.array(zod_1.z.string()).optional().describe('Alternatives that were considered'),
+            }
+        }, async ({ planSlug, title, description, phase, alternatives }) => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const decision = await linker.recordDecision(planSlug, {
+                    title,
+                    description,
+                    phase: phase,
+                    alternatives,
+                    status: 'accepted',
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                decision,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // discoverAgents - Discover all available agents (built-in + custom)
+        this.server.registerTool('discoverAgents', {
+            description: 'Discover all available agents including custom ones. Scans .context/agents/ for custom agent playbooks.',
+            inputSchema: {}
+        }, async () => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const agents = await linker.discoverAgents();
+                const builtIn = agents.filter(a => !a.isCustom);
+                const custom = agents.filter(a => a.isCustom);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                totalAgents: agents.length,
+                                builtInCount: builtIn.length,
+                                customCount: custom.length,
+                                agents: {
+                                    builtIn: builtIn.map(a => a.type),
+                                    custom: custom.map(a => ({ type: a.type, path: a.path })),
+                                },
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // getAgentInfo - Get detailed info about a specific agent
+        this.server.registerTool('getAgentInfo', {
+            description: 'Get detailed information about a specific agent (built-in or custom). Returns path, existence status, title, and description.',
+            inputSchema: {
+                agentType: zod_1.z.string().describe('Agent type/identifier (e.g., "code-reviewer" or "agente-de-marketing")'),
+            }
+        }, async ({ agentType }) => {
+            try {
+                const linker = (0, workflow_2.createPlanLinker)(repoPath);
+                const info = await linker.getAgentInfo(agentType);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                agent: info,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.log('Registered 8 plan-workflow tools');
     }
     /**
      * Register semantic context resources
@@ -373,6 +1303,611 @@ class AIContextMCPServer {
             };
         });
         this.log('Registered 2 resource templates');
+        // Register PREVC workflow resources
+        this.registerWorkflowResources();
+        // Register orchestration tools
+        this.registerOrchestrationTools();
+    }
+    /**
+     * Register PREVC workflow resources
+     */
+    registerWorkflowResources() {
+        const repoPath = this.options.repoPath || process.cwd();
+        // workflow://status - Current workflow status
+        this.server.registerResource('workflow-status', 'workflow://status', {
+            description: 'Current PREVC workflow status including phases, roles, and progress',
+            mimeType: 'application/json'
+        }, async () => {
+            try {
+                const service = new workflow_1.WorkflowService(repoPath);
+                if (!(await service.hasWorkflow())) {
+                    return {
+                        contents: [{
+                                uri: 'workflow://status',
+                                mimeType: 'application/json',
+                                text: JSON.stringify({ error: 'No workflow found' }, null, 2)
+                            }]
+                    };
+                }
+                const summary = await service.getSummary();
+                const status = await service.getStatus();
+                return {
+                    contents: [{
+                            uri: 'workflow://status',
+                            mimeType: 'application/json',
+                            text: JSON.stringify({
+                                name: summary.name,
+                                scale: (0, workflow_2.getScaleName)(summary.scale),
+                                currentPhase: summary.currentPhase,
+                                progress: summary.progress,
+                                isComplete: summary.isComplete,
+                                phases: status.phases,
+                                roles: status.roles,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    contents: [{
+                            uri: 'workflow://status',
+                            mimeType: 'application/json',
+                            text: JSON.stringify({
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.log('Registered 1 workflow resource');
+    }
+    /**
+     * Register agent orchestration tools
+     */
+    registerOrchestrationTools() {
+        // orchestrateAgents - Select agents for a task, phase, or role
+        this.server.registerTool('orchestrateAgents', {
+            description: 'Select appropriate agents based on task description, PREVC phase, or role. Returns recommended agents with their descriptions and relevant documentation.',
+            inputSchema: {
+                task: zod_1.z.string().optional().describe('Task description for intelligent agent selection'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional().describe('PREVC phase to get agents for'),
+                role: zod_1.z.enum(workflow_2.PREVC_ROLES).optional().describe('PREVC role to get agents for'),
+            },
+        }, async ({ task, phase, role }) => {
+            try {
+                let agents = [];
+                let source = '';
+                if (task) {
+                    agents = workflow_2.agentOrchestrator.selectAgentsByTask(task);
+                    source = `task: "${task}"`;
+                }
+                else if (phase) {
+                    agents = workflow_2.agentOrchestrator.getAgentsForPhase(phase);
+                    source = `phase: ${phase} (${workflow_2.PHASE_NAMES_EN[phase]})`;
+                }
+                else if (role) {
+                    agents = workflow_2.agentOrchestrator.getAgentsForRole(role);
+                    source = `role: ${workflow_2.ROLE_DISPLAY_NAMES[role]}`;
+                }
+                else {
+                    return {
+                        content: [{ type: 'text', text: 'Error: Provide task, phase, or role parameter' }],
+                    };
+                }
+                const agentDetails = agents.map((agent) => ({
+                    type: agent,
+                    description: workflow_2.agentOrchestrator.getAgentDescription(agent),
+                    docs: workflow_2.documentLinker.getDocPathsForAgent(agent),
+                }));
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                source,
+                                agents: agentDetails,
+                                count: agents.length,
+                            }, null, 2),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                        }],
+                };
+            }
+        });
+        // getAgentSequence - Get recommended agent sequence for a task
+        this.server.registerTool('getAgentSequence', {
+            description: 'Get recommended sequence of agents for a task, including handoff order. Useful for planning multi-agent workflows.',
+            inputSchema: {
+                task: zod_1.z.string().describe('Task description'),
+                includeReview: zod_1.z.boolean().optional().describe('Include code review in sequence (default: true)'),
+                phases: zod_1.z.array(zod_1.z.enum(['P', 'R', 'E', 'V', 'C'])).optional().describe('PREVC phases to include (for phase-based sequencing)'),
+            },
+        }, async ({ task, includeReview, phases }) => {
+            try {
+                let sequence;
+                if (phases && phases.length > 0) {
+                    sequence = workflow_2.agentOrchestrator.getAgentHandoffSequence(phases);
+                }
+                else {
+                    sequence = workflow_2.agentOrchestrator.getTaskAgentSequence(task, includeReview !== false);
+                }
+                const sequenceDetails = sequence.map((agent, index) => ({
+                    order: index + 1,
+                    agent,
+                    description: workflow_2.agentOrchestrator.getAgentDescription(agent),
+                    primaryDoc: workflow_2.documentLinker.getPrimaryDocForAgent(agent)?.path || null,
+                }));
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                task,
+                                sequence: sequenceDetails,
+                                totalAgents: sequence.length,
+                            }, null, 2),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                        }],
+                };
+            }
+        });
+        // getAgentDocs - Get documentation relevant to an agent
+        this.server.registerTool('getAgentDocs', {
+            description: 'Get documentation guides relevant to a specific agent type. Helps agents find the right context.',
+            inputSchema: {
+                agent: zod_1.z.enum(workflow_2.AGENT_TYPES).describe('Agent type to get documentation for'),
+            },
+        }, async ({ agent }) => {
+            try {
+                if (!workflow_2.agentOrchestrator.isValidAgentType(agent)) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Error: Invalid agent type "${agent}". Valid types: ${workflow_2.AGENT_TYPES.join(', ')}`,
+                            }],
+                    };
+                }
+                const docs = workflow_2.documentLinker.getDocsForAgent(agent);
+                const agentDesc = workflow_2.agentOrchestrator.getAgentDescription(agent);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                agent,
+                                description: agentDesc,
+                                documentation: docs.map((doc) => ({
+                                    type: doc.type,
+                                    title: doc.title,
+                                    path: doc.path,
+                                    description: doc.description,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                        }],
+                };
+            }
+        });
+        // getPhaseDocs - Get documentation for a PREVC phase
+        this.server.registerTool('getPhaseDocs', {
+            description: 'Get documentation relevant to a PREVC workflow phase. Helps understand what documentation is needed at each phase.',
+            inputSchema: {
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).describe('PREVC phase (P=Planning, R=Review, E=Execution, V=Validation, C=Confirmation)'),
+            },
+        }, async ({ phase }) => {
+            try {
+                const docs = workflow_2.documentLinker.getDocsForPhase(phase);
+                const agents = workflow_2.agentOrchestrator.getAgentsForPhase(phase);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                phase,
+                                phaseName: workflow_2.PHASE_NAMES_EN[phase],
+                                documentation: docs.map((doc) => ({
+                                    type: doc.type,
+                                    title: doc.title,
+                                    path: doc.path,
+                                    description: doc.description,
+                                })),
+                                recommendedAgents: agents.map((agent) => ({
+                                    type: agent,
+                                    description: workflow_2.agentOrchestrator.getAgentDescription(agent),
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                        }],
+                };
+            }
+        });
+        // listAgentTypes - List all available agent types
+        this.server.registerTool('listAgentTypes', {
+            description: 'List all available agent types with their descriptions. Use this to understand what agents are available.',
+            inputSchema: {},
+        }, async () => {
+            const agents = workflow_2.agentOrchestrator.getAllAgentTypes().map((agent) => ({
+                type: agent,
+                description: workflow_2.agentOrchestrator.getAgentDescription(agent),
+                primaryDoc: workflow_2.documentLinker.getPrimaryDocForAgent(agent)?.title || null,
+            }));
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            agents,
+                            total: agents.length,
+                        }, null, 2),
+                    }],
+            };
+        });
+        this.log('Registered 5 orchestration tools');
+        // Register skill tools
+        this.registerSkillTools();
+    }
+    /**
+     * Register skill tools for on-demand expertise
+     */
+    registerSkillTools() {
+        const repoPath = this.options.repoPath || process.cwd();
+        // Import skill registry
+        const { createSkillRegistry, BUILT_IN_SKILLS, SKILL_TO_PHASES } = require('../../workflow/skills');
+        // listSkills - List all available skills
+        this.server.registerTool('listSkills', {
+            description: 'List all available skills (built-in + custom). Skills are on-demand expertise for specific tasks.',
+            inputSchema: {
+                includeContent: zod_1.z.boolean().optional().describe('Include full skill content in response'),
+            }
+        }, async ({ includeContent }) => {
+            try {
+                const registry = createSkillRegistry(repoPath);
+                const discovered = await registry.discoverAll();
+                const format = (skill) => ({
+                    slug: skill.slug,
+                    name: skill.metadata.name,
+                    description: skill.metadata.description,
+                    phases: skill.metadata.phases || [],
+                    isBuiltIn: skill.isBuiltIn,
+                    ...(includeContent ? { content: skill.content } : {}),
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                totalSkills: discovered.all.length,
+                                builtInCount: discovered.builtIn.length,
+                                customCount: discovered.custom.length,
+                                skills: {
+                                    builtIn: discovered.builtIn.map(format),
+                                    custom: discovered.custom.map(format),
+                                },
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // getSkillContent - Get full content of a specific skill
+        this.server.registerTool('getSkillContent', {
+            description: 'Get the full content of a skill by slug. Returns the SKILL.md content with instructions.',
+            inputSchema: {
+                skillSlug: zod_1.z.string().describe('Skill slug/identifier (e.g., "commit-message", "pr-review")'),
+            }
+        }, async ({ skillSlug }) => {
+            try {
+                const registry = createSkillRegistry(repoPath);
+                const content = await registry.getSkillContent(skillSlug);
+                if (!content) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: `Skill not found: ${skillSlug}`,
+                                    availableSkills: BUILT_IN_SKILLS,
+                                }, null, 2)
+                            }]
+                    };
+                }
+                const skill = await registry.getSkillMetadata(skillSlug);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                skill: {
+                                    slug: skillSlug,
+                                    name: skill?.metadata.name,
+                                    description: skill?.metadata.description,
+                                    phases: skill?.metadata.phases,
+                                    isBuiltIn: skill?.isBuiltIn,
+                                },
+                                content,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // getSkillsForPhase - Get skills relevant to a PREVC phase
+        this.server.registerTool('getSkillsForPhase', {
+            description: 'Get all skills relevant to a specific PREVC phase. Useful for knowing which skills to activate during workflow execution.',
+            inputSchema: {
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).describe('PREVC phase'),
+            }
+        }, async ({ phase }) => {
+            try {
+                const registry = createSkillRegistry(repoPath);
+                const skills = await registry.getSkillsForPhase(phase);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                phase,
+                                phaseName: workflow_2.PHASE_NAMES_EN[phase],
+                                skills: skills.map((s) => ({
+                                    slug: s.slug,
+                                    name: s.metadata.name,
+                                    description: s.metadata.description,
+                                    isBuiltIn: s.isBuiltIn,
+                                })),
+                                count: skills.length,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // scaffoldSkills - Generate skill files
+        this.server.registerTool('scaffoldSkills', {
+            description: 'Scaffold skill files in .context/skills/. Creates SKILL.md files for built-in or custom skills.',
+            inputSchema: {
+                skills: zod_1.z.array(zod_1.z.string()).optional().describe('Specific skills to scaffold (default: all built-in)'),
+                force: zod_1.z.boolean().optional().describe('Overwrite existing skill files'),
+            }
+        }, async ({ skills, force }) => {
+            try {
+                const { createSkillGenerator } = require('../../generators/skills');
+                const generator = createSkillGenerator({ repoPath });
+                const result = await generator.generate({ skills, force });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                skillsDir: result.skillsDir,
+                                generated: result.generatedSkills,
+                                skipped: result.skippedSkills,
+                                indexPath: result.indexPath,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // exportSkills - Export skills to AI tool directories
+        this.server.registerTool('exportSkills', {
+            description: 'Export skills to AI tool directories (Claude Code, Gemini CLI, Codex). Copies skills to .claude/skills/, .gemini/skills/, etc.',
+            inputSchema: {
+                preset: zod_1.z.enum(['claude', 'gemini', 'codex', 'all']).default('all')
+                    .describe('Target AI tool or "all" for all supported tools'),
+                includeBuiltIn: zod_1.z.boolean().optional().describe('Include built-in skills even if not scaffolded'),
+                force: zod_1.z.boolean().optional().describe('Overwrite existing files'),
+            }
+        }, async ({ preset, includeBuiltIn, force }) => {
+            try {
+                const { SkillExportService } = require('../export/skillExportService');
+                const exportService = new SkillExportService({
+                    ui: {
+                        displayOutput: () => { },
+                        displaySuccess: () => { },
+                        displayError: () => { },
+                        displayWarning: () => { },
+                        startSpinner: () => { },
+                        stopSpinner: () => { },
+                        updateSpinner: () => { },
+                    },
+                    t: (key) => key,
+                    version: version_1.VERSION,
+                });
+                const result = await exportService.run(repoPath, {
+                    preset,
+                    includeBuiltIn,
+                    force,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: result.filesCreated > 0,
+                                targets: result.targets,
+                                skillsExported: result.skillsExported,
+                                filesCreated: result.filesCreated,
+                                filesSkipped: result.filesSkipped,
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        // fillSkills - Return fill instructions for skill files (NO API key required)
+        this.server.registerTool('fillSkills', {
+            description: `Fill/personalize skill files with codebase-aware content.
+Returns semantic context and fill instructions for the AI agent to process.
+The AI agent MUST then fill each skill file using the provided context and instructions.`,
+            inputSchema: {
+                skills: zod_1.z.array(zod_1.z.string()).optional().describe('Specific skills to fill (default: all scaffolded)'),
+                force: zod_1.z.boolean().optional().describe('Include already-filled skills'),
+            }
+        }, async ({ skills, force }) => {
+            try {
+                const fs = require('fs-extra');
+                const registry = createSkillRegistry(repoPath);
+                const skillsDir = path.join(repoPath, '.context', 'skills');
+                // Check if skills directory exists
+                if (!await fs.pathExists(skillsDir)) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: 'Skills directory does not exist. Run scaffoldSkills first.',
+                                    skillsDir,
+                                }, null, 2)
+                            }]
+                    };
+                }
+                // Discover skills to fill
+                const discovered = await registry.discoverAll();
+                let skillsToFill = discovered.all;
+                // Filter by specific skills if provided
+                if (skills && skills.length > 0) {
+                    skillsToFill = skillsToFill.filter((s) => skills.includes(s.slug));
+                }
+                // Filter out already-filled skills unless force is set
+                if (!force) {
+                    skillsToFill = skillsToFill.filter((s) => {
+                        // Check if skill file exists and has minimal content (likely a template)
+                        if (!fs.existsSync(s.path))
+                            return true;
+                        const content = fs.readFileSync(s.path, 'utf-8');
+                        // Consider it unfilled if it's a template (has placeholder markers)
+                        return content.includes('<!-- TODO') || content.includes('[PLACEHOLDER]') || content.length < 500;
+                    });
+                }
+                if (skillsToFill.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    message: 'No skills need filling. Use force=true to refill existing skills.',
+                                    skillsDir,
+                                }, null, 2)
+                            }]
+                    };
+                }
+                // Build semantic context
+                let semanticContext;
+                try {
+                    semanticContext = await (0, tools_1.getOrBuildContext)(repoPath);
+                }
+                catch (contextError) {
+                    // Continue without semantic context
+                    semanticContext = undefined;
+                }
+                // Build fill instructions for each skill
+                const fillInstructions = skillsToFill.map((skill) => ({
+                    skillPath: skill.path,
+                    skillSlug: skill.slug,
+                    skillName: skill.metadata.name || skill.slug,
+                    description: skill.metadata.description || '',
+                    isBuiltIn: skill.isBuiltIn,
+                    instructions: getSkillFillInstructions(skill.slug),
+                }));
+                // Build comprehensive fill prompt
+                const fillPrompt = buildSkillFillPrompt(fillInstructions, semanticContext);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                skillsToFill: fillInstructions,
+                                semanticContext,
+                                fillPrompt,
+                                instructions: 'IMPORTANT: You MUST now fill each skill file using the semantic context and fill instructions provided. Write the content to each skillPath.',
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }]
+                };
+            }
+        });
+        this.log('Registered 6 skill tools');
     }
     /**
      * Start the MCP server with stdio transport
@@ -400,6 +1935,115 @@ class AIContextMCPServer {
     }
 }
 exports.AIContextMCPServer = AIContextMCPServer;
+/**
+ * Get fill instructions for a skill based on its type
+ */
+function getSkillFillInstructions(skillSlug) {
+    const instructions = {
+        'commit-message': `Fill this skill with:
+- Commit message format conventions for this project
+- Examples of good commit messages from the codebase
+- Branch naming conventions if applicable
+- Semantic versioning guidelines`,
+        'pr-review': `Fill this skill with:
+- PR review checklist specific to this codebase
+- Code quality standards to check
+- Testing requirements before merge
+- Documentation expectations`,
+        'code-review': `Fill this skill with:
+- Code review guidelines for this project
+- Common patterns to look for
+- Security and performance considerations
+- Style and convention checks`,
+        'test-generation': `Fill this skill with:
+- Testing framework and conventions used
+- Test file organization patterns
+- Mocking strategies for this codebase
+- Coverage requirements`,
+        'documentation': `Fill this skill with:
+- Documentation standards for this project
+- JSDoc/TSDoc conventions
+- README structure expectations
+- API documentation guidelines`,
+        'refactoring': `Fill this skill with:
+- Refactoring patterns common in this codebase
+- Code smell detection guidelines
+- Safe refactoring procedures
+- Testing requirements after refactoring`,
+        'bug-investigation': `Fill this skill with:
+- Debugging workflow for this codebase
+- Common bug patterns and their fixes
+- Logging and error handling conventions
+- Test verification steps`,
+        'feature-breakdown': `Fill this skill with:
+- Feature decomposition approach
+- Task estimation guidelines
+- Dependency identification process
+- Integration points to consider`,
+        'api-design': `Fill this skill with:
+- API design patterns used in this project
+- Endpoint naming conventions
+- Request/response format standards
+- Versioning and deprecation policies`,
+        'security-audit': `Fill this skill with:
+- Security checklist for this codebase
+- Common vulnerabilities to check
+- Authentication/authorization patterns
+- Data validation requirements`,
+    };
+    return instructions[skillSlug] || `Fill this skill with project-specific content for ${skillSlug}:
+- Identify relevant patterns from the codebase
+- Include specific examples from the project
+- Add conventions and best practices
+- Reference important files and components`;
+}
+/**
+ * Build comprehensive fill prompt for skills
+ */
+function buildSkillFillPrompt(skills, semanticContext) {
+    const lines = [];
+    lines.push('# Skill Fill Instructions');
+    lines.push('');
+    lines.push('You MUST fill each of the following skill files with codebase-specific content.');
+    lines.push('');
+    if (semanticContext) {
+        lines.push('## Codebase Context');
+        lines.push('');
+        lines.push('Use this semantic context to understand the codebase:');
+        lines.push('');
+        lines.push('```');
+        lines.push(semanticContext.length > 6000 ? semanticContext.substring(0, 6000) + '\n...(truncated)' : semanticContext);
+        lines.push('```');
+        lines.push('');
+    }
+    lines.push('## Skills to Fill');
+    lines.push('');
+    for (const skill of skills) {
+        lines.push(`### ${skill.skillName} (${skill.skillSlug})`);
+        lines.push(`**Path:** \`${skill.skillPath}\``);
+        if (skill.description) {
+            lines.push(`**Description:** ${skill.description}`);
+        }
+        lines.push('');
+        lines.push('**Fill Instructions:**');
+        lines.push(skill.instructions);
+        lines.push('');
+    }
+    lines.push('## Action Required');
+    lines.push('');
+    lines.push('For each skill listed above:');
+    lines.push('1. Read the current skill template');
+    lines.push('2. Generate codebase-specific content based on the instructions and context');
+    lines.push('3. Write the filled content to the skill file');
+    lines.push('');
+    lines.push('Each skill should be personalized with:');
+    lines.push('- Specific examples from this codebase');
+    lines.push('- Project-specific conventions and patterns');
+    lines.push('- References to relevant files and components');
+    lines.push('');
+    lines.push('DO NOT leave placeholder text. Each skill must have meaningful, project-specific content.');
+    return lines.join('\n');
+}
 /**
  * Create and start an MCP server
  */