@hivehub/rulebook 5.8.2 → 6.0.0

package/dist/mcp/rulebook-server.js

@@ -5,10 +5,16 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync,
 import { dirname, join, resolve } from 'path';
 import { z } from 'zod';
 import { ConfigManager } from '../core/state/config-manager.js';
-import { BackgroundIndexer } from '../core/indexer/background-indexer.js';
 import { SkillsManager, getDefaultTemplatesPath } from '../core/skills/skills-manager.js';
 import { TaskManager } from '../core/tasks/task-manager.js';
 import { WorkspaceManager } from '../core/workspace/workspace-manager.js';
+import { registerTaskTools } from './tools/task-tools.js';
+import { registerSkillTools } from './tools/skill-tools.js';
+import { registerWorkspaceTools } from './tools/workspace-tools.js';
+import { registerDecisionTools } from './tools/decision-tools.js';
+import { registerKnowledgeTools } from './tools/knowledge-tools.js';
+import { registerLearnTools } from './tools/learn-tools.js';
+import { registerRulesTools } from './tools/rules-tools.js';
 // --- Timeout guard for MCP tool handlers ---
 // Prevents the MCP server from hanging when a tool handler blocks (SQLite, WASM, fs).
 const MCP_TOOL_TIMEOUT_MS = parseInt(process.env.RULEBOOK_MCP_TIMEOUT_MS ?? '10000', 10);
@@ -260,1590 +266,52 @@ export async function startRulebookMcpServer() {
         const w = await workspaceManager.getWorker(projectId);
         return w.getSkillsManager();
     }
-    async function getMemMgr(projectId) {
-        if (workspaceManager) {
-            const pid = projectId ?? workspaceManager.getDefaultProjectId();
-            const w = await workspaceManager.getWorker(pid);
-            return w.getMemoryManager();
-        }
-        return memoryManager;
-    }
-    const server = new McpServer({
-        name: 'rulebook-task-management',
-        version: '5.2.0',
-    });
-    // --- Wrap all tool handlers with a timeout guard ---
-    const originalRegisterTool = server.registerTool.bind(server);
-    server.registerTool = ((name, config, handler) => {
-        const wrappedHandler = async (...handlerArgs) => {
-            try {
-                return await withTimeout(handler(...handlerArgs), MCP_TOOL_TIMEOUT_MS, name);
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                console.error(`[rulebook-mcp] ${name} error: ${msg}`);
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ success: false, error: msg }) },
-                    ],
-                };
-            }
-        };
-        return originalRegisterTool(name, config, wrappedHandler);
-    });
-    // Zod schema reused across tools for workspace project targeting
-    const projectIdSchema = z
-        .string()
-        .optional()
-        .describe('Project ID (workspace mode only, defaults to default project)');
-    // Register tool: rulebook_task_create
-    server.registerTool('rulebook_task_create', {
-        title: 'Create Rulebook Task',
-        description: 'Create a new Rulebook task',
-        inputSchema: {
-            taskId: z
-                .string()
-                .describe('Task ID with phase prefix: phase<N>_<description> (e.g., phase1_add-user-auth, phase2a_fix-login-bug)'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const tm = await getTaskMgr(args.projectId);
-        await tm.createTask(args.taskId);
-        const resultText = JSON.stringify({
-            success: true,
-            taskId: args.taskId,
-            message: `Task ${args.taskId} created successfully`,
-        });
-        autoCapture('rulebook_task_create', args, resultText);
-        return { content: [{ type: 'text', text: resultText }] };
-    });
-    // Register tool: rulebook_task_list
-    server.registerTool('rulebook_task_list', {
-        title: 'List Rulebook Tasks',
-        description: 'List all Rulebook tasks',
-        inputSchema: {
-            includeArchived: z.boolean().optional().describe('Include archived tasks'),
-            status: z
-                .enum(['pending', 'in-progress', 'completed', 'blocked'])
-                .optional()
-                .describe('Filter by status'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const tm = await getTaskMgr(args.projectId);
-        const tasks = await tm.listTasks(args.includeArchived || false);
-        let filtered = tasks;
-        if (args.status) {
-            filtered = tasks.filter((t) => t.status === args.status);
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        tasks: filtered.map((t) => ({
-                            id: t.id,
-                            title: t.title,
-                            status: t.status,
-                            createdAt: t.createdAt,
-                            updatedAt: t.updatedAt,
-                        })),
-                        count: filtered.length,
-                    }),
-                },
-            ],
-        };
-    });
-    // Register tool: rulebook_task_show
-    server.registerTool('rulebook_task_show', {
-        title: 'Show Rulebook Task',
-        description: 'Show task details',
-        inputSchema: {
-            taskId: z.string().describe('Task ID to show'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const tm = await getTaskMgr(args.projectId);
-        const task = await tm.showTask(args.taskId);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        task: task
-                            ? {
-                                id: task.id,
-                                title: task.title,
-                                status: task.status,
-                                proposal: task.proposal,
-                                tasks: task.tasks,
-                                design: task.design,
-                                specs: task.specs,
-                                createdAt: task.createdAt,
-                                updatedAt: task.updatedAt,
-                            }
-                            : null,
-                        found: task !== null,
-                    }),
-                },
-            ],
-        };
-    });
-    // Register tool: rulebook_task_update
-    server.registerTool('rulebook_task_update', {
-        title: 'Update Rulebook Task',
-        description: 'Update task status',
-        inputSchema: {
-            taskId: z.string().describe('Task ID to update'),
-            status: z
-                .enum(['pending', 'in-progress', 'completed', 'blocked'])
-                .optional()
-                .describe('New status'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const tm = await getTaskMgr(args.projectId);
-        if (args.status) {
-            await tm.updateTaskStatus(args.taskId, args.status);
-        }
-        const resultText = JSON.stringify({
-            success: true,
-            taskId: args.taskId,
-            message: `Task ${args.taskId} updated successfully`,
-        });
-        autoCapture('rulebook_task_update', args, resultText);
-        return { content: [{ type: 'text', text: resultText }] };
-    });
-    // Register tool: rulebook_task_validate
-    server.registerTool('rulebook_task_validate', {
-        title: 'Validate Rulebook Task',
-        description: 'Validate task format',
-        inputSchema: {
-            taskId: z.string().describe('Task ID to validate'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const tm = await getTaskMgr(args.projectId);
-        const validation = await tm.validateTask(args.taskId);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        valid: validation.valid,
-                        errors: validation.errors,
-                        warnings: validation.warnings,
-                    }),
-                },
-            ],
-        };
-    });
-    // Register tool: rulebook_task_archive
-    server.registerTool('rulebook_task_archive', {
-        title: 'Archive Rulebook Task',
-        description: 'Archive a completed task',
-        inputSchema: {
-            taskId: z
-                .string()
-                .describe('Task ID to archive (must use phase prefix, e.g., phase1_my-task)'),
-            skipValidation: z.boolean().optional().describe('Skip validation before archiving'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const tm = await getTaskMgr(args.projectId);
-        await tm.archiveTask(args.taskId, args.skipValidation || false);
-        const resultText = JSON.stringify({
-            success: true,
-            taskId: args.taskId,
-            message: `Task ${args.taskId} archived successfully`,
-        });
-        autoCapture('rulebook_task_archive', args, resultText);
-        return { content: [{ type: 'text', text: resultText }] };
-    });
-    // Register tool: rulebook_task_delete
-    server.registerTool('rulebook_task_delete', {
-        title: 'Delete Rulebook Task',
-        description: 'Delete a task permanently',
-        inputSchema: {
-            taskId: z.string().describe('Task ID to delete'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const tm = await getTaskMgr(args.projectId);
-        await tm.deleteTask(args.taskId);
-        const resultText = JSON.stringify({
-            success: true,
-            taskId: args.taskId,
-            message: `Task ${args.taskId} deleted successfully`,
-        });
-        autoCapture('rulebook_task_delete', args, resultText);
-        return { content: [{ type: 'text', text: resultText }] };
-    });
-    // ============================================
-    // Skills Management Functions (v2.0)
-    // ============================================
-    // Register tool: rulebook_skill_list
-    server.registerTool('rulebook_skill_list', {
-        title: 'List Available Skills',
-        description: 'List all available skills, optionally filtered by category',
-        inputSchema: {
-            category: z
-                .enum([
-                'languages',
-                'frameworks',
-                'modules',
-                'services',
-                'workflows',
-                'ides',
-                'core',
-                'cli',
-                'git',
-                'hooks',
-            ])
-                .optional()
-                .describe('Filter by category'),
-            enabledOnly: z.boolean().optional().describe('Show only enabled skills'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const sm = await getSkillsMgr(args.projectId);
-            const cm = await getConfigMgr(args.projectId);
-            let skills;
-            if (args.category) {
-                skills = await sm.getSkillsByCategory(args.category);
-            }
-            else {
-                skills = await sm.getSkills();
-            }
-            const rbConfig = await cm.loadConfig();
-            const enabledIds = new Set(rbConfig.skills?.enabled || []);
-            let filteredSkills = skills.map((s) => ({
-                id: s.id,
-                name: s.metadata.name,
-                description: s.metadata.description,
-                category: s.category,
-                enabled: enabledIds.has(s.id),
-                version: s.metadata.version,
-                tags: s.metadata.tags,
-            }));
-            if (args.enabledOnly) {
-                filteredSkills = filteredSkills.filter((s) => s.enabled);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            skills: filteredSkills,
-                            count: filteredSkills.length,
-                            category: args.category || 'all',
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_skill_show
-    server.registerTool('rulebook_skill_show', {
-        title: 'Show Skill Details',
-        description: 'Show detailed information about a specific skill',
-        inputSchema: {
-            skillId: z.string().describe('Skill ID (e.g., languages/typescript)'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const sm = await getSkillsMgr(args.projectId);
-            const cm = await getConfigMgr(args.projectId);
-            const skill = await sm.getSkillById(args.skillId);
-            if (!skill) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: `Skill not found: ${args.skillId}`,
-                                suggestion: 'Use rulebook_skill_list to see available skills',
-                            }),
-                        },
-                    ],
-                };
-            }
-            const rbConfig = await cm.loadConfig();
-            const enabled = rbConfig.skills?.enabled?.includes(args.skillId) || false;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            skill: {
-                                id: skill.id,
-                                name: skill.metadata.name,
-                                description: skill.metadata.description,
-                                category: skill.category,
-                                enabled,
-                                version: skill.metadata.version,
-                                author: skill.metadata.author,
-                                tags: skill.metadata.tags,
-                                dependencies: skill.metadata.dependencies,
-                                conflicts: skill.metadata.conflicts,
-                                content: skill.content.slice(0, 2000) + (skill.content.length > 2000 ? '...' : ''),
-                            },
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_skill_enable
-    server.registerTool('rulebook_skill_enable', {
-        title: 'Enable Skill',
-        description: 'Enable a skill in the project configuration',
-        inputSchema: {
-            skillId: z.string().describe('Skill ID to enable (e.g., languages/typescript)'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const sm = await getSkillsMgr(args.projectId);
-            const cm = await getConfigMgr(args.projectId);
-            let rbConfig = await cm.loadConfig();
-            rbConfig = await sm.enableSkill(args.skillId, rbConfig);
-            await cm.saveConfig(rbConfig);
-            const validation = await sm.validateSkills(rbConfig);
-            const resultText = JSON.stringify({
-                success: true,
-                skillId: args.skillId,
-                message: `Skill ${args.skillId} enabled successfully`,
-                warnings: validation.warnings,
-                conflicts: validation.conflicts,
-            });
-            autoCapture('rulebook_skill_enable', args, resultText);
-            return { content: [{ type: 'text', text: resultText }] };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_skill_disable
-    server.registerTool('rulebook_skill_disable', {
-        title: 'Disable Skill',
-        description: 'Disable a skill in the project configuration',
-        inputSchema: {
-            skillId: z.string().describe('Skill ID to disable (e.g., languages/typescript)'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const sm = await getSkillsMgr(args.projectId);
-            const cm = await getConfigMgr(args.projectId);
-            let rbConfig = await cm.loadConfig();
-            if (!rbConfig.skills?.enabled?.includes(args.skillId)) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: `Skill ${args.skillId} is not currently enabled`,
-                            }),
-                        },
-                    ],
-                };
-            }
-            rbConfig = await sm.disableSkill(args.skillId, rbConfig);
-            await cm.saveConfig(rbConfig);
-            const resultText = JSON.stringify({
-                success: true,
-                skillId: args.skillId,
-                message: `Skill ${args.skillId} disabled successfully`,
-            });
-            autoCapture('rulebook_skill_disable', args, resultText);
-            return { content: [{ type: 'text', text: resultText }] };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_skill_search
-    server.registerTool('rulebook_skill_search', {
-        title: 'Search Skills',
-        description: 'Search for skills by name, description, or tags',
-        inputSchema: {
-            query: z.string().describe('Search query'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const sm = await getSkillsMgr(args.projectId);
-            const cm = await getConfigMgr(args.projectId);
-            const skills = await sm.searchSkills(args.query);
-            const rbConfig = await cm.loadConfig();
-            const enabledIds = new Set(rbConfig.skills?.enabled || []);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            query: args.query,
-                            skills: skills.map((s) => ({
-                                id: s.id,
-                                name: s.metadata.name,
-                                description: s.metadata.description,
-                                category: s.category,
-                                enabled: enabledIds.has(s.id),
-                            })),
-                            count: skills.length,
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_skill_validate
-    server.registerTool('rulebook_skill_validate', {
-        title: 'Validate Skills Configuration',
-        description: 'Validate the current skills configuration for conflicts and dependencies',
-        inputSchema: {
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const sm = await getSkillsMgr(args.projectId);
-            const cm = await getConfigMgr(args.projectId);
-            const rbConfig = await cm.loadConfig();
-            const validation = await sm.validateSkills(rbConfig);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            valid: validation.valid,
-                            errors: validation.errors,
-                            warnings: validation.warnings,
-                            conflicts: validation.conflicts,
-                            enabledCount: rbConfig.skills?.enabled?.length || 0,
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // ============================================
-    // Memory System Functions (v3.0)
-    // ============================================
-    // Conditionally initialize MemoryManager (single-project mode only;
-    // in workspace mode each worker manages its own memory)
-    let memoryManager = null;
-    let bgIndexer = null;
-    let autoCaptureEnabled = false;
-    if (!isWorkspaceMode) {
-        const rulebookConfig = await configManager.loadConfig();
-        if (rulebookConfig.memory?.enabled) {
-            try {
-                const { createMemoryManager } = await import('../memory/memory-manager.js');
-                const memoryDbPath = join(projectRoot, rulebookConfig.memory.dbPath ?? '.rulebook/memory/memory.db');
-                console.error(`[rulebook-mcp] Memory DB: ${memoryDbPath}`);
-                memoryManager = createMemoryManager(projectRoot, rulebookConfig.memory);
-                autoCaptureEnabled = rulebookConfig.memory.autoCapture !== false;
-                // Boot Background Indexer only if memory is enabled (opt-in to save resources)
-                const indexerEnabled = rulebookConfig.memory?.enabled === true;
-                if (indexerEnabled) {
-                    bgIndexer = new BackgroundIndexer(memoryManager, projectRoot, {
-                        enabled: true,
-                        ...rulebookConfig.indexer,
-                    });
-                    setTimeout(() => {
-                        try {
-                            bgIndexer?.start();
-                        }
-                        catch (e) {
-                            console.error('[rulebook-mcp] BackgroundIndexer start failed:', e);
-                        }
-                    }, 5000);
-                }
-                global.__indexerStatus = () => bgIndexer?.getStatus();
-            }
-            catch (e) {
-                console.warn('[rulebook-mcp] Failed to boot Memory/Indexer:', e);
-            }
-        }
-    }
-    // --- Graceful shutdown for both modes ---
-    // Handles SIGINT (Ctrl+C), SIGTERM (parent exit), SIGHUP (terminal close),
-    // and stdin close (parent process died without signaling).
-    let isShuttingDown = false;
-    async function gracefulShutdown(reason) {
-        if (isShuttingDown)
-            return; // Prevent double-shutdown races
-        isShuttingDown = true;
-        console.error(`[rulebook-mcp] Shutting down (${reason})...`);
-        try {
-            if (bgIndexer)
-                bgIndexer.stop();
-            if (workspaceManager) {
-                await workspaceManager.shutdownAll();
-            }
-            if (memoryManager)
-                await memoryManager.close();
-            releasePidLock(pidFilePath);
-        }
-        catch (e) {
-            console.error('[rulebook-mcp] Error during shutdown:', e);
-        }
-        process.exit(0);
-    }
-    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-    process.on('SIGHUP', () => gracefulShutdown('SIGHUP'));
-    // Detect parent process exit: when the MCP client (e.g. Claude Code) dies,
-    // stdin closes. Without this, the server becomes an orphan that leaks memory.
-    process.stdin.on('end', () => gracefulShutdown('stdin closed'));
-    process.stdin.on('close', () => gracefulShutdown('stdin closed'));
-    // Safety net: if stdin becomes unreadable but doesn't emit 'end'/'close'
-    // (can happen on Windows), poll stdin.readable every 30s.
-    const STDIN_POLL_INTERVAL_MS = 30_000;
-    const stdinPollTimer = setInterval(() => {
-        if (process.stdin.destroyed || !process.stdin.readable) {
-            clearInterval(stdinPollTimer);
-            gracefulShutdown('stdin unreadable');
-        }
-    }, STDIN_POLL_INTERVAL_MS);
-    stdinPollTimer.unref(); // Don't keep the process alive just for this timer
-    /**
-     * Auto-capture: save tool interactions to memory in the background.
-     * Fire-and-forget — never blocks or fails the original tool call.
-     * Has its own 2s timeout to prevent hanging the event loop.
-     *
-     * The dynamic import is cached after the first call to avoid repeated
-     * module loading overhead on every tool invocation.
-     */
-    const AUTO_CAPTURE_TIMEOUT_MS = 2000;
-    let _captureFromToolCall = null;
-    async function autoCapture(toolName, args, resultText) {
-        if (!memoryManager || !autoCaptureEnabled)
-            return;
-        try {
-            await withTimeout((async () => {
-                if (!_captureFromToolCall) {
-                    const mod = await import('../memory/memory-hooks.js');
-                    _captureFromToolCall = mod.captureFromToolCall;
-                }
-                const captured = _captureFromToolCall(toolName, args, resultText);
-                if (!captured)
-                    return;
-                await memoryManager.saveMemory({
-                    type: captured.type,
-                    title: captured.title,
-                    content: captured.content,
-                    tags: captured.tags,
-                });
-            })(), AUTO_CAPTURE_TIMEOUT_MS, `autoCapture(${toolName})`);
-        }
-        catch {
-            // Never fail the original tool call — timeout or error is silently dropped
-        }
-    }
-    function memoryNotEnabled() {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: 'Memory system is not enabled. Set memory.enabled=true in .rulebook',
-                    }),
-                },
-            ],
-        };
-    }
-    // Register tool: rulebook_memory_search
-    server.registerTool('rulebook_memory_search', {
-        title: 'Search Memories',
-        description: 'Search persistent memories using hybrid BM25+vector search',
-        inputSchema: {
-            query: z.string().describe('Search query'),
-            limit: z.number().optional().describe('Max results (default 20)'),
-            mode: z.enum(['bm25', 'vector', 'hybrid']).optional().describe('Search mode'),
-            type: z.string().optional().describe('Filter by memory type'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const mm = await getMemMgr(args.projectId);
-        if (!mm)
-            return memoryNotEnabled();
-        try {
-            const results = await mm.searchMemories({
-                query: args.query,
-                limit: args.limit,
-                mode: args.mode,
-                type: args.type,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, results, total: results.length }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_memory_timeline
-    server.registerTool('rulebook_memory_timeline', {
-        title: 'Memory Timeline',
-        description: 'Get chronological context around a specific memory',
-        inputSchema: {
-            memoryId: z.string().describe('Memory ID to anchor timeline'),
-            window: z.number().optional().describe('Number of memories before/after (default 5)'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const mm = await getMemMgr(args.projectId);
-        if (!mm)
-            return memoryNotEnabled();
-        try {
-            const timeline = await mm.getTimeline(args.memoryId, args.window);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: true, timeline }) }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_memory_get
-    server.registerTool('rulebook_memory_get', {
-        title: 'Get Memory Details',
-        description: 'Get full details for specific memory IDs',
-        inputSchema: {
-            ids: z.array(z.string()).describe('Memory IDs to fetch'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const mm = await getMemMgr(args.projectId);
-        if (!mm)
-            return memoryNotEnabled();
-        try {
-            const memories = await mm.getFullDetails(args.ids);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: true, memories }) }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_memory_save
-    server.registerTool('rulebook_memory_save', {
-        title: 'Save Memory',
-        description: 'Save a new memory manually',
-        inputSchema: {
-            type: z
-                .string()
-                .describe('Memory type (bugfix, feature, refactor, decision, discovery, change, observation)'),
-            title: z.string().describe('Memory title'),
-            content: z.string().describe('Memory content'),
-            tags: z.array(z.string()).optional().describe('Tags'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const mm = await getMemMgr(args.projectId);
-        if (!mm)
-            return memoryNotEnabled();
-        try {
-            const memory = await mm.saveMemory({
-                type: args.type,
-                title: args.title,
-                content: args.content,
-                tags: args.tags,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            memory: { id: memory.id, type: memory.type, title: memory.title },
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_memory_stats
-    server.registerTool('rulebook_memory_stats', {
-        title: 'Memory Statistics',
-        description: 'Get memory database statistics',
-        inputSchema: {
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const mm = await getMemMgr(args.projectId);
-        if (!mm)
-            return memoryNotEnabled();
-        try {
-            const stats = await mm.getStats();
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: true, stats }) }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_memory_cleanup
-    server.registerTool('rulebook_memory_cleanup', {
-        title: 'Memory Cleanup',
-        description: 'Force memory eviction and cleanup',
-        inputSchema: {
-            force: z.boolean().optional().describe('Force cleanup regardless of size'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        const mm = await getMemMgr(args.projectId);
-        if (!mm)
-            return memoryNotEnabled();
-        try {
-            const result = await mm.cleanup(args.force ?? false);
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }) }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // --- Background Indexer Tools ---
-    // Register tool: rulebook_codebase_search
-    server.registerTool('rulebook_codebase_search', {
-        title: 'Codebase Semantic Search',
-        description: 'Search the entire project semantically (via AST chunks and paragraphs)',
-        inputSchema: {
-            query: z.string().describe('The code or concept you are looking for'),
-            limit: z.number().optional().describe('Result limit (default 10)'),
-        },
-    }, async (args) => {
-        if (!memoryManager)
-            return memoryNotEnabled();
-        try {
-            const results = await memoryManager.searchMemories({
-                query: args.query,
-                limit: args.limit ?? 10,
-                mode: 'hybrid', // Force hybrid search for best code-chunk matching
-            });
-            // Filter out normal memories, keep only code nodes
-            const codeResults = results.filter((r) => r.id.startsWith('__code__'));
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: true, results: codeResults }) },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_codebase_graph
-    server.registerTool('rulebook_codebase_graph', {
-        title: 'Codebase Graph Explorer',
-        description: 'Find relationships (imports, exports) of a specific code node or file',
-        inputSchema: {
-            filePath: z.string().describe('The strict file path to query (e.g. src/core/app.ts)'),
-        },
-    }, async (args) => {
-        if (!memoryManager)
-            return memoryNotEnabled();
-        try {
-            // Since V1 has limited Graph search implementation in memory-search,
-            // we'll return a placeholder indicating the edge relations.
-            // In a real implementation we would call a memoryManager.getGraphAdjacent(args.filePath)
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: `Graph query for ${args.filePath} accepted. (Note: Graph deep-search pending V2 implementation, use codebase_search for now.)`,
-                            filePath: args.filePath,
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_indexer_status
-    server.registerTool('rulebook_indexer_status', {
-        title: 'Background Indexer Status',
-        description: 'Get the status of the local autonomous filesystem indexer',
-        inputSchema: {},
-    }, async () => {
-        try {
-            // Because the BackgroundIndexer runs asynchronously, we fetch its global state
-            // assuming it was attached to the server context during boot.
-            const status = global.__indexerStatus
-                ? global.__indexerStatus()
-                : { running: false, error: 'Indexer not attached to global context' };
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: true, status }) }],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                ],
-            };
-        }
-    });
-    // ============================================
-    // Workspace Tools (v4.2 — workspace mode only)
-    // ============================================
-    if (workspaceManager) {
-        // Register tool: rulebook_workspace_list
-        server.registerTool('rulebook_workspace_list', {
-            title: 'List Workspace Projects',
-            description: 'List all projects in the current workspace',
-            inputSchema: {},
-        }, async () => {
-            const projects = workspaceManager.getProjects();
-            const activeIds = workspaceManager.getActiveWorkerIds();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            workspace: workspaceManager.getConfig().name,
-                            defaultProject: workspaceManager.getDefaultProjectId(),
-                            projects: projects.map((p) => ({
-                                name: p.name,
-                                path: p.path,
-                                workerActive: activeIds.includes(p.name),
-                            })),
-                            count: projects.length,
-                        }),
-                    },
-                ],
-            };
-        });
-        // Register tool: rulebook_workspace_status
-        server.registerTool('rulebook_workspace_status', {
-            title: 'Workspace Status',
-            description: 'Get detailed status of all workspace projects (workers, tasks, memory)',
-            inputSchema: {},
-        }, async () => {
-            try {
-                const status = await workspaceManager.getStatus();
-                return {
-                    content: [{ type: 'text', text: JSON.stringify({ success: true, ...status }) }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                    ],
-                };
-            }
-        });
-        // Register tool: rulebook_workspace_search
-        server.registerTool('rulebook_workspace_search', {
-            title: 'Cross-Project Memory Search',
-            description: 'Search memories across all projects in the workspace',
-            inputSchema: {
-                query: z.string().describe('Search query'),
-                limit: z.number().optional().describe('Max results per project (default 10)'),
-            },
-        }, async (args) => {
-            try {
-                const results = await workspaceManager.searchMemoryAcrossProjects(args.query, {
-                    limit: args.limit,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                results,
-                                projectsSearched: results.length,
-                            }),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                    ],
-                };
-            }
-        });
-        // Register tool: rulebook_workspace_tasks
-        server.registerTool('rulebook_workspace_tasks', {
-            title: 'List Tasks Across Projects',
-            description: 'List tasks from all workspace projects',
-            inputSchema: {
-                status: z
-                    .enum(['pending', 'in-progress', 'completed', 'blocked'])
-                    .optional()
-                    .describe('Filter by status'),
-            },
-        }, async (args) => {
-            try {
-                const allTasks = [];
-                for (const project of workspaceManager.getProjects()) {
-                    try {
-                        const tm = await getTaskMgr(project.name);
-                        const tasks = await tm.listTasks(false);
-                        const filtered = args.status ? tasks.filter((t) => t.status === args.status) : tasks;
-                        if (filtered.length > 0) {
-                            allTasks.push({
-                                project: project.name,
-                                tasks: filtered.map((t) => ({
-                                    id: t.id,
-                                    title: t.title,
-                                    status: t.status,
-                                })),
-                            });
-                        }
-                    }
-                    catch {
-                        // Skip projects that fail
-                    }
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                projects: allTasks,
-                                totalTasks: allTasks.reduce((sum, p) => sum + p.tasks.length, 0),
-                            }),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ success: false, error: String(error) }) },
-                    ],
-                };
-            }
-        });
-    }
-    // ============================================
-    // Context Intelligence Layer Tools (v4.4)
-    // ============================================
-    // Register tool: rulebook_decision_create
-    server.registerTool('rulebook_decision_create', {
-        title: 'Create Decision Record',
-        description: 'Create a new architectural decision record (ADR)',
-        inputSchema: {
-            title: z.string().describe('Decision title'),
-            context: z.string().optional().describe('Context and problem statement'),
-            decision: z.string().optional().describe('The decision made'),
-            alternatives: z.array(z.string()).optional().describe('Alternatives considered'),
-            consequences: z.string().optional().describe('Consequences and tradeoffs'),
-            relatedTasks: z.array(z.string()).optional().describe('Related task IDs'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { DecisionManager } = await import('../core/tasks/decision-manager.js');
-            const dm = new DecisionManager(root);
-            const decision = await dm.create(args.title, {
-                context: args.context,
-                decision: args.decision,
-                alternatives: args.alternatives,
-                consequences: args.consequences,
-                relatedTasks: args.relatedTasks,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, decision }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_decision_list
-    server.registerTool('rulebook_decision_list', {
-        title: 'List Decision Records',
-        description: 'List all architectural decision records',
-        inputSchema: {
-            status: z
-                .string()
-                .optional()
-                .describe('Filter by status (proposed, accepted, rejected, superseded, deprecated)'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { DecisionManager } = await import('../core/tasks/decision-manager.js');
-            const dm = new DecisionManager(root);
-            const decisions = await dm.list(args.status);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, decisions, count: decisions.length }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_decision_show
-    server.registerTool('rulebook_decision_show', {
-        title: 'Show Decision Record',
-        description: 'Show full details of a decision record',
-        inputSchema: {
-            id: z.number().describe('Decision ID'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { DecisionManager } = await import('../core/tasks/decision-manager.js');
-            const dm = new DecisionManager(root);
-            const result = await dm.show(args.id);
-            if (!result) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({ success: false, error: `Decision ${args.id} not found` }),
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            decision: result.decision,
-                            content: result.content,
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_decision_update
-    server.registerTool('rulebook_decision_update', {
-        title: 'Update Decision Record',
-        description: 'Update an existing architectural decision record',
-        inputSchema: {
-            id: z.number().describe('Decision ID to update'),
-            status: z
-                .string()
-                .optional()
-                .describe('New status (proposed, accepted, rejected, superseded, deprecated)'),
-            context: z.string().optional().describe('Updated context'),
-            decision: z.string().optional().describe('Updated decision text'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { DecisionManager } = await import('../core/tasks/decision-manager.js');
-            const dm = new DecisionManager(root);
-            const updated = await dm.update(args.id, {
-                status: args.status,
-                context: args.context,
-                decision: args.decision,
-            });
-            if (!updated) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({ success: false, error: `Decision ${args.id} not found` }),
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, decision: updated }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_knowledge_add
-    server.registerTool('rulebook_knowledge_add', {
-        title: 'Add Knowledge Entry',
-        description: 'Add a new pattern or anti-pattern to the project knowledge base',
-        inputSchema: {
-            type: z.string().describe('Knowledge type: "pattern" or "anti-pattern"'),
-            title: z.string().describe('Entry title'),
-            category: z.string().describe('Category (e.g. code, architecture, testing, security)'),
-            description: z.string().describe('Description of the pattern'),
-            example: z.string().optional().describe('Code or usage example'),
-            whenToUse: z.string().optional().describe('When to use this pattern'),
-            whenNotToUse: z.string().optional().describe('When NOT to use this pattern'),
-            tags: z.array(z.string()).optional().describe('Tags for search'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { KnowledgeManager } = await import('../core/tasks/knowledge-manager.js');
-            const km = new KnowledgeManager(root);
-            const entry = await km.add(args.type, args.title, {
-                category: args.category,
-                description: args.description,
-                example: args.example,
-                whenToUse: args.whenToUse,
-                whenNotToUse: args.whenNotToUse,
-                tags: args.tags,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, entry }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_knowledge_list
-    server.registerTool('rulebook_knowledge_list', {
-        title: 'List Knowledge Entries',
-        description: 'List patterns and anti-patterns in the project knowledge base',
-        inputSchema: {
-            type: z.string().optional().describe('Filter by type: "pattern" or "anti-pattern"'),
-            category: z.string().optional().describe('Filter by category'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { KnowledgeManager } = await import('../core/tasks/knowledge-manager.js');
-            const km = new KnowledgeManager(root);
-            const entries = await km.list(args.type, args.category);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, entries, count: entries.length }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
+    const server = new McpServer({
+        name: 'rulebook-task-management',
+        version: '5.2.0',
     });
-    // Register tool: rulebook_knowledge_show
-    server.registerTool('rulebook_knowledge_show', {
-        title: 'Show Knowledge Entry',
-        description: 'Show full details of a knowledge entry',
-        inputSchema: {
-            id: z.string().describe('Knowledge entry ID (slug)'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { KnowledgeManager } = await import('../core/tasks/knowledge-manager.js');
-            const km = new KnowledgeManager(root);
-            const result = await km.show(args.id);
-            if (!result) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: `Knowledge entry "${args.id}" not found`,
-                            }),
-                        },
-                    ],
-                };
+    // --- Wrap all tool handlers with a timeout guard ---
+    const originalRegisterTool = server.registerTool.bind(server);
+    server.registerTool = ((name, config, handler) => {
+        const wrappedHandler = async (...handlerArgs) => {
+            try {
+                return await withTimeout(handler(...handlerArgs), MCP_TOOL_TIMEOUT_MS, name);
             }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, entry: result.entry, content: result.content }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_learn_capture
-    server.registerTool('rulebook_learn_capture', {
-        title: 'Capture Learning',
-        description: 'Capture a learning or insight for future reference',
-        inputSchema: {
-            title: z.string().describe('Brief title for the learning'),
-            content: z.string().describe('Full content of the learning'),
-            tags: z.array(z.string()).optional().describe('Tags for search'),
-            relatedTask: z.string().optional().describe('Related task ID'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { LearnManager } = await import('../core/tasks/learn-manager.js');
-            const lm = new LearnManager(root);
-            const learning = await lm.capture(args.title, args.content, {
-                tags: args.tags,
-                relatedTask: args.relatedTask,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, learning }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_learn_list
-    server.registerTool('rulebook_learn_list', {
-        title: 'List Learnings',
-        description: 'List captured learnings, newest first',
-        inputSchema: {
-            limit: z.number().optional().describe('Maximum number of learnings to return'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { LearnManager } = await import('../core/tasks/learn-manager.js');
-            const lm = new LearnManager(root);
-            const learnings = await lm.list(args.limit);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, learnings, count: learnings.length }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_learn_promote
-    server.registerTool('rulebook_learn_promote', {
-        title: 'Promote Learning',
-        description: 'Promote a learning to a knowledge entry or decision record',
-        inputSchema: {
-            id: z.string().describe('Learning ID to promote'),
-            target: z
-                .enum(['knowledge', 'decision'])
-                .describe('Promote to knowledge base or decision record'),
-            title: z.string().optional().describe('Override title for the promoted entry'),
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { LearnManager } = await import('../core/tasks/learn-manager.js');
-            const lm = new LearnManager(root);
-            const result = await lm.promote(args.id, args.target, { title: args.title });
-            if (!result) {
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                console.error(`[rulebook-mcp] ${name} error: ${msg}`);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify({ success: false, error: `Learning "${args.id}" not found` }),
+                            text: JSON.stringify({ success: false, error: msg }),
                         },
                     ],
                 };
             }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, promoted: result }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
+        };
+        return originalRegisterTool(name, config, wrappedHandler);
     });
+    // Zod schema reused across tools for workspace project targeting
+    const projectIdSchema = z
+        .string()
+        .optional()
+        .describe('Project ID (workspace mode only, defaults to default project)');
+    // Shared context handed to each extracted domain tool module.
+    const ctx = {
+        projectRoot,
+        workspaceManager,
+        projectIdSchema,
+        getTaskMgr,
+        getConfigMgr,
+        getSkillsMgr,
+    };
+    registerTaskTools(server, ctx);
+    registerSkillTools(server, ctx);
+    registerWorkspaceTools(server, ctx);
+    registerDecisionTools(server, ctx);
+    registerKnowledgeTools(server, ctx);
+    registerLearnTools(server, ctx);
     // ── v5.0 Tools: Session Management, Rules, Blockers ──────────────────
     // Register tool: rulebook_session_start
     server.registerTool('rulebook_session_start', {
@@ -1870,15 +338,6 @@ export async function startRulebookMcpServer() {
             if (existsSync(plansPath)) {
                 result.plans = await readFile(plansPath, 'utf-8');
             }
-            // Search relevant memories
-            if (args.query && memoryManager) {
-                const searchResults = await memoryManager.searchMemories({
-                    query: args.query,
-                    mode: 'hybrid',
-                    limit: 5,
-                });
-                result.memories = searchResults;
-            }
             return {
                 content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }) }],
             };
@@ -1938,63 +397,13 @@ export async function startRulebookMcpServer() {
                     mkdirSync(dir, { recursive: true });
                 await writeFile(plansPath, newContent, 'utf-8');
             }
-            // Also save to memory if available
-            if (memoryManager) {
-                await memoryManager.saveMemory({
-                    type: 'observation',
-                    title: `Session summary ${date}`,
-                    content: args.summary,
-                    tags: ['session', 'summary'],
-                });
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: true, message: 'Session summary saved to PLANS.md' }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }),
-                    },
-                ],
-            };
-        }
-    });
-    // Register tool: rulebook_rules_list
-    server.registerTool('rulebook_rules_list', {
-        title: 'List Rules',
-        description: 'List canonical rules from .rulebook/rules/ AND path-scoped language rules from .claude/rules/. Each entry is classified by source (generated by rulebook vs user-authored).',
-        inputSchema: {
-            projectId: projectIdSchema,
-        },
-    }, async (args) => {
-        try {
-            const root = args.projectId && workspaceManager
-                ? (await workspaceManager.getWorker(args.projectId)).projectRoot
-                : projectRoot;
-            const { listRules } = await import('../core/rule-engine.js');
-            const { listRulesWithSource } = await import('../core/generators/rules-generator.js');
-            const canonical = await listRules(root);
-            const languageRules = await listRulesWithSource(root);
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
-                            canonical,
-                            languageRules,
-                            count: canonical.length + languageRules.length,
+                            message: 'Session summary saved to PLANS.md',
                         }),
                     },
                 ],
@@ -2014,6 +423,18 @@ export async function startRulebookMcpServer() {
             };
         }
     });
+    registerRulesTools(server, ctx);
+    // Release the PID lock on shutdown so a restart can re-acquire it.
+    const releaseLock = () => releasePidLock(pidFilePath);
+    process.on('SIGINT', () => {
+        releaseLock();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        releaseLock();
+        process.exit(0);
+    });
+    process.on('exit', releaseLock);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }