@hivehub/rulebook 4.1.0 → 4.2.1

package/dist/mcp/rulebook-server.js

@@ -8,6 +8,7 @@ import { ConfigManager } from '../core/config-manager.js';
 import { BackgroundIndexer } from '../core/indexer/background-indexer.js';
 import { SkillsManager, getDefaultTemplatesPath } from '../core/skills-manager.js';
 import { TaskManager } from '../core/task-manager.js';
+import { WorkspaceManager } from '../core/workspace/workspace-manager.js';
 // Find .rulebook file/directory by walking up directories
 export function findRulebookConfig(startDir) {
     let current = resolve(startDir);
@@ -55,23 +56,94 @@ function loadConfig() {
     return { projectRoot, tasksDir, archiveDir };
 }
 export async function startRulebookMcpServer() {
-    const config = loadConfig();
-    const taskManager = new TaskManager(config.projectRoot, '.rulebook');
-    const skillsManager = new SkillsManager(getDefaultTemplatesPath(), config.projectRoot);
-    const configManager = new ConfigManager(config.projectRoot);
+    // --- Workspace vs Single-Project Mode ---
+    const isWorkspaceMode = process.argv.includes('--workspace');
+    let workspaceManager = null;
+    // Default managers (single-project mode OR default workspace project)
+    let taskManager;
+    let skillsManager;
+    let configManager;
+    let projectRoot;
+    if (isWorkspaceMode) {
+        const projectRootFlagIndex = process.argv.indexOf('--project-root');
+        const startDir = projectRootFlagIndex !== -1 && process.argv[projectRootFlagIndex + 1]
+            ? process.argv[projectRootFlagIndex + 1]
+            : process.cwd();
+        const wsConfig = WorkspaceManager.findWorkspaceConfig(startDir);
+        if (!wsConfig) {
+            console.error('[rulebook-mcp] No workspace config found. Run `rulebook workspace init` to create .rulebook/workspace.json.');
+            process.exit(1);
+        }
+        workspaceManager = new WorkspaceManager(wsConfig, startDir);
+        workspaceManager.startIdleChecker();
+        projectRoot = startDir;
+        // Initialize default project so existing tools work without projectId
+        const defaultId = workspaceManager.getDefaultProjectId();
+        if (defaultId) {
+            try {
+                const defaultWorker = await workspaceManager.getWorker(defaultId);
+                taskManager = defaultWorker.getTaskManager();
+                skillsManager = defaultWorker.getSkillsManager();
+                configManager = defaultWorker.getConfigManager();
+            }
+            catch (e) {
+                console.error(`[rulebook-mcp] Failed to init default project "${defaultId}":`, e);
+                process.exit(1);
+            }
+        }
+        console.error(`[rulebook-mcp] Workspace mode: ${wsConfig.name} (${wsConfig.projects.length} projects, default: ${defaultId})`);
+    }
+    else {
+        const singleConfig = loadConfig();
+        projectRoot = singleConfig.projectRoot;
+        taskManager = new TaskManager(projectRoot, '.rulebook');
+        skillsManager = new SkillsManager(getDefaultTemplatesPath(), projectRoot);
+        configManager = new ConfigManager(projectRoot);
+    }
+    // --- Manager Resolution Helpers (workspace-aware) ---
+    async function getTaskMgr(projectId) {
+        if (!projectId || !workspaceManager)
+            return taskManager;
+        const w = await workspaceManager.getWorker(projectId);
+        return w.getTaskManager();
+    }
+    async function getConfigMgr(projectId) {
+        if (!projectId || !workspaceManager)
+            return configManager;
+        const w = await workspaceManager.getWorker(projectId);
+        return w.getConfigManager();
+    }
+    async function getSkillsMgr(projectId) {
+        if (!projectId || !workspaceManager)
+            return skillsManager;
+        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: '4.1.0',
+        version: '4.2.1',
     });
+    // 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 in kebab-case'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        await taskManager.createTask(args.taskId);
+        const tm = await getTaskMgr(args.projectId);
+        await tm.createTask(args.taskId);
         const resultText = JSON.stringify({
             success: true,
             taskId: args.taskId,
@@ -90,9 +162,11 @@ export async function startRulebookMcpServer() {
                 .enum(['pending', 'in-progress', 'completed', 'blocked'])
                 .optional()
                 .describe('Filter by status'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        const tasks = await taskManager.listTasks(args.includeArchived || false);
+        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);
@@ -121,9 +195,11 @@ export async function startRulebookMcpServer() {
         description: 'Show task details',
         inputSchema: {
             taskId: z.string().describe('Task ID to show'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        const task = await taskManager.showTask(args.taskId);
+        const tm = await getTaskMgr(args.projectId);
+        const task = await tm.showTask(args.taskId);
         return {
             content: [
                 {
@@ -158,10 +234,12 @@ export async function startRulebookMcpServer() {
                 .enum(['pending', 'in-progress', 'completed', 'blocked'])
                 .optional()
                 .describe('New status'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
+        const tm = await getTaskMgr(args.projectId);
         if (args.status) {
-            await taskManager.updateTaskStatus(args.taskId, args.status);
+            await tm.updateTaskStatus(args.taskId, args.status);
         }
         const resultText = JSON.stringify({
             success: true,
@@ -177,9 +255,11 @@ export async function startRulebookMcpServer() {
         description: 'Validate task format',
         inputSchema: {
             taskId: z.string().describe('Task ID to validate'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        const validation = await taskManager.validateTask(args.taskId);
+        const tm = await getTaskMgr(args.projectId);
+        const validation = await tm.validateTask(args.taskId);
         return {
             content: [
                 {
@@ -200,9 +280,11 @@ export async function startRulebookMcpServer() {
         inputSchema: {
             taskId: z.string().describe('Task ID to archive'),
             skipValidation: z.boolean().optional().describe('Skip validation before archiving'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        await taskManager.archiveTask(args.taskId, args.skipValidation || false);
+        const tm = await getTaskMgr(args.projectId);
+        await tm.archiveTask(args.taskId, args.skipValidation || false);
         const resultText = JSON.stringify({
             success: true,
             taskId: args.taskId,
@@ -217,9 +299,11 @@ export async function startRulebookMcpServer() {
         description: 'Delete a task permanently',
         inputSchema: {
             taskId: z.string().describe('Task ID to delete'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        await taskManager.deleteTask(args.taskId);
+        const tm = await getTaskMgr(args.projectId);
+        await tm.deleteTask(args.taskId);
         const resultText = JSON.stringify({
             success: true,
             taskId: args.taskId,
@@ -252,19 +336,21 @@ export async function startRulebookMcpServer() {
                 .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 skillsManager.getSkillsByCategory(args.category);
+                skills = await sm.getSkillsByCategory(args.category);
             }
             else {
-                skills = await skillsManager.getSkills();
+                skills = await sm.getSkills();
             }
-            // Check enabled status from config
-            const rulebookConfig = await configManager.loadConfig();
-            const enabledIds = new Set(rulebookConfig.skills?.enabled || []);
+            const rbConfig = await cm.loadConfig();
+            const enabledIds = new Set(rbConfig.skills?.enabled || []);
             let filteredSkills = skills.map((s) => ({
                 id: s.id,
                 name: s.metadata.name,
@@ -311,10 +397,13 @@ export async function startRulebookMcpServer() {
         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 skill = await skillsManager.getSkillById(args.skillId);
+            const sm = await getSkillsMgr(args.projectId);
+            const cm = await getConfigMgr(args.projectId);
+            const skill = await sm.getSkillById(args.skillId);
             if (!skill) {
                 return {
                     content: [
@@ -329,8 +418,8 @@ export async function startRulebookMcpServer() {
                     ],
                 };
             }
-            const rulebookConfig = await configManager.loadConfig();
-            const enabled = rulebookConfig.skills?.enabled?.includes(args.skillId) || false;
+            const rbConfig = await cm.loadConfig();
+            const enabled = rbConfig.skills?.enabled?.includes(args.skillId) || false;
             return {
                 content: [
                     {
@@ -375,14 +464,16 @@ export async function startRulebookMcpServer() {
         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 {
-            let rulebookConfig = await configManager.loadConfig();
-            rulebookConfig = await skillsManager.enableSkill(args.skillId, rulebookConfig);
-            await configManager.saveConfig(rulebookConfig);
-            // Validate to check for conflicts
-            const validation = await skillsManager.validateSkills(rulebookConfig);
+            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,
@@ -413,12 +504,14 @@ export async function startRulebookMcpServer() {
         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 {
-            let rulebookConfig = await configManager.loadConfig();
-            // Check if skill is enabled
-            if (!rulebookConfig.skills?.enabled?.includes(args.skillId)) {
+            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: [
                         {
@@ -431,8 +524,8 @@ export async function startRulebookMcpServer() {
                     ],
                 };
             }
-            rulebookConfig = await skillsManager.disableSkill(args.skillId, rulebookConfig);
-            await configManager.saveConfig(rulebookConfig);
+            rbConfig = await sm.disableSkill(args.skillId, rbConfig);
+            await cm.saveConfig(rbConfig);
             const resultText = JSON.stringify({
                 success: true,
                 skillId: args.skillId,
@@ -461,12 +554,15 @@ export async function startRulebookMcpServer() {
         description: 'Search for skills by name, description, or tags',
         inputSchema: {
             query: z.string().describe('Search query'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
         try {
-            const skills = await skillsManager.searchSkills(args.query);
-            const rulebookConfig = await configManager.loadConfig();
-            const enabledIds = new Set(rulebookConfig.skills?.enabled || []);
+            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: [
                     {
@@ -505,11 +601,15 @@ export async function startRulebookMcpServer() {
     server.registerTool('rulebook_skill_validate', {
         title: 'Validate Skills Configuration',
         description: 'Validate the current skills configuration for conflicts and dependencies',
-        inputSchema: {},
-    }, async () => {
+        inputSchema: {
+            projectId: projectIdSchema,
+        },
+    }, async (args) => {
         try {
-            const rulebookConfig = await configManager.loadConfig();
-            const validation = await skillsManager.validateSkills(rulebookConfig);
+            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: [
                     {
@@ -520,7 +620,7 @@ export async function startRulebookMcpServer() {
                             errors: validation.errors,
                             warnings: validation.warnings,
                             conflicts: validation.conflicts,
-                            enabledCount: rulebookConfig.skills?.enabled?.length || 0,
+                            enabledCount: rbConfig.skills?.enabled?.length || 0,
                         }),
                     },
                 ],
@@ -543,37 +643,42 @@ export async function startRulebookMcpServer() {
     // ============================================
     // Memory System Functions (v3.0)
     // ============================================
-    // Conditionally initialize MemoryManager
+    // 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;
-    const rulebookConfig = await configManager.loadConfig();
-    if (rulebookConfig.memory?.enabled) {
-        try {
-            const { createMemoryManager } = await import('../memory/memory-manager.js');
-            const memoryDbPath = join(config.projectRoot, rulebookConfig.memory.dbPath ?? '.rulebook/memory/memory.db');
-            console.error(`[rulebook-mcp] Memory DB: ${memoryDbPath}`);
-            memoryManager = createMemoryManager(config.projectRoot, rulebookConfig.memory);
-            autoCaptureEnabled = rulebookConfig.memory.autoCapture !== false; // enabled by default when memory is on
-            // Boot Background Indexer
-            bgIndexer = new BackgroundIndexer(memoryManager, config.projectRoot, { enabled: true });
-            bgIndexer.start();
-            // Expose status to global so the tool can read it
-            global.__indexerStatus = () => bgIndexer?.getStatus();
-            // Intercept process exit to elegantly shut down BackgroundIndexer and SQLite
-            process.on('SIGINT', async () => {
-                console.log('[rulebook-mcp] Shutting down indexes...');
-                if (bgIndexer)
-                    bgIndexer.stop();
-                if (memoryManager)
-                    await memoryManager.close();
-                process.exit(0);
-            });
-        }
-        catch (e) {
-            console.warn('[rulebook-mcp] Failed to boot Memory/Indexer:', e);
+    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
+                bgIndexer = new BackgroundIndexer(memoryManager, projectRoot, { enabled: true });
+                bgIndexer.start();
+                global.__indexerStatus = () => bgIndexer?.getStatus();
+            }
+            catch (e) {
+                console.warn('[rulebook-mcp] Failed to boot Memory/Indexer:', e);
+            }
         }
     }
+    // Graceful shutdown for both modes
+    process.on('SIGINT', async () => {
+        console.error('[rulebook-mcp] Shutting down...');
+        if (workspaceManager) {
+            await workspaceManager.shutdownAll();
+        }
+        if (bgIndexer)
+            bgIndexer.stop();
+        if (memoryManager)
+            await memoryManager.close();
+        process.exit(0);
+    });
     /**
      * Auto-capture: save tool interactions to memory in the background.
      * Fire-and-forget — never blocks or fails the original tool call.
@@ -619,12 +724,14 @@ export async function startRulebookMcpServer() {
             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) => {
-        if (!memoryManager)
+        const mm = await getMemMgr(args.projectId);
+        if (!mm)
             return memoryNotEnabled();
         try {
-            const results = await memoryManager.searchMemories({
+            const results = await mm.searchMemories({
                 query: args.query,
                 limit: args.limit,
                 mode: args.mode,
@@ -654,12 +761,14 @@ export async function startRulebookMcpServer() {
         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) => {
-        if (!memoryManager)
+        const mm = await getMemMgr(args.projectId);
+        if (!mm)
             return memoryNotEnabled();
         try {
-            const timeline = await memoryManager.getTimeline(args.memoryId, args.window);
+            const timeline = await mm.getTimeline(args.memoryId, args.window);
             return {
                 content: [{ type: 'text', text: JSON.stringify({ success: true, timeline }) }],
             };
@@ -678,12 +787,14 @@ export async function startRulebookMcpServer() {
         description: 'Get full details for specific memory IDs',
         inputSchema: {
             ids: z.array(z.string()).describe('Memory IDs to fetch'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        if (!memoryManager)
+        const mm = await getMemMgr(args.projectId);
+        if (!mm)
             return memoryNotEnabled();
         try {
-            const memories = await memoryManager.getFullDetails(args.ids);
+            const memories = await mm.getFullDetails(args.ids);
             return {
                 content: [{ type: 'text', text: JSON.stringify({ success: true, memories }) }],
             };
@@ -707,12 +818,14 @@ export async function startRulebookMcpServer() {
             title: z.string().describe('Memory title'),
             content: z.string().describe('Memory content'),
             tags: z.array(z.string()).optional().describe('Tags'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        if (!memoryManager)
+        const mm = await getMemMgr(args.projectId);
+        if (!mm)
             return memoryNotEnabled();
         try {
-            const memory = await memoryManager.saveMemory({
+            const memory = await mm.saveMemory({
                 type: args.type,
                 title: args.title,
                 content: args.content,
@@ -742,12 +855,15 @@ export async function startRulebookMcpServer() {
     server.registerTool('rulebook_memory_stats', {
         title: 'Memory Statistics',
         description: 'Get memory database statistics',
-        inputSchema: {},
-    }, async () => {
-        if (!memoryManager)
+        inputSchema: {
+            projectId: projectIdSchema,
+        },
+    }, async (args) => {
+        const mm = await getMemMgr(args.projectId);
+        if (!mm)
             return memoryNotEnabled();
         try {
-            const stats = await memoryManager.getStats();
+            const stats = await mm.getStats();
             return {
                 content: [{ type: 'text', text: JSON.stringify({ success: true, stats }) }],
             };
@@ -766,12 +882,14 @@ export async function startRulebookMcpServer() {
         description: 'Force memory eviction and cleanup',
         inputSchema: {
             force: z.boolean().optional().describe('Force cleanup regardless of size'),
+            projectId: projectIdSchema,
         },
     }, async (args) => {
-        if (!memoryManager)
+        const mm = await getMemMgr(args.projectId);
+        if (!mm)
             return memoryNotEnabled();
         try {
-            const result = await memoryManager.cleanup(args.force ?? false);
+            const result = await mm.cleanup(args.force ?? false);
             return {
                 content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }) }],
             };
@@ -798,16 +916,16 @@ export async function startRulebookMcpServer() {
                 const { Logger } = await import('../core/logger.js');
                 const { RalphManager } = await import('../core/ralph-manager.js');
                 const { PRDGenerator } = await import('../core/prd-generator.js');
-                const logger = new Logger(config.projectRoot);
-                const ralphManager = new RalphManager(config.projectRoot, logger);
-                const prdGenerator = new PRDGenerator(config.projectRoot, logger);
+                const logger = new Logger(projectRoot);
+                const ralphManager = new RalphManager(projectRoot, logger);
+                const prdGenerator = new PRDGenerator(projectRoot, logger);
                 const configData = await configManager.loadConfig();
                 const maxIterations = configData.ralph?.maxIterations || 10;
                 const tool = (configData.ralph?.tool || 'claude');
                 // Generate PRD first, then initialize with correct task count
-                const prd = await prdGenerator.generatePRD(basename(config.projectRoot) || 'project');
+                const prd = await prdGenerator.generatePRD(basename(projectRoot) || 'project');
                 const { writeFile } = await import('../utils/file-system.js');
-                const prdPath = join(config.projectRoot, '.rulebook', 'ralph', 'prd.json');
+                const prdPath = join(projectRoot, '.rulebook', 'ralph', 'prd.json');
                 await writeFile(prdPath, JSON.stringify(prd, null, 2));
                 // Initialize after PRD is written so task count is correct
                 await ralphManager.initialize(maxIterations, tool);
@@ -852,8 +970,8 @@ export async function startRulebookMcpServer() {
                 const { RalphParser } = await import('../agents/ralph-parser.js');
                 const { spawn } = await import('child_process');
                 const { execSync } = await import('child_process');
-                const logger = new Logger(config.projectRoot);
-                const ralphManager = new RalphManager(config.projectRoot, logger);
+                const logger = new Logger(projectRoot);
+                const ralphManager = new RalphManager(projectRoot, logger);
                 const configData = await configManager.loadConfig();
                 const maxIterations = args.maxIterations || configData.ralph?.maxIterations || 10;
                 const tool = (args.tool || configData.ralph?.tool || 'claude');
@@ -913,7 +1031,7 @@ export async function startRulebookMcpServer() {
                         let stdout = '';
                         let stderr = '';
                         const proc = spawn(cmd, cmdArgs, {
-                            cwd: config.projectRoot,
+                            cwd: projectRoot,
                             shell: true,
                             stdio: ['pipe', 'pipe', 'pipe'],
                         });
@@ -976,7 +1094,7 @@ export async function startRulebookMcpServer() {
                             }
                         };
                         const proc = spawn(cfg.cmd, cfg.args, {
-                            cwd: config.projectRoot,
+                            cwd: projectRoot,
                             shell: true,
                             stdio: ['pipe', 'pipe', 'pipe'],
                         });
@@ -1163,8 +1281,8 @@ export async function startRulebookMcpServer() {
             try {
                 const { Logger } = await import('../core/logger.js');
                 const { RalphManager } = await import('../core/ralph-manager.js');
-                const logger = new Logger(config.projectRoot);
-                const ralphManager = new RalphManager(config.projectRoot, logger);
+                const logger = new Logger(projectRoot);
+                const ralphManager = new RalphManager(projectRoot, logger);
                 const status = await ralphManager.getStatus();
                 if (!status) {
                     return {
@@ -1230,8 +1348,8 @@ export async function startRulebookMcpServer() {
             try {
                 const { Logger } = await import('../core/logger.js');
                 const { IterationTracker } = await import('../core/iteration-tracker.js');
-                const logger = new Logger(config.projectRoot);
-                const tracker = new IterationTracker(config.projectRoot, logger);
+                const logger = new Logger(projectRoot);
+                const tracker = new IterationTracker(projectRoot, logger);
                 const history = await tracker.getHistory(args.limit || 10, args.taskId);
                 const stats = await tracker.getStatistics();
                 return {
@@ -1290,12 +1408,14 @@ export async function startRulebookMcpServer() {
             const results = await memoryManager.searchMemories({
                 query: args.query,
                 limit: args.limit ?? 10,
-                mode: 'hybrid' // Force hybrid search for best code-chunk matching
+                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 }) }],
+                content: [
+                    { type: 'text', text: JSON.stringify({ success: true, results: codeResults }) },
+                ],
             };
         }
         catch (error) {
@@ -1317,17 +1437,20 @@ export async function startRulebookMcpServer() {
         if (!memoryManager)
             return memoryNotEnabled();
         try {
-            // Since V1 has limited Graph search implementation in memory-search, 
+            // 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({
+                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
-                        })
-                    }],
+                            filePath: args.filePath,
+                        }),
+                    },
+                ],
             };
         }
         catch (error) {
@@ -1347,7 +1470,9 @@ export async function startRulebookMcpServer() {
         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' };
+            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 }) }],
             };
@@ -1360,6 +1485,148 @@ export async function startRulebookMcpServer() {
             };
         }
     });
+    // ============================================
+    // 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) }) },
+                    ],
+                };
+            }
+        });
+    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }