@grec0/memory-bank-mcp 0.1.16 → 0.1.18

package/dist/common/agentBoard.js

@@ -10,6 +10,81 @@ export class AgentBoard {
         this.projectId = projectId;
         this.lockManager = new LockManager(basePath);
     }
+    async getBoardContent() {
+        await this.ensureBoardExists();
+        return await fs.readFile(this.getBoardPath(), 'utf-8');
+    }
+    // --- Task Management Methods ---
+    async createTask(title, fromAgentId, assignedTo, description) {
+        const taskId = `TASK-${Date.now().toString().slice(-6)}`;
+        await this.updateBoard((content) => {
+            const tasks = this.parseTable(content, 'Pending Tasks');
+            const now = new Date().toISOString();
+            // Columns: ID, Title, Assigned To, From, Status, Created At
+            tasks.push([taskId, title, assignedTo, fromAgentId, 'PENDING', now]);
+            return this.updateTable(content, 'Pending Tasks', ['ID', 'Title', 'Assigned To', 'From', 'Status', 'Created At'], tasks);
+        });
+        await this.logMessage(fromAgentId, `Created task ${taskId}: ${title}`);
+        return taskId;
+    }
+    async createExternalTask(title, fromProject, context) {
+        const taskId = `EXT-${Date.now().toString().slice(-6)}`;
+        await this.updateBoard((content) => {
+            const requests = this.parseTable(content, 'External Requests');
+            const now = new Date().toISOString();
+            // Columns: ID, Title, From Project, Context, Status, Received At
+            requests.push([taskId, title, fromProject, context, 'PENDING', now]);
+            return this.updateTable(content, 'External Requests', ['ID', 'Title', 'From Project', 'Context', 'Status', 'Received At'], requests);
+        });
+        await this.logMessage('SYSTEM', `Received external prompt from project ${fromProject}: ${title}`);
+        return taskId;
+    }
+    async completeTask(taskId, agentId) {
+        await this.updateBoard((content) => {
+            let tasks = this.parseTable(content, 'Pending Tasks');
+            const initialCount = tasks.length;
+            tasks = tasks.filter(t => t[0] !== taskId);
+            if (tasks.length < initialCount) {
+                return this.updateTable(content, 'Pending Tasks', ['ID', 'Title', 'Assigned To', 'From', 'Status', 'Created At'], tasks);
+            }
+            // Check external requests if not found in pending
+            let requests = this.parseTable(content, 'External Requests');
+            requests = requests.filter(t => t[0] !== taskId);
+            return this.updateTable(content, 'External Requests', ['ID', 'Title', 'From Project', 'Context', 'Status', 'Received At'], requests);
+        });
+        await this.logMessage(agentId, `Completed task ${taskId}`);
+    }
+    async logMessage(agentId, message) {
+        await this.updateBoard((content) => {
+            const lines = content.split('\n');
+            let msgSectionIdx = -1;
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].trim().startsWith('## Agent Messages')) {
+                    msgSectionIdx = i;
+                    break;
+                }
+            }
+            const timestamp = new Date().toISOString().split('T')[1].split('.')[0];
+            const msgLine = `- [${timestamp}] **${agentId}**: ${message}`;
+            if (msgSectionIdx !== -1) {
+                // Determine insertion point (after header)
+                lines.splice(msgSectionIdx + 1, 0, msgLine);
+                // Truncate logs if too long (keep last 20)
+                let nextHeaderIdx = -1;
+                for (let j = msgSectionIdx + 2; j < lines.length; j++) {
+                    if (lines[j].startsWith('## ')) {
+                        nextHeaderIdx = j;
+                        break;
+                    }
+                }
+                const endOfMessages = nextHeaderIdx === -1 ? lines.length : nextHeaderIdx;
+                if (endOfMessages - (msgSectionIdx + 1) > 20) {
+                    lines.splice(endOfMessages - 1, 1);
+                }
+            }
+            return lines.join('\n');
+        });
+    }
     getBoardPath() {
         return path.join(this.basePath, '.memorybank', 'projects', this.projectId, 'docs', 'agentBoard.md');
     }
@@ -22,8 +97,16 @@ export class AgentBoard {
             const initialContent = `# Multi-Agent Board
 
 ## Active Agents
-| Agent ID | Status | Current Focus | Last Heartbeat |
-|---|---|---|---|
+| Agent ID | Status | Current Focus | Session ID | Last Heartbeat |
+|---|---|---|---|---|
+
+## Pending Tasks
+| ID | Title | Assigned To | From | Status | Created At |
+|---|---|---|---|---|---|
+
+## External Requests
+| ID | Title | From Project | Context | Status | Received At |
+|---|---|---|---|---|---|
 
 ## File Locks
 | File Pattern | Claimed By | Since |
@@ -36,34 +119,64 @@ export class AgentBoard {
             await fs.writeFile(boardPath, initialContent, 'utf-8');
         }
     }
-    async registerAgent(agentId) {
+    async registerAgent(agentId, sessionId) {
         await this.updateBoard((content) => {
             const agents = this.parseTable(content, 'Active Agents');
             const existing = agents.findIndex(a => a[0]?.trim() === agentId);
             const now = new Date().toISOString();
+            const session = sessionId || (existing >= 0 ? (agents[existing][3] || '') : ''); // Use col 3 as SessionID based on previous read
             if (existing >= 0) {
-                agents[existing] = [agentId, 'ACTIVE', '-', now];
+                // Check if it's already 5 cols or 4
+                if (agents[existing].length < 5) {
+                    agents[existing] = [agentId, 'ACTIVE', '-', session, now];
+                }
+                else {
+                    // preserve existing fields if needed, but update timestamp
+                    agents[existing] = [agentId, 'ACTIVE', '-', session, now];
+                }
             }
             else {
-                agents.push([agentId, 'ACTIVE', '-', now]);
+                agents.push([agentId, 'ACTIVE', '-', session, now]);
             }
-            return this.updateTable(content, 'Active Agents', ['Agent ID', 'Status', 'Current Focus', 'Last Heartbeat'], agents);
+            return this.updateTable(content, 'Active Agents', ['Agent ID', 'Status', 'Current Focus', 'Session ID', 'Last Heartbeat'], agents);
         });
     }
     async updateStatus(agentId, status, focus) {
         await this.updateBoard((content) => {
-            const agents = this.parseTable(content, 'Active Agents');
+            let agents = this.parseTable(content, 'Active Agents');
+            // Migration: Ensure 5 columns
+            agents = agents.map(row => {
+                if (row.length === 4) {
+                    return [row[0], row[1], row[2], '', row[3]];
+                }
+                return row;
+            });
             const idx = agents.findIndex(a => a[0]?.trim() === agentId);
             const now = new Date().toISOString();
             if (idx >= 0) {
-                agents[idx] = [agentId, status, focus, now];
+                // Keep existing session ID
+                const currentSession = agents[idx][3] || '';
+                agents[idx] = [agentId, status, focus, currentSession, now];
             }
             else {
-                agents.push([agentId, status, focus, now]);
+                agents.push([agentId, status, focus, '', now]);
             }
-            return this.updateTable(content, 'Active Agents', ['Agent ID', 'Status', 'Current Focus', 'Last Heartbeat'], agents);
+            return this.updateTable(content, 'Active Agents', ['Agent ID', 'Status', 'Current Focus', 'Session ID', 'Last Heartbeat'], agents);
         });
     }
+    async getSessionId(agentId) {
+        const content = await this.getBoardContent();
+        const agents = this.parseTable(content, 'Active Agents');
+        const agent = agents.find(a => a[0]?.trim() === agentId);
+        if (agent) {
+            // Handle 5 cols
+            if (agent.length >= 5)
+                return agent[3].trim();
+            // Handle 4 cols (legacy) - no session ID
+            return undefined;
+        }
+        return undefined;
+    }
     async claimResource(agentId, resource) {
         let success = false;
         await this.updateBoard((content) => {
@@ -95,10 +208,7 @@ export class AgentBoard {
             return this.updateTable(content, 'File Locks', ['File Pattern', 'Claimed By', 'Since'], locks);
         });
     }
-    async getBoardContent() {
-        await this.ensureBoardExists();
-        return await fs.readFile(this.getBoardPath(), 'utf-8');
-    }
+    // [Duplicate getBoardContent removed]
     // --- Helpers ---
     async updateBoard(mutator) {
         await this.ensureBoardExists();

package/dist/common/registryManager.js

@@ -0,0 +1,56 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+export class RegistryManager {
+    globalPath;
+    constructor() {
+        this.globalPath = path.join(os.homedir(), '.memorybank', 'global_registry.json');
+    }
+    async ensureRegistry() {
+        try {
+            await fs.mkdir(path.dirname(this.globalPath), { recursive: true });
+            const content = await fs.readFile(this.globalPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return { projects: [] };
+        }
+    }
+    async saveRegistry(registry) {
+        await fs.writeFile(this.globalPath, JSON.stringify(registry, null, 2), 'utf-8');
+    }
+    async registerProject(projectId, workspacePath, description, keywords = []) {
+        const registry = await this.ensureRegistry();
+        const idx = registry.projects.findIndex(p => p.projectId === projectId);
+        // Preserve existing description/keywords if not provided
+        const existing = idx >= 0 ? registry.projects[idx] : null;
+        const card = {
+            projectId,
+            path: workspacePath,
+            description: description || existing?.description || '',
+            keywords: keywords.length > 0 ? keywords : (existing?.keywords || []),
+            lastActive: new Date().toISOString(),
+            status: 'ACTIVE'
+        };
+        if (idx >= 0) {
+            registry.projects[idx] = card;
+        }
+        else {
+            registry.projects.push(card);
+        }
+        await this.saveRegistry(registry);
+    }
+    async discoverProjects(query) {
+        const registry = await this.ensureRegistry();
+        if (!query || query.trim() === '')
+            return registry.projects;
+        const q = query.toLowerCase();
+        return registry.projects.filter(p => p.projectId.toLowerCase().includes(q) ||
+            (p.description && p.description.toLowerCase().includes(q)) ||
+            p.keywords.some(k => k.toLowerCase().includes(q)));
+    }
+    async getProject(projectId) {
+        const registry = await this.ensureRegistry();
+        return registry.projects.find(p => p.projectId === projectId);
+    }
+}

package/dist/common/sessionLogger.js

@@ -0,0 +1,45 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class SessionLogger {
+    projectPath;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+    }
+    getSessionDir(projectId) {
+        return path.join(this.projectPath, '.memorybank', 'projects', projectId, 'sessions');
+    }
+    getSessionFilePath(projectId, sessionId) {
+        return path.join(this.getSessionDir(projectId), `${sessionId}.jsonl`);
+    }
+    async logSessionEvent(projectId, sessionId, event) {
+        if (!sessionId)
+            return; // No logging if no session ID provided
+        const sessionDir = this.getSessionDir(projectId);
+        try {
+            await fs.mkdir(sessionDir, { recursive: true });
+            const filePath = this.getSessionFilePath(projectId, sessionId);
+            // Append line to JSONL file
+            const line = JSON.stringify(event) + '\n';
+            await fs.appendFile(filePath, line, 'utf-8');
+        }
+        catch (error) {
+            console.error(`[SessionLogger] Error logging event for session ${sessionId}:`, error);
+        }
+    }
+    async getSessionHistory(projectId, sessionId) {
+        const filePath = this.getSessionFilePath(projectId, sessionId);
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return content.split('\n')
+                .filter(line => line.trim().length > 0)
+                .map(line => JSON.parse(line));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+}
+export const sessionLogger = new SessionLogger(process.cwd());

package/dist/common/version.js

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

package/dist/index.js

@@ -80,12 +80,16 @@ import { updateContext, updateContextToolDefinition } from "./tools/updateContex
 import { recordDecision, recordDecisionToolDefinition } from "./tools/recordDecision.js";
 import { trackProgress, trackProgressToolDefinition } from "./tools/trackProgress.js";
 import { manageAgentsTool, manageAgentsToolDefinition } from "./tools/manageAgents.js";
+import { discoverProjectsTool, discoverProjectsToolDefinition } from "./tools/discoverProjects.js";
+import { delegateTaskTool, delegateTaskToolDefinition } from "./tools/delegateTask.js";
+import { RegistryManager } from "./common/registryManager.js";
 import { VERSION } from "./common/version.js";
 // Global services
 let embeddingService;
 let vectorStore;
 let indexManager;
 let projectKnowledgeService;
+let registryManager;
 let workspaceRoot;
 // Create the MCP Server
 const server = new McpServer({
@@ -155,6 +159,10 @@ server.tool("memorybank_search", "Busca código relevante mediante búsqueda sem
         .string()
         .optional()
         .describe("Filtrar resultados por lenguaje de programación (ej: 'typescript', 'python')"),
+    agentId: z
+        .string()
+        .optional()
+        .describe("Identificador del agente (para logging de sesión)"),
 }, async (args) => {
     const result = await searchMemory({
         projectId: args.projectId,
@@ -163,7 +171,8 @@ server.tool("memorybank_search", "Busca código relevante mediante búsqueda sem
         minScore: args.minScore,
         filterByFile: args.filterByFile,
         filterByLanguage: args.filterByLanguage,
-    }, indexManager);
+        agentId: args.agentId,
+    }, indexManager, workspaceRoot);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
     };
@@ -494,6 +503,7 @@ server.tool(manageAgentsToolDefinition.name, manageAgentsToolDefinition.descript
     projectId: z.string().describe("Identificador único del proyecto (OBLIGATORIO)"),
     action: z.enum(["register", "update_status", "claim_resource", "release_resource", "get_board"]).describe("Acción a realizar"),
     agentId: z.string().optional().describe("Identificador del agente (ej: 'dev-agent-1'). Requerido para escrituras."),
+    sessionId: z.string().optional().describe("UUID de sesión del agente para tracking de contexto."),
     status: z.string().optional().describe("Estado del agente (para update_status)."),
     focus: z.string().optional().describe("Tarea o fichero en el que se enfoca (para update_status)."),
     resource: z.string().optional().describe("Identificador del recurso a bloquear (ej: 'src/auth/')."),
@@ -506,6 +516,7 @@ server.tool(manageAgentsToolDefinition.name, manageAgentsToolDefinition.descript
         projectId: args.projectId,
         action: args.action,
         agentId: args.agentId,
+        sessionId: args.sessionId,
         status: args.status,
         focus: args.focus,
         resource: args.resource
@@ -753,6 +764,18 @@ async function validateEnvironment() {
             indexManager.setProjectKnowledgeService(projectKnowledgeService);
             indexManager.setAutoUpdateDocs(autoUpdateDocs);
             console.error("✓ Project Knowledge service connected to Index Manager");
+            // Initialize Registry Manager and register current project
+            try {
+                registryManager = new RegistryManager();
+                // Assuming user defines project ID in env or generic default
+                // We will try to read it from an existing .memorybank config if possible, or pass it later
+                // But here we can't easily know the projectId if it hasn't been initialized by the user.
+                // However, if the user calls initialize_memorybank, we should register it then.
+                console.error("✓ Registry manager initialized");
+            }
+            catch (regError) {
+                console.error(`⚠ Warning: Registry Manager service not available: ${regError}`);
+            }
         }
         catch (error) {
             console.error(`⚠ Warning: Project Knowledge service not available: ${error}`);
@@ -766,6 +789,36 @@ async function validateEnvironment() {
     console.error("\n✓ All services ready");
     console.error("");
 }
+// Tool: Discover Projects
+server.tool(discoverProjectsToolDefinition.name, discoverProjectsToolDefinition.description, {
+    query: z.string().optional().describe("Término de búsqueda (por ID, descripción o keywords)")
+}, async (args) => {
+    const result = await discoverProjectsTool({
+        query: args.query
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool: Delegate Task
+server.tool(delegateTaskToolDefinition.name, delegateTaskToolDefinition.description, {
+    projectId: z.string().describe("ID del proyecto origen (quien pide)"),
+    targetProjectId: z.string().describe("ID del proyecto destino (quien debe hacer el trabajo)"),
+    title: z.string().describe("Título corto de la tarea"),
+    description: z.string().describe("Descripción detallada de lo que se necesita"),
+    context: z.string().optional().describe("Contexto técnico adicional para que el agente receptor entienda la tarea")
+}, async (args) => {
+    const result = await delegateTaskTool({
+        projectId: args.projectId,
+        targetProjectId: args.targetProjectId,
+        title: args.title,
+        description: args.description,
+        context: args.context || ''
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
 /**
  * Starts the stdio server
  */

package/dist/tools/delegateTask.js

@@ -0,0 +1,59 @@
+import { RegistryManager } from '../common/registryManager.js';
+import { AgentBoard } from '../common/agentBoard.js';
+export async function delegateTaskTool(params) {
+    const registryManager = new RegistryManager();
+    const targetProject = await registryManager.getProject(params.targetProjectId);
+    if (!targetProject) {
+        return {
+            success: false,
+            message: `Target project '${params.targetProjectId}' not found in global registry.`
+        };
+    }
+    try {
+        // Initialize board for the TARGET project path
+        // We use targetProject.path as the workspace root for that board
+        const targetBoard = new AgentBoard(targetProject.path, targetProject.projectId);
+        const taskId = await targetBoard.createExternalTask(params.title, params.projectId, `${params.description}\n\nContext:\n${params.context}`);
+        return {
+            success: true,
+            taskId,
+            message: `Task successfully delegated to project '${params.targetProjectId}' (Task ID: ${taskId})`
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to delegate task: ${error.message}`
+        };
+    }
+}
+export const delegateTaskToolDefinition = {
+    name: "memorybank_delegate_task",
+    description: "Delega una tarea a otro proyecto del ecosistema. Crea una petición externa en el tablero del proyecto destino.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "ID del proyecto origen (quien pide)"
+            },
+            targetProjectId: {
+                type: "string",
+                description: "ID del proyecto destino (quien debe hacer el trabajo)"
+            },
+            title: {
+                type: "string",
+                description: "Título corto de la tarea"
+            },
+            description: {
+                type: "string",
+                description: "Descripción detallada de lo que se necesita"
+            },
+            context: {
+                type: "string",
+                description: "Contexto técnico adicional para que el agente receptor entienda la tarea"
+            }
+        },
+        required: ["projectId", "targetProjectId", "title", "description"]
+    }
+};

package/dist/tools/discoverProjects.js

@@ -0,0 +1,23 @@
+import { RegistryManager } from '../common/registryManager.js';
+export async function discoverProjectsTool(params) {
+    const registryManager = new RegistryManager();
+    const projects = await registryManager.discoverProjects(params.query);
+    return {
+        success: true,
+        projectCount: projects.length,
+        projects: projects
+    };
+}
+export const discoverProjectsToolDefinition = {
+    name: "memorybank_discover_projects",
+    description: "Descubre otros proyectos indexados en el ecosistema Memory Bank local. Útil para coordinar tareas entre proyectos.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Término de búsqueda (por ID, descripción o keywords)"
+            }
+        }
+    }
+};

package/dist/tools/getProjectDocs.js

@@ -2,6 +2,8 @@
  * @fileoverview Tool for reading project documentation
  * Retrieves generated markdown documents for project context
  */
+import { AgentBoard } from "../common/agentBoard.js";
+import { sessionLogger } from "../common/sessionLogger.js";
 const VALID_DOC_TYPES = [
     "projectBrief",
     "productContext",
@@ -13,7 +15,30 @@ const VALID_DOC_TYPES = [
 /**
  * Retrieves project documentation
  */
-export async function getProjectDocs(params, projectKnowledgeService) {
+export async function getProjectDocs(params, projectKnowledgeService, workspaceRoot) {
+    const logSession = async (outputSummary) => {
+        if (params.agentId && workspaceRoot) {
+            try {
+                const board = new AgentBoard(workspaceRoot, params.projectId);
+                const sessionId = await board.getSessionId(params.agentId);
+                if (sessionId) {
+                    // Use singleton sessionLogger
+                    await sessionLogger.logSessionEvent(params.projectId, sessionId, {
+                        timestamp: new Date().toISOString(),
+                        type: 'read_doc',
+                        data: {
+                            document: params.document || 'all',
+                            format: params.format || 'full',
+                            summary: outputSummary
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`Failed to log doc session: ${error}`);
+            }
+        }
+    };
     try {
         const projectId = params.projectId;
         const format = params.format || "full";
@@ -41,6 +66,7 @@ export async function getProjectDocs(params, projectKnowledgeService) {
         // Handle summary request
         if (requestedDoc === "summary" || format === "summary") {
             const summary = projectKnowledgeService.getDocumentsSummary(projectId);
+            await logSession("Summary of all documents");
             return {
                 success: true,
                 message: `Retrieved summary of ${stats.documentCount} project documents for "${projectId}".`,
@@ -51,6 +77,7 @@ export async function getProjectDocs(params, projectKnowledgeService) {
         // Handle "all" or no specific document
         if (!requestedDoc || requestedDoc === "all") {
             const documents = projectKnowledgeService.getAllDocuments(projectId);
+            await logSession(`All ${documents.length} documents`);
             return {
                 success: true,
                 message: `Retrieved ${documents.length} project documents for "${projectId}".`,
@@ -76,6 +103,7 @@ export async function getProjectDocs(params, projectKnowledgeService) {
                 stats: statsResult,
             };
         }
+        await logSession(`Document: ${normalizedDoc}`);
         return {
             success: true,
             message: `Retrieved document: ${normalizedDoc} for project "${projectId}"`,

package/dist/tools/initializeMemoryBank.js

@@ -4,6 +4,7 @@
  */
 import * as fs from "fs";
 import * as path from "path";
+import { RegistryManager } from "../common/registryManager.js";
 /**
  * Document templates for initialization
  */
@@ -295,6 +296,15 @@ export async function initializeMemoryBank(params, storagePath = ".memorybank")
     // Create directory structure
     console.error(`Creating directory: ${docsPath}`);
     fs.mkdirSync(docsPath, { recursive: true });
+    // Register project globally
+    try {
+        const registry = new RegistryManager();
+        await registry.registerProject(projectId, projectPath, description, projectName ? [projectName] : []);
+        console.error(`  Global registry updated.`);
+    }
+    catch (regErr) {
+        console.error(`  Failed to update global registry: ${regErr}`);
+    }
     // Create all template documents
     const documentsCreated = [];
     const documents = {

package/dist/tools/manageAgents.js

@@ -1,15 +1,23 @@
 import { AgentBoard } from '../common/agentBoard.js';
+import * as crypto from 'crypto';
 const WORKSPACE_ROOT = process.cwd(); // Will be overridden by actual workspace logic if passed
 export async function manageAgentsTool(params, workspaceRoot = WORKSPACE_ROOT) {
-    const { projectId, action, agentId, status, focus, resource } = params;
+    const { projectId, action, agentId, sessionId, status, focus, resource } = params;
     const board = new AgentBoard(workspaceRoot, projectId);
     try {
         switch (action) {
             case 'register':
                 if (!agentId)
                     throw new Error('agentId is required for register');
-                await board.registerAgent(agentId);
-                return { success: true, message: `Agent ${agentId} registered` };
+                // Auto-generate session ID if not provided.
+                // This abstracts the session management from the agent.
+                const effectiveSessionId = sessionId || crypto.randomUUID();
+                await board.registerAgent(agentId, effectiveSessionId);
+                return {
+                    success: true,
+                    message: `Agent ${agentId} registered`,
+                    sessionId: effectiveSessionId
+                };
             case 'update_status':
                 if (!agentId)
                     throw new Error('agentId is required for update_status');
@@ -63,6 +71,10 @@ export const manageAgentsToolDefinition = {
                 type: "string",
                 description: "Identificador del agente (ej: 'dev-agent-1'). Requerido para escrituras.",
             },
+            sessionId: {
+                type: "string",
+                description: "Identificador de sesión (opcional, para registro)",
+            },
             status: {
                 type: "string",
                 description: "Estado del agente (para update_status).",

package/dist/tools/searchMemory.js

@@ -2,10 +2,12 @@
  * @fileoverview Search memory tool for Memory Bank
  * Searches code semantically using vector similarity
  */
+import { AgentBoard } from "../common/agentBoard.js";
+import { sessionLogger } from "../common/sessionLogger.js";
 /**
  * Searches the Memory Bank for relevant code
  */
-export async function searchMemory(params, indexManager) {
+export async function searchMemory(params, indexManager, workspaceRoot) {
     try {
         if (!params.query || params.query.trim() === "") {
             return {
@@ -34,6 +36,31 @@ export async function searchMemory(params, indexManager) {
             filterByFile: params.filterByFile,
             filterByLanguage: params.filterByLanguage,
         });
+        // Session Logging
+        if (params.agentId && workspaceRoot) {
+            try {
+                const board = new AgentBoard(workspaceRoot, params.projectId);
+                const sessionId = await board.getSessionId(params.agentId);
+                if (sessionId) {
+                    await sessionLogger.logSessionEvent(params.projectId, sessionId, {
+                        timestamp: new Date().toISOString(),
+                        type: 'search',
+                        data: {
+                            query: params.query,
+                            filters: {
+                                file: params.filterByFile,
+                                lang: params.filterByLanguage
+                            },
+                            resultCount: results.length,
+                            topResults: results.slice(0, 5).map(r => ({ path: r.filePath, score: r.score }))
+                        }
+                    });
+                }
+            }
+            catch (logError) {
+                console.error(`Failed to log search session: ${logError}`);
+            }
+        }
         console.error(`Found ${results.length} result(s)`);
         // Format message
         let message = `Found ${results.length} result(s)`;

package/package.json

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