@grec0/memory-bank-mcp 0.1.41 → 0.2.1

package/README.md

@@ -59,6 +59,13 @@ With Memory Bank, AIs:
 - **🆔 Identity Management**: Tracks who is doing what (GitHub Copilot, Cursor, etc.)
 - **🔒 Atomic Locks**: File-system based locking safe across different processes/IDEs
 
+### Task Orchestration (Smart Routing) 🧭 NEW
+- **🎯 Intelligent Routing**: Analyzes tasks BEFORE implementation to determine ownership
+- **📋 Enriched Project Registry**: Projects have responsibilities, ownership, and exports metadata
+- **🤖 AI Reasoning**: Uses reasoning models to distribute work across projects
+- **🔀 Auto-Delegation**: Automatically identifies what should be delegated to other projects
+- **📦 Import Suggestions**: Recommends what to import from other projects instead of reimplementing
+
 ## 📋 Requirements
 
 - **Node.js** >= 18.0.0
@@ -294,13 +301,16 @@ Reads generated documentation.
 1. Index code
    memorybank_index_code({ projectId: "my-project" })
 
-2. Generate documentation
+2. Generate documentation (also updates global registry)
    memorybank_generate_project_docs({ projectId: "my-project" })
 
 3. Query documentation at the start of each session
    memorybank_get_project_docs({ projectId: "my-project", document: "activeContext" })
 
-4. Search specific code
+4. Route task BEFORE implementing (mandatory in auto-index mode)
+   memorybank_route_task({ projectId: "my-project", taskDescription: "..." })
+
+5. Search specific code
    memorybank_search({ projectId: "my-project", query: "..." })
 ```
 
@@ -308,6 +318,21 @@ Reads generated documentation.
 
 If you configure `MEMORYBANK_AUTO_UPDATE_DOCS=true`, documents will be automatically regenerated after each indexing. This is useful for keeping documentation always up to date but consumes more API tokens.
 
+### Upgrading Existing Projects 🆕
+
+If you have projects already initialized with a previous version, simply regenerate the docs to enable Task Orchestration:
+
+```json
+// For each existing project:
+memorybank_generate_project_docs({ "projectId": "your-project", "force": true })
+```
+
+This will:
+1. Regenerate all 6 markdown documents
+2. **NEW**: Extract responsibilities, ownership, and exports
+3. **NEW**: Update `global_registry.json` with enriched metadata
+4. Enable `memorybank_route_task` to work with this project
+
 ---
 
 ## 🤖 Multi-Agent Coordination
@@ -382,6 +407,71 @@ memorybank_delegate_task({
 })
 ```
 
+### Task Orchestration (Smart Routing) 🧭 NEW
+
+The **Task Orchestrator** analyzes tasks BEFORE implementation to prevent agents from creating code that belongs to other projects.
+
+#### Why is this needed?
+
+Without orchestration, agents often:
+- ❌ Create DTOs in the API project when `lib-dtos` exists
+- ❌ Duplicate utilities that are already in `shared-utils`
+- ❌ Implement features that belong to other microservices
+- ❌ Violate architectural boundaries unknowingly
+
+With the orchestrator:
+- ✅ Know exactly what belongs to this project
+- ✅ Automatically delegate work to the right project
+- ✅ Get import suggestions instead of reimplementing
+- ✅ Respect ecosystem boundaries
+
+#### How It Works
+
+1. **Enriched Registry**: When you run `memorybank_generate_project_docs`, it automatically extracts:
+   - `responsibilities`: What this project is responsible for
+   - `owns`: Files/folders that belong to this project
+   - `exports`: What this project provides to others
+   - `projectType`: api, library, frontend, backend, etc.
+
+2. **Route Before Implementing**: Call `memorybank_route_task` BEFORE any code changes:
+```json
+memorybank_route_task({
+  "projectId": "my-api",
+  "taskDescription": "Create DTOs for user management and expose REST endpoints"
+})
+```
+
+3. **Orchestrator Response**:
+```json
+{
+  "action": "partial_delegate",
+  "myResponsibilities": [
+    "Create REST endpoints in src/controllers/",
+    "Implement business logic in src/services/"
+  ],
+  "delegations": [
+    {
+      "targetProjectId": "lib-dtos",
+      "taskTitle": "Create UserDTO and UserResponseDTO",
+      "reason": "DTOs belong to lib-dtos per project responsibilities"
+    }
+  ],
+  "suggestedImports": [
+    "import { UserDTO } from 'lib-dtos'"
+  ],
+  "architectureNotes": "Use shared DTOs to maintain consistency across services"
+}
+```
+
+#### Possible Actions
+
+| Action | Meaning |
+|--------|--------|
+| `implement_here` | Everything belongs to this project, proceed |
+| `delegate_all` | Nothing belongs here, delegate everything |
+| `partial_delegate` | Some parts belong here, delegate the rest |
+| `needs_clarification` | Task is ambiguous, ask user for details |
+
 ---
 
 ## 🔀 Multi-Project: Cross-Project Queries
