@ai-coders/context 0.6.1 → 0.7.0

package/dist/services/mcp/mcpServer.js

@@ -2,7 +2,10 @@
 /**
  * MCP Server - Model Context Protocol server for Claude Code integration
  *
- * Exposes code analysis tools and semantic context as MCP resources.
+ * Exposes 9 tools (5 consolidated gateways + 4 dedicated workflow tools) for
+ * reduced context and simpler tool selection for AI agents.
+ *
+ * Simplified workflow: context init → fillSingle → workflow-init
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -44,1214 +47,459 @@ 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 fs = __importStar(require("fs-extra"));
 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;
-        this.options = {
-            name: 'ai-context',
-            verbose: false,
-            ...options
-        };
-        this.server = new mcp_js_1.McpServer({
-            name: this.options.name,
-            version: version_1.VERSION
-        });
-        this.contextBuilder = new contextBuilder_1.SemanticContextBuilder();
-        this.registerTools();
-        this.registerResources();
-    }
-    /**
-     * Register code analysis tools
-     */
-    registerTools() {
-        // readFile tool
-        this.server.registerTool('readFile', {
-            description: (0, toolRegistry_1.getToolDescription)('readFile'),
-            inputSchema: {
-                filePath: zod_1.z.string().describe('Absolute or relative path to the file to read'),
-                encoding: zod_1.z.enum(['utf-8', 'ascii', 'binary']).default('utf-8').optional()
-            }
-        }, async ({ filePath, encoding }) => {
-            const result = await tools_1.readFileTool.execute({ filePath, encoding }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // listFiles tool
-        this.server.registerTool('listFiles', {
-            description: (0, toolRegistry_1.getToolDescription)('listFiles'),
-            inputSchema: {
-                pattern: zod_1.z.string().describe('Glob pattern to match files (e.g., "**/*.ts")'),
-                cwd: zod_1.z.string().optional().describe('Working directory for the glob pattern'),
-                ignore: zod_1.z.array(zod_1.z.string()).optional().describe('Patterns to ignore')
-            }
-        }, async ({ pattern, cwd, ignore }) => {
-            const result = await tools_1.listFilesTool.execute({ pattern, cwd: cwd || this.options.repoPath, ignore }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // analyzeSymbols tool
-        this.server.registerTool('analyzeSymbols', {
-            description: (0, toolRegistry_1.getToolDescription)('analyzeSymbols'),
-            inputSchema: {
-                filePath: zod_1.z.string().describe('Path to the file to analyze'),
-                symbolTypes: zod_1.z.array(zod_1.z.enum(['class', 'interface', 'function', 'type', 'enum']))
-                    .optional()
-                    .describe('Types of symbols to extract')
-            }
-        }, async ({ filePath, symbolTypes }) => {
-            const result = await tools_1.analyzeSymbolsTool.execute({ filePath, symbolTypes }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // getFileStructure tool
-        this.server.registerTool('getFileStructure', {
-            description: (0, toolRegistry_1.getToolDescription)('getFileStructure'),
-            inputSchema: {
-                rootPath: zod_1.z.string().describe('Root path of the repository'),
-                maxDepth: zod_1.z.number().optional().default(3).describe('Maximum directory depth'),
-                includePatterns: zod_1.z.array(zod_1.z.string()).optional()
-            }
-        }, async ({ rootPath, maxDepth, includePatterns }) => {
-            const result = await tools_1.getFileStructureTool.execute({ rootPath: rootPath || this.options.repoPath || '.', maxDepth, includePatterns }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // searchCode tool
-        this.server.registerTool('searchCode', {
-            description: (0, toolRegistry_1.getToolDescription)('searchCode'),
-            inputSchema: {
-                pattern: zod_1.z.string().describe('Regex pattern to search for'),
-                fileGlob: zod_1.z.string().optional().describe('Glob pattern to filter files'),
-                maxResults: zod_1.z.number().optional().default(50),
-                cwd: zod_1.z.string().optional().describe('Working directory for the search')
-            }
-        }, async ({ pattern, fileGlob, maxResults, cwd }) => {
-            const result = await tools_1.searchCodeTool.execute({
-                pattern,
-                fileGlob,
-                maxResults,
-                cwd: cwd || this.options.repoPath
-            }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // buildSemanticContext tool - higher-level context building
-        this.server.registerTool('buildSemanticContext', {
-            description: (0, toolRegistry_1.getToolDescription)('buildSemanticContext'),
-            inputSchema: {
-                repoPath: zod_1.z.string().describe('Path to the repository'),
-                contextType: zod_1.z.enum(['documentation', 'playbook', 'plan', 'compact'])
-                    .default('compact')
-                    .describe('Type of context to build'),
-                targetFile: zod_1.z.string().optional().describe('Optional target file for focused context'),
-                options: zod_1.z.object({
-                    useLSP: zod_1.z.boolean().optional(),
-                    maxContextLength: zod_1.z.number().optional(),
-                    includeDocumentation: zod_1.z.boolean().optional(),
-                    includeSignatures: zod_1.z.boolean().optional()
-                }).optional()
-            }
-        }, async ({ repoPath, contextType, targetFile, options }) => {
-            const isLocalBuilder = !!options;
-            const builder = isLocalBuilder
-                ? new contextBuilder_1.SemanticContextBuilder(options)
-                : this.contextBuilder;
-            try {
-                let context;
-                const resolvedPath = repoPath || this.options.repoPath || '.';
-                switch (contextType) {
-                    case 'documentation':
-                        context = await builder.buildDocumentationContext(resolvedPath, targetFile);
-                        break;
-                    case 'playbook':
-                        context = await builder.buildPlaybookContext(resolvedPath, targetFile || 'generic');
-                        break;
-                    case 'plan':
-                        context = await builder.buildPlanContext(resolvedPath, targetFile);
-                        break;
-                    case 'compact':
-                    default:
-                        context = await builder.buildCompactContext(resolvedPath);
-                        break;
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: context
-                        }]
-                };
-            }
-            finally {
-                if (isLocalBuilder) {
-                    await builder.shutdown();
-                }
-            }
-        });
-        // checkScaffolding tool
-        this.server.registerTool('checkScaffolding', {
-            description: (0, toolRegistry_1.getToolDescription)('checkScaffolding'),
-            inputSchema: {
-                repoPath: zod_1.z.string().optional().describe('Repository path to check (defaults to cwd)')
-            }
-        }, async ({ repoPath }) => {
-            const result = await tools_1.checkScaffoldingTool.execute({ repoPath: repoPath || this.options.repoPath }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // initializeContext tool
-        this.server.registerTool('initializeContext', {
-            description: (0, toolRegistry_1.getToolDescription)('initializeContext', true),
-            inputSchema: {
-                repoPath: zod_1.z.string().describe('Repository path to initialize'),
-                type: zod_1.z.enum(['docs', 'agents', 'both']).default('both').optional()
-                    .describe('Type of scaffolding to create'),
-                outputDir: zod_1.z.string().optional().describe('Output directory (default: ./.context)'),
-                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'),
-                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, autoFill }) => {
-            const result = await tools_1.initializeContextTool.execute({
-                repoPath: repoPath || this.options.repoPath || process.cwd(),
-                type,
-                outputDir,
-                semantic,
-                include,
-                exclude,
-                autoFill
-            }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // scaffoldPlan tool
-        this.server.registerTool('scaffoldPlan', {
-            description: (0, toolRegistry_1.getToolDescription)('scaffoldPlan'),
-            inputSchema: {
-                planName: zod_1.z.string().describe('Name of the plan (will be slugified)'),
-                repoPath: zod_1.z.string().optional().describe('Repository path'),
-                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'),
-                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, autoFill }) => {
-            const result = await tools_1.scaffoldPlanTool.execute({
-                planName,
-                repoPath: repoPath || this.options.repoPath || process.cwd(),
-                outputDir,
-                title,
-                summary,
-                semantic,
-                autoFill
-            }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // fillScaffolding tool (with pagination)
-        this.server.registerTool('fillScaffolding', {
-            description: (0, toolRegistry_1.getToolDescription)('fillScaffolding', true),
-            inputSchema: {
-                repoPath: zod_1.z.string().describe('Repository path'),
-                outputDir: zod_1.z.string().optional().describe('Scaffold directory (default: ./.context)'),
-                target: zod_1.z.enum(['docs', 'agents', 'plans', 'all']).default('all').optional()
-                    .describe('Which scaffolding to fill'),
-                offset: zod_1.z.number().optional().describe('Skip first N files (for pagination)'),
-                limit: zod_1.z.number().optional().describe('Max files to return (default: 3, use 0 for all)')
-            }
-        }, async ({ repoPath, outputDir, target, offset, limit }) => {
-            const result = await tools_1.fillScaffoldingTool.execute({
-                repoPath: repoPath || this.options.repoPath || process.cwd(),
-                outputDir,
-                target,
-                offset,
-                limit
-            }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // listFilesToFill tool - lightweight listing without content
-        this.server.registerTool('listFilesToFill', {
-            description: (0, toolRegistry_1.getToolDescription)('listFilesToFill', true),
-            inputSchema: {
-                repoPath: zod_1.z.string().describe('Repository path'),
-                outputDir: zod_1.z.string().optional().describe('Scaffold directory (default: ./.context)'),
-                target: zod_1.z.enum(['docs', 'agents', 'plans', 'all']).default('all').optional()
-                    .describe('Which scaffolding to list')
-            }
-        }, async ({ repoPath, outputDir, target }) => {
-            const result = await tools_1.listFilesToFillTool.execute({
-                repoPath: repoPath || this.options.repoPath || process.cwd(),
-                outputDir,
-                target
-            }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // fillSingleFile tool - process one file at a time
-        this.server.registerTool('fillSingleFile', {
-            description: (0, toolRegistry_1.getToolDescription)('fillSingleFile', true),
-            inputSchema: {
-                repoPath: zod_1.z.string().describe('Repository path'),
-                filePath: zod_1.z.string().describe('Absolute path to the scaffold file to fill')
-            }
-        }, async ({ repoPath, filePath }) => {
-            const result = await tools_1.fillSingleFileTool.execute({
-                repoPath: repoPath || this.options.repoPath || process.cwd(),
-                filePath
-            }, { toolCallId: '', messages: [] });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        });
-        // 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)
-                        }]
-                };
-            }
+const actionLogger_1 = require("./actionLogger");
+const workflow_2 = require("../../workflow");
+const gatewayTools_1 = require("./gatewayTools");
+class AIContextMCPServer {
+    constructor(options = {}) {
+        this.transport = null;
+        this.initialRepoPath = null;
+        this.cachedRepoPath = null;
+        this.options = {
+            name: 'ai-context',
+            verbose: false,
+            ...options
+        };
+        this.server = new mcp_js_1.McpServer({
+            name: this.options.name,
+            version: version_1.VERSION
         });
-        // 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.',
+        // Support dependency injection for testing, with default fallback
+        this.contextBuilder = options.contextBuilder ?? new contextBuilder_1.SemanticContextBuilder();
+        // Initialize and cache the correct repo path
+        void this.initializeRepoPath();
+        this.registerGatewayTools();
+        this.registerResources();
+    }
+    /**
+     * Register tools: 5 consolidated gateways + 4 dedicated workflow tools
+     * Total: 9 tools for clear entry points and reduced AI cognitive load
+     *
+     * Project tools removed - use context({ action: "init" }) + workflow-init instead
+     *
+     * NOTE: repoPath is now determined dynamically via getRepoPath() at runtime,
+     * which uses smart initialization and client path caching.
+     */
+    registerGatewayTools() {
+        const wrap = (toolName, handler) => this.wrapWithActionLogging(toolName, handler);
+        // Gateway 1: explore - File and code exploration
+        this.server.registerTool('explore', {
+            description: `File and code exploration. Actions:
+- read: Read file contents (params: filePath, encoding?)
+- list: List files matching pattern (params: pattern, cwd?, ignore?)
+- analyze: Analyze symbols in a file (params: filePath, symbolTypes?)
+- search: Search code with regex (params: pattern, fileGlob?, maxResults?, cwd?)
+- getStructure: Get directory structure (params: rootPath?, maxDepth?, includePatterns?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['read', 'list', 'analyze', 'search', 'getStructure'])
+                    .describe('Action to perform'),
+                filePath: zod_1.z.string().optional()
+                    .describe('(read, analyze) File path to read or analyze'),
+                pattern: zod_1.z.string().optional()
+                    .describe('(list, search) Glob pattern for list, regex pattern for search'),
+                cwd: zod_1.z.string().optional()
+                    .describe('(list, search) Working directory'),
+                encoding: zod_1.z.enum(['utf-8', 'ascii', 'binary']).optional()
+                    .describe('(read) File encoding'),
+                ignore: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(list) Patterns to ignore'),
+                symbolTypes: zod_1.z.array(zod_1.z.enum(['class', 'interface', 'function', 'type', 'enum'])).optional()
+                    .describe('(analyze) Types of symbols to extract'),
+                fileGlob: zod_1.z.string().optional()
+                    .describe('(search) Glob pattern to filter files'),
+                maxResults: zod_1.z.number().optional()
+                    .describe('(search) Maximum results to return'),
+                rootPath: zod_1.z.string().optional()
+                    .describe('(getStructure) Root path for structure'),
+                maxDepth: zod_1.z.number().optional()
+                    .describe('(getStructure) Maximum directory depth'),
+                includePatterns: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(getStructure) Include patterns'),
+            }
+        }, wrap('explore', async (params) => {
+            // explore uses cwd for file operations, not repoPath for context resolution
+            return (0, gatewayTools_1.handleExplore)(params, { repoPath: this.getRepoPath() });
+        }));
+        // Gateway 2: context - Context scaffolding and semantic context
+        this.server.registerTool('context', {
+            description: `Context scaffolding and semantic context. Actions:
+- check: Check if .context scaffolding exists (params: repoPath?)
+- init: Initialize .context scaffolding (params: repoPath?, type?, outputDir?, semantic?, autoFill?, skipContentGeneration?)
+- fill: Fill scaffolding with AI content (params: repoPath?, outputDir?, target?, offset?, limit?)
+- fillSingle: Fill a single scaffold file (params: repoPath?, filePath)
+- listToFill: List files that need filling (params: repoPath?, outputDir?, target?)
+- getMap: Get codebase map section (params: repoPath?, section?)
+- buildSemantic: Build semantic context (params: repoPath?, contextType?, targetFile?, options?)
+- scaffoldPlan: Create a plan template (params: planName, repoPath?, title?, summary?, autoFill?)
+
+**Important:** Agents should provide repoPath on the FIRST call, then it will be cached:
+1. First call: context({ action: "check", repoPath: "/path/to/project" })
+2. Subsequent calls can omit repoPath - it will use cached value from step 1
+3. After context init, call fillSingle for each pending file
+4. Call workflow-init to enable PREVC workflow (unless trivial change)`,
+            inputSchema: {
+                action: zod_1.z.enum(['check', 'init', 'fill', 'fillSingle', 'listToFill', 'getMap', 'buildSemantic', 'scaffoldPlan'])
+                    .describe('Action to perform'),
+                repoPath: zod_1.z.string().optional()
+                    .describe('Repository path (defaults to cwd)'),
+                outputDir: zod_1.z.string().optional()
+                    .describe('Output directory (default: ./.context)'),
+                type: zod_1.z.enum(['docs', 'agents', 'both']).optional()
+                    .describe('(init) Type of scaffolding to create'),
+                semantic: zod_1.z.boolean().optional()
+                    .describe('(init, scaffoldPlan) Enable semantic analysis'),
+                include: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(init) Include patterns'),
+                exclude: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(init) Exclude patterns'),
+                autoFill: zod_1.z.boolean().optional()
+                    .describe('(init, scaffoldPlan) Auto-fill with codebase content'),
+                skipContentGeneration: zod_1.z.boolean().optional()
+                    .describe('(init) Skip pre-generating content'),
+                target: zod_1.z.enum(['docs', 'agents', 'plans', 'all']).optional()
+                    .describe('(fill, listToFill) Which scaffolding to target'),
+                offset: zod_1.z.number().optional()
+                    .describe('(fill) Skip first N files'),
+                limit: zod_1.z.number().optional()
+                    .describe('(fill) Max files to return'),
+                filePath: zod_1.z.string().optional()
+                    .describe('(fillSingle) Absolute path to scaffold file'),
+                section: zod_1.z.enum([
+                    'all', 'stack', 'structure', 'architecture', 'symbols',
+                    'symbols.classes', 'symbols.interfaces', 'symbols.functions',
+                    'symbols.types', 'symbols.enums', 'publicAPI', 'dependencies', 'stats'
+                ]).optional()
+                    .describe('(getMap) Section to retrieve'),
+                contextType: zod_1.z.enum(['documentation', 'playbook', 'plan', 'compact']).optional()
+                    .describe('(buildSemantic) Type of context to build'),
+                targetFile: zod_1.z.string().optional()
+                    .describe('(buildSemantic) Target file for focused context'),
+                options: zod_1.z.object({
+                    useLSP: zod_1.z.boolean().optional(),
+                    maxContextLength: zod_1.z.number().optional(),
+                    includeDocumentation: zod_1.z.boolean().optional(),
+                    includeSignatures: zod_1.z.boolean().optional()
+                }).optional()
+                    .describe('(buildSemantic) Builder options'),
+                planName: zod_1.z.string().optional()
+                    .describe('(scaffoldPlan) Name of the plan'),
+                title: zod_1.z.string().optional()
+                    .describe('(scaffoldPlan) Plan title'),
+                summary: zod_1.z.string().optional()
+                    .describe('(scaffoldPlan) Plan summary/goal'),
+            }
+        }, wrap('context', async (params) => {
+            return (0, gatewayTools_1.handleContext)(params, { repoPath: this.getRepoPath(params.repoPath), contextBuilder: this.contextBuilder });
+        }));
+        // Dedicated Workflow Tools (split from consolidated workflow gateway)
+        // Tool 3a: workflow-init - Initialize PREVC workflow
+        this.server.registerTool('workflow-init', {
+            description: `Initialize a PREVC workflow for structured development.
+
+**What it does:**
+- Creates .context/workflow/ folder (automatically, if it doesn't exist)
+- Initializes workflow status file with phase tracking
+- Detects project scale and configures gates
+- Sets up PREVC phases (Plan → Review → Execute → Verify → Complete)
+
+**Prerequisites:**
+- .context/ folder must exist (use context with action "init" first)
+- Scaffolding files should be filled (use context with action "fillSingle")
+
+**When to use:**
+- Starting a new feature or bug fix after scaffolding is set up
+- Need structured, phase-gated development
+- Working on non-trivial changes
+
+**Don't use if:**
+- Making trivial changes (typo fixes, single-line edits)
+- Just exploring/researching code
+- User explicitly wants to skip workflow`,
+            inputSchema: {
+                name: zod_1.z.string().describe('Workflow/feature name (required)'),
+                description: zod_1.z.string().optional()
+                    .describe('Task description for scale detection'),
+                scale: zod_1.z.enum(['QUICK', 'SMALL', 'MEDIUM', 'LARGE']).optional()
+                    .describe(`Project scale - AI should evaluate based on task characteristics:
+
+SCALE EVALUATION CRITERIA:
+• QUICK: Single file changes, bug fixes, typos (~5 min)
+  - Phases: E → V only
+  - Example: "Fix typo in button text"
+
+• SMALL: Simple features, no architecture changes (~15 min)
+  - Phases: P → E → V
+  - Example: "Add email validation to form"
+
+• MEDIUM: Regular features with design decisions (~30 min)
+  - Phases: P → R → E → V
+  - Example: "Implement user profile page"
+
+• LARGE: Complex features, systems, compliance (~1+ hour)
+  - Phases: P → R → E → V → C (full workflow)
+  - Examples: "Build OAuth system", "Add GDPR compliance"
+
+GUIDANCE:
+- Analyze task complexity, architectural impact, and review needs
+- Use LARGE for security/compliance requirements
+- When uncertain, prefer MEDIUM
+- Omit scale only if unable to evaluate (auto-detect fallback)`),
+                autonomous: zod_1.z.boolean().optional()
+                    .describe('Skip all workflow gates (default: scale-dependent)'),
+                require_plan: zod_1.z.boolean().optional()
+                    .describe('Require plan before P→R'),
+                require_approval: zod_1.z.boolean().optional()
+                    .describe('Require approval before R→E'),
+                archive_previous: zod_1.z.boolean().optional()
+                    .describe('Archive existing workflow'),
+            }
+        }, wrap('workflow-init', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowInit)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Tool 3b: workflow-status - Get current workflow status
+        this.server.registerTool('workflow-status', {
+            description: `Get current PREVC workflow status including phase, gates, and linked plans.
+
+Returns: Current phase, all phase statuses, gate settings, linked plans, agent activity.`,
+            inputSchema: {
+            // No required parameters
+            }
+        }, wrap('workflow-status', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowStatus)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Tool 3c: workflow-advance - Advance to next phase
+        this.server.registerTool('workflow-advance', {
+            description: `Advance workflow to the next PREVC phase (P→R→E→V→C).
+
+Enforces gates:
+- P→R: Requires plan if require_plan=true
+- R→E: Requires approval if require_approval=true
+
+Use force=true to bypass gates, or use workflow-manage({ action: 'setAutonomous' }).`,
             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');
+                outputs: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('Artifact paths produced in current phase'),
+                force: zod_1.z.boolean().optional()
+                    .describe('Force advancement even if gates block'),
+            }
+        }, wrap('workflow-advance', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowAdvance)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Tool 3d: workflow-manage - Manage workflow operations
+        this.server.registerTool('workflow-manage', {
+            description: `Manage workflow operations: handoffs, collaboration, documents, gates, approvals.
+
+Actions:
+- handoff: Transfer work between agents (params: from, to, artifacts)
+- collaborate: Start collaboration session (params: topic, participants?)
+- createDoc: Create workflow document (params: type, docName)
+- getGates: Check gate status
+- approvePlan: Approve linked plan (params: planSlug?, approver?, notes?)
+- setAutonomous: Toggle autonomous mode (params: enabled, reason?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['handoff', 'collaborate', 'createDoc', 'getGates', 'approvePlan', 'setAutonomous'])
+                    .describe('Action to perform'),
+                from: zod_1.z.string().optional()
+                    .describe('(handoff) Agent handing off (e.g., feature-developer)'),
+                to: zod_1.z.string().optional()
+                    .describe('(handoff) Agent receiving (e.g., code-reviewer)'),
+                artifacts: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(handoff) Artifacts to hand off'),
+                topic: zod_1.z.string().optional()
+                    .describe('(collaborate) Collaboration topic'),
+                participants: zod_1.z.array(zod_1.z.enum(workflow_2.PREVC_ROLES)).optional()
+                    .describe('(collaborate) Participating roles'),
+                type: zod_1.z.enum(['prd', 'tech-spec', 'architecture', 'adr', 'test-plan', 'changelog']).optional()
+                    .describe('(createDoc) Document type'),
+                docName: zod_1.z.string().optional()
+                    .describe('(createDoc) Document name'),
+                planSlug: zod_1.z.string().optional()
+                    .describe('(approvePlan) Plan to approve'),
+                approver: zod_1.z.enum(workflow_2.PREVC_ROLES).optional()
+                    .describe('(approvePlan) Approving role'),
+                notes: zod_1.z.string().optional()
+                    .describe('(approvePlan) Approval notes'),
+                enabled: zod_1.z.boolean().optional()
+                    .describe('(setAutonomous) Enable/disable'),
+                reason: zod_1.z.string().optional()
+                    .describe('(setAutonomous) Reason for change'),
+            }
+        }, wrap('workflow-manage', async (params) => {
+            return (0, gatewayTools_1.handleWorkflowManage)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Gateway 5: sync - Import/export synchronization
+        this.server.registerTool('sync', {
+            description: `Import/export synchronization with AI tools. Actions:
+- exportRules: Export rules to AI tools (params: preset?, force?, dryRun?)
+- exportDocs: Export docs to AI tools (params: preset?, indexMode?, force?, dryRun?)
+- exportAgents: Export agents to AI tools (params: preset?, mode?, force?, dryRun?)
+- exportContext: Export all context (params: preset?, skipDocs?, skipAgents?, skipSkills?, docsIndexMode?, agentMode?, force?, dryRun?)
+- exportSkills: Export skills to AI tools (params: preset?, includeBuiltIn?, force?)
+- reverseSync: Import from AI tools to .context/ (params: skipRules?, skipAgents?, skipSkills?, mergeStrategy?, dryRun?, force?, addMetadata?)
+- importDocs: Import docs from AI tools (params: autoDetect?, force?, dryRun?)
+- importAgents: Import agents from AI tools (params: autoDetect?, force?, dryRun?)
+- importSkills: Import skills from AI tools (params: autoDetect?, mergeStrategy?, force?, dryRun?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['exportRules', 'exportDocs', 'exportAgents', 'exportContext', 'exportSkills', 'reverseSync', 'importDocs', 'importAgents', 'importSkills'])
+                    .describe('Action to perform'),
+                preset: zod_1.z.string().optional()
+                    .describe('Target AI tool preset'),
+                force: zod_1.z.boolean().optional()
+                    .describe('Overwrite existing files'),
+                dryRun: zod_1.z.boolean().optional()
+                    .describe('Preview without writing'),
+                indexMode: zod_1.z.enum(['readme', 'all']).optional()
+                    .describe('(exportDocs) Index mode'),
+                mode: zod_1.z.enum(['symlink', 'markdown']).optional()
+                    .describe('(exportAgents) Sync mode'),
+                skipDocs: zod_1.z.boolean().optional()
+                    .describe('(exportContext) Skip docs'),
+                skipAgents: zod_1.z.boolean().optional()
+                    .describe('(exportContext, reverseSync) Skip agents'),
+                skipSkills: zod_1.z.boolean().optional()
+                    .describe('(exportContext, reverseSync) Skip skills'),
+                skipRules: zod_1.z.boolean().optional()
+                    .describe('(reverseSync) Skip rules'),
+                docsIndexMode: zod_1.z.enum(['readme', 'all']).optional()
+                    .describe('(exportContext) Docs index mode'),
+                agentMode: zod_1.z.enum(['symlink', 'markdown']).optional()
+                    .describe('(exportContext) Agent sync mode'),
+                includeBuiltInSkills: zod_1.z.boolean().optional()
+                    .describe('(exportContext) Include built-in skills'),
+                includeBuiltIn: zod_1.z.boolean().optional()
+                    .describe('(exportSkills) Include built-in skills'),
+                mergeStrategy: zod_1.z.enum(['skip', 'overwrite', 'merge', 'rename']).optional()
+                    .describe('(reverseSync, importSkills) Conflict handling'),
+                autoDetect: zod_1.z.boolean().optional()
+                    .describe('(import*) Auto-detect files'),
+                addMetadata: zod_1.z.boolean().optional()
+                    .describe('(reverseSync) Add frontmatter metadata'),
+                repoPath: zod_1.z.string().optional()
+                    .describe('Repository path'),
+            }
+        }, wrap('sync', async (params) => {
+            return (0, gatewayTools_1.handleSync)(params, { repoPath: this.getRepoPath(params.repoPath) });
+        }));
+        // Gateway 6: plan - Plan management and execution tracking
+        this.server.registerTool('plan', {
+            description: `Plan management and execution tracking. Actions:
+- link: Link plan to workflow (params: planSlug)
+- getLinked: Get all linked plans
+- getDetails: Get detailed plan info (params: planSlug)
+- getForPhase: Get plans for PREVC phase (params: phase)
+- updatePhase: Update plan phase status (params: planSlug, phaseId, status)
+- recordDecision: Record a decision (params: planSlug, title, description, phase?, alternatives?)
+- updateStep: Update step status (params: planSlug, phaseId, stepIndex, status, output?, notes?)
+- getStatus: Get plan execution status (params: planSlug)
+- syncMarkdown: Sync tracking to markdown (params: planSlug)
+- commitPhase: Create git commit for completed phase (params: planSlug, phaseId, coAuthor?, stagePatterns?, dryRun?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['link', 'getLinked', 'getDetails', 'getForPhase', 'updatePhase', 'recordDecision', 'updateStep', 'getStatus', 'syncMarkdown', 'commitPhase'])
+                    .describe('Action to perform'),
+                planSlug: zod_1.z.string().optional()
+                    .describe('Plan slug/identifier'),
+                phaseId: zod_1.z.string().optional()
+                    .describe('(updatePhase, updateStep, commitPhase) Phase ID'),
+                status: zod_1.z.enum(['pending', 'in_progress', 'completed', 'skipped']).optional()
+                    .describe('(updatePhase, updateStep) New status'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional()
+                    .describe('(getForPhase, recordDecision) PREVC phase'),
+                title: zod_1.z.string().optional()
+                    .describe('(recordDecision) Decision title'),
+                description: zod_1.z.string().optional()
+                    .describe('(recordDecision) Decision description'),
+                alternatives: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(recordDecision) Considered alternatives'),
+                stepIndex: zod_1.z.number().optional()
+                    .describe('(updateStep) Step number (1-based)'),
+                output: zod_1.z.string().optional()
+                    .describe('(updateStep) Step output artifact'),
+                notes: zod_1.z.string().optional()
+                    .describe('(updateStep) Execution notes'),
+                coAuthor: zod_1.z.string().optional()
+                    .describe('(commitPhase) Agent name for Co-Authored-By footer'),
+                stagePatterns: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(commitPhase) Patterns for files to stage (default: [".context/**"])'),
+                dryRun: zod_1.z.boolean().optional()
+                    .describe('(commitPhase) Preview without committing'),
+            }
+        }, wrap('plan', async (params) => {
+            return (0, gatewayTools_1.handlePlan)(params, { repoPath: this.getRepoPath() });
+        }));
+        // Gateway 7: agent - Agent orchestration and discovery
+        this.server.registerTool('agent', {
+            description: `Agent orchestration and discovery. Actions:
+- discover: Discover all agents (built-in + custom)
+- getInfo: Get agent details (params: agentType)
+- orchestrate: Select agents for task/phase/role (params: task?, phase?, role?)
+- getSequence: Get agent handoff sequence (params: task, includeReview?, phases?)
+- getDocs: Get agent documentation (params: agent)
+- getPhaseDocs: Get phase documentation (params: phase)
+- listTypes: List all agent types`,
+            inputSchema: {
+                action: zod_1.z.enum(['discover', 'getInfo', 'orchestrate', 'getSequence', 'getDocs', 'getPhaseDocs', 'listTypes'])
+                    .describe('Action to perform'),
+                agentType: zod_1.z.string().optional()
+                    .describe('(getInfo) Agent type identifier'),
+                task: zod_1.z.string().optional()
+                    .describe('(orchestrate, getSequence) Task description'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional()
+                    .describe('(orchestrate, getPhaseDocs) PREVC phase'),
+                role: zod_1.z.enum(workflow_2.PREVC_ROLES).optional()
+                    .describe('(orchestrate) PREVC role'),
+                includeReview: zod_1.z.boolean().optional()
+                    .describe('(getSequence) Include code review'),
+                phases: zod_1.z.array(zod_1.z.enum(['P', 'R', 'E', 'V', 'C'])).optional()
+                    .describe('(getSequence) Phases to include'),
+                agent: zod_1.z.enum(workflow_2.AGENT_TYPES).optional()
+                    .describe('(getDocs) Agent type for docs'),
+            }
+        }, wrap('agent', async (params) => {
+            return (0, gatewayTools_1.handleAgent)(params, { repoPath: this.getRepoPath() });
+        }));
+        // Gateway 8: skill - Skill management
+        this.server.registerTool('skill', {
+            description: `Skill management for on-demand expertise. Actions:
+- list: List all skills (params: includeContent?)
+- getContent: Get skill content (params: skillSlug)
+- getForPhase: Get skills for PREVC phase (params: phase)
+- scaffold: Generate skill files (params: skills?, force?)
+- export: Export skills to AI tools (params: preset?, includeBuiltIn?, force?)
+- fill: Fill skills with codebase content (params: skills?, force?)`,
+            inputSchema: {
+                action: zod_1.z.enum(['list', 'getContent', 'getForPhase', 'scaffold', 'export', 'fill'])
+                    .describe('Action to perform'),
+                skillSlug: zod_1.z.string().optional()
+                    .describe('(getContent) Skill identifier'),
+                phase: zod_1.z.enum(['P', 'R', 'E', 'V', 'C']).optional()
+                    .describe('(getForPhase) PREVC phase'),
+                skills: zod_1.z.array(zod_1.z.string()).optional()
+                    .describe('(scaffold, fill) Specific skills to process'),
+                includeContent: zod_1.z.boolean().optional()
+                    .describe('(list) Include full content'),
+                includeBuiltIn: zod_1.z.boolean().optional()
+                    .describe('(export, fill) Include built-in skills'),
+                preset: zod_1.z.enum(['claude', 'gemini', 'codex', 'antigravity', 'all']).optional()
+                    .describe('(export) Target AI tool'),
+                force: zod_1.z.boolean().optional()
+                    .describe('(scaffold, export) Overwrite existing'),
+            }
+        }, wrap('skill', async (params) => {
+            return (0, gatewayTools_1.handleSkill)(params, { repoPath: this.getRepoPath() });
+        }));
+        this.log('Registered 9 tools (5 consolidated gateways + 4 dedicated workflow tools)');
     }
     /**
      * Register semantic context resources
+     * Uses initialRepoPath if found, otherwise process.cwd()
      */
     registerResources() {
-        const repoPath = this.options.repoPath || process.cwd();
+        const repoPath = this.initialRepoPath ?? process.cwd();
         // Register context resources as templates with URI patterns
         this.server.registerResource('codebase-context', `context://codebase/{contextType}`, {
             description: 'Semantic context for the codebase. Use contextType: documentation, playbook, plan, or compact',
@@ -1305,14 +553,13 @@ class AIContextMCPServer {
         this.log('Registered 2 resource templates');
         // Register PREVC workflow resources
         this.registerWorkflowResources();
-        // Register orchestration tools
-        this.registerOrchestrationTools();
     }
     /**
      * Register PREVC workflow resources
+     * Uses initialRepoPath if found, otherwise process.cwd()
      */
     registerWorkflowResources() {
-        const repoPath = this.options.repoPath || process.cwd();
+        const repoPath = this.initialRepoPath ?? process.cwd();
         // workflow://status - Current workflow status
         this.server.registerResource('workflow-status', 'workflow://status', {
             description: 'Current PREVC workflow status including phases, roles, and progress',
@@ -1362,552 +609,161 @@ class AIContextMCPServer {
         this.log('Registered 1 workflow resource');
     }
     /**
-     * Register agent orchestration tools
+     * Initialize repo path with smart detection and caching
+     *
+     * Strategy:
+     * 1. If explicit options.repoPath provided, try to find project root from there
+     * 2. Otherwise search upward from process.cwd() for .context or .git
+     * 3. Set as initialRepoPath if found (for resources)
+     * 4. First valid repoPath from client gets cached for all subsequent tool calls
+     * 5. Fallback to process.cwd() if nothing found (allows flexible MCP usage)
      */
-    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();
+    async initializeRepoPath() {
+        const startPath = this.options.repoPath || process.cwd();
+        const foundRoot = await this.findProjectRoot(startPath);
+        if (foundRoot) {
+            this.initialRepoPath = path.resolve(foundRoot);
+            this.log(`Server initialized with project root: ${this.initialRepoPath}`);
+        }
+        else {
+            // No project found - will use process.cwd() as fallback
+            // This allows flexible MCP server usage without strict project detection
+            this.initialRepoPath = null;
+            this.log(`No project root found. Will use process.cwd() or first valid client-provided path.`);
+        }
     }
     /**
-     * Register skill tools for on-demand expertise
+     * Find project root by searching upward for .context or .git
      */
-    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 }) => {
+    async findProjectRoot(startPath) {
+        let currentPath = path.resolve(startPath);
+        const root = path.parse(currentPath).root;
+        // Search upward for .context or .git
+        while (currentPath !== root) {
+            if (await fs.pathExists(path.join(currentPath, '.context')) ||
+                await fs.pathExists(path.join(currentPath, '.git'))) {
+                return currentPath;
+            }
+            currentPath = path.dirname(currentPath);
+        }
+        // Not found
+        return null;
+    }
+    /**
+     * Cache a valid repoPath from client
+     * Only cache if it contains .context and we haven't cached yet
+     */
+    cacheRepoPathIfValid(repoPath) {
+        if (this.cachedRepoPath) {
+            return; // Already cached
+        }
+        const contextPath = path.join(repoPath, '.context');
+        if (fs.existsSync(contextPath)) {
+            this.cachedRepoPath = path.resolve(repoPath);
+            process.stderr.write(`[mcp] ✓ Cached repoPath for this session: ${this.cachedRepoPath}\n`);
+            this.log(`Cached valid repoPath: ${this.cachedRepoPath}`);
+        }
+    }
+    /**
+     * Get the effective repo path for a tool call
+     * Priority: 1) explicit param, 2) cached path, 3) initial path, 4) process.cwd()
+     */
+    getRepoPath(paramsRepoPath) {
+        if (paramsRepoPath) {
+            const resolved = path.resolve(paramsRepoPath);
+            this.cacheRepoPathIfValid(resolved);
+            return resolved;
+        }
+        if (this.cachedRepoPath) {
+            this.log(`Using cached repoPath: ${this.cachedRepoPath}`);
+            return this.cachedRepoPath;
+        }
+        if (this.initialRepoPath) {
+            this.log(`Using initial repoPath: ${this.initialRepoPath}`);
+            return this.initialRepoPath;
+        }
+        // Fallback to current working directory
+        const cwd = process.cwd();
+        this.log(`Using fallback cwd: ${cwd}`);
+        return cwd;
+    }
+    wrapWithActionLogging(toolName, handler) {
+        return async (params) => {
+            const resolvedRepoPath = this.getRepoPath(params?.repoPath);
+            const action = typeof params?.action === 'string'
+                ? params.action
+                : toolName;
             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)
-                        }]
-                };
+                const response = await handler(params);
+                await this.logToolResponse(resolvedRepoPath, toolName, action, params, response);
+                return response;
             }
             catch (error) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: error instanceof Error ? error.message : String(error)
-                            }, null, 2)
-                        }]
-                };
+                await this.logToolError(resolvedRepoPath, toolName, action, params, error);
+                throw error;
             }
+        };
+    }
+    async logToolResponse(repoPath, toolName, action, params, response) {
+        const payload = this.parseResponsePayload(response);
+        const success = typeof payload?.success === 'boolean'
+            ? payload.success
+            : !response.isError;
+        const errorMessage = typeof payload?.error === 'string' ? payload.error : undefined;
+        const resultSummary = payload ? this.buildResultSummary(payload) : undefined;
+        await (0, actionLogger_1.logMcpAction)(repoPath, {
+            tool: toolName,
+            action,
+            status: success ? 'success' : 'error',
+            details: {
+                params,
+                ...(resultSummary ? { result: resultSummary } : {}),
+            },
+            ...(success ? {} : { error: errorMessage || 'Tool reported failure' }),
         });
-        // 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)
-                        }]
-                };
-            }
+    }
+    async logToolError(repoPath, toolName, action, params, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await (0, actionLogger_1.logMcpAction)(repoPath, {
+            tool: toolName,
+            action,
+            status: 'error',
+            details: { params },
+            error: message,
         });
-        // 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)
-                        }]
-                };
+    }
+    parseResponsePayload(response) {
+        const text = response.content?.[0]?.text;
+        if (!text)
+            return null;
+        try {
+            const parsed = JSON.parse(text);
+            return parsed && typeof parsed === 'object' ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    buildResultSummary(payload) {
+        const summaryKeys = [
+            'success',
+            'message',
+            'currentPhase',
+            'nextPhase',
+            'phase',
+            'scale',
+            'planSlug',
+            'count',
+            'total',
+            'status',
+        ];
+        const summary = {};
+        for (const key of summaryKeys) {
+            if (key in payload) {
+                summary[key] = payload[key];
             }
-        });
-        this.log('Registered 6 skill tools');
+        }
+        return Object.keys(summary).length > 0 ? summary : null;
     }
     /**
      * Start the MCP server with stdio transport
@@ -1935,115 +791,6 @@ The AI agent MUST then fill each skill file using the provided context and instr
     }
 }
 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
  */