@@ -524,9 +614,36 @@ Analyzes project indexing coverage.
 }
 ```
 
+### `memorybank_route_task` 🆕
+
+Analyzes a task and determines what belongs to this project vs what should be delegated. **MUST be called BEFORE any implementation.**
+
+**Parameters:**
+- `projectId` **(REQUIRED)**: Project requesting the routing
+- `taskDescription` **(REQUIRED)**: Detailed description of what needs to be implemented
+
+**Example:**
+```json
+{
+  "projectId": "my-api",
+  "taskDescription": "Create user registration endpoint with validation and DTOs"
+}
+```
+
+**Response:**
+```json
+{
+  "action": "partial_delegate",
+  "myResponsibilities": ["Create POST /users endpoint", "Add validation middleware"],
+  "delegations": [{ "targetProjectId": "lib-dtos", "taskTitle": "Create UserDTO" }],
+  "suggestedImports": ["import { UserDTO } from 'lib-dtos'"],
+  "architectureNotes": "Follow REST conventions, use shared DTOs"
+}
+```
+
 ### `memorybank_generate_project_docs`
 
-Generates structured project documentation using AI with reasoning.
+Generates structured project documentation using AI with reasoning. **Also automatically updates the global registry with enriched project metadata** (responsibilities, owns, exports, projectType).
 
 **Parameters:**
 - `projectId` **(REQUIRED)**: Project identifier
@@ -721,11 +838,13 @@ Memory Bank includes instruction templates in two formats to configure agent beh
 **For active development with automatic synchronization.**
 
 - ✅ Agent consults Memory Bank automatically
+- ✅ **Routes tasks before implementing** (Rule 0.5)
 - ✅ Reindexes EVERY file after modifying it
 - ✅ Keeps Memory Bank always up to date
 - ✅ Can read/write files directly
+- ✅ **Auto-delegates to other projects** when appropriate
 
-**Ideal for**: Active development, rapid iteration, teams.
+**Ideal for**: Active development, rapid iteration, teams, **multi-project ecosystems**.
 
 ### 3. Sandboxed Mode
 
@@ -889,9 +1008,37 @@ Claude: [executes memorybank_generate_project_docs({ projectId: "my-app" })]
         - techContext.md: Tech stack
         ...
         
+        Also updated the global registry with project responsibilities.
         You can query them anytime with memorybank_get_project_docs
 ```
 
+### 5. Task Orchestration (Multi-Project) 🆕
+
+```
+User: I need to add a UserDTO for the new registration endpoint
+Claude: [executes memorybank_route_task({ 
+          projectId: "my-api", 
+          taskDescription: "Create UserDTO for registration endpoint" 
+        })]
+        
+        The orchestrator analyzed your ecosystem and determined:
+        
+        ❌ DTOs should NOT be created in my-api
+        ✅ DTOs belong to lib-dtos project
+        
+        I'll delegate the DTO creation to lib-dtos and import it:
+        
+        [executes memorybank_delegate_task({
+          projectId: "my-api",
+          targetProjectId: "lib-dtos", 
+          title: "Create UserDTO",
+          description: "DTO for user registration with email, password fields"
+        })]
+        
+        Task delegated! Once lib-dtos creates the DTO, you can:
+        import { UserDTO } from 'lib-dtos'
+```
+
 ---
 
 ## 🔧 Configuration Files

package/dist/common/projectKnowledgeService.js

@@ -1008,6 +1008,72 @@ ${chunk.content}
         const files = fs.readdirSync(docsPath);
         return files.filter(f => f.endsWith(".md"));
     }
+    // ==========================================
+    // Project Summary Generation (for Registry)
+    // ==========================================
+    /**
+     * Generates a structured summary of the project for the global registry.
+     * Extracts responsibilities, ownership patterns, and project type from projectBrief.
+     * This is called automatically after generateAllDocuments.
+     */
+    async generateProjectSummary(projectId) {
+        const projectBrief = this.getDocument(projectId, "projectBrief");
+        const techContext = this.getDocument(projectId, "techContext");
+        if (!projectBrief) {
+            console.error(`Cannot generate project summary: projectBrief not found for ${projectId}`);
+            return null;
+        }
+        console.error(`Generating project summary for registry: ${projectId}`);
+        const prompt = `Analyze the following project documentation and extract a structured summary.
+
+PROJECT BRIEF:
+${projectBrief.content}
+
+${techContext ? `TECHNICAL CONTEXT:\n${techContext.content}` : ''}
+
+Extract the following information in JSON format:
+{
+  "description": "A concise 1-2 sentence description of what this project does",
+  "responsibilities": ["List of 3-5 specific things this project is responsible for"],
+  "owns": ["File patterns or types this project owns, e.g., '*DTO.ts', 'services/', 'controllers/'"],
+  "projectType": "One of: api, library, frontend, backend, cli, service, monorepo, fullstack",
+  "exports": "Package name if it's a library (e.g., '@company/lib-dtos'), or null if not applicable",
+  "keywords": ["5-8 keywords describing this project"]
+}
+
+IMPORTANT:
+- Be specific about responsibilities - they help the orchestrator decide where code belongs
+- For "owns", think about what file patterns ONLY this project should create
+- If it's a library, identify what it exports/provides to other projects
+
+Respond ONLY with the JSON object, no markdown or explanation.`;
+        try {
+            const result = await this.callResponsesAPI(prompt);
+            // Parse JSON response
+            const jsonMatch = result.content.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                console.error(`Failed to parse project summary JSON for ${projectId}`);
+                return null;
+            }
+            const summary = JSON.parse(jsonMatch[0]);
+            console.error(`Project summary generated for ${projectId}:`);
+            console.error(`  - Type: ${summary.projectType}`);
+            console.error(`  - Responsibilities: ${summary.responsibilities?.length || 0}`);
+            console.error(`  - Owns: ${summary.owns?.length || 0}`);
+            return {
+                description: summary.description || '',
+                responsibilities: summary.responsibilities || [],
+                owns: summary.owns || [],
+                projectType: summary.projectType || 'unknown',
+                exports: summary.exports || undefined,
+                keywords: summary.keywords || [],
+            };
+        }
+        catch (error) {
+            console.error(`Error generating project summary: ${error}`);
+            return null;
+        }
+    }
 }
 /**
  * Creates a Project Knowledge Service from environment variables

package/dist/common/registryManager.js

@@ -22,10 +22,10 @@ export class RegistryManager {
     async saveRegistry(registry) {
         await fs.writeFile(this.globalPath, JSON.stringify(registry, null, 2), 'utf-8');
     }
-    async registerProject(projectId, workspacePath, description, keywords = [], embeddingService) {
+    async registerProject(projectId, workspacePath, description, keywords = [], embeddingService, enhancedInfo) {
         const registry = await this.ensureRegistry();
         const idx = registry.projects.findIndex(p => p.projectId === projectId);
-        // Preserve existing description/keywords if not provided
+        // Preserve existing data if not provided
         const existing = idx >= 0 ? registry.projects[idx] : null;
         const card = {
             projectId,
@@ -33,7 +33,12 @@ export class RegistryManager {
             description: description || existing?.description || '',
             keywords: keywords.length > 0 ? keywords : (existing?.keywords || []),
             lastActive: new Date().toISOString(),
-            status: 'ACTIVE'
+            status: 'ACTIVE',
+            // Enhanced fields - preserve existing if not provided
+            responsibilities: enhancedInfo?.responsibilities || existing?.responsibilities,
+            owns: enhancedInfo?.owns || existing?.owns,
+            exports: enhancedInfo?.exports || existing?.exports,
+            projectType: enhancedInfo?.projectType || existing?.projectType,
         };
         if (idx >= 0) {
             registry.projects[idx] = card;
@@ -53,12 +58,30 @@ export class RegistryManager {
         }
     }
     async updateProjectEmbedding(card, embeddingService) {
-        const text = `Project: ${card.projectId}\nDescription: ${card.description || ''}\nKeywords: ${card.keywords.join(', ')}`;
+        // Build rich text for embedding including responsibilities
+        const textParts = [
+            `Project: ${card.projectId}`,
+            `Description: ${card.description || ''}`,
+            `Keywords: ${card.keywords.join(', ')}`,
+        ];
+        if (card.responsibilities && card.responsibilities.length > 0) {
+            textParts.push(`Responsibilities: ${card.responsibilities.join('. ')}`);
+        }
+        if (card.owns && card.owns.length > 0) {
+            textParts.push(`Owns: ${card.owns.join(', ')}`);
+        }
+        if (card.projectType) {
+            textParts.push(`Type: ${card.projectType}`);
+        }
+        if (card.exports) {
+            textParts.push(`Exports: ${card.exports}`);
+        }
+        const text = textParts.join('\n');
         const result = await embeddingService.generateEmbedding(card.projectId, text);
         await this.projectVectorStore.upsertProject({
             id: card.projectId,
             vector: result.vector,
-            name: card.projectId, // Using ID as name for now if name not available
+            name: card.projectId,
             description: card.description || '',
             tags: card.keywords,
             path: card.path,
@@ -101,6 +124,14 @@ export class RegistryManager {
         const registry = await this.ensureRegistry();
         return registry.projects.find(p => p.projectId === projectId);
     }
+    /**
+     * Gets all projects from the registry.
+     * Useful for the orchestrator to analyze responsibilities across all projects.
+     */
+    async getAllProjects() {
+        const registry = await this.ensureRegistry();
+        return registry.projects;
+    }
     /**
      * Syncs all projects from the JSON registry to the vector store.
      * Useful for migrating existing projects to the new semantic discovery system.

package/dist/common/version.js

@@ -1,2 +1,2 @@
 // Version of the MCP Kanban server
-export const VERSION = "0.1.39";
+export const VERSION = "0.2.1";

package/dist/index.js

@@ -83,6 +83,7 @@ import { manageAgentsTool, manageAgentsToolDefinition } from "./tools/manageAgen
 import { discoverProjectsTool, discoverProjectsToolDefinition } from "./tools/discoverProjects.js";
 import { delegateTaskTool, delegateTaskToolDefinition } from "./tools/delegateTask.js";
 import { syncProjectsTool, syncProjectsToolDefinition } from "./tools/syncProjects.js";
+import { routeTaskTool, routeTaskToolDefinition } from "./tools/routeTask.js";
 import { RegistryManager } from "./common/registryManager.js";
 import { VERSION } from "./common/version.js";
 // Global services
@@ -864,6 +865,19 @@ server.tool(delegateTaskToolDefinition.name, delegateTaskToolDefinition.descript
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
     };
 });
+// Tool: Route Task (Orchestrator)
+server.tool(routeTaskToolDefinition.name, routeTaskToolDefinition.description, {
+    projectId: z.string().describe("ID del proyecto que está solicitando el enrutamiento"),
+    taskDescription: z.string().describe("Descripción detallada de la tarea a implementar")
+}, async (args) => {
+    const result = await routeTaskTool({
+        projectId: args.projectId,
+        taskDescription: args.taskDescription
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
 /**
  * Starts the stdio server
  */
@@ -900,6 +914,7 @@ async function startStdioServer() {
         console.error("    - memorybank_complete_task: Marcar una tarea como completada");
         console.error("    - memorybank_discover_projects: Descubrir otros proyectos en el ecosistema");
         console.error("    - memorybank_delegate_task: Delegar tareas a otros proyectos");
+        console.error("    - memorybank_route_task: Orquestador - analiza y distribuye tareas");
         console.error("");
         console.error("Available resources:");
         console.error("    - memory://{projectId}/active: Contexto activo");

package/dist/tools/generateProjectDocs.js

@@ -4,6 +4,8 @@
  */
 import { AgentBoard } from "../common/agentBoard.js";
 import { sessionLogger } from "../common/sessionLogger.js";
+import { RegistryManager } from "../common/registryManager.js";
+import { EmbeddingService } from "../common/embeddingService.js";
 import { sessionState } from "../common/sessionState.js";
 /**
  * Generates project documentation using AI reasoning
@@ -94,6 +96,41 @@ export async function generateProjectDocs(params, projectKnowledgeService, vecto
         console.error(`  - Reasoning tokens: ${result.totalReasoningTokens}`);
         console.error(`  - Output tokens: ${result.totalOutputTokens}`);
         console.error(`  - Estimated cost: $${totalCost.toFixed(4)}`);
+        // === AUTO-UPDATE GLOBAL REGISTRY ===
+        // Generate project summary and update registry with enriched info
+        if (result.documentsGenerated.length > 0 || result.documentsUpdated.length > 0) {
+            try {
+                console.error(`\n=== Updating Global Registry ===`);
+                const summary = await projectKnowledgeService.generateProjectSummary(projectId);
+                if (summary) {
+                    const registryManager = new RegistryManager();
+                    let embeddingService;
+                    if (process.env.OPENAI_API_KEY) {
+                        try {
+                            embeddingService = new EmbeddingService(process.env.OPENAI_API_KEY);
+                        }
+                        catch (e) {
+                            console.error(`Warning: Could not init embedding service: ${e}`);
+                        }
+                    }
+                    await registryManager.registerProject(projectId, workspaceRoot, summary.description, summary.keywords, embeddingService, {
+                        responsibilities: summary.responsibilities,
+                        owns: summary.owns,
+                        exports: summary.exports,
+                        projectType: summary.projectType,
+                    });
+                    console.error(`Registry updated for ${projectId}:`);
+                    console.error(`  - Description: ${summary.description.slice(0, 80)}...`);
+                    console.error(`  - Type: ${summary.projectType}`);
+                    console.error(`  - Responsibilities: ${summary.responsibilities.length}`);
+                    message += ` Registry updated with project summary.`;
+                }
+            }
+            catch (regError) {
+                console.error(`Warning: Failed to update registry: ${regError}`);
+                // Don't fail the whole operation if registry update fails
+            }
+        }
         return {
             success: result.success,
             message,

package/dist/tools/index.js

@@ -15,3 +15,5 @@ export * from "./syncProjects.js";
 export * from "./generateProjectDocs.js";
 export * from "./getProjectDocs.js";
 export * from "./manageAgents.js";
+// Export Task Orchestration tools
+export * from "./routeTask.js";

package/dist/tools/routeTask.js

@@ -0,0 +1,302 @@
+/**
+ * @fileoverview Task Routing Orchestrator
+ * Uses AI reasoning to analyze tasks and distribute work across projects
+ * based on their responsibilities. MANDATORY before any implementation.
+ */
+import OpenAI from "openai";
+import { RegistryManager } from "../common/registryManager.js";
+/**
+ * Builds a context string describing all projects and their responsibilities
+ */
+function buildProjectsContext(projects, currentProjectId) {
+    if (projects.length === 0) {
+        return "No other projects registered in the workspace.";
+    }
+    let context = "## Registered Projects in Workspace\n\n";
+    for (const project of projects) {
+        const isCurrent = project.projectId === currentProjectId;
+        context += `### ${project.projectId}${isCurrent ? ' (CURRENT - requesting agent)' : ''}\n`;
+        context += `- **Path**: ${project.path}\n`;
+        context += `- **Type**: ${project.projectType || 'unknown'}\n`;
+        context += `- **Description**: ${project.description || 'No description'}\n`;
+        if (project.responsibilities && project.responsibilities.length > 0) {
+            context += `- **Responsibilities**:\n`;
+            for (const resp of project.responsibilities) {
+                context += `  - ${resp}\n`;
+            }
+        }
+        if (project.owns && project.owns.length > 0) {
+            context += `- **Owns (file patterns)**: ${project.owns.join(', ')}\n`;
+        }
+        if (project.exports) {
+            context += `- **Exports**: ${project.exports}\n`;
+        }
+        context += '\n';
+    }
+    return context;
+}
+/**
+ * The main routing prompt for the AI orchestrator
+ */
+const ROUTING_PROMPT = `You are a Task Routing Orchestrator for a multi-project workspace. Your job is to analyze a task and determine which parts belong to which project based on their responsibilities.
+
+{projectsContext}
+
+## Task to Analyze
+**From Project**: {currentProject}
+**Task Description**: {taskDescription}
+
+## Your Analysis
+
+Analyze the task and determine:
+1. What components/code need to be created or modified?
+2. Which project is responsible for each component based on their declared responsibilities?
+3. If something doesn't exist in any project, it can be created by the requesting project
+4. If something SHOULD exist in another project (based on responsibilities), it must be delegated
+
+## Rules
+- If a project is responsible for DTOs, ALL DTOs must be created there, not in the API
+- If a project is responsible for services, shared services go there
+- If a project is responsible for utils/common code, shared utilities go there
+- The requesting project can ONLY implement what falls within its responsibilities
+- When in doubt, check the "owns" patterns to see what file types belong where
+
+## Response Format
+Respond with a JSON object:
+{
+  "action": "proceed" | "delegate" | "mixed",
+  "myResponsibilities": ["List of things the requesting project should implement"],
+  "delegations": [
+    {
+      "targetProject": "project-id",
+      "taskTitle": "Short title for the task",
+      "taskDescription": "Detailed description of what to create",
+      "reasoning": "Why this belongs to this project"
+    }
+  ],
+  "suggestedImports": ["packages or modules to import after delegations complete"],
+  "architectureNotes": "Explanation of the distribution decision",
+  "warning": "Optional warning if something seems off"
+}
+
+IMPORTANT:
+- "action" is "proceed" if everything can be done by the requesting project
+- "action" is "delegate" if everything needs to go to other projects
+- "action" is "mixed" if some work is local and some needs delegation
+- Be specific in taskDescription so the receiving project knows exactly what to create
+- Always explain the reasoning based on project responsibilities
+
+Respond ONLY with the JSON object.`;
+/**
+ * Routes a task to the appropriate project(s) based on responsibilities
+ */
+export async function routeTaskTool(params) {
+    const { projectId, taskDescription } = params;
+    if (!taskDescription || taskDescription.trim() === '') {
+        return {
+            success: false,
+            action: 'proceed',
+            myResponsibilities: [],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: 'No task description provided.',
+            warning: 'Please provide a task description to analyze.',
+        };
+    }
+    console.error(`\n=== Task Routing Orchestrator ===`);
+    console.error(`Project: ${projectId}`);
+    console.error(`Task: ${taskDescription.slice(0, 100)}...`);
+    // Get all projects with their responsibilities
+    const registryManager = new RegistryManager();
+    const allProjects = await registryManager.getAllProjects();
+    console.error(`Found ${allProjects.length} projects in registry`);
+    // Check if we have any projects with responsibilities defined
+    const projectsWithResponsibilities = allProjects.filter(p => p.responsibilities && p.responsibilities.length > 0);
+    if (projectsWithResponsibilities.length === 0) {
+        console.error(`Warning: No projects have responsibilities defined`);
+        return {
+            success: true,
+            action: 'proceed',
+            myResponsibilities: ['All components (no other project responsibilities defined)'],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: 'No other projects have responsibilities defined. You can proceed with the full implementation. Consider running memorybank_generate_project_docs on other projects to define their responsibilities.',
+            warning: 'No project responsibilities found in workspace. Run generate_project_docs on all projects first.',
+        };
+    }
+    // Build context for the AI
+    const projectsContext = buildProjectsContext(allProjects, projectId);
+    // Call AI to analyze and route
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        return {
+            success: false,
+            action: 'proceed',
+            myResponsibilities: [],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: 'OPENAI_API_KEY not configured. Cannot analyze task routing.',
+            warning: 'AI routing unavailable. Proceeding without validation.',
+        };
+    }
+    try {
+        const client = new OpenAI({ apiKey });
+        const prompt = ROUTING_PROMPT
+            .replace('{projectsContext}', projectsContext)
+            .replace('{currentProject}', projectId)
+            .replace('{taskDescription}', taskDescription);
+        console.error(`Calling AI orchestrator...`);
+        // Use reasoning model for better analysis
+        const model = process.env.MEMORYBANK_REASONING_MODEL || "gpt-5-mini";
+        const response = await client.responses.create({
+            model,
+            reasoning: {
+                effort: "medium",
+            },
+            input: [
+                {
+                    role: "user",
+                    content: prompt,
+                },
+            ],
+            max_output_tokens: 4000,
+        });
+        // Extract content from response
+        let content = "";
+        for (const item of response.output || []) {
+            if (item.type === "message" && item.content) {
+                for (const contentItem of item.content) {
+                    if (contentItem.type === "output_text") {
+                        content += contentItem.text;
+                    }
+                }
+            }
+        }
+        // Parse JSON response
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            console.error(`Failed to parse orchestrator response`);
+            return {
+                success: false,
+                action: 'proceed',
+                myResponsibilities: [],
+                delegations: [],
+                suggestedImports: [],
+                architectureNotes: 'Failed to parse AI response.',
+                warning: 'Orchestrator analysis failed. Review task manually.',
+            };
+        }
+        const result = JSON.parse(jsonMatch[0]);
+        console.error(`\nOrchestrator Decision:`);
+        console.error(`  Action: ${result.action}`);
+        console.error(`  My responsibilities: ${result.myResponsibilities?.length || 0}`);
+        console.error(`  Delegations: ${result.delegations?.length || 0}`);
+        if (result.delegations && result.delegations.length > 0) {
+            console.error(`\n  Delegations:`);
+            for (const d of result.delegations) {
+                console.error(`    → ${d.targetProject}: ${d.taskTitle}`);
+            }
+        }
+        return {
+            success: true,
+            action: result.action || 'proceed',
+            myResponsibilities: result.myResponsibilities || [],
+            delegations: result.delegations || [],
+            suggestedImports: result.suggestedImports || [],
+            architectureNotes: result.architectureNotes || '',
+            warning: result.warning,
+        };
+    }
+    catch (error) {
+        console.error(`Error in task routing: ${error.message}`);
+        // Fallback to chat completions if responses API fails
+        if (error?.status === 404 || error?.code === "model_not_found") {
+            try {
+                const client = new OpenAI({ apiKey });
+                const prompt = ROUTING_PROMPT
+                    .replace('{projectsContext}', projectsContext)
+                    .replace('{currentProject}', projectId)
+                    .replace('{taskDescription}', taskDescription);
+                const response = await client.chat.completions.create({
+                    model: "gpt-4o",
+                    messages: [
+                        {
+                            role: "system",
+                            content: "You are a Task Routing Orchestrator. Analyze tasks and route them to the appropriate projects based on responsibilities. Respond with JSON only.",
+                        },
+                        {
+                            role: "user",
+                            content: prompt,
+                        },
+                    ],
+                    max_tokens: 4000,
+                });
+                const content = response.choices[0]?.message?.content || "";
+                const jsonMatch = content.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    const result = JSON.parse(jsonMatch[0]);
+                    return {
+                        success: true,
+                        action: result.action || 'proceed',
+                        myResponsibilities: result.myResponsibilities || [],
+                        delegations: result.delegations || [],
+                        suggestedImports: result.suggestedImports || [],
+                        architectureNotes: result.architectureNotes || '',
+                        warning: result.warning,
+                    };
+                }
+            }
+            catch (fallbackError) {
+                console.error(`Fallback also failed: ${fallbackError}`);
+            }
+        }
+        return {
+            success: false,
+            action: 'proceed',
+            myResponsibilities: [],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: `Error analyzing task: ${error.message}`,
+            warning: 'Orchestrator failed. Review task distribution manually.',
+        };
+    }
+}
+/**
+ * Tool definition for MCP
+ */
+export const routeTaskToolDefinition = {
+    name: "memorybank_route_task",
+    description: `🚨 OBLIGATORIO antes de implementar cualquier código.
+
+Analiza una tarea y determina qué partes corresponden a qué proyecto según sus responsabilidades.
+
+El orquestador:
+1. Lee las responsabilidades de TODOS los proyectos del workspace
+2. Analiza qué componentes necesita la tarea (DTOs, services, controllers, etc.)
+3. Asigna cada componente al proyecto responsable
+4. Devuelve un plan de acción con delegaciones
+
+DEBES llamar esta herramienta ANTES de escribir código para evitar:
+- Crear DTOs en un API cuando existe una lib-dtos
+- Duplicar services que ya existen en otro proyecto
+- Violar la separación de responsabilidades
+
+La respuesta incluye:
+- myResponsibilities: Lo que TÚ debes implementar
+- delegations: Tareas a delegar a otros proyectos
+- suggestedImports: Dependencias a usar tras las delegaciones`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "ID del proyecto que solicita el análisis (tu proyecto actual)",
+            },
+            taskDescription: {
+                type: "string",
+                description: "Descripción completa de la tarea a realizar",
+            },
+        },
+        required: ["projectId", "taskDescription"],
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grec0/memory-bank-mcp",
-  "version": "0.1.41",
+  "version": "0.2.1",
   "description": "MCP server for semantic code indexing with Memory Bank - AI-powered codebase understanding",
   "license": "MIT",
   "author": "@grec0",